返回题库

事件驱动策略回测器

Event Driven Strategy Backtester

专题
Systems & Architecture / 系统与架构
难度
L4
来源
MyntBit

题目详情

事件驱动回测是量化研究的基础组件，允许从业者按时间顺序对历史行情模拟订单执行。通过维护内部撮合引擎执行价格-时间优先规则，防止前瞻偏差。

任务：实现事件驱动回测器类，按时间顺序处理行情事件和订单事件。维护内部订单簿和撮合引擎，确保策略决策仅基于已发生事件。输出成交记录和累计盈亏。

英文原题

Event-driven backtesting is a foundational component of quantitative research, allowing practitioners to simulate order executions against historical market data chronologically. By maintaining an internal matching engine that enforces price-time priority and volume constraints, backtesters provide realistic estimates of strategy performance and liquidity impact.
Task
Implement an event-driven backtester that processes a chronological sequence of Market Data updates, Limit Orders, and Cancel re

解析

问题分析

事件驱动回测引擎模拟真实市场的事件序列（行情更新、订单成交、定时器触发），相比向量化回测能更准确地建模延迟、订单队列位置和市场冲击。核心组件包括事件队列、时钟管理和回调注册机制。

实现

enum EventType { MARKET_DATA, ORDER_FILL, TIMER, SIGNAL };

struct Event {
    EventType type;
    std::chrono::nanoseconds timestamp;
    std::any payload;
    bool operator>(const Event& o) const { return timestamp > o.timestamp; }
};

class EventDrivenBacktester {
    std::priority_queue<Event, std::vector<Event>, std::greater<Event>> queue_;
    std::unordered_map<EventType, std::vector<std::function<void(Event&)>>> handlers_;
    std::chrono::nanoseconds clock_{0};
public:
    void schedule(Event e) { queue_.push(e); }
    void on(EventType t, std::function<void(Event&)> h) { handlers_[t].push_back(h); }
    
    void run(std::chrono::nanoseconds until) {
        while (!queue_.empty() && queue_.top().timestamp <= until) {
            auto e = queue_.top(); queue_.pop();
            clock_ = e.timestamp;
            for (auto& h : handlers_[e.type]) h(e);
        }
    }
};

复杂度与边界

  • 时间复杂度：每个事件 O(log N) 入队 + O(1) 分发
  • 空间复杂度：O(待处理事件数)
  • 边界条件：(1) 空事件队列正常退出 (2) 同时间戳事件按入队顺序处理 (3) 事件处理器异常不应中断整个回测

英文解析

Analysis

Event-driven backtesting engines simulate real market event sequences (market data updates, order fills, timer triggers). Compared to vectorized backtesting, they more accurately model latency, order queue positions, and market impact. Core components include an event queue, clock management, and callback registration.

Solution

enum EventType { MARKET_DATA, ORDER_FILL, TIMER, SIGNAL };

struct Event {
    EventType type;
    std::chrono::nanoseconds timestamp;
    std::any payload;
    bool operator>(const Event& o) const { return timestamp > o.timestamp; }
};

class EventDrivenBacktester {
    std::priority_queue<Event, std::vector<Event>, std::greater<Event>> queue_;
    std::unordered_map<EventType, std::vector<std::function<void(Event&)>>> handlers_;
    std::chrono::nanoseconds clock_{0};
public:
    void schedule(Event e) { queue_.push(e); }
    void on(EventType t, std::function<void(Event&)> h) { handlers_[t].push_back(h); }
    
    void run(std::chrono::nanoseconds until) {
        while (!queue_.empty() && queue_.top().timestamp <= until) {
            Event e = queue_.top(); queue_.pop();
            clock_ = e.timestamp;
            for (auto& h : handlers_[e.type]) h(e);
        }
    }
};

Complexity & Edge Cases

  • Time complexity: O(N) for N events processed sequentially; O(N log N) for event sorting by timestamp
  • Space complexity: O(N) for event queue storage
  • Edge cases: (1) Missing events in sequence produce incomplete portfolio state. (2) Simulated order fills must respect venue latency assumptions. (3) Event timestamp ordering must handle microsecond-resolution clock skew.

Key Considerations

  1. Simulation accuracy: Event-driven models execution latency and queue position more precisely than vectorized approaches.
  2. Priority queue ordering: Events processed in timestamp order ensures causal consistency.
  3. Callback registration: Handlers must not schedule events with timestamps before the current clock.
  4. Time complexity: O(log N) per event scheduling; O(handlers) per event processing.