Skip to content

Changes advance to advance on time to support large intervals #8

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
GhostofCookie merged 8 commits into from
Aug 24, 2026
Merged

Changes advance to advance on time to support large intervals #8

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
8 commits
Select commit Hold shift + click to select a range
678cbe3
Changes advance to advance on time to support large intervals
TimEvens Jun 10, 2026
97dbcaa
Fast Time Queue (#9)
GhostofCookie Jun 25, 2026
983c52f
FOrward values in push.
GhostofCookie Aug 19, 2026
3304a56
Add benchmark for push with large starting tick value
RichLogan Aug 19, 2026
de80bc2
Don't create empty buckets on advance.
GhostofCookie Aug 19, 2026
8a50347
Add interval 0 check and small rename.
GhostofCookie Aug 19, 2026
e72e2a4
Improve compact compile check.
GhostofCookie Aug 19, 2026
fcba863
Better move for timequeue.
GhostofCookie Aug 19, 2026
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
180 changes: 141 additions & 39 deletions benchmark/time_queue.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,43 +1,79 @@
#include <benchmark/benchmark.h>

#include <timeq/fast_time_queue.h>
#include <timeq/time_queue.h>

#include <type_traits>

struct mock_tick_service : timeq::tick_service
{
explicit mock_tick_service(std::chrono::milliseconds ticks)
: ticks(ticks)
{
}

std::chrono::microseconds get() const override { return ticks; }

std::chrono::microseconds ticks;
};

static auto service = std::make_shared<timeq::threaded_tick_service>();

constexpr size_t kIterations = 100'000'000;

template<class TimeQueue>
static void
BM_TimeQueue_Construct(benchmark::State& state)
Construct(benchmark::State& state)
{
const std::size_t duration = state.range(0);
for (auto _ : state) {
auto tq = timeq::time_queue<int>(300, 1, service, kIterations);
auto tq = TimeQueue(duration, 1, service);

std::size_t size = tq.size();
benchmark::DoNotOptimize(size);
benchmark::ClobberMemory();
}
}

template<class TimeQueue>
static void
BM_TimeQueue_Push(benchmark::State& state)
Push(benchmark::State& state)
{
timeq::time_queue<int> tq(state.range(0), 1, service, kIterations);
TimeQueue tq(state.range(0), 1, service, kIterations);
int64_t items_count = 0;

for (auto _ : state) {
++items_count;
tq.push(items_count, 20);
tq.push({}, 20);
}

state.SetItemsProcessed(items_count);
}

template<class TimeQueue>
static void
FirstPushAfterIdle(benchmark::State& state)
{
const std::size_t duration = state.range(0);
auto aged_service = std::make_shared<mock_tick_service>(std::chrono::milliseconds(duration - 1));
TimeQueue tq(duration, 1, aged_service, 1);

for (auto _ : state) {
tq.push({}, duration);

std::size_t size = tq.size();
benchmark::DoNotOptimize(size);
benchmark::ClobberMemory();
}
}

template<class TimeQueue>
static void
BM_TimeQueue_Pop(benchmark::State& state)
Pop(benchmark::State& state)
{
timeq::time_queue<int> tq(state.range(0), 1, service, kIterations);
TimeQueue tq(state.range(0), 1, service, kIterations);
for (size_t i = 0; i < kIterations; ++i) {
tq.push(i, 10);
tq.push({}, 10);
}

int64_t items_count = 0;
Expand All @@ -49,12 +85,13 @@ BM_TimeQueue_Pop(benchmark::State& state)
state.SetItemsProcessed(items_count);
}

template<class TimeQueue>
static void
BM_TimeQueue_Front(benchmark::State& state)
Front(benchmark::State& state)
{
timeq::time_queue<int> tq(state.range(0), 1, service, kIterations);
TimeQueue tq(state.range(0), 1, service, kIterations);
for (size_t i = 0; i < kIterations; ++i) {
tq.push(i, 15);
tq.push({}, 15);
}

int64_t items_count = 0;
Expand All @@ -68,12 +105,13 @@ BM_TimeQueue_Front(benchmark::State& state)
state.SetItemsProcessed(items_count);
}

template<class TimeQueue>
static void
BM_TimeQueue_PopFront(benchmark::State& state)
PopFront(benchmark::State& state)
{
timeq::time_queue<int> tq(state.range(0), 1, service, kIterations);
TimeQueue tq(state.range(0), 1, service, kIterations);
for (size_t i = 0; i < kIterations; ++i) {
tq.push(i, 15);
tq.push({}, 15);
}

int64_t items_count = 0;
Expand All @@ -87,12 +125,13 @@ BM_TimeQueue_PopFront(benchmark::State& state)
state.SetItemsProcessed(items_count);
}

template<class TimeQueue>
static void
BM_TimeQueue_Size(benchmark::State& state)
Size(benchmark::State& state)
{
timeq::time_queue<int> tq(300, 1, service, kIterations);
TimeQueue tq(300, 1, service, kIterations);
for (size_t i = 0; i < kIterations; ++i) {
tq.push(i, 10);
tq.push({}, 10);
}

for (auto _ : state) {
Expand All @@ -102,12 +141,13 @@ BM_TimeQueue_Size(benchmark::State& state)
}
}

template<class TimeQueue>
static void
BM_TimeQueue_Empty(benchmark::State& state)
Empty(benchmark::State& state)
{
timeq::time_queue<int> tq(300, 1, service, kIterations);
TimeQueue tq(300, 1, service, kIterations);
for (size_t i = 0; i < kIterations; ++i) {
tq.push(i, 10);
tq.push({}, 10);
}

for (auto _ : state) {
Expand All @@ -117,15 +157,16 @@ BM_TimeQueue_Empty(benchmark::State& state)
}
}

template<class TimeQueue>
static void
BM_TimeQueue_PushAndPopLoaded(benchmark::State& state)
PushAndPopLoaded(benchmark::State& state)
{
timeq::time_queue<int> tq(state.range(0), 1, service, kIterations);
TimeQueue tq(state.range(0), 1, service, kIterations);
int64_t items_count = 0;

for (auto _ : state) {
++items_count;
tq.push(items_count, 1000);
tq.push({}, 1000);

// Simulate load by not popping all items
if (items_count % 100 == 0) {
Expand All @@ -139,15 +180,16 @@ BM_TimeQueue_PushAndPopLoaded(benchmark::State& state)
state.SetItemsProcessed(items_count);
}

template<class TimeQueue>
static void
BM_TimeQueue_PushAndPop_Interval_1ms(benchmark::State& state)
PushAndPop_Interval_1ms(benchmark::State& state)
{
timeq::time_queue<int> tq(state.range(0), 1, service, kIterations);
TimeQueue tq(state.range(0), 1, service, kIterations);
int64_t items_count = 0;

for (auto _ : state) {
++items_count;
tq.push(items_count, 1000);
tq.push({}, 1000);

auto elem = tq.front();
tq.pop();
Expand All @@ -159,15 +201,16 @@ BM_TimeQueue_PushAndPop_Interval_1ms(benchmark::State& state)
state.SetItemsProcessed(items_count);
}

template<class TimeQueue>
static void
BM_TimeQueue_PushAndPop_Interval_125ms(benchmark::State& state)
PushAndPop_Interval_125ms(benchmark::State& state)
{
timeq::time_queue<int> tq(state.range(0), 125, service, kIterations);
TimeQueue tq(state.range(0), 125, service, kIterations);
int64_t items_count = 0;

for (auto _ : state) {
++items_count;
tq.push(items_count, 1000);
tq.push({}, 1000);

auto elem = tq.front();
tq.pop();
Expand All @@ -179,13 +222,72 @@ BM_TimeQueue_PushAndPop_Interval_125ms(benchmark::State& state)
state.SetItemsProcessed(items_count);
}

BENCHMARK(BM_TimeQueue_Construct)->Arg(300);
BENCHMARK(BM_TimeQueue_Push)->Iterations(kIterations)->Arg(300)->Arg(1'000'000);
BENCHMARK(BM_TimeQueue_Pop)->Iterations(kIterations)->Arg(300)->Arg(1'000'000);
BENCHMARK(BM_TimeQueue_Front)->Iterations(kIterations)->Arg(300)->Arg(1'000'000);
BENCHMARK(BM_TimeQueue_PopFront)->Iterations(kIterations)->Arg(300)->Arg(1'000'000);
BENCHMARK(BM_TimeQueue_Size)->Iterations(kIterations);
BENCHMARK(BM_TimeQueue_Empty)->Iterations(kIterations);
BENCHMARK(BM_TimeQueue_PushAndPopLoaded)->Arg(5000)->Arg(1'000'000);
BENCHMARK(BM_TimeQueue_PushAndPop_Interval_1ms)->Arg(5000)->Arg(1'000'000);
BENCHMARK(BM_TimeQueue_PushAndPop_Interval_125ms)->Arg(5000)->Arg(1'000'000);
struct TrivialType
{};

static_assert(std::is_trivially_copyable_v<TrivialType>);

struct NonTrivialType
{
NonTrivialType() {}
~NonTrivialType() {}
};

static_assert(!std::is_trivially_copyable_v<NonTrivialType>);

using namespace timeq;

BENCHMARK(Construct<time_queue<TrivialType>>)->Arg(300)->Arg(1'000'000);
BENCHMARK(Construct<time_queue<NonTrivialType>>)->Arg(300)->Arg(1'000'000);
BENCHMARK(Construct<fast_time_queue<TrivialType>>)->Arg(300)->Arg(1'000'000);
BENCHMARK(Construct<fast_time_queue<NonTrivialType>>)->Arg(300)->Arg(1'000'000);

BENCHMARK(Push<time_queue<TrivialType>>)->Iterations(kIterations)->Arg(300)->Arg(1'000'000);
BENCHMARK(Push<time_queue<NonTrivialType>>)->Iterations(kIterations)->Arg(300)->Arg(1'000'000);
BENCHMARK(Push<fast_time_queue<TrivialType>>)->Iterations(kIterations)->Arg(300)->Arg(1'000'000);
BENCHMARK(Push<fast_time_queue<NonTrivialType>>)->Iterations(kIterations)->Arg(300)->Arg(1'000'000);

BENCHMARK(FirstPushAfterIdle<time_queue<TrivialType>>)->Arg(300)->Arg(1'000'000);
BENCHMARK(FirstPushAfterIdle<time_queue<NonTrivialType>>)->Arg(300)->Arg(1'000'000);
BENCHMARK(FirstPushAfterIdle<fast_time_queue<TrivialType>>)->Arg(300)->Arg(1'000'000);
BENCHMARK(FirstPushAfterIdle<fast_time_queue<NonTrivialType>>)->Arg(300)->Arg(1'000'000);

BENCHMARK(Pop<time_queue<TrivialType>>)->Iterations(kIterations)->Arg(300)->Arg(1'000'000);
BENCHMARK(Pop<time_queue<NonTrivialType>>)->Iterations(kIterations)->Arg(300)->Arg(1'000'000);
BENCHMARK(Pop<fast_time_queue<TrivialType>>)->Iterations(kIterations)->Arg(300)->Arg(1'000'000);
BENCHMARK(Pop<fast_time_queue<NonTrivialType>>)->Iterations(kIterations)->Arg(300)->Arg(1'000'000);

BENCHMARK(Front<time_queue<TrivialType>>)->Iterations(kIterations)->Arg(300)->Arg(1'000'000);
BENCHMARK(Front<time_queue<NonTrivialType>>)->Iterations(kIterations)->Arg(300)->Arg(1'000'000);
BENCHMARK(Front<fast_time_queue<TrivialType>>)->Iterations(kIterations)->Arg(300)->Arg(1'000'000);
BENCHMARK(Front<fast_time_queue<NonTrivialType>>)->Iterations(kIterations)->Arg(300)->Arg(1'000'000);

BENCHMARK(PopFront<time_queue<TrivialType>>)->Iterations(kIterations)->Arg(300)->Arg(1'000'000);
BENCHMARK(PopFront<time_queue<NonTrivialType>>)->Iterations(kIterations)->Arg(300)->Arg(1'000'000);
BENCHMARK(PopFront<fast_time_queue<TrivialType>>)->Iterations(kIterations)->Arg(300)->Arg(1'000'000);
BENCHMARK(PopFront<fast_time_queue<NonTrivialType>>)->Iterations(kIterations)->Arg(300)->Arg(1'000'000);

BENCHMARK(Size<time_queue<TrivialType>>)->Iterations(kIterations);
BENCHMARK(Size<time_queue<NonTrivialType>>)->Iterations(kIterations);
BENCHMARK(Size<fast_time_queue<TrivialType>>)->Iterations(kIterations);
BENCHMARK(Size<fast_time_queue<NonTrivialType>>)->Iterations(kIterations);

BENCHMARK(Empty<time_queue<TrivialType>>)->Iterations(kIterations);
BENCHMARK(Empty<time_queue<NonTrivialType>>)->Iterations(kIterations);
BENCHMARK(Empty<fast_time_queue<TrivialType>>)->Iterations(kIterations);
BENCHMARK(Empty<fast_time_queue<NonTrivialType>>)->Iterations(kIterations);

BENCHMARK(PushAndPopLoaded<time_queue<TrivialType>>)->Arg(5000)->Arg(1'000'000);
BENCHMARK(PushAndPopLoaded<time_queue<NonTrivialType>>)->Arg(5000)->Arg(1'000'000);
BENCHMARK(PushAndPopLoaded<fast_time_queue<TrivialType>>)->Arg(5000)->Arg(1'000'000);
BENCHMARK(PushAndPopLoaded<fast_time_queue<NonTrivialType>>)->Arg(5000)->Arg(1'000'000);

BENCHMARK(PushAndPop_Interval_1ms<time_queue<TrivialType>>)->Arg(5000)->Arg(1'000'000);
BENCHMARK(PushAndPop_Interval_1ms<time_queue<NonTrivialType>>)->Arg(5000)->Arg(1'000'000);
BENCHMARK(PushAndPop_Interval_1ms<fast_time_queue<TrivialType>>)->Arg(5000)->Arg(1'000'000);
BENCHMARK(PushAndPop_Interval_1ms<fast_time_queue<NonTrivialType>>)->Arg(5000)->Arg(1'000'000);

BENCHMARK(PushAndPop_Interval_125ms<time_queue<TrivialType>>)->Arg(5000)->Arg(1'000'000);
BENCHMARK(PushAndPop_Interval_125ms<time_queue<NonTrivialType>>)->Arg(5000)->Arg(1'000'000);
BENCHMARK(PushAndPop_Interval_125ms<fast_time_queue<TrivialType>>)->Arg(5000)->Arg(1'000'000);
BENCHMARK(PushAndPop_Interval_125ms<fast_time_queue<NonTrivialType>>)->Arg(5000)->Arg(1'000'000);
Loading
Loading