202 lines
5.8 KiB
C++
202 lines
5.8 KiB
C++
#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 <benchmark/benchmark.h>
|
|
#include <iostream>
|
|
#include <mutex>
|
|
|
|
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<api::Security>(sec_str);
|
|
auto order_state =
|
|
utils::pb::from_string<api::orderman::OrderState>(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<orderman::AccountName>(native.account_name()),
|
|
orderman::to<orderman::OperatorID>(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<api::Security>(sec_str);
|
|
auto order_state =
|
|
utils::pb::from_string<api::orderman::OrderState>(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<orderman::AccountName>(native.account_name()),
|
|
orderman::to<orderman::OperatorID>(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<api::Security>(sec_str);
|
|
auto order_state = utils::pb::from_string<api::orderman::OrderState>(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<api::Security>(sec_str);
|
|
auto order_state =
|
|
utils::pb::from_string<api::orderman::OrderState>(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<orderman::AccountName>(native.account_name()),
|
|
orderman::to<orderman::OperatorID>(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<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);
|
|
|
|
int Benchmark::execute(std::vector<std::string> 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"; }
|
|
}
|
|
}
|
|
|