当前位置： 首页 > news >正文

华为HCCL集合通信库AllGather算子全流程解析

news 2025/9/19 7:08:01

简介

华为集合通信库HCCL（Huawei Collective Communication Library）是基于昇腾AI处理器的高性能集合通信库，提供单机多卡以及多机多卡间的数据并行、模型并行集合通信方案。

HCCL支持AllReduce、Broadcast、AllGather、ReduceScatter、AlltoAll等通信原语，Ring、Mesh、Halving-Doubling（HD）等通信算法，基于HCCS、RoCE和PCIe高速链路实现集合通信。

支持的产品型号

Atlas A3 训练系列产品/Atlas A3 推理系列产品 

Atlas A2 训练系列产品 

Atlas 训练系列产品 

Atlas 300I Duo 推理卡

HCCL在系统中的位置

HCCL提供了C与Python两种语言的接口，其中C语言接口用于实现单算子模式下的框架适配，例如HCCL单算子API嵌入到PyTorch后端代码中，PyTorch用户直接使用PyTorch原生集合通信API，即可实现分布式能力；Python语言的接口用于实现图模式下的框架适配，例如TensorFlow网络基于HCCL的Python API实现分布式优化。

单算子模式与图模式都是神经网络模型的运行模式，其中

  • 单算子模式的特点是每个计算操作依次下发，并立即执行。
  • 图模式的特点是所有计算操作构造成一张图，以图的粒度下发执行。

HCCL软件架构

集合通信库软件架构分为三层：

  • 适配层，图引擎与单算子适配，提供通信域管理及通信算子接口。
  • 集合通信业务层，包含通信框架与通信算法两个模块：
    • 通信框架：负责通信域管理，通信算子的业务串联，协同通信算法模块完成算法选择，协同通信平台模块完成资源申请并实现集合通信任务的下发。
    • 通信算法：作为集合通信算法的承载模块，提供特定集合通信操作的资源计算，并根据通信域信息完成通信任务编排。
  • 集合通信平台层，提供NPU之上与集合通信关联的资源抽象，并提供集合通信的相关维护、测试能力。

集合通信流程

分布式场景中，HCCL提供了服务器间高性能集合通信功能，其通信流程如图所示。

​

服务器间通信过程分为四个阶段：

  1. 通信域初始化：获取必要的集合通信配置参数并初始化通信域。

    通信域初始化阶段不涉及NPU设备之间的交互。

  2. 建立通信连接：建立socket连接并交换通信两端的通信参数和内存信息。

    建立通信连接阶段，HCCL根据用户提供的集群信息并结合网络拓扑与其他NPU设备建链，交换用于通信的参数信息。如果在建链超时时间内未得到其他NPU设备的及时响应，会上报建链超时错误并退出业务进程。

  3. 执行通信操作：通过“等待-通知”机制同步设备执行状态，传递内存数据。

    通信操作执行阶段，HCCL会将通信算法编排、内存访问等任务通过Runtime下发给昇腾设备的任务调度器，设备根据编排信息调度并执行任务。

  4. 通信域销毁：销毁通信域，释放通信资源。

集合通信算法概念介绍

针对同一个通信算子，随着网络拓扑、通信数据量、硬件资源等变化，往往会采用不同的通信算法，从而最大化集群通信性能。以AllGather算子举例，HCCL实现了Mesh、Ring、Recursive Halving-Doubling（RHD）、NHR（Nonuniform Hierarchical Ring）、NB（Nonuniform Bruck）等多种算法用于Server内和Server间的集合通信，通信操作执行时，HCCL会根据输入条件从算法仓中自动选择性能最佳的算法。

通信域

集合通信发生在一组通信对象上（比如一个NPU就是一个通信对象）。通信域是集合通信算子执行的上下文，管理对应的通信对象和通信所需的资源。

Rank

通信域中的每个通信对象称为一个Rank。

Memory

集合通信执行所需要的各种Buffer资源。

流

流（Stream）是NPU上的一种硬件资源，承载了待执行的Task序列。Task可以是一个DMA操作、一个同步操作或者一个NPU算子等。同一个流上的Task序列按顺序执行，不同流上的Task序列可并发执行。

上图展示了一条主流和一条从流，主从流之间通过Post/Wait这一组Task进行同步。主从流之间没有依赖关系时，Task可并行执行。如上图主流的TaskA、TaskB和从流的TaskX、TaskY可以是并行执行的。Post/Wait的具体含义会在后文给出。

Notify

Notify是NPU上的硬件资源，用来做同步。在集合通信中主要有两种作用：1）Rank内主从流之间的同步；2）跨Rank数据收发的同步。

和Notify有关的Task有两种：1）Post；2）Wait。

Post操作给对应的notify寄存器置1，并返回。如果对应的notify值已经是1，则不产生变化，直接返回。

Wait操作会等待对应的notify值变为1。条件满足后，将对应的notify值复位为0，并继续执行后续的Task。

Transport链路

要完成Rank间的数据通信需要先建立Transport链路，Transport链路分两种：1）SDMA链路，对应到HCCS/UB硬件连接；2）RDMA链路，对应到RoCE硬件连接。

每条Transport链路会申请各自的notify资源，不同的Transport之间不会复用notify。SDMA链路会申请四个notify，每端各两个；RDMA链路会申请六个notfy，每端各三个。

算法编写

算法注册与选择

算法注册流程

以AllGather算⼦新增 AllGatherNewExecutor 为例，完整的注册流程包括以下步骤：
第⼀步：Executor层⽂件创建与注册
创建Executor⽂件：
在⽬录 cann/hccl/src/domain/collective_communication/algorithm/impl/coll_executor/coll_all_gather/
下创建：
  • coll_all_gather_new_executor.cc ：实现⽂件
  • coll_all_gather_new_executor.h ：头⽂件
编译配置：
将 coll_all_gather_new_executor.cc 添加到该⽬录下的 CMakeLists.txt ⽂件的 src_list 中：
set(src_list
# ... 其他文件
${CMAKE_CURRENT_SOURCE_DIR}/coll_all_gather_new_executor.cc
)
Executor注册：
在 coll_all_gather_new_executor.cc ⽂件末尾使⽤ REGISTER_EXEC 宏进⾏注册：
REGISTER_EXEC("AllGatherNewExecutor", AllGatherNew, CollAllGatherNewExecutor);
宏参数说明：
  • 第⼀个参数：Executor的注册名称（字符串），该名称将在算法选择时使⽤。
  • 第⼆个参数：算法类型标识符。
  • 第三个参数：具体的Executor类名。
第⼆步：Template层⽂件创建与注册
创建Template⽂件：
在⽬录 cann/hccl/src/domain/collective_communication/algorithm/base/alg_template/temp_all_gather/
下创建：
  • all_gather_new.cc ：实现⽂件
  • all_gather_new.h ：头⽂件
编译配置：
将 all_gather_new.cc 添加到该⽬录下的 CMakeLists.txt ⽂件的 src_list_pub 中：
set(src_list_pub
# ... 其他文件
${CMAKE_CURRENT_SOURCE_DIR}/all_gather_new.cc
)
Template注册：
REGISTER_TEMPLATE(TemplateType::TEMPLATE_ALL_GATHER_NEW, AllGatherNew);
宏参数说明：
  • 第⼀个参数：模板类型枚举值（需要在 alg_template_base_pub.h 中定义）。
  • 第⼆个参数：具体的Template类名。

第三步：模板类型定义
在⽂件 cann/hccl/src/domain/collective_communication/algorithm/base/alg_template/alg_template_base_pub.h 中
的 TemplateType 枚举中添加新的模板类型定义：
enum TemplateType {
// ... 现有的模板类型
TEMPLATE_ALL_GATHER_NEW = 126, // 新增的AllGatherNew模板类型
// ... 其他模板类型
};

注册宏详解

REGISTER_EXEC 宏：
  • ⽤于向Executor注册器中注册算法执⾏器。
  • 使得框架能够通过算法名称（即注册的第⼀个参数）查找并创建对应的Executor实例。
  • 在算法选择阶段，框架会根据 SelectAlg 函数返回的名称匹配相应的Executor。
REGISTER_TEMPLATE 宏：
  • ⽤于向Template注册器中注册算法模板。
  • Executor 在执⾏时，可以通过模板类型枚举值（如 TEMPLATE_ALL_GATHER_NEW ）从注册器中获取对应的Template 实例，进⽽调⽤其实现的具体算法逻辑。

算法选择机制

算法的最终选择权掌握在 Operator 层。开发者需要修改对应算⼦的 SelectAlg 函数，让它在特定条件下返回自定义算法的注册名。
AllGather算法选择
对于AllGather算法，需要修改 cann/hccl/src/domain/collective_communication/algorithm/impl/operator/all_gather_operator.cc ⽂件中
的 SelectAlg 函数。
核⼼修改步骤：
  1. 定位SelectAlg函数：找到 AllGatherOperator::SelectAlg() 函数（约第36⾏）。
  2. 修改选择逻辑：为了调试和验证，我们可以暂时屏蔽掉原有的复杂选择逻辑，强制其返回我们新算法的名称。
HcclResult AllGatherOperator::SelectAlg(const std::string& tag, const OpParam& param,
std::string& algName, std::string& newTag)
{
// 单卡场景保持原有逻辑
if (userRankSize_ == 1 && (workflowMode_ ==
HcclWorkflowMode::HCCL_WORKFLOW_MODE_OP_BASE)) {
algName = "AllGatherSingleExecutor";
return HCCL_SUCCESS;
}
// 直接指定自定义算法（关键修改点）algName = "AllGatherNewExecutor"; // 此处必须与REGISTER_EXEC宏的第一个参数完全一致// 保留newTag生成逻辑
if (workflowMode_ == HcclWorkflowMode::HCCL_WORKFLOW_MODE_OPS_KERNEL_INFO_LIB) {
newTag = tag;
} else if (deviceType_ == DevType::DEV_TYPE_310P3) {
newTag = tag + algName;
} else {
AlgTypeLevel1 algType1 = algType_.algoLevel1;
auto level1Iter = HCCL_ALGO_LEVEL1_NAME_MAP.find(algType1);
CHK_PRT_RET(level1Iter == HCCL_ALGO_LEVEL1_NAME_MAP.end(), HCCL_ERROR("level1:
algType1[%u] is invalid.",
algType1), HCCL_E_INTERNAL);
newTag = tag + level1Iter->second + algName;
}
newTag += (param.aicpuUnfoldMode ? "_device" : "_host");
return HCCL_SUCCESS;
}

选择流程总结：

算法选择请求 → Operator::SelectAlg() → [AllGather: SelectAlgforAllGather()] → 返回算法名称 → 框架查找对应Executor → 创建执行实例
通过这种直接修改选择逻辑的⽅式，开发者可以强制框架使⽤⾃定义算法，极⼤地简化了开发和调试过程。

Executor层

完成算法的注册与选择配置后，我们就进⼊了算法实现的核⼼环节：Executor层的开发。 Executor 是算法逻辑的载 体，负责资源计算、任务编排和对底层 Template 的调⽤。
Executor层次结构
为了最⼤化地复⽤代码，HCCL的 Executor 采⽤了继承的层次结构。以AllGather为例：
CollExecutorBase (最基础的基类)
↓
CollCommExecutor (通信执行器基类)
↓
CollAllGatherExecutor (AllGather算子基类)
↓
CollAllGatherMeshExecutor (具体的Mesh算法Executor实现)

各层的职责分⼯：

  • CollAllGatherExecutor (基类)：为所有AllGather算法提供了⼀个通⽤的执⾏框架。它实现了顶层的 Orchestrate() 函数，负责处理不同的⼯作流模式，并定义了所有派⽣类都需要实现的公共接⼝（纯虚函数） 和数据结构。
  • CollAllGatherMeshExecutor (派⽣类)：⼀个具体的算法Executor实现。它继承⾃
  • CollAllGatherExecutor ，并专注于实现Mesh算法特有的逻辑，如资源计算、算法执⾏和 Template 选择。
基类实现分析
CollAllGatherExecutor 基类为开发者处理了⼤量通⽤⼯作，其提供的核⼼功能包括：
  1. 算法编排⼊⼝ ( Orchestrate )：统⼀的执⾏⼊⼝，开发者通常⽆需关⼼其内部复杂的模式判断。
  2. 公共⼯具函数：提供了数据切⽚计算、循环执⾏逻辑等常⽤功能。
  3. 统⼀接⼝定义：通过纯虚函数，为所有具体的AllGather算法实现定义了⼀套必须遵循的接⼝规范。
基类的核⼼虚函数：
class CollAllGatherExecutor : public CollCommExecutor {
protected:
// 资源计算相关
virtual HcclResult CalcStreamNum(u32& streamNum) = 0;
virtual HcclResult CalcCommInfo(std::vector<LevelNSubCommTransport>& opTransport) = 0;
// 算法执行相关
virtual HcclResult KernelRun(const OpParam &param, ExecMem &execMem) = 0;
virtual u64 CalcLoopMaxCount(const u64 cclBuffSize, const u32 unitSize) = 0;
// 算法模板选择
virtual HcclResult SelectTempAlg(std::unique_ptr<AlgTemplateBase> &tempAlg, u32
rankSize) = 0;
};

具体算法实现分析
以 CollAllGatherMeshExecutor 为例，可以看到，⼀个具体的 Executor 实现⾮常专注，它只需要覆写基类定义的若⼲个核⼼函数即可：
资源计算部分
// Stream数量计算
HcclResult CalcStreamNum(u32& streamNum) override {
u32 totalStreamNum = topoAttr_.deviceNumPerAggregation > 1U ?
topoAttr_.deviceNumPerAggregation - 1U : 1U;
streamNum = totalStreamNum - 1U; // Mesh算法使用 (设备数-1) 个从流
return HCCL_SUCCESS;
}
// 通信链路计算
HcclResult CalcCommInfo(std::vector<LevelNSubCommTransport>& opTransport) override {
// 设置内存类型
TransportMemType inputType, outputType;
CHK_RET(CalcTransportMemType(inputType, outputType));
算法执⾏部分
算法模板选择部分
// 计算Level0和Level1的通信信息
CHK_RET(CalcLevel0CommInfo(inputType, outputType, opTransport)); // Mesh连接
CHK_RET(CalcLevel1CommInfo(inputType, outputType, opTransport)); // 跨服务器连接
return HCCL_SUCCESS;
}
算法执⾏部分
HcclResult KernelRun(const OpParam &param, ExecMem &execMem) override {
// 第一步：数据初始化 - 将input数据拷贝到output对应位置
// ...内存拷贝逻辑
// 第二步：Level0 Mesh算法执行
std::unique_ptr<AlgTemplateBase> level0TempAlg;
level0TempAlg = AlgTemplateRegistry::Instance().GetAlgTemplate(
TemplateType::TEMPLATE_ALL_GATHER_MESH, dispatcher_);
CHK_RET(RunTemplate(level0TempAlg, level0CommInfo));
// 第三步：Level1算法执行 (跨服务器)
std::unique_ptr<AlgTemplateBase> level1TempAlg;
CHK_RET(SelectTempAlg(level1TempAlg, level1RankSize));
CHK_RET(RunTemplate(level1TempAlg, level1CommInfo));
return HCCL_SUCCESS;
}
算法模板选择部分
HcclResult SelectTempAlg(std::unique_ptr<AlgTemplateBase> &level1TempAlg, u32
level1RankSize) override {
if (level1RankSize > 1) {
if (algType_.algoLevel1 == AlgTypeLevel1::ALG_LEVEL1_RING) {
level1TempAlg = AlgTemplateRegistry::Instance().GetAlgTemplate(
TemplateType::TEMPLATE_ALL_GATHER_RING, dispatcher_);
} else if (algType_.algoLevel1 == AlgTypeLevel1::ALG_LEVEL1_NHR) {
level1TempAlg = AlgTemplateRegistry::Instance().GetAlgTemplate(
TemplateType::TEMPLATE_ALL_GATHER_NHR, dispatcher_);
} else {
// 默认使用Halving-Doubling算法
level1TempAlg = AlgTemplateRegistry::Instance().GetAlgTemplate(
TemplateType::TEMPLATE_ALL_GATHER_RECURSIVE_HALVING_DOUBLING, dispatcher_);
}
return HCCL_SUCCESS;
}
return HCCL_E_UNAVAIL;
}
调⽤关系总结

Operator::SelectAlg()
            ↓ 返回算法名称
Framework查找并创建Executor实例
        ↓
CollAllGatherExecutor::Orchestrate() (基类统一入口)
        ↓ 根据工作流模式选择执行路径
CollAllGatherNewExecutor::KernelRun() (具体算法实现)
        ↓ 调用Template执行具体算法
AlgTemplate::RunAsync() (底层算法模板)
        ↓
底层通信接口 (link->TxAsync/RxAsync)

Template层

在 Executor 层完成了算法的顶层设计与编排后，我们便深⼊到算法实现的最底层—— Template 层。 Template 是具体通信算法的载体，负责将 Executor 的指令转化为实际的数据传输和同步操作。
Template层组织结构
alg_template/
├── alg_template_base.h/.cc # Template基类定义
├── alg_template_base_pub.h # Template基类公共接口
├── alg_template_register.h/.cc # Template注册机制
├── temp_all_gather/ # AllGather算法模板
│ ├── all_gather_mesh.cc/.h # Mesh算法实现
│ ├── all_gather_ring.cc/.h # Ring算法实现
│ └── ... # 其他AllGather变体
├── temp_all_reduce/ # AllReduce算法模板
└── ... # 其他算子的模板
Template基类结构
所有的 Template 都继承⾃ AlgTemplateBase ，该基类提供了实现⼀个算法模板所需的通⽤接⼝和基础功能：
class AlgTemplateBase { // AlgTemplateBase是ExecutorBase的别名
public:
// 构造函数
explicit ExecutorBase(const HcclDispatcher dispatcher);
// 异步执行接口（核心纯虚函数）
virtual HcclResult RunAsync(const u32 rank, const u32 rankSize,
const std::vector<LINK> &links) = 0;
// 多种Prepare重载接口，用于从Executor接收参数
virtual HcclResult Prepare(DeviceMem &inputMem, DeviceMem &outputMem,
DeviceMem &scratchMem, const u64 count, const HcclDataType dataType,
const Stream &stream, const HcclReduceOp reductionOp, const u32 root,
const std::vector<Slice> &slices, const u64 baseOffset);
// Mesh算法专用Prepare接口
virtual HcclResult Prepare(std::vector<Stream> &meshStreams,
std::vector<std::shared_ptr<LocalNotify>> &meshSignal,
std::vector<std::shared_ptr<LocalNotify>> &meshSignalAux,
u32 userRank, HcomCollOpInfo *opInfo, u32 interRank, u32 interRankSize);
protected:
// 基础属性
DeviceMem inputMem_; // 输入内存
DeviceMem outputMem_; // 输出内存
DeviceMem scratchMem_; // 暂存内存
u64 count_; // 数据元素数量
HcclDataType dataType_; // 数据类型
Stream stream_; // 执行流
std::vector<Slice> slices_; // 数据切片信息
u64 baseOffset_; // 基址偏移
const HcclDispatcher dispatcher_; // 任务派发器
};
Executor与Template调⽤关系
Executor 通过 AlgTemplateRegistry （算法模板注册器）来获取并调⽤相应的 Template 实例。
// 在CollAllGatherMeshExecutor::KernelRun中的调用示例
HcclResult CollAllGatherMeshExecutor::KernelRun(const OpParam &param, ExecMem &execMem) {
// 第一步：从注册器中获取算法模板实例
std::unique_ptr<AlgTemplateBase> level0TempAlg;
if (topoAttr_.deviceType == DevType::DEV_TYPE_910B) {
level0TempAlg = AlgTemplateRegistry::Instance().GetAlgTemplate(
TemplateType::TEMPLATE_ALL_GATHER_MESH_ATOMIC, dispatcher_);
} else {
level0TempAlg = AlgTemplateRegistry::Instance().GetAlgTemplate(
TemplateType::TEMPLATE_ALL_GATHER_MESH, dispatcher_);
}
// 第二步：通过Prepare接口为Template设置执行所需的环境和参数
CHK_RET(level0TempAlg->Prepare(algResResp_->slaveStreams, algResResp_->notifiesMain,
algResResp_->notifiesAux, topoAttr_.userRank, nullptr, commIndex, level0RankSize));
CHK_RET(level0TempAlg->Prepare(currentOutputMem, currentOutputMem, execMem.inputMem,
execMem.count * level0RankSize, param.DataDes.dataType, param.stream,
HCCL_REDUCE_RESERVED, LEVEL0_BRIDGE_RANK_ID, dataSegsSlice, baseOffset));
// 第三步：调用RunTemplate，最终会执行到Template的RunAsync函数
CHK_RET(RunTemplate(level0TempAlg, level0CommInfo));
return HCCL_SUCCESS;
}
AllGather Mesh算法模板分析
以 AllGatherMesh 为例，我们可以看到⼀个具体的 Template 是如何实现的。
类定义
AllGatherMesh 继承⾃ AlgTemplateBase ，并覆写了核⼼的 Prepare 和 RunAsync 接⼝。同时，它还定义了Mesh
算法⾃⾝需要的私有函数（如 RunAllGather ）和成员变量（如 meshStreams_ ⽤于多流并⾏）。
class AllGatherMesh : public AlgTemplateBase {
public:
explicit AllGatherMesh(const HcclDispatcher dispatcher);
~AllGatherMesh();
// Mesh算法专用准备接口
HcclResult Prepare(std::vector<Stream> &meshStreams,
std::vector<std::shared_ptr<LocalNotify>> &meshSignal,
std::vector<std::shared_ptr<LocalNotify>> &meshSignalAux,
u32 userRank, HcomCollOpInfo *opInfo, u32 interRank, u32 interRankSize) override;
// 异步执行接口
HcclResult RunAsync(const u32 rank, const u32 rankSize,
const std::vector<LINK> &links) override;
private:
// 核心通信函数
HcclResult Tx(const LINK &link, const Slice &txSlice, const Slice &dstSlice, Stream
stream);
HcclResult Rx(const LINK &link, const Slice &srcSlice, const Slice &rxSlice, Stream
stream);
// AllGather算法实现
HcclResult RunAllGather(const std::vector<LINK> &links,
const std::vector<Slice> &outputSlices, const std::vector<Slice> &inputSlices);
// Mesh算法特有属性
std::vector<Stream> meshStreams_; // 多流并行执行
std::vector<std::shared_ptr<LocalNotify>> *meshSignal_; // 主流同步信号
std::vector<std::shared_ptr<LocalNotify>> *meshSignalAux_; // 从流同步信号
u32 interRank_; // 算法内rank
u32 interRankSize_; // 算法内rank总数
u32 userRank_; // 用户层rank
};
核⼼算法实现
AllGather Mesh算法的核⼼逻辑在 RunAllGather 函数中。它通过⼀个循环，在每⼀轮与不同的对端（ dstRank ）进
⾏握⼿、数据传输（ Tx / Rx ）和同步。
HcclResult AllGatherMesh::RunAllGather(const std::vector<LINK> &links,
const std::vector<Slice> &outputSlices, const std::vector<Slice> &inputSlices) {
Stream subStream;
HcclResult ret = HCCL_SUCCESS;
// Mesh算法：每轮与一个邻居交换数据
for (u32 round = 1; round < interRankSize_; round++) {
u32 dstRank = BackwardRank(interRank_, interRankSize_, round);
// 流选择：最后一轮使用主流，其他轮使用从流
subStream = (round == interRankSize_ - 1) ? stream_ : meshStreams_[round - 1];
// 1. 握手同步
CHK_RET(links[dstRank]->TxAck(subStream)); // 发送握手信号
CHK_RET(links[dstRank]->RxAck(subStream)); // 接收握手确认
// 2. 数据传输
CHK_RET(Tx(links[dstRank], inputSlices[interRank_], outputSlices[interRank_],
subStream));
CHK_RET(Rx(links[dstRank], inputSlices[dstRank], outputSlices[dstRank], subStream));
// 3. 完成同步
CHK_RET(ExecuteBarrier(links[dstRank], subStream));
CHK_RET(links[dstRank]->RxWaitDone(subStream));
CHK_RET(links[dstRank]->TxWaitDone(subStream));
}
return HCCL_SUCCESS;
}
数据传输函数
底层的 Tx 和 Rx 函数封装了对 link 对象的异步调⽤，是数据传输的最终执⾏者。
// 发送数据
HcclResult AllGatherMesh::Tx(const LINK &link, const Slice &txSlice,
const Slice &dstSlice, Stream stream) {
DeviceMem srcMem = outputMem_.range(txSlice.offset, txSlice.size);
return link->TxAsync(UserMemType::OUTPUT_MEM, baseOffset_ + dstSlice.offset,
srcMem.ptr(), txSlice.size, stream);
}
// 接收数据
HcclResult AllGatherMesh::Rx(const LINK &link, const Slice &srcSlice,
const Slice &rxSlice, Stream stream) {
DeviceMem rcvMem = outputMem_.range(rxSlice.offset, rxSlice.size);
return link->RxAsync(UserMemType::OUTPUT_MEM, baseOffset_ + srcSlice.offset,
rcvMem.ptr(), rxSlice.size, stream);
}
Template与Executor的协作总结
Executor 和 Template 的协作关系清晰明确，共同完成⼀次集合通信任务：
Executor 的职责：
  • 作为算法的“总指挥”，负责整体编排和分层调⽤。
  • 计算资源、管理内存。
  • 根据需求选择要执⾏的 Template 。
Template 的职责：
  • 作为算法的“执⾏者”，实现具体的通信逻辑。
  • 处理底层的数据传输和同步细节。
协作流程图：

Executor::KernelRun()
        ↓ 获取Template实例
AlgTemplateRegistry::GetAlgTemplate()
        ↓ 设置执行参数
AlgTemplate::Prepare()
        ↓ 执行算法
Executor::RunTemplate()
        ↓
AlgTemplate::RunAsync()
        ↓
底层通信接口 (link->TxAsync/RxAsync)
http://www.dtcms.com/a/389379.html

相关文章：

  • uv管理的python项目怎么打包成docker部署发布上线
  • unity之uv编辑
  • 华为电源研发的IPD实践：从概念到生命周期的结构化管控
  • MySQL中什么是回表查询，如何避免和优化？
  • MySql01
  • 2025版基于springboot的旅游门票预定系统
  • 3. Linux 计划任务管理
  • EasyCVR在智慧城市中场景中的核心应用与实践方案
  • LeetCode 刷题【84. 柱状图中最大的矩形】
  • CPP网络编程基础知识
  • 临床AI产品化全流程研究：环境聆听、在环校验与可追溯系统的多技术融合实践（上）
  • 【k8s】web服务优雅关闭用户连接
  • 设计模式的七大原则总述
  • C/C++柔性数组
  • 从 LiveData 到 Flow：Android 状态管理的现代化演进
  • 34、模型微调技术实战 - LoRA参数高效微调全流程
  • ASP.NET Core 中基于角色的授权
  • C++ 在 Windows 下实现最基础的 WebSocket 服务端与客户端
  • 并发、分布式和实时设计方法
  • C语言第15讲
  • windows 下使用 bat 批处理运行 Chrome 无头模式刷一波访问量
  • 项目名称：基于Qt框架的跨平台天气预报应用程序​​
  • 王自如重操旧业拆箱iPhone：苹果新机发售旧机发热是惯例……
  • 鸿蒙Next Core File Kit：文件管理的高效安全之道
  • Java-128 深入浅出 MySQL MyCat 分布式数据库中间件详解：架构、功能与应用场景
  • gozero使用gRPC-gateway生成http网关
  • Go语言100个实战案例-项目实战篇:股票行情数据爬虫
  • Python开发最新 PyCharm 2025使用（附详细教程）
  • 【session基础】
  • 客户流失预警中uplift建模案例、入门学习（二）