一、基本概念

在Erlang中，通过两个概念管理错误事情：事件管理器(event manager)和事件处理句柄(event handles)。通常各种错误、警告和消息事件都会有Erlang运行时系统发送给事件管理器。在Erlang中，默认的事情管理器为error logger，其进程名注册为error_logger。默认情况下error_logger把这些事件直接输出到控制台上。

       在系统启动的一开始，error_logger只有一个简单的事件处理句柄，该处理句柄只是做缓冲和原始格式的打印操作。查看error_logger的源码，可以看到其启动过程如下：

-spec start() -> {'ok', pid()} | {'error', any()}.

start() ->

    case gen_event:start({local, error_logger}) of

    {ok, Pid} ->

        simple_logger(?buffer_size),

        {ok, Pid};

    Error -> Error

    end.

-spec start_link() -> {'ok', pid()} | {'error', any()}.

start_link() ->

    case gen_event:start_link({local, error_logger}) of

    {ok, Pid} ->

        simple_logger(?buffer_size),

        {ok, Pid};

    Error -> Error

end.

OK，只是简单的注册了一个进程，看看simple_logger的内容：

simple_logger(Buffer_size) when is_integer(Buffer_size) ->

gen_event:add_handler(error_logger, error_logger, Buffer_size).

看来error_logger在一开始的时候除了充当manager，也担当了handler的角色。

在启动的过程中，kernel application使用一个标准的事件处理句柄来代替之前的那个简单版本，这个版本会将输出到控制台的结果做个漂亮的格式化。当然，可以通过kernel的配置选项来修改上述行为，例如将结果输出到文件或者干脆什么都不干（忽略任何event）。口说无凭，还是继续看源码吧：

kernel.erl文件：

start(_, []) ->

    case supervisor:start_link({local, kernel_sup}, kernel, []) of

    {ok, Pid} ->

        Type = get_error_logger_type(),

        error_logger:swap_handler(Type),

        {ok, Pid, []};

    Error -> Error

end.

首先，kernel把自己注册为一个名为kernel_sup的监控树进程，其次立刻就更换了error_logger的处理句柄。go on：

get_error_logger_type() ->

    case application:get_env(kernel, error_logger) of

    {ok, tty} -> tty;

    {ok, {file, File}} when is_list(File) -> {logfile, File};

    {ok, false} -> false;

    {ok, silent} -> silent;

    undefined -> tty; % default value

    {ok, Bad} -> exit({bad_config, {kernel, {error_logger, Bad}}})

end.

代码很容易理解，根据配置来决定以何种方式处理日志。

二、定制Kernel选项

继续接着上面的代码往下走：

swap_handler(tty) ->

    gen_event:swap_handler(error_logger, {error_logger, swap},

              {error_logger_tty_h, []}),

    simple_logger();

swap_handler({logfile, File}) ->

    gen_event:swap_handler(error_logger, {error_logger, swap},

              {error_logger_file_h, File}),

    simple_logger();

swap_handler(silent) ->

    gen_event:delete_handler(error_logger, error_logger, delete),

    simple_logger();

swap_handler(false) ->

ok. % keep primitive event handler as-is

可以看出，如果我们真的希望什么都不做，那么应该传递参数 silent，而不是false，因为false情况下原来的原始处理句柄并没有被移除掉。

打开命令提示符，做个简单的实验(>表示命令提示符)：

实验一，定制为false参数：

> erl -kernel error_logger false  //传递false参数

2> error_logger:error_msg("Haha").  // 尝试产生一个error event

ok{error_logger,{{

2010,2> 3,10},{15,9,1}},"Haha",[]}  //这里是结果

实验二，定制为silent参数：

> erl -kernel error_logger silent  //传递silent 参数

1>  error_logger:error_msg("Haha").

ok   // 看到这里只有ok，没有其他任何信息了！

2>

三、SASL

SASL全称System Architecture Support Libraries，提供如下几个服务：

alarm_handler

overload

rb

release_handler

systools

SASL带有error_logger的事件处理句柄用于格式化SASL错误和crash报告，这些句柄如下：

sasl_report_tty_h   sasl_report_file_h   error_logger_mf_h

细节参考OTP文档可知。

SASL的默认event handler会将crash报告、supervisor和进程报告输出到控制台，如果你希望看到这些信息，那么在erlang启动时需要加上指定的参数以启动sasl。

为了方便日志的查看，通常sasl和其他日志是分开输出的，可以在启动erl时使用如下命令行参数：

-sasl sasl_error_logger {file,"/data/ log/sasl.log"}

四、站在巨人的肩膀上

这里并不打算介绍一个gen_event behavior模块的写法，而是想介绍一个非常强大、成熟的一个日志系统：ejabberd的日志系统。它包含两个部分：

dynamic_compile.erl   动态编译基础模块

ejabberd_logger_h.erl  这是个gen_event behavior模块，可以定制我们写日志的行为

ejabberd_loglevel.h    这个是ejabberd日志系统的精华，可以在运行时动态调节日志的输出级别。

用法很简单：

error_logger:add_report_handler(ejabberd_logger_h, LogPath),

ejabberd_loglevel:set(4) //级别4是info日志

原理很简单，利用code模块的load_binary来实现动态代码替换，但是确实非常强大，可以在需要的时候打开某些特定级别的日志，在系统负载高的时候或者不需要的时候关闭它。

第一组，map和list comprehensions对比，代码如下：

%%map方式

-module(map_test).

-export([start/1]).

start(N) ->

        statistics(runtime),

        erlang:statistics(wall_clock),

        lists:map(fun (X) -> X*X end, lists:seq(1, N)),

        {_, T1} = erlang:statistics(runtime),

        {_, T2} = erlang:statistics(wall_clock),

        io:format("total times: ~p, load time: ~p (~p)", [N, T1, T2]).

%%list comprehensions方式

-module(list_comp_test).

-export([start/1]).

start(N) ->

        statistics(runtime),

        erlang:statistics(wall_clock),

        [X*X || X <- lists:seq(1, N)],

        {_, T1} = erlang:statistics(runtime),

        {_, T2} = erlang:statistics(wall_clock),

        io:format("total times: ~p, load time: ~p (~p)", [N, T1, T2]).

测试N为1000000时结果对比：

结果取得是平均值，可以很明显的看出comprehension方式性能要高。

关于filter，则类似。不再作测试。

erlang的bif中自带了md5计算函数，但是结果却是二进制的，即使转成list，也是10进制表示，google了一下得到一段代码用于获得字符串形式的md5结果（16位）：

md5(S) ->        

Md5_bin =  erlang:md5(S), 

Md5_list = binary_to_list(Md5_bin), 

lists:flatten(list_to_hex(Md5_list)). 

list_to_hex(L) -> 

lists:map(fun(X) -> int_to_hex(X) end, L). 

int_to_hex(N) when N < 256 -> 

[hex(N div 16), hex(N rem 16)]. 

hex(N) when N < 10 -> 

       $0+N; 

hex(N) when N >= 10, N < 16 ->      

$a + (N-10).

英文链接  http://sacharya.com/md5-in-erlang/

从rabbit_sup模块开始看起：

rabbit_sup模块的start_link是被rabbit app模块的start/2方法所调用的

rabbit.erl文件：

start(normal, []) ->

{ok, SupPid} = rabbit_sup:start_link(),

rabbit_sup.erl文件：

-define(SERVER, ?MODULE).

start_link() ->

supervisor:start_link({local, ?SERVER}, ?MODULE, []).

这里的?SERVER和?MODULE是一样的值，都为rabbit_sup 。

跳转到supervisor.erl文件：

start_link(SupName, Mod, Args) ->

gen_server:start_link(SupName, supervisor, {SupName, Mod, Args}, []).

看到supervisor的start_link实际上调用的是gen_server的start_link方法，调用的时候将supervisor作为一个参数传递过去了。

这样到目前为止我们的调用实际为：

gen_server:start_link({local, rabbit_sup}, supervisor, {{local, rabbit_sup}, rabbit_sup, []}, []).

gen_server.erl文件：

start_link(Mod, Args, Options) ->

    gen:start(?MODULE, link, Mod, Args, Options).

start_link(Name, Mod, Args, Options) ->

gen:start(?MODULE, link, Name, Mod, Args, Options).

gen_server的start_link方法调用了gen模块的start方法，实际调用为：

gen:start(gen_server, link, {local, rabbit_sup},supervisor, {{local, rabbit_sup}, rabbit_sup, []}, []).

gen.erl文件：

start(GenMod, LinkP, Name, Mod, Args, Options) ->

    case where(Name) of

undefined ->

    do_spawn(GenMod, LinkP, Name, Mod, Args, Options);

Pid ->

    {error, {already_started, Pid}}

end.

start之前判断是否已经创建了该process，没有则创建，有则返回错误！

do_spawn(GenMod, link, Name, Mod, Args, Options) ->

    Time = timeout(Options),

    proc_lib:start_link(?MODULE, init_it,

[GenMod, self(), self(), Name, Mod, Args, Options],

Time,

spawn_opts(Options));

do_spawn(GenMod, _, Name, Mod, Args, Options) ->

    Time = timeout(Options),

    proc_lib:start(?MODULE, init_it,

   [GenMod, self(), self, Name, Mod, Args, Options], 

   Time,

   spawn_opts(Options)).

实际又是调用了gen模块的init_it方法，采用的link的spawn方式。

init_it(GenMod, Starter, Parent, Mod, Args, Options) ->

    init_it2(GenMod, Starter, Parent, self(), Mod, Args, Options).

init_it(GenMod, Starter, Parent, Name, Mod, Args, Options) ->

    case name_register(Name) of

true ->

    init_it2(GenMod, Starter, Parent, Name, Mod, Args, Options);

{false, Pid} ->

    proc_lib:init_ack(Starter, {error, {already_started, Pid}})

    end.

首先尝试注册这个名字，如果发现已经注册，则通知父进程已经创建了。否则跳转到init_in2，

init_it2(GenMod, Starter, Parent, Name, Mod, Args, Options) ->

GenMod:init_it(Starter, Parent, Name, Mod, Args, Options).

这时又跳转到gen_server:init_it方法。

init_it(Starter, self, Name, Mod, Args, Options) ->

    init_it(Starter, self(), Name, Mod, Args, Options);

init_it(Starter, Parent, Name0, Mod, Args, Options) ->

    Name = name(Name0),

    Debug = debug_options(Name, Options),

    case catch Mod:init(Args) of

{ok, State} ->

    proc_lib:init_ack(Starter, {ok, self()}),      

    loop(Parent, Name, State, Mod, infinity, Debug);

{ok, State, Timeout} ->

    proc_lib:init_ack(Starter, {ok, self()}),      

    loop(Parent, Name, State, Mod, Timeout, Debug);

{stop, Reason} ->

    %% For consistency, we must make sure that the

    %% registered name (if any) is unregistered before

    %% the parent process is notified about the failure.

    %% (Otherwise, the parent process could get

    %% an 'already_started' error if it immediately

    %% tried starting the process again.)

    unregister_name(Name0),

    proc_lib:init_ack(Starter, {error, Reason}),

    exit(Reason);

ignore ->

    unregister_name(Name0),

    proc_lib:init_ack(Starter, ignore),

    exit(normal);

{'EXIT', Reason} ->

    unregister_name(Name0),

    proc_lib:init_ack(Starter, {error, Reason}),

    exit(Reason);

Else ->

    Error = {bad_return_value, Else},

    proc_lib:init_ack(Starter, {error, Error}),

    exit(Error)

end.

又是调用了supervisor的init方法

    init({SupName, Mod, Args}) ->

    process_flag(trap_exit, true),

    case Mod:init(Args) of

{ok, {SupFlags, StartSpec}} ->

    case init_state(SupName, SupFlags, Mod, Args) of

{ok, State} when ?is_simple(State) ->

    init_dynamic(State, StartSpec);

{ok, State} ->

    init_children(State, StartSpec);

Error ->

    {stop, {supervisor_data, Error}}

    end;

ignore ->

    ignore;

Error ->

    {stop, {bad_return, {Mod, init, Error}}}

    end.

呵呵，到了这里终于调用了rabbit_sup的init方法了，根据不同的init返回值做不同的启动子进程的操作。

诸多erlang应用都是基于erlang现有的一些application，rabbitmq也不例外，在rabbitmq中，需要的application有sasl、os_mon、mnesia。而rabbitmq启动这些application（包括其自身）的代码写的相当的巧妙：（源码基于rabbitmq 1.7.0）

文件 rabbit.erl

-define(APPS, [os_mon, mnesia, rabbit]).

start() ->

    try

        ok = prepare(),

        ok = rabbit_misc:start_applications(?APPS) 

    after

        %%give the error loggers some time to catch up

        timer:sleep(100)

    end.

stop() ->

    ok = rabbit_misc:stop_applications(?APPS).

文件 rabbit_misc.erl

manage_applications(Iterate, Do, Undo, SkipError, ErrorTag, Apps) ->

    Iterate(fun (App, Acc) ->

                    case Do(App) of

                        ok -> [App | Acc];

                        {error, {SkipError, _}} -> Acc;

                        {error, Reason} ->

                            lists:foreach(Undo, Acc),

                            throw({error, {ErrorTag, App, Reason}})

                    end

            end, [], Apps),

    ok.

start_applications(Apps) ->

    manage_applications(fun lists:foldl/3,

                        fun application:start/1,

                        fun application:stop/1,

                        already_started,

                        cannot_start_application,

                        Apps).

stop_applications(Apps) ->

    manage_applications(fun lists:foldr/3,

                        fun application:stop/1,

                        fun application:start/1,

                        not_started,

                        cannot_stop_application,

                        Apps).

顺序启动或者关闭几个application，在失败的情况下首先判断操作失败的原因，如果是已经启动或者已经停止，则跳过；如果是启动失败或者停止失败，则先依次停止或者启动之前已经操作成功的application，之后抛出异常结束进程。

关于是否使用exception风格（个人的说法，也就是非正常的返回值都以抛异常的形式返回）来编码，我产生了一些疑问，经过和同事的一些讨论，我决定做些简单的性能测试。

<?php

/**

 * Exception 简单的性能测试

 * @author Qingliang.Cn  qing.liang.cn@gmail.com

 * @created 2009-11-18 

 * @lastmodified 2009-11-18

 */

define(‘T’, 1000000);

function no_except($a, $b)

{

    if (mt_rand(1, 10) > 0){

        return $a + $b;

    }

}

function except($a, $b)

{

    try {

        if (mt_rand(1, 10) > 5){ //  0.5的概率抛出异常

            return $a + $b;

        }else{

            throw new Exception(1);

        }

    }catch (Exception $e){

        return $e->getMessage();

    }

}

echo "1. with no exception, time is:";

$begin = microtime(true);

for ($i=0; $i< T; $i++)

{

    no_except(1, 1);

}

echo microtime(true) - $begin;

echo "\r\n";

echo "2. with exception, time is:";

$begin = microtime(true);

for ($i=0; $i< T; $i++)

{

    except(1, 1);

}

echo microtime(true) - $begin;

echo "\r\n";

结果：

100000 (10W)

1. with no exception, time is:3.2554759979248

2. with exception, time is:4.2815051078796

1000000(100W)

1. with no exception, time is:31.89279794693

2. with exception, time is:39.047714948654

上面的测试结果可以看出消耗的时间是相当稳定的，直接的结果是exception比直接return要慢。 

继续分析

抛出异常的概率为0.5，也就是说：50w次的异常处理导致了11秒的性能损失。每次exception处理的消耗大概是 20 微秒，这个消耗是相当的小的。 因为一般情况下，web请求的时间都是ms级别的。

同时这里还有两点需要注意：

1. 没有使用异常的时候，代码中的逻辑判断分值必然会加多，也是一定的消耗。

2. 多数的程序exception命中率不会如上面代码中那么高（50%）。

所以在PHP中应用exception是不需要考虑性能问题的。

如有不同的观点，欢迎拍砖和讨论。 email: qing.liang.cn at gmail.com

可能是因为我刚换的4核CPU，感觉windows7的操作似乎比xp还要流畅。

跟踪了一下PHP中$_GET、$_POST的产生过程，发现通过zend提供的函数和宏可以很方便注册自己的全局数组。相关的函数和宏：

END_API int zend_register_auto_global(

char *name, //全局数组名

uint name_len,  //数组名称长度- 1

zend_auto_global_callback auto_global_callback TSRMLS_DC //数组初始化回调函数

);

#define ZEND_SET_SYMBOL(symtable, name, var) \

{ \

char *_name = (name); \

\

ZEND_SET_SYMBOL_WITH_LENGTH(symtable, _name, strlen(_name)+1, var, 1, 0); \

}

下面来注册我们的全局变量，假设我们的扩展名为test，我们在MINIT中进行注册操作。

zend_bool ming_global_callback(char *name, uint name_len TSRMLS_DC)

{

        zval *tmp;

        MAKE_STD_ZVAL(tmp);

        array_init(tmp);

        add_next_index_long(tmp,2222);

        ZEND_SET_SYMBOL(&EG(symbol_table), name, tmp);

}

PHP_MINIT_FUNCTION(test)

{

        /* If you have INI entries, uncomment these lines 

        REGISTER_INI_ENTRIES();

        */

        zend_register_auto_global("_MING", sizeof("_MING") - 1, ming_global_callback  TSRMLS_DC);

        return SUCCESS;

}

运行PHP代码 

<?php

var_dump($_MING);

结果：

array(1) {

  [0]=>

  int(2222)

}