C++高频量化交易系统架构设计与性能优化实战

1次阅读

共计 4381 个字符，预计需要花费 11 分钟才能阅读完成。

高频量化交易系统面临的核心挑战在于极致的性能要求。在这样一个环境中，微秒级的延迟差异就可能决定交易的成败。系统需要处理每秒数百万笔订单，同时保持亚微秒级的响应时间。这要求我们在架构设计的每一个环节都必须精心优化，从内存管理到网络通信，再到订单匹配算法。

C++：
优势：直接内存访问、零成本抽象、高性能
劣势：开发复杂度高，需要手动管理内存
Java：
优势：开发效率高，垃圾回收
劣势：GC 停顿不可控，JVM 开销

TCP：
优势：可靠传输，有序交付
劣势：协议开销大，延迟高
UDP：
优势：低延迟，低开销
劣势：需要自行处理丢包和乱序

为了避免频繁的动态内存分配导致的性能下降，我们实现了一个高效的内存池：

class MemoryPool {
private:
    struct Block {Block* next;};

    Block* freeList;
    size_t blockSize;
    std::vector<void*> chunks;

public:
    MemoryPool(size_t blockSize, size_t initialCount)
        : blockSize(blockSize), freeList(nullptr) {expandPool(initialCount);
    }

    void* allocate() {if (!freeList) {expandPool(100); // 按需扩展
        }

        Block* block = freeList;
        freeList = freeList->next;
        return block;
    }

    void deallocate(void* ptr) {Block* block = static_cast<Block*>(ptr);
        block->next = freeList;
        freeList = block;
    }

private:
    void expandPool(size_t count) {void* chunk = ::operator new(blockSize * count);
        chunks.push_back(chunk);

        for (size_t i = 0; i < count; ++i) {Block* block = static_cast<Block*>(static_cast<char*>(chunk) + i * blockSize);
            block->next = freeList;
            freeList = block;
        }
    }
};

使用 C ++ 原子操作实现高效的无锁队列：

template<typename T>
class LockFreeQueue {
private:
    struct Node {
        T data;
        std::atomic<Node*> next;

        Node(const T& data) : data(data), next(nullptr) {}};

    std::atomic<Node*> head;
    std::atomic<Node*> tail;

public:
    LockFreeQueue() {Node* dummy = new Node(T{});
        head.store(dummy);
        tail.store(dummy);
    }

    void enqueue(const T& data) {Node* newNode = new Node(data);
        Node* currentTail;
        Node* tailNext;

        while (true) {currentTail = tail.load(std::memory_order_acquire);
            tailNext = currentTail->next.load(std::memory_order_acquire);

            if (currentTail == tail.load(std::memory_order_relaxed)) {if (tailNext == nullptr) {
                    if (currentTail->next.compare_exchange_weak(tailNext, newNode, std::memory_order_release)) {break;}
                } else {
                    tail.compare_exchange_weak(currentTail, tailNext, std::memory_order_release);
                }
            }
        }

        tail.compare_exchange_weak(currentTail, newNode, std::memory_order_release);
    }

    bool dequeue(T& result) {
        Node* currentHead;
        Node* currentTail;
        Node* next;

        while (true) {currentHead = head.load(std::memory_order_acquire);
            currentTail = tail.load(std::memory_order_acquire);
            next = currentHead->next.load(std::memory_order_acquire);

            if (currentHead == head.load(std::memory_order_relaxed)) {if (currentHead == currentTail) {if (next == nullptr) {return false; // 队列为空}
                    tail.compare_exchange_weak(currentTail, next, std::memory_order_release);
                } else {
                    result = next->data;
                    if (head.compare_exchange_weak(currentHead, next, std::memory_order_release)) {break;}
                }
            }
        }

        delete currentHead;
        return true;
    }
};

内核旁路技术：
使用 DPDK 或 RDMA 绕过内核网络协议栈
直接访问网卡缓冲区，减少数据拷贝
组播通信：
交易所行情通常通过组播发布
使用 IGMP 加入组播组
绑定到特定核心处理组播流量
网络接口配置：
禁用 NIC offloading 功能
调整中断亲和性
使用巨帧减少协议开销

class OrderBook {
private:
    using PriceLevel = std::map<Price, std::list<Order>>;

    PriceLevel bids;
    PriceLevel asks;
    std::unordered_map<OrderId, Order> orders;

public:
    void addOrder(const Order& order) {orders[order.id] = order;

        if (order.side == Side::Buy) {bids[order.price].push_back(order);
        } else {asks[order.price].push_back(order);
        }

        matchOrders();}

    void cancelOrder(OrderId id) {auto it = orders.find(id);
        if (it == orders.end()) return;

        Order& order = it->second;
        auto& level = order.side == Side::Buy ? bids : asks;

        auto levelIt = level.find(order.price);
        if (levelIt != level.end()) {
            auto& ordersAtLevel = levelIt->second;
            ordersAtLevel.remove_if([id](const Order& o) {return o.id == id;});

            if (ordersAtLevel.empty()) {level.erase(levelIt);
            }
        }

        orders.erase(it);
    }

private:
    void matchOrders() {while (!bids.empty() && !asks.empty()) {auto bestBid = bids.rbegin();
            auto bestAsk = asks.begin();

            if (bestBid->first < bestAsk->first) break;

            auto& bidOrders = bestBid->second;
            auto& askOrders = bestAsk->second;

            Order& bid = bidOrders.front();
            Order& ask = askOrders.front();

            Quantity matchQty = std::min(bid.remaining, ask.remaining);
            Price matchPrice = ask.price; // 价格优先

            // 执行撮合
            bid.remaining -= matchQty;
            ask.remaining -= matchQty;

            if (bid.remaining == 0) {bidOrders.pop_front();
                orders.erase(bid.id);
            }

            if (ask.remaining == 0) {askOrders.pop_front();
                orders.erase(ask.id);
            }

            if (bidOrders.empty()) {bids.erase(bestBid->first);
            }

            if (askOrders.empty()) {asks.erase(bestAsk->first);
            }
        }
    }
};

我们在以下环境中进行了测试：