performance measurements

Each table row shows performance measurements for this F# Mono program with a particular command-line input value N.

 N  CPU secs Elapsed secs Memory KB Code B ≈ CPU Load
500,0002.092.1031,808555  2% 0% 1% 100%
5,000,00015.3015.4141,740555  0% 1% 1% 99%
50,000,000153.79154.3841,464555  0% 1% 1% 100%

Read the ↓ make, command line, and program output logs to see how this program was run.

Read thread-ring benchmark to see what this program should do.

 notes

F# Compiler for F# 3.0 (Open Source Edition)

Mono JIT compiler version 3.4.1 (master/1b936ba Mon Apr 28 16:16:26 PDT 2014)
LLVM: yes(3.4svn-mono-mono/e656cac)
GC: sgen

 thread-ring F# Mono #2 program source code

(*  The Computer Language Benchmarks Game

    http://benchmarksgame.alioth.debian.org/



    Contributed by Dmitry Lomov & Jomo Fisher



    Uses F# asyncs (lightweight threads) with customized auto reset cell 

    as semaphore.

*)

let ringLength = 503

type AutoResetCell() =
    let mutable value = -1
    let mutable run = None
    
    member this.RegisterResult res =
        let grabbed = 
            lock this (fun () ->
                match run with
                | None -> value <- res; None
                | grabbed -> run <- None; grabbed)
        match grabbed with
        | None -> ()
        | Some run -> run res

    member this.AsyncResult = 
        Async.FromContinuations(fun (success,_,_) -> 
            let runNow = 
                lock this (fun () ->
                    if value = -1 then
                        run <- Some success
                        false                        
                    else true)                        
            if runNow then 
                let r = value
                value <- -1 // Autoreset

                success r) 

let createCell _ = AutoResetCell()

let createThread (cells:AutoResetCell array) i =
    let next = if i = ringLength-1 then 0 else i + 1
    async {
            let more = ref true
            while !more do
                let! msg = cells.[i].AsyncResult 
                cells.[next].RegisterResult(msg-1)           
                more := msg>0
                if msg = 0 then                    
                    printfn "%d" (i+1) }

[<EntryPoint>]
let main args = 
    let count = if args.Length>0 then int args.[0] else 50000000
    
    let cells = Array.init ringLength createCell

    let threads = Array.init ringLength (createThread cells)

    cells.[0].RegisterResult(count) 

    threads
        |> Async.Parallel // Run all the asyncs at once

        |> Async.Ignore // Ignore the results

        |> Async.RunSynchronously // Block the main thread until work is done

    
    0

 make, command-line, and program output logs

Tue, 29 Apr 2014 19:37:32 GMT

MAKE:
mv threadring.fsharp-2.fsharp threadring.fsharp-2.fs
/usr/local/bin/fsharpc --target:exe --platform:x86 -O  -o threadring.fsharp-2.fsharp_run.exe threadring.fsharp-2.fs
F# Compiler for F# 3.0 (Open Source Edition)
Freely distributed under the Apache 2.0 Open Source License

/home/dunham/benchmarksgame_onecore/threadring/tmp/threadring.fsharp-2.fs(10,1): warning FS0221: The declarations in this file will be placed in an implicit module 'Threadring.fsharp-2' based on the file name 'threadring.fsharp-2.fs'. However this is not a valid F# identifier, so the contents will not be accessible from other files. Consider renaming the file or adding a 'module' or 'namespace' declaration at the top of the file.
rm threadring.fsharp-2.fs
4.11s to complete and log all make actions

COMMAND LINE:
/usr/local/bin/mono --llvm --gc=sgen threadring.fsharp-2.fsharp_run.exe 50000000

PROGRAM OUTPUT:
292

Revised BSD license

  Home   Conclusions   License   Play