来一发一个复杂例子申明为何C言语在2013年仍很主要

对于开发环境的选择尽量要轻量级和高度可定制，航空母舰级别的工具往往会让你迷惑不解；
　　本文作者在开辟Dynym项目，这是一个静态言语的通用运转时。在开辟时，作者以其他言语的运转速率作为基本对照言语的运转速率，因而发明了一些小奥密。迭代盘算斐波那契数列是测试各类言语实行速率的罕见办法。作者以分歧的言语举行测试，终极发明C言语要比Python编写的盘算斐波那契数列快278.5倍。在底层开辟，和专注功能的使用程序中，选择是不言而喻的。而为何会有云云年夜的运转功能差异呢。作者进一步研讨了程序的反汇编代码，发明不同出在内存的会见次数，和展望的CPU指令的准确性方面。

登录/注册后可看大图

　　原作者注：在本文最入手下手，我并没申明举行模2^64的盘算——我固然分明那些不是“准确的”斐波那契数列，实在我不是想剖析年夜数，我只是想探访编译器发生的代码和盘算机系统布局罢了。

　　比来，我一向在开辟Dynvm——一个通用的静态言语运转时。就像其他任何好的言语运转时项目一样，开辟是由基准测试程序驱动的。因而，我一向在用基准测试程序测试各类由分歧言语编写的算法，以此对其典范的运转速率有一个感到上的熟悉。一个典范的测试就是迭代盘算斐波那契数列。为复杂起见，我以2^64为模，用两种言语编写完成了该算法。

　　用Python言语完成以下：

1. deffib(n):SZ=2**64i=0a,b=1,0whilei<n:t=bb=(b+a)%SZa=ti=i+1returnb

复制代码

　　用C言语完成以下：

1. #include<stdio.h>#include<stdlib.h>typedefunsignedlongulong;intmain(intargc,char*argv[]){ulongn=atoi(argv[1]);ulonga=1;ulongb=0;ulongt;for(ulongi=0;i<n;i++){t=b;b=a+b;a=t;}printf("%lu
2. ",b);return0;}

复制代码

　　用其他言语完成的代码示例，我已放在github上。

　　Dynvm包括一个基准测试程序框架，该框架能够同意在分歧言语之间对照运转速率。在一台Inteli7-3840QM（调频到1.2GHz)呆板上，当n=1,000,000时，对照了局以下：

1. =======================================================言语工夫(秒)=======================================================Java0.133CLanguage0.006CPython0.534JavascriptV80.284

复制代码

　　很分明，C言语是这里的老迈，可是java的了局有点误导性，由于年夜部分的工夫是由JIT编译器启动（~120ms）占用的。当n=100,000,000时，了局变得更开阔爽朗：

1. =======================================================言语工夫（秒）=======================================================Java0.300CLanguage0.172CPython47.909JavascriptV824.179

复制代码

　　在这里，我们探求下为何C言语在2013年仍旧很主要，和为何编程天下不会完整“跳槽”到Python大概V8/Node。偶然你必要原始功能，可是静态言语仍在这方面困难挣扎着，即便对以上很复杂的例子而言。我团体信任这类情形会克制失落，经由过程几个项目我们能在这方面看到很年夜的但愿：JVM、V8、PyPy、LuaJIT等等，但在2013年我们还没有抵达“目标地”。

　　但是，我们没法躲避如许的成绩：为何差异云云之年夜？在C言语和Python之间有278.5倍的功能差异！最难以想象的中央是，从语法角度讲，以上例子中的C言语和Python外部轮回基础上千篇一律。

　　为了找到成绩的谜底，我搬出了反汇编器，发明了以下征象：

1. 0000000000400480<main>:247400480:4883ec08sub$0x8,%rsp248400484:488b7e08mov0x8(%rsi),%rdi249400488:ba0a000000mov$0xa,%edx25040048d:31f6xor%esi,%esi25140048f:e8ccffffffcallq400460<strtol@plt>252400494:4898cltq253400496:31d2xor%edx,%edx254400498:4885c0test%rax,%rax25540049b:7426je4004c3<main+0x43>25640049d:31c9xor%ecx,%ecx25740049f:31f6xor%esi,%esi2584004a1:bf01000000mov$0x1,%edi2594004a6:eb0ejmp4004b6<main+0x36>2604004a8:0f1f8400000000nopl0x0(%rax,%rax,1)2614004af:002624004b0:4889f7mov%rsi,%rdi2634004b3:4889d6mov%rdx,%rsi2644004b6:4883c101add$0x1,%rcx2654004ba:488d143elea(%rsi,%rdi,1),%rdx2664004be:4839c8cmp%rcx,%rax2674004c1:77edja4004b0<main+0x30>2684004c3:beac064000mov$0x4006ac,%esi2694004c8:bf01000000mov$0x1,%edi2704004cd:31c0xor%eax,%eax2714004cf:e89cffffffcallq400470<__printf_chk@plt>2724004d4:31c0xor%eax,%eax2734004d6:4883c408add$0x8,%rsp2744004da:c3retq2754004db:90nop

复制代码

　　（译注：

• 1、分歧的编译器版本及分歧的优化选项（-Ox）会发生分歧的汇编代码。
  
• 2、反汇编办法：gcc-g-O2test.c-otest;objdumb-dtest>test.txt读者能够本人实验变更优化选项对照反汇编了局）
  

　　最次要的部分是盘算下一个斐波那契数值的外部轮回：

1. 2624004b0:4889f7mov%rsi,%rdi2634004b3:4889d6mov%rdx,%rsi2644004b6:4883c101add$0x1,%rcx2654004ba:488d143elea(%rsi,%rdi,1),%rdx2664004be:4839c8cmp%rcx,%rax2674004c1:77edja4004b0<main+0x30>

复制代码

　　变量在存放器中的分派情形以下：

1. a:%rsib:%rdxt:%rdii:%rcxn:%rax

复制代码

　　262和263行完成了变量互换，264行增添轮回计数值，固然看起来对照奇异，265行完成了b=a+t。然后做一个复杂地对照，最初一个跳转指令跳到轮回入手下手出持续实行。

　　手动反编译以上代码，代码看起来是如许的：

1. loop:t=aa=bi=i+1b=a+tif(n>i)gotoloop

复制代码

　　全部外部轮回仅用六条X86-64汇编指令就完成了（极可能外部微指令个数也差未几。译者注：IntelX86-64处置器会把指令进一步翻译成微指令，以是CPU实行的实践指令数要比汇编指令多）。CPython注释模块对每条高层的指令字节码最少必要六条乃至更多的指令来注释，比拟而言，C言语完胜。除此以外，另有一些其他更奇妙的中央。

　　拉低古代处置器实行速率的一个次要缘故原由是关于主存的会见。这个方面的影响非常可骇，在微处置器计划时，有数个工程时（engineeringhours）都消费在找到无效地手艺来“遮蔽”访存延时。通用的战略包含：缓存、推想预取、load-store依附性展望、乱序实行等等。这些办法的确在使呆板更快方面起了很高文用，可是不成能完整不发生访存操纵。

　在下面的汇编代码中，从没会见过内存，实践上变量完整存储在CPU存放器中。如今思索CPython：一切器材都是堆上的工具，并且一切办法都是静态的。静态特征太广泛了，以致于我们没有举措晓得，a+b实行integer_add(a,b)、string_concat(a,b)、仍是用户本人界说的函数。这也就意味着良多工夫花在了在运转时找出究竟挪用了哪一个函数。静态JIT运转时会实验在运转时猎取这个信息，并静态发生x86代码，可是这其实不老是十分间接的（我等候V8运转时会体现的更好，但奇异的是它的速率只是Python的0.5倍）。由于CPython是一个地道的翻译器，在每一个轮回迭代时，良多工夫花在懂得决静态特征上，这就必要良多不用要的访存操纵。

　　除以上内存在弄鬼，另有其他要素。古代超标量乱序处置器核一次性能够取好几条指令各处理器中，而且“在最便利时”实行这些指令，也就是说：鉴于了局仍旧是准确的，指令实行按次能够恣意。这些处置器也能够在统一个时钟周期并行实行多条指令，只需这些指令是不相干的。IntelSandyBridgeCPU能够同时将168条指令重排序，并能够在一个周期中发射（即入手下手实行指令）最多6条指令，同时停止（即指令完成实行）最多4条指令！大略地以下面斐波那契举例，Intel这个处置器能够约莫把28（译者注：28*6=168）个外部轮回重排序，而且几近能够在每个时钟周期完成一个轮回！这听起来很霸气，可是像其他事一样，细节老是十分庞大的。

　　我们假定8条指令是不相干的，如许处置器就能够获得充足的指令来使用指令重排序带来的优点。关于包括分支指令的指令流举行重排序长短常庞大的，也就是对if-else和轮回（译者注：if-else必要判别后跳转，以是一定包括分支指令）发生的汇编代码。典范的办法就是关于分支指令举行展望。CPU会静态的使用之前分支实行了局来推测未来要实行的分支指令的实行了局，而且获得那些它“以为”将要实行的指令。但是，这个推想有多是不准确的，假如的确不准确，CPU就会进进复位形式（译者注：这里的复位不是指处置器reset，而是CPU流水线的复位），即抛弃已获得的指令而且从头入手下手取指。这类复位操纵有大概对功能发生很年夜影响。因而，关于分支指令的准确展望是另外一个必要消费良多工程时的范畴。

　　如今，不是一切分支指令都是一样的，有些能够很完善的展望，可是另外一些几近不成能举行展望。后面例子中的轮回中的分支指令——就像反汇编代码中267行——是最简单展望的个中一种，这个分支指令会一连向后跳转100,000,000次。

　　以下是一个十分难展望的分支指令实例：

1. voidmain(void){for(inti=0;i<1000000;i++){intn=random();if(n>=0){printf("positive!
2. ");}else{printf("negative!
3. ");}}}

复制代码

　　假如random()是真正随机的（现实上在C言语中远非云云），那末关于if-else的展望还不如任意猜来的正确。侥幸的是，年夜部分的分支指令没有这么淘气，可是也有很少一部分和下面例子中的轮回分支指令一样反常。

　　回到我们的例子上：C代码完成的斐波那契数列，只发生一个十分简单展望的分支指令。相反地，CPython代码就十分糟。起首，一切地道的翻译器有一个“分派”轮回，就像上面的例子：

1. voidexec_instruction(instruction_t*inst){switch(inst->opcode){caseADD://doaddcaseLOAD://doloadcaseSTORE://dostorecaseGOTO://dogoto}}

复制代码

　　编译器不管怎样处置以上代码，最少有一个直接跳转指令是必需的，而这类直接跳转指令是对照难展望的。

　　接上去回想一下，静态言语必需在运转时断定如“ADD指令的意义是甚么”如许基础的成绩，这固然会发生——你猜对了——加倍反常的分支指令。

　　以上一切要素加起来，最初招致一个278.5倍的功能差异！如今，这固然是一个很复杂的例子，可是其他的只会比这更反常。这个复杂例子足以凸显初级静态言语（比方C言语）在古代软件中的主要位置。我固然不是2013年里C言语最年夜的粉丝，可是C言语仍旧主导着初级把持范畴及对功能请求高的使用程序范畴。

　　原文链接：AnthonyJBonkoski翻译：伯乐在线-qianlong
　　译文链接：http://blog.jobbole.com/47096/
对于开发环境的选择尽量要轻量级和高度可定制，航空母舰级别的工具往往会让你迷惑不解；

实训的项目是高级语言程序设计。说实话，在这么多科目中，这是我学得最糟糕的一科。刚开始，我对这实训没什么信心，不知能否按时完成。

可以说是C++的核心，相对来说也比较难以理解，因为这些技术很多都是面向于写库的人，初学C++的人很难用得上。

当然. 你有兴趣可以再学学动态语言.比如 Ruby．慢慢地. 就会提高的.多学一点东西.就会让你的思维广阔。。

一时兴起，慷慨激扬。个人观点，高手路过，留下心得，大家互相学习。

关于用类来控制C++的内存分配，应该算是C++的一个高级技法。写的好的C++程序，基本看不到delete与new。因为这些内存的分配，销毁都让一特殊的类去管理。

天将降大任与斯人也，必先苦其心志，劳其筋骨，饿其体肤，空乏其身，.......理解得人自然会在心中默念，不理解得会笑我土。