LegData.Quoter is not a pointer any more

This commit is contained in:
Taha Afzal committed 2017-10-12 16:20:17 -04:00
1 parent a945f87864
commit 8a60c65d42
8 files changed
+491 -489

No files matched your search

@@ -31,6 +31,7 @@ SpreaderOrder::SpreaderOrder(securities::SecurityDB &db,
:
SpreaderOrderBase(db, f, os),
_resurrected (true),
_n_legs (0),
me(new PImpl(os.order_status(),
Price(os.spreader().price()),
Quantity(os.spreader().quantity()),
@@ -47,6 +48,7 @@ SpreaderOrder::SpreaderOrder(securities::SecurityDB& db,
:
SpreaderOrderBase(db, f, k, cor),
_resurrected (false),
_n_legs (cor.spreader().security().synthetic().legs().size()),
me(new PImpl(api::orderman::OS_UNACKNOWLEDGED,
Price(cor.spreader().price()),
Quantity(cor.spreader().quantity()),
@@ -69,24 +71,17 @@ SpreaderOrder::SpreaderOrder(securities::SecurityDB& db,
bts_assert(st_it != execution_strategy.leg_params_map().end());
const bts::api::ContractLeg& leg = *it;
api::Side leg_order_side = SpreaderUtils::get_leg_side(cor.spreader().side(), leg);
LegPropertyData leg_property_data(leg_idx++, leg, st_it->second, leg_order_side);
SpreaderBookkeepingData::LegData leg_data(leg_property_data);
LegPropertyData leg_property_data(leg_idx, leg, st_it->second, leg_order_side);
// order
bts::orderman::SpreaderOrderBase::ChildFactory child_factory = get_child_factory(leg_property_data.security(), leg_property_data.trading_side, api::orderman::ChildOrderKind::COK_SPREADER_QUOTING);
bts::orderman::SpreaderOrderBase::ChildOrder child_order = child_factory();
SingleLegQuoter leg_quoter(me_ref, leg_property_data, Price(cor.spreader().price()), Quantity(cor.spreader().quantity()), child_order);
SpreaderBookkeepingData::LegData leg_data(leg_property_data, leg_quoter, child_order.order_key());
leg_data_vector.push_back(leg_data);
leg_idx++;
}
bts_assert(leg_data_vector.size() > 0);
_bookkeeping_data = std::make_unique<SpreaderBookkeepingData>(sec, leg_data_vector);
// now settings up the quoters
for (size_t index = 0; index < _bookkeeping_data->count(); index++)
{
SpreaderBookkeepingData::LegData& leg_data = _bookkeeping_data->get_leg_data(index);
if (leg_data.leg_property_data.is_active_quoting())
{
bts::orderman::SpreaderOrderBase::ChildFactory child_factory = get_child_factory(leg_data.leg_property_data.security(), leg_data.leg_property_data.trading_side, api::orderman::ChildOrderKind::COK_SPREADER_QUOTING);
bts::orderman::SpreaderOrderBase::ChildOrder child_order = child_factory();
leg_data.order_key = child_order.order_key();
leg_data.quoter = new SingleLegQuoter(me_ref, index, Price(cor.spreader().price()), Quantity(cor.spreader().quantity()), child_order);
}
}
}
SpreaderOrder::~SpreaderOrder () {}
@@ -174,7 +169,7 @@ void SpreaderOrder::on_update(const api::orderman::UpdateSpreaderOrder& u)
SpreaderBookkeepingData::LegData& leg_data = _bookkeeping_data->get_leg_data(q_idx);
if (leg_data.leg_property_data.is_active_quoting())
{
accept_changes = accept_changes && leg_data.quoter->accept_modifications();
accept_changes = accept_changes && leg_data.quoter.accept_modifications();
if (!accept_changes)
break;
}
@@ -185,7 +180,7 @@ void SpreaderOrder::on_update(const api::orderman::UpdateSpreaderOrder& u)
{
SpreaderBookkeepingData::LegData& leg_data = _bookkeeping_data->get_leg_data(q_idx);
if (leg_data.leg_property_data.is_active_quoting())
leg_data.quoter->update_order_price_quantity(Price(u.price()), Quantity(u.quantity()));
leg_data.update_order_price_quantity(Price(u.price()), Quantity(u.quantity()));
}
}
}
@@ -240,7 +235,7 @@ void SpreaderOrder::on_book(TickToTradeCorID cid, Book const& book)
{
SpreaderBookkeepingData::LegData& d = _bookkeeping_data->get_leg_data(q_idx);
if (d.leg_property_data.is_active_quoting())
d.quoter->update_md(md_leg.leg_property_data.leg_index);
d.quoter.update_md(md_leg.leg_property_data.leg_index);
}
// send MD to hedgers hedging this security only
for (size_t h_idx = 0; h_idx < md_leg.n_hedgers(); h_idx++)
@@ -316,7 +311,7 @@ void SpreaderOrder::on_child_update(OrderKey orderkey,
{
SpreaderBookkeepingData::LegData& q_leg_data = *(q_leg_data_ptr);
SpreaderOrderUpdateMessage update_message(orderkey, status, filled_quantity, average_price, q_leg_data.filled_quantity, q_leg_data.avergage_filled_price);
q_leg_data_ptr->quoter->update_order_status(update_message);
q_leg_data_ptr->quoter.update_order_status(update_message);
}
else
{
@@ -382,7 +377,7 @@ const LegPropertyData& SpreaderOrder::get_leg_data(size_t leg_index) const
}
size_t SpreaderOrder::n_legs() const
{
return _bookkeeping_data->count();
return _n_legs;
}
void SpreaderOrder::_transform_to_WAITING_FOR_FIRST_CONNECTION()
@@ -404,7 +399,7 @@ void SpreaderOrder::_transform_to_WORKING()
{
SpreaderBookkeepingData::LegData& leg_data = _bookkeeping_data->get_leg_data(index);
if (leg_data.leg_property_data.is_active_quoting())
leg_data.quoter->init();
leg_data.quoter.init();
}
}
void SpreaderOrder::_transform_to_WAITING_FOR_CANCEL_ALL()
@@ -426,7 +421,7 @@ void SpreaderOrder::_handle_quoter_order_update(SpreaderBookkeepingData::LegData
{
// quoter needs to update, if there is a fill, the quoter
// will update its order quantity
leg_data.quoter->update_order_status(update_message);
leg_data.quoter.update_order_status(update_message);
// if there are fill, we need to
// i. update leg_data's price and quantity
// ii. tell other quotes of the fill
@@ -441,7 +436,7 @@ void SpreaderOrder::_handle_quoter_order_update(SpreaderBookkeepingData::LegData
if (idx != leg_data.leg_property_data.leg_index)
{
if (leg_data.leg_property_data.is_active_quoting())
leg_data.quoter->update_other_leg_fills(leg_data.leg_property_data.leg_index, this_fill_quantity);
leg_data.quoter.update_other_leg_fills(leg_data.leg_property_data.leg_index, this_fill_quantity);
_send_hedge(leg_data.leg_property_data.leg_index, this_fill_price, this_fill_quantity, idx);
}
}
@@ -455,7 +450,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++)
@@ -470,7 +465,7 @@ bool SpreaderOrder::_all_quoter_orders_in_terminal_state()
for (size_t q_idx = 0; q_idx < _bookkeeping_data->count(); q_idx++)
{
SpreaderBookkeepingData::LegData& leg_data = _bookkeeping_data->get_leg_data(q_idx);
if (leg_data.leg_property_data.is_active_quoting() && leg_data.quoter->is_active())
if (leg_data.leg_property_data.is_active_quoting() && leg_data.quoter.is_active())
return false;
}
return true;
@@ -108,6 +108,7 @@ private:
void report_state();
private:
const bool _resurrected;
const size_t _n_legs;
struct PImpl;
std::unique_ptr<PImpl> me;
std::unique_ptr<SpreaderBookkeepingData> _bookkeeping_data;
+1 -1
View File
@@ -34,7 +34,7 @@ public:
}
uint32_t security_key() const { return leg_contract.security().id(); }
const bts::api::Security& security() const { return leg_contract.security(); }
double price_multiplier() const { return leg_contract.price_multiplier(); }
double price_multiplier() const { return leg_params.price_multiplier(); }
double size_multiplier() const { return leg_contract.quantity(); }
double tick_size() const { return leg_contract.security().contract_spec().low_tick(); }
bool is_active_quoting() const {return leg_params.is_active_quoting();}
+415 -415
View File
@@ -1,422 +1,422 @@
#include "SimpleSpreader.h"
#include "SingleLegQuoter.h"
#include "SpreaderUtils.h"
#include "SingleFillHedger.h"
#include "SpreaderOrderUpdateMessage.h"
// #include "SimpleSpreader.h"
// #include "SingleLegQuoter.h"
// #include "SpreaderUtils.h"
// #include "SingleFillHedger.h"
// #include "SpreaderOrderUpdateMessage.h"
namespace bts
{
namespace spreader
{
//this is a mock up of what should proably be in the spreadercreate message
class SimpleSpreaderCreate : public SpreaderCreate
{
public:
orderman::AccountName account_name;
orderman::OperatorID operator_id;
api::Side side;
// namespace bts
// {
// namespace spreader
// {
// //this is a mock up of what should proably be in the spreadercreate message
// class SimpleSpreaderCreate : public SpreaderCreate
// {
// public:
// orderman::AccountName account_name;
// orderman::OperatorID operator_id;
// api::Side side;
api::orderman::CustomerOrFirm cust_code;
api::orderman::CTICode cti_code;
UserLogin user_login;
};
// api::orderman::CustomerOrFirm cust_code;
// api::orderman::CTICode cti_code;
// UserLogin user_login;
// };
struct SimpleSpreader::PImpl
{
orderman::OrderKey my_key;
const SimpleSpreaderCreate& create;
bool connected;
PImpl(orderman::OrderKey key, const SpreaderCreate& screate) :
my_key(key),
create(static_cast<const SimpleSpreaderCreate&>(screate)),
connected(false)
{ }
void cancel_all()
{ }
};
// struct SimpleSpreader::PImpl
// {
// orderman::OrderKey my_key;
// const SimpleSpreaderCreate& create;
// bool connected;
// PImpl(orderman::OrderKey key, const SpreaderCreate& screate) :
// my_key(key),
// create(static_cast<const SimpleSpreaderCreate&>(screate)),
// connected(false)
// { }
// void cancel_all()
// { }
// };
SimpleSpreader::SimpleSpreader()
: _state(State::START)
{}
SimpleSpreader::~SimpleSpreader() { }
SpreaderSubscriptions SimpleSpreader::init(orderman::OrderKey my_key, const SpreaderCreate& create)
{
SpreaderSubscriptions subs;
if (_state == State::START)
{
// init is the first call, and is called only once
const api::Security& sec = create.order.security();
_create_order_request = create.create_order_request;
std::vector<SpreaderBookkeepingData::LegData> leg_data_vector;
bts_assert(sec.has_synthetic());
size_t index = 0;
// creating the basic data
//ISpreaderManager& me_ref = *this;
for (auto it = sec.synthetic().legs().begin(); it != sec.synthetic().legs().end(); ++it)
{
uint32_t sec_key = it->security().id();
const spark::ExecutionStrategy& execution_strategy = create.order.execution_strategy();
auto st_it = execution_strategy.leg_params_map().find(sec_key);
bts_assert(st_it != execution_strategy.leg_params_map().end());
const bts::api::ContractLeg& leg = *it;
api::Side leg_order_side = SpreaderUtils::get_leg_side(create.order.side(), leg);
LegPropertyData leg_property_data(index++, leg, st_it->second, leg_order_side);
SpreaderBookkeepingData::LegData leg_data(leg_property_data);
leg_data_vector.push_back(leg_data);
}
_bookkeeping_data = std::make_unique<SpreaderBookkeepingData>(create.order.security(), leg_data_vector);
// now settings up the quoters
for (size_t index = 0; index < _bookkeeping_data->count(); index++)
{
/* OrderTemplate order_template;
SpreaderBookkeepingData::LegData& leg_data = _bookkeeping_data->get_leg_data(index);
leg_data.quoter = new SingleLegQuoter(me_ref, order_template, index, Price(create.order.price()), Quantity(create.order.size()));*/
}
me.reset(new PImpl(my_key, create));
_transform_to_WAITING_FOR_FIRST_CONNECTION();
}
else if (_state == State::WAITING_FOR_FIRST_CONNECTION)
bts_assert(false);
else if (_state == State::WORKING)
bts_assert(false);
else if (_state == State::WAITING_FOR_CANCEL_ALL)
bts_assert(false);
else if (_state == State::END)
bts_assert(false);
return subs;
}
void SimpleSpreader::on_connect()
{
if (_state == State::START)
bts_assert(false);
else if (_state == State::WAITING_FOR_FIRST_CONNECTION)
_transform_to_WORKING();
else if (_state == State::WORKING)
bts_assert(false);
else if (_state == State::WAITING_FOR_CANCEL_ALL)
bts_assert(false);
else if (_state == State::END)
{
// this is ok since once we have disconnected, we
// end up in END, and ignore subsequent re-connections
}
me->connected = true;
}
void SimpleSpreader::on_disconnect()
{
if (_state == State::START)
// getting a disconnect before the first connect is not allowed
bts_assert(false);
else if (_state == WAITING_FOR_FIRST_CONNECTION)
bts_assert(false);
if (_state == State::WORKING)
{
_transform_to_END();
}
else if (_state == State::WAITING_FOR_CANCEL_ALL)
_transform_to_END();
else if (_state == State::END)
{
// it means a connection was established in the end
// state which is dosconnected now
}
if(me->connected)
me->cancel_all();
}
void SimpleSpreader::on_md(const orderman::Book& book)
{
if (_state == State::START)
bts_assert(_state != State::START);
else if (_state == State::WAITING_FOR_FIRST_CONNECTION)
// no md updates until connection is established
bts_assert(false);
else if (_state == State::WORKING)
{
SpreaderBookkeepingData::LegData& 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);
// sending md to all quoters
for (size_t idx = 0; idx < _bookkeeping_data->count(); idx++)
{
SpreaderBookkeepingData::LegData& d = _bookkeeping_data->get_leg_data(idx);
d.quoter->update_md(md_leg.leg_property_data.leg_index);
}
// send MD to hedgers hedging this security only
for (size_t h_idx = 0; h_idx < md_leg.n_hedgers(); h_idx++)
{
SpreaderBookkeepingData::HedgerData h = md_leg.get_hedger(h_idx);
h.hedger.update_md();
}
}
else if (_state == State::WAITING_FOR_CANCEL_ALL)
{
// no need to send md, quoters and hedgers
// done need md when cxl'ing
}
else if (_state == State::END)
{
}
}
void SimpleSpreader::on_child_order_update(orderman::OrderKey orderkey,
api::orderman::OrderStatus status,
Quantity filled_quantity,
Price average_price,
std::string const *error_msg)
{
if (_state == State::START)
bts_assert(false);
else if (_state == State::WAITING_FOR_FIRST_CONNECTION)
bts_assert(false);
else if (_state == State::WORKING)
{
if (_order_update_has_error (error_msg))
_handle_order_error();
else
{
SpreaderBookkeepingData::LegData* q_leg_data_ptr = _bookkeeping_data->find_quoter_from_orderkey(orderkey);
if (q_leg_data_ptr != NULL)
{
SpreaderBookkeepingData::LegData& q_leg_data = *(q_leg_data_ptr);
SpreaderOrderUpdateMessage update_message(orderkey, status, filled_quantity, average_price, q_leg_data.filled_quantity, q_leg_data.avergage_filled_price);
_handle_quoter_order_update(q_leg_data, update_message);
}
else
{
// should be a hedge order then
SpreaderBookkeepingData::HedgerData* hedger_data = _bookkeeping_data->find_hedger_from_orderkey(orderkey);
if (hedger_data != NULL)
{
SpreaderOrderUpdateMessage update_message(orderkey, status, filled_quantity, average_price, hedger_data->filled_quantity, hedger_data->avergage_filled_price);
hedger_data->update_fill(filled_quantity);
hedger_data->hedger.update_order_state(update_message);
}
}
}
}
else if (_state == State::WAITING_FOR_CANCEL_ALL)
{
// all it has to do
SpreaderBookkeepingData::LegData* q_leg_data_ptr = _bookkeeping_data->find_quoter_from_orderkey(orderkey);
if (q_leg_data_ptr != NULL)
{
SpreaderBookkeepingData::LegData& q_leg_data = *(q_leg_data_ptr);
SpreaderOrderUpdateMessage update_message(orderkey, status, filled_quantity, average_price, q_leg_data.filled_quantity, q_leg_data.avergage_filled_price);
q_leg_data_ptr->quoter->update_order_status(update_message);
}
else
{
SpreaderBookkeepingData::HedgerData* hedger_data = _bookkeeping_data->find_hedger_from_orderkey(orderkey);
if (hedger_data != NULL)
{
SpreaderOrderUpdateMessage update_message(orderkey, status, filled_quantity, average_price, hedger_data->filled_quantity, hedger_data->avergage_filled_price);
hedger_data->update_fill(filled_quantity);
hedger_data->hedger.update_order_state(update_message);
}
}
if (_all_quoter_orders_in_terminal_state() && _all_hedger_orders_in_terminal_state())
_transform_to_END();
}
else if (_state == State::END)
{
// it could have reached this state through an
// error in which case, as far as the spreader
// is concerned, no updates will be sent
}
}
void SimpleSpreader::on_time(const TimeStamp&)
{
}
void SimpleSpreader::on_user_update(const SpreaderUpdate& spreader_update)
{
// TODO : send status updates out
if (_state == State::START)
{
}
else if (_state == State::WAITING_FOR_FIRST_CONNECTION)
{
}
else if (_state == State::WORKING)
{
// check if all quoters can accept the change
bool accept_changes = true;
for (size_t q_idx = 0; q_idx < _bookkeeping_data->count(); q_idx++)
{
SpreaderBookkeepingData::LegData& leg_data = _bookkeeping_data->get_leg_data(q_idx);
accept_changes = accept_changes && leg_data.quoter->accept_modifications();
if (!accept_changes)
break;
}
if (accept_changes)
{
for (size_t q_idx = 0; q_idx < _bookkeeping_data->count(); q_idx++)
{
SpreaderBookkeepingData::LegData& leg_data = _bookkeeping_data->get_leg_data(q_idx);
leg_data.quoter->update_order_price_quantity(spreader_update.price, spreader_update.quantity);
}
}
}
else if (_state == State::WAITING_FOR_CANCEL_ALL)
{
}
else if (_state == State::END)
{
}
}
void SimpleSpreader::on_user_cancel()
{
_transform_to_WAITING_FOR_CANCEL_ALL();
}
void SimpleSpreader::on_limit_breach()
{
_transform_to_WAITING_FOR_CANCEL_ALL();
}
void SimpleSpreader::on_system_error()
{
_transform_to_WAITING_FOR_CANCEL_ALL();
}
bts::orderman::OrderKey SimpleSpreader::send_limit_order(const OrderTemplate& t, bts::Price price, bts::Quantity quantity)
{
return create_child(t, price, quantity);
}
void SimpleSpreader::update_order(bts::orderman::OrderKey order_key, bts::Price price, bts::Quantity quantity)
{
update_child(order_key, price, quantity);
}
void SimpleSpreader::cancel_order(bts::orderman::OrderKey order_key)
{
cancel_child(order_key);
}
const orderman::Book& SimpleSpreader::get_book(size_t leg_index) const
{
return _bookkeeping_data->get_leg_data(leg_index).book;
}
const LegPropertyData& SimpleSpreader::get_leg_data(size_t leg_index) const
{
return _bookkeeping_data->get_leg_data(leg_index).leg_property_data;
}
size_t SimpleSpreader::n_legs() const
{
return _bookkeeping_data->count();
}
void SimpleSpreader::_transform_to_WAITING_FOR_FIRST_CONNECTION()
{
bts_assert(_state == State::START);
_state = State::WAITING_FOR_FIRST_CONNECTION;
}
void SimpleSpreader::_transform_to_WORKING()
{
bts_assert(_state == State::WAITING_FOR_FIRST_CONNECTION);
_state = State::WORKING;
for (size_t index = 0; index < _bookkeeping_data->count(); index++)
{
SpreaderBookkeepingData::LegData& leg_data = _bookkeeping_data->get_leg_data(index);
leg_data.quoter->init();
}
}
void SimpleSpreader::_transform_to_WAITING_FOR_CANCEL_ALL()
{
bts_assert(_state == State::WORKING);
_state = State::WAITING_FOR_CANCEL_ALL;
_cancel_orders(true, true);
}
void SimpleSpreader::_transform_to_END()
{
bts_assert(_state == State::WORKING || _state == State::WAITING_FOR_CANCEL_ALL);
_state = State::END;
}
void SimpleSpreader::_handle_order_error()
{
// TODO report it
_transform_to_WAITING_FOR_CANCEL_ALL();
}
void SimpleSpreader::_handle_quoter_order_update(SpreaderBookkeepingData::LegData& leg_data, const SpreaderOrderUpdateMessage& update_message)
{
// quoter needs to update, if there is a fill, the quoter
// will update its order quantity
leg_data.quoter->update_order_status(update_message);
// if there are fill, we need to
// i. update leg_data's price and quantity
// ii. tell other quotes of the fill
// iii send hedges
Quantity this_fill_quantity; Price this_fill_price;
if (update_message.update_fill_price_quantity (this_fill_quantity, this_fill_price))
{
leg_data.filled_quantity = update_message.filled_quantity;
leg_data.avergage_filled_price = update_message.average_price;
for (size_t idx = 0; idx < _bookkeeping_data->count(); idx++)
{
if (idx != leg_data.leg_property_data.leg_index)
{
leg_data.quoter->update_other_leg_fills(leg_data.leg_property_data.leg_index, this_fill_quantity);
_send_hedge(leg_data.leg_property_data.leg_index, this_fill_price, this_fill_quantity, idx);
}
}
}
}
void SimpleSpreader::_cancel_orders(bool cancel_quotes, bool cancel_hedges)
{
for (size_t q_idx = 0; q_idx < _bookkeeping_data->count(); q_idx++)
{
SpreaderBookkeepingData::LegData& leg_data = _bookkeeping_data->get_leg_data(q_idx);
if (cancel_quotes)
leg_data.quoter->cancel_order();
if (cancel_hedges)
for (size_t h_idx = 0; h_idx < leg_data.n_hedgers(); h_idx++)
{
SpreaderBookkeepingData::HedgerData& hedger_data = leg_data.get_hedger(h_idx);
hedger_data.hedger.cancel_hedge();
}
}
}
bool SimpleSpreader::_all_quoter_orders_in_terminal_state()
{
for (size_t q_idx = 0; q_idx < _bookkeeping_data->count(); q_idx++)
{
SpreaderBookkeepingData::LegData& leg_data = _bookkeeping_data->get_leg_data(q_idx);
if (leg_data.quoter->is_active())
return false;
}
return true;
}
// SimpleSpreader::SimpleSpreader()
// : _state(State::START)
// {}
// SimpleSpreader::~SimpleSpreader() { }
// SpreaderSubscriptions SimpleSpreader::init(orderman::OrderKey my_key, const SpreaderCreate& create)
// {
// SpreaderSubscriptions subs;
// if (_state == State::START)
// {
// // init is the first call, and is called only once
// const api::Security& sec = create.order.security();
// _create_order_request = create.create_order_request;
// std::vector<SpreaderBookkeepingData::LegData> leg_data_vector;
// bts_assert(sec.has_synthetic());
// size_t index = 0;
// // creating the basic data
// //ISpreaderManager& me_ref = *this;
// for (auto it = sec.synthetic().legs().begin(); it != sec.synthetic().legs().end(); ++it)
// {
// uint32_t sec_key = it->security().id();
// const spark::ExecutionStrategy& execution_strategy = create.order.execution_strategy();
// auto st_it = execution_strategy.leg_params_map().find(sec_key);
// bts_assert(st_it != execution_strategy.leg_params_map().end());
// const bts::api::ContractLeg& leg = *it;
// api::Side leg_order_side = SpreaderUtils::get_leg_side(create.order.side(), leg);
// LegPropertyData leg_property_data(index++, leg, st_it->second, leg_order_side);
// SpreaderBookkeepingData::LegData leg_data(leg_property_data);
// leg_data_vector.push_back(leg_data);
// }
// _bookkeeping_data = std::make_unique<SpreaderBookkeepingData>(create.order.security(), leg_data_vector);
// // now settings up the quoters
// for (size_t index = 0; index < _bookkeeping_data->count(); index++)
// {
// /* OrderTemplate order_template;
// SpreaderBookkeepingData::LegData& leg_data = _bookkeeping_data->get_leg_data(index);
// leg_data.quoter = new SingleLegQuoter(me_ref, order_template, index, Price(create.order.price()), Quantity(create.order.size()));*/
// }
// me.reset(new PImpl(my_key, create));
// _transform_to_WAITING_FOR_FIRST_CONNECTION();
// }
// else if (_state == State::WAITING_FOR_FIRST_CONNECTION)
// bts_assert(false);
// else if (_state == State::WORKING)
// bts_assert(false);
// else if (_state == State::WAITING_FOR_CANCEL_ALL)
// bts_assert(false);
// else if (_state == State::END)
// bts_assert(false);
// return subs;
// }
// void SimpleSpreader::on_connect()
// {
// if (_state == State::START)
// bts_assert(false);
// else if (_state == State::WAITING_FOR_FIRST_CONNECTION)
// _transform_to_WORKING();
// else if (_state == State::WORKING)
// bts_assert(false);
// else if (_state == State::WAITING_FOR_CANCEL_ALL)
// bts_assert(false);
// else if (_state == State::END)
// {
// // this is ok since once we have disconnected, we
// // end up in END, and ignore subsequent re-connections
// }
// me->connected = true;
// }
// void SimpleSpreader::on_disconnect()
// {
// if (_state == State::START)
// // getting a disconnect before the first connect is not allowed
// bts_assert(false);
// else if (_state == WAITING_FOR_FIRST_CONNECTION)
// bts_assert(false);
// if (_state == State::WORKING)
// {
// _transform_to_END();
// }
// else if (_state == State::WAITING_FOR_CANCEL_ALL)
// _transform_to_END();
// else if (_state == State::END)
// {
// // it means a connection was established in the end
// // state which is dosconnected now
// }
// if(me->connected)
// me->cancel_all();
// }
// void SimpleSpreader::on_md(const orderman::Book& book)
// {
// if (_state == State::START)
// bts_assert(_state != State::START);
// else if (_state == State::WAITING_FOR_FIRST_CONNECTION)
// // no md updates until connection is established
// bts_assert(false);
// else if (_state == State::WORKING)
// {
// SpreaderBookkeepingData::LegData& 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);
// // sending md to all quoters
// for (size_t idx = 0; idx < _bookkeeping_data->count(); idx++)
// {
// SpreaderBookkeepingData::LegData& d = _bookkeeping_data->get_leg_data(idx);
// d.quoter->update_md(md_leg.leg_property_data.leg_index);
// }
// // send MD to hedgers hedging this security only
// for (size_t h_idx = 0; h_idx < md_leg.n_hedgers(); h_idx++)
// {
// SpreaderBookkeepingData::HedgerData h = md_leg.get_hedger(h_idx);
// h.hedger.update_md();
// }
// }
// else if (_state == State::WAITING_FOR_CANCEL_ALL)
// {
// // no need to send md, quoters and hedgers
// // done need md when cxl'ing
// }
// else if (_state == State::END)
// {
// }
// }
// void SimpleSpreader::on_child_order_update(orderman::OrderKey orderkey,
// api::orderman::OrderStatus status,
// Quantity filled_quantity,
// Price average_price,
// std::string const *error_msg)
// {
// if (_state == State::START)
// bts_assert(false);
// else if (_state == State::WAITING_FOR_FIRST_CONNECTION)
// bts_assert(false);
// else if (_state == State::WORKING)
// {
// if (_order_update_has_error (error_msg))
// _handle_order_error();
// else
// {
// SpreaderBookkeepingData::LegData* q_leg_data_ptr = _bookkeeping_data->find_quoter_from_orderkey(orderkey);
// if (q_leg_data_ptr != NULL)
// {
// SpreaderBookkeepingData::LegData& q_leg_data = *(q_leg_data_ptr);
// SpreaderOrderUpdateMessage update_message(orderkey, status, filled_quantity, average_price, q_leg_data.filled_quantity, q_leg_data.avergage_filled_price);
// _handle_quoter_order_update(q_leg_data, update_message);
// }
// else
// {
// // should be a hedge order then
// SpreaderBookkeepingData::HedgerData* hedger_data = _bookkeeping_data->find_hedger_from_orderkey(orderkey);
// if (hedger_data != NULL)
// {
// SpreaderOrderUpdateMessage update_message(orderkey, status, filled_quantity, average_price, hedger_data->filled_quantity, hedger_data->avergage_filled_price);
// hedger_data->update_fill(filled_quantity);
// hedger_data->hedger.update_order_state(update_message);
// }
// }
// }
// }
// else if (_state == State::WAITING_FOR_CANCEL_ALL)
// {
// // all it has to do
// SpreaderBookkeepingData::LegData* q_leg_data_ptr = _bookkeeping_data->find_quoter_from_orderkey(orderkey);
// if (q_leg_data_ptr != NULL)
// {
// SpreaderBookkeepingData::LegData& q_leg_data = *(q_leg_data_ptr);
// SpreaderOrderUpdateMessage update_message(orderkey, status, filled_quantity, average_price, q_leg_data.filled_quantity, q_leg_data.avergage_filled_price);
// q_leg_data_ptr->quoter->update_order_status(update_message);
// }
// else
// {
// SpreaderBookkeepingData::HedgerData* hedger_data = _bookkeeping_data->find_hedger_from_orderkey(orderkey);
// if (hedger_data != NULL)
// {
// SpreaderOrderUpdateMessage update_message(orderkey, status, filled_quantity, average_price, hedger_data->filled_quantity, hedger_data->avergage_filled_price);
// hedger_data->update_fill(filled_quantity);
// hedger_data->hedger.update_order_state(update_message);
// }
// }
// if (_all_quoter_orders_in_terminal_state() && _all_hedger_orders_in_terminal_state())
// _transform_to_END();
// }
// else if (_state == State::END)
// {
// // it could have reached this state through an
// // error in which case, as far as the spreader
// // is concerned, no updates will be sent
// }
// }
// void SimpleSpreader::on_time(const TimeStamp&)
// {
// }
// void SimpleSpreader::on_user_update(const SpreaderUpdate& spreader_update)
// {
// // TODO : send status updates out
// if (_state == State::START)
// {
// }
// else if (_state == State::WAITING_FOR_FIRST_CONNECTION)
// {
// }
// else if (_state == State::WORKING)
// {
// // check if all quoters can accept the change
// bool accept_changes = true;
// for (size_t q_idx = 0; q_idx < _bookkeeping_data->count(); q_idx++)
// {
// SpreaderBookkeepingData::LegData& leg_data = _bookkeeping_data->get_leg_data(q_idx);
// accept_changes = accept_changes && leg_data.quoter->accept_modifications();
// if (!accept_changes)
// break;
// }
// if (accept_changes)
// {
// for (size_t q_idx = 0; q_idx < _bookkeeping_data->count(); q_idx++)
// {
// SpreaderBookkeepingData::LegData& leg_data = _bookkeeping_data->get_leg_data(q_idx);
// leg_data.quoter->update_order_price_quantity(spreader_update.price, spreader_update.quantity);
// }
// }
// }
// else if (_state == State::WAITING_FOR_CANCEL_ALL)
// {
// }
// else if (_state == State::END)
// {
// }
// }
// void SimpleSpreader::on_user_cancel()
// {
// _transform_to_WAITING_FOR_CANCEL_ALL();
// }
// void SimpleSpreader::on_limit_breach()
// {
// _transform_to_WAITING_FOR_CANCEL_ALL();
// }
// void SimpleSpreader::on_system_error()
// {
// _transform_to_WAITING_FOR_CANCEL_ALL();
// }
// bts::orderman::OrderKey SimpleSpreader::send_limit_order(const OrderTemplate& t, bts::Price price, bts::Quantity quantity)
// {
// return create_child(t, price, quantity);
// }
// void SimpleSpreader::update_order(bts::orderman::OrderKey order_key, bts::Price price, bts::Quantity quantity)
// {
// update_child(order_key, price, quantity);
// }
// void SimpleSpreader::cancel_order(bts::orderman::OrderKey order_key)
// {
// cancel_child(order_key);
// }
// const orderman::Book& SimpleSpreader::get_book(size_t leg_index) const
// {
// return _bookkeeping_data->get_leg_data(leg_index).book;
// }
// const LegPropertyData& SimpleSpreader::get_leg_data(size_t leg_index) const
// {
// return _bookkeeping_data->get_leg_data(leg_index).leg_property_data;
// }
// size_t SimpleSpreader::n_legs() const
// {
// return _bookkeeping_data->count();
// }
// void SimpleSpreader::_transform_to_WAITING_FOR_FIRST_CONNECTION()
// {
// bts_assert(_state == State::START);
// _state = State::WAITING_FOR_FIRST_CONNECTION;
// }
// void SimpleSpreader::_transform_to_WORKING()
// {
// bts_assert(_state == State::WAITING_FOR_FIRST_CONNECTION);
// _state = State::WORKING;
// for (size_t index = 0; index < _bookkeeping_data->count(); index++)
// {
// SpreaderBookkeepingData::LegData& leg_data = _bookkeeping_data->get_leg_data(index);
// leg_data.quoter->init();
// }
// }
// void SimpleSpreader::_transform_to_WAITING_FOR_CANCEL_ALL()
// {
// bts_assert(_state == State::WORKING);
// _state = State::WAITING_FOR_CANCEL_ALL;
// _cancel_orders(true, true);
// }
// void SimpleSpreader::_transform_to_END()
// {
// bts_assert(_state == State::WORKING || _state == State::WAITING_FOR_CANCEL_ALL);
// _state = State::END;
// }
// void SimpleSpreader::_handle_order_error()
// {
// // TODO report it
// _transform_to_WAITING_FOR_CANCEL_ALL();
// }
// void SimpleSpreader::_handle_quoter_order_update(SpreaderBookkeepingData::LegData& leg_data, const SpreaderOrderUpdateMessage& update_message)
// {
// // quoter needs to update, if there is a fill, the quoter
// // will update its order quantity
// leg_data.quoter->update_order_status(update_message);
// // if there are fill, we need to
// // i. update leg_data's price and quantity
// // ii. tell other quotes of the fill
// // iii send hedges
// Quantity this_fill_quantity; Price this_fill_price;
// if (update_message.update_fill_price_quantity (this_fill_quantity, this_fill_price))
// {
// leg_data.filled_quantity = update_message.filled_quantity;
// leg_data.avergage_filled_price = update_message.average_price;
// for (size_t idx = 0; idx < _bookkeeping_data->count(); idx++)
// {
// if (idx != leg_data.leg_property_data.leg_index)
// {
// leg_data.quoter->update_other_leg_fills(leg_data.leg_property_data.leg_index, this_fill_quantity);
// _send_hedge(leg_data.leg_property_data.leg_index, this_fill_price, this_fill_quantity, idx);
// }
// }
// }
// }
// void SimpleSpreader::_cancel_orders(bool cancel_quotes, bool cancel_hedges)
// {
// for (size_t q_idx = 0; q_idx < _bookkeeping_data->count(); q_idx++)
// {
// SpreaderBookkeepingData::LegData& leg_data = _bookkeeping_data->get_leg_data(q_idx);
// if (cancel_quotes)
// leg_data.quoter->cancel_order();
// if (cancel_hedges)
// for (size_t h_idx = 0; h_idx < leg_data.n_hedgers(); h_idx++)
// {
// SpreaderBookkeepingData::HedgerData& hedger_data = leg_data.get_hedger(h_idx);
// hedger_data.hedger.cancel_hedge();
// }
// }
// }
// bool SimpleSpreader::_all_quoter_orders_in_terminal_state()
// {
// for (size_t q_idx = 0; q_idx < _bookkeeping_data->count(); q_idx++)
// {
// SpreaderBookkeepingData::LegData& leg_data = _bookkeeping_data->get_leg_data(q_idx);
// if (leg_data.quoter->is_active())
// return false;
// }
// return true;
// }
bool SimpleSpreader::_all_hedger_orders_in_terminal_state()
{
for (size_t q_idx = 0; q_idx < _bookkeeping_data->count(); q_idx++)
{
SpreaderBookkeepingData::LegData& leg_data = _bookkeeping_data->get_leg_data(q_idx);
for (size_t h_idx = 0; h_idx < leg_data.n_hedgers(); h_idx++)
{
SpreaderBookkeepingData::HedgerData hedger_data = leg_data.get_hedger(h_idx);
if (hedger_data.hedger.is_active())
return false;
}
}
return true;
}
void SimpleSpreader::_send_hedge(size_t filled_leg_index, Price filled_price, Quantity filled_quantity, size_t leg_index)
{
Price hedge_price; Quantity hedge_quantity;
_compute_hedge_price_quantity(filled_leg_index, filled_price, filled_quantity,
leg_index, hedge_price, hedge_quantity);
SpreaderBookkeepingData::LegData& leg_data = _bookkeeping_data->get_leg_data(leg_index);
OrderTemplate hedge_order_template;
SpreaderBookkeepingData::HedgerData& hedger_data = leg_data.add_new_hedger(*this, leg_index, hedge_order_template, leg_data.leg_property_data, hedge_price, hedge_quantity, api::SIDE_BUY);
hedger_data.hedger.init();
}
// bool SimpleSpreader::_all_hedger_orders_in_terminal_state()
// {
// for (size_t q_idx = 0; q_idx < _bookkeeping_data->count(); q_idx++)
// {
// SpreaderBookkeepingData::LegData& leg_data = _bookkeeping_data->get_leg_data(q_idx);
// for (size_t h_idx = 0; h_idx < leg_data.n_hedgers(); h_idx++)
// {
// SpreaderBookkeepingData::HedgerData hedger_data = leg_data.get_hedger(h_idx);
// if (hedger_data.hedger.is_active())
// return false;
// }
// }
// return true;
// }
// void SimpleSpreader::_send_hedge(size_t filled_leg_index, Price filled_price, Quantity filled_quantity, size_t leg_index)
// {
// Price hedge_price; Quantity hedge_quantity;
// _compute_hedge_price_quantity(filled_leg_index, filled_price, filled_quantity,
// leg_index, hedge_price, hedge_quantity);
// SpreaderBookkeepingData::LegData& leg_data = _bookkeeping_data->get_leg_data(leg_index);
// OrderTemplate hedge_order_template;
// SpreaderBookkeepingData::HedgerData& hedger_data = leg_data.add_new_hedger(*this, leg_index, hedge_order_template, leg_data.leg_property_data, hedge_price, hedge_quantity, api::SIDE_BUY);
// hedger_data.hedger.init();
// }
void SimpleSpreader::_compute_hedge_price_quantity(size_t,
Price, Quantity,
size_t,
Price&, Quantity&)
{}
// void SimpleSpreader::_compute_hedge_price_quantity(size_t,
// Price, Quantity,
// size_t,
// Price&, Quantity&)
// {}
const OrderTemplate& SimpleSpreader::_get_order_template(size_t leg_index)
{
SpreaderBookkeepingData::LegData& leg_data = _bookkeeping_data->get_leg_data(leg_index);
return make_order_template(_bookkeeping_data->security,
orderman::AccountName(), //TODO _create_order_request.native_order().account_name
orderman::OperatorID(), //_create_order_request.native_order().operator_id(),
leg_data.leg_property_data.trading_side,
UserLogin());
}
}}
// const OrderTemplate& SimpleSpreader::_get_order_template(size_t leg_index)
// {
// SpreaderBookkeepingData::LegData& leg_data = _bookkeeping_data->get_leg_data(leg_index);
// return make_order_template(_bookkeeping_data->security,
// orderman::AccountName(), //TODO _create_order_request.native_order().account_name
// orderman::OperatorID(), //_create_order_request.native_order().operator_id(),
// leg_data.leg_property_data.trading_side,
// UserLogin());
// }
// }}
@@ -10,17 +10,16 @@ namespace bts {
namespace spreader {
SingleLegQuoter::SingleLegQuoter(ISpreaderManager& order_bridge,
size_t leg_index,
LegPropertyData leg_data,
bts::Price spread_order_price,
bts::Quantity spread_order_quantity,
bts::orderman::SpreaderOrderBase::ChildOrder child_order)
:
_tick_size(order_bridge.get_leg_data(leg_index).leg_contract.security().contract_spec().low_tick()),
_tick_size(leg_data.leg_contract.security().contract_spec().low_tick()),
_two_legged (order_bridge.n_legs() == 2),
_order_bridge(order_bridge),
// _order_template (order_template),
_this_leg_data (order_bridge.get_leg_data(leg_index)),
_this_leg_index(leg_index),
_this_leg_data (leg_data),
_this_leg_index(leg_data.leg_index),
_child_order (child_order),
_state(QuoterState::START),
_price_quantity_state(QuoteLegPriceQuantityState(spread_order_price, Quantity(static_cast<double>(spread_order_quantity.value() * _this_leg_data.size_multiplier()))))
+2 -2
View File
@@ -122,7 +122,7 @@ private:
const double _tick_size;
const bool _two_legged;
ISpreaderManager& _order_bridge;
const LegPropertyData& _this_leg_data;
const LegPropertyData _this_leg_data;
const size_t _this_leg_index;
bts::orderman::SpreaderOrderBase::ChildOrder _child_order;
std::vector<PQPair> _aux_comp_data;
@@ -130,7 +130,7 @@ private:
QuoteLegPriceQuantityState _price_quantity_state;
public:
SingleLegQuoter(ISpreaderManager& order_bridge,
size_t this_leg_index,
LegPropertyData leg_property_data,
bts::Price spread_order_price,
bts::Quantity spread_order_quantity,
bts::orderman::SpreaderOrderBase::ChildOrder child_order);
@@ -41,19 +41,21 @@ public:
class LegData
{
public:
const LegPropertyData leg_property_data;
Quantity filled_quantity;
SingleLegQuoter* quoter;
const LegPropertyData leg_property_data;
SingleLegQuoter quoter;
orderman::Book book;
Quantity filled_quantity;
Price avergage_filled_price;
orderman::OrderKey order_key;
std::vector<HedgerData> hedger_data_vector;
LegData(const LegPropertyData& leg_shared_data_arg)
:
leg_property_data(leg_shared_data_arg),
filled_quantity (Quantity (0)),
quoter (NULL)
LegData(const LegPropertyData& leg_shared_data_arg, SingleLegQuoter quoter_arg, orderman::OrderKey order_key_arg)
:
leg_property_data(leg_shared_data_arg),
quoter (quoter_arg),
book (),
filled_quantity (Quantity (0)),
order_key (order_key_arg)
{
}
void set_book(const orderman::Book& book_arg)
@@ -61,6 +63,11 @@ public:
// copying by value here
book = book_arg;
}
void update_order_price_quantity (Price new_average_filled_price, Quantity new_filled_quantity)
{
filled_quantity = new_filled_quantity;
avergage_filled_price = new_average_filled_price;
}
HedgerData* find_hedger(orderman::OrderKey order_key)
{
for (auto it = hedger_data_vector.begin(); it < hedger_data_vector.end(); it++)
+34 -34
View File
@@ -113,14 +113,14 @@ namespace bts {
_leg_2_spr_params.set_allocated_quote_params(&_leg_2_q_params);
_leg_2_property_data = new LegPropertyData(1, _leg_2_contract, _leg_1_spr_params, api::SIDE_BUY);
SpreaderBookkeepingData::LegData leg_1_data(*_leg_1_property_data);
SpreaderBookkeepingData::LegData leg_2_data(*_leg_2_property_data);
// SpreaderBookkeepingData::LegData leg_1_data(*_leg_1_property_data);
// SpreaderBookkeepingData::LegData leg_2_data(*_leg_2_property_data);
std::vector<SpreaderBookkeepingData::LegData> leg_data_v;
leg_data_v.push_back(LegPropertyData(0, _leg_1_contract, _leg_1_spr_params, api::SIDE_BUY));
leg_data_v.push_back(LegPropertyData(1, _leg_2_contract, _leg_1_spr_params, api::SIDE_SELL));
// std::vector<SpreaderBookkeepingData::LegData> leg_data_v;
// leg_data_v.push_back(LegPropertyData(0, _leg_1_contract, _leg_1_spr_params, api::SIDE_BUY));
// leg_data_v.push_back(LegPropertyData(1, _leg_2_contract, _leg_1_spr_params, api::SIDE_SELL));
bookkeeping_data = new SpreaderBookkeepingData(_spread_security, leg_data_v);
// bookkeeping_data = new SpreaderBookkeepingData(_spread_security, leg_data_v);
}
bts::orderman::OrderKey send_limit_order(const OrderTemplate&, bts::Price, bts::Quantity) override
{
@@ -275,36 +275,36 @@ namespace bts {
{
SECTION("Reprice Perf")
{
// create sim spreader
bts::spreader::SpreaderManagerSim sim;
// create quoter
bts::orderman::SpreaderOrderBase::ChildOrder child_order;
SingleLegQuoter quoter(sim, 0, Price(0.0), Quantity(100), child_order);
REQUIRE(quoter.get_state() == SingleLegQuoter::QuoterState::START);
// // create sim spreader
// bts::spreader::SpreaderManagerSim sim;
// // create quoter
// bts::orderman::SpreaderOrderBase::ChildOrder child_order;
// SingleLegQuoter quoter(sim, 0, Price(0.0), Quantity(100), child_order);
// REQUIRE(quoter.get_state() == SingleLegQuoter::QuoterState::START);
quoter.init();
REQUIRE(quoter.get_state() == SingleLegQuoter::QuoterState::WAITING_FOR_MARKET);
// fire md update
Book book;
uint16_t book_sizes[] = { 10, 30, 100, 5, 5 };
_fill_book(book, 2500, 0.25, book_sizes, api::SIDE_BUY);
sim.bookkeeping_data->get_leg_data(1).set_book(book);
quoter.update_md(1);
quoter.update_md(1);
quoter.update_order_status(SpreaderOrderUpdateMessage(OrderKey(1), api::orderman::OrderStatus::OS_NEW, Quantity(0), Price(0), Quantity(0), Price(0)));
// quoter.init();
// REQUIRE(quoter.get_state() == SingleLegQuoter::QuoterState::WAITING_FOR_MARKET);
// // fire md update
// Book book;
// uint16_t book_sizes[] = { 10, 30, 100, 5, 5 };
// _fill_book(book, 2500, 0.25, book_sizes, api::SIDE_BUY);
// sim.bookkeeping_data->get_leg_data(1).set_book(book);
// quoter.update_md(1);
// quoter.update_md(1);
// quoter.update_order_status(SpreaderOrderUpdateMessage(OrderKey(1), api::orderman::OrderStatus::OS_NEW, Quantity(0), Price(0), Quantity(0), Price(0)));
size_t n_runs = 20, n_updates = 1000000;
for (size_t t = 0; t < n_runs; t++)
{
auto t0 = Timer::now();
for (size_t u = 0; u < n_updates; u++)
quoter.update_md(1);
auto t1 = Timer::now();
int64_t diff = us_diff(t1, t0);
double single_update_time = (double)diff / n_updates;
std::cout << "time to process one md update " << single_update_time << " usecs" << std::endl;
REQUIRE(diff < 10000000);
}
// size_t n_runs = 20, n_updates = 1000000;
// for (size_t t = 0; t < n_runs; t++)
// {
// auto t0 = Timer::now();
// for (size_t u = 0; u < n_updates; u++)
// quoter.update_md(1);
// auto t1 = Timer::now();
// int64_t diff = us_diff(t1, t0);
// double single_update_time = (double)diff / n_updates;
// std::cout << "time to process one md update " << single_update_time << " usecs" << std::endl;
// REQUIRE(diff < 10000000);
// }
}
}
}