企业官网建设流程全解析

1. Os_MultiCoreServer 的定位与作用

Os_MultiCoreServer（多核服务机制）位于 Os_MultiCore.c，是 AUTOSAR OS 多核 OS 的跨核服务调用机制。它允许一个核上的任务/ISR 调用目标核上才能执行的 OS 服务（因为目标对象 Task/Alarm/Counter 等归属于目标核）。

1.1 为什么需要这个机制？

AUTOSAR OS 多核架构中，OS 对象是核本地归属的：

• 每个 Task、Alarm、Counter、ScheduleTable、ISR 都归属于某个特定核
• 任务调度、Alarm 管理、Counter 计数等操作必须在归属核上执行
• 当 Core0 上的代码要 ActivateTask(TaskOfCore1) 时，不能直接操作 Core1 的调度器

解决方案：通过 Os_MultiCoreServer 把请求"转发"到目标核执行

1.2 与 IOC 的区别

2. 支持的服务列表

typedefenum{Os_MCServe_ActivateTask_ID=0U,/* 激活任务 */Os_MCServe_AlarmActivateTask_ID,/* Alarm 激活任务 */Os_MCServe_ChainTask_ID,/* 链接任务 */Os_MCServe_GetTaskState_ID,/* 查询任务状态 */Os_MCServe_GetAlarm_ID,/* 查询 Alarm 剩余 tick */Os_MCServe_GetAlarmBase_ID,/* 查询 AlarmBase */Os_MCServe_SetRelAlarm_ID,/* 相对 Alarm */Os_MCServe_SetAbsAlarm_ID,/* 绝对 Alarm */Os_MCServe_CancelAlarm_ID,/* 取消 Alarm */Os_MCServe_TerminateApplication_ID,/* 终止应用 */Os_MCServe_GetApplicationState_ID,/* 查询应用状态 */Os_MCServe_ShutdownAllCores_ID,/* 关闭所有核 */Os_MCServe_SetEvent_ID,/* 设置事件 */Os_MCServe_AlarmSetEvent_ID,/* Alarm 设置事件 */Os_MCServe_StartSchdTbRel_ID,/* 启动调度表（相对） */Os_MCServe_StartSchdTbAbs_ID,/* 启动调度表（绝对） */Os_MCServe_StopSchdTb_ID,/* 停止调度表 */Os_MCServe_NextSchdTb_ID,/* 切换下一个调度表 */Os_MCServe_GetSchdTbStatus_ID,/* 查询调度表状态 */Os_MCServe_GetTaskStackUsage_ID,/* 查询任务栈使用 */Os_MCServe_GetIsrStackUsage_ID,/* 查询 ISR 栈使用 */Os_MCServe_GetCounterValue_ID,/* 查询 Counter 值 */Os_MCServe_Func_Counter}Os_MCServe_FuncId;

这 22 个服务覆盖了几乎所有需要跨核操作的 OS API，函数表是 ID 到具体处理函数的映射。

3. 核心数据结构

3.1 三层缓冲结构

┌─────────────────────────────────────────────────────────────────────┐ │ Os_MultiCoreServe[OS_COREID_COUNT](每核一个，发送缓冲)│ │ ┌─────────────────────────────────────────────────────────────────┐ │ │ │Os_MultiCoreServeType(srcCore 自己维护)│ │ │ │ ├─ uint8 writeId 已写入数量 │ │ │ │ └─ Os_CoreServeType Os_CoreServe[6]★6个槽位的环形数组 │ │ │ │ ├─[0]{isSync,active,funcId,param,retVal}│ │ │ │ ├─[1]...│ │ │ │ └─[5]...│ │ │ └─────────────────────────────────────────────────────────────────┘ │ └─────────────────────────────────────────────────────────────────────┘ ↓ 共享地址传递 ┌─────────────────────────────────────────────────────────────────────┐ │ Os_MCServe_ShareMemory[OS_MULTICORE_BUFFCNT](跨核共享内存)│ │ Os_MultiCoreCommType{active,addr}│ │ ★ addr 指向发送方 Os_CoreServeType │ └─────────────────────────────────────────────────────────────────────┘ ↓ 触发软中断 ┌─────────────────────────────────────────────────────────────────────┐ │ 目标核 ISR:Os_MultiCoreServer_Handler │ │ 通过 addr 读出发送方 Os_CoreServeType，执行 func，写回 retVal │ └─────────────────────────────────────────────────────────────────────┘

3.2 共享内存缓冲布局

#defineOS_MULTICORE_BUFFCNT(OS_COREID_COUNT*(OS_COREID_COUNT-1))#defineOS_MULTICORE_GETBUFF(coreId)(coreId*(OS_COREID_COUNT-1))

每个目标核在 Os_MCServe_ShareMemory 中分配 OS_COREID_COUNT-1 个 Os_MultiCoreCommType 项，每个对应一个可能的发送核。例如 3 核系统：

• Core0 的发送槽（给 Core1、Core2）：索引 0, 1
• Core1 的发送槽（给 Core0、Core2）：索引 2, 3
• Core2 的发送槽（给 Core0、Core1）：索引 4, 5

Os_MultiCore_GetSendBuff 处理 srcCore>desCore 时的索引偏移，避免双向通信冲突。

3.3 关键内存属性

#defineOS_START_SEC_GLOBAL_NOCACHE_VAR★ NOCACHE 关键：多核可见#include"Os_MemMap.h"staticVAR(Os_MultiCoreServeType,OS_VAR_NO_INIT)Os_MultiCoreServe[OS_COREID_COUNT];staticVAR(Os_MultiCoreCommType,OS_VAR_NO_INIT)Os_MCServe_ShareMemory[OS_MULTICORE_BUFFCNT];volatileVAR(uint8,OS_VAR_NO_INIT)Os_MultiCoreSync[OS_COREID_COUNT];#defineOS_STOP_SEC_GLOBAL_NOCACHE_VAR

NOCACHE 是多核可见性的关键：若使用 cache，Core0 写入 Core1 可能读到旧值。

4. 跨核服务调用完整流程

以 Core0 上的 TaskA 调用 ActivateTask(TaskB_OfCore1) 为例：

4.1 调用入口（在 Task/Event/Alarm 等模块中）

parameter.Os_ActivateTask.taskId=taskId;/* Execute multi-core calling function. */ret=Os_MultiCore_Trigger(TRUE,/* isSync=同步等待 */coreId,/* srcCore=0 */OS_TASK_GETCOREID(taskCfg),/* desCore=1 */Os_MCServe_ActivateTask_ID,/* funcId */&parameter);/* 参数 */

4.2 Os_MultiCore_Trigger 主流程

1.校验 srcCore/desCore 有效性2.计算 buffOffset=Os_MultiCore_GetSendBuff(srcCore,desCore)3.multicoreComm=&Os_MCServe_ShareMemory[buffOffset+OS_MULTICORE_GETBUFF(desCore)]★ 指向"目标核 desCore 的发送槽中、对应 srcCore 的那一项"4.multiCoreServe=&Os_MultiCoreServe[srcCore]★ 指向 srcCore 自己的发送缓冲5.ret=Os_MultiCoreServer_Write(isSync,funcId,param,multiCoreServe)6.if(OK)ret=Os_MultiCoreServer_Read(multiCoreServe,multicoreComm,desCore,param)

4.3 Os_MultiCoreServer_Write

Os_Arch_IntDisable(&intState);// 关本核中断（防 ISR 干扰）writeId=multiCoreServe->writeId;if(Os_MULTICORE_MESSAGE_SIZE==writeId)// 6 个槽位满ret=E_OS_BUFFFULL;else{// 1. 拷贝参数到发送槽Os_MultiCore_ParamMemCyp(param,&multiCoreServe->Os_CoreServe[writeId].Os_MultiCoreServeParam);// 2. 设置标志multiCoreServe->Os_CoreServe[writeId].isSync=isSync;multiCoreServe->Os_CoreServe[writeId].funcId=funcId;multiCoreServe->Os_CoreServe[writeId].active=TRUE;// ★ 标记待处理multiCoreServe->writeId++;}Os_Arch_IntEnable(intState);

4.4 Os_MultiCoreServer_Read

这是核心同步逻辑，区分同步/异步：

while(TRUE){if(FALSE==multiCoreComm->active)// 槽位未被占用{Os_Arch_IntDisable(&intState);if(FALSE==multiCoreServe->Os_CoreServe[writeId].active){// ★ Case A: 已被目标核处理完// 拷贝返回值到 param，减少 writeId，退出multiCoreServe->writeId--;Os_MultiCore_ParamMemCyp(&...->Os_MultiCoreServeParam,param);ret=multiCoreServe->Os_CoreServe[writeId].retVal;breakFlag=TRUE;}else{// ★ Case B: 首次发送，触发目标核处理multiCoreComm->active=TRUE;multiCoreComm->addr=&multiCoreServe->Os_CoreServe[writeId];Os_Arch_Trigger_Core(desCore);// ★ 触发目标核软中断if(FALSE==isSync)// 异步模式{multiCoreServe->writeId--;breakFlag=TRUE;// 立即返回，不等结果}// 同步模式：不退出 while，循环轮询 active 标志}Os_Arch_IntEnable(intState);}if(breakFlag)break;}

同步模式：发送方在 while(TRUE) 中忙等待目标核处理完成（active 被清为 FALSE），然后取出 retVal 返回。
异步模式：发送即返回，不等结果（适用于 Fire-and-Forget 场景，如 Alarm 回调中的 SetEvent）。

4.5 目标核中断处理

OS_ISR(Os_MultiCoreServer_Handler){Os_Arch_IntDisableAll();coreId=Os_Core_GetLogicId();Os_Arch_ClrMultiInt(coreId);// 清软中断标志multicoreComm=&Os_MCServe_ShareMemory[OS_MULTICORE_GETBUFF(coreId)];// 遍历所有可能的发送核（OS_COREID_COUNT - 1 个）for(index=0;index<(OS_COREID_COUNT-1);index++){if(TRUE==multicoreComm[index].active)// 该发送核有请求{coreServe=multicoreComm[index].addr;// 通过地址访问发送核的缓冲funcId=coreServe->funcId;func=MultiCoreFuncList[funcId];// 查函数表status=func(&coreServe->Os_MultiCoreServeParam);// ★ 执行目标核 OS 服务coreServe->retVal=status;// 写回返回值coreServe->active=FALSE;// ★ 通知发送方已完成multicoreComm[index].active=FALSE;// 释放共享槽}}}

4.6 完整时序图

Core0(发送方)Core1(目标核)───────────── ───────────── TaskA 调用ActivateTask(TaskB_Core1)│ ▼ Os_Task_ActivateTask ├─ 检测 TaskB 归属 Core1 └─Os_MultiCore_Trigger(isSync=TRUE,0,1,ActivateTask_ID,&param)│ ▼ Os_MultiCoreServer_Write ├─ 写入 Os_MultiCoreServe[0].Os_CoreServe[idx]├─ active=TRUE,funcId,isSync,param └─ writeId++│ ▼ Os_MultiCoreServer_Read ├─ multiCoreComm->active==FALSE?│ └─ YES，进入首次发送分支 ├─ multiCoreComm->active=TRUE ├─ multiCoreComm->addr=&Os_CoreServe[idx]├─Os_Arch_Trigger_Core(1)──────────► SRC.SR=1触发软中断 │ │ │(忙等待while(TRUE))▼ │ 轮询 multiCoreComm->active Os_MultiCoreServer_Handler ISR │ ├─Os_Arch_ClrMultiInt(1)│ ├─ 遍历 multicoreComm[]│ ├─ 找到 active==TRUE 的项 │ ├─ coreServe=multicoreComm.addr │ ├─ funcId=coreServe->funcId │ ├─ func=MultiCoreFuncList[funcId]│ │=Os_MCServe_ActivateTask │ ├─ status=func(&coreServe->param)│ │ └─Os_TargetActivateTask(TaskB)│ │ └─ Os_Task_ActivateTask 本地 │ ├─ coreServe->retVal=status │ ├─ coreServe->active=FALSE ★ │ └─ multicoreComm->active=FALSE ★ │ ◄───────────────────────────────────── ISR 返回 │ active 变 FALSE，退出循环 ├─ 拷贝 retVal 到 param └─ 返回 ret │ ▼ TaskA 得到 ActivateTask 的返回值，继续执行

5. 硬件触发机制

5.1 Os_Arch_Trigger_Core

FUNC(void,OS_CODE)Os_Arch_Trigger_Core(CoreIdType coreId){uint32 regValue;constOs_Arch_IsrSourceType*isrSource;isrSource=OS_CORE_GETMULTICOMMISRSOURCE(coreId);// 取目标核的中断源号regValue=*(volatileuint32*)(OS_ARCH_INT_SRC_BASE+(isrSource->number));*(volatileuint32*)(OS_ARCH_INT_SRC_BASE+(isrSource->number))=(regValue|OS_ARCH_INT_SRC_SETR_MASK);// ★ 设置 SRC.SETR 位触发软中断}

原理：TC3XX的 SRC（System Interrupt Controller）有 SETR 位，软件写 1 可触发对应核的中断。每个核都有一个专用的"多核通信中断源"，配置为 Cat2 ISR，服务函数就是 Os_MultiCoreServer_Handler。

5.2 清中断的简化

Os_Arch_ClrMultiInt：

FUNC(void,OS_CODE)Os_Arch_ClrMultiInt(CoreIdType coreId){OS_DUMMY_STATEMENT(coreId);// 空实现}

TC3XX 的 SRC 类型中断在 ISR 进入时硬件会自动清 SR，因此软件清中断是空操作。这与 STM 的 ISCR 需要软件清不同。

6. 多核启动同步

6.1 四阶段同步

Os_MultiCore_Sync(coreId, OS_MULTISYNCFIRST); // 阶段1：所有核启动请求同步 Os_Hook_CallStartupHook(coreId); // 调用 StartupHook Os_MultiCore_Sync(coreId, OS_MULTISYNCSECOND); // 阶段2：Hook 完成 /* Counter/Alarm/Task/ISR 等初始化 */ Os_MultiCore_Sync(coreId, OS_MULTISYNCTHIRD); // 阶段3：OS 对象初始化完成 Os_Task_StartFirst(coreId); // 启动第一个任务

ShutdownAllCores 时有 OS_MULTISYNCFOURTH。

6.2 Os_MultiCore_Sync 实现

void Os_MultiCore_Sync(CoreIdType coreId, uint8 syncCounter) { uint8 syncIdx; uint8 syncRet; do { // 1. 在自己的 sync 数组位上置位（位图） Os_MultiCoreSync[coreId] = Os_MultiCoreSync[coreId] | OS_MULTICOREMATCH(syncCounter); // 2. 计算期望值（该阶段的位） syncRet = OS_MULTICOREMATCH(syncCounter); // 3. 检查所有核是否都置了该位 for( syncIdx = 0; syncIdx < OS_COREID_COUNT; syncIdx++ ) { syncRet &= Os_MultiCoreSync[syncIdx]; } } while( FALSE == syncRet ); // ★ 所有核到位才退出 }

原理：用 Os_MultiCoreSync[OS_COREID_COUNT] 数组（每核一个字节）做位图同步屏障（Barrier）。每个阶段对应一个 bit（1, 2, 4, 8…），所有核都置位后才放行。

7. 调用方使用模式汇总

Os_Task.c、Os_Event.c、Os_Alarm.c 等模块中的调用统一模式：

/* 1. 检测目标对象归属核 */ if( coreId != OS_TASK_GETCOREID(taskCfg) ) { /* 2. 跨核：填充参数联合体 */ Os_MultiCoreServeParamType parameter; parameter.Os_ActivateTask.taskId = taskId; /* 3. 触发跨核调用 */ ret = Os_MultiCore_Trigger(TRUE, /* 同步 */ coreId, /* srcCore */ OS_TASK_GETCOREID(taskCfg), /* desCore */ Os_MCServe_ActivateTask_ID, /* funcId */ &parameter); } else { /* 本核：直接调用 */ ret = Os_Task_IntlActivateTask(taskId); }