低延迟交易系统架构

// 用 rdtsc 做低开销计时（注意频率校准）
static inline uint64_t rdtsc() {
    uint32_t lo, hi;
    __asm__ __volatile__("rdtsc" : "=a"(lo), "=d"(hi));
    return ((uint64_t)hi << 32) | lo;
}

void on_tick(const Tick& t) {
    uint64_t t0 = rdtsc();
    process(t);
    uint64_t t1 = rdtsc();
    // 累积直方图，而不是平均值
    latency_hist_.record((t1 - t0) * ns_per_cycle_);
}

// ef_vi 风格的收包循环（简化）
while (running) {
    int n = ef_eventq_poll(vi, events, MAX_EVENTS);
    for (int i = 0; i < n; ++i) {
        if (events[i].type == EF_EVENT_TYPE_RX) {
            const uint8_t* pkt = ef_vi_receive_buffer(vi, &events[i]);
            uint64_t hw_ts = ef_vi_receive_get_timestamp(vi, &events[i]);
            on_packet(pkt, hw_ts);      // 处理
            ef_vi_receive_post(vi, buf); // 归还缓冲区
        }
    }
}

1. 零拷贝：网卡 DMA 直接写到应用缓冲区，不做内存复制
2. 忙轮询：不睡眠，持续 poll，牺牲 CPU 换取低延迟
3. 批量处理：一次收多个包，摊薄系统调用开销
4. 无中断：关闭网卡中断，完全靠轮询

void busy_poll_loop() {
    pin_to_core(3);              // 绑定到独占核
    while (running) {
        int n = rx_ring.poll(batch, BATCH_SIZE);
        if (n == 0) continue;    // 空转，不睡眠
        for (int i = 0; i < n; ++i) handle(batch[i]);
    }
}

isolcpus=2,3,4,5,6,7 nohz_full=2,3,4,5,6,7 rcu_nocbs=2,3,4,5,6,7   # 内核启动参数

template <typename T, size_t N>
class SpscQueue {
    static_assert((N & (N - 1)) == 0, "N must be power of 2");
    alignas(64) std::atomic<size_t> head_{0};   // 生产者索引
    alignas(64) std::atomic<size_t> tail_{0};   // 消费者索引
    alignas(64) T buffer_[N];

public:
    bool push(const T& v) {
        size_t h = head_.load(std::memory_order_relaxed);
        size_t next = (h + 1) & (N - 1);
        if (next == tail_.load(std::memory_order_acquire)) return false;  // 满
        buffer_[h] = v;
        head_.store(next, std::memory_order_release);
        return true;
    }

    bool pop(T& v) {
        size_t t = tail_.load(std::memory_order_relaxed);
        if (t == head_.load(std::memory_order_acquire)) return false;     // 空
        v = buffer_[t];
        tail_.store((t + 1) & (N - 1), std::memory_order_release);
        return true;
    }
};

cat /sys/class/net/eth0/device/numa_node            # 查看网卡所在 NUMA 节点
numactl --cpunodebind=0 --membind=0 ./trading_app   # 绑定进程到对应节点

// 紧凑的价格档位：8 字节
struct alignas(8) PriceLevel {
    int32_t price_ticks;   // 价格以 tick 为单位（整数）
    int32_t qty;           // 数量
};
// 对比：用 double 价格 + int64 数量 = 16 字节，缓存效率减半

// 共享内存布局：环形队列 + 事件标志
struct SharedChannel {
    alignas(64) std::atomic<uint64_t> seq{0};
    alignas(64) char data[SLOT_SIZE];
    // 生产者写入后递增 seq，消费者自旋等待 seq 变化
};

1. 启动时预分配所有内存（预热）
2. 运行时零分配（no allocation on hot path）
3. 用对象池/竞技场（arena）代替 malloc/free

class OrderPool {
    std::vector<Order> storage_;          // 预分配
    std::vector<Order*> free_list_;
public:
    OrderPool(size_t n) : storage_(n) {
        free_list_.reserve(n);
        for (auto& o : storage_) free_list_.push_back(&o);
    }
    Order* acquire() {
        if (free_list_.empty()) return nullptr;   // 不分配，返回空
        Order* o = free_list_.back();
        free_list_.pop_back();
        return o;
    }
    void release(Order* o) { free_list_.push_back(o); }
};

mlockall(MCL_CURRENT | MCL_FUTURE);   // 禁止换页

[网卡 PHY] → [包解析] → [订单簿更新] → [策略逻辑] → [风控] → [报单生成] → [MAC]
    ↑ 全部在 FPGA 内的流水线上，单周期推进

pmc -u -b 0 'GET TIME_STATUS_NP'   # 查看 PTP 同步状态，master_offset 应在 ±100ns 内

class LatencyHistogram {
    static constexpr int BUCKETS = 1000;   // 0~100 μs，0.1 μs 一档
    std::array<uint64_t, BUCKETS> counts_{};
    uint64_t total_{0};
public:
    void record(uint64_t ns) {
        size_t idx = std::min<size_t>(ns / 100, BUCKETS - 1);
        counts_[idx]++;
        total_++;
    }
    uint64_t percentile(double p) const {
        uint64_t target = static_cast<uint64_t>(total_ * p);
        uint64_t acc = 0;
        for (size_t i = 0; i < BUCKETS; ++i) {
            acc += counts_[i];
            if (acc >= target) return i * 100;
        }
        return BUCKETS * 100;
    }
};