Files
spark/src/server/sparkd/cmds/Benchmark.cpp
T
John Colvin 576fd34429 build: Replace several external libs w/ CPM pkgs
These replace include files/libs previously tracked in externals

* absl
* benchmark
* ccapi
* concurrentqueue
* date
* double-conversion
* fmt
* json
* range-v3
* readerwriterqueue
* rxcpp
* websocketpp
2022-10-11 23:19:47 -04:00

939 lines
26 KiB
C++

#include "Benchmark.h"
#include "lib/api/services/OrderService.server.pb.h"
#include "lib/jetfix/jetfix.h"
#include "lib/md/PriceSize.h"
#include "lib/mercury/actors/Actor.h"
#include "lib/mercury/common/FatWrapper.h"
#include "lib/mercury/executor/Executor.h"
#include "lib/orderman/events/OrderStateUpdateEvent.h"
#include "lib/os/os.h"
#include "lib/utils/ConcurrentAppendCollection.h"
#include "lib/utils/PBUtils.h"
#include "lib/utils/Puid.h"
#include "lib/utils/SpinLock.h"
#include "lib/utils/TimeStamp.h"
#include "lib/utils/Uuid.h"
#include "lib/utils/mpmc_bounded_queue.h"
#include "system/Delegate.h"
#include "lib/tracing/PerfLog.h"
#include "system/ProducerConsumerQueue.h"
#include <benchmark/benchmark.h>
#include <boost/container/flat_map.hpp>
#include <boost/container/small_vector.hpp>
#include <boost/lockfree/queue.hpp>
#include <boost/lockfree/spsc_queue.hpp>
#include <boost/lockfree/stack.hpp>
#include <boost/pool/object_pool.hpp>
#include <boost/pool/pool.hpp>
#include <boost/pool/pool_alloc.hpp>
#include <boost/pool/singleton_pool.hpp>
#include <cstdlib>
#include <iostream>
#include <concurrentqueue.h>
#include <readerwriterqueue.h>
#include <mutex>
#include <sys/time.h>
#include <btree/btree_set.h>
#include <set>
#include <unordered_set>
#include "logger/ILoggingSink.h"
#include "logger/Logger.h"
#include "logger/LoggerHub.h"
#include <date/date.h>
#include <tbb/concurrent_queue.h>
#include <tbb/concurrent_vector.h>
namespace bts::cmds {
// using namespace orderman;
// static void test_date_conversion(::benchmark::State &state) {
// auto lldt = datetime::ll_now();
// for (auto _ : state) {
// ::benchmark::DoNotOptimize(datetime::utc_ll_to_timepoint(lldt));
// }
// }
// BENCHMARK(test_date_conversion);
// static void gen_id(::benchmark::State &state) {
// std::string scope = "benchmark";
// for (auto _ : state) {
// auto id = utils::reserve_ids(scope, 1);
// ::benchmark::DoNotOptimize(id + 1 > 0);
// }
// }
// BENCHMARK(gen_id);
// static void mutex_lock_unlock(::benchmark::State &state) {
// int i = 0;
// std::mutex lock;
// for (auto _ : state) {
// std::lock_guard<std::mutex> l(lock);
// ::benchmark::DoNotOptimize(i++);
// }
// }
// BENCHMARK(mutex_lock_unlock);
// static void spin_lock_unlock(::benchmark::State &state) {
// int i = 0;
// std::atomic_flag _mutex = ATOMIC_FLAG_INIT;
// for (auto _ : state) {
// while (_mutex.test_and_set(std::memory_order_acquire))
// ;
// ::benchmark::DoNotOptimize(i++);
// _mutex.clear(std::memory_order_release);
// }
// }
// BENCHMARK(spin_lock_unlock);
// static void bts_spinlock_lock_unlock(::benchmark::State &state) {
// int i = 0;
// utils::SpinLock l;
// for (auto _ : state) {
// std::lock_guard<utils::SpinLock> g(l);
// ::benchmark::DoNotOptimize(i++);
// }
// }
// BENCHMARK(bts_spinlock_lock_unlock);
// // static void serialize_update(::benchmark::State &state) {
// // api::orderman::Update update;
// // update.set_order_key(1);
// // update.set_price(1.2);
// // update.set_quantity(2);
// // std::string buffer;
// // buffer.resize(update.ByteSizeLong());
// // bts_assert(update.SerializeToArray(&buffer[0], buffer.size()));
// // for (auto _ : state) {
// // update.SerializeWithCachedSizesToArray((unsigned char *)&buffer[0]);
// // }
// // }
// // BENCHMARK(serialize_update);
// // struct IntId {
// // IntId() { value = std::rand(); }
// // bool operator<(IntId const &v) const { return value < v.value; }
// // uint32_t value;
// // };
// // static void binary_search_of_guid(::benchmark::State &state) {
// // using Id = utils::Uuid;
// // using Map = boost::container::flat_map<Id, int>;
// // auto sz = state.range(0);
// // Map m;
// // for (int i = 0; i < sz; i++)
// // m[Id()] = i;
// // auto target = Id();
// // int found_count = 0;
// // for (auto _ : state) {
// // auto it = m.find(target);
// // if (it != m.end())
// // found_count++;
// // ::benchmark::DoNotOptimize(found_count);
// // }
// // }
// // BENCHMARK(binary_search_of_guid)->Range(8, 8 << 10);
// // static void binary_search_of_int64(::benchmark::State &state) {
// // using Id = IntId;
// // using Map = boost::container::flat_map<Id, int>;
// // auto sz = state.range(0);
// // Map m;
// // for (int i = 0; i < sz; i++)
// // m[Id()] = i;
// // auto target = Id();
// // int found_count = 0;
// // for (auto _ : state) {
// // auto it = m.find(target);
// // if (it != m.end())
// // found_count++;
// // ::benchmark::DoNotOptimize(found_count);
// // }
// // }
// // BENCHMARK(binary_search_of_int64)->Range(8, 8 << 10);
// // static void binary_search_of_int32(::benchmark::State &state) {
// // using Id = IntId;
// // using Map = boost::container::flat_map<Id, int>;
// // auto sz = state.range(0);
// // Map m;
// // for (int i = 0; i < sz; i++)
// // m[Id()] = i;
// // auto target = Id();
// // int found_count = 0;
// // for (auto _ : state) {
// // auto it = m.find(target);
// // if (it != m.end())
// // found_count++;
// // ::benchmark::DoNotOptimize(found_count);
// // }
// // }
// // BENCHMARK(binary_search_of_int32)->Range(8, 8 << 10);
// // static void guid_gen(::benchmark::State &state) {
// // for (auto _ : state) {
// // ::benchmark::DoNotOptimize(utils::Uuid());
// // }
// // }
// // BENCHMARK(guid_gen);
// // struct A {
// // int x;
// // };
// // static void shared_ptr_cpy(::benchmark::State &state) {
// // auto a = std::make_shared<A>();
// // for (auto _ : state) {
// // std::shared_ptr<A> b;
// // ::benchmark::DoNotOptimize(b = a);
// // }
// // }
// // BENCHMARK(shared_ptr_cpy);
// // static void alloc_free(::benchmark::State &state) {
// // for (auto _ : state) {
// // auto a = std::make_shared<A>();
// // ::benchmark::DoNotOptimize(a.get());
// // }
// // }
// // BENCHMARK(alloc_free);
// // static void new_delete(::benchmark::State &state) {
// // for (auto _ : state) {
// // auto a = new A();
// // delete a;
// // ::benchmark::DoNotOptimize(a);
// // }
// // }
// // BENCHMARK(new_delete);
// // static void boost_pool(::benchmark::State &state) {
// // boost::pool<> p(sizeof(A));
// // for (auto _ : state) {
// // auto a = p.malloc();
// // p.free(a);
// // ::benchmark::DoNotOptimize(a);
// // }
// // }
// // BENCHMARK(boost_pool);
// // static void boost_object_pool(::benchmark::State &state) {
// // boost::object_pool<A> p;
// // for (auto _ : state) {
// // auto a = p.malloc();
// // p.free(a);
// // ::benchmark::DoNotOptimize(a);
// // }
// // }
// // BENCHMARK(boost_object_pool);
// // static void protected_boost_pool(::benchmark::State &state) {
// // boost::pool<> p(sizeof(A));
// // std::atomic_flag _mutex = ATOMIC_FLAG_INIT;
// // for (auto _ : state) {
// // while (_mutex.test_and_set(std::memory_order_acquire))
// // ;
// // auto a = p.malloc();
// // _mutex.clear(std::memory_order_release);
// // while (_mutex.test_and_set(std::memory_order_acquire))
// // ;
// // p.free(a);
// // _mutex.clear(std::memory_order_release);
// // ::benchmark::DoNotOptimize(a);
// // }
// // }
// // BENCHMARK(protected_boost_pool);
// // static void boost_singleton_pool(::benchmark::State &state) {
// // using Pool = boost::singleton_pool<struct Single, sizeof(A)>;
// // for (auto _ : state) {
// // auto a = Pool::malloc();
// // Pool::free(a);
// // ::benchmark::DoNotOptimize(a);
// // }
// // }
// // BENCHMARK(boost_singleton_pool);
// static void atomic_inc(::benchmark::State &state) {
// std::atomic<size_t> i(0);
// for (auto _ : state) {
// ::benchmark::DoNotOptimize(i++);
// }
// }
// BENCHMARK(atomic_inc);
// static void mem_copy(::benchmark::State &state) {
// char *src = new char[state.range(0)];
// char *dst = new char[state.range(0)];
// memset(src, 'x', state.range(0));
// for (auto _ : state)
// memcpy(dst, src, state.range(0));
// state.SetBytesProcessed(
// int64_t(state.iterations()) * int64_t(state.range(0)));
// delete[] src;
// delete[] dst;
// }
// BENCHMARK(mem_copy)->Arg(8)->Arg(64)->Arg(128)->Arg(512)->Arg(1 << 10)->Arg(
// 8 << 10);
// // static void alloc_and_copy_from_pool(::benchmark::State &state) {
// // boost::pool<> p(sizeof(A));
// // for (auto _ : state) {
// // auto a = new (p.malloc()) A(); // NOLINT
// // a->~A(); // NOLINT
// // p.free(a);
// // ::benchmark::DoNotOptimize(a);
// // }
// // }
// // BENCHMARK(alloc_and_copy_from_pool);
// // static void lambda_copy(::benchmark::State &state) {
// // auto p = std::make_shared<A>();
// // std::function<int()> f = [p]() { return 1; };
// // std::array<std::function<int()>, 1> buffer;
// // for (auto _ : state) {
// // ::benchmark::DoNotOptimize(buffer[0] = f);
// // }
// // }
// // BENCHMARK(lambda_copy);
// // static void boost_pool_allocator(::benchmark::State &state) {
// // boost::fast_pool_allocator<A> p;
// // for (auto _ : state) {
// // auto ptr = std::allocate_shared<A>(p);
// // ::benchmark::DoNotOptimize(ptr.get());
// // }
// // }
// // BENCHMARK(boost_pool_allocator);
// static void boost_lockless_queue(::benchmark::State &state) {
// using FreeList = boost::lockfree::queue<void *>;
// FreeList queue(1000000);
// for (auto _ : state) {
// void *result;
// queue.push(nullptr);
// ::benchmark::DoNotOptimize(queue.pop(result));
// }
// }
// BENCHMARK(boost_lockless_queue);
// static void tbb_concurrent_queue(::benchmark::State &state) {
// using FreeList = tbb::concurrent_queue<void *>;
// FreeList queue;
// for (auto _ : state) {
// void *result;
// queue.push(nullptr);
// ::benchmark::DoNotOptimize(queue.try_pop(result));
// }
// }
// BENCHMARK(tbb_concurrent_queue);
static void boost_spsc_str(::benchmark::State &state) {
boost::lockfree::spsc_queue<std::string> q(10000);
std::string x;
std::string y;
for (auto _ : state) {
q.push(x);
::benchmark::DoNotOptimize(q.pop(y));
}
}
BENCHMARK(boost_spsc_str);
static void folly_spsc(::benchmark::State &state) {
folly::ProducerConsumerQueue<int> q(10000);
int x;
for (auto _ : state) {
q.write(1);
::benchmark::DoNotOptimize(q.read(x));
}
}
BENCHMARK(folly_spsc);
static void boost_spsc(::benchmark::State &state) {
boost::lockfree::spsc_queue<int> q(10000);
int i = 0;
for (auto _ : state) {
q.push(12);
::benchmark::DoNotOptimize(q.pop(i));
}
}
BENCHMARK(boost_spsc);
// // static void boost_lockless_stack(::benchmark::State &state) {
// // using FreeList = boost::lockfree::stack<void *>;
// // FreeList stack;
// // for (auto _ : state) {
// // void *result;
// // stack.push(nullptr);
// // ::benchmark::DoNotOptimize(stack.pop(result));
// // }
// // }
// // BENCHMARK(boost_lockless_stack);
// // using Msg = mercury::FatWrapper<80>;
// // struct PPQueue {
// // std::atomic_flag _mutex = ATOMIC_FLAG_INIT;
// // std::vector<Msg *> v;
// // void push(Msg *e) {
// // while (_mutex.test_and_set(std::memory_order_acquire))
// // ;
// // v.push_back(e);
// // _mutex.clear(std::memory_order_release);
// // }
// // bool pop(Msg **e) {
// // auto result = false;
// // while (_mutex.test_and_set(std::memory_order_acquire))
// // ;
// // if (v.size()) {
// // *e = v.back();
// // v.pop_back();
// // result = true;
// // }
// // _mutex.clear(std::memory_order_release);
// // return result;
// // }
// // };
// static void get_thread_id(::benchmark::State &state) {
// for (auto _ : state) {
// auto tid = std::this_thread::get_id();
// ::benchmark::DoNotOptimize(tid == std::this_thread::get_id());
// }
// }
// BENCHMARK(get_thread_id);
// // static void native_order_fix_data_create(::benchmark::State &state) {
// // auto sz = state.range(0);
// // for (auto _ : state) {
// // auto p = new uint8_t[sz];
// // delete[] p;
// // ::benchmark::DoNotOptimize(p);
// // }
// // }
// // BENCHMARK(native_order_fix_data_create)->Range(8, 8 << 14);
// // static void native_order_fix_data_fragment(::benchmark::State &state) {
// // for (auto _ : state) {
// // auto p = new jetfix::FIXFragment();
// // delete p;
// // ::benchmark::DoNotOptimize(p);
// // }
// // }
// // BENCHMARK(native_order_fix_data_fragment);
// // static void small_vec(::benchmark::State &state) {
// // auto i = 0;
// // for (auto _ : state) {
// // boost::container::small_vector<size_t, 1> vec;
// // vec.emplace_back(i++);
// // ::benchmark::DoNotOptimize(vec[0]);
// // }
// // }
// // BENCHMARK(small_vec);
// static void inter_thread_spsc(::benchmark::State &state) {
// boost::lockfree::spsc_queue<int> q1(10);
// boost::lockfree::spsc_queue<int> q2(10);
// auto t2 = std::thread([&q1, &q2]() {
// int i = 1;
// cpu_set_t cpuset;
// CPU_ZERO(&cpuset);
// CPU_SET(1, &cpuset);
// pthread_setaffinity_np(pthread_self(), sizeof(cpu_set_t), &cpuset);
// do {
// while (!q1.pop(i))
// ;
// q2.push(i);
// } while (i);
// });
// cpu_set_t cpuset;
// CPU_ZERO(&cpuset);
// CPU_SET(0, &cpuset);
// pthread_setaffinity_np(pthread_self(), sizeof(cpu_set_t), &cpuset);
// sleep_for(2s);
// int i = 0;
// for (auto _ : state) {
// q1.push(++i);
// while (!q2.pop(i))
// ;
// }
// q1.push(0);
// t2.join();
// }
// BENCHMARK(inter_thread_spsc);
// // static void inter_thread_mpmc(::benchmark::State &state) {
// // using Queue = boost::lockfree::queue<int>;
// // Queue q1(100), q2(100);
// // auto t2 = std::thread([&q1, &q2]() {
// // int i = 1;
// // cpu_set_t cpuset;
// // CPU_ZERO(&cpuset);
// // CPU_SET(1, &cpuset);
// // pthread_setaffinity_np(pthread_self(), sizeof(cpu_set_t), &cpuset);
// // do {
// // while (!q1.pop(i))
// // ;
// // q2.push(i);
// // } while (i);
// // });
// // cpu_set_t cpuset;
// // CPU_ZERO(&cpuset);
// // CPU_SET(0, &cpuset);
// // pthread_setaffinity_np(pthread_self(), sizeof(cpu_set_t), &cpuset);
// // sleep_for(2s);
// // int i = 0;
// // for (auto _ : state) {
// // q1.push(++i);
// // while (!q2.pop(i))
// // ;
// // }
// // q1.push(0);
// // t2.join();
// // }
// // BENCHMARK(inter_thread_mpmc);
// static void inter_thread_mpmc_spdlog(::benchmark::State &state) {
// using Queue = spdlog::details::mpmc_bounded_queue<int>;
// Queue q1(8), q2(8);
// auto t2 = std::thread([&q1, &q2]() {
// int i = 1;
// cpu_set_t cpuset;
// CPU_ZERO(&cpuset);
// CPU_SET(1, &cpuset);
// pthread_setaffinity_np(pthread_self(), sizeof(cpu_set_t), &cpuset);
// do {
// while (!q1.dequeue(i))
// ;
// q2.enqueue(i);
// } while (i);
// });
// cpu_set_t cpuset;
// CPU_ZERO(&cpuset);
// CPU_SET(0, &cpuset);
// pthread_setaffinity_np(pthread_self(), sizeof(cpu_set_t), &cpuset);
// sleep_for(2s);
// int i = 0;
// for (auto _ : state) {
// q1.enqueue(++i);
// while (!q2.dequeue(i))
// ;
// }
// q1.enqueue(0);
// t2.join();
// }
// BENCHMARK(inter_thread_mpmc_spdlog);
// static void same_thread_mpmc_spdlog(::benchmark::State &state) {
// using Queue = spdlog::details::mpmc_bounded_queue<int>;
// Queue q1(8);
// int i = 0;
// for (auto _ : state) {
// q1.enqueue(++i);
// q1.dequeue(i);
// }
// }
// BENCHMARK(same_thread_mpmc_spdlog);
// static void moodycamel_concurrent_queue(::benchmark::State &state) {
// using Q = moodycamel::ConcurrentQueue<int>;
// Q queue(8);
// int i = 0;
// for (auto _ : state) {
// queue.enqueue(++i); // NOLINT
// ::benchmark::DoNotOptimize(queue.try_dequeue(i));
// }
// }
// BENCHMARK(moodycamel_concurrent_queue);
// static void moodycamel_spsc_queue(::benchmark::State &state) {
// using Queue = moodycamel::ReaderWriterQueue<int>;
// Queue q1(8);
// int i = 0;
// for (auto _ : state) {
// q1.enqueue(++i);
// ::benchmark::DoNotOptimize(q1.try_dequeue(i));
// }
// }
// BENCHMARK(moodycamel_spsc_queue);
// // struct MyBase {
// // virtual int inc(int &x) = 0;
// // };
// // struct MyDerived : MyBase {
// // int inc(int &x) override { return x += 1; };
// // };
// // struct MyDirect {
// // int inc(int &x) { return x += 1; };
// // };
// // static void derived_call(::benchmark::State &state) {
// // int x = 0;
// // MyDerived d;
// // MyBase &b = d;
// // for (auto _ : state) {
// // ::benchmark::DoNotOptimize(b.inc(x));
// // }
// // }
// // BENCHMARK(derived_call);
// // static void direct_call(::benchmark::State &state) {
// // int x = 0;
// // MyDerived b;
// // for (auto _ : state) {
// // ::benchmark::DoNotOptimize(b.inc(x));
// // }
// // }
// // BENCHMARK(direct_call);
// // static void get_time_of_day(::benchmark::State &state) {
// // std::string result(strlen("20121204-14:44:02.999"), ' ');
// // struct timeval tv;
// // for (auto _ : state) {
// // gettimeofday(&tv, nullptr);
// // auto tm = localtime(&tv.tv_sec);
// // sprintf(
// // &result[0], "%d%02d%02d-%02d:%02d:%02d.%03d", tm->tm_year,
// // tm->tm_mon, tm->tm_mday, tm->tm_hour, tm->tm_min, tm->tm_sec,
// 0);
// // }
// // }
// // BENCHMARK(get_time_of_day);
// // static void fix_time_stamp(::benchmark::State &state) {
// // std::string r(128, 32);
// // auto now = datetime::now();
// // for (auto _ : state) {
// // datetime::FIX_timestamp(now, &r);
// // }
// // }
// // BENCHMARK(fix_time_stamp);
// // static void perf_log(::benchmark::State &state) {
// // trace::PerfLog l;
// // for (auto _ : state) {
// // l.log(trace::CorID{"sim", 0}, "this", 1, "txt", 3);
// // }
// // }
// // BENCHMARK(perf_log);
// // void int_price_less(::benchmark::State &state) {
// // for (auto _ : state) {
// // state.PauseTiming();
// // int64_t count = state.range(0);
// // std::vector<md::IntPrice> prices;
// // prices.reserve((int)count);
// // for (int64_t x = 0; x < count; ++x) {
// // prices.push_back({x % 100, (int8_t) - (x % 5)});
// // }
// // state.ResumeTiming();
// // std::sort(prices.begin(), prices.end());
// // }
// // }
// // BENCHMARK(int_price_less)->Range(8, 8 << 11);
// // void set_hashset_insert(::benchmark::State &state) {
// // std::unordered_set<uintptr_t> s;
// // size_t x = 0;
// // for (auto _ : state) {
// // x = std::rand();
// // s.insert(x);
// // }
// // }
// // void set_stdset_insert(::benchmark::State &state) {
// // std::set<uintptr_t> s;
// // size_t x = 0;
// // for (auto _ : state) {
// // x = std::rand();
// // s.insert(x);
// // }
// // }
// // void set_btreeset_insert(::benchmark::State &state) {
// // btree::set<uintptr_t> s;
// // size_t x = 0;
// // for (auto _ : state) {
// // x = std::rand();
// // s.insert(x);
// // }
// // }
// // void set_hashset_iterate(::benchmark::State &state) {
// // std::unordered_set<uintptr_t> s;
// // size_t x = 0;
// // for (auto _ : state) {
// // x = std::rand();
// // s.insert(x);
// // for (const auto &p : s) {
// // ::benchmark::DoNotOptimize(p);
// // }
// // }
// // }
// // void set_stdset_iterate(::benchmark::State &state) {
// // std::set<uintptr_t> s;
// // size_t x = 0;
// // for (auto _ : state) {
// // x = std::rand();
// // s.insert(x);
// // for (const auto &p : s) {
// // ::benchmark::DoNotOptimize(p);
// // }
// // }
// // }
// // void set_btreeset_iterate(::benchmark::State &state) {
// // btree::set<uintptr_t> s;
// // size_t x = 0;
// // for (auto _ : state) {
// // x = std::rand();
// // s.insert(x);
// // for (const auto &p : s) {
// // ::benchmark::DoNotOptimize(p);
// // }
// // }
// // }
// // BENCHMARK(set_hashset_insert);
// // BENCHMARK(set_stdset_insert);
// // BENCHMARK(set_btreeset_insert);
// // BENCHMARK(set_hashset_iterate);
// // BENCHMARK(set_stdset_iterate);
// // BENCHMARK(set_btreeset_iterate);
// // struct Chunk {
// // size_t a, b, c, d;
// // };
// // void tbb_concurrent_vector_insert(::benchmark::State &state) {
// // tbb::concurrent_vector<Chunk> vec;
// // size_t x = 0;
// // for (auto _ : state) {
// // vec.push_back({++x, ++x, ++x, ++x});
// // }
// // }
// // BENCHMARK(tbb_concurrent_vector_insert);
// // void tbb_concurrent_vector_iterate(::benchmark::State &state) {
// // tbb::concurrent_vector<Chunk> vec;
// // for (size_t x = 0; x < 9999; ++x) {
// // vec.push_back({++x, ++x, ++x, ++x});
// // }
// // for (auto _ : state) {
// // for (const auto &v : vec) {
// // ::benchmark::DoNotOptimize(v);
// // }
// // }
// // }
// // BENCHMARK(tbb_concurrent_vector_iterate);
// // void tbb_concurrent_vector_index(::benchmark::State &state) {
// // tbb::concurrent_vector<Chunk> vec;
// // for (size_t x = 0; x < 9999; ++x) {
// // vec.push_back({++x, ++x, ++x, ++x});
// // }
// // for (auto _ : state) {
// // for (size_t x = 0; x < vec.size(); ++x) {
// // ::benchmark::DoNotOptimize(vec[x]);
// // }
// // }
// // }
// // BENCHMARK(tbb_concurrent_vector_index);
// // void concurrent_append_collection_insert(::benchmark::State &state) {
// // ConcurrentAppendCollection<Chunk> vec;
// // size_t x = 0;
// // for (auto _ : state) {
// // vec.push_back({++x, ++x, ++x, ++x});
// // }
// // }
// // BENCHMARK(concurrent_append_collection_insert);
// // void concurrent_append_collection_iterate(::benchmark::State &state) {
// // ConcurrentAppendCollection<Chunk> vec;
// // for (size_t x = 0; x < 9999; ++x) {
// // vec.push_back({++x, ++x, ++x, ++x});
// // }
// // for (auto _ : state) {
// // for (const auto &v : vec) {
// // ::benchmark::DoNotOptimize(v);
// // }
// // }
// // }
// // BENCHMARK(concurrent_append_collection_iterate);
// // void concurrent_append_collection_index(::benchmark::State &state) {
// // ConcurrentAppendCollection<Chunk> vec;
// // for (size_t x = 0; x < 9999; ++x) {
// // vec.push_back({++x, ++x, ++x, ++x});
// // }
// // for (auto _ : state) {
// // for (size_t x = 0; x < vec.size(); ++x) {
// // ::benchmark::DoNotOptimize(vec[x]);
// // }
// // }
// // }
// // BENCHMARK(concurrent_append_collection_index);
// // void utils_timestamp(::benchmark::State &state) {
// // for (auto _ : state) {
// // ::benchmark::DoNotOptimize(utils::TimeStamp::now());
// // }
// // }
// // BENCHMARK(utils_timestamp);
// // void bts_chrono_now(::benchmark::State &state) {
// // for (auto _ : state) {
// // ::benchmark::DoNotOptimize(Timer::now());
// // }
// // }
// // BENCHMARK(bts_chrono_now);
// // void unix_nano_now(::benchmark::State &state) {
// // for (auto _ : state) {
// // ::benchmark::DoNotOptimize(datetime::unix_nano_now());
// // }
// // }
// // BENCHMARK(unix_nano_now);
// struct TestHandler {
// int g(int x) { return 2 * x; }
// static int z(int x);
// };
// int TestHandler::z(int x) { return 2 * x; }
// void function_handler(::benchmark::State &state) {
// TestHandler h;
// std::function<int(int)> f = [&h](int x) { return h.g(x); };
// for (auto _ : state) {
// ::benchmark::DoNotOptimize(f(1));
// }
// }
// BENCHMARK(function_handler);
// void raw_handler(::benchmark::State &state) {
// TestHandler h;
// for (auto _ : state) {
// ::benchmark::DoNotOptimize(h.g(1));
// }
// }
// BENCHMARK(raw_handler);
// void method_pointer(::benchmark::State &state) {
// TestHandler h;
// spartan::Delegate<int(int)> d;
// d.bind<&TestHandler::g>(h);
// for (auto _ : state) {
// ::benchmark::DoNotOptimize(d(1));
// }
// }
// BENCHMARK(method_pointer);
// void static_method(::benchmark::State &state) {
// spartan::Delegate<int(int)> d;
// d.bind<&TestHandler::z>();
// for (auto _ : state) {
// ::benchmark::DoNotOptimize(d(1));
// }
// }
// BENCHMARK(static_method);
// void lambda_method(::benchmark::State &state) {
// spartan::Delegate<int(int)> d;
// auto op = [](int x) { return 2 * x; };
// d.bind(op);
// for (auto _ : state) {
// ::benchmark::DoNotOptimize(d(1));
// }
// }
// BENCHMARK(lambda_method);
// int fd(int x) { return 2 * x; }
// void function_delegate(::benchmark::State &state) {
// spartan::Delegate<int(int)> d;
// d.bind<&fd>();
// for (auto _ : state) {
// ::benchmark::DoNotOptimize(d(1));
// }
// }
// BENCHMARK(function_delegate);
// void direct_static(::benchmark::State &state) {
// for (auto _ : state) {
// ::benchmark::DoNotOptimize(fd(1));
// }
// }
// BENCHMARK(direct_static);
struct Benchmark::Args {
std::vector<std::string> args;
};
Benchmark::Benchmark()
: CLI::App(
"Run micro-benchmarks. Use --benchmark_filter=regex to run only "
"specific benchmarks.",
"benchmark"),
_args(new Benchmark::Args()) {
add_option("args", _args->args);
callback([&] {
bts_assert(_args->args.size() < 99);
int argc = _args->args.size() + 1;
char *argv[100];
argv[0] = (char *)"spark";
for (size_t i = 0; i < _args->args.size(); i++)
::benchmark::Initialize(&argc, argv);
::benchmark::RunSpecifiedBenchmarks();
});
}
Benchmark::~Benchmark() {}
} // namespace bts::cmds