position flattener

This commit is contained in:
Mohammad Arham committed 2023-09-14 16:25:59 +00:00
1 parent 50ec2f14f7
commit 2e51aebc94
4 files changed
+458 -2

No files matched your search

+4 -1
View File
@@ -66,7 +66,10 @@ message CustomFormatIceSecurities{
message IgnoreNansInDayPnL {
optional bool enabled = 1 [default = true];
}
message SendLimitOrderForPositionFlattener {
optional bool enabled = 1 [default = true];
optional uint32 quantity = 2 [default = 0];
}
message DynamicAlgos{
optional bool enable_dorman = 1 [default = false];
optional bool enable_pyramid = 2 [default = false];
@@ -0,0 +1,400 @@
#include "lib/orderman/orders/algo/algo_orders/PositionFlattenerAlgo.h"
#include "lib/api/services/OrderService.pb.h"
#include "lib/config/config.h"
#include "lib/config/protos/toggles.pb.h"
#include "lib/domain_model/Security.h"
#include "lib/domain_model/Security.pb.h"
#include "lib/domain_model/SecurityKey.h"
#include "lib/domain_model/common.h"
#include "lib/logging/logging.h"
#include "lib/md/IntPrice.h"
#include "lib/md/PriceSize.h"
#include "lib/orderman/actors/SODPosition.h"
#include "lib/orderman/order_factory/IOrderFactory.h"
#include "lib/orderman/orderman_utils/Book.h"
#include "lib/orderman/orderman_utils/orderman_common.h"
#include "lib/orderman/orderman_utils/orderman_utils.h"
#include "lib/orderman/orders/algo/DynamicHelpers.h"
#include "lib/orderman/orders/algo/IAlgoOrder.h"
#include "lib/orderman/orders/algo/IAlgoServices.h"
#include "lib/orderman/orders/algo/algo_orders/MomentumAlgo.h"
#include "lib/os/os.h"
#include "lib/utils/PBUtils.h"
#include "lib/utils/bts_assert.h"
#include "lib/utils/bts_chrono.h"
#include "lib/utils/datetime.h"
#include <algorithm>
#include <bits/stdint-intn.h>
#include <bits/stdint-uintn.h>
#include <boost/circular_buffer.hpp>
#include <boost/none.hpp>
#include <boost/tokenizer.hpp>
#include <c++/7/bits/c++config.h>
#include <cmath>
#include <cstddef>
#include <cstdint>
#include <ctime>
#include <fstream>
#include <functional>
#include <google/protobuf/util/time_util.h>
#include <iostream>
#include <math.h>
#include <memory>
#include <optional>
#include <ostream>
#include <set>
#include <stdint.h>
#include <string>
#include <vector>
namespace bts {
namespace orderman {
using namespace api::orderman;
using namespace google::protobuf;
enum class PositionFlattenerAlgo::AlgoStatus {
PAUSED,
WORKING,
WAITING_FOR_CXL_ACK,
WAITING_FOR_FLATTEN,
CANCELLED
};
enum class PositionFlattenerAlgo::ExitPath { CANCEL, ERR, COMPLETE };
ChildTemplate *_get_Terimnator_child_template(IBeforeLaunchAlgoServices &serv,
const CustomOrderDefinition &cod,
SecurityKey key, api::Side side) {
OrderDefinition rv = serv.definition();
rv.set_security_key(key.value());
rv.set_side(side);
rv.mutable_custom_def()->CopyFrom(cod);
return &(serv.make_child_template(rv));
}
struct PositionFlattenerAlgoLegData {
const SecurityKey sec_key;
ChildTemplate *order_template = nullptr;
OrderKey order_key;
ChildState order_state;
ChildStatus status;
PositionFlattenerAlgoLegData(SecurityKey sec_key_a,
ChildTemplate *order_template_a)
: sec_key(sec_key_a), order_template(order_template_a),
order_key(null_order_key()), order_state(), status() {}
};
struct PositionFlattenerAlgoParams {
SecurityKey security_key_id;
std::string security_name_str;
std::vector<PositionFlattenerAlgoLegData> legs;
bool dont_flatten;
PositionFlattenerAlgoParams(SecurityKey key, std::string sec_name,
std::vector<PositionFlattenerAlgoLegData> lgs,
bool dont_flatten)
: security_key_id(key), security_name_str(sec_name), legs(lgs),
dont_flatten(dont_flatten) {}
};
struct PositionFlattenerAlgo::PImpl {
IAlgoServices *algo;
std::vector<PositionFlattenerAlgoLegData> legs;
AlgoStatus status = AlgoStatus::PAUSED;
std::unique_ptr<PositionFlattenerAlgoParams> algo_params;
OrderKey flatten_child_key = null_order_key();
AccountID acc_id;
int order_distance = 0;
// std::unordered_set<OrderKey> flatten_child_keys_sim;
ChildTemplate *flatten_template_buy = nullptr;
ChildTemplate *flatten_template_sell = nullptr;
double pos = 0;
bool is_sim;
};
bool _convert_params(IBeforeLaunchAlgoServices &serv,
const CustomOrderDefinition &cod,
std::unique_ptr<PositionFlattenerAlgoParams> &out_p) {
LOG(OrderMan, Diag, "PositionFlattenerAlgo::_convert_params");
const DynamicOrderDefinition &def = cod.dynamic();
const auto &params = def.order_params();
std::vector<PositionFlattenerAlgoLegData> prs;
auto sec_key = SecurityKey(serv.security().id());
size_t n_child_ords = 5;
for (size_t i = 0; i < n_child_ords; i++) {
auto idx = std::to_string(i + 1);
auto order = get_if<CustomOrderDefinition>(params, "Order " + idx);
if (!order.has_value()) {
continue;
}
ChildTemplate *child_template = _get_Terimnator_child_template(
serv, order.value(), sec_key, api::Side::SIDE_BUY);
prs.push_back(PositionFlattenerAlgoLegData(sec_key, child_template));
}
auto flatten = get_if<bool>(params, "Dont Flatten");
if (!flatten.has_value()) {
return false;
}
out_p = std::make_unique<PositionFlattenerAlgoParams>(
PositionFlattenerAlgoParams(sec_key,
serv.security().glbx().security_desc(), prs,
flatten.value()));
return true;
}
PositionFlattenerAlgo::PositionFlattenerAlgo() : me(new PImpl()) {}
PositionFlattenerAlgo::~PositionFlattenerAlgo() {}
IAlgoServices &PositionFlattenerAlgo::algo() const { return *me->algo; }
ChildTemplate *_get_limit_template(IBeforeLaunchAlgoServices &serv,
SecurityKey key, api::Side side) {
OrderDefinition rv = serv.definition();
rv.set_security_key(key.value());
rv.set_side(side);
rv.mutable_custom_def()->mutable_limit()->MergeFrom(
api::orderman::LimitOrderDefinition());
return &(serv.make_child_template(rv));
}
ChildTemplate *_get_market_template(IBeforeLaunchAlgoServices &serv,
SecurityKey key, api::Side side) {
OrderDefinition rv = serv.definition();
rv.set_security_key(key.value());
rv.set_side(side);
rv.mutable_custom_def()->mutable_market()->MergeFrom(
api::orderman::MarketOrderDefinition());
return &(serv.make_child_template(rv));
}
OrderOpResult
PositionFlattenerAlgo::do_before_launch(IBeforeLaunchAlgoServices &serv) {
LOG(OrderMan, Diag, "PositionFlattenerAlgo::do_before_launch");
OrderDefinition def = serv.definition();
if (def.has_custom_def() && def.custom_def().has_dynamic() &&
_convert_params(serv, def.custom_def(), me->algo_params)) {
me->acc_id = AccountID(def.account_id());
me->is_sim =
config::get<config::toggles::SendLimitOrderForPositionFlattener>()
.enabled();
me->order_distance =
config::get<config::toggles::SendLimitOrderForPositionFlattener>()
.quantity();
me->legs =
std::vector<PositionFlattenerAlgoLegData>(me->algo_params->legs);
me->flatten_template_buy =
me->is_sim
? _get_limit_template(serv, SecurityKey(serv.security().id()),
api::Side::SIDE_BUY)
: _get_market_template(serv, SecurityKey(serv.security().id()),
api::Side::SIDE_BUY);
me->flatten_template_sell =
me->is_sim
? _get_limit_template(serv, SecurityKey(serv.security().id()),
api::Side::SIDE_SELL)
: _get_market_template(serv, SecurityKey(serv.security().id()),
api::Side::SIDE_SELL);
return {};
}
return {OrderError::ORDER_ERROR_INVALID_PARAMETER,
std::string("Parameters are not well formed")};
}
void PositionFlattenerAlgo::on_position(PositionUpdate const &pos) {
if (pos.security->id() != me->algo->security().id() ||
pos.account_id != me->acc_id) {
return; //|| pos.account_id != me->algo-> add this
}
me->pos =
double(pos.long_quantity.value()) - double(pos.short_quantity.value());
LOG(OrderMan, Diag,
"PositionFlattenerAlgo::on_cancel state {}, pos: {}, long: {}, short: "
"{}",
me->status, me->pos, pos.long_quantity.value(),
pos.short_quantity.value());
}
void PositionFlattenerAlgo::do_launch(IAlgoServices &algo) {
LOG(OrderMan, Diag, "PositionFlattenerAlgo::do_launch");
me->algo = &algo;
me->status = PositionFlattenerAlgo::AlgoStatus::WORKING;
// LUANCH CHILD ORDERS
me->algo->subscribe_position();
for (size_t i = 0; i < me->legs.size(); i++) {
me->legs[i].order_key = me->algo->launch_child(
*me->legs[i].order_template, me->algo->price(), bts::Quantity(1));
}
}
void PositionFlattenerAlgo::do_launch_attached(IAlgoServices &algo, OrderKey,
ChildState) {
me->algo = &algo;
_cxl_and_end(true,
"PositionFlattener Algo can not be attached to working orders");
}
void PositionFlattenerAlgo::do_update(api::orderman::Update const &update) {
if (!update.has_custom() || !update.custom().has_dynamic()) {
return;
}
const DynamicOrderDefinition &def = update.custom().dynamic();
const auto &params = def.order_params();
auto dont_flatten = get_if<bool>(params, "Dont Flatten");
if (!dont_flatten.has_value()) {
return;
}
me->algo_params->dont_flatten = dont_flatten.value();
LOG(OrderMan, Diag,
"PositionFlattenerAlgo order {} receiving update: {} UPDATES NOT "
"ALLOWED",
algo().order_key().value(), utils::pb::to_string(update));
}
std::optional<size_t>
find_leg_index(std::vector<PositionFlattenerAlgoLegData> legs, OrderKey k) {
for (size_t index = 0; index < legs.size(); index++) {
if (legs[index].order_key == k) {
return index;
}
}
return std::nullopt;
}
void PositionFlattenerAlgo::on_child_change(OrderKey k,
ChildState const &state) {
if (me->flatten_child_key == k) {
// bts_assert(state.status != ChildStatus::CANCELED);
if (state.status == ChildStatus::COMPLETED) {
me->status = PositionFlattenerAlgo::AlgoStatus::PAUSED;
_cxl_and_end(false, "POSITION FLATTENED");
return;
}
}
auto maybe_leg_index = find_leg_index(me->legs, k);
if (!maybe_leg_index.has_value()) {
return;
}
auto leg_index = maybe_leg_index.value();
me->legs[leg_index].status = state.status;
switch (me->status) {
case PositionFlattenerAlgo::AlgoStatus::WORKING:
case PositionFlattenerAlgo::AlgoStatus::WAITING_FOR_FLATTEN:
break;
case PositionFlattenerAlgo::AlgoStatus::WAITING_FOR_CXL_ACK:
if (state.status != ChildStatus::WORKING) {
_cxl_and_end(false, "");
}
break;
case PositionFlattenerAlgo::AlgoStatus::CANCELLED:
case PositionFlattenerAlgo::AlgoStatus::PAUSED:
bts_assert(false);
};
}
Price get_price(double algo_price, api::Side side, bool is_sim, int quantity,
double tick_val) {
if (!is_sim) {
return Price(algo_price);
}
if (side == api::Side::SIDE_BUY) {
return Price(algo_price + tick_val * std::abs(quantity));
}
return Price(algo_price - tick_val * std::abs(quantity));
}
void PositionFlattenerAlgo::_fire_orders(size_t count, api::Side side) {
bts_assert(me->status ==
PositionFlattenerAlgo::AlgoStatus::WAITING_FOR_FLATTEN);
LOG(OrderMan, Diag, "PositionFlattenerAlgo::_fire_orders count: {} side: {}",
count, side);
ChildTemplate &ct = side == api::Side::SIDE_BUY ? *me->flatten_template_buy
: *me->flatten_template_sell;
double tick_size = me->algo->security().contract_spec().low_tick();
auto price = get_price(me->algo->price().value(), side, me->is_sim,
me->order_distance, tick_size);
me->flatten_child_key =
me->algo->launch_child(ct, price, bts::Quantity(count));
return;
}
// this only gets called on am explicit algo cancel
// from the outside
IAlgoOrder::OnCancelResponse PositionFlattenerAlgo::on_cancel() {
LOG(OrderMan, Diag,
"PositionFlattenerAlgo::"
"on_cancel state {}",
me->status);
// cancel top spread, let
// hedges work, cancel algo
switch (me->status) {
case PositionFlattenerAlgo::AlgoStatus::WORKING:
_cxl_and_end(false, "Algo cancelled");
break;
case PositionFlattenerAlgo::AlgoStatus::WAITING_FOR_FLATTEN:
case PositionFlattenerAlgo::AlgoStatus::WAITING_FOR_CXL_ACK:
case PositionFlattenerAlgo::AlgoStatus::CANCELLED:
case PositionFlattenerAlgo::AlgoStatus::PAUSED:
break;
};
return IAlgoOrder::OnCancelResponse::IGNORE;
}
void PositionFlattenerAlgo::_cxl_leg(bool is_error,
const std::string &err_msg) {
LOG(OrderMan, Diag,
"PositionFlattenerAlgo::_"
"cxl_leg legs {}",
me->legs.size());
if (me->legs.size()) {
switch (me->legs.back().status) {
case ChildStatus::CANCELED:
case ChildStatus::COMPLETED:
me->legs.pop_back();
_cxl_and_end(is_error, err_msg);
break;
case ChildStatus::WORKING:
me->algo->cancel_child(me->legs.back().order_key);
};
}
}
void PositionFlattenerAlgo::_flatten_pos() {
LOG(OrderMan, Diag,
"PositionFlattenerAlgo::_"
"flatten_pos state {}",
me->status);
bts_assert(me->status ==
PositionFlattenerAlgo::AlgoStatus::WAITING_FOR_FLATTEN);
if (me->algo_params->dont_flatten || me->pos == 0) {
me->status = PositionFlattenerAlgo::AlgoStatus::PAUSED;
return;
}
if (me->pos < 0) {
_fire_orders(abs(me->pos), api::Side::SIDE_BUY);
return;
}
if (me->pos > 0) {
_fire_orders(abs(me->pos), api::Side::SIDE_SELL);
return;
}
}
void PositionFlattenerAlgo::_cxl_and_end(bool is_error,
const std::string &err_msg) {
LOG(OrderMan, Diag,
"PositionFlattenerAlgo::_"
"cxl_and_end state {} "
"legs size {}",
me->status, me->legs.size());
if (is_error) {
me->algo->cancel();
}
switch (me->status) {
case PositionFlattenerAlgo::AlgoStatus::WORKING:
me->status = AlgoStatus::WAITING_FOR_CXL_ACK;
_cxl_and_end(is_error, err_msg);
break;
case PositionFlattenerAlgo::AlgoStatus::WAITING_FOR_CXL_ACK:
if (me->legs.size()) {
_cxl_leg(is_error, err_msg);
break;
} else {
me->status = AlgoStatus::WAITING_FOR_FLATTEN;
_flatten_pos();
_cxl_and_end(is_error, err_msg);
break;
}
case PositionFlattenerAlgo::AlgoStatus::WAITING_FOR_FLATTEN:
break;
case PositionFlattenerAlgo::AlgoStatus::CANCELLED:
case PositionFlattenerAlgo::AlgoStatus::PAUSED:
me->algo->cancel();
};
}
} // namespace orderman
} // namespace bts
@@ -0,0 +1,39 @@
#pragma once
#include "lib/orderman/orders/algo/IAlgoOrder.h"
namespace bts {
namespace orderman {
// PositionFlattener runs set child algos and flattens state
class PositionFlattenerAlgo : public IAlgoOrder {
public:
PositionFlattenerAlgo();
~PositionFlattenerAlgo();
OrderOpResult do_before_launch(IBeforeLaunchAlgoServices &) override;
void do_launch(IAlgoServices &) override;
void do_launch_attached(IAlgoServices &, OrderKey, ChildState) override;
void do_update(api::orderman::Update const &) override;
void on_child_change(OrderKey, ChildState const &) override;
void on_position(PositionUpdate const &) override;
enum class AlgoStatus;
private:
enum class ExitPath;
struct PImpl;
std::unique_ptr<PImpl> me;
IAlgoServices &algo() const;
IAlgoOrder::OnCancelResponse on_cancel() override;
void _cxl_leg(bool is_error, const std::string &err_msg);
void init_child_template(IBeforeLaunchAlgoServices &,
api::orderman::CustomOrderDefinition const &);
void _cxl_and_end(bool is_error, const std::string &err_msg);
void _fire_orders(size_t count, api::Side side);
void _flatten_pos();
};
} // namespace orderman
} // namespace bts
@@ -4,6 +4,7 @@
#include "MomentumAlgo.h"
#include "MomentumRecorder.h"
#include "OnSignalAlgo.h"
#include "PositionFlattenerAlgo.h"
#include "PyramidAlgo.h"
#include "TASAlgo.h"
#include "TASCounterAlgo.h"
@@ -230,7 +231,19 @@ extern "C" void init_limit_cover(bts::SparkServices &srv) {
srv.register_dynamic_algo_order(
lc_desc, []() { return std::make_unique<orderman::LimitCoverAlgo>(); });
}
extern "C" void init_position_flattener(bts::SparkServices &srv) {
DynamicOrderDescriptor term;
term.set_dynamic_order_type("PositionFlattener");
size_t n_child_ords = 5;
*term.add_param_desc() = param_bool("Dont Flatten");
for (size_t i = 0; i < n_child_ords; i++) {
auto idx = std::to_string(i + 1);
*term.add_param_desc() = param_order("Order " + idx);
}
srv.register_dynamic_algo_order(term, []() {
return std::make_unique<orderman::PositionFlattenerAlgo>();
});
}
extern "C" void init_on_signal_plugin(bts::SparkServices &srv) {
DynamicOrderDescriptor on_signal;
on_signal.set_dynamic_order_type("OnSignal");
@@ -325,6 +338,7 @@ extern "C" void init_spark_plugin(bts::SparkServices &srv) {
init_on_signal_plugin(srv);
init_momentum_algo_plugin(srv);
init_momentum_recorder_plugin(srv);
init_position_flattener(srv);
init_file_runner_plugin(srv);
}