erlang - 从头开始实现 pmap。为什么我的执行速度很慢？

Question

我是 Erlang 新手，因此为了训练，我尝试从头开始实现标准功能。我尝试从 lists 模块创建 ma​​p/2 函数的并行实现。但我的实现速度非常慢。如果我在实现中犯了任何主要错误，您能指出我吗:

-module( my_pmap ).
-export([ pmap/2 ]).
-export([ map/4, collect/3 ]).

map( F, Value, Indx, SenderPid ) ->
        SenderPid ! { Indx, F( Value ) }.

pmap( F, List ) ->
        CollectorPid = spawn_link( my_pmap, collect, [ length( List ), [], self() ] ),
        lists:foldl(
                fun( X, Indx ) ->
                        spawn_link( my_pmap, map, [ F, X, Indx, CollectorPid ] ),
                        Indx + 1
                end,
                1,
                List ),
        Mapped =
                receive
                        { collected, M } ->
                                M
                end,
        Sorted = lists:sort(
                        fun( { Indx1, _ }, { Indx2, _ } ) ->
                                Indx1 < Indx2
                        end,
                        Mapped ),
        [ Val || { _Indx, Val } <- Sorted ].

collect( 0, List, SenderPid ) ->
        SenderPid ! { collected, List };
collect( N, List, SenderPid ) when N > 0 ->
        receive
                Mapped ->
                        collect( N - 1, [ Mapped | List ], SenderPid )
        end.

这是测试结果:

1> c(my_pmap).
{ok,my_pmap}
2> timer:tc( my_pmap, pmap, [ fun(X) -> X*X*X*X end, lists:seq( 1, 10000 ) ] ).
{137804,
 [1,16,81,256,625,1296,2401,4096,6561,10000,14641,20736,
  28561,38416,50625,65536,83521,104976,130321,160000,194481,
  234256,279841,331776,390625,456976,531441|...]}
3> timer:tc( lists, map, [ fun(X) -> X*X*X*X end, lists:seq( 1, 10000 ) ] ).   
{44136,
 [1,16,81,256,625,1296,2401,4096,6561,10000,14641,20736,
  28561,38416,50625,65536,83521,104976,130321,160000,194481,
  234256,279841,331776,390625,456976,531441|...]}

正如您可能已经看到的那样，0,137804 秒与0,044136 秒

谢谢

Answer 1

评论是正确的。问题是生成过程很便宜，但它确实有成本。将数字乘以三倍的速度非常快，并且生成新进程的开销会降低您的性能。

将列表划分为片段并在单独的进程中处理每个片段可能会更快。如果您知道自己有 8 个核心，则可以尝试将其分成 8 个片段。像 pmap 这样的东西可以在 Erlang 中实现，但这不是 Erlang 的强项。像 Haskell GHC 运行时这样的系统有 Sparks，它是实现此类细粒度并行性的更好工具。此外，像这样的乘法显然是 SSE 或 GPU 中的 SIMD 指令的候选者。 Erlang 对此也没有解决方案，但 GHC 有 accelerate 和 repa ，它们是处理这种情况的库。

另一方面，您可以通过简单地使用进程来处理几个片段(如暗示的那样)，从而在 Erlang 中获得良好的加速。另请注意，由于通信开销，并行计算在低 N(如 10000)时通常表现不佳。您需要解决更大的问题才能获得好处。