simplify compare definitions and other improvements

CMakeLists.txt

@@ -1,5 +1,10 @@
 cmake_minimum_required(VERSION 3.20 FATAL_ERROR)
 
+find_program(CCACHE_PROGRAM ccache)
+if (CCACHE_PROGRAM)
+    set_property(GLOBAL PROPERTY RULE_LAUNCH_COMPILE "${CCACHE_PROGRAM}")
+endif()
+
 set(CPP_ORDERBOOK orderbook)
 project(${CPP_ORDERBOOK} LANGUAGES CXX)
 

include/orderbook.hpp

@@ -20,10 +20,10 @@ class OrderBook {
     OrderBook(NotificationInterface<Notification>& n, size_t price_level_pool_size = 16384, size_t order_pool_size = 16384)
         : order_pool_(order_pool_size),
           notification_(static_cast<Notification&>(n)),
-          bids_(PriceLevel<CmpGreater>(PriceType::Bid, price_level_pool_size)),
-          asks_(PriceLevel<CmpLess>(PriceType::Ask, price_level_pool_size)),
-          trigger_over_(PriceLevel<CmpGreater>(PriceType::Trigger, price_level_pool_size)),
-          trigger_under_(PriceLevel<CmpLess>(PriceType::Trigger, price_level_pool_size)),
+          bids_(PriceLevel<PriceType::Bid>(price_level_pool_size)),
+          asks_(PriceLevel<PriceType::Ask>(price_level_pool_size)),
+          trigger_over_(PriceLevel<PriceType::TriggerOver>(price_level_pool_size)),
+          trigger_under_(PriceLevel<PriceType::TriggerUnder>(price_level_pool_size)),
           orders_(OrderMap()),
           trig_orders_(OrderMap()){};
 
@@ -39,10 +39,10 @@ class OrderBook {
    private:
     pool::AdaptiveObjectPool<Order> order_pool_;
 
-    PriceLevel<CmpGreater> bids_;
-    PriceLevel<CmpLess> asks_;
-    PriceLevel<CmpGreater> trigger_over_;
-    PriceLevel<CmpLess> trigger_under_;
+    PriceLevel<PriceType::Bid> bids_;
+    PriceLevel<PriceType::Ask> asks_;
+    PriceLevel<PriceType::TriggerOver> trigger_over_;
+    PriceLevel<PriceType::TriggerUnder> trigger_under_;
 
     OrderMap orders_;
     OrderMap trig_orders_;

include/orderqueue.hpp

@@ -16,6 +16,7 @@ class OrderQueue : public boost::intrusive::set_base_hook<boost::intrusive::opti
     Order *head_ = nullptr;
     Order *tail_ = nullptr;
 
+    Decimal price_;
     Decimal total_qty_;
     uint64_t size_ = 0;
 
@@ -30,11 +31,11 @@ class OrderQueue : public boost::intrusive::set_base_hook<boost::intrusive::opti
     void remove(Order *o);
     Decimal process(const TradeNotification &tn, const PostOrderFill &postFill, OrderID takerOrderID, Decimal qty);
 
-    Decimal price_;
-
     friend bool operator<(const OrderQueue &a, const OrderQueue &b) { return a.price_ < b.price_; }
     friend bool operator>(const OrderQueue &a, const OrderQueue &b) { return a.price_ > b.price_; }
     friend bool operator==(const OrderQueue &a, const OrderQueue &b) { return a.price_ == b.price_; }
+
+    friend class PriceCompare;
 };
 
 struct PriceCompare {

include/pricelevel.hpp

@@ -20,58 +20,36 @@ class Compare {
 using CmpGreater = boost::intrusive::compare<std::greater<>>;
 using CmpLess = boost::intrusive::compare<std::less<>>;
 
-template <class CompareType>
+template <PriceType P>
 class PriceLevel {
     pool::AdaptiveObjectPool<OrderQueue> queue_pool_;
 
+    using CompareType = std::conditional_t<(P == PriceType::Bid || P == PriceType::TriggerOver), CmpGreater, CmpLess>;
     using PriceTree = boost::intrusive::rbtree<OrderQueue, CompareType>;
     PriceTree price_tree_;
 
-    PriceType price_type_;
+    PriceType price_type_ = P;
     Decimal volume_;
     uint64_t num_orders_ = 0;
     uint64_t depth_ = 0;
 
    public:
-    PriceLevel(PriceType price_type, size_t price_level_pool_size) : price_type_(price_type), queue_pool_(price_level_pool_size){};
+    PriceLevel(size_t price_level_pool_size) : queue_pool_(price_level_pool_size){};
     uint64_t len();
     uint64_t depth();
     Decimal volume();
-    OrderQueue* getQueue();
+    [[nodiscard]] OrderQueue* getQueue();
+    [[nodiscard]] OrderQueue* getNextQueue(const Decimal& price);
+    [[nodiscard]] OrderQueue* largestLessThan(const Decimal& price);
+    [[nodiscard]] OrderQueue* smallestGreaterThan(const Decimal& price);
+
     void append(Order* order);
     void remove(Order* order);
+
     Decimal processMarketOrder(const TradeNotification& tn, const PostOrderFill& pf, OrderID takerOrderID, Decimal qty, Flag flag);
     Decimal processLimitOrder(const TradeNotification& tn, const PostOrderFill& pf, OrderID& takerOrderID, Decimal& price, Decimal qty, Flag& flag);
 
-    PriceTree& price_tree() { return price_tree_; }
-
-    OrderQueue* LargestLessThan(const Decimal& price) {
-        auto it = price_tree_.lower_bound(price, PriceCompare());
-        if (it != price_tree_.begin()) {
-            --it;
-            return &(*it);
-        }
-        return nullptr;
-    }
-
-    OrderQueue* SmallestGreaterThan(const Decimal& price) {
-        auto it = price_tree_.upper_bound(price, PriceCompare());
-        if (it != price_tree_.end()) {
-            return &(*it);
-        }
-        return nullptr;
-    }
-
-    OrderQueue* GetNextQueue(const Decimal& price) {
-        switch (price_type_) {
-            case PriceType::Bid:
-                return LargestLessThan(price);
-            case PriceType::Ask:
-                return SmallestGreaterThan(price);
-            default:
-                throw std::runtime_error("invalid call to GetQueue");
-        }
-    }
+    PriceTree& price_tree() { return price_tree_; };
 };
 
 }  // namespace orderbook

include/types.hpp

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <cstdint>
+#include <cwchar>
 #include <iostream>
 
 #include "decimal.hpp"
@@ -44,7 +45,8 @@ std::ostream& operator<<(std::ostream& os, const OrderStatus& status);
 enum class PriceType {
     Bid,
     Ask,
-    Trigger,
+    TriggerOver,
+    TriggerUnder,
 };
 
 std::ostream& operator<<(std::ostream& os, const PriceType& priceType);

src/order.cpp

@@ -5,7 +5,7 @@
 namespace orderbook {
 
 Decimal Order::getPrice(PriceType pt) {
-    if (pt == PriceType::Trigger) {
+    if (pt == PriceType::TriggerOver || pt == PriceType::TriggerUnder) [[unlikely]] {
         return trig_price;
     }
 

src/pricelevel.cpp

@@ -12,23 +12,23 @@
 
 namespace orderbook {
 
-template <class CompareType>
-uint64_t PriceLevel<CompareType>::len() {
+template <PriceType P>
+uint64_t PriceLevel<P>::len() {
     return num_orders_;
 }
 
-template <class CompareType>
-uint64_t PriceLevel<CompareType>::depth() {
+template <PriceType P>
+uint64_t PriceLevel<P>::depth() {
     return depth_;
 }
 
-template <class CompareType>
-Decimal PriceLevel<CompareType>::volume() {
+template <PriceType P>
+Decimal PriceLevel<P>::volume() {
     return volume_;
 }
 
-template <class CompareType>
-void PriceLevel<CompareType>::append(Order* order) {
+template <PriceType P>
+void PriceLevel<P>::append(Order* order) {
     auto price = order->getPrice(price_type_);
 
     auto it = price_tree_.find(price);
@@ -45,8 +45,8 @@ void PriceLevel<CompareType>::append(Order* order) {
     q->append(order);
 }
 
-template <class CompareType>
-void PriceLevel<CompareType>::remove(Order* order) {
+template <PriceType P>
+void PriceLevel<P>::remove(Order* order) {
     auto price = order->getPrice(price_type_);
 
     auto q = order->queue;
@@ -64,8 +64,8 @@ void PriceLevel<CompareType>::remove(Order* order) {
     volume_ -= order->qty;
 }
 
-template <class CompareType>
-OrderQueue* PriceLevel<CompareType>::getQueue() {
+template <PriceType P>
+OrderQueue* PriceLevel<P>::getQueue() {
     auto q = price_tree_.begin();
     if (q != price_tree_.end()) {
         return &*q;
@@ -74,8 +74,8 @@ OrderQueue* PriceLevel<CompareType>::getQueue() {
     return nullptr;
 }
 
-template <class CompareType>
-Decimal PriceLevel<CompareType>::processMarketOrder(const TradeNotification& tn, const PostOrderFill& pf, OrderID takerOrderID, Decimal qty, Flag flag) {
+template <PriceType P>
+Decimal PriceLevel<P>::processMarketOrder(const TradeNotification& tn, const PostOrderFill& pf, OrderID takerOrderID, Decimal qty, Flag flag) {
     // TODO: this won't work as pricelevel volumes aren't accounted for correctly
     if ((flag & (AoN | FoK)) != 0 && qty > volume_) {
         return uint64_t(0);
@@ -92,9 +92,8 @@ Decimal PriceLevel<CompareType>::processMarketOrder(const TradeNotification& tn,
     return uint64_t(0);
 };
 
-template <class CompareType>
-Decimal PriceLevel<CompareType>::processLimitOrder(const TradeNotification& tn, const PostOrderFill& pf, OrderID& takerOrderID, Decimal& price, Decimal qty,
-                                                   Flag& flag) {
+template <PriceType P>
+Decimal PriceLevel<P>::processLimitOrder(const TradeNotification& tn, const PostOrderFill& pf, OrderID& takerOrderID, Decimal& price, Decimal qty, Flag& flag) {
     Decimal qtyProcessed = {};
     auto orderQueue = getQueue();
 
@@ -127,7 +126,7 @@ Decimal PriceLevel<CompareType>::processLimitOrder(const TradeNotification& tn,
                     break;
                 }
                 aQty -= orderQueue->totalQty();
-                orderQueue = GetNextQueue(orderQueue->price());
+                orderQueue = getNextQueue(orderQueue->price());
             }
         } else {
             while (orderQueue != nullptr && price > orderQueue->price()) {
@@ -136,7 +135,7 @@ Decimal PriceLevel<CompareType>::processLimitOrder(const TradeNotification& tn,
                     break;
                 }
                 aQty -= orderQueue->totalQty();
-                orderQueue = GetNextQueue(orderQueue->price());
+                orderQueue = getNextQueue(orderQueue->price());
             }
         }
 
@@ -157,7 +156,40 @@ Decimal PriceLevel<CompareType>::processLimitOrder(const TradeNotification& tn,
     return qtyProcessed;
 };
 
-template class PriceLevel<CmpGreater>;
-template class PriceLevel<CmpLess>;
+template <PriceType P>
+OrderQueue* PriceLevel<P>::largestLessThan(const Decimal& price) {
+    auto it = price_tree_.lower_bound(price, PriceCompare());
+    if (it != price_tree_.begin()) {
+        --it;
+        return &(*it);
+    }
+    return nullptr;
+}
+
+template <PriceType P>
+OrderQueue* PriceLevel<P>::smallestGreaterThan(const Decimal& price) {
+    auto it = price_tree_.upper_bound(price, PriceCompare());
+    if (it != price_tree_.end()) {
+        return &(*it);
+    }
+    return nullptr;
+}
+
+template <PriceType P>
+OrderQueue* PriceLevel<P>::getNextQueue(const Decimal& price) {
+    switch (price_type_) {
+        case PriceType::Bid:
+            return largestLessThan(price);
+        case PriceType::Ask:
+            return smallestGreaterThan(price);
+        default:
+            throw std::runtime_error("invalid call to GetQueue");
+    }
+}
+
+template class PriceLevel<PriceType::Bid>;
+template class PriceLevel<PriceType::Ask>;
+template class PriceLevel<PriceType::TriggerOver>;
+template class PriceLevel<PriceType::TriggerUnder>;
 
 }  // namespace orderbook

src/types.cpp

@@ -54,8 +54,10 @@ std::ostream& operator<<(std::ostream& os, const PriceType& priceType) {
             return os << "Bid";
         case PriceType::Ask:
             return os << "Ask";
-        case PriceType::Trigger:
-            return os << "Trigger";
+        case PriceType::TriggerOver:
+            return os << "TriggerOver";
+        case PriceType::TriggerUnder:
+            return os << "TriggerUnder";
     }
     return os << "Unknown";
 }

test/pricelevel_test.cpp

@@ -16,7 +16,7 @@ class PriceLevelTest : public ::testing::Test {
 };
 
 TEST_F(PriceLevelTest, TestPriceLevel) {
-    PriceLevel<CmpLess> bidLevel(PriceType::Bid, 10);
+    PriceLevel<PriceType::Bid> bidLevel(10);
 
     auto o1 = std::make_shared<Order>(1, Type::Limit, Side::Buy, Decimal(10, 0), Decimal(10, 0), Decimal(uint64_t(0)), Flag::None);
     auto o2 = std::make_shared<Order>(2, Type::Limit, Side::Buy, Decimal(10, 0), Decimal(20, 0), Decimal(uint64_t(0)), Flag::None);
@@ -43,9 +43,10 @@ TEST_F(PriceLevelTest, TestPriceLevel) {
     ASSERT_EQ(bidLevel.depth(), 2);
     ASSERT_EQ(bidLevel.len(), 2);
 
-    if (tree.begin()->head() != o1.get() || tree.begin()->tail() != o1.get() || tree.rbegin()->head() != o2.get() || tree.rbegin()->tail() != o2.get()) {
-        FAIL() << "invalid price levels";
-    }
+    ASSERT_EQ(tree.begin()->head(), o2.get()) << "Invalid price levels: head of the first element does not match o1";
+    ASSERT_EQ(tree.begin()->tail(), o2.get()) << "Invalid price levels: tail of the first element does not match o1";
+    ASSERT_EQ(tree.rbegin()->head(), o1.get()) << "Invalid price levels: head of the last element does not match o2";
+    ASSERT_EQ(tree.rbegin()->tail(), o1.get()) << "Invalid price levels: tail of the last element does not match o2";
 
     bidLevel.remove(o1.get());
 
@@ -62,7 +63,7 @@ TEST_F(PriceLevelTest, TestPriceLevel) {
 }
 
 TEST_F(PriceLevelTest, TestPriceFinding) {
-    PriceLevel<CmpLess> askLevel(PriceType::Ask, 10);
+    PriceLevel<PriceType::Ask> askLevel(10);
 
     askLevel.append(new Order(1, Type::Limit, Side::Sell, Decimal(5, 0), Decimal(130, 0), Decimal(uint64_t(0)), Flag::None));
     askLevel.append(new Order(2, Type::Limit, Side::Sell, Decimal(5, 0), Decimal(170, 0), Decimal(uint64_t(0)), Flag::None));
@@ -75,17 +76,17 @@ TEST_F(PriceLevelTest, TestPriceFinding) {
 
     ASSERT_EQ(askLevel.volume(), Decimal(40, 0));
 
-    ASSERT_EQ(askLevel.LargestLessThan(Decimal(101, 0))->price(), Decimal(100, 0));
-    ASSERT_EQ(askLevel.LargestLessThan(Decimal(150, 0))->price(), Decimal(140, 0));
-    ASSERT_EQ(askLevel.LargestLessThan(Decimal(100, 0)), nullptr);
+    ASSERT_EQ(askLevel.largestLessThan(Decimal(101, 0))->price(), Decimal(100, 0));
+    ASSERT_EQ(askLevel.largestLessThan(Decimal(150, 0))->price(), Decimal(140, 0));
+    ASSERT_EQ(askLevel.largestLessThan(Decimal(100, 0)), nullptr);
 
-    ASSERT_EQ(askLevel.SmallestGreaterThan(Decimal(169, 0))->price(), Decimal(170, 0));
-    ASSERT_EQ(askLevel.SmallestGreaterThan(Decimal(150, 0))->price(), Decimal(160, 0));
-    ASSERT_EQ(askLevel.SmallestGreaterThan(Decimal(170, 0)), nullptr);
+    ASSERT_EQ(askLevel.smallestGreaterThan(Decimal(169, 0))->price(), Decimal(170, 0));
+    ASSERT_EQ(askLevel.smallestGreaterThan(Decimal(150, 0))->price(), Decimal(160, 0));
+    ASSERT_EQ(askLevel.smallestGreaterThan(Decimal(170, 0)), nullptr);
 }
 
 TEST_F(PriceLevelTest, TestStopQueuePriceFinding) {
-    PriceLevel<CmpLess> trigLevel(PriceType::Trigger, 10);
+    PriceLevel<PriceType::TriggerUnder> trigLevel(10);
 
     trigLevel.append(new Order(1, Type::Limit, Side::Sell, Decimal(5, 0), Decimal(10, 0), Decimal(130, 0), Flag::None));
     trigLevel.append(new Order(2, Type::Limit, Side::Sell, Decimal(5, 0), Decimal(20, 0), Decimal(170, 0), Flag::None));
@@ -98,13 +99,15 @@ TEST_F(PriceLevelTest, TestStopQueuePriceFinding) {
 
     ASSERT_EQ(trigLevel.volume(), Decimal(40, 0));
 
-    ASSERT_EQ(trigLevel.LargestLessThan(Decimal(101, 0))->price(), Decimal(100, 0));
-    ASSERT_EQ(trigLevel.LargestLessThan(Decimal(150, 0))->price(), Decimal(140, 0));
-    ASSERT_EQ(trigLevel.LargestLessThan(Decimal(100, 0)), nullptr);
+    std::cout << 1 << std::endl;
+    ASSERT_EQ(trigLevel.largestLessThan(Decimal(101, 0))->price(), Decimal(100, 0));
+    std::cout << 2 << std::endl;
+    ASSERT_EQ(trigLevel.largestLessThan(Decimal(150, 0))->price(), Decimal(140, 0));
+    ASSERT_EQ(trigLevel.largestLessThan(Decimal(100, 0)), nullptr);
 
-    ASSERT_EQ(trigLevel.SmallestGreaterThan(Decimal(169, 0))->price(), Decimal(170, 0));
-    ASSERT_EQ(trigLevel.SmallestGreaterThan(Decimal(150, 0))->price(), Decimal(160, 0));
-    ASSERT_EQ(trigLevel.SmallestGreaterThan(Decimal(170, 0)), nullptr);
+    ASSERT_EQ(trigLevel.smallestGreaterThan(Decimal(169, 0))->price(), Decimal(170, 0));
+    ASSERT_EQ(trigLevel.smallestGreaterThan(Decimal(150, 0))->price(), Decimal(160, 0));
+    ASSERT_EQ(trigLevel.smallestGreaterThan(Decimal(170, 0)), nullptr);
 }
 
 }  // namespace test