Project
Loading...
Searching...
No Matches
test_AsyncQueue.cxx
Go to the documentation of this file.
1// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
2// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
3// All rights not expressly granted are reserved.
4//
5// This software is distributed under the terms of the GNU General Public
6// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
7//
8// In applying this license CERN does not waive the privileges and immunities
9// granted to it by virtue of its status as an Intergovernmental Organization
10// or submit itself to any jurisdiction.
11#include <catch_amalgamated.hpp>
13
15 int& count;
16};
17
20TEST_CASE("TestDebouncing")
21{
22 using namespace o2::framework;
23 AsyncQueue queue;
24 auto taskId = AsyncQueueHelpers::create(queue, {.name = "test", .score = 10});
25 // Push two tasks on the queue with the same id
26 int count = 0;
27 AsyncQueueHelpers::post(queue,
28 AsyncTask{.timeslice = TimesliceId{0}, .id = taskId, .debounce = 10, .callback = [](AsyncTask& task, size_t) { task.user<TaskContext>().count += 1; }}.user<TaskContext>({.count = count}));
29 AsyncQueueHelpers::post(queue,
30 AsyncTask{.timeslice = TimesliceId{1}, .id = taskId, .debounce = 20, .callback = [](AsyncTask& task, size_t) { task.user<TaskContext>().count += 2; }}.user<TaskContext>({.count = count}));
31 AsyncQueueHelpers::run(queue, TimesliceId{2});
32 REQUIRE(count == 2);
33}
34
35// Test task oridering. The tasks with the highest priority should be executed first.
36TEST_CASE("TestPriority")
37{
38 using namespace o2::framework;
39 AsyncQueue queue;
40 auto taskId1 = AsyncQueueHelpers::create(queue, {.name = "test1", .score = 10});
41 auto taskId2 = AsyncQueueHelpers::create(queue, {.name = "test2", .score = 20});
42 // Push two tasks on the queue with the same id
43 int count = 0;
44 AsyncQueueHelpers::post(queue, AsyncTask{.timeslice = TimesliceId{0}, .id = taskId1, .callback = [](AsyncTask& task, size_t) { task.user<TaskContext>().count += 10; }}.user<TaskContext>({.count = count}));
45 AsyncQueueHelpers::post(queue, AsyncTask{.timeslice = TimesliceId{0}, .id = taskId2, .callback = [](AsyncTask& task, size_t) { task.user<TaskContext>().count /= 10; }}.user<TaskContext>({.count = count}));
46 AsyncQueueHelpers::run(queue, TimesliceId{2});
47 REQUIRE(count == 10);
48}
49
50// Make sure we execute tasks only up to the timeslice provided to run.
51TEST_CASE("TestOldestTimeslice")
52{
53 using namespace o2::framework;
54 AsyncQueue queue;
55 auto taskId1 = AsyncQueueHelpers::create(queue, {.name = "test1", .score = 10});
56 auto taskId2 = AsyncQueueHelpers::create(queue, {.name = "test2", .score = 20});
57 // Push two tasks on the queue with the same id
58 auto count = 0;
59 AsyncQueueHelpers::post(
60 queue, AsyncTask{.timeslice = TimesliceId{1}, .id = taskId1, .callback = [](AsyncTask& task, size_t) { task.user<TaskContext>().count += 10; }}.user<TaskContext>({.count = count}));
61 AsyncQueueHelpers::post(
62 queue, AsyncTask{.timeslice = TimesliceId{0}, .id = taskId2, .callback = [](AsyncTask& task, size_t) { task.user<TaskContext>().count += 20; }}.user<TaskContext>({.count = count}));
63 AsyncQueueHelpers::run(queue, TimesliceId{0});
64 REQUIRE(count == 20);
65 AsyncQueueHelpers::run(queue, TimesliceId{0});
66 REQUIRE(count == 20);
67 AsyncQueueHelpers::run(queue, TimesliceId{1});
68 REQUIRE(count == 30);
69}
70
71// Make sure we execute tasks only up to the timeslice provided to run with bouncing enabled.
72TEST_CASE("TestOldestTimesliceWithBounce")
73{
74 using namespace o2::framework;
75 AsyncQueue queue;
76 // Push two tasks on the queue with the same id
77 auto count = 0;
78 auto taskId1 = AsyncQueueHelpers::create(queue, {.name = "test1", .score = 10});
79 auto taskId2 = AsyncQueueHelpers::create(queue, {.name = "test2", .score = 20});
80 REQUIRE(taskId1.value != taskId2.value);
81 AsyncQueueHelpers::post(queue, AsyncTask{
83 .id = taskId1,
84 .callback = [](AsyncTask& task, size_t) { task.user<TaskContext>().count += 10; }}
85 .user<TaskContext>({.count = count}));
86 AsyncQueueHelpers::post(queue, AsyncTask{
88 .id = taskId2,
89 .debounce = 10,
90 .callback = [](AsyncTask& task, size_t) { task.user<TaskContext>().count += 20; }}
91 .user<TaskContext>({.count = count}));
92 AsyncQueueHelpers::post(queue, AsyncTask{
94 .id = taskId2,
95 .debounce = 20,
96 .callback = [](AsyncTask& task, size_t) { task.user<TaskContext>().count += 30; }}
97 .user<TaskContext>({.count = count}));
98 AsyncQueueHelpers::run(queue, TimesliceId{0});
99 REQUIRE(count == 0);
100 REQUIRE(queue.tasks.size() == 3);
101 AsyncQueueHelpers::run(queue, TimesliceId{1});
102 REQUIRE(count == 30);
103 REQUIRE(queue.tasks.size() == 1);
104 AsyncQueueHelpers::run(queue, TimesliceId{2});
105 REQUIRE(count == 40);
106 REQUIRE(queue.tasks.size() == 0);
107}
108
109// test bouncing disabled with negative value
110TEST_CASE("TestOldestTimesliceWithNegativeBounce")
111{
112 using namespace o2::framework;
113 AsyncQueue queue;
114 int count = 0;
115 auto taskId1 = AsyncQueueHelpers::create(queue, {.name = "test1", .score = 10});
116 auto taskId2 = AsyncQueueHelpers::create(queue, {.name = "test2", .score = 20});
117 // Push two tasks on the queue with the same id
118 AsyncQueueHelpers::post(
119 queue, AsyncTask{.timeslice = TimesliceId{2},
120 .id = taskId1,
121 .callback = [](AsyncTask& task, size_t) { task.user<TaskContext>().count += 10; }}
122 .user<TaskContext>({.count = count}));
123 AsyncQueueHelpers::post(
124 queue, AsyncTask{.timeslice = TimesliceId{1},
125 .id = taskId2,
126 .debounce = -10,
127 .callback = [](AsyncTask& task, size_t) { task.user<TaskContext>().count += 20; }}
128 .user<TaskContext>({.count = count}));
129 AsyncQueueHelpers::post(
130 queue, AsyncTask{.timeslice = TimesliceId{1},
131 .id = taskId2,
132 .debounce = -20,
133 .callback = [](AsyncTask& task, size_t) { task.user<TaskContext>().count += 30; }}
134 .user<TaskContext>({.count = count}));
135 AsyncQueueHelpers::run(queue, TimesliceId{0});
136 REQUIRE(count == 0);
137 REQUIRE(queue.tasks.size() == 3);
138 AsyncQueueHelpers::run(queue, TimesliceId{1});
139 REQUIRE(count == 50);
140 REQUIRE(queue.tasks.size() == 1);
141 AsyncQueueHelpers::run(queue, TimesliceId{2});
142 REQUIRE(count == 60);
143 REQUIRE(queue.tasks.size() == 0);
144}
145
146// Make sure we execute tasks only up to the timeslice provided to run.
147TEST_CASE("TestOldestTimeslicePerTimeslice")
148{
149 using namespace o2::framework;
150 AsyncQueue queue;
151 auto taskId1 = AsyncQueueHelpers::create(queue, {.name = "test1", .score = 10});
152 // Push two tasks on the queue with the same id
153 int count = 0;
154 AsyncQueueHelpers::post(
155 queue, AsyncTask{.timeslice = TimesliceId{1},
156 .id = taskId1,
157 .callback = [](AsyncTask& task, size_t) { task.user<TaskContext>().count += 10; }}
158 .user<TaskContext>({.count = count}));
159 // The size of the queue is only updated once a flush happens
160 REQUIRE(queue.tasks.size() == 0);
161 AsyncQueueHelpers::flushPending(queue);
162 REQUIRE(queue.tasks.size() == 1);
163 AsyncQueueHelpers::run(queue, TimesliceId{0});
164 REQUIRE(queue.tasks.size() == 1);
165 REQUIRE(count == 0);
166 AsyncQueueHelpers::post(
167 queue, AsyncTask{.timeslice = TimesliceId{2},
168 .id = taskId1,
169 .callback = [](AsyncTask& task, size_t) { task.user<TaskContext>().count += 20; }}
170 .user<TaskContext>({.count = count}));
171 REQUIRE(queue.tasks.size() == 1);
172 AsyncQueueHelpers::flushPending(queue);
173 REQUIRE(queue.tasks.size() == 2);
174 AsyncQueueHelpers::run(queue, TimesliceId{1});
175 REQUIRE(queue.tasks.size() == 1);
176 REQUIRE(count == 10);
177 AsyncQueueHelpers::run(queue, TimesliceId{2});
178 REQUIRE(queue.tasks.size() == 0);
179 REQUIRE(count == 30);
180}
GLint GLsizei count
Definition glcorearb.h:399
Defining PrimaryVertex explicitly as messageable.
Definition TFIDInfo.h:20
std::vector< AsyncTask > tasks
Definition AsyncQueue.h:94
An actuatual task to be executed.
Definition AsyncQueue.h:32
TEST_CASE("TestDebouncing")