本文基于CANN开源社区的driver仓库进行技术解读

CANN组织地址：https://atomgit.com/cann

driver仓库地址：https://atomgit.com/cann/driver

前言

NPU硬件需要驱动程序的支持才能正常工作。如何实现基础驱动和资源管理及调度？

DRIVER是CANN提供的驱动模块，实现基础驱动和资源管理及调度等功能，使能芯片。

什么是DRIVER

DRIVER是CANN的驱动模块：

没有驱动：
应用无法访问硬件 → 无法使用NPU

有驱动：
提供驱动接口 → 应用可以使用NPU

架构：

应用层
    ↓
CANN Runtime
    ↓
DRIVER（驱动模块）
    ↓
NPU硬件

核心概念

1. 设备管理

设备管理功能：

#include "driver/driver.h"

// 设备信息
typedef struct {
    int device_id;
    char name[256];
    uint64_t memory_total;
    uint64_t memory_free;
    int compute_units;
    int clock_rate;
} device_info_t;

// 查询设备信息
driver_result_t driver_query_device_info(int device_id, device_info_t *info);

2. 资源管理

资源管理功能：

// 内存资源
typedef struct {
    void *ptr;
    size_t size;
    int device_id;
} memory_resource_t;

// 分配内存
driver_result_t driver_alloc_memory(int device_id, size_t size, memory_resource_t *resource);

// 释放内存
driver_result_t driver_free_memory(memory_resource_t *resource);

3. 任务调度

任务调度功能：

// 任务
typedef struct {
    task_id_t id;
    void *kernel;
    task_config_t config;
    task_status_t status;
} task_t;

// 提交任务
driver_result_t driver_submit_task(task_t *task);

// 等待任务完成
driver_result_t driver_wait_task(task_id_t id);

核心API

1. 初始化

#include "driver/driver.h"

int main() {
    // 初始化驱动
    driver_handle_t handle;
    driver_result_t ret = driver_init(&handle);

    if (ret != DRIVER_SUCCESS) {
        fprintf(stderr, "Failed to initialize driver: %d\n", ret);
        return -1;
    }

    // 使用驱动
    // ...

    // 清理
    driver_finalize(handle);

    return 0;
}

2. 设备操作

// 查询设备数量
int num_devices = 0;
driver_result_t ret = driver_get_device_count(&num_devices);

if (ret == DRIVER_SUCCESS) {
    printf("Found %d devices\n", num_devices);
}

// 查询设备信息
for (int i = 0; i < num_devices; i++) {
    device_info_t info;
    ret = driver_query_device_info(i, &info);

    if (ret == DRIVER_SUCCESS) {
        printf("Device %d:\n", i);
        printf("  Name: %s\n", info.name);
        printf("  Memory: %lu MB\n", info.memory_total / 1024 / 1024);
        printf("  Compute units: %d\n", info.compute_units);
        printf("  Clock rate: %d MHz\n", info.clock_rate);
    }
}

// 设置当前设备
ret = driver_set_device(0);

if (ret != DRIVER_SUCCESS) {
    fprintf(stderr, "Failed to set device: %d\n", ret);
    return -1;
}

3. 内存操作

// 分配内存
memory_resource_t resource;
ret = driver_alloc_memory(0, 1024 * 1024, &resource);

if (ret == DRIVER_SUCCESS) {
    printf("Allocated %zu bytes\n", resource.size);
    printf("Device ID: %d\n", resource.device_id);
} else {
    fprintf(stderr, "Failed to allocate memory: %d\n", ret);
    return -1;
}

// 写入内存
char *data = "Hello, NPU!";
ret = driver_write_memory(&resource, data, strlen(data));

if (ret != DRIVER_SUCCESS) {
    fprintf(stderr, "Failed to write memory: %d\n", ret);
    return -1;
}

// 读取内存
char buffer[256];
ret = driver_read_memory(&resource, buffer, strlen(data));

if (ret == DRIVER_SUCCESS) {
    printf("Read: %s\n", buffer);
}

// 释放内存
ret = driver_free_memory(&resource);

if (ret != DRIVER_SUCCESS) {
    fprintf(stderr, "Failed to free memory: %d\n", ret);
}

4. 任务操作

// 创建任务
task_t task;
task.id = 0;
task.kernel = my_kernel;
task.config.stream_id = 0;
task.config.priority = 0;

// 提交任务
ret = driver_submit_task(&task);

if (ret != DRIVER_SUCCESS) {
    fprintf(stderr, "Failed to submit task: %d\n", ret);
    return -1;
}

// 等待任务完成
ret = driver_wait_task(task.id);

if (ret != DRIVER_SUCCESS) {
    fprintf(stderr, "Failed to wait task: %d\n", ret);
    return -1;
}

// 查询任务状态
task_status_t status;
ret = driver_query_task_status(task.id, &status);

if (ret == DRIVER_SUCCESS) {
    printf("Task %d status: %d\n", task.id, status);
}

使用场景

场景一：模型训练

// 模型训练场景
void train_model(Model *model, Dataset *dataset, int epochs) {
    // 初始化驱动
    driver_handle_t handle;
    driver_init(&handle);

    // 设置设备
    driver_set_device(0);

    // 分配内存
    memory_resource_t model_memory;
    driver_alloc_memory(0, model_size, &model_memory);

    // 加载模型到设备
    driver_write_memory(&model_memory, model_weights, model_size);

    // 训练循环
    for (int epoch = 0; epoch < epochs; epoch++) {
        for (int batch = 0; batch < dataset->num_batches; batch++) {
            // 准备输入
            memory_resource_t input_memory;
            driver_alloc_memory(0, input_size, &input_memory);
            driver_write_memory(&input_memory, input_data, input_size);

            // 创建任务
            task_t forward_task;
            forward_task.kernel = forward_kernel;
            forward_task.config.input_ptr = input_memory.ptr;
            forward_task.config.model_ptr = model_memory.ptr;

            // 提交任务
            driver_submit_task(&forward_task);
            driver_wait_task(forward_task.id);

            // 释放输入内存
            driver_free_memory(&input_memory);
        }
    }

    // 释放模型内存
    driver_free_memory(&model_memory);

    // 清理
    driver_finalize(handle);
}

场景二：模型推理

// 模型推理场景
void infer_model(Model *model, Input *input, Output *output) {
    // 初始化驱动
    driver_handle_t handle;
    driver_init(&handle);

    // 设置设备
    driver_set_device(0);

    // 分配内存
    memory_resource_t input_memory;
    memory_resource_t output_memory;
    driver_alloc_memory(0, input_size, &input_memory);
    driver_alloc_memory(0, output_size, &output_memory);

    // 加载输入
    driver_write_memory(&input_memory, input_data, input_size);

    // 创建推理任务
    task_t inference_task;
    inference_task.kernel = inference_kernel;
    inference_task.config.input_ptr = input_memory.ptr;
    inference_task.config.output_ptr = output_memory.ptr;

    // 提交任务
    driver_submit_task(&inference_task);
    driver_wait_task(inference_task.id);

    // 读取输出
    driver_read_memory(&output_memory, output_data, output_size);

    // 释放内存
    driver_free_memory(&input_memory);
    driver_free_memory(&output_memory);

    // 清理
    driver_finalize(handle);
}

场景三：多设备训练

// 多设备训练场景
void multi_device_train(Model *model, Dataset *dataset, int num_devices) {
    // 初始化驱动
    driver_handle_t handle;
    driver_init(&handle);

    // 为每个设备分配资源
    memory_resource_t *model_memories = malloc(num_devices * sizeof(memory_resource_t));
    for (int i = 0; i < num_devices; i++) {
        driver_set_device(i);
        driver_alloc_memory(i, model_size, &model_memories[i]);
        driver_write_memory(&model_memories[i], model_weights, model_size);
    }

    // 训练循环
    for (int epoch = 0; epoch < epochs; epoch++) {
        for (int batch = 0; batch < dataset->num_batches; batch++) {
            // 数据并行
            for (int i = 0; i < num_devices; i++) {
                driver_set_device(i);

                // 准备输入
                memory_resource_t input_memory;
                driver_alloc_memory(i, input_size, &input_memory);
                driver_write_memory(&input_memory, batch_data[i], input_size);

                // 创建任务
                task_t forward_task;
                forward_task.kernel = forward_kernel;
                forward_task.config.input_ptr = input_memory.ptr;
                forward_task.config.model_ptr = model_memories[i].ptr;

                // 提交任务
                driver_submit_task(&forward_task);
            }

            // 等待所有任务完成
            for (int i = 0; i < num_devices; i++) {
                driver_wait_task(forward_tasks[i].id);
            }
        }
    }

    // 释放资源
    for (int i = 0; i < num_devices; i++) {
        driver_free_memory(&model_memories[i]);
    }
    free(model_memories);

    // 清理
    driver_finalize(handle);
}

性能优化

1. 内存池

// 内存池管理
typedef struct {
    memory_resource_t *resources;
    int num_resources;
    int max_resources;
} memory_pool_t;

// 创建内存池
memory_pool_t *create_memory_pool(int device_id, int pool_size) {
    memory_pool_t *pool = malloc(sizeof(memory_pool_t));
    pool->resources = malloc(pool_size * sizeof(memory_resource_t));
    pool->num_resources = 0;
    pool->max_resources = pool_size;

    // 预分配内存
    for (int i = 0; i < pool_size; i++) {
        driver_alloc_memory(device_id, 1024 * 1024, &pool->resources[i]);
        pool->num_resources++;
    }

    return pool;
}

// 从池中获取内存
memory_resource_t *pool_alloc(memory_pool_t *pool) {
    if (pool->num_resources > 0) {
        pool->num_resources--;
        return &pool->resources[pool->num_resources];
    }

    // 池为空，分配新内存
    memory_resource_t *resource = malloc(sizeof(memory_resource_t));
    driver_alloc_memory(0, 1024 * 1024, resource);
    return resource;
}

2. 任务队列

// 任务队列
typedef struct {
    task_t *tasks;
    int num_tasks;
    int max_tasks;
} task_queue_t;

// 创建任务队列
task_queue_t *create_task_queue(int queue_size) {
    task_queue_t *queue = malloc(sizeof(task_queue_t));
    queue->tasks = malloc(queue_size * sizeof(task_t));
    queue->num_tasks = 0;
    queue->max_tasks = queue_size;

    return queue;
}

// 提交任务到队列
void queue_submit(task_queue_t *queue, task_t *task) {
    if (queue->num_tasks < queue->max_tasks) {
        queue->tasks[queue->num_tasks] = *task;
        queue->num_tasks++;
    }
}

// 批量处理任务
void batch_process(task_queue_t *queue) {
    for (int i = 0; i < queue->num_tasks; i++) {
        driver_submit_task(&queue->tasks[i]);
    }

    for (int i = 0; i < queue->num_tasks; i++) {
        driver_wait_task(queue->tasks[i].id);
    }

    queue->num_tasks = 0;
}

3. 异步执行

// 异步任务
typedef struct {
    task_id_t id;
    task_t task;
    task_callback_t callback;
    void *callback_data;
} async_task_t;

// 异步执行任务
void async_execute(async_task_t *async_task) {
    // 提交任务
    driver_submit_task(&async_task->task);
    async_task->id = async_task->task.id;

    // 在后台线程中等待
    pthread_t thread;
    pthread_create(&thread, NULL, async_wait_thread, async_task);
}

void *async_wait_thread(void *arg) {
    async_task_t *async_task = (async_task_t *)arg;

    // 等待任务完成
    driver_wait_task(async_task->id);

    // 调用回调
    if (async_task->callback) {
        async_task->callback(async_task->callback_data);
    }

    return NULL;
}

与其他组件的关系

组件	关系
Runtime	使用DRIVER访问硬件
ops-nn	使用DRIVER执行算子
GE	使用DRIVER执行图

关系：

应用层
    ↓
Runtime（运行时）
    ↓
DRIVER（驱动）
    ↓
NPU硬件

调试技巧

1. 设备状态检查

// 检查设备状态
void check_device_status(int device_id) {
    device_info_t info;
    driver_result_t ret = driver_query_device_info(device_id, &info);

    if (ret == DRIVER_SUCCESS) {
        printf("Device %d status:\n", device_id);
        printf("  Memory total: %lu MB\n", info.memory_total / 1024 / 1024);
        printf("  Memory free: %lu MB\n", info.memory_free / 1024 / 1024);
        printf("  Temperature: %d°C\n", info.temperature);
        printf("  Utilization: %d%%\n", info.utilization);
    }
}

2. 内存监控

// 监控内存使用
void monitor_memory_usage(int device_id) {
    device_info_t info;
    driver_query_device_info(device_id, &info);

    uint64_t memory_used = info.memory_total - info.memory_free;
    float usage_percent = (float)memory_used / info.memory_total * 100;

    printf("Memory usage: %.2f%%\n", usage_percent);
}

3. 任务监控

// 监控任务状态
void monitor_tasks() {
    // 获取任务列表
    task_t *tasks;
    int num_tasks;
    driver_get_tasks(&tasks, &num_tasks);

    printf("Active tasks: %d\n", num_tasks);

    for (int i = 0; i < num_tasks; i++) {
        printf("  Task %d: status=%d\n", tasks[i].id, tasks[i].status);
    }
}

常见问题

问题1：设备初始化失败

// 错误：设备ID不存在
driver_set_device(999);  // 设备不存在！

// 正确：使用有效的设备ID
int device_id = 0;
driver_set_device(device_id);

问题2：内存分配失败

// 错误：请求的内存太大
driver_alloc_memory(0, 1024ULL * 1024 * 1024 * 1024, &resource);  // 太大！

// 正确：请求合理的内存大小
driver_alloc_memory(0, 1024 * 1024, &resource);  // 1MB

问题3：任务提交失败

// 错误：任务配置错误
task_t task;
task.kernel = NULL;  // kernel为空！
driver_submit_task(&task);  // 失败！

// 正确：正确配置任务
task_t task;
task.kernel = my_kernel;
task.config.input_ptr = input_ptr;
driver_submit_task(&task);  // 成功

应用场景总结

场景一：模型训练

用于模型训练场景。

场景二：模型推理

用于模型推理场景。

场景三：多设备训练

用于多设备训练场景。

场景四：资源管理

用于资源管理场景。

总结

DRIVER是CANN的驱动模块：

• 设备管理
• 资源管理
• 任务调度
• 性能优化
• 错误处理

是CANN与硬件交互的基础层，为上层提供了可靠的硬件访问接口。

相关链接

driver仓库地址：https://atomgit.com/cann/driver

CANN组织地址：https://atomgit.com/cann

runtime仓库地址：https://atomgit.com/cann/runtime

ops-nn仓库地址：https://atomgit.com/cann/ops-nn

---

这篇是我学习DRIVER时的笔记，如有错误欢迎指正。