如何在 erlang 或 elixir 中产生 n-k 光进程？答案

【问题标题】：How to spawn n-k light-process in erlang or elixir?如何在 erlang 或 elixir 中产生 n-k 光进程？
【发布时间】：2017-06-13 03:20:42
【问题描述】：

在 Go 中，我可以创建这样的 goroutine（EDITED 由kelu-thatsall 的回答报告）：

// test.go
package main

import (
        "fmt"
        "os"
        "strconv"
        "sync"
        "runtime"
)

func main() {
        var wg sync.WaitGroup
        if len(os.Args) < 2 {
                os.Exit(1)
        }
        k, ok := strconv.Atoi(os.Args[1])
        if ok != nil {
                os.Exit(2)
        }
        wg.Add(k * 1000)
        for z := 0; z < k*1000; z++ {
            go func(x int) {
                    defer wg.Done()
                    fmt.Println(x)
            }(z)
            if z%k == k-1 {
                // @mattn: avoid busy loop, so Go can start processing like BEAM do 
                runtime.Gosched() 
            }
        }
        wg.Wait()
}

Go 1.8.0（64 位）中的结果：

# shell    
$ go build test.go ; for k in 5 50 500 5000 50000 500000; do echo -n $k; time ./test $k > /dev/null; done

5
CPU: 0.00s      Real: 0.00s     RAM: 2080KB
50
CPU: 0.06s      Real: 0.01s     RAM: 3048KB
500
CPU: 0.61s      Real: 0.12s     RAM: 7760KB
5000
CPU: 6.02s      Real: 1.23s     RAM: 17712KB # 17 MB
50000
CPU: 62.30s     Real: 12.53s    RAM: 207720KB # 207 MB
500000
CPU: 649.47s    Real: 131.53s   RAM: 3008180KB # 3 GB

Erlang 或 Elixir 中的等效代码是什么？（已编辑patrick-oscity 的评论报告）

到目前为止我尝试过的如下：

# test.exs
defmodule Recursion do
  def print_multiple_times(n) when n <= 1 do
    spawn fn -> IO.puts n end
  end

  def print_multiple_times(n) do
    spawn fn -> IO.puts n end
    print_multiple_times(n - 1)
  end
end

[x]=System.argv()
{k,_}=Integer.parse(x)
k=k*1000
Recursion.print_multiple_times(k)

elixir 1.4.2 (erts-8.2.2) 中的结果：

# shell    
$ for k in 5 50 500 5000 50000 ; do echo -n $k; time elixir --erl "+P 90000000" test.exs $k > /dev/null; done

5
CPU: 0.53s      Real: 0.50s     RAM: 842384KB # 842 MB
50
CPU: 1.50s      Real: 0.62s     RAM: 934276KB # 934 MB
500
CPU: 11.92s     Real: 2.53s     RAM: 1675872KB # 1.6 GB
5000
CPU: 122.65s    Real: 20.20s    RAM: 4336116KB # 4.3 GB
50000
CPU: 1288.65s   Real: 209.66s   RAM: 6573560KB # 6.5 GB

但我不确定这两者是否等价。是吗？

编辑作为mudasobwa的评论的缩短版本没有给出正确的输出

# test2.exs
[x]=System.argv()
{k,_}=Integer.parse(x)
k=k*1000
1..k |> Enum.each(fn n -> spawn fn -> IO.puts n end end)

结果for k in 5 50 500 5000 50000 ; do echo -n $k; time elixir --erl "+P 90000000" test.exs $k | wc -l ; done：

5
CPU: 0.35s      Real: 0.41s     RAM: 1623344KB # 1.6 GB
2826 # does not complete, this should be 5000
50
CPU: 1.08s      Real: 0.53s     RAM: 1691060KB # 1.6 GB
35062
500
CPU: 8.69s      Real: 1.70s     RAM: 2340200KB # 2.3 GB
373193
5000        
CPU: 109.95s    Real: 18.49s    RAM: 4980500KB # 4.9 GB
4487475
50000
erl_child_setup closed
Crash dump is being written to: erl_crash.dump...Command terminated by signal 9
CPU: 891.35s    Real: 157.52s   RAM: 24361288KB # 24.3 GB

没有测试 500m 的长生不老药，因为它花了太长时间，+P 500000000 参数是 bad number of processes

【问题讨论】：

也许能解释一下为什么你认为它不等价？
我只是不确定..
您是否正在尝试对 Go 与 Elixir 中生成进程的性能进行基准测试？只是一个疯狂的猜测，但 IO 可能会成为你的瓶颈。在您的长生不老药代码中还有一个错误，您实际上正在产生 n+1 个进程 - 尽管这在这里不会有太大的不同。要获得有意义的基准，了解您实际希望在流程中执行的工作类型会很有趣。
看起来和我差不多。如果我将代码放在一个混合包中，编译它，然后运行它，我会得到大约 15-20% 的速度。即使我从 Elixir 中完全删除 IO.puts，它仍然只比当前的快 30%，而且比您发布的 Go 数字慢得多。
注意内存消耗。看看 Go 将如何处理 500000 将会很有趣。此外，严格来说，等价于 1..k |> Enum.each(fn n -> spawn fn - > IO.puts n end end)。尾递归应该很重要。

标签： go erlang elixir

【解决方案1】：

对不起各位，但我不相信 Go 中的这段代码真的能按预期工作。我不是专家，如果我错了，请纠正我。首先它打印z，这似乎是它在全局范围内的当前值（通常是k*1000）https://play.golang.org/p/a4TJyjKBQh

// test.go
package main
import (
  "fmt"
  "time"
)

func main() {

  for z:=0; z<1000; z++ {
    go func(x int) { // I'm passing z to the function with current value now
      fmt.Println(x) 
    }(z)
  }

  time.Sleep(1 * time.Nanosecond)

}

如果我注释掉Sleep，程序甚至会在启动任何 goroutines 之前退出（至少它不会打印出结果）。我很高兴知道我是否做错了什么，但从这个简单的例子看来，问题不在于Elixir，而是Go 提供的代码。有一些Go 大师吗？

我还在本地机器上运行了一些测试：

go run test.go 500 | wc -l
72442 # expected 500000
go run test.go 5000 | wc -l
76274 # expected 5000000

【讨论】：