cli: Remove ValidateFifo cmd (obsolete)
This commit is contained in:
1 parent
849adc5d7c
commit
d0ceed37b5
5 files changed
-639
No files matched your search
@@ -11,7 +11,6 @@
|
||||
#include "cmds/SQL.h"
|
||||
#include "cmds/Sim.h"
|
||||
#include "cmds/Stats.h"
|
||||
#include "cmds/ValidateFifo.h"
|
||||
#include "cmds/ValuePolys.h"
|
||||
#include "cmds/Test.h"
|
||||
|
||||
@@ -33,7 +32,6 @@ Spartan::Spartan() : CLI::App("Futures trading system for devs", "spartan") {
|
||||
add_subcommand(CLI::App_p(new Sim()));
|
||||
add_subcommand(CLI::App_p(new SQL()));
|
||||
add_subcommand(CLI::App_p(new Stats()));
|
||||
add_subcommand(CLI::App_p(new ValidateFifo()));
|
||||
add_subcommand(CLI::App_p(new ValuePolys()));
|
||||
add_subcommand(CLI::App_p(new Test()));
|
||||
}
|
||||
|
||||
-541
@@ -1,541 +0,0 @@
|
||||
#include "back_testing/matcher/validation/matcher_validation_observer.h"
|
||||
#include "back_testing/matcher/FifoMatcherContext.h"
|
||||
#include "back_testing/matcher/FillDepot.h"
|
||||
#include "back_testing/matcher/iceberg_helper.h"
|
||||
#include "back_testing/matcher/matcher_diagnostics.h"
|
||||
#include "back_testing/matcher/validation/event_flags.h"
|
||||
#include "domain/SecuritySnapshot.h"
|
||||
#include "lib/orderman/orderman_utils/Formatter.h"
|
||||
#include "lib/orderman/orderman_utils/PriceComp.h"
|
||||
#include "back_testing/matcher/iceberg_helper.h"
|
||||
#include "back_testing/matcher/matcher_diagnostics.h"
|
||||
#include "back_testing/matcher/validation/event_flags.h"
|
||||
#include "domain/SecuritySnapshot.h"
|
||||
#include "feed_handler/detail/gen/src/SecurityTradingStatus.h"
|
||||
#include "back_testing/common/event_ordinal.h"
|
||||
#include "back_testing/common/mdp3_utils.h"
|
||||
#include "back_testing/common/order_utils.h"
|
||||
#include "back_testing/common/security_comp.h"
|
||||
#include "utils/ActionSummarizer.h"
|
||||
#include "utils/ActionSummarizerMacros.h"
|
||||
#include <boost/container/flat_map.hpp>
|
||||
#include <functional>
|
||||
#include <iostream>
|
||||
|
||||
// Error logs are automatically logged to the console
|
||||
// (w/ default logging configuration), but they lag behind
|
||||
// immediate console output (i.e., calls to std::cout).
|
||||
// If _ECHO_ON is defined, the _ERROR_LEVEL macro is set to Info
|
||||
// to avoid duplicate, and (perhaps more importantly) unsynchronized output.
|
||||
// #define _ECHO_ON
|
||||
#ifdef _ECHO_ON
|
||||
#define _ECHO(...) std::cout << bts::orderman::Formatter::fmt(__VA_ARGS__);
|
||||
#define _ERROR_LEVEL Info
|
||||
#else
|
||||
#define _ECHO(...)
|
||||
#define _ERROR_LEVEL Error
|
||||
#endif
|
||||
#define _LOG(level, msg) \
|
||||
_ECHO(_log_header(), " ", msg, "\n") \
|
||||
LOG(OrderMan, level, "{} {}", _log_header(), msg)
|
||||
#define INFO(...) _LOG(Info, bts::orderman::Formatter::fmt(__VA_ARGS__))
|
||||
#define ERROR(...) \
|
||||
_LOG(_ERROR_LEVEL, bts::orderman::Formatter::fmt(__VA_ARGS__))
|
||||
|
||||
// SUMMARIZE macro wrappers
|
||||
#define _SUMMARIZE SUMMARIZE(_log_header())
|
||||
#define _SUMMARIZE_TRANSACTION(...) \
|
||||
SUMMARIZE_TRANSACTION(_log_header(), FMT(__VA_ARGS__))
|
||||
#define _SUMMARIZE_TRANSACTION_NAMED(name, ...) \
|
||||
SUMMARIZE_TRANSACTION_NAMED(name, _log_header(), FMT(__VA_ARGS__))
|
||||
|
||||
namespace bts::spartan::mdp3 {
|
||||
using namespace bts::spartan::mdp3::iceberg_helper;
|
||||
// aliases
|
||||
using TradingStatus = MatcherValidationObserver::TradingStatus;
|
||||
template <typename K, typename V>
|
||||
using flat_map = boost::container::flat_map<K, V>;
|
||||
// consts
|
||||
const size_t NO_EVENT = 0, MIN_OBSERVED_EVENT = 100;
|
||||
|
||||
enum class Verbosity { Minimal = 0, Normal = 1, Verbose = 2 };
|
||||
|
||||
///////////////////////
|
||||
// stateless helpers
|
||||
///////////////////////
|
||||
inline std::string _log_header() { return "MatcherValidationObserver"; }
|
||||
|
||||
inline bool _is_interesting_sec(const SecuritySnapshot &s) {
|
||||
return s.definition().asset() == "ES";
|
||||
// return strcmp(s.definition().asset(), "SI") == 0;
|
||||
}
|
||||
|
||||
void _sync_orders(
|
||||
size_t event_id,
|
||||
const SecuritySnapshot &s,
|
||||
Orders &orders,
|
||||
const std::unordered_map<OrderKey, IcebergInput> &icebergs) {
|
||||
//
|
||||
for (auto ch : s.order_changes()) {
|
||||
switch (ch.change) {
|
||||
case OrderChange::added:
|
||||
case OrderChange::updated:
|
||||
case OrderChange::updated_price:
|
||||
add_iceberg_annotation(ch.order, ch.change, icebergs, event_id, true);
|
||||
orders[ch.order.key] = ch.order;
|
||||
break;
|
||||
case OrderChange::removed:
|
||||
orders.erase(ch.order.key);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
bool _has_multiple_aggressor_secs(const FeedEvent &ev) {
|
||||
bool aggr_sec_found = false;
|
||||
for (auto *s : ev) {
|
||||
for (auto f : s->fills()) {
|
||||
switch (f.aggressor) {
|
||||
case MDP3Fill::Aggressor::THIS_BUY:
|
||||
case MDP3Fill::Aggressor::THIS_SELL:
|
||||
if (aggr_sec_found)
|
||||
return true;
|
||||
aggr_sec_found = true;
|
||||
break;
|
||||
default:
|
||||
continue;
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
inline std::ostream &operator<<(std::ostream &ostr, const TradingStatus &ts) {
|
||||
switch (ts) {
|
||||
case TradingStatus::None:
|
||||
ostr << "None";
|
||||
break;
|
||||
case TradingStatus::Preopen:
|
||||
ostr << "Preopen";
|
||||
break;
|
||||
case TradingStatus::Uninitialized:
|
||||
ostr << "Uninitialized";
|
||||
break;
|
||||
case TradingStatus::Initialized:
|
||||
ostr << "Initialized";
|
||||
break;
|
||||
default:
|
||||
ostr << "TradingStatus_" << static_cast<int>(ts);
|
||||
break;
|
||||
}
|
||||
return ostr;
|
||||
}
|
||||
|
||||
template <class TIter>
|
||||
inline void print_if_not_empty(
|
||||
TIter first, TIter last, std::string title, std::ostream &out = std::cout) {
|
||||
bool printed_title = false;
|
||||
while (first != last) {
|
||||
if (!printed_title) {
|
||||
out << title << std::endl;
|
||||
printed_title = true;
|
||||
}
|
||||
out << *first << std::endl;
|
||||
first++;
|
||||
}
|
||||
}
|
||||
|
||||
inline bool fill_equals(const MDP3Fill &a, const MDP3Fill &b) {
|
||||
return a.aggressor == b.aggressor && a.quantity == b.quantity &&
|
||||
orderman::price_comp::is_equal(a.price, b.price);
|
||||
}
|
||||
|
||||
inline bool match_fills(
|
||||
const FillDepot &fd,
|
||||
std::vector<const SecuritySnapshot *> snaps,
|
||||
std::ostream &out = std::cout) {
|
||||
std::unordered_map<SecurityID, std::vector<MDP3Fill>> fill_map;
|
||||
fd.copy_to(fill_map);
|
||||
bool errors = false;
|
||||
for (const auto *s : snaps) {
|
||||
auto sec_fills_it = fill_map.find(s->security_id());
|
||||
if (sec_fills_it == fill_map.end()) {
|
||||
print_if_not_empty(
|
||||
s->fills().begin(), s->fills().end(),
|
||||
FMT(s->symbol(), " unmatched fills"), out);
|
||||
continue;
|
||||
}
|
||||
auto &act_fills = sec_fills_it->second;
|
||||
auto exp_it = s->fills().begin();
|
||||
std::vector<MDP3Fill> unmatched_exp;
|
||||
while (exp_it != s->fills().end()) {
|
||||
bool matched = false;
|
||||
for (auto act_it = act_fills.begin(); act_it != act_fills.end();
|
||||
act_it++) {
|
||||
if (fill_equals(*act_it, *exp_it)) {
|
||||
act_fills.erase(act_it);
|
||||
matched = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (!matched) {
|
||||
unmatched_exp.push_back(*exp_it);
|
||||
}
|
||||
exp_it++;
|
||||
}
|
||||
errors |= (act_fills.size() || unmatched_exp.size());
|
||||
print_if_not_empty(
|
||||
act_fills.begin(), act_fills.end(),
|
||||
FMT(s->symbol(), " unexpected fills"), out);
|
||||
print_if_not_empty(
|
||||
unmatched_exp.begin(), unmatched_exp.begin(),
|
||||
FMT(s->symbol(), " unmatched fills"), out);
|
||||
}
|
||||
return !errors;
|
||||
}
|
||||
///////////////////////
|
||||
// private classes
|
||||
///////////////////////
|
||||
struct _SecurityData {
|
||||
_SecurityData()
|
||||
: status(TradingStatus::None), current_orders(), previous_orders() {}
|
||||
TradingStatus status;
|
||||
Orders current_orders, previous_orders;
|
||||
size_t last_observed_event = NO_EVENT;
|
||||
const SecuritySnapshot *snapshot = nullptr;
|
||||
std::string symbol() const {
|
||||
return snapshot == nullptr ? "N/A" : snapshot->symbol();
|
||||
}
|
||||
SecurityID security_id() const {
|
||||
return snapshot == nullptr ? SecurityID(0) : snapshot->security_id();
|
||||
}
|
||||
};
|
||||
|
||||
struct MatcherValidationObserver::PImpl {
|
||||
PImpl() {}
|
||||
PImpl(
|
||||
std::unordered_map<OrderKey, IcebergInput> icebergs,
|
||||
flat_map<size_t, size_t> interesting_event_ranges)
|
||||
: icebergs(icebergs),
|
||||
interesting_event_ranges(interesting_event_ranges) {}
|
||||
|
||||
flat_map<SecurityID, _SecurityData> security_cache;
|
||||
std::unordered_map<OrderKey, IcebergInput> icebergs;
|
||||
flat_map<size_t, size_t> interesting_event_ranges;
|
||||
flat_map<OrderKey, MDP3Order> interesting_orders;
|
||||
|
||||
// number of 'interesting events' observed so far.
|
||||
uint32_t interesting_event_count = 0;
|
||||
// actual event_id (from the exchange) of most recently observed event.
|
||||
size_t event_id = NO_EVENT;
|
||||
FifoMatcherContext exch_matcher;
|
||||
Verbosity verbosity = Verbosity::Minimal;
|
||||
EventFlags ignore_flags = EventFlags::MultipleSecurityAggressors;
|
||||
|
||||
// event_id is used to transition the security's trading status from
|
||||
// Preopen to Uninitialized
|
||||
_SecurityData &
|
||||
get_security_data(const SecuritySnapshot &s, size_t event_id) {
|
||||
auto it = security_cache.find(s.security_id());
|
||||
if (it != security_cache.end()) {
|
||||
auto &data = it->second;
|
||||
if (event_id != data.last_observed_event) {
|
||||
data.last_observed_event = event_id;
|
||||
switch (data.status) {
|
||||
case TradingStatus::Preopen:
|
||||
data.status = TradingStatus::Uninitialized;
|
||||
break;
|
||||
case TradingStatus::None:
|
||||
if (s.trading_status() ==
|
||||
::mdp3::SecurityTradingStatus::ReadyToTrade)
|
||||
data.status = TradingStatus::Preopen;
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
data.snapshot = &s;
|
||||
return data;
|
||||
}
|
||||
// this is the first time this security has been observed; initialize its
|
||||
// data.
|
||||
auto &data = security_cache.emplace(s.security_id(), _SecurityData())
|
||||
.first->second;
|
||||
data.snapshot = &s;
|
||||
data.last_observed_event = event_id;
|
||||
data.previous_orders = s.orders();
|
||||
for (auto &o : data.previous_orders)
|
||||
add_iceberg_annotation(
|
||||
o.second, OrderChange::ChangeType::added, icebergs, event_id);
|
||||
// the first event at the open isn't processed bc
|
||||
// we don't have a clear understanding of how preopen matching works.
|
||||
data.status =
|
||||
s.trading_status() == ::mdp3::SecurityTradingStatus::ReadyToTrade
|
||||
? TradingStatus::Preopen
|
||||
: TradingStatus::None;
|
||||
data.snapshot = &s;
|
||||
return data;
|
||||
}
|
||||
|
||||
EventFlags get_event_flags(const FeedEvent &ev) {
|
||||
EventFlags flags = EventFlags::None;
|
||||
if (_has_multiple_aggressor_secs(ev))
|
||||
flags |= EventFlags::MultipleSecurityAggressors;
|
||||
for (const auto *s : ev) {
|
||||
for (auto &f : s->fills()) {
|
||||
if (icebergs.find(f.key) != icebergs.end())
|
||||
flags |= EventFlags::IcebergOrders;
|
||||
switch (f.aggressor) {
|
||||
case MDP3Fill::Aggressor::THIS_BUY:
|
||||
case MDP3Fill::Aggressor::THIS_SELL:
|
||||
flags |= EventFlags::DirectFills;
|
||||
break;
|
||||
case MDP3Fill::Aggressor::IMPLIED:
|
||||
flags |= EventFlags::ImpliedFills;
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
return flags;
|
||||
}
|
||||
};
|
||||
///////////////////////
|
||||
// constructors
|
||||
///////////////////////
|
||||
MatcherValidationObserver::MatcherValidationObserver(
|
||||
std::unordered_map<OrderKey, IcebergInput> icebergs)
|
||||
: MatcherValidationObserver(icebergs, flat_map<size_t, size_t>{}) {}
|
||||
|
||||
MatcherValidationObserver::MatcherValidationObserver(
|
||||
std::unordered_map<OrderKey, IcebergInput> icebergs,
|
||||
flat_map<size_t, size_t> interesting_event_ranges)
|
||||
: _me(new MatcherValidationObserver::PImpl(
|
||||
icebergs, interesting_event_ranges)) {}
|
||||
|
||||
MatcherValidationObserver::~MatcherValidationObserver() {}
|
||||
|
||||
///////////////////////
|
||||
// misc private methods
|
||||
///////////////////////
|
||||
TradingStatus MatcherValidationObserver::_trading_status(
|
||||
const SecuritySnapshot &s, size_t event_id) {
|
||||
return _me->get_security_data(s, event_id).status;
|
||||
}
|
||||
|
||||
bool MatcherValidationObserver::_is_ready_to_trade(
|
||||
const SecuritySnapshot &s, size_t event_id) {
|
||||
switch (_trading_status(s, event_id)) {
|
||||
case TradingStatus::Uninitialized:
|
||||
case TradingStatus::Initialized:
|
||||
return true;
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
void MatcherValidationObserver::_sync_current_orders(FeedEvent const &ev) {
|
||||
for (auto s : ev) {
|
||||
auto &new_orders = _me->get_security_data(*s, ev.event_id).current_orders;
|
||||
_sync_orders(ev.event_id, *s, new_orders, _me->icebergs);
|
||||
}
|
||||
}
|
||||
|
||||
void MatcherValidationObserver::_sync_previous_orders(const FeedEvent &ev) {
|
||||
for (auto s : ev) {
|
||||
auto &old_orders =
|
||||
_me->get_security_data(*s, ev.event_id).previous_orders;
|
||||
_sync_orders(ev.event_id, *s, old_orders, _me->icebergs);
|
||||
}
|
||||
}
|
||||
|
||||
void MatcherValidationObserver::_reset_matcher() {
|
||||
// remove orders, and change [actively trading] securities
|
||||
// trading status back to Preopen so they will be added back
|
||||
// in the next update (the state must be re-initialized
|
||||
// before updates can be consumed incrementally again).
|
||||
if (_me->verbosity > Verbosity::Normal)
|
||||
INFO("clearing orders to reset the matcher's state");
|
||||
_me->exch_matcher.clear();
|
||||
for (auto &kv : _me->security_cache) {
|
||||
if (kv.second.status != TradingStatus::None)
|
||||
kv.second.status = TradingStatus::Preopen;
|
||||
}
|
||||
}
|
||||
///////////////////////
|
||||
// IMDP3FeedObserver
|
||||
///////////////////////
|
||||
void MatcherValidationObserver::on_recovery_complete(
|
||||
InitialSnapshot const &snap) {
|
||||
_SUMMARIZE;
|
||||
for (auto s : snap) {
|
||||
auto &sec_data = _me->get_security_data(*s, NO_EVENT);
|
||||
sec_data.current_orders.clear();
|
||||
_sync_orders(NO_EVENT, *s, sec_data.current_orders, _me->icebergs);
|
||||
sec_data.previous_orders = sec_data.current_orders;
|
||||
}
|
||||
}
|
||||
|
||||
void MatcherValidationObserver::on_event_end(FeedEvent const &ev) {
|
||||
bts_assert(ev.event_id > _me->event_id);
|
||||
_me->event_id = ev.event_id;
|
||||
switch (get_event_ordinal(
|
||||
_me->interesting_event_ranges, ev.event_id, MIN_OBSERVED_EVENT)) {
|
||||
case bts::spartan::EventOrdinal::Waiting:
|
||||
// just need to synchronize the order caches.
|
||||
// the matcher is only validated during 'interesting events.'
|
||||
_sync_current_orders(ev);
|
||||
_sync_previous_orders(ev);
|
||||
return;
|
||||
case bts::spartan::EventOrdinal::Interesting:
|
||||
// _sync_previous_orders should be called after
|
||||
// the matcher has digested the order changes.
|
||||
break;
|
||||
case bts::spartan::EventOrdinal::Done:
|
||||
// nothing left to do (might as well kill the process).
|
||||
bts_assert_msg(false, "no further events of interest.");
|
||||
return;
|
||||
}
|
||||
auto flags = _me->get_event_flags(ev);
|
||||
if ((flags & _me->ignore_flags) != EventFlags::None) {
|
||||
if (_me->verbosity > Verbosity::Minimal)
|
||||
INFO(FMT("skipping event ", ev.event_id, ", with flags ", flags));
|
||||
_sync_current_orders(ev);
|
||||
_sync_previous_orders(ev);
|
||||
_reset_matcher();
|
||||
return;
|
||||
}
|
||||
++_me->interesting_event_count;
|
||||
if (_me->verbosity > Verbosity::Minimal)
|
||||
INFO(
|
||||
"Update No ", _me->interesting_event_count, "(event id ", ev.event_id,
|
||||
")");
|
||||
// Note: the exchange processes the order updates per security,
|
||||
// in a particular order, sorted hierarchically by symbol, then expiration.
|
||||
// 'sorted_secs' will contain the proper order of securities.
|
||||
std::vector<const SecuritySnapshot *> sorted_secs;
|
||||
for (auto *s : ev) {
|
||||
if (_is_interesting_sec(*s))
|
||||
sorted_secs.push_back(s);
|
||||
}
|
||||
if (sorted_secs.empty())
|
||||
return;
|
||||
std::sort(
|
||||
sorted_secs.begin(), sorted_secs.end(), security_comp::SymbolComp());
|
||||
// securities must be added to the matcher before the order
|
||||
// changes are processed to ensure the correct implied markets are used.
|
||||
// Fills are also indexed in this pass, so they can be added to the iceberg
|
||||
// qty
|
||||
std::unordered_map<OrderKey, Quantity> fill_map;
|
||||
for (const auto *s : sorted_secs) {
|
||||
accumulate_fills(s->fills().begin(), s->fills().end(), fill_map);
|
||||
_me->exch_matcher.add_security(
|
||||
s->security_id(), s->symbol(), s->definition().legs());
|
||||
_me->exch_matcher.implied_matching_status(
|
||||
s->security_id(), s->definition().implied_matching());
|
||||
}
|
||||
// initialize matcher with previous state (only applies
|
||||
// to securities whose orders the matcher hasn't seen yet).
|
||||
for (const auto *s : sorted_secs) {
|
||||
if (_trading_status(*s, ev.event_id) != TradingStatus::Uninitialized)
|
||||
continue;
|
||||
auto it = _me->security_cache.find(s->security_id());
|
||||
bts_assert(it != _me->security_cache.end());
|
||||
auto prev_ords =
|
||||
it->second.previous_orders |
|
||||
ranges::views::transform([](auto &p) { return p.second; });
|
||||
_me->exch_matcher.reset(
|
||||
s->security_id(), prev_ords.begin(), prev_ords.end());
|
||||
_me->security_cache[s->security_id()].status = TradingStatus::Initialized;
|
||||
}
|
||||
// process changes with matcher
|
||||
FillDepot fills;
|
||||
for (const auto *s : sorted_secs) {
|
||||
switch (_trading_status(*s, ev.event_id)) {
|
||||
case TradingStatus::Initialized:
|
||||
break;
|
||||
default:
|
||||
continue;
|
||||
}
|
||||
auto deduced = s->deduced_order_changes();
|
||||
if (deduced.size()) {
|
||||
std::vector<SmallOrderChange> deduced_sm;
|
||||
for (auto &ch : deduced) {
|
||||
add_iceberg_annotation(
|
||||
ch.order, ch.change, _me->icebergs, ev.event_id);
|
||||
deduced_sm.emplace_back(ch);
|
||||
}
|
||||
_me->exch_matcher.on_order_change(
|
||||
s->security_id(), deduced_sm, nullptr, fills);
|
||||
}
|
||||
}
|
||||
// Verify the matcher's orders are identitical to the exchange's.
|
||||
_sync_current_orders(ev);
|
||||
bool orders_match = true;
|
||||
for (const auto *s : sorted_secs) {
|
||||
if (!_is_ready_to_trade(*s, ev.event_id))
|
||||
continue;
|
||||
auto &sec_data = _me->security_cache[s->security_id()];
|
||||
auto &curr_orders = sec_data.current_orders;
|
||||
auto error =
|
||||
_me->exch_matcher.has_same_orders(s->security_id(), curr_orders);
|
||||
if (error) {
|
||||
ERROR(
|
||||
"order discrepancies detected for ", s->symbol(), " on event ",
|
||||
ev.event_id, "\nError: ", error.value(), "\nOld Orders:\n",
|
||||
_me->security_cache[s->security_id()].previous_orders);
|
||||
orders_match = false;
|
||||
}
|
||||
}
|
||||
bool fills_match = match_fills(fills, sorted_secs);
|
||||
if (!orders_match || !fills_match) {
|
||||
// todo: add the iceberg fills back, to get to the previous state.
|
||||
// describe current state for diagnostic purposes
|
||||
std::stringstream msg;
|
||||
msg << "Spartan Top of Books:" << std::endl;
|
||||
_me->exch_matcher.print_all_bbos(msg);
|
||||
msg << std::endl;
|
||||
// spartan fills
|
||||
msg << "Spartan Total Fill Qty: " << fills.total_fill_qty() << std::endl;
|
||||
auto fill_cmp = [](const auto &lhs, const auto &rhs) {
|
||||
return lhs.trade_entry_id == rhs.trade_entry_id
|
||||
? static_cast<int>(lhs.aggressor) >
|
||||
static_cast<int>(rhs.aggressor)
|
||||
: lhs.trade_entry_id < rhs.trade_entry_id;
|
||||
};
|
||||
std::vector<MDP3Fill> spartan_fills;
|
||||
fills.copy_to(spartan_fills);
|
||||
std::sort(spartan_fills.begin(), spartan_fills.end(), fill_cmp);
|
||||
msg << "Spartan Fills (ordered by Trade ID):" << std::endl;
|
||||
diagnostics::print_fills(spartan_fills.begin(), spartan_fills.end(), msg);
|
||||
// exch top of books
|
||||
msg << "Exchange Top of Books:" << std::endl;
|
||||
diagnostics::print_many_bbo(
|
||||
sorted_secs.begin(), sorted_secs.end(), true, true, msg);
|
||||
int exch_fill_qty = 0;
|
||||
for (auto *s : sorted_secs) {
|
||||
for (auto f : s->fills())
|
||||
exch_fill_qty += f.quantity.value();
|
||||
}
|
||||
// exch fills
|
||||
msg << "Exchange Total Fill Qty: " << exch_fill_qty << std::endl;
|
||||
std::vector<MDP3Fill> all_exch_fills;
|
||||
for (auto *s : sorted_secs) {
|
||||
for (auto f : s->fills())
|
||||
all_exch_fills.push_back(f);
|
||||
}
|
||||
std::sort(all_exch_fills.begin(), all_exch_fills.end(), fill_cmp);
|
||||
msg << "Exchange Fills (ordered by Trade ID):" << std::endl;
|
||||
diagnostics::print_fills(
|
||||
all_exch_fills.begin(), all_exch_fills.end(), msg);
|
||||
INFO(msg.str());
|
||||
// reset the matcher to avoid cascading/compounding errors in subsequent
|
||||
// events.
|
||||
_reset_matcher();
|
||||
}
|
||||
_sync_previous_orders(ev);
|
||||
}
|
||||
|
||||
} // namespace bts::spartan::mdp3
|
||||
-55
@@ -1,55 +0,0 @@
|
||||
#pragma once
|
||||
#include "back_testing/matcher/FifoMatcherContext.h"
|
||||
#include "domain/SecuritySnapshot.h"
|
||||
#include "back_testing/common/mdp3_common.h"
|
||||
#include "back_testing/feed_observers/IcebergFinder.h"
|
||||
#include "back_testing/feed_observers/FeedObserver.h"
|
||||
#include "back_testing/common/mdp3_utils.h"
|
||||
#include <boost/container/flat_map.hpp>
|
||||
#include <memory>
|
||||
#include <unordered_map>
|
||||
|
||||
namespace bts::spartan::mdp3 {
|
||||
struct MatcherValidationObserver : FeedObserver {
|
||||
MatcherValidationObserver(
|
||||
std::unordered_map<OrderKey, IcebergInput> icebergs);
|
||||
// interesting_event_ranges:
|
||||
// - keys indicate the first event in an interesting range
|
||||
// - values indicate the number of events in the range (i.e., the range's
|
||||
// length).
|
||||
MatcherValidationObserver(
|
||||
std::unordered_map<OrderKey, IcebergInput> icebergs,
|
||||
boost::container::flat_map<size_t, size_t> interesting_event_ranges);
|
||||
~MatcherValidationObserver();
|
||||
void on_recovery_complete(InitialSnapshot const &snap) override;
|
||||
void on_event_end(FeedEvent const &ev) override;
|
||||
// the first time a security's actual trading status
|
||||
// (i.e., mdp3::SecurityTradingStatus from the exchange)
|
||||
// is observed to be 'ReadyToTrade,' its local TradingStatus
|
||||
// (this enum) is switched from 'None' to Preopen.' The security's
|
||||
// changes in that event are ignored, but on the subsequent event
|
||||
// its TradingStatus will be flipped from 'Preopen' to 'Uninitialized'
|
||||
// (in the beginning of the callback). That will be the first event
|
||||
// in which order changes will be processed for the security.
|
||||
// As such, the matcher will initialize the state for the security
|
||||
// by adding every resting order it had prior to the event.
|
||||
// After that, the TradingStatus will be flipped to 'Initialized.'
|
||||
// From then on, updates for the security will be processed incrementally.
|
||||
enum class TradingStatus { None, Preopen, Uninitialized, Initialized };
|
||||
|
||||
private:
|
||||
struct PImpl;
|
||||
std::unique_ptr<PImpl> _me;
|
||||
|
||||
TradingStatus _trading_status(const SecuritySnapshot &s, size_t event_id);
|
||||
// returns true if the security's TradingStatus is 'Uninitialized', or
|
||||
// 'Initialized' (in other words, if it isn't 'None,' or 'Preopen')
|
||||
bool _is_ready_to_trade(const SecuritySnapshot &s, size_t event_id);
|
||||
// std::tuple<bool, std::string> _event_filter(const FeedEvent&);
|
||||
|
||||
// state maintenance
|
||||
void _sync_current_orders(FeedEvent const &ev);
|
||||
void _sync_previous_orders(FeedEvent const &ev);
|
||||
void _reset_matcher();
|
||||
};
|
||||
} // namespace bts::spartan::mdp3
|
||||
@@ -1,25 +0,0 @@
|
||||
#include "ValidateFifo.h"
|
||||
#include "back_testing/matcher/validation/matcher_validation_observer.h"
|
||||
#include "back_testing/feed_observers/IcebergFinder.h"
|
||||
#include "back_testing/common/mdp3_utils.h"
|
||||
#include <iostream>
|
||||
|
||||
namespace bts::spartan::cmds {
|
||||
|
||||
struct ValidateFifo::Args {
|
||||
std::string pcap;
|
||||
};
|
||||
|
||||
ValidateFifo::ValidateFifo()
|
||||
: CLI::App("", "validate-fifo"), _args(new ValidateFifo::Args()) {
|
||||
add_option("pcap,--pcap", _args->pcap)->required();
|
||||
callback([&] {
|
||||
auto ibs = mdp3::IcebergFinder::find_all(_args->pcap);
|
||||
mdp3::MatcherValidationObserver obs(ibs);
|
||||
mdp3::observe_channel(_args->pcap, obs);
|
||||
});
|
||||
}
|
||||
|
||||
ValidateFifo::~ValidateFifo() {}
|
||||
|
||||
} // namespace bts::spartan::cmds
|
||||
@@ -1,16 +0,0 @@
|
||||
#pragma once
|
||||
#include <CLI11/CLI11.hpp>
|
||||
#include <memory>
|
||||
|
||||
namespace bts::spartan::cmds {
|
||||
|
||||
struct ValidateFifo : public CLI::App {
|
||||
ValidateFifo();
|
||||
~ValidateFifo();
|
||||
|
||||
private:
|
||||
struct Args;
|
||||
std::unique_ptr<Args> _args;
|
||||
};
|
||||
|
||||
} // namespace bts::spartan::cmds
|
||||
Reference in new issue
Block a user