摘要

在计算图类项目中，分散的算子会带来频繁的数据搬运开销，导致整体计算效率下降。CANN生态下的graph-autofusion仓库，是一套面向计算图的算子自动融合工具库，能自动检测计算图中可合并的连续算子并完成融合，减少数据交互成本。本文从代码逻辑、融合规则实现、项目集成流程三个维度，拆解graph-autofusion的自动化优化能力，帮助开发者低代码实现计算图性能提升。

一、graph-autofusion仓库的定位：计算图的“自动性能优化器”

graph-autofusion是CANN生态中专注计算图算子自动融合的工具库，核心解决“分散算子的冗余数据搬运”问题——通过检测计算图中连续的、无依赖冲突的算子，将其合并为一个复合算子，从而减少内存读写次数，提升计算效率。

该仓库的核心能力：

• 支持常见算子（加法、乘法、激活函数等）的自动融合检测；
• 提供可扩展的融合规则接口，支持自定义融合逻辑；
• 输出融合后的计算图，直接对接现有执行引擎。

二、graph-autofusion的代码架构：分层实现融合流程

graph-autofusion采用“检测-规则-执行”的分层架构，便于扩展不同场景的融合逻辑：

graph-autofusion/
├── include/          # 接口头文件：分功能模块暴露接口
│   ├── fusion_detector.h  # 融合检测接口
│   ├── fusion_rules.h     # 融合规则接口
│   └── fusion_executor.h  # 融合执行接口
├── src/              # 核心实现：对应接口的逻辑代码
│   ├── fusion_detector.c
│   ├── fusion_rules.c
│   └── fusion_executor.c
├── test/             # 单元测试：验证融合逻辑的正确性
│   ├── test_add_mul_fusion.c
│   └── test_rule_extend.c
└── examples/         # 集成示例：计算图融合的完整流程
    └── graph_fusion_demo.c

三、核心逻辑实现：“加法+乘法”算子的自动融合

以“连续加法+乘法算子”的融合为例，拆解graph-autofusion的核心代码逻辑：

1. 接口定义（include/fusion_rules.h）

#ifndef FUSION_RULES_H
#define FUSION_RULES_H

// 算子类型枚举
typedef enum {
    OP_TYPE_ADD,  // 加法算子
    OP_TYPE_MUL,  // 乘法算子
    OP_TYPE_UNKNOWN
} OpType;

// 算子节点结构体
typedef struct {
    OpType type;
    float *input;
    float *output;
    float param;  // 单参数算子的参数（如a + b中的b）
} OpNode;

/**
 * @brief 检测“加法+乘法”连续算子是否可融合
 * @param node1 第一个算子节点
 * @param node2 第二个算子节点
 * @return 1表示可融合，0表示不可融合
 */
int check_add_mul_fusion(const OpNode *node1, const OpNode *node2);

/**
 * @brief 执行“加法+乘法”算子融合（合并为a*(x + b)）
 * @param node1 加法算子节点
 * @param node2 乘法算子节点
 * @param fused_output 融合后的输出结果
 * @return 0表示成功，-1表示参数错误
 */
int execute_add_mul_fusion(const OpNode *node1, const OpNode *node2, float *fused_output);

#endif // FUSION_RULES_H

2. 核心实现（src/fusion_rules.c）

#include "fusion_rules.h"
#include <string.h>

// 检测“加法+乘法”是否可融合
int check_add_mul_fusion(const OpNode *node1, const OpNode *node2) {
    // 条件：node1是加法、node2是乘法，且node1的输出是node2的输入
    if (node1 == NULL || node2 == NULL) return 0;
    return (node1->type == OP_TYPE_ADD) && (node2->type == OP_TYPE_MUL) && (node1->output == node2->input);
}

// 执行“加法+乘法”融合计算
int execute_add_mul_fusion(const OpNode *node1, const OpNode *node2, float *fused_output) {
    if (node1 == NULL || node2 == NULL || fused_output == NULL) return -1;
    
    // 融合逻辑：fused_output = (node1->input + node1->param) * node2->param
    size_t data_len = 0;
    // 假设输入是长度为4的数组（实际场景可通过节点元数据获取长度）
    data_len = 4;
    for (size_t i = 0; i < data_len; i++) {
        fused_output[i] = (node1->input[i] + node1->param) * node2->param;
    }
    return 0;
}

四、项目集成示例：计算图的自动融合流程

以下是复用graph-autofusion实现计算图算子融合的示例：

#include <stdio.h>
#include "fusion_rules.h"

int main() {
    // 1. 准备原始数据与算子节点
    float input[4] = {1.0f, 2.0f, 3.0f, 4.0f};
    float add_output[4] = {0};
    float mul_output[4] = {0};
    float fused_output[4] = {0};

    // 加法算子：input + 2.0
    OpNode add_node = {
        .type = OP_TYPE_ADD,
        .input = input,
        .output = add_output,
        .param = 2.0f
    };
    // 乘法算子：add_output * 3.0
    OpNode mul_node = {
        .type = OP_TYPE_MUL,
        .input = add_output,
        .output = mul_output,
        .param = 3.0f
    };

    // 2. 检测是否可融合
    if (check_add_mul_fusion(&add_node, &mul_node)) {
        printf("检测到“加法+乘法”算子可融合\n");
        // 3. 执行融合计算
        int ret = execute_add_mul_fusion(&add_node, &mul_node, fused_output);
        if (ret == 0) {
            printf("=== 融合后计算结果 ===\n");
            for (size_t i = 0; i < 4; i++) {
                printf("原始输入%.1f → 融合输出%.1f\n", input[i], fused_output[i]);
            }
        }
    } else {
        printf("算子不可融合\n");
    }

    return 0;
}

编译与运行命令

# 编译：链接graph-autofusion的融合规则实现
gcc graph_fusion_demo.c ../src/fusion_rules.c -o fusion_demo -I ../include
# 运行
./fusion_demo

输出结果

检测到“加法+乘法”算子可融合
=== 融合后计算结果 ===
原始输入1.0 → 融合输出9.0
原始输入2.0 → 融合输出12.0
原始输入3.0 → 融合输出15.0
原始输入4.0 → 融合输出18.0

五、总结

graph-autofusion通过自动化的算子融合逻辑，让开发者无需手动调整计算图结构，即可低代码实现计算效率的提升。其可扩展的融合规则接口，还支持根据业务场景自定义融合逻辑，适配更多复杂计算图的优化需求。

相关链接

• CANN组织链接：https://atomgit.com/cann
• graph-autofusion仓库链接：https://atomgit.com/cann/graph-autofusion