marcelb
8 months ago
parent
14663d631a
commit
e4fbabd530
@ -1,237 +0,0 @@ |
|||||||
#ifndef _ROTOR_ |
|
||||||
#define _ROTOT_ |
|
||||||
|
|
||||||
#include "runner.hpp" |
|
||||||
#include "chrono" |
|
||||||
#include <memory> |
|
||||||
|
|
||||||
#include "iostream" |
|
||||||
|
|
||||||
using namespace std; |
|
||||||
using namespace marcelb; |
|
||||||
using namespace asynco; |
|
||||||
|
|
||||||
namespace marcelb { |
|
||||||
namespace asynco { |
|
||||||
|
|
||||||
/**
|
|
||||||
* Get the time in ms from the epoch |
|
||||||
*/ |
|
||||||
|
|
||||||
int64_t rtime_ms() { |
|
||||||
return chrono::duration_cast<chrono::milliseconds>(chrono::system_clock::now() |
|
||||||
.time_since_epoch()) |
|
||||||
.count(); |
|
||||||
} |
|
||||||
|
|
||||||
int64_t rtime_us() { |
|
||||||
return chrono::duration_cast<chrono::microseconds>(chrono::system_clock::now() |
|
||||||
.time_since_epoch()) |
|
||||||
.count(); |
|
||||||
} |
|
||||||
|
|
||||||
namespace { |
|
||||||
|
|
||||||
/**
|
|
||||||
* Intern class for timer async loop |
|
||||||
*/ |
|
||||||
class timer_core { |
|
||||||
public: |
|
||||||
mutex hangon; |
|
||||||
condition_variable cv; |
|
||||||
function<void()> callback; |
|
||||||
int64_t time; |
|
||||||
int64_t next; |
|
||||||
bool repeat; |
|
||||||
bool stop; |
|
||||||
|
|
||||||
/**
|
|
||||||
* Timer constructor, receives a callback function and time |
|
||||||
*/ |
|
||||||
timer_core( function<void()> _callback, int64_t _time, bool _repeat): |
|
||||||
callback(_callback), time(_time*1000), repeat(_repeat), stop(false) { |
|
||||||
next = rtime_us() + time; |
|
||||||
} |
|
||||||
|
|
||||||
/**
|
|
||||||
* Stop timer |
|
||||||
*/ |
|
||||||
void clear() { |
|
||||||
// lock_guard<mutex> hang(hangon);
|
|
||||||
stop = true; |
|
||||||
cv.notify_one(); |
|
||||||
} |
|
||||||
|
|
||||||
/**
|
|
||||||
* Destruktor of timer, call stop |
|
||||||
*/ |
|
||||||
~timer_core() { |
|
||||||
clear(); |
|
||||||
} |
|
||||||
}; |
|
||||||
|
|
||||||
/**
|
|
||||||
* Event loop for time events |
|
||||||
*/ |
|
||||||
|
|
||||||
class rotor { |
|
||||||
vector<shared_ptr<timer_core>> tcores; |
|
||||||
mutex te_m; |
|
||||||
bool rotating = true; |
|
||||||
int64_t sampling; |
|
||||||
|
|
||||||
condition_variable te_cv; |
|
||||||
|
|
||||||
/**
|
|
||||||
* Loop method, started by the constructor in a separate runner |
|
||||||
* It checks the events on the stack and sends the expired ones to the runner |
|
||||||
*/ |
|
||||||
void loop() { |
|
||||||
while (rotating) { |
|
||||||
vector<shared_ptr<timer_core>>::iterator next_tc; |
|
||||||
shared_ptr<timer_core> next_ptr; |
|
||||||
|
|
||||||
{ |
|
||||||
unique_lock<mutex> te_l(te_m); |
|
||||||
te_cv.wait(te_l, [this]{ return !tcores.empty() || rotating; }); |
|
||||||
if (!rotating) { |
|
||||||
break; |
|
||||||
} |
|
||||||
|
|
||||||
next_tc = min_element( tcores.begin(), tcores.end(), |
|
||||||
[](shared_ptr<timer_core> a, shared_ptr<timer_core> b ) { |
|
||||||
return a->next < b->next; |
|
||||||
} |
|
||||||
); |
|
||||||
|
|
||||||
next_ptr = *next_tc; |
|
||||||
} |
|
||||||
|
|
||||||
unique_lock<mutex> next_l(next_ptr->hangon); |
|
||||||
next_ptr->cv.wait_for(next_l, chrono::microseconds(next_ptr->next - rtime_us()), [&next_ptr] () { |
|
||||||
return next_ptr->stop; |
|
||||||
}); |
|
||||||
|
|
||||||
if (next_ptr->stop) { |
|
||||||
remove(next_tc); |
|
||||||
} else { |
|
||||||
_asyncon.put_task(next_ptr->callback); |
|
||||||
if (next_ptr->repeat) { |
|
||||||
next_ptr->next += next_ptr->time; |
|
||||||
} |
|
||||||
else { |
|
||||||
remove(next_tc); |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
}
|
|
||||||
} |
|
||||||
|
|
||||||
/**
|
|
||||||
* The method deletes a non-repeating or stopped event from the stack |
|
||||||
*/ |
|
||||||
void remove(vector<shared_ptr<timer_core>>::iterator it) { |
|
||||||
lock_guard<mutex> lock(te_m); |
|
||||||
tcores.erase(it); |
|
||||||
// te_cv.notify_one();
|
|
||||||
} |
|
||||||
|
|
||||||
public: |
|
||||||
|
|
||||||
/**
|
|
||||||
* Constructor for the rotor, starts the given loop by occupying one runner |
|
||||||
*/ |
|
||||||
rotor() { |
|
||||||
_asyncon.put_task( [&] () { |
|
||||||
loop(); |
|
||||||
}); |
|
||||||
}; |
|
||||||
|
|
||||||
/**
|
|
||||||
* Adds a time event to the stack |
|
||||||
*/ |
|
||||||
void insert(shared_ptr<timer_core> tcore) { |
|
||||||
lock_guard<mutex> lock(te_m); |
|
||||||
tcores.push_back(tcore); |
|
||||||
te_cv.notify_one(); |
|
||||||
}; |
|
||||||
|
|
||||||
/**
|
|
||||||
* Returns the number of active events |
|
||||||
*/ |
|
||||||
int active() { |
|
||||||
return tcores.size(); |
|
||||||
} |
|
||||||
|
|
||||||
/**
|
|
||||||
* Stops all active events and stops the rotor |
|
||||||
*/ |
|
||||||
~rotor() { |
|
||||||
for (int i=0; i<tcores.size(); i++) { |
|
||||||
tcores[i]->clear(); |
|
||||||
} |
|
||||||
rotating = false; |
|
||||||
} |
|
||||||
|
|
||||||
}; |
|
||||||
|
|
||||||
/**
|
|
||||||
* It is intended that there is only one global declaration |
|
||||||
*/ |
|
||||||
static rotor _rotor; |
|
||||||
} |
|
||||||
|
|
||||||
/**
|
|
||||||
* Core class for pure async timer functions |
|
||||||
*/ |
|
||||||
|
|
||||||
class _timer_intern { |
|
||||||
shared_ptr<timer_core> tcore; |
|
||||||
public: |
|
||||||
|
|
||||||
_timer_intern(function<void()> _callback, int64_t _time, bool repeat) { |
|
||||||
tcore = make_shared<timer_core>(_callback, _time, repeat); |
|
||||||
_rotor.insert(tcore); |
|
||||||
} |
|
||||||
|
|
||||||
/**
|
|
||||||
* Stop interval |
|
||||||
*/ |
|
||||||
void clear() { |
|
||||||
tcore->clear(); |
|
||||||
} |
|
||||||
}; |
|
||||||
|
|
||||||
/**
|
|
||||||
* Class interval for periodic execution of the callback in time in ms |
|
||||||
*/ |
|
||||||
class interval : public _timer_intern { |
|
||||||
public: |
|
||||||
|
|
||||||
/**
|
|
||||||
* The constructor receives a callback function and an interval time |
|
||||||
*/ |
|
||||||
interval( function<void()> _callback, int64_t _time): |
|
||||||
_timer_intern(_callback, _time, true) { |
|
||||||
} |
|
||||||
}; |
|
||||||
|
|
||||||
/**
|
|
||||||
* Class interval for delayed callback execution in ms |
|
||||||
*/ |
|
||||||
class timeout : public _timer_intern { |
|
||||||
public: |
|
||||||
|
|
||||||
/**
|
|
||||||
* The constructor receives a callback function and a delay time |
|
||||||
*/ |
|
||||||
timeout( function<void()> _callback, int64_t delay): |
|
||||||
_timer_intern(_callback, delay, false) { |
|
||||||
} |
|
||||||
|
|
||||||
}; |
|
||||||
|
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
#endif |
|
||||||
@ -1,136 +0,0 @@ |
|||||||
#ifndef _RUNNER_ |
|
||||||
#define _RUNNER_ |
|
||||||
|
|
||||||
#include <thread> |
|
||||||
#include <vector> |
|
||||||
#include <queue> |
|
||||||
#include <functional> |
|
||||||
#include <mutex> |
|
||||||
#include <condition_variable> |
|
||||||
#include <future> |
|
||||||
|
|
||||||
using namespace std; |
|
||||||
|
|
||||||
namespace marcelb { |
|
||||||
namespace asynco { |
|
||||||
|
|
||||||
#define HW_CONCURRENCY_MINIMAL 4 |
|
||||||
|
|
||||||
/**
|
|
||||||
* The runner class implements multithread, task stack and event loop for asynchronous execution of tasks |
|
||||||
*/ |
|
||||||
class runner { |
|
||||||
private: |
|
||||||
vector<thread> runners; |
|
||||||
queue<function<void()>> tasks; |
|
||||||
mutex q_io; |
|
||||||
condition_variable cv; |
|
||||||
bool stop; |
|
||||||
|
|
||||||
public: |
|
||||||
|
|
||||||
/**
|
|
||||||
* The constructor starts as many threads as the system has cores,
|
|
||||||
* and runs an event loop inside each one.
|
|
||||||
* Each event loop waits for tasks from the stack and executes them. |
|
||||||
*/ |
|
||||||
runner(unsigned int _num_of_runners = 0) : stop(false) { |
|
||||||
unsigned int num_of_runners = _num_of_runners; |
|
||||||
|
|
||||||
if (num_of_runners == 0) { |
|
||||||
#ifdef NUM_OF_RUNNERS |
|
||||||
num_of_runners = NUM_OF_RUNNERS; |
|
||||||
#else |
|
||||||
num_of_runners = thread::hardware_concurrency(); |
|
||||||
if (num_of_runners < HW_CONCURRENCY_MINIMAL) { |
|
||||||
num_of_runners = HW_CONCURRENCY_MINIMAL; |
|
||||||
} |
|
||||||
#endif |
|
||||||
} |
|
||||||
|
|
||||||
for (size_t i = 0; i < num_of_runners; ++i) { |
|
||||||
runners.emplace_back( thread([&] { |
|
||||||
while (!stop) { |
|
||||||
function<void()> task; |
|
||||||
{ |
|
||||||
unique_lock<mutex> lock(q_io); |
|
||||||
cv.wait(lock, [this] { return stop || !tasks.empty(); }); |
|
||||||
// if (stop && tasks.empty())
|
|
||||||
if (stop) |
|
||||||
return; |
|
||||||
task = move(tasks.front()); |
|
||||||
tasks.pop(); |
|
||||||
} |
|
||||||
task(); |
|
||||||
} |
|
||||||
})); |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
/**
|
|
||||||
* With the method, we send the callback function and its arguments to the task stack |
|
||||||
*/ |
|
||||||
template<class F, class... Args> |
|
||||||
auto put_task(F&& f, Args&&... args) |
|
||||||
-> future<typename result_of<F(Args...)>::type> { |
|
||||||
using return_type = typename result_of<F(Args...)>::type; |
|
||||||
|
|
||||||
auto task = make_shared<packaged_task<return_type()>>(bind(forward<F>(f), forward<Args>(args)...)); |
|
||||||
future<return_type> res = task->get_future(); |
|
||||||
{ |
|
||||||
unique_lock<mutex> lock(q_io); |
|
||||||
|
|
||||||
if (stop) { |
|
||||||
throw runtime_error("Pool is stoped!"); |
|
||||||
} |
|
||||||
|
|
||||||
tasks.emplace([task]() { (*task)(); }); |
|
||||||
} |
|
||||||
|
|
||||||
cv.notify_one(); |
|
||||||
return res; |
|
||||||
} |
|
||||||
|
|
||||||
/**
|
|
||||||
* Returns the number of tasks the runner has to perform |
|
||||||
*/ |
|
||||||
unsigned int count_tasks() { |
|
||||||
return tasks.size(); |
|
||||||
} |
|
||||||
|
|
||||||
/**
|
|
||||||
* Returns the number of threads used by the runner |
|
||||||
*/ |
|
||||||
unsigned int count_threads() { |
|
||||||
return runners.size(); |
|
||||||
} |
|
||||||
|
|
||||||
/**
|
|
||||||
* The destructor stops all loops and stops all threads |
|
||||||
*/ |
|
||||||
~runner() { |
|
||||||
{ |
|
||||||
unique_lock<mutex> lock(q_io); |
|
||||||
stop = true; |
|
||||||
} |
|
||||||
cv.notify_all(); |
|
||||||
for (thread& runner : runners) { |
|
||||||
runner.join(); |
|
||||||
} |
|
||||||
runners.clear(); |
|
||||||
} |
|
||||||
|
|
||||||
}; |
|
||||||
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Internal global library variable |
|
||||||
*/ |
|
||||||
static runner _asyncon; |
|
||||||
|
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
#endif |
|
||||||
@ -0,0 +1,223 @@ |
|||||||
|
#ifndef _ROTOR_ |
||||||
|
#define _ROTOT_ |
||||||
|
|
||||||
|
#include "asynco.hpp" |
||||||
|
#include <chrono> |
||||||
|
|
||||||
|
using namespace std; |
||||||
|
using namespace marcelb; |
||||||
|
using namespace asynco; |
||||||
|
|
||||||
|
namespace marcelb { |
||||||
|
namespace asynco { |
||||||
|
|
||||||
|
/**
|
||||||
|
* Get the time in ms from the epoch |
||||||
|
*/ |
||||||
|
|
||||||
|
int64_t rtime_ms() { |
||||||
|
return chrono::duration_cast<chrono::milliseconds>(chrono::system_clock::now() |
||||||
|
.time_since_epoch()) |
||||||
|
.count(); |
||||||
|
} |
||||||
|
|
||||||
|
/**
|
||||||
|
* Get the time in us from the epoch |
||||||
|
*/ |
||||||
|
|
||||||
|
int64_t rtime_us() { |
||||||
|
return chrono::duration_cast<chrono::microseconds>(chrono::system_clock::now() |
||||||
|
.time_since_epoch()) |
||||||
|
.count(); |
||||||
|
} |
||||||
|
|
||||||
|
/**
|
||||||
|
* Core timer class for construct time async functions |
||||||
|
*/ |
||||||
|
class timer { |
||||||
|
boost::asio::steady_timer st; |
||||||
|
bool _stop = false; |
||||||
|
bool repeate; |
||||||
|
function<void()> callback; |
||||||
|
uint64_t time; |
||||||
|
uint64_t _ticks = 0; |
||||||
|
|
||||||
|
/**
|
||||||
|
* A method to assign a callback wrapper and a reinitialization algorithm |
||||||
|
*/ |
||||||
|
void init() { |
||||||
|
st.async_wait( [this] (const boost::system::error_code&) { |
||||||
|
if (!_stop) { |
||||||
|
callback(); |
||||||
|
if (repeate) { |
||||||
|
st = boost::asio::steady_timer(_asynco_engine.io_context, boost::asio::chrono::milliseconds(time)); |
||||||
|
init(); |
||||||
|
} |
||||||
|
_ticks++; |
||||||
|
} |
||||||
|
}); |
||||||
|
} |
||||||
|
|
||||||
|
public: |
||||||
|
|
||||||
|
/**
|
||||||
|
* The constructor creates the steady_timer and accompanying variables and runs a method to initialize the timer |
||||||
|
*/ |
||||||
|
timer (function<void()> _callback, uint64_t _time, bool _repeate) : |
||||||
|
st(_asynco_engine.io_context, boost::asio::chrono::milliseconds(_time)), |
||||||
|
_stop(false), |
||||||
|
repeate(_repeate), |
||||||
|
callback(_callback), |
||||||
|
time(_time) { |
||||||
|
|
||||||
|
init(); |
||||||
|
} |
||||||
|
|
||||||
|
/**
|
||||||
|
* Stop timer |
||||||
|
* The stop flag is set and timer remove it from the queue |
||||||
|
*/ |
||||||
|
void stop() { |
||||||
|
_stop = true; |
||||||
|
st.cancel(); |
||||||
|
} |
||||||
|
|
||||||
|
/**
|
||||||
|
* Run callback now |
||||||
|
* Forces the callback function to run independently of the timer |
||||||
|
*/ |
||||||
|
void now() { |
||||||
|
st.cancel(); |
||||||
|
} |
||||||
|
|
||||||
|
/**
|
||||||
|
* Get the number of times the timer callback was runned |
||||||
|
*/ |
||||||
|
uint64_t ticks() { |
||||||
|
return _ticks; |
||||||
|
} |
||||||
|
|
||||||
|
/**
|
||||||
|
* The logic status of the timer stop state |
||||||
|
*/ |
||||||
|
bool stoped() { |
||||||
|
return _stop; |
||||||
|
} |
||||||
|
|
||||||
|
/**
|
||||||
|
* The destructor stops the timer |
||||||
|
*/ |
||||||
|
~timer() { |
||||||
|
stop(); |
||||||
|
} |
||||||
|
}; |
||||||
|
|
||||||
|
/**
|
||||||
|
* Class interval for periodic execution of the callback in time in ms |
||||||
|
*/ |
||||||
|
class interval { |
||||||
|
shared_ptr<timer> _timer; |
||||||
|
|
||||||
|
public: |
||||||
|
/**
|
||||||
|
* Constructor initializes a shared pointer of type timer |
||||||
|
*/ |
||||||
|
interval(function<void()> callback, uint64_t time) :
|
||||||
|
_timer(make_shared<timer> (callback, time, true)) { |
||||||
|
} |
||||||
|
|
||||||
|
/**
|
||||||
|
* Stop interval |
||||||
|
* The stop flag is set and interval remove it from the queue |
||||||
|
*/ |
||||||
|
void stop() { |
||||||
|
_timer->stop(); |
||||||
|
} |
||||||
|
|
||||||
|
/**
|
||||||
|
* Run callback now |
||||||
|
* Forces the callback function to run independently of the interval |
||||||
|
*/ |
||||||
|
void now() { |
||||||
|
_timer->now(); |
||||||
|
} |
||||||
|
|
||||||
|
/**
|
||||||
|
* Get the number of times the interval callback was runned |
||||||
|
*/ |
||||||
|
uint64_t ticks() { |
||||||
|
return _timer->ticks(); |
||||||
|
} |
||||||
|
|
||||||
|
/**
|
||||||
|
* The logic status of the interval stop state |
||||||
|
*/ |
||||||
|
bool stoped() { |
||||||
|
return _timer->stoped(); |
||||||
|
} |
||||||
|
|
||||||
|
/**
|
||||||
|
* The destructor stops the interval |
||||||
|
*/ |
||||||
|
~interval() { |
||||||
|
stop(); |
||||||
|
} |
||||||
|
}; |
||||||
|
|
||||||
|
/**
|
||||||
|
* Class timeout for delayed callback execution in ms |
||||||
|
*/ |
||||||
|
class timeout { |
||||||
|
shared_ptr<timer> _timer; |
||||||
|
|
||||||
|
public: |
||||||
|
/**
|
||||||
|
* Constructor initializes a shared pointer of type timer |
||||||
|
*/ |
||||||
|
timeout(function<void()> callback, uint64_t time) :
|
||||||
|
_timer(make_shared<timer> (callback, time, false)) { |
||||||
|
} |
||||||
|
|
||||||
|
/**
|
||||||
|
* Stop timeout |
||||||
|
* The stop flag is set and timeout remove it from the queue |
||||||
|
*/ |
||||||
|
void stop() { |
||||||
|
_timer->stop(); |
||||||
|
} |
||||||
|
|
||||||
|
/**
|
||||||
|
* Run callback now |
||||||
|
* Forces the callback function to run independently of the timeout |
||||||
|
*/ |
||||||
|
void now() { |
||||||
|
_timer->now(); |
||||||
|
} |
||||||
|
|
||||||
|
/**
|
||||||
|
* Get the number of times the timeout callback was runned |
||||||
|
*/ |
||||||
|
bool expired() { |
||||||
|
return bool(_timer->ticks()); |
||||||
|
} |
||||||
|
|
||||||
|
/**
|
||||||
|
* The logic status of the timeout stop state |
||||||
|
*/ |
||||||
|
bool stoped() { |
||||||
|
return _timer->stoped(); |
||||||
|
} |
||||||
|
|
||||||
|
/**
|
||||||
|
* The destructor stops the timeout |
||||||
|
*/ |
||||||
|
~timeout() { |
||||||
|
stop(); |
||||||
|
} |
||||||
|
|
||||||
|
}; |
||||||
|
|
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
#endif |
||||||
Loading…
Reference in new issue