Rename, add listeners, off all, edit readme
This commit is contained in:
marcelb
parent
e91c7f646d
commit
22dbfe89f1
36
README.md
36
README.md
@ -3,6 +3,12 @@
|
||||
|
||||
A C++ library for event-driven asynchronous multi-threaded programming.
|
||||
|
||||
## Motivation
|
||||
|
||||
The original concept was to create an interface capable of asynchronously calling any function. It has since evolved into a library that incorporates a thread pool, each with its own event loop, event-driven programming, and functions inherently designed for asynchronous operation (including periodic and delayed functions).
|
||||
|
||||
The asynchronous filesystem is provided solely to guide users on how to wrap any time- or IO-intensive function for asynchronous execution.
|
||||
|
||||
## Features
|
||||
|
||||
- Object oriented
|
||||
@ -10,7 +16,7 @@ A C++ library for event-driven asynchronous multi-threaded programming.
|
||||
- Header only
|
||||
- Asynchronous programming
|
||||
- Multithread
|
||||
- Asynchronous timer functions: interval, timeout
|
||||
- Asynchronous timer functions: periodic, delayed (like setInterval and setTimeout from JS)
|
||||
- Typed events (on, emit, off)
|
||||
- Event loops
|
||||
- Multiple parallel execution loops
|
||||
@ -23,10 +29,10 @@ Just download the latest release and unzip it into your project.
|
||||
```c++
|
||||
#define NUM_OF_RUNNERS 8 // To change the number of threads used by atask, without this it runs according to the number of cores
|
||||
|
||||
#include "asynco/lib/asynco.hpp" // atask(), wait()
|
||||
#include "asynco/lib/event.hpp" // event
|
||||
#include "asynco/lib/timers.hpp" // interval, timeout
|
||||
#include "asynco/lib/filesystem.hpp" // for async read and write files
|
||||
#include "asynco/lib/asynco.hpp" // atask(), wait()
|
||||
#include "asynco/lib/event.hpp" // event
|
||||
#include "asynco/lib/timers.hpp" // periodic, delayed (like setInterval and setTimeout from JS)
|
||||
#include "asynco/lib/filesystem.hpp" // for async read and write files
|
||||
|
||||
using namespace marcelb;
|
||||
using namespace asynco;
|
||||
@ -43,12 +49,12 @@ return 0;
|
||||
Time asynchronous functions
|
||||
|
||||
```c++
|
||||
// start interval
|
||||
interval inter1 ([]() {
|
||||
// start periodic
|
||||
periodic inter1 ([]() {
|
||||
cout << "Interval 1" << endl;
|
||||
}, 1000);
|
||||
|
||||
// stop interval
|
||||
// stop periodic
|
||||
inter1.stop();
|
||||
|
||||
// how many times it has expired
|
||||
@ -57,12 +63,12 @@ int t = inter1.ticks();
|
||||
// is it stopped
|
||||
bool stoped = inter1.stoped();
|
||||
|
||||
// start timeout
|
||||
timeout time1 ( [] () {
|
||||
// start delayed
|
||||
delayed time1 ( [] () {
|
||||
cout << "Timeout 1 " << endl;
|
||||
}, 10000);
|
||||
|
||||
// stop timeout
|
||||
// stop delayed
|
||||
time1.stop();
|
||||
|
||||
// is it expired
|
||||
@ -137,12 +143,12 @@ cout << wait(atask( [] () {
|
||||
})) << endl;
|
||||
|
||||
/**
|
||||
* Sleep with timeout sleep implement
|
||||
* Sleep with delayed sleep implement
|
||||
*/
|
||||
|
||||
void sleep_to (int _time) {
|
||||
promise<void> _promise;
|
||||
timeout t( [&]() {
|
||||
delayed t( [&]() {
|
||||
_promise.set_value();
|
||||
}, _time);
|
||||
|
||||
@ -157,7 +163,7 @@ sleep_to(3000);
|
||||
|
||||
void promise_reject (int _time) {
|
||||
promise<void> _promise;
|
||||
timeout t( [&]() {
|
||||
delayed t( [&]() {
|
||||
try {
|
||||
// simulate except
|
||||
throw runtime_error("Error simulation");
|
||||
@ -237,7 +243,7 @@ class myOwnClass : public event<int> {
|
||||
|
||||
myOwnClass myclass;
|
||||
|
||||
timeout t( [&] {
|
||||
delayed t( [&] {
|
||||
myclass.emit("constructed", 1);
|
||||
}, 200);
|
||||
|
||||
|
||||
@ -55,6 +55,33 @@ class event {
|
||||
events.erase(key);
|
||||
}
|
||||
|
||||
/**
|
||||
* Remove all event listener
|
||||
*/
|
||||
void off() {
|
||||
lock_guard _off(m_eve);
|
||||
events.clear();
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Get num of listeners by an event key
|
||||
*/
|
||||
unsigned int listeners(const string& key) {
|
||||
return events[key].size();
|
||||
}
|
||||
|
||||
/**
|
||||
* Get num of all listeners
|
||||
*/
|
||||
unsigned int listeners() {
|
||||
unsigned int listeners = 0;
|
||||
for (auto& ev : events) {
|
||||
listeners += ev.second.size();
|
||||
}
|
||||
return listeners;
|
||||
}
|
||||
|
||||
|
||||
};
|
||||
|
||||
|
||||
@ -1,5 +1,5 @@
|
||||
#ifndef _ROTOR_
|
||||
#define _ROTOT_
|
||||
#ifndef _TIMERS_
|
||||
#define _TIMERS_
|
||||
|
||||
#include "asynco.hpp"
|
||||
#include <chrono>
|
||||
@ -113,22 +113,22 @@ class timer {
|
||||
};
|
||||
|
||||
/**
|
||||
* Class interval for periodic execution of the callback in time in ms
|
||||
* Class periodic for periodic execution of the callback in time in ms
|
||||
*/
|
||||
class interval {
|
||||
class periodic {
|
||||
shared_ptr<timer> _timer;
|
||||
|
||||
public:
|
||||
/**
|
||||
* Constructor initializes a shared pointer of type timer
|
||||
*/
|
||||
interval(function<void()> callback, uint64_t time) :
|
||||
periodic(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
|
||||
* Stop periodic
|
||||
* The stop flag is set and periodic remove it from the queue
|
||||
*/
|
||||
void stop() {
|
||||
_timer->stop();
|
||||
@ -136,51 +136,51 @@ class interval {
|
||||
|
||||
/**
|
||||
* Run callback now
|
||||
* Forces the callback function to run independently of the interval
|
||||
* Forces the callback function to run independently of the periodic
|
||||
*/
|
||||
void now() {
|
||||
_timer->now();
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the number of times the interval callback was runned
|
||||
* Get the number of times the periodic callback was runned
|
||||
*/
|
||||
uint64_t ticks() {
|
||||
return _timer->ticks();
|
||||
}
|
||||
|
||||
/**
|
||||
* The logic status of the interval stop state
|
||||
* The logic status of the periodic stop state
|
||||
*/
|
||||
bool stoped() {
|
||||
return _timer->stoped();
|
||||
}
|
||||
|
||||
/**
|
||||
* The destructor stops the interval
|
||||
* The destructor stops the periodic
|
||||
*/
|
||||
~interval() {
|
||||
~periodic() {
|
||||
stop();
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* Class timeout for delayed callback execution in ms
|
||||
* Class delayed for delayed callback execution in ms
|
||||
*/
|
||||
class timeout {
|
||||
class delayed {
|
||||
shared_ptr<timer> _timer;
|
||||
|
||||
public:
|
||||
/**
|
||||
* Constructor initializes a shared pointer of type timer
|
||||
*/
|
||||
timeout(function<void()> callback, uint64_t time) :
|
||||
delayed(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
|
||||
* Stop delayed
|
||||
* The stop flag is set and delayed remove it from the queue
|
||||
*/
|
||||
void stop() {
|
||||
_timer->stop();
|
||||
@ -188,30 +188,30 @@ class timeout {
|
||||
|
||||
/**
|
||||
* Run callback now
|
||||
* Forces the callback function to run independently of the timeout
|
||||
* Forces the callback function to run independently of the delayed
|
||||
*/
|
||||
void now() {
|
||||
_timer->now();
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the number of times the timeout callback was runned
|
||||
* Get is the delayed callback runned
|
||||
*/
|
||||
bool expired() {
|
||||
return bool(_timer->ticks());
|
||||
}
|
||||
|
||||
/**
|
||||
* The logic status of the timeout stop state
|
||||
* The logic status of the delayed stop state
|
||||
*/
|
||||
bool stoped() {
|
||||
return _timer->stoped();
|
||||
}
|
||||
|
||||
/**
|
||||
* The destructor stops the timeout
|
||||
* The destructor stops the delayed
|
||||
*/
|
||||
~timeout() {
|
||||
~delayed() {
|
||||
stop();
|
||||
}
|
||||
|
||||
|
||||
362
test/test.cpp
362
test/test.cpp
@ -18,7 +18,7 @@ using namespace this_thread;
|
||||
|
||||
void sleep_to (int _time) {
|
||||
promise<void> _promise;
|
||||
timeout t( [&]() {
|
||||
delayed t( [&]() {
|
||||
_promise.set_value();
|
||||
}, _time);
|
||||
|
||||
@ -27,7 +27,7 @@ void sleep_to (int _time) {
|
||||
|
||||
void promise_reject (int _time) {
|
||||
promise<void> _promise;
|
||||
timeout t( [&]() {
|
||||
delayed t( [&]() {
|
||||
try {
|
||||
// simulate except
|
||||
throw runtime_error("Error simulation");
|
||||
@ -65,249 +65,255 @@ int main () {
|
||||
|
||||
// --------------- TIME ASYNCHRONOUS FUNCTIONS --------------
|
||||
|
||||
/**
|
||||
* Init interval and timeout; clear interval and timeout
|
||||
*/
|
||||
// /**
|
||||
// * Init periodic and delayed; clear periodic and delayed
|
||||
// */
|
||||
|
||||
interval inter1 ([&]() {
|
||||
cout << "interval prvi " << rtime_ms() - start << endl;
|
||||
}, 1000);
|
||||
// periodic inter1 ([&]() {
|
||||
// cout << "periodic prvi " << rtime_ms() - start << endl;
|
||||
// }, 1000);
|
||||
|
||||
interval inter2 ([&]() {
|
||||
cout << "interval drugi " << rtime_ms() - start << endl;
|
||||
}, 2000);
|
||||
// periodic inter2 ([&]() {
|
||||
// cout << "periodic drugi " << rtime_ms() - start << endl;
|
||||
// }, 2000);
|
||||
|
||||
interval inter3 ([&]() {
|
||||
cout << "interval treći " << rtime_ms() - start << endl;
|
||||
}, 1000);
|
||||
// periodic inter3 ([&]() {
|
||||
// cout << "periodic treći " << rtime_ms() - start << endl;
|
||||
// }, 1000);
|
||||
|
||||
interval inter4 ([&]() {
|
||||
// cout << "interval cetvrti " << rtime_ms() - start << endl;
|
||||
cout << "Ticks " << inter3.ticks() << endl;
|
||||
}, 500);
|
||||
// periodic inter4 ([&]() {
|
||||
// // cout << "periodic cetvrti " << rtime_ms() - start << endl;
|
||||
// cout << "Ticks " << inter3.ticks() << endl;
|
||||
// }, 500);
|
||||
|
||||
interval inter5 ([&]() {
|
||||
cout << "interval peti " << rtime_ms() - start << endl;
|
||||
}, 2000);
|
||||
// periodic inter5 ([&]() {
|
||||
// cout << "periodic peti " << rtime_ms() - start << endl;
|
||||
// }, 2000);
|
||||
|
||||
interval inter6 ([&]() {
|
||||
cout << "interval sesti " << rtime_ms() - start << endl;
|
||||
}, 3000);
|
||||
// periodic inter6 ([&]() {
|
||||
// cout << "periodic sesti " << rtime_ms() - start << endl;
|
||||
// }, 3000);
|
||||
|
||||
timeout time1 ( [&] () {
|
||||
cout << "Close interval 1 i 2 " << rtime_ms() - start << endl;
|
||||
inter1.stop();
|
||||
cout << "inter1.stop " << endl;
|
||||
inter2.stop();
|
||||
cout << "inter2.stop " << endl;
|
||||
}, 8000);
|
||||
// delayed time1 ( [&] () {
|
||||
// cout << "Close periodic 1 i 2 " << rtime_ms() - start << endl;
|
||||
// inter1.stop();
|
||||
// cout << "inter1.stop " << endl;
|
||||
// inter2.stop();
|
||||
// cout << "inter2.stop " << endl;
|
||||
// }, 8000);
|
||||
|
||||
|
||||
timeout time2 ([&] () {
|
||||
cout << "Close interval 3 " << rtime_ms() - start << endl;
|
||||
inter3.stop();
|
||||
cout << "Stoped " << inter3.stoped() << endl;
|
||||
// time1.stop();
|
||||
}, 5000);
|
||||
// delayed time2 ([&] () {
|
||||
// cout << "Close periodic 3 " << rtime_ms() - start << endl;
|
||||
// inter3.stop();
|
||||
// cout << "Stoped " << inter3.stoped() << endl;
|
||||
// // time1.stop();
|
||||
// }, 5000);
|
||||
|
||||
|
||||
if (time2.expired()) {
|
||||
cout << "isteko " << endl;
|
||||
} else {
|
||||
cout << "nije isteko " << endl;
|
||||
}
|
||||
// if (time2.expired()) {
|
||||
// cout << "isteko " << endl;
|
||||
// } else {
|
||||
// cout << "nije isteko " << endl;
|
||||
// }
|
||||
|
||||
// sleep(6);
|
||||
// // sleep(6);
|
||||
|
||||
if (time2.expired()) {
|
||||
cout << "isteko " << endl;
|
||||
} else {
|
||||
cout << "nije isteko " << endl;
|
||||
}
|
||||
// if (time2.expired()) {
|
||||
// cout << "isteko " << endl;
|
||||
// } else {
|
||||
// cout << "nije isteko " << endl;
|
||||
// }
|
||||
|
||||
// // ------------------------ MAKE FUNCTIONS ASYNCHRONOUS -------------------------
|
||||
// // // ------------------------ MAKE FUNCTIONS ASYNCHRONOUS -------------------------
|
||||
|
||||
/**
|
||||
* Run an function asyncronic
|
||||
*/
|
||||
// /**
|
||||
// * Run an function asyncronic
|
||||
// */
|
||||
|
||||
atask( []() {
|
||||
sleep_for(2s); // only for simulate log duration function
|
||||
cout << "atask 1" << endl;
|
||||
return 5;
|
||||
});
|
||||
// atask( []() {
|
||||
// sleep_for(2s); // only for simulate log duration function
|
||||
// cout << "atask 1" << endl;
|
||||
// return 5;
|
||||
// });
|
||||
|
||||
/**
|
||||
* Call not lambda function
|
||||
*/
|
||||
// /**
|
||||
// * Call not lambda function
|
||||
// */
|
||||
|
||||
atask (notLambdaFunction);
|
||||
// atask (notLambdaFunction);
|
||||
|
||||
|
||||
wait (
|
||||
atask (
|
||||
notLambdaFunction
|
||||
)
|
||||
);
|
||||
// wait (
|
||||
// atask (
|
||||
// notLambdaFunction
|
||||
// )
|
||||
// );
|
||||
|
||||
/**
|
||||
* Call class method
|
||||
*/
|
||||
// /**
|
||||
// * Call class method
|
||||
// */
|
||||
|
||||
clm classes;
|
||||
atask( [&classes] () {
|
||||
classes.classMethode();
|
||||
});
|
||||
// clm classes;
|
||||
// atask( [&classes] () {
|
||||
// classes.classMethode();
|
||||
// });
|
||||
|
||||
sleep(5);
|
||||
// sleep(5);
|
||||
|
||||
/**
|
||||
* Wait after runned as async
|
||||
*/
|
||||
// /**
|
||||
// * Wait after runned as async
|
||||
// */
|
||||
|
||||
auto a = atask( []() {
|
||||
sleep_for(2s); // only for simulate log duration function
|
||||
cout << "atask 2" << endl;
|
||||
return 5;
|
||||
});
|
||||
// auto a = atask( []() {
|
||||
// sleep_for(2s); // only for simulate log duration function
|
||||
// cout << "atask 2" << endl;
|
||||
// return 5;
|
||||
// });
|
||||
|
||||
cout << wait(a) << endl;
|
||||
cout << "print after atask 2" << endl;
|
||||
// cout << wait(a) << endl;
|
||||
// cout << "print after atask 2" << endl;
|
||||
|
||||
/**
|
||||
* Wait async function call and use i cout
|
||||
*/
|
||||
// /**
|
||||
// * Wait async function call and use i cout
|
||||
// */
|
||||
|
||||
cout << wait(atask( [] () {
|
||||
sleep_for(chrono::seconds(1)); // only for simulate log duration function
|
||||
cout << "wait end" << endl;
|
||||
return 4;
|
||||
})) << endl;
|
||||
// cout << wait(atask( [] () {
|
||||
// sleep_for(chrono::seconds(1)); // only for simulate log duration function
|
||||
// cout << "wait end" << endl;
|
||||
// return 4;
|
||||
// })) << endl;
|
||||
|
||||
/**
|
||||
* Sleep with timeout sleep implement
|
||||
*/
|
||||
// /**
|
||||
// * Sleep with delayed sleep implement
|
||||
// */
|
||||
|
||||
sleep_to(3000);
|
||||
cout << "sleep_to " << rtime_ms() - start << endl;
|
||||
// sleep_to(3000);
|
||||
// cout << "sleep_to " << rtime_ms() - start << endl;
|
||||
|
||||
/**
|
||||
* Catch promise reject
|
||||
*/
|
||||
// /**
|
||||
// * Catch promise reject
|
||||
// */
|
||||
|
||||
try {
|
||||
promise_reject(3000);
|
||||
} catch (runtime_error err) {
|
||||
cout<< err.what() << endl;
|
||||
}
|
||||
// try {
|
||||
// promise_reject(3000);
|
||||
// } catch (runtime_error err) {
|
||||
// cout<< err.what() << endl;
|
||||
// }
|
||||
|
||||
cout << "promise_reject " << rtime_ms() - start << endl;
|
||||
// cout << "promise_reject " << rtime_ms() - start << endl;
|
||||
|
||||
|
||||
/**
|
||||
* Nested asynchronous invocation
|
||||
*/
|
||||
// /**
|
||||
// * Nested asynchronous invocation
|
||||
// */
|
||||
|
||||
|
||||
atask( [] {
|
||||
cout << "idemo ..." << endl;
|
||||
atask( [] {
|
||||
cout << "ugdnježdena async funkcija " << endl;
|
||||
});
|
||||
});
|
||||
// atask( [] {
|
||||
// cout << "idemo ..." << endl;
|
||||
// atask( [] {
|
||||
// cout << "ugdnježdena async funkcija " << endl;
|
||||
// });
|
||||
// });
|
||||
|
||||
// // --------------- EVENTS -------------------
|
||||
|
||||
/**
|
||||
* initialization of typed events
|
||||
*/
|
||||
// /**
|
||||
// * initialization of typed events
|
||||
// */
|
||||
|
||||
event<int, int> ev2int;
|
||||
event<int, string> evintString;
|
||||
event<> evoid;
|
||||
// event<int, int> ev2int;
|
||||
// event<int, string> evintString;
|
||||
// event<> evoid;
|
||||
|
||||
ev2int.on("sum", [](int a, int b) {
|
||||
cout << "Sum " << a+b << endl;
|
||||
});
|
||||
// ev2int.on("sum", [](int a, int b) {
|
||||
// cout << "Sum " << a+b << endl;
|
||||
// });
|
||||
|
||||
ev2int.on("sum", [](int a, int b) {
|
||||
cout << "Sum done" << endl;
|
||||
});
|
||||
// ev2int.on("sum", [](int a, int b) {
|
||||
// cout << "Sum done" << endl;
|
||||
// });
|
||||
|
||||
evintString.on("substract", [](int a, string b) {
|
||||
cout << "Substract " << a-stoi(b) << endl;
|
||||
});
|
||||
// evintString.on("substract", [](int a, string b) {
|
||||
// cout << "Substract " << a-stoi(b) << endl;
|
||||
// });
|
||||
|
||||
evoid.on("void", []() {
|
||||
cout << "Void emited" << endl;
|
||||
});
|
||||
// evoid.on("void", []() {
|
||||
// cout << "Void emited" << endl;
|
||||
// });
|
||||
|
||||
string emited2 = "2";
|
||||
// string emited2 = "2";
|
||||
|
||||
evoid.on("void", [&]() {
|
||||
cout << "Void emited " << emited2 << endl;
|
||||
});
|
||||
// evoid.on("void", [&]() {
|
||||
// cout << "Void emited " << emited2 << endl;
|
||||
// });
|
||||
|
||||
evoid.emit("void");
|
||||
sleep(1);
|
||||
// evoid.emit("void");
|
||||
// sleep(1);
|
||||
|
||||
/**
|
||||
* Emit
|
||||
*/
|
||||
// /**
|
||||
// * Emit
|
||||
// */
|
||||
|
||||
ev2int.emit("sum", 5, 8);
|
||||
// ev2int.emit("sum", 5, 8);
|
||||
|
||||
|
||||
sleep(1);
|
||||
evintString.emit("substract", 3, to_string(2));
|
||||
// sleep(1);
|
||||
// evintString.emit("substract", 3, to_string(2));
|
||||
|
||||
sleep(1);
|
||||
evoid.off("void");
|
||||
evoid.emit("void");
|
||||
// sleep(1);
|
||||
// evoid.off("void");
|
||||
// evoid.emit("void");
|
||||
|
||||
/**
|
||||
* Own class
|
||||
*/
|
||||
|
||||
myOwnClass myclass;
|
||||
// cout << "Ukupno 2 int " << ev2int.listeners() << endl;
|
||||
// cout << "Ukupno evintString " << evintString.listeners() << endl;
|
||||
// cout << "Ukupno evoid " << evoid.listeners() << endl;
|
||||
// cout << "Ukupno 2 int " << ev2int.listeners("sum") << endl;
|
||||
|
||||
timeout t( [&] {
|
||||
myclass.emit("constructed", 1);
|
||||
}, 200);
|
||||
// /**
|
||||
// * Own class
|
||||
// */
|
||||
|
||||
myclass.on("constructed", [] (int i) {
|
||||
cout << "Constructed " << i << endl;
|
||||
});
|
||||
// myOwnClass myclass;
|
||||
|
||||
// delayed t( [&] {
|
||||
// myclass.emit("constructed", 1);
|
||||
// }, 200);
|
||||
|
||||
// myclass.on("constructed", [] (int i) {
|
||||
// cout << "Constructed " << i << endl;
|
||||
// });
|
||||
|
||||
|
||||
|
||||
auto status = fs::read("test1.txt");
|
||||
// auto status = fs::read("test1.txt");
|
||||
|
||||
|
||||
try {
|
||||
auto data = wait(status);
|
||||
cout << data;
|
||||
} catch (exception& err) {
|
||||
cout << err.what() << endl;
|
||||
}
|
||||
// try {
|
||||
// auto data = wait(status);
|
||||
// cout << data;
|
||||
// } catch (exception& err) {
|
||||
// cout << err.what() << endl;
|
||||
// }
|
||||
|
||||
|
||||
string data_;
|
||||
auto start_read = rtime_us();
|
||||
// string data_;
|
||||
// auto start_read = rtime_us();
|
||||
|
||||
fs::read("test1.txt", [&data_, &start_read] (string data, exception* error) {
|
||||
if (error) {
|
||||
cout << "Error " << error->what() << endl;
|
||||
} else {
|
||||
// cout << "Data " << endl << data << endl;
|
||||
// data_ = data;
|
||||
// cout << "Data_" << data_ << endl;
|
||||
cout << "read " << rtime_us() - start_read << endl;
|
||||
}
|
||||
});
|
||||
// fs::read("test1.txt", [&data_, &start_read] (string data, exception* error) {
|
||||
// if (error) {
|
||||
// cout << "Error " << error->what() << endl;
|
||||
// } else {
|
||||
// // cout << "Data " << endl << data << endl;
|
||||
// // data_ = data;
|
||||
// // cout << "Data_" << data_ << endl;
|
||||
// cout << "read " << rtime_us() - start_read << endl;
|
||||
// }
|
||||
// });
|
||||
|
||||
|
||||
// ----------------------------------------------------------------------------------------------------
|
||||
// // ----------------------------------------------------------------------------------------------------
|
||||
|
||||
cout << "Run" << endl;
|
||||
_asynco_engine.run();
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user