社区应用 最新帖子 精华区 社区服务 会员列表 统计排行 银行

  • 15627阅读
  • 26回复

C++性能优化要点

级别: 管理员
发帖
8532
金币
2762
威望
3231
贡献值
0
元宝
0
只看该作者 10楼 发表于: 2011-12-20
Tcmalloc介绍
Tcmalloc早有耳闻,没有进行过细节的了解,直到最近有同事在几个模块中使用,才领略到它的强大!


场景:
模块多线程并发处理输入数据,大量使用各种STL容器,运行内存30G。
程序重启,导入历史后,处理速度变慢,数个小时候后才能回到正常处理速度,处理速度慢期间,cpu idle高

分析:
重启后,缓存的内存被收回,大量内存需要重新分配,cpu频繁锁在malloc上

解决:
1. 使用STL内存分配器:__mt_alloc
参考:http://blog.csdn.net/yfkiss/article/details/6633337
2. 使用tcmalloc

使用Tcmalloc:
下载编译google-perftool(performance tool,includes TCMalloc, heap-checker, heap-profiler and cpu-profiler.)
将tcmalloc通过“-ltcmalloc”链接器标志接入模块

Tcmalloc概述
tcmalloc将内存请求分为两类,大对象请求和小对象请求,大对象为>=32K的对象。|
tcmalloc会为每个线程分配线程局部缓冲
对于小对象请求,可以直接从线程局部缓冲区获取,如果线程局部缓冲区没有空闲内存,则从central heap中一次性获取一连串小对象。
tcmalloc对于小内存,按8的整数次倍分配,对于大内存,按4K的整数次倍分配。
这样做有两个好处,一是分配的时候比较快。二是短期的收益比较大,分配的小内存至多浪费7个字节,大内存则4K
当某个线程缓存当缓存中所有对象的总共大小超过2MB的时候,会对他进行垃圾收集。垃圾收集阈值会自动根据线程数量的增加而减少,这样就不会因为程序有大量线程而过度浪费内存。
更细节可以参考:http://google-perftools.googlecode.com/svn/trunk/doc/tcmalloc.html

Tcmalloc在不需要增加任何开发代价的情况下,就可以使得程序有可能在性能上有一个飞跃
QQ: 378890364 微信:wwtree(省短信费) 紧急事宜发短信到0061432027638  本站微博:http://t.qq.com/wwtree QQ群:122538123
级别: 管理员
发帖
8532
金币
2762
威望
3231
贡献值
0
元宝
0
只看该作者 11楼 发表于: 2012-02-21
C++程序性能优化

1. 故事
    背景:线上流式计算,某个关键模块Mario一个大业务版本(带来输入数据double)升级上线
    注:流式计算的典型范式之一是不确定数据速率的事件流流入系统,系统处理能力必须与事件流量匹配。
    故事分为3个阶段
    1)上线后,线上报警,Mario出现数据积压(处理能力无法满足当前线上流量)。
         经查:Mario中经过处理后的数据需要进入远程数据库,处理线程以同步的方式将数据插入远程数据库,这种方式,使得线程处理能力急剧下降。
         解决:数据写入磁盘,另外一个程序入库
    2)第一个问题解决后,再次出现性能问题
         解决:使用Tcmalloc(参考:http://blog.csdn.net/yfkiss/article/details/6902269
    3)使用Tcmalloc之后,发现线上CPU抖动非常厉害,并且有一定概率程序hang住
         经查:一个求去重后的数据个数的算法,采用字典进行计算,频繁的对字典进行构建和删除,使得系统频繁申请、释放内存,从而导致cpu抖动。
         解决:对于小数据,采用O(n^2)的算法,对于大数据,采取O(n)的算法(http://blog.csdn.net/yfkiss/article/details/6754786)。

2. 原理
程序性能优化可以做三个层次的事情。
1)设计
2)算法&数据结构
3)代码
当然,以上三个层面只是一般程序员可以做的优化,之上还有架构,之下还有运行系统和硬件。
设计:个人理解是最重要的一块,包括:数据如何处理?多线程还是单线程?多线程之间如何同步?锁粒度多大?是否使用内存池?同步还是异步等等
算法和数据结构:对算法优化往往可以使得程序性能有数量级的飞跃。
代码调优:运行中的程序有一种典型情况:20%的代码占了80%的运行时间,优化的重点是这20%的代码。
回到story,第一个阶段的问题,很明显是设计出现问题,在出现需要网络交互的时候的,考虑异步方案。
第二个阶段使用了tcmalloc,本质上是从设计、算法、代码多个角度对内存分配做了优化,只是这个优化是别人帮你做的~
第三个阶段属于算法优化,原有算法非常快,但带来了内存操作的过大开销,我们的应用中,数据集99%都非常小(数据集平均大小为2),因此,对于小数据集,采用O(n^2)的算法,对于大数据集,采用O(n)的算法,实际证明非常有效。所以,没有最好的算法,只有最适合的算法。

3. 如何找出热点代码
1)梳理程序,找出执行热点。很土,但是很有效
2)辅助工具:Google Cpu Profiler
方法1更多的是依靠经验,辅助工具Google Cpu Profiler简要介绍下。
Google Cpu Profiler是 google-perftools的一部分(google-perftools还包括Tcmalloc、Heap checkedr、Heap profiler)
其使用非常简单:
链接 profiler库及设置环境变量CPUPROFILE

4.使用Google Cpu Profiler进行性能分析的一个实例(使用 LD_PRELOAD,懒人法,不需要重编译)
code:

  1. #include <iostream>  
  2. #include <time.h>  
  3. using namespace std;  
  4.   
  5. const int MAX_OPERATION = 2;  
  6. enum TYPE{MINUS = 0, PLUS};  
  7.   
  8. int random(unsigned int n)  
  9. {  
  10.         if(n != 0)  
  11.         {  
  12.                 return rand() % n;  
  13.         }  
  14.         else  
  15.         {  
  16.                 return 0;  
  17.         }  
  18. }  
  19.   
  20. void make_expression(int n)  
  21. {  
  22.         int left = random(n);  
  23.         int operation = random(MAX_OPERATION);  
  24.         int right = (PLUS==operation ? random(left) : random(n));  
  25.         cout << left << (operation==PLUS ? "-" : "+") << right << "=";  
  26. }  
  27.   
  28. void make(int n, int max)  
  29. {  
  30.         for(int i = 1; i <= n; i++)  
  31.         {  
  32.                 make_expression(max);  
  33.                 if(0 != i % 3)  
  34.                 {  
  35.                         cout << "\t" << "\t";  
  36.                 }  
  37.                 else  
  38.                 {  
  39.                         cout << endl;  
  40.                 }  
  41.         }  
  42. }  
  43.   
  44. int main(int argc, char** argv)  
  45. {  
  46.         srand((int)time(0));  
  47.   
  48.         if(argc != 3)  
  49.         {  
  50.                 cout << "we need 3 argc" << endl;  
  51.                 return 1;  
  52.         }  
  53.   
  54.         make(atoi(argv[1]), atoi(argv[2]));  
  55.         cout << endl;  
  56.   
  57.         return 0;  
  58. }  
设置环境变量 LD_PRELOAD和CPUPROFILE
export "LD_PRELOAD=/home/work/zhouxm/google-perf_1.8.3/lib/libprofiler.so"
export "CPUPROFILE=/home/work/zhouxm/google-perf_1.8.3/bin/myprofiler"
注:LD_PRELOAD指定在程序运行前优先加载的动态链接库。这个功能主要就是用来有选择性的载入不同动态链接库中的相同函数。通过这个环境变量,我们可以在主程序和其动态链接库的中间加载别的动态链接库,甚至覆盖正常的函数库。这个环境变量相当危险,慎用
CPUPROFILE指定profiler文件保存位置及文件名
运行:
$./test 10000000 10000  1>/dev/null 
PROFILE: interrupts/evictions/bytes =508/228/12704

分析:
1)文本分析:
$ ./pprof -text ./test ./myprofiler 
Using local file ./test.
Using local file ./myprofiler.
Removing killpg from all stack traces.
Total: 508 samples
     149  29.3%  29.3%      149  29.3% __write_nocancel
      47   9.3%  38.6%       47   9.3% fwrite
      41   8.1%  46.7%       41   8.1% _IO_file_xsputn@@GLIBC_2.2.5
      41   8.1%  54.7%       41   8.1% random
      33   6.5%  61.2%       33   6.5% std::operator<< 
      32   6.3%  67.5%       32   6.3% std::basic_ostream::operator<<
      29   5.7%  73.2%       29   5.7% std::has_facet
      26   5.1%  78.3%       26   5.1% std::num_put::_M_insert_int
      15   3.0%  81.3%       15   3.0% std::basic_ostream::sentry::sentry
      14   2.8%  84.1%       97  19.1% make_expression
      13   2.6%  86.6%       73  14.4% std::num_put::do_put
      11   2.2%  88.8%       11   2.2% random_r
       9   1.8%  90.6%        9   1.8% strlen
       7   1.4%  91.9%        7   1.4% CXXABI_1.3
       7   1.4%  93.3%        7   1.4% std::basic_ostream::put
       6   1.2%  94.5%      135  26.6% make
       4   0.8%  95.3%        4   0.8% _IO_do_write@@GLIBC_2.2.5
       4   0.8%  96.1%        4   0.8% _init
       4   0.8%  96.9%        4   0.8% std::time_put::put
       3   0.6%  97.4%        3   0.6% _IO_file_write@@GLIBC_2.2.5
       3   0.6%  98.0%        3   0.6% fflush
       3   0.6%  98.6%        3   0.6% std::__numpunct_cache::_M_cache
       2   0.4%  99.0%        2   0.4% __gnu_cxx::stdio_sync_filebuf::file
       2   0.4%  99.4%        2   0.4% std::basic_ios::widen
       2   0.4%  99.8%        2   0.4% std::endl
       1   0.2% 100.0%        1   0.2% rand
       0   0.0% 100.0%        1   0.2% _DYNAMIC
       0   0.0% 100.0%        8   1.6% __bss_start
       0   0.0% 100.0%      143  28.1% __libc_start_main
       0   0.0% 100.0%      143  28.1% main
2)图形分析
$ ./pprof -dot ./test ./myprofiler > test.dot
可是使用Graphviz打开dot文件

QQ: 378890364 微信:wwtree(省短信费) 紧急事宜发短信到0061432027638  本站微博:http://t.qq.com/wwtree QQ群:122538123
级别: 管理员
发帖
8532
金币
2762
威望
3231
贡献值
0
元宝
0
只看该作者 12楼 发表于: 2012-02-21
TcMalloc-C++内存分配优化模块
google perftools中的一员

比glic的实现ptmalloc2快6倍,ptmalloc2一次malloc和free操作约要300ns,tcmalloc只需约50ns

比ptmalloc更高的空间利用率,ptmalloc每个对象约浪费8字节,tcmalloc只额外花费1%的空间

周期性的内存回收,避免ptmalloc2中可能出现的内存爆炸式增长的问题。tcmalloc会在线程cache和中心内存堆栈之间迁移空闲对象。

尽量避免加锁(一次加锁解锁约浪费100ns),使用更高效的spinlock,采用更合理的粒度。

小块内存和打开内存分配采取不同的策略:
小于32K的被定义为小块内存
小块内存按大小被分为8Bytes,16Bytes,。。。,236Bytes进行分级。不是某个级别整数倍的大小都会被分配向上取整。如13Bytes的会按16Bytes分配
分配时,首先在本线程相应大小级别的空闲链表里面找,如果找到的话可以避免加锁操作(本线程的cache只有本线程自己使用)。如果找不到的话,则尝试从中心内存区的相应级别的空闲链表里搬一些对象到本线程的链表。如果中心内存区相应链表也为空的话,则向中心页分配器请求内存页面,然后分割成该级别的对象存储。

大块内存处理方式:
按页分配,每页大小是4K,然后内存按1页,2页,。。。,255页的大小分类,相同大小的内存块也用链表连接。


Tcmalloc早有耳闻,没有进行过细节的了解,直到最近有同事在几个模块中使用,才领略到它的强大!
场景:
模块多线程并发处理输入数据,大量使用各种STL容器,运行内存30G。
程序重启,导入历史后,处理速度变慢,数个小时候后才能回到正常处理速度,处理速度慢期间,cpu idle高

分析:
重启后,缓存的内存被收回,大量内存需要重新分配,cpu频繁锁在malloc上

解决:
1. 使用STL内存分配器:__mt_alloc
参考:http://blog.csdn.net/yfkiss/article/details/6633337
2. 使用tcmalloc

使用Tcmalloc:
下载编译google-perftool(performance tool,includes TCMalloc, heap-checker, heap-profiler and cpu-profiler.)
将tcmalloc通过“-ltcmalloc”链接器标志接入模块

Tcmalloc概述
tcmalloc将内存请求分为两类,大对象请求和小对象请求,大对象为>=32K的对象。|
tcmalloc会为每个线程分配线程局部缓冲
对于小对象请求,可以直接从线程局部缓冲区获取,如果线程局部缓冲区没有空闲内存,则从central heap中一次性获取一连串小对象。
tcmalloc对于小内存,按8的整数次倍分配,对于大内存,按4K的整数次倍分配。
这样做有两个好处,一是分配的时候比较快。二是短期的收益比较大,分配的小内存至多浪费7个字节,大内存则4K
当某个线程缓存当缓存中所有对象的总共大小超过2MB的时候,会对他进行垃圾收集。垃圾收集阈值会自动根据线程数量的增加而减少,这样就不会因为程序有大量线程而过度浪费内存。

内存泄露检测
使用Tcmalloc的程序,用valgrind无法检测内存泄露,可以使用google-perftools
提供的heap checker
使用方法:
export  HEAPCHECK=TYPE
TYPE可以为:minimal、normal、strict、draconian

更细节可以参考:http://google-perftools.googlecode.com/svn/trunk/doc/tcmalloc.html

Tcmalloc在不需要增加任何开发代价的情况下,就可以使得程序有可能在性能上有一个飞跃

QQ: 378890364 微信:wwtree(省短信费) 紧急事宜发短信到0061432027638  本站微博:http://t.qq.com/wwtree QQ群:122538123
级别: 管理员
发帖
8532
金币
2762
威望
3231
贡献值
0
元宝
0
只看该作者 13楼 发表于: 2012-02-21
让mysql支持TCMalloc
TCMalloc(Thread-Caching Malloc)是google-perftools工具中的一个,与标准的glibc库的malloc相 比,TCMalloc在内存的分配上效率和速度要高得多,可以提高Mysql服 务器在高并发情况下的性能,降低系统负载。





Google-perftools的项目:http://code.google.com/p/google-perftools/


TCMalloc的原理介绍翻译:http://shiningray.cn/tcmalloc-thread-caching-malloc.html
google-perftools包括TCMalloc、heap-checker、heap-profiler和cpu-profiler共4个组件,在只 用TCMalloc的场景下,可以不编译其他三个组件,使用tcmalloc_minimal就足够。
下面介绍在Linux SUSE x86上安装TCMalloc动态库的过程。

安装TCMalloc
http://code.google.com/p/google-perftools/ 下载源码包,现在最新版本是1.4。如果机器联网,直接:
wget  http://google-perftools.googlecode.com/files/google-perftools-1.4.tar.gz
tar zxvf google-perftools-1.4.tar.gz
cd  google-perftools-1.4
Mysql服 务器只需要用SO动态库就可以了,没有必须要把其他的文件(头文件静态库文档等)也安装到/usr/local/里。先安装到一个临时文件夹:
mkdir /tmp/tc
./configure --prefix=/tmp/tc --disable-cpu-profiler --disable-heap-profiler --disable-heap-checker --disable-debugalloc --enable-minimal
加上后面的几个参数是指只生成tcmalloc_minimal。
如果要生成包含所有组件的tcmalloc,可:
./configure --prefix=/tmp/tc
如果要将文件直接安装到文件,就不需要临时目录了,可:
./configure
使用./configure –h可查看安装选项。
编译安装:
make && make install
ls -alt /tmp/tc/lib/*
使用了最小安装,拷贝tcmalloc_minimal的动态库到系统库目录:
cp /tmp/tc/lib/libtcmalloc_minimal.so.0.0.0 /usr/local/lib
建立软连接指向tcmalloc:
ln -s /usr/local/lib/libtcmalloc_minimal.so.0.0.0 /usr/local/lib/libtcmalloc.so
ln -s /usr/local/lib/libtcmalloc_minimal.so.0.0.0 /usr/local/lib/libtcmalloc.so.0
ln -s /usr/local/lib/libtcmalloc_minimal.so.0.0.0 /usr/local/lib/libtcmalloc.so.0.0.0
rm -rf /tmp/tc

Mysql加入动态库
修改mysql服 务的启动脚本mysqld_safe,在“ # executing mysqld_safe”行后添加行:
export LD_PRELOAD="/usr/local/lib/libtcmalloc.so"
目的是在启动mysql前, 加载tcmalloc动态库。
重启Mysql服 务:
/usr/local/mysql/bin/mysqladmin shutdown
/usr/local/mysql/bin/mysqld_safe –user=mysql &

验证
使用lsof查看mysql进 程是否已经加载了tcmalloc库:
shell > lsof -n | grep tcmalloc
mysqld    32398      mysql mem       REG        8,3     668454    1477703 /usr/local/lib/libtcmalloc_minimal.so.0.0.0
恭喜,成功安装了tcmalloc。
QQ: 378890364 微信:wwtree(省短信费) 紧急事宜发短信到0061432027638  本站微博:http://t.qq.com/wwtree QQ群:122538123
级别: 管理员
发帖
8532
金币
2762
威望
3231
贡献值
0
元宝
0
只看该作者 14楼 发表于: 2012-02-26
如何提高C++的效率
自从七十年代C语言诞生以来,一直以其灵活性、高效率和可移植性为软件开发人员所钟爱,成为系统软件开发的首选工具。而C++作为C语言的继承和发展,不仅保留了C语言的高度灵活、高效率和易于理解等诸多优点,还包含了几乎所有面向对象的特征,成为新一代软件系统构建的利器。


相对来说,C语言是一种简洁的语言,所涉及的概念和元素比较少,主要是:宏(macro)、指针(pointer)、结构(struct)、函数(function)和数组(array),比较容易掌握和理解。而C++不仅包含了上面所提到的元素,还提供了私有成员(private members)、公有成员(public members)、函数重载(function overloading)、缺省参数(default parameters)、构造函数、析构函数、对象的引用(references)、操作符重载(operator overloading)、友元(friends)、模板(templates)、异常处理(exceptions)等诸多的要素,给程序员提供了更大的设计空间,同时也增加了软件设计的难度。


C语言之所以能被广泛的应用,其高效率是一个不可忽略的原因,C语言的效率能达到汇编语言的80%以上,对于一种高级语言来说,C语言的高效率就不言而喻了。那么,C++相对于C来说,其效率如何呢?实际上,C++的设计者stroustrup要求C++效率必须至少维持在与C相差5%以内,所以,经过精心设计和实现的C++同样有很高的效率,但并非所有C++程序具有当然的高效率,由于C++的特殊性,一些不好的设计和实现习惯依然会对系统的效率造成较大的影响。同时,也由于有一部分程序员对C++的一些底层实现机制不够了解,就不能从原理上理解如何提高软件系统的效率。


本文主要讨论两个方面的问题:第一,对比C++的函数调用和C函数调用,解析C++的函数调用机制;第二,例举一些C++程序员不太注意的技术细节,解释如何提高C++的效率。为方便起见,本文的讨论以下面所描述的单一继承为例(多重继承有其特殊性,另作讨论)。  


class X

{

public:

virtual ~X(); //析构函数

virtual void VirtualFunc(); //虚函数

inline int InlineFunc() { return m_iMember}; //内联函数

void NormalFunc(); //普通成员函数

static void StaticFunc(); //静态函数

private:

int m_iMember;


};


class XX: public X

{

public:

XX();

virtual ~XX();

virtual void VirtualFunc();

private:

String m_strName;

int m_iMember2;


};



C++的的函数分为四种:内联函数(inline member function)、静态成员函数(static member function)、虚函数(virtual member function)和普通成员函数。


内联函数类似于C语言中的宏定义函数调用,C++编译器将内联函数的函数体扩展在函数调用的位置,使内联函数看起来象函数,却不需要承受函数调用的开销,对于一些函数体比较简单的内联函数来说,可以大大提高内联函数的调用效率。但内联函数并非没有代价,如果内联函数体比较大,内联函数的扩展将大大增加目标文件和可运行文件的大小;另外,inline关键字对编译器只是一种提示,并非一个强制指令,也就是说,编译器可能会忽略某些inline关键字,如果被忽略,内联函数将被当作普通的函数调用,编译器一般会忽略一些复杂的内联函数,如函数体中有复杂语句,包括循环语句、递归调用等。所以,内联函数的函数体定义要简单,否则在效率上会得不偿失。


静态函数的调用,如下面的几种方式:  


X obj; X* ptr = &obj;

obj.StaticFunc();

ptr->StaticFunc();

X::StaticFunc();  

将被编译器转化为一般的C函数调用形式,如同这样: mangled_name_of_X_StaticFunc();

//obj.StaticFunc();

mangled_name_of_X_StaticFunc();

// ptr- >StaticFunc();

mangled_name_of_X_StaticFunc();

// X::StaticFunc();  


mangled_name_of_X_StaticFunc()是指编译器将X::StaticFunc()函数经过变形(mangled)后的内部名称(C++编译器保证每个函数将被mangled为独一无二的名称,不同的编译器有不同的算法,C++标准并没有规定统一的算法,所以mangled之后的名称也可能不同)。可以看出,静态函数的调用同普通的C函数调用有完全相同的效率,并没有额外的开销。


普通成员函数的调用,如下列方式:  


X obj; X* ptr = &obj;

obj.NormalFunc();

ptr->NormalFunc();  

将被被编译器转化为如下的C函数调用形式,如同这样。 mangled_name_of_X_NormalFunc(&obj);

//obj.NormalFunc();

mangled_name_of_X_NormalFunc(ptr);

// ptr- >NormalFunc();  

www.zztarena.com  

可以看出普通成员函数的调用同普通的C调用没有大的区别,效率与静态函数也相同。编译器将重新改写函数的定义,增加一个const X* this参数将调用对象的地址传送进函数。


虚函数的调用稍微复杂一些,为了支持多态性,实现运行时刻绑定,编译器需要在每个对象上增加一个字段也就是vptr以指向类的虚函数表vtbl。


虚函数的多态性只能通过对象指针或对象的引用调用来实现,如下的调用:  


X obj;

X* ptr = &obj; X& ref = obj;

ptr->VirtualFunc();

ref.VirtualFunc();  


将被C++编译器转换为如下的形式。  


( *ptr->vptr[2] )(ptr);

( *ptr->vptr[2] )(&ref);  


其中的2表示VirtualFunc在类虚函数表的第2个槽位。可以看出,虚函数的调用相当于一个C的函数指针调用,其效率也并未降低。


由以上的四个例子可以看出,C++的函数调用效率依然很高。但C++还是有其特殊性,为了保证面向对象语义的正确性,C++编译器会在程序员所编写的程序基础上,做大量的扩展,如果程序员不了解编译器背后所做的这些工作,就可能写出效率不高的程序。对于一些继承层次很深的派生类或在成员变量中包含了很多其它类对象(如XX中的m_strName变量)的类来说,对象的创建和销毁的开销是相当大的,比如XX类的缺省构造函数,即使程序员没有定义任何语句,编译器依然会给其构造函数扩充以下代码来保证对象语义的正确性:  


XX::XX()

{

// 编译器扩充代码所要做的工作


1、调用父类X的缺省构造函数

2、设定vptr指向XX类虚函数表

3、调用String类的缺省构造函数构造m_strName

};



所以为了提高效率,减少不必要的临时对象的产生、拖延暂时不必要的对象定义、用初始化代替赋值、使用构造函数初始化列表代替在构造函数中赋值等方法都能有效提高程序的运行效率。以下举例说明:


1、 减少临时对象的生成。如以传送对象引用的方式代替传值方式来定义函数的参数,如下例所示,传值方式将导致一个XX临时对象的产生  


效率不高的做法 高效率做法

void Function( XX xx ) void Function( const XX& xx )

{{

//函数体 //函数体  

}}  

2、 拖延暂时不必要的对象定义。在C中要将所有的局部变量定义在函数体头部,考虑到C++中对象创建的开销,这不是一个好习惯。如下例,如果大部分情况下bCache为"真",则拖延xx的定义可以大大提高函数的效率。 效率不高的做法高效率做法

void Function( bool bCache )void Function( bool bCache )

{{

//函数体//函数体  

XX xx;if( bCache )

if( bCache ) {// do something without xx

{return;

// do something without xx}

return;  

}

//对xx进行操作XX xx;

//对xx进行操作


return;return;

}}  

3、 可能情况下,以初始化代替先定义后赋值。如下例,高效率的做法会比效率不高的做法省去了cache变量的缺省构造函数调用开销。 效率不高的做法高效率做法

void Function( const XX& xx )void Function( const XX& xx )

{{

XX cache; XX cache = xx;  

cache = xx ;  

}}  

4、 在构造函数中使用成员变量的初始化列表代替在构造函数中赋值。如下例,在效率不高的做法中,XX的构造函数会首先调用m_strName的缺省构造函数,再产生一个临时的String object,用空串""初始化临时对象,再以临时对象赋值(assign)给m_strName,然后销毁临时对象。而高效的做法只需要调用一次m_strName的构造函数。 效率不高的做法高效率做法

XX::XX()XX::XX() : m_strName( "" )

{{

m_strName = ""; …

…  

}}  

类似的例子还很多,如何写出高效的C++程序需要实践和积累,但理解C++的底层运行机制是一个不可缺少的步骤,只要平时多学习和思考,编写高效的C++程序是完全可行的。
QQ: 378890364 微信:wwtree(省短信费) 紧急事宜发短信到0061432027638  本站微博:http://t.qq.com/wwtree QQ群:122538123
级别: 管理员
发帖
8532
金币
2762
威望
3231
贡献值
0
元宝
0
只看该作者 15楼 发表于: 2012-10-22
细节上提升你的程序的性能
虽然,这些使用方法看似差别不大,在现在的cpu运行期起来几乎上可以忽略不计,
但是,我们想一下现在软件,每一个都是那么的庞大,一个小项目都是几万行代码,
一个函数中你消耗一点,那么多函数是很大的性能消耗的。举一个不恰当的例子,
如果在百度首页中,每天几亿次的点击率,每一个函数里面都有一个无用++运算,这个i++可以小视吗?

下面的例子是我在虚拟机中运行,其中也会有机器性能不好的原因,但是我觉得这样才会将问题展示的更加的严重。


1.不要将函数作为循环的条件
SIZE= 1024
program 1:   time:29ms

     p = &a;
     for( ; i <  SIZE *sizeof(int); i++)
     {
          p = 1;
          p++;
     }
program 2: time:1ms
    p = &a;
    len =  SIZE *sizeof(int);
    for( ; i < len; i++)
    {
          p = 1;
          p++;
     }
原因:因为每次比较条件,函数都需要重新计算的,将会消耗时间。

2. 减少内存访问次数

program:1     time:1ms
   i = 0;
    for( ; i < 1024; i++)

            tmp ++;


program:2    time:7s
     i = 0;
     for( ; i < 1024; i++)
           tmp = tmp + 1;
原因:内存与cpu的频率差别很大,尽量减少cpu对内存的访问,减少变量引用;

3.去除不必要的分支

program:1     time:3ms
   i = 0;
   for (tmp = 0; tmp < 100; tmp++)
  {
       max = min = a[0] ;
       for( ; i < 100; i++)
       {
              if (max > a) max = a;
              if (min < a) min = a;
        }
   }
program:2     time:2ms
     i = 0;
     for (tmp = 0; tmp < 100; tmp++)
    {
           max = min = a[0] ;
           for( ; i < 100; i++)
          {
                if (max > a) max = a;
                else if (min < a) min = a;
          }
      }
注意:这个平时写代码的时候注意方可,很多时候书上都是这样的写的,大家觉得没什么?不影响程序的运行结果。所以,没有注意。

4.间接寻址比基地址寻址慢,所以将结构体中常用的成员放前面,并且放在一起。(类、接口、文件同理)

program 1: time:11ms

       i = 0;
      for( ; i < 1000; i++)
      {
            t.t1 = 1;
            t.t3 = 1;
      }

program 1: time:7ms
      i = 0;
      for( ; i < 1000; i++)
      {
            t.t1 = 1;
            t.t2 = 1;
       }

原因:将数据放到同一内存页中,减少页面切换,增加缓存的命中率。


5.关于数组的测试,看另外的博客
QQ: 378890364 微信:wwtree(省短信费) 紧急事宜发短信到0061432027638  本站微博:http://t.qq.com/wwtree QQ群:122538123
级别: 管理员
发帖
8532
金币
2762
威望
3231
贡献值
0
元宝
0
只看该作者 16楼 发表于: 2012-10-22
a[i][j]与a[j][i]性能差别的原因
一下内容仅是个人理解,有错误之处,望大家谅解和指正。

a[j]使用时间:94s



for( k = 0 ; k <10000 ; k++ )
for( i = 0 ; i<MAX; i++ )
for( j = 0;j < MAX; j++ )
a[j] = 0;
a[j]使用时间:488s


for( k = 0 ; k <  10000  ; k++ )
for( i = 0 ; i<MAX; i++ )
for( j = 0;j < MAX; j++ )
a[j] = 0;
我将两种方法使用gcc生成了汇编代码。使用diff比较只发现了一下四句汇编代码的不同


1c1
<  .file"array.c"
---
>  .file"array1.c"
31c31
<  movl4194352(%esp), %eax
---
>  movl4194356(%esp), %eax
33c33
<  addl  4194356(%esp), %eax
---
>  addl        4194352(%esp), %eax

并且,这四句汇编在这行的时候不会产生性能差别,那性能差别出现在那里。可定不是循环、计算数据产生的差别。差别会出现在内存的访问位置上吗?不会的,内存是随机访问,访问任何一个位置内存的地址的时间应该是一样的。我们现在考虑一下是不是操作系统的缓存的功能。首先,本程序在加载到内存执行、以后除了cpu访问内存之外没有任何的资源消耗。所以说不是系统的问题。想了很久,想到cpu访问数据的时候是以块进行访问的,将取来的数据放到缓存中。因为a是顺序访问,所以cpu缓存中的数据可以直接使用,无需再访问内存。而a[j]非顺序访问,下一个访问的位置,不在cpu的缓存中。


提议:在写代码的时候
1. 对数组、结构体进行顺序访问。提高缓存的命中率。
2. 减少不必要的判断,提高cpu的分支预测的命中率
QQ: 378890364 微信:wwtree(省短信费) 紧急事宜发短信到0061432027638  本站微博:http://t.qq.com/wwtree QQ群:122538123
级别: 管理员
发帖
8532
金币
2762
威望
3231
贡献值
0
元宝
0
只看该作者 17楼 发表于: 2012-10-24
C++代码速度优化方法
在一些对速度要求非常苛刻的应用系统中,每一个CPU周期都是要争取的。这个部分展现了一些简单方法来进行速度优化。
1. 使用类来包裹长的参数列表
一个函数调用的负担将会随着参数列表的增长而增加。运行时系统不得不建立堆栈来存储参数值;通常,当参数很多的时候,这样一个操作就会花费很长的时间。
把参数列表包裹进一个单独的类中并且通过引用进行传递,这样将会节省很多的时间。当然,如果函数本身就很长,那么建立堆栈的时间就可以忽略了,因此也就没有必要这样做。然而,对于那些执行时间很短而且经常被调用的函数来说,包裹一个长的参数列表在对象中并且通过引用传递将会提高性能。
2. 寄存器变量
register specifier被用来告诉编译器一个对象将被会非常多的使用,可以把它放入寄存器中。例如:
void f()
{
int *p = new int[3000000];
     register int *p2 = p; //store the address in a register
    for (register int j = 0; j<3000000; j++)
       {
        *p2++ = 0;
     }
     //...use p
     delete [] p;
}
循环计数是应用寄存器变量的最好的候选者。当它们没有被存入一个寄存器中,大部分的循环时间都被用在了从内存中取出变量和给变量赋新值上。如果把它存入一个寄存器中的话,将会大大减少这种负担。需要注意的是,register specifier仅仅是对编译器的一个建议。就好比内联函数一样,编译器可以拒绝把一个对象存储到寄存器中。另外,现代的编译器都会通过把变量放入寄存器中来优化循环计数。Register storage specifier并不仅仅局限在基本类型上,它能够被应用于任何类型的对象。如果对象太大而不能装进寄存器的话,编译器仍然能够把它放入一个高速存储器中,例如cache。
用register storage specifier声明函数型参将会是建议编译器把实参存入寄存器中而不是堆栈中。例如:
void f(register int j, register Date d);
3. 把那些保持不变的对象声明为const
通过把对象声明为const,编译器就可以利用这个声明把这样一个对象放入寄存器中。
4. Virtual function的运行期负担
当调用一个virtual function,如果编译器能够解决调用的静态化,将不会引入额外的负担。另外,一个非常短的虚函数可以被内联处理。在下面这个例子中,一个聪明的编译器能够做到静态调用虚函数:
#include <iostream>
using namespace std;
class V
{
public:
virtual void show() const { cout<<"I'm V"<<endl; }
};
class W : public V
{
public:
void show() const { cout<<"I'm W"<<endl; }
};
void f(V & v, V *pV)
{
v.show();  
pV->show();
}
void g()
{
     V v;
     f(v, &v);
}
int main()
{
g();
return 0;
}
如果整个程序出现在一个单独的编译单元中,编译器能够对main()中的g()进行内联替换。并且在g()中f()的调用也能够被内联处理。因为传给f()的参数的动态类型能够在编译期被知晓,因此编译器能够把对虚函数的调用静态化。但是不能保证每个编译器都这样做。然而,一些编译器确实能够利用在编译期获得参数的动态类型从而使得函数的调用在编译期间就确定了下来,避免了动态绑定的负担。
5. Function objects VS function pointers
用function objects取代function pointers的好处不仅仅局限在能够泛化和简单的维护性上。而且编译器能够对function object的函数调用进行内联处理,从而进一步的增强了性能
六. 最后的求助
迄今为止为大家展示的优化技术并没有在设计以及代码的可读性上做出妥协。事实上,它们中的一些还提高了软件的稳固性和可维护性。但是在一些对时间和内存有严格限制的软件开发中,上面的技术可能还不够;有可能还需要一些会影响软件的可移植性和扩展性的技术。但是这些技术只能在所有其他的优化技术都被应用但是还不符合要求的情况下使用。
1. 关闭RTTI和异常处理支持
当你导入纯C代码给C++编译器的时候,你可能会发现有一些性能上的损失。这并不是语言或者编译器的错误,而是编译器作出的一些调整。如果你想获得和C编译器同样的性能,那么请关闭编译器对RTTI以及异常处理的支持。为什么会这样呢?因为为了支持RTTI和异常处理,C++编译器会插入额外的代码。这样就增加了可执行体的大小,从而使得效率有所下降。当应用纯C代码的时候,那些额外的代码是不需要的,所以你可以通过关闭来避免它。
2. 内联汇编
对时间要求苛刻的部分可以用本地汇编来重写。结果可能是速度上的显著提高。然而,这个方法不能想当然的就去实施,因为它将使得将来的修改非常的困难。维护代码的程序员可能对汇编并不了解。如果想要把软件运行于其他平台也需要重写汇编代码部分。另外,开发和测试汇编代码是一件辛苦的工作,它将花费更长的时间。
3. 直接和操作系统进行交互
API函数可以使你直接与操作系统进行交互。有时,直接执行一个系统命令可能会快许多。出于这个目的,你可以使用标准函数system()。例如,在一个dos/windows系统下,你可以这样显示当前目录下的文件:
#include <CStdlib>
using namespace std;
int main()
{
system("dir"); //execute the "dir" command
}
注意:这里是在速度和可移植性以及可扩展性之间做出的折衷。
QQ: 378890364 微信:wwtree(省短信费) 紧急事宜发短信到0061432027638  本站微博:http://t.qq.com/wwtree QQ群:122538123
级别: 管理员
发帖
8532
金币
2762
威望
3231
贡献值
0
元宝
0
只看该作者 18楼 发表于: 2012-10-24
变量缓存在寄存器中是一个非常有价值的优化方法
阐述C++编译器变量进行优化说明,
在大多数情况下,把变量缓存在寄存器中是一个非常有价值的优化方法,如果不用的话很可惜。C++编译器提供了显式禁用这种缓存优化的机会。如果你声明变量是使用了volatile修饰符,编译器就不会把这个变量缓存在寄存器里——每次访问都将去存取变量在内存中的实际位置。
防止了C++编译器对所修饰的变量进行优化。主要应用于多线程编程。volatile 可以用于修饰原生类型也可用于自定义类型。volatile 虽与const的语义不同但用法类似。
[pre]
    class Gadget  
  1. {  
  2. public:  
  3. void Foo() volatile{};  
  4. void Bar() const{};  
  5. void Doo(){};  
  6. //private:  
  7.     char name_;  
  8.     int state_;  
  9. };
[/pre]若定义一个对象为const:const Gadget  cGadget; 说明cGadget对象的成员变量的值不可更改。所以要求该对象只能调用接口中的const型的成员函数。即要求其可调用的接口不能修改其成员变量的值,该成员函数必须为const型。即:
[pre]
    class Gadget  
  1. {  
  2. public:  
  3. void Foo() volatile{};  
  4. void Bar() const{};  
  5. void Doo(){};  
  6. //private:  
  7.     char name_;  
  8.     int state_;  
  9. };
[/pre]因为const型变量要求其可调用接口为const型,而对象之间赋值需要调用其赋值函数,C++编译器的赋值函数并非是const型,因此重载成了必然。可是有个可笑的问题是,const型对象是要求不能更改成员变量的值,但赋值是为了改变其值。
所以赋值函数(考贝构造函数)不能为变量赋值。只要不在赋值函数(考贝构造函数)里为变量赋值是可以编译通过的。但这毫无意义,说这个只是为volatile,因为volatile于const操作是一样的,只是volatile是可以更改成员变量值,所以这里不成问题。
该运算符把expression转换为type-id类型,但没有运行时类型检查来保证转换的安全性。它主要有如下几种用法:
①用于类层次结构中基类和子类之间指针或引用的转换。进行上行转换(把子类的指针或引用转换成基类表示)是安全的;进行下行转换(把基类指针或引用转换成子类表示)时,由于没有动态类型检查,所以是不安全的。
②用于基本数据类型之间的转换,如把int转换成char,把int转换成enum。这种转换的安全性也要开发人员来保证。
③把空指针转换成目标类型的空指针。


④把任何类型的表达式转换成void类型。

注意:C++编译器不能转换掉expression的const、volitale、或者__unaligned属性。
来自CSDN网站pizi0475博客
QQ: 378890364 微信:wwtree(省短信费) 紧急事宜发短信到0061432027638  本站微博:http://t.qq.com/wwtree QQ群:122538123
级别: 管理员
发帖
8532
金币
2762
威望
3231
贡献值
0
元宝
0
只看该作者 19楼 发表于: 2012-11-16
软件开发性能调优攻略
关于性能优化这是一个比较大的话题,在《由12306.cn谈谈网站性能技术》中我从业务和设计上说过一些可用的技术以及那些技术的优缺点,今天,想从一些技术细节上谈谈性能优化,主要是一些代码级别的技术和方法。本文的东西是我的一些经验和知识,并不一定全对,希望大家指正和补充。


在开始这篇文章之前,大家可以移步去看一下酷壳以前发表的《代码优化概要》,这篇文章基本上告诉你——要进行优化,先得找到性能瓶颈! 但是在讲如何定位系统性能瓶劲之前,请让我讲一下系统性能的定义和测试,因为没有这两件事,后面的定位和优化无从谈起。


一、系统性能定义


让我们先来说说如何什么是系统性能。这个定义非常关键,如果我们不清楚什么是系统性能,那么我们将无法定位之。我见过很多朋友会觉得这很容易,但是仔细一问,其实他们并没有一个比较系统的方法,所以,在这里我想告诉大家如何系统地来定位性能。 总体来说,系统性能就是两个事:


Throughput ,吞吐量。也就是每秒钟可以处理的请求数,任务数。
Latency, 系统延迟。也就是系统在处理一个请求或一个任务时的延迟。
一般来说,一个系统的性能受到这两个条件的约束,缺一不可。比如,我的系统可以顶得住一百万的并发,但是系统的延迟是2分钟以上,那么,这个一百万的负载毫无意义。系统延迟很短,但是吞吐量很低,同样没有意义。所以,一个好的系统的性能测试必然受到这两个条件的同时作用。 有经验的朋友一定知道,这两个东西的一些关系:


Throughput越大,Latency会越差。因为请求量过大,系统太繁忙,所以响应速度自然会低。
Latency越好,能支持的Throughput就会越高。因为Latency短说明处理速度快,于是就可以处理更多的请求。
二、系统性能测试


经过上述的说明,我们知道要测试系统的性能,需要我们收集系统的Throughput和Latency这两个值。




首先,需要定义Latency这个值,比如说,对于网站系统响应时间必需是5秒以内(对于某些实时系统可能需要定义的更短,比如5ms以内,这个更根据不同的业务来定义)
其次,开发性能测试工具,一个工具用来制造高强度的Throughput,另一个工具用来测量Latency。对于第一个工具,你可以参考一下“十个免费的Web压力测试工具”,关于如何测量Latency,你可以在代码中测量,但是这样会影响程序的执行,而且只能测试到程序内部的Latency,真正的Latency是整个系统都算上,包括操作系统和网络的延时,你可以使用Wireshark来抓网络包来测量。这两个工具具体怎么做,这个还请大家自己思考去了。
最后,开始性能测试。你需要不断地提升测试的Throughput,然后观察系统的负载情况,如果系统顶得住,那就观察Latency的值。这样,你就可以找到系统的最大负载,并且你可以知道系统的响应延时是多少。
再多说一些,


关于Latency,如果吞吐量很少,这个值估计会非常稳定,当吞吐量越来越大时,系统的Latency会出现非常剧烈的抖动,所以,我们在测量Latency的时候,我们需要注意到Latency的分布,也就是说,有百分之几的在我们允许的范围,有百分之几的超出了,有百分之几的完全不可接受。也许,平均下来的Latency达标了,但是其中仅有50%的达到了我们可接受的范围。那也没有意义。
关于性能测试,我们还需要定义一个时间段。比如:在某个吞吐量上持续15分钟。因为当负载到达的时候,系统会变得不稳定,当过了一两分钟后,系统才会稳定。另外,也有可能是,你的系统在这个负载下前几分钟还表现正常,然后就不稳定了,甚至垮了。所以,需要这么一段时间。这个值,我们叫做峰值极限。
性能测试还需要做Soak Test,也就是在某个吞吐量下,系统可以持续跑一周甚至更长。这个值,我们叫做系统的正常运行的负载极限。
性能测试有很多很复要的东西,比如:burst test等。 这里不能一一详述,这里只说了一些和性能调优相关的东西。总之,性能测试是一细活和累活。


三、定位性能瓶颈


有了上面的铺垫,我们就可以测试到到系统的性能了,再调优之前,我们先来说说如何找到性能的瓶颈。我见过很多朋友会觉得这很容易,但是仔细一问,其实他们并没有一个比较系统的方法。


3.1)查看操作系统负载
首先,当我们系统有问题的时候,我们不要急于去调查我们代码,这个毫无意义。我们首要需要看的是操作系统的报告。看看操作系统的CPU利用率,看看内存使用率,看看操作系统的IO,还有网络的IO,网络链接数,等等。Windows下的perfmon是一个很不错的工具,Linux下也有很多相关的命令和工具,比如:SystemTap,LatencyTOP,vmstat, sar, iostat, top, tcpdump等等 。通过观察这些数据,我们就可以知道我们的软件的性能基本上出在哪里。比如:


1)先看CPU利用率,如果CPU利用率不高,但是系统的Throughput和Latency上不去了,这说明我们的程序并没有忙于计算,而是忙于别的一些事,比如IO。(另外,CPU的利用率还要看内核态的和用户态的,内核态的一上去了,整个系统的性能就下来了。而对于多核CPU来说,CPU 0 是相当关键的,如果CPU 0的负载高,那么会影响其它核的性能,因为CPU各核间是需要有调度的,这靠CPU0完成)


2)然后,我们可以看一下IO大不大,IO和CPU一般是反着来的,CPU利用率高则IO不大,IO大则CPU就小。关于IO,我们要看三个事,一个是磁盘文件IO,一个是驱动程序的IO(如:网卡),一个是内存换页率。这三个事都会影响系统性能。


3)然后,查看一下网络带宽使用情况,在Linux下,你可以使用iftop, iptraf, ntop, tcpdump这些命令来查看。或是用Wireshark来查看。


4)如果CPU不高,IO不高,内存使用不高,网络带宽使用不高。但是系统的性能上不去。这说明你的程序有问题,比如,你的程序被阻塞了。可能是因为等那个锁,可能是因为等某个资源,或者是在切换上下文。


通过了解操作系统的性能,我们才知道性能的问题,比如:带宽不够,内存不够,TCP缓冲区不够,等等,很多时候,不需要调整程序的,只需要调整一下硬件或操作系统的配置就可以了。


3.2)使用Profiler测试
接下来,我们需要使用性能检测工具,也就是使用某个Profiler来差看一下我们程序的运行性能。如:Java的JProfiler/TPTP/CodePro Profiler,GNU的gprof,IBM的PurifyPlus,Intel的VTune,AMD的CodeAnalyst,还有Linux下的OProfile/perf,后面两个可以让你对你的代码优化到CPU的微指令级别,如果你关心CPU的L1/L2的缓存调优,那么你需要考虑一下使用VTune。 使用这些Profiler工具,可以让你程序中各个模块函数甚至指令的很多东西,如:运行的时间 ,调用的次数,CPU的利用率,等等。这些东西对我们来说非常有用。


我们重点观察运行时间最多,调用次数最多的那些函数和指令。这里注意一下,对于调用次数多但是时间很短的函数,你可能只需要轻微优化一下,你的性能就上去了(比如:某函数一秒种被调用100万次,你想想如果你让这个函数提高0.01毫秒的时间 ,这会给你带来多大的性能)


使用Profiler有个问题我们需要注意一下,因为Profiler会让你的程序运行的性能变低,像PurifyPlus这样的工具会在你的代码中插入很多代码,会导致你的程序运行效率变低,从而没发测试出在高吞吐量下的系统的性能,对此,一般有两个方法来定位系统瓶颈:


1)在你的代码中自己做统计,使用微秒级的计时器和函数调用计算器,每隔10秒把统计log到文件中。


2)分段注释你的代码块,让一些函数空转,做Hard Code的Mock,然后再测试一下系统的Throughput和Latency是否有质的变化,如果有,那么被注释的函数就是性能瓶颈,再在这个函数体内注释代码,直到找到最耗性能的语句。


最后再说一点,对于性能测试,不同的Throughput会出现不同的测试结果,不同的测试数据也会有不同的测试结果。所以,用于性能测试的数据非常重要,性能测试中,我们需要观测试不同Throughput的结果。


四、常见的系统瓶颈


下面这些东西是我所经历过的一些问题,也许并不全,也许并不对,大家可以补充指正,我纯属抛砖引玉。关于系统架构方面的性能调优,大家可移步看一下《由12306.cn谈谈网站性能技术》,关于Web方面的一些性能调优的东西,大家可以看看《Web开发中需要了解的东西》一文中的性能一章。我在这里就不再说设计和架构上的东西了。


一般来说,性能优化也就是下面的几个策略:


用空间换时间。各种cache如CPU L1/L2/RAM到硬盘,都是用空间来换时间的策略。这样策略基本上是把计算的过程一步一步的保存或缓存下来,这样就不用每次用的时候都要再计算一遍,比如数据缓冲,CDN,等。这样的策略还表现为冗余数据,比如数据镜象,负载均衡什么的。
用时间换空间。有时候,少量的空间可能性能会更好,比如网络传输,如果有一些压缩数据的算法(如前些天说的“Huffman 编码压缩算法” 和 “rsync 的核心算法”),这样的算法其实很耗时,但是因为瓶颈在网络传输,所以用时间来换空间反而能省时间。
简化代码。最高效的程序就是不执行任何代码的程序,所以,代码越少性能就越高。关于代码级优化的技术大学里的教科书有很多示例了。如:减少循环的层数,减少递归,在循环中少声明变量,少做分配和释放内存的操作,尽量把循环体内的表达式抽到循环外,条件表达的中的多个条件判断的次序,尽量在程序启动时把一些东西准备好,注意函数调用的开销(栈上开销),注意面向对象语言中临时对象的开销,小心使用异常(不要用异常来检查一些可接受可忽略并经常发生的错误),…… 等等,等等,这连东西需要我们非常了解编程语言和常用的库。
并行处理。如果CPU只有一个核,你要玩多进程,多线程,对于计算密集型的软件会反而更慢(因为操作系统调度和切换开销很大),CPU的核多了才能真正体现出多进程多线程的优势。并行处理需要我们的程序有Scalability,不能水平或垂直扩展的程序无法进行并行处理。从架构上来说,这表再为——是否可以做到不改代码只是加加机器就可以完成性能提升?
总之,根据2:8原则来说,20%的代码耗了你80%的性能,找到那20%的代码,你就可以优化那80%的性能。 下面的一些东西都是我的一些经验,我只例举了一些最有价值的性能调优的的方法,供你参考,也欢迎补充。


4.1)算法调优。算法非常重要,好的算法会有更好的性能。举几个我经历过的项目的例子,大家可以感觉一下。


一个是过滤算法,系统需要对收到的请求做过滤,我们把可以被filter in/out的东西配置在了一个文件中,原有的过滤算法是遍历过滤配置,后来,我们找到了一种方法可以对这个过滤配置进行排序,这样就可以用二分折半的方法来过滤,系统性能增加了50%。
一个是哈希算法。计算哈希算法的函数并不高效,一方面是计算太费时,另一方面是碰撞太高,碰撞高了就跟单向链表一个性能(可参看Hash Collision DoS 问题)。我们知道,算法都是和需要处理的数据很有关系的,就算是被大家所嘲笑的“冒泡排序”在某些情况下(大多数数据是排好序的)其效率会高于所有的排序算法。哈希算法也一样,广为人知的哈希算法都是用英文字典做测试,但是我们的业务在数据有其特殊性,所以,对于还需要根据自己的数据来挑选适合的哈希算法。对于我以前的一个项目,公司内某牛人给我发来了一个哈希算法,结果让我们的系统性能上升了150%。(关于各种哈希算法,你一定要看看StackExchange上的这篇关于各种hash算法的文章 )
分而治之和预处理。以前有一个程序为了生成月报表,每次都需要计算很长的时间,有时候需要花将近一整天的时间。于是我们把我们找到了一种方法可以把这个算法发成增量式的,也就是说我每天都把当天的数据计算好了后和前一天的报表合并,这样可以大大的节省计算时间,每天的数据计算量只需要20分钟,但是如果我要算整个月的,系统则需要10个小时以上(SQL语句在大数据量面前性能成级数性下降)。这种分而治之的思路在大数据面前对性能有很帮助,就像merge排序一样。SQL语句和数据库的性能优化也是这一策略,如:使用嵌套式的Select而不是笛卡尔积的Select,使用视图,等等。
4.2)代码调优。从我的经验上来说,代码上的调优有下面这几点:


字符串操作。这是最费系统性能的事了,无论是strcpy, strcat还是strlen,最需要注意的是字符串子串匹配。所以,能用整型最好用整型。举几个例子,第一个例子是N年前做银行的时候,我的同事喜欢把日期存成字符串(如:2012-05-29 08:30:02),我勒个去,一个select  where between语句相当耗时。另一个例子是,我以前有个同事把一些状态码用字符串来处理,他的理由是,这样可以在界面上直接显示,后来性能调优的时候,我把这些状态码全改成整型,然后用位操作查状态,因为有一个每秒钟被调用了150K次的函数里面有三处需要检查状态,经过改善以后,整个系统的性能上升了30%左右。还有一个例子是,我以前从事的某个产品编程规范中有一条是要在每个函数中把函数名定义出来,如:const char fname[]=”functionName()”, 这是为了好打日志,但是为什么不声明成 static类型的呢?
多线程调优。有人说,thread is evil,这个对于系统性能在某些时候是个问题。因为多线程瓶颈就在于互斥和同步的锁上,以及线程上下文切换的成本,怎么样的少用锁或不用锁是根本(比如:多版本并发控制(MVCC)在分布式系统中的应用 中说的乐观锁可以解决性能问题),此外,还有读写锁也可以解决大多数是读操作的并发的性能问题。这里多说一点在C++中,我们可能会使用线程安全的智能指针AutoPtr或是别的一些容器,只要是线程安全的,其不管三七二十一都要上锁,上锁是个成本很高的操作,使用AutoPtr会让我们的系统性能下降得很快,如果你可以保证不会有线程并发问题,那么你应该不要用AutoPtr。我记得我上次我们同事去掉智能指针的引用计数,让系统性能提升了50%以上。对于Java对象的引用计数,如果我猜的没错的话,到处都是锁,所以,Java的性能问题一直是个问题。另外,线程不是越多越好,线程间的调度和上下文切换也是很夸张的事,尽可能的在一个线程里干,尽可能的不要同步线程。这会让你有很多的性能。
内存分配。不要小看程序的内存分配。malloc/realloc/calloc这样的系统调非常耗时,尤其是当内存出现碎片的时候。我以前的公司出过这样一个问题——在用户的站点上,我们的程序有一天不响应了,用GDB跟进去一看,系统hang在了malloc操作上,20秒都没有返回,重启一些系统就好了。这就是内存碎片的问题。这就是为什么很多人抱怨STL有严重的内存碎片的问题,因为太多的小内存的分配释放了。有很多人会以为用内存池可以解决这个问题,但是实际上他们只是重新发明了Runtime-C或操作系统的内存管理机制,完全于事无补。当然解决内存碎片的问题还是通过内存池,具体来说是一系列不同尺寸的内存池(这个留给大家自己去思考)。当然,少进行动态内存分配是最好的。说到内存池就需要说一下池化技术。比如线程池,连接池等。池化技术对于一些短作业来说(如http服务) 相当相当的有效。这项技术可以减少链接建立,线程创建的开销,从而提高性能。
异步操作。我们知道Unix下的文件操作是有block和non-block的方式的,像有些系统调用也是block式的,如:Socket下的select,Windows下的WaitforObject之类的,如果我们的程序是同步操作,那么会非常影响性能,我们可以改成异步的,但是改成异步的方式会让你的程序变复杂。异步方式一般要通过队列,要注间队列的性能问题,另外,异步下的状态通知通常是个问题,比如消息事件通知方式,有callback方式,等,这些方式同样可能会影响你的性能。但是通常来说,异步操作会让性能的吞吐率有很大提升(Throughput),但是会牺牲系统的响应时间(latency)。这需要业务上支持。
语言和代码库。我们要熟悉语言以及所使用的函数库或类库的性能。比如:STL中的很多容器分配了内存后,那怕你删除元素,内存也不会回收,其会造成内存泄露的假像,并可能造成内存碎片问题。再如,STL某些容器的size()==0  和 empty()是不一样的,因为,size()是O(n)复杂度,empty()是O(1)的复杂度,这个要小心。Java中的JVM调优需要使用的这些参数:-Xms -Xmx -Xmn -XX:SurvivorRatio -XX:MaxTenuringThreshold,还需要注意JVM的GC,GC的霸气大家都知道,尤其是full GC(还整理内存碎片),他就像“恐龙特级克赛号”一样,他运行的时候,整个世界的时间都停止了。
4.3)网络调优


关于网络调优,尤其是TCP Tuning(你可以以这两个关键词在网上找到很多文章),这里面有很多很多东西可以说。看看Linux下TCP/IP的那么多参数就知道了(顺便说一下,你也许不喜欢Linux,但是你不能否认Linux给我们了很多可以进行内核调优的权力)。强烈建议大家看看《TCP/IP 详解 卷1:协议》这本书。我在这里只讲一些概念上的东西。


A) TCP调优


我们知道TCP链接是有很多开销的,一个是会占用文件描述符,另一个是会开缓存,一般来说一个系统可以支持的TCP链接数是有限的,我们需要清楚地认识到TCP链接对系统的开销是很大的。正是因为TCP是耗资源的,所以,很多攻击都是让你系统上出现大量的TCP链接,把你的系统资源耗尽。比如著名的SYNC Flood攻击。


所以,我们要注意配置KeepAlive参数,这个参数的意思是定义一个时间,如果链接上没有数据传输,系统会在这个时间发一个包,如果没有收到回应,那么TCP就认为链接断了,然后就会把链接关闭,这样可以回收系统资源开销。(注:HTTP层上也有KeepAlive参数)对于像HTTP这样的短链接,设置一个1-2分钟的keepalive非常重要。这可以在一定程度上防止DoS攻击。有下面几个参数(下面这些参数的值仅供参考):


1
2
3
net.ipv4.tcp_keepalive_probes = 5
net.ipv4.tcp_keepalive_intvl = 20
net.ipv4.tcp_fin_timeout = 30
对于TCP的TIME_WAIT这个状态,主动关闭的一方进入TIME_WAIT状态,TIME_WAIT状态将持续2个MSL(Max Segment Lifetime),默认为4分钟,TIME_WAIT状态下的资源不能回收。有大量的TIME_WAIT链接的情况一般是在HTTP服务器上。对此,有两个参数需要注意,


1
2
net.ipv4.tcp_tw_reuse=1
net.ipv4.tcp_tw_recycle=1
前者表示重用TIME_WAIT,后者表示回收TIME_WAIT的资源。


TCP还有一个重要的概念叫RWIN(TCP Receive Window Size),这个东西的意思是,我一个TCP链接在没有向Sender发出ack时可以接收到的最大的数据包。为什么这个很重要?因为如果Sender没有收到Receiver发过来ack,Sender就会停止发送数据并会等一段时间,如果超时,那么就会重传。这就是为什么TCP链接是可靠链接的原因。重传还不是最严重的,如果有丢包发生的话,TCP的带宽使用率会马上受到影响(会盲目减半),再丢包,再减半,然后如果不丢包了,就逐步恢复。相关参数如下:


1
2
3
4
net.core.wmem_default = 8388608
net.core.rmem_default = 8388608
net.core.rmem_max = 16777216
net.core.wmem_max = 16777216
一般来说,理论上的RWIN应该设置成:吞吐量  * 回路时间。Sender端的buffer应该和RWIN有一样的大小,因为Sender端发送完数据后要等Receiver端确认,如果网络延时很大,buffer过小了,确认的次数就会多,于是性能就不高,对网络的利用率也就不高了。也就是说,对于延迟大的网络,我们需要大的buffer,这样可以少一点ack,多一些数据,对于响应快一点的网络,可以少一些buffer。因为,如果有丢包(没有收到ack),buffer过大可能会有问题,因为这会让TCP重传所有的数据,反而影响网络性能。(当然,网络差的情况下,就别玩什么高性能了) 所以,高性能的网络重要的是要让网络丢包率非常非常地小(基本上是用在LAN里),如果网络基本是可信的,这样用大一点的buffer会有更好的网络传输性能(来来回回太多太影响性能了)。


另外,我们想一想,如果网络质量非常好,基本不丢包,而业务上我们不怕偶尔丢几个包,如果是这样的话,那么,我们为什么不用速度更快的UDP呢?你想过这个问题了吗?


B)UDP调优


说到UDP的调优,有一些事我想重点说一样,那就是MTU——最大传输单元(其实这对TCP也一样,因为这是链路层上的东西)。所谓最大传输单元,你可以想像成是公路上的公交车,假设一个公交车可以最多坐70人,带宽就像是公路的车道数一样,如果一条路上最多可以容下100辆公交车,那意味着我最多可以运送7000人,但是如果公交车坐不满,比如平均每辆车只有20人,那么我只运送了2000人,于是我公路资源(带宽资源)就被浪费了。 所以,我们对于一个UDP的包,我们要尽量地让他大到MTU的最大尺寸再往网络上传,这样可以最大化带宽利用率。对于这个MTU,以太网是1500字节,光纤是4352字节,802.11无线网是7981。但是,当我们用TCP/UDP发包的时候,我们的有效负载Payload要低于这个值,因为IP协议会加上20个字节,UDP会加上8个字节(TCP加的更多),所以,一般来说,你的一个UDP包的最大应该是1500-8-20=1472,这是你的数据的大小。当然,如果你用光纤的话, 这个值就可以更大一些。(顺便说一下,对于某些NB的千光以态网网卡来说,在网卡上,网卡硬件如果发现你的包的大小超过了MTU,其会帮你做fragment,到了目标端又会帮你做重组,这就不需要你在程序中处理了)


再多说一下,使用Socket编程的时候,你可以使用setsockopt() 设置 SO_SNDBUF/SO_RCVBUF 的大小,TTL和KeepAlive这些关键的设置,当然,还有很多,具体你可以查看一下Socket的手册。


最后说一点,UDP还有一个最大的好处是multi-cast多播,这个技术对于你需要在内网里通知多台结点时非常方便和高效。而且,多播这种技术对于机会的水平扩展(需要增加机器来侦听多播信息)也很有利。


C)网卡调优


对于网卡,我们也是可以调优的,这对于千兆以及网网卡非常必要,在Linux下,我们可以用ifconfig查看网上的统计信息,如果我们看到overrun上有数据,我们就可能需要调整一下txqueuelen的尺寸(一般默认为1000),我们可以调大一些,如:ifconfig eth0 txqueuelen 5000。Linux下还有一个命令叫:ethtool可以用于设置网卡的缓冲区大小。在Windows下,我们可以在网卡适配器中的高级选项卡中调整相关的参数(如:Receive Buffers, Transmit Buffer等,不同的网卡有不同的参数)。把Buffer调大对于需要大数据量的网络传输非常有效。


D)其它网络性能


关于多路复用技术,也就是用一个线程来管理所有的TCP链接,有三个系统调用要重点注意:一个是select,这个系统调用只支持上限1024个链接,第二个是poll,其可以突破1024的限制,但是select和poll本质上是使用的轮询机制,轮询机制在链接多的时候性能很差,因主是O(n)的算法,所以,epoll出现了,epoll是操作系统内核支持的,仅当在链接活跃时,操作系统才会callback,这是由操作系统通知触发的,但其只有Linux Kernel 2.6以后才支持(准确说是2.5.44中引入的),当然,如果所有的链接都是活跃的,过多的使用epoll_ctl可能会比轮询的方式还影响性能,不过影响的不大。


另外,关于一些和DNS Lookup的系统调用要小心,比如:gethostbyaddr/gethostbyname,这个函数可能会相当的费时,因为其要到网络上去找域名,因为DNS的递归查询,会导致严重超时,而又不能通过设置什么参数来设置time out,对此你可以通过配置hosts文件来加快速度,或是自己在内存中管理对应表,在程序启动时查好,而不要在运行时每次都查。另外,在多线程下面,gethostbyname会一个更严重的问题,就是如果有一个线程的gethostbyname发生阻塞,其它线程都会在gethostbyname处发生阻塞,这个比较变态,要小心。(你可以试试GNU的gethostbyname_r(),这个的性能要好一些) 这种到网上找信息的东西很多,比如,如果你的Linux使用了NIS,或是NFS,某些用户或文件相关的系统调用就很慢,所以要小心。


4.4)系统调优


A)I/O模型


前面说到过select/poll/epoll这三个系统调用,我们都知道,Unix/Linux下把所有的设备都当成文件来进行I/O,所以,那三个操作更应该算是I/O相关的系统调用。说到  I/O模型,这对于我们的I/O性能相当重要,我们知道,Unix/Linux经典的I/O方式是(关于Linux下的I/O模型,大家可以读一下这篇文章《使用异步I/O大大提高性能》):


第一种,同步阻塞式I/O,这个不说了。


第二种,同步无阻塞方式。其通过fctnl设置 O_NONBLOCK 来完成。


第三种,对于select/poll/epoll这三个是I/O不阻塞,但是在事件上阻塞,算是:I/O异步,事件同步的调用。


第四种,AIO方式。这种I/O 模型是一种处理与 I/O 并行的模型。I/O请求会立即返回,说明请求已经成功发起了。在后台完成I/O操作时,向应用程序发起通知,通知有两种方式:一种是产生一个信号,另一种是执行一个基于线程的回调函数来完成这次 I/O 处理过程。


第四种因为没有任何的阻塞,无论是I/O上,还是事件通知上,所以,其可以让你充分地利用CPU,比起第二种同步无阻塞好处就是,第二种要你一遍一遍地去轮询。Nginx之所所以高效,是其使用了epoll和AIO的方式来进行I/O的。


再说一下Windows下的I/O模型,


a)一个是WriteFile系统调用,这个系统调用可以是同步阻塞的,也可以是同步无阻塞的,关于看文件是不是以Overlapped打开的。关于同步无阻塞,需要设置其最后一个参数Overlapped,微软叫Overlapped I/O,你需要WaitForSingleObject才能知道有没有写完成。这个系统调用的性能可想而知。


b)另一个叫WriteFileEx的系统调用,其可以实现异步I/O,并可以让你传入一个callback函数,等I/O结束后回调之, 但是这个回调的过程Windows是把callback函数放到了APC(Asynchronous Procedure Calls)的队列中,然后,只用当应用程序当前线程成为可被通知状态(Alterable)时,才会被回调。只有当你的线程使用了这几个函数时WaitForSingleObjectEx, WaitForMultipleObjectsEx, MsgWaitForMultipleObjectsEx, SignalObjectAndWait 和 SleepEx,线程才会成为Alterable状态。可见,这个模型,还是有wait,所以性能也不高。


c)然后是IOCP – IO Completion Port,IOCP会把I/O的结果放在一个队列中,但是,侦听这个队列的不是主线程,而是专门来干这个事的一个或多个线程去干(老的平台要你自己创建线程,新的平台是你可以创建一个线程池)。IOCP是一个线程池模型。这个和Linux下的AIO模型比较相似,但是实现方式和使用方式完全不一样。


当然,真正提高I/O性能方式是把和外设的I/O的次数降到最低,最好没有,所以,对于读来说,内存cache通常可以从质上提升性能,因为内存比外设快太多了。对于写来说,cache住要写的数据,少写几次,但是cache带来的问题就是实时性的问题,也就是latency会变大,我们需要在写的次数上和相应上做权衡。


B)多核CPU调优


关于CPU的多核技术,我们知道,CPU0是很关键的,如果0号CPU被用得过狠的话,别的CPU性能也会下降,因为CPU0是有调整功能的,所以,我们不能任由操作系统负载均衡,因为我们自己更了解自己的程序,所以,我们可以手动地为其分配CPU核,而不会过多地占用CPU0,或是让我们关键进程和一堆别的进程挤在一起。


对于Windows来说,我们可以通过“任务管理器”中的“进程”而中右键菜单中的“设置相关性……”(Set Affinity…)来设置并限制这个进程能被运行在哪些核上。
对于Linux来说,可以使用taskset命令来设置(你可以通过安装schedutils来安装这个命令:apt-get install schedutils)
多核CPU还有一个技术叫NUMA技术(Non-Uniform Memory Access)。传统的多核运算是使用SMP(Symmetric Multi-Processor )模式,多个处理器共享一个集中的存储器和I/O总线。于是就会出现一致存储器访问的问题,一致性通常意味着性能问题。NUMA模式下,处理器被划分成多个node, 每个node有自己的本地存储器空间。关于NUMA的一些技术细节,你可以查看一下这篇文章《Linux 的 NUMA 技术》,在Linux下,对NUMA调优的命令是:numactl 。如下面的命令:(指定命令“myprogram arg1 arg2”运行在node 0 上,其内存分配在node 0 和 1上)


1
numactl --cpubind=0 --membind=0,1 myprogram arg1 arg2
当然,上面这个命令并不好,因为内存跨越了两个node,这非常不好。最好的方式是只让程序访问和自己运行一样的node,如:


1
$ numactl --membind 1 --cpunodebind 1 --localalloc myapplication
C)文件系统调优


关于文件系统,因为文件系统也是有cache的,所以,为了让文件系统有最大的性能。首要的事情就是分配足够大的内存,这个非常关键,在Linux下可以使用free命令来查看 free/used/buffers/cached,理想来说,buffers和cached应该有40%左右。然后是一个快速的硬盘控制器,SCSI会好很多。最快的是Intel SSD 固态硬盘,速度超快,但是写次数有限。


接下来,我们就可以调优文件系统配置了,对于Linux的Ext3/4来说,几乎在所有情况下都有所帮助的一个参数是关闭文件系统访问时间,在/etc/fstab下看看你的文件系统 有没有noatime参数(一般来说应该有),还有一个是dealloc,它可以让系统在最后时刻决定写入文件发生时使用哪个块,可优化这个写入程序。还要注间一下三种日志模式:data=journal、data=ordered和data=writeback。默认设置data=ordered提供性能和防护之间的最佳平衡。


当然,对于这些来说,ext4的默认设置基本上是最佳优化了。


这里介绍一个Linux下的查看I/O的命令—— iotop,可以让你看到各进程的磁盘读写的负载情况。


其它还有一些关于NFS、XFS的调优,大家可以上google搜索一些相关优化的文章看看。关于各文件系统,大家可以看一下这篇文章——《Linux日志文件系统及性能分析》


4.5)数据库调优


数据库调优并不是我的强项,我就仅用我非常有限的知识说上一些吧。注意,下面的这些东西并不一定正确,因为在不同的业务场景,不同的数据库设计下可能会得到完全相反的结论,所以,我仅在这里做一些一般性的说明,具体问题还要具体分析。


A)数据库引擎调优


我对数据库引擎不是熟,但是有几个事情我觉得是一定要去了解的。


数据库的锁的方式。这个非常非常地重要。并发情况下,锁是非常非常影响性能的。各种隔离级别,行锁,表锁,页锁,读写锁,事务锁,以及各种写优先还是读优先机制。性能最高的是不要锁,所以,分库分表,冗余数据,减少一致性事务处理,可以有效地提高性能。NoSQL就是牺牲了一致性和事务处理,并冗余数据,从而达到了分布式和高性能。
数据库的存储机制。不但要搞清楚各种类型字段是怎么存储的,更重要的是数据库的数据存储方式,是怎么分区的,是怎么管理的,比如Oracle的数据文件,表空间,段,等等。了解清楚这个机制可以减轻很多的I/O负载。比如:MySQL下使用show engines;可以看到各种存储引擎的支持。不同的存储引擎有不同的侧重点,针对不同的业务或数据库设计会让你有不同的性能。
数据库的分布式策略。最简单的就是复制或镜像,需要了解分布式的一致性算法,或是主主同步,主从同步。通过了解这种技术的机理可以做到数据库级别的水平扩展。
B)SQL语句优化


关于SQL语句的优化,首先也是要使用工具,比如:MySQL SQL Query Analyzer,Oracle SQL Performance Analyzer,或是微软SQL Query Analyzer,基本上来说,所有的RMDB都会有这样的工具,来让你查看你的应用中的SQL的性能问题。 还可以使用explain来看看SQL语句最终Execution Plan会是什么样的。


还有一点很重要,数据库的各种操作需要大量的内存,所以服务器的内存要够,优其应对那些多表查询的SQL语句,那是相当的耗内存。


下面我根据我有限的数据库SQL的知识说几个会有性能问题的SQL:


全表检索。比如:select * from user where lastname = “xxxx”,这样的SQL语句基本上是全表查找,线性复杂度O(n),记录数越多,性能也越差(如:100条记录的查找要50ms,一百万条记录需要5分钟)。对于这种情况,我们可以有两种方法提高性能:一种方法是分表,把记录数降下来,另一种方法是建索引(为lastname建索引)。索引就像是key-value的数据结构一样,key就是where后面的字段,value就是物理行号,对索引的搜索复杂度是基本上是O(log(n)) ——用B-Tree实现索引(如:100条记录的查找要50ms,一百万条记录需要100ms)。
索引。对于索引字段,最好不要在字段上做计算、类型转换、函数、空值判断、字段连接操作,这些操作都会破坏索引原本的性能。当然,索引一般都出现在Where或是Order by字句中,所以对Where和Order by子句中的子段最好不要进行计算操作,或是加上什么NOT之类的,或是使用什么函数。
多表查询。关系型数据库最多的操作就是多表查询,多表查询主要有三个关键字,EXISTS,IN和JOIN(关于各种join,可以参看图解SQL的Join一文)。基本来说,现代的数据引擎对SQL语句优化得都挺好的,JOIN和IN/EXISTS在结果上有些不同,但性能基本上都差不多。有人说,EXISTS的性能要好于IN,IN的性能要好于JOIN,我各人觉得,这个还要看你的数据、schema和SQL语句的复杂度,对于一般的简单的情况来说,都差不多,所以千万不要使用过多的嵌套,千万不要让你的SQL太复杂,宁可使用几个简单的SQL也不要使用一个巨大无比的嵌套N级的SQL。还有人说,如果两个表的数据量差不多,Exists的性能可能会高于In,In可能会高于Join,如果这两个表一大一小,那么子查询中,Exists用大表,In则用小表。这个,我没有验证过,放在这里让大家讨论吧。另,有一篇关于SQL Server的文章大家可以看看《IN vs JOIN vs EXISTS》
JOIN操作。有人说,Join表的顺序会影响性能,只要Join的结果集是一样,性能和join的次序无关。因为后台的数据库引擎会帮我们优化的。Join有三种实现算法,嵌套循环,排序归并,和Hash式的Join。(MySQL只支持第一种)
嵌套循环,就好像是我们常见的多重嵌套循环。注意,前面的索引说过,数据库的索引查找算法用的是B-Tree,这是O(log(n))的算法,所以,整个算法复法度应该是O(log(n)) * O(log(m)) 这样的。
Hash式的Join,主要解决嵌套循环的O(log(n))的复杂,使用一个临时的hash表来标记。
排序归并,意思是两个表按照查询字段排好序,然后再合并。当然,索引字段一般是排好序的。
还是那句话,具体要看什么样的数据,什么样的SQL语句,你才知道用哪种方法是最好的。


部分结果集。我们知道MySQL里的Limit关键字,Oracle里的rownum,SQL Server里的Top都是在限制前几条的返回结果。这给了我们数据库引擎很多可以调优的空间。一般来说,返回top n的记录数据需要我们使用order by,注意在这里我们需要为order by的字段建立索引。有了被建索引的order by后,会让我们的select语句的性能不会被记录数的所影响。使用这个技术,一般来说我们前台会以分页方式来显现数据,Mysql用的是OFFSET,SQL Server用的是FETCH NEXT,这种Fetch的方式其实并不好是线性复杂度,所以,如果我们能够知道order by字段的第二页的起始值,我们就可以在where语句里直接使用>=的表达式来select,这种技术叫seek,而不是fetch,seek的性能比fetch要高很多。
字符串。正如我前面所说的,字符串操作对性能上有非常大的恶梦,所以,能用数据的情况就用数字,比如:时间,工号,等。
全文检索。千万不要用Like之类的东西来做全文检索,如果要玩全文检索,可以尝试使用Sphinx。
其它。
不要select *,而是明确指出各个字段,如果有多个表,一定要在字段名前加上表名,不要让引擎去算。
不要用Having,因为其要遍历所有的记录。性能差得不能再差。
尽可能地使用UNION ALL  取代  UNION。
索引过多,insert和delete就会越慢。而update如果update多数索引,也会慢,但是如果只update一个,则只会影响一个索引表。
等等。
关于SQL语句的优化,网上有很多文章, 不同的数据库引擎有不同的优化技巧,正如本站以前转发的《MySQL性能优化的最佳20+条经验》


先写这么多吧,欢迎大家指正补充。
QQ: 378890364 微信:wwtree(省短信费) 紧急事宜发短信到0061432027638  本站微博:http://t.qq.com/wwtree QQ群:122538123
描述
快速回复

您目前还是游客,请 登录注册
如果您在写长篇帖子又不马上发表,建议存为草稿