DSP裸机NBG U8类型运行错误 - 深度技术分析与解决方案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

typedef struct _pnna_io_patch_info {
    pnna_uint32_t     slice_num;           // 切片数量
    pnna_address_t    *logical_in_cmd;     // 逻辑地址指针数组
    pnna_uint32_t     *physical_in_cmd;    // 物理地址指针数组
    pnna_uint32_t     *offsets;            // 偏移数组
    pnna_uint32_t     *transformation;     // 变换数组
    pnna_uint32_t     counter;
    pnna_uint32_t     physical;
    pnna_uint8_t      *logical;
    pnna_uint8_t      **sw_op_buffer;      // 软件操作缓冲
    pnna_buffer       buffer;
    pnna_uint32_t     patch_belong;
} gcpnna_io_patch_info_t;

1
2
3
4

// 原代码
pnna_uint32_t tmp_size = sizeof(pnna_address_t) * io_info->slice_num;
gcOnError(gcpnna_user_allocate_memory(tmp_size, (void **)&io_info->logical_in_cmd));
gcpnna_user_zero_memory(io_info->logical_in_cmd, tmp_size);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

应用层
   ↓
RT-Thread 内存管理层
   ├─ 内存对齐检查
   ├─ 内存保护机制
   ├─ Cache一致性管理
   ├─ MMU虚拟地址映射
   └─ 内存屏障(barriers)
   ↓
底层硬件

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

应用层
   ↓
直接硬件内存操作
   └─ 无对齐检查
   └─ 无保护机制
   └─ 无Cache一致性
   └─ 直接物理地址
   └─ 无访问限制
   ↓
底层硬件

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

// 修复：添加Canary保护
pnna_uint32_t payload_size = sizeof(pnna_address_t) * io_info->slice_num;
const pnna_uint32_t canary_bytes = sizeof(pnna_uint64_t);  // 8字节
pnna_uint32_t alloc_size = payload_size + 2 * canary_bytes; // +16字节总

void *alloc_base = PNNA_NULL;
gcOnError(gcpnna_user_allocate_memory(alloc_size, (void **)&alloc_base));

/* 有效载荷位于前缀Canary之后 */
io_info->logical_in_cmd = (pnna_address_t *)((pnna_uint8_t *)alloc_base + canary_bytes);
gcpnna_user_zero_memory(io_info->logical_in_cmd, payload_size);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

原分配（8字节）：
┌──────────────────────────────────┐
│  logical_in_cmd (直接分配)       │ <- 可能不对齐
└──────────────────────────────────┘

新分配（24字节）：
┌──────────────────────────────────────────────────┐
│ canary│    logical_in_cmd (偏移+8)    │ canary│
│ (8B)  │           (8B)                │ (8B)  │
└──────────────────────────────────────────────────┘
                    ↑
           强制对齐到16字节边界

1
2
3
4

if (io_info->logical_in_cmd != PNNA_NULL) {
    gcpnna_user_free_memory(io_info->logical_in_cmd);  // ❌ 释放的是已偏移的指针！
    io_info->logical_in_cmd = PNNA_NULL;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

分配时：
alloc_base ──────────────┬──────────────
            [canary 8B]  │[payload 8B][canary 8B]
                         ↑
                    logical_in_cmd = alloc_base + 8

释放时应该：
gcpnna_user_free_memory(alloc_base);   // ✓ 释放原始指针

但代码做的是：
gcpnna_user_free_memory(logical_in_cmd);  // ❌ 释放偏移后的指针

1
2
3

// 优点：简单，立竿见影地解决U8问题
// 缺点：留下内存泄漏隐患
// 风险：长期运行可能堆崩溃

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

typedef struct _pnna_io_patch_info {
    pnna_uint32_t     slice_num;
    pnna_address_t    *logical_in_cmd;
    pnna_uint32_t     *physical_in_cmd;
    pnna_uint32_t     *offsets;
    pnna_uint32_t     *transformation;
    pnna_uint32_t     counter;
    pnna_uint32_t     physical;
    pnna_uint8_t      *logical;
    pnna_uint8_t      **sw_op_buffer;
    pnna_buffer       buffer;
    pnna_uint32_t     patch_belong;
    
    // 新增：保存原始分配指针
    void              *logical_in_cmd_alloc_base;  // ✓ 跟踪原始分配
} gcpnna_io_patch_info_t;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

pnna_uint32_t payload_size = sizeof(pnna_address_t) * io_info->slice_num;
const pnna_uint32_t canary_bytes = sizeof(pnna_uint64_t);
pnna_uint32_t alloc_size = payload_size + 2 * canary_bytes;

void *alloc_base = PNNA_NULL;
gcOnError(gcpnna_user_allocate_memory(alloc_size, (void **)&alloc_base));

// ✓ 保存原始指针
io_info->logical_in_cmd_alloc_base = alloc_base;

// 有效载荷位于前缀Canary之后
io_info->logical_in_cmd = (pnna_address_t *)((pnna_uint8_t *)alloc_base + canary_bytes);
gcpnna_user_zero_memory(io_info->logical_in_cmd, payload_size);

1
2
3
4
5

if (io_info->logical_in_cmd_alloc_base != PNNA_NULL) {
    gcpnna_user_free_memory(io_info->logical_in_cmd_alloc_base);  // ✓ 释放原始指针
    io_info->logical_in_cmd_alloc_base = PNNA_NULL;
    io_info->logical_in_cmd = PNNA_NULL;
}

1
2
3
4
5
6
7
8
9

INT16 NBG
   ↓
较大数据块（2字节/元素）
   ↓
处理次数较少
   ↓
内存访问模式相对宽松
   ↓
不触发硬件对齐异常

1
2
3
4
5
6
7
8
9

U8 NBG
   ↓
较小数据块（1字节/元素）
   ↓
处理次数众多
   ↓
内存访问密集
   ↓
触发硬件对齐检查

1
2
3

分配8字节时：可能返回未对齐指针
分配16字节时：分配器倾向于返回16字节对齐指针
分配24字节时：更可能满足硬件对齐要求

1
2
3
4

1. U8 NBG单层测试：✓ 已成功
2. U8 NBG多层测试：需要验证
3. INT16 NBG回归测试：✓ 需要确认无破坏
4. 混合U8/INT16测试：需要验证

1
2
3
4
5
6
7
8
9

// 添加Canary检查（调试时）
#define CHECK_CANARY(base_ptr, alloc_size) \
    do { \
        pnna_uint64_t *prefix = (pnna_uint64_t *)base_ptr; \
        pnna_uint64_t *suffix = (pnna_uint64_t *)((pnna_uint8_t *)base_ptr + alloc_size - 8); \
        if (*prefix != CANARY_VALUE || *suffix != CANARY_VALUE) { \
            gcpnna_error("Canary corrupted! Buffer overflow detected!"); \
        } \
    } while(0)