Many changes.
This commit is contained in:
1 parent
a851dc6bb5
commit
f07e018fbd
18 files changed
+329
-299
No files matched your search
@@ -167,6 +167,7 @@ CREATE TABLE polygon_values(
|
||||
book_5_eid numeric,
|
||||
book_5_side text
|
||||
);
|
||||
CREATE UNIQUE INDEX polygon_value_idx ON polygon_values(vid);
|
||||
|
||||
drop table if exists polygon_opportunities;
|
||||
create table polygon_opportunities(
|
||||
@@ -184,7 +185,7 @@ create table polygon_opportunities(
|
||||
end_eid numeric, /* last event where this opportunity appeared */
|
||||
min_n_orders numeric /* smallest number of orders preset for each of the legs of the polygon */
|
||||
);
|
||||
|
||||
CREATE UNIQUE INDEX polygon_op_value_idx ON polygon_opportunities(begin_vid,end_vid);
|
||||
|
||||
/* Usefull Views -------------------------------------------------------------------------------- */
|
||||
|
||||
@@ -279,7 +280,8 @@ select
|
||||
events_begin.h_t_time h_time,
|
||||
events_begin.last_st begin_ts,
|
||||
events_end.t_time end_ts,
|
||||
(events_end.t_time - events_begin.last_st) / 1000 duration,
|
||||
(events_end.t_time - events_begin.last_st) / 1000 observable_duration,
|
||||
(events_end.t_time - events_begin.t_time) / 1000 duration,
|
||||
events_begin.t_time t_time,
|
||||
(events_begin.last_st - events_begin.t_time)/ 1000 transaction_duration
|
||||
from
|
||||
@@ -303,89 +305,34 @@ where
|
||||
duration >20 and
|
||||
merged_value > 5;
|
||||
|
||||
|
||||
|
||||
drop view if exists j_tops_v;
|
||||
drop view if exists sim_md_mismatches;
|
||||
drop table if exists sim_books ;
|
||||
CREATE TABLE sim_books(
|
||||
eid numeric,
|
||||
sid numeric,
|
||||
/* regular books */
|
||||
/* ---------------------------------------------------- */
|
||||
/* price qty n orders */
|
||||
/* ---------------------------------------------------- */
|
||||
bid_p_0 numeric, bid_q_0 numeric, bid_no_0 numeric,
|
||||
bid_p_1 numeric, bid_q_1 numeric, bid_no_1 numeric,
|
||||
bid_p_2 numeric, bid_q_2 numeric, bid_no_2 numeric,
|
||||
bid_p_3 numeric, bid_q_3 numeric, bid_no_3 numeric,
|
||||
bid_p_4 numeric, bid_q_4 numeric, bid_no_4 numeric,
|
||||
bid_p_5 numeric, bid_q_5 numeric, bid_no_5 numeric,
|
||||
bid_p_6 numeric, bid_q_6 numeric, bid_no_6 numeric,
|
||||
bid_p_7 numeric, bid_q_7 numeric, bid_no_7 numeric,
|
||||
bid_p_8 numeric, bid_q_8 numeric, bid_no_8 numeric,
|
||||
bid_p_9 numeric, bid_q_9 numeric, bid_no_9 numeric,
|
||||
ask_p_0 numeric, ask_q_0 numeric, ask_no_0 numeric,
|
||||
ask_p_1 numeric, ask_q_1 numeric, ask_no_1 numeric,
|
||||
ask_p_2 numeric, ask_q_2 numeric, ask_no_2 numeric,
|
||||
ask_p_3 numeric, ask_q_3 numeric, ask_no_3 numeric,
|
||||
ask_p_4 numeric, ask_q_4 numeric, ask_no_4 numeric,
|
||||
ask_p_5 numeric, ask_q_5 numeric, ask_no_5 numeric,
|
||||
ask_p_6 numeric, ask_q_6 numeric, ask_no_6 numeric,
|
||||
ask_p_7 numeric, ask_q_7 numeric, ask_no_7 numeric,
|
||||
ask_p_8 numeric, ask_q_8 numeric, ask_no_8 numeric,
|
||||
ask_p_9 numeric, ask_q_9 numeric, ask_no_9 numeric
|
||||
);
|
||||
CREATE UNIQUE INDEX sim_book_idx ON sim_books(eid,sid);
|
||||
|
||||
drop view if exists j_tops_v;
|
||||
create view j_tops_v as
|
||||
drop view if exists opportunities_detail;
|
||||
create view opportunities_detail as
|
||||
select
|
||||
books.eid,
|
||||
books.sid,
|
||||
books.bid_p_0 md_bid, sim_books.bid_p_0 sim_bid,
|
||||
books.bid_q_0 md_bid_qty, sim_books.bid_q_0 sim_bid_qty,
|
||||
books.ask_p_0 md_ask, sim_books.ask_p_0 sim_ask,
|
||||
books.ask_q_0 md_ask_qty, sim_books.ask_q_0 sim_ask_qty
|
||||
from
|
||||
books, sim_books
|
||||
opportunities.*,
|
||||
(polygon_values.s_time-polygon_values.t_time)/1000 detail_transaction_duration,
|
||||
polygon_values.min_n_orders detail_n_orders,
|
||||
polygon_values.merged_value detail_value,
|
||||
polygon_values.merged_qty detail_qty
|
||||
from
|
||||
opportunities,
|
||||
polygon_values
|
||||
where
|
||||
books.sid = sim_books.sid and
|
||||
books.eid = sim_books.eid;
|
||||
polygon_values.vid >= opportunities.begin_vid and
|
||||
polygon_values.vid <= opportunities.end_vid;
|
||||
|
||||
create p_value as
|
||||
drop view if exists opportunity_summary;
|
||||
create view opportunity_summary as
|
||||
select
|
||||
h_t_time, events.eid,t_time,first_st,last_st,
|
||||
esz0.bid esz0_bid,
|
||||
esz0.ask esz0_ask,
|
||||
esu0.bid esu0_bid,
|
||||
esu0.ask esu0_ask,
|
||||
esu0_esz0.bid esu0_esz0_bid,
|
||||
esu0_esz0.ask esu0_esz0_ask,
|
||||
esu0.bid_qty esu0_bid_qty,
|
||||
esu0.ask_qty esu0_ask_qty,
|
||||
esz0.bid_qty esz0_bid_qty,
|
||||
esz0.ask_qty esz0_ask_qty,
|
||||
esu0_esz0.bid_qty esu0_esz0_bid_qty,
|
||||
esu0_esz0.ask_qty esu0_esz0_ask_qty
|
||||
min(merged_value) merged_value,
|
||||
min(observable_duration) observable_duration,
|
||||
min(transaction_duration) transaction_duration,
|
||||
avg(detail_transaction_duration) avg_detail_transaction_duration,
|
||||
max(detail_n_orders) max_n_orders,
|
||||
max(detail_value) max_value,
|
||||
max(detail_qty) max_detail_qt,
|
||||
count(*) event_count
|
||||
from
|
||||
events
|
||||
left join (select * from top_of_books where symbol='ESU0') esu0 on events.eid=esu0.eid
|
||||
left join (select * from top_of_books where symbol='ESZ0') esz0 on events.eid=esz0.eid
|
||||
left join (select * from top_of_books where symbol='ESU0-ESZ0') esu0_esz0 on events.eid=esz0.eid;
|
||||
opportunities_detail
|
||||
group by opid;
|
||||
|
||||
|
||||
|
||||
|
||||
drop function if exists get_book;
|
||||
create function get_book(sid_p numeric,eid_p numeric)
|
||||
returns numeric
|
||||
language plpgsql
|
||||
as
|
||||
$$
|
||||
declare
|
||||
eid_r numeric;
|
||||
begin
|
||||
select max(books.eid) into eid_r from books where books.sid=sid_p and books.eid<=eid_p ;
|
||||
return eid_r;
|
||||
end;
|
||||
$$
|
||||
@@ -93,20 +93,23 @@ select
|
||||
position_pandl,
|
||||
param_latency.param_value latency,
|
||||
param_date.param_value date,
|
||||
param_qty.param_value shot_qty,
|
||||
param_min_depth.param_value min_depth,
|
||||
param_min_value.param_value min_value,
|
||||
param_min_orders.param_value min_orders
|
||||
from
|
||||
session,
|
||||
run,
|
||||
(select * from param where param_name='base_algo_latency_ns') param_latency,
|
||||
(select * from param where param_name='market_date') param_date,
|
||||
(select * from param where param_name='Qty') param_qty,
|
||||
(select * from param where param_name='MinDepth') param_min_depth,
|
||||
(select * from param where param_name='MinValue') param_min_value,
|
||||
(select * from param where param_name='MinOrdersAtTop') param_min_orders
|
||||
WHERE
|
||||
session.session_id = run.session_id and
|
||||
run.run_id = param_latency.run_id and
|
||||
run.run_id = param_date.run_id and
|
||||
run.run_id = param_qty.run_id and
|
||||
run.run_id = param_min_depth.run_id and
|
||||
run.run_id = param_min_value.run_id and
|
||||
run.run_id = param_min_orders.run_id
|
||||
order by
|
||||
cast(realized_pandl as real) desc;
|
||||
|
||||
@@ -81,6 +81,12 @@ class IntPrice {
|
||||
_exponent = temp._exponent;
|
||||
return *this;
|
||||
}
|
||||
IntPrice& operator -=(const IntPrice& o) {
|
||||
auto temp = *this - o;
|
||||
_mantissa = temp._mantissa;
|
||||
_exponent = temp._exponent;
|
||||
return *this;
|
||||
}
|
||||
IntPrice operator * (const IntPrice& other) const {
|
||||
return op(other, [](int64_t m1, int64_t m2) { return m1 * m2; });
|
||||
}
|
||||
@@ -199,4 +205,4 @@ inline std::ostream& operator<<(std::ostream& os, const IntPrice& p) {
|
||||
return os;
|
||||
}
|
||||
|
||||
}}
|
||||
}}
|
||||
@@ -33,31 +33,30 @@ struct PolyObserver::Opportunity {
|
||||
MDP3Quantity quantity;
|
||||
};
|
||||
|
||||
struct PolyObserver::DependentTargets {
|
||||
MBPUpdate book;
|
||||
std::vector<Target *> dependencies;
|
||||
};
|
||||
|
||||
struct PolyObserver::PImpl {
|
||||
ISimServices *sim = nullptr;
|
||||
std::unordered_map<MDP3SecurityID, DependentTargets> books;
|
||||
std::unordered_map<MDP3SecurityID,MBPUpdate> books;
|
||||
std::vector<std::unique_ptr<Target>> targets;
|
||||
size_t event_id;
|
||||
AlgoEventID event_id;
|
||||
MDP3TimeStamp transact_time;
|
||||
MDP3TimeStamp observable_time;
|
||||
size_t max_events;
|
||||
};
|
||||
|
||||
PolyObserver::PolyObserver() : me(new PImpl()) {}
|
||||
PolyObserver::~PolyObserver() {}
|
||||
|
||||
void PolyObserver::init(ISimServices &s, protos::SimRunOptions const &) {
|
||||
|
||||
void PolyObserver::init(ISimServices &s, protos::SimRunOptions const &options) {
|
||||
me->sim = &s;
|
||||
me->books.clear();
|
||||
me->targets.clear();
|
||||
|
||||
me->event_id = 0;
|
||||
me->event_id = {0, 0};
|
||||
me->transact_time = MDP3TimeStamp{0};
|
||||
me->observable_time = MDP3TimeStamp{0};
|
||||
me->max_events =
|
||||
param_or_default(options, "MaxEvents", std::numeric_limits<int>::max());
|
||||
|
||||
for (auto &p : s.polygons()) {
|
||||
auto buy_t =
|
||||
@@ -71,28 +70,37 @@ void PolyObserver::init(ISimServices &s, protos::SimRunOptions const &) {
|
||||
me->targets.emplace_back(std::make_unique<Target>(buy_t));
|
||||
me->targets.emplace_back(std::make_unique<Target>(sell_t));
|
||||
}
|
||||
|
||||
for (auto &t : me->targets) {
|
||||
for (auto &pp : t->polygon.parts) {
|
||||
auto &dependencies = me->books[pp.sec_id].dependencies;
|
||||
dependencies.push_back(t.get());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void PolyObserver::on_notification(AlgoNotification const &n) {
|
||||
me->transact_time = n.transact_time;
|
||||
me->observable_time = n.observable_time;
|
||||
std::visit(*this, n.event);
|
||||
if (n.event_id.first >= me->max_events)
|
||||
me->sim->terminate_simulation();
|
||||
else {
|
||||
if (me->event_id.first) {
|
||||
for (auto i = me->event_id.first+1;i < n.event_id.first;i++) {
|
||||
me->event_id.first = i;
|
||||
me->event_id.second = 0;
|
||||
me->transact_time = n.transact_time;
|
||||
me->observable_time = n.observable_time;
|
||||
eval();
|
||||
rank();
|
||||
log();
|
||||
}
|
||||
}
|
||||
me->event_id = n.event_id;
|
||||
me->transact_time = n.transact_time;
|
||||
me->observable_time = n.observable_time;
|
||||
std::visit(*this, n.event);
|
||||
}
|
||||
}
|
||||
|
||||
void PolyObserver::eval(std::vector<Target *> const &targets) {
|
||||
for (auto &t : targets) {
|
||||
void PolyObserver::eval() {
|
||||
for (auto &t : me->targets) {
|
||||
t->value = 0;
|
||||
int qty = 1;
|
||||
for (auto &l : t->polygon.parts) {
|
||||
auto mkt_side = securities::other_side(side_from_ratio(l.ratio));
|
||||
auto &mkt = me->books[l.sec_id].book.mbp_side(mkt_side);
|
||||
auto &mkt = me->books[l.sec_id].mbp_side(mkt_side);
|
||||
auto this_qty = mkt[0].quantity.value();
|
||||
auto this_ratio = this_qty / std::abs(l.ratio);
|
||||
if (this_ratio < qty)
|
||||
@@ -126,35 +134,45 @@ void PolyObserver::rank() {
|
||||
void PolyObserver::log() {
|
||||
for (auto const &t : me->targets)
|
||||
if (t->has_value())
|
||||
me->sim->log("opportunity", me->event_id, t->descriptor, t->value,
|
||||
t->quantity.value());
|
||||
me->sim->log("opportunity", me->event_id.first, me->event_id.second,
|
||||
t->descriptor, t->value, t->quantity.value());
|
||||
}
|
||||
|
||||
void PolyObserver::log_book_update(MBPUpdate const &update) {
|
||||
me->sim->log("book", me->sim->get_sec(update.security_id).symbol(),
|
||||
update.original_event_id, update.mbp_buy[0].price.price(),
|
||||
update.mbp_buy[0].quantity.value(),
|
||||
update.mbp_sell[0].price.price(),
|
||||
update.mbp_sell[0].quantity.value());
|
||||
}
|
||||
|
||||
void PolyObserver::operator()(const MBPUpdate &mbp) {
|
||||
me->sim->log("book", me->sim->get_sec(mbp.security_id).symbol(),
|
||||
mbp.original_event_id, mbp.mbp_buy[0].price.price(),
|
||||
mbp.mbp_buy[0].quantity.value(), mbp.mbp_sell[0].price.price(),
|
||||
mbp.mbp_sell[0].quantity.value());
|
||||
|
||||
if (mbp.original_event_id > 20000)
|
||||
me->sim->terminate_simulation();
|
||||
std::pair<md::IntPrice, MDP3Quantity> available(Book const&b) {
|
||||
std::pair<md::IntPrice, MDP3Quantity> result ;
|
||||
result.first = md::IntPrice{};
|
||||
result.second= MDP3Quantity{0};
|
||||
|
||||
me->event_id = mbp.original_event_id;
|
||||
auto it = me->books.find(mbp.security_id);
|
||||
if (it == me->books.end())
|
||||
return;
|
||||
for (size_t i = 0; i < b.size();i++) {
|
||||
if (b[i].quantity.value() == 0)
|
||||
break;
|
||||
else {
|
||||
result.first = b[i].price;
|
||||
result.second.value() += b[i].quantity.value();
|
||||
}
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
auto &book = it->second;
|
||||
book.book = mbp;
|
||||
eval(book.dependencies);
|
||||
|
||||
void PolyObserver::operator()(const MBPUpdate &mbp) {
|
||||
|
||||
auto avb = available(mbp.mbp_buy);
|
||||
auto avs = available(mbp.mbp_sell);
|
||||
|
||||
me->sim->log("book", me->sim->get_sec(mbp.security_id).symbol(),
|
||||
me->event_id.first,
|
||||
mbp.mbp_buy[0].price.price(),
|
||||
mbp.mbp_buy[0].quantity.value(),
|
||||
mbp.mbp_sell[0].price.price(),
|
||||
mbp.mbp_sell[0].quantity.value(),
|
||||
avb.first.price(),
|
||||
avb.second.value(),
|
||||
avs.first.price(),
|
||||
avs.second.value());
|
||||
|
||||
me->books[mbp.security_id] = mbp;
|
||||
eval();
|
||||
rank();
|
||||
log();
|
||||
}
|
||||
|
||||
@@ -23,8 +23,7 @@ private:
|
||||
struct Target;
|
||||
struct Opportunity;
|
||||
struct DependentTargets;
|
||||
void log_book_update(MBPUpdate const &);
|
||||
void eval(std::vector<Target*> const&);
|
||||
void eval();
|
||||
void rank();
|
||||
void log();
|
||||
std::unique_ptr<PImpl> me;
|
||||
|
||||
@@ -13,7 +13,7 @@
|
||||
|
||||
namespace bts::spartan::mdp3 {
|
||||
|
||||
enum class Sniper::State { WAIT_OPPORTUNITY, WAIT_FILLS };
|
||||
enum class Sniper::State { WAIT_OPPORTUNITY, WAIT_FILLS, WAIT_CLEAR };
|
||||
|
||||
struct Sniper::Target {
|
||||
constexpr static double Worthless = -1.0;
|
||||
@@ -28,18 +28,17 @@ struct Sniper::Target {
|
||||
|
||||
void mark_as_worthless() { value = Worthless; }
|
||||
|
||||
bool has_value() const { return value > securities::market_epsilon(); }
|
||||
bool has_value(double v) const { return value > v; }
|
||||
|
||||
int value_in_ticks() const { return value / tick_size; }
|
||||
};
|
||||
|
||||
struct Sniper::Shot {
|
||||
Target ⌖
|
||||
size_t observed_event_id;
|
||||
AlgoEventID observed_event_id;
|
||||
MDP3TimeStamp observed_ts;
|
||||
double value_at_observation_ts;
|
||||
MDP3Quantity quantity;
|
||||
size_t end_of_opportunity_window;
|
||||
std::unordered_map<MDP3OrderKey, std::vector<OrderUpdate>> fills;
|
||||
};
|
||||
|
||||
@@ -55,74 +54,81 @@ struct Sniper::PImpl {
|
||||
int order_qty;
|
||||
int min_depth;
|
||||
bool affect_books;
|
||||
size_t max_events;
|
||||
double min_value;
|
||||
size_t max_transaction_latency;
|
||||
|
||||
State state = State::WAIT_OPPORTUNITY;
|
||||
std::unordered_map<MDP3SecurityID, DependentTargets> books;
|
||||
std::vector<Target> targets;
|
||||
std::optional<Shot> in_flight;
|
||||
size_t event_id;
|
||||
std::vector<std::unique_ptr<Target>> targets;
|
||||
std::optional<Shot> current_shot;
|
||||
|
||||
MDP3TimeStamp transact_time;
|
||||
MDP3TimeStamp observable_time;
|
||||
AlgoEventID current_event;
|
||||
};
|
||||
|
||||
Sniper::Sniper() : me(new PImpl()) {}
|
||||
Sniper::~Sniper() {}
|
||||
|
||||
int param_or_default(protos::SimRunOptions const &options,
|
||||
std::string const &name, int default_value) {
|
||||
auto it = options.parameters().find(name);
|
||||
if (it != options.parameters().end())
|
||||
return std::stoi(it->second);
|
||||
else
|
||||
return default_value;
|
||||
}
|
||||
|
||||
void Sniper::init(ISimServices &s, protos::SimRunOptions const &options) {
|
||||
me->sim = &s;
|
||||
me->options = options;
|
||||
|
||||
me->min_orders_at_top = param_or_default(options, "MinOrdersAtTop", 1);
|
||||
me->order_qty = param_or_default(options, "Qty", 1);
|
||||
me->min_depth = param_or_default(options, "MinDepth", 100);
|
||||
me->min_depth = param_or_default(options, "MinDepth", 0);
|
||||
me->affect_books = param_or_default(options, "AffectBooks", true);
|
||||
me->max_events =
|
||||
param_or_default(options, "MaxEvents", std::numeric_limits<int>::max());
|
||||
me->min_value = param_or_default(options, "MinValue", 2);
|
||||
me->max_transaction_latency =
|
||||
param_or_default(options, "MaxTransactionLatency", 100000);
|
||||
|
||||
me->state = State::WAIT_OPPORTUNITY;
|
||||
me->books.clear();
|
||||
me->targets.clear();
|
||||
me->in_flight.reset();
|
||||
me->event_id = 0;
|
||||
me->current_shot.reset();
|
||||
me->current_event = {0, 0};
|
||||
me->transact_time = MDP3TimeStamp{0};
|
||||
me->observable_time = MDP3TimeStamp{0};
|
||||
|
||||
for (auto &p : s.polygons()) {
|
||||
auto buy_t =
|
||||
|
||||
auto desc = polygon_descriptor(p.second, me->sim->instruments());
|
||||
auto buy_t = std::make_unique<Target>(
|
||||
Target{p.second, polygon_descriptor(p.second, me->sim->instruments()),
|
||||
polygon_product(p.second, me->sim->instruments()),
|
||||
abs_contracts(p.second, me->sim->instruments()),
|
||||
tick_size(p.second, me->sim->instruments())};
|
||||
auto sell_t =
|
||||
tick_size(p.second, me->sim->instruments())});
|
||||
auto sell_t = std::make_unique<Target>(
|
||||
Target{flip(p.second),
|
||||
polygon_descriptor(flip(p.second), me->sim->instruments()),
|
||||
polygon_product(p.second, me->sim->instruments()),
|
||||
abs_contracts(p.second, me->sim->instruments()),
|
||||
tick_size(p.second, me->sim->instruments())};
|
||||
tick_size(p.second, me->sim->instruments())});
|
||||
|
||||
me->targets.emplace_back(buy_t);
|
||||
me->targets.emplace_back(sell_t);
|
||||
me->targets.emplace_back(std::move(buy_t));
|
||||
me->targets.emplace_back(std::move(sell_t));
|
||||
}
|
||||
|
||||
for (auto &t : me->targets) {
|
||||
for (auto &pp : t.polygon.parts) {
|
||||
for (auto &pp : t->polygon.parts) {
|
||||
auto &dependencies = me->books[pp.sec_id].dependencies;
|
||||
dependencies.push_back(&t);
|
||||
dependencies.push_back(t.get());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void Sniper::on_notification(AlgoNotification const &n) {
|
||||
me->transact_time = n.transact_time;
|
||||
me->observable_time = n.observable_time;
|
||||
std::visit(*this, n.event);
|
||||
if (n.event_id.first >= me->max_events)
|
||||
me->sim->terminate_simulation();
|
||||
else {
|
||||
me->current_event = n.event_id;
|
||||
me->transact_time = n.transact_time;
|
||||
me->observable_time = n.observable_time;
|
||||
std::visit(*this, n.event);
|
||||
}
|
||||
}
|
||||
|
||||
void Sniper::eval(std::vector<Target *> const &targets) {
|
||||
@@ -149,9 +155,10 @@ void Sniper::eval(std::vector<Target *> const &targets) {
|
||||
}
|
||||
}
|
||||
|
||||
Sniper::MaybeShot Sniper::pick(std::vector<Target *> &targets) {
|
||||
std::sort(targets.begin(), targets.end(),
|
||||
[](Target const *ptr1, Target const *ptr2) {
|
||||
Sniper::MaybeShot Sniper::pick() {
|
||||
std::sort(me->targets.begin(), me->targets.end(),
|
||||
[](std::unique_ptr<Target> const &ptr1,
|
||||
std::unique_ptr<Target> const &ptr2) {
|
||||
auto val1 = ptr1->value * ptr1->quantity.value();
|
||||
auto val2 = ptr2->value * ptr2->quantity.value();
|
||||
if (std::abs(val1 - val2) > securities::market_epsilon())
|
||||
@@ -161,20 +168,19 @@ Sniper::MaybeShot Sniper::pick(std::vector<Target *> &targets) {
|
||||
ptr2->polygon.parts.size();
|
||||
});
|
||||
|
||||
if (targets[0]->has_value()) {
|
||||
for (auto t : targets)
|
||||
if (t->has_value())
|
||||
me->sim->log("opportunity", me->event_id, t->descriptor, t->product,
|
||||
t->n_abs_contracts, t->value_in_ticks(), t->value,
|
||||
t->quantity.value(), t->value * t->quantity.value());
|
||||
if (me->order_qty)
|
||||
return Shot{*targets[0],
|
||||
me->event_id,
|
||||
me->sim->now(),
|
||||
targets[0]->value,
|
||||
targets[0]->quantity,
|
||||
0,
|
||||
{}};
|
||||
if (me->targets[0]->has_value(me->min_value)) {
|
||||
for (auto const &t : me->targets)
|
||||
if (t->has_value(me->min_value))
|
||||
me->sim->log("opportunity", me->transact_time.value(),
|
||||
me->observable_time.value(), me->current_event.first,
|
||||
me->current_event.second, t->descriptor, t->value,
|
||||
t->quantity.value());
|
||||
if (me->order_qty &&
|
||||
(me->observable_time.value() - me->transact_time.value()) <
|
||||
me->max_transaction_latency)
|
||||
return Shot{*me->targets[0], me->current_event,
|
||||
me->sim->now(), me->targets[0]->value,
|
||||
me->targets[0]->quantity, {}};
|
||||
else
|
||||
return {};
|
||||
} else
|
||||
@@ -183,19 +189,29 @@ Sniper::MaybeShot Sniper::pick(std::vector<Target *> &targets) {
|
||||
|
||||
void Sniper::fire(Shot const &s) {
|
||||
|
||||
auto &shot = me->in_flight.emplace(s);
|
||||
auto &shot = me->current_shot.emplace(s);
|
||||
|
||||
for (auto &p : shot.target.polygon.parts) {
|
||||
auto part_side = p.ratio > 0 ? api::SIDE_BUY : api::SIDE_SELL;
|
||||
auto mkt_side = securities::other_side(part_side);
|
||||
auto &book = me->books[p.sec_id].book.mbp_side(mkt_side);
|
||||
|
||||
md::IntPrice worst_price;
|
||||
size_t available_qty = 0;
|
||||
for (int i = book.size() - 1; i >= 0; i--) {
|
||||
if (book[i].quantity.value()) {
|
||||
worst_price = book[i].price;
|
||||
for (int n = 0; n <= i; n++)
|
||||
available_qty += book[n].quantity.value();
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (part_side == api::SIDE_BUY)
|
||||
worst_price +=
|
||||
me->sim->get_sec(p.sec_id).min_price_increment_int_price() * 100;
|
||||
else
|
||||
worst_price -=
|
||||
me->sim->get_sec(p.sec_id).min_price_increment_int_price() * 100;
|
||||
|
||||
auto order_change = SmallOrderChange{};
|
||||
order_change.affect_book = me->affect_books;
|
||||
@@ -206,75 +222,63 @@ void Sniper::fire(Shot const &s) {
|
||||
MDP3Quantity{s.quantity.value() * std::abs(p.ratio)};
|
||||
order_change.order.side = part_side;
|
||||
order_change.change = OrderChange::added;
|
||||
|
||||
me->sim->log("sending_order", api::Side_Name(part_side),
|
||||
me->sim->log("sending_order", me->current_event.first,
|
||||
me->current_event.second, api::Side_Name(part_side),
|
||||
me->sim->get_sec(p.sec_id).symbol(), book[0].price.price(),
|
||||
worst_price.price());
|
||||
worst_price.price(), available_qty);
|
||||
me->sim->send(order_change);
|
||||
shot.fills[order_change.order.key] = {};
|
||||
|
||||
order_change.change = OrderChange::removed;
|
||||
me->sim->send(order_change);
|
||||
}
|
||||
me->sim->log("shot", shot.target.descriptor, shot.observed_event_id,
|
||||
shot.target.product, shot.target.n_abs_contracts,
|
||||
shot.target.value_in_ticks(), shot.observed_ts.value(),
|
||||
shot.value_at_observation_ts);
|
||||
}
|
||||
|
||||
void Sniper::eval_pick_fire(std::vector<Target *> &targets) {
|
||||
bts_assert(me->state == State::WAIT_OPPORTUNITY);
|
||||
eval(targets);
|
||||
auto best_shot = pick(targets);
|
||||
if (best_shot) {
|
||||
fire(best_shot.value());
|
||||
transition(State::WAIT_FILLS);
|
||||
}
|
||||
}
|
||||
|
||||
void Sniper::operator()(const MBPUpdate &mbp) {
|
||||
me->sim->log("book", me->sim->get_sec(mbp.security_id).symbol(),
|
||||
mbp.original_event_id, mbp.mbp_buy[0].price.price(),
|
||||
mbp.mbp_buy[0].quantity.value(), mbp.mbp_sell[0].price.price(),
|
||||
mbp.mbp_sell[0].quantity.value());
|
||||
|
||||
if (mbp.original_event_id > 20000)
|
||||
me->sim->terminate_simulation();
|
||||
|
||||
if (mbp.original_event_id)
|
||||
me->event_id = mbp.original_event_id;
|
||||
auto it = me->books.find(mbp.security_id);
|
||||
if (it == me->books.end())
|
||||
return;
|
||||
|
||||
|
||||
auto &book = it->second;
|
||||
book.book = mbp;
|
||||
|
||||
switch (me->state) {
|
||||
case State::WAIT_OPPORTUNITY:
|
||||
eval_pick_fire(book.dependencies);
|
||||
break;
|
||||
case State::WAIT_FILLS:
|
||||
eval({&me->in_flight->target});
|
||||
if (!me->in_flight->target.has_value() && !me->in_flight->end_of_opportunity_window) {
|
||||
me->in_flight->end_of_opportunity_window = me->event_id;
|
||||
auto t = &me->in_flight->target;
|
||||
me->sim->log("opportunity_end", me->event_id, t->descriptor,
|
||||
t->product, t->n_abs_contracts, t->value_in_ticks(),
|
||||
t->value, t->quantity.value(),
|
||||
t->value * t->quantity.value());
|
||||
}
|
||||
eval(book.dependencies);
|
||||
|
||||
pick(book.dependencies);
|
||||
switch (me->state) {
|
||||
case State::WAIT_OPPORTUNITY: {
|
||||
auto best_shot = pick();
|
||||
if (best_shot) {
|
||||
fire(best_shot.value());
|
||||
transition(State::WAIT_FILLS);
|
||||
}
|
||||
break;
|
||||
}
|
||||
} // namespace bts::spartan::mdp3
|
||||
case State::WAIT_FILLS:
|
||||
me->sim->log("wait_fills", me->current_event.first,
|
||||
me->current_event.second);
|
||||
break;
|
||||
case State::WAIT_CLEAR:
|
||||
bts_assert(me->current_shot);
|
||||
if (!me->current_shot->target.has_value(me->min_value)) {
|
||||
me->current_shot.reset();
|
||||
me->state = State::WAIT_OPPORTUNITY;
|
||||
auto best_shot = pick();
|
||||
if (best_shot) {
|
||||
fire(best_shot.value());
|
||||
transition(State::WAIT_FILLS);
|
||||
}
|
||||
} else {
|
||||
me->sim->log("wait_clear", me->current_event.first,
|
||||
me->current_event.second);
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
void Sniper::operator()(const OrderUpdate &update) {
|
||||
bts_assert(me->state == State::WAIT_FILLS);
|
||||
bts_assert(me->in_flight);
|
||||
auto &in_flight = me->in_flight.value();
|
||||
bts_assert(me->current_shot);
|
||||
auto &in_flight = me->current_shot.value();
|
||||
|
||||
bts_assert(in_flight.fills.count(update.key));
|
||||
in_flight.fills[update.key].push_back(update);
|
||||
@@ -298,22 +302,13 @@ void Sniper::operator()(const OrderUpdate &update) {
|
||||
these_fills.end());
|
||||
}
|
||||
PandL pandl(me->sim->instruments());
|
||||
me->sim->log("shot_outcome", in_flight.observed_event_id,
|
||||
in_flight.observed_ts.value(), in_flight.target.descriptor,
|
||||
in_flight.value_at_observation_ts,
|
||||
in_flight.quantity.value(), me->transact_time.value(),
|
||||
pandl.net_cash(all_fills), in_flight.target.n_abs_contracts);
|
||||
me->sim->log("shot_outcome", in_flight.target.descriptor,
|
||||
in_flight.observed_event_id.first,
|
||||
in_flight.observed_event_id.second, me->current_event.first,
|
||||
me->current_event.second, in_flight.value_at_observation_ts,
|
||||
pandl.net_cash(all_fills));
|
||||
me->sim->log_pandl();
|
||||
transition(State::WAIT_OPPORTUNITY);
|
||||
auto observed_ts = me->in_flight->observed_ts;
|
||||
me->in_flight.reset();
|
||||
if (observed_ts < me->observable_time) {
|
||||
// We have received events since we shot, revaluate
|
||||
std::vector<Target*> t_ptr;
|
||||
for (auto &t:me->targets)
|
||||
t_ptr.push_back(&t);
|
||||
eval_pick_fire(t_ptr);
|
||||
}
|
||||
transition(State::WAIT_CLEAR);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -323,6 +318,8 @@ const char *Sniper::state_name(State s) {
|
||||
return "WAIT";
|
||||
case State::WAIT_OPPORTUNITY:
|
||||
return "WATCH";
|
||||
case State::WAIT_CLEAR:
|
||||
return "WAIT_CLEAR";
|
||||
}
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
@@ -27,9 +27,8 @@ private:
|
||||
using MaybeShot = std::optional<Shot>;
|
||||
|
||||
void eval(std::vector<Target*> const&);
|
||||
MaybeShot pick(std::vector<Target*> &);
|
||||
MaybeShot pick();
|
||||
void fire(Shot const&);
|
||||
void eval_pick_fire(std::vector<Target*> &);
|
||||
|
||||
void transition(State);
|
||||
const char *state_name(State);
|
||||
|
||||
+4
@@ -139,6 +139,7 @@ TEST_CASE ("sim_spreader", "[spreader]"){
|
||||
// send leg_1 book update => leg_2 should quote
|
||||
sim_spreader.on_notification(
|
||||
{
|
||||
{},
|
||||
bts::spartan::mdp3::MDP3TimeStamp{},
|
||||
bts::spartan::mdp3::MDP3TimeStamp{},
|
||||
md_udpate_leg_1
|
||||
@@ -163,6 +164,7 @@ TEST_CASE ("sim_spreader", "[spreader]"){
|
||||
auto md_udpate_leg_1 = get_book_update(bids,asks,leg_1.security().id());
|
||||
sim_spreader.on_notification(
|
||||
{
|
||||
{},
|
||||
bts::spartan::mdp3::MDP3TimeStamp{},
|
||||
bts::spartan::mdp3::MDP3TimeStamp{},
|
||||
md_udpate_leg_1
|
||||
@@ -181,6 +183,7 @@ TEST_CASE ("sim_spreader", "[spreader]"){
|
||||
auto q_ord = sim_services.last_change.order;
|
||||
sim_spreader.on_notification(
|
||||
{
|
||||
{},
|
||||
bts::spartan::mdp3::MDP3TimeStamp{},
|
||||
bts::spartan::mdp3::MDP3TimeStamp{},
|
||||
bts::spartan::mdp3::OrderUpdate{
|
||||
@@ -206,6 +209,7 @@ TEST_CASE ("sim_spreader", "[spreader]"){
|
||||
// send the hedge fill and it should go to end state
|
||||
sim_spreader.on_notification(
|
||||
{
|
||||
{},
|
||||
bts::spartan::mdp3::MDP3TimeStamp{},
|
||||
bts::spartan::mdp3::MDP3TimeStamp{},
|
||||
bts::spartan::mdp3::OrderUpdate{
|
||||
|
||||
@@ -182,6 +182,8 @@ void FifoSecurityMatcher::_on_order_not_affecting_books(
|
||||
auto& opp_book = _book(_opp_side(ord.side));
|
||||
uint32_t new_ord_rem = total_quantity(ord).value();
|
||||
for (FifoPriceLevelMatcher &pl : opp_book) {
|
||||
if(!pl.populated())
|
||||
continue;
|
||||
if (_is_cross(ord, pl)){
|
||||
uint32_t level_qty =
|
||||
static_cast<uint32_t>(pl.total_quantity().value());
|
||||
|
||||
@@ -177,7 +177,6 @@ void MergedMatcher::match(ChangeSrc,
|
||||
auto new_mbp = sec_kv.second.get_new_mbp();
|
||||
if (new_mbp.has_value()) {
|
||||
res->emplace_back(MBPUpdate{
|
||||
0,
|
||||
sec_kv.first,
|
||||
new_mbp.value().bids,
|
||||
new_mbp.value().asks,
|
||||
@@ -291,7 +290,6 @@ void DirectMatcher::match(ChangeSrc,
|
||||
res->emplace_back(
|
||||
MBPUpdate
|
||||
{
|
||||
0,
|
||||
cm.first,
|
||||
cm.second->matcher.book(api::Side::SIDE_BUY),
|
||||
cm.second->matcher.book(api::Side::SIDE_SELL),
|
||||
|
||||
@@ -4,8 +4,9 @@
|
||||
|
||||
namespace bts::spartan::mdp3 {
|
||||
|
||||
using AlgoEventID = std::pair<size_t,size_t> ;
|
||||
|
||||
struct MBPUpdate {
|
||||
size_t original_event_id;
|
||||
MDP3SecurityID security_id;
|
||||
Book mbp_buy;
|
||||
Book mbp_sell;
|
||||
@@ -49,6 +50,7 @@ using MatchEffect =
|
||||
std::variant<MBPUpdate,OrderUpdate>;
|
||||
|
||||
struct AlgoNotification {
|
||||
AlgoEventID event_id;
|
||||
MDP3TimeStamp transact_time;
|
||||
MDP3TimeStamp observable_time;
|
||||
std::variant<MBPUpdate,OrderUpdate> event;
|
||||
|
||||
@@ -80,7 +80,7 @@ void ExchangeSim::prepare_run(std::vector<IAlgoModel *> const &algos,
|
||||
|
||||
// Init gateways, add them to the simulator
|
||||
for (auto &i : me->inputs) {
|
||||
auto &gw = me->run_state->gateways.emplace_back(i->instruments, options);
|
||||
auto &gw = me->run_state->gateways.emplace_back(me->logger,i->instruments, options);
|
||||
me->run_state->simulator.add_agent(gw);
|
||||
}
|
||||
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
#pragma once
|
||||
|
||||
#include "../../common/mdp3_common.h"
|
||||
#include "server/sparkd/cmds/spartan/md/mdp3/back_testing/orchestrator/SimSessionOptions.pb.h"
|
||||
#include "AlgoEvent.h"
|
||||
|
||||
namespace bts::spartan::protos {
|
||||
@@ -9,6 +10,15 @@ class SimRunOptions;
|
||||
namespace bts::spartan::mdp3 {
|
||||
class ISimServices;
|
||||
|
||||
inline int param_or_default(protos::SimRunOptions const &options,
|
||||
std::string const &name, int default_value) {
|
||||
auto it = options.parameters().find(name);
|
||||
if (it != options.parameters().end())
|
||||
return std::stoi(it->second);
|
||||
else
|
||||
return default_value;
|
||||
}
|
||||
|
||||
class IAlgoModel {
|
||||
public:
|
||||
virtual ~IAlgoModel();
|
||||
|
||||
@@ -127,6 +127,9 @@ Book AlgoAgent::book(MDP3SecurityID id, api::Side s) const {
|
||||
}
|
||||
|
||||
void AlgoAgent::send(SmallOrderChange const &change, uint64_t propagation_delay) {
|
||||
auto total_delay = me->options.base_algo_latency_ns() + propagation_delay;
|
||||
auto t_time = time() + total_delay;
|
||||
|
||||
log("order_action", change_name(change.change),
|
||||
get_sec(change.order.security).symbol(), change.order.price.price(),
|
||||
change.order.quantity.value(), api::Side_Name(change.order.side),
|
||||
@@ -134,8 +137,8 @@ void AlgoAgent::send(SmallOrderChange const &change, uint64_t propagation_delay)
|
||||
|
||||
me->my_orders.insert(change.order.key);
|
||||
emit_delayed_event<AlgoActionEvent>(
|
||||
me->options.base_algo_latency_ns() + propagation_delay,
|
||||
AlgoAction{MDP3TimeStamp{time()}, change});
|
||||
total_delay,
|
||||
AlgoAction{MDP3TimeStamp{t_time}, change});
|
||||
}
|
||||
|
||||
void AlgoAgent::terminate_simulation() {
|
||||
|
||||
+75
-44
@@ -16,7 +16,7 @@
|
||||
// just uncomment the line below.
|
||||
#define ENABLE_IMPLIED_MATCHING
|
||||
namespace bts::spartan::mdp3 {
|
||||
|
||||
|
||||
#ifdef ENABLE_IMPLIED_MATCHING
|
||||
using Matcher = MergedMatcher;
|
||||
#else
|
||||
@@ -33,27 +33,33 @@ extract_ids(std::unordered_map<MDP3SecurityID, InstrumentDefinition> const &m) {
|
||||
|
||||
struct GatewayAgent::PImpl {
|
||||
#ifdef ENABLE_IMPLIED_MATCHING
|
||||
PImpl(std::unordered_map<MDP3SecurityID, InstrumentDefinition> const &defs,
|
||||
PImpl(SimLogger const &l,
|
||||
std::unordered_map<MDP3SecurityID, InstrumentDefinition> const &defs,
|
||||
protos::SimRunOptions const &options)
|
||||
: my_instruments(defs), options(options), matcher() {
|
||||
auto def_vals = defs | ranges::views::transform([](const auto& p) { return p.second; });
|
||||
matcher.init(def_vals.begin(), def_vals.end());
|
||||
}
|
||||
: my_instruments(defs), options(options), matcher(),
|
||||
logger(l), current_event{0, 0} {
|
||||
auto def_vals = defs | ranges::views::transform(
|
||||
[](const auto &p) { return p.second; });
|
||||
matcher.init(def_vals.begin(), def_vals.end());
|
||||
}
|
||||
#else
|
||||
PImpl(std::unordered_map<MDP3SecurityID, InstrumentDefinition> const &defs,
|
||||
protos::SimRunOptions const &options)
|
||||
: my_instruments(defs), options(options), matcher(extract_ids(defs)) { }
|
||||
: my_instruments(defs), options(options), matcher(extract_ids(defs)) {}
|
||||
#endif
|
||||
std::unordered_map<MDP3SecurityID, InstrumentDefinition> const
|
||||
&my_instruments;
|
||||
protos::SimRunOptions options;
|
||||
Matcher matcher;
|
||||
SimLogger logger;
|
||||
AlgoEventID current_event;
|
||||
};
|
||||
|
||||
GatewayAgent::GatewayAgent(
|
||||
SimLogger const &l,
|
||||
std::unordered_map<MDP3SecurityID, InstrumentDefinition> const &defs,
|
||||
protos::SimRunOptions const &options)
|
||||
: me(new PImpl(defs, options)) {
|
||||
: me(new PImpl(l, defs, options)) {
|
||||
me->options = options;
|
||||
}
|
||||
|
||||
@@ -82,6 +88,14 @@ Book GatewayAgent::book(MDP3SecurityID id, api::Side s) {
|
||||
return me->matcher.book(id, s);
|
||||
}
|
||||
|
||||
template <class... T>
|
||||
void log(SimLogger &l, sim::TimeStamp ts, std::string const &log_entry_type,
|
||||
T &&... args) {
|
||||
auto lst =
|
||||
std::initializer_list<std::string>{to_str(std::forward<T>(args))...};
|
||||
l(MDP3TimeStamp{ts}, log_entry_type, lst);
|
||||
}
|
||||
|
||||
// Handle a recorded order change, that is an order change we got from
|
||||
// a pcap recording of the market data
|
||||
void GatewayAgent::_handle(ExchangeTransactionEvent const &e) {
|
||||
@@ -92,9 +106,11 @@ void GatewayAgent::_handle(ExchangeTransactionEvent const &e) {
|
||||
|
||||
if (me->my_instruments.count(first_change.order.security)) {
|
||||
|
||||
// Advance our clock either to the send time in the recording
|
||||
// (unless we are already ahead of that time, possibly because
|
||||
// we got delayed processing algo operations).
|
||||
me->current_event = AlgoEventID{ev->event_id, 0};
|
||||
|
||||
// Advance our clock to the send time in the recording (unless
|
||||
// we are already ahead of that time, possibly because we got
|
||||
// delayed processing algo operations).
|
||||
auto send_time = ev->last_packet_send_time.value();
|
||||
if (send_time > time())
|
||||
forward_clock_by(send_time - time());
|
||||
@@ -107,49 +123,64 @@ void GatewayAgent::_handle(ExchangeTransactionEvent const &e) {
|
||||
me->matcher.match(Matcher::SIMULATOR_INPUT, ev->order_changes, &effects);
|
||||
|
||||
for (auto &ef : effects)
|
||||
std::visit(overloaded{[&](MBPUpdate &mbp) {
|
||||
mbp.original_event_id = e.ev->event_id;
|
||||
emit_delayed_event<AlgoNotificationEvent>(
|
||||
me->options.mbp_update_delay_ns(),
|
||||
AlgoNotification{ev->transact_time,
|
||||
MDP3TimeStamp{time()},
|
||||
mbp});
|
||||
},
|
||||
[&](OrderUpdate const &order_update) {
|
||||
emit_delayed_event<AlgoNotificationEvent>(
|
||||
me->options.order_update_delay_ns(),
|
||||
AlgoNotification{ev->transact_time,
|
||||
MDP3TimeStamp{time()},
|
||||
order_update});
|
||||
}},
|
||||
ef);
|
||||
std::visit(
|
||||
overloaded{
|
||||
[&](MBPUpdate &mbp) {
|
||||
emit_delayed_event<AlgoNotificationEvent>(
|
||||
me->options.mbp_update_delay_ns(),
|
||||
AlgoNotification{me->current_event, ev->transact_time,
|
||||
MDP3TimeStamp{time()}, mbp});
|
||||
},
|
||||
[&](OrderUpdate const &order_update) {
|
||||
emit_delayed_event<AlgoNotificationEvent>(
|
||||
me->options.order_update_delay_ns(),
|
||||
AlgoNotification{me->current_event, ev->transact_time,
|
||||
MDP3TimeStamp{time()}, order_update});
|
||||
}},
|
||||
ef);
|
||||
}
|
||||
}
|
||||
|
||||
// Handle an algo order change, that is an order change requested by
|
||||
// one of the algos under test.
|
||||
void GatewayAgent::_handle(AlgoActionEvent const &e) {
|
||||
me->current_event.second++;
|
||||
auto const &algo_action = e.ev;
|
||||
auto const &change = algo_action.change;
|
||||
|
||||
|
||||
log(me->logger, time(), "gw_algo_order", algo_action.transact_time.value(),
|
||||
change_name(change.change), get_sec(change.order.security).symbol(),
|
||||
change.order.price.price(), change.order.quantity.value(),
|
||||
api::Side_Name(change.order.side), change.order.key.value(),
|
||||
change.order.security.value(), me->current_event.first,
|
||||
me->current_event.second);
|
||||
|
||||
std::vector<Matcher::MatchEffect> effects;
|
||||
me->matcher.match(Matcher::ALGO, {algo_action.change}, &effects);
|
||||
for (auto &ef : effects)
|
||||
std::visit(overloaded{[&](MBPUpdate &mbp) {
|
||||
mbp.original_event_id = 0;
|
||||
emit_delayed_event<AlgoNotificationEvent>(
|
||||
me->options.mbp_update_delay_ns(),
|
||||
AlgoNotification{algo_action.transact_time,
|
||||
MDP3TimeStamp{time()},
|
||||
mbp});
|
||||
},
|
||||
[&](OrderUpdate const &order_update) {
|
||||
emit_delayed_event<AlgoNotificationEvent>(
|
||||
me->options.order_update_delay_ns(),
|
||||
AlgoNotification{algo_action.transact_time,
|
||||
MDP3TimeStamp{time()},
|
||||
order_update});
|
||||
}},
|
||||
ef);
|
||||
std::visit(
|
||||
overloaded{[&](MBPUpdate &mbp) {
|
||||
emit_delayed_event<AlgoNotificationEvent>(
|
||||
me->options.mbp_update_delay_ns(),
|
||||
AlgoNotification{me->current_event,
|
||||
algo_action.transact_time,
|
||||
MDP3TimeStamp{time()}, mbp});
|
||||
},
|
||||
[&](OrderUpdate const &order_update) {
|
||||
emit_delayed_event<AlgoNotificationEvent>(
|
||||
me->options.order_update_delay_ns(),
|
||||
AlgoNotification{
|
||||
me->current_event, algo_action.transact_time,
|
||||
MDP3TimeStamp{time()}, order_update});
|
||||
}},
|
||||
ef);
|
||||
}
|
||||
|
||||
} // namespace bts::spartan::mdp3
|
||||
InstrumentDefinition const &GatewayAgent::get_sec(MDP3SecurityID id) const {
|
||||
auto it = me->my_instruments.find(id);
|
||||
bts_assert(it != me->my_instruments.end());
|
||||
return it->second;
|
||||
}
|
||||
|
||||
} // namespace bts::spartan::mdp3
|
||||
@@ -3,6 +3,7 @@
|
||||
#include "../core/AgentBase.h"
|
||||
#include "../events/SimEvents.h"
|
||||
#include "server/sparkd/cmds/spartan/md/mdp3/back_testing/orchestrator/SimSessionOptions.pb.h"
|
||||
#include "server/sparkd/cmds/spartan/md/mdp3/back_testing/simulator/SimLogger.h"
|
||||
|
||||
#include <memory>
|
||||
#include <vector>
|
||||
@@ -14,7 +15,7 @@ class InstrumentDefinition;
|
||||
|
||||
class GatewayAgent : public sim::AgentBase {
|
||||
public:
|
||||
GatewayAgent(
|
||||
GatewayAgent(SimLogger const &logger,
|
||||
std::unordered_map<MDP3SecurityID, InstrumentDefinition> const &,
|
||||
protos::SimRunOptions const &);
|
||||
GatewayAgent(GatewayAgent &&);
|
||||
@@ -27,8 +28,9 @@ class GatewayAgent : public sim::AgentBase {
|
||||
private:
|
||||
void _handle(ExchangeTransactionEvent const &);
|
||||
void _handle(AlgoActionEvent const &);
|
||||
InstrumentDefinition const &get_sec(MDP3SecurityID) const;
|
||||
struct PImpl;
|
||||
std::unique_ptr<PImpl> me;
|
||||
};
|
||||
|
||||
} // namespace bts::spartan::mdp3
|
||||
} // namespace bts::spartan::mdp3
|
||||
@@ -130,6 +130,13 @@ class InstrumentDefinition {
|
||||
});
|
||||
}
|
||||
|
||||
md::IntPrice min_price_increment_int_price() const {
|
||||
return get([](auto m) {
|
||||
return md::IntPrice(m.minPriceIncrement().mantissa(),
|
||||
m.minPriceIncrement().exponent());
|
||||
});
|
||||
}
|
||||
|
||||
double min_price_increment_ammount() const {
|
||||
auto visitor = overloaded{
|
||||
[](::mdp3::MDInstrumentDefinitionFuture54 m) {
|
||||
|
||||
@@ -358,7 +358,9 @@ std::string polygon_descriptor(Polygon const &p,
|
||||
str << ")";
|
||||
str << " ";
|
||||
}
|
||||
return str.str();
|
||||
auto result = str.str();
|
||||
result.resize(result.size()-1);
|
||||
return result;
|
||||
}
|
||||
|
||||
std::string polygon_product(Polygon const &polygon,
|
||||
|
||||
Reference in new issue
Block a user