Czy F # jest naprawdę szybszy od Erlanga w procesie tarła i zabijania?

Aktualizacja: to pytanie zawiera błąd, który sprawia, że benchmark nie ma znaczenia. Spróbuję lepszego benchmarka porównującego podstawową funkcjonalność współbieżności F# i Erlanga i zapytam o wyniki w innym pytaniu.

-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)].

Na moim MacBooku Pro zrobienie i zabicie 100 tysięcy procesów (processes:max(100000)) zajmuje około 8 mikrosekund na procesy. Mogę podnieść liczbę procesów nieco dalej, ale milion wydaje się łamać rzeczy dość konsekwentnie.

Znając bardzo mało F#, próbowałem zaimplementować ten przykład używając async i MailBoxProcessor. Moja próba, która może być błędna, wygląda następująco:

#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."

Używanie F# na Mono, uruchomienie i zabicie 100 000 aktorów/procesorów zajmuje mniej niż 2 mikrosekundy na proces, około 4 razy szybciej niż Erlang. Co ważniejsze, być może, mogę zwiększyć skalę do milionów procesów bez widocznych problemów. Uruchomienie 1 lub 2 milionów procesów trwa nadal około 2 mikrosekund na proces. Uruchomienie 20 milionów procesorów jest nadal możliwe, ale spowalnia do około 6 mikrosekund na proces.

Nie poświęciłem jeszcze czasu, aby w pełni zrozumieć, jak F# implementuje async i procesor MailBoxProcessor, ale te wyniki są zachęcające. Czy jest coś, co robię strasznie źle?

Jeśli nie, to czy jest jakieś miejsce, gdzie Erlang prawdopodobnie przewyższy F#? Na jest jakiś powód, dla którego Erlang nie może być przeniesiony do F# przez Bibliotekę?

EDIT: powyższe liczby są błędne, z powodu błędu, na który wskazywał Brian. Zaktualizuję całe pytanie, kiedy to naprawię.