Added concurrent market example and string functions

Author: jmsadair

CMakeLists.txt

@@ -136,32 +136,36 @@ set(MEMORYCHECK_COMMAND_OPTIONS "${MEMORYCHECK_COMMAND_OPTIONS} --error-exitcode
 # ------------------------------------------------------------------------------
 file(GLOB_RECURSE LIB_HEADER_FILES "include/*.h")
 file(GLOB_RECURSE LIB_SOURCE_FILES "src/*.cpp")
-add_library(rapid_trader ${LIB_HEADER_FILES} ${LIB_SOURCE_FILES} src/matching/orderbook/symbol.cpp)
-target_link_libraries(rapid_trader spdlog)
+add_library(trader_lib ${LIB_HEADER_FILES} ${LIB_SOURCE_FILES})
+target_link_libraries(trader_lib spdlog)
+install(TARGETS trader_lib DESTINATION ${TRADER_INSTALL_LIB_DIR})
 
 # ------------------------------------------------------------------------------
 # Rapid Trader Example
 # ------------------------------------------------------------------------------
-add_executable(rapid_trader_example examples/market_example.cpp)
-target_link_libraries(rapid_trader_example rapid_trader)
-install(TARGETS rapid_trader_example DESTINATION ${TRADER_INSTALL_BIN_DIR}/examples)
+add_executable(trader_market_example examples/market_example.cpp)
+add_executable(trader_concurrent_market_example examples/concurrent_market_example.cpp examples/simple_event_handler.h)
+target_link_libraries(trader_market_example trader_lib)
+target_link_libraries(trader_concurrent_market_example trader_lib)
+install(TARGETS trader_market_example DESTINATION ${TRADER_INSTALL_BIN_DIR}/examples)
+install(TARGETS trader_concurrent_market_example DESTINATION ${TRADER_INSTALL_BIN_DIR}/examples)
 
 # ------------------------------------------------------------------------------
 # Rapid Trader Benchmark
 # ------------------------------------------------------------------------------
-add_executable(rapid_trader_benchmark benchmark/bench_market.cpp)
-target_link_libraries(rapid_trader_benchmark benchmark::benchmark rapid_trader)
-install(TARGETS rapid_trader_benchmark DESTINATION ${TRADER_INSTALL_BIN_DIR}/benchmarks)
+add_executable(trader_benchmark benchmark/bench_market.cpp)
+target_link_libraries(trader_benchmark benchmark::benchmark trader_lib)
+install(TARGETS trader_benchmark DESTINATION ${TRADER_INSTALL_BIN_DIR}/benchmarks)
 
 # ------------------------------------------------------------------------------
 # Rapid Trader Tests
 # ------------------------------------------------------------------------------
 include(CTest)
 include(GoogleTest)
 file(GLOB_RECURSE TEST_SOURCE_FILES "test/*.cpp")
-add_executable(rapid_trader_tests ${TEST_SOURCE_FILES})
-target_link_libraries(rapid_trader_tests rapid_trader)
-target_link_libraries(rapid_trader_tests gtest_main)
-gtest_discover_tests(rapid_trader_tests)
-install(TARGETS rapid_trader_tests DESTINATION ${TRADER_INSTALL_BIN_DIR}/tests)
+add_executable(trader_tests ${TEST_SOURCE_FILES})
+target_link_libraries(trader_tests trader_lib)
+target_link_libraries(trader_tests gtest_main)
+gtest_discover_tests(trader_tests)
+install(TARGETS trader_tests DESTINATION ${TRADER_INSTALL_BIN_DIR}/tests)
 

benchmark/bench_market.cpp

@@ -4,6 +4,8 @@
 #include "market/market.h"
 #include "event_handler/event_handler.h"
 
+using namespace RapidTrader;
+
 class DebugEventHandler : public EventHandler
 {};
 
@@ -37,7 +39,7 @@ static void BM_Market(benchmark::State &state)
     for (auto _ : state)
     {
         state.PauseTiming();
-        RapidTrader::Matching::Market market{std::make_unique<EventHandler>()};
+        Market market{std::make_unique<EventHandler>()};
         for (int i = 1; i <= num_symbols; ++i)
             market.addSymbol(i, "MARKET BENCH");
         state.ResumeTiming();

examples/concurrent_market_example.cpp

@@ -0,0 +1,39 @@
+#include <iostream>
+#include "market/concurrent_market.h"
+#include "simple_event_handler.h"
+
+using namespace RapidTrader;
+
+int main()
+{
+    // Create a new concurrent market that uses 2 threads.
+    // Note that there must be one event handler per thread.
+    const uint32_t num_threads = 2;
+    std::vector<std::unique_ptr<EventHandler>> event_handlers;
+    for (uint32_t i = 0; i < num_threads; ++i)
+        event_handlers.push_back(std::unique_ptr<EventHandler>(new SimpleEventHandler));
+    ConcurrentMarket market{event_handlers, num_threads};
+
+    // Add a new symbol to the market. A symbol must be added to the market before any orders with that symbol are submitted.
+    std::string symbol1_name = "GOOG";
+    uint32_t symbol1_id = 1;
+    market.addSymbol(symbol1_id, symbol1_name);
+
+    // Add bid limit order to the market.
+    OrderTimeInForce time_in_force1 = OrderTimeInForce::GTC;
+    uint64_t quantity1 = 200;
+    uint64_t price1 = 350;
+    uint64_t id1 = 1;
+    Order order1 = Order::limitBidOrder(id1, symbol1_id, price1, quantity1, time_in_force1);
+    market.addOrder(order1);
+
+    // Add ask limit order to the market.
+    OrderTimeInForce time_in_force2 = OrderTimeInForce::GTC;
+    uint64_t quantity2 = 200;
+    uint64_t price2 = 350;
+    uint64_t id2 = 2;
+    Order order2 = Order::limitAskOrder(id2, symbol1_id, price2, quantity2, time_in_force2);
+    market.addOrder(order2);
+
+    return 0;
+}

examples/market_example.cpp

@@ -1,55 +1,29 @@
 #include <iostream>
 #include "market/market.h"
-#include "event_handler.h"
+#include "simple_event_handler.h"
 
-class SimpleEventHandler : public EventHandler
-{
-protected:
-    void handleOrderAdded(const OrderAdded &notification) override
-    {
-        std::cout << notification << "\n";
-    }
-    void handleOrderDeleted(const OrderDeleted &notification) override
-    {
-        std::cout << notification << "\n";
-    }
-    void handleOrderUpdated(const OrderUpdated &notification) override
-    {
-        std::cout << notification << "\n";
-    }
-    void handleOrderExecuted(const ExecutedOrder &notification) override
-    {
-        std::cout << notification << "\n";
-    }
-    void handleSymbolAdded(const SymbolAdded &notification) override
-    {
-        std::cout << notification << "\n";
-    }
-    void handleSymbolDeleted(const SymbolDeleted &notification) override
-    {
-        std::cout << notification << "\n";
-    }
-};
+using namespace RapidTrader;
 
 int main()
 {
     // Create a new market with an event handler. Note that the market requires ownership of the event handler.
     auto event_handler = std::unique_ptr<EventHandler>(new SimpleEventHandler);
-    RapidTrader::Matching::Market market{std::move(event_handler)};
+    Market market{std::move(event_handler)};
 
     // Add a new symbol to the market. A symbol must be added to the market before any orders with that symbol are submitted.
     std::string symbol_name = "GOOG";
     uint32_t symbol_id = 1;
     market.addSymbol(symbol_id, symbol_name);
 
-    // Add some limit orders to the market.
+    // Add bid limit order to the market.
     OrderTimeInForce time_in_force1 = OrderTimeInForce::GTC;
     uint64_t quantity1 = 200;
     uint64_t price1 = 350;
     uint64_t id1 = 1;
     Order order1 = Order::limitBidOrder(id1, symbol_id, price1, quantity1, time_in_force1);
     market.addOrder(order1);
 
+    // Add ask limit order to the market.
     OrderTimeInForce time_in_force2 = OrderTimeInForce::GTC;
     uint64_t quantity2 = 200;
     uint64_t price2 = 350;

examples/simple_event_handler.h

@@ -0,0 +1,36 @@
+#ifndef RAPID_TRADER_SIMPLE_EVENT_HANDLER_H
+#define RAPID_TRADER_SIMPLE_EVENT_HANDLER_H
+#include "event_handler.h"
+
+using namespace RapidTrader;
+
+class SimpleEventHandler : public EventHandler
+{
+
+protected:
+    void handleOrderAdded(const OrderAdded &notification) override
+    {
+        std::cout << notification << std::endl;;
+    }
+    void handleOrderDeleted(const OrderDeleted &notification) override
+    {
+        std::cout << notification << std::endl;;
+    }
+    void handleOrderUpdated(const OrderUpdated &notification) override
+    {
+        std::cout << notification << std::endl;;
+    }
+    void handleOrderExecuted(const ExecutedOrder &notification) override
+    {
+        std::cout << notification << std::endl;;
+    }
+    void handleSymbolAdded(const SymbolAdded &notification) override
+    {
+        std::cout << notification << std::endl;;
+    }
+    void handleSymbolDeleted(const SymbolDeleted &notification) override
+    {
+        std::cout << notification << std::endl;;
+    }
+};
+#endif // RAPID_TRADER_SIMPLE_EVENT_HANDLER_H

include/concurrent/queue.h

@@ -4,7 +4,7 @@
 #include <mutex>
 #include <condition_variable>
 
-namespace Concurrent {
+namespace RapidTrader::Concurrent {
 /**
  * A thread-safe queue.
  *

include/concurrent/thread_joiner.h

@@ -3,6 +3,7 @@
 #include <vector>
 #include <thread>
 
+namespace RapidTrader::Concurrent {
 /**
  * A class to clean up threads used by the thread pool.
  */
@@ -26,4 +27,5 @@ struct ThreadJoiner
     // The threads that the joiner is responsible for joining.
     std::vector<std::thread> &threads;
 };
+}
 #endif // RAPID_TRADER_THREAD_JOINER_H

include/concurrent/thread_pool.h

@@ -8,7 +8,7 @@
 #include "concurrent/thread_joiner.h"
 #include "concurrent/queue.h"
 
-namespace Concurrent {
+namespace RapidTrader::Concurrent {
 class ThreadPool
 {
 public:
@@ -98,6 +98,7 @@ class ThreadPool
                 task_promise->set_exception(std::current_exception());
             }
         });
+        return task_promise->get_future();
     }
 
     /**

include/event_handler/event.h

@@ -2,6 +2,7 @@
 #define RAPID_TRADER_EVENT_H
 #include "order.h"
 
+namespace RapidTrader {
 struct Event
 {
     virtual ~Event() = default;
@@ -80,4 +81,5 @@ struct OrderUpdated : public OrderEvent
 
     friend std::ostream &operator<<(std::ostream &os, const OrderUpdated &notification);
 };
+}
 #endif // RAPID_TRADER_EVENT_H

include/event_handler/event_handler.h

@@ -4,6 +4,7 @@
 #include "market/concurrent_market.h"
 #include "event_handler/event.h"
 
+namespace RapidTrader {
 class EventHandler
 {
 public:
@@ -62,4 +63,5 @@ class EventHandler
     virtual void handleSymbolDeleted(const SymbolDeleted &event) {}
     // LCOV_EXCL_STOP
 };
+}
 #endif // RAPID_TRADER_EVENT_HANDLER_H

include/matching/market/concurrent_market.h

@@ -9,10 +9,12 @@
 #include "orderbook.h"
 #include "symbol.h"
 
+
+namespace RapidTrader {
+using namespace Concurrent;
 class EventHandler;
 class OrderBookHandler;
 
-namespace RapidTrader::Matching {
 class ConcurrentMarket
 {
 public:
@@ -58,7 +60,6 @@ class ConcurrentMarket
      *
      * @param symbol_id the symbol ID associated with the order.
      * @param order_id the ID associated with the order.
-     * @return ErrorStatus indicating whether the order was successfully deleted.
      */
     void deleteOrder(uint32_t symbol_id, uint64_t order_id);
 
@@ -68,7 +69,6 @@ class ConcurrentMarket
      * @param symbol_id the symbol ID associated with the order.
      * @param order_id the ID associated with the order.
      * @param cancelled_quantity the quantity of the order to cancel, require that cancelled_quantity is positive.
-     * @return ErrorStatus indicating whether the order was successfully cancelled.
      */
     void cancelOrder(uint32_t symbol_id, uint64_t order_id, uint64_t cancelled_quantity);
 
@@ -101,6 +101,21 @@ class ConcurrentMarket
      */
     void executeOrder(uint32_t symbol_id, uint64_t order_id, uint64_t quantity);
 
+    /**
+     * @return the string representation of the market.
+     */
+    [[nodiscard]] std::string toString();
+
+    /**
+     * Writes the string representation to a file with the provided
+     * name. Creates a new file.
+     *
+     * @param name the name to the file that will be written to.
+     */
+    void dumpMarket(const std::string &name);
+
+    friend std::ostream &operator<<(std::ostream &os, ConcurrentMarket &concurrent_market);
+
 private:
     /**
      * Gets the index that that corresponds to the queue in the thread pool
@@ -127,10 +142,10 @@ class ConcurrentMarket
     // handler that is associated with the symbol ID.
     robin_hood::unordered_map<uint32_t, uint32_t> id_to_submission_index;
     // The thread pool that order operations will be submitted to.
-    Concurrent::ThreadPool thread_pool;
+    ThreadPool thread_pool;
     // The index of the thread pool queue and orderbook handler that will be associated
     // with a newly added symbol.
     uint32_t symbol_submission_index;
 };
-} // namespace RapidTrader::Matching
+}
 #endif // RAPID_TRADER_CONCURRENT_MARKET_H

include/matching/market/market.h

@@ -8,7 +8,9 @@
 #include "order.h"
 #include "orderbook.h"
 #include "symbol.h"
+#include "event_handler.h"
 
+namespace RapidTrader {
 class EventHandler;
 
 // A struct for the shared logic between market and concurrent market.
@@ -42,7 +44,6 @@ struct OrderBookHandler
     std::unique_ptr<EventHandler> event_handler;
 };
 
-namespace RapidTrader::Matching {
 class Market
 {
 public:
@@ -138,12 +139,12 @@ class Market
     [[nodiscard]] std::string toString() const;
 
     /**
-     * Writes the string representation of the the market to
-     * a file at the provided path. Creates a new file.
+     * Writes the string representation to a file with the provided
+     * name. Creates a new file.
      *
-     * @param path the path to the file that will be written to.
+     * @param name the name to the file that will be written to.
      */
-    void dumpMarket(const std::string &path) const;
+    void dumpMarket(const std::string &name) const;
 
     friend std::ostream &operator<<(std::ostream &os, const Market &book);
 
@@ -153,6 +154,5 @@ class Market
     // Symbol IDs to symbols.
     robin_hood::unordered_map<uint32_t, std::unique_ptr<Symbol>> id_to_symbol;
 };
-
-} // namespace RapidTrader::Matching
+} // namespace RapidTrader
 #endif // RAPID_TRADER_MARKET_H

include/matching/orderbook/level.h

@@ -2,6 +2,7 @@
 #define RAPID_TRADER_LEVEL_H
 #include "order.h"
 
+namespace RapidTrader {
 // Only validate level in debug mode.
 #ifndef NDEBUG
 #    define VALIDATE_LEVEL validateLevel()
@@ -180,4 +181,5 @@ class Level
     uint64_t volume;
     uint64_t price;
 };
+}
 #endif // RAPID_TRADER_LEVEL_H