This commit is contained in:
Taha Afzal committed 2024-12-26 07:01:30 +00:00
1 parent 187894ca84
commit ce96d42db8
11 files changed
+777 -13057

No files matched your search

+18 -1
View File
@@ -31,7 +31,24 @@
"type": "cppdbg",
"request": "launch",
"program": "/home/bts/spark/build/sparkd-debug-clang/server/sparkd",
"args": ["run"],
"args": [
"run"
],
"stopAtEntry": false,
"cwd": "/home/bts/spark/build/sparkd-debug-clang/server",
"environment": [],
"externalConsole": false,
"MIMode": "gdb",
},
{
"name": "spreader tests2",
"type": "cppdbg",
"request": "launch",
"program": "/home/bts/spark/build/sparkd-debug-clang/server/sparkd",
"args": [
"test",
"[spreader2]"
],
"stopAtEntry": false,
"cwd": "/home/bts/spark/build/sparkd-debug-clang/server",
"environment": [],
+1 -13016
View File
File diff suppressed because it is too large. Load diff
+8
View File
@@ -170,12 +170,20 @@ message OptionContract {
message SpotContract{
}
// his tells the relationshio of a leg with thr previous leg
enum PriceCalc {
ADD = 0;
MULT = 1;
Div = 2;
}
message ContractLeg {
Security security = 10;
double quantity = 20;
Side side = 30;
double price_multiplier = 40;
double leg_delta = 50;
PriceCalc price_calc = 60;
}
message SpreadContract {
@@ -23,6 +23,12 @@ double get_qty_tick(const api::Security &sec) {
return 0.1;
}
}
} else if (
sec.has_spot() && sec.exchange() == ::bts::api::Venue::VENUE_BINANCE) {
return 0.001;
} else if (
sec.has_spot() && sec.exchange() == ::bts::api::Venue::VENUE_OKX) {
return 0.001;
}
return 1.0;
}
@@ -68,7 +74,7 @@ struct SpreaderFractionalQtyHelper ::PImpl {
// bts::api::ContractLeg leg_adj = lpd.leg_contract();
// leg_adj.set_quantity(lpd.size_multiplier() * leg_mult);
// rv.emplace_back(
// lpd.leg_index(), leg_adj, lpd.leg_params(), lpd.trading_side(),
// lpd.leg_index(), leg_adj, lpd.leg_params(), lpconstd.trading_side(),
// api::SyntheticContract::PriceCalc::
// SyntheticContract_PriceCalc_PRICECALC_STANDARD,
// leg_tick_size);
@@ -77,7 +83,7 @@ struct SpreaderFractionalQtyHelper ::PImpl {
// }
SpreaderFractionalQtyHelper::SpreaderFractionalQtyHelper(
OrderKey spreader_ord_key, const std::vector<LegPropertyData> &lpd_vec)
OrderKey /*spreader_ord_key*/, const std::vector<LegPropertyData> &lpd_vec)
: me(new PImpl()) {
for (const auto &lpd : lpd_vec) {
double leg_tick_sz = get_qty_tick(lpd.security());
@@ -91,19 +97,19 @@ SpreaderFractionalQtyHelper::SpreaderFractionalQtyHelper(
leg_tick_sz);
me->leg_mults.push_back({SecurityKey(lpd.security().id()), leg_mult});
}
me->passthrough = true;
size_t i = 0;
for (const auto &lm : me->leg_mults) {
me->passthrough &= lm.passthrough;
const auto &lpd = me->leg_pds.at(i++);
LOG(OrderMan, Info,
"SpreaderFractionalQtyHelper::SpreaderFractionalQtyHelper key: {} "
"leg_sec: {} "
"mult: {} passthrough: {} leg_contract: {} params: {}",
spreader_ord_key.value(), lm.key.value(), lm.qty_mult, lm.passthrough,
utils::pb::to_string(lpd.leg()),
utils::pb::to_string(lpd.leg_params()));
}
//me->passthrough = true;
//size_t i = 0;
// for (const auto &lm : me->leg_mults) {
// me->passthrough &= lm.passthrough;
// const auto &lpd = me->leg_pds.at(i++);
// LOG(OrderMan, Info,
// "SpreaderFractionalQtyHelper::SpreaderFractionalQtyHelper key: {} "
// "leg_sec: {} "
// "mult: {} passthrough: {} leg_contract: {} params: {}",
// spreader_ord_key.value(), lm.key.value(), lm.qty_mult, lm.passthrough,
// utils::pb::to_string(lpd.leg()),
// utils::pb::to_string(lpd.leg_params()));
// }
}
const std::vector<LegPropertyData> &SpreaderFractionalQtyHelper::legs() const {
@@ -12,14 +12,17 @@ class OrderState;
namespace bts::orderman {
class Book;
class OrderStateUpdateEvent;
// forinstruments with fractional qtys this sits on the outside layer and does conversions,
//both for market data and orders
// this resdies inside SpeaderBookkeepingData
class SpreaderFractionalQtyHelper {
public:
// static std::vector<LegPropertyData> transform_legs(
// const std::vector<LegPropertyData> &lpd_vec);
SpreaderFractionalQtyHelper(
OrderKey spreader_ord_key, const std::vector<LegPropertyData> &legs);
const std::vector<LegPropertyData> &legs() const;
// in_ and out_ signify market data / orders coming in or out.
const Book &in_transform_book(const Book &book);
// this is called when the order feedback fomr the outside in to the spreader
const OrderStateUpdateEvent &in_transform_order_event(
SecurityKey sec_key, const OrderStateUpdateEvent &);
Quantity in_transform_spreader_qty(Quantity qty) const;
@@ -82,7 +82,7 @@ bool SpreaderUtils::resolve_synthetic_spread(
it != sec.synthetic().legs().end(); ++it) {
const bts::api::ContractLeg &leg = *it;
if (leg.security().has_future() || leg.security().has_spread() ||
leg.security().has_option()) {
leg.security().has_option() || leg.security().has_spot()) {
const bts::api::Security *leg_sec_ptr =
spreader_pao_services.resolve(
bts::SecurityKey(leg.security().id()));
@@ -156,15 +156,15 @@ bool SpreaderUtils::resolve_synthetic_spread(
} else {
LOG(OrderMan, Error,
"resolve_synthetic_spread failure: could not resolve leg "
"key: {}",
leg.security().id());
"key: {} leg: {}",
leg.security().id(), utils::pb::to_string(leg));
return false;
}
} else {
LOG(OrderMan, Error,
"resolve_synthetic_spread failure: leg with key: {} was not "
"a future or future spread",
leg.security().id());
"a future or future spread or option or spot, leg: {}",
leg.security().id(), utils::pb::to_string(leg));
return false;
}
}
@@ -4,7 +4,7 @@ namespace bts {
namespace orderman {
enum class QuoterState {
START,
WAITING_FOR_SIZE,
WAITING_FOR_SIZE, // means, waiting for the hedge leg's market
WAITING_FOR_FIRST_ACK,
WAITING_FOR_IOC,
WAITING_FOR_FIRST_ACK_CANCELLED,
@@ -5,6 +5,7 @@
#include "lib/md/IMarketDataListener.h"
#include "lib/orderman/orderman_utils/Book.h"
#include "lib/orderman/orders/spreader_orders/spreader/SpreaderUtils.h"
#include "lib/orderman/orders/spreader_orders/spreader_states/SpreaderState.h"
#include "lib/orderman/orders/spreader_orders/tests/tests_common.h"
#include "lib/os/os.h"
#include "lib/utils/helper_macros.h"
@@ -5852,6 +5853,658 @@ TEST_CASE("crossing_orders", "[spreader_matching]") {
}});
}
}
} // namespace orderman
} // namespace bts
namespace bts::orderman::tests {
// QuoteLegPriceQuantityState is used by the quoter
// to keep the state of the order state, ie
// target price, qty
// filled qty
// reduced quantity due to other legs
// output price, qty
// TEST_CASE("fractional_qtys", "[spreader2]") {
// int n = 1000000;
// for (int i = 0; i < n; i++) {
// int j = i;
// REQUIRE(i == j);
// }
// }
TEST_CASE("spreader_main", "[spreader2]") {
bts::orderman::OrderKey order_key(0);
Price spreader_price = Price(1);
Quantity spreader_quantity = Quantity(100);
ContractLeg leg_1, leg_2;
// fill_future_contract_leg(
// leg_1, 2468, "ES", bts::api::Venue::VENUE_GLBX, 2017, 12, 15, 1.0, 1.0,
// api::Side::SIDE_BUY, 1.0, 0.25);
// fill_future_contract_leg(
// leg_2, 13579, "ES", bts::api::Venue::VENUE_GLBX, 2018, 3, 15, -1.0, -1.0,
// api::Side::SIDE_SELL, 1.0, 0.25);
fill_spot_leg(
leg_1, 2468, "BTCUSD", bts::api::Venue::VENUE_BINANCE, 1.0, 1.0,
api::Side::SIDE_BUY, 1.0, 0.25);
fill_spot_leg(
leg_2, 13579, "BTCUSD", bts::api::Venue::VENUE_OKX, 1.0, 1.0,
api::Side::SIDE_SELL, 1.0, 0.25);
std::vector<ContractLeg> contract_legs;
contract_legs.push_back(leg_1);
contract_legs.push_back(leg_2);
Security synthetic_security;
fill_synthetic_security(
synthetic_security, 2000, "synthetic_security", contract_legs);
// execution params/order def
LegSpreaderParams lsp_1, lsp_2, lsp_3;
fill_leg_spreader_params(lsp_1, 1.0, true, 1.0);
fill_leg_spreader_params(lsp_2, -1.0, true, 1.0);
std::vector<LegSpreaderParams> spreader_params;
spreader_params.push_back(lsp_1);
spreader_params.push_back(lsp_2);
bts::api::orderman::OrderDefinition order_def;
fill_spreader_order_definition(
order_def, Side::SIDE_BUY, synthetic_security, spreader_params);
// putting it together in SpreaderBookkeepingData
SpreaderPreActivationOrderServices pao_services(synthetic_security);
std::vector<LegPropertyData> leg_props;
std::vector<bts::api::orderman::OrderDefinition> quoter_ord_defs,
hedger_ord_defs;
SpreaderUtils::resolve_synthetic_spread(
pao_services, order_def, leg_props, quoter_ord_defs, hedger_ord_defs);
SpreaderManagerForTest spreader_manager(
order_key, order_def, pao_services, leg_props, quoter_ord_defs,
hedger_ord_defs);
// speader cons ////////////////////////////////////////
SpreaderOrder spreader(spreader_manager.alt_order_gateway());
std::cout << "spreader(cons) state: "
<< static_cast<int>(spreader.test_only_func_spreader_state())
<< std::endl;
REQUIRE(spreader.test_only_func_spreader_state() == SpreaderState::START);
// speader test_only_on_init_new ////////////////////////////////////////
spreader.test_only_on_init_new(order_def, pao_services);
std::cout << "spreader(test_only_on_init_new) state: "
<< static_cast<int>(spreader.test_only_func_spreader_state())
<< std::endl;
SpreaderOrderServices order_services(nullptr);
// speader test_only_on_activate ////////////////////////////////////////
spreader.test_only_on_activate(
spreader_price, spreader_quantity, order_services);
std::cout << "spreader(test_only_on_activate) state: "
<< static_cast<int>(spreader.test_only_func_spreader_state())
<< std::endl;
SpreaderBookkeepingData &bookkeeping_data =
spreader.test_only_func_spreader_full_data();
verify_basic_spreader_state(
spreader, SpreaderState::WORKING, spreader_price, spreader_quantity);
SpreaderLegData &leg_data_1 = bookkeeping_data.get_leg_data(0);
SpreaderLegData &leg_data_2 = bookkeeping_data.get_leg_data(1);
//return;
verify_complete_quoter_state(
leg_data_1.quoter(), QuoterState::WAITING_FOR_SIZE, false,
spreader_price, Quantity(100 * 1000), Quantity(0), Quantity(0), Price(0),
Quantity(0), Quantity(100 * 1000), false);
// verify_complete_quoter_state(
// leg_data_2.quoter(), QuoterState::WAITING_FOR_SIZE, false,
// spreader_price, Quantity(100), Quantity(0), Quantity(0), Price(0),
// Quantity(0), Quantity(100), false);
// temporary end //////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
return;
set_spreader_orders(
spreader, new double[5]{1999, 1998, 1997, 1996, 1995},
new uint16_t[5]{50, 50, 10, 10, 30},
new double[5]{2000, 2001, 2002, 2003, 2004},
new uint16_t[5]{10, 15, 25, 50, 10},
new double[5]{2002, 2001, 2000, 1999, 1998},
new uint16_t[5]{20, 20, 20, 20, 20},
new double[5]{2003, 2004, 2005, 2006, 2007},
new uint16_t[5]{25, 25, 20, 20, 10}, 0, 0, 0, 0);
// verify working orders
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.test_only_on_child_order_update(
leg_data_1.order_key(), api::orderman::OrderStatus::ORDER_STATUS_WORKING,
Quantity(20), Price(2000));
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.test_only_on_child_order_update(
leg_data_1.order_key(), api::orderman::OrderStatus::ORDER_STATUS_WORKING,
Quantity(30), Price(2000));
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.test_only_on_child_order_update(
leg_data_2.order_key(), api::orderman::OrderStatus::ORDER_STATUS_WORKING,
Quantity(15), Price(2001));
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.test_only_on_child_order_update(
leg_data_2.order_key(), api::orderman::OrderStatus::ORDER_STATUS_WORKING,
Quantity(45), Price(2001));
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.test_only_on_child_order_update(
leg_data_2.order_key(), api::orderman::OrderStatus::ORDER_STATUS_WORKING,
Quantity(55), Price(2001));
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_active_hedgers(); i++)
// if(leg_data_1.get_hedger_test_only(i).is_active_order())
spreader.test_only_on_child_order_update(
leg_data_1.get_hedger_test_only(i).order_state().order_key(),
api::orderman::OrderStatus::ORDER_STATUS_WORKING, Quantity(0),
Price(0));
for (size_t i = 0; i < leg_data_2.n_active_hedgers(); i++)
// if(leg_data_2.get_hedger_test_only(i).is_active_order())
spreader.test_only_on_child_order_update(
leg_data_2.get_hedger_test_only(i).order_state().order_key(),
api::orderman::OrderStatus::ORDER_STATUS_WORKING, Quantity(0),
Price(0));
REQUIRE(leg_data_1.n_active_hedgers() == 3);
REQUIRE(leg_data_2.n_active_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_hedger_state(
leg_data_1.get_hedger_test_only(0), HedgerState::WORKING, Price(2002),
Quantity(15), Quantity(0), Price(2002), Quantity(15), Quantity(15));
verify_complete_hedger_state(
leg_data_1.get_hedger_test_only(1), HedgerState::WORKING, Price(2002),
Quantity(30), Quantity(0), Price(2002), Quantity(30), Quantity(30));
verify_complete_hedger_state(
leg_data_1.get_hedger_test_only(2), HedgerState::WORKING, Price(2002),
Quantity(10), Quantity(0), Price(2002), Quantity(10), Quantity(10));
verify_complete_hedger_state(
leg_data_2.get_hedger_test_only(0), HedgerState::WORKING, Price(1999),
Quantity(20), Quantity(0), Price(1999), Quantity(20), Quantity(20));
verify_complete_hedger_state(
leg_data_2.get_hedger_test_only(1), HedgerState::WORKING, Price(1999),
Quantity(10), Quantity(0), Price(1999), Quantity(10), Quantity(10));
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);
};
auto generic_validate_hedgers = [&](HedgerState hedger_state) -> void {
REQUIRE(leg_data_1.n_active_hedgers() == 3);
REQUIRE(leg_data_2.n_active_hedgers() == 2);
verify_complete_hedger_state(
leg_data_1.get_hedger_test_only(0), hedger_state, Price(2002),
Quantity(15), Quantity(0), Price(2002), Quantity(15), Quantity(15));
verify_complete_hedger_state(
leg_data_1.get_hedger_test_only(1), hedger_state, Price(2002),
Quantity(30), Quantity(0), Price(2002), Quantity(30), Quantity(30));
verify_complete_hedger_state(
leg_data_1.get_hedger_test_only(2), hedger_state, Price(2002),
Quantity(10), Quantity(0), Price(2002), Quantity(10), Quantity(10));
verify_complete_hedger_state(
leg_data_2.get_hedger_test_only(0), hedger_state, Price(1999),
Quantity(20), Quantity(0), Price(1999), Quantity(20), Quantity(20));
verify_complete_hedger_state(
leg_data_2.get_hedger_test_only(1), hedger_state, Price(1999),
Quantity(10), Quantity(0), Price(1999), Quantity(10), Quantity(10));
};
// SECTION("1. init") {}
// SECTION("2. on_connect") {}
// SECTION("4. on_update") {
// // updating the spreader order should cause
// // the quoters to requote. hedgers should
// // be as is
// spreader_price = Price(0);
// spreader_quantity = Quantity(200);
// spreader.on_update(spreader_price, spreader_quantity);
// 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);
// // nothing changes with the hedgers
// generic_validate_hedgers(HedgerState::WORKING);
// LOG(OrderMan, Diag, "spreader_WORKING.on_update");
// }
// SECTION("5. on_cancel") {
// spreader.on_cancel();
// verify_basic_spreader_state(
// spreader, SpreaderState::WAITING_FOR_CANCEL_ALL, spreader_price,
// spreader_quantity);
// generic_validate_quoters(QuoterState::WAITING_FOR_CANCEL_ACK, true);
// generic_validate_hedgers(HedgerState::WAITING_FOR_CANCEL_ACK);
// LOG(OrderMan, Diag, "spreader_WORKING.on_cancel");
// }
// SECTION("6. on_book") {
// // 1. change the market such that it translates to no changes in order
// // leg 1 needs 15 more to get filled. the 15 cumulative size level in leg2
// // comes out to be at 2002, which gives leg1 = spreader_price + leg2 = 1 +
// // 2002 = 2003. changing leg 2's books such that 15 still comes at 2002
// uint32_t leg_1_id = leg_data_1.leg_property_data().security_key(),
// leg_2_id = leg_data_2.leg_property_data().security_key();
// bts::orderman::Book modified_book = get_book(
// SecurityKey(leg_2_id), 5, new double[5]{2004, 2003, 2002, 2001, 2000},
// new uint16_t[5]{5, 5, 5, 0, 0},
// new double[5]{2005, 2006, 2007, 2008, 2009},
// new uint16_t[5]{0, 0, 0, 0, 0}, true);
// spreader.test_only_on_book_update(modified_book);
// verify_basic_spreader_state(
// spreader, SpreaderState::WORKING, spreader_price, spreader_quantity);
// generic_validate_quoters(QuoterState::WORKING, false);
// generic_validate_hedgers(HedgerState::WORKING);
// LOG(OrderMan, Diag, "spreader_WORKING.on_book");
// // 2. change the market to induce a price change
// // we will go back to the prevoius market but make it thinner
// // to force leg 1's quoter to go deeper into leg 2's book
// modified_book = get_book(
// SecurityKey(leg_2_id), 5, new double[5]{2002, 2001, 2000, 1999, 1998},
// new uint16_t[5]{1, 1, 1, 1, 11},
// new double[5]{2003, 2004, 2005, 2006, 2007},
// new uint16_t[5]{25, 25, 20, 20, 10}, true);
// // spreader.on_book (bts::orderman::trace::CorID(), modified_book);
// spreader.test_only_on_book_update(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);
// generic_validate_hedgers(HedgerState::WORKING);
// LOG(OrderMan, Diag, "spreader_WORKING.on_book");
// // 3. shrink to market to force a size change
// // the remaining target is 15, so we'll make the total
// // less than 15
// modified_book = get_book(
// SecurityKey(leg_2_id), 5, new double[5]{2002, 2001, 2000, 1999, 1998},
// new uint16_t[5]{1, 1, 1, 1, 0},
// new double[5]{2003, 2004, 2005, 2006, 2007},
// new uint16_t[5]{25, 25, 20, 20, 10}, true);
// // spreader.on_book (bts::orderman::trace::CorID(), modified_book);
// spreader.test_only_on_book_update(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);
// generic_validate_hedgers(HedgerState::WORKING);
// LOG(OrderMan, Diag, "spreader_WORKING.on_book");
// // 4. change the market to force both a price and size change
// modified_book = get_book(
// SecurityKey(leg_2_id), 5, new double[5]{2002, 2001, 2000, 1999, 1998},
// new uint16_t[5]{1, 1, 13, 1, 1},
// new double[5]{2003, 2004, 2005, 2006, 2007},
// new uint16_t[5]{25, 25, 20, 20, 10}, true);
// // spreader.on_book (bts::orderman::trace::CorID(), modified_book);
// spreader.test_only_on_book_update(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);
// generic_validate_hedgers(HedgerState::WORKING);
// LOG(OrderMan, Diag, "spreader_WORKING.on_book");
// // 5. remove the market
// // this should pull the order
// modified_book = get_book(
// SecurityKey(leg_2_id), 5, new double[5]{2002, 2001, 2000, 1999, 1998},
// new uint16_t[5]{0, 0, 0, 0, 0},
// new double[5]{2003, 2004, 2005, 2006, 2007},
// new uint16_t[5]{25, 25, 20, 20, 10}, true);
// // spreader.on_book (bts::orderman::trace::CorID(), modified_book);
// spreader.test_only_on_book_update(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);
// generic_validate_hedgers(HedgerState::WORKING);
// LOG(OrderMan, Diag, "spreader_WORKING.on_book");
// }
// SECTION("7. on_time") {}
// SECTION("8. on_quoter_order_error") {
// spreader.test_only_on_child_order_update(
// leg_data_1.order_key(),
// bts::api::orderman::OrderStatus::ORDER_STATUS_ERROR, Quantity(30),
// Price(2000));
// verify_basic_spreader_state(
// spreader, SpreaderState::WAITING_FOR_CANCEL_ALL, spreader_price,
// spreader_quantity);
// // the one that has an error goes to the end, the others are waiting on
// // cancel ack's
// REQUIRE(
// spreader.test_only_func_spreader_full_data()
// .get_leg_data(0)
// .quoter()
// .test_only_func_quoter_state() == QuoterState::END);
// REQUIRE(
// spreader.test_only_func_spreader_full_data()
// .get_leg_data(1)
// .quoter()
// .test_only_func_quoter_state() ==
// QuoterState::WAITING_FOR_CANCEL_ACK);
// generic_validate_hedgers(HedgerState::WAITING_FOR_CANCEL_ACK);
// LOG(OrderMan, Diag, "spreader_WORKING.on_quoter_order_error");
// }
// SECTION("9. on_quoter_order_fill") {
// // add one more hedge
// spreader.test_only_on_child_order_update(
// leg_data_2.order_key(),
// bts::api::orderman::OrderStatus::ORDER_STATUS_WORKING, Quantity(65),
// Price(2001));
// for (size_t i = 0; i < leg_data_1.n_active_hedgers(); i++)
// spreader.test_only_on_child_order_update(
// leg_data_1.get_hedger_test_only(i).order_state().order_key(),
// bts::api::orderman::OrderStatus::ORDER_STATUS_WORKING, Quantity(0),
// Price(0));
// for (size_t i = 0; i < leg_data_2.n_active_hedgers(); i++)
// spreader.test_only_on_child_order_update(
// leg_data_2.get_hedger_test_only(i).order_state().order_key(),
// api::orderman::OrderStatus::ORDER_STATUS_WORKING, Quantity(0),
// Price(0));
// REQUIRE(leg_data_1.n_active_hedgers() == 4);
// REQUIRE(leg_data_2.n_active_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_hedger_state(
// leg_data_1.get_hedger_test_only(0), HedgerState::WORKING, Price(2002),
// Quantity(15), Quantity(0), Price(2002), Quantity(15), Quantity(15));
// verify_complete_hedger_state(
// leg_data_1.get_hedger_test_only(1), HedgerState::WORKING, Price(2002),
// Quantity(30), Quantity(0), Price(2002), Quantity(30), Quantity(30));
// verify_complete_hedger_state(
// leg_data_1.get_hedger_test_only(2), HedgerState::WORKING, Price(2002),
// Quantity(10), Quantity(0), Price(2002), Quantity(10), Quantity(10));
// verify_complete_hedger_state(
// leg_data_1.get_hedger_test_only(3), HedgerState::WORKING, Price(2002),
// Quantity(10), Quantity(0), Price(2002), Quantity(10), Quantity(10));
// verify_complete_hedger_state(
// leg_data_2.get_hedger_test_only(0), HedgerState::WORKING, Price(1999),
// Quantity(20), Quantity(0), Price(1999), Quantity(20), Quantity(20));
// verify_complete_hedger_state(
// leg_data_2.get_hedger_test_only(1), HedgerState::WORKING, Price(1999),
// Quantity(10), Quantity(0), Price(1999), Quantity(10), Quantity(10));
// LOG(OrderMan, Diag, "spreader_WORKING.on_quoter_order_fill");
// }
// SECTION("10. on_quoter_order_status_update") {
// // since order update has already been done in 9, lets fill
// // it completely
// spreader.test_only_on_child_order_update(
// leg_data_2.order_key(),
// bts::api::orderman::OrderStatus::ORDER_STATUS_COMPLETED, Quantity(70),
// Price(2001));
// for (size_t i = 0; i < leg_data_1.n_active_hedgers(); i++)
// spreader.test_only_on_child_order_update(
// leg_data_1.get_hedger_test_only(i).order_state().order_key(),
// bts::api::orderman::OrderStatus::ORDER_STATUS_WORKING, Quantity(0),
// Price(0));
// for (size_t i = 0; i < leg_data_2.n_active_hedgers(); i++)
// spreader.test_only_on_child_order_update(
// leg_data_2.get_hedger_test_only(i).order_state().order_key(),
// bts::api::orderman::OrderStatus::ORDER_STATUS_WORKING, Quantity(0),
// Price(0));
// REQUIRE(leg_data_1.n_active_hedgers() == 4);
// REQUIRE(leg_data_2.n_active_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_hedger_state(
// leg_data_1.get_hedger_test_only(0), HedgerState::WORKING, Price(2002),
// Quantity(15), Quantity(0), Price(2002), Quantity(15), Quantity(15));
// verify_complete_hedger_state(
// leg_data_1.get_hedger_test_only(1), HedgerState::WORKING, Price(2002),
// Quantity(30), Quantity(0), Price(2002), Quantity(30), Quantity(30));
// verify_complete_hedger_state(
// leg_data_1.get_hedger_test_only(2), HedgerState::WORKING, Price(2002),
// Quantity(10), Quantity(0), Price(2002), Quantity(10), Quantity(10));
// verify_complete_hedger_state(
// leg_data_1.get_hedger_test_only(3), HedgerState::WORKING, Price(2002),
// Quantity(15), Quantity(0), Price(2002), Quantity(15), Quantity(15));
// verify_complete_hedger_state(
// leg_data_2.get_hedger_test_only(0), HedgerState::WORKING, Price(1999),
// Quantity(20), Quantity(0), Price(1999), Quantity(20), Quantity(20));
// verify_complete_hedger_state(
// leg_data_2.get_hedger_test_only(1), HedgerState::WORKING, Price(1999),
// Quantity(10), Quantity(0), Price(1999), Quantity(10), Quantity(10));
// LOG(OrderMan, Diag, "spreader_WORKING.on_quoter_order_fill");
// }
// SECTION("11. on_hedger_order_error") {
// spreader.test_only_on_child_order_update(
// leg_data_1.get_hedger_test_only(0).order_state().order_key(),
// bts::api::orderman::OrderStatus::ORDER_STATUS_ERROR, Quantity(0),
// Price(0));
// verify_basic_spreader_state(
// spreader, SpreaderState::WAITING_FOR_CANCEL_ALL, spreader_price,
// spreader_quantity);
// generic_validate_quoters(QuoterState::WAITING_FOR_CANCEL_ACK, true);
// REQUIRE(
// leg_data_1.get_hedger_test_only(0).test_only_func_hedger_state() ==
// HedgerState::END);
// REQUIRE(
// leg_data_1.get_hedger_test_only(1).test_only_func_hedger_state() ==
// HedgerState::WAITING_FOR_CANCEL_ACK);
// REQUIRE(
// leg_data_1.get_hedger_test_only(2).test_only_func_hedger_state() ==
// HedgerState::WAITING_FOR_CANCEL_ACK);
// REQUIRE(
// leg_data_2.get_hedger_test_only(0).test_only_func_hedger_state() ==
// HedgerState::WAITING_FOR_CANCEL_ACK);
// REQUIRE(
// leg_data_2.get_hedger_test_only(1).test_only_func_hedger_state() ==
// HedgerState::WAITING_FOR_CANCEL_ACK);
// LOG(OrderMan, Diag, "spreader_WORKING.on_hedger_order_error");
// }
// SECTION("12. on_hedger_order_update") {
// // send as fill for the hedger
// spreader.test_only_on_child_order_update(
// leg_data_1.get_hedger_test_only(0).order_state().order_key(),
// bts::api::orderman::OrderStatus::ORDER_STATUS_WORKING, Quantity(10),
// Price(2002));
// verify_basic_spreader_state(
// spreader, SpreaderState::WORKING, spreader_price, spreader_quantity);
// generic_validate_quoters(QuoterState::WORKING, false);
// REQUIRE(leg_data_1.n_active_hedgers() == 3);
// REQUIRE(leg_data_2.n_active_hedgers() == 2);
// verify_complete_hedger_state(
// leg_data_1.get_hedger_test_only(0), HedgerState::WORKING, Price(2002),
// Quantity(15), Quantity(10), Price(2002), Quantity(15), Quantity(5));
// verify_complete_hedger_state(
// leg_data_1.get_hedger_test_only(1), HedgerState::WORKING, Price(2002),
// Quantity(30), Quantity(0), Price(2002), Quantity(30), Quantity(30));
// verify_complete_hedger_state(
// leg_data_1.get_hedger_test_only(2), HedgerState::WORKING, Price(2002),
// Quantity(10), Quantity(0), Price(2002), Quantity(10), Quantity(10));
// verify_complete_hedger_state(
// leg_data_2.get_hedger_test_only(0), HedgerState::WORKING, Price(1999),
// Quantity(20), Quantity(0), Price(1999), Quantity(20), Quantity(20));
// verify_complete_hedger_state(
// leg_data_2.get_hedger_test_only(1), HedgerState::WORKING, Price(1999),
// Quantity(10), Quantity(0), Price(1999), Quantity(10), Quantity(10));
// LOG(OrderMan, Diag, "spreader_WORKING.on_hedger_order_update");
// }
// SECTION("14. on_check_termination") {
// // the only way to do a termination and transit
// // to END is if the orders get filled. If we cancel
// // it leaves this state; if we send terminal status
// // on the quoters, and its not fully filled, the quoters
// // resubmit and continue
// // leg has 30 hedge deduction, and 55 filled, another 15 will fill it
// // completely
// spreader.test_only_on_child_order_update(
// leg_data_2.order_key(),
// bts::api::orderman::OrderStatus::ORDER_STATUS_COMPLETED, Quantity(70),
// Price(2001));
// REQUIRE(leg_data_1.n_active_hedgers() == 4);
// REQUIRE(leg_data_2.n_active_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_hedger_state(
// leg_data_1.get_hedger_test_only(0), HedgerState::WORKING, Price(2002),
// Quantity(15), Quantity(0), Price(2002), Quantity(15), Quantity(15));
// verify_complete_hedger_state(
// leg_data_1.get_hedger_test_only(1), HedgerState::WORKING, Price(2002),
// Quantity(30), Quantity(0), Price(2002), Quantity(30), Quantity(30));
// verify_complete_hedger_state(
// leg_data_1.get_hedger_test_only(2), HedgerState::WORKING, Price(2002),
// Quantity(10), Quantity(0), Price(2002), Quantity(10), Quantity(10));
// verify_complete_hedger_state(
// leg_data_1.get_hedger_test_only(3),
// HedgerState::WAITING_FOR_FIRST_ACK, Price(2002), Quantity(15),
// Quantity(0), Price(2002), Quantity(15), Quantity(15)); // new hedger
// verify_complete_hedger_state(
// leg_data_2.get_hedger_test_only(0), HedgerState::WORKING, Price(1999),
// Quantity(20), Quantity(0), Price(1999), Quantity(20), Quantity(20));
// verify_complete_hedger_state(
// leg_data_2.get_hedger_test_only(1), HedgerState::WORKING, Price(1999),
// Quantity(10), Quantity(0), Price(1999), Quantity(10), Quantity(10));
// verify_basic_spreader_state(
// spreader, SpreaderState::WORKING, spreader_price, spreader_quantity);
// // now bring the quoter and hedgers to their end states
// // when all of them are at the end state, the spreader
// // should also go to end
// spreader.test_only_on_child_order_update(
// leg_data_1.order_key(),
// bts::api::orderman::OrderStatus::ORDER_STATUS_CANCELED, Quantity(30),
// Price(2001));
// 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.test_only_on_child_order_update(
// leg_data_1.get_hedger_test_only(0).order_state().order_key(),
// bts::api::orderman::OrderStatus::ORDER_STATUS_COMPLETED, Quantity(15),
// Price(2002));
// verify_basic_spreader_state(
// spreader, SpreaderState::WORKING, spreader_price, spreader_quantity);
// spreader.test_only_on_child_order_update(
// leg_data_1.get_hedger_test_only(1).order_state().order_key(),
// bts::api::orderman::OrderStatus::ORDER_STATUS_COMPLETED, Quantity(30),
// Price(2002));
// verify_basic_spreader_state(
// spreader, SpreaderState::WORKING, spreader_price, spreader_quantity);
// spreader.test_only_on_child_order_update(
// leg_data_1.get_hedger_test_only(2).order_state().order_key(),
// bts::api::orderman::OrderStatus::ORDER_STATUS_COMPLETED, Quantity(10),
// Price(2002));
// verify_basic_spreader_state(
// spreader, SpreaderState::WORKING, spreader_price, spreader_quantity);
// spreader.test_only_on_child_order_update(
// leg_data_1.get_hedger_test_only(3).order_state().order_key(),
// bts::api::orderman::OrderStatus::ORDER_STATUS_COMPLETED, Quantity(15),
// Price(2002));
// verify_basic_spreader_state(
// spreader, SpreaderState::WORKING, spreader_price, spreader_quantity);
// spreader.test_only_on_child_order_update(
// leg_data_2.get_hedger_test_only(0).order_state().order_key(),
// bts::api::orderman::OrderStatus::ORDER_STATUS_COMPLETED, Quantity(20),
// Price(1999));
// verify_basic_spreader_state(
// spreader, SpreaderState::WORKING, spreader_price, spreader_quantity);
// spreader.test_only_on_child_order_update(
// leg_data_2.get_hedger_test_only(1).order_state().order_key(),
// bts::api::orderman::OrderStatus::ORDER_STATUS_COMPLETED, Quantity(10),
// Price(1999));
// verify_basic_spreader_state(
// spreader, SpreaderState::END, spreader_price, spreader_quantity);
// LOG(OrderMan, Diag, "spreader_WORKING.on_quoter_order_fill");
// }
}
} // namespace bts::orderman::tests
@@ -3,6 +3,7 @@
#include <map>
#include "lib/domain_model/Security.h"
#include "lib/domain_model/Security.pb.h"
#include "lib/orderman/securities/ISecurityDB.h"
#include "lib/utils/bts_chrono.h"
//#include "lib/utils/REQUIRE.h"
@@ -243,6 +244,23 @@ void _fill_future_security(
c_spec.set_high_tick(tick_size);
sec.mutable_contract_spec()->MergeFrom(c_spec);
}
void _fill_spot_security(
Security &sec,
uint32_t key,
const std::string &symbol,
Venue exchange,
double tick_size) {
sec.set_id(key);
sec.set_symbol(symbol);
sec.set_exchange(exchange);
SpotContract sc;
sec.mutable_spot()->MergeFrom(sc);
ContractSpecification c_spec;
c_spec.set_low_tick(tick_size);
c_spec.set_high_tick(tick_size);
sec.mutable_contract_spec()->MergeFrom(c_spec);
}
// (internal function)
// gives a security fills it with spread leg data (mults etc)
void _fill_contract_leg(
@@ -279,6 +297,23 @@ void fill_future_contract_leg(
_fill_contract_leg(
leg, sec, leg_quantity, price_multiplier, side, leg_delta);
}
void fill_spot_leg(
ContractLeg &leg,
uint32_t key,
const std::string &symbol,
Venue exchange,
double leg_quantity,
double price_multiplier,
Side side,
double leg_delta,
double tick_size) {
Security sec;
_fill_spot_security(sec, key, symbol, exchange, tick_size);
_fill_contract_leg(
leg, sec, leg_quantity, price_multiplier, side, leg_delta);
}
// (public function)
// creates a synthetic security
void fill_synthetic_security(
@@ -364,6 +399,15 @@ void fill_book(
for (size_t i = 0; i < book.n_levels(); i++)
bookside[i] = bts::md::PriceSize_from_double<6>(prices[i], sizes[i]);
}
void fill_book(
bts::orderman::Book &book,
double *prices,
bts::md::Size *sizes,
bts::api::Side side) {
bts::orderman::BookSide &bookside = book.side(side);
for (size_t i = 0; i < book.n_levels(); i++)
bookside[i] = bts::md::PriceSize_from_double<6>(prices[i], sizes[i]);
}
void fill_book(
bts::orderman::Book &book,
double *bid_prices,
@@ -31,10 +31,10 @@ namespace bts::md::DatabentoHandler {
#define SEC_TYPE(name) bts::api::domain::SECURITY_TYPE_##name
using bts::domain::SecurityID;
using bts::api::domain::CallPut;
using bts::api::domain::SecurityType;
using bts::api::domain::Venue;
using bts::domain::SecurityID;
std::string remove_spaces(const std::string_view &str) {
std::string result;
@@ -68,29 +68,31 @@ void DatabentoDatahandler::run(
const std::string &dataset,
const bool filter_securities,
const bool load_reference_data,
const std::chrono::duration<long double> sleep_duration ) {
const std::chrono::duration<long double> sleep_duration) {
(void)filter_securities;
auto sleep_duration_updated = sleep_duration;
if (!use_file) {
sleep_duration_updated = std::chrono::duration<long double>::zero(); // Set to zero for live data
sleep_duration_updated = std::chrono::duration<
long double>::zero(); // Set to zero for live data
}
auto process_security = [&](const databento::Record &record) {
const auto &msg = record.Get<databento::InstrumentDefMsg>();
std::string id = remove_spaces(msg.RawSymbol());
std::string symbol;
switch (venue) {
case api::domain::Venue::VENUE_CBOE:{
symbol = remove_spaces(std::string(msg.underlying.data(),msg.underlying.size()));
case api::domain::Venue::VENUE_CBOE: {
symbol = remove_spaces(
std::string(msg.underlying.data(), msg.underlying.size()));
break;
}
case api::domain::Venue::VENUE_GLBX:
if (id.length() > 5)
return databento::KeepGoing::Continue;
symbol = id.substr(0, 2);
// sec.security_common.cpp = msg.unit_of_measure_qty;
// sec.security_common.cpp = msg.unit_of_measure_qty;
break;
default:
@@ -115,7 +117,8 @@ void DatabentoDatahandler::run(
parse_sec_type({msg.security_type.data(), msg.security_type.size()});
const auto exp_nanos = msg.expiration;
std::string exp_string = databento::ToIso8601(exp_nanos);
const auto expiration_time = bts::core::TimeStamp::from_iso_string(exp_string);
const auto expiration_time =
bts::core::TimeStamp::from_iso_string(exp_string);
switch (sec_type) {
case SEC_TYPE(FUTURE):
@@ -162,7 +165,8 @@ void DatabentoDatahandler::run(
}
sleep_for(sleep_duration_updated);
bts::domain::SecurityID sec_id = bts::domain::SecurityID(sec_id_opt.value());
bts::domain::SecurityID sec_id =
bts::domain::SecurityID(sec_id_opt.value());
domain::Book book;
book.set_security_id(sec_id);
@@ -183,9 +187,7 @@ void DatabentoDatahandler::run(
return databento::KeepGoing::Continue;
};
if (use_file) {
auto client = databento::HistoricalBuilder{}
.SetKey(key)
.Build();
auto client = databento::HistoricalBuilder{}.SetKey(key).Build();
databento::DbnFileStore dbn_file_store(securities_path);
dbn_file_store.Replay(process_security);
databento::DbnFileStore dbn_file_store2(books_path);
@@ -58,8 +58,10 @@ struct MDReplayer ::PImpl {
PImpl(
bts::api::Venue venue,
bts::md::GeneralSecurityIndex &index,
bts::md::MDProducer &md_producer, double replay_speed)
: venue(venue), listener(index, md_producer, venue), replay_speed(replay_speed) {}
bts::md::MDProducer &md_producer,
double replay_speed)
: venue(venue), listener(index, md_producer, venue),
replay_speed(replay_speed) {}
};
MDReplayer::MDReplayer(
bts::api::Venue venue,
@@ -101,7 +103,7 @@ void MDReplayer::_replay_file_once(const std::string &file_name) {
int i = 0;
uint64_t beg_ns = bts::core::TimeStamp::now_ns();
uint64_t last_msg_ts = 0;
double replay_speed = me->replay_speed > 0 ? me->replay_speed: 1;
double replay_speed = me->replay_speed > 0 ? me->replay_speed : 1;
while (!in.eof() && utils::pb::readbuf(in, &rec_msg)) {
if (i++ == 0) {
last_msg_ts = rec_msg.timestamp();
@@ -111,7 +113,7 @@ void MDReplayer::_replay_file_once(const std::string &file_name) {
uint64_t this_msg_ts = rec_msg.timestamp();
bts_assert(this_msg_ts >= last_msg_ts);
uint64_t ts_diff = this_msg_ts - last_msg_ts;
uint64_t adjusted_ts = ts_diff/replay_speed;
uint64_t adjusted_ts = ts_diff / replay_speed;
last_msg_ts = this_msg_ts;
std::this_thread::sleep_for(std::chrono::nanoseconds(adjusted_ts));
_replay_message(rec_msg);