高级搜索|网站地图|TAG标签RSS订阅[设为首页] [加入收藏]

搜索

热门标签:

当前位置: > Linux编程 >

何不 Ack？Grep, Ack, Ag的搜索效率对比

时间:2015-03-20 00:30来源:dongwm.com 作者:董伟明

前言

我（@董伟明9 ）经常看到很多程序员， 运维在代码搜索上使用ack， 甚至ag(the_silver_searcher )， 而我工作中95%都是用grep，剩下的是ag。 我觉得很有必要聊一聊这个话题。

我以前也是一个运维， 我当时也希望找到最好的最快的工具用在工作的方方面面。 但是我很好奇为什么ag和ack没有作为linux发行版的内置部分。 内置的一直是grep。 我当初的理解是受各种开源协议的限制， 或者发行版的boss个人喜好。 后来我就做了实验， 研究了下他们到底谁快。 当时的做法也无非跑几个真实地线上log看看用时。 然后我也有了我的一个认识: 大部分时候用grep也无妨， 日志很大的时候用ag。

ack原来的域名是betterthangrep.com， 现在是beyondgrep.com。 好吧，其实我理解使用ack的同学， 也理解ack产生的原因。 这里就有个故事。

最开始我做运维使用shell， 经常做一些分析日志的工作。 那时候经常写比较复杂的shell代码实现一些特定的需求。 后来来了一位会perl的同学。 原来我写shell做一个事情， 写了20多行shell代码， 跑一次大概5分钟， 这位同学来了用perl改写， 4行， 一分钟就能跑完。 亮瞎我们的眼， 从那时候开始， 我就觉得需要学perl，以至于后来的python。

perl是天生用来文本解析的语言， ack的效率确实很高。 我想着可能是大家认为ack要更快更合适的理由吧。 其实这件事要看场景。 我为什么还用比较’土’的grep呢？

看一下这篇文章， 希望给大家点启示。不耐烦看具体测试过程的同学，可以直接看结论：

  1. 在搜索的总数据量较小的情况下， 使用grep， ack甚至ag在感官上区别不大
  2. 搜索的总数据量较大时， grep效率下滑的很多， 完全不要选
  3. ack在某些场景下没有grep效果高(比如使用-v搜索中文的时候)
  4. 在不使用ag没有实现的选项功能的前提下， ag完全可以替代ack/grep

实验条件

PS: 严重声明， 本实验经个人实践， 我尽量做到合理。 大家看完觉得有异议可以试着其他的角度来做。 并和我讨论。

  • 我使用了公司的一台开发机(gentoo)

  • 我测试了纯英文和汉语2种， 汉语使用了结巴分词的字典， 英语使用了miscfiles中提供的词典



    
	
  1. 
		# 假如你是ubuntu: sudo apt-get install miscfiles
    2. 
	
  2. 
		wget https://raw.githubusercontent.com/fxsjy/jieba/master/extra_dict/dict.txt.big
    3. 




	实验前的准备



	我会分成英语和汉语2种文件， 文件大小为1MB， 10MB， 100MB， 500MB， 1GB， 5GB。 没有更多是我觉得在实际业务里面不会单个日志文件过大的。 也就没有必要测试了(就算有， 可以看下面结果的趋势)。用下列程序深入测试的文件：




    
	
  1. 
		cat make_words.py
    2. 
	
  2. 
		# coding=utf-8
    3. 
	
  3. 
		 
    4. 
	
  4. 
		import os
    5. 
	
  5. 
		import random
    6. 
	
  6. 
		from cStringIO import StringIO
    7. 
	
  7. 
		 
    8. 
	
  8. 
		EN_WORD_FILE = '/usr/share/dict/words'
    9. 
	
  9. 
		CN_WORD_FILE = 'dict.txt.big'
    10. 
	
  10. 
		with open(EN_WORD_FILE) as f:
    11. 
	
  11. 
		EN_DATA = f.readlines()
    12. 
	
  12. 
		with open(CN_WORD_FILE) as f:
    13. 
	
  13. 
		CN_DATA = f.readlines()
    14. 
	
  14. 
		MB = pow(1024, 2)
    15. 
	
  15. 
		SIZE_LIST = [1, 10, 100, 500, 1024, 1024 * 5]
    16. 
	
  16. 
		EN_RESULT_FORMAT = 'text_{0}_en_MB.txt'
    17. 
	
  17. 
		CN_RESULT_FORMAT = 'text_{0}_cn_MB.txt'
    18. 
	
  18. 
		 
    19. 
	
  19. 
		 
    20. 
	
  20. 
		def write_data(f, size, data, cn=False):
    21. 
	
  21. 
		total_size = 0
    22. 
	
  22. 
		while 1:
    23. 
	
  23. 
		s = StringIO()
    24. 
	
  24. 
		for x in range(10000):
    25. 
	
  25. 
		cho = random.choice(data)
    26. 
	
  26. 
		cho = cho.split()[0] if cn else cho.strip()
    27. 
	
  27. 
		s.write(cho)
    28. 
	
  28. 
		s.seek(0, os.SEEK_END)
    29. 
	
  29. 
		total_size += s.tell()
    30. 
	
  30. 
		contents = s.getvalue()
    31. 
	
  31. 
		f.write(contents + '\n')
    32. 
	
  32. 
		if total_size > size:
    33. 
	
  33. 
		break
    34. 
	
  34. 
		f.close()
    35. 
	
  35. 
		 
    36. 
	
  36. 
		 
    37. 
	
  37. 
		for index, size in enumerate([
    38. 
	
  38. 
		MB,
    39. 
	
  39. 
		MB * 10,
    40. 
	
  40. 
		MB * 100,
    41. 
	
  41. 
		MB * 500,
    42. 
	
  42. 
		MB * 1024,
    43. 
	
  43. 
		MB * 1024 * 5]):
    44. 
	
  44. 
		size_name = SIZE_LIST[index]
    45. 
	
  45. 
		en_f = open(EN_RESULT_FORMAT.format(size_name), 'a+')
    46. 
	
  46. 
		cn_f = open(CN_RESULT_FORMAT.format(size_name), 'a+')
    47. 
	
  47. 
		write_data(en_f, size, EN_DATA)
    48. 
	
  48. 
		write_data(cn_f, size, CN_DATA, True)
    49. 




	好吧， 效率比较低是吧？ 我自己没有vps， 公司服务器我不能没事把全部内核的cpu都占满(不是运维好几年了)。 假如你不介意htop的多核cpu飘红， 可以这样，耗时就是各文件生成的时间短板。这是生成测试文件的多进程版本：




    
	
  1. 
		# coding=utf-8
    2. 
	
  2. 
		 
    3. 
	
  3. 
		import os
    4. 
	
  4. 
		import random
    5. 
	
  5. 
		import multiprocessing
    6. 
	
  6. 
		from cStringIO import StringIO
    7. 
	
  7. 
		 
    8. 
	
  8. 
		EN_WORD_FILE = '/usr/share/dict/words'
    9. 
	
  9. 
		CN_WORD_FILE = 'dict.txt.big'
    10. 
	
  10. 
		with open(EN_WORD_FILE) as f:
    11. 
	
  11. 
		EN_DATA = f.readlines()
    12. 
	
  12. 
		with open(CN_WORD_FILE) as f:
    13. 
	
  13. 
		CN_DATA = f.readlines()
    14. 
	
  14. 
		MB = pow(1024, 2)
    15. 
	
  15. 
		SIZE_LIST = [1, 10, 100, 500, 1024, 1024 * 5]
    16. 
	
  16. 
		EN_RESULT_FORMAT = 'text_{0}_en_MB.txt'
    17. 
	
  17. 
		CN_RESULT_FORMAT = 'text_{0}_cn_MB.txt'
    18. 
	
  18. 
		 
    19. 
	
  19. 
		inputs = []
    20. 
	
  20. 
		 
    21. 
	
  21. 
		def map_func(args):
    22. 
	
  22. 
		def write_data(f, size, data, cn=False):
    23. 
	
  23. 
		f = open(f, 'a+')
    24. 
	
  24. 
		total_size = 0
    25. 
	
  25. 
		while 1:
    26. 
	
  26. 
		s = StringIO()
    27. 
	
  27. 
		for x in range(10000):
    28. 
	
  28. 
		cho = random.choice(data)
    29. 
	
  29. 
		cho = cho.split()[0] if cn else cho.strip()
    30. 
	
  30. 
		s.write(cho)
    31. 
	
  31. 
		s.seek(0, os.SEEK_END)
    32. 
	
  32. 
		total_size += s.tell()
    33. 
	
  33. 
		contents = s.getvalue()
    34. 
	
  34. 
		f.write(contents + '\n')
    35. 
	
  35. 
		if total_size > size:
    36. 
	
  36. 
		break
    37. 
	
  37. 
		f.close()
    38. 
	
  38. 
		 
    39. 
	
  39. 
		_f, size, data, cn = args
    40. 
	
  40. 
		write_data(_f, size, data, cn)
    41. 
	
  41. 
		 
    42. 
	
  42. 
		 
    43. 
	
  43. 
		for index, size in enumerate([
    44. 
	
  44. 
		MB,
    45. 
	
  45. 
		MB * 10,
    46. 
	
  46. 
		MB * 100,
    47. 
	
  47. 
		MB * 500,
    48. 
	
  48. 
		MB * 1024,
    49. 
	
  49. 
		MB * 1024 * 5]):
    50. 
	
  50. 
		size_name = SIZE_LIST[index]
    51. 
	
  51. 
		inputs.append((EN_RESULT_FORMAT.format(size_name), size, EN_DATA, False))
    52. 
	
  52. 
		inputs.append((CN_RESULT_FORMAT.format(size_name), size, CN_DATA, True))
    53. 
	
  53. 
		 
    54. 
	
  54. 
		pool = multiprocessing.Pool()
    55. 
	
  55. 
		pool.map(map_func, inputs, chunksize=1)
    56. 




	等待一段时间后，测试的文件生成了。目录下是这样的：




    
	
  1. 
		$ls -lh
    2. 
	
  2. 
		total 14G
    3. 
	
  3. 
		-rw-rw-r-- 1 vagrant vagrant 2.2K Mar 14 05:25 benchmarks.ipynb
    4. 
	
  4. 
		-rw-rw-r-- 1 vagrant vagrant 8.2M Mar 12 15:43 dict.txt.big
    5. 
	
  5. 
		-rw-rw-r-- 1 vagrant vagrant 1.2K Mar 12 15:46 make_words.py
    6. 
	
  6. 
		-rw-rw-r-- 1 vagrant vagrant 101M Mar 12 15:47 text_100_cn_MB.txt
    7. 
	
  7. 
		-rw-rw-r-- 1 vagrant vagrant 101M Mar 12 15:47 text_100_en_MB.txt
    8. 
	
  8. 
		-rw-rw-r-- 1 vagrant vagrant 1.1G Mar 12 15:54 text_1024_cn_MB.txt
    9. 
	
  9. 
		-rw-rw-r-- 1 vagrant vagrant 1.1G Mar 12 15:51 text_1024_en_MB.txt
    10. 
	
  10. 
		-rw-rw-r-- 1 vagrant vagrant 11M Mar 12 15:47 text_10_cn_MB.txt
    11. 
	
  11. 
		-rw-rw-r-- 1 vagrant vagrant 11M Mar 12 15:47 text_10_en_MB.txt
    12. 
	
  12. 
		-rw-rw-r-- 1 vagrant vagrant 1.1M Mar 12 15:47 text_1_cn_MB.txt
    13. 
	
  13. 
		-rw-rw-r-- 1 vagrant vagrant 1.1M Mar 12 15:47 text_1_en_MB.txt
    14. 
	
  14. 
		-rw-rw-r-- 1 vagrant vagrant 501M Mar 12 15:49 text_500_cn_MB.txt
    15. 
	
  15. 
		-rw-rw-r-- 1 vagrant vagrant 501M Mar 12 15:48 text_500_en_MB.txt
    16. 
	
  16. 
		-rw-rw-r-- 1 vagrant vagrant 5.1G Mar 12 16:16 text_5120_cn_MB.txt
    17. 
	
  17. 
		-rw-rw-r-- 1 vagrant vagrant 5.1G Mar 12 16:04 text_5120_en_MB.txt
    18. 




	确认版本




    
	
  1. 
		$ ack --version # ack在ubuntu下叫`ack-grep`
    2. 
	
  2. 
		ack 2.12
    3. 
	
  3. 
		Running under Perl 5.16.3 at /usr/bin/perl
    4. 
	
  4. 
		 
    5. 
	
  5. 
		Copyright 2005-2013 Andy Lester.
    6. 
	
  6. 
		 
    7. 
	
  7. 
		This program is free software. You may modify or distribute it
    8. 
	
  8. 
		under the terms of the Artistic License v2.0.
    9. 
	
  9. 
		$ ag --version
    10. 
	
  10. 
		ag version 0.21.0
    11. 
	
  11. 
		$ grep --version
    12. 
	
  12. 
		grep (GNU grep) 2.14
    13. 
	
  13. 
		Copyright (C) 2012 Free Software Foundation, Inc.
    14. 
	
  14. 
		License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>.
    15. 
	
  15. 
		This is free software: you are free to change and redistribute it.
    16. 
	
  16. 
		There is NO WARRANTY, to the extent permitted by law.
    17. 
	
  17. 
		 
    18. 
	
  18. 
		Written by Mike Haertel and others, see <http://git.sv.gnu.org/cgit/grep.git/tree/AUTHORS>.
    19. 




	实验设计



	为了不产生并行执行的相互响应， 我还是选择了效率很差的同步执行， 我使用了ipython提供的%timeit。 测试程序的代码如下：




    
	
  1. 
		import re
    2. 
	
  2. 
		import glob
    3. 
	
  3. 
		import subprocess
    4. 
	
  4. 
		import cPickle as pickle
    5. 
	
  5. 
		from collections import defaultdict
    6. 
	
  6. 
		 
    7. 
	
  7. 
		IMAP = {
    8. 
	
  8. 
		'cn': ('豆瓣', '小明明'),
    9. 
	
  9. 
		'en': ('four', 'python')
    10. 
	
  10. 
		}
    11. 
	
  11. 
		OPTIONS = ('', '-i', '-v')
    12. 
	
  12. 
		FILES = glob.glob('text_*_MB.txt')
    13. 
	
  13. 
		EN_RES = defaultdict(dict)
    14. 
	
  14. 
		CN_RES = defaultdict(dict)
    15. 
	
  15. 
		RES = {
    16. 
	
  16. 
		'en': EN_RES,
    17. 
	
  17. 
		'cn': CN_RES
    18. 
	
  18. 
		}
    19. 
	
  19. 
		REGEX = re.compile(r'text_(\d+)_(\w+)_MB.txt')
    20. 
	
  20. 
		CALL_STR = '{command} {option} {word} {filename} > /dev/null 2>&1'
    21. 
	
  21. 
		 
    22. 
	
  22. 
		for filename in FILES:
    23. 
	
  23. 
		size, xn = REGEX.search(filename).groups()
    24. 
	
  24. 
		for word in IMAP[xn]:
    25. 
	
  25. 
		_r = defaultdict(dict)
    26. 
	
  26. 
		for command in ['grep', 'ack', 'ag']:
    27. 
	
  27. 
		for option in OPTIONS:
    28. 
	
  28. 
		rs = %timeit -o -n10 subprocess.call(CALL_STR.format(command=command, option=option, word=word, filename=filename), shell=True)
    29. 
	
  29. 
		best = rs.best
    30. 
	
  30. 
		_r[command][option] = best
    31. 
	
  31. 
		RES[xn][word][size] = _r
    32. 
	
  32. 
		 
    33. 
	
  33. 
		# 存起来
    34. 
	
  34. 
		 
    35. 
	
  35. 
		data = pickle.dumps(RES)
    36. 
	
  36. 
		 
    37. 
	
  37. 
		with open('result.db', 'w') as f:
    38. 
	
  38. 
		f.write(data)
    39. 




	温馨提示， 这是一个灰常耗时的测试。 开始执行后 要喝很久的茶…



	我来秦皇岛办事完毕(耗时超过1一天)， 继续我们的实验。



	我想要的效果



	我想工作的时候一般都是用到不带参数/带-i(忽略大小写)/-v(查找不匹配项)这三种。 所以这里测试了:


    
	
  1. 
		英文搜索/中文搜索
    2. 
	
  2. 
		选择了2个搜索词(效率太低， 否则可能选择多个)
    3. 
	
  3. 
		分别测试’’/’-i’/’-v’三种参数的执行
    4. 
	
  4. 
		使用%timeit， 每种条件执行10遍， 选择效率最好的一次的结果
    5. 
	
  5. 
		每个图代码一个搜索词， 3搜索命令， 一个选项在搜索不同大小文件时的效率对比
    6. 




	我先说结论


    
	
  1. 
		在搜索的总数据量较小的情况下， 使用grep， ack甚至ag在感官上区别不大
    2. 
	
  2. 
		搜索的总数据量较大时， grep效率下滑的很多， 完全不要选
    3. 
	
  3. 
		ack在某些场景下没有grep效果高(比如使用-v搜索中文的时候)
    4. 
	
  4. 
		在不使用ag没有实现的选项功能的前提下， ag完全可以替代ack/grep
    5. 




	渲染图片的gist可以看这里benchmarks.ipynb。 它的数据来自上面跑的结果在序列化之后存入的文件。



	chartchart-1chart-2chart-3chart-4chart-5chart-6



	chart-7chart-8chart-9chart-10chart-11







原文：http://www.dongwm.com/archives/ack/        作者： 董伟明


























      (责任编辑：IT)		
    

   




 





 




  
  

   
    
    
   

  



  



  



  
 ------分隔线---------------------------- 

  

   

    
   

   
   
  

  
 

 
  




 
 

  

   

    
栏目列表

    

     
    
      
     

    

   

  

  

  

   

    
推荐内容

    

     
    
      
     

    

   

  

  
  

   

    
热点内容

    

     
    

   

  

  

 

 







	
    

    


免责申明 -
 
版权申明

	
 
		
Copyright © 2014 - 2022 IT网 版权所有   www.it.net.cn    IT网.com    IT网.cn
 Linux学习     IT.LINK