florian/mesytec-mnode
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
mesytec-mnode/external/taskflow-3.8.0/unittests/test_data_pipelines.cpp
Florian Lüke e426fb7628 add taskflow-3.8.0
2025-01-04 01:25:05 +01:00

2871 lines
80 KiB
C++
Raw Permalink Blame History

#define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN
#include <doctest.h>
#include <taskflow/taskflow.hpp>
#include <taskflow/algorithm/data_pipeline.hpp>
#include <stdlib.h> /* srand, rand */
#include <time.h> /* time */
// --------------------------------------------------------
// Testcase: 1 pipe, L lines, w workers
// --------------------------------------------------------
void data_pipeline_1P(size_t L, unsigned w, tf::PipeType type) {
tf::Executor executor(w);
const size_t maxN = 100;
std::vector<int> source(maxN);
std::iota(source.begin(), source.end(), 0);
// iterate different data amount (1, 2, 3, 4, 5, ... 1000000)
for (size_t N = 0; N <= maxN; N++) {
// serial direction
if (type == tf::PipeType::SERIAL) {
tf::Taskflow taskflow;
size_t j = 0;
tf::DataPipeline pl (L, tf::make_data_pipe<tf::Pipeflow&, void>(type, [L, N, &j, &source](auto& pf) mutable {
if (j == N) {
pf.stop();
return;
}
REQUIRE(j == source[j]);
REQUIRE(pf.token() % L == pf.line());
j++;
}));
auto datapipeline = taskflow.composed_of(pl).name("module_of_datapipeline");
auto test = taskflow.emplace([&](){
REQUIRE(j == N);
REQUIRE(pl.num_tokens() == N);
}).name("test");
datapipeline.precede(test);
executor.run_until(taskflow, [counter=3, j]() mutable{
j = 0;
return counter --== 0;
}).get();
}
}
}
// serial pipe with one line
TEST_CASE("DataPipeline.1P(S).1L.1W" * doctest::timeout(300)) {
data_pipeline_1P(1, 1, tf::PipeType::SERIAL);
}
TEST_CASE("DataPipeline.1P(S).1L.2W" * doctest::timeout(300)) {
data_pipeline_1P(1, 2, tf::PipeType::SERIAL);
}
TEST_CASE("DataPipeline.1P(S).1L.3W" * doctest::timeout(300)) {
data_pipeline_1P(1, 3, tf::PipeType::SERIAL);
}
TEST_CASE("DataPipeline.1P(S).1L.4W" * doctest::timeout(300)) {
data_pipeline_1P(1, 4, tf::PipeType::SERIAL);
}
// serial pipe with two lines
TEST_CASE("DataPipeline.1P(S).2L.1W" * doctest::timeout(300)) {
data_pipeline_1P(2, 1, tf::PipeType::SERIAL);
}
TEST_CASE("DataPipeline.1P(S).2L.2W" * doctest::timeout(300)) {
data_pipeline_1P(2, 2, tf::PipeType::SERIAL);
}
TEST_CASE("DataPipeline.1P(S).2L.3W" * doctest::timeout(300)) {
data_pipeline_1P(2, 3, tf::PipeType::SERIAL);
}
TEST_CASE("DataPipeline.1P(S).2L.4W" * doctest::timeout(300)) {
data_pipeline_1P(2, 4, tf::PipeType::SERIAL);
}
// serial pipe with three lines
TEST_CASE("DataPipeline.1P(S).3L.1W" * doctest::timeout(300)) {
data_pipeline_1P(3, 1, tf::PipeType::SERIAL);
}
TEST_CASE("DataPipeline.1P(S).3L.2W" * doctest::timeout(300)) {
data_pipeline_1P(3, 2, tf::PipeType::SERIAL);
}
TEST_CASE("DataPipeline.1P(S).3L.3W" * doctest::timeout(300)) {
data_pipeline_1P(3, 3, tf::PipeType::SERIAL);
}
TEST_CASE("DataPipeline.1P(S).3L.4W" * doctest::timeout(300)) {
data_pipeline_1P(3, 4, tf::PipeType::SERIAL);
}
// serial pipe with three lines
TEST_CASE("DataPipeline.1P(S).4L.1W" * doctest::timeout(300)) {
data_pipeline_1P(4, 1, tf::PipeType::SERIAL);
}
TEST_CASE("DataPipeline.1P(S).4L.2W" * doctest::timeout(300)) {
data_pipeline_1P(4, 2, tf::PipeType::SERIAL);
}
TEST_CASE("DataPipeline.1P(S).4L.3W" * doctest::timeout(300)) {
data_pipeline_1P(4, 3, tf::PipeType::SERIAL);
}
TEST_CASE("DataPipeline.1P(S).4L.4W" * doctest::timeout(300)) {
data_pipeline_1P(4, 4, tf::PipeType::SERIAL);
}
// ----------------------------------------------------------------------------
// two pipes (SS), L lines, W workers
// ----------------------------------------------------------------------------
void data_pipeline_2P_SS(size_t L, unsigned w) {
tf::Executor executor(w);
const size_t maxN = 100;
std::vector<int> source(maxN);
std::iota(source.begin(), source.end(), 0);
// std::vector<std::array<int, 2>> mybuffer(L);
for(size_t N = 0; N <= maxN; N++) {
tf::Taskflow taskflow;
size_t j1 = 0, j2 = 0;
size_t cnt = 1;
tf::DataPipeline pl(
L,
tf::make_data_pipe<tf::Pipeflow&, int>(tf::PipeType::SERIAL, [N, &source, &j1, L](auto& pf) mutable {
if(j1 == N) {
pf.stop();
return 0;
}
REQUIRE(j1 == source[j1]);
REQUIRE(pf.token() % L == pf.line());
// mybuffer[pf.line()][pf.pipe()] = source[j1] + 1;
// j1++;
return source[j1++] + 1;
}),
tf::make_data_pipe<int, void>(tf::PipeType::SERIAL, [N, &source, &j2, L](int& input, tf::Pipeflow& pf) mutable {
REQUIRE(j2 < N);
REQUIRE(pf.token() % L == pf.line());
// REQUIRE(source[j2] + 1 == mybuffer[pf.line()][pf.pipe() - 1]);
// j2++;
REQUIRE(source[j2++] + 1 == input);
})
);
auto datapipeline = taskflow.composed_of(pl).name("module_of_datapipeline");
auto test = taskflow.emplace([&](){
REQUIRE(j1 == N);
REQUIRE(j2 == N);
REQUIRE(pl.num_tokens() == cnt * N);
}).name("test");
datapipeline.precede(test);
executor.run_n(taskflow, 3, [&]() mutable {
j1 = 0;
j2 = 0;
// for(size_t i = 0; i < mybuffer.size(); ++i){
// for(size_t j = 0; j < mybuffer[0].size(); ++j){
// mybuffer[i][j] = 0;
// }
// }
cnt++;
}).get();
}
}
// two pipes (SS)
TEST_CASE("DataPipeline.2P(SS).1L.1W" * doctest::timeout(300)) {
data_pipeline_2P_SS(1, 1);
}
TEST_CASE("DataPipeline.2P(SS).1L.2W" * doctest::timeout(300)) {
data_pipeline_2P_SS(1, 2);
}
TEST_CASE("DataPipeline.2P(SS).1L.3W" * doctest::timeout(300)) {
data_pipeline_2P_SS(1, 3);
}
TEST_CASE("DataPipeline.2P(SS).1L.4W" * doctest::timeout(300)) {
data_pipeline_2P_SS(1, 4);
}
TEST_CASE("DataPipeline.2P(SS).2L.1W" * doctest::timeout(300)) {
data_pipeline_2P_SS(2, 1);
}
TEST_CASE("DataPipeline.2P(SS).2L.2W" * doctest::timeout(300)) {
data_pipeline_2P_SS(2, 2);
}
TEST_CASE("DataPipeline.2P(SS).2L.3W" * doctest::timeout(300)) {
data_pipeline_2P_SS(2, 3);
}
TEST_CASE("DataPipeline.2P(SS).2L.4W" * doctest::timeout(300)) {
data_pipeline_2P_SS(2, 4);
}
TEST_CASE("DataPipeline.2P(SS).3L.1W" * doctest::timeout(300)) {
data_pipeline_2P_SS(3, 1);
}
TEST_CASE("DataPipeline.2P(SS).3L.2W" * doctest::timeout(300)) {
data_pipeline_2P_SS(3, 2);
}
TEST_CASE("DataPipeline.2P(SS).3L.3W" * doctest::timeout(300)) {
data_pipeline_2P_SS(3, 3);
}
TEST_CASE("DataPipeline.2P(SS).3L.4W" * doctest::timeout(300)) {
data_pipeline_2P_SS(3, 4);
}
TEST_CASE("DataPipeline.2P(SS).4L.1W" * doctest::timeout(300)) {
data_pipeline_2P_SS(4, 1);
}
TEST_CASE("DataPipeline.2P(SS).4L.2W" * doctest::timeout(300)) {
data_pipeline_2P_SS(4, 2);
}
TEST_CASE("DataPipeline.2P(SS).4L.3W" * doctest::timeout(300)) {
data_pipeline_2P_SS(4, 3);
}
TEST_CASE("DataPipeline.2P(SS).4L.4W" * doctest::timeout(300)) {
data_pipeline_2P_SS(4, 4);
}
// ----------------------------------------------------------------------------
// two pipes (SP), L lines, W workers
// ----------------------------------------------------------------------------
void data_pipeline_2P_SP(size_t L, unsigned w) {
tf::Executor executor(w);
const size_t maxN = 100;
std::vector<int> source(maxN);
std::iota(source.begin(), source.end(), 0);
// std::vector<std::array<int, 2>> mybuffer(L);
for(size_t N = 0; N <= maxN; N++) {
tf::Taskflow taskflow;
size_t j1 = 0;
std::atomic<size_t> j2 = 0;
std::mutex mutex;
std::vector<int> collection;
size_t cnt = 1;
tf::DataPipeline pl(L,
tf::make_data_pipe<tf::Pipeflow&, int>(tf::PipeType::SERIAL, [N, &source, &j1, L](auto& pf) mutable {
if(j1 == N) {
pf.stop();
return 0;
}
REQUIRE(j1 == source[j1]);
REQUIRE(pf.token() % L == pf.line());
// mybuffer[pf.line()][pf.pipe()] = source[j1] + 1;
// j1++;
return source[j1++] + 1;
}),
tf::make_data_pipe<int, void>(tf::PipeType::PARALLEL,
[N, &collection, &mutex, &j2, L](int& input, tf::Pipeflow& pf) mutable {
REQUIRE(j2++ < N);
{
std::scoped_lock<std::mutex> lock(mutex);
REQUIRE(pf.token() % L == pf.line());
// collection.push_back(mybuffer[pf.line()][pf.pipe() - 1]);
collection.push_back(input);
}
})
);
auto datapipeline = taskflow.composed_of(pl).name("module_of_datapipeline");
auto test = taskflow.emplace([&](){
REQUIRE(j1 == N);
REQUIRE(j2 == N);
std::sort(collection.begin(), collection.end());
for(size_t i = 0; i < N; i++) {
REQUIRE(collection[i] == i + 1);
}
REQUIRE(pl.num_tokens() == cnt * N);
}).name("test");
datapipeline.precede(test);
executor.run_n(taskflow, 3, [&]() mutable {
j1 = j2 = 0;
collection.clear();
// for(size_t i = 0; i < mybuffer.size(); ++i){
// for(size_t j = 0; j < mybuffer[0].size(); ++j){
// mybuffer[i][j] = 0;
// }
// }
cnt++;
}).get();
}
}
// two pipes (SP)
TEST_CASE("DataPipeline.2P(SP).1L.1W" * doctest::timeout(300)) {
data_pipeline_2P_SP(1, 1);
}
TEST_CASE("DataPipeline.2P(SP).1L.2W" * doctest::timeout(300)) {
data_pipeline_2P_SP(1, 2);
}
TEST_CASE("DataPipeline.2P(SP).1L.3W" * doctest::timeout(300)) {
data_pipeline_2P_SP(1, 3);
}
TEST_CASE("DataPipeline.2P(SP).1L.4W" * doctest::timeout(300)) {
data_pipeline_2P_SP(1, 4);
}
TEST_CASE("DataPipeline.2P(SP).2L.1W" * doctest::timeout(300)) {
data_pipeline_2P_SP(2, 1);
}
TEST_CASE("DataPipeline.2P(SP).2L.2W" * doctest::timeout(300)) {
data_pipeline_2P_SP(2, 2);
}
TEST_CASE("DataPipeline.2P(SP).2L.3W" * doctest::timeout(300)) {
data_pipeline_2P_SP(2, 3);
}
TEST_CASE("DataPipeline.2P(SP).2L.4W" * doctest::timeout(300)) {
data_pipeline_2P_SP(2, 4);
}
TEST_CASE("DataPipeline.2P(SP).3L.1W" * doctest::timeout(300)) {
data_pipeline_2P_SP(3, 1);
}
TEST_CASE("DataPipeline.2P(SP).3L.2W" * doctest::timeout(300)) {
data_pipeline_2P_SP(3, 2);
}
TEST_CASE("DataPipeline.2P(SP).3L.3W" * doctest::timeout(300)) {
data_pipeline_2P_SP(3, 3);
}
TEST_CASE("DataPipeline.2P(SP).3L.4W" * doctest::timeout(300)) {
data_pipeline_2P_SP(3, 4);
}
TEST_CASE("DataPipeline.2P(SP).4L.1W" * doctest::timeout(300)) {
data_pipeline_2P_SP(4, 1);
}
TEST_CASE("DataPipeline.2P(SP).4L.2W" * doctest::timeout(300)) {
data_pipeline_2P_SP(4, 2);
}
TEST_CASE("DataPipeline.2P(SP).4L.3W" * doctest::timeout(300)) {
data_pipeline_2P_SP(4, 3);
}
TEST_CASE("DataPipeline.2P(SP).4L.4W" * doctest::timeout(300)) {
data_pipeline_2P_SP(4, 4);
}
// ----------------------------------------------------------------------------
// three pipes (SSS), L lines, W workers
// ----------------------------------------------------------------------------
void data_pipeline_3P_SSS(size_t L, unsigned w) {
tf::Executor executor(w);
const size_t maxN = 100;
std::vector<int> source(maxN);
std::iota(source.begin(), source.end(), 0);
// std::vector<std::array<int, 3>> mybuffer(L);
for(size_t N = 0; N <= maxN; N++) {
tf::Taskflow taskflow;
size_t j1 = 0, j2 = 0, j3 = 0;
size_t cnt = 1;
tf::DataPipeline pl(L,
tf::make_data_pipe<tf::Pipeflow&, int>(tf::PipeType::SERIAL, [N, &source, &j1, L](auto& pf) mutable {
if(j1 == N) {
pf.stop();
return 0;
}
REQUIRE(j1 == source[j1]);
REQUIRE(pf.token() % L == pf.line());
// mybuffer[pf.line()][pf.pipe()] = source[j1] + 1;
// j1++;
return source[j1++] + 1;
}),
tf::make_data_pipe<int, std::string>(tf::PipeType::SERIAL, [N, &source, &j2, L](int input, tf::Pipeflow& pf) mutable {
REQUIRE(j2 < N);
REQUIRE(source[j2] + 1 == input);
REQUIRE(pf.token() % L == pf.line());
// mybuffer[pf.line()][pf.pipe()] = source[j2] + 1;
j2++;
return std::to_string(input);
}),
tf::make_data_pipe<std::string, void>(tf::PipeType::SERIAL, [N, &source, &j3, L](std::string input, tf::Pipeflow& pf) mutable {
REQUIRE(j3 < N);
REQUIRE(source[j3] + 1 == stoi(input));
REQUIRE(pf.token() % L == pf.line());
j3++;
})
);
auto datapipeline = taskflow.composed_of(pl).name("module_of_datapipeline");
auto test = taskflow.emplace([&](){
REQUIRE(j1 == N);
REQUIRE(j2 == N);
REQUIRE(j3 == N);
REQUIRE(pl.num_tokens() == cnt * N);
}).name("test");
datapipeline.precede(test);
executor.run_n(taskflow, 3, [&]() mutable {
j1 = j2 = j3 = 0;
// for(size_t i = 0; i < mybuffer.size(); ++i){
// for(size_t j = 0; j < mybuffer[0].size(); ++j){
// mybuffer[i][j] = 0;
// }
// }
cnt++;
}).get();
}
}
// three pipes (SSS)
TEST_CASE("DataPipeline.3P(SSS).1L.1W" * doctest::timeout(300)) {
data_pipeline_3P_SSS(1, 1);
}
TEST_CASE("DataPipeline.3P(SSS).1L.2W" * doctest::timeout(300)) {
data_pipeline_3P_SSS(1, 2);
}
TEST_CASE("DataPipeline.3P(SSS).1L.3W" * doctest::timeout(300)) {
data_pipeline_3P_SSS(1, 3);
}
TEST_CASE("DataPipeline.3P(SSS).1L.4W" * doctest::timeout(300)) {
data_pipeline_3P_SSS(1, 4);
}
TEST_CASE("DataPipeline.3P(SSS).2L.1W" * doctest::timeout(300)) {
data_pipeline_3P_SSS(2, 1);
}
TEST_CASE("DataPipeline.3P(SSS).2L.2W" * doctest::timeout(300)) {
data_pipeline_3P_SSS(2, 2);
}
TEST_CASE("DataPipeline.3P(SSS).2L.3W" * doctest::timeout(300)) {
data_pipeline_3P_SSS(2, 3);
}
TEST_CASE("DataPipeline.3P(SSS).2L.4W" * doctest::timeout(300)) {
data_pipeline_3P_SSS(2, 4);
}
TEST_CASE("DataPipeline.3P(SSS).3L.1W" * doctest::timeout(300)) {
data_pipeline_3P_SSS(3, 1);
}
TEST_CASE("DataPipeline.3P(SSS).3L.2W" * doctest::timeout(300)) {
data_pipeline_3P_SSS(3, 2);
}
TEST_CASE("DataPipeline.3P(SSS).3L.3W" * doctest::timeout(300)) {
data_pipeline_3P_SSS(3, 3);
}
TEST_CASE("DataPipeline.3P(SSS).3L.4W" * doctest::timeout(300)) {
data_pipeline_3P_SSS(3, 4);
}
TEST_CASE("DataPipeline.3P(SSS).4L.1W" * doctest::timeout(300)) {
data_pipeline_3P_SSS(4, 1);
}
TEST_CASE("DataPipeline.3P(SSS).4L.2W" * doctest::timeout(300)) {
data_pipeline_3P_SSS(4, 2);
}
TEST_CASE("DataPipeline.3P(SSS).4L.3W" * doctest::timeout(300)) {
data_pipeline_3P_SSS(4, 3);
}
TEST_CASE("DataPipeline.3P(SSS).4L.4W" * doctest::timeout(300)) {
data_pipeline_3P_SSS(4, 4);
}
// ----------------------------------------------------------------------------
// three pipes (SSP), L lines, W workers
// ----------------------------------------------------------------------------
void data_pipeline_3P_SSP(size_t L, unsigned w) {
tf::Executor executor(w);
const size_t maxN = 100;
std::vector<int> source(maxN);
std::iota(source.begin(), source.end(), 0);
// std::vector<std::array<int, 3>> mybuffer(L);
for(size_t N = 0; N <= maxN; N++) {
tf::Taskflow taskflow;
size_t j1 = 0, j2 = 0;
std::atomic<size_t> j3 = 0;
std::mutex mutex;
std::vector<int> collection;
size_t cnt = 1;
tf::DataPipeline pl(L,
tf::make_data_pipe<tf::Pipeflow&, int>(tf::PipeType::SERIAL, [N, &source, &j1, L](auto& pf) mutable {
if(j1 == N) {
pf.stop();
return 0;
}
REQUIRE(j1 == source[j1]);
REQUIRE(pf.token() % L == pf.line());
//*(pf.output()) = source[j1] + 1;
// mybuffer[pf.line()][pf.pipe()] = source[j1] + 1;
// j1++;
return source[j1++] + 1;
}),
tf::make_data_pipe<int, int>(tf::PipeType::SERIAL, [N, &source, &j2, L](int input, tf::Pipeflow& pf) mutable {
REQUIRE(j2 < N);
REQUIRE(source[j2] + 1 == input);
REQUIRE(pf.token() % L == pf.line());
//*(pf.output()) = source[j2] + 1;
// mybuffer[pf.line()][pf.pipe()] = source[j2] + 1;
j2++;
return input;
}),
tf::make_data_pipe<int, void>(tf::PipeType::PARALLEL, [N, &j3, &mutex, &collection, L](int input, tf::Pipeflow& pf) mutable {
REQUIRE(j3++ < N);
{
std::scoped_lock<std::mutex> lock(mutex);
REQUIRE(pf.token() % L == pf.line());
collection.push_back(input);
}
})
);
auto datapipeline = taskflow.composed_of(pl).name("module_of_datapipeline");
auto test = taskflow.emplace([&](){
REQUIRE(j1 == N);
REQUIRE(j2 == N);
REQUIRE(j3 == N);
REQUIRE(collection.size() == N);
std::sort(collection.begin(), collection.end());
for (size_t i = 0; i < N; ++i) {
REQUIRE(collection[i] == i + 1);
}
REQUIRE(pl.num_tokens() == cnt * N);
}).name("test");
datapipeline.precede(test);
executor.run_n(taskflow, 3, [&](){
j1 = j2 = j3 = 0;
collection.clear();
// for(size_t i = 0; i < mybuffer.size(); ++i){
// for(size_t j = 0; j < mybuffer[0].size(); ++j){
// mybuffer[i][j] = 0;
// }
// }
cnt++;
}).get();
}
}
// three pipes (SSP)
TEST_CASE("DataPipeline.3P(SSP).1L.1W" * doctest::timeout(300)) {
data_pipeline_3P_SSP(1, 1);
}
TEST_CASE("DataPipeline.3P(SSP).1L.2W" * doctest::timeout(300)) {
data_pipeline_3P_SSP(1, 2);
}
TEST_CASE("DataPipeline.3P(SSP).1L.3W" * doctest::timeout(300)) {
data_pipeline_3P_SSP(1, 3);
}
TEST_CASE("DataPipeline.3P(SSP).1L.4W" * doctest::timeout(300)) {
data_pipeline_3P_SSP(1, 4);
}
TEST_CASE("DataPipeline.3P(SSP).2L.1W" * doctest::timeout(300)) {
data_pipeline_3P_SSP(2, 1);
}
TEST_CASE("DataPipeline.3P(SSP).2L.2W" * doctest::timeout(300)) {
data_pipeline_3P_SSP(2, 2);
}
TEST_CASE("DataPipeline.3P(SSP).2L.3W" * doctest::timeout(300)) {
data_pipeline_3P_SSP(2, 3);
}
TEST_CASE("DataPipeline.3P(SSP).2L.4W" * doctest::timeout(300)) {
data_pipeline_3P_SSP(2, 4);
}
TEST_CASE("DataPipeline.3P(SSP).3L.1W" * doctest::timeout(300)) {
data_pipeline_3P_SSP(3, 1);
}
TEST_CASE("DataPipeline.3P(SSP).3L.2W" * doctest::timeout(300)) {
data_pipeline_3P_SSP(3, 2);
}
TEST_CASE("DataPipeline.3P(SSP).3L.3W" * doctest::timeout(300)) {
data_pipeline_3P_SSP(3, 3);
}
TEST_CASE("DataPipeline.3P(SSP).3L.4W" * doctest::timeout(300)) {
data_pipeline_3P_SSP(3, 4);
}
TEST_CASE("DataPipeline.3P(SSP).4L.1W" * doctest::timeout(300)) {
data_pipeline_3P_SSP(4, 1);
}
TEST_CASE("DataPipeline.3P(SSP).4L.2W" * doctest::timeout(300)) {
data_pipeline_3P_SSP(4, 2);
}
TEST_CASE("DataPipeline.3P(SSP).4L.3W" * doctest::timeout(300)) {
data_pipeline_3P_SSP(4, 3);
}
TEST_CASE("DataPipeline.3P(SSP).4L.4W" * doctest::timeout(300)) {
data_pipeline_3P_SSP(4, 4);
}
// ----------------------------------------------------------------------------
// three pipes (SPS), L lines, W workers
// ----------------------------------------------------------------------------
void data_pipeline_3P_SPS(size_t L, unsigned w) {
tf::Executor executor(w);
const size_t maxN = 100;
std::vector<int> source(maxN);
std::iota(source.begin(), source.end(), 0);
// std::vector<std::array<int, 3>> mybuffer(L);
for(size_t N = 0; N <= maxN; N++) {
tf::Taskflow taskflow;
size_t j1 = 0, j3 = 0;
std::atomic<size_t> j2 = 0;
std::mutex mutex;
std::vector<int> collection;
size_t cnt = 1;
tf::DataPipeline pl(L,
tf::make_data_pipe<tf::Pipeflow&, int>(tf::PipeType::SERIAL, [N, &source, &j1, L](tf::Pipeflow& pf) mutable {
if(j1 == N) {
pf.stop();
return 0;
}
REQUIRE(j1 == source[j1]);
REQUIRE(pf.token() % L == pf.line());
//*(pf.output()) = source[j1] + 1;
// mybuffer[pf.line()][pf.pipe()] = source[j1] + 1;
// j1++;
return source[j1++] + 1;
}),
tf::make_data_pipe<int, int>(tf::PipeType::PARALLEL, [N, &j2, &mutex, &collection, L](int input, tf::Pipeflow& pf) mutable {
REQUIRE(j2++ < N);
//*(pf.output()) = *(pf.input()) + 1;
{
std::scoped_lock<std::mutex> lock(mutex);
// mybuffer[pf.line()][pf.pipe()] = mybuffer[pf.line()][pf.pipe() - 1] + 1;
REQUIRE(pf.token() % L == pf.line());
collection.push_back(input);
return input + 1;
}
}),
tf::make_data_pipe<int, void>(tf::PipeType::SERIAL, [N, &source, &j3, L](int input, tf::Pipeflow& pf) mutable {
REQUIRE(j3 < N);
REQUIRE(pf.token() % L == pf.line());
REQUIRE(source[j3] + 2 == input);
j3++;
})
);
auto datapipeline = taskflow.composed_of(pl).name("module_of_datapipeline");
auto test = taskflow.emplace([&](){
REQUIRE(j1 == N);
REQUIRE(j2 == N);
REQUIRE(j3 == N);
REQUIRE(collection.size() == N);
std::sort(collection.begin(), collection.end());
for (size_t i = 0; i < N; ++i) {
REQUIRE(collection[i] == i + 1);
}
REQUIRE(pl.num_tokens() == cnt * N);
}).name("test");
datapipeline.precede(test);
executor.run_n(taskflow, 3, [&]() mutable {
j1 = j2 = j3 = 0;
collection.clear();
// for(size_t i = 0; i < mybuffer.size(); ++i){
// for(size_t j = 0; j < mybuffer[0].size(); ++j){
// mybuffer[i][j] = 0;
// }
// }
cnt++;
}).get();
}
}
// three pipes (SPS)
TEST_CASE("DataPipeline.3P(SPS).1L.1W" * doctest::timeout(300)) {
data_pipeline_3P_SPS(1, 1);
}
TEST_CASE("DataPipeline.3P(SPS).1L.2W" * doctest::timeout(300)) {
data_pipeline_3P_SPS(1, 2);
}
TEST_CASE("DataPipeline.3P(SPS).1L.3W" * doctest::timeout(300)) {
data_pipeline_3P_SPS(1, 3);
}
TEST_CASE("DataPipeline.3P(SPS).1L.4W" * doctest::timeout(300)) {
data_pipeline_3P_SPS(1, 4);
}
TEST_CASE("DataPipeline.3P(SPS).2L.1W" * doctest::timeout(300)) {
data_pipeline_3P_SPS(2, 1);
}
TEST_CASE("DataPipeline.3P(SPS).2L.2W" * doctest::timeout(300)) {
data_pipeline_3P_SPS(2, 2);
}
TEST_CASE("DataPipeline.3P(SPS).2L.3W" * doctest::timeout(300)) {
data_pipeline_3P_SPS(2, 3);
}
TEST_CASE("DataPipeline.3P(SPS).2L.4W" * doctest::timeout(300)) {
data_pipeline_3P_SPS(2, 4);
}
TEST_CASE("DataPipeline.3P(SPS).3L.1W" * doctest::timeout(300)) {
data_pipeline_3P_SPS(3, 1);
}
TEST_CASE("DataPipeline.3P(SPS).3L.2W" * doctest::timeout(300)) {
data_pipeline_3P_SPS(3, 2);
}
TEST_CASE("DataPipeline.3P(SPS).3L.3W" * doctest::timeout(300)) {
data_pipeline_3P_SPS(3, 3);
}
TEST_CASE("DataPipeline.3P(SPS).3L.4W" * doctest::timeout(300)) {
data_pipeline_3P_SPS(3, 4);
}
TEST_CASE("DataPipeline.3P(SPS).4L.1W" * doctest::timeout(300)) {
data_pipeline_3P_SPS(4, 1);
}
TEST_CASE("DataPipeline.3P(SPS).4L.2W" * doctest::timeout(300)) {
data_pipeline_3P_SPS(4, 2);
}
TEST_CASE("DataPipeline.3P(SPS).4L.3W" * doctest::timeout(300)) {
data_pipeline_3P_SPS(4, 3);
}
TEST_CASE("DataPipeline.3P(SPS).4L.4W" * doctest::timeout(300)) {
data_pipeline_3P_SPS(4, 4);
}
// ----------------------------------------------------------------------------
// three pipes (SPP), L lines, W workers
// ----------------------------------------------------------------------------
void data_pipeline_3P_SPP(size_t L, unsigned w) {
tf::Executor executor(w);
const size_t maxN = 100;
std::vector<int> source(maxN);
std::iota(source.begin(), source.end(), 0);
// std::vector<std::array<int, 3>> mybuffer(L);
for(size_t N = 0; N <= maxN; N++) {
tf::Taskflow taskflow;
size_t j1 = 0;
std::atomic<size_t> j2 = 0;
std::atomic<size_t> j3 = 0;
std::mutex mutex2;
std::mutex mutex3;
std::vector<int> collection2;
std::vector<int> collection3;
size_t cnt = 1;
tf::DataPipeline pl(L,
tf::make_data_pipe<tf::Pipeflow&, int>(tf::PipeType::SERIAL, [N, &source, &j1, L](tf::Pipeflow& pf) mutable {
if(j1 == N) {
pf.stop();
return 0;
}
REQUIRE(j1 == source[j1]);
REQUIRE(pf.token() % L == pf.line());
//*(pf.output()) = source[j1] + 1;
// mybuffer[pf.line()][pf.pipe()] = source[j1] + 1;
// j1++;
return source[j1++] + 1;
}),
tf::make_data_pipe<int, int>(tf::PipeType::PARALLEL, [N, &j2, &mutex2, &collection2, L](int input, tf::Pipeflow& pf) mutable {
REQUIRE(j2++ < N);
//*pf.output() = *pf.input() + 1;
{
std::scoped_lock<std::mutex> lock(mutex2);
REQUIRE(pf.token() % L == pf.line());
// mybuffer[pf.line()][pf.pipe()] = mybuffer[pf.line()][pf.pipe() - 1] + 1;
collection2.push_back(input);
return input + 1;
}
}),
tf::make_data_pipe<int, void>(tf::PipeType::PARALLEL, [N, &j3, &mutex3, &collection3, L](int input, tf::Pipeflow& pf) mutable {
REQUIRE(j3++ < N);
{
std::scoped_lock<std::mutex> lock(mutex3);
REQUIRE(pf.token() % L == pf.line());
collection3.push_back(input);
}
})
);
auto datapipeline = taskflow.composed_of(pl).name("module_of_datapipeline");
auto test = taskflow.emplace([&](){
REQUIRE(j1 == N);
REQUIRE(j2 == N);
REQUIRE(j3 == N);
REQUIRE(collection2.size() == N);
REQUIRE(collection3.size() == N);
std::sort(collection2.begin(), collection2.end());
std::sort(collection3.begin(), collection3.end());
for (size_t i = 0; i < N; ++i) {
REQUIRE(collection2[i] == i + 1);
REQUIRE(collection3[i] == i + 2);
}
REQUIRE(pl.num_tokens() == cnt * N);
}).name("test");
datapipeline.precede(test);
executor.run_n(taskflow, 3, [&]() mutable {
j1 = j2 = j3 = 0;
collection2.clear();
collection3.clear();
// for(size_t i = 0; i < mybuffer.size(); ++i){
// for(size_t j = 0; j < mybuffer[0].size(); ++j){
// mybuffer[i][j] = 0;
// }
// }
cnt++;
}).get();
}
}
// three pipes (SPP)
TEST_CASE("DataPipeline.3P(SPP).1L.1W" * doctest::timeout(300)) {
data_pipeline_3P_SPP(1, 1);
}
TEST_CASE("DataPipeline.3P(SPP).1L.2W" * doctest::timeout(300)) {
data_pipeline_3P_SPP(1, 2);
}
TEST_CASE("DataPipeline.3P(SPP).1L.3W" * doctest::timeout(300)) {
data_pipeline_3P_SPP(1, 3);
}
TEST_CASE("DataPipeline.3P(SPP).1L.4W" * doctest::timeout(300)) {
data_pipeline_3P_SPP(1, 4);
}
TEST_CASE("DataPipeline.3P(SPP).2L.1W" * doctest::timeout(300)) {
data_pipeline_3P_SPP(2, 1);
}
TEST_CASE("DataPipeline.3P(SPP).2L.2W" * doctest::timeout(300)) {
data_pipeline_3P_SPP(2, 2);
}
TEST_CASE("DataPipeline.3P(SPP).2L.3W" * doctest::timeout(300)) {
data_pipeline_3P_SPP(2, 3);
}
TEST_CASE("DataPipeline.3P(SPP).2L.4W" * doctest::timeout(300)) {
data_pipeline_3P_SPP(2, 4);
}
TEST_CASE("DataPipeline.3P(SPP).3L.1W" * doctest::timeout(300)) {
data_pipeline_3P_SPP(3, 1);
}
TEST_CASE("DataPipeline.3P(SPP).3L.2W" * doctest::timeout(300)) {
data_pipeline_3P_SPP(3, 2);
}
TEST_CASE("DataPipeline.3P(SPP).3L.3W" * doctest::timeout(300)) {
data_pipeline_3P_SPP(3, 3);
}
TEST_CASE("DataPipeline.3P(SPP).3L.4W" * doctest::timeout(300)) {
data_pipeline_3P_SPP(3, 4);
}
TEST_CASE("DataPipeline.3P(SPP).4L.1W" * doctest::timeout(300)) {
data_pipeline_3P_SPP(4, 1);
}
TEST_CASE("DataPipeline.3P(SPP).4L.2W" * doctest::timeout(300)) {
data_pipeline_3P_SPP(4, 2);
}
TEST_CASE("DataPipeline.3P(SPP).4L.3W" * doctest::timeout(300)) {
data_pipeline_3P_SPP(4, 3);
}
TEST_CASE("DataPipeline.3P(SPP).4L.4W" * doctest::timeout(300)) {
data_pipeline_3P_SPP(4, 4);
}
// ----------------------------------------------------------------------------
// three parallel pipelines. each pipeline with L lines.
// one with four pipes (SSSS), one with three pipes (SPP),
// One with two Pipes (SP)
//
// --> SSSS --> O --
// | |
// O -> --> SSP --> O -- --> O
// | |
// --> SP --> O --
//
// ----------------------------------------------------------------------------
void three_parallel_data_pipelines(size_t L, unsigned w) {
tf::Executor executor(w);
const size_t maxN = 100;
std::vector<int> source(maxN);
std::iota(source.begin(), source.end(), 0);
// std::vector<std::array<int, 4>> mybuffer1(L);
// std::vector<std::array<int, 3>> mybuffer2(L);
// std::vector<std::array<int, 2>> mybuffer3(L);
for(size_t N = 0; N <= maxN; N++) {
tf::Taskflow taskflow;
size_t j1_1 = 0, j1_2 = 0, j1_3 = 0, j1_4 = 0;
size_t cnt1 = 1;
// pipeline 1 is SSSS
tf::DataPipeline pl1(L,
tf::make_data_pipe<tf::Pipeflow&, int>(tf::PipeType::SERIAL, [N, &source, &j1_1, L](tf::Pipeflow& pf) mutable {
if(j1_1 == N) {
pf.stop();
return 0;
}
REQUIRE(j1_1 == source[j1_1]);
REQUIRE(pf.token() % L == pf.line());
// mybuffer1[pf.line()][pf.pipe()] = source[j1_1] + 1;
// j1_1++;
return source[j1_1++] + 1;
}),
tf::make_data_pipe<int, int>(tf::PipeType::SERIAL, [N, &source, &j1_2, L](int input, tf::Pipeflow& pf) mutable {
REQUIRE(j1_2 < N);
REQUIRE(pf.token() % L == pf.line());
REQUIRE(source[j1_2] + 1 == input);
// mybuffer1[pf.line()][pf.pipe()] = source[j1_2] + 1;
j1_2++;
return input;
}),
tf::make_data_pipe<int, int>(tf::PipeType::SERIAL, [N, &source, &j1_3, L](int input, tf::Pipeflow& pf) mutable {
REQUIRE(j1_3 < N);
REQUIRE(pf.token() % L == pf.line());
REQUIRE(source[j1_3] + 1 == input);
// mybuffer1[pf.line()][pf.pipe()] = source[j1_3] + 1;
j1_3++;
return input;
}),
tf::make_data_pipe<int, void>(tf::PipeType::SERIAL, [N, &source, &j1_4, L](int input, tf::Pipeflow& pf) mutable {
REQUIRE(j1_4 < N);
REQUIRE(pf.token() % L == pf.line());
REQUIRE(source[j1_4] + 1 == input);
j1_4++;
})
);
auto datapipeline1 = taskflow.composed_of(pl1).name("module_of_datapipeline1");
auto test1 = taskflow.emplace([&](){
REQUIRE(j1_1 == N);
REQUIRE(j1_2 == N);
REQUIRE(j1_3 == N);
REQUIRE(j1_4 == N);
REQUIRE(pl1.num_tokens() == cnt1 * N);
}).name("test1");
datapipeline1.precede(test1);
// the followings are definitions for pipeline 2
size_t j2_1 = 0, j2_2 = 0;
std::atomic<size_t> j2_3 = 0;
std::mutex mutex2_3;
std::vector<int> collection2_3;
size_t cnt2 = 1;
// pipeline 2 is SSP
tf::DataPipeline pl2(L,
tf::make_data_pipe<tf::Pipeflow&, int>(tf::PipeType::SERIAL, [N, &source, &j2_1, L](tf::Pipeflow& pf) mutable {
if(j2_1 == N) {
pf.stop();
return 0 ;
}
REQUIRE(j2_1 == source[j2_1]);
REQUIRE(pf.token() % L == pf.line());
// mybuffer2[pf.line()][pf.pipe()] = source[j2_1] + 1;
// j2_1++;
return source[j2_1++] + 1;
}),
tf::make_data_pipe<int, int>(tf::PipeType::SERIAL, [N, &source, &j2_2, L](int input, tf::Pipeflow& pf) mutable {
REQUIRE(j2_2 < N);
REQUIRE(source[j2_2] + 1 == input);
REQUIRE(pf.token() % L == pf.line());
// mybuffer2[pf.line()][pf.pipe()] = source[j2_2] + 1;
j2_2++;
return input;
}),
tf::make_data_pipe<int, void>(tf::PipeType::PARALLEL, [N, &j2_3, &mutex2_3, &collection2_3, L](int input, tf::Pipeflow& pf) mutable {
REQUIRE(j2_3++ < N);
{
std::scoped_lock<std::mutex> lock(mutex2_3);
REQUIRE(pf.token() % L == pf.line());
collection2_3.push_back(input);
}
})
);
auto datapipeline2 = taskflow.composed_of(pl2).name("module_of_datapipeline2");
auto test2 = taskflow.emplace([&](){
REQUIRE(j2_1 == N);
REQUIRE(j2_2 == N);
REQUIRE(j2_3 == N);
REQUIRE(collection2_3.size() == N);
std::sort(collection2_3.begin(), collection2_3.end());
for (size_t i = 0; i < N; ++i) {
REQUIRE(collection2_3[i] == i + 1);
}
REQUIRE(pl2.num_tokens() == cnt2 * N);
}).name("test2");
datapipeline2.precede(test2);
// the followings are definitions for pipeline 3
size_t j3_1 = 0;
std::atomic<size_t> j3_2 = 0;
std::mutex mutex3_2;
std::vector<int> collection3_2;
size_t cnt3 = 1;
// pipeline 3 is SP
tf::DataPipeline pl3(L,
tf::make_data_pipe<tf::Pipeflow&, int>(tf::PipeType::SERIAL, [N, &source, &j3_1, L](tf::Pipeflow& pf) mutable {
if(j3_1 == N) {
pf.stop();
return 0;
}
REQUIRE(j3_1 == source[j3_1]);
REQUIRE(pf.token() % L == pf.line());
// mybuffer3[pf.line()][pf.pipe()] = source[j3_1] + 1;
// j3_1++;
return source[j3_1++] + 1;
}),
tf::make_data_pipe<int, void>(tf::PipeType::PARALLEL,
[N, &collection3_2, &mutex3_2, &j3_2, L](int input, tf::Pipeflow& pf) mutable {
REQUIRE(j3_2++ < N);
{
std::scoped_lock<std::mutex> lock(mutex3_2);
REQUIRE(pf.token() % L == pf.line());
collection3_2.push_back(input);
}
})
);
auto datapipeline3 = taskflow.composed_of(pl3).name("module_of_datapipeline3");
auto test3 = taskflow.emplace([&](){
REQUIRE(j3_1 == N);
REQUIRE(j3_2 == N);
std::sort(collection3_2.begin(), collection3_2.end());
for(size_t i = 0; i < N; i++) {
REQUIRE(collection3_2[i] == i + 1);
}
REQUIRE(pl3.num_tokens() == cnt3 * N);
}).name("test3");
datapipeline3.precede(test3);
auto initial = taskflow.emplace([](){}).name("initial");
auto terminal = taskflow.emplace([](){}).name("terminal");
initial.precede(datapipeline1, datapipeline2, datapipeline3);
terminal.succeed(test1, test2, test3);
//taskflow.dump(std::cout);
executor.run_n(taskflow, 3, [&]() mutable {
// reset variables for pipeline 1
j1_1 = j1_2 = j1_3 = j1_4 = 0;
// for(size_t i = 0; i < mybuffer1.size(); ++i){
// for(size_t j = 0; j < mybuffer1[0].size(); ++j){
// mybuffer1[i][j] = 0;
// }
// }
cnt1++;
// reset variables for pipeline 2
j2_1 = j2_2 = j2_3 = 0;
collection2_3.clear();
// for(size_t i = 0; i < mybuffer2.size(); ++i){
// for(size_t j = 0; j < mybuffer2[0].size(); ++j){
// mybuffer2[i][j] = 0;
// }
// }
cnt2++;
// reset variables for pipeline 3
j3_1 = j3_2 = 0;
collection3_2.clear();
// for(size_t i = 0; i < mybuffer3.size(); ++i){
// for(size_t j = 0; j < mybuffer3[0].size(); ++j){
// mybuffer3[i][j] = 0;
// }
// }
cnt3++;
}).get();
}
}
// three parallel piplines
TEST_CASE("Three.Parallel.DataPipelines.1L.1W" * doctest::timeout(300)) {
three_parallel_data_pipelines(1, 1);
}
TEST_CASE("Three.Parallel.DataPipelines.1L.2W" * doctest::timeout(300)) {
three_parallel_data_pipelines(1, 2);
}
TEST_CASE("Three.Parallel.DataPipelines.1L.3W" * doctest::timeout(300)) {
three_parallel_data_pipelines(1, 3);
}
TEST_CASE("Three.Parallel.DataPipelines.1L.4W" * doctest::timeout(300)) {
three_parallel_data_pipelines(1, 4);
}
TEST_CASE("Three.Parallel.DataPipelines.1L.5W" * doctest::timeout(300)) {
three_parallel_data_pipelines(1, 5);
}
TEST_CASE("Three.Parallel.DataPipelines.1L.6W" * doctest::timeout(300)) {
three_parallel_data_pipelines(1, 6);
}
TEST_CASE("Three.Parallel.DataPipelines.1L.7W" * doctest::timeout(300)) {
three_parallel_data_pipelines(1, 7);
}
TEST_CASE("Three.Parallel.DataPipelines.1L.8W" * doctest::timeout(300)) {
three_parallel_data_pipelines(1, 8);
}
TEST_CASE("Three.Parallel.DataPipelines.2L.1W" * doctest::timeout(300)) {
three_parallel_data_pipelines(2, 1);
}
TEST_CASE("Three.Parallel.DataPipelines.2L.2W" * doctest::timeout(300)) {
three_parallel_data_pipelines(2, 2);
}
TEST_CASE("Three.Parallel.DataPipelines.2L.3W" * doctest::timeout(300)) {
three_parallel_data_pipelines(2, 3);
}
TEST_CASE("Three.Parallel.DataPipelines.2L.4W" * doctest::timeout(300)) {
three_parallel_data_pipelines(2, 4);
}
TEST_CASE("Three.Parallel.DataPipelines.2L.5W" * doctest::timeout(300)) {
three_parallel_data_pipelines(2, 5);
}
TEST_CASE("Three.Parallel.DataPipelines.2L.6W" * doctest::timeout(300)) {
three_parallel_data_pipelines(2, 6);
}
TEST_CASE("Three.Parallel.DataPipelines.2L.7W" * doctest::timeout(300)) {
three_parallel_data_pipelines(2, 7);
}
TEST_CASE("Three.Parallel.DataPipelines.2L.8W" * doctest::timeout(300)) {
three_parallel_data_pipelines(2, 8);
}
TEST_CASE("Three.Parallel.DataPipelines.3L.1W" * doctest::timeout(300)) {
three_parallel_data_pipelines(3, 1);
}
TEST_CASE("Three.Parallel.DataPipelines.3L.2W" * doctest::timeout(300)) {
three_parallel_data_pipelines(3, 2);
}
TEST_CASE("Three.Parallel.DataPipelines.3L.3W" * doctest::timeout(300)) {
three_parallel_data_pipelines(3, 3);
}
TEST_CASE("Three.Parallel.DataPipelines.3L.4W" * doctest::timeout(300)) {
three_parallel_data_pipelines(3, 4);
}
TEST_CASE("Three.Parallel.DataPipelines.3L.5W" * doctest::timeout(300)) {
three_parallel_data_pipelines(3, 5);
}
TEST_CASE("Three.Parallel.DataPipelines.3L.6W" * doctest::timeout(300)) {
three_parallel_data_pipelines(3, 6);
}
TEST_CASE("Three.Parallel.DataPipelines.3L.7W" * doctest::timeout(300)) {
three_parallel_data_pipelines(3, 7);
}
TEST_CASE("Three.Parallel.DataPipelines.3L.8W" * doctest::timeout(300)) {
three_parallel_data_pipelines(3, 8);
}
TEST_CASE("Three.Parallel.DataPipelines.4L.1W" * doctest::timeout(300)) {
three_parallel_data_pipelines(4, 1);
}
TEST_CASE("Three.Parallel.DataPipelines.4L.2W" * doctest::timeout(300)) {
three_parallel_data_pipelines(4, 2);
}
TEST_CASE("Three.Parallel.DataPipelines.4L.3W" * doctest::timeout(300)) {
three_parallel_data_pipelines(4, 3);
}
TEST_CASE("Three.Parallel.DataPipelines.4L.4W" * doctest::timeout(300)) {
three_parallel_data_pipelines(4, 4);
}
TEST_CASE("Three.Parallel.DataPipelines.4L.5W" * doctest::timeout(300)) {
three_parallel_data_pipelines(4, 5);
}
TEST_CASE("Three.Parallel.DataPipelines.4L.6W" * doctest::timeout(300)) {
three_parallel_data_pipelines(4, 6);
}
TEST_CASE("Three.Parallel.DataPipelines.4L.7W" * doctest::timeout(300)) {
three_parallel_data_pipelines(4, 7);
}
TEST_CASE("Three.Parallel.DataPipelines.4L.8W" * doctest::timeout(300)) {
three_parallel_data_pipelines(4, 8);
}
TEST_CASE("Three.Parallel.DataPipelines.5L.1W" * doctest::timeout(300)) {
three_parallel_data_pipelines(5, 1);
}
TEST_CASE("Three.Parallel.DataPipelines.5L.2W" * doctest::timeout(300)) {
three_parallel_data_pipelines(5, 2);
}
TEST_CASE("Three.Parallel.DataPipelines.5L.3W" * doctest::timeout(300)) {
three_parallel_data_pipelines(5, 3);
}
TEST_CASE("Three.Parallel.DataPipelines.5L.4W" * doctest::timeout(300)) {
three_parallel_data_pipelines(5, 4);
}
TEST_CASE("Three.Parallel.DataPipelines.5L.5W" * doctest::timeout(300)) {
three_parallel_data_pipelines(5, 5);
}
TEST_CASE("Three.Parallel.DataPipelines.5L.6W" * doctest::timeout(300)) {
three_parallel_data_pipelines(5, 6);
}
TEST_CASE("Three.Parallel.DataPipelines.5L.7W" * doctest::timeout(300)) {
three_parallel_data_pipelines(5, 7);
}
TEST_CASE("Three.Parallel.DataPipelines.5L.8W" * doctest::timeout(300)) {
three_parallel_data_pipelines(5, 8);
}
TEST_CASE("Three.Parallel.DataPipelines.6L.1W" * doctest::timeout(300)) {
three_parallel_data_pipelines(6, 1);
}
TEST_CASE("Three.Parallel.DataPipelines.6L.2W" * doctest::timeout(300)) {
three_parallel_data_pipelines(6, 2);
}
TEST_CASE("Three.Parallel.DataPipelines.6L.3W" * doctest::timeout(300)) {
three_parallel_data_pipelines(6, 3);
}
TEST_CASE("Three.Parallel.DataPipelines.6L.4W" * doctest::timeout(300)) {
three_parallel_data_pipelines(6, 4);
}
TEST_CASE("Three.Parallel.DataPipelines.6L.5W" * doctest::timeout(300)) {
three_parallel_data_pipelines(6, 5);
}
TEST_CASE("Three.Parallel.DataPipelines.6L.6W" * doctest::timeout(300)) {
three_parallel_data_pipelines(6, 6);
}
TEST_CASE("Three.Parallel.DataPipelines.6L.7W" * doctest::timeout(300)) {
three_parallel_data_pipelines(6, 7);
}
TEST_CASE("Three.Parallel.DataPipelines.6L.8W" * doctest::timeout(300)) {
three_parallel_data_pipelines(6, 8);
}
TEST_CASE("Three.Parallel.DataPipelines.7L.1W" * doctest::timeout(300)) {
three_parallel_data_pipelines(7, 1);
}
TEST_CASE("Three.Parallel.DataPipelines.7L.2W" * doctest::timeout(300)) {
three_parallel_data_pipelines(7, 2);
}
TEST_CASE("Three.Parallel.DataPipelines.7L.3W" * doctest::timeout(300)) {
three_parallel_data_pipelines(7, 3);
}
TEST_CASE("Three.Parallel.DataPipelines.7L.4W" * doctest::timeout(300)) {
three_parallel_data_pipelines(7, 4);
}
TEST_CASE("Three.Parallel.DataPipelines.7L.5W" * doctest::timeout(300)) {
three_parallel_data_pipelines(7, 5);
}
TEST_CASE("Three.Parallel.DataPipelines.7L.6W" * doctest::timeout(300)) {
three_parallel_data_pipelines(7, 6);
}
TEST_CASE("Three.Parallel.DataPipelines.7L.7W" * doctest::timeout(300)) {
three_parallel_data_pipelines(7, 7);
}
TEST_CASE("Three.Parallel.DataPipelines.7L.8W" * doctest::timeout(300)) {
three_parallel_data_pipelines(7, 8);
}
TEST_CASE("Three.Parallel.DataPipelines.8L.1W" * doctest::timeout(300)) {
three_parallel_data_pipelines(8, 1);
}
TEST_CASE("Three.Parallel.DataPipelines.8L.2W" * doctest::timeout(300)) {
three_parallel_data_pipelines(8, 2);
}
TEST_CASE("Three.Parallel.DataPipelines.8L.3W" * doctest::timeout(300)) {
three_parallel_data_pipelines(8, 3);
}
TEST_CASE("Three.Parallel.DataPipelines.8L.4W" * doctest::timeout(300)) {
three_parallel_data_pipelines(8, 4);
}
TEST_CASE("Three.Parallel.DataPipelines.8L.5W" * doctest::timeout(300)) {
three_parallel_data_pipelines(8, 5);
}
TEST_CASE("Three.Parallel.DataPipelines.8L.6W" * doctest::timeout(300)) {
three_parallel_data_pipelines(8, 6);
}
TEST_CASE("Three.Parallel.DataPipelines.8L.7W" * doctest::timeout(300)) {
three_parallel_data_pipelines(8, 7);
}
TEST_CASE("Three.Parallel.DataPipelines.8L.8W" * doctest::timeout(300)) {
three_parallel_data_pipelines(8, 8);
}
// ----------------------------------------------------------------------------
// three concatenated pipelines. each pipeline with L lines.
// one with four pipes (SSSS), one with three pipes (SSP),
// One with two Pipes (SP)
//
// O -> SSSS -> O -> SSP -> O -> SP -> O
//
// ----------------------------------------------------------------------------
void three_concatenated_data_pipelines(size_t L, unsigned w) {
tf::Executor executor(w);
const size_t maxN = 100;
std::vector<int> source(maxN);
std::iota(source.begin(), source.end(), 0);
// std::vector<std::array<int, 4>> mybuffer1(L);
// std::vector<std::array<int, 3>> mybuffer2(L);
// std::vector<std::array<int, 2>> mybuffer3(L);
for(size_t N = 0; N <= maxN; N++) {
tf::Taskflow taskflow;
size_t j1_1 = 0, j1_2 = 0, j1_3 = 0, j1_4 = 0;
size_t cnt1 = 1;
// pipeline 1 is SSSS
tf::DataPipeline pl1(L,
tf::make_data_pipe<tf::Pipeflow&, int>(tf::PipeType::SERIAL, [N, &source, &j1_1, L](auto& pf) mutable {
if(j1_1 == N) {
pf.stop();
return 0;
}
REQUIRE(j1_1 == source[j1_1]);
REQUIRE(pf.token() % L == pf.line());
// mybuffer1[pf.line()][pf.pipe()] = source[j1_1] + 1;
// j1_1++;
return source[j1_1++] + 1;
}),
tf::make_data_pipe<int, std::string>(tf::PipeType::SERIAL, [N, &source, &j1_2, L](int input, auto& pf) mutable {
REQUIRE(j1_2 < N);
REQUIRE(pf.token() % L == pf.line());
REQUIRE(source[j1_2] + 1 == input);
// mybuffer1[pf.line()][pf.pipe()] = source[j1_2] + 1;
j1_2++;
return std::to_string(input);
}),
tf::make_data_pipe<std::string, int>(tf::PipeType::SERIAL, [N, &source, &j1_3, L](std::string& input, auto& pf) mutable {
REQUIRE(j1_3 < N);
REQUIRE(pf.token() % L == pf.line());
REQUIRE(source[j1_3] + 1 == stoi(input));
// mybuffer1[pf.line()][pf.pipe()] = source[j1_3] + 1;
j1_3++;
return stoi(input);
}),
tf::make_data_pipe<int, void>(tf::PipeType::SERIAL, [N, &source, &j1_4, L](int input, auto& pf) mutable {
REQUIRE(j1_4 < N);
REQUIRE(pf.token() % L == pf.line());
REQUIRE(source[j1_4] + 1 == input);
j1_4++;
})
);
auto datapipeline1 = taskflow.composed_of(pl1).name("module_of_datapipeline1");
auto test1 = taskflow.emplace([&](){
REQUIRE(j1_1 == N);
REQUIRE(j1_2 == N);
REQUIRE(j1_3 == N);
REQUIRE(j1_4 == N);
REQUIRE(pl1.num_tokens() == cnt1 * N);
}).name("test1");
// the followings are definitions for pipeline 2
size_t j2_1 = 0, j2_2 = 0;
std::atomic<size_t> j2_3 = 0;
std::mutex mutex2_3;
std::vector<int> collection2_3;
size_t cnt2 = 1;
// pipeline 2 is SSP
tf::DataPipeline pl2(L,
tf::make_data_pipe<tf::Pipeflow&, int>(tf::PipeType::SERIAL, [N, &source, &j2_1, L](auto& pf) mutable {
if(j2_1 == N) {
pf.stop();
return 0;
}
REQUIRE(j2_1 == source[j2_1]);
REQUIRE(pf.token() % L == pf.line());
// mybuffer2[pf.line()][pf.pipe()] = source[j2_1] + 1;
// j2_1++;
return source[j2_1++] + 1;
}),
tf::make_data_pipe<int, int>(tf::PipeType::SERIAL, [N, &source, &j2_2, L](int input, auto& pf) mutable {
REQUIRE(j2_2 < N);
REQUIRE(source[j2_2] + 1 == input);
REQUIRE(pf.token() % L == pf.line());
// mybuffer2[pf.line()][pf.pipe()] = source[j2_2] + 1;
j2_2++;
return input;
}),
tf::make_data_pipe<int, void>(tf::PipeType::PARALLEL, [N, &j2_3, &mutex2_3, &collection2_3, L](int input, auto& pf) mutable {
REQUIRE(j2_3++ < N);
{
std::scoped_lock<std::mutex> lock(mutex2_3);
REQUIRE(pf.token() % L == pf.line());
collection2_3.push_back(input);
}
})
);
auto datapipeline2 = taskflow.composed_of(pl2).name("module_of_datapipeline2");
auto test2 = taskflow.emplace([&](){
REQUIRE(j2_1 == N);
REQUIRE(j2_2 == N);
REQUIRE(j2_3 == N);
REQUIRE(collection2_3.size() == N);
std::sort(collection2_3.begin(), collection2_3.end());
for (size_t i = 0; i < N; ++i) {
REQUIRE(collection2_3[i] == i + 1);
}
REQUIRE(pl2.num_tokens() == cnt2 * N);
}).name("test2");
// the followings are definitions for pipeline 3
size_t j3_1 = 0;
std::atomic<size_t> j3_2 = 0;
std::mutex mutex3_2;
std::vector<int> collection3_2;
size_t cnt3 = 1;
// pipeline 3 is SP
tf::DataPipeline pl3(L,
tf::make_data_pipe<tf::Pipeflow&, int>(tf::PipeType::SERIAL, [N, &source, &j3_1, L](auto& pf) mutable {
if(j3_1 == N) {
pf.stop();
return 0;
}
REQUIRE(j3_1 == source[j3_1]);
REQUIRE(pf.token() % L == pf.line());
// mybuffer3[pf.line()][pf.pipe()] = source[j3_1] + 1;
// j3_1++;
return source[j3_1++] + 1;
}),
tf::make_data_pipe<int, void>(tf::PipeType::PARALLEL,
[N, &collection3_2, &mutex3_2, &j3_2, L](int input, auto& pf) mutable {
REQUIRE(j3_2++ < N);
{
std::scoped_lock<std::mutex> lock(mutex3_2);
REQUIRE(pf.token() % L == pf.line());
collection3_2.push_back(input);
}
})
);
auto datapipeline3 = taskflow.composed_of(pl3).name("module_of_datapipeline3");
auto test3 = taskflow.emplace([&](){
REQUIRE(j3_1 == N);
REQUIRE(j3_2 == N);
std::sort(collection3_2.begin(), collection3_2.end());
for(size_t i = 0; i < N; i++) {
REQUIRE(collection3_2[i] == i + 1);
}
REQUIRE(pl3.num_tokens() == cnt3 * N);
}).name("test3");
auto initial = taskflow.emplace([](){}).name("initial");
auto terminal = taskflow.emplace([](){}).name("terminal");
initial.precede(datapipeline1);
datapipeline1.precede(test1);
test1.precede(datapipeline2);
datapipeline2.precede(test2);
test2.precede(datapipeline3);
datapipeline3.precede(test3);
test3.precede(terminal);
//taskflow.dump(std::cout);
executor.run_n(taskflow, 3, [&]() mutable {
// reset variables for pipeline 1
j1_1 = j1_2 = j1_3 = j1_4 = 0;
// for(size_t i = 0; i < mybuffer1.size(); ++i){
// for(size_t j = 0; j < mybuffer1[0].size(); ++j){
// mybuffer1[i][j] = 0;
// }
// }
cnt1++;
// reset variables for pipeline 2
j2_1 = j2_2 = j2_3 = 0;
collection2_3.clear();
// for(size_t i = 0; i < mybuffer2.size(); ++i){
// for(size_t j = 0; j < mybuffer2[0].size(); ++j){
// mybuffer2[i][j] = 0;
// }
// }
cnt2++;
// reset variables for pipeline 3
j3_1 = j3_2 = 0;
collection3_2.clear();
// for(size_t i = 0; i < mybuffer3.size(); ++i){
// for(size_t j = 0; j < mybuffer3[0].size(); ++j){
// mybuffer3[i][j] = 0;
// }
// }
cnt3++;
}).get();
}
}
// three concatenated piplines
TEST_CASE("Three.Concatenated.DataPipelines.1L.1W" * doctest::timeout(300)) {
three_concatenated_data_pipelines(1, 1);
}
TEST_CASE("Three.Concatenated.DataPipelines.1L.2W" * doctest::timeout(300)) {
three_concatenated_data_pipelines(1, 2);
}
TEST_CASE("Three.Concatenated.DataPipelines.1L.3W" * doctest::timeout(300)) {
three_concatenated_data_pipelines(1, 3);
}
TEST_CASE("Three.Concatenated.DataPipelines.1L.4W" * doctest::timeout(300)) {
three_concatenated_data_pipelines(1, 4);
}
TEST_CASE("Three.Concatenated.DataPipelines.1L.5W" * doctest::timeout(300)) {
three_concatenated_data_pipelines(1, 5);
}
TEST_CASE("Three.Concatenated.DataPipelines.1L.6W" * doctest::timeout(300)) {
three_concatenated_data_pipelines(1, 6);
}
TEST_CASE("Three.Concatenated.DataPipelines.1L.7W" * doctest::timeout(300)) {
three_concatenated_data_pipelines(1, 7);
}
TEST_CASE("Three.Concatenated.DataPipelines.1L.8W" * doctest::timeout(300)) {
three_concatenated_data_pipelines(1, 8);
}
TEST_CASE("Three.Concatenated.DataPipelines.2L.1W" * doctest::timeout(300)) {
three_concatenated_data_pipelines(2, 1);
}
TEST_CASE("Three.Concatenated.DataPipelines.2L.2W" * doctest::timeout(300)) {
three_concatenated_data_pipelines(2, 2);
}
TEST_CASE("Three.Concatenated.DataPipelines.2L.3W" * doctest::timeout(300)) {
three_concatenated_data_pipelines(2, 3);
}
TEST_CASE("Three.Concatenated.DataPipelines.2L.4W" * doctest::timeout(300)) {
three_concatenated_data_pipelines(2, 4);
}
TEST_CASE("Three.Concatenated.DataPipelines.2L.5W" * doctest::timeout(300)) {
three_concatenated_data_pipelines(2, 5);
}
TEST_CASE("Three.Concatenated.DataPipelines.2L.6W" * doctest::timeout(300)) {
three_concatenated_data_pipelines(2, 6);
}
TEST_CASE("Three.Concatenated.DataPipelines.2L.7W" * doctest::timeout(300)) {
three_concatenated_data_pipelines(2, 7);
}
TEST_CASE("Three.Concatenated.DataPipelines.2L.8W" * doctest::timeout(300)) {
three_concatenated_data_pipelines(2, 8);
}
TEST_CASE("Three.Concatenated.DataPipelines.3L.1W" * doctest::timeout(300)) {
three_concatenated_data_pipelines(3, 1);
}
TEST_CASE("Three.Concatenated.DataPipelines.3L.2W" * doctest::timeout(300)) {
three_concatenated_data_pipelines(3, 2);
}
TEST_CASE("Three.Concatenated.DataPipelines.3L.3W" * doctest::timeout(300)) {
three_concatenated_data_pipelines(3, 3);
}
TEST_CASE("Three.Concatenated.DataPipelines.3L.4W" * doctest::timeout(300)) {
three_concatenated_data_pipelines(3, 4);
}
TEST_CASE("Three.Concatenated.DataPipelines.3L.5W" * doctest::timeout(300)) {
three_concatenated_data_pipelines(3, 5);
}
TEST_CASE("Three.Concatenated.DataPipelines.3L.6W" * doctest::timeout(300)) {
three_concatenated_data_pipelines(3, 6);
}
TEST_CASE("Three.Concatenated.DataPipelines.3L.7W" * doctest::timeout(300)) {
three_concatenated_data_pipelines(3, 7);
}
TEST_CASE("Three.Concatenated.DataPipelines.3L.8W" * doctest::timeout(300)) {
three_concatenated_data_pipelines(3, 8);
}
TEST_CASE("Three.Concatenated.DataPipelines.4L.1W" * doctest::timeout(300)) {
three_concatenated_data_pipelines(4, 1);
}
TEST_CASE("Three.Concatenated.DataPipelines.4L.2W" * doctest::timeout(300)) {
three_concatenated_data_pipelines(4, 2);
}
TEST_CASE("Three.Concatenated.DataPipelines.4L.3W" * doctest::timeout(300)) {
three_concatenated_data_pipelines(4, 3);
}
TEST_CASE("Three.Concatenated.DataPipelines.4L.4W" * doctest::timeout(300)) {
three_concatenated_data_pipelines(4, 4);
}
TEST_CASE("Three.Concatenated.DataPipelines.4L.5W" * doctest::timeout(300)) {
three_concatenated_data_pipelines(4, 5);
}
TEST_CASE("Three.Concatenated.DataPipelines.4L.6W" * doctest::timeout(300)) {
three_concatenated_data_pipelines(4, 6);
}
TEST_CASE("Three.Concatenated.DataPipelines.4L.7W" * doctest::timeout(300)) {
three_concatenated_data_pipelines(4, 7);
}
TEST_CASE("Three.Concatenated.DataPipelines.4L.8W" * doctest::timeout(300)) {
three_concatenated_data_pipelines(4, 8);
}
TEST_CASE("Three.Concatenated.DataPipelines.5L.1W" * doctest::timeout(300)) {
three_concatenated_data_pipelines(5, 1);
}
TEST_CASE("Three.Concatenated.DataPipelines.5L.2W" * doctest::timeout(300)) {
three_concatenated_data_pipelines(5, 2);
}
TEST_CASE("Three.Concatenated.DataPipelines.5L.3W" * doctest::timeout(300)) {
three_concatenated_data_pipelines(5, 3);
}
TEST_CASE("Three.Concatenated.DataPipelines.5L.4W" * doctest::timeout(300)) {
three_concatenated_data_pipelines(5, 4);
}
TEST_CASE("Three.Concatenated.DataPipelines.5L.5W" * doctest::timeout(300)) {
three_concatenated_data_pipelines(5, 5);
}
TEST_CASE("Three.Concatenated.DataPipelines.5L.6W" * doctest::timeout(300)) {
three_concatenated_data_pipelines(5, 6);
}
TEST_CASE("Three.Concatenated.DataPipelines.5L.7W" * doctest::timeout(300)) {
three_concatenated_data_pipelines(5, 7);
}
TEST_CASE("Three.Concatenated.DataPipelines.5L.8W" * doctest::timeout(300)) {
three_concatenated_data_pipelines(5, 8);
}
TEST_CASE("Three.Concatenated.DataPipelines.6L.1W" * doctest::timeout(300)) {
three_concatenated_data_pipelines(6, 1);
}
TEST_CASE("Three.Concatenated.DataPipelines.6L.2W" * doctest::timeout(300)) {
three_concatenated_data_pipelines(6, 2);
}
TEST_CASE("Three.Concatenated.DataPipelines.6L.3W" * doctest::timeout(300)) {
three_concatenated_data_pipelines(6, 3);
}
TEST_CASE("Three.Concatenated.DataPipelines.6L.4W" * doctest::timeout(300)) {
three_concatenated_data_pipelines(6, 4);
}
TEST_CASE("Three.Concatenated.DataPipelines.6L.5W" * doctest::timeout(300)) {
three_concatenated_data_pipelines(6, 5);
}
TEST_CASE("Three.Concatenated.DataPipelines.6L.6W" * doctest::timeout(300)) {
three_concatenated_data_pipelines(6, 6);
}
TEST_CASE("Three.Concatenated.DataPipelines.6L.7W" * doctest::timeout(300)) {
three_concatenated_data_pipelines(6, 7);
}
TEST_CASE("Three.Concatenated.DataPipelines.6L.8W" * doctest::timeout(300)) {
three_concatenated_data_pipelines(6, 8);
}
TEST_CASE("Three.Concatenated.DataPipelines.7L.1W" * doctest::timeout(300)) {
three_concatenated_data_pipelines(7, 1);
}
TEST_CASE("Three.Concatenated.DataPipelines.7L.2W" * doctest::timeout(300)) {
three_concatenated_data_pipelines(7, 2);
}
TEST_CASE("Three.Concatenated.DataPipelines.7L.3W" * doctest::timeout(300)) {
three_concatenated_data_pipelines(7, 3);
}
TEST_CASE("Three.Concatenated.DataPipelines.7L.4W" * doctest::timeout(300)) {
three_concatenated_data_pipelines(7, 4);
}
TEST_CASE("Three.Concatenated.DataPipelines.7L.5W" * doctest::timeout(300)) {
three_concatenated_data_pipelines(7, 5);
}
TEST_CASE("Three.Concatenated.DataPipelines.7L.6W" * doctest::timeout(300)) {
three_concatenated_data_pipelines(7, 6);
}
TEST_CASE("Three.Concatenated.DataPipelines.7L.7W" * doctest::timeout(300)) {
three_concatenated_data_pipelines(7, 7);
}
TEST_CASE("Three.Concatenated.DataPipelines.7L.8W" * doctest::timeout(300)) {
three_concatenated_data_pipelines(7, 8);
}
TEST_CASE("Three.Concatenated.DataPipelines.8L.1W" * doctest::timeout(300)) {
three_concatenated_data_pipelines(8, 1);
}
TEST_CASE("Three.Concatenated.DataPipelines.8L.2W" * doctest::timeout(300)) {
three_concatenated_data_pipelines(8, 2);
}
TEST_CASE("Three.Concatenated.DataPipelines.8L.3W" * doctest::timeout(300)) {
three_concatenated_data_pipelines(8, 3);
}
TEST_CASE("Three.Concatenated.DataPipelines.8L.4W" * doctest::timeout(300)) {
three_concatenated_data_pipelines(8, 4);
}
TEST_CASE("Three.Concatenated.DataPipelines.8L.5W" * doctest::timeout(300)) {
three_concatenated_data_pipelines(8, 5);
}
TEST_CASE("Three.Concatenated.DataPipelines.8L.6W" * doctest::timeout(300)) {
three_concatenated_data_pipelines(8, 6);
}
TEST_CASE("Three.Concatenated.DataPipelines.8L.7W" * doctest::timeout(300)) {
three_concatenated_data_pipelines(8, 7);
}
TEST_CASE("Three.Concatenated.DataPipelines.8L.8W" * doctest::timeout(300)) {
three_concatenated_data_pipelines(8, 8);
}
// ----------------------------------------------------------------------------
// pipeline (SPSP) and conditional task. pipeline has L lines, W workers
//
// O -> SPSP -> conditional_task
// ^ |
// |____________|
// ----------------------------------------------------------------------------
void looping_data_pipelines(size_t L, unsigned w) {
tf::Executor executor(w);
const size_t maxN = 100;
std::vector<int> source(maxN);
std::iota(source.begin(), source.end(), 0);
// std::vector<std::array<int, 4>> mybuffer(L);
tf::Taskflow taskflow;
size_t j1 = 0, j3 = 0;
std::atomic<size_t> j2 = 0;
std::atomic<size_t> j4 = 0;
std::mutex mutex2;
std::mutex mutex4;
std::vector<int> collection2;
std::vector<int> collection4;
size_t cnt = 0;
size_t N = 0;
tf::DataPipeline pl(L,
tf::make_data_pipe<tf::Pipeflow&, int>(tf::PipeType::SERIAL, [&N, &source, &j1, L](auto& pf) mutable {
if(j1 == N) {
pf.stop();
return 0;
}
REQUIRE(j1 == source[j1]);
REQUIRE(pf.token() % L == pf.line());
// mybuffer[pf.line()][pf.pipe()] = source[j1] + 1;
// j1++;
return source[j1++] + 1;
}),
tf::make_data_pipe<int, int>(tf::PipeType::PARALLEL, [&N, &j2, &mutex2, &collection2, L](int input, auto& pf) mutable {
REQUIRE(j2++ < N);
{
std::scoped_lock<std::mutex> lock(mutex2);
REQUIRE(pf.token() % L == pf.line());
// mybuffer[pf.line()][pf.pipe()] = mybuffer[pf.line()][pf.pipe() - 1] + 1;
collection2.push_back(input);
return input + 1;
}
}),
tf::make_data_pipe<int, int>(tf::PipeType::SERIAL, [&N, &source, &j3, L](int input, auto& pf) mutable {
REQUIRE(j3 < N);
REQUIRE(pf.token() % L == pf.line());
REQUIRE(source[j3] + 2 == input);
// mybuffer[pf.line()][pf.pipe()] = mybuffer[pf.line()][pf.pipe() - 1] + 1;
j3++;
return input + 1;
}),
tf::make_data_pipe<int, void>(tf::PipeType::PARALLEL, [&N, &j4, &mutex4, &collection4, L](int input, auto& pf) mutable {
REQUIRE(j4++ < N);
{
std::scoped_lock<std::mutex> lock(mutex4);
REQUIRE(pf.token() % L == pf.line());
collection4.push_back(input);
}
})
);
auto datapipeline = taskflow.composed_of(pl).name("module_of_datapipeline");
auto initial = taskflow.emplace([](){}).name("initial");
auto conditional = taskflow.emplace([&](){
REQUIRE(j1 == N);
REQUIRE(j2 == N);
REQUIRE(j3 == N);
REQUIRE(j4 == N);
REQUIRE(collection2.size() == N);
REQUIRE(collection4.size() == N);
std::sort(collection2.begin(), collection2.end());
std::sort(collection4.begin(), collection4.end());
for (size_t i = 0; i < N; ++i) {
REQUIRE(collection2[i] == i + 1);
REQUIRE(collection4[i] == i + 3);
}
REQUIRE(pl.num_tokens() == cnt);
// reset variables
j1 = j2 = j3 = j4 = 0;
// for(size_t i = 0; i < mybuffer.size(); ++i){
// for(size_t j = 0; j < mybuffer[0].size(); ++j){
// mybuffer[i][j] = 0;
// }
// }
collection2.clear();
collection4.clear();
++N;
cnt+=N;
return N < maxN ? 0 : 1;
}).name("conditional");
auto terminal = taskflow.emplace([](){}).name("terminal");
initial.precede(datapipeline);
datapipeline.precede(conditional);
conditional.precede(datapipeline, terminal);
executor.run(taskflow).wait();
}
// looping piplines
TEST_CASE("Looping.DataPipelines.1L.1W" * doctest::timeout(300)) {
looping_data_pipelines(1, 1);
}
TEST_CASE("Looping.DataPipelines.1L.2W" * doctest::timeout(300)) {
looping_data_pipelines(1, 2);
}
TEST_CASE("Looping.DataPipelines.1L.3W" * doctest::timeout(300)) {
looping_data_pipelines(1, 3);
}
TEST_CASE("Looping.DataPipelines.1L.4W" * doctest::timeout(300)) {
looping_data_pipelines(1, 4);
}
TEST_CASE("Looping.DataPipelines.1L.5W" * doctest::timeout(300)) {
looping_data_pipelines(1, 5);
}
TEST_CASE("Looping.DataPipelines.1L.6W" * doctest::timeout(300)) {
looping_data_pipelines(1, 6);
}
TEST_CASE("Looping.DataPipelines.1L.7W" * doctest::timeout(300)) {
looping_data_pipelines(1, 7);
}
TEST_CASE("Looping.DataPipelines.1L.8W" * doctest::timeout(300)) {
looping_data_pipelines(1, 8);
}
TEST_CASE("Looping.DataPipelines.2L.1W" * doctest::timeout(300)) {
looping_data_pipelines(2, 1);
}
TEST_CASE("Looping.DataPipelines.2L.2W" * doctest::timeout(300)) {
looping_data_pipelines(2, 2);
}
TEST_CASE("Looping.DataPipelines.2L.3W" * doctest::timeout(300)) {
looping_data_pipelines(2, 3);
}
TEST_CASE("Looping.DataPipelines.2L.4W" * doctest::timeout(300)) {
looping_data_pipelines(2, 4);
}
TEST_CASE("Looping.DataPipelines.2L.5W" * doctest::timeout(300)) {
looping_data_pipelines(2, 5);
}
TEST_CASE("Looping.DataPipelines.2L.6W" * doctest::timeout(300)) {
looping_data_pipelines(2, 6);
}
TEST_CASE("Looping.DataPipelines.2L.7W" * doctest::timeout(300)) {
looping_data_pipelines(2, 7);
}
TEST_CASE("Looping.DataPipelines.2L.8W" * doctest::timeout(300)) {
looping_data_pipelines(2, 8);
}
TEST_CASE("Looping.DataPipelines.3L.1W" * doctest::timeout(300)) {
looping_data_pipelines(3, 1);
}
TEST_CASE("Looping.DataPipelines.3L.2W" * doctest::timeout(300)) {
looping_data_pipelines(3, 2);
}
TEST_CASE("Looping.DataPipelines.3L.3W" * doctest::timeout(300)) {
looping_data_pipelines(3, 3);
}
TEST_CASE("Looping.DataPipelines.3L.4W" * doctest::timeout(300)) {
looping_data_pipelines(3, 4);
}
TEST_CASE("Looping.DataPipelines.3L.5W" * doctest::timeout(300)) {
looping_data_pipelines(3, 5);
}
TEST_CASE("Looping.DataPipelines.3L.6W" * doctest::timeout(300)) {
looping_data_pipelines(3, 6);
}
TEST_CASE("Looping.DataPipelines.3L.7W" * doctest::timeout(300)) {
looping_data_pipelines(3, 7);
}
TEST_CASE("Looping.DataPipelines.3L.8W" * doctest::timeout(300)) {
looping_data_pipelines(3, 8);
}
TEST_CASE("Looping.DataPipelines.4L.1W" * doctest::timeout(300)) {
looping_data_pipelines(4, 1);
}
TEST_CASE("Looping.DataPipelines.4L.2W" * doctest::timeout(300)) {
looping_data_pipelines(4, 2);
}
TEST_CASE("Looping.DataPipelines.4L.3W" * doctest::timeout(300)) {
looping_data_pipelines(4, 3);
}
TEST_CASE("Looping.DataPipelines.4L.4W" * doctest::timeout(300)) {
looping_data_pipelines(4, 4);
}
TEST_CASE("Looping.DataPipelines.4L.5W" * doctest::timeout(300)) {
looping_data_pipelines(4, 5);
}
TEST_CASE("Looping.DataPipelines.4L.6W" * doctest::timeout(300)) {
looping_data_pipelines(4, 6);
}
TEST_CASE("Looping.DataPipelines.4L.7W" * doctest::timeout(300)) {
looping_data_pipelines(4, 7);
}
TEST_CASE("Looping.DataPipelines.4L.8W" * doctest::timeout(300)) {
looping_data_pipelines(4, 8);
}
TEST_CASE("Looping.DataPipelines.5L.1W" * doctest::timeout(300)) {
looping_data_pipelines(5, 1);
}
TEST_CASE("Looping.DataPipelines.5L.2W" * doctest::timeout(300)) {
looping_data_pipelines(5, 2);
}
TEST_CASE("Looping.DataPipelines.5L.3W" * doctest::timeout(300)) {
looping_data_pipelines(5, 3);
}
TEST_CASE("Looping.DataPipelines.5L.4W" * doctest::timeout(300)) {
looping_data_pipelines(5, 4);
}
TEST_CASE("Looping.DataPipelines.5L.5W" * doctest::timeout(300)) {
looping_data_pipelines(5, 5);
}
TEST_CASE("Looping.DataPipelines.5L.6W" * doctest::timeout(300)) {
looping_data_pipelines(5, 6);
}
TEST_CASE("Looping.DataPipelines.5L.7W" * doctest::timeout(300)) {
looping_data_pipelines(5, 7);
}
TEST_CASE("Looping.DataPipelines.5L.8W" * doctest::timeout(300)) {
looping_data_pipelines(5, 8);
}
TEST_CASE("Looping.DataPipelines.6L.1W" * doctest::timeout(300)) {
looping_data_pipelines(6, 1);
}
TEST_CASE("Looping.DataPipelines.6L.2W" * doctest::timeout(300)) {
looping_data_pipelines(6, 2);
}
TEST_CASE("Looping.DataPipelines.6L.3W" * doctest::timeout(300)) {
looping_data_pipelines(6, 3);
}
TEST_CASE("Looping.DataPipelines.6L.4W" * doctest::timeout(300)) {
looping_data_pipelines(6, 4);
}
TEST_CASE("Looping.DataPipelines.6L.5W" * doctest::timeout(300)) {
looping_data_pipelines(6, 5);
}
TEST_CASE("Looping.DataPipelines.6L.6W" * doctest::timeout(300)) {
looping_data_pipelines(6, 6);
}
TEST_CASE("Looping.DataPipelines.6L.7W" * doctest::timeout(300)) {
looping_data_pipelines(6, 7);
}
TEST_CASE("Looping.DataPipelines.6L.8W" * doctest::timeout(300)) {
looping_data_pipelines(6, 8);
}
TEST_CASE("Looping.DataPipelines.7L.1W" * doctest::timeout(300)) {
looping_data_pipelines(7, 1);
}
TEST_CASE("Looping.DataPipelines.7L.2W" * doctest::timeout(300)) {
looping_data_pipelines(7, 2);
}
TEST_CASE("Looping.DataPipelines.7L.3W" * doctest::timeout(300)) {
looping_data_pipelines(7, 3);
}
TEST_CASE("Looping.DataPipelines.7L.4W" * doctest::timeout(300)) {
looping_data_pipelines(7, 4);
}
TEST_CASE("Looping.DataPipelines.7L.5W" * doctest::timeout(300)) {
looping_data_pipelines(7, 5);
}
TEST_CASE("Looping.DataPipelines.7L.6W" * doctest::timeout(300)) {
looping_data_pipelines(7, 6);
}
TEST_CASE("Looping.DataPipelines.7L.7W" * doctest::timeout(300)) {
looping_data_pipelines(7, 7);
}
TEST_CASE("Looping.DataPipelines.7L.8W" * doctest::timeout(300)) {
looping_data_pipelines(7, 8);
}
TEST_CASE("Looping.DataPipelines.8L.1W" * doctest::timeout(300)) {
looping_data_pipelines(8, 1);
}
TEST_CASE("Looping.DataPipelines.8L.2W" * doctest::timeout(300)) {
looping_data_pipelines(8, 2);
}
TEST_CASE("Looping.DataPipelines.8L.3W" * doctest::timeout(300)) {
looping_data_pipelines(8, 3);
}
TEST_CASE("Looping.DataPipelines.8L.4W" * doctest::timeout(300)) {
looping_data_pipelines(8, 4);
}
TEST_CASE("Looping.DataPipelines.8L.5W" * doctest::timeout(300)) {
looping_data_pipelines(8, 5);
}
TEST_CASE("Looping.DataPipelines.8L.6W" * doctest::timeout(300)) {
looping_data_pipelines(8, 6);
}
TEST_CASE("Looping.DataPipelines.8L.7W" * doctest::timeout(300)) {
looping_data_pipelines(8, 7);
}
TEST_CASE("Looping.DataPipelines.8L.8W" * doctest::timeout(300)) {
looping_data_pipelines(8, 8);
}
// ----------------------------------------------------------------------------
//
// ifelse pipeline has three pipes, L lines, w workers
//
// SPS
// ----------------------------------------------------------------------------
int ifelse_pipe_ans(int a) {
// pipe 1
if(a / 2 != 0) {
a += 8;
}
// pipe 2
if(a > 4897) {
a -= 1834;
}
else {
a += 3;
}
// pipe 3
if((a + 9) / 4 < 50) {
a += 1;
}
else {
a += 17;
}
return a;
}
void ifelse_data_pipeline(size_t L, unsigned w) {
srand(time(NULL));
tf::Executor executor(w);
size_t maxN = 200;
std::vector<int> source(maxN);
for(auto&& s: source) {
s = rand() % 9962;
}
// std::vector<std::array<int, 4>> buffer(L);
for(size_t N = 1; N < maxN; ++N) {
tf::Taskflow taskflow;
std::vector<int> collection;
collection.reserve(N);
tf::DataPipeline pl(L,
// pipe 1
tf::make_data_pipe<tf::Pipeflow&, int>(tf::PipeType::SERIAL, [&, N](auto& pf){
if(pf.token() == N) {
pf.stop();
return 0;
}
if(source[pf.token()] / 2 == 0) {
// buffer[pf.line()][pf.pipe()] = source[pf.token()];
return source[pf.token()];
}
else {
// buffer[pf.line()][pf.pipe()] = source[pf.token()] + 8;
return source[pf.token()] + 8;
}
}),
// pipe 2
tf::make_data_pipe<int, int>(tf::PipeType::PARALLEL, [&](int input){
if(input > 4897) {
// buffer[pf.line()][pf.pipe()] = buffer[pf.line()][pf.pipe() - 1] - 1834;
return input - 1834;
}
else {
// buffer[pf.line()][pf.pipe()] = buffer[pf.line()][pf.pipe() - 1] + 3;
return input + 3;
}
}),
// pipe 3
tf::make_data_pipe<int, void>(tf::PipeType::SERIAL, [&](int input){
int tmp = 0;
if((input + 9) / 4 < 50) {
// buffer[pf.line()][pf.pipe()] = buffer[pf.line()][pf.pipe() - 1] + 1;
tmp = input + 1;
}
else {
// buffer[pf.line()][pf.pipe()] = buffer[pf.line()][pf.pipe() - 1] + 17;
tmp = input + 17;
}
collection.push_back(tmp);
})
);
auto pl_t = taskflow.composed_of(pl).name("datapipeline");
auto check_t = taskflow.emplace([&](){
for(size_t n = 0; n < N; ++n) {
REQUIRE(collection[n] == ifelse_pipe_ans(source[n]));
}
}).name("check");
pl_t.precede(check_t);
executor.run(taskflow).wait();
}
}
TEST_CASE("Ifelse.DataPipelines.1L.1W" * doctest::timeout(300)) {
ifelse_data_pipeline(1, 1);
}
TEST_CASE("Ifelse.DataPipelines.1L.2W" * doctest::timeout(300)) {
ifelse_data_pipeline(1, 2);
}
TEST_CASE("Ifelse.DataPipelines.1L.3W" * doctest::timeout(300)) {
ifelse_data_pipeline(1, 3);
}
TEST_CASE("Ifelse.DataPipelines.1L.4W" * doctest::timeout(300)) {
ifelse_data_pipeline(1, 4);
}
TEST_CASE("Ifelse.DataPipelines.3L.1W" * doctest::timeout(300)) {
ifelse_data_pipeline(3, 1);
}
TEST_CASE("Ifelse.DataPipelines.3L.2W" * doctest::timeout(300)) {
ifelse_data_pipeline(3, 2);
}
TEST_CASE("Ifelse.DataPipelines.3L.3W" * doctest::timeout(300)) {
ifelse_data_pipeline(3, 3);
}
TEST_CASE("Ifelse.DataPipelines.3L.4W" * doctest::timeout(300)) {
ifelse_data_pipeline(3, 4);
}
TEST_CASE("Ifelse.DataPipelines.5L.1W" * doctest::timeout(300)) {
ifelse_data_pipeline(5, 1);
}
TEST_CASE("Ifelse.DataPipelines.5L.2W" * doctest::timeout(300)) {
ifelse_data_pipeline(5, 2);
}
TEST_CASE("Ifelse.DataPipelines.5L.3W" * doctest::timeout(300)) {
ifelse_data_pipeline(5, 3);
}
TEST_CASE("Ifelse.DataPipelines.5L.4W" * doctest::timeout(300)) {
ifelse_data_pipeline(5, 4);
}
TEST_CASE("Ifelse.DataPipelines.7L.1W" * doctest::timeout(300)) {
ifelse_data_pipeline(7, 1);
}
TEST_CASE("Ifelse.DataPipelines.7L.2W" * doctest::timeout(300)) {
ifelse_data_pipeline(7, 2);
}
TEST_CASE("Ifelse.DataPipelines.7L.3W" * doctest::timeout(300)) {
ifelse_data_pipeline(7, 3);
}
TEST_CASE("Ifelse.DataPipelines.7L.4W" * doctest::timeout(300)) {
ifelse_data_pipeline(7, 4);
}
// ----------------------------------------------------------------------------
// pipeline in pipeline
// pipeline has 4 pipes, L lines, W workers
// each subpipeline has 3 pipes, subL lines
//
// pipeline = SPPS
// each subpipeline = SPS
//
// ----------------------------------------------------------------------------
void pipeline_in_pipeline(size_t L, unsigned w, unsigned subL) {
tf::Executor executor(w);
const size_t maxN = 5;
const size_t maxsubN = 4;
std::vector<std::vector<int>> source(maxN);
for(auto&& each: source) {
each.resize(maxsubN);
std::iota(each.begin(), each.end(), 0);
}
for (size_t N = 1; N < maxN; ++N) {
for(size_t subN = 1; subN < maxsubN; ++subN) {
size_t j1 = 0, j4 = 0;
std::atomic<size_t> j2 = 0;
std::atomic<size_t> j3 = 0;
// begin of pipeline ---------------------------
tf::DataPipeline pl(L,
// begin of pipe 1 -----------------------------
tf::make_data_pipe<void, int>(tf::PipeType::SERIAL, [&, N, subN, subL](auto& pf) mutable {
if(j1 == N) {
pf.stop();
return 0;
}
size_t subj1 = 0, subj3 = 0;
std::atomic<size_t> subj2 = 0;
std::vector<int> subcollection;
subcollection.reserve(subN);
// subpipeline
tf::DataPipeline subpl(subL,
// subpipe 1
tf::make_data_pipe<void, int>(tf::PipeType::SERIAL, [&, subN](auto& subpf) mutable {
if(subj1 == subN) {
subpf.stop();
return 0;
}
REQUIRE(subpf.token() % subL == subpf.line());
return source[pf.token()][subj1++] + 1;
}),
// subpipe 2
tf::make_data_pipe<int, int>(tf::PipeType::PARALLEL, [&, subN](int input, auto& subpf) mutable {
REQUIRE(subj2++ < subN);
REQUIRE(subpf.token() % subL == subpf.line());
REQUIRE(source[pf.token()][subpf.token()] + 1 == input);
return input;
}),
// subpipe 3
tf::make_data_pipe<int, void>(tf::PipeType::SERIAL, [&, subN](int input, auto& subpf) mutable {
REQUIRE(subj3 < subN);
REQUIRE(subpf.token() % subL == subpf.line());
REQUIRE(source[pf.token()][subj3] + 1 == input);
subcollection.push_back(input + 2);
++subj3;
})
);
tf::Taskflow taskflow;
// test task
auto test_t = taskflow.emplace([&, subN](){
REQUIRE(subj1 == subN);
REQUIRE(subj2 == subN);
REQUIRE(subj3 == subN);
//REQUIRE(subpl.num_tokens() == subN);
REQUIRE(subcollection.size() == subN);
}).name("test");
// subpipeline
auto subpl_t = taskflow.composed_of(subpl).name("module_of_subpipeline");
subpl_t.precede(test_t);
executor.corun(taskflow);
j1++;
return std::accumulate(
subcollection.begin(),
subcollection.end(),
0
);
}),
// end of pipe 1 -----------------------------
//begin of pipe 2 ---------------------------
tf::make_data_pipe<int, int>(tf::PipeType::PARALLEL, [&, N, subN, subL](int input, auto& pf) mutable {
REQUIRE(j2++ < N);
int res = std::accumulate(
source[pf.token()].begin(),
source[pf.token()].begin() + subN,
0
);
REQUIRE(input == res + 3 * subN);
size_t subj1 = 0, subj3 = 0;
std::atomic<size_t> subj2 = 0;
std::vector<int> subcollection;
subcollection.reserve(subN);
// subpipeline
tf::DataPipeline subpl(subL,
// subpipe 1
tf::make_data_pipe<void, int>(tf::PipeType::SERIAL, [&, subN](auto& subpf) mutable {
if(subj1 == subN) {
subpf.stop();
return 0;
}
REQUIRE(subpf.token() % subL == subpf.line());
return source[pf.token()][subj1++] + 1;
}),
// subpipe 2
tf::make_data_pipe<int, int>(tf::PipeType::PARALLEL, [&, subN](int in, auto& subpf) mutable {
REQUIRE(subj2++ < subN);
REQUIRE(subpf.token() % subL == subpf.line());
REQUIRE(source[j2][subpf.token()] + 1 == in);
return in;
}),
// subpipe 3
tf::make_data_pipe<int, void>(tf::PipeType::SERIAL, [&, subN](int in, auto& subpf) mutable {
REQUIRE(subj3 < subN);
REQUIRE(subpf.token() % subL == subpf.line());
REQUIRE(source[pf.token()][subj3] + 1 == in);
subcollection.push_back(in + 12);
++subj3;
})
);
tf::Taskflow taskflow;
// test task
auto test_t = taskflow.emplace([&, subN](){
REQUIRE(subj1 == subN);
REQUIRE(subj2 == subN);
REQUIRE(subj3 == subN);
//REQUIRE(subpl.num_tokens() == subN);
REQUIRE(subcollection.size() == subN);
}).name("test");
// subpipeline
auto subpl_t = taskflow.composed_of(subpl).name("module_of_subpipeline");
subpl_t.precede(test_t);
executor.corun(taskflow);
return std::accumulate(
subcollection.begin(),
subcollection.end(),
0
);
}),
// end of pipe 2 -----------------------------
// begin of pipe 3 ---------------------------
tf::make_data_pipe<int, int>(tf::PipeType::SERIAL, [&, N, subN, subL](int input, auto& pf) mutable {
REQUIRE(j3++ < N);
int res = std::accumulate(
source[pf.token()].begin(),
source[pf.token()].begin() + subN,
0
);
REQUIRE(input == res + 13 * subN);
size_t subj1 = 0, subj3 = 0;
std::atomic<size_t> subj2 = 0;
std::vector<int> subcollection;
subcollection.reserve(subN);
// subpipeline
tf::DataPipeline subpl(subL,
// subpipe 1
tf::make_data_pipe<void, int>(tf::PipeType::SERIAL, [&, subN](auto& subpf) mutable {
if(subj1 == subN) {
subpf.stop();
return 0;
}
REQUIRE(subpf.token() % subL == subpf.line());
return source[pf.token()][subj1++] + 1;
}),
// subpipe 2
tf::make_data_pipe<int, int>(tf::PipeType::PARALLEL, [&, subN](int in, auto& subpf) mutable {
REQUIRE(subj2++ < subN);
REQUIRE(subpf.token() % subL == subpf.line());
REQUIRE(source[pf.token()][subpf.token()] + 1 == in);
return in;
}),
// subpipe 3
tf::make_data_pipe<int, void>(tf::PipeType::SERIAL, [&, subN](int in, auto& subpf) mutable {
REQUIRE(subj3 < subN);
REQUIRE(subpf.token() % subL == subpf.line());
REQUIRE(source[pf.token()][subj3] + 1 == in);
subcollection.push_back(in + 6);
++subj3;
})
);
tf::Taskflow taskflow;
// test task
auto test_t = taskflow.emplace([&, subN](){
REQUIRE(subj1 == subN);
REQUIRE(subj2 == subN);
REQUIRE(subj3 == subN);
//REQUIRE(subpl.num_tokens() == subN);
REQUIRE(subcollection.size() == subN);
}).name("test");
// subpipeline
auto subpl_t = taskflow.composed_of(subpl).name("module_of_subpipeline");
subpl_t.precede(test_t);
executor.corun(taskflow);
return std::accumulate(
subcollection.begin(),
subcollection.end(),
0
);
}),
// end of pipe 3 -----------------------------
// begin of pipe 4 ---------------------------
tf::make_data_pipe<int, void>(tf::PipeType::SERIAL, [&, subN](int input) mutable {
int res = std::accumulate(
source[j4].begin(),
source[j4].begin() + subN,
0
);
REQUIRE(input == res + 7 * subN);
j4++;
})
// end of pipe 4 -----------------------------
);
tf::Taskflow taskflow;
taskflow.composed_of(pl).name("module_of_pipeline");
executor.run(taskflow).wait();
}
}
}
TEST_CASE("PipelineinPipeline.DataPipelines.1L.1W.1subL" * doctest::timeout(300)) {
pipeline_in_pipeline(1, 1, 1);
}
TEST_CASE("PipelineinPipeline.DataPipelines.1L.1W.3subL" * doctest::timeout(300)) {
pipeline_in_pipeline(1, 1, 3);
}
TEST_CASE("PipelineinPipeline.DataPipelines.1L.1W.4subL" * doctest::timeout(300)) {
pipeline_in_pipeline(1, 1, 4);
}
TEST_CASE("PipelineinPipeline.DataPipelines.1L.2W.1subL" * doctest::timeout(300)) {
pipeline_in_pipeline(1, 2, 1);
}
TEST_CASE("PipelineinPipeline.DataPipelines.1L.2W.3subL" * doctest::timeout(300)) {
pipeline_in_pipeline(1, 2, 3);
}
TEST_CASE("PipelineinPipeline.DataPipelines.1L.2W.4subL" * doctest::timeout(300)) {
pipeline_in_pipeline(1, 2, 4);
}
TEST_CASE("PipelineinPipeline.DataPipelines.3L.1W.1subL" * doctest::timeout(300)) {
pipeline_in_pipeline(3, 1, 1);
}
TEST_CASE("PipelineinPipeline.DataPipelines.3L.1W.3subL" * doctest::timeout(300)) {
pipeline_in_pipeline(3, 1, 3);
}
TEST_CASE("PipelineinPipeline.DataPipelines.3L.1W.4subL" * doctest::timeout(300)) {
pipeline_in_pipeline(3, 1, 4);
}
TEST_CASE("PipelineinPipeline.DataPipelines.3L.2W.1subL" * doctest::timeout(300)) {
pipeline_in_pipeline(3, 2, 1);
}
TEST_CASE("PipelineinPipeline.DataPipelines.3L.2W.3subL" * doctest::timeout(300)) {
pipeline_in_pipeline(3, 2, 3);
}
TEST_CASE("PipelineinPipeline.DataPipelines.3L.2W.4subL" * doctest::timeout(300)) {
pipeline_in_pipeline(3, 2, 4);
}
TEST_CASE("PipelineinPipeline.DataPipelines.5L.1W.1subL" * doctest::timeout(300)) {
pipeline_in_pipeline(5, 1, 1);
}
TEST_CASE("PipelineinPipeline.DataPipelines.5L.1W.3subL" * doctest::timeout(300)) {
pipeline_in_pipeline(5, 1, 3);
}
TEST_CASE("PipelineinPipeline.DataPipelines.5L.1W.4subL" * doctest::timeout(300)) {
pipeline_in_pipeline(5, 1, 4);
}
TEST_CASE("PipelineinPipeline.DataPipelines.5L.2W.1subL" * doctest::timeout(300)) {
pipeline_in_pipeline(5, 2, 1);
}
TEST_CASE("PipelineinPipeline.DataPipelines.5L.2W.3subL" * doctest::timeout(300)) {
pipeline_in_pipeline(5, 2, 3);
}
TEST_CASE("PipelineinPipeline.DataPipelines.5L.2W.4subL" * doctest::timeout(300)) {
pipeline_in_pipeline(5, 2, 4);
}
Reference in a new issue View git blame Copy permalink