标签：kernel perf DMA kallsyms IO async main dma
转自：https://www.cnblogs.com/arnoldlu/p/10219704.html
DMA本身用于减轻CPU负担，进行CPU off-load搬运工作。
在DMA驱动内部实现有同步和异步模式，异步模式使用dma_async_issue_pending()，然后在callback()中发送SIGIO信号，用户空间收到SIGIO进行handler处理视为一个周期完成。
同步模式，采用dma_sync_wait()进行等待，期间并没有释放CPU给其他进程使用。
在一个项目中，发现DMA相关占用率高的问题，后来发现是因为其使用了同步模式。然后，将其改成异步模式，并对其进行详细的分析，记录如下。
那么当初为什么没有使用async IO模式呢？
原来是因为同一进程中其他线程也是用了async IO设备，由于kill_fasync()发送SIGIO信号，在一个进程内无法多个handler。
权宜措施使用了同步DMA，造成占用率高。
然后通过fcntl(fd, F_SETSIG, sig);解决了kill_fasync()发送相同SIGIO信号的冲突问题。
1. 问题发现：DMA同步模式占用率高
抓数据命令：
perf record -a -e cpu-clock -- sleep 60 perf report perf report -s comm
不同数据量，不同CMA处理方式下的top和perf结果：
| Item | 1 cma | per cma | ||
| top | perf | top | perf | |
| 4K 25fps | 15% | 84.43% swapper [kernel.kallsyms] [k] __sched_text_end 11.51% main [kernel.kallsyms] [k] dma_cookie_status 2.81% main [kernel.kallsyms] [k] dma_sync_wait 0.20% main [kernel.kallsyms] [k] uart_write 0.13% swapper [kernel.kallsyms] [k] cache_op_range 0.12% swapper [kernel.kallsyms] [k] __dma_tx_complete 0.06% swapper [kernel.kallsyms] [k] dw_dma_tasklet 0.04% ksoftirqd/0 [kernel.kallsyms] [k] finish_task_switch 0.03% perf [kernel.kallsyms] [k] raw_copy_from_user 0.02% swapper [kernel.kallsyms] [k] __softirqentry_text_start |
61% | 45.93% main [kernel.kallsyms] [k] dcache_wb_line 36.79% swapper [kernel.kallsyms] [k] __sched_text_end 4.86% main [kernel.kallsyms] [k] dma_cookie_status 4.06% main [kernel.kallsyms] [k] free_hot_cold_page 1.28% main [kernel.kallsyms] [k] dma_sync_wait 1.28% main [kernel.kallsyms] [k] skip_ftrace 0.66% main [kernel.kallsyms] [k] _mcount 0.58% main [kernel.kallsyms] [k] unset_migratetype_isolate 0.51% main [kernel.kallsyms] [k] __free_pages 0.41% main [kernel.kallsyms] [k] start_isolate_page_range |
| 1080p 50fps | 9% | 89.82% swapper [kernel.kallsyms] [k] __sched_text_end 5.63% main [kernel.kallsyms] [k] dma_cookie_status 1.48% main [kernel.kallsyms] [k] dma_sync_wait 0.49% ksoftirqd/0 [kernel.kallsyms] [k] finish_task_switch 0.24% swapper [kernel.kallsyms] [k] dw_dma_tasklet 0.13% swapper [kernel.kallsyms] [k] __dma_tx_complete 0.10% swapper [kernel.kallsyms] [k] tasklet_action 0.10% main [kernel.kallsyms] [k] do_futex 0.06% main [kernel.kallsyms] [k] raw_copy_from_user 0.06% main [kernel.kallsyms] [k] restore_from_user_fp |
44% | 53.49% swapper [kernel.kallsyms] [k] __sched_text_end 30.73% main [kernel.kallsyms] [k] dcache_wb_line 3.65% main [kernel.kallsyms] [k] free_hot_cold_page 3.36% main [kernel.kallsyms] [k] dma_cookie_status 1.03% main [kernel.kallsyms] [k] skip_ftrace 0.85% main [kernel.kallsyms] [k] dma_sync_wait 0.56% main [kernel.kallsyms] [k] _mcount 0.48% main [kernel.kallsyms] [k] unset_migratetype_isolate 0.38% main [kernel.kallsyms] [k] __free_pages 0.33% main [kernel.kallsyms] [k] isolate_migratepages_range |
问题的分析：
1. skip_trace和_mcount两个是因为ftrace引入的负荷，不合理。此时不应该有这些。----需要推动csky修改成Dynamic function/function_graph。
2. dcache_wb_line/free_hot_cold_page是CMA操作引起的。-----------------------------------这里需要修改处理方式，CMA不需要重复申请释放。
3. dma_cookie_status/dma_sync_wait是DMA操作引起的。------------------------------------这里可以通过修改DMA异步信号触发来降低占用率。
分析总结：
1. 从上面的测试结果看，应该尽量避免内存申请释放。csky内存处理效率很低。
2. 同步模式效率非常低，4K单路占用率达到15%，如果4K双路就没法使用了。
所以必须要使用异步模式，这也是使用DMA的初衷。
1.1 不同DMA size对性能影响
多大的传输使用DMA获得的收益最高呢？做了个实验，结果如下，横轴单位是B，纵轴单位是MB/s、
可以看出，DMA size大小越大效率越高，size接近3MB的时候，以及以后吞吐率就比较稳定了。
2. 分析问题：让DMA异步起来
int axidma_memcpy(dma_addr_t src, dma_addr_t dst, unsigned int len)
{
struct dma_async_tx_descriptor *tx = NULL;
dma_cookie_t cookie;
unsigned long flags;
bool sync_wait = false;-------------------------------------------------------------------true表示同步等待模式；false表示异步模式，和callback()配合。
int err = 0;
flags = DMA_CTRL_ACK | DMA_PREP_INTERRUPT;
tx = xxxxxx->dma.chan->device->device_prep_dma_memcpy(xxxxxx->dma.chan, dst, src, len, flags);
if (!tx)
{
pr_err("Fail to prepare memcpy.\n");
return -1;
}
tx->callback = axidma_callback;
tx->callback_param = xxxxxx;
cookie = tx->tx_submit(tx);
if (dma_submit_error(cookie))
{
pr_err("Fail to submit axi dma.\n");
return -1;
}
if (!sync_wait) {
dma_async_issue_pending(dma_dev->dma.chan);------------------------------------------发送DMA传输请求，然后退出。这里不会等待操作结果。
} else {
if (dma_sync_wait(dma_dev->dma.chan, cookie) == DMA_COMPLETE) {
err = 0;
} else {
err = -EIO;
}
}
return err;
}
enum dma_status dma_sync_wait(struct dma_chan *chan, dma_cookie_t cookie)
{
enum dma_status status;
unsigned long dma_sync_wait_timeout = jiffies + msecs_to_jiffies(5000);-------------------超时5000ms，足够大了。
dma_async_issue_pending(chan);------------------------------------------------------------和之前同样功能，发送DMA传输请求。只是下面会进行等待，并有超时动作。
do {
status = dma_async_is_tx_complete(chan, cookie, NULL, NULL);--------------------------pool DMA传输状态。
if (time_after_eq(jiffies, dma_sync_wait_timeout)) {
dev_err(chan->device->dev, "%s: timeout!\n", __func__);
return DMA_ERROR;-----------------------------------------------------------------超时退出。
}
if (status != DMA_IN_PROGRESS)
break;
cpu_relax();--------------------------------------------------------------------------让出CPU执行。
} while (1);
return status;
}
static inline enum dma_status dma_async_is_tx_complete(struct dma_chan *chan,
dma_cookie_t cookie, dma_cookie_t *last, dma_cookie_t *used)
{
struct dma_tx_state state;
enum dma_status status;
status = chan->device->device_tx_status(chan, cookie, &state);
if (last)
*last = state.last;
if (used)
*used = state.used;
return status;
}
然后在callback()中发送SIGIO信号：
static void axidma_callback(void *arg)
{
if(dma_dev->async)
{
pr_debug("axidma callback: chan=%s.\n", dma_chan_name(dma_dev->dma.chan));
pr_debug("axidma_callback: magic=0x%08x pid_type=%d\n", dma_dev->async->magic, dma_dev->async->fa_file->f_owner.pid_type);
kill_fasync(&dma_dev->async, SIGIO, POLL_IN);--------------------------------在传输完成后，异步发送SIGIO信号。
}
}
3. 解决问题：DMA异步传输
为了排除其他进程影响，单独构造3个试用例：1. 4K 25fps；2. 1080p 2路 25fps；3. 1080p 4路 25fps。
然后改成DMA异步模式，CPU占用率是否明显下降？
测试程序如下：
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <poll.h>
#include <signal.h>
#include <sys/types.h>
#include <unistd.h>
#include <fcntl.h>
#include <time.h>
#include <pthread.h>
#include <sys/prctl.h>
#include <sys/syscall.h>
#include <sys/ioctl.h>
#include "IFMS_MemCMA_API.h"
int fd;
unsigned int handle_count = 0;
volatile unsigned int dmatest_exit = 0;
volatile sigio_received = 0;
#define LOOP_COUNT 10000
#define DMA_MEMCPY 0
#define DMA_FILE "/dev/dpeye1000_axidma"
#define DPEYE1000_AXIDMA_IOC_MAGIC 'd'
#define DPEYE1000_AXIDMA_REQUEST_CHNN _IOW(DPEYE1000_AXIDMA_IOC_MAGIC, 1, int) //Request channel.
#define DPEYE1000_AXIDMA_RELEASE_CHNN _IOW(DPEYE1000_AXIDMA_IOC_MAGIC, 2, int) //Release channel.
#define DPEYE1000_AXIDMA_MEMCPY _IOW(DPEYE1000_AXIDMA_IOC_MAGIC, 3, int) //Do 1d memcpy.
//#define PERFORMANCE_DEBUG
struct axidma_dma
{
struct dma_chan *chan;
unsigned long src;
unsigned long dst;
// for memcpy
unsigned int len;
unsigned int n_channels;
};
struct thread_para
{
unsigned int size;
unsigned int expries;
struct cma_block cma_block1;
struct cma_block cma_block2;
};
static struct axidma_dma axidma_dma;
struct thread_para t_para;
int dmacopy_tid = 0;
void trigger_dma_copy(void)
{
int ret;
#ifdef PERFORMANCE_DEBUG
struct timespec time_0, time_1;
unsigned long duration;
float throughput = 0.0;
clock_gettime(CLOCK_REALTIME, &time_0);
#endif
axidma_dma.src = (unsigned long)t_para.cma_block1.addr_p;
axidma_dma.dst = (unsigned long)t_para.cma_block2.addr_p;
axidma_dma.len = t_para.size;
ret = ioctl(fd, DPEYE1000_AXIDMA_MEMCPY, &axidma_dma);
if(ret < 0)
{
printf("fail to ioctl DPEYE1000_AXIDMA_MEMCPY!!!\n");
}
#ifdef PERFORMANCE_DEBUG
clock_gettime(CLOCK_REALTIME, &time_1);
duration = (time_1.tv_sec-time_0.tv_sec)*1000000000 + (time_1.tv_nsec-time_0.tv_nsec);
throughput = (float)t_para.size/1048576*1000000000/duration;
printf("%ld.%ld %d %d, %ld, %f\n", time_1.tv_sec, time_1.tv_nsec, handle_count, t_para.size, duration, throughput);
#endif
}
void sigint_handler(int sig)
{
if(sig == SIGINT)
{
printf("%s SIGINT\n", __func__);
dmatest_exit = 1;
}
}
void sigio_handler(int sig)
{
if(sig == SIGIO)
{
sigio_received = 1;
}
}
static void pthread_func(void *arg)
{
int ret;
int Oflags;
struct f_owner_ex owner_ex;
struct timespec time1, time2;
struct sigaction sa, sa2;
sigset_t set, oldset;
long long duration;
unsigned int mode = DMA_MEMCPY;
ret = IFMS_MemCMAAlloc(t_para.size, &t_para.cma_block1);
if(ret<0)
{
printf("CMA alloc failed.\n");
return -1;
}
ret=IFMS_MemCMAAlloc(t_para.size, &t_para.cma_block2);
if(ret<0)
{
printf("CMA alloc failed.\n");
return -1;
}
//===========================================================================================
//Set thread name.
prctl(PR_SET_NAME,"sigio");
dmacopy_tid = syscall(SYS_gettid);
printf("sigio thread tid=%ld %ld.\n", syscall(SYS_gettid), getpid());
//Set SIGIO actiong.
memset(&sa, 0, sizeof(sa));
sa.sa_handler = sigio_handler;
sa.sa_flags |= SA_RESTART;
sigaction(SIGIO, &sa, NULL);
//Set proc mask.
sigemptyset(&set);
sigprocmask(SIG_SETMASK, &set, NULL);
sigaddset(&set, SIGIO);
fd = open(DMA_FILE, O_RDWR);
if (fd < 0)
{
printf("Can't open %s!\n", DMA_FILE);
}
//If set F_SETOWN_EX, SIGIO will send to this thread only.
owner_ex.pid = syscall(SYS_gettid);
owner_ex.type = F_OWNER_TID;
fcntl(fd, F_SETOWN_EX, &owner_ex);
Oflags = fcntl(fd, F_GETFL);
fcntl(fd, F_SETFL, Oflags | FASYNC);
clock_gettime(CLOCK_REALTIME, &time1);
ret = ioctl(fd, DPEYE1000_AXIDMA_REQUEST_CHNN, &mode);
if(ret < 0)
{
printf("fail to ioctl DPEYE1000_AXIDMA_REQUEST_CHNN!!!\n");
}
while(!dmatest_exit)
{
if(t_para.expries > 1)
usleep(t_para.expries);
trigger_dma_copy(); //Send DMA copy request. while(!sigio_received)
while(!sigio_received)
{
pthread_sigmask(SIG_BLOCK, &set, &oldset);
//sigprocmask(SIG_BLOCK, &set, &oldset);
sigsuspend(&oldset); //Will pause here, and will be waked up by SIGIO.
pthread_sigmask(SIG_UNBLOCK, &set, NULL);
//sigprocmask(SIG_UNBLOCK, &set, NULL);
handle_count++;
}
sigio_received = 0;
}
clock_gettime(CLOCK_REALTIME, &time2);
duration = (long long)(time2.tv_sec-time1.tv_sec)*1000000000 + (time2.tv_nsec-time1.tv_nsec);
sleep(1);
printf("End time %lld.%09lld count=%d fps=%lld.\n", duration/1000000000, duration%1000000000, handle_count, (long long)handle_count*1000000000/duration);
ioctl(fd, DPEYE1000_AXIDMA_RELEASE_CHNN, NULL);
if(ret < 0)
{
printf("fail to ioctl DPEYE1000_AXIDMA_RELEASE_CHNN!!!\n");
}
close(fd);
//===========================================================================================
ret=IFMS_MemCMAFree(t_para.cma_block1);
if(ret<0)
{
printf("CMA free failed.\n");
return -1;
}
ret=IFMS_MemCMAFree(t_para.cma_block2);
if(ret<0)
{
printf("CMA free failed.\n");
return -1;
}
pthread_exit(0);
}
void main(int argc, char **argv)
{
pthread_t tidp;
sigset_t set;
unsigned int size = 0, expries = 0;
struct sigaction sa;
if(argc != 3)
{
printf("Usage: %s size(B) expries(us).\n", argv[0]);
return -1;
}
size = atoi(argv[1]);
if(!size)
{
printf("Please input right size.\n");
return -1;
}
expries = atoi(argv[2]);
if(!expries)
{
printf("Please input right expries time.\n");
return -1;
}
t_para.size = size;
t_para.expries = expries;
memset(&sa, 0, sizeof(sa));
sa.sa_handler = sigint_handler;
sa.sa_flags |= SA_RESTART;
sigaction(SIGINT, &sa, NULL);
sigemptyset(&set);
sigaddset(&set, SIGIO);
sigprocmask(SIG_BLOCK, &set, NULL);
if(pthread_create(&tidp, NULL, pthread_func, NULL) == -1)
{
printf("Create pthread error.\n");
return;
}
if(pthread_join(tidp, NULL))
{
printf("Join pthread error.\n");
return;
}
printf("Main exit.\n");
return;
}
3.1 DMA异步和同步在不同场景下对比测试
dma_thread测试不同分辨率、不同帧率下的性能对比：
| Case | 同步DMA | 异步DMA | ||
| top -d 5 |
perf record -a -e cpu-clock -- sleep 60 |
top -d 5 | perf record -a -e cpu-clock -- sleep 60 | |
|
1080p 50fps dma_thread 3110400 20000 |
7.5% 单次耗时：1.6ms |
91.12% swapper [kernel.kallsyms] [k] __sched_text_end 91.22% swapper 8.04% main0.43% perf 0.11% jbd2/mmcblk1p2- 0.08% mmcqd/1 |
dma_sigio 3110400 20000 0.3% 单次耗时：135us |
98.57% swapper |
|
1080p 100fps dma_thread 3110400 10000 |
14.1% 单次耗时：1.6ms |
84.27% swapper [kernel.kallsyms] [k] __sched_text_end 84.30% swapper |
dma_sigio 3110400 10000 0.5% 单次耗时：135us |
98.48% swapper |
|
4k 25fps dma_thread 13271040 40000 |
14.5% 单次耗时：6.7ms |
84.71% swapper [kernel.kallsyms] [k] __sched_text_end 84.75% swapper |
dma_sigio 13271040 40000 0.2% 单次耗时：135us |
98.51% swapper |
分析总结：
1. 同步模式下，CPU占用率跟数据量大小强相关，基本成正比；影响CPU占用率的最大因素是DMA传输同步等待，即上面dma_sync_wait()和dma_cookie_status()两个函数。
2. 异步模式下，请求发送后，交出CPU，在收到信号后继续下一次发送，期间不会占用CPU。CPU占用率跟DMA请求次数强相关，主要是发送请求，以及sigsuspend()和SIGIO信号处理占用。
3. 帧的吞吐率受DMA传输的帧大小影响。
3.2 那么异步模式的极限在哪里？
明显DMA的异步极限帧率，同样受限于DMA传输效率，并不会增大吞吐率。
那么看看不同帧率下的CPU情况：
| Case | 异步DMA | |
| top -d 5 | perf record -a -e cpu-clock -- sleep 60 | |
|
1080p 550 fps (max) |
2.6% |
96.50% swapper |
| 1080p 375 fps | 1.8 | 98.44% swapper |
| 1080p 273 fps | 1.2% | 98.43% swapper |
|
4K 145 fps (max) |
0.8% |
98.45% swapper |
所以DMA极限帧率，主要受DMA传输大小和传输速度影响。
3.3 kernelshark对比DMA同步/异步模式
分别看看上面3个场景下同步模式下，kernelshark输出可以看出1080p执行时间是1.67ms，4k时间是6.88ms；每次时间间隔跟fps设置也对应。
1080p 50fps、1080p 100fps、4k 25fps三种占用率应该是1.67/21.67=7.7%、1.67/11.67=14.3%、6.88/46.88=14.7%。
再来看一下异步情况下的输出，这时候越是大尺寸DMA传输CPU占用率的收益越大。4k的时候
下面以1080p和4k对比看一下异步的收益。
1080p的DMA传输占用时间从1.65，降到了1.65-1.57=0.08，收益率95%。
可以看出4k情况下异步DMA的CPU占用时间从6.70，降到6.70-6.64=0.06，收益率达到99%。
4. 同进程多SIGIO冲突解决
当测试通过，进入方案的时候遇到SIGIO无法接收到的问题。
检查得知，原来是存在多个设备kill_fasync()。而一个进程范围内，SIGIO只能有一个handler。
通过fcntl()设置F_SETSIG可以定义sig代提SIGIO发送信号。
操作如下：
#define SIGDMA (SIGRTMIN+1)--------------------------定义一个实时信号
fcntl(fd, F_SETSIG, SIGDMA);---------------------使用SIGDMA代提SIGIO作为async信号。
memset(&sa, 0, sizeof(sa));
sa.sa_sigaction = sigdma_handler;----------------一定要修改为sa_sigaction，对应的sigdma_handler参数也需要修改。
sa.sa_flags = SA_RESTART | SA_SIGINFO;-----------一定要增加SA_SIGINFO。
sigaction(SIGDMA, &sa, NULL);
除了有上面的好处之外，实时信号还能排队，这就比非实时信号更不会丢失。除非队列溢出。
5. 实际场景提升效果
在实际场景中，每40ms来一帧数据进行DMA搬运，
那么这段时间内，整个线程占用多少时间呢？2.303-0.225=2.078ms，对应的CPU占用率应该是5.2%。
再看看异步DMA实际效果如何？可以看出copy线程，中间调度出去的时间增大不小。
那么此时CPU占用率多少呢？2.288-1.177-0.431=0.68ms，对应的CPU占用率应该是1.7%。
从计算来看CPU占用率能降低3%左右。
6. 其他方案
1. 使用AXI DMA两通道，能否提高DMA吞吐率？相当于DMA并发，copy双线程？------------硬件双通道，如何构造同时触发的双通道case？
2. 如何标识每一次DMA传输，通过netlink port端口？--------------------------------------------------修改异步触发方式，port和channel绑定
联系方式:arnoldlu@qq.com标签：kernel,perf,DMA,kallsyms,IO,async,main,dma 来源： https://www.cnblogs.com/sky-heaven/p/16280815.html
本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享； 2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关； 3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关； 4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除； 5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。