Ocaml performance vs go - performance

Question

I'm trying to implement utf8 decoding in Ocaml as a learning project. To check the performance I'm benchmarking against the go standard library.
This is the go code:
package main
import (
"fmt"
"time"
"unicode/utf8"
)
func main() {
start := time.Now()
for i := 0; i < 1000000000; i++ {
utf8.ValidRune(23450)
}
elapsed := time.Since(start)
fmt.Println(elapsed)
}
When I run it, I get:
go build b.go
./b
344.979492ms
I decided to write an equivalent in ocaml:
let min = 0x0000
let max = 0x10FFFF
let surrogateMin = 0xD800
let surrogateMax = 0xDFFF
let validUchar c =
if (0 <= c && c < surrogateMin) then
true
else if (surrogateMax < c && c <= max) then
true
else
false
let time f x =
let t = Sys.time () in
let _ = f x in
let t2 = Sys.time () in
let diff = (t2 -. t) *. 1000. in
print_endline ((string_of_float diff) ^ "ms")
let test () =
for i = 0 to 1000000000 do
let _ = validUchar 23450 in
()
done
let () = time test ()
Output:
ocamlopt bMl.ml -o bMl
./bMl
2041.075ms
The ocaml equivalent basically copies the implementation of the go stdlib from https://golang.org/src/unicode/utf8/utf8.go#L517
Why is the ocaml code so much slower?

Answer 1

As observed you should be using Unix.gettimeofday to measure wallclock time. You can use Sys.opaque_identity however to prevent OCaml from optimizing useless operations away, and you can use ignore to 'return unit' instead of the usual value of an expression. Altogether:
let time f x =
let t = Unix.gettimeofday () in
ignore (Sys.opaque_identity (f x));
let t2 = Unix.gettimeofday () in
...
let test () =
for i = 1 to 1_000_000_000 do
ignore (Sys.opaque_identity (validUchar 23450));
done
Note the i = 1, which you want if you want exactly one billion iterations (a figure I couldn't tell was one billion before adding the underscores, which OCaml allows). Previously you were measuring one billion plus 1 iterations. Not that that was the difference.
Your verbose definition of validUchar did not benefit its performance any. Please write a microbenchmark and confirm that.
Finally, after making the changes suggested above and writing your validUchar in a more natural manner, I get an OCaml runtime that's identical to the Go runtime ... after adding -O3 to the ocamlopt arguments. And it's easy to confirm that this isn't due to the compiler 'optimizing the operations away' -- commenting out the f x call in time results in runtimes of 0 or near-0 values like 1.19e-06.
Don't be discouraged by the responses you got to this question. But do expect that any kind of "why does this benchmark have this result?" question to a programming forum will be answered similarly.

Answer 2

The Sys.time shouldn't be used for time measurements, as it returns a processor time, not the real time. The Unix.gettimeofday function is a much better candidate. Alternatively, you can time your program from the shell using the time command.
As a side note, benchmarking is hard, and it is very easy to get misleading results. In your particular case, if you will turn on optimizations both compilers will remove the computations, since they are not used and will produce code that does nothing, and thus is rather fast :)