本文为原创，转载请注明：http://www.cnblogs.com/tolimit/
引言
大家都知道，当进行嵌套循环时，大循环放最外面和放最里面所造成的执行效率会不同，本篇文章会通过汇编代码进行分析具体情况。
测试环境
- 操作系统：ubuntu-14.04.1
- 编译器：gcc-4.8
- 编译命令：gcc test.c -o test -g -Wall
测试代码：
1 #include <stdio.h> 2 3 /* 大循环在外 */ 4 void big_in_out (void) 5 { 6 int i; 7 int j; 8 int k; 9 10 for (i = 10000; i != 0; i--) 11 for (j = 1000; j != 0; j--) 12 for (k = 100; k != 0; k--) 13 ; 14 } 15 16 /* 大循环在内 */ 17 void big_in_in (void) 18 { 19 int i; 20 int j; 21 int k; 22 23 for (i = 100; i != 0; i--) 24 for (j = 1000; j != 0; j--) 25 for (k = 10000; k != 0; k--) 26 ; 27 } 28 29 int main (int argc, char * argv[]) 30 { 31 return 0; 32 }
通过objdump命令，获取其汇编代码，如下：
1 #include <stdio.h> 2 3 void big_in_out (void) 4 { 5 4004ed: 55 push %rbp 6 4004ee: 48 89 e5 mov %rsp,%rbp 7 int i; 8 int j; 9 int k; 10 11 for (i = 10000; i != 0; i--) 12 4004f1: c7 45 f4 10 27 00 00 movl $0x2710,-0xc(%rbp) # i = 10000 13 4004f8: eb 2a jmp 400524 <big_in_out+0x37> # 跳转至400524 14 for (j = 1000; j != 0; j--) 15 4004fa: c7 45 f8 e8 03 00 00 movl $0x3e8,-0x8(%rbp) # j = 1000 16 400501: eb 17 jmp 40051a <big_in_out+0x2d> # 跳转至40051a 17 for (k = 100; k != 0; k--) 18 400503: c7 45 fc 64 00 00 00 movl $0x64,-0x4(%rbp) # k = 100 19 40050a: eb 04 jmp 400510 <big_in_out+0x23> # 跳转至400510 20 40050c: 83 6d fc 01 subl $0x1,-0x4(%rbp) # k = k - 1 21 400510: 83 7d fc 00 cmpl $0x0,-0x4(%rbp) # 判断k是否为0 22 400514: 75 f6 jne 40050c <big_in_out+0x1f> # 不为0跳转至40050c 23 int i; 24 int j; 25 int k; 26 27 for (i = 10000; i != 0; i--) 28 for (j = 1000; j != 0; j--) 29 400516: 83 6d f8 01 subl $0x1,-0x8(%rbp) # j = j - 1 30 40051a: 83 7d f8 00 cmpl $0x0,-0x8(%rbp) # 判断j是否为0 31 40051e: 75 e3 jne 400503 <big_in_out+0x16> # j不为0跳转至400503 32 { 33 int i; 34 int j; 35 int k; 36 37 for (i = 10000; i != 0; i--) 38 400520: 83 6d f4 01 subl $0x1,-0xc(%rbp) # i = i - 1 39 400524: 83 7d f4 00 cmpl $0x0,-0xc(%rbp) # 判断i是否为0 40 400528: 75 d0 jne 4004fa <big_in_out+0xd> # i不为0跳转至4004fa 41 for (j = 1000; j != 0; j--) 42 for (k = 100; k != 0; k--) 43 ; 44 } 45 40052a: 5d pop %rbp 46 40052b: c3 retq 47 48 000000000040052c <big_in_in>: 49 50 void big_in_in (void) 51 { 52 40052c: 55 push %rbp 53 40052d: 48 89 e5 mov %rsp,%rbp 54 int i; 55 int j; 56 int k; 57 58 for (i = 100; i != 0; i--) 59 400530: c7 45 f4 64 00 00 00 movl $0x64,-0xc(%rbp) # i = 100 60 400537: eb 2a jmp 400563 <big_in_in+0x37> # 跳转至400563 61 for (j = 1000; j != 0; j--) 62 400539: c7 45 f8 e8 03 00 00 movl $0x3e8,-0x8(%rbp) # j = 1000 63 400540: eb 17 jmp 400559 <big_in_in+0x2d> # 跳转至400559 64 for (k = 10000; k != 0; k--) 65 400542: c7 45 fc 10 27 00 00 movl $0x2710,-0x4(%rbp) # k = 10000 66 400549: eb 04 jmp 40054f <big_in_in+0x23> # 跳转至40054f 67 40054b: 83 6d fc 01 subl $0x1,-0x4(%rbp) # k = k - 1 68 40054f: 83 7d fc 00 cmpl $0x0,-0x4(%rbp) # 判断k是否为0 69 400553: 75 f6 jne 40054b <big_in_in+0x1f> # 不为0跳转至40054b 70 int i; 71 int j; 72 int k; 73 74 for (i = 100; i != 0; i--) 75 for (j = 1000; j != 0; j--) 76 400555: 83 6d f8 01 subl $0x1,-0x8(%rbp) # j = j - 1 77 400559: 83 7d f8 00 cmpl $0x0,-0x8(%rbp) # 判断j是否为0 78 40055d: 75 e3 jne 400542 <big_in_in+0x16> # j不为0跳转至400542 79 { 80 int i; 81 int j; 82 int k; 83 84 for (i = 100; i != 0; i--) 85 40055f: 83 6d f4 01 subl $0x1,-0xc(%rbp) # i = i - 1 86 400563: 83 7d f4 00 cmpl $0x0,-0xc(%rbp) # 判断i是否为0 87 400567: 75 d0 jne 400539 <big_in_in+0xd> # i不为0跳转至400539 88 for (j = 1000; j != 0; j--) 89 for (k = 10000; k != 0; k--) 90 ; 91 } 92 400569: 5d pop %rbp 93 40056a: c3 retq 94 95 000000000040056b <main>: 96 97 int main (int argc, char * argv[]) 98 { 99 40056b: 55 push %rbp 100 40056c: 48 89 e5 mov %rsp,%rbp 101 40056f: 89 7d fc mov %edi,-0x4(%rbp) 102 400572: 48 89 75 f0 mov %rsi,-0x10(%rbp) 103 return 0; 104 400576: b8 00 00 00 00 mov $0x0,%eax 105 }
循环结果
由于是嵌套循环，即使循环0次，比如for(i = 0; i != 0; i--)情况，都需要执行4条指令，分别是：赋值、跳转、比较、判断跳转。具体的例子如18行~22行汇编代码所体现的情况(假设k赋值为0)。而for的主循环结构为3条指令，分别为：赋值、比较、判断跳转。具体例子同样也是18行~22行的汇编代码所体现。所以在嵌套循环中，假如其中一个循环结构需要循环n次，它所需要执行的指令量为：
指令量 = 4 + 3n
大循环在外
好的，根据以上所得的结论，我们可以很轻松的计算出大循环在外的整个三层循环所需要执行的指令数量，如下：
i = 10000 j = 1000 k = 100 i循环结构指令数量 = 4 + i * 3 = 30004 j循环结构指令数量 = 4 + j * 3 = 3004 k循环结构指令数量 = 4 + k * 3 = 304 i循环结构被循环次数 = 1 j循环结构被循环次数 = i k循环结构被循环次数 = i * j 整个结构指令数量 = i循环结构指令数量 * i循环结构被循环次数 + j循环结构指令数量 * j循环结构被循环次数 + k循环结构指令数量 * k循环结构被循环次数 整个结构指令数量 = 30004 * 1 + 3004 * 10000 + 304 * 1000 * 10000 = 3070070004
大循环在内
同上，我们也可以计算出大循环在内的整个三层循环所需要执行的指令数量，如下：
i = 100 j = 1000 k = 10000 i循环结构指令数量 = 4 + i * 3 = 304 j循环结构指令数量 = 4 + j * 3 = 3004 k循环结构指令数量 = 4 + k * 3 = 30004 i循环结构被循环次数 = 1 j循环结构被循环次数 = i k循环结构被循环次数 = i * j 整个结构指令数量 = i循环结构指令数量 * i循环结构被循环次数 + j循环结构指令数量 * j循环结构被循环次数 + k循环结构指令数量 * k循环结构被循环次数 整个结构指令数量 = 304 * 1 + 3004 * 100 + 30004 * 100 * 1000 = 3000700704
结论
可以很清楚得看出来，大循环在内所需要执行的指令数量 < 大循环在外所需执行的指令数量。表示在嵌套循环中，把大循环放入内层比把大循环放入外层的代码要高。而为什么会这样，我们可以通过数学进行计算，如下：
假设 X1,X2,X3,X4,X5,...,Xn都为正整数，他们代表着循环次数，并且 0 < X1 < X2 < X3 < X4 < X5 < ..... < Xn。
大循环在外的情况
第n层(最内层)的循环结构所需要执行的指令次数为: (4 + 3X1)X2X3X4X5...Xn
第n-1层循环结构所需要执行的指令次数为: (4 + 3X2)X3X4X5...Xn
第n-2层循环结构所需要执行的指令次数为: (4 + 3X3)X4X5...Xn
....................
第2层循环结构所需要执行指令次数为: (4 + 3Xn-1)Xn
第1层循环结构所需要执行的指令次数为: (4 + 3Xn)
总指令数为
ALL1 = (4 + 3X1)X2X3X4X5...Xn + (4 + 3X2)X3X4X5...Xn + (4 + 3X3)X4X5...Xn + (4 + 3X4)X5...Xn +...+ (4 + 3Xn-1)Xn + (4 + 3Xn)
ALL1 = 4X2X3X4X5...Xn + 3X1X2X3X4X5...Xn + 4X3X4X5...Xn + 3X2X3X4X5...Xn + 4X4X5...Xn + 3X2X3X4...Xn + 4X5...Xn + 3X4X5...Xn +...+ 4Xn + 3Xn-1Xn + 4 + 3Xn
合并同类项后，得
ALL1 = 4 + 3X1X2X3X4X5...Xn + 7X2X3X4X5...Xn + 7X3X4X5...Xn + 7X4X5...Xn +7X5...Xn + ... + 7Xn-1Xn + 7Xn
第n层(最内层)的循环结构所需要执行的指令次数为: (4 + 3Xn)Xn-1Xn-2Xn-3Xn-4...X1
第n-1层循环结构所需要执行的指令次数为: (4 + 3Xn-1)Xn-2Xn-3Xn-4...X1
第n-2层循环结构所需要执行的指令次数为: (4 + 3Xn-2)Xn-3Xn-4...X1
....................
第2层循环结构所需要执行指令次数为: (4 + 3X2)X1
第1层循环结构所需要执行的指令次数为: (4 + 3X1)
总指令数为
ALL2 = (4 + 3Xn)Xn-1Xn-2Xn-3Xn-4...X1 + (4 + 3Xn-1)Xn-2Xn-3Xn-4...X1 + (4 + 3Xn-2)Xn-3Xn-4...X1 + (4 + 3Xn-3)Xn-4...X1 +...+ (4 + 3X2)X1 + (4 + 3X1)
ALL2 = 4X1X2X3X4...Xn-1 + 3X1X2X3X4X5...Xn + 4X1X2X3...Xn-2 + 3X1X2X3X4...Xn-1 + 4X1X2...Xn-3 + 3X1X2X3...Xn-2 + 4X1...Xn-4 + 3X1X2...Xn-3 +...+ 4X1 + 3X2X1 + 4 + 3X1
合并同类项后，得
ALL2 = 4 + 3X1X2X3X4X5...Xn + 7X1X2X3X4...Xn-1 + 7X1X2X3...Xn-2 + 7X1X2...Xn-3 +7X1...Xn-4 + ... + 7X2X1 + 7X1
结果
大循环在外的总指令数为ALL1，大循环在内的总指令数为ALL2，我们用ALL1的每一项除以ALL2中对应的每一项，结果为R，如下
R1 = 4 / 4 = 1
R2 = 3X1X2X3X4X5...Xn / 3X1X2X3X4X5...Xn = 1
R3 = 7X2X3X4X5...Xn / 7X1X2X3X4...Xn-1 = Xn / X1 > 1
R4 = 7X3X4X5...Xn / 7X1X2X3...Xn-2 = XnXn-1 / X1X2 > 1
R5 = 7X4X5...Xn / 7X1X2...Xn-3 = XnXn-1Xn-2 / X1X2X3 > 1
R6 = 7X5...Xn / 7X1...Xn-4 = XnXn-1Xn-2Xn-3 / X1X2X3X4 > 1
......
Rm-1 = 7Xn-1Xn / 7X2X1 > 1
Rm = 7Xn / 7X1 > 1
从以上结果可以很明显的看出，除了ALL1和ALL2公有项4，3X1X2X3X4X5...Xn相除为1，其他ALL1的每一项对应除以ALL2的每一项，结果R都大于1，说明ALL1中的每一项都大于ALL2中对应的每一项，即说明了ALL1 > ALL2 ，同时也证明了大循环在外所需要执行的指令数量大于大循环在内所需要执行的指令数量，也就是将大循环放在内层时比大循环放在外层的循环效率要高的。