#ifndef NO_CPP0X #include "MDConsumerHandle.h" #include "lib/domain_model/Security.h" #include #define never bts_assert(false) template using small_vector = boost::container::small_vector; namespace bts { namespace md { MDConsumerHandle::MDConsumerHandle() { memset(this, 0, sizeof(MDConsumerHandle)); _type = HANDLETYPE_VOID; static_assert(sizeof(MDConsumerHandle) <= 32, ""); } MDConsumerHandle::MDConsumerHandle(const std::shared_ptr& def) { memset(this, 0, sizeof(MDConsumerHandle)); synthetic.def = def; _type = HANDLETYPE_SYNTHETIC; for(size_t x = 0; x < def->legs.size(); ++x) { bts_assert(def->legs[x].key() == def->security.synthetic().legs(x).security().id()); } } MDConsumerHandle::MDConsumerHandle(const MDConsumerHandle& other) { memset(this, 0, sizeof(MDConsumerHandle)); _type = HANDLETYPE_VOID; *this = other; } MDConsumerHandle::~MDConsumerHandle() {} void MDConsumerHandle::init(const ColdHeader& cheader, const ColdEntry& centry, const void* pvhot) { set_cold(&cheader, ¢ry); set_hot(pvhot); } TimeStamp copy_bbo(const HotEntry& hot, PriceSize& out_bid, PriceSize& out_ask) { // We expect the time, in_bid and in_ask to be changing (rapidly) // TimeStamp t; int attempts = 0; // If the publisher crashed and left TimeStamp::invalid() in memory we need to be able to escape the loop // This max_attempts allows get_bbo() to return 'false' in this case so the calling thread can continue and // hopefully check the heartbeat. const int max_attempts = 1619200; do { t = hot.time(); out_bid = hot.book.bid(); out_ask = hot.book.ask(); ++attempts; } while((t != hot.time() || t == TimeStamp::invalid()) && attempts < max_attempts); if (attempts >= max_attempts) { return TimeStamp::invalid(); } return t; } TimeStamp copy_depth( const HotDepthEntry& hot, size_t count, PriceSize* bid, PriceSize* ask) { TimeStamp t; int attempts = 0; const int max_attempts = 1619200; do { t = hot.time(); for (size_t x = 0; x < count; ++x) { hot.read_direct(x, &bid[x], &ask[x]); } ++attempts; } while((t != hot.time() || t == TimeStamp::invalid()) && attempts < max_attempts); if (attempts >= max_attempts) { return TimeStamp::invalid(); } return t; } ///////////////////////////// // SYNTHETIC DEPTH ///////////////////////////// struct Level { double price; double size; }; struct DepthTraversal { std::array levels; size_t head; api::Side side; double qty, price_mult; DepthTraversal(api::Side side, double qty, double price_mult, const PriceSize* depth, size_t depth_count) : levels(), head(0), side(side), qty(qty), price_mult(price_mult) { // Copy prices into mutable storage for (size_t x = 0; x < depth_count; ++x) { levels[x].price = depth[x].price(); levels[x].size = depth[x].size(); } } #ifdef PRECISE_SYNTHETICS double available_size() const { double available = 0.0; auto cur = head; bool partial = false; while(cur < levels.size() && available < 1) { available += levels[cur].size / qty; if (available < 1.0) partial = true; ++cur; } if (partial && available >= 1.0) return 1.0; return available; } double consume(double size) { bts_assert_d(size <= available_size()); double take = size * qty; double price = 0.0; while(take > 0) { if (levels[head].size >= take) { price += levels[head].price * price_mult * (take/qty); levels[head].size -= take; if (levels[head].size <= 0) ++head; break; } else { double available = levels[head].size; price += levels[head].price * price_mult * (available/qty); levels[head].size = 0; ++head; take -= available; } } return price/size; } #else double available_size() const { double available = 0.0; auto cur = head; while(cur < levels.size() && available < 1) { available += levels[cur].size / qty; ++cur; } return available; } double consume(double size) { bts_assert_d(size <= available_size()); double take = size * qty; double price = 0.0; while(take > 0) { if (levels[head].size >= take) { price = levels[head].price * price_mult; levels[head].size -= take; if (levels[head].size <= 0) ++head; break; } else { double available = levels[head].size; price = levels[head].price * price_mult; levels[head].size = 0; ++head; take -= available; } } return price; } #endif }; void copy_synthetic_side(size_t count, api::Side side, const api::ContractSpecification& spec, small_vector& leg_travs, Level* out_price) { size_t out_index = 0; bool first = true; while(out_index < count) { double price = 0.0; // Find the leg with the minimum available size double size = std::numeric_limits().max(); for (const auto& dt : leg_travs) { auto sz = dt.available_size(); // If we can't get 1.0 from any leg we're done if (sz <= size) size = sz; if (size < 1.0) break; } size = (int64_t)size; if (size < 1.0) { // We've run out of book so we nan out any remaining levels and finish size_t start = first ? out_index : out_index+1; for (size_t x=start; x < count; ++x) { out_price[x].price = os::nan(); out_price[x].size = 0; } return; } // Take that size from each leg for (auto& dt : leg_travs) { double temp = dt.consume(size); price += temp; } bts_assert_d(!os::is_nan(price)); // Round to tick size price = securities::checked_round_to_quote_price(spec, price, side); if (first) { first = false; out_price[out_index].price = price; } if (price == out_price[out_index].price) { out_price[out_index].size += size; } else { out_index += 1; if (out_index < count) { out_price[out_index].price = price; out_price[out_index].size = size; } } } } const spark::LegSpreaderParams& get_spreader_params(const SyntheticStrategy& synth, security_key key) { auto strategy = synth.strategy.get(); if (strategy) { auto iter = strategy->leg_params_map().find(key); if (iter != strategy->leg_params_map().end()) { return iter->second; } } return spark::LegSpreaderParams::default_instance(); } TimeStamp copy_synthetic_depth(const SyntheticStrategy& synth, size_t count, PriceSize* bid, PriceSize* ask) { small_vector bid_leg_travs; small_vector ask_leg_travs; bid_leg_travs.reserve(synth.legs.size()); ask_leg_travs.reserve(synth.legs.size()); TimeStamp rv = std::numeric_limits::min(); for (size_t x = 0; x < synth.legs.size(); ++x) { std::array bids, asks; TimeStamp t; const spark::LegSpreaderParams& leg_params = get_spreader_params(synth, synth.legs[x].key()); auto mdtype = leg_params.market_data_type(); HandleReadResult r; if (mdtype == spark::LegSpreaderParams::DIRECT) { r = synth.legs[x].get_direct_book(t, count, &bids[0], &asks[0]); } else { r = synth.legs[x].get_book(t, count, &bids[0], &asks[0]); } if (r == HandleReadResult::BUSY || t == TimeStamp::invalid()) return TimeStamp::invalid(); // NET Change if (leg_params.leg_md_calc() == spark::LegSpreaderParams::NET_CHANGE) { auto settle = synth.legs[x].settlement_price(); for (size_t d = 0; d < COCONUT_MAX_DEPTH; ++d) { bids[d] = bids[d] - settle; asks[d] = asks[d] - settle; } } rv = std::max(rv, t); const auto& leg = synth.security.synthetic().legs(x); const auto& eff_bid = leg.side() == api::SIDE_BUY ? bids : asks; const auto& eff_ask = leg.side() == api::SIDE_BUY ? asks : bids; bid_leg_travs.push_back(DepthTraversal(leg.side(), leg.quantity(), leg.price_multiplier(), &eff_bid[0], eff_bid.size())); ask_leg_travs.push_back(DepthTraversal(leg.side(), leg.quantity(), leg.price_multiplier(), &eff_ask[0], eff_ask.size())); } std::array scratch {}; const auto& spec = synth.security.contract_spec(); copy_synthetic_side(count, api::SIDE_BUY, spec, bid_leg_travs, scratch.data()); for (size_t x = 0; x < count; ++x) { bid[x] = PriceSize_from_double<7>(scratch[x].price, scratch[x].size); } memset(scratch.data(), 0, sizeof(scratch)); copy_synthetic_side(count, api::SIDE_SELL, spec, ask_leg_travs, scratch.data()); for (size_t x = 0; x < count; ++x) { ask[x] = PriceSize_from_double<7>(scratch[x].price, scratch[x].size); } return rv; } ///////////////////////////// // END SYNTHETIC DEPTH ///////////////////////////// bool MDConsumerHandle::get_last_trade(TimeStamp& time, PriceSize& trade, datetime::LLDateTime& trade_timestamp, size_t* total_volume) const { switch(_type) { case HANDLETYPE_VOID: return false; case HANDLETYPE_DEPTH: case HANDLETYPE_BBO: { const ColdEntry* pcold = (_type == HANDLETYPE_BBO) ? bbo.cdata : book.cdata; bool result = pcold->last_trade.load_if_new(time, trade); if (result) { trade_timestamp = pcold->last_trade_time; if (total_volume) { *total_volume = pcold->total_volume; } } return result; } case HANDLETYPE_SYNTHETIC: return false; } never; } TimeStamp MDConsumerHandle::misc_timestamp() const { switch(_type) { case HANDLETYPE_SYNTHETIC: case HANDLETYPE_VOID: return std::numeric_limits::min(); case HANDLETYPE_DEPTH: return book.cdata->misc.misc_timestamp; case HANDLETYPE_BBO: return bbo.cdata->misc.misc_timestamp; } never; } MiscData MDConsumerHandle::misc() const { switch(_type) { case HANDLETYPE_SYNTHETIC: case HANDLETYPE_VOID: return MiscData(); case HANDLETYPE_DEPTH: return book.cdata->misc; case HANDLETYPE_BBO: return bbo.cdata->misc; } never; } bool is_heart_beat_ok(const ColdHeader &); bool MDConsumerHandle::is_heart_beating() const { switch(_type) { case HANDLETYPE_VOID: return true; case HANDLETYPE_DEPTH: return is_heart_beat_ok(*book.cheader); case HANDLETYPE_BBO: return is_heart_beat_ok(*bbo.cheader); case HANDLETYPE_SYNTHETIC: return sane::true_for_all(synthetic.def->legs, [](const MDConsumerHandle& h) { return h.is_heart_beating(); }); } never; } TimeStamp MDConsumerHandle::heartbeat() const { switch(_type) { case HANDLETYPE_VOID: return TimeStamp::now(); case HANDLETYPE_DEPTH: return book.cheader->heartbeat; case HANDLETYPE_BBO: return bbo.cheader->heartbeat; case HANDLETYPE_SYNTHETIC: return sane::min(synthetic.def->legs, [](const MDConsumerHandle& h) { return h.heartbeat(); }); } never; } CoconutSecurityStatus MDConsumerHandle::status() const { switch(_type) { case HANDLETYPE_VOID: return CoconutSecurityStatus::COCONUTSECURITYSTATUS_OK; case HANDLETYPE_DEPTH: return (CoconutSecurityStatus)book.hot->status; case HANDLETYPE_BBO: return (CoconutSecurityStatus)bbo.hot->status; case HANDLETYPE_SYNTHETIC: { for (const auto& handle : synthetic.def->legs) { auto status = handle.status(); if (status != CoconutSecurityStatus::COCONUTSECURITYSTATUS_OK) { return status; } } } } never; } }}//namespace #endif