征程6功能安全开发：搭建一个满足ASIL-B要求的最小AI应用框架

做智能驾驶相关的项目，功能安全是绕不开的门槛。ISO 26262要求ASIL-B级别以上的系统必须做失效模式分析、冗余设计、安全监控。征程6的工具链通过了ASIL-B认证，芯片本身支持双核锁步、ECC内存等安全机制。这篇从一个实际项目出发，讲讲怎么用征程6搭一个满足ASIL-B要求的最小AI应用框架。

一、功能安全的风险点

对于AI应用，主要的安全风险：

1. 模型输出错误：检测框位置偏差太大、分类错误、漏检

2. 硬件故障：BPU core计算错误、内存bit flip、传感器数据损坏

3. 软件异常：推理超时、内存越界、除零错误

征程6的安全特性：

· 双核锁步：两个BPU core配置成lock-step模式，同时执行同一条指令，结果对比，不一致时触发安全中断

· ECC内存：DDR和SRAM支持ECC纠错，单bit错误自动修复，双bit错误报告

· WDT看门狗：防止推理线程卡死

· 安全监控单元：独立硬件模块监控BPU、CPU、温度、电压

二、三层安全框架设计

```

Layer 3: 应用安全层

- 输入数据校验（范围、格式）

- 输出结果校验（置信度阈值、范围）

- 决策安全（速度限制、紧急制动）

Layer 2: 推理安全层

- 模型推理超时监控

- 双模型冗余推理（主+影子模型）

- 输出一致性对比

Layer 1: 硬件安全层

- ECC内存校验

- 双核锁步（可选）

- WDT看门狗

- 温度/电压监控

```

三、硬件安全层实现

ECC内存

在设备树里开启：

```

&ddr {

ecc-mode = "secded";

scrub-interval-ms = ;

};

```

Linux内核查看ECC事件：

```bash

cat /sys/devices/system/edac/mc/mc0/ce_count # 单bit错误

cat /sys/devices/system/edac/mc/mc0/ue_count # 双bit错误

```

WDT看门狗

```cpp

#include

class SafetyWatchdog {

int fd_;

int timeout_ms_;

public:

SafetyWatchdog(int timeout_ms = 500) : timeout_ms_(timeout_ms) {

fd_ = open("/dev/watchdog", O_RDWR);

ioctl(fd_, WDIOC_SETTIMEOUT, &timeout_ms);

}

void Feed() {

ioctl(fd_, WDIOC_KEEPALIVE, 0);

}

void TriggerReboot() {

write(fd_, "V", 1);

}

};

```

双核锁步

锁步模式下，两个BPU core同时执行同一个算子，硬件自动对比结果。应用层注册中断处理：

```cpp

void BpuLockstepErrorHandler(int sig) {

SafetyLogger::LogError("BPU lockstep error detected");

EnterSafeState();

}

signal(SIGBPU_LOCKSTEP, BpuLockstepErrorHandler);

```

锁步模式有10-15%的性能损失，但ASIL-B级别以上一般强制要求。

四、推理安全层

超时监控

```cpp

class InferenceMonitor {

public:

struct Result {

std::vector output;

bool timeout;

bool success;

};

Result RunWithTimeout(std::function fn, int timeout_ms = 100) {

auto future = std::async(std::launch::async, fn);

auto status = future.wait_for(std::chrono::milliseconds(timeout_ms));

if (status == std::future_status::timeout) {

return {{}, true, false};

}

return future.get();

}

};

```

双模型冗余（影子模型）

```cpp

class RedundantInference {

ModelHandle primary_;

ModelHandle shadow_;

float consistency_threshold_ = 0.7f;

float CompareOutputs(const InferenceResult& a, const InferenceResult& b) {

// 用IoU对比检测框

float total_iou = 0.0f;

int matched = 0;

for (const auto& box_a : a.boxes) {

float best_iou = 0.0f;

for (const auto& box_b : b.boxes) {

if (box_a.class_id == box_b.class_id) {

best_iou = std::max(best_iou, ComputeIoU(box_a, box_b));

}

}

if (best_iou > 0.5f) {

total_iou += best_iou;

matched++;

}

}

return matched > 0 ? total_iou / matched : 0.0f;

}

public:

bool Init(const char* primary, const char* shadow) {

primary_ = LoadModel(primary);

shadow_ = LoadModel(shadow);

return primary_ && shadow_;

}

InferenceResult Run(const uint8_t* input) {

auto future_primary = std::async(std::launch::async, [&](){

return RunModel(primary_, input);

});

auto future_shadow = std::async(std::launch::async, [&](){

return RunModel(shadow_, input);

});

auto primary = future_primary.get();

auto shadow = future_shadow.get();

float consistency = CompareOutputs(primary, shadow);

if (consistency < consistency_threshold_) {

// 输出不一致，取置信度更高的

return primary.confidence > shadow.confidence ? primary : shadow;

}

return primary;

}

};

```

影子模型选型建议：

· 主模型：YOLOv5-Large，mAP 85%，延迟30ms

· 影子模型：YOLOv5-Nano，mAP 70%，延迟10ms

· 两个模型并行跑在两个BPU core上，不增加总延迟

输出校验

```cpp

bool ValidateOutput(const InferenceResult& result) {

// 检测框坐标必须在图像范围内

for (const auto& box : result.boxes) {

if (box.x1 < 0 || box.y1 < 0 || box.x2 > IMAGE_W || box.y2 > IMAGE_H)

return false;

if (box.x1 >= box.x2 || box.y1 >= box.y2)

return false;

}

// 置信度在合理范围

for (const auto& box : result.boxes) {

if (box.confidence < 0.0f || box.confidence > 1.0f)

return false;

}

// 检测数量不能异常多

if (result.boxes.size() > MAX_DETECTIONS)

return false;

return true;

}

```

五、应用安全层

```cpp

class VehicleSafetyController {

public:

struct Decision {

bool allow_move;

float max_speed;

bool emergency_brake;

std::string reason;

};

Decision MakeDecision(const InferenceResult& perception) {

Decision d{true, MAX_SPEED, false, ""};

// 检测到行人或障碍物距离

for (const auto& obj : perception.boxes) {

if (obj.class_id == CLASS_PEDESTRIAN || obj.class_id == CLASS_OBSTACLE) {

float distance = EstimateDistance(obj);

if (distance < 2.0f && obj.confidence > 0.8f) {

d.emergency_brake = true;

d.allow_move = false;

d.reason = "Obstacle too close";

return d;

}

}

}

// 感知结果校验失败，降速

if (!ValidateOutput(perception)) {

d.max_speed = 5.0f;

d.reason = "Invalid perception output";

return d;

}

// 推理超时，使用缓存结果并降速

if (perception.timeout) {

d.max_speed = 10.0f;

d.reason = "Inference timeout";

return d;

}

return d;

}

private:

float EstimateDistance(const DetectionBox& box) {

float pixel_height = box.y2 - box.y1;

return (KNOWN_OBJECT_HEIGHT * FOCAL_LENGTH) / pixel_height;

}

const float MAX_SPEED = 20.0f;

};

```

六、安全状态定义

状态 行为 触发条件

Normal 正常运行，全速 所有安全层通过

Degraded 降速运行，人工监控 某一层检测到轻微异常

Safe 停车，等待人工干预 严重故障或连续异常

```cpp

enum class SafetyState { NORMAL, DEGRADED, SAFE };

class SafetyStateMachine {

SafetyState current_ = SafetyState::NORMAL;

int normal_frame_count_ = 0;

void Update(SafetyDecision decision) {

switch (current_) {

case SafetyState::NORMAL:

if (decision.emergency_brake) {

TransitionTo(SafetyState::SAFE, decision.reason);

} else if (decision.max_speed < MAX_SPEED) {

TransitionTo(SafetyState::DEGRADED, decision.reason);

}

break;

case SafetyState::DEGRADED:

if (decision.emergency_brake) {

TransitionTo(SafetyState::SAFE, decision.reason);

} else if (decision.max_speed == MAX_SPEED) {

if (++normal_frame_count_ >= 5) {

TransitionTo(SafetyState::NORMAL, "Recovered");

}

} else {

normal_frame_count_ = 0;

}

break;

case SafetyState::SAFE:

// 只能人工复位

break;

}

}

void ManualReset() {

TransitionTo(SafetyState::NORMAL, "Manual reset");

}

};

```

七、工具链安全编译选项

```yaml

compiler_parameters:

optimize_level: O2 # 安全场景建议O2，O3的激进优化可能影响确定性

safety_parameters:

enable_fault_injection_test: true

enable_deterministic_mode: true # 相同输入永远产生相同输出

enable_bounds_check: true # 数组越界检查，性能损耗约5%

enable_divide_by_zero_check: true

```

enable_deterministic_mode很重要，ASIL-B要求推理结果具有可重复性。

八、注意事项总结

1. 硬件层：开启ECC、WDT、双核锁步，监控温度和电压。

2. 推理层：加超时监控、双模型冗余、输出校验，防止模型异常输出。

3. 应用层：根据场景定义安全规则（行人避让、降速、停车），实现状态机。

4. 工具链：开安全编译选项，保证推理的确定性和边界安全。

5. 测试：做故障注入测试，验证系统在异常场景下的行为。

这个最小安全框架覆盖了ASIL-B的主要要求，如果要做ASIL-C或ASIL-D，还需要更复杂的冗余设计和更严格的测试流程。