内容不断更新，目前包括协议中握手和数据帧的分析

1.1 背景

1.2 协议概览

协议包含两部分：握手，数据传输。

客户端的握手如下：
GET /chat HTTP/1.1
Host: server.example.com
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==
Origin: http://example.com
Sec-WebSocket-Protocol: chat, superchat
Sec-WebSocket-Version: 13

服务端的握手如下：
        HTTP/1.1 101 Switching Protocols         Upgrade: websocket         Connection: Upgrade         Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=         Sec-WebSocket-Protocol: chat

客户端和服务端都发送了握手，并且成功，数据传输即可开始。

1.3 发起握手

发起握手是为了兼容基于HTTP的服务端程序，这样一个端口可以同时处理HTTP客户端和WebSocket客户端

因此WebSocket客户端握手是一个HTTP Upgrade请求：
        GET /chat HTTP/1.1         Host: server.example.com         Upgrade: websocket         Connection: Upgrade         Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==         Origin: http://example.com         Sec-WebSocket-Protocol: chat, superchat         Sec-WebSocket-Version: 13

握手中的域的顺序是任意的。

5 数据帧

5.1 概述

WebScoket协议中，数据以帧序列的形式传输。

考虑到数据安全性，客户端向服务器传输的数据帧必须进行掩码处理。服务器若接收到未经过掩码处理的数据帧，则必须主动关闭连接。

服务器向客户端传输的数据帧一定不能进行掩码处理。客户端若接收到经过掩码处理的数据帧，则必须主动关闭连接。

针对上情况，发现错误的一方可向对方发送close帧（状态码是1002，表示协议错误），以关闭连接。

5.2 帧协议

WebSocket数据帧结构如下图所示：

      0                   1                   2                   3       0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1      +-+-+-+-+-------+-+-------------+-------------------------------+      |F|R|R|R| opcode|M| Payload len |    Extended payload length    |      |I|S|S|S|  (4)  |A|     (7)     |             (16/64)           |      |N|V|V|V|       |S|             |   (if payload len==126/127)   |      | |1|2|3|       |K|             |                               |      +-+-+-+-+-------+-+-------------+ - - - - - - - - - - - - - - - +      |     Extended payload length continued, if payload len == 127  |      + - - - - - - - - - - - - - - - +-------------------------------+      |                               |Masking-key, if MASK set to 1  |      +-------------------------------+-------------------------------+      | Masking-key (continued)       |          Payload Data         |      +-------------------------------- - - - - - - - - - - - - - - - +      :                     Payload Data continued ...                :      + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +      |                     Payload Data continued ...                |      +---------------------------------------------------------------+

FIN：1位
表示这是消息的最后一帧（结束帧），一个消息由一个或多个数据帧构成。若消息由一帧构成，起始帧即结束帧。

RSV1，RSV2，RSV3：各1位
MUST be 0 unless an extension is negotiated that defines meanings for non-zero values. If a nonzero value is received and none of the negotiated extensions defines the meaning of such a nonzero value, the receiving endpoint MUST _Fail the WebSocket Connection_.
这里我翻译不好，大致意思是如果未定义扩展，各位是0；如果定义了扩展，即为非0值。如果接收的帧此处非0，扩展中却没有该值的定义，那么关闭连接。

OPCODE：4位
解释PayloadData，如果接收到未知的opcode，接收端必须关闭连接。
0x0表示附加数据帧
0x1表示文本数据帧
0x2表示二进制数据帧
0x3-7暂时无定义，为以后的非控制帧保留
0x8表示连接关闭
0x9表示ping
0xA表示pong
0xB-F暂时无定义，为以后的控制帧保留

MASK：1位
用于标识PayloadData是否经过掩码处理。如果是1，Masking-key域的数据即是掩码密钥，用于解码PayloadData。客户端发出的数据帧需要进行掩码处理，所以此位是1。

Payload length：7位，7+16位，7+64位
PayloadData的长度（以字节为单位）。
如果其值在0-125，则是payload的真实长度。
如果值是126，则后面2个字节形成的16位无符号整型数的值是payload的真实长度。注意，网络字节序，需要转换。
如果值是127，则后面8个字节形成的64位无符号整型数的值是payload的真实长度。注意，网络字节序，需要转换。
长度表示遵循一个原则，用最少的字节表示长度（我理解是尽量减少不必要的传输）。举例说，payload真实长度是124，在0-125之间，必须用前7位表示；不允许长度1是126或127，然后长度2是124，这样违反原则。
Payload长度是ExtensionData长度与ApplicationData长度之和。ExtensionData长度可能是0，这种情况下，Payload长度即是ApplicationData长度。

WebSocket协议规定数据通过帧序列传输。

客户端必须对其发送到服务器的所有帧进行掩码处理。

服务器一旦收到无掩码帧，将关闭连接。服务器可能发送一个状态码是1002（表示协议错误）的Close帧。

而服务器发送客户端的数据帧不做掩码处理，一旦客户端发现经过掩码处理的帧，将关闭连接。客户端可能使用状态码1002。

消息分片

分片目的是发送长度未知的消息。如果不分片发送，即一帧，就需要缓存整个消息，计算其长度，构建frame并发送；使用分片的话，可使用一个大小合适的buffer，用消息内容填充buffer，填满即发送出去。

分片规则：

1.一个未分片的消息只有一帧（FIN为1，opcode非0）

2.一个分片的消息由起始帧（FIN为0，opcode非0），若干（0个或多个）帧（FIN为0，opcode为0），结束帧（FIN为1，opcode为0）。

3.控制帧可以出现在分片消息中间，但控制帧本身不允许分片。

4.分片消息必须按次序逐帧发送。

5.如果未协商扩展的情况下，两个分片消息的帧之间不允许交错。

6.能够处理存在于分片消息帧之间的控制帧

7.发送端为非控制消息构建长度任意的分片

8.client和server兼容接收分片消息与非分片消息

9.控制帧不允许分片，中间媒介不允许改变分片结构（即为控制帧分片）

10.如果使用保留位，中间媒介不知道其值表示的含义，那么中间媒介不允许改变消息的分片结构

11.如果协商扩展，中间媒介不知道，那么中间媒介不允许改变消息的分片结构，同样地，如果中间媒介不了解一个连接的握手信息，也不允许改变该连接的消息的分片结构

12.由于上述规则，一个消息的所有分片是同一数据类型（由第一个分片的opcode定义）的数据。因为控制帧不允许分片，所以一个消息的所有分片的数据类型是文本、二进制、opcode保留类型中的一种。

需要注意的是，如果控制帧不允许夹杂在一个消息的分片之间，延迟会较大，比如说当前正在传输一个较大的消息，此时的ping必须等待消息传输完成，才能发送出去，会导致较大的延迟。为了避免类似问题，需要允许控制帧夹杂在消息分片之间。

控制帧

根据官方文档整理，官方文档参考http://datatracker.ietf.org/doc/rfc6455/?include_text=1

1.若用C語言，且想將int轉char *，可用sprintf()，sprintf()可用類似printf()參數轉型。

 1/* 
 2(C) OOMusou 2007 http://oomusou.cnblogs.com
 3
 4Filename    : int2str_sprintf.cpp
 5Compiler    : Visual C++ 8.0 / ANSI C
 6Description : Demo the how to convert int to const char *
 7Release     : 01/06/2007 1.0
 8*/
 9#include "stdio.h"
10
11void int2str(int , char *);
12
13int main() {
14  int i = 123;
15  char s[64];
16  int2str(i, s);
17  puts(s);
18}
19
20void int2str(int i, char *s) {
21  sprintf(s,"%d",i);
22}

2.若用C語言，還有另外一個寫法，使用_itoa()，Microsoft將這個function擴充成好幾個版本，可參考MSDN Library。

 1/* 
 2(C) OOMusou 2007 http://oomusou.cnblogs.com
 3
 4Filename    : int2str_itoa.cpp
 5Compiler    : Visual C++ 8.0 / ANSI C
 6Description : Demo the how to convert int to const char *
 7Release     : 01/06/2007 1.0
 8*/
 9#include "stdio.h"  // puts()
10#include "stdlib.h" // _itoa()
11
12void int2str(int , char *);
13
14int main() {
15  int i = 123;
16  char s[64];
17  int2str(i, s);
18  puts(s);
19}
20
21void int2str(int i, char *s) {
22  _itoa(i, s, 10);
23}

3.若用C++，stringstream是個很好用的東西，stringstream無論是<<或>>，都會自動轉型，要做各型別間的轉換，stringstream是個很好的媒介。

 1/* 
 2(C) OOMusou 2007 http://oomusou.cnblogs.com
 3
 4Filename    : int2str_sstream.cpp
 5Compiler    : Visual C++ 8.0 / ISO C++
 6Description : Demo the how to convert int to string
 7Release     : 01/06/2007 1.0
 8*/
 9
10#include <iostream>
11#include <string>
12#include <sstream>
13
14using namespace std;
15
16string int2str(int &);
17
18int main(void) {
19  int i = 123;
20  string s;
21  s = int2str(i);
22
23  cout << s << endl;
24}
25
26string int2str(int &i) {
27  string s;
28  stringstream ss(s);
29  ss << i;
30
31  return ss.str();
32}

4.若用C++，據稱boost有更好的方法，不過我還沒有裝boost，所以無從測試

今天经同事推荐，查阅了一下msgpack相关的资料。msgpack提供快速的打包解包功能，官网上给出的图号称比protobuf快4倍，可以说相当高效了。最大的好处在与msgpack支持多语言，服务器端可以用C++，android客户端可以用java，能满足实际需求。

在实际安装msgpack的过程中，碰到了一点小问题，因为开发机器是32位机器，i686的，所以安装完后跑一个简单的sample时，c++编译报错，错误的表现为链接时报错：undefined reference to `__sync_sub_and_fetch_4'，后来参考了下面的博客，在configure时指定CFLAGS="-march=i686"解决，注意要make clean先。

msgpack官网地址：http://msgpack.org/

安装过程中参考的博客地址：http://blog.csdn.net/xiarendeniao/article/details/6801338

====================================================================================

====================================================================================

补上近期简单的测试结果

测试机器，cpu 4核 Dual-Core AMD Opteron(tm) Processor 2212，单核2GHz，1024KB cache, 内存4G。

1. 简单包测试

测试中省略了包头本地字节序与网络字节序之间的转化，只有包体做msgpack打包处理.

2. 复杂包测试(vector嵌套)

基本上每次打包解包一次要耗时0.25ms，每秒估算可以做4k次打包解包，速度还是不错的。

3. 加上crc校验

如果每个循环中，打包过程加上crc的计算，解包过程中加上crc校验，得到测试结果如下：

基本上每次打包解包耗时0.26ms左右，与没有crc差别不大；

代码：
> require ‘msgpack’
> msg = [1,2,3].to_msgpack  #=> “\x93\x01\x02\x03″
> MessagePack.unpack(msg)   #=> [1,2,3]

以上摘自oschina介绍。

msgpack官方主页：http://msgpack.org/

github主页：https://github.com/msgpack/msgpack

因我只使用C++版本，故只下载了CPP部分，大家请按需下载。

源码安装msgpack

打开终端下载msgpac 4 cpp最新版本0.5.7

wget http://msgpack.org/releases/cpp/msgpack-0.5.7.tar.gz

解压

tar zxvf msgpack-0.5.7.tar.gz

进入解压后的文件夹中进行安装

cd msgpack-0.5.7 ./configure make sudo make install

当然了，你也可以使用git和svn直接抓取源代码进行编译，不过需要安装版本控制工具。

自动安装msgpack

apt-get install libmsgpack-dev

(安装过程中会将头文件拷贝到 /usr/local/include/ 库文件拷贝到/usr/local/lib/)

安装好了，我们直接使用用它看看效果。

直接包含msgpack.hpp即可使用。

simple using

#include <msgpack.hpp> #include <vector> #include <string> #include <iostream>  int main() { 	std::vector<std::string> _vecString; 	_vecString.push_back("Hello"); 	_vecString.push_back("world");  	// pack 	msgpack::sbuffer _sbuffer; 	msgpack::pack(_sbuffer, _vecString); 	std::cout << _sbuffer.data() << std::endl;  	// unpack 	msgpack::unpacked msg; 	msgpack::unpack(&msg, _sbuffer.data(), _sbuffer.size()); 	msgpack::object obj = msg.get(); 	std::cout << obj << std::endl;  	// convert 	std::vector<std::string> _vecRString; 	obj.convert(&_vecRString);  	// print 	for(size_t i = 0; i < _vecRString.size(); ++i) 	{ 		std::cout << _vecRString[i] << std::endl; 	}      return 0; }

结果就不贴了，大家自己运行下便知。

using stream

#include <msgpack.hpp> #include <vector> #include <string> #include <iostream>  int main() { 	// msgpack stream  	// use msgpack::packer to pack multiple objects. 	msgpack::sbuffer buffer_; 	msgpack::packer pack_(&buffer_); 	pack_.pack(std::string("this is 1st string")); 	pack_.pack(std::string("this is 2nd string")); 	pack_.pack(std::string("this is 3th string"));  	// use msgpack::unpacker to unpack multiple objects. 	msgpack::unpacker unpack_; 	unpack_.reserve_buffer(buffer_.size()); 	memcpy(unpack_.buffer(), buffer_.data(), buffer_.size()); 	unpack_.buffer_consumed(buffer_.size());  	msgpack::unpacked result_; 	while (unpack_.next(&result_)) 	{ 		std::cout << result_.get() << std::endl; 	}  	return 0; }

使用sbuffer stream序列化多个对象。

如何序列化自定义数据结构

msgpack支持序列化/反序列化自定义数据结构，只需要简单的使用MSGPACK_DEFINE宏即可。

##include <msgpack.hpp> #include <vector> #include <string>  class my_class { private: 	std::string my_string; 	std::vector vec_int; 	std::vector vec_string; public: 	MSGPACK_DEFINE(my_string, vec_int, vec_string); };  int main() { 	std::vector<my_class> my_class_vec;  	// add some data  	msgpack::sbuffer buffer; 	msgpack::pack(buffer, my_class_vec);  	msgpack::unpacked msg; 	msgpack::unpack(&msg, buffer.data(), buffer.size());  	msgpack::object obj = msg.get(); 	std::vector<my_class> my_class_vec_r; 	obj.convert(&my_class_vec_r);  	return 0; }

这样我们就可以在网络通讯等地方可以使用msgpack来序列化我们的数据结构，完全可以做到安全高效，并且可以在接收方使用别的语言来处理结构做逻辑。完全是 多种语言-多种语言，现在支持的语言如下：

Ruby Perl Python C/C++ Java PHP JS OC C# Lua Scala D Haskell Erlang Ocaml Smallalk GO LabVIEW

完全够我们使用了，当然了，如果没有你要的语言，建议看源代码模仿一个。

关于性能测试结果可以查看：linux使用msgpack及测试 

Thrift是一个非常棒的工具，是Facebook的开源项目，目前的开发非常的活跃，由Apache管理，所以用的是Apache Software License，这非常重要，因为可以放心的对其修改并用到自己的项目中。

谈到修改Thrift,这非常重要。因为我觉得如果要严肃的使用Thrift，不可避免的要深入了解它，并几乎都要修改Thrift的代码。一个通信框架，它不可能帮你做到所有的事情，也不可能在不了解的情况下就贸然的使用。

1.Thrift 的Java Server/Client有个较为严重的bug(https://issues.apache.org/jira/browse/THRIFT-601 )，随机向thrift  sever的监听端口发些数据，可能会导致Server OutOfMemory，细细看看代码，这个bug有点土。

2.Thrift Client线程不安全，多线程下使用可能导致Server和客户端程序崩溃。Client的每次调用远程方法其实是有多次Socket写操作，因此每个线程中使用的Client要保证独立，如果多个线程混用同一个Client(其实是用同一个Socket)，可能会导致传输的字节顺序混乱，使得Server OutOfMemory(参考1）

3.Thrift定义数据结构时，尽量避免用map, 或者set。在cpp下, map被对应为std::map(rb tree)和std::set，thrift生成的类不会重载”<”，因此需要手动修改生成类，否则link没法通过。较为麻烦。

4.如果Client端基于效率考虑，要缓存Socket，需要重新实现其TTransport类，以支持 Socket缓存池。当然，这个实现其实跟thrift没多大关系，算是2次开发。但一般都要这么做的吧？

5.如果Client基于效率考虑，缓存了Socket，那么thrift Server端的模式选择就较为重要了。如果使用同步的TThreadPoolServer，那么无可避免的，客户端缓存1个Socket，Server端就会有一个线程一直处于Server状态，等待peek这个Socket上的数据。这个线程就不能用于其它请求了。所以，及时清理Client端的Socket及控制Socket池的大小是非常必要的。

6.听同事说CPP Thrift Server的Epoll NonBlocking模式有效率问题。其实，并发要求不高的Server用LT模式的EPoll其实很方便的，当然，这个要自己给Thrfit Server做patch了，不过也不麻烦。开发起来也是很方便的。我想给我们的Server加个EPOLLONESHOT的同步EPoll实现。

7.CPP下的 TThreadPoolServer和TThreadServer由一个有趣的问题，如果有客户端维护长连接，那么对这个Server实例做析构的时候会堵塞（前面说过了，在peek中…）。

8.用valgrind看，thrift cpp似乎有一些内存问题。没细看。

9.无论是Java，还是CPP，Server端都无法通过合法的方式获取Client的ip, port。可以通过编写ThriftServerEventHandler可以处理这件事情。如果想要获取Client ip, port的话，可以看看这个东西。

今年年初由于facebook而火起来的jemalloc广为人之，但殊不知，它在malloc界里面很早就出名了。Jemalloc的创始人Jason Evans也是在FreeBSD很有名的开发人员。此人就在2006年为提高低性能的malloc而写的jemalloc。Jemalloc是从2007年开始以FreeBSD标准引进来的。软件技术革新很多是FreeBSD发起的。在FreeBSD应用广泛的技术会慢慢导入到linux。

目前jemalloc在firefox中也在使用。在firefox2中出现了内存碎片问题之后，便在firefox3中使用了jemalloc。在safari和chrome中使用的是google的tcmalloc。

Jemalloc的技术特性

Jemalloc聚集了malloc的使用过程中所验证的很多技术。忽略细节，从架构着眼，最出色的部分仍是arena和thread cache。（事实上，这两个与tcmalloc的架构几乎相同。Jemalloc only的部分将会在另一次posting中继续探讨。）

Arena

与其像malloc一样集中管理一整块内存，不如将其分成许多个小块来分而治之。此小块便称为arena。让我们想象一下，给几个小朋友一张大图纸，让他们随意地画点。结果可想而知，他们肯定相互顾忌对方而不敢肆意地画（synchronization），从而影响画图效率。但是如果老师事先在大图纸上划分好每个人的区域，小朋友们就可以又快又准地在各自地领域上画图。这样的概念就是arena。

Thread cache

如果是开辟小块内存，为使不参照arena而直接malloc，给各自的线程thread cache领域。此idea是google的tcmalloc的核心部分，亦在jemalloc中体现。

再拿上面的例子，这次给小朋友们除了一张大图纸外，再各自给A4纸一张。这样，小朋友们在不画大面积的点时，只在自己的A4纸上心情地画即可（no arena seeking）。可以在自己手上的纸上画或涂（using thread cache），完全不用顾忌别人（no synchronization, no locking），迅速有效地画。

下图是jemalloc的核心layout。看着复杂，其实都是上面说明的部分。

实际jemalloc的性能呢？

最左边的就是glibc的malloc，最右边的就是jemalloc。从图表上可以看出，jemalloc的性能有glibc的两倍以上。非常压倒性的性能差异。因此，使用了jemalloc的应用程序自然会快很多。Jemalloc旁边的就是tcmalloc。Tcmalloc的性能与其相差甚微，低jemalloc2.1.0慢4.5%。图上和tcmalloc的1.4版本，而如今它已经到了1.6版本，因此实际上这两者应该是不相仲伯的。Jemalloc的创始人jason evans也意识到这一点，说在cpu core 8以上的计算机上jemalloc效率更高。

给程序员的最后的免费午餐 – kth分布式技术lab的实例      

2005年发表了一篇文章“免费午餐的时代结束了”。在之前，程序就算不用费脑子，随着cpu时钟速度增加，程序性能自己就会上去。但现在不同，现在cpu时钟趋于稳定，而核数不断地增加。程序员需要适应这样的多线程多进程的环境，并要开发出适合的程序。文章讲的大概是这样的内容。

6年之后的如今，这篇文章完全变成现实了。事实上cpu时钟停留在3GHz，而核不断上升。现在程序要适应多线程多进程的分布式计算，速度才能上升。但是这样的程序很难。

现在在多线程的环境下，给程序员们的最后一道午餐便是tcmalloc，jemalloc这样的malloc library。对于使用多线程的程序而言，性能会提高数十%。

共享一下我本人的经验。我本人在kth技术研究所分布式技术lab中承担iLock（分布式同步工具，请参考google的chubby）。在iLock中用了google的tcmalloc的结果，性能提升了18~22%。

最大的优点就是你不需要做任何复杂的工作便可得到这样的效果。不需要代码重编译。只需在执行二进制之前，在cmd窗口中输入

$ LD_PRELOAD=”tcmalloc所设置的文件夹/libtcmalloc.so”

这样在之后执行的应用程序会使用tcmalloc或jemalloc，从而代替glibc标准malloc（ptmalloc）。这需设置此处，我们便可得到性能20%的提升，这真可谓是送给我们的最后的免费午餐。

如今，在分布式技术lab中使用google的tcmalloc。原因在于性能上两者差不多，但google的tcmalloc所提供的程序分析工具非常（heap profiler, cpu profiler）丰富。所以tcmalloc可能更方便一些。

一定要使用最新的malloc么？一定要的！

Darts 既可以像 Hash 一样作为简单的词典使用，也能非常高效的执行分词词典中必须的 Common Prefix Search 操作。

自2003年7月起， 两个开源的日语分词系统 MeCab, ChaSen 都使用了 Darts .

下载

• Darts 是自由软件．遵循 LGPL(Lesser GNU General Public License) 和 BSD 协议, 可以修改后重新发布.

Source

• darts-0.32.tar.gz: HTTP

安装

% ./configure 
% make
% make check
% make install
然后在程序中  include /usr/local/include/darts.h  

使用方法

Darts 只提供了 darts.h 这个 C++ 模板文件。每次使用的时候 include 该文件即可.
使用这样的发布方式是希望通过内联函数实现高效率。

类接口

namespace Darts {

   template <class NodeType, class NodeUType class ArrayType, 
                class ArrayUType, class LengthFunc = Length<NodeType> >

   class DobuleArrayImpl
   {
    public:
     typedef ArrayType   result_type;
     typedef NodeType    key_type;

     DoubleArrayImpl();
     ~DoubleArrayImpl();

     int    set_array(void *ptr, size_t = 0);
     void   *array();
     void   clear();
     size_t size ();
     size_t unit_size ();
     size_t nonzero_size ();
     size_t total_size ();

     int build (size_t        key_size,
                key_type      **key,
                size_t        *len = 0,
                result_type   *val = 0,
                int (*pg)(size_t, size_t) = 0);

     int open (const char *file,
               const char *mode = "rb",
               size_t offset = 0,
               size_t _size = 0);

     int save (const char *file,
               const char *mode = "wb",
               size_t offset = 0);

     result_type exactMatchSearch (const key_type *key,
                                   size_t len = 0,
                                   size_t node_pos = 0)
      
     size_t commonPrefixSearch  (const key_type *key,
                                 result_type *result,
                                 size_t result_size,
                                 size_t len = 0,
                                 size_t node_pos = 0)

     result_type traverse (const key_type *key, 
                           size_t &node_pos, 
                           size_t &key_pos, 
                           size_t len = 0)
   };

   typedef Darts::DoubleArrayImpl<char, unsigned char,
              int, unsigned int> DoubleArray;
};

模板参数说明

typedef 说明

模板参数类型的别名. 在外部需要使用这些类型的时候使用 .

方法说明

int Darts::DoubleArrayImpl::build(size_t size, const key_type **str, const size_t *len = 0, const result_type *val = 0, int (*progress_func)(size_t, size_t) = 0)

构建 Double Array .

size 词典大小 (记录的词条数目),
str 指向各词条的指针 (共 size个指针)
len 用于记录各个词条的长度的数组(数组大小为 size)
val 用于保存各词条对应的 value 的数组 (数组大小为 size)
progress_func 构建进度函数.

str 的各个元素必须按照字典序排好序.
另外 val 数组中的元素不能有负值.
len, val, progress_func 可以省略,
省略的时候， len 使用 LengthFunc 计算,
val 的各元素的值为从 0 开始的计数值。 


构建成功，返回 0； 失败的时候返回值为负.
进度函数 progress_func 有两个参数.
第一个 size_t 型参数表示目前已经构建的词条数 
第二个 size_t 型参数表示所有的词条数 

result_type Darts::DoubleArrayImpl::exactMatchSearch(const key_type *key, size_t len = 0, size_t node_pos = 0)

进行精确匹配(exact match) 检索, 判断给定字符串是否为词典中的词条.

key 待检索字符串,
len 字符串长度,
node_pos 指定从 Double-Array 的哪个节点位置开始检索.

len, 和 node_pos 都可以省略, 省略的时候， len 缺省使用 LengthFunc 计算,
node_pos 缺省为 root 节点.

检索成功时， 返回 key 对应的 value 值, 失败则返回 -1. 

size_t Darts::DoubleArrayImpl::commonPrefixSearch (const key_type *key, result_type *result, size_t result_size, size_t len = 0, size_t node_pos = 0)

执行 common prefix search. 检索给定字符串的哪些的前缀是词典中的词条

key 待检索字符串,
result 用于保存多个命中结果的数组,
result_size 数组 result 大小,
len 待检索字符串长度,
node_pos 指定从 Double-Array 的哪个节点位置开始检索.

len, 和 node_pos 都可以省略, 省略的时候， len 缺省使用 LengthFunc 计算,
node_pos 缺省为 root 节点.

函 数返回命中的词条个数. 对于每个命中的词条， 词条对应的 value 值存依次放在 result 数组中. 如果命中的词条个数超过 result_size 的大小， 则 result 数组中只保存 result_size 个结果。函数的返回值为实际的命中词条个数， 可能超过 result_size 的大小。 

result_t Darts::DoubleArrayImpl::traverse (const key_type *key, size_t &node_pos, size_t &key_pos, size_t len = 0)

traverse Trie， 检索当前字符串并记录检索后到达的位置 

key 待检索字符串,
node_pos 指定从 Double-Array 的哪个节点位置开始检索.
key_pos 从待检索字符串的哪个位置开始检索
len 待检索字符串长度,

该函数和 exactMatchSearch 很相似. traverse 过程是按照检索串 key 在 TRIE 的节点中进行转移.
但是函数执行后, 可以获取到最后到达的 Trie 节点位置，最后到达的字符串位置 . 这和 exactMatchSearch 是有区别的. 

node_pos 通常指定为 root 位置 (0) . 函数调用后， node_pos 的值记录最后到达的 DoubleArray 节点位置。 
key_pos 通常指定为 0. 函数调用后， key_pos 保存最后到达的字符串 key 中的位置。 

检索失败的时候， 返回 -1 或者 -2 .
-1 表示再叶子节点失败, -2 表示在中间节点失败,.
检索成功的时候， 返回 key 对应的 value. 

int Darts::DoubleArrayImpl::save(const char *file, const char *mode = "wb", size_t offset = 0)

把 Double-Array 保存为文件.

file 保存文件名,
mode 文件打开模式 
offset 保存的文件位置偏移量, 预留将来使用， 目前没有实现 .

成功返回 0 ， 失败返回 -1 

int Darts::DoubleArrayImpl::open (const char *file, const char *mode = "rb", size_t offset = 0, size_t size = 0)

读入 Double-Array 文件.

file 读取文件名,
mode 文件打开模式 
offset 读取的文件位置偏移量 

size 为 0 的时候, size 使用文件的大小 .

成功返回 0 ， 失败返回 -1 

size_t Darts::DoubleArrayImpl::size()

返回 Double-Array 大小. 

size_t Darts::DoubleArrayImpl::unit_size()

Double-Array 一个元素的大小(byte).

size() * unit_size() 是, 存放 Double-Array 所需要的内存(byte) 大小. 

size_t Darts::DoubleArrayImpl::nonzero_size()

Double-Array 的所有元素中， 被使用的元素的数目, .
nonezero_size()/size() 用于计算压缩率. 

例子程序

从静态词典构建双数组 Double-Array.

#include <iostream>
#include <darts.h>

int main (int argc, char **argv)
{
  using namespace std;

  Darts::DoubleArray::key_type   *str[] = { "ALGOL", "ANSI", "ARCO",  "ARPA", "ARPANET", "ASCII" }; // same as char*
  Darts::DobuleArray::result_type val[] = { 1, 2, 3, 4, 5, 6 }; // same as int 

  Darts::DoubleArray da;
  da.build (6, str, 0, val); 

  cout << da.exactMatchSearch("ALGOL") << endl;
  cout << da.exactMatchSearch("ANSI") << endl;
  cout << da.exactMatchSearch("ARCO") << endl;;
  cout << da.exactMatchSearch("ARPA") << endl;;
  cout << da.exactMatchSearch("ARPANET") << endl;;
  cout << da.exactMatchSearch("ASCII") << endl;;
  cout << da.exactMatchSearch("APPARE") << endl;

  da.save("some_file");
}

执行结果
1
2
3
4
5
6
-1

从标准输入读取字符串, 对 Double-Array 执行 Common Prefix Search

#include <iostream>
#include <string>
#include <algorithm>
#include <darts.h>

int main (int argc, char **argv)
{
  using namespace std;

  Darts::DoubleArray da;
  if (da.open("some_file") == -1) return -1;

  Darts::DoubleArray::result_type  r [1024];
  Darts::DoubleArray::key_type     buf [1024];

  while (cin.getline (buf, 1024)) {
    size_t result = da.commonPrefixSearch(buf, r, 1024);
    if (result == 0) {
       cout << buf << ": not found" << endl;
    } else {
       cout << buf << ": found, num=" << result << " ";
       copy (r, r + result, ostream_iterator<Darts::DoubleArray::result_type>(cout, " "));
       cout << endl;
    }
  }

  return 0;
}

付属程序说明

mkdarts

% ./mkdarts DictionaryFile DoubleArrayFile 

darts

% ./darts DoubleArrayFile 

使用 DoubleArrayFile 做 common prefix search .

使用例子

% cd tests
% head -10 linux.words
ALGOL
ANSI
ARCO
ARPA
ARPANET
ASCII
 .. 

% ../mkdarts linux.words dar
Making Double Array: 100% |*******************************************|
Done!, Compression Ratio: 94.6903 %

% ../darts dar
Linux
Linux: found, num=2 3697 3713
Windows
Windows: not found
LaTeX
LaTeX: found, num=1 3529

参考文献, 链接

• [Aoe1989] Aoe, J. An Efficient Digital Search Algorithm by Using a Double-Array Structure. IEEE Transactions on Software Engineering. Vol. 15, 9 (Sep 1989). pp. 1066-1077.
• [Datrie] Theppitak Karoonboonyanan An Implementation of Double-Array Triehttp://www.links.nectec.or.th/~thep/datrie/
• [単語と辞書] 松本裕治 ほか. 単語と辞書 岩波講座言語の科学 Vol.3 pp.79-81

Linux下GDB调试

One major aspect of system programming is to handle memory related issues effectively. The more you work close to the system, the more memory related issues you need to face.

Sometimes these issues are very trivial while many times it becomes a nightmare to debug memory related issues. So, as a practice many tools are used for debugging memory related issues.

In this article, we will discuss the most popular open source memory management framework VALGRIND.

From Valgrind.org :

Valgrind is an instrumentation framework for building dynamic analysis tools. It comes with a set of tools each of which performs some kind of debugging, profiling, or similar task that helps you improve your programs. Valgrind’s architecture is modular, so new tools can be created easily and without disturbing the existing structure.

A number of useful tools are supplied as standard.

1. Memcheck is a memory error detector. It helps you make your programs, particularly those written in C and C++, more correct.
2. Cachegrind is a cache and branch-prediction profiler. It helps you make your programs run faster.
3. Callgrind is a call-graph generating cache profiler. It has some overlap with Cachegrind, but also gathers some information that Cachegrind does not.
4. Helgrind is a thread error detector. It helps you make your multi-threaded programs more correct.
5. DRD is also a thread error detector. It is similar to Helgrind but uses different analysis techniques and so may find different problems.
6. Massif is a heap profiler. It helps you make your programs use less memory.
7. DHAT is a different kind of heap profiler. It helps you understand issues of block lifetimes, block utilisation, and layout inefficiencies.
8. SGcheck is an experimental tool that can detect overruns of stack and global arrays. Its functionality is complementary to that of Memcheck: SGcheck finds problems that Memcheck can’t, and vice versa..
9. BBV is an experimental SimPoint basic block vector generator. It is useful to people doing computer architecture research and development.

There are also a couple of minor tools that aren’t useful to most users: Lackey is an example tool that illustrates some instrumentation basics; and Nulgrind is the minimal Valgrind tool that does no analysis or instrumentation, and is only useful for testing purposes.

Here in this article we will focus on the tool ‘memcheck’.

Using Valgrind Memcheck

The memcheck tool is used as follows :

valgrind --tool=memcheck ./a.out

As clear from the command above, the main binary is ‘Valgrind’ and the tool which we want to use is specified by the option ‘–tool’. The ‘a.out’ above signifies the executable over which we want to run memcheck.

This tool can detect the following memory related problems :

• Use of uninitialized memory
• Reading/writing memory after it has been freed
• Reading/writing off the end of malloc’d blocks
• Memory leaks
• Mismatched use of malloc/new/new[] vs free/delete/delete[]
• Doubly freed memory

Note : The above list is not exhaustive but contains the popular problems detected by this tool.

Lets discuss the above scenarios one by one:

Note : All the test code described below should be compiled using gcc with -g option(to generate line numbers in memcheck output) enabled. As we discussed earlier for a C program to get compiled into an executable, it has to go through 4 different stages.

1. Use of uninitialized memory

Code :

#include <stdio.h> #include <stdlib.h>   int main(void) {     char *p;       char c = *p;       printf("\n [%c]\n",c);       return 0; }

In the above code, we try to use an uninitialized pointer ‘p’.

Lets run memcheck and see the result.

$ valgrind --tool=memcheck ./val ==2862== Memcheck, a memory error detector ==2862== Copyright (C) 2002-2009, and GNU GPL'd, by Julian Seward et al. ==2862== Using Valgrind-3.6.0.SVN-Debian and LibVEX; rerun with -h for copyright info ==2862== Command: ./val ==2862== ==2862== Use of uninitialised value of size 8 ==2862==    at 0x400530: main (valgrind.c:8) ==2862==  [#] ==2862== ==2862== HEAP SUMMARY: ==2862==     in use at exit: 0 bytes in 0 blocks ==2862==   total heap usage: 0 allocs, 0 frees, 0 bytes allocated ==2862== ==2862== All heap blocks were freed -- no leaks are possible ==2862== ==2862== For counts of detected and suppressed errors, rerun with: -v ==2862== Use --track-origins=yes to see where uninitialized values come from ==2862== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 4 from 4)

As seen from the output above, Valgrind detects the uninitialized variable and gives a warning(see the lines in bold above).

2. Reading/writing memory after it has been freed

Code :

#include <stdio.h> #include <stdlib.h>   int main(void) {     char *p = malloc(1);     *p = 'a';       char c = *p;       printf("\n [%c]\n",c);       free(p);     c = *p;     return 0; }

In the above piece of code, we have freed a pointer ‘p’ and then again we have tried to access the value help by the pointer.

Lets run memcheck and see what Valgrind has to offer for this scenario.

$ valgrind --tool=memcheck ./val ==2849== Memcheck, a memory error detector ==2849== Copyright (C) 2002-2009, and GNU GPL'd, by Julian Seward et al. ==2849== Using Valgrind-3.6.0.SVN-Debian and LibVEX; rerun with -h for copyright info ==2849== Command: ./val ==2849==    [a] ==2849== Invalid read of size 1 ==2849==    at 0x400603: main (valgrind.c:30) ==2849==  Address 0x51b0040 is 0 bytes inside a block of size 1 free'd ==2849==    at 0x4C270BD: free (vg_replace_malloc.c:366) ==2849==    by 0x4005FE: main (valgrind.c:29) ==2849== ==2849== ==2849== HEAP SUMMARY: ==2849==     in use at exit: 0 bytes in 0 blocks ==2849==   total heap usage: 1 allocs, 1 frees, 1 bytes allocated ==2849== ==2849== All heap blocks were freed -- no leaks are possible ==2849== ==2849== For counts of detected and suppressed errors, rerun with: -v ==2849== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 4 from 4)

As seen in the output above, the tool detects the invalid read and prints the warning ‘Invalid read of size 1′.

On a side note, to debug a c program use gdb.

3. Reading/writing off the end of malloc’d blocks

Code :

#include <stdio.h> #include <stdlib.h>   int main(void) {     char *p = malloc(1);     *p = 'a';       char c = *(p+1);       printf("\n [%c]\n",c);       free(p);     return 0; }

In the above piece of code, we have allocated 1 byte for ‘p’ but we access the the address p+1 while reading the value into ‘c’.

Now we run Valgrind on this piece of code :

$ valgrind --tool=memcheck ./val ==2835== Memcheck, a memory error detector ==2835== Copyright (C) 2002-2009, and GNU GPL'd, by Julian Seward et al. ==2835== Using Valgrind-3.6.0.SVN-Debian and LibVEX; rerun with -h for copyright info ==2835== Command: ./val ==2835== ==2835== Invalid read of size 1 ==2835==    at 0x4005D9: main (valgrind.c:25) ==2835==  Address 0x51b0041 is 0 bytes after a block of size 1 alloc'd ==2835==    at 0x4C274A8: malloc (vg_replace_malloc.c:236) ==2835==    by 0x4005C5: main (valgrind.c:22) ==2835==    [] ==2835== ==2835== HEAP SUMMARY: ==2835==     in use at exit: 0 bytes in 0 blocks ==2835==   total heap usage: 1 allocs, 1 frees, 1 bytes allocated ==2835== ==2835== All heap blocks were freed -- no leaks are possible ==2835== ==2835== For counts of detected and suppressed errors, rerun with: -v ==2835== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 4 from 4)

Again, this tool detects the invalid read done in this case.

4. Memory leaks

Code:

#include <stdio.h> #include <stdlib.h>   int main(void) {     char *p = malloc(1);     *p = 'a';       char c = *p;       printf("\n [%c]\n",c);       return 0; }

In this code, we have malloced one byte but haven’t freed it. Now lets run Valgrind and see what happens :

$ valgrind --tool=memcheck --leak-check=full ./val ==2888== Memcheck, a memory error detector ==2888== Copyright (C) 2002-2009, and GNU GPL'd, by Julian Seward et al. ==2888== Using Valgrind-3.6.0.SVN-Debian and LibVEX; rerun with -h for copyright info ==2888== Command: ./val ==2888==    [a] ==2888== ==2888== HEAP SUMMARY: ==2888==     in use at exit: 1 bytes in 1 blocks ==2888==   total heap usage: 1 allocs, 0 frees, 1 bytes allocated ==2888== ==2888== 1 bytes in 1 blocks are definitely lost in loss record 1 of 1 ==2888==    at 0x4C274A8: malloc (vg_replace_malloc.c:236) ==2888==    by 0x400575: main (valgrind.c:6) ==2888== ==2888== LEAK SUMMARY: ==2888==    definitely lost: 1 bytes in 1 blocks ==2888==    indirectly lost: 0 bytes in 0 blocks ==2888==      possibly lost: 0 bytes in 0 blocks ==2888==    still reachable: 0 bytes in 0 blocks ==2888==         suppressed: 0 bytes in 0 blocks ==2888== ==2888== For counts of detected and suppressed errors, rerun with: -v ==2888== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 4 from 4)

The lines (in bold above) shows that this tool was able to detect the leaked memory.

Note: In this case we added an extra option ‘–leak-check=full’ to get verbose details of the memory leak.

5. Mismatched use of malloc/new/new[] vs free/delete/delete[]

Code:

#include <stdio.h> #include <stdlib.h> #include<iostream>   int main(void) {     char *p = (char*)malloc(1);     *p = 'a';       char c = *p;       printf("\n [%c]\n",c);     delete p;     return 0; }

In the above code, we have used malloc() to allocate memory but used delete operator to delete the memory.

Note : Use g++ to compile the above code as delete operator was introduced in C++ and to compile c++ code, g++ tool is used.

Lets run this tool and see :

$ valgrind --tool=memcheck --leak-check=full ./val ==2972== Memcheck, a memory error detector ==2972== Copyright (C) 2002-2009, and GNU GPL'd, by Julian Seward et al. ==2972== Using Valgrind-3.6.0.SVN-Debian and LibVEX; rerun with -h for copyright info ==2972== Command: ./val ==2972==    [a] ==2972== Mismatched free() / delete / delete [] ==2972==    at 0x4C26DCF: operator delete(void*) (vg_replace_malloc.c:387) ==2972==    by 0x40080B: main (valgrind.c:13) ==2972==  Address 0x595e040 is 0 bytes inside a block of size 1 alloc'd ==2972==    at 0x4C274A8: malloc (vg_replace_malloc.c:236) ==2972==    by 0x4007D5: main (valgrind.c:7) ==2972== ==2972== ==2972== HEAP SUMMARY: ==2972==     in use at exit: 0 bytes in 0 blocks ==2972==   total heap usage: 1 allocs, 1 frees, 1 bytes allocated ==2972== ==2972== All heap blocks were freed -- no leaks are possible ==2972== ==2972== For counts of detected and suppressed errors, rerun with: -v ==2972== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 4 from 4)

We see from the output above (see lines in bold), the tool clearly states ‘Mismatched free() / delete / delete []‘

You can try and use the combination ‘new’ and ‘free’ in a test code and see what result this tool gives.

6. Doubly freed memory

Code :

#include <stdio.h> #include <stdlib.h>   int main(void) {     char *p = (char*)malloc(1);     *p = 'a';       char c = *p;     printf("\n [%c]\n",c);     free(p);     free(p);     return 0; }

In the above peice of code, we have freed the memory pointed by ‘p’ twice. Now, lets run the tool memcheck :

$ valgrind --tool=memcheck --leak-check=full ./val ==3167== Memcheck, a memory error detector ==3167== Copyright (C) 2002-2009, and GNU GPL'd, by Julian Seward et al. ==3167== Using Valgrind-3.6.0.SVN-Debian and LibVEX; rerun with -h for copyright info ==3167== Command: ./val ==3167==    [a] ==3167== Invalid free() / delete / delete[] ==3167==    at 0x4C270BD: free (vg_replace_malloc.c:366) ==3167==    by 0x40060A: main (valgrind.c:12) ==3167==  Address 0x51b0040 is 0 bytes inside a block of size 1 free'd ==3167==    at 0x4C270BD: free (vg_replace_malloc.c:366) ==3167==    by 0x4005FE: main (valgrind.c:11) ==3167== ==3167== ==3167== HEAP SUMMARY: ==3167==     in use at exit: 0 bytes in 0 blocks ==3167==   total heap usage: 1 allocs, 2 frees, 1 bytes allocated ==3167== ==3167== All heap blocks were freed -- no leaks are possible ==3167== ==3167== For counts of detected and suppressed errors, rerun with: -v ==3167== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 4 from 4)

As seen from the output above(lines in bold), the tool detects that we have called free twice on the same pointer.

In this article, we concentrated on memory management framework Valgrind and used the tool memcheck (provided by this framework) to describe how it makes life easy for a developer working close to memory. This tool can detect many memory related problems that are very hard to find manually.

一、前言
以前写过一些使用C语言来扩展PHP的应用[1]。在淘宝使用C++做PHP的扩展做项目的过程中，遇到了一些问题，从Google中查找，使用C++来开发PHP的中文文章少之又少，而且没有一个手册来告诉用户怎么写m4[2]文件，怎么使用zend[3]引擎的一套api函数去写相关PHP的接口，这里就怎么用C++语言来开发PHP的一些心得介绍给大家，希望有心人能够有所收获；
二、为什么要用C++开发PHP
使用C++比用C语言开发PHP主要有2个好处：
使用C++能够很方便的操作string类型，本身的一些容器和模板[4]、以及面对对象的功能让开发者能够节省大量开发的时间，这是比较重要的一点；
C++可以直接使用C的库，只需要extern “C” {}将其C的头文件和库定义包含起来就可以，不需要太多的移植工作，可以重复利用前人的代码或者库进行后续的工作；
用C++开发PHP是快速、迅捷的，熟悉了相关的定义以及语法，相信开发PHP不是难事。

三、书写config文件

config.m4[5]或config.w32[6]文件是编译基础中最核心的文件，这个文件主要是用autoconf[7]来产生configure[8]配置文件，继而自动生成大家所熟悉的Makefile文件，以Linux系统为例：

你可以自己书写config.m4文件，也可以由Shell脚本 ext_skel[9] 来生成样板：
[cnangel@localhost ~]$wget http://docs.php.net/get/php-5.2.5.tar.bz2/from/cn.php.net/mirror
[cnangel@localhost ~]$tar -jxf php-5.2.5.tar.bz2
[cnangel@localhost ~]$cd php-5.2.6/ext
[cnangel@localhost ext]./ext_skel –extname=extern_name

接着你会发现在ext目录下多了一个叫extern_name的目录。进入该目录，会发现目录下有几个文件：
[cnangel@localhost ext_name]$ls -l
总计 32
-rw-r–r– 1 cnangel cnangel 2103 06-29 19:00 config.m4
-rw-r–r– 1 cnangel cnangel 310 06-29 19:00 config.w32
-rw-r–r– 1 cnangel cnangel 8 06-29 19:00 CREDITS
-rw-r–r– 1 cnangel cnangel 0 06-29 19:00 EXPERIMENTAL
-rw-r–r– 1 cnangel cnangel 5305 06-29 19:00 ext_name.c
-rw-r–r– 1 cnangel cnangel 508 06-29 19:00 ext_name.php
-rw-r–r– 1 cnangel cnangel 2766 06-29 19:00 php_ext_name.h
drwxr-xr-x 2 cnangel cnangel 4096 06-29 19:00 tests

然后可以根据提示来修改config.m4文件，这里有几个重要的宏命令如下：
dnl 是注释；
PHP_ARG_WITH 或者 PHP_ARG_ENABLE 指定了PHP扩展模块的工作方式，前者意味着不需要第三方库，后者正好相反；
PHP_REQUIRE_CXX 用于指定这个扩展用到了C++；
PHP_ADD_INCLUDE 指定PHP扩展模块用到的头文件目录；
PHP_CHECK_LIBRARY 指定PHP扩展模块PHP_ADD_LIBRARY_WITH_PATH定义以及库连接错误信息等；
PHP_ADD_LIBRARY(stdc++,”",EXTERN_NAME_LIBADD)用于将标准C++库链接进入扩展
PHP_SUBST(EXTERN_NAME_SHARED_LIBADD) 用于说明这个扩展编译成动态链接库的形式；
PHP_NEW_EXTENSION 用于指定有哪些源文件应该被编译,文件和文件之间用空格隔开；

ext_skel默认生成的模块框架是针对C的,我们要使用C++进行PHP扩展, 那除以上的PHP_REQUIRE_CXX, PHP_ADD_LIBRARY两个宏必需外，还要把extern_name.c改名成extern_name.cpp。

需要注意的是，在config.m4里面可以使用类似的Makefile语法，片段如下：
PHP_REQUIRE_CXX()
INCLUDES=”$INCLUDES `mysql_config –cflags`”
PHP_ADD_LIBRARY(stdc++, “”, EXTRA_LDFLAGS)
EXTRA_LDFLAGS=”$EXTRA_LDFLAGS `mysql_config –libs` -lmemcached”
AC_CHECK_HEADERS([mysql/mysql.h])
CPPFILE=”ext_name.cpp antiForbitWord.cpp antiBaseDict.cpp Trie.cpp Logger.cpp antiEncodeConverter.cpp strnormalize.cpp”
PHP_NEW_EXTENSION(ext_name, $CPPFILE, $ext_shared)
四、书写.h文件

这里指修改php_ext_name.h这个头文件。

由于TSRM.h这个文件所包含的函数和类都是用纯C语言写的，故应该使用extern来说明如下：
extern “C” {
#ifdef ZTS
#include “TSRM.h”
#endif
}

如果该php_ext_name.h头文件或者ext_name.cpp文件用到了C++语言中的一些容器或者一些函数，则需要在头文件中包含相应的c++库的头文件，否则会出现找不到相应的C++函数错误。
五、书写.cpp文件

这里指修改ext_name.cpp这个cpp文件。

由于config.h、php.h、php_ini.h和ext/standard/info.h中包含的函数和类如TSRM.h一样，都是用纯C语言写的，所以也需要用extern说明如下：
extern “C” {
#ifdef HAVE_CONFIG_H
#include “config.h”
#endif
#include “php.h”
#include “php_ini.h”
#include “ext/standard/info.h”
}

而 #include “php_ext_name.h” 这句则已经不需要包含在extern “C”内，另外，ZEND_GET_MODULE这个宏命令也是需要特别申明如下：
#ifdef COMPILE_DL_EXT_NAME
BEGIN_EXTERN_C()
ZEND_GET_MODULE(ext_name)
END_EXTERN_C()
#endif

总之，把一些C写的库或轰用兼容的方式给解决。
六、初步执行

这里需要用到一个命令：phpize[10]，命令如下：
[cnangel@localhost ext_name]$phpize
[cnangel@localhost ext_name]$./configure
[cnangel@localhost ext_name]$make

注意：可以使用用phpize生成configure执行文件后，可以使用./configure –help查看帮助信息，修改config.m4文件可以修改configure的帮助信息。每次修改了config.m4文件，需要使用清除临时文件 命令phpize –clean来完成消除configure。
七、初步应用

怎么应用到php上，把刚才的扩展模块当作一个普通的php函数调用呢？简单的应用直接使用命令：
[cnangel@localhost ext_name]$sudo make install

如果有多个php版本，则寻找扩展库目录显得没有那么好找了，比如，你的php执行文件的路径在/usr/local/php/bin/目录下，想知道php扩展模块所在的目录的话，那么执行(PHP5.0以上)：
[cnangel@localhost ext_name]$/usr/local/php/bin/php-config | grep extension-dir | sed ’s/.*\[\(.*\)]/\1/’`

PHP5.0以下执行：
[cnangel@localhost ext_name]$/usr/local/php/bin/php-config –extension-dir

这样你可以发现你的扩展库的路径：
/usr/local/php/lib/php/extensions/no-debug-non-zts-20060613

当然，你可以修改php.ini，找到php安装的配置文件，修改extension_dir的值为你想要的一个路径另外，需要将你的扩展写入php.ini，像这样：

extension=ext_name.so

最后，找到扩展库的路径后，将modules下面的extern_name.so文件复制到扩展库的目录下，重新启动一下Apache进程：
[cnangel@localhost ext_name]$which httpd
/usr/bin/httpd
[cnangel@localhost ext_name]$sudo /usr/bin/httpd -k stop
[cnangel@localhost ext_name]$sudo /usr/bin/httpd -k start

把这个样例ext_name.php复制到web路径上去，看看是否好使啦？下一节我们将详细讲一些Zend API的宏在ext_name.cpp中的一些复杂应用。

——————————————————————————-
（二）

这里主要讲述在PHP及Zend框架下怎么使用Zend API和C++语言来实现自己所要的功能以及项目的开发。
此篇文章所运用的环境在Linux 2.4.21-4.ELsmp(Red Hat Linux
3.2.3-20)，Apache/2.2.8，gcc version 3.2.3 20030502，PHP 5.2.5 (cli)，Zend
Engine v2.2.0下进行。
前言

上次我们说到使用c++写一个完整的php扩展，这里以ext_name模块为例复习一下：

首先仍然修改config.m4文件，由于没有引用外面的模块或者相关库，所以不需要使用PHP_ARG_WITH的方式，使用PHP_ARG_ENABLE方式。找到
PHP_NEW_EXTENSION(ext_name, ext_name.c, $ext_shared)

修改成
PHP_REQUIRE_CXX()
PHP_ADD_LIBRARY(stdc++, “”, EXTRA_LDFLAGS)
PHP_NEW_EXTENSION(ext_name, ext_name.cpp, $ext_shared)

并将ext_name.c重新命名为ext_name.cpp，接着修改其内容，将
#include “php.h”
#include “php_ini.h”
#include “ext/standard/info.h”

用extern “C”将其用大括号括起来，修改
ZEND_GET_MODULE(ext_name)

为
BEGIN_EXTERN_C()
ZEND_GET_MODULE(ext_name)
END_EXTERN_C()

到此为止，这就是我们第一章内容，第二章比较庞大，这里还是分节来叙述吧。
概述

概述里面主要简单介绍PHP扩展中的一些大致结构和需要注意的事项，做过C扩展PHP的都会知道 PHP_FE是一个宏把这个宏标识的函数，例如：helloworld，这个函数可以直接作用于PHP解释器，比如
< ?php
helloworld();
?>

安装ext_name样板后，系统会自动有一个函数confirm_ext_name_compiled，这个函数是可以自行修改的，当然，PHP_FE可以定义多个函数，这些函数都必须在之前进行申明，一般在php_ext_name.h头文件进行申明。

我们还知道，仅仅有头文件和PHP_FE宏来申明这个函数是不行的，这个函数还没有内容，怎么编写这个函数的内容呢？这个在接下来会讲到。

其实，稍微细心的人看了ext_name.cpp就知道，去掉注释后，还有很多的宏命令，比如zend_module_entry、ZEND_GET_MODULE、PHP_MINIT_FUNCTION等等，读者不要着急，下面会一一道来。

关于ext_name.cpp文件中一些变量的命名，通常是PHP模块名（eg:ext_name）前面或者后面有一串字符，比如 le_ext_name、ext_name_functions、这是一种习惯，最好我们在书写的时候遵循这种习惯，这样写出来的代码不仅仅让你自己明 白，让其他的开发人员也能够很快熟悉你的代码。通常一些定义的常量会大写，比如要定义这个模块的名字和版本，可以在头文件中添加：
#define PHP_EXT_NAME_EXTNAME “ext_name”
#define PHP_EXT_NAME_VERSION “0.1″

然后修改ext_name_module_entry的内容，将”ext_name”和”0.1″分别用PHP_EXT_NAME_EXTNAME和PHP_EXT_NAME_VERSION来替换，这样具有方便且通用。

如果你可能在代码中可能需要用到stl之类的或者c++的一些库，那么你可以在ext_name.cpp文件中添加
#ifndef __APP_CPP__
#define __APP_CPP__
#include
#include
#include
/*
#include
#include #include
#include

引用一句经典的原文来说明PHP和Zend API之间的关系
PHP的核心由两部分组成。最底层是Zend引擎（ZE）。ZE把人类易读的脚本解析成机器可读的符号，
然后在进程空间内执行这些符号。ZE也处理内存管理、变量作用域及调度程序调用。另一部分是PHP内核，
它绑定了SAPI层（Server Application Programming Interface，通常涉及主机环境，如Apache，IIS，CLI，CGI等），
并处理与它的通信。它同时对safe_mode和open_basedir的检测提供一致的控制层，就像流层将fopen()、fread()和
fwrite()等用户空间的函数与文件和网络I/O联系起来一样。
模块信息

模块信息主要体现在ext_name_module_entry结构上，它包含了

1, 标准模块的头

通常用 “STANDARD_MODULE_HEADER” 来填充，它指定了模块的四个成员：
标识整个模块结构大小的 size
值为 ZEND_MODULE_API_NO 常量的 zend_api
标识是否为调试版本（使用 ZEND_DEBUG 进行编译）的 zend_debug
还有一个用来标识是否启用了 ZTS （Zend 线程安全，使用 ZTS 或USING_ZTS 进行编译）的 zts。

2, 模块名称

模块名称这个名字就是使用 phpinfo() 函数后在“Additional Modules”部分所显示的名称。

3, PHP扩展可用到的函数或类

zend函数块的指针

4, 模块启动函数

5, 模块关闭函数

6, 请求启动函数

7, 请求关闭函数

8, 模块信息函数

9, 模块的版本号

10,　其它结构元素

原文：http://my.huhoo.net/archives/2008/02/php_ip.html#1
参考：
快速开发一个PHP扩展：http://blog.csdn.net/heiyeshuwu/archive/2008/12/05/3453854.aspx
如何编写PHP扩展：http://blog.csdn.net/taft/archive/2006/02/10/596291.aspx

cd /php5.2.5/ext

生成骨架 ./ext_skel --extname=cltest 会在当前目录建立一个cltest的目录

进入该目录 cd cltest

修改 配置文件config.m4
vi cltest/config.m4 

注释3个dnl [dnl代表注释,对应shell的#]
PHP_ARG_WITH(my_module, for my_module support,
Make sure that the comment is aligned:
[ --with-my_module Include my_module support])

修改完毕。

vi cltest.c
改成这样:
function_entry my_module_functions[] = {
PHP_FE(say_hello, NULL) /* ?添加这一行代码   注册函数say_hello() */
PHP_FE(confirm_my_module_compiled, NULL) /* For testing, remove later. */
{NULL, NULL, NULL} /* Must be the last line in my_module_functions[] */
};

另外在文件的最后添加下列代码 函数程序主体
PHP_FUNCTION(say_hello)
{
        RETURN_STRINGL("hello world",100,1);
}

修改完毕。

vi php_cltest.h

在文件中PHP_FUNCTION(confirm_my_module_compiled);一行前面添加下面的代码 函数定义
PHP_FUNCTION(say_hello);

修改完毕。

找到这个执行文件phpize ，在cltest目录下执行命令，用于加载动态链接库

/usr/local/php/bin/phpize
./configure --enable-cltest --with-apxs2=/usr/local/apache2/bin/apxs --with-php-config=/usr/local/php/bin/php-config

make
会在当前的目录下生成一个目录叫modules他的下面就放着你要的cltest.so文件

make install
会cp modules/cltest.so /usr/local/php/include/php/ext/
其余的就是修改 php.ini加载该.so webserver要生效需要重启。

/**************************************  Filename    : get string length  Description  :   Author      : HCJ  Date        : 2006/5/7  **************************************/  #include<stdio.h>  #include<assert.h>  int Strlen(char *pStr)  {      unsigned long ulLength;      assert(NULL != pStr);      ulLength = 0;      while(*pStr++)      {          ulLength++;      }      return ulLength;  }

**********************************************  Fileneme: mystrnlen.c  Description: get input string length,if string large               max length input return max length,               else real length  Author: HCJ  Date  : 2006-5-7  **********************************************/  #include<stdio.h>  #include<assert.h>  int StrNlen(char *pStr, unsigned long ulMaxLen)  {      unsigned long ulLength;      assert(NULL != pStr);      if(ulMaxLen <= 0)      {          printf("Wrong Max Length!\n");          return -1;      }      ulLength = 0;      while(*pStr++ &&  ulLength < ulMaxLen)      {          ulLength++;      }      return ulLength;  }

/*****************************************  FileName: main.c  Description: test static/dynamic library  Author: HCJ  Date  : 2005-5-7  ******************************************/  #include<stdio.h>  #include <String.h>   //静态库对应函数的头文件  int main(int argc, char* argv[])  {      char str[] = {"hello world"};      unsigned long ulLength = 0;      printf("The string is : %s\n", str);      ulLength = Strlen(str);      printf("The string length is : %d(use Strlen)\n", ulLength);      ulLength = StrNlen(str, 10);      printf("The string length is : %d(use StrNlen)\n", ulLength);      return 0;  }

/*****************************************  FileName: main2.c  Description: test static/dynamic library  Author: HCJ  Date  : 2005-5-7  ******************************************/  #include<stdio.h>  #include<dlfcn.h>  int main(int argc, char* argv[])  {      //define function pointor      int (*pStrlenFun)(char* pStr);     //声明对应的函数的函数指针      int (*pStrnlenFun)(char* pStr, int ulMaxLen);      char str[] = {"hello world"};      unsigned long ulLength = 0;      void *pdlHandle;      char *pszErr;      pdlHandle = dlopen("./libstr.so", RTLD_LAZY);  //加载链接库/libstr.so      if(!pdlHandle)      {          printf("Failed load library\n");      }      pszErr = dlerror();      if(pszErr != NULL)      {          printf("%s\n", pszErr);          return 0;      }      //get function from lib      pStrlenFun = dlsym(pdlHandle, "Strlen"); //获取函数的地址      pszErr = dlerror();      if(pszErr != NULL)      {          printf("%s\n", pszErr);          return 0;      }      pStrnlenFun = dlsym(pdlHandle, "StrNlen");      pszErr = dlerror();      if(pszErr != NULL)      {          printf("%s\n", pszErr);          return 0;      }      printf("The string is : %s\n", str);      ulLength = pStrlenFun(str);   //调用相关的函数      printf("The string length is : %d(use Strlen)\n", ulLength);      ulLength = pStrnlenFun(str, 10);      printf("The string length is : %d(use StrNlen)\n", ulLength);   dlclose(pdlHandle);      return 0;  }

gcc -o mian2 -ldl main2.c 

用gcc编译对应的源文件生成可执行文件，-ldl选项，表示生成的对象模块需要使用共享库。执行对应得文件同样可以得到正确的结果。 
相关函数的说明如下： 
(1)dlopen() 
第一个参数：指定共享库的名称，将会在下面位置查找指定的共享库。 
－环境变量LD_LIBRARY_PATH列出的用分号间隔的所有目录。 
－文件/etc/ld.so.cache中找到的库的列表，用ldconfig维护。 
－目录usr/lib。 
－目录/lib。 
－当前目录。 
第二个参数：指定如何打开共享库。 
－RTLD_NOW：将共享库中的所有函数加载到内存 
－RTLD_LAZY：会推后共享库中的函数的加载操作，直到调用dlsym()时方加载某函数 
(2)dlsym() 
调用dlsym时，利用dlopen()返回的共享库的phandle以及函数名称作为参数，返回要加载函数的入口地址。 
(3)dlerror() 
该函数用于检查调用共享库的相关函数出现的错误。 
 这样我们就用简单的例子说明了在Linux下静态/动态库的创建和使用。                                                                                                                                                                                                                                                      

开放、自由和灵活是Linux的魅力所在，而这一点在GCC上的体现就是程序员通过它能够更好地控制整个编译过程。在使用GCC编译程序时，编译过程可以被细分为四个阶段：

◆ 预处理（Pre-Processing）

◆ 编译（Compiling）

◆ 汇编（Assembling）

◆ 链接（Linking）

Linux程序员可以根据自己的需要让GCC在编译的任何阶段结束，以便检查或使用编译器在该阶段的输出信息，或者对最后生成的二进制文件进行控制，以便通过加入不同数量和种类的调试代码来为今后的调试做好准备。和其它常用的编译器一样，GCC也提供了灵活而强大的代码优化功能，利用它可以生成执行效率更高的代码。

GCC提供了30多条警告信息和三个警告级别，使用它们有助于增强程序的稳定性和可移植性。此外，GCC还对标准的C和C++语言进行了大量的扩展，提高程序的执行效率，有助于编译器进行代码优化，能够减轻编程的工作量。

GCC起步

在学习使用GCC之前，下面的这个例子能够帮助用户迅速理解GCC的工作原理，并将其立即运用到实际的项目开发中去。首先用熟悉的编辑器输入清单1所示的代码：

清单1：hello.c

 #include <stdio.h>
 int main(void)
 {
  printf ("Hello world, Linux programming!\n");
  return 0;
 }
 
然后执行下面的命令编译和运行这段程序：

 # gcc hello.c -o hello # ./hello Hello world, Linux programming!
 
从程序员的角度看，只需简单地执行一条GCC命令就可以了，但从编译器的角度来看，却需要完成一系列非常繁杂的工作。首先，GCC需要调用预处理程序cpp，由它负责展开在源文件中定义的宏，并向其中插入“#include”语句所包含的内容；接着，GCC会调用ccl和as将处理后的源代码编译成目标代码；最后，GCC会调用链接程序ld，把生成的目标代码链接成一个可执行程序。

为了更好地理解GCC的工作过程，可以把上述编译过程分成几个步骤单独进行，并观察每步的运行结果。第一步是进行预编译，使用-E参数可以让GCC在预处理结束后停止编译过程：

 # gcc -E hello.c -o hello.i
 
此时若查看hello.cpp文件中的内容，会发现stdio.h的内容确实都插到文件里去了，而其它应当被预处理的宏定义也都做了相应的处理。下一步是将hello.i编译为目标代码，这可以通过使用-c参数来完成：

 # gcc -c hello.i -o hello.o
 
GCC默认将.i文件看成是预处理后的C语言源代码，因此上述命令将自动跳过预处理步骤而开始执行编译过程，也可以使用-x参数让GCC从指定的步骤开始编译。最后一步是将生成的目标文件链接成可执行文件：

 # gcc hello.o -o hello
 
在采用模块化的设计思想进行软件开发时，通常整个程序是由多个源文件组成的，相应地也就形成了多个编译单元，使用GCC能够很好地管理这些编译单元。假设有一个由foo1.c和foo2.c两个源文件组成的程序，为了对它们进行编译，并最终生成可执行程序foo，可以使用下面这条命令：

 # gcc foo1.c foo2.c -o foo
 
如果同时处理的文件不止一个，GCC仍然会按照预处理、编译和链接的过程依次进行。如果深究起来，上面这条命令大致相当于依次执行如下三条命令：

 # gcc -c foo1.c -o foo1.o # gcc -c foo2.c -o foo2.o # gcc foo1.o foo2.o -o foo
 
在编译一个包含许多源文件的工程时，若只用一条GCC命令来完成编译是非常浪费时间的。假设项目中有100个源文件需要编译，并且每个源文件中都包含10000行代码，如果像上面那样仅用一条GCC命令来完成编译工作，那么GCC需要将每个源文件都重新编译一遍，然后再全部连接起来。很显然，这样浪费的时间相当多，尤其是当用户只是修改了其中某一个文件的时候，完全没有必要将每个文件都重新编译一遍，因为很多已经生成的目标文件是不会改变的。要解决这个问题，关键是要灵活运用GCC，同时还要借助像Make这样的工具。

警告提示功能

GCC包含完整的出错检查和警告提示功能，它们可以帮助Linux程序员写出更加专业和优美的代码。先来读读清单2所示的程序，这段代码写得很糟糕，仔细检查一下不难挑出很多毛病：

◆main函数的返回值被声明为void，但实际上应该是int；

◆使用了GNU语法扩展，即使用long long来声明64位整数，不符合ANSI/ISO C语言标准；

◆main函数在终止前没有调用return语句。

清单2：illcode.c

 #include <stdio.h>
 void main(void)
 {
  long long int var = 1;
  printf("It is not standard C code!\n");
 }

下面来看看GCC是如何帮助程序员来发现这些错误的。当GCC在编译不符合ANSI/ISO C语言标准的源代码时，如果加上了-pedantic选项，那么使用了扩展语法的地方将产生相应的警告信息：

 # gcc -pedantic illcode.c -o illcode illcode.c: In function `main': illcode.c:9: ISO C89 does not support `long long' illcode.c:8: return type of `main' is not `int'

需要注意的是，-pedantic编译选项并不能保证被编译程序与ANSI/ISO C标准的完全兼容，它仅仅只能用来帮助Linux程序员离这个目标越来越近。或者换句话说，-pedantic选项能够帮助程序员发现一些不符合ANSI/ISO C标准的代码，但不是全部，事实上只有ANSI/ISO C语言标准中要求进行编译器诊断的那些情况，才有可能被GCC发现并提出警告。

除了-pedantic之外，GCC还有一些其它编译选项也能够产生有用的警告信息。这些选项大多以-W开头，其中最有价值的当数-Wall了，使用它能够使GCC产生尽可能多的警告信息：

 # gcc -Wall illcode.c -o illcode illcode.c:8: warning: return type of `main' is not `int' illcode.c: In function `main': illcode.c:9: warning: unused variable `var'

GCC给出的警告信息虽然从严格意义上说不能算作是错误，但却很可能成为错误的栖身之所。一个优秀的Linux程序员应该尽量避免产生警告信息，使自己的代码始终保持简洁、优美和健壮的特性。

在处理警告方面，另一个常用的编译选项是-Werror，它要求GCC将所有的警告当成错误进行处理，这在使用自动编译工具（如Make等）时非常有用。如果编译时带上-Werror选项，那么GCC会在所有产生警告的地方停止编译，迫使程序员对自己的代码进行修改。只有当相应的警告信息消除时，才可能将编译过程继续朝前推进。执行情况如下：

 # gcc -Wall -Werror illcode.c -o illcode cc1: warnings being treated as errors illcode.c:8: warning: return type of `main' is not `int' illcode.c: In function `main': illcode.c:9: warning: unused variable `var'

对Linux程序员来讲，GCC给出的警告信息是很有价值的，它们不仅可以帮助程序员写出更加健壮的程序，而且还是跟踪和调试程序的有力工具。建议在用GCC编译源代码时始终带上-Wall选项，并把它逐渐培养成为一种习惯，这对找出常见的隐式编程错误很有帮助。

库依赖

在Linux下开发软件时，完全不使用第三方函数库的情况是比较少见的，通常来讲都需要借助一个或多个函数库的支持才能够完成相应的功能。从程序员的角度看，函数库实际上就是一些头文件（.h）和库文件（.so或者.a）的集合。虽然Linux下的大多数函数都默认将头文件放到/usr/include/目录下，而库文件则放到/usr/lib/目录下，但并不是所有的情况都是这样。正因如此，GCC在编译时必须有自己的办法来查找所需要的头文件和库文件。

GCC采用搜索目录的办法来查找所需要的文件，-I选项可以向GCC的头文件搜索路径中添加新的目录。例如，如果在/home/xiaowp/include/目录下有编译时所需要的头文件，为了让GCC能够顺利地找到它们，就可以使用-I选项：

 # gcc foo.c -I /home/xiaowp/include -o foo

同样，如果使用了不在标准位置的库文件，那么可以通过-L选项向GCC的库文件搜索路径中添加新的目录。例如，如果在/home/xiaowp/lib/目录下有链接时所需要的库文件libfoo.so，为了让GCC能够顺利地找到它，可以使用下面的命令：

 # gcc foo.c -L /home/xiaowp/lib -lfoo -o foo

值得好好解释一下的是-l选项，它指示GCC去连接库文件libfoo.so。Linux下的库文件在命名时有一个约定，那就是应该以lib三个字母开头，由于所有的库文件都遵循了同样的规范，因此在用-l选项指定链接的库文件名时可以省去lib三个字母，也就是说GCC在对-lfoo进行处理时，会自动去链接名为libfoo.so的文件。

Linux下的库文件分为两大类分别是动态链接库（通常以.so结尾）和静态链接库（通常以.a结尾），两者的差别仅在程序执行时所需的代码是在运行时动态加载的，还是在编译时静态加载的。默认情况下，GCC在链接时优先使用动态链接库，只有当动态链接库不存在时才考虑使用静态链接库，如果需要的话可以在编译时加上-static选项，强制使用静态链接库。例如，如果在/home/xiaowp/lib/目录下有链接时所需要的库文件libfoo.so和libfoo.a，为了让GCC在链接时只用到静态链接库，可以使用下面的命令：

 # gcc foo.c -L /home/xiaowp/lib -static -lfoo -o foo
 
代码优化

代码优化指的是编译器通过分析源代码，找出其中尚未达到最优的部分，然后对其重新进行组合，目的是改善程序的执行性能。GCC提供的代码优化功能非常强大，它通过编译选项-On来控制优化代码的生成，其中n是一个代表优化级别的整数。对于不同版本的GCC来讲，n的取值范围及其对应的优化效果可能并不完全相同，比较典型的范围是从0变化到2或3。

编译时使用选项-O可以告诉GCC同时减小代码的长度和执行时间，其效果等价于-O1。在这一级别上能够进行的优化类型虽然取决于目标处理器，但一般都会包括线程跳转（Thread Jump）和延迟退栈（Deferred Stack Pops）两种优化。选项-O2告诉GCC除了完成所有-O1级别的优化之外，同时还要进行一些额外的调整工作，如处理器指令调度等。选项-O3则除了完成所有-O2级别的优化之外，还包括循环展开和其它一些与处理器特性相关的优化工作。通常来说，数字越大优化的等级越高，同时也就意味着程序的运行速度越快。许多Linux程序员都喜欢使用-O2选项，因为它在优化长度、编译时间和代码大小之间，取得了一个比较理想的平衡点。

下面通过具体实例来感受一下GCC的代码优化功能，所用程序如清单3所示。

清单3：optimize.c

 #include <stdio.h>
 int main(void)
 {
  double counter;
  double result;
  double temp;
  
  for (counter = 0; counter < 2000.0 * 2000.0 * 2000.0 / 20.0 + 2020; counter += (5 - 1) / 4)
  {
    temp = counter / 1979; result = counter;
  }
  printf("Result is %lf\n", result); return 0;
 }

首先不加任何优化选项进行编译：

 # gcc -Wall optimize.c -o optimize
 
借助Linux提供的time命令，可以大致统计出该程序在运行时所需要的时间：

 # time ./optimize Result is 400002019.000000 real 0m14.942s user 0m14.940s sys 0m0.000s
 
接下去使用优化选项来对代码进行优化处理：

 # gcc -Wall -O optimize.c -o optimize
 
在同样的条件下再次测试一下运行时间：

 # time ./optimize Result is 400002019.000000 real 0m3.256s user 0m3.240s sys 0m0.000s
 
对比两次执行的输出结果不难看出，程序的性能的确得到了很大幅度的改善，由原来的14秒缩短到了3秒。这个例子是专门针对GCC的优化功能而设计的，因此优化前后程序的执行速度发生了很大的改变。尽管GCC的代码优化功能非常强大，但作为一名优秀的Linux程序员，首先还是要力求能够手工编写出高质量的代码。如果编写的代码简短，并且逻辑性强，编译器就不会做更多的工作，甚至根本用不着优化。

优化虽然能够给程序带来更好的执行性能，但在如下一些场合中应该避免优化代码：

◆ 程序开发的时候 优化等级越高，消耗在编译上的时间就越长，因此在开发的时候最好不要使用优化选项，只有到软件发行或开发结束的时候，才考虑对最终生成的代码进行优化。

◆ 资源受限的时候 一些优化选项会增加可执行代码的体积，如果程序在运行时能够申请到的内存资源非常紧张（如一些实时嵌入式设备），那就不要对代码进行优化，因为由这带来的负面影响可能会产生非常严重的后果。

◆ 跟踪调试的时候 在对代码进行优化的时候，某些代码可能会被删除或改写，或者为了取得更佳的性能而进行重组，从而使跟踪和调试变得异常困难。

调试

一个功能强大的调试器不仅为程序员提供了跟踪程序执行的手段，而且还可以帮助程序员找到解决问题的方法。对于Linux程序员来讲，GDB（GNU Debugger）通过与GCC的配合使用，为基于Linux的软件开发提供了一个完善的调试环境。

默认情况下，GCC在编译时不会将调试符号插入到生成的二进制代码中，因为这样会增加可执行文件的大小。如果需要在编译时生成调试符号信息，可以使用GCC的-g或者-ggdb选项。GCC在产生调试符号时，同样采用了分级的思路，开发人员可以通过在-g选项后附加数字1、2或3来指定在代码中加入调试信息的多少。默认的级别是2（-g2），此时产生的调试信息包括扩展的符号表、行号、局部或外部变量信息。级别3（-g3）包含级别2中的所有调试信息，以及源代码中定义的宏。级别1（-g1）不包含局部变量和与行号有关的调试信息，因此只能够用于回溯跟踪和堆栈转储之用。回溯跟踪指的是监视程序在运行过程中的函数调用历史，堆栈转储则是一种以原始的十六进制格式保存程序执行环境的方法，两者都是经常用到的调试手段。

GCC产生的调试符号具有普遍的适应性，可以被许多调试器加以利用，但如果使用的是GDB，那么还可以通过-ggdb选项在生成的二进制代码中包含GDB专用的调试信息。这种做法的优点是可以方便GDB的调试工作，但缺点是可能导致其它调试器（如DBX）无法进行正常的调试。选项-ggdb能够接受的调试级别和-g是完全一样的，它们对输出的调试符号有着相同的影响。

需要注意的是，使用任何一个调试选项都会使最终生成的二进制文件的大小急剧增加，同时增加程序在执行时的开销，因此调试选项通常仅在软件的开发和调试阶段使用。调试选项对生成代码大小的影响从下面的对比过程中可以看出来：

 # gcc optimize.c -o optimize # ls optimize -l -rwxrwxr-x 1 xiaowp xiaowp 11649 Nov 20 08:53 optimize (未加调试选项) # gcc -g optimize.c -o optimize # ls optimize -l -rwxrwxr-x 1 xiaowp xiaowp 15889 Nov 20 08:54 optimize (加入调试选项)
 
虽然调试选项会增加文件的大小，但事实上Linux中的许多软件在测试版本甚至最终发行版本中仍然使用了调试选项来进行编译，这样做的目的是鼓励用户在发现问题时自己动手解决，是Linux的一个显著特色。

下面还是通过一个具体的实例说明如何利用调试符号来分析错误，所用程序见清单4所示。

清单4：crash.c

 #include <stdio.h>
 int main(void)
 {
  int input =0;
  
  printf("Input an integer:");
  scanf("%d", input);
  printf("The integer you input is %d\n", input);
  return 0;
 }
 
编译并运行上述代码，会产生一个严重的段错误（Segmentation fault）如下：

 # gcc -g crash.c -o crash # ./crash Input an integer:10 Segmentation fault
 
为了更快速地发现错误所在，可以使用GDB进行跟踪调试，方法如下：

 # gdb crash GNU gdb Red Hat Linux (5.3post-0.20021129.18rh) …… (gdb)
 
当GDB提示符出现的时候，表明GDB已经做好准备进行调试了，现在可以通过run命令让程序开始在GDB的监控下运行：

 (gdb) run Starting program: /home/xiaowp/thesis/gcc/code/crash Input an integer:10 Program received signal SIGSEGV, Segmentation fault. 0x4008576b in _IO_vfscanf_internal () from /lib/libc.so.6
 
仔细分析一下GDB给出的输出结果不难看出，程序是由于段错误而导致异常中止的，说明内存操作出了问题，具体发生问题的地方是在调用_IO_vfscanf_internal ( )的时候。为了得到更加有价值的信息，可以使用GDB提供的回溯跟踪命令backtrace，执行结果如下：

 (gdb) backtrace #0 0x4008576b in _IO_vfscanf_internal () from /lib/libc.so.6 #1 0xbffff0c0 in ?? () #2 0x4008e0ba in scanf () from /lib/libc.so.6 #3 0x08048393 in main () at crash.c:11 #4 0x40042917 in __libc_start_main () from /lib/libc.so.6
 
跳过输出结果中的前面三行，从输出结果的第四行中不难看出，GDB已经将错误定位到crash.c中的第11行了。现在仔细检查一下：

 (gdb) frame 3 #3 0x08048393 in main () at crash.c:11 11 scanf("%d", input);
 
使用GDB提供的frame命令可以定位到发生错误的代码段，该命令后面跟着的数值可以在backtrace命令输出结果中的行首找到。现在已经发现错误所在了，应该将

 scanf("%d", input); 改为 scanf("%d", &input);
 
完成后就可以退出GDB了，命令如下：

 (gdb) quit
 
GDB的功能远远不止如此，它还可以单步跟踪程序、检查内存变量和设置断点等。

调试时可能会需要用到编译器产生的中间结果，这时可以使用-save-temps选项，让GCC将预处理代码、汇编代码和目标代码都作为文件保存起来。如果想检查生成的代码是否能够通过手工调整的办法来提高执行性能，在编译过程中生成的中间文件将会很有帮助，具体情况如下：

 # gcc -save-temps foo.c -o foo # ls foo* foo foo.c foo.i foo.s
 
GCC支持的其它调试选项还包括-p和-pg，它们会将剖析（Profiling）信息加入到最终生成的二进制代码中。剖析信息对于找出程序的性能瓶颈很有帮助，是协助Linux程序员开发出高性能程序的有力工具。在编译时加入-p选项会在生成的代码中加入通用剖析工具（Prof）能够识别的统计信息，而-pg选项则生成只有GNU剖析工具（Gprof）才能识别的统计信息。

最后提醒一点，虽然GCC允许在优化的同时加入调试符号信息，但优化后的代码对于调试本身而言将是一个很大的挑战。代码在经过优化之后，在源程序中声明和使用的变量很可能不再使用，控制流也可能会突然跳转到意外的地方，循环语句有可能因为循环展开而变得到处都有，所有这些对调试来讲都将是一场噩梦。建议在调试的时候最好不使用任何优化选项，只有当程序在最终发行的时候才考虑对其进行优化。

上次的培训园地中介绍了GCC的编译过程、警告提示功能、库依赖、代码优化和程序调试六个方面的内容。这期是最后的一部分内容。

加速

在将源代码变成可执行文件的过程中，需要经过许多中间步骤，包含预处理、编译、汇编和连接。这些过程实际上是由不同的程序负责完成的。大多数情况下GCC可以为Linux程序员完成所有的后台工作，自动调用相应程序进行处理。

这样做有一个很明显的缺点，就是GCC在处理每一个源文件时，最终都需要生成好几个临时文件才能完成相应的工作，从而无形中导致处理速度变慢。例如，GCC在处理一个源文件时，可能需要一个临时文件来保存预处理的输出、一个临时文件来保存编译器的输出、一个临时文件来保存汇编器的输出，而读写这些临时文件显然需要耗费一定的时间。当软件项目变得非常庞大的时候，花费在这上面的代价可能会变得很沉重。

解决的办法是，使用Linux提供的一种更加高效的通信方式—管道。它可以用来同时连接两个程序，其中一个程序的输出将被直接作为另一个程序的输入，这样就可以避免使用临时文件，但编译时却需要消耗更多的内存。

在编译过程中使用管道是由GCC的-pipe选项决定的。下面的这条命令就是借助GCC的管道功能来提高编译速度的：

 # gcc -pipe foo.c -o foo
 
在编译小型工程时使用管道，编译时间上的差异可能还不是很明显，但在源代码非常多的大型工程中，差异将变得非常明显。

文件扩展名

在使用GCC的过程中，用户对一些常用的扩展名一定要熟悉，并知道其含义。为了方便大家学习使用GCC，在此将这些扩展名罗列如下：

.c C原始程序；

.C C++原始程序；

.cc C++原始程序；

.cxx C++原始程序；

.m Objective-C原始程序；

.i 已经过预处理的C原始程序；

.ii 已经过预处理之C++原始程序；

.s 组合语言原始程序；

.S 组合语言原始程序；

.h 预处理文件(标头文件)；

.o 目标文件；

.a 存档文件。

GCC常用选项

GCC作为Linux下C/C++重要的编译环境，功能强大，编译选项繁多。为了方便大家日后编译方便，在此将常用的选项及说明罗列出来如下：

-c 通知GCC取消链接步骤，即编译源码并在最后生成目标文件；

-Dmacro 定义指定的宏，使它能够通过源码中的#ifdef进行检验；

-E 不经过编译预处理程序的输出而输送至标准输出；

-g3 获得有关调试程序的详细信息，它不能与-o选项联合使用；

-Idirectory 在包含文件搜索路径的起点处添加指定目录；

-llibrary 提示链接程序在创建最终可执行文件时包含指定的库；

-O、-O2、-O3 将优化状态打开，该选项不能与-g选项联合使用；

-S 要求编译程序生成来自源代码的汇编程序输出；

-v 启动所有警报；

-Wall 在发生警报时取消编译操作，即将警报看作是错误；

-Werror 在发生警报时取消编译操作，即把报警当作是错误；

-w 禁止所有的报警。

小结

GCC是在Linux下开发程序时必须掌握的工具之一。本文对GCC做了一个简要的介绍，主要讲述了如何使用GCC编译程序、产生警告信息、调试程序和加快GCC的编译速度。对所有希望早日跨入Linux开发者行列的人来说，GCC就是成为一名优秀的Linux程序员的起跑线。

2004年4月20日最新版本的GCC编译器3.4.0发布了。目前，GCC可以用来编译C/C++、FORTRAN、JAVA、OBJC、ADA等语言的程序，可根据需要选择安装支持的语言。GCC 3.4.0比以前版本更好地支持了C++标准。本文以在Redhat Linux上安装GCC3.4.0为例，介绍了GCC的安装过程。

　　安装之前，系统中必须要有cc或者gcc等编译器，并且是可用的，或者用环境变量CC指定系统上的编译器。如果系统上没有编译器，不能安装源代码形式的GCC 3.4.0。如果是这种情况，可以在网上找一个与你系统相适应的如RPM等二进制形式的GCC软件包来安装使用。本文介绍的是以源代码形式提供的GCC软件包的安装过程，软件包本身和其安装过程同样适用于其它Linux和Unix系统。

　　系统上原来的GCC编译器可能是把gcc等命令文件、库文件、头文件等分别存放到系统中的不同目录下的。与此不同，现在GCC建议我们将一个版本的GCC安装在一个单独的目录下。这样做的好处是将来不需要它的时候可以方便地删除整个目录即可（因为GCC没有uninstall功能）；缺点是在安装完成后要做一些设置工作才能使编译器工作正常。在本文中我采用这个方案安装GCC 3.4.0，并且在安装完成后，仍然能够使用原来低版本的GCC编译器，即一个系统上可以同时存在并使用多个版本的GCC编译器。

　　按照本文提供的步骤和设置选项，即使以前没有安装过GCC，也可以在系统上安装上一个可工作的新版本的GCC编译器。

　　1. 下载

　　在GCC网站上（http://gcc.gnu.org/）或者通过网上搜索可以查找到下载资源。目前GCC的最新版本为 3.4.0。可供下载的文件一般有两种形式：gcc-3.4.0.tar.gz和gcc-3.4.0.tar.bz2，只是压缩格式不一样，内容完全一致，下载其中一种即可。

　　2. 解压缩

　　根据压缩格式，选择下面相应的一种方式解包（以下的“%”表示命令行提示符）：

　　% tar xzvf gcc-3.4.0.tar.gz
　　或者
　　% bzcat gcc-3.4.0.tar.bz2 | tar xvf -

　　新生成的gcc-3.4.0这个目录被称为源目录，用${srcdir}表示它。以后在出现${srcdir}的地方，应该用真实的路径来替换它。用pwd命令可以查看当前路径。

　　在${srcdir}/INSTALL目录下有详细的GCC安装说明，可用浏览器打开index.html阅读。

　　3. 建立目标目录
 
　　目标目录（用${objdir}表示）是用来存放编译结果的地方。GCC建议编译后的文件不要放在源目录${srcdir]中（虽然这样做也可以），最好单独存放在另外一个目录中，而且不能是${srcdir}的子目录。

　　例如，可以这样建立一个叫 gcc-build 的目标目录（与源目录${srcdir}是同级目录）：

　　% mkdir gcc-build
　　% cd gcc-build

　　以下的操作主要是在目标目录 ${objdir} 下进行。

　　4. 配置
 
　　配置的目的是决定将GCC编译器安装到什么地方（${destdir}），支持什么语言以及指定其它一些选项等。其中，${destdir}不能与${objdir}或${srcdir}目录相同。

　　配置是通过执行${srcdir}下的configure来完成的。其命令格式为（记得用你的真实路径替换${destdir}）：

　　% ${srcdir}/configure --prefix=${destdir} [其它选项]

　　例如，如果想将GCC 3.4.0安装到/usr/local/gcc-3.4.0目录下，则${destdir}就表示这个路径。

　　在我的机器上，我是这样配置的：

　　% ../gcc-3.4.0/configure --prefix=/usr/local/gcc-3.4.0 --enable-threads=posix --disable-checking --enable--long-long --host=i386-redhat-linux --with-system-zlib --enable-languages=c,c++,java

　　将GCC安装在/usr/local/gcc-3.4.0目录下，支持C/C++和JAVA语言，其它选项参见GCC提供的帮助说明。

　　5. 编译

　　% make

　　这是一个漫长的过程。在我的机器上（P4-1.6），这个过程用了50多分钟。

　　6. 安装

　　执行下面的命令将编译好的库文件等拷贝到${destdir}目录中（根据你设定的路径，可能需要管理员的权限）：

　　% make install

　　至此，GCC 3.4.0安装过程就完成了。

　　6. 其它设置

　　GCC 3.4.0的所有文件，包括命令文件（如gcc、g++）、库文件等都在${destdir}目录下分别存放，如命令文件放在bin目录下、库文件在lib下、头文件在include下等。由于命令文件和库文件所在的目录还没有包含在相应的搜索路径内，所以必须要作适当的设置之后编译器才能顺利地找到并使用它们。

　　6.1 gcc、g++、gcj的设置

　　要想使用GCC 3.4.0的gcc等命令，简单的方法就是把它的路径${destdir}/bin放在环境变量PATH中。我不用这种方式，而是用符号连接的方式实现，这样做的好处是我仍然可以使用系统上原来的旧版本的GCC编译器。

　　首先，查看原来的gcc所在的路径：

　　% which gcc

　　在我的系统上，上述命令显示：/usr/bin/gcc。因此，原来的gcc命令在/usr/bin目录下。我们可以把GCC 3.4.0中的gcc、g++、gcj等命令在/usr/bin目录下分别做一个符号连接：

　　% cd /usr/bin
　　% ln -s ${destdir}/bin/gcc gcc34
　　% ln -s ${destdir}/bin/g++ g++34
　　% ln -s ${destdir}/bin/gcj gcj34

　　这样，就可以分别使用gcc34、g++34、gcj34来调用GCC 3.4.0的gcc、g++、gcj完成对C、C++、JAVA程序的编译了。同时，仍然能够使用旧版本的GCC编译器中的gcc、g++等命令。

　　6.2 库路径的设置

　　将${destdir}/lib路径添加到环境变量LD_LIBRARY_PATH中，最好添加到系统的配置文件中，这样就不必要每次都设置这个环境变量了。

　　例如，如果GCC 3.4.0安装在/usr/local/gcc-3.4.0目录下，在RH Linux下可以直接在命令行上执行或者在文件/etc/profile中添加下面一句：

　　setenv LD_LIBRARY_PATH /usr/local/gcc-3.4.0/lib:$LD_LIBRARY_PATH

　　7. 测试
 
　　用新的编译命令（gcc34、g++34等）编译你以前的C、C++程序，检验新安装的GCC编译器是否能正常工作。

　　8. 根据需要，可以删除或者保留${srcdir}和${objdir}目录。