Erlang服务器内存耗尽bug跟踪过程

本文描述朋友Erlang服务器内存耗尽bug的解决过程。
首先说明一下问题，服务器1千多人在线,16G内存快被吃光。玩家进程占用内存偏高：


接下来是解决过程。

第一步:
查看进程数目是否正常? erlang:system_info(process_count). 进程数目合理

第二步:
查看节点的内存消耗在什么地方?
> erlang:memory().
[{total,2099813400},
 {processes,1985444264},
 {processes_used,1985276128},
 {system,114369136},
 {atom,4479545},
 {atom_used,4477777},
 {binary,22756952},
 {code,10486554},
 {ets,47948808}]
显示内存大部分消耗在进程上,由此确定是进程占用了大量内存

第三步:
查看哪些进程占用内存最高?
> spawn(fun() -> etop:start([{output, text}, {interval, 1}, {lines, 20}, {sort, memory}]) end).
(以输出text方式启动etop,其间隔为1秒,输出行数为20行,按照内存排序. 这里spawn一个新进程,目的是输出etop数据时不影响erlang shell 输入.)
结果如下:
etop输出有点乱,超过一定范围变成了**,不过我们已经找到了内存占用最高的进程.

第四步:
查看占用内存最高的进程状态
> erlang:process_info(pid(0,12571,0)).           
[{current_function,{mod_player,send_msg,2}},
 {initial_call,{erlang,apply,2}},
 {status,waiting},
 {message_queue_len,0},
 {messages,[]},
 {links,[<0.12570.0>]},
 {dictionary,[]},
 {trap_exit,false},
 {error_handler,error_handler},
 {priority,normal},
 {group_leader,<0.46.0>},
 {total_heap_size,12538050},
 {heap_size,12538050},
 {stack_size,10122096},
 {reductions,3795950},
 {garbage_collection,[{min_bin_vheap_size,46368},
                      {min_heap_size,233},
                      {fullsweep_after,65535},
                      {minor_gcs,0}]},
 {suspending,[]}]

其中” {total_heap_size,12538050},” 表示占用内存为 12358050 words(32位系统word size为4,64位系统word size为8, 可以通过erlang:system_info(wordsize) 查看),在64位系统下将近100M, 太夸张了!

第五步:
手动gc回收,希望问题可以解决
>  erlang:garbage_collect(pid(0,12571,0)).
true
再次查看进程内存,发现没有任何变化!gc没有回收到任何资源,因此消耗的内存还在发挥作用,没有回收!

第六步:
不要怀疑系统,首先要怀疑自己的代码
认真观察代码,其大致结构如下:
send_msg(Socket, Pid) ->
   try
        receive
            {send, Bin} ->
                ...
            {inet_reply, _Sock, Result} ->
               ...
   catch
       _:_ ->
           send_msg(Sock, Pid)
   end.
其目的是循环等待数据,然后进行发送,其使用了try...catch捕获异常.
这段代码有问题么?
对,这段代码的确有问题, 其不是尾递归! try...catch会在stack中保存相应的信息,异常捕获需要放置在函数内部，所以send_msg最后调用的是try...catch，而不是自身，所以不是尾递归！
可以通过代码得到验证:
 cat test.erl
-module(test).
-compile([export_all]).


t1() ->
   Pid = spawn(fun() -> do_t1() end),
   send_msg(Pid, 100000).

t2() ->
   Pid = spawn(fun() -> do_t2() end),
   send_msg(Pid, 100000).

send_msg(_Pid, 0) ->
   ok;
send_msg(Pid, N) ->
   Pid ! <<2:(N)>>,
   timer:sleep(200),
   send_msg(Pid, N-1).

do_t1() ->
   erlang:garbage_collect(self()),
   Result = erlang:process_info(self(), [memory, garbage_collection]),
   io:format("~w ~n", [Result]),
   io:format("backtrace:~w~n~n", [erlang:process_display(self(), backtrace)]),
   try
     receive
         _ ->
             do_t1()
     end
   catch
     _:_ ->
         do_t1()
   end.

do_t2() ->
   erlang:garbage_collect(self()),
   Result = erlang:process_info(self(), [memory, garbage_collection]),
   io:format("~w ~n", [Result]),
   io:format("backtrace:~w~n~n", [erlang:process_display(self(), backtrace)]),
   receive
     _ ->
         do_t2()
   end.

版本1:erlc test.erl && erl -eval "test:t1()"
版本2:erlc test.erl && erl -eval "test:t2()"
你会看到版本1代码的调用堆栈在不断增长,内存也在增长, 而版本2函数调用地址保持不变,内存也没有发生变化!

总结:
1,服务器编程中,循环一定确保为尾递归
2,善于使用OTP,如果使用gen_server替换手写loop,就不会出现这个问题!

评论

9 楼 simsunny22 2015-11-06  

4年之后我才看到 慢慢的干货

8 楼 yjl49 2012-03-14  

顺便问个问题编译后的字节码咋查看？谢谢

7 楼 yjl49 2012-03-14  

litaocheng 写道

chaoslawful 写道

最好说明一下，try...catch结构中只有try block ....

顶！谢谢指点哦~~~~

文章看了几遍了，觉得原始的问题还没有解决：
以下这段代码的问题出在哪里？

send_msg(Socket, Pid) ->
   try
        receive
            {send, Bin} ->
                ...
            {inet_reply, _Sock, Result} ->
               ...
   catch
       _:_ ->
           send_msg(Sock, Pid)
   end.

按chaoslawful的说法

send_msg(Socket, Pid) ->
   try
        receive
          ...
          ...
        end
   catch
       _:_ ->
           send_msg(Sock, Pid)
   end.

这种结构的代码是没问题的(只要recive ...end 中间没有再调用send_msg/2)

6 楼 zdx3578 2012-02-29  

good 学习力

5 楼 expp 2011-11-04  

记得armstrong爷爷某书中提高erlang做法是任其崩溃，ms不提倡try catch防御式的做法

4 楼 francis333 2011-10-31  

good!  帅哥，我接触erlang没多久，发现确实有其他语言不能比拟的优势，能不能写一篇关于进程字典的文章，包括其用法等等，我目前在开发阶段遇到一个问题，我需要从数据库读取信息，然后逐个执行模块，但是当数据库信息更新后，需要在不停止已运行模块的前提下更新该模块执行的个别参数，从网上看好像可以通过进程字典实现参数的替换，不知道行不行

3 楼 litaocheng 2011-10-26  

chaoslawful 写道

最好说明一下，try...catch结构中只有try block ....

顶！谢谢指点哦~~~~

2 楼 chaoslawful 2011-10-26  

最好说明一下，try...catch结构中只有try block（即try/catch之间的代码）中的函数调用无法构造成尾递归，而catch block（即catch/end之间的代码）中的函数调用则可构造为尾递归形式。故文中代码里

send_msg(Socket, Pid) ->
    try
        receive
            {send, Bin} ->
                ...
            {inet_reply, _Sock, Result} ->
                ...
    catch
        _:_ ->
            [color=red]send_msg(Sock, Pid)[/color]
    end.

有问题的非尾递归调用存在于try/catch间receive中被隐去的部分里，而catch/end之间的那个 send_msg/2 调用则确实是尾递归，不会造成问题。同理，后面测试用例中造成内存占用不断上涨的问题在于 do_t1/0 中 try/catch 间 receive 中的 do_t1/0 调用，而非 catch/end 间的 do_t1/0 调用。

对于有疑问的 Erlang 代码，从 erlc 产生的字节码文件其实可以看得更清楚，尾递归调用会使用 call_last 字节码，而普通调用则使用 call 字节码，一目了然。比如如下代码

-module(x).
-compile(export_all).

x() ->
	try
		x()
	catch
		_:_ -> x()
	end.

生成字节码文件：

$ erlc +"'S'" x.erl
$ cat x.S
...
{function, x, 0, 2}.
  {label,1}.
    {func_info,{atom,x},{atom,x},0}.
  {label,2}.
    {allocate_zero,1,0}.
    {'try',{y,0},{f,3}}.
    [color=red]{call,0,{f,2}}.[/color]
    {try_end,{y,0}}.
    {deallocate,1}.
    return.
  {label,3}.
    {try_case,{y,0}}.
    [color=green]{call_last,0,{f,2},1}.[/color]
...

1 楼 orez88 2011-10-26  

好文章，学习了