erlang定时器的强度测试

erlang的定时器在做网络程序的时候几乎无所不在， 语法层面的receive after，IO操作超时，driver内部等都大量使用timer,特别是tcp 在发送接收都有个超时。 如果你有大量的tcp链接， 就意味着大量的定时器。 那么定时器的性能就是个很大的考验。erts的定时器是个timer_wheel实现， 和linux内核用的差不多，大概支持百万级别的规模。 测试如下：

并发开N个进程 每个进程里面0-10秒的随机定时，模拟tcp超时的情况。每个定时器事件的流程是这样的 进程检查消息队列 没消息 注册定时器事件 进程换出 定时器超时 进程换入 处理定时器事件。

root@nd-desktop:~/test# cat ttimer.erl
-module(ttimer).
-export([start/1]).

upmap(F, L) ->
    Parent = self(),
    Ref = make_ref(),
    [receive {Ref, Result} -> Result end
     || _ <- [spawn(fun() -> Parent ! {Ref, F(X)} end) || X <- L]].

loop(0)->
    ok;

loop(Cnt)->
        receive after random:uniform(10000) -> cont end,
        loop(Cnt-1).

start([A1, A2]) ->
         Start= now(),
         N= list_to_integer(atom_to_list(A1)),
         Cnt = list_to_integer(atom_to_list(A2)),
         io:format("spawn ~w process, loop ~w~n", [N, Cnt]),
         upmap(fun loop/1, lists:duplicate(N, Cnt)),
         io:format("run ~w ms~n", [round(timer:now_diff(now(), Start) /1000)]),
         done.


root@nd-desktop:~/test# erl -smp disable -noshell +P 9999999 -s ttimer start 500000 10 -s erlang halt
spawn 500000 process, loop 10
run 63201 ms

单cpu保持在70-80%， 63秒处理了500W个定时器事件， 大概每秒8W.

root@nd-desktop:~/test# cat /proc/cpuinfo
model name      : Pentium(R) Dual-Core  CPU      E5200  @ 2.50GHz
bogomips        : 4987.08

结论： 定时器处理还是比较费时间的。

E2160 超频至 2.25GHz
leopard 10.5.7
erlang 5.6.5

-my-workstation-:erlangs peter$ erl -smp disable -noshell +P 9999999 -s ttimer start 500000 10 -s erlang halt
spawn 500000 process, loop 10
run 61181 ms

还是你家CPU cool点。。。

我这边程序发现，启动大量erlang进程，估计一万吧，然后每个进程receive after end,after 是2分钟，结果，如果有其他进程去给这一万个进程的某个发消息，就会不断timeout了，我理解 调度器 会把recieve等待消息的进程挂起，收到消息时，再重新转入调度队列，从我程序的结果看，erlang调度器处理这上万进程，还是有问题的

每个定时器事件的流程是这样的 进程检查消息队列 没消息 注册定时器事件 进程换出 定时器超时 进程换入 处理定时器事件。 所以有大量的消息拷贝 进程调度。 erlang的进程给另一个进程发送消息的流程是这样的：消息放到对端的队列 同时如果对端不是可运行的，加入运行队列。 调度器最终调度对端， 对端取出消息，进行处理。

我现在在用 gen_fsm:send_event_after 来实现游戏中的恢复体力的逻辑

不知道它和 erlang:send_after,timer:send_after 有啥区别？
看它的说明都是创建一个 timer, 为啥在很多模块里面都有 类似的函数？

% Returns Ref, sends event {timeout,Ref,Msg} after Time                                                                                                                          
%% to the (then) current state.                                                                                                                                                   
start_timer(Time, Msg) ->
    erlang:start_timer(Time, self(), {'$gen_timer', Msg}).

%% Returns Ref, sends Event after Time to the (then) current state.                                                                                                               
send_event_after(Time, Event) ->
    erlang:start_timer(Time, self(), {'$gen_event', Event}).

%% Returns the remaing time for the timer if Ref referred to                                                                                                                      
%% an active timer/send_event_after, false otherwise.                                                                                                                             
cancel_timer(Ref) ->
    case erlang:cancel_timer(Ref) of
        false ->
            receive {timeout, Ref, _} -> 0
            after 0 -> false
            end;
        RemainingTime ->
            RemainingTime
    end.



timer是单进程设计 会有很大的性能瓶颈，gen_fsm的就没有问题。