From 3a72a4a82eb4bbf24bdd7e40ff7a9c8bf72debb9 Mon Sep 17 00:00:00 2001 From: Taha Afzal Date: Wed, 6 Jun 2018 10:11:23 -0400 Subject: [PATCH] Spreader's bookkeepingdata_ptr is a unique_ptr and some stylistic changes to shorten line widths --- .../orders/spreader_orders/SpreaderOrder.cpp | 2 +- .../orders/spreader_orders/SpreaderOrder.h | 2 +- .../spreader/SingleFillHedger.h | 14 +++-- .../spreader/SingleLegQuoter.h | 26 ++++---- .../SpreaderEndStateWorker.cpp | 2 +- .../spreader_states/SpreaderEndStateWorker.h | 21 ++++--- .../SpreaderStartStateWorker.cpp | 6 +- .../SpreaderWorkingStateWorker.cpp | 63 +++++++------------ .../SpreaderWorkingStateWorker.h | 21 ++++--- 9 files changed, 74 insertions(+), 83 deletions(-) diff --git a/src/server/sparkd/orderman/orders/spreader_orders/SpreaderOrder.cpp b/src/server/sparkd/orderman/orders/spreader_orders/SpreaderOrder.cpp index fd6ddb70e..ef396e46c 100644 --- a/src/server/sparkd/orderman/orders/spreader_orders/SpreaderOrder.cpp +++ b/src/server/sparkd/orderman/orders/spreader_orders/SpreaderOrder.cpp @@ -15,7 +15,7 @@ SpreaderOrder::SpreaderOrder() _cancelled (false), _cancel_timeout (5000),// TODO:get it from config _active(true), - _bookkeeping_data_ptr(nullptr), + //_bookkeeping_data_ptr(nullptr), _order_services(nullptr), _reported_state(), _state_worker(nullptr), diff --git a/src/server/sparkd/orderman/orders/spreader_orders/SpreaderOrder.h b/src/server/sparkd/orderman/orders/spreader_orders/SpreaderOrder.h index c74e19e23..d30a40088 100644 --- a/src/server/sparkd/orderman/orders/spreader_orders/SpreaderOrder.h +++ b/src/server/sparkd/orderman/orders/spreader_orders/SpreaderOrder.h @@ -52,7 +52,7 @@ private: // is false if created from disk const bool _active; // this is the main data - SpreaderBookkeepingData* _bookkeeping_data_ptr; + std::unique_ptr _bookkeeping_data_ptr; // pointer kept to send reports SpreaderOrderServices* _order_services; // state thats sent out in report (its kept here vs creating a new one everytime) diff --git a/src/server/sparkd/orderman/orders/spreader_orders/spreader/SingleFillHedger.h b/src/server/sparkd/orderman/orders/spreader_orders/spreader/SingleFillHedger.h index 30417ac9d..d9923eb30 100644 --- a/src/server/sparkd/orderman/orders/spreader_orders/spreader/SingleFillHedger.h +++ b/src/server/sparkd/orderman/orders/spreader_orders/spreader/SingleFillHedger.h @@ -73,21 +73,23 @@ public: SingleFillHedger (SingleFillHedger&&); SingleFillHedger& operator=(const SingleFillHedger&) = delete; SingleFillHedger& operator=(SingleFillHedger&&) = delete; - //1. leave the start state and submit the order + // the a-f actions are associated with the state machine + // side effect actions + //a. leave the start state and submit the order void init(); - //2. called by the spreader when there is an order update + //b. called by the spreader when there is an order update // reported by the exchange void on_order_update(const SpreaderChildOrderState& order_update_message); - //3. called when the market data associated + //c. called when the market data associated // with this security is changed void on_book(bts::orderman::TickToTradeCorID corid, const bts::orderman::Book& book); - //4. called when the hedge order is cancelled, either + //d. called when the hedge order is cancelled, either // manually or automatically void cancel_hedge(); - //5. immediatly terminates this hedger, without any attempts + //e. immediatly terminates this hedger, without any attempts // to cancel the order void terminate (); - //6. on the engine infrastructure time + //f. on the engine infrastructure time void on_time(const bts::TimeStamp&); // returns true if the quoter is in the final state, from which // it will never come back diff --git a/src/server/sparkd/orderman/orders/spreader_orders/spreader/SingleLegQuoter.h b/src/server/sparkd/orderman/orders/spreader_orders/spreader/SingleLegQuoter.h index a3c0ee6aa..31615a63c 100644 --- a/src/server/sparkd/orderman/orders/spreader_orders/spreader/SingleLegQuoter.h +++ b/src/server/sparkd/orderman/orders/spreader_orders/spreader/SingleLegQuoter.h @@ -65,36 +65,38 @@ public: SpreaderChildOrderState& child_order_state); public: SingleLegQuoter() = delete; - SingleLegQuoter (SingleLegQuoter&&); - SingleLegQuoter (const SingleLegQuoter&) = delete; + SingleLegQuoter(SingleLegQuoter&&); // implementation has an assert since it will not be called + SingleLegQuoter(const SingleLegQuoter&) = delete; SingleLegQuoter& operator=(const SingleLegQuoter&) = delete; SingleLegQuoter& operator=(SingleLegQuoter&&) = delete; public: - //1. this is called only once. this all could have been passed in + // the a-h actions are associated with the state machine + // side effect actions + //a. this is called only once. this could have been passed in // the constructor, but the spreader is created in 2 stages. // all the memory is allocated in a slow path and then values // are initialized on fast activation path void one_time_activate (Price, Quantity); - //2. called by the spreader a change in + //b. called by the spreader a change in // order status(or fills) is reported // by the exchange // by the exchange void update_order_status(const SpreaderChildOrderState& u); - //3. called when the market data associated + //c. called when the market data associated // with this security is changed void on_book(bts::orderman::TickToTradeCorID cid, size_t leg_index, const bts::orderman::Book&); - //4. called when the order is cancelled, either + //d. called when the order is cancelled, either // manually or automatically void cancel_order(); - //5. the quoter forgets everything and goes to the end state + //e. the quoter forgets everything and goes to the end state void terminate (); - //6. time update + //f. time update void on_time(const bts::TimeStamp&); - //7. this is called by the spreader when a quoting fill + //g. this is called by the spreader when a quoting fill // (ie not hedging fill) happens on one of the quoting // legs void update_other_leg_fills(size_t leg_index, Quantity filled_quantity); - //8. called when the user modified the spreader order price or quantity + //h. called when the user modified the spreader order price or quantity void update_order_price_quantity(Price price, Quantity quantity); // true if the quoter has an active working order. the order can // be in an unknown state, but as long as an order has been sent @@ -125,8 +127,8 @@ public: private: bts::orderman::OrderKey _key() {return _child_order_state.order_key();} TimeStamp _current_time () const {return _spreader.current_time();} - std::string _log_prefix() - { + // TODO: state out and move the string to a const + std::string _log_prefix(){ std::ostringstream oss; oss << " spreader_order_key: " << _spreader.spreader_order_key(); oss << " sec_key: " << _this_leg_data.security_key(); diff --git a/src/server/sparkd/orderman/orders/spreader_orders/spreader_states/SpreaderEndStateWorker.cpp b/src/server/sparkd/orderman/orders/spreader_orders/spreader_states/SpreaderEndStateWorker.cpp index e1aa7b904..48b657f02 100644 --- a/src/server/sparkd/orderman/orders/spreader_orders/spreader_states/SpreaderEndStateWorker.cpp +++ b/src/server/sparkd/orderman/orders/spreader_orders/spreader_states/SpreaderEndStateWorker.cpp @@ -24,7 +24,7 @@ void SpreaderEndStateWorker::on_init_recovered(const bts::api::orderman::OrderRe void SpreaderEndStateWorker::on_activate(Price price, Quantity quantity, SpreaderOrderServices&){ // this can only happen if the security could not be resolved - // resulting in START->END. however on_active will could still + // resulting in START->END. however on_active could still // be called bts_assert (!_spreader->_bookkeeping_data().all_legs_resolved()); _spreader->_bookkeeping_data().update_order(price, quantity); diff --git a/src/server/sparkd/orderman/orders/spreader_orders/spreader_states/SpreaderEndStateWorker.h b/src/server/sparkd/orderman/orders/spreader_orders/spreader_states/SpreaderEndStateWorker.h index 20efa86a9..e2413311f 100644 --- a/src/server/sparkd/orderman/orders/spreader_orders/spreader_states/SpreaderEndStateWorker.h +++ b/src/server/sparkd/orderman/orders/spreader_orders/spreader_states/SpreaderEndStateWorker.h @@ -6,26 +6,27 @@ namespace orderman { class SpreaderOrder; -class SpreaderEndStateWorker : public ISpreaderStateWorker -{ +class SpreaderEndStateWorker : public ISpreaderStateWorker{ private: SpreaderOrder* const _spreader; public: SpreaderEndStateWorker (SpreaderOrder*); - void on_transition() override; SpreaderState state() const override; - void on_init_new(api::orderman::OrderDefinition const&, const SpreaderPreActivationOrderServices&) override; - void on_init_recovered(const bts::api::orderman::OrderRecord&, const SpreaderPreActivationOrderServices&) override; + void on_transition() override; + void on_init_new(const api::orderman::OrderDefinition&, + const SpreaderPreActivationOrderServices&) override; + void on_init_recovered(const bts::api::orderman::OrderRecord&, + const SpreaderPreActivationOrderServices&) override; void on_activate(Price, Quantity, SpreaderOrderServices&) override; void on_update(Price, Quantity) override; void on_cancel() override; - void on_book(bts::orderman::TickToTradeCorID, const bts::orderman::Book&) override; + void on_book(TickToTradeCorID, const Book&) override; void on_time(const TimeStamp&) override; - void on_quoter_order_error(bts::orderman::SpreaderLegData& leg_data) override; - void on_quoter_order_fill(bts::orderman::SpreaderLegData& leg_data) override; - void on_quoter_order_status_update(bts::orderman::SpreaderLegData& leg_data) override; + void on_quoter_order_error(SpreaderLegData& leg_data) override; + void on_quoter_order_fill(SpreaderLegData& leg_data) override; + void on_quoter_order_status_update(SpreaderLegData& leg_data) override; void on_hedger_order_error(SingleFillHedger&) override; void on_hedger_order_update(SingleFillHedger&) override; - void on_check_termination () override; + void on_check_termination() override; }; }} diff --git a/src/server/sparkd/orderman/orders/spreader_orders/spreader_states/SpreaderStartStateWorker.cpp b/src/server/sparkd/orderman/orders/spreader_orders/spreader_states/SpreaderStartStateWorker.cpp index f8fbb7ee5..e67ad9729 100644 --- a/src/server/sparkd/orderman/orders/spreader_orders/spreader_states/SpreaderStartStateWorker.cpp +++ b/src/server/sparkd/orderman/orders/spreader_orders/spreader_states/SpreaderStartStateWorker.cpp @@ -22,10 +22,10 @@ void SpreaderStartStateWorker::on_init_new(const api::orderman::OrderDefinition& bts_assert(!_spreader->_inited()); std::vector spreader_legs; if (SpreaderUtils::resolve_synthetic_spread (spreader_pao_services, order_def, spreader_legs, false)) - _spreader->_bookkeeping_data_ptr = new SpreaderBookkeepingData (*_spreader, _spreader->key(), order_def, spreader_pao_services, spreader_legs); + _spreader->_bookkeeping_data_ptr = std::make_unique(*_spreader, _spreader->key(), order_def, spreader_pao_services, spreader_legs); else { - _spreader->_bookkeeping_data_ptr = new SpreaderBookkeepingData (*_spreader, _spreader->key(), order_def, spreader_pao_services, std::vector()); + _spreader->_bookkeeping_data_ptr = std::make_unique(*_spreader, _spreader->key(), order_def, spreader_pao_services, std::vector()); // if securities can not be resolved, the order is terminated LOG(OrderMan, Error, "SpreaderStartStateWorker.on_init_new key: {} , could not resolve securities", _spreader->key().value()); std::string msg = "Could not resolve securities"; @@ -36,7 +36,7 @@ void SpreaderStartStateWorker::on_init_recovered(const bts::api::orderman::Order { bts_assert(!_spreader->_inited()); // we are not handling this yet, so lets send it directly to END - _spreader->_bookkeeping_data_ptr = new SpreaderBookkeepingData (*_spreader, _spreader->key(), order_record.def(), spreader_pao_services, std::vector()); + _spreader->_bookkeeping_data_ptr = std::make_unique(*_spreader, _spreader->key(), order_record.def(), spreader_pao_services, std::vector()); LOG(OrderMan, Warn, "SpreaderStartStateWorker.on_init_recovered key: {} , going to END", _spreader->key().value()); std::string msg = "Recovered spreader orders and not supported"; _spreader->_transform_to_END (&msg); diff --git a/src/server/sparkd/orderman/orders/spreader_orders/spreader_states/SpreaderWorkingStateWorker.cpp b/src/server/sparkd/orderman/orders/spreader_orders/spreader_states/SpreaderWorkingStateWorker.cpp index 4fe8b5bf6..f1ba07a8d 100644 --- a/src/server/sparkd/orderman/orders/spreader_orders/spreader_states/SpreaderWorkingStateWorker.cpp +++ b/src/server/sparkd/orderman/orders/spreader_orders/spreader_states/SpreaderWorkingStateWorker.cpp @@ -9,50 +9,47 @@ SpreaderWorkingStateWorker::SpreaderWorkingStateWorker (SpreaderOrder* spreader) : _spreader(spreader) {} -SpreaderState SpreaderWorkingStateWorker::state() const {return SpreaderState::WORKING;} -void SpreaderWorkingStateWorker::on_transition() -{} -void SpreaderWorkingStateWorker::on_init_new(api::orderman::OrderDefinition const&, const SpreaderPreActivationOrderServices&) -{ +SpreaderState SpreaderWorkingStateWorker::state() const { + return SpreaderState::WORKING; +} +void SpreaderWorkingStateWorker::on_transition(){ +} +void SpreaderWorkingStateWorker::on_init_new(api::orderman::OrderDefinition const&, + const SpreaderPreActivationOrderServices&){ bts_assert_msg (false, "SpreaderWorkingStateWorker::on_init_new is an illegal operation"); } -void SpreaderWorkingStateWorker::on_init_recovered(const bts::api::orderman::OrderRecord&, const SpreaderPreActivationOrderServices&) -{ +void SpreaderWorkingStateWorker::on_init_recovered(const bts::api::orderman::OrderRecord&, + const SpreaderPreActivationOrderServices&){ bts_assert_msg (false, "SpreaderWorkingStateWorker::on_init_recovered is an illegal operation"); } -void SpreaderWorkingStateWorker::on_activate(Price, Quantity, SpreaderOrderServices&) -{ +void SpreaderWorkingStateWorker::on_activate(Price, Quantity, + SpreaderOrderServices&){ bts_assert_msg (false, "SpreaderWorkingStateWorker::on_activate is an illegal operation"); } -void SpreaderWorkingStateWorker::on_update(Price price, Quantity quantity) -{ - if (_spreader->_quoters_can_accept_modification()) - { +void SpreaderWorkingStateWorker::on_update(Price price, Quantity quantity){ + if (_spreader->_quoters_can_accept_modification()){ _spreader->_set_price_quantity (price, quantity); // updating all active quoters, nothing to do with the hedgers - for (size_t q_idx = 0; q_idx < _spreader->_bookkeeping_data().n_legs(); q_idx++) - { + for (size_t q_idx = 0; q_idx < _spreader->_bookkeeping_data().n_legs(); q_idx++){ SpreaderLegData& leg_data = _spreader->_bookkeeping_data().get_leg_data(q_idx); if (leg_data.leg_property_data().is_active_quoting()) leg_data.quoter().update_order_price_quantity (price, quantity); } } } -void SpreaderWorkingStateWorker::on_cancel() -{ +void SpreaderWorkingStateWorker::on_cancel(){ _spreader->_cancel_orders (true, true); _spreader->_transform_to_WAITING_FOR_CANCEL_ALL (); } -void SpreaderWorkingStateWorker::on_book(bts::orderman::TickToTradeCorID cid, const bts::orderman::Book& book) -{ +void SpreaderWorkingStateWorker::on_book(TickToTradeCorID cid, + const Book& book){ SpreaderBookkeepingData& bookkeeping_data = _spreader->_bookkeeping_data(); // this is a key->index lookup SpreaderLegData& md_leg = bookkeeping_data.get_leg_data(book.security_key()); // updating md state (this is the only place where its done) md_leg.update_book(book); // sending md to all quoters - for (size_t q_idx = 0; q_idx < bookkeeping_data.n_legs(); q_idx++) - { + for (size_t q_idx = 0; q_idx < bookkeeping_data.n_legs(); q_idx++){ SpreaderLegData& d = bookkeeping_data.get_leg_data(q_idx); if (d.leg_property_data().is_active_quoting()) d.quoter().on_book(cid, md_leg.leg_property_data().leg_index(), book); @@ -61,11 +58,9 @@ void SpreaderWorkingStateWorker::on_book(bts::orderman::TickToTradeCorID cid, co for (size_t h_idx = 0; h_idx < md_leg.n_hedgers(); h_idx++) md_leg.get_hedger(h_idx).on_book(cid, book); } -void SpreaderWorkingStateWorker::on_time(const TimeStamp& ts) -{ +void SpreaderWorkingStateWorker::on_time(const TimeStamp& ts){ SpreaderBookkeepingData& bookkeeping_data = _spreader->_bookkeeping_data(); - for (size_t q_idx = 0; q_idx < bookkeeping_data.n_legs(); q_idx++) - { + for (size_t q_idx = 0; q_idx < bookkeeping_data.n_legs(); q_idx++){ SpreaderLegData& leg_data = bookkeeping_data.get_leg_data(q_idx); if (leg_data.leg_property_data().is_active_quoting()) leg_data.quoter().on_time(ts); @@ -73,15 +68,13 @@ void SpreaderWorkingStateWorker::on_time(const TimeStamp& ts) leg_data.get_hedger(h_idx).on_time (ts); } } -void SpreaderWorkingStateWorker::on_quoter_order_error(bts::orderman::SpreaderLegData& leg_data) -{ +void SpreaderWorkingStateWorker::on_quoter_order_error(SpreaderLegData& leg_data){ // this is because the error message could also have status changes leg_data.quoter().update_order_status (leg_data.order_update_message()); _spreader->_cancel_orders (true, true); _spreader->_transform_to_WAITING_FOR_CANCEL_ALL (); } -void SpreaderWorkingStateWorker::on_quoter_order_fill(bts::orderman::SpreaderLegData& leg_data) -{ +void SpreaderWorkingStateWorker::on_quoter_order_fill(SpreaderLegData& leg_data){ // this is the most complex part of the spreader. the following needs to be done // 1. tell other quoters about it (so they reduce their sizes) // 2. launch a new hedger @@ -101,11 +94,9 @@ void SpreaderWorkingStateWorker::on_quoter_order_fill(bts::orderman::SpreaderLeg LOG(OrderMan, Info, "SpreaderWorkingStateWorker::on_quoter_order_fill order: key: {} order_key: {} status: {} filled_qty: {} last_price: {}", _spreader->key(), order_update_message.order_key(), order_update_message.status(), order_update_message.last_update_filled_quantity(), order_update_message.last_update_filled_price()); bts_assert (order_update_message.last_update_filled_quantity().value() > 0); - for (size_t q_idx = 0; q_idx < _spreader->_bookkeeping_data().n_legs(); q_idx++) - { + for (size_t q_idx = 0; q_idx < _spreader->_bookkeeping_data().n_legs(); q_idx++){ SpreaderLegData& other_leg_data = _spreader->_bookkeeping_data().get_leg_data (q_idx); - if (q_idx != leg_data.leg_property_data().leg_index()) - { + if (q_idx != leg_data.leg_property_data().leg_index()){ // if it is an actively quoting leg, inform the quoter about it // so it can decrease the proportional size if (other_leg_data.leg_property_data().is_active_quoting()) @@ -140,10 +131,4 @@ void SpreaderWorkingStateWorker::on_check_termination() if (_spreader->_all_quoter_orders_in_terminal_state() && _spreader->_all_hedger_orders_in_terminal_state()) _spreader->_transform_to_END (); } -bool SpreaderWorkingStateWorker::_is_leg_filled (size_t leg_idx) const -{ - const SpreaderLegData& leg_data = _spreader->_bookkeeping_data().get_leg_data(leg_idx); - Quantity leg_target_qty = SpreaderUtils::get_leg_quantity_from_spreader_quantity (leg_data.leg_property_data(), _spreader->_bookkeeping_data().quantity()); - return leg_data.total_fills().value() >= leg_target_qty.value(); -} }} diff --git a/src/server/sparkd/orderman/orders/spreader_orders/spreader_states/SpreaderWorkingStateWorker.h b/src/server/sparkd/orderman/orders/spreader_orders/spreader_states/SpreaderWorkingStateWorker.h index e5340ce4d..010ad6ead 100644 --- a/src/server/sparkd/orderman/orders/spreader_orders/spreader_states/SpreaderWorkingStateWorker.h +++ b/src/server/sparkd/orderman/orders/spreader_orders/spreader_states/SpreaderWorkingStateWorker.h @@ -14,21 +14,22 @@ public: SpreaderWorkingStateWorker (SpreaderOrder*); void on_transition() override; SpreaderState state() const override; - void on_init_new(api::orderman::OrderDefinition const&, const SpreaderPreActivationOrderServices&) override; - void on_init_recovered(const bts::api::orderman::OrderRecord&, const SpreaderPreActivationOrderServices&) override; - void on_activate(Price, Quantity, SpreaderOrderServices&) override; + void on_init_new(api::orderman::OrderDefinition const&, + const SpreaderPreActivationOrderServices&) override; + void on_init_recovered(const bts::api::orderman::OrderRecord&, + const SpreaderPreActivationOrderServices&) override; + void on_activate(Price, Quantity, + SpreaderOrderServices&) override; void on_update(Price, Quantity) override; void on_cancel() override; - void on_book(bts::orderman::TickToTradeCorID, const bts::orderman::Book&) override; + void on_book(TickToTradeCorID, + const Book&) override; void on_time(const TimeStamp&) override; - void on_quoter_order_error(bts::orderman::SpreaderLegData& leg_data) override; - void on_quoter_order_fill(bts::orderman::SpreaderLegData& leg_data) override; - void on_quoter_order_status_update(bts::orderman::SpreaderLegData& leg_data) override; + void on_quoter_order_error(SpreaderLegData& leg_data) override; + void on_quoter_order_fill(SpreaderLegData& leg_data) override; + void on_quoter_order_status_update(SpreaderLegData& leg_data) override; void on_hedger_order_error(SingleFillHedger&) override; void on_hedger_order_update(SingleFillHedger&) override; void on_check_termination () override; -private: - bool _is_leg_filled (size_t leg_idx) const; }; - }}