MBO perf work

This commit is contained in:
Eric Harding committed 2019-04-18 14:39:15 -04:00
1 parent 73c9be3bec
commit 5392d05ec8
8 files changed
+328 -29

No files matched your search

+1 -1
View File
@@ -215,7 +215,7 @@
"type": "cppdbg",
"request": "launch",
"program": "/home/bts/spark/build/ninja_debug/server/sparkd",
"args": ["test", "[md]"],
"args": ["test", "[mbo]"],
"stopAtEntry": false,
"cwd": "/home/bts/spark/build/ninja_debug/server/",
"environment": [],
+6
View File
@@ -60,6 +60,12 @@ class IntPrice {
return delta.mantissa() < 0;
}
}
bool operator <=(const IntPrice& other) {
return *this == other || *this < other;
}
bool operator >=(const IntPrice& other) {
return !(*this < other);
}
IntPrice operator - (const IntPrice& o) const {
return op(o, [](int64_t m1, int64_t m2) { return m1 - m2; });
}
+78 -13
View File
@@ -1,4 +1,4 @@
#include "MBOProcessor.h"
#include "MBOProcessor.h"
#include "lib/utils/Dispatcher.h"
#include "lib/utils/ConcurrentPool.h"
#include "lib/config/config.h"
@@ -12,8 +12,8 @@
#include <tbb/concurrent_hash_map.h>
namespace bts {
namespace md {
namespace bts {
namespace md {
struct SecurityKeyHashCompare {
static size_t hash(const SecurityKey& k) {
@@ -51,8 +51,8 @@ void print_pool_stats(const utils::ConcurrentPool<MBOSnapshot>& pool) {
}
bid_percentiles << bid_sz[count-1] << " ";
ask_percentiles << ask_sz[count-1] << " ";
LOG(md,Info,
"MBO statistics: count: {} - %[50,75,90,95,99,100] bid: [{}] - ask: [{}]",
LOG(md,Info,
"MBO statistics: count: {} - %[50,75,90,95,99,100] bid: [{}] - ask: [{}]",
count, bid_percentiles.str(), ask_percentiles.str());
}
@@ -60,11 +60,13 @@ typedef tbb::concurrent_hash_map<SecurityKey, MBOSnapshot*, SecurityKeyHashCompa
struct MBOProcessorImpl {
utils::ConcurrentPool<MBOSnapshot> pool;
MapType snapshots;
utils::Dispatcher& dispatcher;
utils::DispatcherTimer timer;
MBOProcessorImpl() :
pool(2048,512),
snapshots(),
timer(utils::Dispatcher::background(), 600*1000, [&]() { print_pool_stats(pool); })
MBOProcessorImpl(utils::Dispatcher& d) :
pool(2048,512),
snapshots(),
dispatcher(d),
timer(d, 600*1000, [&]() { print_pool_stats(pool); })
{
if (config::get<config::toggles::MBOStats>().enabled()) {
timer.start();
@@ -75,8 +77,8 @@ struct MBOProcessorImpl {
//
// Processor
MBOProcessor::MBOProcessor() :
_me(std::make_shared<MBOProcessorImpl>()),
MBOProcessor::MBOProcessor(utils::Dispatcher* d) :
_me(std::make_shared<MBOProcessorImpl>(d == nullptr ? utils::Dispatcher::background() : *d)),
_producer(_me),
_consumer(_me)
{}
@@ -86,9 +88,10 @@ MBOReader& MBOProcessor::reader() { return _consumer; }
//
// Writer
MBOWriter::MBOWriter(std::shared_ptr<MBOProcessorImpl>& me): _me(me) { }
MBOWriter::~MBOWriter() { }
MBOSnapshot* MBOWriter::allocate_snapshot() {
MBOSnapshot* MBOWriter::allocate_snapshot(size_t, size_t) {
return _me->pool.allocate();
}
void MBOWriter::publish_snapshot(SecurityKey key, MBOSnapshot* snapshot) {
@@ -102,6 +105,68 @@ void MBOWriter::publish_snapshot(SecurityKey key, MBOSnapshot* snapshot) {
}
}
bool MBOWriter::validate_snapshot(SecurityKey key, MBOSnapshot* control) {
#define REQUIRE(x) if (!(x)) { LOG(md,Error, "{}", std::string(#x)); return false; }
// retrieve current snapshot and check they are equal
MBOReader reader(_me);
auto snap = reader.acquire_snapshot(key);
REQUIRE (snap->bids.size() == control->bids.size())
REQUIRE (snap->asks.size() == control->asks.size())
for (size_t x = 0; x < snap->bids.size(); ++x) {
REQUIRE (snap->bids[x].id == control->bids[x].id);
REQUIRE (snap->bids[x].price == control->bids[x].price);
REQUIRE (snap->bids[x].size == control->bids[x].size);
}
for (size_t x = 0; x < snap->asks.size(); ++x) {
REQUIRE (snap->asks[x].id == control->asks[x].id);
REQUIRE (snap->asks[x].price == control->asks[x].price);
REQUIRE (snap->asks[x].size == control->asks[x].size);
}
#undef REQUIRE
return true;
}
void MBOWriter::enqueue_incremental(MBOWorkingState& state, const inc::Update& update) {
_me->dispatcher.post([this,&state,update]() {
this->apply_incremental(state,update);
});
}
void MBOWriter::apply_incremental(MBOWorkingState& state, const inc::Update& update) {
// fast part
apply_incremental(state, update);
// determine if we need to publish
// slow part
auto snap = allocate_snapshot(state.bid.size(), state.ask.size());
copy_to_snapshot(state, snap);
publish_snapshot(state.security, snap);
}
void copy_to_snapshot(MBOWorkingState& state, MBOSnapshot* dest) {
if (dest == nullptr) return;
// copy working state to snapshot
dest->updated = state.updated;
auto type_map = [](auto pair) {
return SnapshotOrder { pair.second.id, std::get<IntPrice>(pair.first), pair.second.size };
};
std::transform(state.bid.rbegin(), state.bid.rend(), std::back_inserter(dest->bids), type_map);
std::transform(state.ask.begin(), state.ask.end(), std::back_inserter(dest->asks), type_map);
}
void apply_incremental(MBOWorkingState& state, const inc::Update& update) {
// apply the update to the working state
MBOWorkingState::Side& collection = (update.type == inc::UpdateType::Bid) ? state.bid : state.ask;
auto key = std::make_tuple(update.price, update.priority);
switch(update.action) {
case inc::UpdateAction::New:
case inc::UpdateAction::Change:
collection[key] = { update.order_id, update.size };
break;
case inc::UpdateAction::Delete:
collection.erase(key);
break;
}
}
//
// Reader
@@ -123,4 +188,4 @@ void MBOReader::release_snapshot(MBOSnapshot**s) const {
_me->pool.release(s);
}
}}
}}
+73 -5
View File
@@ -2,16 +2,20 @@
#include "lib/domain_model/SecurityKey.h"
#include "lib/domain_model/Security.h"
#include "lib/utils/TimeStamp.h"
#include "lib/utils/ValueWrapper.h"
#include "lib/utils/Dispatcher.h"
#include "IntPrice.h"
#include "ExchangeOrderKey.h"
#include "google/btree/btree_map.h"
#include <vector>
#include <memory>
#include <map>
#include <tuple>
namespace bts {
namespace md {
struct SnapshotOrder {
ExchangeOrderKey id;
IntPrice price;
@@ -39,6 +43,59 @@ struct MBOSnapshot {
}
};
namespace inc {
// according to this link MBO book only has these updates types
// https://www.cmegroup.com/confluence/display/EPICSANDBOX/MDP+3.0+-+Market+Data+Snapshot+Full+Refresh#MDP3.0-MarketDataSnapshotFullRefresh-MarketbyOrder(MBO)DataBlock
enum class UpdateType {
Bid, // 0
Ask, // 1
// ImpliedBid, // 'E'
// ImpliedAsk, // 'F'
// BookReset // 'J'
};
// OrderUpdateAction=37708
enum class UpdateAction {
New, //0
Change, //1
Delete //2
};
typedef int64_t Priority;
struct Update {
ExchangeOrderKey order_id;
Priority priority;
IntPrice price;
int32_t size;
UpdateType type;
UpdateAction action;
};
}
struct MBOWorkingState {
typedef std::tuple<IntPrice,inc::Priority> key_t;
struct Data {
ExchangeOrderKey id;
int32_t size;
};
//todo: b-tree this
typedef std::map<key_t,Data> Side;
SecurityKey security;
utils::TimeStamp updated;
Side bid,ask;
};
void copy_to_snapshot(MBOWorkingState& state, MBOSnapshot* destination);
void apply_incremental(MBOWorkingState&, const inc::Update&);
template <class V>
void apply_incremental(MBOWorkingState& state, const V& vec) {
for (const auto& update : vec) {
apply_incremental(state, update);
}
}
struct MBOProcessorImpl;
class MBOProcessor;
@@ -47,16 +104,27 @@ class MBOWriter {
friend class MBOProcessor;
MBOWriter(std::shared_ptr<MBOProcessorImpl>&);
~MBOWriter();
public:
//
// Snapshot api
MBOSnapshot* allocate_snapshot(size_t bid_count=0, size_t ask_count=0);
void publish_snapshot(SecurityKey, MBOSnapshot*);
bool validate_snapshot(SecurityKey, MBOSnapshot*);
MBOSnapshot* allocate_snapshot();
//
// Incremental api
void publish_snapshot(SecurityKey key, MBOSnapshot* snapshot);
// Enqueue the update to the mbo work queue.
void enqueue_incremental(MBOWorkingState&, const inc::Update&);
// Update working state and publish directly.
void apply_incremental(MBOWorkingState&, const inc::Update&);
};
class MBOReader {
std::shared_ptr<MBOProcessorImpl> _me;
friend class MBOProcessor;
friend class MBOWriter;
MBOReader(std::shared_ptr<MBOProcessorImpl>&);
~MBOReader();
public:
@@ -70,7 +138,7 @@ class MBOProcessor {
MBOReader _consumer;
public:
MBOProcessor();
MBOProcessor(utils::Dispatcher* _=nullptr);
MBOWriter& writer();
MBOReader& reader();
};
+131 -1
View File
@@ -1,12 +1,17 @@
#ifndef _WIN32
#include "catch/catch.hpp"
#include "../IntPrice.h"
#include "../MBOProcessor.h"
#include <random>
#include <algorithm>
namespace bts {
namespace md {
namespace test {
int mbo_tests = 0;
TEST_CASE("mbo basic", "[md][mbo]") {
TEST_CASE("MBO publish snapshot", "[md][mbo]") {
MBOProcessor p;
// publish a snapshot
auto sec = SecurityKey(99);
@@ -23,5 +28,130 @@ TEST_CASE("mbo basic", "[md][mbo]") {
REQUIRE(s->asks.size() == 0);
}
std::vector<inc::Update> gen_test_orders(uint64_t id=100, inc::UpdateType type=inc::UpdateType::Bid) {
std::vector<inc::Update> result;
inc::Priority priority = 10000;
for (int p = 100; p < 501; p+=100) {
// 6 sizes
for (int32_t s = 1; s <= 5; ++s) {
IntPrice price { p + 5 , -2};
auto order_id = ExchangeOrderKey(++id);
auto size = s;
priority++;
result.push_back( inc::Update {
order_id,
priority,
price,
size,
type,
inc::UpdateAction::New
});
// std::cout << std::endl << order_id.value() << ": " << price.price() << "-" << size;
}
}
std::random_shuffle(result.begin(), result.end());
return result;
}
TEST_CASE("MBO state to snapshot", "[md][mbo]") {
// convert state to snapshot
MBOWorkingState state;
state.security = SecurityKey(42);
state.updated = utils::TimeStamp::now();
auto bids = gen_test_orders(1000, inc::UpdateType::Bid);
apply_incremental(state, bids);
auto asks = gen_test_orders(2000, inc::UpdateType::Ask);
apply_incremental(state, asks);
MBOSnapshot result;
copy_to_snapshot(state, &result);
REQUIRE(result.updated == state.updated);
REQUIRE(result.bids.size() == state.bid.size());
REQUIRE(result.asks.size() == state.ask.size());
REQUIRE(bids.size() == result.bids.size());
REQUIRE(asks.size() == result.asks.size());
for (size_t x = 0; x < result.bids.size() - 1; ++x) {
// std::cout << std::endl << result.bids[x].id.value() << ": " << result.bids[x].price.price() << "-" << result.bids[x].size;
REQUIRE(result.bids[x].price >= result.bids[x+1].price);
}
for (size_t x = 0; x < result.asks.size() - 1; ++x) {
// std::cout << std::endl << result.asks[x].id.value() << ": " << result.asks[x].price.price() << "-" << result.asks[x].size;
REQUIRE(result.asks[x].price <= result.asks[x+1].price);
}
}
template <class T>
std::vector<T> concat(const std::vector<T>& a, const std::vector<T>& b) {
std::vector<T> res;
std::copy(a.begin(), a.end(), std::back_inserter(res));
std::copy(b.begin(), b.end(), std::back_inserter(res));
return res;
}
TEST_CASE("MBO incremental", "[md][mbo]") {
// basic incremental test
MBOWorkingState state;
auto orders =
concat( gen_test_orders(128, inc::UpdateType::Bid),
gen_test_orders(256, inc::UpdateType::Ask));
std::random_shuffle(orders.begin(), orders.end());
apply_incremental(state, orders);
REQUIRE(state.bid.size() + state.ask.size() == orders.size());
// generate some updates/deletes
std::vector<inc::Update> updates;
// - change all size=2 to size=6
// - delete all size=3
size_t removed = 0;
for (const auto& e : orders) {
if (e.size == 2) {
updates.push_back( inc::Update {
e.order_id,
e.priority,
e.price,
6,
e.type,
inc::UpdateAction::Change
});
}
else if (e.size == 3) {
++removed;
updates.push_back( inc::Update {
e.order_id,
e.priority,
e.price,
e.size,
e.type,
inc::UpdateAction::Delete
});
}
}
apply_incremental(state,updates);
REQUIRE(state.bid.size() + state.ask.size() == (orders.size() - removed));
MBOSnapshot result;
copy_to_snapshot(state, &result);
auto all = concat (result.bids, result.asks);
std::map<int,int> counts;
for (const auto& order : all) {
REQUIRE(order.size != 3);
REQUIRE(order.size != 2);
counts[order.size] ++;
}
REQUIRE(counts[6] > 0);
REQUIRE(counts[6] == counts[1]);
REQUIRE(counts[5] == counts[4]);
REQUIRE(counts[6] == counts[5]);
}
}}}
#endif
+1 -1
View File
@@ -60,7 +60,7 @@ int Run::execute(std::vector<std::string> const &) {
persistence::PersistenceServiceServer settings_saver(sc, "settings");
user::AuthServiceServer login_server(sc);
md::MBOProcessor mbo;
md::MBOProcessor mbo(&utils::Dispatcher::get_named("MBO"));
md::run_market_datapublishers(&mbo.writer());
api::synthetic::SyntheticSecurityService synthetic_service(sc);
@@ -62,16 +62,42 @@ public:
// int qty;
// a.displayQty(qty);
// uint8_t ref;
// a.referenceId(ref);
// const auto& ref_entry = args.message().entries()[(size_t)ref];
// std::cout
// << a.orderId()
// << qty
// << ref_entry.securityId()
// ;
// if (a.referenceId(ref)) {
// const auto& ref_entry = args.message().entries()[(size_t)ref];
// LOG(md,Info, "INCREMENTAL32: {} {} {}",
// a.orderId(),
// qty,
// ref_entry.securityId());
// }
// }
// };
// void onMessage(onixs::Handler&, const onixs::IncrementalRefreshBook46Args&) override {};
void onMessage(onixs::Handler&, const onixs::IncrementalRefreshBook46Args& args) override {
for(const auto& a : args.message().orderIdEntries()) {
int qty;
a.displayQty(qty);
uint8_t ref;
if (a.referenceId(ref)) {
const auto& ref_entry = args.message().entries()[(size_t)ref];
LOG(md,Info, "INCREMENTAL46: {} {} {}",
a.orderId(),
qty,
ref_entry.securityId());
}
}
};
void onMessage(onixs::Handler&, const onixs::SnapshotFullRefreshOrderBook44Args&) override {
if (_mbo) {
LOG(md,Info, "GOT SNAPSHOT44");
}
}
void onMessage(onixs::Handler&, const onixs::SnapshotFullRefreshOrderBook53Args&) override {
if (_mbo) {
LOG(md,Info, "GOT SNAPSHOT53");
}
}
//
@@ -129,7 +129,11 @@ onixs::SessionSettings session_settings_for_channel(const string& channel_id) {
}
if (!options.join_snapshot_on_gap()) {
#ifdef DEBUG
settings.gapAndErrorHandling(onixs::GapAndErrorHandlingOptions::RecoverMarketState);
#else
settings.gapAndErrorHandling(onixs::GapAndErrorHandlingOptions::ContinueProcessing);
#endif
}
if (options.use_natural_refresh()) {
settings.joinRecovery(onixs::JoinRecoveryOptions::Disabled);