2018-02-04 03:22:01 +01:00
|
|
|
// Matrix Construct
|
|
|
|
//
|
|
|
|
// Copyright (C) Matrix Construct Developers, Authors & Contributors
|
|
|
|
// Copyright (C) 2016-2018 Jason Volk <jason@zemos.net>
|
|
|
|
//
|
|
|
|
// Permission to use, copy, modify, and/or distribute this software for any
|
|
|
|
// purpose with or without fee is hereby granted, provided that the above
|
|
|
|
// copyright notice and this permission notice is present in all copies. The
|
|
|
|
// full license for this software is available in the LICENSE file.
|
2017-03-25 00:45:26 +01:00
|
|
|
|
2017-09-30 08:04:41 +02:00
|
|
|
#pragma once
|
|
|
|
#define HAVE_IRCD_IOS_H
|
|
|
|
|
2018-01-08 12:01:33 +01:00
|
|
|
// Boost headers are not exposed to our users unless explicitly included by a
|
|
|
|
// definition file. Other libircd headers may extend this namespace with more
|
|
|
|
// forward declarations.
|
|
|
|
|
2017-09-30 08:04:41 +02:00
|
|
|
/// Forward declarations for boost::asio because it is not included here.
|
|
|
|
namespace boost::asio
|
2017-08-28 23:51:22 +02:00
|
|
|
{
|
2017-12-29 23:53:39 +01:00
|
|
|
struct io_context;
|
2018-12-11 23:55:10 +01:00
|
|
|
struct signal_set;
|
2019-03-27 00:53:31 +01:00
|
|
|
|
|
|
|
template<class function>
|
|
|
|
void asio_handler_invoke(function&, ...);
|
2017-08-28 23:51:22 +02:00
|
|
|
}
|
2017-03-25 00:45:26 +01:00
|
|
|
|
2017-09-30 08:04:41 +02:00
|
|
|
namespace ircd
|
2017-03-25 00:45:26 +01:00
|
|
|
{
|
2018-10-17 14:12:10 +02:00
|
|
|
namespace asio = boost::asio; ///< Alias so that asio:: can be used.
|
2018-11-02 04:14:00 +01:00
|
|
|
|
|
|
|
extern const uint boost_version[3];
|
|
|
|
extern const string_view boost_version_str;
|
2018-10-17 14:12:10 +02:00
|
|
|
}
|
2017-03-25 00:45:26 +01:00
|
|
|
|
2018-10-17 14:12:10 +02:00
|
|
|
namespace ircd::ios
|
|
|
|
{
|
2019-03-27 00:53:31 +01:00
|
|
|
struct handler;
|
|
|
|
struct descriptor;
|
|
|
|
template<class function> struct handle;
|
|
|
|
|
2017-10-12 02:38:24 +02:00
|
|
|
extern const std::thread::id static_thread_id;
|
2018-10-17 14:12:10 +02:00
|
|
|
extern std::thread::id main_thread_id;
|
|
|
|
extern asio::io_context *user;
|
2017-10-12 02:38:24 +02:00
|
|
|
|
|
|
|
bool is_main_thread();
|
2018-12-28 22:17:28 +01:00
|
|
|
bool is_static_thread();
|
2017-10-12 02:38:24 +02:00
|
|
|
void assert_main_thread();
|
|
|
|
|
2018-12-28 22:05:03 +01:00
|
|
|
bool available();
|
2018-10-17 14:12:10 +02:00
|
|
|
asio::io_context &get();
|
2018-12-28 22:05:03 +01:00
|
|
|
|
2019-03-27 00:53:31 +01:00
|
|
|
void dispatch(descriptor &, std::function<void ()>);
|
|
|
|
void post(descriptor &, std::function<void ()>);
|
2017-10-12 02:38:24 +02:00
|
|
|
void dispatch(std::function<void ()>);
|
2018-10-17 14:12:10 +02:00
|
|
|
void post(std::function<void ()>);
|
|
|
|
void init(asio::io_context &user);
|
|
|
|
}
|
|
|
|
|
|
|
|
namespace ircd
|
|
|
|
{
|
|
|
|
using ios::assert_main_thread;
|
|
|
|
using ios::is_main_thread;
|
|
|
|
using ios::dispatch;
|
|
|
|
using ios::post;
|
2017-10-12 02:38:24 +02:00
|
|
|
}
|
|
|
|
|
2019-03-27 00:53:31 +01:00
|
|
|
struct ircd::ios::descriptor
|
|
|
|
:instance_list<descriptor>
|
|
|
|
{
|
|
|
|
static uint64_t ids;
|
|
|
|
|
|
|
|
string_view name;
|
|
|
|
uint64_t id {++ids};
|
|
|
|
uint64_t calls {0};
|
|
|
|
uint64_t faults {0};
|
2019-03-27 05:22:22 +01:00
|
|
|
uint64_t allocs {0};
|
|
|
|
uint64_t alloc_bytes{0};
|
|
|
|
uint64_t frees {0};
|
|
|
|
uint64_t free_bytes{0};
|
2019-03-27 06:03:48 +01:00
|
|
|
uint64_t slice_total {0};
|
|
|
|
uint64_t slice_last {0};
|
2019-03-27 00:53:31 +01:00
|
|
|
|
|
|
|
descriptor(const string_view &name);
|
|
|
|
descriptor(descriptor &&) = delete;
|
|
|
|
descriptor(const descriptor &) = delete;
|
|
|
|
~descriptor() noexcept;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct ircd::ios::handler
|
|
|
|
{
|
2019-03-27 05:22:22 +01:00
|
|
|
static void *allocate(handler *const &, const size_t &);
|
|
|
|
static void deallocate(handler *const &, void *const &, const size_t &);
|
2019-03-27 00:53:31 +01:00
|
|
|
static void enter(handler *const &);
|
|
|
|
static void leave(handler *const &);
|
|
|
|
static bool fault(handler *const &);
|
|
|
|
|
|
|
|
ios::descriptor *descriptor;
|
2019-03-27 06:03:48 +01:00
|
|
|
uint64_t slice_start {0};
|
2019-03-27 00:53:31 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
template<class function>
|
|
|
|
struct ircd::ios::handle
|
|
|
|
:handler
|
|
|
|
{
|
|
|
|
function f;
|
|
|
|
|
|
|
|
template<class... args>
|
|
|
|
void operator()(args&&... a) const;
|
|
|
|
|
|
|
|
handle(ios::descriptor &d, function&& f);
|
|
|
|
};
|
|
|
|
|
|
|
|
namespace ircd::ios
|
|
|
|
{
|
2019-03-27 05:22:22 +01:00
|
|
|
template<class function>
|
|
|
|
void asio_handler_deallocate(void *, size_t, handle<function> *);
|
|
|
|
|
|
|
|
template<class function>
|
|
|
|
void *asio_handler_allocate(size_t, handle<function> *);
|
|
|
|
|
2019-03-27 00:53:31 +01:00
|
|
|
template<class callable,
|
|
|
|
class function>
|
|
|
|
void asio_handler_invoke(callable &f, handle<function> *);
|
|
|
|
}
|
|
|
|
|
|
|
|
template<class function>
|
|
|
|
ircd::ios::handle<function>::handle(ios::descriptor &d,
|
|
|
|
function&& f)
|
|
|
|
:handler{&d}
|
|
|
|
,f{std::forward<function>(f)}
|
|
|
|
{}
|
|
|
|
|
|
|
|
template<class function>
|
|
|
|
template<class... args>
|
|
|
|
void
|
|
|
|
ircd::ios::handle<function>::operator()(args&&... a)
|
|
|
|
const
|
|
|
|
{
|
|
|
|
f(std::forward<args>(a)...);
|
|
|
|
}
|
|
|
|
|
2019-03-27 05:22:22 +01:00
|
|
|
template<class function>
|
|
|
|
void
|
|
|
|
ircd::ios::asio_handler_deallocate(void *const ptr,
|
|
|
|
size_t size,
|
|
|
|
handle<function> *const h)
|
|
|
|
{
|
|
|
|
handler::deallocate(h, ptr, size);
|
|
|
|
}
|
|
|
|
|
|
|
|
template<class function>
|
|
|
|
void *
|
|
|
|
__attribute__((malloc, returns_nonnull, warn_unused_result, alloc_size(1)))
|
|
|
|
ircd::ios::asio_handler_allocate(size_t size,
|
|
|
|
handle<function> *const h)
|
|
|
|
{
|
|
|
|
return handler::allocate(h, size);
|
|
|
|
}
|
|
|
|
|
2019-03-27 00:53:31 +01:00
|
|
|
template<class callable,
|
|
|
|
class function>
|
|
|
|
void
|
|
|
|
ircd::ios::asio_handler_invoke(callable &f,
|
|
|
|
handle<function> *const h)
|
|
|
|
try
|
|
|
|
{
|
|
|
|
handler::enter(h);
|
|
|
|
boost::asio::asio_handler_invoke(f, &h);
|
|
|
|
handler::leave(h);
|
|
|
|
}
|
|
|
|
catch(...)
|
|
|
|
{
|
|
|
|
if(handler::fault(h))
|
|
|
|
handler::leave(h);
|
|
|
|
else
|
|
|
|
throw;
|
|
|
|
}
|
|
|
|
|
2017-10-12 02:38:24 +02:00
|
|
|
inline void
|
2018-10-17 14:12:10 +02:00
|
|
|
ircd::ios::assert_main_thread()
|
2017-10-12 02:38:24 +02:00
|
|
|
{
|
|
|
|
assert(is_main_thread());
|
|
|
|
}
|
|
|
|
|
|
|
|
inline bool
|
2018-10-17 14:12:10 +02:00
|
|
|
ircd::ios::is_main_thread()
|
2017-10-12 02:38:24 +02:00
|
|
|
{
|
2018-10-17 14:12:10 +02:00
|
|
|
return std::this_thread::get_id() == main_thread_id;
|
2017-09-30 08:04:41 +02:00
|
|
|
}
|
2018-12-28 22:17:28 +01:00
|
|
|
|
|
|
|
inline bool
|
|
|
|
ircd::ios::is_static_thread()
|
|
|
|
{
|
|
|
|
return std::this_thread::get_id() == static_thread_id;
|
|
|
|
}
|