Merge branch 'spartan_tas' of bitbucket.org:bluetradesys/spark into spartan_tas

This commit is contained in:
Taha Afzal committed 2020-09-22 11:24:01 -04:00
commit 2f21e73d8d
2 files changed
+59 -32

No files matched your search

@@ -350,33 +350,54 @@ OrderChanges InstrumentSnapshot::deduced_order_changes() const {
trading_status() != ::mdp3::SecurityTradingStatus::ReadyToTrade)
return {};
else {
struct AggFillRecord {
struct AggOrderRec {
MDP3OrderKey ok;
Fills fills;
};
std::vector<AggFillRecord> aggressor_fills;
auto get_agg_order =
[&aggressor_fills](MDP3OrderKey ok) -> AggFillRecord & {
for (auto &agg_rec : aggressor_fills)
std::vector<AggOrderRec> agg_orders;
OrderChanges deduced_orders;
// Return the AggOrderRec for a given order
auto get_agg_order = [&agg_orders](MDP3OrderKey ok) -> AggOrderRec & {
for (auto &agg_rec : agg_orders)
if (agg_rec.ok == ok)
return agg_rec;
aggressor_fills.push_back(AggFillRecord{ok, {}});
return aggressor_fills.back();
agg_orders.push_back(AggOrderRec{ok, {}});
return agg_orders.back();
};
OrderChanges result;
// Group all aggressor fills for a given order together in the
// aggressor_fills container
for (auto const &f : fills())
if (f.aggressor == MDP3Fill::THIS_BUY ||
f.aggressor == MDP3Fill::THIS_SELL)
get_agg_order(f.key).fills.push_back(f);
for (auto const &agg_rec : aggressor_fills) {
auto &aggressor_fills = agg_rec.fills;
// In some cases its possible for an order to trade both
// aggressively and passively. This can happen if the initially
// aggressive order became the top of the book, but then
// immediately crossed with a stop order that was triggered by
// the first round of trades. To account for that possibility we
// have to do a second pass over the fills to add any non
// aggressive fills we might see for the initially aggressive
// orders.
for (auto &agg_order : agg_orders) {
for (auto const &f : fills())
if (agg_order.ok == f.key &&
f.aggressor != MDP3Fill::THIS_BUY &&
f.aggressor != MDP3Fill::THIS_SELL )
agg_order.fills.push_back(f);
}
// For each aggressor order, add up its fills and calculate a
// price that would explain all the observed fills
for (auto const &agg_order : agg_orders) {
auto &aggressor_fills = agg_order.fills;
bts_assert(aggressor_fills.size());
OrderChange &deduced_order = result.emplace_back();
OrderChange &deduced_order = deduced_orders.emplace_back();
deduced_order.previous_order = {};
deduced_order.order.key = agg_rec.ok;
deduced_order.order.key = agg_order.ok;
deduced_order.order.security = security_id();
deduced_order.order.side =
aggressor_fills[0].aggressor == MDP3Fill::THIS_BUY
@@ -399,7 +420,7 @@ OrderChanges InstrumentSnapshot::deduced_order_changes() const {
// fills in this event. We now examine the order book that CME
// communicated and adjust these deduced orders so that they are
// consistent with it as well.
for (auto &deduced_order : result) {
for (auto &deduced_order : deduced_orders) {
deduced_order.change = OrderChange::added;
for (auto &o : order_changes())
if (o.order.key == deduced_order.order.key) {
@@ -417,7 +438,8 @@ OrderChanges InstrumentSnapshot::deduced_order_changes() const {
}
}
// Now we make some adjustment to account for special circunstances
// Now we make some final adjustment to account for special
// circunstances.
for (auto &o : order_changes())
if (o.change == OrderChange::added) {
// Its possible that in some cases for a new order to be added
@@ -425,22 +447,22 @@ OrderChanges InstrumentSnapshot::deduced_order_changes() const {
// multiple stop orders are activated simultaneously and some of
// them trade and some do not.
auto it = std::find_if(
result.begin(), result.end(),
deduced_orders.begin(), deduced_orders.end(),
[k = o.order.key](auto const &d) { return d.order.key == k; });
if (it == result.end())
result.push_back(o);
if (it == deduced_orders.end())
deduced_orders.push_back(o);
} else if (o.change == OrderChange::removed) {
// It is also possible for an order to be removed even if
// it had no fills because of self match prevention.
auto it = std::find_if(
fills().begin(),fills().end(),
fills().begin(), fills().end(),
[k = o.order.key](auto const &f) { return f.key == k; });
if (it == fills().end())
// Removes would happen before anything else
result.insert(result.begin(),o);
deduced_orders.insert(deduced_orders.begin(), o);
}
return result;
return deduced_orders;
}
}
@@ -370,13 +370,11 @@ struct ObsWrapper : mdp3::IChannelObserver {
std::stringstream str;
mdp3::cme_ts_to_time_str(ev.transact_time.value(), &str);
std::cout << "Packet time: " << str.str()
<< " Event ID: " << ev.event_id
<< " ("
<< " Event ID: " << ev.event_id << " ("
<< (ev.first_packet_sn - previous_packet) << " pkt/sec, "
<< (ev.first_packet_send_time.value() - previous_send_ts) /
1000000000
<< "x speedup)"
<< std::endl;
<< "x speedup)" << std::endl;
previous_packet = ev.first_packet_sn;
previous_send_ts = ev.first_packet_send_time.value();
}
@@ -622,8 +620,7 @@ int to_csv(std::string const &file, std::string const &out_dir) {
auto ice = find_icebergs(file);
for (auto &i : ice)
icebergs << i.first.value() << "," << i.second.estimated_quantity.value()
<< "," << i.second.filled
<< std::endl;
<< "," << i.second.filled << std::endl;
return 0;
}
@@ -670,7 +667,7 @@ find_icebergs(std::string const &pcap) {
for (auto const &o : s->order_changes()) {
changes_in_event[o.order.key] = o;
if (o.change == OrderChange::removed) {
for (auto const &f : s->fills())
for (auto const &f : s->fills())
if (f.key == o.order.key) {
order_data[o.order.key].filled = true;
break;
@@ -699,11 +696,16 @@ find_icebergs(std::string const &pcap) {
break;
auto &change = it->second;
// A passive order must have already existed before
// this event occurred.
bts_assert(change.change != OrderChange::added);
if (change.change == OrderChange::updated) {
// So we have a passive order that
// Sometimes an aggressor order is also passively
// filled. This is rare but it can happen due to stop
// order triggering. In this case we have no previous
// state for the order so we cannot determine wheter its
// an iceberg so we have to bail.
if (change.change == OrderChange::added)
break;
else if (change.change == OrderChange::updated) {
// So we have a passive order tha
// was partially filled. If its new
// size is not simply it previous
// quantity minus the fill size then
@@ -736,6 +738,9 @@ find_icebergs(std::string const &pcap) {
di.key = k;
di.estimated_quantity.value() = od.accumulated_fills;
di.filled = od.filled;
// If we have not seen an iceberg order fill completely then
// all we can say is that its hidden size is at least one
// contract bigger than the observed fills.
if (!od.filled)
di.estimated_quantity.value() += 1;
}