SPARK-327 (restrcutured SpreaderBookkeepingData to be more efficent)

This commit is contained in:
Taha Afzal committed 2018-01-03 15:00:34 -05:00
1 parent 8fe166633d
commit d1861cb404
25 files changed
+409 -311

No files matched your search

@@ -20,7 +20,7 @@ SpreaderOrder::SpreaderOrder(securities::ISecurityDB &db,
_active(false),
_real_orders (!bts::utils::internal::is_unittest_environment()),
_create_order_request (api::orderman::CreateOrderRequest()),
//_bookkeeping_data_ptr (nullptr),
_bookkeeping_data_val (0, Price(0), Quantity(0)),
_state_worker(nullptr)
{
LOG(OrderMan, Diag, "SpreaderOrder.cons recovered from disk, key: {}", os.order_key() );
@@ -35,8 +35,7 @@ SpreaderOrder::SpreaderOrder(securities::ISecurityDB& db,
_active (true),
_real_orders (!bts::utils::internal::is_unittest_environment()),
_create_order_request (cor),
_bookkeeping_data_val (SpreaderBookkeepingData (std::vector<SpreaderLegData>(), Price(cor.spreader().price()), Quantity(cor.spreader().quantity()))),
//_bookkeeping_data_ptr (new SpreaderBookkeepingData (std::vector<SpreaderLegData>(), Price(cor.spreader().price()), Quantity(cor.spreader().quantity()))),
_bookkeeping_data_val (cor.spreader().execution_strategy().leg_params_map().size(), Price(cor.spreader().price()), Quantity(cor.spreader().quantity())),
_state_worker(nullptr)
{
LOG(OrderMan, Diag, "SpreaderOrder.cons request: {} key: {}", utils::pb::to_string(cor), k.value());
@@ -220,7 +219,7 @@ void SpreaderOrder::_cancel_orders(bool cancel_quotes, bool cancel_hedges)
if (cancel_quotes)
{
if (leg_data.leg_property_data().is_active_quoting())
leg_data.quoter()->cancel_order();
leg_data.quoter().cancel_order();
}
if (cancel_hedges)
for (size_t h_idx = 0; h_idx < leg_data.n_hedgers(); h_idx++)
@@ -236,7 +235,7 @@ bool SpreaderOrder::_all_quoter_orders_in_terminal_state()
{
SpreaderLegData& leg_data = _bookkeeping_data().get_leg_data(q_idx);
if (leg_data.leg_property_data().is_active_quoting())
if (!leg_data.quoter()->is_terminal_state())
if (!leg_data.quoter().is_terminal_state())
return false;
}
return true;
@@ -261,7 +260,7 @@ void SpreaderOrder::_terminate_quoters ()
for (size_t q_idx = 0; q_idx < _bookkeeping_data().n_legs(); q_idx++)
{
SpreaderLegData& leg_data = _bookkeeping_data().get_leg_data(q_idx);
leg_data.quoter()->terminate();
leg_data.quoter().terminate();
}
}
void SpreaderOrder::_terminate_hedgers ()
@@ -282,7 +281,7 @@ bool SpreaderOrder::_quoters_can_accept_modification ()
{
SpreaderLegData& leg_data = _bookkeeping_data().get_leg_data(q_idx);
if (leg_data.leg_property_data().is_active_quoting())
if (!leg_data.quoter()->accept_modifications())
if (!leg_data.quoter().accept_modifications())
return false;
}
return true;
@@ -296,7 +295,7 @@ void SpreaderOrder::_send_hedge(size_t filled_leg_index, Price filled_price, Qua
_compute_hedge_price_quantity (filled_leg_index, filled_price, filled_quantity, hedge_leg_index,
hedge_price, hedge_quantity);
bts::orderman::SpreaderOrderBase::ChildOrder new_hedge_order = _get_new_order (leg_data.leg_property_data(), false);
SpreaderHedgerData& hedger_data = leg_data.add_new_hedger (*this, new_hedge_order, hedge_price, hedge_quantity,leg_data.leg_property_data().trading_side());
SpreaderHedgerData& hedger_data = _bookkeeping_data_val.add_new_hedger (*this, new_hedge_order, hedge_leg_index, hedge_price, hedge_quantity);
hedger_data.hedger().init ();
}
void SpreaderOrder::_compute_hedge_price_quantity(size_t filled_leg_index,
@@ -314,7 +313,7 @@ void SpreaderOrder::_compute_hedge_price_quantity(size_t filled_leg_index,
}
else
{
Price driver_price = hedged_leg_data.quoter()->driver_price(hedge_leg_index);
Price driver_price = hedged_leg_data.quoter().driver_price(hedge_leg_index);
SpreaderUtils::compute_hedge_price_size_n_legs (filled_leg_data.leg_property_data(), fill_price, fill_quantity, driver_price,
hedged_leg_data.leg_property_data(), hedge_price, hedge_quantity);
}
@@ -47,13 +47,13 @@ void SpreaderWaitingForCancelAllStateWorker::on_time(const TimeStamp& ts)
void SpreaderWaitingForCancelAllStateWorker::on_quoter_order_error(bts::orderman::SpreaderLegData& leg_data, api::orderman::OrderStatus status, Quantity filled_quantity, Price average_price, std::string const* err_msg)
{
leg_data.order_update_message().update (status, filled_quantity, average_price, err_msg);
leg_data.quoter()->update_order_status (leg_data.order_update_message());
leg_data.quoter().update_order_status (leg_data.order_update_message());
}
void SpreaderWaitingForCancelAllStateWorker::on_quoter_order_fill(bts::orderman::SpreaderLegData& leg_data, api::orderman::OrderStatus status,
Quantity filled_quantity, Price average_price)
{
leg_data.order_update_message().update (status, filled_quantity, average_price, nullptr);
leg_data.quoter()->update_order_status (leg_data.order_update_message());
leg_data.quoter().update_order_status (leg_data.order_update_message());
}
void SpreaderWaitingForCancelAllStateWorker::on_quoter_order_status_update(bts::orderman::SpreaderLegData& leg_data, api::orderman::OrderStatus status)
{
@@ -91,7 +91,7 @@ void SpreaderWaitingForFirstConnStateWorker::_init_quoters ()
{
SpreaderLegData& leg_data = _spreader->_bookkeeping_data().get_leg_data(index);
if (leg_data.leg_property_data().is_active_quoting())
leg_data.quoter()->init();
leg_data.quoter().init();
}
}
bool SpreaderWaitingForFirstConnStateWorker::_can_resolve_securities ()
@@ -133,8 +133,6 @@ void SpreaderWaitingForFirstConnStateWorker::_subscribe_to_marketdata()
}
void SpreaderWaitingForFirstConnStateWorker::_construct_bookkeeping_data_and_quoters()
{
std::vector<SpreaderLegData> leg_data_vector;
//creating the basic data
ISpreaderManager& me_ref = *_spreader;
const bts::api::orderman::CreateSpreaderOrder& cor = _spreader->_create_order_request.spreader();
spark::ExecutionStrategy execution_strategy = cor.execution_strategy();
@@ -151,15 +149,8 @@ void SpreaderWaitingForFirstConnStateWorker::_construct_bookkeeping_data_and_quo
// ii. setting up the order for this leg
bts::orderman::SpreaderOrderBase::ChildOrder child_order = _spreader->_get_new_order (leg_property_data, api::orderman::ChildOrderKind::COK_SPREADER_QUOTING);
LOG(OrderMan, Diag, "Initiazing quoting order {} owned by spreader order {}", child_order.order_key().value(), _spreader->key().value());
// iii. setting up the quoter (which needs the quoter and property from i and ii)
SingleLegQuoter* leg_quoter = new SingleLegQuoter(me_ref, leg_property_data, sec.synthetic().legs().size(), Price(cor.price()), Quantity(cor.quantity()), child_order);
// iv. finally setting up the full leg_data (which needs the quoter and property from i, ii and iii)
SpreaderLegData leg_data(leg_property_data, leg_quoter, child_order.order_key());
leg_data_vector.push_back(leg_data);
leg_idx++;
_spreader->_bookkeeping_data_val.add_leg (leg_property_data, child_order, me_ref);
leg_idx++;
}
bts_assert(leg_data_vector.size() > 0);
_spreader->_bookkeeping_data_val = SpreaderBookkeepingData(leg_data_vector, Price(cor.price()), Quantity(cor.quantity()));
//_spreader->_bookkeeping_data_ptr = new SpreaderBookkeepingData(leg_data_vector, Price(cor.price()), Quantity(cor.quantity()));
}
}}
@@ -37,7 +37,7 @@ void SpreaderWorkingStateWorker::on_update(const api::orderman::UpdateSpreaderOr
{
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);
leg_data.quoter().update_order_price_quantity (price, quantity);
}
}
}
@@ -52,13 +52,13 @@ void SpreaderWorkingStateWorker::on_book(TickToTradeCorID cid, const Book& book)
// 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.set_book(book);
md_leg.update_book(book);
// sending md to all quoters
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);
d.quoter().on_book(cid, md_leg.leg_property_data().leg_index(), book);
}
// send md to hedgers hedging this security only
for (size_t h_idx = 0; h_idx < md_leg.n_hedgers(); h_idx++)
@@ -72,7 +72,7 @@ void SpreaderWorkingStateWorker::on_time(const TimeStamp& ts)
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);
leg_data.quoter().on_time(ts);
for (size_t h_idx = 0; h_idx < leg_data.n_hedgers(); h_idx++)
leg_data.get_hedger(h_idx).hedger().on_time (ts);
}
@@ -82,7 +82,7 @@ void SpreaderWorkingStateWorker::on_quoter_order_error(bts::orderman::SpreaderLe
{
leg_data.order_update_message().update(status, filled_quantity, average_price, err_msg);
// this is because the error message could also have status changes
leg_data.quoter()->update_order_status (leg_data.order_update_message());
leg_data.quoter().update_order_status (leg_data.order_update_message());
_spreader->_cancel_orders (true, true);
_spreader->_transform_to_WAITING_FOR_CANCEL_ALL ();
}
@@ -96,18 +96,18 @@ void SpreaderWorkingStateWorker::on_quoter_order_fill(bts::orderman::SpreaderLeg
// 5. init the hedger
SpreaderChildOrderState& order_update_message = leg_data.order_update_message();
order_update_message.update (status, filled_quantity, average_price, nullptr);
leg_data.quoter()->update_order_status (order_update_message);
leg_data.quoter().update_order_status (order_update_message);
if (order_update_message.last_update_filled_quantity().value() > 0)
{
for (size_t q_idx = 0; q_idx < _spreader->_bookkeeping_data().n_legs(); q_idx++)
{
bts::orderman::SpreaderLegData other_leg_data = _spreader->_bookkeeping_data().get_leg_data (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 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())
other_leg_data.quoter()->update_other_leg_fills(leg_data.leg_property_data().leg_index(), order_update_message.last_update_filled_quantity());
other_leg_data.quoter().update_other_leg_fills(leg_data.leg_property_data().leg_index(), order_update_message.last_update_filled_quantity());
// a hedge is sent regardless
_spreader->_send_hedge (leg_data.leg_property_data().leg_index(), order_update_message.last_update_filled_price(), order_update_message.last_update_filled_quantity(), q_idx);
}
@@ -117,7 +117,7 @@ void SpreaderWorkingStateWorker::on_quoter_order_fill(bts::orderman::SpreaderLeg
void SpreaderWorkingStateWorker::on_quoter_order_status_update(bts::orderman::SpreaderLegData& leg_data, api::orderman::OrderStatus status)
{
leg_data.order_update_message().update (status);
leg_data.quoter()->update_order_status (leg_data.order_update_message());
leg_data.quoter().update_order_status (leg_data.order_update_message());
}
void SpreaderWorkingStateWorker::on_hedger_order_error(OrderKey order_key, api::orderman::OrderStatus status, Quantity filled_quantity, Price average_price, std::string const* err_msg)
{
@@ -236,81 +236,81 @@ TEST_CASE ("book traversal", "[spreader]")
}
}
//this is how the spreader organizes the data
TEST_CASE ("spreader bookkeeping data", "[spreader]")
{
// constants
double leg_mult_1 = -1.25, leg_mult_2 = 3.33, leg_mult_3 = -1.75;
std::string symbol_1 = "ES", symbol_2 = "ZN", symbol_3 = "GC";
uint32_t sec_key_1 = 1111, sec_key_2 = 2222, sec_key_3 = 3333;
double lean_ratio_1 = 1.33, lean_ratio_2 = 5.0, lean_ratio_3 = 2.75;
double price_mult_1 = -2.5, price_mult_2 = 5.0, price_mult_3 = -3.33;
Price spread_price (-0.35);
Quantity spread_quantity (125);
OrderKey order_key_1 (4), order_key_2 (22), order_key_3 (2007);
// leg property data
ContractLeg leg_1, leg_2, leg_3;
fill_future_contract_leg (leg_1, sec_key_1, symbol_1, bts::api::Venue::VENUE_GLBX, 2017, 12, 15, leg_mult_1, api::Side::SIDE_SELL, 1.0, 0.25);
fill_future_contract_leg (leg_2, sec_key_2, symbol_2, bts::api::Venue::VENUE_GLBX, 2018, 3, 15, leg_mult_2, api::Side::SIDE_BUY, 1.0, 0.03125);
fill_future_contract_leg (leg_3, sec_key_3, symbol_3, bts::api::Venue::VENUE_GLBX, 2018, 6, 15, leg_mult_3, api::Side::SIDE_SELL, 1.0, 0.05);
QuoteParams qp_1, qp_2, qp_3;
fill_quote_params(qp_1, lean_ratio_1);
fill_quote_params(qp_2, lean_ratio_2);
fill_quote_params(qp_3, lean_ratio_3);
LegSpreaderParams lsp_1, lsp_2, lsp_3;
fill_leg_spreader_params (lsp_1, price_mult_1, true, qp_1);
fill_leg_spreader_params (lsp_2, price_mult_2, true, qp_2);
fill_leg_spreader_params (lsp_3, price_mult_3, true, qp_3);
LegPropertyData leg_prop_data_1 (0, leg_1, lsp_1, api::Side::SIDE_SELL);
LegPropertyData leg_prop_data_2 (1, leg_2, lsp_2, api::Side::SIDE_BUY);
LegPropertyData leg_prop_data_3 (2, leg_3, lsp_3, api::Side::SIDE_SELL);
Book book1, book2, book3;
// SpreaderManager
std::vector<LegPropertyData> legs;
legs.push_back (leg_prop_data_1);legs.push_back (leg_prop_data_2);legs.push_back (leg_prop_data_3);
std::vector<Book> books;
books.push_back (book1);books.push_back (book2);books.push_back (book3);
SpreaderManagerForTest spreader_manager (legs, books);
// quoter
SingleLegQuoter quoter_1 (spreader_manager, leg_prop_data_1, 3, spread_price , spread_quantity, bts::orderman::SpreaderOrderBase::ChildOrder());
SingleLegQuoter quoter_2 (spreader_manager, leg_prop_data_2, 3, spread_price , spread_quantity, bts::orderman::SpreaderOrderBase::ChildOrder());
SingleLegQuoter quoter_3 (spreader_manager, leg_prop_data_3, 3, spread_price , spread_quantity, bts::orderman::SpreaderOrderBase::ChildOrder());
// bookkeeping data
std::vector<SpreaderLegData> leg_data_v;
leg_data_v.push_back (SpreaderLegData (leg_prop_data_1, &quoter_1, order_key_1));
leg_data_v.push_back (SpreaderLegData (leg_prop_data_2, &quoter_2, order_key_2));
leg_data_v.push_back (SpreaderLegData (leg_prop_data_3, &quoter_3, order_key_3));
SpreaderBookkeepingData bookkeeping_data (leg_data_v, spread_price, spread_quantity);
SECTION("verify security key access")
{
SpreaderLegData res_3 = bookkeeping_data.get_leg_data (SecurityKey (sec_key_3));
verify_leg_data (res_3, order_key_3, 2, sec_key_3, 2018, 6, 15, symbol_3, leg_mult_3, price_mult_3, api::Side::SIDE_SELL);
SpreaderLegData res_2 = bookkeeping_data.get_leg_data (SecurityKey (sec_key_2));
verify_leg_data (res_2, order_key_2, 1, sec_key_2, 2018, 3, 15, symbol_2, leg_mult_2, price_mult_2, api::Side::SIDE_BUY);
SpreaderLegData res_1 = bookkeeping_data.get_leg_data (SecurityKey (sec_key_1));
verify_leg_data (res_1, order_key_1, 0, sec_key_1, 2017, 12, 15, symbol_1, leg_mult_1, price_mult_1, api::Side::SIDE_SELL);
}
SECTION("verify index access")
{
SpreaderLegData res_3 = bookkeeping_data.get_leg_data (2);
verify_leg_data (res_3, order_key_3, 2, sec_key_3, 2018, 6, 15, symbol_3, leg_mult_3, price_mult_3, api::Side::SIDE_SELL);
SpreaderLegData res_2 = bookkeeping_data.get_leg_data (1);
verify_leg_data (res_2, order_key_2, 1, sec_key_2, 2018, 3, 15, symbol_2, leg_mult_2, price_mult_2, api::Side::SIDE_BUY);
SpreaderLegData res_1 = bookkeeping_data.get_leg_data (0);
verify_leg_data (res_1, order_key_1, 0, sec_key_1, 2017, 12, 15, symbol_1, leg_mult_1, price_mult_1, api::Side::SIDE_SELL);
}
SECTION("verify order key access")
{
SpreaderLegData* res_3 = bookkeeping_data.find_leg_from_quoter_orderkey (order_key_3);
bts_assert (res_3 != nullptr);
verify_leg_data (*res_3, order_key_3, 2, sec_key_3, 2018, 6, 15, symbol_3, leg_mult_3, price_mult_3, api::Side::SIDE_SELL);
SpreaderLegData* res_2 = bookkeeping_data.find_leg_from_quoter_orderkey (order_key_2);
bts_assert (res_2 != nullptr);
verify_leg_data (*res_2, order_key_2, 1, sec_key_2, 2018, 3, 15, symbol_2, leg_mult_2, price_mult_2, api::Side::SIDE_BUY);
SpreaderLegData* res_1 = bookkeeping_data.find_leg_from_quoter_orderkey (order_key_1);
bts_assert (res_1 != nullptr);
verify_leg_data (*res_1, order_key_1, 0, sec_key_1, 2017, 12, 15, symbol_1, leg_mult_1, price_mult_1, api::Side::SIDE_SELL);
}
}
// TEST_CASE ("spreader bookkeeping data", "[spreader]")
// {
// // constants
// double leg_mult_1 = -1.25, leg_mult_2 = 3.33, leg_mult_3 = -1.75;
// std::string symbol_1 = "ES", symbol_2 = "ZN", symbol_3 = "GC";
// uint32_t sec_key_1 = 1111, sec_key_2 = 2222, sec_key_3 = 3333;
// double lean_ratio_1 = 1.33, lean_ratio_2 = 5.0, lean_ratio_3 = 2.75;
// double price_mult_1 = -2.5, price_mult_2 = 5.0, price_mult_3 = -3.33;
// Price spread_price (-0.35);
// Quantity spread_quantity (125);
// OrderKey order_key_1 (4), order_key_2 (22), order_key_3 (2007);
// // leg property data
// ContractLeg leg_1, leg_2, leg_3;
// fill_future_contract_leg (leg_1, sec_key_1, symbol_1, bts::api::Venue::VENUE_GLBX, 2017, 12, 15, leg_mult_1, api::Side::SIDE_SELL, 1.0, 0.25);
// fill_future_contract_leg (leg_2, sec_key_2, symbol_2, bts::api::Venue::VENUE_GLBX, 2018, 3, 15, leg_mult_2, api::Side::SIDE_BUY, 1.0, 0.03125);
// fill_future_contract_leg (leg_3, sec_key_3, symbol_3, bts::api::Venue::VENUE_GLBX, 2018, 6, 15, leg_mult_3, api::Side::SIDE_SELL, 1.0, 0.05);
// QuoteParams qp_1, qp_2, qp_3;
// fill_quote_params(qp_1, lean_ratio_1);
// fill_quote_params(qp_2, lean_ratio_2);
// fill_quote_params(qp_3, lean_ratio_3);
// LegSpreaderParams lsp_1, lsp_2, lsp_3;
// fill_leg_spreader_params (lsp_1, price_mult_1, true, qp_1);
// fill_leg_spreader_params (lsp_2, price_mult_2, true, qp_2);
// fill_leg_spreader_params (lsp_3, price_mult_3, true, qp_3);
// LegPropertyData leg_prop_data_1 (0, leg_1, lsp_1, api::Side::SIDE_SELL);
// LegPropertyData leg_prop_data_2 (1, leg_2, lsp_2, api::Side::SIDE_BUY);
// LegPropertyData leg_prop_data_3 (2, leg_3, lsp_3, api::Side::SIDE_SELL);
// Book book1, book2, book3;
// // SpreaderManager
// std::vector<LegPropertyData> legs;
// legs.push_back (leg_prop_data_1);legs.push_back (leg_prop_data_2);legs.push_back (leg_prop_data_3);
// std::vector<Book> books;
// books.push_back (book1);books.push_back (book2);books.push_back (book3);
// SpreaderManagerForTest spreader_manager (legs, books);
// // quoter
// SingleLegQuoter quoter_1 (spreader_manager, leg_prop_data_1, 3, spread_price , spread_quantity, bts::orderman::SpreaderOrderBase::ChildOrder());
// SingleLegQuoter quoter_2 (spreader_manager, leg_prop_data_2, 3, spread_price , spread_quantity, bts::orderman::SpreaderOrderBase::ChildOrder());
// SingleLegQuoter quoter_3 (spreader_manager, leg_prop_data_3, 3, spread_price , spread_quantity, bts::orderman::SpreaderOrderBase::ChildOrder());
// // bookkeeping data
// std::vector<SpreaderLegData> leg_data_v;
// leg_data_v.push_back (SpreaderLegData (leg_prop_data_1, &quoter_1, order_key_1));
// leg_data_v.push_back (SpreaderLegData (leg_prop_data_2, &quoter_2, order_key_2));
// leg_data_v.push_back (SpreaderLegData (leg_prop_data_3, &quoter_3, order_key_3));
// SpreaderBookkeepingData bookkeeping_data (leg_data_v, spread_price, spread_quantity);
// SECTION("verify security key access")
// {
// SpreaderLegData res_3 = bookkeeping_data.get_leg_data (SecurityKey (sec_key_3));
// verify_leg_data (res_3, order_key_3, 2, sec_key_3, 2018, 6, 15, symbol_3, leg_mult_3, price_mult_3, api::Side::SIDE_SELL);
// SpreaderLegData res_2 = bookkeeping_data.get_leg_data (SecurityKey (sec_key_2));
// verify_leg_data (res_2, order_key_2, 1, sec_key_2, 2018, 3, 15, symbol_2, leg_mult_2, price_mult_2, api::Side::SIDE_BUY);
// SpreaderLegData res_1 = bookkeeping_data.get_leg_data (SecurityKey (sec_key_1));
// verify_leg_data (res_1, order_key_1, 0, sec_key_1, 2017, 12, 15, symbol_1, leg_mult_1, price_mult_1, api::Side::SIDE_SELL);
// }
// SECTION("verify index access")
// {
// SpreaderLegData res_3 = bookkeeping_data.get_leg_data (2);
// verify_leg_data (res_3, order_key_3, 2, sec_key_3, 2018, 6, 15, symbol_3, leg_mult_3, price_mult_3, api::Side::SIDE_SELL);
// SpreaderLegData res_2 = bookkeeping_data.get_leg_data (1);
// verify_leg_data (res_2, order_key_2, 1, sec_key_2, 2018, 3, 15, symbol_2, leg_mult_2, price_mult_2, api::Side::SIDE_BUY);
// SpreaderLegData res_1 = bookkeeping_data.get_leg_data (0);
// verify_leg_data (res_1, order_key_1, 0, sec_key_1, 2017, 12, 15, symbol_1, leg_mult_1, price_mult_1, api::Side::SIDE_SELL);
// }
// SECTION("verify order key access")
// {
// SpreaderLegData* res_3 = bookkeeping_data.find_leg_from_quoter_orderkey (order_key_3);
// bts_assert (res_3 != nullptr);
// verify_leg_data (*res_3, order_key_3, 2, sec_key_3, 2018, 6, 15, symbol_3, leg_mult_3, price_mult_3, api::Side::SIDE_SELL);
// SpreaderLegData* res_2 = bookkeeping_data.find_leg_from_quoter_orderkey (order_key_2);
// bts_assert (res_2 != nullptr);
// verify_leg_data (*res_2, order_key_2, 1, sec_key_2, 2018, 3, 15, symbol_2, leg_mult_2, price_mult_2, api::Side::SIDE_BUY);
// SpreaderLegData* res_1 = bookkeeping_data.find_leg_from_quoter_orderkey (order_key_1);
// bts_assert (res_1 != nullptr);
// verify_leg_data (*res_1, order_key_1, 0, sec_key_1, 2017, 12, 15, symbol_1, leg_mult_1, price_mult_1, api::Side::SIDE_SELL);
// }
// }
// quote price and quantity for a 2 legged spread
TEST_CASE ("compute quoting price quantity 2 legs", "[spreader]")
{
@@ -1599,28 +1599,28 @@ TEST_CASE ("spreader_WORKING", "[spreader]")
// verify working orders
SpreaderBookkeepingData& bookkeeping_data = spreader.test_only_func_spreader_full_data ();
SpreaderLegData& leg_data_1 = bookkeeping_data.get_leg_data (0); SpreaderLegData& leg_data_2 = bookkeeping_data.get_leg_data (1);
verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (0), Quantity(0), Price(1999), Quantity(100), Quantity(100), false);
verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (0), Quantity(0), Price(2002), Quantity(100), Quantity(100), false);
verify_complete_quoter_state (leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (0), Quantity(0), Price(1999), Quantity(100), Quantity(100), false);
verify_complete_quoter_state (leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (0), Quantity(0), Price(2002), Quantity(100), Quantity(100), false);
// send fill on leg 1 (20)
spreader.on_child_update (leg_data_1.order_key(), api::orderman::OrderStatus::OS_PARTIALLY_FILLED, Quantity (20), Price (2000), nullptr);
verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (20), Quantity(0), Price(2000), Quantity(100), Quantity(80), false);
verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (0), Quantity(20), Price(2002), Quantity(80), Quantity(80), false);
verify_complete_quoter_state (leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (20), Quantity(0), Price(2000), Quantity(100), Quantity(80), false);
verify_complete_quoter_state (leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (0), Quantity(20), Price(2002), Quantity(80), Quantity(80), false);
// send another fill on leg 1 (10)
spreader.on_child_update (leg_data_1.order_key(), api::orderman::OrderStatus::OS_PARTIALLY_FILLED, Quantity (30), Price (2000), nullptr);
verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (30), Quantity(0), Price(2000), Quantity(100), Quantity(70), false);
verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (0), Quantity(30), Price(2002), Quantity(70), Quantity(70), false);
verify_complete_quoter_state (leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (30), Quantity(0), Price(2000), Quantity(100), Quantity(70), false);
verify_complete_quoter_state (leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (0), Quantity(30), Price(2002), Quantity(70), Quantity(70), false);
// send fill on leg 2 (15)
spreader.on_child_update (leg_data_2.order_key(), api::orderman::OrderStatus::OS_PARTIALLY_FILLED, Quantity (15), Price (2001), nullptr);
verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (30), Quantity(15), Price(2001), Quantity(85), Quantity(55), false);
verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (15), Quantity(30), Price(2002), Quantity(70), Quantity(55), false);
verify_complete_quoter_state (leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (30), Quantity(15), Price(2001), Quantity(85), Quantity(55), false);
verify_complete_quoter_state (leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (15), Quantity(30), Price(2002), Quantity(70), Quantity(55), false);
// send another fill on leg 2 (30)
spreader.on_child_update (leg_data_2.order_key(), api::orderman::OrderStatus::OS_PARTIALLY_FILLED, Quantity (45), Price (2001), nullptr);
verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (30), Quantity(45), Price(2002), Quantity(55), Quantity(25), false);
verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (45), Quantity(30), Price(2000), Quantity(70), Quantity(25), false);
verify_complete_quoter_state (leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (30), Quantity(45), Price(2002), Quantity(55), Quantity(25), false);
verify_complete_quoter_state (leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (45), Quantity(30), Price(2000), Quantity(70), Quantity(25), false);
// send another fill on leg 2 (10)
spreader.on_child_update (leg_data_2.order_key(), api::orderman::OrderStatus::OS_PARTIALLY_FILLED, Quantity (55), Price (2001), nullptr);
verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (30), Quantity(55), Price(2003), Quantity(45), Quantity(15), false);
verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (55), Quantity(30), Price(2000), Quantity(70), Quantity(15), false);
verify_complete_quoter_state (leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (30), Quantity(55), Price(2003), Quantity(45), Quantity(15), false);
verify_complete_quoter_state (leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (55), Quantity(30), Price(2000), Quantity(70), Quantity(15), false);
// verify the hedgers
// leg 1 should have 3 hedgers, for each of the 3 fills
for (size_t i = 0; i < leg_data_1.n_hedgers(); i++)
@@ -1629,8 +1629,8 @@ TEST_CASE ("spreader_WORKING", "[spreader]")
spreader.on_child_update (leg_data_2.get_hedger(i).order_update_message().order_key(), api::orderman::OrderStatus::OS_NEW, Quantity (0), Price (0), nullptr);
bts_assert (leg_data_1.n_hedgers () == 3);
bts_assert (leg_data_2.n_hedgers () == 2);
verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (30), Quantity(55), Price(2003), Quantity(45), Quantity(15), false);
verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (55), Quantity(30), Price(2000), Quantity(70), Quantity(15), false);
verify_complete_quoter_state (leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (30), Quantity(55), Price(2003), Quantity(45), Quantity(15), false);
verify_complete_quoter_state (leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (55), Quantity(30), Price(2000), Quantity(70), Quantity(15), false);
verify_complete_hedger_state (leg_data_1.get_hedger (0).hedger(), HedgerState::WORKING, Price (2002), Quantity(15), Quantity (0), Price(2002), Quantity (15), Quantity (15));
verify_complete_hedger_state (leg_data_1.get_hedger (1).hedger(), HedgerState::WORKING, Price (2002), Quantity(30), Quantity (0), Price(2002), Quantity (30), Quantity (30));
verify_complete_hedger_state (leg_data_1.get_hedger (2).hedger(), HedgerState::WORKING, Price (2002), Quantity(10), Quantity (0), Price(2002), Quantity (10), Quantity (10));
@@ -1639,18 +1639,18 @@ TEST_CASE ("spreader_WORKING", "[spreader]")
auto generic_validate_quoters = [&](QuoterState quoter_state, bool quoter_cancelled_by_spreader) -> void
{
verify_complete_quoter_state (*leg_data_1.quoter(), quoter_state, quoter_cancelled_by_spreader, spreader_price, Quantity (100), Quantity (30), Quantity(55), Price(2003), Quantity(45), Quantity(15), false);
verify_complete_quoter_state (*leg_data_2.quoter(), quoter_state, quoter_cancelled_by_spreader, spreader_price, Quantity (100), Quantity (55), Quantity(30), Price(2000), Quantity(70), Quantity(15), false);
verify_complete_quoter_state (leg_data_1.quoter(), quoter_state, quoter_cancelled_by_spreader, spreader_price, Quantity (100), Quantity (30), Quantity(55), Price(2003), Quantity(45), Quantity(15), false);
verify_complete_quoter_state (leg_data_2.quoter(), quoter_state, quoter_cancelled_by_spreader, spreader_price, Quantity (100), Quantity (55), Quantity(30), Price(2000), Quantity(70), Quantity(15), false);
};
auto generic_validate_hedgers = [&](HedgerState hedger_state) -> void
{
bts_assert (leg_data_1.n_hedgers () == 3);
bts_assert (leg_data_2.n_hedgers () == 2);
verify_complete_hedger_state (leg_data_1.get_hedger (0).hedger(), hedger_state, Price (2002), Quantity(15), Quantity (0), Price(2002), Quantity (15), Quantity (15));
verify_complete_hedger_state (leg_data_1.get_hedger (1).hedger(), hedger_state, Price (2002), Quantity(30), Quantity (0), Price(2002), Quantity (30), Quantity (30));
verify_complete_hedger_state (leg_data_1.get_hedger (2).hedger(), hedger_state, Price (2002), Quantity(10), Quantity (0), Price(2002), Quantity (10), Quantity (10));
verify_complete_hedger_state (leg_data_2.get_hedger (0).hedger(), hedger_state, Price (1999), Quantity(20), Quantity (0), Price(1999), Quantity (20), Quantity (20));
verify_complete_hedger_state (leg_data_2.get_hedger (1).hedger(), hedger_state, Price (1999), Quantity(10), Quantity (0), Price(1999), Quantity (10), Quantity (10));
verify_complete_hedger_state (leg_data_1.get_hedger(0).hedger(), hedger_state, Price (2002), Quantity(15), Quantity (0), Price(2002), Quantity (15), Quantity (15));
verify_complete_hedger_state (leg_data_1.get_hedger(1).hedger(), hedger_state, Price (2002), Quantity(30), Quantity (0), Price(2002), Quantity (30), Quantity (30));
verify_complete_hedger_state (leg_data_1.get_hedger(2).hedger(), hedger_state, Price (2002), Quantity(10), Quantity (0), Price(2002), Quantity (10), Quantity (10));
verify_complete_hedger_state (leg_data_2.get_hedger(0).hedger(), hedger_state, Price (1999), Quantity(20), Quantity (0), Price(1999), Quantity (20), Quantity (20));
verify_complete_hedger_state (leg_data_2.get_hedger(1).hedger(), hedger_state, Price (1999), Quantity(10), Quantity (0), Price(1999), Quantity (10), Quantity (10));
};
SECTION("1. init")
{
@@ -1678,8 +1678,8 @@ TEST_CASE ("spreader_WORKING", "[spreader]")
api::orderman::UpdateSpreaderOrder u; u.set_price(spreader_price.value()); u.set_quantity (spreader_quantity.value());
spreader.on_update (u);
verify_basic_spreader_state (spreader, SpreaderState::WORKING, spreader_price, spreader_quantity);
verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, spreader_quantity, Quantity (30), Quantity(55), Price(1998), Quantity(130), Quantity(115), false);
verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, spreader_quantity, Quantity (55), Quantity(30), Price(2004), Quantity(165), Quantity(115), false);
verify_complete_quoter_state (leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, spreader_quantity, Quantity (30), Quantity(55), Price(1998), Quantity(130), Quantity(115), false);
verify_complete_quoter_state (leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, spreader_quantity, Quantity (55), Quantity(30), Price(2004), Quantity(165), Quantity(115), false);
// nothing changes with the hedgers
generic_validate_hedgers (HedgerState::WORKING);
LOG(OrderMan, Diag, "spreader_WORKING.on_update");
@@ -1724,8 +1724,8 @@ TEST_CASE ("spreader_WORKING", "[spreader]")
true);
spreader.on_book (bts::orderman::NullTickToTradeCorID, modified_book);
verify_basic_spreader_state (spreader, SpreaderState::WORKING, spreader_price, spreader_quantity);
verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (30), Quantity(55), Price(1999), Quantity(45), Quantity(15), false);
verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (55), Quantity(30), Price(2000), Quantity(70), Quantity(15), false);
verify_complete_quoter_state (leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (30), Quantity(55), Price(1999), Quantity(45), Quantity(15), false);
verify_complete_quoter_state (leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (55), Quantity(30), Price(2000), Quantity(70), Quantity(15), false);
generic_validate_hedgers (HedgerState::WORKING);
LOG(OrderMan, Diag, "spreader_WORKING.on_book");
// 3. shrink to market to force a size change
@@ -1739,8 +1739,8 @@ TEST_CASE ("spreader_WORKING", "[spreader]")
true);
spreader.on_book (bts::orderman::NullTickToTradeCorID, modified_book);
verify_basic_spreader_state (spreader, SpreaderState::WORKING, spreader_price, spreader_quantity);
verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (30), Quantity(55), Price(2000), Quantity(34), Quantity(15), false);
verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (55), Quantity(30), Price(2000), Quantity(70), Quantity(15), false);
verify_complete_quoter_state (leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (30), Quantity(55), Price(2000), Quantity(34), Quantity(15), false);
verify_complete_quoter_state (leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (55), Quantity(30), Price(2000), Quantity(70), Quantity(15), false);
generic_validate_hedgers (HedgerState::WORKING);
LOG(OrderMan, Diag, "spreader_WORKING.on_book");
// 4. change the market to force both a price and size change
@@ -1752,8 +1752,8 @@ TEST_CASE ("spreader_WORKING", "[spreader]")
true);
spreader.on_book (bts::orderman::NullTickToTradeCorID, modified_book);
verify_basic_spreader_state (spreader, SpreaderState::WORKING, spreader_price, spreader_quantity);
verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (30), Quantity(55), Price(2001), Quantity(45), Quantity(15), false);
verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (55), Quantity(30), Price(2000), Quantity(70), Quantity(15), false);
verify_complete_quoter_state (leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (30), Quantity(55), Price(2001), Quantity(45), Quantity(15), false);
verify_complete_quoter_state (leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (55), Quantity(30), Price(2000), Quantity(70), Quantity(15), false);
generic_validate_hedgers (HedgerState::WORKING);
LOG(OrderMan, Diag, "spreader_WORKING.on_book");
// 5. remove the market
@@ -1766,8 +1766,8 @@ TEST_CASE ("spreader_WORKING", "[spreader]")
true);
spreader.on_book (bts::orderman::NullTickToTradeCorID, modified_book);
verify_basic_spreader_state (spreader, SpreaderState::WORKING, spreader_price, spreader_quantity);
verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, false, spreader_price, Quantity (100), Quantity (30), Quantity(55), Price(2001), Quantity(45), Quantity(15), false);
verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (55), Quantity(30), Price(2000), Quantity(70), Quantity(15), false);
verify_complete_quoter_state (leg_data_1.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, false, spreader_price, Quantity (100), Quantity (30), Quantity(55), Price(2001), Quantity(45), Quantity(15), false);
verify_complete_quoter_state (leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (55), Quantity(30), Price(2000), Quantity(70), Quantity(15), false);
generic_validate_hedgers (HedgerState::WORKING);
LOG(OrderMan, Diag, "spreader_WORKING.on_book");
}
@@ -1794,8 +1794,8 @@ TEST_CASE ("spreader_WORKING", "[spreader]")
spreader.on_child_update (leg_data_2.get_hedger(i).order_update_message().order_key(), api::orderman::OrderStatus::OS_NEW, Quantity (0), Price (0), nullptr);
bts_assert (leg_data_1.n_hedgers () == 4);
bts_assert (leg_data_2.n_hedgers () == 2);
verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (30), Quantity(65), Price(2003), Quantity(35), Quantity(5), false);
verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (65), Quantity(30), Price(1999), Quantity(70), Quantity(5), false);
verify_complete_quoter_state (leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (30), Quantity(65), Price(2003), Quantity(35), Quantity(5), false);
verify_complete_quoter_state (leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (65), Quantity(30), Price(1999), Quantity(70), Quantity(5), false);
verify_complete_hedger_state (leg_data_1.get_hedger (0).hedger(), HedgerState::WORKING, Price (2002), Quantity(15), Quantity (0), Price(2002), Quantity (15), Quantity (15));
verify_complete_hedger_state (leg_data_1.get_hedger (1).hedger(), HedgerState::WORKING, Price (2002), Quantity(30), Quantity (0), Price(2002), Quantity (30), Quantity (30));
verify_complete_hedger_state (leg_data_1.get_hedger (2).hedger(), HedgerState::WORKING, Price (2002), Quantity(10), Quantity (0), Price(2002), Quantity (10), Quantity (10));
@@ -1815,8 +1815,8 @@ TEST_CASE ("spreader_WORKING", "[spreader]")
spreader.on_child_update (leg_data_2.get_hedger(i).order_update_message().order_key(), api::orderman::OrderStatus::OS_NEW, Quantity (0), Price (0), nullptr);
bts_assert (leg_data_1.n_hedgers () == 4);
bts_assert (leg_data_2.n_hedgers () == 2);
verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, false, spreader_price, Quantity (100), Quantity (30), Quantity(70), Price(2003), Quantity(45), Quantity(0), true);
verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::END, false, spreader_price, Quantity (100), Quantity (0), Quantity(30), Price(0), Quantity(0), Quantity(0), true);
verify_complete_quoter_state (leg_data_1.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, false, spreader_price, Quantity (100), Quantity (30), Quantity(70), Price(2003), Quantity(45), Quantity(0), true);
verify_complete_quoter_state (leg_data_2.quoter(), QuoterState::END, false, spreader_price, Quantity (100), Quantity (0), Quantity(30), Price(0), Quantity(0), Quantity(0), true);
verify_complete_hedger_state (leg_data_1.get_hedger (0).hedger(), HedgerState::WORKING, Price (2002), Quantity(15), Quantity (0), Price(2002), Quantity (15), Quantity (15));
verify_complete_hedger_state (leg_data_1.get_hedger (1).hedger(), HedgerState::WORKING, Price (2002), Quantity(30), Quantity (0), Price(2002), Quantity (30), Quantity (30));
verify_complete_hedger_state (leg_data_1.get_hedger (2).hedger(), HedgerState::WORKING, Price (2002), Quantity(10), Quantity (0), Price(2002), Quantity (10), Quantity (10));
@@ -1870,8 +1870,8 @@ TEST_CASE ("spreader_WORKING", "[spreader]")
spreader.on_child_update (leg_data_2.order_key(), api::orderman::OrderStatus::OS_FILLED, Quantity (70), Price (2001), nullptr);
bts_assert (leg_data_1.n_hedgers () == 4);
bts_assert (leg_data_2.n_hedgers () == 2);
verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, false, spreader_price, Quantity (100), Quantity (30), Quantity(70), Price(2003), Quantity(45), Quantity(0), true);
verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::END, false, spreader_price, Quantity (100), Quantity (0), Quantity(30), Price(0), Quantity(0), Quantity(0), true);
verify_complete_quoter_state (leg_data_1.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, false, spreader_price, Quantity (100), Quantity (30), Quantity(70), Price(2003), Quantity(45), Quantity(0), true);
verify_complete_quoter_state (leg_data_2.quoter(), QuoterState::END, false, spreader_price, Quantity (100), Quantity (0), Quantity(30), Price(0), Quantity(0), Quantity(0), true);
verify_complete_hedger_state (leg_data_1.get_hedger (0).hedger(), HedgerState::WORKING, Price (2002), Quantity(15), Quantity (0), Price(2002), Quantity (15), Quantity (15));
verify_complete_hedger_state (leg_data_1.get_hedger (1).hedger(), HedgerState::WORKING, Price (2002), Quantity(30), Quantity (0), Price(2002), Quantity (30), Quantity (30));
verify_complete_hedger_state (leg_data_1.get_hedger (2).hedger(), HedgerState::WORKING, Price (2002), Quantity(10), Quantity (0), Price(2002), Quantity (10), Quantity (10));
@@ -1882,7 +1882,7 @@ TEST_CASE ("spreader_WORKING", "[spreader]")
// when all of them are at the end state, the spreader
// should also go to end
spreader.on_child_update (leg_data_1.order_key(), api::orderman::OrderStatus::OS_CANCELED, Quantity (30), Price (2001), nullptr);
verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::END, false, spreader_price, Quantity (100), Quantity (0), Quantity(70), Price(0), Quantity(0), Quantity(0), true);
verify_complete_quoter_state (leg_data_1.quoter(), QuoterState::END, false, spreader_price, Quantity (100), Quantity (0), Quantity(70), Price(0), Quantity(0), Quantity(0), true);
verify_basic_spreader_state (spreader, SpreaderState::WORKING, spreader_price, spreader_quantity);
// all the quoters are done now
spreader.on_child_update (leg_data_1.get_hedger (0).order_update_message().order_key(), api::orderman::OrderStatus::OS_FILLED, Quantity (15), Price (2002), nullptr);
@@ -1948,28 +1948,28 @@ TEST_CASE ("spreader_WAITING_FOR_CANCEL_ACK", "[spreader]")
// verify working orders
SpreaderBookkeepingData& bookkeeping_data = spreader.test_only_func_spreader_full_data ();
SpreaderLegData& leg_data_1 = bookkeeping_data.get_leg_data (0); SpreaderLegData& leg_data_2 = bookkeeping_data.get_leg_data (1);
verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (0), Quantity(0), Price(1999), Quantity(100), Quantity(100), false);
verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (0), Quantity(0), Price(2002), Quantity(100), Quantity(100), false);
verify_complete_quoter_state (leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (0), Quantity(0), Price(1999), Quantity(100), Quantity(100), false);
verify_complete_quoter_state (leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (0), Quantity(0), Price(2002), Quantity(100), Quantity(100), false);
// send fill on leg 1 (20)
spreader.on_child_update (leg_data_1.order_key(), api::orderman::OrderStatus::OS_PARTIALLY_FILLED, Quantity (20), Price (2000), nullptr);
verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (20), Quantity(0), Price(2000), Quantity(100), Quantity(80), false);
verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (0), Quantity(20), Price(2002), Quantity(80), Quantity(80), false);
verify_complete_quoter_state (leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (20), Quantity(0), Price(2000), Quantity(100), Quantity(80), false);
verify_complete_quoter_state (leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (0), Quantity(20), Price(2002), Quantity(80), Quantity(80), false);
// send another fill on leg 1 (10)
spreader.on_child_update (leg_data_1.order_key(), api::orderman::OrderStatus::OS_PARTIALLY_FILLED, Quantity (30), Price (2000), nullptr);
verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (30), Quantity(0), Price(2000), Quantity(100), Quantity(70), false);
verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (0), Quantity(30), Price(2002), Quantity(70), Quantity(70), false);
verify_complete_quoter_state (leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (30), Quantity(0), Price(2000), Quantity(100), Quantity(70), false);
verify_complete_quoter_state (leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (0), Quantity(30), Price(2002), Quantity(70), Quantity(70), false);
// send fill on leg 2 (15)
spreader.on_child_update (leg_data_2.order_key(), api::orderman::OrderStatus::OS_PARTIALLY_FILLED, Quantity (15), Price (2001), nullptr);
verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (30), Quantity(15), Price(2001), Quantity(85), Quantity(55), false);
verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (15), Quantity(30), Price(2002), Quantity(70), Quantity(55), false);
verify_complete_quoter_state (leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (30), Quantity(15), Price(2001), Quantity(85), Quantity(55), false);
verify_complete_quoter_state (leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (15), Quantity(30), Price(2002), Quantity(70), Quantity(55), false);
// send another fill on leg 2 (30)
spreader.on_child_update (leg_data_2.order_key(), api::orderman::OrderStatus::OS_PARTIALLY_FILLED, Quantity (45), Price (2001), nullptr);
verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (30), Quantity(45), Price(2002), Quantity(55), Quantity(25), false);
verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (45), Quantity(30), Price(2000), Quantity(70), Quantity(25), false);
verify_complete_quoter_state (leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (30), Quantity(45), Price(2002), Quantity(55), Quantity(25), false);
verify_complete_quoter_state (leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (45), Quantity(30), Price(2000), Quantity(70), Quantity(25), false);
// send another fill on leg 2 (10)
spreader.on_child_update (leg_data_2.order_key(), api::orderman::OrderStatus::OS_PARTIALLY_FILLED, Quantity (55), Price (2001), nullptr);
verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (30), Quantity(55), Price(2003), Quantity(45), Quantity(15), false);
verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (55), Quantity(30), Price(2000), Quantity(70), Quantity(15), false);
verify_complete_quoter_state (leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (30), Quantity(55), Price(2003), Quantity(45), Quantity(15), false);
verify_complete_quoter_state (leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (55), Quantity(30), Price(2000), Quantity(70), Quantity(15), false);
// verify the hedgers
// leg 1 should have 3 hedgers, for each of the 3 fills
bts_assert (leg_data_1.n_hedgers() == 3);
@@ -1993,8 +1993,8 @@ TEST_CASE ("spreader_WAITING_FOR_CANCEL_ACK", "[spreader]")
verify_basic_spreader_state (spreader, SpreaderState::WAITING_FOR_CANCEL_ALL, spreader_price, spreader_quantity);
bts_assert (leg_data_1.n_hedgers () == 3);
bts_assert (leg_data_2.n_hedgers () == 2);
verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, true, spreader_price, Quantity (100), Quantity (30), Quantity(55), Price(2003), Quantity(45), Quantity(15), false);
verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, true, spreader_price, Quantity (100), Quantity (55), Quantity(30), Price(2000), Quantity(70), Quantity(15), false);
verify_complete_quoter_state (leg_data_1.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, true, spreader_price, Quantity (100), Quantity (30), Quantity(55), Price(2003), Quantity(45), Quantity(15), false);
verify_complete_quoter_state (leg_data_2.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, true, spreader_price, Quantity (100), Quantity (55), Quantity(30), Price(2000), Quantity(70), Quantity(15), false);
verify_complete_hedger_state (leg_data_1.get_hedger (0).hedger(), HedgerState::WAITING_FOR_CANCEL_ACK, Price (2002), Quantity(15), Quantity (0), Price(2002), Quantity (15), Quantity (15));
verify_complete_hedger_state (leg_data_1.get_hedger (1).hedger(), HedgerState::WAITING_FOR_CANCEL_ACK, Price (2002), Quantity(30), Quantity (0), Price(2002), Quantity (30), Quantity (30));
verify_complete_hedger_state (leg_data_1.get_hedger (2).hedger(), HedgerState::WAITING_FOR_CANCEL_ACK, Price (2002), Quantity(10), Quantity (0), Price(2002), Quantity (10), Quantity (10));
@@ -2016,7 +2016,7 @@ TEST_CASE ("spreader_WAITING_FOR_CANCEL_ACK", "[spreader]")
for (size_t i = 0; i < bookkeeping_data.n_legs(); i++)
{
SpreaderLegData& leg_data = bookkeeping_data.get_leg_data (i);
bts_assert (leg_data.quoter()->test_only_func_quoter_state() == QuoterState::END);
bts_assert (leg_data.quoter().test_only_func_quoter_state() == QuoterState::END);
// all hedgers should be in the end state
for (size_t h = 0; h < leg_data.n_hedgers(); h++)
bts_assert (leg_data.get_hedger (h).hedger().test_only_func_hedger_state() == HedgerState::END);
@@ -2059,8 +2059,8 @@ TEST_CASE ("spreader_WAITING_FOR_CANCEL_ACK", "[spreader]")
}
int64_t time_since_cxl = ms_diff (std::chrono::system_clock::now(), cancel_timestamp);
bts_assert (time_since_cxl >= spreader.test_cancel_timeout());
verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::END, true, spreader_price, Quantity (100), Quantity (30), Quantity(55), Price(2003), Quantity(45), Quantity(15), false);
verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::END, true, spreader_price, Quantity (100), Quantity (55), Quantity(30), Price(2000), Quantity(70), Quantity(15), false);
verify_complete_quoter_state (leg_data_1.quoter(), QuoterState::END, true, spreader_price, Quantity (100), Quantity (30), Quantity(55), Price(2003), Quantity(45), Quantity(15), false);
verify_complete_quoter_state (leg_data_2.quoter(), QuoterState::END, true, spreader_price, Quantity (100), Quantity (55), Quantity(30), Price(2000), Quantity(70), Quantity(15), false);
verify_complete_hedger_state (leg_data_1.get_hedger (0).hedger(), HedgerState::END, Price (2002), Quantity(15), Quantity (0), Price(2002), Quantity (15), Quantity (15));
verify_complete_hedger_state (leg_data_1.get_hedger (1).hedger(), HedgerState::END, Price (2002), Quantity(30), Quantity (0), Price(2002), Quantity (30), Quantity (30));
verify_complete_hedger_state (leg_data_1.get_hedger (2).hedger(), HedgerState::END, Price (2002), Quantity(10), Quantity (0), Price(2002), Quantity (10), Quantity (10));
@@ -2083,8 +2083,8 @@ TEST_CASE ("spreader_WAITING_FOR_CANCEL_ACK", "[spreader]")
verify_basic_spreader_state (spreader, SpreaderState::WAITING_FOR_CANCEL_ALL, spreader_price, spreader_quantity);
bts_assert (leg_data_1.n_hedgers () == 3);
bts_assert (leg_data_2.n_hedgers () == 2);
verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, true, spreader_price, Quantity (100), Quantity (40), Quantity(55), Price(2003), Quantity(45), Quantity(5), false);
verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, true, spreader_price, Quantity (100), Quantity (55), Quantity(30), Price(2000), Quantity(70), Quantity(15), false);
verify_complete_quoter_state (leg_data_1.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, true, spreader_price, Quantity (100), Quantity (40), Quantity(55), Price(2003), Quantity(45), Quantity(5), false);
verify_complete_quoter_state (leg_data_2.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, true, spreader_price, Quantity (100), Quantity (55), Quantity(30), Price(2000), Quantity(70), Quantity(15), false);
verify_complete_hedger_state (leg_data_1.get_hedger (0).hedger(), HedgerState::WAITING_FOR_CANCEL_ACK, Price (2002), Quantity(15), Quantity (0), Price(2002), Quantity (15), Quantity (15));
verify_complete_hedger_state (leg_data_1.get_hedger (1).hedger(), HedgerState::WAITING_FOR_CANCEL_ACK, Price (2002), Quantity(30), Quantity (0), Price(2002), Quantity (30), Quantity (30));
verify_complete_hedger_state (leg_data_1.get_hedger (2).hedger(), HedgerState::WAITING_FOR_CANCEL_ACK, Price (2002), Quantity(10), Quantity (0), Price(2002), Quantity (10), Quantity (10));
@@ -2099,8 +2099,8 @@ TEST_CASE ("spreader_WAITING_FOR_CANCEL_ACK", "[spreader]")
verify_basic_spreader_state (spreader, SpreaderState::WAITING_FOR_CANCEL_ALL, spreader_price, spreader_quantity);
bts_assert (leg_data_1.n_hedgers () == 3);
bts_assert (leg_data_2.n_hedgers () == 2);
verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::END, true, spreader_price, Quantity (100), Quantity (0), Quantity(55), Price(0), Quantity(0), Quantity(15), false);
verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, true, spreader_price, Quantity (100), Quantity (55), Quantity(30), Price(2000), Quantity(70), Quantity(15), false);
verify_complete_quoter_state (leg_data_1.quoter(), QuoterState::END, true, spreader_price, Quantity (100), Quantity (0), Quantity(55), Price(0), Quantity(0), Quantity(15), false);
verify_complete_quoter_state (leg_data_2.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, true, spreader_price, Quantity (100), Quantity (55), Quantity(30), Price(2000), Quantity(70), Quantity(15), false);
verify_complete_hedger_state (leg_data_1.get_hedger (0).hedger(), HedgerState::WAITING_FOR_CANCEL_ACK, Price (2002), Quantity(15), Quantity (0), Price(2002), Quantity (15), Quantity (15));
verify_complete_hedger_state (leg_data_1.get_hedger (1).hedger(), HedgerState::WAITING_FOR_CANCEL_ACK, Price (2002), Quantity(30), Quantity (0), Price(2002), Quantity (30), Quantity (30));
verify_complete_hedger_state (leg_data_1.get_hedger (2).hedger(), HedgerState::WAITING_FOR_CANCEL_ACK, Price (2002), Quantity(10), Quantity (0), Price(2002), Quantity (10), Quantity (10));
@@ -2119,8 +2119,8 @@ TEST_CASE ("spreader_WAITING_FOR_CANCEL_ACK", "[spreader]")
{
// send a fill
spreader.on_child_update (leg_data_1.get_hedger (0).order_update_message().order_key(), api::orderman::OrderStatus::OS_PARTIALLY_FILLED, Quantity (10), Price (2000), nullptr);
verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, true, spreader_price, Quantity (100), Quantity (30), Quantity(55), Price(2003), Quantity(45), Quantity(15), false);
verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, true, spreader_price, Quantity (100), Quantity (55), Quantity(30), Price(2000), Quantity(70), Quantity(15), false);
verify_complete_quoter_state (leg_data_1.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, true, spreader_price, Quantity (100), Quantity (30), Quantity(55), Price(2003), Quantity(45), Quantity(15), false);
verify_complete_quoter_state (leg_data_2.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, true, spreader_price, Quantity (100), Quantity (55), Quantity(30), Price(2000), Quantity(70), Quantity(15), false);
verify_complete_hedger_state (leg_data_1.get_hedger (0).hedger(), HedgerState::WAITING_FOR_CANCEL_ACK, Price (2002), Quantity(15), Quantity (10), Price(2002), Quantity (15), Quantity (5));
verify_complete_hedger_state (leg_data_1.get_hedger (1).hedger(), HedgerState::WAITING_FOR_CANCEL_ACK, Price (2002), Quantity(30), Quantity (0), Price(2002), Quantity (30), Quantity (30));
verify_complete_hedger_state (leg_data_1.get_hedger (2).hedger(), HedgerState::WAITING_FOR_CANCEL_ACK, Price (2002), Quantity(10), Quantity (0), Price(2002), Quantity (10), Quantity (10));
@@ -2140,9 +2140,9 @@ TEST_CASE ("spreader_WAITING_FOR_CANCEL_ACK", "[spreader]")
// send cancel for orders, once all quoters and hedgers
// are cancelled, spreader should come to end
spreader.on_child_update (leg_data_1.order_update_message().order_key(), api::orderman::OrderStatus::OS_CANCELED, Quantity (30), Price (2000), nullptr);
verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::END, true, spreader_price, Quantity (100), Quantity (0), Quantity(55), Price(0), Quantity(0), Quantity(15), false);
verify_complete_quoter_state (leg_data_1.quoter(), QuoterState::END, true, spreader_price, Quantity (100), Quantity (0), Quantity(55), Price(0), Quantity(0), Quantity(15), false);
spreader.on_child_update (leg_data_2.order_update_message().order_key(), api::orderman::OrderStatus::OS_CANCELED, Quantity (55), Price (2000), nullptr);
verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::END, true, spreader_price, Quantity (100), Quantity (0), Quantity(30), Price(0), Quantity(0), Quantity(15), false);
verify_complete_quoter_state (leg_data_2.quoter(), QuoterState::END, true, spreader_price, Quantity (100), Quantity (0), Quantity(30), Price(0), Quantity(0), Quantity(15), false);
verify_basic_spreader_state (spreader, SpreaderState::WAITING_FOR_CANCEL_ALL, spreader_price, spreader_quantity);
spreader.on_child_update (leg_data_1.get_hedger (0).order_update_message().order_key(), api::orderman::OrderStatus::OS_CANCELED, Quantity (0), Price (0), nullptr);
verify_complete_hedger_state (leg_data_1.get_hedger (0).hedger(), HedgerState::END, Price (2002), Quantity(15), Quantity (0), Price(0), Quantity (0), Quantity (15));
@@ -2160,43 +2160,43 @@ TEST_CASE ("spreader_WAITING_FOR_CANCEL_ACK", "[spreader]")
}
}
// class Temp
// {
// public:
// int i;
// Temp (int arg_i) : i (arg_i){}
// };
// TEST_CASE ("ref test", "[spreader]")
// {
// Temp* t_ptr = new Temp (100);
// Temp t_val = *t_ptr;
// t_val.i = 200;
// bts_assert (t_ptr->i == 100);
// bts_assert (t_val.i == 200);
// Temp& t_ref = *t_ptr;
// t_ref.i = 200;
// bts_assert (t_ptr->i == 200);
// bts_assert (t_ref.i == 200);
// t_ptr->i = 300;
// bts_assert (t_ptr->i == 300);
// bts_assert (t_ref.i == 300);
// }
// TEST_CASE ("vector ref test", "[spreader]")
// {
// Temp t_val (0);
// std::vector<Temp> t_vect;
// t_vect.push_back (t_val);
// t_vect.push_back (t_val);
// t_vect.push_back (t_val);
// Temp& t_ref = t_vect[1];
// t_ref.i = 100;
// bts_assert (t_vect[1].i == 100);
// for (auto it = t_vect.begin(); it != t_vect.end(); it++)
// {
// Temp& t_it_ref = *it;
// t_it_ref.i = 115;
// }
// bts_assert (t_vect[1].i == 115);
// }
class Temp
{
public:
int i;
Temp (int arg_i) : i (arg_i){}
};
TEST_CASE ("ref test", "[spreader]")
{
Temp* t_ptr = new Temp (100);
Temp t_val = *t_ptr;
t_val.i = 200;
bts_assert (t_ptr->i == 100);
bts_assert (t_val.i == 200);
Temp& t_ref = *t_ptr;
t_ref.i = 200;
bts_assert (t_ptr->i == 200);
bts_assert (t_ref.i == 200);
t_ptr->i = 300;
bts_assert (t_ptr->i == 300);
bts_assert (t_ref.i == 300);
}
TEST_CASE ("vector ref test", "[spreader]")
{
Temp t_val (0);
std::vector<Temp> t_vect;
t_vect.push_back (t_val);
t_vect.push_back (t_val);
t_vect.push_back (t_val);
Temp& t_ref = t_vect[1];
t_ref.i = 100;
bts_assert (t_vect[1].i == 100);
for (auto it = t_vect.begin(); it != t_vect.end(); it++)
{
Temp& t_it_ref = *it;
t_it_ref.i = 115;
}
bts_assert (t_vect[1].i == 115);
}
}}
@@ -20,11 +20,55 @@ SingleFillHedger::SingleFillHedger(ISpreaderManager& spreader_manager,
_leg_property_data (leg_property_data),
_order (order),
_price_quantity_state(hedge_price, hedge_quantity, hedge_side),
_worker (nullptr)
{
_worker (nullptr),
_start_state_worker (this),
_waiting_for_first_ack_state_worker (this),
_waiting_for_first_ack_cancelled_state_worker (this),
_working_state_worker (this),
_waiting_for_cancel_ack_state_worker (this),
_end_state_worker (this)
{
LOG(OrderMan,Diag,"SingleFillHedger cons, sec {} price {} quantity {} order_key {}", leg_property_data.security_key(), hedge_price.value(), hedge_quantity.value(), order.order_key().value());
transform_to_START ();
}
SingleFillHedger::SingleFillHedger (const SingleFillHedger& other)
:
_spreader (other._spreader),
_leg_property_data (other._leg_property_data),
_order (other._order),
_price_quantity_state (other._price_quantity_state),
_worker(nullptr),
_start_state_worker (this, other._start_state_worker),
_waiting_for_first_ack_state_worker (this, other._waiting_for_first_ack_state_worker),
_waiting_for_first_ack_cancelled_state_worker (this, other._waiting_for_first_ack_cancelled_state_worker),
_working_state_worker (this, other._working_state_worker),
_waiting_for_cancel_ack_state_worker (this, other._waiting_for_cancel_ack_state_worker),
_end_state_worker (this, other._end_state_worker)
{
HedgerState state = other._worker->state();
switch(state)
{
case HedgerState::START:
_worker = &_start_state_worker;
break;
case HedgerState::WAITING_FOR_FIRST_ACK:
_worker = &_waiting_for_first_ack_state_worker;
break;
case HedgerState::WAITING_FOR_FIRST_ACK_CANCELLED:
_worker = &_waiting_for_first_ack_cancelled_state_worker;
break;
case HedgerState::WORKING:
_worker = &_working_state_worker;
break;
case HedgerState::WAITING_FOR_CANCEL_ACK:
_worker = &_waiting_for_cancel_ack_state_worker;
break;
case HedgerState::END:
_worker = &_end_state_worker;
break;
}
bts_assert(_worker!=nullptr);
}
/********************************************************************/
/****************************External Calls**************************/
/********************************************************************/
@@ -104,7 +148,7 @@ void SingleFillHedger::_switch_state (IHedgerStateWorker* new_state)
{
LOG(OrderMan, Diag, "SingleFillHedger::_switch_state key: {}, {} -> {} ", _order.order_key().value(), (_worker == nullptr ? "NULL" : _worker->state_text()), new_state->state_text());
_worker = new_state;
_worker->build_once (this);
_worker->on_transition();
}
/********************************************************************/
/******************************Helpers*******************************/
@@ -57,7 +57,7 @@ public:
bts::Price hedge_price,
bts::Quantity hedge_quantity,
api::Side hedge_side);
~SingleFillHedger() {}
SingleFillHedger (const SingleFillHedger&);
//1. leave the start state and submit the order
void init();
//2. called by the spreader when there is an order update
@@ -35,6 +35,21 @@ SingleLegQuoter::SingleLegQuoter(ISpreaderManager& spreader,
}
_transform_to_START ();
}
SingleLegQuoter::SingleLegQuoter(SingleLegQuoter&& other)
:
_two_legged (other._two_legged),
_spreader(other._spreader),
_this_leg_data (other._this_leg_data),
_n_spreader_legs (other._n_spreader_legs),
_order (other._order),
_drivers_temp_usage(other._drivers_temp_usage),
_drivers_commited (other._drivers_commited),
_price_quantity_state(other._price_quantity_state),
_is_permenantly_cancelled (other._is_permenantly_cancelled),
_worker(nullptr)
{
bts_assert (false);
}
/*********************************************************************************/
/*********************************spreader calls**********************************/
/*********************************************************************************/
+7 -4
View File
@@ -56,10 +56,13 @@ public:
bts::Price spread_order_price,
bts::Quantity spread_order_quantity,
bts::orderman::SpreaderOrderBase::ChildOrder child_order);
~SingleLegQuoter()
{
}
public:
SingleLegQuoter() = delete;
SingleLegQuoter (SingleLegQuoter&&);
SingleLegQuoter (const SingleLegQuoter&) = delete;
SingleLegQuoter& operator=(const SingleLegQuoter&) = delete;
SingleLegQuoter& operator=(SingleLegQuoter&&) = delete;
public:
//1. leave the start state and actually starts processing
// market data
void init();
@@ -12,25 +12,34 @@ class SpreaderHedgerData;
class SpreaderBookkeepingData
{
private:
const size_t _n_legs;
std::vector<SpreaderLegData> _leg_data;
std::vector<SingleLegQuoter> _quoters;
std::vector<std::vector<SpreaderHedgerData>> _hedgers;
boost::container::flat_map<uint32_t, size_t> _sec_key_to_index;
Price _price;
Quantity _quantity;
public:
SpreaderBookkeepingData ()
: _leg_data (std::vector<SpreaderLegData>()),
_sec_key_to_index (boost::container::flat_map<uint32_t, size_t>()),
_price (Price(0)),
_quantity (Quantity(0))
{}
SpreaderBookkeepingData(const std::vector<SpreaderLegData>& leg_data, Price price, Quantity quantity)
SpreaderBookkeepingData(size_t n_legs, Price price, Quantity quantity)
:
_leg_data (leg_data),
_n_legs (n_legs),
_price (price),
_quantity (quantity)
{
for (auto it = leg_data.begin(); it != leg_data.end(); ++it)
_sec_key_to_index.insert(std::pair<uint32_t, size_t>(it->leg_property_data().security_key(), it->leg_property_data().leg_index()));
_leg_data.reserve (n_legs);
_quoters.reserve (n_legs);
_hedgers.reserve (n_legs);
}
void add_leg (const LegPropertyData& leg_property_data,
SpreaderOrderBase::ChildOrder child_order,
ISpreaderManager& spreader_manager)
{
_quoters.emplace_back(spreader_manager, leg_property_data, _n_legs, _price, _quantity, child_order);
_hedgers.emplace_back ();
//_hedgers.back().reserve(10);
_leg_data.emplace_back(leg_property_data, _quoters.back(), _hedgers.back (), child_order);
bts_assert (_sec_key_to_index.find(leg_property_data.security_key()) == _sec_key_to_index.end());
_sec_key_to_index.insert(std::pair<uint32_t, size_t>(leg_property_data.security_key(), leg_property_data.leg_index()));
}
SpreaderLegData& get_leg_data (SecurityKey security_key)
{
@@ -49,7 +58,7 @@ public:
return _leg_data[index];
}
size_t n_legs() const { return _leg_data.size(); }
SpreaderLegData* find_leg_from_quoter_orderkey(orderman::OrderKey order_key)
SpreaderLegData* find_leg_from_quoter_orderkey(OrderKey order_key)
{
for (auto q_it = _leg_data.begin(); q_it != _leg_data.end(); q_it++)
if (q_it->leg_property_data().is_active_quoting())
@@ -57,7 +66,7 @@ public:
return &(*q_it);
return nullptr;
}
SpreaderHedgerData* find_hedger_from_orderkey(orderman::OrderKey order_key)
SpreaderHedgerData* find_hedger_from_orderkey(OrderKey order_key)
{
for (auto l_it = _leg_data.begin(); l_it != _leg_data.end(); ++l_it)
{
@@ -67,6 +76,18 @@ public:
}
return nullptr;
}
SpreaderHedgerData& add_new_hedger(ISpreaderManager& spreader_manager,
SpreaderOrderBase::ChildOrder order,
size_t leg_index,
bts::Price hedge_price,
bts::Quantity hedge_quantity)
{
bts_assert(leg_index < _n_legs);
SpreaderLegData& leg_data = _leg_data[leg_index];
std::vector<SpreaderHedgerData>& leg_hedgers = _hedgers[leg_index];
leg_hedgers.emplace_back (spreader_manager, leg_data.leg_property_data(), order, hedge_price, hedge_quantity);
return leg_hedgers.back();
}
Price price () const {return _price;}
Quantity quantity () const {return _quantity;}
void update_order (Price price, Quantity quantity)
@@ -75,5 +96,4 @@ public:
_quantity = quantity;
}
};
}}
@@ -10,17 +10,19 @@ namespace orderman{
class SpreaderHedgerData
{
private:
SingleFillHedger* const _hedger;
SingleFillHedger _hedger;
SpreaderChildOrderState _order_update_message;
public:
SpreaderHedgerData(SingleFillHedger* hedger,
SpreaderChildOrderState order_update_message)
:
_hedger (hedger),
_order_update_message (order_update_message)
SpreaderHedgerData (ISpreaderManager& spreader_manager,
const LegPropertyData& leg_property_data,
SpreaderOrderBase::ChildOrder order,
bts::Price hedge_price,
bts::Quantity hedge_quantity)
: _hedger(spreader_manager, leg_property_data, order, hedge_price, hedge_quantity, leg_property_data.trading_side()),
_order_update_message (order.order_key())
{
}
SingleFillHedger& hedger () {return *_hedger;}
SingleFillHedger& hedger () {return _hedger;}
SpreaderChildOrderState& order_update_message() {return _order_update_message;}
};
}}
+34 -31
View File
@@ -6,6 +6,8 @@
#include "SpreaderChildOrderState.h"
#include <google/protobuf/util/message_differencer.h>
using bts::orderman::SpreaderOrderBase;
namespace bts{
namespace orderman{
// all the data for a leg :
@@ -21,32 +23,46 @@ class SpreaderLegData
{
private:
const LegPropertyData _leg_property_data;
SingleLegQuoter* const _quoter;
orderman::Book _book;
SingleLegQuoter& _quoter;
std::vector<SpreaderHedgerData>& _hedger_data_vector;
SpreaderChildOrderState _order_update_message;
std::vector<SpreaderHedgerData> _hedger_data_vector;
public:
SpreaderLegData(const LegPropertyData& leg_property_data_arg,
SingleLegQuoter* quoter_arg,
orderman::OrderKey order_key)
:
_leg_property_data(leg_property_data_arg),
_quoter (quoter_arg),
_book(),
_order_update_message (SpreaderChildOrderState (order_key)),
_hedger_data_vector() {}
Book _book;
public:
SpreaderLegData (const LegPropertyData& leg_property_data,
SingleLegQuoter& quoter,
std::vector<SpreaderHedgerData>& hedger_data_vector,
SpreaderOrderBase::ChildOrder child_order)
: _leg_property_data (leg_property_data),
_quoter (quoter),
_hedger_data_vector (hedger_data_vector),
_order_update_message (child_order.order_key()),
_book()
{}
SpreaderLegData() = delete;
SpreaderLegData(const SpreaderLegData&) = delete;
SpreaderLegData(SpreaderLegData&& other)
: _leg_property_data (other._leg_property_data),
_quoter (other._quoter),
_hedger_data_vector (other._hedger_data_vector),
_order_update_message (other._order_update_message),
_book()
{
bts_assert (false);
}
SpreaderLegData& operator=(const SpreaderLegData&) = delete;
SpreaderLegData& operator=(SpreaderLegData&&) = delete;
// accessors
const LegPropertyData& leg_property_data() const {return _leg_property_data;}
SingleLegQuoter* quoter() {return _quoter;}
const orderman::Book& book () const {return _book;}
SingleLegQuoter& quoter() {return _quoter;}
const Book& book () const {return _book;}
SpreaderChildOrderState& order_update_message () {return _order_update_message;}
orderman::OrderKey order_key() {return _order_update_message.order_key();}
OrderKey order_key() {return _order_update_message.order_key();}
// returns the number of active hedgers
size_t n_hedgers() { return _hedger_data_vector.size(); }
// returns the hedger at a given index
SpreaderHedgerData& get_hedger(size_t index) {return _hedger_data_vector[index];}
// returns a hedger from its order_key
SpreaderHedgerData* find_hedger_from_orderkey(orderman::OrderKey order_key)
SpreaderHedgerData* find_hedger_from_orderkey(OrderKey order_key)
{
for (auto h_it = _hedger_data_vector.begin(); h_it != _hedger_data_vector.end(); ++h_it)
if (h_it->order_update_message().order_key() == order_key)
@@ -56,19 +72,6 @@ public:
std::vector<SpreaderHedgerData>& get_hedgers () {return _hedger_data_vector;}
// mutators
// called for every book update (copied by value)
void set_book(const orderman::Book& book_arg) {_book = book_arg;}
// adds a new hedger with the given values
SpreaderHedgerData& add_new_hedger(ISpreaderManager& spreader_manager,
bts::orderman::SpreaderOrderBase::ChildOrder order,
bts::Price hedge_price,
bts::Quantity hedge_quantity,
api::Side hedge_side)
{
SpreaderChildOrderState hedger_order_update (order.order_key());
SingleFillHedger* hedger = new SingleFillHedger(spreader_manager, _leg_property_data, order, hedge_price, hedge_quantity, hedge_side);
SpreaderHedgerData hedger_data(hedger, hedger_order_update);
_hedger_data_vector.push_back(hedger_data);
return _hedger_data_vector.back();
}
void update_book(const Book& book_arg) {_book = book_arg;}
};
}}
@@ -10,9 +10,10 @@ class SpreaderChildOrderState;
class Book;
class SingleFillHedger;
class IHedgerStateWorker
{
public:
virtual void build_once (SingleFillHedger* hedger) = 0;
{
public:
// called once when transition to this state happens
virtual void on_transition () = 0;
// state of this worker
virtual HedgerState state () const = 0;
// string representation of the state
@@ -5,8 +5,6 @@
namespace bts{
namespace orderman{
HedgerEndStateWorker::HedgerEndStateWorker () : _state_text ("END"){}
void HedgerEndStateWorker::build_once (SingleFillHedger* hedger) {_hedger = hedger;}
HedgerState HedgerEndStateWorker::state() const {return HedgerState::END;}
const std::string& HedgerEndStateWorker::state_text() const {return _state_text;}
void HedgerEndStateWorker::init()
@@ -10,11 +10,18 @@ class SingleFillHedger;
class HedgerEndStateWorker : public IHedgerStateWorker
{
private:
SingleFillHedger* _hedger;
SingleFillHedger* const _hedger;
const std::string _state_text;
public:
HedgerEndStateWorker ();
void build_once (SingleFillHedger* hedger) override;
HedgerEndStateWorker (SingleFillHedger* hedger)
: _hedger(hedger),
_state_text ("END")
{}
HedgerEndStateWorker (SingleFillHedger* hedger, const HedgerEndStateWorker&)
: HedgerEndStateWorker (hedger)
{
}
void on_transition () override {}
HedgerState state () const override;
const std::string& state_text () const override;
void init () override;
@@ -22,7 +29,6 @@ public:
void on_book (bts::orderman::TickToTradeCorID corid, const bts::orderman::Book& book) override;
void cancel() override;
void terminate() override;
void on_time(const TimeStamp&) override;
void on_time(const TimeStamp&) override;
};
}}
@@ -7,8 +7,6 @@
namespace bts{
namespace orderman{
HedgerStartStateWorker::HedgerStartStateWorker () : _state_text ("START"){}
void HedgerStartStateWorker::build_once (SingleFillHedger* hedger) {_hedger = hedger;}
HedgerState HedgerStartStateWorker::state() const {return HedgerState::START;}
const std::string& HedgerStartStateWorker::state_text() const {return _state_text;}
void HedgerStartStateWorker::init()
@@ -8,11 +8,17 @@ namespace orderman{
class HedgerStartStateWorker : public IHedgerStateWorker
{
private:
SingleFillHedger* _hedger;
SingleFillHedger* const _hedger;
const std::string _state_text;
public:
HedgerStartStateWorker();
void build_once (SingleFillHedger* hedger) override;
HedgerStartStateWorker (SingleFillHedger* hedger)
: _hedger(hedger),
_state_text ("START")
{}
HedgerStartStateWorker (SingleFillHedger* hedger, const HedgerStartStateWorker&)
: HedgerStartStateWorker (hedger)
{}
void on_transition () override {}
HedgerState state () const override;
const std::string& state_text () const override;
void init () override;
@@ -20,7 +26,7 @@ public:
void on_book (bts::orderman::TickToTradeCorID corid, const bts::orderman::Book& book) override;
void cancel() override;
void terminate() override;
void on_time(const TimeStamp&) override;
void on_time(const TimeStamp&) override;
};
}}
@@ -5,8 +5,6 @@
namespace bts{
namespace orderman{
HedgerWaitingForCancelAckStateWorker::HedgerWaitingForCancelAckStateWorker () : _state_text ("WAITING_FOR_CANCEL_ACK"){}
void HedgerWaitingForCancelAckStateWorker::build_once (SingleFillHedger* hedger) {_hedger = hedger;}
HedgerState HedgerWaitingForCancelAckStateWorker::state() const {return HedgerState::WAITING_FOR_CANCEL_ACK;}
const std::string& HedgerWaitingForCancelAckStateWorker::state_text() const {return _state_text;}
void HedgerWaitingForCancelAckStateWorker::init()
@@ -8,11 +8,18 @@ namespace orderman{
class HedgerWaitingForCancelAckStateWorker : public IHedgerStateWorker
{
private:
SingleFillHedger* _hedger;
SingleFillHedger* const _hedger;
const std::string _state_text;
public:
HedgerWaitingForCancelAckStateWorker ();
void build_once (SingleFillHedger* hedger) override;
HedgerWaitingForCancelAckStateWorker (SingleFillHedger* hedger)
: _hedger(hedger),
_state_text ("WAITING_FOR_CANCEL_ACK")
{}
HedgerWaitingForCancelAckStateWorker (SingleFillHedger* hedger, const HedgerWaitingForCancelAckStateWorker&)
: HedgerWaitingForCancelAckStateWorker (hedger)
{
}
void on_transition () override {}
HedgerState state () const override;
const std::string& state_text () const override;
void init () override;
@@ -22,5 +29,4 @@ public:
void terminate() override;
void on_time(const TimeStamp&) override;
};
}}
@@ -6,8 +6,6 @@
namespace bts{
namespace orderman{
HedgerWaitingForFirstAckCancelledStateWorker::HedgerWaitingForFirstAckCancelledStateWorker () : _state_text ("WAITING_FOR_FIRST_ACK_CANCELLED"){}
void HedgerWaitingForFirstAckCancelledStateWorker::build_once (SingleFillHedger* hedger) {_hedger = hedger;}
HedgerState HedgerWaitingForFirstAckCancelledStateWorker::state() const {return HedgerState::WAITING_FOR_FIRST_ACK_CANCELLED;}
const std::string& HedgerWaitingForFirstAckCancelledStateWorker::state_text() const {return _state_text;}
void HedgerWaitingForFirstAckCancelledStateWorker::init()
@@ -8,11 +8,17 @@ namespace orderman{
class HedgerWaitingForFirstAckCancelledStateWorker : public IHedgerStateWorker
{
private:
SingleFillHedger* _hedger;
SingleFillHedger* const _hedger;
const std::string _state_text;
public:
HedgerWaitingForFirstAckCancelledStateWorker ();
void build_once (SingleFillHedger* hedger) override;
HedgerWaitingForFirstAckCancelledStateWorker (SingleFillHedger* hedger)
: _hedger(hedger),
_state_text ("WAITING_FOR_FIRST_ACK_CANCELLED")
{}
HedgerWaitingForFirstAckCancelledStateWorker (SingleFillHedger* hedger, const HedgerWaitingForFirstAckCancelledStateWorker&)
: HedgerWaitingForFirstAckCancelledStateWorker (hedger)
{}
void on_transition () override {}
HedgerState state () const override;
const std::string& state_text () const override;
void init () override;
@@ -22,5 +28,4 @@ public:
void terminate() override;
void on_time(const TimeStamp&) override;
};
}}
@@ -4,8 +4,6 @@
namespace bts{
namespace orderman{
HedgerWaitingForFirstAckStateWorker::HedgerWaitingForFirstAckStateWorker () : _state_text ("WAITING_FOR_FIRST_ACK"){}
void HedgerWaitingForFirstAckStateWorker::build_once (SingleFillHedger* hedger) {_hedger = hedger;}
HedgerState HedgerWaitingForFirstAckStateWorker::state() const {return HedgerState::WAITING_FOR_FIRST_ACK;}
const std::string& HedgerWaitingForFirstAckStateWorker::state_text() const {return _state_text;}
void HedgerWaitingForFirstAckStateWorker::init()
@@ -8,11 +8,17 @@ namespace orderman{
class HedgerWaitingForFirstAckStateWorker : public IHedgerStateWorker
{
private:
SingleFillHedger* _hedger;
SingleFillHedger* const _hedger;
const std::string _state_text;
public:
HedgerWaitingForFirstAckStateWorker ();
void build_once (SingleFillHedger* hedger) override;
HedgerWaitingForFirstAckStateWorker (SingleFillHedger* hedger)
: _hedger(hedger),
_state_text ("WAITING_FOR_FIRST_ACK")
{}
HedgerWaitingForFirstAckStateWorker (SingleFillHedger* hedger, const HedgerWaitingForFirstAckStateWorker&)
: HedgerWaitingForFirstAckStateWorker (hedger)
{}
void on_transition () override {}
HedgerState state () const override;
const std::string& state_text () const override;
void init () override;
@@ -20,7 +26,6 @@ public:
void on_book (bts::orderman::TickToTradeCorID corid, const bts::orderman::Book& book) override;
void cancel() override;
void terminate() override;
void on_time(const TimeStamp&) override;
void on_time(const TimeStamp&) override;
};
}}
@@ -6,12 +6,6 @@
namespace bts{
namespace orderman{
HedgerWorkingStateWorker::HedgerWorkingStateWorker () : _state_text ("WORKING"){}
void HedgerWorkingStateWorker::build_once (SingleFillHedger* hedger)
{
_hedger = hedger;
_order_place_time = _hedger->_spreader.current_time();
}
HedgerState HedgerWorkingStateWorker::state() const {return HedgerState::WORKING;}
const std::string& HedgerWorkingStateWorker::state_text() const {return _state_text;}
void HedgerWorkingStateWorker::init()
@@ -8,12 +8,20 @@ namespace orderman{
class HedgerWorkingStateWorker : public IHedgerStateWorker
{
private:
SingleFillHedger* _hedger;
SingleFillHedger* const _hedger;
const std::string _state_text;
TimeStamp _order_place_time;
public:
HedgerWorkingStateWorker ();
void build_once (SingleFillHedger* hedger) override;
HedgerWorkingStateWorker (SingleFillHedger* hedger)
: _hedger(hedger),
_state_text ("WORKING")
{}
HedgerWorkingStateWorker (SingleFillHedger* hedger, const HedgerWorkingStateWorker& other)
: HedgerWorkingStateWorker (hedger)
{
_order_place_time = other._order_place_time;
}
void on_transition () override {}
HedgerState state () const override;
const std::string& state_text () const override;
void init () override;