303 lines
6.5 KiB
C++
Executable File
303 lines
6.5 KiB
C++
Executable File
#ifndef NO_CPP0X
|
|
|
|
#include "Dispatcher.h"
|
|
#include <boost/asio.hpp>
|
|
#include "lib/utils/bts_assert.h"
|
|
#include "../os/os.h"
|
|
#include "defer.h"
|
|
#include "lib/utils/bts_chrono.h"
|
|
#include "lib/logging/logging.h"
|
|
#include "lib/utils/thread_manager.h"
|
|
|
|
#include <memory>
|
|
|
|
#include <chrono>
|
|
#include <condition_variable>
|
|
#include <boost/thread.hpp>
|
|
#include <mutex>
|
|
#include <thread>
|
|
|
|
using namespace std;
|
|
using namespace boost::asio;
|
|
|
|
namespace bts {
|
|
namespace utils {
|
|
|
|
struct DispatcherImpl
|
|
{
|
|
public:
|
|
DispatcherImpl() :
|
|
thread(std::this_thread::get_id()),
|
|
service(),
|
|
work(),
|
|
is_pool(false)
|
|
{
|
|
}
|
|
|
|
std::thread::id thread;
|
|
io_service service;
|
|
unique_ptr<io_service::work> work;
|
|
bool is_pool;
|
|
};
|
|
|
|
|
|
Dispatcher::Dispatcher() :
|
|
_me(new DispatcherImpl())
|
|
{
|
|
#ifdef _WIN32
|
|
_mm_mfence();
|
|
#else
|
|
__sync_synchronize();
|
|
#endif
|
|
}
|
|
|
|
void wait_for_stop(io_service& service)
|
|
{
|
|
while(!service.stopped())
|
|
{
|
|
std::this_thread::sleep_for(1ms);
|
|
}
|
|
}
|
|
|
|
Dispatcher::~Dispatcher()
|
|
{
|
|
if (!_me->service.stopped())
|
|
{
|
|
_me->work.reset();
|
|
_me->service.stop();
|
|
wait_for_stop(_me->service);
|
|
}
|
|
}
|
|
|
|
void Dispatcher::run(size_t threads)
|
|
{
|
|
bts_assert_msg(_me && _me->work == nullptr, "Error dispatcher is already running.");
|
|
_me->service.reset();
|
|
_me->work.reset(new io_service::work(_me->service));
|
|
DEFER(_me->work.reset());
|
|
// Start N-1 threads in addition to the current one
|
|
for (size_t x = 1; x < threads; ++x) {
|
|
add_thread();
|
|
}
|
|
_me->service.run();
|
|
}
|
|
|
|
void Dispatcher::add_thread() {
|
|
_me->is_pool = true;
|
|
auto t = threading::make_thread("DispatcherPool",[=] () {_me->service.run();});
|
|
t.detach();
|
|
}
|
|
|
|
bool Dispatcher::is_threadpool() {
|
|
return _me->is_pool;
|
|
}
|
|
|
|
bool Dispatcher::is_running()
|
|
{
|
|
return _me->work != nullptr && !_me->service.stopped();
|
|
}
|
|
|
|
void Dispatcher::terminate()
|
|
{
|
|
// allows run() to exit normally
|
|
_me->work.reset();
|
|
// At this point this Dispatcher instance may be asyncronously deleted and is no longer safe to use.
|
|
}
|
|
|
|
bool Dispatcher::check_access()
|
|
{
|
|
return std::this_thread::get_id() == _me->thread;
|
|
}
|
|
|
|
|
|
boost::thread_specific_ptr<Dispatcher> _tl_dispatchers;
|
|
Dispatcher& Dispatcher::current() {
|
|
if (_tl_dispatchers.get() == nullptr) {
|
|
_tl_dispatchers.reset(new Dispatcher());
|
|
}
|
|
return *(_tl_dispatchers.get());
|
|
}
|
|
|
|
Dispatcher& Dispatcher::get_named(const char* name) {
|
|
static std::mutex mutex;
|
|
static std::map<string, Dispatcher*> s_dispatchers;
|
|
std::lock_guard<std::mutex> lock(mutex);
|
|
auto result = s_dispatchers.find(name);
|
|
if (result != s_dispatchers.end()) {
|
|
return *result->second;
|
|
}
|
|
|
|
Dispatcher& d = create_new(name);
|
|
s_dispatchers[name] = &d;
|
|
return d;
|
|
}
|
|
|
|
Dispatcher& Dispatcher::background()
|
|
{
|
|
static Dispatcher* s_dispatcher = nullptr;
|
|
Dispatcher** p_s_dispatcher = &s_dispatcher;
|
|
if (s_dispatcher == nullptr)
|
|
{
|
|
*p_s_dispatcher = &get_named("DispatcherBG");
|
|
}
|
|
|
|
return *s_dispatcher;
|
|
}
|
|
|
|
Dispatcher& Dispatcher::create_new(const char* name) {
|
|
Dispatcher* new_dispatcher = nullptr;
|
|
mutex m;
|
|
condition_variable c;
|
|
// Take the lock before starting the thread to ensure c.notify_all() cannot happen before we wait on the condition
|
|
unique_lock<mutex> lock(m);
|
|
auto t = threading::make_thread(name,[&]() {
|
|
Dispatcher& temp = current();
|
|
try {
|
|
temp.post([&]() {
|
|
unique_lock<mutex> lock(m);
|
|
new_dispatcher = ¤t();
|
|
c.notify_all();
|
|
});
|
|
temp.run();
|
|
}
|
|
catch(const std::exception& ex) {
|
|
LOG(Gen,Error ,"Exception on dispatcher thread: {}" ,std::string(ex.what()));
|
|
bts_assert_msg(false, ex.what());
|
|
}
|
|
});
|
|
t.detach();
|
|
auto result = c.wait_for(lock, chrono::seconds(5));// releases the lock temporarily
|
|
bts_assert_msg(result == cv_status::no_timeout, "Dispatcher failed to start.");
|
|
bts_assert(new_dispatcher); // Could happen to to spurious wake
|
|
return *new_dispatcher;
|
|
}
|
|
|
|
void Dispatcher::invoke(Action action)
|
|
{
|
|
bts_assert(!_me->service.stopped());
|
|
|
|
// If we're calling from the thread that owns this dispatcher
|
|
// We can just call the function - to do otherwise would result in deadlock
|
|
if (check_access())
|
|
{
|
|
action();
|
|
return;
|
|
}
|
|
|
|
mutex m;
|
|
condition_variable c;
|
|
unique_lock<mutex> lock(m);
|
|
bool complete = false;
|
|
_me->service.dispatch([&]()
|
|
{
|
|
action();
|
|
unique_lock<mutex> lock(m);
|
|
complete = true;
|
|
c.notify_all();
|
|
});
|
|
while(!complete) {
|
|
c.wait(lock);
|
|
}
|
|
}
|
|
|
|
void Dispatcher::post(Action&& action, int64_t delay_ms)
|
|
{
|
|
if (delay_ms > 0)
|
|
{
|
|
shared_ptr<deadline_timer> timer = make_shared<deadline_timer>(_me->service);
|
|
timer->expires_from_now(boost::posix_time::milliseconds(delay_ms));
|
|
timer->async_wait([timer, action] (const boost::system::error_code& err) { if (!err) action(); });
|
|
}
|
|
else
|
|
{
|
|
_me->service.post(action);
|
|
}
|
|
}
|
|
|
|
io_service* Dispatcher::io_service() { return &_me->service; }
|
|
|
|
//
|
|
// DispatcherTimer
|
|
//
|
|
|
|
struct DispatcherTimerImpl
|
|
{
|
|
DispatcherTimerImpl(Dispatcher& dispatcher, int64_t ms, Action& cb) :
|
|
running(false),
|
|
callback(cb),
|
|
delay(ms),
|
|
timer(new deadline_timer(dispatcher._me->service))
|
|
{
|
|
}
|
|
|
|
void schedule()
|
|
{
|
|
if (running)
|
|
{
|
|
timer->expires_from_now(boost::posix_time::milliseconds(delay));
|
|
timer->async_wait(std::bind(&DispatcherTimerImpl::execute, this, std::placeholders::_1));
|
|
}
|
|
}
|
|
|
|
void execute(const boost::system::error_code& error)
|
|
{
|
|
if (!error)
|
|
{
|
|
callback();
|
|
schedule();
|
|
}
|
|
}
|
|
|
|
bool running;
|
|
Action callback;
|
|
int64_t delay;
|
|
unique_ptr<deadline_timer> timer;
|
|
};
|
|
|
|
|
|
DispatcherTimer::DispatcherTimer(Dispatcher& dispatcher, int64_t time_ms, Action cb)
|
|
: _me(new DispatcherTimerImpl(dispatcher, time_ms, cb))
|
|
{
|
|
}
|
|
|
|
DispatcherTimer::DispatcherTimer(DispatcherTimer&& other) : _me(std::move(other._me)) {}
|
|
|
|
|
|
DispatcherTimer::~DispatcherTimer() { }
|
|
|
|
void DispatcherTimer::start()
|
|
{
|
|
if (!running()) {
|
|
_me->running = true;
|
|
_me->schedule();
|
|
}
|
|
}
|
|
|
|
void DispatcherTimer::stop()
|
|
{
|
|
_me->running = false;
|
|
_me->timer->cancel();
|
|
}
|
|
|
|
bool DispatcherTimer::running()
|
|
{
|
|
return _me->running;
|
|
}
|
|
|
|
void DispatcherTimer::set_interval(int64_t time_ms)
|
|
{
|
|
// This invalidates existing waits so restart
|
|
_me->timer->expires_from_now(boost::posix_time::milliseconds(time_ms));
|
|
_me->schedule();
|
|
}
|
|
|
|
void DispatcherTimer::set_callback(Action cb)
|
|
{
|
|
_me->callback = cb;
|
|
}
|
|
|
|
|
|
}}//namespace
|
|
|
|
#endif
|