撮合引擎设计

输入：NewOrder / CancelOrder / ModifyOrder（来自参与者）
输出：OrderAccepted / OrderRejected / Trade / OrderCancelled（回报）
状态：订单簿（Order Book）+ 订单表（Order Table）

1. 买单出价高的优先成交
2. 卖单要价低的优先成交
3. 同价格的，先报单的优先成交（时间优先）

def match(book, incoming):
    trades = []
    if incoming.side == 'BUY':
        while incoming.qty > 0 and book.asks:   # 买单与卖盘撮合，从最低卖价起
            best_ask_price = min(book.asks)
            if incoming.price < best_ask_price:
                break                      # 无法成交，挂入买盘
            level = book.asks[best_ask_price]
            while level and incoming.qty > 0:
                maker = level[0]           # FIFO，最早的单先成交
                qty = min(incoming.qty, maker.qty)
                trades.append(Trade(price=best_ask_price, qty=qty,
                                    buyer=incoming.id, seller=maker.id))
                incoming.qty -= qty
                maker.qty -= qty
                if maker.qty == 0:
                    level.popleft()
            if not level:
                del book.asks[best_ask_price]
    if incoming.qty > 0:      # 未成交部分挂入订单簿
        book.add(incoming)
    return trades

// 价格档位数组：价格范围 [min_price, max_price]，每 tick 一个槽位
template <size_t MAX_TICKS>
class PriceLevelArray {
    struct Level {
        int64_t total_qty{0};
        Order* head{nullptr};   // FIFO 队列头
        Order* tail{nullptr};
    };
    std::array<Level, MAX_TICKS> levels_;
    int32_t best_bid_idx_{-1};
    int32_t best_ask_idx_{-1};

public:
    // 价格 → 数组下标，O(1) 寻址
    static size_t to_index(int64_t price_ticks) { return price_ticks; }

    void add_order(Order* o) {
        auto& lv = levels_[to_index(o->price_ticks)];
        if (lv.tail) { lv.tail->next = o; o->prev = lv.tail; }
        else { lv.head = o; o->prev = nullptr; }
        lv.tail = o;
        o->next = nullptr;
        lv.total_qty += o->qty;
    }
};

struct Order {
    uint64_t order_id;
    uint64_t account_id;
    int64_t  price_ticks;
    int64_t  qty;
    int64_t  filled;
    Order*   next;          // FIFO 链表
    Order*   prev;
    uint8_t  side;
    uint8_t  type;
    // ... 共 64 字节，正好一个缓存行
};
static_assert(sizeof(Order) == 64, "Order must fit in one cache line");

class OrderIndex {
    static constexpr size_t CAP = 1 << 20;   // 100 万订单
    std::array<Order*, CAP> slots_{};
    static size_t hash(uint64_t id) { return (id * 0x9E3779B97F4A7C15ULL) >> 44; }
public:
    Order* find(uint64_t id) {
        size_t i = hash(id);
        while (slots_[i] && slots_[i]->order_id != id) i = (i + 1) & (CAP - 1);
        return slots_[i];
    }
    void insert(Order* o) {
        size_t i = hash(o->order_id);
        while (slots_[i]) i = (i + 1) & (CAP - 1);
        slots_[i] = o;
    }
};

1. 确定性：单线程天然保证同样的输入产生同样的输出
2. 无锁：不需要任何同步原语，没有竞争开销
3. 简单：状态机简单，容易验证正确性

         ┌──────────────┐
订单流 ──►│ 路由（按 symbol 哈希）│
         └──────┬───────┘
      ┌─────────┼─────────┐
      ▼         ▼         ▼
   [线程 0]  [线程 1]  [线程 2]
   600519    000001    300750
   订单簿     订单簿     订单簿

1. 重放验证：用同一份订单日志重放，结果必须完全一致
2. 快速恢复：崩溃后重放日志即可恢复订单簿状态

struct JournalEntry {
    uint64_t seq;          // 单调递增序号
    uint64_t timestamp_ns; // 处理时刻
    uint8_t  type;         // NEW / CANCEL / MODIFY
    Order    order;        // 订单内容
};

class Journal {
    int fd_;                // O_APPEND | O_DSYNC
public:
    void append(const JournalEntry& e) {
        // 先写日志再改内存（write-ahead log）
        ::write(fd_, &e, sizeof(e));
    }
};

恢复流程：
1. 加载最近的内存快照（如每 100 万条订单做一次快照）
2. 从快照对应的 seq 开始重放日志
3. 重放到最后一条，状态恢复完成

// Disruptor 风格：预分配事件对象，只更新内容不创建新对象
public final class OrderEvent {
    long orderId;
    long price;
    long qty;
    byte side;
}

// 生产者：申请序号 → 写入 → 发布
long seq = ringBuffer.next();
OrderEvent e = ringBuffer.get(seq);
e.orderId = id; e.price = px; e.qty = qty; e.side = side;
ringBuffer.publish(seq);

// 消费者：等待序号可用 → 处理
long nextSeq = sequenceBarrier.waitFor(cursor + 1);
for (long i = cursor + 1; i <= nextSeq; i++) {
    process(ringBuffer.get(i));
}

def call_auction_price(orders):
    candidates = sorted({o.price for o in orders})   # 候选价格 = 所有订单价格
    best_price, best_volume = None, -1
    for p in candidates:
        buy_vol = sum(o.qty for o in orders if o.side == 'BUY' and o.price >= p)
        sell_vol = sum(o.qty for o in orders if o.side == 'SELL' and o.price <= p)
        volume = min(buy_vol, sell_vol)
        if volume > best_volume:
            best_volume, best_price = volume, p
    return best_price, best_volume

1. 稳态负载：持续均匀的订单流
2. 突发负载：开盘瞬间的订单洪峰（可达稳态的 100 倍）
3. 极端场景：涨停板时的巨量挂单与撤单

def capacity_plan(daily_orders, peak_ratio=50, safety=3, trading_seconds=14400):
    avg_tps = daily_orders / trading_seconds
    peak_tps = avg_tps * peak_ratio
    return {
        'avg_tps': avg_tps,
        'peak_tps': peak_tps,
        'design_tps': peak_tps * safety,
    }

print(capacity_plan(5e7))   # 日均 5000 万单