RGA图像处理对比Opencv慢10倍，是什么问题？

硬件：RK3588
软件：RGA：/usr/lib/aarch64-linux-gnu/librga.so.2.1.0

对比测试crop + resize 操作，RGA平均用时2ms左右，OpenCV平均用时0.2ms，部分代码如下：
TransformData

1. typedef struct _TransformData
   
2. {
   
3.     // 图像基本信息
   
4.     int width, height, format;
   
5.     int size;
   
6. 
   
7.     // 对齐后的宽度
   
8.     int stride;
   
9.     int size_with_stride;
   
10. 
    
11.     // 图像原始数据
    
12.     char *data;
    
13. 
    
14.     // DMA
    
15.     int dma_fd;
    
16. 
    
17.     // im2d
    
18.     im_rect rect;
    
19. 
    
20.     // RGA
    
21.     rga_buffer_t buffer;
    
22.     rga_buffer_handle_t handle;
    
23. 
    
24. } TransformData;

复制代码TransformData 实例化

1. std::unique_ptr<TransformData> Transformer::wrapTransformData(cv::Mat cv_img, const im_rect &rect)
   
2. {
   
3.     m_timer.record(__func__);
   
4. 
   
5.     std::unique_ptr<TransformData> td(new TransformData());
   
6. 
   
7.     td->width = cv_img.cols;
   
8.     td->height = cv_img.rows;
   
9.     td->format = m_format;
   
10.     td->size = td->width * td->height * get_bpp_from_format(td->format);
    
11. 
    
12.     // 对齐后的宽度
    
13.     td->stride = td->width;
    
14.     td->size_with_stride = td->size;
    
15.     if (td->width % m_align_bit)
    
16.     {
    
17.         td->stride = (td->width / m_align_bit + 1) * m_align_bit;
    
18.         td->size_with_stride = td->size / td->width * td->stride;
    
19.     }
    
20. 
    
21.     // 使用dma_heap分配内存调用RGA
    
22.     td->dma_fd = -1;
    
23.     dma_buf_alloc(DMA_HEAP_PATH, td->size_with_stride, &(td->dma_fd), reinterpret_cast<void **>(&(td->data)));
    
24.     assert(td->dma_fd != -1);
    
25. 
    
26.     // 数据拷贝
    
27.     if (td->width == td->stride)
    
28.     {
    
29.         std::memcpy(reinterpret_cast<uchar *>(td->data), cv_img.data, td->size);
    
30.     }
    
31.     else
    
32.     {
    
33.         size_t c = get_bpp_from_format(td->format);
    
34.         size_t src_stride = td->width * c;
    
35.         size_t dst_stride = td->stride * c;
    
36. 
    
37.         uchar *src_ptr = cv_img.data;
    
38.         uchar *dst_ptr = reinterpret_cast<uchar *>(td->data);
    
39. 
    
40.         for (int i = 0; i < td->height; i++)
    
41.         {
    
42.             std::memcpy(dst_ptr, src_ptr, src_stride);
    
43.             src_ptr += src_stride;
    
44.             dst_ptr += dst_stride;
    
45.         }
    
46.     }
    
47. 
    
48.     td->handle = importbuffer_fd(td->dma_fd, td->size_with_stride);
    
49.     td->buffer = wrapbuffer_handle(td->handle, td->stride, td->height, td->format);
    
50. 
    
51.     td->rect = rect;
    
52. 
    
53.     m_timer.stop(__func__);
    
54.     return td;
    
55. }
    
56. 
    
57. std::unique_ptr<TransformData> Transformer::wrapTransformData(const im_rect &rect)
    
58. {
    
59.     m_timer.record(__func__);
    
60. 
    
61.     std::unique_ptr<TransformData> td(new TransformData());
    
62. 
    
63.     td->width = rect.width;
    
64.     td->height = rect.height;
    
65.     td->format = m_format;
    
66.     td->size = td->width * td->height * get_bpp_from_format(td->format);
    
67. 
    
68.     // 对齐后的宽度
    
69.     td->stride = td->width;
    
70.     td->size_with_stride = td->size;
    
71.     if (td->width % m_align_bit)
    
72.     {
    
73.         td->stride = (td->width / m_align_bit + 1) * m_align_bit;
    
74.         td->size_with_stride = td->size / td->width * td->stride;
    
75.     }
    
76. 
    
77.     // 使用dma_heap分配内存调用RGA
    
78.     td->dma_fd = -1;
    
79.     dma_buf_alloc(DMA_HEAP_PATH, td->size_with_stride, &(td->dma_fd), reinterpret_cast<void **>(&(td->data)));
    
80.     assert(td->dma_fd != -1);
    
81. 
    
82.     td->handle = importbuffer_fd(td->dma_fd, td->size_with_stride);
    
83.     td->buffer = wrapbuffer_handle(td->handle, td->stride, td->height, td->format);
    
84. 
    
85.     td->rect = {};
    
86. 
    
87.     m_timer.stop(__func__);
    
88.     return td;
    
89. }
    
90. 
    
91. void Transformer::resetTransformData(std::unique_ptr<TransformData> &td)
    
92. {
    
93.     if (td)
    
94.     {
    
95.         m_timer.record(__func__);
    
96. 
    
97.         // invalid CPU cache
    
98.         dma_sync_device_to_cpu(td->dma_fd);
    
99.         std::cout << "td->dma_fd: " << td->dma_fd << std::endl;
    
100.         dma_buf_free(td->size_with_stride, &(td->dma_fd), reinterpret_cast<void **>(&(td->data)));
     
101. 
     
102.         // release buffer
     
103.         releasebuffer_handle(td->handle);
     
104. 
     
105.         // reset
     
106.         td.reset(nullptr);
     
107. 
     
108.         m_timer.stop(__func__);
     
109.     }
     
110. }

复制代码crop + resize 实际就是把原始图像中某一个区域进行resize操作

1. void *Transformer::process(cv::Mat &cv_src, const im_rect &crop_rect, const im_rect &dst_info)
   
2. {
   
3.     m_timer.record(__func__);
   
4. 
   
5.     // init src TransformData
   
6.     resetTransformData(m_src);
   
7.     m_src = wrapTransformData(cv_src, crop_rect);
   
8. 
   
9.     // init dst TransformData
   
10.     resetTransformData(m_dst);
    
11.     m_dst = wrapTransformData(dst_info);
    
12. 
    
13.     // rga process
    
14.     IM_STATUS ret = imcheck(m_src->buffer, m_dst->buffer, m_src->rect, m_dst->rect);
    
15.     assert(ret == IM_STATUS_NOERROR);
    
16. 
    
17.     ret = improcess(m_src->buffer, m_dst->buffer, {}, m_src->rect, m_dst->rect, {}, IM_SYNC);
    
18.     assert(ret == IM_STATUS_SUCCESS);
    
19. 
    
20.     m_timer.stop(__func__);
    
21.     return reinterpret_cast<void *>(m_dst->data);
    
22. }

复制代码请问是代码中的哪些地方影响了处理速度？有什么不合理的地方？

硬件算法仅对Non-Cache的物理连续Buffer友好。
这种CPU从MMU申请的非连续还带Cache的buffer，同步cache以及频繁的mmu访问都是速度低下的原因。

你好，针对你的建议，我的理解是：
1. 带Cache的buffer，意思是需要将DMA_HEAP_PATH修改为DMA_HEAP_UNCACHE_PATH ？
2. 同步cache，意思是取消dma_sync_device_to_cpu ？
3. 频繁的mmu访问，意思是dma_buf_alloc在外部调用一次，在后续批处理过程中重复使用同一个dma_fd ?
这样理解对吗？

问题还有：
1. 要求输出结果为127，那么RK_FORMAT_RGB_888 RGA3要求16对齐，那么我需要将wstride设置为128，这样循环拷贝依然存在，耗时存在，但是在RGA处理中对齐后格式可以直接作为rknn zero-copy的输入，所以这一步有没有更好的处理方案；
2. 如何保证buffer是连续的？在sample中提到了rga_allocator_dma32_demo.cpp不保证物理连续，其他方式并没有提及？
2.

萌虎龟来 发表于 2024-3-29 10:34
你好，针对你的建议，我的理解是：
1. 带Cache的buffer，意思是需要将DMA_HEAP_PATH修改为DMA_HEAP_UNCACHE ...

1. 改用CMA
2. 不用cache就不存在同步
3. CMA物理连续，使用物理地址不需要访问mmu
4. 对其可以用RGA Crop
5. 代码里存在memcpy就是有问题的写法，要从架构设计上进出buf就得是dma/cma ，如果你想cpu读一个图再用rga，那是无意义的。