#ifndef NO_CPP0X #include "MDConsumerHandle.h" #include "lib/utils/sane_algorithm.h" #include "lib/domain_model/Security.h" #define never bts_assert(false) 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.bid.load(); out_ask = hot.ask.load(); ++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) { bid[x] = hot.bid(x).load(); ask[x] = hot.ask(x).load(); } ++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; uint16_t 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(); } } double try_take1() { if (head >= levels.size()) return os::nan(); if (levels[head].size >= qty) { levels[head].size -= qty; return levels[head].price * price_mult; } else { double price = 0; size_t count = 0; while(count < qty) { if (levels[head].size >= 1) { price += levels[head].price; levels[head].size -= 1; count += 1; } else { head++; if (head >= levels.size()) return os::nan(); } } return (price / qty) * price_mult; } } }; void copy_depth(size_t count, api::Side side, const api::ContractSpecification& spec, std::vector& leg_travs, Level* out_price) { size_t out_index = 0; bool first = true; while(out_index < count) { double price = 0.0; for (auto& dt : leg_travs) { double temp = dt.try_take1(); price += temp; } if (os::is_nan(price)) { // 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; } // 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 += 1; } else { out_index += 1; if (out_index < count) { out_price[out_index].price = price; out_price[out_index].size = 1; } } } } TimeStamp copy_depth(const SyntheticStrategy& synth, size_t count, PriceSize* bid, PriceSize* ask) { std::vector bid_leg_travs; std::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; HandleReadResult r = synth.legs[x].get_depth(t, count, &bids[0], &asks[0]); if (r == HandleReadResult::BUSY || t == TimeStamp::invalid()) return TimeStamp::invalid(); 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_depth(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_depth(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 ///////////////////////////// TimeStamp MDConsumerHandle::last_market_update() const { switch(_type) { case HANDLETYPE_VOID: return TimeStamp::invalid(); case HANDLETYPE_DEPTH: return book.hot->time(); case HANDLETYPE_BBO: return bbo.hot->time(); case HANDLETYPE_SYNTHETIC: return sane::max(synthetic.def->legs, [](const MDConsumerHandle& h) { return h.last_market_update(); }); } never; } bool MDConsumerHandle::get_customer_bbo(TimeStamp& time, PriceSize& out_bid, PriceSize& out_ask) const { switch(_type) { case HANDLETYPE_SYNTHETIC: case HANDLETYPE_VOID: return false; case HANDLETYPE_DEPTH: case HANDLETYPE_BBO: { const ColdEntry* pcold = (_type == HANDLETYPE_BBO) ? bbo.cdata : book.cdata; // This can loop forever if publisher crashes with an invalid time in shm // good thing nobody uses customer_bbo bool result = false; while(pcold->customer_bbo_updated > time || time == TimeStamp::invalid()) { time = pcold->customer_bbo_updated; out_bid = pcold->customer_bid.load(); out_ask = pcold->customer_ask.load(); result = true; } return result; } } never; } 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 = false; while (pcold->last_trade_updated > time) { time = pcold->last_trade_updated; trade = pcold->last_trade.load(); trade_timestamp = pcold->last_trade_time; if (total_volume) { *total_volume = pcold->total_volume; } result = true; } 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; } uint16_t MDConsumerHandle::sequence() const { switch(_type) { case HANDLETYPE_VOID: return 0; case HANDLETYPE_DEPTH: return book.hot->sequence; case HANDLETYPE_BBO: return bbo.hot->sequence; case HANDLETYPE_SYNTHETIC: bts_assert(!synthetic.def->legs.empty()); return sane::min_by(synthetic.def->legs, [](const MDConsumerHandle& h) { return h.last_market_update(); })->sequence(); } never; } }}//namespace #endif