119 lines
3.5 KiB
C++
119 lines
3.5 KiB
C++
#include <benchmark/benchmark.h>
|
|
|
|
#include <freepipe/freepipe.hpp>
|
|
#include <pipeline/pipeline.hpp>
|
|
#include <pipes/pipes.hpp>
|
|
#include <tuple>
|
|
#include <vector>
|
|
|
|
namespace {
|
|
|
|
void BM_Pipeline(benchmark::State &state) {
|
|
using namespace pipeline;
|
|
|
|
for (auto _ : state) {
|
|
auto add = fn([](auto a, auto b) { return a + b; });
|
|
auto double_it = fn([](auto a) { return a * 2; });
|
|
auto square_it = fn([](auto a) { return a * a; });
|
|
auto pipeline = add | double_it | square_it;
|
|
|
|
auto ans = pipeline(0, 1);
|
|
benchmark::DoNotOptimize(ans);
|
|
}
|
|
}
|
|
BENCHMARK(BM_Pipeline);
|
|
|
|
void BM_Pipeline2(benchmark::State &state) {
|
|
using namespace pipeline;
|
|
|
|
for (auto _ : state) {
|
|
std::vector<int> ans0, ans1, ans2;
|
|
|
|
auto add = fn([](auto a) { return std::tuple{std::get<0>(a) + 1, std::get<1>(a) + 2}; });
|
|
auto push_back_0 = fn([&ans0](auto a) { ans0.push_back(a); });
|
|
auto push_back_1 = fn([&ans1](auto a) { ans1.push_back(a); });
|
|
auto push_back_2 = fn([&ans2](auto a) { ans2.push_back(a); });
|
|
auto filter = fn([](auto a) { return a < 1; });
|
|
|
|
auto pipeline = add | unzip_into(push_back_0, fork_into(push_back_1, filter | push_back_2));
|
|
|
|
pipeline(std::tuple{1, 2});
|
|
benchmark::DoNotOptimize(ans0);
|
|
benchmark::DoNotOptimize(ans1);
|
|
benchmark::DoNotOptimize(ans2);
|
|
}
|
|
}
|
|
BENCHMARK(BM_Pipeline2);
|
|
|
|
void BM_Pipes(benchmark::State &state) {
|
|
using namespace pipes;
|
|
|
|
for (auto _ : state) {
|
|
std::vector<int> ans;
|
|
|
|
mux(std::vector<int>{0}, std::vector<int>{1}) >>=
|
|
transform([](int a, int b) { return a + b; }) >>= transform([](int a) { return a * 2; }) >>=
|
|
transform([](int a) { return a * a; }) >>= push_back(ans);
|
|
|
|
benchmark::DoNotOptimize(ans);
|
|
}
|
|
}
|
|
BENCHMARK(BM_Pipes);
|
|
|
|
void BM_Pipes2(benchmark::State &state) {
|
|
using namespace pipes;
|
|
|
|
for (auto _ : state) {
|
|
std::vector<int> ans0, ans1, ans2;
|
|
|
|
std::vector<std::tuple<int, int>>{std::tuple{1, 2}} >>= pipes::transform([](auto a) {
|
|
return std::tuple{std::get<0>(a) + 1, std::get<1>(a) + 2};
|
|
}) >>= pipes::unzip(pipes::push_back(ans0),
|
|
pipes::fork(pipes::push_back(ans1), pipes::filter([](int a) {
|
|
return a < 1;
|
|
}) >>= pipes::push_back(ans2)));
|
|
benchmark::DoNotOptimize(ans0);
|
|
benchmark::DoNotOptimize(ans1);
|
|
benchmark::DoNotOptimize(ans2);
|
|
}
|
|
}
|
|
BENCHMARK(BM_Pipes2);
|
|
|
|
void BM_Pipe(benchmark::State &state) {
|
|
using namespace freepipe;
|
|
|
|
for (auto _ : state) {
|
|
const Pipe p;
|
|
|
|
auto r = p | [] { return std::tuple{0, 1}; } | [](auto ab) {
|
|
auto a = std::get<0>(ab);
|
|
auto b = std::get<1>(ab);
|
|
|
|
return a + b;
|
|
} | [](auto a) {
|
|
return a * 2;
|
|
} | [](auto a) { return a * a; };
|
|
|
|
benchmark::DoNotOptimize(r);
|
|
}
|
|
}
|
|
BENCHMARK(BM_Pipe);
|
|
|
|
} // namespace
|
|
|
|
// 2025-08-06T21:13:50+01:00
|
|
// Running /home/murta/src/pipeline/build/tests/pipeline.test
|
|
// Run on (16 X 3199.99 MHz CPU s)
|
|
// CPU Caches:
|
|
// L1 Data 32 KiB (x8)
|
|
// L1 Instruction 64 KiB (x8)
|
|
// L2 Unified 512 KiB (x8)
|
|
// L3 Unified 8192 KiB (x2)
|
|
// Load Average: 1.68, 1.49, 0.97
|
|
// -------------------------------------------------------
|
|
// Benchmark Time CPU Iterations
|
|
// -------------------------------------------------------
|
|
// BM_Pipeline 0.323 ns 0.323 ns 2163778209
|
|
// BM_Pipes 12.2 ns 12.2 ns 57225038
|
|
// BM_Pipe 0.320 ns 0.320 ns 2173384108
|