Wiring complete

This commit is contained in:
Pedro Pinto committed 2019-11-15 09:03:51 -05:00
1 parent 404104e12b
commit 91020c2ccc
12 files changed
+172 -116

No files matched your search

+7 -7
View File
@@ -15,17 +15,17 @@ public:
void do_work();
//Inputs
void on_om_bootstrap_orders(const OM_BootStrapOrder&);
void on_gw_ops (const GW_Op &);
void on_account_pnl (const AccountPnLUpdate &);
void on_excess_liquidity (const ExcessLiquidityUpdate &);
void on_admin_data(const AdminDataUpdate &);
void on_position(const PositionUpdate &);
void on_om_bootstrap_orders(OM_BootStrapOrder const&) {};
void on_gw_ops (const GW_Op &) {};
void on_account_pnl (const AccountPnLUpdate &) {}
void on_excess_liquidity (const ExcessLiquidityUpdate &) {}
void on_admin_data(const AdminDataUpdate &) {}
void on_position(const PositionUpdate &) {}
// Signals
Signal<GW_OrderUpdate> on_native_order_update;
Signal<GW_UnknownNativeOrderUpdate> on_unknown_native_order_update;
Signal<GWError> on_gw_error;
Signal<GW_Error> on_gw_error;
};
}}
+2 -1
View File
@@ -10,12 +10,13 @@ namespace md {class MDConsumer;}
namespace orderman_v2 {
class MDSource : public Actor {
public:
MDSource(md::MDConsumer &consumer) ;
// Inputs
void on_md_request(MDRequest const&);
void on_md_request(MDRequest const&) {};
// Signals
Signal<BookUpdate> on_book;
+1 -2
View File
@@ -13,7 +13,7 @@ public:
OrderManager();
// Inputs
void on_bootstrap_orders(std::vector<api::orderman::OrderRecord> const*) {}
void on_bootstrap_orders(BootstrapOrders) {}
void on_native_order_update (GW_OrderUpdate const&) {}
void on_unknown_native_order_update(GW_UnknownNativeOrderUpdate const&) {}
void on_create_order (CreateOrderRequest const&) {}
@@ -24,7 +24,6 @@ public:
void on_ticker(TickerUpdate const&) {}
void on_sec_status(SecurityStatusUpdate const&) {}
void on_admin_data(const AdminDataUpdate &) {}
void on_gw_error(const GWError &) {}
// Signals
Signal<GW_Op> on_gw_op;
+4 -4
View File
@@ -13,12 +13,12 @@ public:
ServiceBridge();
// Inputs
void on_bootstrap_orders(std::vector<api::orderman::OrderRecord> const*) {}
void on_bootstrap_fills(std::vector<api::orderman::Fill> const*) {}
void on_bootstrap_orders(BootstrapOrders) {}
void on_bootstrap_fills(BootstrapFills) {}
void on_new_stored_order(api::orderman::OrderRecord const*) {}
void on_new_stored_fill(api::orderman::Fill const*) {}
void on_gw_status(GWStatus const&) {}
void on_gw_error(GWError const&) {}
void on_gw_status(GW_Status const&) {}
void on_gw_error(GW_Error const&) {}
void on_om_reply(OM_Reply const&) {}
// Signals
+3 -3
View File
@@ -13,11 +13,11 @@ public:
Storage();
// Inputs
void on_order_update (OM_OrderUpdate const&);
void on_order_update (OM_OrderUpdate const&) {}
// Signals
Signal<std::vector<api::orderman::OrderRecord>const*> on_bootstrap_orders;
Signal<std::vector<api::orderman::Fill>const*> on_bootstrap_fills;
Signal<BootstrapOrders> on_bootstrap_orders;
Signal<BootstrapFills> on_bootstrap_fills;
Signal<api::orderman::OrderRecord const*> on_new_stored_order;
Signal<api::orderman::Fill const*> on_new_stored_fill;
};
+54 -43
View File
@@ -1,16 +1,20 @@
#pragma once
#include "lib/orderman_v2/common.h"
#include "lib/utils/TimeStamp.h"
#include <boost/container/pmr/small_vector.hpp>
#include <variant>
#include <boost/container/small_vector.hpp>
#include "lib/orderman_v2/interconnect/Action.h"
namespace bts {
namespace orderman_v2 {
template <class EV>
constexpr bool meets_event_constraints () {
return std::is_trivial<EV>::value && sizeof(EV) <= MaxEventSize;
}
enum class MDRequestType { BOOK, TICKER, STATUS, SETTLEMENT };
struct BookUpdate {
Book book;
Book *book;
};
// 168 bytes on 10/11/2019
@@ -18,26 +22,29 @@ struct MDRequest {
SecurityKey key;
MDRequestType request_type;
};
static_assert(std::is_trivial<MDRequest>::value);
static_assert(meets_event_constraints<MDRequest>());
struct TickerUpdate {
SecurityKey key;
struct Trade {
utils::TimeStamp ts;
Price price;
Quantity quantity;
Quantity total_volume;
co2::AggressorSide aggressor_side;
struct TickerUpdatePayload {
SecurityKey key;
struct Trade {
utils::TimeStamp ts;
Price price;
Quantity quantity;
Quantity total_volume;
co2::AggressorSide aggressor_side;
};
boost::container::small_vector<TickerUpdatePayload::Trade, 5> trades;
};
boost::container::small_vector<TickerUpdate::Trade, 5> trades;
TickerUpdatePayload *value;
};
static_assert(std::is_trivial<MDRequest>::value);
static_assert(meets_event_constraints<TickerUpdate>());
struct SecurityStatusUpdate {
SecurityKey key;
co2::TradingStatus status;
};
static_assert(std::is_trivial<SecurityStatusUpdate>::value);
static_assert(meets_event_constraints<SecurityStatusUpdate>());
struct PositionUpdate {
SecurityKey key;
@@ -45,7 +52,7 @@ struct PositionUpdate {
Quantity long_quantity;
Quantity short_quantity;
};
static_assert(std::is_trivial<PositionUpdate>::value);
static_assert(meets_event_constraints<PositionUpdate>());
class IExecReport;
class OM_NativeOrderRecord;
@@ -60,23 +67,21 @@ struct CommonOrderState {
Price last_price;
OrderStatus status;
};
static_assert(std::is_trivial<CommonOrderState>::value);
struct GW_OrderUpdate {
CommonOrderState common;
IExecReport const *last_report;
OM_NativeOrderRecord const *om_record;
OM_Id originator;
OM_Id target;
};
static_assert(std::is_trivial<GW_OrderUpdate>::value);
static_assert(meets_event_constraints<GW_OrderUpdate>());
struct GW_UnknownNativeOrderUpdate {
CommonOrderState common;
GW_Id source_gw;
IExecReport const *last_report;
};
static_assert(std::is_trivial<GW_OrderUpdate>::value);
static_assert(meets_event_constraints<GW_UnknownNativeOrderUpdate>());
struct OM_OrderUpdate {
CommonOrderState common;
@@ -85,8 +90,7 @@ struct OM_OrderUpdate {
api::orderman::OrderDefinition const *def;
const char *last_msg;
};
static_assert(std::is_trivial<OM_OrderUpdate>::value);
static_assert(sizeof(OM_OrderUpdate)<=128);
static_assert(meets_event_constraints<OM_OrderUpdate>());
struct CreateOrderRequest {
OM_Id target;
@@ -95,7 +99,7 @@ struct CreateOrderRequest {
Quantity quantity;
api::orderman::OrderDefinition const *def;
};
static_assert(std::is_trivial<CreateOrderRequest>::value);
static_assert(meets_event_constraints<CreateOrderRequest>());
struct UpdateOrderRequest {
OM_Id target;
@@ -105,22 +109,23 @@ struct UpdateOrderRequest {
Quantity quantity;
api::orderman::OrderDefinition const *def;
};
static_assert(std::is_trivial<UpdateOrderRequest>::value);
static_assert(meets_event_constraints<UpdateOrderRequest>());
struct CancelOrderRequest {
OM_Id target;
RequestID request_id;
OrderKey key;
};
static_assert(std::is_trivial<CancelOrderRequest>::value);
static_assert(meets_event_constraints<CancelOrderRequest>());
struct DetachOrderRequest {
OM_Id target;
RequestID request_id;
OrderKey key;
};
static_assert(std::is_trivial<DetachOrderRequest>::value);
static_assert(meets_event_constraints<DetachOrderRequest>());
// GW Order Ops
struct NewOrder {
OrderKey order_key;
UserID user_id;
@@ -131,9 +136,8 @@ struct NewOrder {
Side side;
ManualOrderIndicator moi;
TimeInForce tif;
OM_NativeOrderRecord const* om_record;
OM_NativeOrderRecord const *om_record;
};
static_assert(std::is_trivial<NewOrder>::value);
struct BoundOrder {
NewOrder bound_order;
@@ -142,7 +146,7 @@ struct BoundOrder {
struct OM_BootStrapOrder {
OM_Id originator;
GW_Id target;
std::vector<BoundOrder> bootstrap;
std::vector<BoundOrder> *bootstrap;
};
struct CancelReplace {
@@ -151,12 +155,11 @@ struct CancelReplace {
Quantity quantity;
api::orderman::CustomOrderDefinition const *custom_update;
};
static_assert(std::is_trivial<CancelReplace>::value);
struct Cancel {
OrderKey order_key;
};
static_assert(std::is_trivial<Cancel>::value);
// Order Ops
struct GW_Op {
OM_Id originator;
@@ -169,49 +172,57 @@ struct GW_Op {
Cancel cancel;
BoundOrder bind_order;
};
enum : uint8_t { NEW_ORDER, CANCEL_REPLACE, CANCEL, BIND_ORDER,NO_OP };
enum : uint8_t { NEW_ORDER, CANCEL_REPLACE, CANCEL, BIND_ORDER, NO_OP };
};
static_assert(std::is_trivial<GW_Op>::value);
static_assert(sizeof(GW_Op)<=64);
static_assert(meets_event_constraints<GW_Op>());
struct GWStatus {
struct GW_Status {
GW_Id gw;
bool connected;
};
static_assert(std::is_trivial<GWStatus>::value);
static_assert(meets_event_constraints<GW_Status>());
struct GWError {
struct GW_Error {
GW_Id gw;
enum uint8_t { CANCEL_REJECT, BUSSINESS_REJECT, SESSION_REJECT } error;
const char *error_msg;
OrderKey cancel_reject_order_key;
};
static_assert(std::is_trivial<GWError>::value);
static_assert(meets_event_constraints<GW_Error>());
struct OM_Reply {
RequestID req_id;
const char *error_msg;
bool success;
};
static_assert(std::is_trivial<OM_Reply>::value);
static_assert(meets_event_constraints<OM_Reply>());
struct AccountPnLUpdate {
AccountID account_id;
double day_pnl;
};
static_assert(std::is_trivial<AccountPnLUpdate>::value);
static_assert(meets_event_constraints<AccountPnLUpdate>());
struct ExcessLiquidityUpdate {
AccountID account_id;
double excess_liquidity;
};
static_assert(std::is_trivial<ExcessLiquidityUpdate>::value);
static_assert(meets_event_constraints<ExcessLiquidityUpdate>());
struct AdminDataUpdate {
api::admin::AdminData const *admin_data;
};
static_assert(std::is_trivial<AdminDataUpdate>::value);
static_assert(meets_event_constraints<AdminDataUpdate>());
struct BootstrapOrders {
std::vector<api::orderman::OrderRecord> const *orders;
};
static_assert(meets_event_constraints<BootstrapOrders>());
struct BootstrapFills {
std::vector<api::orderman::Fill> const *fills;
};
static_assert(meets_event_constraints<BootstrapFills>());
} // namespace orderman_v2
} // namespace bts
+4 -7
View File
@@ -6,7 +6,9 @@ namespace bts {
namespace orderman_v2 {
using Stub = void (*)(void *, void const *);
using ActionArgument = std::array<uint8_t, 64 - 2 * sizeof(void *)>;
auto const MaxEventSize = 128 - 2*sizeof(void*);
using ActionArgument = std::array<uint8_t, MaxEventSize>;
struct Slot;
struct Action {
@@ -23,11 +25,6 @@ struct Action {
new (argument.data()) A(arg);
}
template <class A>
Action(Stub stub, Slot *src_slot, A const *arg)
: stub(stub), src_slot(src_slot) {
*((A const**) (argument.data())) = arg;
}
void operator()(void) { stub(src_slot, argument.data()); }
Stub stub;
@@ -35,7 +32,7 @@ struct Action {
ActionArgument argument;
};
static_assert(sizeof(Action) == 64);
static_assert(sizeof(Action) == 128);
static_assert(std::is_trivial<Action>::value);
} // namespace orderman_v2
@@ -27,7 +27,7 @@ struct Orchestrator::PImpl {
std::vector<Gateway *> gateways;
template <auto method> auto collect_om_fwds() {
using Arg = typename decltype(deduce_invoker(method))::FullArg;
using Arg = typename decltype(deduce_invoker(method))::Arg;
std::vector<Forwarder<Arg>> result;
for (auto p : order_managers)
result.push_back(fwd<method>(p.second));
@@ -35,7 +35,7 @@ struct Orchestrator::PImpl {
}
template <auto method> auto collect_gw_fwds() {
using Arg = typename decltype(deduce_invoker(method))::FullArg;
using Arg = typename decltype(deduce_invoker(method))::Arg;
std::vector<Forwarder<Arg>> result;
for (auto gw : gateways)
result.push_back(fwd<method>(gw));
@@ -102,6 +102,8 @@ void Orchestrator::create_actors(config::OrderManThreadingCfg const &cfg) {
void Orchestrator::wire_actors() {
wire_storage();
wire_service_bridge();
wire_order_managers();
wire_gateways();
}
void Orchestrator::wire_storage() {
@@ -148,10 +150,66 @@ void Orchestrator::wire_service_bridge() {
// AdminDataUpdate
auto admin_fwds = me->collect_om_fwds<&OrderManager::on_admin_data>();
auto gw_admin_fwds = me->collect_gw_fwds<&Gateway::on_admin_data>();
admin_fwds.insert(admin_fwds.end(),gw_admin_fwds.begin(), gw_admin_fwds.end());
auto gw_admin_fwds = me->collect_gw_fwds<&Gateway::on_admin_data>();
admin_fwds.insert(admin_fwds.end(), gw_admin_fwds.begin(),
gw_admin_fwds.end());
sb->on_admin_data.broadcast_to(admin_fwds);
// ExcessLiquidityUpdate
sb->on_excess_liquidity.broadcast_to(
me->collect_gw_fwds<&Gateway::on_excess_liquidity>());
// AccountPnLUpdate
sb->on_account_pnl.broadcast_to(
me->collect_gw_fwds<&Gateway::on_account_pnl>());
// PositionUpdate
sb->on_position.broadcast_to(me->collect_gw_fwds<&Gateway::on_position>());
}
void Orchestrator::wire_order_managers() {
for (auto [md, om] : me->order_managers) {
// md req/reply
md->on_book.forward_to<&OrderManager::on_book>(om);
md->on_ticker.forward_to<&OrderManager::on_ticker>(om);
md->on_sec_status.forward_to<&OrderManager::on_sec_status>(om);
om->on_md_request.forward_to<&MDSource::on_md_request>(md);
// GW_op
om->on_gw_op.route_to([](const auto &op) { return op.target.value; },
me->collect_gw_fwds<&Gateway::on_gw_ops>());
// OM_OrderUpdate
om->on_order_update.forward_to<&Storage::on_order_update>(me->storage);
// OM_Reply
om->on_om_reply.forward_to<&ServiceBridge::on_om_reply>(
me->service_bridge);
// OM_BootStrapOrder
om->on_om_bootstrap_orders.route_to(
[](const auto &o) { return o.target.value; },
me->collect_gw_fwds<&Gateway::on_om_bootstrap_orders>());
}
}
void Orchestrator::wire_gateways() {
for (auto gw : me->gateways) {
// GW_OrderUpdate
gw->on_native_order_update.route_to(
[](auto const &o) { return o.target.value; },
me->collect_om_fwds<&OrderManager::on_native_order_update>());
// Route unknown native order updates to the first order manager
// only
gw->on_unknown_native_order_update
.forward_to<&OrderManager::on_unknown_native_order_update>(
me->order_managers[0].second);
// Route errors to the service bridge for display in the
// UI. Invidual order manager will get order specific updates
// when a gateway disconnects
gw->on_gw_error.forward_to<&ServiceBridge::on_gw_error>(
me->service_bridge);
}
}
Thread *Orchestrator::get_thread(std::string const &name, bool poll,
@@ -30,6 +30,8 @@ class Orchestrator {
void wire_actors();
void wire_storage();
void wire_service_bridge();
void wire_order_managers();
void wire_gateways();
Thread *get_thread(std::string const &name, bool poll,
uint32_t slow_worker_period);
};
+21 -16
View File
@@ -11,11 +11,10 @@ template <class A> struct Forwarder {
Stub qstub;
};
template <auto method, class Target>
Forwarder<typename decltype(deduce_invoker(method))::FullArg> fwd(Target *t) {
template <auto method, class Target> auto fwd(Target *t) {
static_assert(is_member_of<method, Target>());
static_assert(std::is_base_of<Actor, Target>::value);
using Arg = typename decltype(deduce_invoker(method))::FullArg;
using Arg = typename decltype(deduce_invoker(method))::Arg;
Forwarder<Arg> result;
result.target = t;
@@ -28,26 +27,32 @@ template <class A> class Signal : Slot {
public:
Signal(Actor *owner) : owner(owner) {}
template <auto method, class Target>
void forward_to(Target*t) {
template <auto method, class Target> void forward_to(Target *t) {
assign(make_slot(fwd<method>(t)));
}
void broadcast_to(std::vector<Forwarder<A>> const&fwds) {
stub = &broadcasting_stub<A>;
load_slots(fwds);
void broadcast_to(std::vector<Forwarder<A>> const &fwds) {
bts_assert(fwds.size());
if (fwds.size() > 1) {
stub = &broadcasting_stub<A>;
load_slots(fwds);
} else
assign(make_slot(fwds[0]));
}
template <class Callable>
void route_to(Callable r,
std::vector<Forwarder<A>> const &routes)
{
stub = &routing_stub<A>;
route = r;
load_slots(routes);
void route_to(Callable r, std::vector<Forwarder<A>> const &routes) {
bts_assert(routes.size());
if (routes.size() > 1) {
stub = &routing_stub<A>;
route = r;
load_slots(routes);
} else
assign(make_slot(routes[0]));
}
void operator()(const A &arg) { stub(this, &arg); }
private:
@@ -27,36 +27,24 @@ struct Slot {
template <class C, class A, bool PtrToA> struct Invoker {
using Class = C;
using Arg = A;
static const bool PtrToArg = PtrToA;
using FullArg = std::conditional_t<PtrToA,A const*,A>;
static void invoke(void *o, void const *a, void (C::*m)(const A &)) {
auto obj = (Class *)o;
auto arg = (Arg *)a;
(obj->*m)(*arg);
}
static void invoke(void *o, void const *a, void (C::*m)(A)) {
auto obj = (Class *)o;
auto arg = (Arg *)a;
(obj->*m)(*arg);
}
static void invoke(void *o, void const *a, void (C::*m)(const A *)) {
auto obj = (Class *)o;
auto arg = (Arg **)a;
(obj->*m)(*arg);
}
};
template <class C, class A>
Invoker<C, A, false> deduce_invoker(void (C::*)(A));
template <class C, class A>
Invoker<C, A, false> deduce_invoker(void (C::*)(A const &));
template <class C, class A>
Invoker<C, A, true> deduce_invoker(void (C::*)(A const *));
Invoker<C, A, false> deduce_invoker(void (C::*)(A));
template<auto method, class C>
constexpr bool is_member_of() {
@@ -90,13 +78,8 @@ template <auto method> void queuing_stub(void *s, void const *a) {
auto slot = (Slot *)s;
auto queue = slot->queue;
using Inv = decltype(deduce_invoker(method));
if constexpr (Inv::PtrToArg) {
auto arg = (typename Inv::Arg **)a;
queue->push({&direct_stub<method>, slot, *arg});
} else {
auto arg = (typename Inv::Arg *)a;
queue->push({&direct_stub<method>, slot, *arg});
}
auto arg = (typename Inv::Arg *)a;
queue->push({&direct_stub<method>, slot, *arg});
}
template <class Arg> class Signal;
+8 -8
View File
@@ -164,16 +164,16 @@ void raw_queue() {
struct C1 : Actor {
C1() : on_ping(this) {}
Signal<int const*> on_ping;
Signal<int> on_ping;
int x = 0;
void init() override { on_ping(&x); }
void init() override { on_ping(x); }
void pong(int const *y) {
if (*y == 0)
void pong(int y) {
if (y == 0)
start = utils::TimeStamp::now();
x++;
if (*y == deltas.size())
y++;
if (y == deltas.size())
std::cout << (utils::TimeStamp::now() - start).nanoseconds() /
deltas.size()
<< "\n";
@@ -186,8 +186,8 @@ struct C1 : Actor {
struct C2 : Actor {
C2() : on_pong(this) {}
Signal<int const*> on_pong;
void ping(int const *y) { on_pong(y); }
Signal<int> on_pong;
void ping(int y) { on_pong(y); }
};
void inter_executor(int seconds) {