NPU 架构与性能概览

1. 概述

1.1 功能简介

RK3576 内置高性能 NPU（Neural Processing Unit），算力达到 6 TOPS（INT8），是 Rockchip 新一代 AI 加速引擎。NPU 支持多种量化精度格式，包括 INT8、INT16 和 FP16，能够在保持较高推理精度的同时提供极高的计算吞吐量。

NPU 模块由多个独立推理核心组成（NPU0、NPU1、NPU2），每个核心内部包含大规模 MAC（Multiply-Accumulate）阵列，可并行执行卷积、矩阵乘法、激活等深度学习算子。多个核心可协同工作以加速大模型推理，也可分别独立运行不同模型，实现灵活的多任务调度。

核心特性：

特性	说明
算力	6 TOPS（INT8）
量化精度	INT8 / INT16 / FP16
推理核心	3 个独立核心（NPU0、NPU1、NPU2）
架构	基于 Rockchip 自研 NPU 架构，MAC 阵列并行计算
软件栈	RKNN Toolkit2（模型转换）+ rknpu2（驱动）+ librknnrt（运行时）
算子覆盖	60+ ONNX 算子、35+ Caffe 算子、30+ PyTorch 算子、35+ TensorFlow 算子、15+ Darknet 算子
框架支持	ONNX、PyTorch、TensorFlow、Caffe、Darknet

NPU 核心数量、算子覆盖等架构细节以实际发布的 RK3576 SDK 为准（待板上确认）。

1.2 应用场景

RK3576 NPU 适用于以下典型 AI 推理场景：

• 智能安防：实时视频分析、人脸识别、行为检测、车牌识别
• 智慧零售：商品识别、客流统计、自助结算
• 工业视觉：缺陷检测、产品分类、尺寸测量
• 智能驾驶：ADAS 辅助驾驶、DMS 驾驶员监控、环视拼接
• 边缘 AI 终端：多路视频并发推理、云端模型边缘部署
• 机器人：SLAM、目标跟踪、语义理解
• 智慧医疗：医学影像辅助诊断、X 光片分析
• AIoT 终端：语音识别加速、智能音箱、无人机视觉

1.3 工作原理

RK3576 NPU 的工作流程涉及硬件加速层、驱动层、运行时层和应用层四个层次的协同配合：

┌─────────────────────────────────────────────────────┐
│                  应用层（Application）                 │
│   Python 应用 / C/C++ 应用 / Android App              │
├─────────────────────────────────────────────────────┤
│              工具链层（rknn-toolkit2）                  │
│   模型转换 · 量化校准 · 模型优化 · 模型导出              │
├─────────────────────────────────────────────────────┤
│             运行时层（librknnrt）                       │
│   模型加载 · 内存分配 · 算子调度 · 推理执行              │
├─────────────────────────────────────────────────────┤
│              驱动层（rknpu2）                          │
│   内核模块 · IOCTL 接口 · DMA-BUF 管理                 │
├─────────────────────────────────────────────────────┤
│              硬件层（NPU Hardware）                    │
│   NPU0 Core · NPU1 Core · NPU2 Core                  │
│   MAC 阵列 · 片上 SRAM · 数据搬运引擎                   │
└─────────────────────────────────────────────────────┘

工作流程说明：

阶段	组件	功能
模型转换	rknn-toolkit2	在 PC 主机上将 ONNX/PyTorch/TensorFlow 等模型转换为 RKNN 格式，执行量化校准
模型传输	adb / scp	将转换后的 .rknn 模型文件拷贝到开发板存储
运行时初始化	librknnrt	加载 RKNN 模型，分配 NPU 内存，初始化推理上下文
推理执行	NPU 硬件	NPU 核心接收指令，MAC 阵列并行计算，输出推理结果
结果获取	librknnrt	从 NPU 内存读回输出张量，供应用层处理

多核调度机制：

RK3576 的 3 个 NPU 核心支持以下调度模式：

模式	说明	适用场景
单核模式	仅使用一个核心推理	单模型、低延迟需求
多核分组	多个核心协同推理同一模型	大模型、高吞吐需求
多核独立	各核心独立运行不同模型	多任务并发推理

---

2. 硬件准备

2.1 硬件清单

序号	物料名称	型号/规格	数量	用途
1	核心板 + 底板	C-3576BQ 核心板 + M4-R2 底板	1	主开发板
2	调试串口	USB to TTL 3.3V 转换器	1	串口调试，波特率 1500000
3	存储扩展（可选）	M.2 SSD/算力模块、TF 卡（最大 128GB）	1	模型文件大容量存储
4	电源适配器	5V/2A 电源（Type-C 或 6pin 供电）	1	主板供电（空载最小 1000mA）
5	显示器 + HDMI 线	支持 4K 的显示器	1	图形界面调试（可选）

2.2 硬件确认

接入调试串口后，启动开发板，通过串口终端确认 NPU 硬件信息：

# 查看设备树中 NPU 节点
dtc -I dtb -O dts /sys/firmware/fdt | grep -A 8 "npu@"
# 预期输出: compatible = "rockchip,rk3576-npu"

# 查看内存信息，确认 NPU 可用内存
cat /proc/meminfo | grep MemTotal

# 查看 SoC 型号
cat /proc/device-tree/compatible
# 预期输出包含 rk3576 关键字

以上 NPU 设备树节点路径和寄存器信息以实际发布的 RK3576 SDK 设备树为准（待板上确认）。

---

3. 软件准备

3.1 内核配置

在 Linux 内核配置中，需要开启 NPU 相关驱动选项。使用 menuconfig 或直接修改 .config 文件：

# 路径: Device Drivers → Accelerators → Rockchip NPU
CONFIG_ROCKCHIP_RKNPU=y
CONFIG_RKNPU=y

确认内核版本及驱动加载情况：

# 查看内核版本
uname -a

# 查看 NPU 驱动是否编译入内核
grep -i rknpu /boot/config-$(uname -r)
# 预期输出: CONFIG_ROCKCHIP_RKNPU=y

3.2 设备树

NPU 设备树节点定义了 NPU 硬件的寄存器地址、中断号、时钟和复位等信息：

npu: npu@<base_addr> {
    compatible = "rockchip,rk3576-npu";
    reg = <0x0 <base_addr> 0x0 0x20000>;
    interrupts = <GIC_SPI <irq_num> IRQ_TYPE_LEVEL_HIGH>;
    clocks = <&cru CLK_NPU>, <&cru PCLK_NPU>;
    clock-names = "clk_npu", "pclk_npu";
    resets = <&cru SRST_NPU>;
    reset-names = "npu";
    status = "disabled";
    #cooling-cells = <2>;
};

设备树节点说明：

属性	值	说明
compatible	rockchip,rk3576-npu	NPU 设备兼容字符串
reg	<base_addr>, 0x20000	寄存器基地址和大小（128KB）
interrupts	GIC_SPI <irq_num>	SPI 中断号，高电平触发
clocks	CLK_NPU, PCLK_NPU	NPU 功能时钟和总线时钟
resets	SRST_NPU	NPU 复位信号
status	disabled	需要在板级 DTS 中启用

以上寄存器基地址、中断号与时钟标识为 RK 平台通用结构示例，具体数值以实际发布的 RK3576 SDK 设备树为准（待板上确认）。

在板级设备树中启用 NPU：

&npu {
    status = "okay";
};

---

4. 操作步骤

4.1 查看 NPU 驱动信息

启动开发板后，通过以下命令确认 NPU 驱动已正确加载：

# 查看 rknpu 模块是否加载
lsmod | grep rknpu
# 预期输出: rknpu  xxxx  0

# 查看内核日志中 NPU 初始化信息
dmesg | grep -i npu
# 预期输出包含: rockchip-rk3576-npu ...: ... initialized

# 查看 NPU 设备节点
ls -la /dev/dri/
# 预期包含 render 节点

4.2 查看 NPU 频率

# 查看 NPU 当前时钟频率（Hz）
cat /sys/kernel/debug/clk/clk_npu/clk_rate

# 查看 NPU 可用频率档位
cat /sys/kernel/debug/clk/clk_npu/clk_possible_rates

# 查看 NPU 使能计数
cat /sys/kernel/debug/clk/clk_npu/clk_enable_count

NPU 具体频率档位以实际 RK3576 SDK 内核配置为准。

4.3 安装 RKNN Toolkit2

在 PC 主机（x86_64 Ubuntu）上安装 RKNN 模型转换工具：

# 创建 Python 虚拟环境
python3 -m venv rknn_env
source rknn_env/bin/activate

# 安装 rknn-toolkit2（使用 Rockchip 提供的 wheel 包）
pip install rknn-toolkit2-<version>.whl

# 验证安装
python3 -c "from rknn.api import RKNN; print('RKNN Toolkit2 installed successfully')"

4.4 模型转换示例

将 ONNX 模型转换为 RKNN 格式：

from rknn.api import RKNN

rknn = RKNN()

# 配置输入预处理参数
rknn.config(mean_values=[[123.675, 116.28, 103.53]],
            std_values=[[58.395, 57.12, 57.375]],
            target_platform='rk3576')

# 加载 ONNX 模型
rknn.load_onnx(model='model.onnx')

# 执行量化（INT8）
rknn.build(do_quantization=True, dataset='calibration_data.txt')

# 导出 RKNN 模型
rknn.export_rknn('model.rknn')

rknn.release()
print("Model conversion completed: model.rknn")

4.5 传输模型到开发板

# 通过 scp 传输
scp model.rknn root@<board_ip>:/data/

# 或通过 adb 推送模型文件（Android 系统）
adb push model.rknn /data/

4.6 在开发板上执行推理

使用 Python 接口在开发板上运行推理：

from rknnlite.api import RKNNLite
import numpy as np

# 初始化 RKNNLite
rknn = RKNNLite()

# 加载 RKNN 模型
rknn.load_rknn('model.rknn')

# 初始化运行时，指定 NPU 核心
rknn.init_runtime(core_mask=RKNNLite.NPU_CORE_0)

# 准备输入数据
img = np.random.randint(0, 255, size=(1, 224, 224, 3), dtype=np.uint8)

# 执行推理
outputs = rknn.inference(inputs=[img])

# 处理输出
print(f"Output shape: {outputs[0].shape}")
print(f"Predicted class: {np.argmax(outputs[0])}")

# 释放资源
rknn.release()

---

5. 代码详解

5.1 NPU 硬件架构

RK3576 NPU 内部由多个独立的推理核心组成，每个核心具有完整的计算单元和本地存储：

┌──────────────────────────────────────────────────┐
│              RK3576 NPU 子系统                     │
│                                                   │
│  ┌────────────┐  ┌────────────┐  ┌────────────┐  │
│  │   NPU0     │  │   NPU1     │  │   NPU2     │  │
│  │ ┌────────┐ │  │ ┌────────┐ │  │ ┌────────┐ │  │
│  │ │MAC 阵列│ │  │ │MAC 阵列│ │  │ │MAC 阵列│ │  │
│  │ └────────┘ │  │ └────────┘ │  │ └────────┘ │  │
│  │ ┌────────┐ │  │ ┌────────┐ │  │ ┌────────┐ │  │
│  │ │片上SRAM│ │  │ │片上SRAM│ │  │ │片上SRAM│ │  │
│  │ └────────┘ │  │ └────────┘ │  │ └────────┘ │  │
│  └────────────┘  └────────────┘  └────────────┘  │
│                                                   │
│  ┌──────────────────────────────────────────┐     │
│  │         共享数据总线 / DMA 引擎            │     │
│  └──────────────────────────────────────────┘     │
│                                                   │
│  ┌──────────────────────────────────────────┐     │
│  │      AXI 总线接口（连接 DDR 控制器）       │     │
│  └──────────────────────────────────────────┘     │
└──────────────────────────────────────────────────┘

每个 NPU 核心内部的 MAC 阵列负责执行卷积和矩阵乘法运算。片上 SRAM 用于缓存权重数据和中间特征图，减少对外部 DDR 的访问带宽压力。DMA 引擎负责在 DDR 和片上 SRAM 之间搬运数据。

NPU 核心数量与 MAC 阵列规格为 RK 平台通用结构描述，具体以实际发布的 RK3576 规格书为准（待板上确认）。

5.2 RKNN 软件栈详解

RKNN 软件栈分为三个层次：

rknn-toolkit2（主机端工具链）：

模块	功能
模型加载	支持 ONNX、PyTorch、TensorFlow、Caffe、Darknet 格式
图优化	算子融合、常量折叠、冗余节点消除
量化校准	基于校准数据集的 INT8/INT16 量化
模型导出	生成 .rknn 二进制模型文件
仿真验证	在 PC 上模拟 NPU 推理行为

rknpu2（内核驱动）：

功能	说明
IOCTL 接口	为用户态运行时提供设备控制接口
DMA-BUF 管理	管理 NPU 与 DDR 之间的内存共享
中断处理	处理 NPU 完成中断和错误中断
时钟管理	控制 NPU 核心时钟频率和功耗状态
多核心调度	分配和管理 NPU0/NPU1/NPU2 核心资源

librknnrt（运行时库）：

功能	说明
模型加载	解析 .rknn 文件并映射到 NPU 内存
内存管理	分配推理所需的输入/输出缓冲区
算子调度	将模型中的算子分配到合适的 NPU 核心
推理执行	触发 NPU 硬件执行计算
后处理	提供输出数据格式转换接口

5.3 RKNN C/C++ API 概览

在嵌入式场景中，通常使用 C/C++ API 进行推理以获得最佳性能：

#include "rknn_api.h"
#include <stdio.h>
#include <stdlib.h>

int main() {
    rknn_context ctx;
    rknn_input inputs[1];
    rknn_output outputs[1];
    rknn_input_output_num io_num;

    // 1. 读取模型文件
    FILE *fp = fopen("model.rknn", "rb");
    fseek(fp, 0, SEEK_END);
    int model_size = ftell(fp);
    fseek(fp, 0, SEEK_SET);
    void *model_data = malloc(model_size);
    fread(model_data, 1, model_size, fp);
    fclose(fp);

    // 2. 初始化 RKNN 上下文
    rknn_init(&ctx, model_data, model_size, 0, NULL);
    free(model_data);

    // 3. 查询输入输出信息
    rknn_query(ctx, RKNN_QUERY_IN_OUT_NUM, &io_num, sizeof(io_num));
    printf("Input num: %d, Output num: %d\n", io_num.n_input, io_num.n_output);

    // 4. 配置输入
    inputs[0].index = 0;
    inputs[0].type = RKNN_TENSOR_UINT8;
    inputs[0].size = 224 * 224 * 3;
    inputs[0].fmt = RKNN_TENSOR_NHWC;
    inputs[0].buf = input_image_data;
    inputs[0].pass_through = 0;
    rknn_inputs_set(ctx, 1, inputs);

    // 5. 执行推理
    rknn_run(ctx, NULL);

    // 6. 获取输出
    outputs[0].want_float = 1;
    rknn_outputs_get(ctx, 1, outputs, NULL);
    printf("Output[0] shape: [%d, %d, %d, %d]\n",
           outputs[0].size / (224 * 224),
           224, 224, 1);

    // 7. 释放资源
    rknn_outputs_release(ctx, 1, outputs);
    rknn_destroy(ctx);

    return 0;
}

编译命令：

aarch64-linux-gnu-gcc -o rknn_demo rknn_demo.c -lrknn_api -I./include -L./lib

5.4 内存管理（DMA-BUF）

RK3576 NPU 使用 DMA-BUF 机制实现 NPU 与 CPU 之间的零拷贝内存共享：

#include <linux/dma-buf.h>

// NPU 推理所需的输入/输出缓冲区通过 DMA-BUF 分配
// 数据在 DDR 中由 CPU 或 ISP 写入后，NPU 可直接通过 DMA 访问
// 避免了 CPU 和 NPU 之间的数据拷贝开销

内存布局：

区域	用途	说明
输入缓冲区	存放预处理后的输入张量	通过 DMA-BUF 在 CPU 和 NPU 间共享
模型权重区	存放量化后的模型权重	加载模型时由 librknnrt 分配
中间特征图	存放层间计算结果	NPU 运行时自动管理
输出缓冲区	存放推理输出结果	通过 DMA-BUF 供 CPU 读取

---

6. 常见问题

6.1 NPU 驱动未加载

现象： 执行 lsmod | grep rknpu 无输出，或 /dev/dri/ 下无 render 节点。

解决方案：

# 检查内核配置
grep -i rknpu /boot/config-$(uname -r)
# 确认 CONFIG_ROCKCHIP_RKNPU=y 和 CONFIG_RKNPU=y

# 检查设备树 NPU 节点是否启用
dtc -I dtb -O dts /sys/firmware/fdt | grep -A 8 "npu@"
# 应包含 status = "okay"

# 查看内核日志中的错误信息
dmesg | grep -i npu
# 关注是否有 probe 失败或时钟错误

# 如果设备树中 status 为 "disabled"，需修改板级 DTS 重新编译
# 在板级 DTS 中添加:
# &npu { status = "okay"; };

6.2 模型转换失败

现象： 使用 rknn-toolkit2 转换模型时提示算子不支持或维度错误。

解决方案：

# 1. 检查 ONNX 模型版本和算子兼容性
python3 -c "
import onnx
model = onnx.load('model.onnx')
print('ONNX opset:', model.opset_import[0].version)
for node in model.graph.node:
    print(f'  {node.op_type}')
"

# 2. 简化模型（使用 onnx-simplifier）
pip install onnx-simplifier
python3 -m onnxsim model.onnx model_sim.onnx

# 3. 降低不支持的算子复杂度
#    - 将不支持的自定义算子替换为等效的标准算子组合
#    - 调整输入维度为静态（避免动态 shape）

# 4. 查看 RKNN Toolkit2 支持的算子列表
rknn_list_ops  # 命令行工具
# 或在 Python 中查看
from rknn.api import RKNN
rknn = RKNN()
# 转换日志中会列出不支持的算子

6.3 推理结果异常

现象： 模型在 PC 上推理结果正常，但在 NPU 上推理结果偏差很大。

解决方案：

# 1. 检查输入预处理是否一致
#    确认 mean_values 和 std_values 与训练时一致
#    确认输入数据格式（RGB/BGR）与模型期望一致

# 2. 检查量化校准数据集
#    使用有代表性的校准数据（覆盖真实场景的多样性）
#    校准数据集建议 50-200 张图片

# 3. 对比 PC 端和 NPU 端的输出
#    可使用 rknn-toolkit2 的性能分析工具
python3 -c "
from rknn.api import RKNN
rknn = RKNN()
rknn.config(mean_values=[[123.675, 116.28, 103.53]],
            std_values=[[58.395, 57.12, 57.375]],
            target_platform='rk3576')
rknn.load_onnx(model='model.onnx')
rknn.build(do_quantization=True, dataset='calibration_data.txt')
# 使用量化前后的模型分别推理，对比精度差异
"

# 4. 尝试使用 FP16 量化替代 INT8
rknn.build(do_quantization=True, dataset='calibration_data.txt',
           quantized_dtype='asymmetric_quantized-16')

# 5. 检查输入数据的内存布局
#    确认 NHWC vs NCHW 格式与模型定义一致

6.4 NPU 推理性能低于预期

现象： 推理帧率明显低于预期值。

解决方案：

# 1. 确认 NPU 运行在最高频率
cat /sys/kernel/debug/clk/clk_npu/clk_rate

# 2. 检查是否使用了多核模式
#    Python: init_runtime(core_mask=RKNNLite.NPU_CORE_0_1_2)
#    仅单核时性能约为多核的 1/3

# 3. 检查输入预处理是否在主线程中
#    将图像预处理移到子线程，与 NPU 推理并行执行

# 4. 检查内存带宽是否成为瓶颈
#    使用大尺寸输入时可能受限于 DDR 带宽
#    可通过降低输入分辨率或调整 NPU 频率缓解

# 5. 查看 NPU 实际使能状态
cat /sys/kernel/debug/clk/clk_npu/clk_enable_count

6.5 NPU 与 GPU/VPU 资源冲突

现象： 同时使用 GPU 渲染和 NPU 推理时出现性能下降或系统不稳定。

解决方案：

# 1. 合理分配 CPU 核心
#    将 NPU 推理线程绑定到高性能核心（CPU4-7，A72）
taskset -c 4-7 python3 inference.py

# 2. 使用多核模式分散负载
#    当 NPU 多核推理和 GPU 并发时，注意内存带宽竞争

# 3. 调整 DDR 频率
cat /sys/class/devfreq/dmc/cur_freq
# 确认 DDR 运行在较高频率

# 4. 避免 NPU 推理过程中频繁进行 DMA 传输
#    批量处理可减少总线竞争

---

相关文档

序号	文档名称	路径
1	RKNN Toolkit2 安装与使用	RKNN Toolkit2安装与使用
2	模型转换与量化	模型转换与量化
3	NPU 性能调优与调试	NPU性能调优与调试
4	设备树详解与实践	设备树详解与实践
5	Python 应用开发	Python应用开发

---