Corium 1.1.0
High-Performance Zero-Heap C++20 MPSC Application Runtime
Loading...
Searching...
No Matches
RuntimeBuilder.hpp
Go to the documentation of this file.
1
7#pragma once
8
9#include <cstddef>
10#include "corium/Runtime.hpp"
11#include "corium/policies/OverflowPolicies.hpp"
12#include "corium/policies/QueuePolicies.hpp"
13#include "corium/policies/SignalPolicies.hpp"
14#include "corium/policies/StoragePolicies.hpp"
15#include "corium/policies/TimerPolicies.hpp"
16#include "corium/profiler/ProfilerPolicies.hpp"
17
18namespace corium {
19
20template <
21 typename EventVariant,
22 typename QueuePolicy,
23 typename SignalPolicy,
24 typename StoragePolicy,
25 typename OverflowPolicy,
26 typename TimerStoragePolicy,
27 typename ProfilerPolicy
28>
29class BasicRuntime;
30
31namespace internal {
32
34template <std::size_t N>
35constexpr std::size_t next_power_of_two() {
36 if (N <= 1) return 1;
37 uint64_t val = N - 1;
38 val |= val >> 1;
39 val |= val >> 2;
40 val |= val >> 4;
41 val |= val >> 8;
42 val |= val >> 16;
43 val |= val >> 32;
44 return static_cast<std::size_t>(val + 1);
45}
46
50template <typename QueuePolicy, typename = void>
51struct queue_capacity_of : std::integral_constant<std::size_t, 1024> {};
52
53template <typename QueuePolicy>
54struct queue_capacity_of<QueuePolicy, std::void_t<decltype(QueuePolicy::capacity)>>
55 : std::integral_constant<std::size_t, next_power_of_two<QueuePolicy::capacity>()> {};
56
57template <typename QueuePolicy>
58static constexpr std::size_t queue_capacity_of_v = queue_capacity_of<QueuePolicy>::value;
59
61template <typename QueuePolicy, typename NewEventVariant>
62struct rebind_queue_policy;
63
64template <template <typename, size_t> class QueuePolicy, typename OldEventVariant, size_t Capacity, typename NewEventVariant>
65struct rebind_queue_policy<QueuePolicy<OldEventVariant, Capacity>, NewEventVariant> {
66 using type = QueuePolicy<NewEventVariant, Capacity>;
67};
68
69template <template <typename, size_t, size_t, size_t> class QueuePolicy, typename OldEventVariant, size_t HighCap, size_t NormalCap, size_t LowCap, typename NewEventVariant>
70struct rebind_queue_policy<QueuePolicy<OldEventVariant, HighCap, NormalCap, LowCap>, NewEventVariant> {
71 using type = QueuePolicy<NewEventVariant, HighCap, NormalCap, LowCap>;
72};
73
74template <template <typename> class QueuePolicy, typename OldEventVariant, typename NewEventVariant>
75struct rebind_queue_policy<QueuePolicy<OldEventVariant>, NewEventVariant> {
76 using type = QueuePolicy<NewEventVariant>;
77};
78
79template <typename QueuePolicy, typename NewEventVariant>
80using rebind_queue_policy_t = typename rebind_queue_policy<QueuePolicy, NewEventVariant>::type;
81
83template <typename QueuePolicy, size_t NewCapacity>
84struct rebind_queue_capacity;
85
86template <template <typename, size_t> class QueuePolicy, typename EventVariant, size_t OldCapacity, size_t NewCapacity>
87struct rebind_queue_capacity<QueuePolicy<EventVariant, OldCapacity>, NewCapacity> {
88 using type = QueuePolicy<EventVariant, NewCapacity>;
89};
90
91template <template <typename, size_t, size_t, size_t> class QueuePolicy, typename EventVariant, size_t HighCap, size_t OldNormalCap, size_t LowCap, size_t NewCapacity>
92struct rebind_queue_capacity<QueuePolicy<EventVariant, HighCap, OldNormalCap, LowCap>, NewCapacity> {
93 using type = QueuePolicy<EventVariant, HighCap, NewCapacity, LowCap>;
94};
95
96template <typename QueuePolicy, size_t NewCapacity>
97using rebind_queue_capacity_t = typename rebind_queue_capacity<QueuePolicy, NewCapacity>::type;
98
99} // namespace internal
100
103template <
104 typename EventVariant = DefaultEvents,
105 typename QueuePolicy = BoundedMpscQueuePolicy<EventVariant, 1024>,
106 typename SignalPolicy = NoSignalPolicy,
107 typename StoragePolicy = DefaultStoragePolicy,
108 typename OverflowPolicy = DropNewestOverflowPolicy,
109 typename TimerStoragePolicy = DefaultTimerStoragePolicy,
110 typename ProfilerPolicy = profiler::NullProfiler
111>
112struct BasicRuntimeBuilder {
114 template <typename NewEventVariant>
115 using WithEvents = BasicRuntimeBuilder<
116 NewEventVariant,
117 internal::rebind_queue_policy_t<QueuePolicy, NewEventVariant>,
118 SignalPolicy,
119 StoragePolicy,
120 OverflowPolicy,
121 TimerStoragePolicy,
122 ProfilerPolicy
123 >;
124
126 template <size_t Capacity>
127 using WithCapacity = BasicRuntimeBuilder<
128 EventVariant,
129 internal::rebind_queue_capacity_t<QueuePolicy, Capacity>,
130 SignalPolicy,
131 StoragePolicy,
132 OverflowPolicy,
133 TimerStoragePolicy,
134 ProfilerPolicy
135 >;
136
138 template <size_t HighCapacity = 256, size_t NormalCapacity = 1024>
139 using WithPriorityQueue = BasicRuntimeBuilder<
140 EventVariant,
141 PriorityMpscQueuePolicy<EventVariant, HighCapacity, NormalCapacity>,
142 SignalPolicy,
143 StoragePolicy,
144 OverflowPolicy,
145 TimerStoragePolicy,
146 ProfilerPolicy
147 >;
148
150 template <typename NewQueuePolicy>
151 using WithQueuePolicy = BasicRuntimeBuilder<
152 EventVariant,
153 NewQueuePolicy,
154 SignalPolicy,
155 StoragePolicy,
156 OverflowPolicy,
157 TimerStoragePolicy,
158 ProfilerPolicy
159 >;
160
162 template <typename NewSignalPolicy>
163 using WithSignalPolicy = BasicRuntimeBuilder<
164 EventVariant,
165 QueuePolicy,
166 NewSignalPolicy,
167 StoragePolicy,
168 OverflowPolicy,
169 TimerStoragePolicy,
170 ProfilerPolicy
171 >;
172
174 template <typename NewStoragePolicy>
175 using WithStoragePolicy = BasicRuntimeBuilder<
176 EventVariant,
177 QueuePolicy,
178 SignalPolicy,
179 NewStoragePolicy,
180 OverflowPolicy,
181 TimerStoragePolicy,
182 ProfilerPolicy
183 >;
184
186 template <typename NewOverflowPolicy>
187 using WithOverflowPolicy = BasicRuntimeBuilder<
188 EventVariant,
189 QueuePolicy,
190 SignalPolicy,
191 StoragePolicy,
192 NewOverflowPolicy,
193 TimerStoragePolicy,
194 ProfilerPolicy
195 >;
196
198 template <size_t MaxTimers>
199 using WithMaxTimers = BasicRuntimeBuilder<
200 EventVariant,
201 QueuePolicy,
202 SignalPolicy,
203 StoragePolicy,
204 OverflowPolicy,
205 FixedTimerStoragePolicy<MaxTimers>,
206 ProfilerPolicy
207 >;
208
210 template <typename NewClockPolicy>
211 using WithClockPolicy = BasicRuntimeBuilder<
212 EventVariant,
213 QueuePolicy,
214 SignalPolicy,
215 StoragePolicy,
216 OverflowPolicy,
217 FixedTimerStoragePolicy<TimerStoragePolicy::max_timers, NewClockPolicy>,
218 ProfilerPolicy
219 >;
220
222 template <typename NewTimerStoragePolicy>
223 using WithTimerStoragePolicy = BasicRuntimeBuilder<
224 EventVariant,
225 QueuePolicy,
226 SignalPolicy,
227 StoragePolicy,
228 OverflowPolicy,
229 NewTimerStoragePolicy,
230 ProfilerPolicy
231 >;
232
234 template <size_t NewMaxHandlers>
235 using WithMaxHandlersPerEvent = BasicRuntimeBuilder<
236 EventVariant,
237 QueuePolicy,
238 SignalPolicy,
239 FixedStoragePolicy<NewMaxHandlers, StoragePolicy::inline_storage_size>,
240 OverflowPolicy,
241 TimerStoragePolicy,
242 ProfilerPolicy
243 >;
244
246 template <size_t NewInlineSize>
247 using WithInlineSize = BasicRuntimeBuilder<
248 EventVariant,
249 QueuePolicy,
250 SignalPolicy,
251 FixedStoragePolicy<StoragePolicy::max_handlers_per_event, NewInlineSize>,
252 OverflowPolicy,
253 TimerStoragePolicy,
254 ProfilerPolicy
255 >;
256
258 template <typename NewProfilerPolicy>
259 using WithProfiler = BasicRuntimeBuilder<
260 EventVariant,
261 QueuePolicy,
262 SignalPolicy,
263 StoragePolicy,
264 OverflowPolicy,
265 TimerStoragePolicy,
266 NewProfilerPolicy
267 >;
268
272 template <std::size_t BufferCapacity = 256>
273 using WithFlightRecorder = BasicRuntimeBuilder<
274 EventVariant,
275 QueuePolicy,
276 SignalPolicy,
277 StoragePolicy,
278 OverflowPolicy,
279 TimerStoragePolicy,
280 profiler::FlightRecorderProfiler<BufferCapacity, internal::queue_capacity_of_v<QueuePolicy>>
281 >;
282
286 template <std::size_t BufferCapacity = 256>
287 using WithLatencyTracker = BasicRuntimeBuilder<
288 EventVariant,
289 QueuePolicy,
290 SignalPolicy,
291 StoragePolicy,
292 OverflowPolicy,
293 TimerStoragePolicy,
294 profiler::LatencyTracker<internal::queue_capacity_of_v<QueuePolicy>>
295 >;
296
298 using Build = BasicRuntime<EventVariant, QueuePolicy, SignalPolicy, StoragePolicy, OverflowPolicy, TimerStoragePolicy, ProfilerPolicy>;
299};
300
304struct RuntimeBuilder : BasicRuntimeBuilder<> {};
305
306} // namespace corium
OverflowPolicies.hpp
Queue saturation policies (DropNewest, DropOldest, Audit, Panic).
ProfilerPolicies.hpp
Latency tracking and flight recording policies with runtime toggle.
QueuePolicies.hpp
Bounded and multi-tier priority MPSC queueing policies.
Runtime.hpp
Deterministic single-consumer event loop coordinator and runner.
SignalPolicies.hpp
Thread wake-up policies (NoSignalPolicy, ConditionVariableSignalPolicy).
StoragePolicies.hpp
Static storage capacity policies for FastDelegate SBO inline buffers.
TimerPolicies.hpp
Timer scheduler static capacity and storage policies.
corium::BasicRuntime
Corium Application Runtime managing MPSC event loops and static policy execution. Zero dynamic heap a...
Definition Runtime.hpp:48
corium::BoundedMpscQueuePolicy
Queue Policy for fixed-capacity, zero-allocation lock-free MPSC RingBuffer.
Definition QueuePolicies.hpp:43
corium::NoSignalPolicy
Signal Policy for busy-spin / polling event loops (sub-microsecond latency, zero signaling cost).
Definition SignalPolicies.hpp:72
corium::PriorityMpscQueuePolicy
Queue Policy supporting strict event priorities using separate lock-free MPSC ring buffers....
Definition QueuePolicies.hpp:96
corium::profiler::FlightRecorderProfiler
Combined Flight Recorder and Latency Tracker Profiler. Records historical event traces into a circula...
Definition ProfilerPolicies.hpp:251
corium::profiler::LatencyTracker
Real-time event latency and performance statistics tracker. Zero dynamic memory allocation....
Definition ProfilerPolicies.hpp:87
corium::internal::next_power_of_two
constexpr std::size_t next_power_of_two()
Compile-time helper to round up an integer to the next power of 2.
Definition RuntimeBuilder.hpp:35
corium::internal::queue_capacity_of_v
static constexpr std::size_t queue_capacity_of_v
Definition RuntimeBuilder.hpp:58
corium::internal::rebind_queue_capacity_t
typename rebind_queue_capacity< QueuePolicy, NewCapacity >::type rebind_queue_capacity_t
Definition RuntimeBuilder.hpp:97
corium::internal::rebind_queue_policy_t
typename rebind_queue_policy< QueuePolicy, NewEventVariant >::type rebind_queue_policy_t
Definition RuntimeBuilder.hpp:80
corium
Definition Application.hpp:16
corium::DefaultTimerStoragePolicy
FixedTimerStoragePolicy< 64, ChronoClockPolicy > DefaultTimerStoragePolicy
Definition TimerPolicies.hpp:24
corium::DefaultEvents
std::variant< QuitEvent, TickEvent, UpdateEvent, ErrorEvent, SignalEvent > DefaultEvents
Default variant list of core Corium events.
Definition Events.hpp:62
corium::DefaultStoragePolicy
FixedStoragePolicy< 8, 32 > DefaultStoragePolicy
Default storage policy (8 handlers per event type, 32 bytes inline delegate storage).
Definition StoragePolicies.hpp:24
corium::BasicRuntimeBuilder
Primary template implementation for fluent compile-time Runtime construction.
Definition RuntimeBuilder.hpp:112
corium::DropNewestOverflowPolicy
Default Overflow Policy: Silently drop incoming new event when queue is full. Zero overhead.
Definition OverflowPolicies.hpp:20
corium::FixedStoragePolicy
Policy configuring compile-time handler capacity and delegate inline storage size.
Definition StoragePolicies.hpp:18
corium::FixedTimerStoragePolicy
Compile-time policy configuring TimerScheduler capacity and clock source.
Definition TimerPolicies.hpp:19
corium::RuntimeBuilder
Fluent compile-time builder for configuring BasicRuntime. Usage: using MyRuntime = corium::RuntimeBui...
Definition RuntimeBuilder.hpp:304
corium::internal::queue_capacity_of
Extract queue capacity from a QueuePolicy if it exposes a static ::capacity member,...
Definition RuntimeBuilder.hpp:51
corium::internal::rebind_queue_capacity< QueuePolicy< EventVariant, HighCap, OldNormalCap, LowCap >, NewCapacity >::type
QueuePolicy< EventVariant, HighCap, NewCapacity, LowCap > type
Definition RuntimeBuilder.hpp:93
corium::internal::rebind_queue_capacity< QueuePolicy< EventVariant, OldCapacity >, NewCapacity >::type
QueuePolicy< EventVariant, NewCapacity > type
Definition RuntimeBuilder.hpp:88
corium::internal::rebind_queue_capacity
Rebind QueuePolicy Capacity while preserving EventVariant.
Definition RuntimeBuilder.hpp:84
corium::internal::rebind_queue_policy< QueuePolicy< OldEventVariant, Capacity >, NewEventVariant >::type
QueuePolicy< NewEventVariant, Capacity > type
Definition RuntimeBuilder.hpp:66
corium::internal::rebind_queue_policy< QueuePolicy< OldEventVariant, HighCap, NormalCap, LowCap >, NewEventVariant >::type
QueuePolicy< NewEventVariant, HighCap, NormalCap, LowCap > type
Definition RuntimeBuilder.hpp:71
corium::internal::rebind_queue_policy< QueuePolicy< OldEventVariant >, NewEventVariant >::type
QueuePolicy< NewEventVariant > type
Definition RuntimeBuilder.hpp:76
corium::internal::rebind_queue_policy
Rebind QueuePolicy EventVariant type parameter while preserving Capacity or Policy structure.
Definition RuntimeBuilder.hpp:62
corium::profiler::NullProfiler
Default Profiler Policy: Zero-overhead, completely compiled out by inline empty functions.
Definition ProfilerPolicies.hpp:21