并发 on cnDenis的笔记

【Erl代码片段】简易的并行版lists:map/2

Mon, 16 Jun 2014 00:00:00 +0000

Joe在书上示范了一个并行化的lists:map:

pmap(F, L) ->
 S = self(),
 %% make_ref() returns a unique reference
 %% we'll match on this later
 Ref = erlang:make_ref(),
 Pids = map(fun(I) ->
 spawn(fun() -> do_f(S, Ref, F, I) end)
 end, L),

 %% gather the results
 gather(Pids, Ref).

do_f(Parent, Ref, F, I) ->
 Parent ! {self(), Ref, (catch F(I))}.

gather([Pid|T], Ref) ->
 receive
 {Pid, Ref, Ret} -> [Ret|gather(T, Ref)]
 end;
gather([], _) ->
 [].

其实里面的Ref是没什么必要的, Pid本身就是不重复的, 可以用列表解析改简短一点:

pmap(F, L) ->
 Parent = self(),
 [receive {Pid, Result} -> Result end
 || Pid <- [spawn(fun() -> Parent ! {self(), (catch F(X))} end) || X <- L]].

如果不在乎返回值的次序, 可以用霸爷的版本: http://blog.yufeng.info/archives/401, 不过他没有在F(X)前加catch, 下面的代码中加上了. 他在论坛中解释说不加 catch 是为了"fail fast"(链接), 不过这并不完全成立, 因为F(X)是在新建的进程中执行的, 而且没有link, 出错只会使调用者无限等待, 并不见得特别好.

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

Tsung里有一个限制产生进程数的版本: https://github.com/processone/tsung/blob/master/src/tsung/ts_utils.erl#L874 如下:

pmap(F, L, NProcs) ->
 pmap(F, L, NProcs,"").

pmap(F, L, NProcs, Res) when length(L) > NProcs->
 {Head, Tail} = lists:split(NProcs,L),
 Parent = self(),
 lists:foldl(fun(X, Acc) -> spawn(fun() -> Parent ! {self(), F(X), Acc} end), Acc+1 end, 0, Head),
 NewRes = wait_result(NProcs,[]),
 pmap(F,Tail, NProcs, Res ++ NewRes);

pmap(F, L, _NProcs, Acc) ->
 Acc ++ pmap(F,L).

wait_result(0, Res)->
 {_Ids, RealRes} = lists:unzip(lists:keysort(1, Res)),
 RealRes;
wait_result(Nprocs, Res)->
 receive
 {_Pid, Result, Id} ->
 NewRes = Res ++ [{Id, Result}],
 wait_result(Nprocs-1, NewRes)
 end.

这代码看起来并不怎么好, 子进程发送的 {self(), F(X), Acc} 中self()是没有用的, 底下的 wait_result/2 也没有对它进行匹配, 合理来说这地方应该是一个 Ref 才对. 而且代码中先是 Res ++ [{Id, Result}], 然后又做 keysort, 并不太必要.

其实用现成的 pmap/2 去实现就可以了.

pmap(F, L, NProcs) ->
 pmap(F, L, NProcs, []).

pmap(F, L, NProcs, Res) when length(L) > NProcs->
 {Head, Tail} = lists:split(NProcs,L),
 pmap(F, Tail, NProcs, [pmap(F, Head)|Res]);

pmap(F, L, _NProcs, Res) ->
 Res1 = [pmap(F, L)|Res],
 lists:append(lists:reverse(Res1)).

由于创建进程和消息往返都有开销, 选择性消息接收会有遍历消息队列的开销, 只有当F是一个耗时的操作, 这些并行化的map才会比较划算.

【Erlang】ETS的并发性能调节选项

Sun, 08 Jun 2014 00:00:00 +0000

ETS在创建表时, 有 write_concurrency 和 read_concurrency 这两个选项, 可以用以优化ETS的并发性能.

write_concurrency 默认设置是 false, 当表进行写操作时, 整个表会被锁起来, 直到写完为止. 把这个值设置为 true, 可以优化并发写性能, 表中的不同项可以同时进行读写, 代价是会消耗一些内存, 并且会降低并发读的性能. 但是对于 order_set 类型的表, 目前的Erlang版本下是不受这个选项影响的.

read_concurrency 默认设置也是 false, 当设置为 true, 并且Erlang运行在多核机器上且开启SMP支持时, 并发读的性能会提升. 代价是读写切换变得更慢.

这两个选项是不会对操作的原子性和独立性有影响的, 也就是说这两项设置只改变性能, 不影响逻辑.

显然, write_concurrency 适用于读少写多的表, read_concurrency 适用于读多写少的表, 以及读写交替少的表 (即读一大堆数据后再写一大堆, 读取操作较少被写入操作打断).

这两个选项是可以同时开启的, 但额外的内存消耗会更大.

测试一下, 分别对默认, 开启read_concurrency, 开启write_concurrency 这三种设置, 测试 insert, lookup, update_counter 三种操作

bench for default ets
ets:insert/2
Single Process: 5664151 call per sec, 8388608 times in 1481 ms
 1000 Process: 2448296 call per sec, 4096000 times in 1673 ms
ets:lookup/2
Single Process: 6096372 call per sec, 8388608 times in 1376 ms
 1000 Process: 9481481 call per sec, 16384000 times in 1728 ms
ets:update_counter/3
Single Process: 5821379 call per sec, 8388608 times in 1441 ms
 1000 Process: 105872 call per sec, 128000 times in 1209 ms

bench for read_concurrency ets
ets:insert/2
Single Process: 5418997 call per sec, 8388608 times in 1548 ms
 1000 Process: 2493000 call per sec, 4096000 times in 1643 ms
ets:lookup/2
Single Process: 4981358 call per sec, 8388608 times in 1684 ms
 1000 Process: 10944555 call per sec, 16384000 times in 1497 ms
ets:update_counter/3
Single Process: 5769331 call per sec, 8388608 times in 1454 ms
 1000 Process: 1935727 call per sec, 2048000 times in 1058 ms

bench for write_concurrency ets
ets:insert/2
Single Process: 4371343 call per sec, 8388608 times in 1919 ms
 1000 Process: 2617252 call per sec, 4096000 times in 1565 ms
ets:lookup/2
Single Process: 4507580 call per sec, 8388608 times in 1861 ms
 1000 Process: 8062992 call per sec, 8192000 times in 1016 ms
ets:update_counter/3
Single Process: 4412734 call per sec, 8388608 times in 1901 ms
 1000 Process: 1889298 call per sec, 2048000 times in 1084 ms

可以看出, 开启并发性能优化的选项, 对于多进程的update_counter的性能有很大帮助.