testcode.git

1) #include <iostream>
2) #include <semaphore.h>
3) #include "thread_manager.hpp"
4) 
5) // using namespace std;
6) using std::condition_variable;
7) using std::cout;
8) using std::endl;

9) using std::lock_guard;
10) using std::mutex;
11) using std::thread;
12) using std::unique_lock;
13) using std::chrono::seconds;

14) 
15) /*
16) class Reporter {

17)     // TODO: Move all the reporting stuff over to this class.

18) };
19) 
20) class Worker {

21)     Worker(): count_(0) {}
22)     void work();

23) 

24)     int count_;

25) };
26) */
27) 

28) Manager::Manager() : abort_reporting_(false), data_to_protect_(0)

29) {

30)     report_thread_ = thread([this] { WriteReport(); });

31) }
32) 
33) Manager::~Manager()
34) {

35)     abort_reporting_ = true;
36)     report_condition_.notify_all();
37)     report_thread_.join();

38) }
39) 
40) void Manager::DeployWorker()
41) {

42)     // See http://preshing.com/20150316/semaphores-are-surprisingly-versatile/
43)     // And https://github.com/preshing/cpp11-on-multicore

44)     //  unique_lock<Semaphore> sem(thread_counter_sem);
45)     //  thread(&Manager::work, this, std::move(sem)).detach();

46) }
47) 
48) /*
49) void Manager::work(unique_lock<Semaphore> //sem
50)                                                 )
51) {
52)     cout << "Work here." << endl;
53) }
54) */
55) 
56) void Manager::WriteReport()
57) {

58)     const seconds duration(5);
59)     mutex timer_mutex;
60)     while (!abort_reporting_) {
61)         unique_lock<mutex> timeout(timer_mutex);
62)         if (report_condition_.wait_for(timeout, duration,

63)                                        [this]() { return abort_reporting_; })) {

64)             return;
65)         }
66)         lock_guard<mutex> crit_sec(report_lock_);
67)         cout << "This is the report: " << data_to_protect_ << endl;
68)     }