x64 Ubuntu : Intel® Q6600® quad-core
Computer Language Benchmarks Game      [[ Play ]]

- all benchmarks - n-body fannkuch-redux meteor-contest fasta fasta-redux spectral-norm reverse-complement mandelbrot k-nucleotide regex-dna pidigits chameneos-redux thread-ring binary-trees-redux binary-trees - all languages - Ada 2005 GNAT ATS C gcc Clojure C# Mono C++ g++ Dart Erlang Erlang HiPE F# Mono Fortran Intel Go Haskell GHC Java 7 Lisp SBCL OCaml Pascal Free Pascal Perl PHP Python 3 Racket Ruby 2.0 Ruby JRuby Scala x86 one core x64 quad-core x86 quad-core x64 one core

 binary-trees benchmark N=20

Each chart bar shows how many times more Code, one ↓ binary-trees program used, compared to the program that used least Code.

These are not the only programs that could be written. These are not the only compilers and interpreters. These are not the only programming languages.

Column × shows how many times more each program used compared to the benchmark program that used least.

		sort	sort	sort
×	Program Source Code	CPU secs	Elapsed secs	Memory KB	Code B	≈ CPU Load
1.0	Ruby JRuby	10 min	229.74	1,167,076	412	74% 81% 58% 53%
1.1	Ruby JRuby #3	10 min	228.43	1,166,852	439	82% 53% 58% 72%
1.1	Ruby 2.0 #3	203.16	203.36	436,644	439	0% 78% 22% 0%
1.1	Erlang	119.16	119.30	866,752	441	4% 93% 3% 0%
1.1	Erlang HiPE	68.16	68.25	958,748	441	0% 98% 0% 2%
1.1	Perl	10 min	10 min	480,528	448	44% 56% 0% 0%
1.2	PHP #3	19 min	19 min	2,385,540	483	15% 17% 6% 62%
1.2	Scala #4	16.37	12.46	477,616	494	12% 12% 11% 99%
1.2	Racket	49.84	49.91	452,728	495	0% 100% 0% 0%
1.2	OCaml #5	41.34	41.40	223,180	496	0% 0% 0% 100%
1.2	Erlang HiPE #2	69.72	28.01	1,028,396	499	52% 57% 47% 95%
1.2	Erlang #2	122.37	34.07	828,976	499	93% 87% 92% 88%
1.2	PHP	11 min	11 min	1,021,804	504	8% 6% 1% 87%
1.3	F# Mono #2	148.42	90.02	274,616	515	22% 43% 62% 39%
1.3	Go	122.58	122.66	475,328	516	0% 0% 50% 50%
1.3	Haskell GHC	54.45	24.21	359,360	521	42% 100% 42% 41%
1.3	Dart	114.06	114.22	237,968	543	0% 0% 0% 100%
1.3	C++ g++ #2	37.70	37.73	197,756	553	95% 0% 0% 5%
1.4	F# Mono #3	78.00	48.09	245,164	565	75% 21% 27% 40%
1.5	Java 7  #2	16.94	12.32	476,228	603	13% 27% 86% 13%
1.5	Haskell GHC #4	65.00	20.04	787,716	612	90% 85% 75% 75%
1.5	Lisp SBCL	27.40	27.45	448,668	612	0% 30% 70% 0%
1.5	Python 3 #6	8 min	142.51	1,209,460	626	93% 95% 98% 93%
1.6	Racket #2	40.88	40.94	400,344	640	13% 87% 0% 0%
1.6	Lisp SBCL #2	20.50	20.54	439,708	649	1% 0% 100% 0%
1.6	C# Mono #2	93.38	55.97	472,228	650	23% 23% 56% 66%
1.6	C# Mono	79.23	40.87	143,172	654	32% 48% 47% 69%
1.6	Clojure	30.11	18.50	596,772	657	24% 95% 22% 22%
1.7	Go #4	238.33	63.78	580,720	688	93% 95% 94% 93%
1.7	Go #2	240.01	64.30	538,624	694	93% 93% 95% 94%
1.7	Clojure #6	25.95	18.33	531,756	705	71% 15% 15% 43%
1.7	Perl #3	12 min	211.70	1,593,648	706	78% 95% 96% 89%
1.7	C gcc	35.61	35.64	131,668	706	0% 0% 0% 100%
1.9	Pascal Free Pascal	40.79	40.82	131,380	769	0% 0% 100% 0%
1.9	OCaml #2	67.33	27.17	201,692	784	40% 84% 55% 71%
2.0	Fortran Intel	45.54	45.57	132,316	826	98% 0% 2% 2%
2.1	C gcc #7	15.71	4.79	155,788	850	93% 67% 78% 94%
2.2	C++ g++ #6	32.34	9.25	360,404	892	89% 79% 95% 88%
2.2	ATS	16.61	16.64	198,252	926	0% 0% 0% 100%
2.3	Ada 2005 GNAT	37.86	37.90	198,176	955	0% 0% 100% 0%
2.3	C gcc #5	78.74	20.70	219,168	963	92% 97% 93% 99%
2.4	Go #5	233.88	63.20	486,560	1000	95% 94% 93% 91%
2.4	Java 7	22.31	9.24	523,784	1007	37% 65% 58% 83%
2.9	Fortran Intel #2	23.39	7.55	181,000	1199	69% 72% 99% 72%
3.3	Ada 2005 GNAT #3	102.84	29.26	656,640	1342	91% 88% 87% 89%
5.2	ATS #3	18.29	6.19	328,516	2143	64% 99% 71% 62%
5.3	Ada 2005 GNAT #4	20.11	6.20	176,860	2167	82% 79% 76% 92%
5.3	Ada 2005 GNAT #5	19.92	6.27	176,824	2167	71% 82% 93% 75%
	Racket #3	Bad Output			877
	Ruby 2.0 #2	Failed			413
	Ruby 2.0	Failed			412
	Scala #2	Failed			641
"wrong" (different) algorithm / less comparable programs
1.3	Scala	15.52	10.39	334,868	549
1.4	OCaml	14.72	14.76	485,364	563
1.4	C gcc #2	3.34	3.35	49,544	594
1.5	Haskell GHC #5	40.97	15.67	247,864	611
2.1	Go #3	17.21	8.19	214,644	872
2.7	C gcc #9	9.89	3.01	229,044	1103

 binary-trees benchmark : Allocate and deallocate many many binary trees

diff program output N = 10 with this 1KB output file to check your program is correct before contributing.

We are trying to show the performance of various programming language implementations - so we ask that contributed programs not only give the correct result, but also use the same algorithm to calculate that result.

Each program should

• define a tree node class and methods, a tree node record and procedures, or an algebraic data type and functions, or…
• allocate a binary tree to 'stretch' memory, check it exists, and deallocate it
• allocate a long-lived binary tree which will live-on while other trees are allocated and deallocated
• allocate, walk, and deallocate many bottom-up binary trees
  • allocate a tree
  • walk the tree nodes, checksum the node items (and maybe deallocate the node)
  • deallocate the tree
• check that the long-lived binary tree still exists

Note: this is an adaptation of a benchmark for testing GC so we are interested in the whole tree being allocated before any nodes are GC'd - which probably excludes lazy evaluation.

Note: the left subtrees are heads of the right subtrees, keeping a depth counter in the accessors to avoid duplication is cheating!

Note: the tree should have tree-nodes all the way down, replacing the bottom nodes by some other value is not acceptable; and the bottom nodes should be at depth 0.

Note: these programs are being measured with the default initial heap size - the measurements may be very different with a larger initial heap size or GC tuning.

Please don't implement your own custom memory pool or free list.

The binary-trees benchmark is a simplistic adaptation of Hans Boehm's GCBench, which in turn was adapted from a benchmark by John Ellis and Pete Kovac.

Thanks to Christophe Troestler and Einar Karttunen for help with this benchmark.

  Home   Conclusions   License   Play