1 // Copyright (c) 2012-2015 The Bitcoin Core developers
2 // Distributed under the MIT software license, see the accompanying
3 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
4 
5 #include "random.h"
6 #include "scheduler.h"
7 
8 #include "test/test_bitcoin.h"
9 
10 #include <boost/bind.hpp>
11 #include <boost/random/mersenne_twister.hpp>
12 #include <boost/random/uniform_int_distribution.hpp>
13 #include <boost/thread.hpp>
14 #include <boost/test/unit_test.hpp>
15 
BOOST_AUTO_TEST_SUITE(scheduler_tests)16 BOOST_AUTO_TEST_SUITE(scheduler_tests)
17 
18 static void microTask(CScheduler& s, boost::mutex& mutex, int& counter, int delta, boost::chrono::system_clock::time_point rescheduleTime)
19 {
20     {
21         boost::unique_lock<boost::mutex> lock(mutex);
22         counter += delta;
23     }
24     boost::chrono::system_clock::time_point noTime = boost::chrono::system_clock::time_point::min();
25     if (rescheduleTime != noTime) {
26         CScheduler::Function f = boost::bind(&microTask, boost::ref(s), boost::ref(mutex), boost::ref(counter), -delta + 1, noTime);
27         s.schedule(f, rescheduleTime);
28     }
29 }
30 
MicroSleep(uint64_t n)31 static void MicroSleep(uint64_t n)
32 {
33 #if defined(HAVE_WORKING_BOOST_SLEEP_FOR)
34     boost::this_thread::sleep_for(boost::chrono::microseconds(n));
35 #elif defined(HAVE_WORKING_BOOST_SLEEP)
36     boost::this_thread::sleep(boost::posix_time::microseconds(n));
37 #else
38     //should never get here
39     #error missing boost sleep implementation
40 #endif
41 }
42 
BOOST_AUTO_TEST_CASE(manythreads)43 BOOST_AUTO_TEST_CASE(manythreads)
44 {
45     seed_insecure_rand(false);
46 
47     // Stress test: hundreds of microsecond-scheduled tasks,
48     // serviced by 10 threads.
49     //
50     // So... ten shared counters, which if all the tasks execute
51     // properly will sum to the number of tasks done.
52     // Each task adds or subtracts from one of the counters a
53     // random amount, and then schedules another task 0-1000
54     // microseconds in the future to subtract or add from
55     // the counter -random_amount+1, so in the end the shared
56     // counters should sum to the number of initial tasks performed.
57     CScheduler microTasks;
58 
59     boost::mutex counterMutex[10];
60     int counter[10] = { 0 };
61     boost::random::mt19937 rng(insecure_rand());
62     boost::random::uniform_int_distribution<> zeroToNine(0, 9);
63     boost::random::uniform_int_distribution<> randomMsec(-11, 1000);
64     boost::random::uniform_int_distribution<> randomDelta(-1000, 1000);
65 
66     boost::chrono::system_clock::time_point start = boost::chrono::system_clock::now();
67     boost::chrono::system_clock::time_point now = start;
68     boost::chrono::system_clock::time_point first, last;
69     size_t nTasks = microTasks.getQueueInfo(first, last);
70     BOOST_CHECK(nTasks == 0);
71 
72     for (int i = 0; i < 100; i++) {
73         boost::chrono::system_clock::time_point t = now + boost::chrono::microseconds(randomMsec(rng));
74         boost::chrono::system_clock::time_point tReschedule = now + boost::chrono::microseconds(500 + randomMsec(rng));
75         int whichCounter = zeroToNine(rng);
76         CScheduler::Function f = boost::bind(&microTask, boost::ref(microTasks),
77                                              boost::ref(counterMutex[whichCounter]), boost::ref(counter[whichCounter]),
78                                              randomDelta(rng), tReschedule);
79         microTasks.schedule(f, t);
80     }
81     nTasks = microTasks.getQueueInfo(first, last);
82     BOOST_CHECK(nTasks == 100);
83     BOOST_CHECK(first < last);
84     BOOST_CHECK(last > now);
85 
86     // As soon as these are created they will start running and servicing the queue
87     boost::thread_group microThreads;
88     for (int i = 0; i < 5; i++)
89         microThreads.create_thread(boost::bind(&CScheduler::serviceQueue, &microTasks));
90 
91     MicroSleep(600);
92     now = boost::chrono::system_clock::now();
93 
94     // More threads and more tasks:
95     for (int i = 0; i < 5; i++)
96         microThreads.create_thread(boost::bind(&CScheduler::serviceQueue, &microTasks));
97     for (int i = 0; i < 100; i++) {
98         boost::chrono::system_clock::time_point t = now + boost::chrono::microseconds(randomMsec(rng));
99         boost::chrono::system_clock::time_point tReschedule = now + boost::chrono::microseconds(500 + randomMsec(rng));
100         int whichCounter = zeroToNine(rng);
101         CScheduler::Function f = boost::bind(&microTask, boost::ref(microTasks),
102                                              boost::ref(counterMutex[whichCounter]), boost::ref(counter[whichCounter]),
103                                              randomDelta(rng), tReschedule);
104         microTasks.schedule(f, t);
105     }
106 
107     // Drain the task queue then exit threads
108     microTasks.stop(true);
109     microThreads.join_all(); // ... wait until all the threads are done
110 
111     int counterSum = 0;
112     for (int i = 0; i < 10; i++) {
113         BOOST_CHECK(counter[i] != 0);
114         counterSum += counter[i];
115     }
116     BOOST_CHECK_EQUAL(counterSum, 200);
117 }
118 
119 BOOST_AUTO_TEST_SUITE_END()
120