交易系统的OMS、EMS、PMS、RMS¶
OMS - 订单管理系统 (Order Management System)
OMS负责管理订单的完整生命周期。
- 订单创建与管理：接收并管理来自交易策略或用户的订单请求
- 订单状态跟踪：实时跟踪订单的状态变化（新订单、部分成交、全部成交、已取消、已拒绝等）
- 订单簿维护：维护所有订单的历史记录和当前状态
- 订单查询：提供高效的订单查询接口，支持通过订单ID或客户端订单ID查询
- 订单生命周期管理：处理订单的创建、修改、取消等操作
核心数据结构
// 订单状态
enum class OrderStatus : uint8_t {
NEW = 0, // 新订单
PARTIALLY_FILLED = 1, // 部分成交
FILLED = 2, // 全部成交
CANCELLED = 3, // 已取消
REJECTED = 4 // 已拒绝
};
// 订单结构
struct Order {
OrderId order_id; // 订单ID
SymbolId symbol_id; // 交易对ID
Side side; // 买入/卖出
OrderType order_type; // 订单类型（市价单、限价单等）
OrderStatus status; // 订单状态
Quantity quantity; // 订单数量
Quantity filled_quantity; // 已成交数量
Price limit_price; // 限价
Timestamp created_at; // 创建时间
Timestamp updated_at; // 更新时间
std::string symbol; // 交易对名称
std::string client_order_id; // 客户端订单ID
bool is_filled() const {
return status == OrderStatus::FILLED || filled_quantity >= quantity;
}
bool is_active() const {
return status == OrderStatus::NEW ||
status == OrderStatus::PARTIALLY_FILLED;
}
};
核心代码
订单簿（OrderBook）
class OrderBook {
public:
// 添加订单到订单簿
OrderId add_order(std::unique_ptr<Order> order) {
OrderId id = next_order_id_.fetch_add(1);
if (id >= MAX_ORDERS) return 0;
Order* order_ptr = order.release();
Order* expected = nullptr;
if (!orders_[id].order.compare_exchange_weak(expected, order_ptr,
std::memory_order_release,
std::memory_order_relaxed)) {
delete order_ptr;
return 0;
}
return id;
}
// 根据订单ID获取订单
Order* get_order(OrderId order_id) const {
if (order_id >= MAX_ORDERS) return nullptr;
return orders_[id].order.load(std::memory_order_acquire);
}
// 更新订单的成交数量
bool update_filled_quantity(OrderId order_id, Quantity filled_qty) {
if (order_id >= MAX_ORDERS) return false;
Order* order = orders_[order_id].order.load(std::memory_order_acquire);
if (!order) return false;
order->filled_quantity = filled_qty;
order->updated_at = now_ns();
if (filled_qty >= order->quantity) {
order->status = OrderStatus::FILLED;
} else if (filled_qty > 0) {
order->status = OrderStatus::PARTIALLY_FILLED;
}
return true;
}
// 取消订单
bool cancel_order(OrderId order_id) {
if (order_id >= MAX_ORDERS) return false;
Order* order = orders_[order_id].order.load(std::memory_order_acquire);
if (!order) return false;
if (!order->is_active()) return false;
order->status = OrderStatus::CANCELLED;
order->updated_at = now_ns();
return true;
}
private:
std::vector<OrderSlot> orders_; // 订单存储数组
std::atomic<OrderId> next_order_id_;
};
订单管理器（OrderManager）
class OrderManager {
public:
// 提交新订单
OrderId submit_order(SymbolId symbol_id, const std::string& symbol, Side side,
OrderType order_type, Quantity quantity,
Price limit_price = 0) {
// 创建订单对象
auto order = std::make_unique<Order>(symbol_id, side, order_type, quantity,
limit_price);
order->symbol = symbol;
// 添加到订单簿
OrderId order_id = order_book_.add_order(std::move(order));
// 触发状态回调通知
if (status_callback_) {
auto* order_ptr = order_book_.get_order(order_id);
if (order_ptr) {
status_callback_(order_id, OrderStatus::NEW, order_ptr);
}
}
return order_id;
}
// 取消订单
bool cancel_order(OrderId order_id) {
bool cancelled = order_book_.cancel_order(order_id);
if (cancelled && status_callback_) {
auto* order = order_book_.get_order(order_id);
if (order) {
status_callback_(order_id, OrderStatus::CANCELLED, order);
}
}
return cancelled;
}
// 处理成交（由EMS调用）
void on_fill(const Fill& fill) {
auto* order = order_book_.get_order(fill.order_id);
if (!order) return;
// 更新订单的成交数量
Quantity new_filled = order->filled_quantity + fill.quantity;
order_book_.update_filled_quantity(fill.order_id, new_filled);
// 触发成交回调
if (fill_callback_) {
fill_callback_(fill.order_id, fill);
}
// 如果订单已完成，触发状态回调
order = order_book_.get_order(fill.order_id);
if (order && order->is_filled() && status_callback_) {
status_callback_(fill.order_id, OrderStatus::FILLED, order);
}
}
private:
OrderBook order_book_;
OrderStatusCallback status_callback_;
FillCallback fill_callback_;
};
OMS的业务流程
- 订单提交：交易策略或用户通过OrderManager提交订单，OMS创建订单并分配订单ID
- 订单状态管理：OMS跟踪订单状态，从NEW到FILLED/CANCELLED/REJECTED
- 成交处理：当EMS通知订单成交时，OMS更新订单的成交数量，并更新订单状态
- 订单查询：提供订单查询接口，支持实时查询订单状态和成交情况
- 订单取消：处理订单取消请求，更新订单状态为CANCELLED
EMS - 执行管理系统 (Execution Management System)
EMS负责将订单实际提交到交易所进行交易。
- 订单执行：接收来自OMS的订单，并将其提交到交易所执行
- 交易所对接：与交易所API接口对接，处理订单提交、取消等操作
- 智能路由：根据市场深度和订单类型，选择最优的执行策略（立即执行或挂单）
- 执行状态反馈：将订单执行结果（成交、拒绝等）反馈给OMS
- 异步处理：使用异步队列处理订单执行，提高系统吞吐量
核心代码
执行管理器（ExecutionManager）
执行管理器是EMS的核心组件，负责管理订单的执行流程。
class ExecutionManager {
public:
ExecutionManager(std::unique_ptr<ExchangeInterface> exchange,
OrderManager* order_manager,
PortfolioManager* portfolio_manager)
: exchange_(std::move(exchange)),
order_manager_(order_manager),
portfolio_manager_(portfolio_manager),
running_(false) {}
// 执行订单（非阻塞，放入执行队列）
void execute_order(OrderId order_id) {
{
std::lock_guard<std::mutex> lock(queue_mutex_);
execution_queue_.push(order_id);
}
cv_.notify_one();
}
// 智能路由：根据市场深度选择最优执行策略
bool smart_route_order(const Order& order) {
if (order.order_type != OrderType::LIMIT) {
// 市价单直接执行
return execute_order_immediate(order.order_id);
}
// 限价单需要检查市场深度
Price best_bid, best_ask;
Quantity bid_size, ask_size;
if (!exchange_->get_order_book(order.symbol_id, best_bid, best_ask,
bid_size, ask_size)) {
return false;
}
// 检查限价单是否可以立即成交
if (order.side == Side::BUY) {
// 买入限价单：如果限价 >= 卖一价，可以立即成交
if (order.limit_price >= best_ask) {
return execute_order_immediate(order.order_id);
}
} else {
// 卖出限价单：如果限价 <= 买一价，可以立即成交
if (order.limit_price <= best_bid) {
return execute_order_immediate(order.order_id);
}
}
// 限价单进入订单簿，提交到交易所
return exchange_->submit_order(order);
}
// 更新市场价格（由市场数据订阅者调用）
void update_market_price(SymbolId symbol_id, Price price) {
if (portfolio_manager_) {
portfolio_manager_->update_market_price(symbol_id, price);
}
}
private:
// 工作线程循环：处理执行队列中的订单
void worker_loop() {
while (running_.load()) {
std::unique_lock<std::mutex> lock(queue_mutex_);
cv_.wait(lock, [this] {
return !execution_queue_.empty() || !running_.load();
});
while (!execution_queue_.empty() && running_.load()) {
OrderId order_id = execution_queue_.front();
execution_queue_.pop();
lock.unlock();
process_order_by_id(order_id);
lock.lock();
}
}
}
// 处理单个订单
bool process_order(const Order& order) {
if (!order.is_active()) {
return false;
}
// 提交订单到交易所
bool submitted = exchange_->submit_order(order);
if (!submitted) {
order_manager_->on_order_rejected(order.order_id, "Exchange rejected");
return false;
}
// 对于市价单，模拟立即成交（实际场景中由交易所回调）
if (order.order_type == OrderType::MARKET) {
simulate_market_fill(order);
}
return true;
}
// 模拟市价单成交
void simulate_market_fill(const Order& order) {
// 获取市场价格
Price market_price = exchange_->get_market_price(order.symbol_id);
// 生成成交记录
Fill fill(order.order_id, order.symbol_id, order.side, order.quantity,
market_price, now_ns());
fill.symbol = order.symbol;
// 通知OMS更新订单状态
if (order_manager_) {
order_manager_->on_fill(fill);
}
// 通知PMS更新持仓
if (portfolio_manager_) {
portfolio_manager_->on_fill(fill);
}
}
private:
std::unique_ptr<ExchangeInterface> exchange_; // 交易所接口
OrderManager* order_manager_; // 订单管理器
PortfolioManager* portfolio_manager_; // 投资组合管理器
std::atomic<bool> running_;
std::thread worker_thread_;
std::queue<OrderId> execution_queue_; // 执行队列
std::mutex queue_mutex_;
std::condition_variable cv_;
};
EMS的业务流程
- 订单接收：从OMS接收待执行的订单
- 执行决策：根据订单类型和市场情况，决定立即执行还是挂单
- 订单提交：将订单提交到交易所
- 成交处理：接收交易所的成交通知，生成成交记录
- 状态反馈：将成交信息通知OMS和PMS，更新订单状态和持仓
EMS的执行策略
- 市价单：立即以当前市场价格执行，通常立即成交
- 限价单：如果价格满足条件（买入限价>=卖一价，卖出限价<=买一价），立即成交；否则挂单等待
- 智能路由：根据市场深度选择最优执行策略，平衡成交速度和价格
PMS - 投资组合管理系统 (Portfolio Management System)
PMS负责管理投资组合的状态和风险。
- 持仓管理：跟踪和管理所有持仓（多头和空头）
- 盈亏计算：实时计算已实现盈亏和未实现盈亏
- 资金管理：管理现金余额，跟踪总权益
- 风险控制：检查订单是否可执行（资金是否充足、持仓是否足够）
- 业绩分析：计算收益率、总盈亏等业绩指标
核心数据结构
// 持仓结构
struct Position {
SymbolId symbol_id; // 交易对ID
std::string symbol; // 交易对名称
Quantity quantity; // 持仓数量（正数为多头，负数为空头）
Price avg_cost_price; // 平均成本价
Price current_price; // 当前市场价格
Price unrealized_pnl; // 未实现盈亏
Price realized_pnl; // 已实现盈亏
Timestamp updated_at; // 最后更新时间
// 获取市值
Price market_value() const {
return multiply_price_quantity(current_price, quantity);
}
// 获取总盈亏
Price total_pnl() const { return realized_pnl + unrealized_pnl; }
};
核心代码
持仓（Position）
struct Position {
SymbolId symbol_id;
std::string symbol;
Quantity quantity; // 持仓数量
Price avg_cost_price; // 平均成本价
Price current_price; // 当前价格
Price unrealized_pnl; // 未实现盈亏
Price realized_pnl; // 已实现盈亏
// 更新持仓（成交后调用）
void update_on_fill(Quantity fill_qty, Price fill_price, Side side) {
bool is_buy = (side == Side::BUY);
Quantity signed_qty = is_buy ? fill_qty : -fill_qty;
if (quantity == 0) {
// 新开仓
quantity = signed_qty;
avg_cost_price = fill_price;
} else if ((quantity > 0 && signed_qty > 0) ||
(quantity < 0 && signed_qty < 0)) {
// 加仓：重新计算平均成本价
Price old_cost = quantity * avg_cost_price;
quantity += signed_qty;
avg_cost_price = (old_cost + fill_qty * fill_price) / quantity;
} else {
// 减仓或反向开仓：计算已实现盈亏
Quantity old_qty = quantity;
quantity += signed_qty;
if (quantity == 0) {
// 平仓：计算已实现盈亏
Quantity closed_qty = std::abs(old_qty);
Price pnl = closed_qty * (fill_price - avg_cost_price);
realized_pnl += (old_qty > 0) ? pnl : -pnl;
avg_cost_price = 0;
} else {
// 部分平仓
Quantity closed_qty = std::abs(signed_qty);
Price pnl = closed_qty * (fill_price - avg_cost_price);
realized_pnl += (old_qty > 0) ? pnl : -pnl;
}
}
update_unrealized_pnl();
}
// 更新未实现盈亏
void update_unrealized_pnl() {
if (quantity == 0 || current_price == 0) {
unrealized_pnl = 0;
return;
}
Price current_value = multiply_price_quantity(current_price, quantity);
Price cost_value = multiply_price_quantity(avg_cost_price, quantity);
unrealized_pnl = current_value - cost_value;
}
// 更新市场价格
void update_market_price(Price price) {
current_price = price;
update_unrealized_pnl();
updated_at = now_ns();
}
};
投资组合管理器（PortfolioManager）
class PortfolioManager {
public:
PortfolioManager(Quantity initial_capital = 0)
: initial_capital_(initial_capital),
total_equity_(initial_capital),
cash_(initial_capital) {}
// 更新成交（来自EMS）
void on_fill(const Fill& fill) {
// 获取或创建持仓
Position& pos = get_or_create_position(fill.symbol_id, fill.symbol);
// 更新持仓
pos.update_on_fill(fill.quantity, fill.price, fill.side);
// 更新现金（买入减去现金，卖出增加现金）
Price cash_value = multiply_price_quantity(fill.price, fill.quantity);
Price cash_change = (fill.side == Side::BUY) ? -cash_value : cash_value;
Quantity old_cash = cash_.load(std::memory_order_relaxed);
cash_.store(old_cash + cash_change, std::memory_order_relaxed);
// 重新计算总权益
recalculate_equity();
}
// 更新市场价格
void update_market_price(SymbolId symbol_id, Price price) {
auto it = positions_.find(symbol_id);
if (it != positions_.end()) {
it->second.update_market_price(price);
recalculate_equity();
}
}
// 获取持仓
Position* get_position(SymbolId symbol_id) {
auto it = positions_.find(symbol_id);
return (it != positions_.end()) ? &it->second : nullptr;
}
// 获取总权益
Quantity total_equity() const {
return total_equity_.load(std::memory_order_acquire);
}
// 获取现金
Quantity cash() const { return cash_.load(std::memory_order_acquire); }
// 获取总盈亏
Price total_pnl() const {
return total_equity_.load(std::memory_order_acquire) - initial_capital_;
}
// 获取收益率
double return_rate() const {
if (initial_capital_ == 0) return 0.0;
Quantity equity = total_equity_.load(std::memory_order_acquire);
return static_cast<double>(equity - initial_capital_) /
static_cast<double>(initial_capital_);
}
// 风控检查：检查是否可以执行订单
bool can_execute_order(const Order& order) const {
if (order.side == Side::BUY) {
// 买单：检查现金是否足够
Price required_cash =
multiply_price_quantity(order.limit_price, order.quantity);
Quantity current_cash = cash_.load(std::memory_order_acquire);
return current_cash >= required_cash;
} else {
// 卖单：检查持仓是否足够
auto it = positions_.find(order.symbol_id);
if (it == positions_.end()) {
return true; // 允许卖空
}
return it->second.quantity >= order.quantity || true;
}
}
private:
// 获取或创建持仓
Position& get_or_create_position(SymbolId symbol_id,
const std::string& symbol) {
auto it = positions_.find(symbol_id);
if (it == positions_.end()) {
it = positions_.try_emplace(symbol_id, symbol_id, symbol).first;
}
return it->second;
}
// 重新计算总权益
void recalculate_equity() {
Price positions_value = 0;
for (auto& [id, pos] : positions_) {
positions_value += pos.market_value();
}
Quantity current_cash = cash_.load(std::memory_order_relaxed);
total_equity_.store(current_cash + positions_value,
std::memory_order_relaxed);
}
private:
std::unordered_map<SymbolId, Position> positions_; // 持仓映射表
Quantity initial_capital_; // 初始资金
std::atomic<Quantity> total_equity_; // 总权益
std::atomic<Quantity> cash_; // 现金余额
};
PMS的业务流程
- 持仓更新：当EMS通知订单成交时，PMS更新对应的持仓
- 成本计算：对于加仓操作，重新计算平均成本价；对于减仓操作，计算已实现盈亏
- 盈亏计算：根据当前市场价格，实时计算未实现盈亏
- 资金管理：跟踪现金余额，买入时减少现金，卖出时增加现金
- 总权益计算：总权益 = 现金余额 + 持仓市值
- 风控检查：在订单执行前，检查资金是否充足或持仓是否足够
PMS的计算逻辑
- 平均成本价：加仓时，平均成本价 = (原持仓成本 + 新成交成本) / 总持仓数量
- 已实现盈亏：平仓时，已实现盈亏 = 平仓数量 × (成交价格 - 平均成本价)
- 未实现盈亏：未实现盈亏 = 持仓市值 - 持仓成本 = 当前价格 × 持仓数量 - 平均成本价 × 持仓数量
- 总权益：总权益 = 现金余额 + 所有持仓的市值
- 总盈亏：总盈亏 = 总权益 - 初始资金 = 已实现盈亏 + 未实现盈亏
RMS - 风险管理系统 (Risk Management System)
RMS负责监控和管理交易风险。
- 市场数据接收：接收并维护实时市场数据（买卖盘、价格等）
- 持仓监控：从PMS同步持仓数据，监控持仓风险
- 风险指标计算：计算风险敞口、保证金、VaR（风险价值）等风险指标
- 订单验证：在订单提交前验证订单是否符合风险限制（持仓限制、敞口限制、价格滑点等）
- 风险告警：当风险指标超过预设阈值时，发送告警通知
- 风险报告：生成风险报告，展示当前的风险状况
核心数据结构
// 市场数据层级
struct LevelInfo {
Price price; // 价格
Quantity quantity; // 数量
};
// 市场数据
struct MarketData {
SymbolId symbol_id;
std::string symbol;
std::vector<LevelInfo> bid_levels; // 买盘层级
std::vector<LevelInfo> ask_levels; // 卖盘层级
Timestamp timestamp;
// 获取买一价
Price best_bid() const {
return bid_levels.empty() ? 0 : bid_levels[0].price;
}
// 获取卖一价
Price best_ask() const {
return ask_levels.empty() ? 0 : ask_levels[0].price;
}
// 获取中间价
Price mid_price() const {
Price bid = best_bid();
Price ask = best_ask();
if (bid == 0 || ask == 0) return 0;
return (bid + ask) / 2;
}
};
// 单个交易对的风险指标
struct InstrumentRisk {
Price exposure; // 风险敞口
Price margin; // 保证金
Quantity position_limit; // 持仓限制
Quantity current_position; // 当前持仓
Price delta; // Delta风险
Price var_99; // 99% VaR
};
// 风险参数
struct RiskParams {
Price max_single_exposure; // 单个交易对最大敞口
Price max_total_exposure; // 总敞口限制
double margin_rate; // 保证金率（如0.1表示10%）
Quantity max_position_per_instr; // 每个交易对最大持仓
double price_slide_tolerance; // 价格滑点容忍度（如0.02表示2%）
};
核心代码
风险管理器（RiskManager）
class RiskManager {
public:
// 风险验证结果
struct ValidationResult {
bool valid;
std::string reason;
ValidationResult(bool v = true, const std::string& r = "")
: valid(v), reason(r) {}
};
public:
RiskManager(RiskParams params = RiskParams())
: risk_params_(params),
total_exposure_(0),
total_margin_(0),
total_pnl_(0),
max_drawdown_(0) {}
// 设置风险参数
void set_risk_params(const RiskParams& params) { risk_params_ = params; }
// 更新市场数据
void update_market_data(const MarketData& market_data) {
market_data_[market_data.symbol_id] = market_data;
// 重新计算相关风险指标
calculate_instrument_risk(market_data.symbol_id);
calculate_portfolio_risk();
}
// 更新持仓（从PMS同步）
void update_position(SymbolId symbol_id, const std::string& symbol,
Quantity quantity, Price avg_cost_price,
Price current_price) {
// 计算风险敞口
Price exposure = calculate_exposure(quantity, current_price);
Price margin = static_cast<Price>(static_cast<double>(exposure) *
risk_params_.margin_rate);
InstrumentRisk& risk = instrument_risks_[symbol_id];
risk.exposure = exposure;
risk.margin = margin;
risk.current_position = std::abs(quantity);
risk.delta = quantity; // 简化：Delta等于持仓数量
// 重新计算总风险
calculate_portfolio_risk();
}
// 验证订单（订单提交前调用）
ValidationResult validate_order(const Order& order) {
// 检查市场数据是否存在
auto md_it = market_data_.find(order.symbol_id);
if (md_it == market_data_.end()) {
return ValidationResult(false, "Market data not found for symbol");
}
const MarketData& md = md_it->second;
// 检查价格是否合理（滑点检查）
Price ref_price = (order.side == Side::BUY) ? md.best_ask() : md.best_bid();
if (ref_price == 0) {
ref_price = md.mid_price();
}
if (order.order_type == OrderType::LIMIT && ref_price > 0) {
Price price_diff = std::abs(order.limit_price - ref_price);
Price tolerance = static_cast<Price>(static_cast<double>(ref_price) *
risk_params_.price_slide_tolerance);
if (price_diff > tolerance) {
return ValidationResult(false, "Order price exceeds slide tolerance");
}
}
// 检查持仓限制
auto risk_it = instrument_risks_.find(order.symbol_id);
Quantity current_pos = (risk_it != instrument_risks_.end())
? risk_it->second.current_position
: 0;
Quantity new_pos = current_pos + order.quantity;
if (new_pos > risk_params_.max_position_per_instr) {
return ValidationResult(false, "Position limit would be exceeded");
}
// 检查单个交易对敞口限制
Price new_exposure = calculate_exposure(new_pos, ref_price);
if (new_exposure > risk_params_.max_single_exposure) {
return ValidationResult(
false, "Single instrument exposure limit would be exceeded");
}
// 检查总敞口限制（估算）
Price estimated_total =
total_exposure_.load(std::memory_order_acquire) +
(new_exposure - calculate_exposure(current_pos, ref_price));
if (estimated_total > risk_params_.max_total_exposure) {
return ValidationResult(false, "Total exposure limit would be exceeded");
}
return ValidationResult(true);
}
// 评估订单对投资组合的影响
Price assess_order_impact(const Order& order) {
auto md_it = market_data_.find(order.symbol_id);
if (md_it == market_data_.end()) {
return 0;
}
const MarketData& md = md_it->second;
Price market_price = md.mid_price();
if (market_price == 0) {
market_price = (order.side == Side::BUY) ? md.best_ask() : md.best_bid();
}
if (market_price == 0) return 0;
// 计算敞口变化
return multiply_price_quantity(market_price, order.quantity);
}
// 获取风险指标
InstrumentRisk* get_instrument_risk(SymbolId symbol_id) {
auto it = instrument_risks_.find(symbol_id);
return (it != instrument_risks_.end()) ? &it->second : nullptr;
}
// 获取总敞口
Price total_exposure() const {
return total_exposure_.load(std::memory_order_acquire);
}
// 获取总保证金
Price total_margin() const {
return total_margin_.load(std::memory_order_acquire);
}
// 获取99% VaR
Price var_99() const { return var_99_.load(std::memory_order_acquire); }
// 生成风险报告
void generate_risk_report() {
Price exposure = total_exposure_.load(std::memory_order_acquire);
Price margin = total_margin_.load(std::memory_order_acquire);
Price var = var_99_.load(std::memory_order_acquire);
std::cout << "\n=== Risk Report ===" << std::endl;
std::cout << "Total Exposure: " << price_to_double(exposure) << std::endl;
std::cout << "Total Margin: " << price_to_double(margin) << std::endl;
std::cout << "99% VaR: " << price_to_double(var) << std::endl;
std::cout << "===================\n" << std::endl;
}
// 检查风险限制并发送告警
void check_risk_limits() {
Price exposure = total_exposure_.load(std::memory_order_acquire);
if (exposure > risk_params_.max_total_exposure) {
send_alert(
"Total exposure exceeds limit: " +
std::to_string(price_to_double(exposure)) + " > " +
std::to_string(price_to_double(risk_params_.max_total_exposure)));
}
Price var = var_99_.load(std::memory_order_acquire);
Price var_threshold = static_cast<Price>(
static_cast<double>(risk_params_.max_total_exposure) * 0.1);
if (var > var_threshold) {
send_alert("VaR exceeds threshold: " +
std::to_string(price_to_double(var)));
}
// 检查每个交易对的持仓限制
for (const auto& [symbol_id, risk] : instrument_risks_) {
if (risk.current_position > risk_params_.max_position_per_instr) {
auto md_it = market_data_.find(symbol_id);
std::string symbol = (md_it != market_data_.end())
? md_it->second.symbol
: std::to_string(symbol_id);
send_alert("Position limit exceeded for " + symbol + ": " +
std::to_string(quantity_to_double(risk.current_position)) +
" > " +
std::to_string(quantity_to_double(
risk_params_.max_position_per_instr)));
}
}
}
private:
// 计算风险敞口（持仓数量 × 市场价格）
Price calculate_exposure(Quantity quantity, Price price) {
if (price == 0) return 0;
Quantity abs_quantity = std::abs(quantity);
return multiply_price_quantity(price, abs_quantity);
}
// 计算单个交易对的风险
void calculate_instrument_risk(SymbolId symbol_id) {
auto md_it = market_data_.find(symbol_id);
if (md_it == market_data_.end()) {
return;
}
const MarketData& md = md_it->second;
Price market_price = md.mid_price();
if (market_price == 0) return;
auto risk_it = instrument_risks_.find(symbol_id);
if (risk_it == instrument_risks_.end()) {
return;
}
InstrumentRisk& risk = risk_it->second;
Quantity quantity = risk.current_position;
// 重新计算敞口和保证金
risk.exposure = calculate_exposure(quantity, market_price);
risk.margin = static_cast<Price>(static_cast<double>(risk.exposure) *
risk_params_.margin_rate);
// 计算VaR（简化：使用敞口的5%作为VaR）
risk.var_99 = static_cast<Price>(static_cast<double>(risk.exposure) * 0.05);
}
// 计算投资组合总风险
void calculate_portfolio_risk() {
Price total_exp = 0;
Price total_marg = 0;
Price total_var = 0;
for (auto& [symbol_id, risk] : instrument_risks_) {
total_exp += risk.exposure;
total_marg += risk.margin;
total_var += risk.var_99;
}
total_exposure_.store(total_exp, std::memory_order_release);
total_margin_.store(total_marg, std::memory_order_release);
var_99_.store(total_var, std::memory_order_release);
}
// 发送告警
void send_alert(const std::string& message) {
if (alert_callback_) {
alert_callback_(message);
} else {
std::cerr << "[RISK ALERT] " << message << std::endl;
}
}
private:
RiskParams risk_params_;
std::unordered_map<SymbolId, MarketData> market_data_;
std::unordered_map<SymbolId, InstrumentRisk> instrument_risks_;
alignas(64) std::atomic<Price> total_exposure_;
alignas(64) std::atomic<Price> total_margin_;
alignas(64) std::atomic<Price> total_pnl_;
alignas(64) std::atomic<Price> max_drawdown_;
alignas(64) std::atomic<Price> var_99_;
RiskAlertCallback alert_callback_;
};
RMS的业务流程
- 市场数据更新：接收并维护实时市场数据（买卖盘、价格等）
- 持仓同步：从PMS同步持仓数据，更新风险指标
- 风险计算：根据市场数据和持仓情况，计算风险敞口、保证金、VaR等指标
- 订单验证：在订单提交前，验证订单是否符合风险限制
- 风险监控：实时监控风险指标，当超过阈值时发送告警
- 风险报告：生成风险报告，展示当前的风险状况
RMS的风险指标
- 风险敞口（Exposure）：风险敞口 = |持仓数量| × 当前市场价格
- 保证金（Margin）：保证金 = 风险敞口 × 保证金率
- 持仓限制（Position Limit）：每个交易对的最大持仓数量
- 敞口限制（Exposure Limit）：单个交易对和总敞口的最大限制
- VaR（风险价值）：在99%置信度下，可能的最大损失（简化：使用敞口的5%作为VaR）
- 价格滑点容忍度（Price Slide Tolerance）：订单价格偏离市场价格的允许范围
RMS的订单验证规则
- 价格滑点检查：限价单的价格不能偏离市场价格超过容忍度
- 持仓限制检查：执行订单后的持仓不能超过单个交易对的最大持仓限制
- 敞口限制检查：执行订单后的敞口不能超过单个交易对和总敞口的限制
系统协作关系
数据流向
交易策略/用户
│
├─→ OMS: 提交订单
│ │
│ ├─→ 创建订单记录
│ ├─→ 分配订单ID
│ └─→ 返回订单ID
│
├─→ RMS: 验证订单（订单提交前）
│ │
│ ├─→ 检查风险限制
│ ├─→ 验证价格合理性
│ └─→ 返回验证结果
│
├─→ EMS: 执行订单
│ │
│ ├─→ 接收订单ID
│ ├─→ 从OMS查询订单信息
│ ├─→ 提交到交易所
│ ├─→ 接收成交信息
│ └─→ 通知OMS和PMS
│
└─→ PMS: 更新持仓
│
├─→ 接收成交信息
├─→ 更新持仓数量
├─→ 计算盈亏
└─→ 更新现金和总权益
│
└─→ RMS: 同步持仓数据（用于风险监控）
│
├─→ 更新风险指标
├─→ 计算风险敞口
└─→ 监控风险限制
典型交易流程
-
订单提交阶段
-
交易策略调用OMS的
submit_order()提交订单 -
OMS创建订单记录，分配订单ID
-
订单验证阶段
-
交易策略调用RMS的
validate_order()验证订单 - RMS检查风险限制（持仓限制、敞口限制、价格滑点等）
-
如果验证通过，继续执行；如果验证失败，拒绝订单
-
订单执行阶段
-
交易策略调用EMS的
execute_order()执行订单 - EMS从OMS获取订单信息，提交到交易所
-
交易所执行订单，返回成交结果
-
成交处理阶段
-
EMS收到成交信息，调用OMS的
on_fill()更新订单状态 - EMS同时调用PMS的
on_fill()更新持仓和现金 -
PMS更新后，通知RMS更新持仓数据，重新计算风险指标
-
风险监控阶段
-
RMS实时监控风险指标
-
当风险指标超过阈值时，发送告警通知
-
状态查询阶段
-
交易策略可以从OMS查询订单状态
- 交易策略可以从PMS查询持仓和资金情况
- 交易策略可以从RMS查询风险指标和风险报告
辅助函数-定点数乘法
由于价格和数量都使用定点数表示（1e8精度），直接相乘会产生二次放大，需要使用专门的函数：
// 定点数乘法（quantity和price都是定点数，相乘后需要除以SCALE）
inline int64_t multiply_price_quantity(int64_t price, int64_t quantity) {
double result = (static_cast<double>(price) * quantity) / PRICE_SCALE_D;
return static_cast<int64_t>(result);
}
这个函数在计算持仓市值、现金变化等场景中都会用到。