粘合二进制文件（list_to_binary）有多昂贵？

Question

一个进程在异步套接字上侦听服务器，并且在每条消息 {tcp, Socket, Bin} 上获取其缓冲区，并且：

Data = list_to_binary([Buffer, Bin]),
    {next_state, 'READY', State#state{buffer = Data}}.

在某些事件上，它会刷新缓冲区：

'READY'({flush}, #state{buffer = Buffer} = State) ->
    {reply, {Buffer}, 'READY', State#state{buffer = <<>>}}.

昂贵吗？也许最好只是创建一个列表并在刷新时创建 list_to_binary(lists:reverse()) 一次？

Answer 1

您的第一种方法似乎比第二种方法慢得多（在我的平台上慢了大约 3000 倍）：

-module(test).
-export([test/0, performance_test/4]).

-define(ITERATIONS, 100000).
-define(NEW_DATA, <<1, 2, 3, 4, 5, 6, 7, 8, 9, 10>>).

accumulate_1(AccumulatedData, NewData) ->
  list_to_binary([AccumulatedData, NewData]).

extract_1(AccumulatedData) ->
  AccumulatedData.

accumulate_2(AccumulatedData, NewData) ->
  [NewData | AccumulatedData].

extract_2(AccumulatedData) ->
  list_to_binary(lists:reverse(AccumulatedData)).

performance_test(AccumulateFun, ExtractFun) ->
  {Time, _Result} = timer:tc(test, performance_test, [AccumulateFun, ExtractFun, [], ?ITERATIONS]),
  io:format("Test run: ~p microseconds~n", [Time]).

performance_test(_AccumulateFun, ExtractFun, AccumulatedData, _MoreIterations = 0) ->
  ExtractFun(AccumulatedData);

performance_test(AccumulateFun, ExtractFun, AccumulatedData, MoreIterations) ->
  NewAccumulatedData = AccumulateFun(AccumulatedData, ?NEW_DATA),
  performance_test(AccumulateFun, ExtractFun, NewAccumulatedData, MoreIterations - 1).

test() ->
  performance_test(fun accumulate_1/2, fun extract_1/1),
  performance_test(fun accumulate_2/2, fun extract_2/1),
  ok.

输出：

7> test:test().
Test run: 57204314 microseconds
Test run: 18996 microseconds

Answer 2

在当前版本中，模拟器对二进制文件的处理已得到显着改进，
所以现在您还可以采用更简单的路径并按块生成二进制块：

buffer = #state{buffer = <>}。

我没有针对其他方法对其进行测试，但应该不错。
不同实现之间的性能也可能取决于您在同一缓冲区上执行此操作的次数以及每个块有多大。