diff_list() ->
    {ok, Cwd} = file:get_cwd(),
    Filelist = filelib:fold_files( Cwd ++ "/../ebin", ".beam", true, fun(File, Acc) -> [File|Acc] end, []),

    F = fun(File,Acc0) ->
        {ok,{Module,NewVsn}} = beam_lib:version(File),

        List = Module:module_info(attributes),
        case lists:keyfind(vsn, 1, List) of
            {vsn,NewVsn} ->
                Acc0;
            _ ->
                [Module|Acc0]
        end
    end,
    lists:foldl(F, [], Filelist).

send_after(Time, Pid, Message) -> 
    req(apply_after, {Time, {?MODULE, send, [Pid, Message]}})

req(Req, Arg) ->
    SysTime = system_time(),
    ensure_started(),
    gen_server:call(timer_server, {Req, Arg, SysTime}, infinity)

handle_call({apply_after, {Time, Op}, Started}, _From, _Ts)
  when is_integer(Time), Time >= 0 ->
    BRef = {Started + 1000*Time, make_ref()},   %返回给调用进程的数据，{到期时间，ref}
    Timer = {BRef, timeout, Op},  
    ets:insert(?TIMER_TAB, Timer),  %插入定时ets表
    Timeout = timer_timeout(system_time()),  
    {reply, {ok, BRef}, [], Timeout};   %这里返回值带有Timout参数，如果超时未能收到其它消息，将会触发超时

%%超时处理函数
timer_timeout(SysTime) ->
    case ets:first(?TIMER_TAB) of
 '$end_of_table' ->
     infinity;
 {Time, _Ref} when Time > SysTime ->
     Timeout = (Time - SysTime + 999) div 1000,
     %% Returned timeout must fit in a small int
     erlang:min(Timeout, ?MAX_TIMEOUT);
 Key ->
     case ets:lookup(?TIMER_TAB, Key) of
  [{Key, timeout, MFA}] ->
      ets:delete(?TIMER_TAB,Key),
      do_apply(MFA),
      timer_timeout(SysTime);
  [{{Time, Ref}, Repeat = {repeat, Interv, To}, MFA}] ->
      ets:delete(?TIMER_TAB,Key),
      NewTime = Time + Interv,
      %% Update the interval entry (last in table)
      ets:insert(?INTERVAL_TAB,{{interval,Ref},{NewTime,Ref},To}),
      do_apply(MFA),
      ets:insert(?TIMER_TAB, {{NewTime, Ref}, Repeat, MFA}),
      timer_timeout(SysTime)
     end
    end.


%%超时后执行相应的操作
%% Help functions
do_apply({M,F,A}) ->
    case {M, F, A} of
 {?MODULE, send, A} -> %发送消息
     %% If send op. send directly, (faster than spawn)
     catch send(A);
 {erlang, exit, [Name, Reason]} ->
     catch exit(get_pid(Name), Reason);
 _ ->
     %% else spawn process with the operation
     catch spawn(M,F,A)       %开启新进程，执行M:F(A), 由timer:apply_after/4调用
    end.

%%gen_server主循环
loop(Parent, Name, State, Mod, hibernate, Debug) ->
    proc_lib:hibernate(?MODULE,wake_hib,[Parent, Name, State, Mod, Debug]);
loop(Parent, Name, State, Mod, Time, Debug) ->
    Msg = receive
       Input ->
      Input
   after Time -> 　%超时则产生一个timeout消息
    timeout
   end,
    decode_msg(Msg, Parent, Name, State, Mod, Time, Debug, false)

exit(Reason)
erlang:error(Reason)
erlang:error(Reason, Args)

process_flag(trap_exit, true)

{'EXIT',FromPid, Reason}

{'DOWN', Ref, process, Pid2, Reason}

([email protected])3> AccInfo = #account_info{account="abc", role_ids = []}.
#account_info{account = "abc",role_ids = []}
([email protected])5> lager:pr(AccInfo,login_mgr). 
{'$lager_record',account_info,
                 [{account,"abc"},{role_ids,[]}]}

lager:trace_console([{module, mymodule}], error)
lager:trace_console([{module, mymodule}]) % default loglevel is debug

{ok, Trace} = lager:trace_file("log/error.log", [{module, mymodule}]),
lager:stop_trace(Trace)

([email protected])6> lager:status().
Lager status:
Console (lager_event) at level info
File log/error.log (lager_event) at level error
File log/console.log (lager_event) at level info
Active Traces:
Tracing Reductions:
Tracing Statistics:
  input: 0
 output: 0
 filter: 0
ok

{lager, [
  {handlers, [...]},
  {traces, [
    %% handler,                         filter,                message level (defaults to debug if not given)
    {lager_console_backend,             [{module, foo}],       info },
    {{lager_file_backend, "trace.log"}, [{request, '>', 120}], error},
    {{lager_file_backend, "event.log"}, [{module, bar}]             } %% implied debug level here
  ]}
]}.

   fprof:trace([start, {procs, all}]). % 跟踪所有文件，all可以替换成pid, 或者[pid,...]
   fprof:trace(stop).
   fprof:profile().
   fprof:analyse().  % 指定输出文件到文件，fprof:analyse([{dest, "result.txt"}])

{ok, Tracer} = fprof:profile(start),
fprof:trace([start, {tracer, Tracer}]),
%% Code to profile
fprof:trace(stop);

eprof:start().
eprof:start_profiling([Pid]).
eprof:stop_profiling().
eprof:log(FileName). % 后续的分析报告同时保存到文件中，没有这一步只会打印到shell中
eprof:analyze(). % 生成分析报告

([email protected])3> erlang:system_info(process_limit).
262144
([email protected])4> erlang:system_info(port_limit).   
8192
([email protected])5> erlang:system_info(ets_limit). 
2053

erlang:system_info(process_count)
erlang:system_info(port_count)
erlang:system_info(ets_count)

%% 启动进程池
PoolArgs = [{name, {local, my_pool}}, {worker_module, test_proc},{size, 15000}, {max_overflow, 0}],
poolboy:start_link(PoolArgs),

%% 从进程池中获取一个进程
Worker = poolboy:checkout(Pool)
%% 释放一个进程到池中
poolboy:checkin(Pool, Worker)

code(File)->
    {ok,{_Mod, [{abstract_code, {_X, Ac}}]}} = beam_lib:chunks(File,[abstract_code]),
    Src = erl_prettypr:format(erl_syntax:form_list(Ac)),
    file:write_file(File++".erl",Src).

call(N,M,F,A,infinity) when node() =:= N ->  %% Optimize local call
    local_call(M,F,A);
call(N,M,F,A,infinity) ->
    do_call(N, {call,M,F,A,group_leader()}, infinity);
call(N,M,F,A,Timeout) when is_integer(Timeout), Timeout >= 0 ->
    do_call(N, {call,M,F,A,group_leader()}, Timeout).

local_call(M, F, A) when is_atom(M), is_atom(F), is_list(A) ->
    case catch apply(M, F, A) of
    {'EXIT',_}=V -> {badrpc, V};
    Other -> Other
    end.

do_call(Node, Request, infinity) ->
    rpc_check(catch gen_server:call({?NAME,Node}, Request, infinity));
do_call(Node, Request, Timeout) ->
    Tag = make_ref(),
    {Receiver,Mref} =
    erlang:spawn_monitor(
      fun() ->
          %% Middleman process. Should be unsensitive to regular
          %% exit signals.
          process_flag(trap_exit, true),
          Result = gen_server:call({?NAME,Node}, Request, Timeout),
          exit({self(),Tag,Result})
      end),
    receive
    {'DOWN',Mref,_,_,{Receiver,Tag,Result}} ->
        rpc_check(Result);
    {'DOWN',Mref,_,_,Reason} ->
        %% The middleman code failed. Or someone did 
        %% exit(_, kill) on the middleman process => Reason==killed
        rpc_check_t({'EXIT',Reason})
    end.

handle_info({From, {call,Mod,Fun,Args,Gleader}}, S) ->
    %% Special for hidden C node's, uugh ...
    handle_call_call(Mod, Fun, Args, Gleader, {From,?NAME}, S);

handle_call_call(Mod, Fun, Args, Gleader, To, S) ->
    RpcServer = self(),
    %% Spawn not to block the rpc server.
    {Caller,_} =
    erlang:spawn_monitor(
      fun () ->
          set_group_leader(Gleader),
          Reply = 
              %% in case some sucker rex'es 
              %% something that throws
              case catch apply(Mod, Fun, Args) of
              {'EXIT', _} = Exit ->
                  {badrpc, Exit};
              Result ->
                  Result
              end,
          RpcServer ! {self(), {reply, Reply}}
      end),
    {noreply, gb_trees:insert(Caller, To, S)}.

handle_info({Caller, {reply, Reply}}, S) ->
    case gb_trees:lookup(Caller, S) of
    {value, To} ->
        receive
        {'DOWN', _, process, Caller, _} -> 
            gen_server:reply(To, Reply),
            {noreply, gb_trees:delete(Caller, S)}
        end;
    none ->
        {noreply, S}
    end;

handle_call({block_call, Mod, Fun, Args, Gleader}, _To, S) ->
    MyGL = group_leader(),
    set_group_leader(Gleader),
    Reply = 
    case catch apply(Mod,Fun,Args) of
        {'EXIT', _} = Exit ->
        {badrpc, Exit};
        Other ->
        Other
    end,
    group_leader(MyGL, self()), % restore
    {reply, Reply, S};

cast(Node, Mod, Fun, Args) when Node =:= node() ->
    catch spawn(Mod, Fun, Args),
    true;
cast(Node, Mod, Fun, Args) ->
    gen_server:cast({?NAME,Node}, {cast,Mod,Fun,Args,group_leader()}),
    true.

handle_cast({cast, Mod, Fun, Args, Gleader}, S) ->
    spawn(fun() ->
          set_group_leader(Gleader),
          apply(Mod, Fun, Args)
      end),
    {noreply, S};

%% test_server.erl
-module(test_server).
-export([start/0]).
start() ->
    ok = inets:start(),
    {ok, Pid} = inets:start(httpd, [{proplist_file, "test_server.config"}]),
    io:format("server info:~p", [httpd:info(Pid)]),
    ok.

%% test.erl
-module(test).
-export([server_list/3]).
server_list(SesstionId, Env, Input) ->
    io:format("Env:~p", [Env]),
    io:format("Input:~p", [Input]),
    mod_esi:deliver(SesstionId, "hello world"),
    ok.

[{port, 8090},
 {server_name, "httpd_test"},
 {server_root,"e:/test"},
 {document_root, "e:/test"},
 {erl_script_alias, {"", [test]}},
 {modules, [mod_esi]}
].

1> test_server:start().
server info:[{mime_types,[{"htm","text/html"},{"html","text/html"}]},
             {ipfamily,inet},
             {server_name,"httpd_test"},
             {bind_address,any},
             {modules,[mod_esi]},
             {server_root,"e:/test"},
             {erl_script_alias,{[],[test]}},
             {port,8090},
             {document_root,"e:/test"}]ok
2> Env:[{server_software,"inets/6.2"},
     {server_name,"admin-PC"},
     {gateway_interface,"CGI/1.1"},
     {server_protocol,"HTTP/1.1"},
     {server_port,8090},
     {request_method,"GET"},
     {remote_addr,"127.0.0.1"},
     {script_name,"/test/server_list?adb=3"},
     {http_host,"127.0.0.1:8090"},
     {http_connection,"keep-alive"},
     {http_cache_control,"max-age=0"},
     {http_upgrade_insecure_requests,"1"},
     {http_user_agent,"Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/51.0.2704.103 Safari/537.36"},
     {http_accept,"text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8"},
     {http_accept_encoding,"gzip, deflate, sdch"},
     {http_accept_language,"zh-CN,zh;q=0.8"},
     {query_string,"adb=3"}]2>
     Input:"adb=3"2>

8> erlang:load_nif("debug/erl_nif",0).
{error,{load_failed,"Failed to load NIF library debug/erl_nif: '找不到指定的模块。'"}}

9> erlang:load_nif("release/erl_nif",0).
{error,{bad_lib,"Library module name 'erl_nif' does not match calling module 'erl_eval'"}}

{port_specs, [
    %{"win", "priv/test.dll",["c_src/test.c"]},
    {"priv/test.so",["c_src/test.c"]}
]}.

C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\bin;
C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC;

{port_env, [{"win32", "CC", "gcc.exe"},
            {"win32", "LINKER", "ld.exe"},
            {"win32", "CFLAGS", "-O3 -march=native $ERL_CFLAGS"},
            {"win32", "DRV_CFLAGS", "-g -Wall $ERL_CFLAGS"},
            {"win32", "DRV_LDFLAGS", "-shared $ERL_LDFLAGS"},
            {"win32", "DRV_CC_TEMPLATE", "$CC -c $CFLAGS $DRV_CFLAGS $PORT_IN_FILES -o $PORT_OUT_FILE"},
            {"win32", "DRV_LINK_TEMPLATE", "$LINKER $PORT_IN_FILES $LDFLAGS $DRV_LDFLAGS -o $PORT_OUT_FILE"},
            {"win32", "ERL_LDFLAGS", " -L$ERL_EI_LIBDIR -lerl_interface -lei"}
           ]}.