Es F # realmente más rápido que Erlang en los procesos de desove y matanza?

Actualizado: Esta pregunta contiene un error que hace que el punto de referencia carezca de sentido. Intentaré un mejor punto de referencia comparando F# y la funcionalidad de concurrencia básica de Erlang y preguntaré sobre los resultados en otra pregunta.

Estoy tratando de entender las características de rendimiento de Erlang y F#. Encuentro el modelo de concurrencia de Erlang muy atractivo, pero me inclino a usar F # por razones de interoperabilidad. Mientras que fuera de la caja F# no ofrece nada como el de Erlang primitivas de concurrencia from de lo que puedo decir async y MailboxProcessor solo cubren una pequeña porción de lo que Erlang hace bien've He estado tratando de entender lo que es posible en F# rendimiento sabio.

En el libro de programación Erlang de Joe Armstrong, señala que los procesos son muy baratos en Erlang. Él usa (aproximadamente) el siguiente código para demostrar este hecho:

-module(processes).
-export([max/1]).

%% max(N) 
%%   Create N processes then destroy them
%%   See how much time this takes

max(N) ->
    statistics(runtime),
    statistics(wall_clock),
    L = for(1, N, fun() -> spawn(fun() -> wait() end) end),
    {_, Time1} = statistics(runtime),
    {_, Time2} = statistics(wall_clock),
    lists:foreach(fun(Pid) -> Pid ! die end, L),
    U1 = Time1 * 1000 / N,
    U2 = Time2 * 1000 / N,
    io:format("Process spawn time=~p (~p) microseconds~n",
          [U1, U2]).

wait() ->
    receive
        die -> void
    end.

for(N, N, F) -> [F()];
for(I, N, F) -> [F()|for(I+1, N, F)].

En mi Macbook Pro, generar y matar 100 mil procesos (processes:max(100000)) toma alrededor de 8 microsegundos por procesos. Puedo aumentar el número de procesos un poco más, pero un millón parece romper las cosas bastante consistentemente.

Sabiendo muy poco F#, intenté implementar este ejemplo usando async y MailboxProcessor. Mi intento, que puede estar equivocado, es el siguiente:

#r "System.dll"
open System.Diagnostics

type waitMsg =
    | Die

let wait =
    MailboxProcessor.Start(fun inbox ->
        let rec loop =
            async { let! msg = inbox.Receive()
                    match msg with 
                    | Die -> return() }
        loop)

let max N =
    printfn "Started!"
    let stopwatch = new Stopwatch()
    stopwatch.Start()
    let actors = [for i in 1 .. N do yield wait]
    for actor in actors do
        actor.Post(Die)
    stopwatch.Stop()
    printfn "Process spawn time=%f microseconds." (stopwatch.Elapsed.TotalMilliseconds * 1000.0 / float(N))
    printfn "Done."

Usar F# en Mono, iniciar y matar 100,000 actores/procesadores toma menos de 2 microsegundos por proceso, aproximadamente 4 veces más rápido que Erlang. Lo más importante, quizás, es que puedo escalar a millones de procesos sin problemas aparentes. El inicio de 1 o 2 millones de procesos aún toma alrededor de 2 microsegundos por proceso. Aún es posible iniciar 20 millones de procesadores, pero se ralentiza a unos 6 microsegundos por proceso.

Todavía no me he tomado el tiempo para entender completamente cómo F# implementa async y MailboxProcessor, pero estos resultados son alentadores. Hay algo que estoy haciendo terriblemente mal?

Si no, ¿hay algún lugar donde Erlang probablemente superará a F#? Ser ¿hay alguna razón por la que las primitivas de concurrencia de Erlang no se pueden llevar a F# a través de una biblioteca?

EDITAR: Los números anteriores son incorrectos, debido al error que Brian señaló. Actualizaré toda la pregunta cuando la arregle.