-
Notifications
You must be signed in to change notification settings - Fork 0
/
benchmark.cc
117 lines (100 loc) · 3.72 KB
/
benchmark.cc
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
#include <chrono>
#include <iostream>
#include <thread>
#include <vector>
#include <algorithm>
#include "lock_free_queue.h"
#include "gcl_queue.h"
struct Timer
{
std::chrono::high_resolution_clock::time_point _start, _finish;
void start() { _start = std::chrono::high_resolution_clock::now(); }
void stop() { _finish = std::chrono::high_resolution_clock::now(); }
auto elapsed_mcs() { return std::chrono::duration_cast<std::chrono::microseconds>(_finish - _start).count(); }
};
template <template <typename> typename TQueue, typename TValue>
auto test(auto capacity, auto objects_count, auto produce_time, auto consume_time)
{
TQueue<TValue> queue(capacity);
std::vector<TValue> src(objects_count), dst(objects_count);
std::ranges::for_each(src, [](auto & v){ v = rand(); });
Timer timer;
timer.start();
std::thread producer([&src, &queue, produce_time]
{
auto time = std::chrono::system_clock::now();
size_t index = 0;
while (index != src.size())
{
if (queue.try_push(src[index]))
{
++index;
time += std::chrono::microseconds(produce_time);
std::this_thread::sleep_until(time);
}
else
{
std::this_thread::yield();
}
}
});
std::thread consumer([&dst, &queue, consume_time]
{
auto time = std::chrono::system_clock::now();
size_t index = 0;
while (index != dst.size())
{
if (queue.try_pop(dst[index]))
{
++index;
time += std::chrono::microseconds(consume_time);
std::this_thread::sleep_until(time);
}
else
{
std::this_thread::yield();
}
}
});
producer.join();
consumer.join();
timer.stop();
if (!std::ranges::equal(src, dst))
{
std::cout << "Content is not equal!" << std::endl;
}
return timer.elapsed_mcs();
}
int main(int argc, char* argv[])
{
size_t queue_capacity = std::atoll(argv[1]);
size_t objects_count = std::atoll(argv[2]);
size_t produce_time = std::atoll(argv[3]);
size_t consume_time = std::atoll(argv[4]);
std::cout << "queue_capacity: " << queue_capacity
<< ", objects_count: " << objects_count
<< ", produce_time, mcs: " << produce_time
<< ", consume_time, mcs: " << consume_time
<< std::endl;
constexpr size_t REPEATS = 51;
auto repeats = REPEATS;
size_t lfq_signed = 0, gcl = 0, lfq_unsigned = 0, lfq_blind = 0;
while (repeats--)
{
// lfq_signed += test<LockFreeQueue, uint64_t>(queue_capacity, objects_count, produce_time, consume_time);
lfq_unsigned += test<LockFreeQueueUnsignedIndex, uint64_t>(queue_capacity, objects_count, produce_time, consume_time);
gcl += test<GclQueue, uint64_t>(queue_capacity, objects_count, produce_time, consume_time);
// lfq_blind += test<LockFreeQueueBlind, uint64_t>(queue_capacity, objects_count, produce_time, consume_time);
if (repeats == REPEATS - 1)
{
lfq_signed = 0;
lfq_unsigned = 0;
gcl = 0;
lfq_blind = 0;
}
}
// std::cout << "LockFreeQueue signed index type measures: " << lfq_signed / (REPEATS - 1) << " mcs" << std::endl;
std::cout << "LockFreeQueue unsigned index type measures: " << lfq_unsigned / (REPEATS - 1) << " mcs" << std::endl;
std::cout << "GclQueue measures: " << gcl / (REPEATS - 1) << " mcs" << std::endl;
// std::cout << "LockFreeQueue blind measures: " << lfq_blind / (REPEATS - 1) << " mcs" << std::endl << std::endl;
}