#include "Benchmark.h" #include "lib/utils/PBUtils.h" #include "server/sparkd/cmds/CmdRegistry.h" #include "server/sparkd/orderman/native_orders/NativeOrder.h" #include "lib/utils/Puid.h" #include "server/sparkd/orderman/persistence/gen_order_id.h" #include "lib/api/services/OrderService.pb.h" #include #include #include namespace bts { namespace cmd { auto sec_str = " id: 3\n" " symbol: \"ES\"\n" " exchange: VENUE_GLBX\n" " contract_spec {\n" " low_tick: 0.25\n" " high_tick: 0.25\n" " cash_per_point: 50\n" " price_multiplier: 0.01\n" " }\n" " future {\n" " expiration_year: 2018\n" " expiration_month: 9\n" " expiration_day: 1\n" " }\n" " glbx {\n" " exchange_id: 57287\n" " security_desc: \"ESU8\"\n" " cfi_code: \"FFIXSX\"\n" " cme_symbol: \"ES\"\n" " }\n"; auto order_str = " order_key: 189285\n" " timestamp {\n" " seconds: 1509644176\n" " nanos: 717250000\n" " }\n" " native {\n" " account_name: \"BTS \"\n" " operator_id: \"BTS \"\n" " security_key: 3\n" " side: SIDE_BUY\n" " time_in_force: TIF_DAY\n" " manual_order_indicator: MOI_YES\n" " order_type: OT_LIMIT\n" " price: 2500\n" " order_quantity: 12\n" " }\n" " customer_or_firm: COF_FIRM\n" " cti_code: CTI_CTI1\n" " order_status: OS_UNACKNOWLEDGED\n"; static void create_native_order_from_header(benchmark::State &state) { auto sec = utils::pb::from_string(sec_str); auto order_state = utils::pb::from_string(order_str); auto &native = order_state.native(); auto header = orderman::NativeOrderHeader { orderman::null_order_key(), orderman::null_order_key(), api::orderman::COK_UNDEFINED, &sec, orderman::to(native.account_name()), orderman::to(native.operator_id()), native.side(), native.time_in_force(), native.order_type(), native.manual_order_indicator(), order_state.customer_or_firm(), order_state.cti_code() }; for (auto _ : state) { orderman::NativeOrder n(header); benchmark::DoNotOptimize(n.can_be_canceled()); } } BENCHMARK(create_native_order_from_header); static void compare_native_order_header(benchmark::State &state) { auto sec = utils::pb::from_string(sec_str); auto order_state = utils::pb::from_string(order_str); auto &native = order_state.native(); auto header = orderman::NativeOrderHeader { orderman::null_order_key(), orderman::null_order_key(), api::orderman::COK_UNDEFINED, &sec, orderman::to(native.account_name()), orderman::to(native.operator_id()), native.side(), native.time_in_force(), native.order_type(), native.manual_order_indicator(), order_state.customer_or_firm(), order_state.cti_code() }; auto header2 = header; int i = 0; auto n = 0; for (auto _ : state) { header2.side = (api::Side) ((int)header.side + i); benchmark::DoNotOptimize(n += (header == header2)); } } BENCHMARK(compare_native_order_header); static void create_native_order_from_state(benchmark::State &state) { auto sec = utils::pb::from_string(sec_str); auto order_state = utils::pb::from_string(order_str); for (auto _ : state) { orderman::NativeOrder n(sec, order_state); benchmark::DoNotOptimize(n.can_be_canceled()); } } BENCHMARK(create_native_order_from_state); static void create_native_order_header(benchmark::State &state) { auto sec = utils::pb::from_string(sec_str); auto order_state = utils::pb::from_string(order_str); auto &native = order_state.native(); for (auto _ : state) { auto header = orderman::NativeOrderHeader { orderman::null_order_key(), orderman::null_order_key(), api::orderman::COK_UNDEFINED, &sec, orderman::to(native.account_name()), orderman::to(native.operator_id()), native.side(), native.time_in_force(), native.order_type(), native.manual_order_indicator(), order_state.customer_or_firm(), order_state.cti_code() }; benchmark::DoNotOptimize(header.order_key == orderman::null_order_key()); } } BENCHMARK(create_native_order_header); 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 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); int Benchmark::execute(std::vector const &args) { bts_assert(args.size() < 100); int argc = args.size(); char *argv[100]; for (size_t i = 0; i < args.size(); i++) argv[i] = (char *)args[i].c_str(); benchmark::Initialize(&argc, argv); benchmark::RunSpecifiedBenchmarks(); return 0; } std::string Benchmark::help() { return "Run micro-benchmarks"; } } }