From 6c0cc76773881b8729ade9f2bbbaa7de19004e4b Mon Sep 17 00:00:00 2001 From: Pedro Pinto Date: Sun, 4 Nov 2018 22:14:14 +0000 Subject: [PATCH] Significantly improved engine performance when updating multiple orders. --- .../actors/order_manager/OrderManager.cpp | 160 +++++--- .../actors/order_manager/OrderManager.h | 33 +- .../actors/order_manager/OrderServices.h | 71 ++-- .../order_manager/OrderServicesData.cpp | 2 +- .../actors/order_manager/OrderServicesData.h | 11 +- src/lib/orderman/events/OutFIXMsgEvent.h | 6 +- src/lib/orderman/orders/NativeOrder.cpp | 61 +-- src/lib/orderman/orders/NativeOrder.h | 1 + src/lib/orderman/perf_analysis/load_data.py | 14 +- .../orderman/server/OrderServiceServer.cpp | 2 +- src/lib/utils/inplace_function.h | 361 ++++++++++++++++++ src/server/sparkd/cmds/Benchmark.cpp | 57 ++- 12 files changed, 628 insertions(+), 151 deletions(-) create mode 100644 src/lib/utils/inplace_function.h diff --git a/src/lib/orderman/actors/order_manager/OrderManager.cpp b/src/lib/orderman/actors/order_manager/OrderManager.cpp index 176dd1246..3338b7cf0 100644 --- a/src/lib/orderman/actors/order_manager/OrderManager.cpp +++ b/src/lib/orderman/actors/order_manager/OrderManager.cpp @@ -11,7 +11,9 @@ #include "lib/orderman/order_factory/OrderFactory.h" #include "lib/orderman/orders/Order.h" #include "lib/orderman/securities/ISecurityDB.h" +#include "lib/utils/inplace_function.h" +#include #include namespace bts { @@ -40,10 +42,15 @@ struct OrderManager::OrderInfo { }; struct OrderManager::PImpl { - PImpl(Actor &owner) : state(State::WAIT_ADMIN), services_data(owner) {} + PImpl(OrderManager &owner) : state(State::WAIT_ADMIN), services_data(owner) { + pending_order_events.reserve(1000); + } State state; std::unordered_map orders; + + std::vector pending_order_events; + mercury::Actor::SubHandle stored_order_sub; mercury::Actor::SubHandle stored_fills_sub; OrderServicesData services_data; @@ -192,66 +199,82 @@ void OrderManager::on_execution_report( } } +void OrderManager::queue_order_event(PendingOrderEvent const &event_handler) { + me->pending_order_events.push_back(event_handler); +} + void OrderManager::on_activate_order( const mercury::Update &m) { if (m.events) - for (auto const &ev : *m.events) { - auto order = ev.order; - auto k = order->key(); - bts_assert(me->orders.find(k) == me->orders.end()); - OrderInfo oi{*order, me->services_data}; - auto serv_ptr = oi.order_services.get(); - me->orders[k] = std::move(oi); - order->on_activate(ev.price, ev.quantity, *serv_ptr, ev.trace); - } + for (auto const &ev : *m.events) + queue_order_event(ev); +} + +void OrderManager::handle_order_event(ActivateOrderEvent const &ev) { + auto order = ev.order; + auto k = order->key(); + bts_assert(me->orders.find(k) == me->orders.end()); + OrderInfo oi{*order, me->services_data}; + auto serv_ptr = oi.order_services.get(); + me->orders[k] = std::move(oi); + order->on_activate(ev.price, ev.quantity, *serv_ptr, ev.trace); } void OrderManager::on_update_order(const mercury::Update &m) { if (m.events) - for (auto const &ev : *m.events) { - auto k = ev.key(); - auto it = me->orders.find(k); - if (it != me->orders.end()) - it->second.order->on_update(ev.price, ev.quantity, ev.trace); - else { - LOG(OrderMan, Error, - "Received an update request for an unknown order {}. " - "This should not happen and likely indicates a serious bug. ", - ev.key().value()); - } - } + for (auto const &ev : *m.events) + queue_order_event(ev); +} + +void OrderManager::handle_order_event(UpdateOrderEvent const &ev) { + auto k = ev.key(); + auto it = me->orders.find(k); + if (it != me->orders.end()) + it->second.order->on_update(ev.price, ev.quantity, ev.trace); + else { + LOG(OrderMan, Error, + "Received an update request for an unknown order {}. " + "This should not happen and likely indicates a serious bug. ", + ev.key().value()); + } } void OrderManager::on_cancel_order(const mercury::Update &m) { if (m.events) - for (auto const &ev : *m.events) { - auto k = ev.key(); - auto it = me->orders.find(k); - if (it != me->orders.end()) - it->second.order->on_cancel(ev.trace); - else { - LOG(OrderMan, Error, - "Received a cancel request for an unknown order {}. " - "This should not happen and likely indicates a serious bug. ", - ev.key().value()); - } - } + for (auto const &ev : *m.events) + queue_order_event(ev); +} + +void OrderManager::handle_order_event(CancelOrderEvent const &ev) { + auto k = ev.key(); + auto it = me->orders.find(k); + if (it != me->orders.end()) + it->second.order->on_cancel(ev.trace); + else { + LOG(OrderMan, Error, + "Received a cancel request for an unknown order {}. " + "This should not happen and likely indicates a serious bug. ", + ev.key().value()); + } } void OrderManager::on_crack_order(const mercury::Update &m) { if (m.events) - for (auto const &ev : *m.events) { - auto k = ev.key(); - auto it = me->orders.find(k); - if (it != me->orders.end()) - it->second.order->on_crack(ev.trace); - else { - LOG(OrderMan, Error, - "Received a crack request for an unknown order {}. " - "This should not happen and likely indicates a serious bug. ", - ev.key().value()); - } - } + for (auto const &ev : *m.events) + queue_order_event(ev); +} + +void OrderManager::handle_order_event(CrackOrderEvent const &ev) { + auto k = ev.key(); + auto it = me->orders.find(k); + if (it != me->orders.end()) + it->second.order->on_crack(ev.trace); + else { + LOG(OrderMan, Error, + "Received a crack request for an unknown order {}. " + "This should not happen and likely indicates a serious bug. ", + ev.key().value()); + } } void OrderManager::on_gateway_state( @@ -276,6 +299,13 @@ void OrderManager::on_timer(const mercury::Update &m) { if (m.events) for (auto ev : *m.events) me->services_data.last_timer_ev = ev; + + for (auto &osd : me->services_data.sessions) { + if (fix_buffer_pool_size > osd->free_buffers.size()) { + auto need = fix_buffer_pool_size - osd->free_buffers.size(); + publish(me->services_data.create_fix_req_pub, need, osd->cfg); + } + } } std::vector & @@ -338,6 +368,7 @@ void OrderManager::init_order_services() { // FIX output s->out_fix_pub = make_stream(gw_name); + reload_fix_buffer(*s); } // Order creation and maintenance @@ -359,7 +390,6 @@ void OrderManager::init_order_services() { [this](auto const &ev) { this->on_new_fix_buffer(ev); }); // Outputs - me->services_data.order_state_pub = make_stream(); me->services_data.activate_order_pub = make_stream(); me->services_data.update_order_pub = make_stream(); me->services_data.cancel_order_pub = make_stream(); @@ -370,7 +400,8 @@ void OrderManager::init_order_services() { me->services_data.create_fix_req_pub = make_stream(); me->services_data.md_request_pub = make_stream(); - me->services_data.settlement_request_pub= make_stream(); + me->services_data.settlement_request_pub = + make_stream(); me->services_data.report_order_state_pub = make_stream(); me->pub_ready = make_stream(); @@ -389,12 +420,43 @@ void OrderManager::init_order_services() { me->services_data.md_subs = std::make_unique>(*this, on_md_sub); me->services_data.settlement_subs = - std::make_unique>(*this,on_settlement_sub); + std::make_unique>( + *this, on_settlement_sub); me->services_data.time_subs = std::make_unique>(*this); me->services_data.order_creation_subs = std::make_unique>(*this); } +void OrderManager::on_poll() { + if (me->state == State::READY) { + for (size_t i = 0; i < me->pending_order_events.size(); i++) + me->pending_order_events[i](*this); + me->pending_order_events.clear(); + for (auto &osd : me->services_data.sessions) { + auto &fix_stream = osd->current_buffer->first_stream(); + if (fix_stream.n_msgs()) { + fix_stream.close(); + publish(osd->out_fix_pub, osd->current_buffer, osd->current_traces); + osd->current_traces.clear(); + reload_fix_buffer(*osd); + } + } + } +} + +void OrderManager::reload_fix_buffer(SessionServicesData &dt) { + if (dt.free_buffers.size()) { + dt.current_buffer = dt.free_buffers.back(); + dt.free_buffers.pop_back(); + } else { + LOG(OrderMan, Warn, + "Ran out of fix buffers in {}. Will allocate directly. " + "This will have an impact on performance", + dt.cfg.name()); + dt.current_buffer = std::make_shared(dt.cfg); + } +} + } // namespace orderman } // namespace bts diff --git a/src/lib/orderman/actors/order_manager/OrderManager.h b/src/lib/orderman/actors/order_manager/OrderManager.h index 78981cf34..8ef2f29e4 100644 --- a/src/lib/orderman/actors/order_manager/OrderManager.h +++ b/src/lib/orderman/actors/order_manager/OrderManager.h @@ -3,6 +3,13 @@ #include "lib/config/protos/jetfix.pb.h" #include "lib/jetfix/common/OutFIXPtr.h" #include "lib/mercury/actors/Actor.h" +#include "lib/mercury/actors/IPollableActor.h" +#include "lib/utils/inplace_function.h" +#include "lib/orderman/events/ActivateOrderEvent.h" +#include "lib/orderman/events/UpdateOrderEvent.h" +#include "lib/orderman/events/CancelOrderEvent.h" +#include "lib/orderman/events/CrackOrderEvent.h" + #include // fwd @@ -22,6 +29,7 @@ class StoredFillEvent; class CreateFIXBufferReplyEvent; class GatewayStatusChangeEvent; class NewAdminDataEvent; +struct SessionServicesData; } } @@ -49,13 +57,16 @@ namespace orderman { // - crack // - update -class OrderManager : public mercury::Actor { +class OrderManager : public mercury::Actor, + public mercury::IPollableActor +{ public: OrderManager(); ~OrderManager(); void init() override; private: + friend class OrderServices; void on_securities(const mercury::Update &); void on_fill_recovery(const mercury::Update &); void on_order_recovery(const mercury::Update &); @@ -70,6 +81,26 @@ class OrderManager : public mercury::Actor { void on_admin_data(const mercury::Update &); void init_order_services(); + + void on_poll() override; + + using PendingOrderEvent = stdext::inplace_function< + void(OrderManager &), + std::max({128ul, sizeof(ActivateOrderEvent), sizeof(UpdateOrderEvent), + sizeof(CancelOrderEvent), sizeof(CrackOrderEvent)})>; + + template + void queue_order_event(EV const&ev) { + queue_order_event(PendingOrderEvent( [ev] (auto &om) { + om.handle_order_event(ev); + })); + } + void queue_order_event(PendingOrderEvent const&ev); + void handle_order_event(ActivateOrderEvent const &); + void handle_order_event(UpdateOrderEvent const &); + void handle_order_event(CancelOrderEvent const &); + void handle_order_event(CrackOrderEvent const&); + void reload_fix_buffer(SessionServicesData &dt); std::vector &free_buffers(std::string const&); enum class State; diff --git a/src/lib/orderman/actors/order_manager/OrderServices.h b/src/lib/orderman/actors/order_manager/OrderServices.h index 4e50f804f..ac5826b57 100644 --- a/src/lib/orderman/actors/order_manager/OrderServices.h +++ b/src/lib/orderman/actors/order_manager/OrderServices.h @@ -3,10 +3,12 @@ #include "lib/api/services/OrderService.pb.h" #include "lib/jetfix/common/OutFIX.h" #include "lib/logging/logging.h" +#include "lib/orderman/actors/order_manager/OrderManager.h" #include "lib/orderman/actors/order_manager/OrderServicesData.h" #include "lib/orderman/governor/Governor.h" #include "lib/orderman/orderman_utils/EventStream.h" #include "lib/orderman/orders/Order.h" + #include namespace bts { @@ -15,69 +17,44 @@ namespace orderman { class SessionServices { public: - SessionServices(SessionServicesData &session_data, OrderServicesData &data) + SessionServices(SessionServicesData &session_data) : exe_reports(*session_data.exe_report_subs), cancel_rejects(*session_data.cancel_reject_subs), gateway_status(*session_data.gateway_status_subs), - _session_data(&session_data), _data(&data) {} + _session_data(&session_data) {} std::string const &session_name() const { return _session_data->session; } + config::JetFIX::Connection const &session_cfg() const { return _session_data->cfg; } - jetfix::OutFIXPtr get_fix_buffer() { - jetfix::OutFIXPtr result; - if (_session_data->free_buffers.size()) { - result = _session_data->free_buffers.back(); - _session_data->free_buffers.pop_back(); - } else { - LOG(OrderMan, Warn, - "Ran out of fix buffers in {}. Will allocate directly. " - "This will have an impact on performance", - _session_data->cfg.name()); - result = std::make_shared(_session_data->cfg); - } - return result; - } - - void refill_fix_buffer_pool() - { - if (fix_buffer_pool_size > _session_data->free_buffers.size()) { - auto need = fix_buffer_pool_size - _session_data->free_buffers.size(); - _data->owner.publish(_data->create_fix_req_pub, need, - _session_data->cfg); - } + void queue_fix(jetfix::MessageTypes mt, jetfix::FIXFragment const&f,PerfTrace const&trace) { + auto &stream = _session_data->current_buffer->first_stream(); + stream.new_msg(mt).append(f); + _session_data->current_traces.push_back(trace); } bool is_gateway_connected() const { return _session_data->gw_connected; } - - void send_fix_buffer(jetfix::OutFIXPtr const &fix, PerfTrace &trace) { - trace.send_fix_buffer = utils::TimeStamp::now(); - _data->owner.publish(_session_data->out_fix_pub, trace, fix); - } + Governor &governor() { return _session_data->governor; } EventStream exe_reports; EventStream cancel_rejects; EventStream gateway_status; - Governor &governor() { return _session_data->governor; } private: SessionServicesData *_session_data; - OrderServicesData *_data; }; class OrderServices { public: OrderServices(Order &owner, OrderServicesData &data) - : book_updates(*data.md_subs), - settlement_updates(*data.settlement_subs), - child_updates(*data.child_order_subs), - time_change(*data.time_subs), + : book_updates(*data.md_subs), settlement_updates(*data.settlement_subs), + child_updates(*data.child_order_subs), time_change(*data.time_subs), order_creations(*data.order_creation_subs), _owner(owner), _data(data), _sessions() { for (auto &sd : data.sessions) - _sessions.push_back(std::make_unique(*sd, data)); + _sessions.push_back(std::make_unique(*sd)); } EventStream book_updates; @@ -119,7 +96,7 @@ class OrderServices { bts_assert(false); } - void schedule_action(std::function const&action) { + void schedule_action(std::function const &action) { _data.owner.schedule_action(action); } @@ -136,29 +113,33 @@ class OrderServices { } friend class ChildOrder; + + template void queue_order_op(const OP &op) { + _data.owner.queue_order_event(op); + } void send_activate(Order &o, Price p, Quantity q, PerfTrace const &trace) { - _data.owner.publish(_data.activate_order_pub, o, p, q, trace); + queue_order_op(ActivateOrderEvent{o, p, q, trace}); } void send_activate(Order &o, Price p, Quantity q) { - _data.owner.publish(_data.activate_order_pub, o, p, q, PerfTrace()); + queue_order_op(ActivateOrderEvent{o, p, q, PerfTrace()}); } void send_update(OrderKey k, Price p, Quantity q, PerfTrace const &trace) { - _data.owner.publish(_data.update_order_pub, k, p, q, trace); + queue_order_op(UpdateOrderEvent{k, p, q, trace}); } void send_update(OrderKey k, Price p, Quantity q) { - _data.owner.publish(_data.update_order_pub, k, p, q, PerfTrace()); + queue_order_op(UpdateOrderEvent{k, p, q, PerfTrace()}); } void send_crack(OrderKey k, PerfTrace const &trace) { - _data.owner.publish(_data.crack_order_pub, k, trace); + queue_order_op(CrackOrderEvent{k, trace}); } void send_crack(OrderKey k) { - _data.owner.publish(_data.crack_order_pub, k, PerfTrace()); + queue_order_op(CrackOrderEvent{k, PerfTrace()}); } void send_cancel(OrderKey k, PerfTrace const &trace) { - _data.owner.publish(_data.cancel_order_pub, k, trace); + queue_order_op(CancelOrderEvent{k, trace}); } void send_cancel(OrderKey k) { - _data.owner.publish(_data.cancel_order_pub, k, PerfTrace()); + queue_order_op(CancelOrderEvent{k, PerfTrace()}); } Order &_owner; diff --git a/src/lib/orderman/actors/order_manager/OrderServicesData.cpp b/src/lib/orderman/actors/order_manager/OrderServicesData.cpp index b868f5ced..f074d502a 100644 --- a/src/lib/orderman/actors/order_manager/OrderServicesData.cpp +++ b/src/lib/orderman/actors/order_manager/OrderServicesData.cpp @@ -5,7 +5,7 @@ namespace bts { namespace orderman { -OrderServicesData::OrderServicesData(mercury::Actor &owner) +OrderServicesData::OrderServicesData(OrderManager &owner) : owner(owner), order_router(), order_factory(sec_db, order_router), last_timer_ev( Timer::now(), diff --git a/src/lib/orderman/actors/order_manager/OrderServicesData.h b/src/lib/orderman/actors/order_manager/OrderServicesData.h index 07b10bf53..13748a639 100644 --- a/src/lib/orderman/actors/order_manager/OrderServicesData.h +++ b/src/lib/orderman/actors/order_manager/OrderServicesData.h @@ -35,6 +35,7 @@ namespace bts { namespace orderman { +class OrderManager; struct ParentKey { OrderKey operator()(const OrderStateUpdateEvent &ev) { @@ -49,7 +50,9 @@ struct SessionServicesData { cfg(cfg), governor(cfg.max_order_msgs_per_window(), cfg.window_duration_msecs()) - {} + { + current_traces.reserve(1000); + } std::string session; std::vector free_buffers; @@ -65,12 +68,14 @@ struct SessionServicesData { gateway_status_subs; Governor governor; + jetfix::OutFIXPtr current_buffer; + std::vector current_traces; }; class OrderServicesData { public: - OrderServicesData(mercury::Actor &owner); - mercury::Actor &owner; + OrderServicesData(OrderManager &owner); + OrderManager &owner; securities::MapSecurityDB sec_db; OrderRouter order_router; Limiter limiter; diff --git a/src/lib/orderman/events/OutFIXMsgEvent.h b/src/lib/orderman/events/OutFIXMsgEvent.h index dd483643c..5b0556fba 100644 --- a/src/lib/orderman/events/OutFIXMsgEvent.h +++ b/src/lib/orderman/events/OutFIXMsgEvent.h @@ -21,12 +21,12 @@ public: // missed. using SynopsisPolicy = mercury::NoSynopsis; - OutFIXMsgEvent (PerfTrace trace, jetfix::OutFIXPtr const&fix) : - trace(trace), msg(fix) + OutFIXMsgEvent (jetfix::OutFIXPtr const&fix,std::vector const&traces) : + msg(fix),trace(traces[0]) {} + jetfix::OutFIXPtr msg; PerfTrace trace; - jetfix::OutFIXPtr msg; }; }} diff --git a/src/lib/orderman/orders/NativeOrder.cpp b/src/lib/orderman/orders/NativeOrder.cpp index be637b6d4..e9aa82549 100644 --- a/src/lib/orderman/orders/NativeOrder.cpp +++ b/src/lib/orderman/orders/NativeOrder.cpp @@ -384,18 +384,9 @@ void NativeOrder::on_activate(Price p, Quantity q, auto const &ts = services.get_time_str(); me->create_transact_time_bm = encoding.overwrite( me->create_transact_time_bm, &ts.value()[0], ts.value().size()); - auto buffer = me->session_services->get_fix_buffer(); - auto &stream = buffer->fix[0]; - auto &f = stream.new_msg(jetfix::MessageTypes::NewOrderSingle); - f.append(me->create_encoding); - stream.close(); - - // Send it - me->session_services->send_fix_buffer(buffer, trace); - - // post send book keeping + me->session_services->queue_fix(jetfix::MessageTypes::NewOrderSingle, + me->create_encoding, trace); me->session_services->governor().record_sent(); - me->session_services->refill_fix_buffer_pool(); me->state.set_status(ORDER_STATUS_PENDING_WORKING); LOG(OrderMan, Info, "Sent new order with key {} to gateway", @@ -532,31 +523,14 @@ void NativeOrder::on_update(Price p, Quantity q, PerfTrace const &t) { auto const &ts = me->services->get_time_str(); me->update_transact_time_bm = encoding.overwrite( me->update_transact_time_bm, &ts.value()[0], ts.value().size()); - auto buffer = me->session_services->get_fix_buffer(); - auto &stream = buffer->fix[0]; - tracepoint(bts_trace, trace_order, (char *)"on_update.before_new_msg", 0, - trace.md_sn, trace.order_key); - auto &f = stream.new_msg(jetfix::MessageTypes::CancelReplace); - f.append(me->update_encoding); - stream.close(); - // send it - tracepoint(bts_trace, trace_order, (char *)"on_update.before_send_fix", 0, - trace.md_sn, trace.order_key); - me->session_services->send_fix_buffer(buffer, trace); + me->session_services->queue_fix(jetfix::MessageTypes::CancelReplace, + me->update_encoding, trace); + me->session_services->governor().record_sent(); - tracepoint(bts_trace, trace_order, (char *)"on_update.end", 0, - trace.md_sn, trace.order_key); - // post send book keeping - - // these are slow and we need to return out of this handler so - // that we can process the fix - me->services->schedule_action([this]() { - me->session_services->refill_fix_buffer_pool(); - if (me->state.last_msg().size()) - me->state.set_last_msg(""); - report_state(); - }); + update_working_position(); + if (me->state.last_msg().size()) + me->state.set_last_msg(""); // early return so we skip report_state (for speed) return; @@ -590,16 +564,10 @@ void NativeOrder::on_cancel(PerfTrace const &trace) { auto const &ts = me->services->get_time_str(); me->cancel_transact_time_bm = encoding.overwrite( me->cancel_transact_time_bm, &ts.value()[0], ts.value().size()); - auto buffer = me->session_services->get_fix_buffer(); - auto &stream = buffer->fix[0]; - auto &f = stream.new_msg(jetfix::MessageTypes::Cancel); - f.append(me->cancel_encoding); - stream.close(); - auto trace_cpy = trace; - me->session_services->send_fix_buffer(buffer, trace_cpy); - // post send book keeping - me->session_services->refill_fix_buffer_pool(); + me->session_services->queue_fix(jetfix::MessageTypes::Cancel, + me->cancel_encoding, trace); + break; } @@ -807,7 +775,7 @@ void NativeOrder::on_gateway_status(const GatewayStatusChangeEvent &ev) { report_state(); } -void NativeOrder::report_state(PerfTrace const &trace) { +void NativeOrder::update_working_position() { if (me->sec) { auto current_position = position_contribution(); auto previous_position = me->previous_position_contribution; @@ -828,7 +796,10 @@ void NativeOrder::report_state(PerfTrace const &trace) { "Order {} ignored for purposes of limit enforcing " "because it references unknown security {} ", key().value(), me->definition.security_key()); +} +void NativeOrder::report_state(PerfTrace const &trace) { + update_working_position(); me->services->report_state(me->state, trace); } @@ -1043,7 +1014,7 @@ void NativeOrder::transition(api::orderman::OrderStatus new_status) { else LOG(OrderMan, Diag, "Transitioning order {} from {} to {}", key().value(), from, to); - + me->state.set_status(new_status); } diff --git a/src/lib/orderman/orders/NativeOrder.h b/src/lib/orderman/orders/NativeOrder.h index 93cefe450..d1b52279c 100644 --- a/src/lib/orderman/orders/NativeOrder.h +++ b/src/lib/orderman/orders/NativeOrder.h @@ -46,6 +46,7 @@ private: void transition_to_error(api::orderman::NativeOrderState::SubError sub_error, std::string const&msg); + void update_working_position(); bool has_exchange_order_id() ; Quantity position_contribution(); bool is_old_exe_report( api::orderman::NativeOrderState &, const NewExecutionReportEvent &) const; diff --git a/src/lib/orderman/perf_analysis/load_data.py b/src/lib/orderman/perf_analysis/load_data.py index de32152ee..3e3f9130e 100755 --- a/src/lib/orderman/perf_analysis/load_data.py +++ b/src/lib/orderman/perf_analysis/load_data.py @@ -3,6 +3,9 @@ import pandas as pd import sqlite3 import dateutil +import matplotlib.pyplot as plt +import numpy as np + from pathlib import Path # dt = dateutil.parser.parse('2018-10-23 16:35:01.566000') @@ -13,11 +16,13 @@ from pathlib import Path requotes = None db_path = "%s/sparkdata/data/databases/perf_trace/perf_trace.sqlite" % str(Path.home()) c = sqlite3.connect(db_path,uri = True) +raw_data = None def load(): - raw_data = pd.read_sql_query("select * from trace;", c) + global raw_data global requotes + raw_data = pd.read_sql_query("select * from trace;", c) requotes = raw_data[(raw_data.order_update>0) ] requotes = requotes.assign (total = (requotes.fix_socket_w - requotes.md) / 1000) requotes = requotes.assign (md = (requotes.spreader_on_book - requotes.md) / 1000) @@ -38,6 +43,13 @@ def load(): summary() requotes +def plot(n): + plt.clf() + p = requotes[-n:][['trace_time','total']] + q = p.set_index('trace_time') + plt.plot(q) + + def summary(): grouped = requotes.groupby(requotes['session_start']) counts = grouped.count()['total'] diff --git a/src/lib/orderman/server/OrderServiceServer.cpp b/src/lib/orderman/server/OrderServiceServer.cpp index a7fdb9853..5c06f88b1 100644 --- a/src/lib/orderman/server/OrderServiceServer.cpp +++ b/src/lib/orderman/server/OrderServiceServer.cpp @@ -20,7 +20,7 @@ #include "lib/utils/bts_chrono.h" #include "lib/utils/thread_manager.h" #include "lib/utils/type_name.h" - + #include namespace bts { diff --git a/src/lib/utils/inplace_function.h b/src/lib/utils/inplace_function.h new file mode 100644 index 000000000..40677f74f --- /dev/null +++ b/src/lib/utils/inplace_function.h @@ -0,0 +1,361 @@ +/* + * Boost Software License - Version 1.0 - August 17th, 2003 + * + * Permission is hereby granted, free of charge, to any person or organization + * obtaining a copy of the software and accompanying documentation covered by + * this license (the "Software") to use, reproduce, display, distribute, + * execute, and transmit the Software, and to prepare derivative works of the + * Software, and to permit third-parties to whom the Software is furnished to + * do so, all subject to the following: + * + * The copyright notices in the Software and this entire statement, including + * the above license grant, this restriction and the following disclaimer, + * must be included in all copies of the Software, in whole or in part, and + * all derivative works of the Software, unless such copies or derivative + * works are solely in the form of machine-executable object code generated by + * a source language processor. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT + * SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE + * FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + */ + +#pragma once + +#include +#include +#include + +namespace stdext { + +namespace inplace_function_detail { + +static constexpr size_t InplaceFunctionDefaultCapacity = 32; + +#if defined(__GLIBCXX__) // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=61458 +template +union aligned_storage_helper { + struct double1 { double a; }; + struct double4 { double a[4]; }; + template using maybe = std::conditional_t<(Cap >= sizeof(T)), T, char>; + char real_data[Cap]; + maybe a; + maybe b; + maybe c; + maybe d; + maybe e; + maybe f; + maybe g; + maybe h; +}; + +template>::value> +struct aligned_storage { + using type = std::aligned_storage_t; +}; + +template>::value> +using aligned_storage_t = typename aligned_storage::type; +#else +using std::aligned_storage; +using std::aligned_storage_t; +#endif + +template struct wrapper +{ + using type = T; +}; + +template struct vtable +{ + using storage_ptr_t = void*; + + using invoke_ptr_t = R(*)(storage_ptr_t, Args&&...); + using process_ptr_t = void(*)(storage_ptr_t, storage_ptr_t); + using destructor_ptr_t = void(*)(storage_ptr_t); + + const invoke_ptr_t invoke_ptr; + const process_ptr_t copy_ptr; + const process_ptr_t relocate_ptr; + const destructor_ptr_t destructor_ptr; + + explicit constexpr vtable() noexcept : + invoke_ptr{ [](storage_ptr_t, Args&&...) -> R + { throw std::bad_function_call(); } + }, + copy_ptr{ [](storage_ptr_t, storage_ptr_t) noexcept -> void {} }, + relocate_ptr{ [](storage_ptr_t, storage_ptr_t) noexcept -> void {} }, + destructor_ptr{ [](storage_ptr_t) noexcept -> void {} } + {} + + template explicit constexpr vtable(wrapper) noexcept : + invoke_ptr{ [](storage_ptr_t storage_ptr, Args&&... args) + noexcept(noexcept(std::declval()(args...))) -> R + { return (*static_cast(storage_ptr))( + std::forward(args)... + ); } + }, + copy_ptr{ [](storage_ptr_t dst_ptr, storage_ptr_t src_ptr) + noexcept(std::is_nothrow_copy_constructible::value) -> void + { ::new (dst_ptr) C{ (*static_cast(src_ptr)) }; } + }, + relocate_ptr{ [](storage_ptr_t dst_ptr, storage_ptr_t src_ptr) + noexcept(std::is_nothrow_move_constructible::value) -> void + { + ::new (dst_ptr) C{ std::move(*static_cast(src_ptr)) }; + static_cast(src_ptr)->~C(); + } + }, + destructor_ptr{ [](storage_ptr_t src_ptr) + noexcept -> void + { static_cast(src_ptr)->~C(); } + } + {} + + vtable(const vtable&) = delete; + vtable(vtable&&) = delete; + + vtable& operator= (const vtable&) = delete; + vtable& operator= (vtable&&) = delete; + + ~vtable() = default; +}; + +template +#if __cplusplus >= 201703L +inline constexpr +#endif +vtable empty_vtable{}; + +template +struct is_valid_inplace_dst : std::true_type +{ + static_assert(DstCap >= SrcCap, + "Can't squeeze larger inplace_function into a smaller one" + ); + + static_assert(DstAlign % SrcAlign == 0, + "Incompatible inplace_function alignments" + ); +}; + +} // namespace inplace_function_detail + +template< + typename Signature, + size_t Capacity = inplace_function_detail::InplaceFunctionDefaultCapacity, + size_t Alignment = std::alignment_of>::value +> +class inplace_function; // unspecified + +template< + typename R, + typename... Args, + size_t Capacity, + size_t Alignment +> +class inplace_function +{ +public: + using capacity = std::integral_constant; + using alignment = std::integral_constant; + + using storage_t = inplace_function_detail::aligned_storage_t; + using vtable_t = inplace_function_detail::vtable; + using vtable_ptr_t = const vtable_t*; + + template friend class inplace_function; + + inplace_function() noexcept : + vtable_ptr_{std::addressof(inplace_function_detail::empty_vtable)} + {} + + template< + typename T, + typename C = std::decay_t, + typename = std::enable_if_t< + !(std::is_same::value + || std::is_convertible::value) + > + > + inplace_function(T&& closure) + { +#if __cplusplus >= 201703L + static_assert(std::is_invocable_r::value, + "inplace_function cannot be constructed from non-callable type" + ); +#endif + static_assert(std::is_copy_constructible::value, + "inplace_function cannot be constructed from non-copyable type" + ); + + static_assert(sizeof(C) <= Capacity, + "inplace_function cannot be constructed from object with this (large) size" + ); + + static_assert(Alignment % std::alignment_of::value == 0, + "inplace_function cannot be constructed from object with this (large) alignment" + ); + + static const vtable_t vt{inplace_function_detail::wrapper{}}; + vtable_ptr_ = std::addressof(vt); + + ::new (std::addressof(storage_)) C{std::forward(closure)}; + } + + inplace_function(std::nullptr_t) noexcept : + vtable_ptr_{std::addressof(inplace_function_detail::empty_vtable)} + {} + + inplace_function(const inplace_function& other) : + vtable_ptr_{other.vtable_ptr_} + { + vtable_ptr_->copy_ptr( + std::addressof(storage_), + std::addressof(other.storage_) + ); + } + + inplace_function(inplace_function&& other) : + vtable_ptr_{std::exchange(other.vtable_ptr_, std::addressof(inplace_function_detail::empty_vtable))} + { + vtable_ptr_->relocate_ptr( + std::addressof(storage_), + std::addressof(other.storage_) + ); + } + + inplace_function& operator= (std::nullptr_t) noexcept + { + vtable_ptr_->destructor_ptr(std::addressof(storage_)); + vtable_ptr_ = std::addressof(inplace_function_detail::empty_vtable); + return *this; + } + + inplace_function& operator= (const inplace_function& other) + { + if(this != std::addressof(other)) + { + vtable_ptr_->destructor_ptr(std::addressof(storage_)); + + vtable_ptr_ = other.vtable_ptr_; + vtable_ptr_->copy_ptr( + std::addressof(storage_), + std::addressof(other.storage_) + ); + } + return *this; + } + + inplace_function& operator= (inplace_function&& other) + { + if(this != std::addressof(other)) + { + vtable_ptr_->destructor_ptr(std::addressof(storage_)); + + vtable_ptr_ = std::exchange(other.vtable_ptr_, std::addressof(inplace_function_detail::empty_vtable)); + vtable_ptr_->relocate_ptr( + std::addressof(storage_), + std::addressof(other.storage_) + ); + } + return *this; + } + + ~inplace_function() + { + vtable_ptr_->destructor_ptr(std::addressof(storage_)); + } + + R operator() (Args... args) const + { + return vtable_ptr_->invoke_ptr( + std::addressof(storage_), + std::forward(args)... + ); + } + + constexpr bool operator== (std::nullptr_t) const noexcept + { + return !operator bool(); + } + + constexpr bool operator!= (std::nullptr_t) const noexcept + { + return operator bool(); + } + + explicit constexpr operator bool() const noexcept + { + return vtable_ptr_ != std::addressof(inplace_function_detail::empty_vtable); + } + + template + operator inplace_function() const& + { + static_assert(inplace_function_detail::is_valid_inplace_dst< + Cap, Align, Capacity, Alignment + >::value, "conversion not allowed"); + + return {vtable_ptr_, vtable_ptr_->copy_ptr, std::addressof(storage_)}; + } + + template + operator inplace_function() && + { + static_assert(inplace_function_detail::is_valid_inplace_dst< + Cap, Align, Capacity, Alignment + >::value, "conversion not allowed"); + + auto vtable_ptr = std::exchange(vtable_ptr_, std::addressof(inplace_function_detail::empty_vtable)); + + return {vtable_ptr, vtable_ptr->relocate_ptr, std::addressof(storage_)}; + } + + void swap(inplace_function& other) + { + if (this == std::addressof(other)) return; + + storage_t tmp; + vtable_ptr_->relocate_ptr( + std::addressof(tmp), + std::addressof(storage_) + ); + + other.vtable_ptr_->relocate_ptr( + std::addressof(storage_), + std::addressof(other.storage_) + ); + + vtable_ptr_->relocate_ptr( + std::addressof(other.storage_), + std::addressof(tmp) + ); + + std::swap(vtable_ptr_, other.vtable_ptr_); + } + + friend void swap(inplace_function& lhs, inplace_function& rhs) + { + lhs.swap(rhs); + } + +private: + vtable_ptr_t vtable_ptr_; + mutable storage_t storage_; + + inplace_function( + vtable_ptr_t vtable_ptr, + typename vtable_t::process_ptr_t process_ptr, + typename vtable_t::storage_ptr_t storage_ptr + ) : vtable_ptr_{vtable_ptr} + { + process_ptr(std::addressof(storage_), storage_ptr); + } +}; + +} // namespace stdext diff --git a/src/server/sparkd/cmds/Benchmark.cpp b/src/server/sparkd/cmds/Benchmark.cpp index 76c83eab7..aa308cc04 100644 --- a/src/server/sparkd/cmds/Benchmark.cpp +++ b/src/server/sparkd/cmds/Benchmark.cpp @@ -30,6 +30,7 @@ #include #include #include +#include #include @@ -446,7 +447,6 @@ static void tbb_concurrent_queue(benchmark::State &state) { } BENCHMARK(tbb_concurrent_queue); - static void boost_spsc(benchmark::State &state) { boost::lockfree::spsc_queue q(10000); @@ -652,7 +652,7 @@ static void moodycamel_concurrent_queue(benchmark::State &state) { using Q = moodycamel::ConcurrentQueue; Q queue(8); int i = 0; - + for (auto _ : state) { queue.enqueue(++i); // NOLINT benchmark::DoNotOptimize(queue.try_dequeue(i)); @@ -672,6 +672,59 @@ static void moodycamel_spsc_queue(benchmark::State &state) { } 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); + std::string Benchmark::help() { return "Run micro-benchmarks. Use --benchmark_filter=regex to run only " "specific benchmarks.";