• 内核中内存数据迁移速度对比

    前言

            我这样干不知道合理不合理啊，路过的大神给指点指点啊。

            本次实验完整以下任务：

            1 申请两块内核 abuf和bbuf，大小是1280*800

            2 执行memcpy(abuf,bbuf,1280*800)，计算消耗的时间

            3 在定时器处理函数中执行memcpy(abuf,bbuf,1280*800)，计算消耗的时间

            4 使用dmaengine 复制两块内存的数据。并计算每次消耗的时间。也是计算十次

            5 

    一 涉及到的函数

    使用__get_free_pages分配内存

    #define CSS_DMA_IMAGE_SIZE 1280*800

    css_dev->buf_size = CSS_DMA_IMAGE_SIZE;

    css_dev->buf_size_order = get_order(CSS_DMA_IMAGE_SIZE );

    p = (void*)__get_free_pages(GFP_KERNEL|GFP_DMA,css_dev->buf_size_order);
        if(p == NULL || IS_ERR(p)){
            DEBUG_CSS("devm_kmalloc error");
            return -ENOMEM;
        }

    在驱动初始化函数中使用memcpy复制内存：

    memcpy(css_dev->dst_buf,css_dev->src_buf,css_dev->buf_size);

    计算时间

    struct timeval {
        __kernel_time_t        tv_sec;        /* seconds */
        __kernel_suseconds_t    tv_usec;    /* microseconds */
    };

    struct timeval tv_start,tv_end;

    do_gettimeofday(&tv_start);
    memcpy(css_dev->dst_buf,css_dev->src_buf,css_dev->buf_size);
    do_gettimeofday(&tv_end);

    DEBUG_CSS("used time = %d us",
        tv_end.tv_sec - tv_start.tv_sec)*1000000 +
        tv_end.tv_usec - tv_start.tv_usec
        );

    测试结果，如下图，最小值1683微秒，最大值2315微秒。

    二 计算memcpy消耗的时间 

    在定时器函数中使用memcpy复制内存：

    1. static void __maybe_unused css_timer_function(unsigned long arg)
    2. {
    3.     struct _css_dev_ *css_dev = (struct _css_dev_ *)arg;
    4.     static int count = 0;
    5.     struct timeval tv_start,tv_end;
    6.     if(count < 10){
    7.         do_gettimeofday(&tv_start);
    8.         memcpy(css_dev->dst_buf,css_dev->src_buf,css_dev->buf_size);
    9.         do_gettimeofday(&tv_end);
    10.         DEBUG_CSS("used time = %d us",
    11.         (tv_end.tv_sec - tv_start.tv_sec)*1000000 + (tv_end.tv_usec - tv_start.tv_usec));
    12.         count++;
    13.         mod_timer(&css_dev->timer,jiffies + msecs_to_jiffies(1000));
    14.     }
    15. }
    16.  
    17.     init_timer(&css_dev->timer);
    18.     css_dev->timer.function = css_timer_function;
    19.     css_dev->timer.data = (unsigned long)css_dev;
    20.     mod_timer(&css_dev->timer,jiffies + msecs_to_jiffies(1000));

    执行结果如下所示：由结果可知，在定时器中执行memcpy还是时间比较稳定的。

     三 计算dmaengine消耗的时间

    源码：

            实验内容等同于memcpy(css_dev->dst_buf,css_dev->src_buf,css_dev->buf_size);

            第一次使用dmaengine的时候，经过测试，发现复制后，src和dst数据不一致，经过多次修改后，终于数据正常了

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10. #include 
    11. #include 
    12. #include 
    13. #include 
    14. #include 
    15. #include 
    16. #include 
    17. #include 
    18.  
    19.  
    20. #define DEBUG_CSS(format,...)\
    21. 		printk(KERN_INFO"info:%s:%s:%d: "format"\n",\
    22. 		__FILE__,__func__,__LINE__,\
    23. 		##__VA_ARGS__)
    24. #define DEBUG_CSS_ERR(format,...)\
    25. 		printk("\001" "1""error:%s:%s:%d: "format"\n",\
    26. 		__FILE__,__func__,__LINE__,\
    27. 		##__VA_ARGS__)
    28.  
    29. #define CSS_DMA_IMAGE_SIZE		(1280*800)
    30.  
    31. #define CSI_DMA_SET_CUR_MAP_BUF_TYPE_IOCTL 0x1001
    32.  
    33. enum _css_dev_buf_type{
    34.    _CSS_DEV_READ_BUF = 0,
    35.    _CSS_DEV_WRITE_BUF,
    36.    _CSS_DEV_UNKNOWN_BUF_TYPE,
    37.    _CSS_DEV_MAX_BUF_TYPE,
    38. };
    39. struct _css_dev_{
    40. 	struct file_operations _css_fops;
    41. 	struct miscdevice misc;
    42. 	int buf_size;
    43. 	int buf_size_order;
    44. 	char *src_buf;
    45. 	char *dst_buf;
    46. 	char *user_src_buf_vaddr;
    47. 	char *user_dst_buf_vaddr;
    48. 	dma_addr_t src_addr;
    49. 	dma_addr_t dst_addr;	
    50. 	struct spinlock slock;
    51. 	struct mutex open_lock;
    52. 	char name[10];
    53. 	enum _css_dev_buf_type buf_type; 
    54. 	struct device *dev;
    55. 	struct dma_chan * dma_m2m_chan;
    56. 	struct completion dma_m2m_ok;
    57. 	struct imx_dma_data m2m_dma_data;
    58. 	struct timeval tv_start,tv_end;
    59. };
    60.  
    61. #define _to_css_dev_(file)	(struct _css_dev_ *)container_of(file->f_op,struct _css_dev_,_css_fops)
    62. static int _css_open(struct inode *inode, struct file *file)
    63. {
    64. 	struct _css_dev_ *css_dev = _to_css_dev_(file);
    65. 	DEBUG_CSS("css_dev->name = %s",css_dev->name);
    66. 	return 0;
    67. }
    68. static ssize_t _css_read(struct file *file, char __user *ubuf, size_t size, loff_t *ppos)
    69. {
    70. 	struct _css_dev_ *css_dev = _to_css_dev_(file);
    71. 	DEBUG_CSS("css_dev->name = %s",css_dev->name);
    72. 	return 0;
    73. }
    74. static int _css_mmap (struct file *file, struct vm_area_struct *vma)
    75. {
    76. 	struct _css_dev_ *css_dev = _to_css_dev_(file);
    77. 	char *p = NULL;
    78. 	char **user_addr;
    79.  
    80. 	switch(css_dev->buf_type){
    81. 		case _CSS_DEV_READ_BUF:
    82. 			p = css_dev->src_buf;
    83. 			user_addr = (char**)&css_dev->user_src_buf_vaddr;
    84. 			break;
    85. 		case _CSS_DEV_WRITE_BUF:
    86. 			p = css_dev->dst_buf;
    87. 			user_addr = (char**)&css_dev->user_dst_buf_vaddr;
    88. 			break;
    89. 		default:
    90. 			p = NULL;
    91. 			return -EINVAL;
    92. 			break;			
    93. 	}
    94. 	if (remap_pfn_range(vma, vma->vm_start, virt_to_phys(p) >> PAGE_SHIFT,
    95. 	        vma->vm_end-vma->vm_start, vma->vm_page_prot)) {
    96. 	        DEBUG_CSS_ERR( "remap_pfn_range error\n"); 
    97. 	        return -EAGAIN;
    98. 	}
    99. 	css_dev->buf_type = _CSS_DEV_UNKNOWN_BUF_TYPE;
    100. 	*user_addr = (void*)vma->vm_start;	
    101. 	DEBUG_CSS("mmap ok user_addr = %p kernel addr = %p",*user_addr,p);
    102. 	return 0;
    103. }
    104. static ssize_t _css_write(struct file *file, const char __user *ubuf, size_t size, loff_t *ppos)
    105. {
    106. 	struct _css_dev_ *css_dev = _to_css_dev_(file);
    107. 	DEBUG_CSS("css_dev->name = %s",css_dev->name);
    108. 	return size;
    109. }
    110.  
    111. static int _css_release (struct inode *inode, struct file *file)
    112. {
    113. 	struct _css_dev_ *css_dev = _to_css_dev_(file);
    114. 	DEBUG_CSS("css_dev->name = %s",css_dev->name);
    115. 	DEBUG_CSS("css_dev->src_buf[%d] = %c",css_dev->buf_size - 1,
    116. 		((char*)css_dev->src_buf)[css_dev->buf_size - 1]);
    117. 	DEBUG_CSS("css_dev->dst_buf[%d] = %c",css_dev->buf_size - 1,
    118. 		((char*)css_dev->dst_buf)[css_dev->buf_size - 1]);
    119. 	return 0;
    120. }
    121.  
    122. static int _css_set_buf_type(struct file *file, enum _css_dev_buf_type buf_type)
    123. {
    124. 	unsigned long flags;
    125. 	struct _css_dev_ *css_dev = _to_css_dev_(file);
    126. 	DEBUG_CSS("buf_type=%d",buf_type);
    127. 	if(buf_type >= _CSS_DEV_MAX_BUF_TYPE){
    128. 		DEBUG_CSS_ERR("invalid buf type");
    129. 		return -EINVAL;
    130. 	}
    131. 	spin_lock_irqsave(&css_dev->slock,flags);
    132. 	css_dev->buf_type = buf_type;	
    133. 	spin_unlock_irqrestore(&css_dev->slock,flags);
    134. 	return 0;
    135. }
    136. static long _css_unlocked_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
    137. {
    138. 	int ret = 0;
    139. 	switch(cmd){
    140. 		case CSI_DMA_SET_CUR_MAP_BUF_TYPE_IOCTL:
    141. 		ret = _css_set_buf_type(file,(enum _css_dev_buf_type)arg);
    142. 		break;
    143. 		default:
    144. 			DEBUG_CSS_ERR("unknown cmd = %x",cmd);
    145. 			ret = -EINVAL;
    146. 			break;
    147. 	}
    148. 	
    149. 	return ret;
    150. }
    151.  
    152. static struct _css_dev_ _global_css_dev = {
    153. 	.name = "lkmao",
    154. 	._css_fops = {
    155. 		.owner = THIS_MODULE,
    156. 		.mmap = _css_mmap,
    157. 		.open = _css_open,
    158. 		.release = _css_release,
    159. 		.read = _css_read,
    160. 		.write = _css_write,
    161. 		.unlocked_ioctl = _css_unlocked_ioctl,
    162. 	},
    163. 	.misc = {
    164. 		.minor = MISC_DYNAMIC_MINOR,
    165. 		.name = "css_dma",
    166. 	},
    167. 	.buf_type = _CSS_DEV_UNKNOWN_BUF_TYPE,
    168. 	.user_src_buf_vaddr = NULL,
    169. 	.user_dst_buf_vaddr = NULL,
    170. 	.m2m_dma_data = {
    171. 		.peripheral_type = IMX_DMATYPE_MEMORY,
    172. 		.priority = DMA_PRIO_HIGH,
    173. 	},
    174. };
    175.  
    176.  
    177. static int css_dev_get_dma_addr(struct _css_dev_ *css_dev,char **vaddr,dma_addr_t *phys, int direction)
    178. {
    179. 	char *p;
    180. 	dma_addr_t dma_addr;
    181.  
    182. 	p = (char*)__get_free_pages(GFP_KERNEL|GFP_DMA,css_dev->buf_size_order);
    183. 	if(p == NULL || IS_ERR(p)){
    184. 		DEBUG_CSS("devm_kmalloc error");
    185. 		return -ENOMEM;
    186. 	}
    187. 	dma_addr = dma_map_single(css_dev->dev, p, css_dev->buf_size, direction);	
    188.  
    189. 	*vaddr = p;
    190. 	*phys = dma_addr;
    191.  
    192. 	DEBUG_CSS("32bit:p = %p,dma_addr = %x",p,dma_addr);
    193. 	return 0;
    194. }
    195.  
    196. static bool css_dma_filter_fn(struct dma_chan *chan, void *filter_param)
    197. {
    198. 	if(!imx_dma_is_general_purpose(chan)){
    199. 		DEBUG_CSS("css_dma_filter_fn error");
    200. 		return false;
    201. 	}
    202. 	chan->private = filter_param;
    203. 	return true;
    204. }
    205. static void css_dma_async_tx_callback(void *dma_async_param)
    206. {
    207. 	struct _css_dev_ *css_dev = (struct _css_dev_ *)dma_async_param;
    208. 	complete(&css_dev->dma_m2m_ok);
    209. }
    210.  
    211. static int css_dmaengine_init(struct _css_dev_ *css_dev)
    212. {
    213. 	dma_cap_mask_t dma_m2m_mask;
    214. 	struct dma_slave_config dma_m2m_config = {0};
    215. 	css_dev->m2m_dma_data.peripheral_type = IMX_DMATYPE_MEMORY;
    216. 	css_dev->m2m_dma_data.priority = DMA_PRIO_HIGH;
    217. 	
    218. 	dma_cap_zero(dma_m2m_mask);
    219. 	dma_cap_set(DMA_MEMCPY,dma_m2m_mask);
    220.  
    221. 	
    222.  
    223. 	css_dev->dma_m2m_chan = dma_request_channel(dma_m2m_mask,css_dma_filter_fn,&css_dev->m2m_dma_data);
    224. 	if(!css_dev->dma_m2m_chan){
    225. 		DEBUG_CSS("dma_request_channel error");
    226. 		return -EINVAL;
    227. 	}
    228. 	dma_m2m_config.direction = DMA_MEM_TO_MEM;
    229. 	dma_m2m_config.dst_addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES;
    230. 	dmaengine_slave_config(css_dev->dma_m2m_chan,&dma_m2m_config);
    231. 	
    232. 	return 0;
    233. }
    234.  
    235. static int css_dmaengine_test(unsigned long arg)
    236. {
    237. 	struct _css_dev_ *css_dev = (struct _css_dev_ *)arg;
    238. 	struct dma_async_tx_descriptor *dma_m2m_desc;
    239. 	struct dma_device *dma_dev;
    240. 	struct device *chan_dev;
    241. 	dma_cookie_t cookie;
    242. 	enum dma_status dma_status;
    243.  
    244. 	do_gettimeofday(&css_dev->tv_start);
    245. 	dma_dev = css_dev->dma_m2m_chan->device;
    246. 	chan_dev = css_dev->dma_m2m_chan->device->dev;
    247.  
    248. 	css_dev->src_addr = dma_map_single(chan_dev, css_dev->src_buf, css_dev->buf_size, DMA_TO_DEVICE);	
    249.  
    250. 	css_dev->dst_addr = dma_map_single(chan_dev, css_dev->dst_buf, css_dev->buf_size, DMA_FROM_DEVICE);	
    251. 	
    252. 	//DEBUG_CSS("32bit:css_dev->src_addr = %x,css_dev->dst_addr = %x",css_dev->src_addr,css_dev->dst_addr);
    253.  
    254. 	
    255. 	dma_m2m_desc = dma_dev->device_prep_dma_memcpy(css_dev->dma_m2m_chan,
    256. 													css_dev->dst_addr,
    257. 													css_dev->src_addr,
    258. 													css_dev->buf_size,0);
    259. 	dma_m2m_desc->callback = css_dma_async_tx_callback;
    260. 	dma_m2m_desc->callback_param = css_dev;
    261. 	
    262. 	init_completion(&css_dev->dma_m2m_ok);
    263. 	cookie = dmaengine_submit(dma_m2m_desc);
    264. 	if(dma_submit_error(cookie)){
    265. 		DEBUG_CSS("dmaengine_submit error");
    266. 		return -EINVAL;
    267. 	}
    268. 	dma_async_issue_pending(css_dev->dma_m2m_chan);
    269. 	wait_for_completion(&css_dev->dma_m2m_ok);
    270. 	
    271. 	dma_status = dma_async_is_tx_complete(css_dev->dma_m2m_chan,cookie,NULL,NULL);
    272. 	if(DMA_COMPLETE != dma_status){
    273. 		DEBUG_CSS("dma_status = %d",dma_status);
    274. 	}
    275. 	dma_unmap_single(chan_dev,css_dev->src_addr,css_dev->buf_size,DMA_TO_DEVICE);
    276. 	dma_unmap_single(chan_dev,css_dev->dst_addr,css_dev->buf_size,DMA_FROM_DEVICE);
    277. 	
    278. 	do_gettimeofday(&css_dev->tv_end);
    279. 	DEBUG_CSS("used time = %ld us",
    280. 	(css_dev->tv_end.tv_sec - css_dev->tv_start.tv_sec)*1000000 
    281. 	+ (css_dev->tv_end.tv_usec - css_dev->tv_start.tv_usec));
    282. 	return 0;
    283. }
    284.  
    285. static int css_dev_init(struct platform_device *pdev,struct _css_dev_ *css_dev)
    286. {
    287. 	int i = 0,j = 0;
    288. 	css_dev->misc.fops = &css_dev->_css_fops;
    289.  
    290. 	pr_debug("css_init init ok");
    291. 	mutex_init(&css_dev->open_lock);
    292. 	spin_lock_init(&css_dev->slock);
    293. 	printk("KERN_ALERT = %s",KERN_ALERT);
    294. 	
    295.  
    296. 	css_dev->dev = &pdev->dev;
    297. 	css_dev->buf_size = CSS_DMA_IMAGE_SIZE;
    298. 	css_dev->buf_size_order = get_order(css_dev->buf_size);
    299. 	
    300. 	if(css_dev_get_dma_addr(css_dev,&css_dev->src_buf,&css_dev->src_addr,DMA_TO_DEVICE)){
    301. 		return -ENOMEM;
    302. 	}
    303. 	css_dev->src_buf = (char*)__get_free_pages(GFP_KERNEL|GFP_DMA,css_dev->buf_size_order);
    304. 	if(css_dev->src_buf == NULL || IS_ERR(css_dev->src_buf)){
    305. 		DEBUG_CSS("devm_kmalloc error");
    306. 		return -ENOMEM;
    307. 	}
    308. 	css_dev->dst_buf = (char*)__get_free_pages(GFP_KERNEL|GFP_DMA,css_dev->buf_size_order);
    309. 	if(css_dev->dst_buf == NULL || IS_ERR(css_dev->dst_buf)){
    310. 		DEBUG_CSS("devm_kmalloc error");
    311. 		return -ENOMEM;
    312. 	}
    313. 	DEBUG_CSS("32bit:css_dev->src_buf = %p,css_dev->dst_buf = %p",css_dev->src_buf,css_dev->dst_buf);
    314.  
    315. 	if(misc_register(&css_dev->misc) != 0){
    316. 		DEBUG_CSS("misc_register error");
    317. 		return -EINVAL;
    318. 	}
    319. 	platform_set_drvdata(pdev,css_dev);
    320. 	css_dmaengine_init(css_dev);
    321. 	
    322. 	for(i = 0;i < 10;i++){
    323. 		memset(css_dev->src_buf,5,css_dev->buf_size);
    324. 		memset(css_dev->dst_buf,6,css_dev->buf_size);
    325. #if 1		
    326. 		css_dmaengine_test((unsigned long)css_dev);
    327. #else
    328. 		memcpy(css_dev->dst_buf,css_dev->src_buf,css_dev->buf_size);
    329. #endif		
    330. 		for(j = 0;j < css_dev->buf_size;j++){
    331. 			if(css_dev->dst_buf[j] != 5){
    332. 				DEBUG_CSS("css_dev->dst_buf[%d] = %d",j,css_dev->dst_buf[j]);
    333. 				DEBUG_CSS("css_dev->src_buf[%d] = %d",j,css_dev->src_buf[j]);
    334. 				break;
    335. 			}
    336. 		}
    337. 		if(j != css_dev->buf_size){
    338. 			DEBUG_CSS("i = %d,css_dmaengine_test error",i);
    339. 			return -EINVAL;
    340. 		}else{
    341. 			DEBUG_CSS("copy ok %d times",i+1);
    342. 		}
    343. 	}
    344. 	return 0;
    345. }
    346.  
    347.  
    348. static int css_probe(struct platform_device *pdev)
    349. {
    350. 	struct _css_dev_ *css_dev = (struct _css_dev_ *)&_global_css_dev;
    351. 	if(css_dev_init(pdev,css_dev)){
    352. 		return -EINVAL;
    353. 	}	
    354. 	DEBUG_CSS("init ok");
    355. 	return 0;
    356. }
    357.  
    358. static int css_remove(struct platform_device *pdev)
    359. {
    360. 	struct _css_dev_ *css_dev = &_global_css_dev;
    361.  
    362. 	dma_unmap_single(css_dev->dev,css_dev->src_addr,css_dev->buf_size,DMA_FROM_DEVICE);
    363. 	dma_unmap_single(css_dev->dev,css_dev->dst_addr,css_dev->buf_size,DMA_FROM_DEVICE);
    364.  
    365. 	free_page((unsigned long )css_dev->dst_buf);
    366. 	free_page((unsigned long )css_dev->src_buf);
    367.  
    368. 	misc_deregister(&css_dev->misc);
    369. 	dma_release_channel(css_dev->dma_m2m_chan);
    370. 	DEBUG_CSS("exit ok");
    371. 	return 0;
    372. }
    373.  
    374. static const struct of_device_id css_of_ids[] = {
    375. 	{.compatible = "css_dma"},
    376. 	{},
    377. };
    378. MODULE_DEVICE_TABLE(of,css_of_ids);
    379. static struct platform_driver css_platform_driver = {
    380. 	.probe =  css_probe,
    381. 	.remove = css_remove,
    382. 	.driver = {
    383. 		.name = "css_dma",
    384. 		.of_match_table = css_of_ids,
    385. 		.owner = THIS_MODULE,
    386. 	},
    387. };
    388.  
    389. static int __init css_init(void)
    390. {
    391. 	int ret_val;
    392. 	ret_val = platform_driver_register(&css_platform_driver);
    393. 	if(ret_val != 0){
    394. 		DEBUG_CSS("platform_driver_register error");
    395. 		return ret_val;
    396. 	}
    397. 	DEBUG_CSS("platform_driver_register ok");
    398. 	return 0;
    399. }
    400.  
    401. static void __exit css_exit(void)
    402. {
    403. 	platform_driver_unregister(&css_platform_driver);
    404. }
    405.  
    406. module_init(css_init);
    407. module_exit(css_exit);
    408. MODULE_LICENSE("GPL");
    409.

    设备树：

    1.     sdma_m2m{
    2. 		compatible = "css_dma";
    3. 	};

    测试结果，这个有点恐怖了，需要20多毫秒，是memcpy的十几倍啊，

    小结

            

  • 相关阅读:
    Mysql互不关联的联表查询（减少了查询的次数）
    病毒攻防原理
    [C国演义] 第十六章
    IO拷贝文件大全
    20220719_Filter_Listener_AJAX_Axios的用法
    golang学习笔记系列之流程控制
    vue2与vue3的使用区别与组件通信
    c++ 类的多态以及虚函数
    IOS开发学习日记（十七）
    12 张图看懂 CPU 缓存一致性与 MESI 协议，真的一致吗？
  • 原文地址：https://blog.csdn.net/yueni_zhao/article/details/127730383