#include "MBOProcessor.h" #include "lib/utils/ConcurrentPool.h" #include "lib/config/config.h" #include "lib/config/protos/toggles.pb.h" #include "lib/utils/thread_manager.h" #include #include #include #include #include #include #ifndef _WIN32 #include #endif #include #include namespace bts { namespace md { struct SecurityKeyHashCompare { static size_t hash(const SecurityKey& k) { return k.value(); } static bool equal(const SecurityKey& a, const SecurityKey& b) { return a.value() == b.value(); } }; void print_pool_stats(const utils::ConcurrentPool& pool) { size_t count = 0; std::vector bid_sz,ask_sz; pool.unsafe_iterate([&](const MBOSnapshot& s) { if (s.bids.size() > 0 || s.asks.size() > 0) { count++; bid_sz.push_back(s.bids.size()); ask_sz.push_back(s.asks.size()); } }); if (count == 0) return; std::sort(bid_sz.begin(), bid_sz.end()); std::sort(ask_sz.begin(), ask_sz.end()); size_t bid_tot =0, ask_tot = 0; for(size_t i : bid_sz) { bid_tot += i; } for(size_t i : ask_sz) { ask_tot += i; } std::stringstream bid_percentiles, ask_percentiles; for (double x : { 0.5, 0.75, 0.9, 0.95, 0.99 }) { size_t index = count * x; bid_percentiles << bid_sz[index] << " "; ask_percentiles << ask_sz[index] << " "; } 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: [{}]", count, bid_percentiles.str(), ask_percentiles.str()); } typedef tbb::concurrent_hash_map MapType; struct Incremental { MBOWorkingState* state; inc::Update update; }; struct MBOProcessorImpl { utils::ConcurrentPool pool; tbb::concurrent_queue incremental_input; MapType snapshots; bool running; utils::TimeStamp last_pool_print; std::thread thread; MBOProcessorImpl() : pool(2048,512), snapshots(), running(true), last_pool_print(utils::TimeStamp::invalid()), thread(threading::make_thread("MBO", [=]() { process_incremental(); })) { if (config::get().enabled()) { last_pool_print = utils::TimeStamp::now(); } } ~MBOProcessorImpl() { running = false; thread.join(); } void publish_snapshot(SecurityKey key, MBOSnapshot** snapshot) { bts_assert(*snapshot != nullptr); MapType::accessor accessor; snapshots.insert(accessor, key); std::swap(accessor->second, *snapshot); if (*snapshot != nullptr) { // Note: relase() must happen inside accessor lifetime to ensure correctness pool.release(snapshot); } } void publish_incremental(MBOWorkingState& state) { // determine if we need to publish auto key = SecurityKey(state.handle.key()); if (key.value() != invalid_security_key) { auto snap = pool.allocate(); snap->bids.reserve(state.bid.size()); snap->asks.reserve(state.ask.size()); copy_to_snapshot(state, snap); publish_snapshot(key, &snap); } } void process_incremental() { #ifndef _WIN32 // drain queue and update state // insert changed state pointers into a set // after draining publish the set in small batches // re-check input queue regularly btree::btree_set dirty; std::vector clean; while(running) { Incremental temp; // Drain entire input queue quickly while(incremental_input.try_pop(temp)) { bts_assert_d(temp.state != nullptr); if (temp.state != nullptr) { apply_incremental(*temp.state, temp.update); dirty.insert(temp.state); } } // publish a small batch of snapshots (then check queue again) for (auto iter = dirty.begin(); iter != dirty.end(); ++iter) { publish_incremental(**iter); clean.push_back(*iter); if (clean.size() >= 128) break; } // Remove 'clean' from set for (const auto& iter : clean) { dirty.erase(iter); } clean.clear(); // If the queue is still empty sleep briefly if (incremental_input.empty()) { if (last_pool_print != TimeStamp::invalid()) { auto now = TimeStamp::now(); if ((now - last_pool_print).seconds() > 600) { last_pool_print = now; print_pool_stats(pool); } } std::this_thread::sleep_for( std::chrono::milliseconds(1) ); } } #endif } }; // // Processor MBOProcessor::MBOProcessor() : _me(std::make_shared()), _writer(_me), _reader(_me) { } MBOWriter& MBOProcessor::writer() { return _writer;} MBOReader& MBOProcessor::reader() { return _reader; } // // Writer MBOWriter::MBOWriter(std::shared_ptr& me): _me(me) { } MBOWriter::~MBOWriter() { } MBOSnapshot* MBOWriter::allocate_snapshot(size_t, size_t) { return _me->pool.allocate(); } void MBOWriter::release_snapshot(MBOSnapshot** s) { _me->pool.release(s); } void MBOWriter::publish_snapshot(SecurityKey key, MBOSnapshot** snapshot) { _me->publish_snapshot(key,snapshot); } #if 0 bool MBOWriter::validate_snapshot(uint32_t exchid, SecurityKey key, MBOSnapshot* control) { #define REQUIRE(a,b,y) \ if ((a) != (b)) { \ LOG(md,Error, "Validation error exch:{} sec:{} {}!={} other:{}", exchid, key.value(), a, b, y); \ return false; \ } // retrieve current snapshot and check they are equal _me->dispatcher.post([this,exchid,key,control]() { MBOReader reader(_me); auto snap = reader.acquire_snapshot(key); if (snap) { 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, x); REQUIRE (snap->bids[x].size, control->bids[x].size, x); } for (size_t x = 0; x < snap->asks.size(); ++x) { REQUIRE (snap->asks[x].id, control->asks[x].id, x); REQUIRE (snap->asks[x].size, control->asks[x].size, x); } } return true; }); #undef REQUIRE return true; } #endif void MBOWriter::enqueue_incremental(MBOWorkingState& state, const inc::Update& update) { LOG(md,Diag, "sec:{} : {}", state.handle.key(), update); _me->incremental_input.push({&state, update}); } 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(pair.first), pair.second.size }; }; std::transform(state.bid.begin(), state.bid.end(), std::back_inserter(dest->bids), type_map); std::transform(state.ask.begin(), state.ask.end(), std::back_inserter(dest->asks), type_map); } template void apply_incremental(uint32_t security_key, C& collection, std::unordered_map& index, const inc::Update& update) { auto key = std::make_tuple(update.price, update.priority); switch(update.action) { case inc::UpdateAction::New: collection.insert(std::make_pair(key, MBOWorkingState::Data { update.order_id, update.size })); index[update.order_id] = key; break; case inc::UpdateAction::Change: { // look up old key auto r = index.find(update.order_id); if (r != index.end()) { auto oldkey = r->second; collection.erase(oldkey); index.erase(r); } else { LOG(md,Warn, "MBO Update w/out Add for: sec:{} {}", security_key, update); } collection.insert(std::make_pair(key, MBOWorkingState::Data { update.order_id, update.size })); index[update.order_id] = key; } break; case inc::UpdateAction::Delete: collection.erase(key); index.erase(update.order_id); break; } } void apply_incremental(MBOWorkingState& state, const inc::Update& update) { // apply the update to the working state if (update.type == inc::UpdateType::Bid) { apply_incremental(state.handle.key(), state.bid, state.orderid_index, update); } else { apply_incremental(state.handle.key(),state.ask, state.orderid_index, update); } } // // Reader MBOReader::MBOReader(std::shared_ptr& me): _me(me) { } MBOReader::~MBOReader() { } MBOSnapshot* MBOReader::acquire_snapshot(SecurityKey key) const { // get a result eagerly so we don't have to do it while accessor has the entry locked auto result = _me->pool.allocate(); MapType::const_accessor accessor; if (_me->snapshots.find(accessor, key) && accessor->second != nullptr) { result->copy_from(*accessor->second); } else { release_snapshot(&result); } return result; } void MBOReader::release_snapshot(MBOSnapshot**s) const { _me->pool.release(s); } }} namespace std { using namespace bts; using namespace bts::md; ostream& operator<<(ostream& os, const inc::Update& update) { os << "Update: { " << "id:" << update.order_id.value() << " " << "pri:" << update.priority << " " << update.price.price() << " " << update.size << " "; switch(update.type) { case inc::UpdateType::Bid: os << "B "; break; case inc::UpdateType::Ask: os << "A "; break; } switch(update.action) { case inc::UpdateAction::New: os << "+"; break; case inc::UpdateAction::Change: os << "C"; break; case inc::UpdateAction::Delete: os << "-"; break; } os << "}"; return os; } }