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 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 slower, one ↓ binary-trees program was, compared to the fastest program.

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	C gcc #7	14.38	4.32	103,396	850	81% 90% 99% 72%
1.3	Ada 2005 GNAT #5	18.04	5.61	106,104	2167	82% 80% 78% 95%
1.3	Ada 2005 GNAT #4	17.94	5.62	117,856	2167	77% 95% 73% 78%
1.4	ATS #3	18.33	6.05	218,600	2143	73% 99% 64% 69%
1.5	C++ g++ #6	19.06	6.60	173,960	892	60% 92% 75% 65%
1.8	Fortran Intel #2	23.99	7.93	116,980	1199	68% 68% 98% 69%
2.1	Java 7	21.35	9.21	525,420	1007	50% 70% 48% 65%
2.9	Haskell GHC #4	36.99	12.30	365,756	612	68% 67% 67% 99%
3.0	Java 7  #2	16.90	12.75	485,056	603	12% 62% 48% 12%
3.3	Scala #4	18.93	14.12	462,460	494	13% 28% 82% 13%
3.8	OCaml #2	41.33	16.37	101,016	784	95% 69% 55% 35%
3.9	Erlang HiPE #2	52.63	16.82	646,636	499	89% 75% 70% 81%
4.2	ATS	17.91	17.92	132,104	926	1% 0% 0% 100%
4.4	Clojure	32.52	19.05	553,112	657	53% 71% 27% 20%
4.6	Haskell GHC	39.47	19.95	174,636	521	33% 33% 33% 100%
4.7	Lisp SBCL #2	20.41	20.45	220,104	649	83% 0% 18% 0%
5.3	C# Mono	22.68	22.68	137,004	654	100% 0% 0% 0%
5.7	C gcc #5	84.38	24.68	101,636	963	90% 83% 85% 85%
6.2	Racket #2	26.92	26.94	226,016	640	0% 0% 0% 100%
6.6	Clojure #6	41.84	28.47	554,804	705	97% 19% 13% 19%
6.7	Lisp SBCL	28.80	28.85	227,004	612	0% 100% 0% 0%
7.5	Ada 2005 GNAT #3	118.04	32.50	329,012	1342	91% 90% 90% 93%
7.6	C gcc	32.84	32.86	66,096	706	96% 0% 0% 4%
7.7	Pascal Free Pascal	33.24	33.26	65,844	769	96% 0% 0% 4%
8.2	OCaml #5	35.52	35.56	115,684	496	0% 0% 100% 0%
8.7	Racket	37.67	37.71	284,428	495	0% 0% 100% 0%
8.8	C++ g++ #2	38.16	38.19	99,080	553	92% 0% 0% 8%
8.9	F# Mono #3	38.22	38.23	179,420	565	0% 0% 17% 83%
9.1	Ada 2005 GNAT	39.34	39.37	99,440	955	0% 0% 100% 0%
9.8	Dart	42.31	42.36	153,364	543	0% 0% 100% 0%
10	C# Mono #2	42.87	42.90	304,604	650	0% 0% 100% 0%
12	Erlang HiPE	50.92	50.98	427,992	441	2% 1% 97% 2%
12	Go #2	203.21	53.87	305,172	694	96% 94% 94% 96%
14	Go #5	213.69	61.72	378,520	1000	91% 88% 86% 83%
15	F# Mono #2	66.62	66.64	276,364	515	0% 0% 97% 3%
25	Go	106.70	106.71	260,256	516	0% 0% 100% 0%
29	Ruby JRuby #3	204.38	126.34	879,972	439	22% 22% 96% 21%
32	Python 3 #6	8 min	139.16	685,880	626	98% 93% 93% 93%
33	Ruby JRuby	263.75	141.78	868,844	412	31% 94% 31% 31%
41	Fortran Intel	177.99	178.17	153,820	826	0% 0% 0% 100%
54	Ruby 2.0 #3	231.93	232.04	393,696	439	86% 0% 0% 15%
62	Perl #3	14 min	265.80	960,488	706	71% 70% 97% 98%
149	PHP	10 min	10 min	549,880	504	5% 4% 1% 93%
157	Perl	11 min	11 min	289,780	448	98% 1% 0% 1%
208	PHP #3	14 min	14 min	1,249,352	483	8% 5% 0% 88%
	Racket #3	Bad Output			877
	Ruby 2.0	Failed			412
	Ruby 2.0 #2	Failed			413
	Scala #2	Failed			641
"wrong" (different) algorithm / less comparable programs
0.4	C gcc #9	6.53	1.82	114,124	1103
0.7	C gcc #2	2.99	3.00	25,148	594
1.6	Go #3	14.52	6.85	107,700	872
2.4	Haskell GHC #5	27.06	10.38	151,668	611
2.7	Scala	15.24	11.66	392,740	549
2.9	OCaml	12.65	12.67	235,696	563

 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