文章详情

短信预约-IT技能 免费直播动态提醒

请输入下面的图形验证码

提交验证

短信预约提醒成功

Linux大文件重定向和管道的效率对比

2024-12-24 19:35

关注
  1. # 命令1,管道导入 
  2. shell> cat huge_dump.sql | mysql -uroot; 
  1. # 命令2,重定向导入 
  2. shell> mysql -uroot < huge_dump.sql

大家先看一下上面二个命令,假如huge_dump.sql文件很大,然后猜测一下哪种导入方式效率会更高一些?

这个问题挺有意思的,我的第一反应是:没比较过,应该是一样的,一个是cat负责打开文件,一个是bash

这种场景在MySQL运维操作里面应该比较多,所以就花了点时间做了个比较和原理上的分析:

我们先构造场景:

首先准备一个程序b.out来模拟mysql对数据的消耗:

  1. int main(int argc, char *argv[]) 
  2.   while(fread(buf, sizeof(buf), 1, stdin) > 0); 
  3.     return 0; 
  4.  
  5. $  gcc  -o b.out b.c 
  6. $ ls|./b.out 

再来写个systemtap脚本用来方便观察程序的行为。

  1. $ cat test.stp 
  2. function should_log(){ 
  3.   return (execname() == "cat" || 
  4.       execname() == "b.out" || 
  5.       execname() == "bash") ; 
  6. probe syscall.open, 
  7.       syscall.close, 
  8.       syscall.read, 
  9.       syscall.write, 
  10.       syscall.pipe, 
  11.       syscall.fork, 
  12.       syscall.execve, 
  13.       syscall.dup, 
  14.       syscall.wait4 
  15.   if (!should_log()) next; 
  16.   printf("%s -> %s\n", thread_indent(0), probefunc()); 
  17.   
  18. probe kernel.function("pipe_read"), 
  19.       kernel.function("pipe_readv"), 
  20.       kernel.function("pipe_write"), 
  21.       kernel.function("pipe_writev") 
  22.   if (!should_log()) next; 
  23.   printf("%s -> %s: file ino %d\n",  thread_indent(0), probefunc(), __file_ino($filp)); 
  24. probe begin { println(":~") } 

这个脚本重点观察几个系统调用的顺序和pipe的读写情况,然后再准备个419M的大文件huge_dump.sql,在我们几十G内存的机器很容易在内存里放下:

  1. $ sudo dd if=/dev/urandom of=huge_dump.sql bs=4096 count=102400 
  2. 102400+0 records in 
  3. 102400+0 records out 
  4. 419430400 bytes (419 MB) copied, 63.9886 seconds, 6.6 MB/s 

因为这个文件是用bufferio写的,所以它的内容都cache在pagecahce内存里面,不会涉及到磁盘。

好了,场景齐全了,我们接着来比较下二种情况下的速度,第一种管道:

  1. # 第一种管道方式 
  2. $ time (cat huge_dump.sql|./b.out) 
  3.   
  4. real    0m0.596s 
  5. user    0m0.001s 
  6. sys     0m0.919s 
  7.   
  8. # 第二种重定向方式 
  9. $ time (./b.out <huge_dump.sql
  10.   
  11. real    0m0.151s 
  12. user    0m0.000s 
  13. sys     0m0.147s 

从执行时间数看出来速度有3倍左右的差别了,第二种明显快很多。

是不是有点奇怪?好吧我们来从原来上面分析下,还是继续用数据说话:

这次准备个很小的数据文件,方便观察然后在一个窗口运行stap

  1. $ echo hello > huge_dump.sql 
  2. $ sudo stap test.stp 
  3. :~ 
  4.      0 bash(26570): -> sys_read 
  5.      0 bash(26570): -> sys_read 
  6.      0 bash(26570): -> sys_write 
  7.      0 bash(26570): -> sys_read 
  8.      0 bash(26570): -> sys_write 
  9.      0 bash(26570): -> sys_close 
  10.      0 bash(26570): -> sys_pipe 
  11.      0 bash(26570): -> sys_pipe 
  12.      0 bash(26570): -> do_fork 
  13.      0 bash(26570): -> sys_close 
  14.      0 bash(26570): -> sys_close 
  15.      0 bash(26570): -> do_fork 
  16.      0 bash(13775): -> sys_close 
  17.      0 bash(13775): -> sys_read 
  18.      0 bash(13775): -> pipe_read: file ino 20906911 
  19.      0 bash(13775): -> pipe_readv: file ino 20906911 
  20.      0 bash(13776): -> sys_close 
  21.      0 bash(13776): -> sys_close 
  22.      0 bash(13776): -> sys_close 
  23.      0 bash(13776): -> do_execve 
  24.      0 bash(26570): -> sys_close 
  25.      0 bash(26570): -> sys_close 
  26.      0 bash(26570): -> sys_close 
  27.      0 bash(13775): -> sys_close 
  28.      0 bash(26570): -> sys_wait4 
  29.      0 bash(13775): -> sys_close 
  30.      0 bash(13775): -> sys_close 
  31.      0 b.out(13776): -> sys_close 
  32.      0 b.out(13776): -> sys_close 
  33.      0 bash(13775): -> do_execve 
  34.      0 b.out(13776): -> sys_open 
  35.      0 b.out(13776): -> sys_close 
  36.      0 b.out(13776): -> sys_open 
  37.      0 b.out(13776): -> sys_read 
  38.      0 b.out(13776): -> sys_close 
  39.      0 cat(13775): -> sys_close 
  40.      0 cat(13775): -> sys_close 
  41.      0 b.out(13776): -> sys_read 
  42.      0 b.out(13776): -> pipe_read: file ino 20906910 
  43.      0 b.out(13776): -> pipe_readv: file ino 20906910 
  44.      0 cat(13775): -> sys_open 
  45.      0 cat(13775): -> sys_close 
  46.      0 cat(13775): -> sys_open 
  47.      0 cat(13775): -> sys_read 
  48.      0 cat(13775): -> sys_close 
  49.      0 cat(13775): -> sys_open 
  50.      0 cat(13775): -> sys_close 
  51.      0 cat(13775): -> sys_open 
  52.      0 cat(13775): -> sys_read 
  53.      0 cat(13775): -> sys_write 
  54.      0 cat(13775): -> pipe_write: file ino 20906910 
  55.      0 cat(13775): -> pipe_writev: file ino 20906910 
  56.      0 cat(13775): -> sys_read 
  57.      0 b.out(13776): -> sys_read 
  58.      0 b.out(13776): -> pipe_read: file ino 20906910 
  59.      0 b.out(13776): -> pipe_readv: file ino 20906910 
  60.      0 cat(13775): -> sys_close 
  61.      0 cat(13775): -> sys_close 
  62.      0 bash(26570): -> sys_wait4 
  63.      0 bash(26570): -> sys_close 
  64.      0 bash(26570): -> sys_wait4 
  65.      0 bash(26570): -> sys_write 

stap在收集数据了,我们在另外一个窗口运行管道的情况:

  1. $ cat huge_dump.sql|./b.out 

我们从systemtap的日志可以看出:

那么再看下命令2重定向的情况:

  1. $ ./b.out < huge_dump.sql 
  2.   
  3. stap输出: 
  4.       0 bash(26570): -> sys_read 
  5.      0 bash(26570): -> sys_read 
  6.      0 bash(26570): -> sys_write 
  7.      0 bash(26570): -> sys_read 
  8.      0 bash(26570): -> sys_write 
  9.      0 bash(26570): -> sys_close 
  10.      0 bash(26570): -> sys_pipe 
  11.      0 bash(26570): -> do_fork 
  12.      0 bash(28926): -> sys_close 
  13.      0 bash(28926): -> sys_read 
  14.      0 bash(28926): -> pipe_read: file ino 20920902 
  15.      0 bash(28926): -> pipe_readv: file ino 20920902 
  16.      0 bash(26570): -> sys_close 
  17.      0 bash(26570): -> sys_close 
  18.      0 bash(26570): -> sys_wait4 
  19.      0 bash(28926): -> sys_close 
  20.      0 bash(28926): -> sys_open 
  21.      0 bash(28926): -> sys_close 
  22.      0 bash(28926): -> do_execve 
  23.      0 b.out(28926): -> sys_close 
  24.      0 b.out(28926): -> sys_close 
  25.      0 b.out(28926): -> sys_open 
  26.      0 b.out(28926): -> sys_close 
  27.      0 b.out(28926): -> sys_open 
  28.      0 b.out(28926): -> sys_read 
  29.      0 b.out(28926): -> sys_close 
  30.      0 b.out(28926): -> sys_read 
  31.      0 b.out(28926): -> sys_read 
  32.      0 bash(26570): -> sys_wait4 
  33.      0 bash(26570): -> sys_write 
  34.      0 bash(26570): -> sys_read 

现在就非常清楚为什么二种场景速度有3倍的差别:

结论:Linux下大文件重定向效率更高。

来源:Linux云计算网络内容投诉

免责声明:

① 本站未注明“稿件来源”的信息均来自网络整理。其文字、图片和音视频稿件的所属权归原作者所有。本站收集整理出于非商业性的教育和科研之目的,并不意味着本站赞同其观点或证实其内容的真实性。仅作为临时的测试数据,供内部测试之用。本站并未授权任何人以任何方式主动获取本站任何信息。

② 本站未注明“稿件来源”的临时测试数据将在测试完成后最终做删除处理。有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341

软考中级精品资料免费领

  • 历年真题答案解析
  • 备考技巧名师总结
  • 高频考点精准押题
  • 2024年上半年信息系统项目管理师第二批次真题及答案解析(完整版)

    难度     813人已做
    查看
  • 【考后总结】2024年5月26日信息系统项目管理师第2批次考情分析

    难度     354人已做
    查看
  • 【考后总结】2024年5月25日信息系统项目管理师第1批次考情分析

    难度     318人已做
    查看
  • 2024年上半年软考高项第一、二批次真题考点汇总(完整版)

    难度     435人已做
    查看
  • 2024年上半年系统架构设计师考试综合知识真题

    难度     224人已做
    查看

相关文章

发现更多好内容

猜你喜欢

AI推送时光机
位置:首页-资讯-后端开发
咦!没有更多了?去看看其它编程学习网 内容吧
首页课程
资料下载
问答资讯