C++博客-网络服务器软件开发/中间件开发，关注ACE/TAO/ICE-随笔分类-ACE

Buffer类就应该简单，直观

true — Wed, 12 Jan 2011 16:51:00 GMT

摘要: 最近几天一直在思考一个问题：我们需要什么样的网络基础开发包？libevent，asio，ace，还是自己封装？Buffer类，内存池阅读全文

true 2011-01-13 00:51 发表评论

ACE中简易的序列化机制：ACE_OutputCDR/ACE_InputCDR

true — Sun, 26 Dec 2010 01:52:00 GMT

CDR可以提供对基本数据类型如int，short，double，string等的序列化机制，简单包装后即可担当RPC中的序列化角色。

#include <iostream>
#include <string>
#include <ace/OS.h>
#include <ace/String_Base.h>
#include <ace/CDR_Stream.h>
using namespace std;
#pragma comment(lib,"aced")

int main(int argc, char* argv[])
{
    cout << "ACE CDR demo" << endl;

    ACE_CString sAppName = "CDRDemo",sAppName2;
    ACE_CDR::Long nUID = 123456,nUID2;
    ACE_CDR::Float nfPosX = 120.51,nfPosX2;
    ACE_CDR::Double ndScore = 120.51,ndScore2;
    ACE_CString sDummy = "another string",sDummy2;
    ACE_CDR::Short  nsLength = 10,nsLength2;

    ACE_OutputCDR outCDR(ACE_DEFAULT_CDR_BUFSIZE);

    outCDR << nUID;
    outCDR << nfPosX;
    outCDR << ndScore;
    outCDR << sAppName;//写字符串时，先写入字符串的长度
    outCDR << sDummy;
    outCDR << nsLength;

    cout << "OutputCDR size = " << outCDR.length() << endl;

    //可以通过socket发送出去,而在服务端进行下面的解析
    //1.ACE_Message_Block *ACE_OutputCDR::begin (void)
    //2.通过ACE_SOCK_Stream发送出去

    ACE_InputCDR inCDR(outCDR);

    inCDR >> nUID2;
    inCDR >> nfPosX2;
    inCDR >> ndScore2;
    inCDR >> sAppName2;
    inCDR >> sDummy2;
    inCDR >> nsLength2;


    ACE_ASSERT(nUID == nUID2);
    ACE_ASSERT(nfPosX == nfPosX2);
    ACE_ASSERT(ndScore == ndScore2);
    ACE_ASSERT(sAppName == sAppName2);
    ACE_ASSERT(sDummy == sDummy2);
    ACE_ASSERT(nsLength == nsLength2);

    cout << "test ok." << endl;

    return 0;
}

假若有如下的demo.idl,内容如下：

      struct user_info
      {
            int user_id;
            string user_name;
      }
利用idl_gen生成代码时：
      (1)如果是侵入式的方案，则生成user_info类时，自动添加成员OutputCDR和InputCDR成员，并添加pack(ACE_Message_Block &* msg)和parse(ACE_Message_Block * msg)成员函数，在pack和parse里面，调到对于的CDR类，按照类中数据成员的声明顺序依次序列化，反序列化
      (2)如果是非侵入式方案，则生成user_info类时，生成独立函数的pack(user_info& info, ACE_Message_Block &* msg)和parse(user_info& info,ACE_Message_Block * msg),pack和parse的函数实现同上

true 2010-12-26 09:52 发表评论

ACE_Get_Opt解析命令行参数

true — Tue, 09 Nov 2010 15:53:00 GMT

摘要: ACE ACE_Get_Opt 命令行阅读全文

true 2010-11-09 23:53 发表评论

ACE_Thread_Mutex一个不跨平台的地方

true — Sat, 23 Oct 2010 13:44:00 GMT

ACE_Thread_Mutex的成员， int acquire (ACE_Time_Value *tv);在windows下是不支持的，有些出人意料，之前一直没用过这个参数，今天造轮子，参考ace发现的。

true 2010-10-23 21:44 发表评论

仿照system v消息队列的内存消息队列

true — Sat, 18 Sep 2010 17:01:00 GMT

摘要: 内存消息队列是服务器端常用的基础组件，他使得符合生产者-消费者模型的两个线程或两组线程之间的通讯看起来更加清晰阅读全文

true 2010-09-19 01:01 发表评论

ace中常用类的使用举例（不断补充）

true — Sun, 13 Apr 2008 08:32:00 GMT

#include "ace/Task.h"
#include
#include
#include "ace/OS.h"
#include
#include

using namespace std;
#pragma comment(lib,"aced")

/**
* if MANUAL reset
*    sleep till the event becomes signaled
*    event remains signaled after wait() completes.
* else AUTO reset
*    sleep till the event becomes signaled
*    event resets wait() completes.
*/
//ACE_Manual_Event mevent;
ACE_Auto_Event   auto_event;
class TaskTest : public ACE_Task_Base
{
public:
int svc()
{
  cout << "task base test" << endl;
  ACE_Date_Time dt;
  cout << "y = " << dt.year() << endl;
  cout << "m = " << dt.month() << endl;
  cout << "s = " << dt.second() << endl;
  ACE_OS::sleep(2);
  //mevent.signal();
  auto_event.signal();
  return 0;
}
protected:
private:
};
int main(int argc, char* argv[])
{
TaskTest tt;
tt.activate();
//mevent.wait();
auto_event.wait();
tt.wait();
return 0;
}

true 2008-04-13 16:32 发表评论

ACE在Linux环境下的编译安装[转]

true — Sun, 15 Jul 2007 05:06:00 GMT

ACE在Linux环境下的编译安装
[Author by Jet Yan in April 4,2005]

第一步设置ACE_ROOT环境变量
（1）export ACE_ROOT=/home/jet/ACE_wrappers
export LD_LIBRARY_PATH=$ACE_ROOT/ace:$LD_LIBRARY_PATH

（2）或者直接在用户目录下编辑.bashrc文件，内容如下：
ACE_ROOT=/home/jet/ACE_wrappers
export ACE_ROOT
LD_LIBRARY_PATH=$ACE_ROOT/ace:$LD_LIBRARY_PATH
export LD_LIBRARY_PATH
然后重新登陆

（3）另一种方法是修改系统的/etc/profile文件（不过这样还是以用户变量为
优先设置，即如果已经按照上面的两种方法进行了设置，那么以下的设置将不
会被系统采用。）
“vi /etc/profile”
在其中加入4行
ACE_ROOT=/opt/ACE
export ACE_ROOT
LD_LIBRARY_PATH=$ACE_ROOT/ace:$LD_LIBRARY_PATH
export LD_LIBRARY_PATH
我是加在“export PATH USER….”后的。完成后将/etc/profile执行一次，命令：
“chmod 555 /etc/profile”
“/etc/profile”
这样我们的ACE_ROOT就设置好了，可以用如下命令查看ACE_ROOT是否设置好了：
“echo $ACE_ROOT”
这个时候最好reboot启动一次linux。
-------------------------------------------------------------------

第二步解压出ACE-install.sh文件并修改
（1）在/home/jet下建立子目录ACEInstall，将ACE.tar.gz上传至该目录

（2）从ACE.tar.gz解压出单个文件ACE-install.sh：
tar –zxvf ACE.tar.gz ACE_wrappers/ACE-install.sh

（3）ACE-install.sh放在哪个目录下无所谓，因为安装目录是由刚才设定的$ACE_ROOT决定的。

（4）vi ACE-install.sh
我们可以看到缺省的，这个文件是用来在UNIX下做安装的。所以我们要将其中的有
关UNIX的部分换成linux即可。
“MY_ACEDIR=${HOME}/aceconfig” -->> “MY_ACEDIR=/home/my/ACE”
“MY_ACE_CONFIG=config-sunos5.4-sunc++-4.x.h” -->> “MY_ACE_CONFIG=config-linux.h”
“MY_ACE_GNU_MACROS=platform_sunos5_sunc++.GNU” -->> “MY_ACE_GNU_MACROS=platform_linux.GNU”
好了，文件修改完毕，保存退出“:wq”。
-------------------------------------------------------------------

第三步运行ACE-install.sh（shell脚本）安装ACE
（1）当前目录/home/jet/ACEInstall/ACE_wrappers

（2）修改ACE-install.sh的属性，使其可执行
chmod 777 ACE-install.sh

（3）执行：
./ACE-install.sh
此后将是较长时间的解包、编译等待时间。这个过程将不会出现任何错误，因为安装脚本
将为我们做很多事情，如：生成config.h，生成platform_macros.GNU。（即使出现删除
文件的错误，对结果应该没有影响，遇到这种情况要具体分析一下。）
因此就不需要按ACE-install.html中说的那样手工做如下改动：
在$ACE_ROOT/ace目录下:
ln -s config-linux.h config.h
在$ACE_ROOT/include/makeinclude/目录下:
ln -s platform_linux.GNU platform_macros.GNU
（Windows中没有文件连接这一说，所以要自己生成一个config.h文件，再在它的里面加一
句话“#include "ace/config-win32.h"”。）

（4）如果编译中出现错误，如“../apps/gperf”等，请编辑$ACE_ROOT/apps下的Makefile，
将其中的有关“gperf”的部分注释掉，这个东西只是一个例子，可以不去编译它。
强调一下，用ACE-install.sh来安装，会编译ACE、tests、apps等。
最后会生成libACE.so及tests、apps下也会出来很多经过编译的文件。
当然如果你只是下载了ACE.tar.gz这样的单个包来安装，你可以手工改文件，再make，
因为只编译ACE，工作就少了很多，手工做还可以接受。

（5）编译过程日志放在/tmp/myacemaker.err
-------------------------------------------------------------------

第四步直接测试ACE提供的例子
（1）在$ACE_ROOT/examples/Synch中，修改proc_sema.cpp文件如下：
#include "ace/OS_NS_stdio.h"
在main函数中
ACE_OS::printf("Hello,World! \n");

（2）执行make，OK后运行。

（3）如果运行时装在不到share object，可能是lib路径问题，因为.so文件是程序运行过程中
装载的，不是在编译的时候，因此要设置LD_LIBRARY_PATH：
[jet@S]$ export LD_LIBRARY_PATH=/home/jet/ACE_wrappers/lib:$LD_LIBRARY_PATH
-------------------------------------------------------------------

第五步写一个简单的程序测试一下ACE
（1）在/home/jet/下新建ACETest子目录，写好程序如client.cpp，上传到该目录

（2）拷贝第四步的那个Makefile文件到该目录，并做如下修改
修改其中输出文件名“BIN = hello”，并修改“
.obj/proc_sema.o .obj/proc_sema.so .shobj/proc_sema.o .shobj/proc_sema.so: proc_sema.cpp \”
中后面的“proc_sema.cpp”成“client.cpp”。
好，我们可以编译一个我们自己的ACE程序了，make即可。应该能通过，生成执行文件client，
大小大约为112Kb。运行之，“./client”。
-------------------------------------------------------------------

=================================================
另一种更为直接的安装方法：

步骤1：设置环境变量
export ACE_ROOT=/home/jet/ACE_wrappers
export LD_LIBRARY_PATH=$ACE_ROOT/ace:$LD_LIBRARY_PATH
也可以直接修改.bashrc文件，以免退出后设置的这些变量消失

[env][echo $ACE_ROOT]

步骤2：
针对不同版本创建两个文件链接:
在$ACE_ROOT/ace目录下:
ln -s config-linux.h config.h
在$ACE_ROOT/include/makeinclude/目录下:
ln -s platform_linux.GNU platform_macros.GNU

步骤3：
在$ACE_ROOT目录下，新建一个目录，用以执行configure的结果
mkdir aaa
cd aaa
在$ACE_ROOT/aaa中运行
../configure
在确认结果无误后，执行
make
OK！

[rm -f -r *]删除目录下所有的文件和子目录-f是强制force删除，-r是代表目录也删除

[ldd 可执行文件] 显示该文件运行时候需要的动态链接库

[ipcs] 显示系统的共享内存、信号量、消息队列的情况 ipc show
[ipcrm id]

true 2007-07-15 13:06 发表评论

ACE关于文件的操作

true — Sat, 09 Jun 2007 10:30:00 GMT

ACE_FILE_Addr file_addr;
file_addr.set("log.txt");
ACE_FILE_IO file;
ACE_FILE_Connector file_connector;
if (file_connector.connect(file,
        file_addr,
        0,
        ACE_Addr::sap_any,
        0,
        O_RDWR|O_CREAT|O_APPEND
        ) == -1)
{
  cout << "error" << endl;
}

true 2007-06-09 18:30 发表评论

ACE_NT_Service（WINDOWS

true — Tue, 24 Apr 2007 09:55:00 GMT

ACE_NT_Service（WINDOWS）
本人的观点，SERVICE就是WINDOWS版的DAEMON。ACE_NT_Service通过包装一整套WINDOWS提供的SERVICE API定义了一个控制NT SERVICE的接口。应用程序继承该接口就可以实现和UNIX上DAEMON相似的功能。下面先简单描述WINDOWSSERVICE程序框架，再详细描述类ACE_NT_Service对WINDOWS SERVICE程序框架的包装。

WINDOWS SERVICE
一个完整的NT SERVICE程序应该包含以下四部分：
1.控制台应用程序的main函数
2.SERVICE入口函数ServiceMain
3.SERVICE CONTROL HANDLER，SCM利用该函数和SERVICE通信并控制程序的起停。
4.SERVICE安装和卸载器

ServiceMain和Service Control Handler
首先我们来讨论ServiceMain和Service Control Handler。WINDOWS规定每个SERVICE都拥有自己独立的ServiceMain以及Service Control Handler函数。主程序调用StartServiceCtrlDispatcher时，WINDOWS为每个SERVICE创建一个线程，并且在新线程中运行ServiceMain函数。SCM利用Service Control Handler函数和SERVICE程序通信，用户执行start，stop，pause以及continue等操作时，SCM通过Service Control Handler函数来控制SERVICE的行为。Service Control Handler函数基本上会包含一个switch语句来处理每种情况。

安装/卸载SERVICE
WINDOWS提供一些API来安装/卸载SERVICE，这样我们就可以不使用注册函数就能在系统中注册这些节点。这些API分别是CreateService和DeleteService。要安装SERVICE，需要先利用函数OpenSCManager打开SCM数据库，接着利用SERVICE的二进制文件路径调用CreateService，在调用CreateService时需要为SERVICE指定名称，原因是使用DeleteService删除服务时需要利用该标识。

ACE_NT_Service
查看ACE源码，其中和类 ACE_NT_Service实现密切相关的的文件有NT_Service.cpp、NT_Service.h、NT_Service.i。

ACE_NT_Service中的ServiceMain和Service Control Handler
ServiceMain和Service Control Handler定义具有固定模式，ACE_NT_Service提供宏#define ACE_NT_SERVICE_DEFINE(SVCNAME, SVCCLASS, SVCDESC)用于简化定义。具体的宏定义可以参考ACE代码，这里不再列出，这里只分析相关的类ACE_NT_Service的成员函数handle_control,init,open,wait和fini。函数handle_control被用于响应SERVICE DISPATCHER请求,其必须和SVC函数交互以影响请求控制操作。缺省实现包括SERVICE_CONTROL_STOP，SERVICE_CONTROL_PAUSE，SERVICE_CONTROL_CONTINUE，SERVICE_CONTROL_INTERROGATE，SERVICE_CONTROL_SHUTDOWN。

函数handle_control的部分关键代码解析
/* 调用stop_requested响应关闭操作 */
case SERVICE_CONTROL_SHUTDOWN:
case SERVICE_CONTROL_STOP:
this->stop_requested (control_code);
break;
/* 调用pause_requested响应挂起操作 */
case SERVICE_CONTROL_PAUSE:
this->pause_requested (control_code);
break;
/* 调用continue_requested响应挂起后启动操作 */
case SERVICE_CONTROL_CONTINUE:
this->continue_requested (control_code);
break;
/* 调用interrogate_requested报告当前状态*/
case SERVICE_CONTROL_INTERROGATE:
this->interrogate_requested (control_code);
break;

函数open 的部分关键代码解析
/* 报告状态 */
this->report_status (SERVICE_START_PENDING, 0);
/* 执行用户代码 */
int svc_return = this->svc ();

函数fini 的部分关键代码解析
/* 报告状态 */
return this->report_status (SERVICE_STOPPED, 0);

函数stop_requested的部分关键代码解析
/* 报告状态 */
this->report_status (SERVICE_STOP_PENDING);

函数pause_requested的部分关键代码解析
/* 报告状态 */
this->report_status (SERVICE_PAUSE_PENDING);
/* 挂起*/
this->suspend ();
/* 报告状态 */
this->report_status (SERVICE_PAUSED);

函数continue_requested的部分关键代码解析
/* 报告状态 */
this->report_status (SERVICE_CONTINUE_PENDING);
/* 恢复*/
this->resume ();
/* 报告状态 */
this->report_status (SERVICE_RUNNING);

函数interrogate_requested的部分关键代码解析
/* 报告状态 */
this->report_status (0);
安装/卸载SERVICE
ACE_NT_Service定义两个成员函数Insert，remove来安装（卸载）SERVICE。它们分别在内部调用WINDOWS API——CreateService以及DeleteService。

Insert函数的部分关键代码解析

/* 打开和host()上SCManager的通信 */
SC_HANDLE sc_mgr = ACE_TEXT_OpenSCManager (this->host ()，……);
/* 以名称name() 创建服务 */
SC_HANDLE sh = ACE_TEXT_CreateService (sc_mgr,this->name (),this->desc (),
SERVICE_ALL_ACCESS,this->svc_status_.dwServiceType,start_type,
error_control,exe_path,……);
/* 关闭和SCManager的通信 */
CloseServiceHandle (sc_mgr);
/* 关闭服务句柄，重新写入新句柄 */
if (this->svc_sc_handle_ != 0)
CloseServiceHandle (this->svc_sc_handle_);
this->svc_sc_handle_ = sh;

Remove函数部分关键代码解析

/* 从SCM中删除insert创建的服务句柄 */
if (DeleteService (this->svc_sc_handle()) == 0
&& GetLastError () != ERROR_SERVICE_MARKED_FOR_DELETE)
控制SERVICE
ACE_NT_Service定义成员函数start_svc, stop_svc, pause_svc, continue_svc分别用于启动、停止、挂起和继续服务。
start_svc函数的部分关键代码解析

/* 启动服务 */
if (!ACE_TEXT_StartService (svc, argc, argv))
this->wait_for_service_state (SERVICE_RUNNING, wait_time);

stop_svc函数的部分关键代码解析

/* 关闭服务 */
if (!ControlService (svc, SERVICE_CONTROL_STOP, &this->svc_status_))
this->wait_for_service_state (SERVICE_STOPPED, wait_time);

pause_svc函数的部分关键代码解析

/* 吊起服务 */
if (!ControlService (svc, SERVICE_CONTROL_PAUSE,&this->svc_status_))
this->wait_for_service_state (SERVICE_PAUSED,wait_time);

continue_svc函数的部分关键代码解析

/* 将挂起业务重新启动 */
if (!ControlService (svc,SERVICE_CONTROL_CONTINUE,&this->svc_status_))
this->wait_for_service_state (SERVICE_RUNNING,wait_time);

一些辅助函数
svc_sc_handle部份关键代码解析

/* 打开SCM */
SC_HANDLE sc_mgr = ACE_TEXT_OpenSCManager (this->host (),……)
if (sc_mgr != 0)
{
/* 获取服务句柄 */
this->svc_sc_handle_ = ACE_TEXT_OpenService (sc_mgr,……)
/* 关闭SCM */
CloseServiceHandle (sc_mgr);
}
/* 返回获取到的服务句柄 */
return this->svc_sc_handle_;

wait_for_service_state部份关键代码解析

/* 获取当前时间 */
ACE_Time_Value time_out = ACE_OS::gettimeofday ();
/* 加上等待时间 */
if (wait_time != 0) time_out += *wait_time;
// Poll until the service reaches the desired state.
for (;
{
/* 查询当前状态 */
service_ok = 0 != QueryServiceStatus (this->svc_sc_handle_, &this->svc_status_);
/* 如果已经到达指定状态，退出循环 */
if (desired_state == this->svc_status_.dwCurrentState) break;
/* 如果超出指定时间，退出循环 */
if (wait_time != 0 && ACE_OS::gettimeofday () > time_out )
{ ……
break;
}
/* 睡眠等待 */
::Sleep (this->svc_status_.dwWaitHint);
}

report_status部份关键代码解析
/* 告诉系统服务新的状态 */
SetServiceStatus (this->svc_handle_,&this->svc_status_) ? 0 : -1;

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=748930

true 2007-04-24 17:55 发表评论

C10k[转]

true — Thu, 05 Apr 2007 01:00:00 GMT

摘要

编写连接数巨大的高负载服务器程序时，经典的多线程模式和select模式都不再适用。
应当抛弃它们，采用epoll/kqueue/dev_poll来捕获I/O事件。最后简要介绍了AIO。

由来

网络服务在处理数以万计的客户端连接时，往往出现效率低下甚至完全瘫痪，这被称为
C10K问题。随着互联网的迅速发展，越来越多的网络服务开始面临C10K问题，作为大型
网站的开发人员有必要对C10K问题有一定的了解。本文的主要参考文献是
<http://www.kegel.com/c10k.html> http://www.kegel.com/c10k.htmls。

C10K问题的最大特点是：设计不够良好的程序，其性能和连接数及机器性能的关系往往
是非线性的。举个例子：如果没有考虑过C10K问题，一个经典的基于select的程序能在
旧服务器上很好处理1000并发的吞吐量，它在2倍性能新服务器上往往处理不了并发
2000的吞吐量。

这是因为在策略不当时，大量操作的消耗和当前连接数n成线性相关。会导致单个任务
的资源消耗和当前连接数的关系会是O(n)。而服务程序需要同时对数以万计的socket进
行I/O处理，积累下来的资源消耗会相当可观，这显然会导致系统吞吐量不能和机器性
能匹配。为解决这个问题，必须改变对连接提供服务的策略。

基本策略

主要有两方面的策略：1.应用软件以何种方式和操作系统合作，获取I/O事件并调度多
个socket上的I/O操作；2. 应用软件以何种方式处理任务和线程/进程的关系。前者主
要有阻塞I/O、非阻塞I/O、异步I/O这3种方案，后者主要有每任务1进程、每任务1线
程、单线程、多任务共享线程池以及一些更复杂的变种方案。常用的经典策略如下：

1.         Serve one client with each thread/process, and use blocking I/O
这是小程序和java常用的策略，对于交互式的长连接应用也是常见的选择(比如BBS)。
这种策略很能难足高性能程序的需求，好处是实现极其简单，容易嵌入复杂的交互逻
辑。Apache、ftpd等都是这种工作模式。

2.         Serve many clients with single thread, and use nonblocking I/O
and readiness notification
这是经典模型，datapipe等程序都是如此实现的。优点在于实现较简单，方便移植，也
能提供足够的性能；缺点在于无法充分利用多CPU的机器。尤其是程序本身没有复杂的
业务逻辑时。

3.         Serve many clients with each thread, and use nonblocking I/O and
readiness notification
对经典模型2的简单改进，缺点是容易在多线程并发上出bug，甚至某些OS不支持多线程
操作readiness notification。

4.         Serve many clients with each thread, and use asynchronous I/O
在有AI/O支持的OS上，能提供相当高的性能。不过AI/O编程模型和经典模型差别相当
大，基本上很难写出一个框架同时支持AI/O和经典模型，降低了程序的可移植性。在
Windows上，这基本上是唯一的可选方案。

本文主要讨论模型2的细节，也就是在模型2下应用软件如何处理Socket I/O。

select 与 poll

最原始的同步阻塞 I/O 模型的典型流程如下：

同步阻塞 I/O 模型的典型流程

从应用程序的角度来说，read 调用会延续很长时间，应用程序需要相当多线程来解决
并发访问问题。同步非阻塞I/O对此有所改进：

经典的单线程服务器程序结构往往如下：

do {

         Get Readiness Notification of all sockets

         Dispatch ready handles to corresponding handlers

                   If (readable) {
                            read the socket

                            If (read done)

                                     Handler process the request
                   }

                   if (writable)

                            write response

                   if (nothing to do)

                            close socket

} while(True)

非阻塞 I/O 模型的典型流程:

异步阻塞 I/O 模型的典型流程

其中关键的部分是readiness notification，找出哪一个socket上面发生了I/O事件。
一般从教科书和例子程序中首先学到的是用select来实现。Select定义如下：

int select(int n, fd_set *rd_fds, fd_set *wr_fds, fd_set *ex_fds, struct
timeval *timeout);

Select用到了fd_set结构，从man page里可以知道fd_set能容纳的句柄和FD_SETSIZE相
关。实际上fd_set在*nix下是一个bit标志数组，每个bit表示对应下标的fd是不是在
fd_set中。fd_set只能容纳编号小于 FD_SETSIZE的那些句柄。

FD_SETSIZE默认是1024，如果向fd_set里放入过大的句柄，数组越界以后程序就会垮
掉。系统默认限制了一个进程最大的句柄号不超过1024，但是可以通过ulimit -n命令
/setrlimit函数来扩大这一限制。如果不幸一个程序在FD_SETSIZE=1024的环境下编
译，运行时又遇到ulimit –n > 1024的，那就只有祈求上帝保佑不会垮掉了。

在ACE环境中，ACE_Select_Reactor针对这一点特别作了保护措施，但是还是有recv_n
这样的函数间接的使用了select，这需要大家注意。

针对fd_set的问题，*nix提供了poll函数作为select的一个替代品。Poll的接口如下：

int poll(struct pollfd *ufds, unsigned int nfds, int timeout);

第1个参数ufds是用户提供的一个pollfd数组，数组大小由用户自行决定，因此避免了
FD_SETSIZE带来的麻烦。Ufds是fd_set的一个完全替代品，从select到poll的移植很方
便。到此为止，至少我们面对C10K，可以写出一个能work的程序了。

然而Select和Poll在连接数增加时，性能急剧下降。这有两方面的原因：首先操作系统
面对每次的select/poll操作，都需要重新建立一个当前线程的关心事件列表，并把线
程挂在这个复杂的等待队列上，这是相当耗时的。其次，应用软件在select/poll返回
后也需要对传入的句柄列表做一次扫描来dispatch，这也是很耗时的。这两件事都是和
并发数相关，而I/O事件的密度也和并发数相关，导致CPU占用率和并发数近似成O(n2)
的关系。

epoll, kqueue, /dev/poll

因为以上的原因，*nix的hacker们开发了epoll, kqueue, /dev/poll这3套利器来帮助
大家，让我们跪拜三分钟来感谢这些大神。其中epoll是linux的方案，kqueue是
freebsd的方案，/dev/poll是最古老的Solaris的方案，使用难度依次递增。

简单的说，这些api做了两件事：1.避免了每次调用select/poll时kernel分析参数建立
事件等待结构的开销，kernel维护一个长期的事件关注列表，应用程序通过句柄修改这
个列表和捕获I/O事件。2.避免了select/poll返回后，应用程序扫描整个句柄表的开
销，Kernel直接返回具体的事件列表给应用程序。

在接触具体api之前，先了解一下边缘触发(edge trigger)和条件触发(level trigger)
的概念。边缘触发是指每当状态变化时发生一个io事件，条件触发是只要满足条件就发
生一个io事件。举个读socket的例子，假定经过长时间的沉默后，现在来了100个字
节，这时无论边缘触发和条件触发都会产生一个read ready notification通知应用程
序可读。应用程序读了50个字节，然后重新调用api等待io事件。这时条件触发的api会
因为还有50个字节可读从而立即返回用户一个read ready notification。而边缘触发
的api会因为可读这个状态没有发生变化而陷入长期等待。

因此在使用边缘触发的api时，要注意每次都要读到socket返回EWOULDBLOCK为止，否则
这个socket就算废了。而使用条件触发的api时，如果应用程序不需要写就不要关注
socket可写的事件，否则就会无限次的立即返回一个write ready notification。大家
常用的select就是属于条件触发这一类，以前本人就犯过长期关注socket写事件从而
CPU 100%的毛病。

epoll的相关调用如下：

int epoll_create(int size)

int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event)

int epoll_wait(int epfd, struct epoll_event * events, int maxevents, int
timeout)

epoll_create创建kernel中的关注事件表，相当于创建fd_set。

epoll_ctl修改这个表，相当于FD_SET等操作

epoll_wait等待I/O事件发生，相当于select/poll函数

epoll完全是select/poll的升级版，支持的事件完全一致。并且epoll同时支持边缘触
发和条件触发，一般来讲边缘触发的性能要好一些。这里有个简单的例子：

struct epoll_event ev, *events;

int kdpfd = epoll_create(100);

ev.events = EPOLLIN | EPOLLET;  // 注意这个EPOLLET，指定了边缘触发

ev.data.fd =listener;

epoll_ctl(kdpfd, EPOLL_CTL_ADD, listener, &ev);

for(;;) {

   nfds = epoll_wait(kdpfd, events, maxevents, -1);

   for(n = 0; n < nfds; ++n) {

       if(events[n].data.fd == listener) {

           client = accept(listener, (struct sockaddr *) &local,

                           &addrlen);

           if(client < 0){

               perror("accept");

               continue;

           }

           setnonblocking(client);

           ev.events = EPOLLIN | EPOLLET;

           ev.data.fd = client;

           if (epoll_ctl(kdpfd, EPOLL_CTL_ADD, client, &ev) < 0) {

               fprintf(stderr, "epoll set insertion error: fd=%d0,

                       client);

               return -1;

           }

       }

       else

           do_use_fd(events[n].data.fd);

   }

}

简单介绍一下kqueue和/dev/poll

kqueue是freebsd的宠儿，kqueue实际上是一个功能相当丰富的kernel事件队列，它不
仅仅是select/poll的升级，而且可以处理signal、目录结构变化、进程等多种事件。
Kqueue是边缘触发的

/dev/poll是Solaris的产物，是这一系列高性能API中最早出现的。Kernel提供一个特
殊的设备文件/dev/poll。应用程序打开这个文件得到操纵fd_set的句柄，通过写入
pollfd来修改它，一个特殊ioctl调用用来替换select。由于出现的年代比较早，所以
/dev/poll的接口现在看上去比较笨拙可笑。

C++开发：ACE 5.5以上版本提供了ACE_Dev_Poll_Reactor封装了epoll和/dev/poll两种
api，需要分别在config.h中定义ACE_HAS_EPOLL和ACE_HAS_DEV_POLL来启用。

Java开发： JDK 1.6的Selector提供了对epoll的支持，JDK1.4提供了对/dev/poll的支
持。只要选择足够高的JDK版本就行了。

异步I/O以及Windows

和经典模型不同，异步I/O提供了另一种思路。和传统的同步I/O不同，异步I/O允许进
程发起很多 I/O 操作，而不用阻塞或等待任何操作完成。稍后或在接收到 I/O 操作完
成的通知时，进程就可以检索 I/O 操作的结果。

异步非阻塞 I/O 模型是一种处理与 I/O 重叠进行的模型。读请求会立即返回，说明
read 请求已经成功发起了。在后台完成读操作时，应用程序然后会执行其他处理操
作。当 read 的响应到达时，就会产生一个信号或执行一个基于线程的回调函数来完成
这次 I/O 处理过程。异步I/O 模型的典型流程：

异步非阻塞 I/O 模型的典型流程

对于文件操作而言，AIO有一个附带的好处：应用程序将多个细碎的磁盘请求并发的提
交给操作系统后，操作系统有机会对这些请求进行合并和重新排序，这对同步调用而言
是不可能的——除非创建和请求数目同样多的线程。

Linux Kernel 2.6提供了对AIO的有限支持——仅支持文件系统。libc也许能通过来线
程来模拟socket的AIO，不过这对性能没意义。总的来说Linux的aio还不成熟

Windows对AIO的支持很好，有IOCP队列和IPCP回调两种方式，甚至提供了用户级异步调
用APC功能。Windows下AIO是唯一可用的高性能方案，详情请参考MSDN

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=1537545

true 2007-04-05 09:00 发表评论

在ACE中使用epoll[zhuan]

true — Thu, 05 Apr 2007 00:32:00 GMT

在ACE中使用epoll

2007-01-18 15:56

星期四, 六月 8th, 2006

        很显然，文章的标题决定了我们是在linux下使用ACE。我们知道ACE在linux下缺省是用select来实现Reactor的，epoll相对于select的好处这里就不再啰嗦了，我们直接讲操作步骤:
    第一：重新编译ACE库
     ACE库中通过ACE_Dev_Poll_Reactor类来支持epoll,但是ACE库缺省的安装是没有编译这个类的，我们要做的就是将ACE_Dev_Poll_Reactor编译连接到ACE库中(faint,又要重新编译ACE，在我那台破服务器上编译一次需要一个多小时).我的操作系统是Redhat linux AS4.0,ACE的版本是5.4.10。根据ACE压缩包中的ACE-INSTALL.html，我是用”Building ACE with GNU Autoconf“这种方式来安装的，安装步骤如下(很简单,就不翻译了):
       1 cd to the top-level ACE_wrappers directory.

2.Create a subdirectory to hold your build’s configuration and built ACE version, and then change to the new directory:

mkdir build

cd build

3.Note that you do not run the create_ace_build.pl utility mentioned in the Cloning the Source Tree section. The configure script takes care of creating all files and links that are needed.

Configure ACE for your platform by issuing the following command: c

../configure [options]

4.Build ACE by typing make.

5. Install ACE by typing make install.
好，现在终于可以讲如何将ACE_Dev_Poll_Reactor编译到ACE库中去了。在上述的第一步和第二步之间修改ACE_wrappers/ace/config-linux.h,增加一行：#define ACE_HAS_EVENT_POLL，然后执行第2、3步，第3步../configure执行完之后，build目录下会生成一些文件和目录，打开ACE_wrappers/build/ace/config.h,增加一行：#define ACE_HAS_EVENT_POLL。然后执行第4步make和第5步make install.OK，在漫长的编译以后，支持epoll的ACE库总算完成了。

     第二：修改应用程序
        应用程序修改很简单，两行代码搞掂,在应用程序初始化时(必须是在第一次使用ACE_Reactor::instance()之间)加入:

        m_pDevPollReactor=new ACE_Dev_Poll_Reactor;
       ACE_Reactor::instance(new ACE_Reactor(m_pDevPollReactor));

       那么在后续的对ACE_Reactor::instance()的调用就是使用ACE_Dev_Poll_Reactor的实现了。

   第三：重新编译应用程序

        在应用程序的makefile中加入 -DACE_HAS_EVENT_POLL,重新make应用程序。OK,打完收工。

true 2007-04-05 08:32 发表评论