第8章：自动驾驶客户端系统

┌─────────────────────────────────────────────────────────┐
│                    车载计算平台架构                      │
├─────────────────────────────────────────────────────────┤
│  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌────────┐ │
│  │   CPU    │  │   GPU    │  │   NPU    │  │  DSP   │ │
│  │ (控制流) │  │ (并行化) │  │ (AI推理) │  │(信号处)│ │
│  └─────┬────┘  └─────┬────┘  └─────┬────┘  └────┬───┘ │
│        │              │              │             │     │
│  ┌─────┴──────────────┴──────────────┴─────────────┴──┐ │
│  │              高速互联总线 (PCIe/CXL)                │ │
│  └─────┬──────────────┬──────────────┬────────────────┘ │
│        │              │              │                   │
│  ┌─────┴────┐  ┌─────┴────┐  ┌─────┴────┐              │
│  │  共享    │  │   ISP    │  │   VPU    │              │
│  │  内存    │  │ (图像处) │  │ (视频编) │              │
│  │  (LPDDR) │  │          │  │   解码   │              │
│  └──────────┘  └──────────┘  └──────────┘              │
└─────────────────────────────────────────────────────────┘

实际吞吐量 = min(计算能力, 内存带宽 × 数据重用率)

功耗 ∝ C × V² × f

┌─────────────────────────────────────┐
│         热管理系统架构               │
├─────────────────────────────────────┤
│  芯片 → 导热界面材料 → 散热器        │
│   ↓                      ↓          │
│  结温     外壳温度    环境温度       │
│  Tj        Tc          Ta           │
│                                     │
│  热阻: Rjc + Rca = (Tj - Ta) / P   │
│  其中P是功耗                        │
└─────────────────────────────────────┘

感知到控制的延迟分解（典型L3系统）
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
传感器采集    ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
             ├─────┤ 5ms（相机曝光+传输）
数据预处理            ├────┤ 3ms（ISP处理）
感知推理                   ├──────────┤ 15ms（DNN推理）
融合跟踪                              ├─────┤ 5ms
预测规划                                    ├──────┤ 8ms
控制输出                                           ├──┤ 2ms
CAN总线                                              ├─┤ 2ms
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
总延迟: 40ms

WCET分析方法：

1. 静态分析：通过程序流图分析所有可能路径
2. 测量法：大量测试用例的统计上界
3. 混合方法：结合静态分析和实际测量

WCET = 基本块执行时间 + 缓存未命中惩罚 + 中断延迟

QNX系统架构
┌─────────────────────────────────────┐
│         应用层                       │
│  ┌─────┐ ┌─────┐ ┌─────┐ ┌─────┐  │
│  │感知 │ │规划 │ │控制 │ │诊断 │  │
│  └──┬──┘ └──┬──┘ └──┬──┘ └──┬──┘  │
├─────┴───────┴───────┴───────┴───────┤
│         资源管理器                   │
│  ┌─────┐ ┌─────┐ ┌─────┐ ┌─────┐  │
│  │文件 │ │网络 │ │设备 │ │ IPC │  │
│  │系统 │ │协议 │ │驱动 │ │管理 │  │
│  └──┬──┘ └──┬──┘ └──┬──┘ └──┬──┘  │
├─────┴───────┴───────┴───────┴───────┤
│         QNX微内核                    │
│  • 消息传递 • 线程调度              │
│  • 中断处理 • 时钟管理              │
└─────────────────────────────────────┘

标准Linux vs RT-Linux延迟对比
┌────────────────────────────────┐
│         延迟分布图              │
│                                │
│ 标准Linux:                     │
│ ▁▂▄█████▄▂▁________▁▂▁_____   │
│ └─────────────────────────┘    │
│ 0   100μs  1ms   10ms   100ms  │
│                                │
│ RT-Linux:                      │
│ ▁████▄▂▁___________________    │
│ └─────────────────────────┘    │
│ 0   100μs  1ms   10ms   100ms  │
└────────────────────────────────┘

典型的8核系统任务分配
┌──────────────────────────────────────┐
│  核心分配策略                        │
├──────────────────────────────────────┤
│ Core 0-1: 系统服务、中断处理         │
│   - OS内核                          │
│   - 设备驱动                        │
│   - 网络协议栈                      │
│                                      │
│ Core 2-3: 感知处理                  │
│   - 图像预处理                      │
│   - 点云处理                        │
│   - 传感器融合                      │
│                                      │
│ Core 4-5: 决策规划                  │
│   - 行为预测                        │
│   - 路径规划                        │
│   - 决策树评估                      │
│                                      │
│ Core 6-7: 安全监控                  │
│   - 功能安全监控                    │
│   - 冗余计算                        │
│   - 故障检测                        │
└──────────────────────────────────────┘

生产者核心              消费者核心
┌─────────┐            ┌─────────┐
│ Writer  │            │ Reader  │
└────┬────┘            └────┬────┘
     │                      │
     ▼                      ▼
┌──────────────────────────────┐
│     环形缓冲区（L3 Cache）    │
│  ┌──┬──┬──┬──┬──┬──┬──┬──┐  │
│  │  │██│██│██│  │  │  │  │  │
│  └──┴──┴──┴──┴──┴──┴──┴──┘  │
│     ↑wr_idx      ↑rd_idx     │
└──────────────────────────────┘

False Sharing示例及解决方案
━━━━━━━━━━━━━━━━━━━━━━━━━━━━
问题：两个核心访问同一cache line的不同数据
struct {
    int core0_data;  // Core 0写
    int core1_data;  // Core 1写  
} shared;  // 导致cache line乒乓

解决：使用padding分离到不同cache line
struct {
    int core0_data;
    char pad[60];    // 填充到64字节
    int core1_data;
    char pad[60];
} shared;

高关键性模式触发条件：

- 低关键性任务超时
- 系统资源不足
- 安全事件检测

模式切换：暂停低关键性任务，保证高关键性任务

┌─────────────────────────────────────────────┐
│            应用层                            │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐  │
│  │  感知    │  │  规划    │  │  控制    │  │
│  │  服务    │  │  服务    │  │  服务    │  │
│  └────┬─────┘  └────┬─────┘  └────┬─────┘  │
├───────┴──────────────┴──────────────┴───────┤
│            ARA（AUTOSAR Runtime for          │
│              Adaptive Applications）         │
│  ┌──────────────────────────────────────┐   │
│  │ • ara::com  (通信管理)               │   │
│  │ • ara::exec (执行管理)               │   │
│  │ • ara::sm   (状态管理)               │   │
│  │ • ara::diag (诊断服务)               │   │
│  └──────────────────────────────────────┘   │
├──────────────────────────────────────────────┤
│          自适应平台基础                      │
│  ┌─────────┐ ┌─────────┐ ┌─────────────┐   │
│  │ 操作系统│ │ 执行   │ │ 通信中间件  │   │
│  │ (POSIX) │ │ 管理器 │ │ (SOME/IP)   │   │
│  └─────────┘ └─────────┘ └─────────────┘   │
└─────────────────────────────────────────────┘

服务发现流程：

1. 服务提供者注册
   Provider → Service Registry: RegisterService(interface, endpoint)

2. 服务消费者查询
   Consumer → Service Registry: FindService(interface)
   Registry → Consumer: ServiceHandle[]

3. 建立连接
   Consumer → Provider: Subscribe/Request via ServiceHandle

// 服务接口定义
service PerceptionService {
    method GetObjects() -> ObjectList;
    event ObjectsUpdated -> ObjectList;
    field<ObjectList> CurrentObjects;
}

// 服务提供者
class PerceptionProvider {
    ara::com::ServiceSkeleton skeleton;

    void Offer() {
        skeleton.OfferService();
        // 处理请求
        skeleton.GetObjects.SetHandler([this](){
            return ComputeObjects();
        });
    }
}

// 服务消费者
class PlanningConsumer {
    ara::com::ServiceProxy proxy;

    void Start() {
        auto handles = proxy.FindService();
        if (!handles.empty()) {
            proxy = ServiceProxy(handles[0]);
            proxy.ObjectsUpdated.Subscribe([](ObjectList objs){
                ProcessObjects(objs);
            });
        }
    }
}

ROS2/DDS架构层次
┌─────────────────────────────────┐
│      ROS2应用节点               │
├─────────────────────────────────┤
│      RCL (ROS Client Library)   │
├─────────────────────────────────┤
│      RMW (ROS Middleware)       │
│         接口抽象层               │
├─────────────────────────────────┤
│    DDS实现 (FastDDS/CycloneDDS) │
│  • RTPS协议                     │
│  • QoS策略                      │
│  • 自动发现                     │
├─────────────────────────────────┤
│      传输层 (UDP/共享内存)       │
└─────────────────────────────────┘

// 创建实时性要求高的发布者
auto qos = rclcpp::QoS(10)  // 队列深度
    .reliability(RMW_QOS_POLICY_RELIABILITY_RELIABLE)
    .deadline(std::chrono::milliseconds(10))
    .liveliness(RMW_QOS_POLICY_LIVELINESS_AUTOMATIC);

auto publisher = node->create_publisher<ControlMsg>(
    "vehicle_control", qos);

// 使用内存池避免动态分配
rclcpp::PublisherOptions pub_options;
pub_options.use_intra_process_comm = true;
pub_options.allocator = 
    std::make_shared<CustomAllocator<>>();

// 单线程执行器用于确定性
rclcpp::executors::SingleThreadedExecutor executor;

// 静态执行器用于实时性
rclcpp::executors::StaticSingleThreadedExecutor 
    static_executor;

共享内存架构
┌──────────────────────────────────────┐
│          物理内存                     │
├──────────────────────────────────────┤
│  ┌────────────────────────────────┐  │
│  │     共享内存段 (SHM)           │  │
│  │  ┌──────────────────────────┐  │  │
│  │  │  元数据区                │  │  │
│  │  │  • 写入索引              │  │  │
│  │  │  • 读取索引              │  │  │
│  │  │  • 时间戳                │  │  │
│  │  └──────────────────────────┘  │  │
│  │  ┌──────────────────────────┐  │  │
│  │  │  数据缓冲区              │  │  │
│  │  │  [Frame0][Frame1]...     │  │  │
│  │  └──────────────────────────┘  │  │
│  └────────────────────────────────┘  │
├──────────────────────────────────────┤
│  进程A内存空间    │   进程B内存空间  │
│    映射SHM       │     映射SHM       │
└──────────────────────────────────────┘

传统方式（4次拷贝）：
设备 → 内核缓冲 → 用户缓冲 → 内核缓冲 → 网络

零拷贝（DMA + sendfile）：
设备 → 内核缓冲 → 网络
       ↑________↑
         DMA传输

// 定义schema
struct PointCloud {
    timestamp @0 :UInt64;
    points @1 :List(Point);
    struct Point {
        x @0 :Float32;
        y @1 :Float32;  
        z @2 :Float32;
        intensity @3 :UInt8;
    }
}

// 零拷贝读取
auto reader = capnp::FlatArrayMessageReader(data);
auto cloud = reader.getRoot<PointCloud>();
// 直接访问，无需解析
for (auto point : cloud.getPoints()) {
    process(point.getX(), point.getY(), point.getZ());
}