Files
spark/src/server/sparkd/position/PositionServicePNLHelper.cpp
T
2020-06-05 10:01:18 -04:00

271 lines
8.8 KiB
C++

#include "lib/api/services/OrderService.client.pb.h"
#include "lib/logging/logging.h"
#include "lib/md/MDClient.h"
#include "lib/os/os.h"
#include "PositionServicePNLHelper.h"
#include "lib/config/protos/cme_reference_data.pb.h"
#include "lib/config/protos/toggles.pb.h"
#include "lib/config/config.h"
#include "lib/utils/PBUtils.h"
#include "lib/utils/LockBox.h"
#include <vector>
#include <unordered_map>
#include <boost/algorithm/string.hpp>
#include <boost/tokenizer.hpp>
#include <map>
#include <set>
#include <utility>
namespace bts {
namespace position{
using namespace bts::api::position;
using namespace bts::api::orderman;
using namespace bts::md;
class HandleIndex {
public:
enum PNLType{
UNRESOLVED = 0,
SPREAD,
OUTRIGHT
};
bts::md::MDClient& _client;
int _sub;
std::optional<bts::md::MDConsumer> _consumer;
public:
utils::LockBox<std::unordered_map<SecurityKey,MDConsumerHandle>> index;
HandleIndex(md::MDClient& client):
_client(client),
_sub(0),
_consumer(std::nullopt),
index() {
_sub = _client.on_consumer().subscribe([=](const MDConsumer& c) { on_consumer(c); });
on_consumer(_client.current_consumer());
}
~HandleIndex() { _client.on_consumer().unsubscribe(_sub); }
MDConsumerHandle _get_handle(SecurityKey key) const{
auto handle = index.lock([id=key](const auto& index) {
auto iter = index.find(id);
return iter != index.end() ? iter->second : MDConsumerHandle {};
});
return handle;
}
PNLType get_pnl_type (SecurityKey key) const{
auto h = _get_handle(key);
if (h.is_initialized()){
const auto& sec = h.get_normalized_security();
if (sec.has_future() || sec.has_option())
return PNLType::OUTRIGHT;
else
return PNLType::SPREAD;
}
else
return PNLType::UNRESOLVED;
}
double get_cpp (SecurityKey key) const{
auto h = _get_handle(key);
if (h.is_initialized()){
const auto& sec = h.get_normalized_security();
return sec.contract_spec().cash_per_point();
}
return os::nan();
}
void get_md(SecurityKey key,
double& bid, double& ask, double& last, double& settle){
auto handle = _get_handle(key);
bid = bts::os::nan();
ask = bid;
last = bid;
settle = bid;
if(handle.is_initialized()){
TimeStamp time;
PriceSize bid_ps,ask_ps;
handle.get_direct_book(time, 1, &bid_ps, &ask_ps);
bid = bid_ps.price();
ask = ask_ps.price();
PriceSize last_ps;
datetime::LLDateTime trade_time;
handle.get_last_trade(time, last_ps, trade_time, nullptr);
last = last_ps.price();
settle = handle.settlement_price().price();
}
}
private:
void on_consumer(const MDConsumer& c) {
MDConsumer temp(c);
if (temp.all_heartbeats_ok()) {
auto existing = _consumer ? _consumer->id() : 0;
LOG(md,Info, "Updating MBOService MDConsumer. Old {} new {}", existing, temp.id());
// clear the index
index.lock([](auto& index) { index.clear(); });
// Swap to new consumer
if (_consumer) {
_consumer->swap(temp);
}
else { _consumer = temp; }
// Subscribe to on_security
auto id = _consumer->id();
_consumer->on_security([this,id](const SecurityPtr&, MDConsumerHandle handle) {
if (_consumer->id() == id) {
index.lock([handle](auto& index) {
index[SecurityKey(handle.key())] = handle;
});
}
});
}
}
};
struct PositionServicePNLHelper::PImpl {
HandleIndex handle_index;
std::map<SecurityKey, uint16_t> missing_data_log_count;
PImpl(bts::md::MDClient& md_client)
:
handle_index(md_client),
missing_data_log_count(){
}
};
void PositionServicePNLHelper::compute_pnl(
const std::map<int, PositionUnit const*>& in_pos,
const std::map<std::string,uint32_t>& account_map,
const std::map<uint32_t,double>& cpp_override_map,
std::vector<PNLUnit>& out_pnl,
std::vector<AccountPNL>& out_account_pnl){
out_account_pnl.clear();
for (const auto& p : in_pos) {
const PositionUnit& pu = *(p.second);
uint32_t sec_key = pu.security_id();
double cpp = me->handle_index.get_cpp(SecurityKey(sec_key));
auto it = cpp_override_map.find(sec_key);
cpp = (it != cpp_override_map.end()) ? it->second : cpp;
double bid, ask, last, settle;
me->handle_index.get_md(SecurityKey(sec_key),bid,ask,last,settle);
PNLUnit pnlu;
pnlu.set_record_id(pu.record_id());
pnlu.mutable_pos()->CopyFrom(pu);
pnlu.set_cash_value(cpp);
pnlu.set_bid_price(bid);
pnlu.set_ask_price(ask);
pnlu.set_last_price(last);
pnlu.set_settlement_price(settle);
out_pnl.push_back(pnlu);
_log_missing_data(pnlu);
}
_aggregate_account_pnl(out_pnl,account_map,out_account_pnl);
}
void PositionServicePNLHelper::_aggregate_account_pnl(
const std::vector<api::position::PNLUnit>& in_pnl,
const std::map<std::string,uint32_t>& account_map,
std::vector<api::position::AccountPNL>& out_account_pnl){
out_account_pnl.clear();
if (account_map.size() == 0)
return;
std::map<uint32_t, AccountPNL> acc_pnl;
for (const auto& pnlu : in_pnl){
uint32_t acct_id = pnlu.pos().account_id();
const std::string& acct_name = pnlu.pos().account();
auto it=acc_pnl.find(acct_id);
if(it==acc_pnl.end()){
AccountPNL new_acc;
new_acc.set_account_id(acct_id);
new_acc.set_account_name(acct_name);
new_acc.set_day_pnl(0.0);
acc_pnl[acct_id]=new_acc;
it=acc_pnl.find(acct_id);
}
AccountPNL& acc_pnl = it->second;
double pnl_dollars = _compute_day_pnl(pnlu);
acc_pnl.set_day_pnl(acc_pnl.day_pnl()+pnl_dollars);
}
// for accounts with no positions add 0
for (const auto& p : account_map){
const std::string& acct_name = p.first;
uint32_t acct_id = p.second;
if(acc_pnl.find(acct_id) == acc_pnl.end()){
AccountPNL new_acc;
new_acc.set_account_id(acct_id);
new_acc.set_account_name(acct_name);
new_acc.set_day_pnl(0.0);
acc_pnl[acct_id]=new_acc;
}
}
for(auto& u : acc_pnl)
out_account_pnl.push_back(u.second);
}
double PositionServicePNLHelper::_compute_day_pnl (
const bts::api::position::PNLUnit& u){
// long
double pnl;
auto pnl_type = me->handle_index.get_pnl_type(
SecurityKey(u.pos().security_id()));
switch(pnl_type){
case HandleIndex::OUTRIGHT:{
double md = (u.bid_price() + u.ask_price())*0.5;
md = bts::os::is_nan(md) ? u.bid_price() : md;
md = bts::os::is_nan(md) ? u.ask_price() : md;
md = bts::os::is_nan(md) ? u.settlement_price() : md;
double long_pnl = std::abs(u.pos().day_long_pos()) * u.cash_value() *
(md - u.pos().day_long_avg_price()),
short_pnl = std::abs(u.pos().day_short_pos()) * u.cash_value() *
(u.pos().day_short_avg_price() - md);
if(config::get<config::toggles::IgnoreNansInDayPnL>().enabled())
{
if(bts::os::is_nan(long_pnl))
long_pnl = 0.0;
if(bts::os::is_nan(short_pnl))
short_pnl = 0.0;
}
pnl = long_pnl + short_pnl;
break;
}
case HandleIndex::SPREAD:
pnl = 0.0;
break;
case HandleIndex::UNRESOLVED:
pnl = os::nan();
break;
}
return pnl;
}
void PositionServicePNLHelper::_log_missing_data(const PNLUnit& u){
auto sec_key = SecurityKey(u.pos().security_id());
bool missing_cpp = os::is_nan(u.cash_value()),
missing_md = os::is_nan(u.bid_price()) &&
os::is_nan(u.ask_price()) &&
os::is_nan(u.last_price()) &&
os::is_nan(u.settlement_price());
if(missing_cpp || missing_md){
const auto it = me->missing_data_log_count.find(sec_key);
uint16_t count = it == me->missing_data_log_count.end() ? 0 :
it->second;
if (count <= 50)
LOG(md, Warn, "Missing pnl data sec:{} cpp:{} md:{}",
sec_key, missing_cpp, missing_md);
me->missing_data_log_count[sec_key] = count+1;
}
else
me->missing_data_log_count[sec_key] = 0;
}
PositionServicePNLHelper::PositionServicePNLHelper(md::MDClient& md_client)
:
me(new PImpl(md_client)){
}
PositionServicePNLHelper::~PositionServicePNLHelper(){
}
}}