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
|
#ifndef RENDERER_H
#define RENDERER_H
#include <algorithm>
#include <atomic>
#include <ranges>
#include <thread>
class Renderer
{
public:
template<typename Fn>
void start(Fn func, int tn) {
actives.store(tn);
processed.store(0);
Stop.store(false);
if (primary.joinable())
primary.join();
primary = std::thread(&Renderer::dispatchWorkers<Fn>, this, func);
}
void setBuffer(std::uint32_t *pixelbuf, unsigned w, unsigned h) {
pixelBuffer = pixelbuf;
width = w;
height = h;
}
~Renderer() {
stop();
}
operator bool() const {
return !Stop.load();
}
unsigned progress() const {
return processed.load() * 100 / total;
}
void stop() {
Stop.store(true);
if (primary.joinable())
primary.join();
}
private:
std::uint32_t *pixelBuffer = nullptr;
unsigned width = 0, height = 0, total = 0;
std::thread primary;
std::atomic_uint actives;
std::atomic_uint processed;
std::atomic_bool Stop;
template<typename Fn>
void dispatchWorkers(Fn func) {
const auto N = actives.load();
total = N * 16;
auto threads = std::views::transform(
std::views::chunk(
std::views::cartesian_product(
std::views::iota(0u, width),
std::views::iota(0u, height)),
width * height / total),
[=, this](auto chunk) { return std::thread([=, this] { worker(func, chunk); }); });
for (auto th : threads) {
while (actives.load() == 0)
std::this_thread::yield();
--actives;
th.detach();
}
while (actives.load() < N)
std::this_thread::yield();
Stop.store(true);
}
void worker(auto func, auto chunk) {
for (auto [x, y] : chunk) {
if (Stop.load())
break;
pixelBuffer[y * width + x] = func(x, y);
}
++processed;
++actives;
}
};
#endif // RENDERER_H
|
