Merge pull request #508 from crypto-chassis/develop

Release

Author: cryptochassis

.github/workflows/test.yml

@@ -261,21 +261,6 @@ jobs:
           endif()
         endif()
 
-        execute_process(
-          COMMAND ${{ steps.cmake_and_ninja.outputs.cmake_dir }}/cmake
-            -S performance
-            -B performance/build
-            -D CMAKE_BUILD_TYPE=$ENV{CMAKE_BUILD_TYPE}
-            -G Ninja
-            -D CMAKE_MAKE_PROGRAM=ninja
-            # -D CMAKE_C_COMPILER_LAUNCHER=ccache
-            # -D CMAKE_CXX_COMPILER_LAUNCHER=ccache
-          RESULT_VARIABLE result
-        )
-        if (NOT result EQUAL 0)
-          message(FATAL_ERROR "Bad exit status")
-        endif()
-
     - name: Build 1
       shell: cmake -P {0}
       run: |
@@ -325,22 +310,6 @@ jobs:
           message(FATAL_ERROR "Bad exit status")
         endif()
 
-        execute_process(
-          COMMAND ${{ steps.cmake_and_ninja.outputs.cmake_dir }}/cmake --build performance/build -j 2
-          RESULT_VARIABLE result
-        )
-        if (NOT result EQUAL 0)
-          message(FATAL_ERROR "Bad exit status")
-        endif()
-
-        execute_process(
-          COMMAND rm -rf performance/build
-          RESULT_VARIABLE result
-        )
-        if (NOT result EQUAL 0)
-          message(FATAL_ERROR "Bad exit status")
-        endif()
-
         execute_process(
           COMMAND ${{ steps.cmake_and_ninja.outputs.cmake_dir }}/cmake --build test/build -j 2
           RESULT_VARIABLE result

README.md

@@ -988,7 +988,6 @@ session->setTimer(
 * Enable link time optimization (e.g. in CMakeLists.txt `set(CMAKE_INTERPROCEDURAL_OPTIMIZATION TRUE)` before a target is created). Note that link time optimization is only applicable to static linking.
 * Shorten constant strings used as key names in the returned `Element` (e.g. in CmakeLists.txt `add_compile_definitions(CCAPI_BEST_BID_N_PRICE="b")`).
 * Only enable the services and exchanges that you need.
-* Use FIX API instead of REST API.
 * Handle events in ["batching" mode](#handle-events-in-immediate-vs-batching-mode) if your application (e.g. market data archiver) isn't latency sensitive.
 * Define macro `CCAPI_USE_SINGLE_THREAD`. It reduces locking overhead for single threaded applications.
 

example/CMakeLists.txt

@@ -83,3 +83,4 @@ add_subdirectory(src/fix_advanced)
 add_subdirectory(src/enable_library_logging)
 add_subdirectory(src/utility_set_timer)
 add_subdirectory(src/override_exchange_url_at_runtime)
+add_subdirectory(src/test_order_latency)

example/src/test_order_latency/CMakeLists.txt

@@ -0,0 +1,6 @@
+set(NAME test_order_latency)
+project(${NAME})
+add_compile_definitions(CCAPI_ENABLE_SERVICE_EXECUTION_MANAGEMENT)
+add_compile_definitions(CCAPI_ENABLE_EXCHANGE_OKX)
+add_executable(${NAME} main.cpp)
+add_dependencies(${NAME} boost rapidjson)

example/src/test_order_latency/main.cpp

@@ -0,0 +1,151 @@
+#include <atomic>
+
+#include "ccapi_cpp/ccapi_session.h"
+
+namespace ccapi {
+Logger* Logger::logger = nullptr;  // This line is needed.
+
+class MyEventHandler : public EventHandler {
+ public:
+  MyEventHandler(const std::string& symbol, const std::string& side, const std::string& quantity, const std::string& price, int clientOrderIdLength,
+                 bool cancelByClientOrderId, int numOrders)
+      : symbol(symbol),
+        side(side),
+        quantity(quantity),
+        price(price),
+        clientOrderIdLength(clientOrderIdLength),
+        cancelByClientOrderId(cancelByClientOrderId),
+        numOrders(numOrders) {}
+
+  bool processEvent(const Event& event, Session* sessionPtr) override {
+    if (event.getType() == Event::Type::SUBSCRIPTION_STATUS) {
+      const auto& message = event.getMessageList().at(0);
+      if (message.getType() == Message::Type::SUBSCRIPTION_STARTED) {
+        Request request(Request::Operation::GET_OPEN_ORDERS, "okx", this->symbol);
+        sessionPtr->sendRequest(request);
+      }
+    } else if (event.getType() == Event::Type::RESPONSE) {
+      const auto& message = event.getMessageList().at(0);
+      if (message.getType() == Message::Type::GET_OPEN_ORDERS) {
+        for (int i = 0; i < this->numOrders; ++i) {
+          sessionPtr->setTimer(
+              std::to_string(i), 100 * i,
+              [](const boost::system::error_code&) {
+                std::cout << std::string("Timer error handler is triggered at ") + UtilTime::getISOTimestamp(UtilTime::now()) << std::endl;
+              },
+              [this, sessionPtr]() {
+                Request request(Request::Operation::CREATE_ORDER, "okx", this->symbol);
+                const auto& clientOrderId = UtilString::generateRandomString(this->clientOrderIdLength);
+                request.appendParam({
+                    {"SIDE", UtilString::toUpper(this->side)},
+                    {"LIMIT_PRICE", this->price},
+                    {"QUANTITY", this->quantity},
+                    {"CLIENT_ORDER_ID", clientOrderId},
+                });
+                this->orderCreateTimes.emplace(clientOrderId, UtilTime::now());
+                sessionPtr->sendRequest(request);
+              });
+        }
+      }
+    } else if (event.getType() == Event::Type::SUBSCRIPTION_DATA) {
+      const auto& message = event.getMessageList().at(0);
+      if (message.getType() == Message::Type::EXECUTION_MANAGEMENT_EVENTS_ORDER_UPDATE) {
+        const auto& now = UtilTime::now();
+        const auto& element = message.getElementList().front();
+        const auto& orderId = element.getValue("ORDER_ID");
+        const auto& clientOrderId = element.getValue("CLIENT_ORDER_ID");
+        const auto& status = element.getValue("STATUS");
+        if (status == "live") {
+          this->orderCreateLatencies.push_back(now - this->orderCreateTimes.at(clientOrderId));
+          this->orderCreateTimes.erase(clientOrderId);
+          Request request(Request::Operation::CANCEL_ORDER, "okx", this->symbol);
+          if (this->cancelByClientOrderId) {
+            request.appendParam({
+                {"CLIENT_ORDER_ID", clientOrderId},
+            });
+          } else {
+            request.appendParam({
+                {"ORDER_ID", orderId},
+            });
+          }
+          this->orderCancelTimes.emplace(clientOrderId, now);
+          sessionPtr->sendRequest(request);
+        } else if (status == "canceled") {
+          this->orderCancelLatencies.push_back(now - this->orderCancelTimes.at(clientOrderId));
+          this->orderCancelTimes.erase(clientOrderId);
+          ++this->numCanceledOrders;
+          if (this->numCanceledOrders == this->numOrders) {
+            done = true;
+          }
+        }
+      }
+    }
+    return true;
+  }
+
+  std::string symbol;
+  std::string side;
+  std::string quantity;
+  std::string price;
+  int clientOrderIdLength{};
+  bool cancelByClientOrderId{};
+  int numOrders{};
+
+  std::map<std::string, TimePoint> orderCreateTimes;
+  std::vector<std::chrono::nanoseconds> orderCreateLatencies;
+  std::map<std::string, TimePoint> orderCancelTimes;
+  std::vector<std::chrono::nanoseconds> orderCancelLatencies;
+
+  int numCanceledOrders{};
+  std::atomic<bool> done{};
+};
+} /* namespace ccapi */
+
+using ::ccapi::MyEventHandler;
+using ::ccapi::Request;
+using ::ccapi::Session;
+using ::ccapi::SessionConfigs;
+using ::ccapi::SessionOptions;
+using ::ccapi::Subscription;
+using ::ccapi::UtilSystem;
+
+int main(int argc, char** argv) {
+  if (UtilSystem::getEnvAsString("OKX_API_KEY").empty()) {
+    std::cerr << "Please set environment variable OKX_API_KEY" << std::endl;
+    return EXIT_FAILURE;
+  }
+  if (UtilSystem::getEnvAsString("OKX_API_SECRET").empty()) {
+    std::cerr << "Please set environment variable OKX_API_SECRET" << std::endl;
+    return EXIT_FAILURE;
+  }
+  if (UtilSystem::getEnvAsString("OKX_API_PASSPHRASE").empty()) {
+    std::cerr << "Please set environment variable OKX_API_PASSPHRASE" << std::endl;
+    return EXIT_FAILURE;
+  }
+  const auto& symbol = UtilSystem::getEnvAsString("SYMBOL");
+  const auto& side = UtilSystem::getEnvAsString("SIDE");
+  const auto& quantity = UtilSystem::getEnvAsString("QUANTITY");
+  const auto& price = UtilSystem::getEnvAsString("PRICE");
+  const auto& clientOrderIdLength = UtilSystem::getEnvAsInt("CLIENT_ORDER_ID_LENGTH", 4);
+  const auto& cancelByClientOrderId = UtilSystem::getEnvAsBool("CANCEL_BY_CLIENT_ORDER_ID");
+  const auto& numOrders = UtilSystem::getEnvAsInt("NUM_ORDERS", 10);
+  SessionOptions sessionOptions;
+  SessionConfigs sessionConfigs;
+  MyEventHandler eventHandler(symbol, side, quantity, price, clientOrderIdLength, cancelByClientOrderId, numOrders);
+  Session session(sessionOptions, sessionConfigs, &eventHandler);
+  Subscription subscription("okx", symbol, "ORDER_UPDATE");
+  session.subscribe(subscription);
+  while (!eventHandler.done) {
+    std::this_thread::sleep_for(std::chrono::seconds(1));
+  }
+  session.stop();
+  double avgCreateLatencyMs =
+      std::accumulate(eventHandler.orderCreateLatencies.begin(), eventHandler.orderCreateLatencies.end(), std::chrono::nanoseconds{0}).count() / 1e6 /
+      eventHandler.orderCreateLatencies.size();
+  std::cout << "avgCreateLatencyMs = " << avgCreateLatencyMs << " for " << eventHandler.orderCreateLatencies.size() << " orders" << std::endl;
+  double avgCancelLatencyMs =
+      std::accumulate(eventHandler.orderCancelLatencies.begin(), eventHandler.orderCancelLatencies.end(), std::chrono::nanoseconds{0}).count() / 1e6 /
+      eventHandler.orderCancelLatencies.size();
+  std::cout << "avgCancelLatencyMs = " << avgCancelLatencyMs << " for " << eventHandler.orderCancelLatencies.size() << " orders" << std::endl;
+  return EXIT_SUCCESS;
+}

format_cpp.sh

@@ -1,2 +1,2 @@
 #!/usr/bin/env bash
-find . -type f -not -path "*/build/*" -not -name "ccapi_hmac.h" \( -name "*.h" -or -name "*.cpp" -or -name "*.hpp" \) -exec clang-format -i -style=file {} \+
+find . -type f -not -path "*/build/*" \( -name "*.h" -or -name "*.cpp" -or -name "*.hpp" \) -exec clang-format -i -style=file {} \+

include/ccapi_cpp/ccapi_decimal.h

@@ -10,7 +10,7 @@ namespace ccapi {
  * This class provides a numeric type for representing an arbitrary precision decimal number. It is minimalistic for the purpose of high performance.
  * Furthermore, unlike double, it is suitable for being used as the key of a map.
  */
-class Decimal CCAPI_FINAL {
+class Decimal {
  public:
   Decimal() {}
 

include/ccapi_cpp/ccapi_element.h

@@ -10,7 +10,7 @@ namespace ccapi {
  * Element represents an item in a message. The value(s) in an Element can be queried in a number of ways. Use the getValue() functions to retrieve a single
  * value. Use the getNameValueMap() function (or getTagValueMap() function for FIX API) to retrieve all the values.
  */
-class Element CCAPI_FINAL {
+class Element {
  public:
   explicit Element(bool isFix = false) : isFix(isFix) {}
 

include/ccapi_cpp/ccapi_event.h

@@ -12,7 +12,7 @@ namespace ccapi {
 *event. The event is the basic unit of work provided to applications. Each Event object consists of an Type attribute and zero or more Message objects.
 */
 
-class Event CCAPI_FINAL {
+class Event {
  public:
   enum class Type {
     UNKNOWN,

include/ccapi_cpp/ccapi_event_dispatcher.h

@@ -20,7 +20,7 @@ namespace ccapi {
  * more internal threads for one or more sessions.
  */
 
-class EventDispatcher CCAPI_FINAL {
+class EventDispatcher {
  public:
   explicit EventDispatcher(const int numDispatcherThreads = 1) : numDispatcherThreads(numDispatcherThreads) {
     CCAPI_LOGGER_FUNCTION_ENTER;