« Reading List: The Great Influenza | Main | Reading List: Command and Control »

Sunday, October 26, 2014

Floating Point Benchmark: Rust Language Added

I have posted an update to my trigonometry-intense floating point benchmark which adds Rust to the list of languages in which the benchmark is implemented. A new release of the benchmark collection including Rust is now available for downloading.

Rust is a systems programming language currently under development. It attempts to provide performance comparable to low-level programming languages such as C and C++ while avoiding common causes of crashes and security problems such as subscript and pointer errors, dangling pointers, memory leaks, and multi-thread race conditions. It is a compiled language with extensive compile-time checking which detects many errors which cause run-time errors in other languages, and has a reference-counted memory management architecture which avoids the overhead of garbage collection and provides critical section locking in multi-thread programs.

As a language actively under development, Rust is a moving target and any program developed for it may require modification as the language and run-time libraries evolve. This program was developed on version 0.13.0, and I encountered no problems with the language or libraries. Rust supports multiple programming paradigms: I chose to implement this program in a functional style with no mutable variables.

The relative performance of the various language implementations (with C taken as 1) is as follows. All language implementations of the benchmark listed below produced identical results to the last (11th) decimal place.

Language Relative
C 1 GCC 3.2.3 -O3, Linux
Visual Basic .NET 0.866 All optimisations, Windows XP
FORTRAN 1.008 GNU Fortran (g77) 3.2.3 -O3, Linux
Pascal 1.027
Free Pascal 2.2.0 -O3, Linux
GNU Pascal 2.1 (GCC 2.95.2) -O3, Linux
Rust 1.077 Rust 0.13.0, --release, Linux
Java 1.121 Sun JDK 1.5.0_04-b05, Linux
Visual Basic 6 1.132 All optimisations, Windows XP
Haskell 1.223 GHC 7.4.1-O2 -funbox-strict-fields, Linux
Ada 1.401 GNAT/GCC 3.4.4 -O3, Linux
Go 1.481 Go version go1.1.1 linux/amd64, Linux
Simula 2.099 GNU Cim 5.1, GCC 4.8.1 -O2, Linux
Lua 2.515
LuaJIT 2.0.3, Linux
Lua 5.2.3, Linux
Python 2.633
PyPy 2.2.1 (Python 2.7.3), Linux
Python 2.7.6, Linux
Erlang 3.663
Erlang/OTP 17, emulator 6.0, HiPE [native, {hipe, [o3]}]
Byte code (BEAM), Linux
ALGOL 60 3.951 MARST 2.7, GCC 4.8.1 -O3, Linux
Lisp 7.41
GNU Common Lisp 2.6.7, Compiled, Linux
GNU Common Lisp 2.6.7, Interpreted
Smalltalk 7.59 GNU Smalltalk 2.3.5, Linux
Forth 9.92 Gforth 0.7.0, Linux
COBOL 12.5
Micro Focus Visual COBOL 2010, Windows 7
Fixed decimal instead of computational-2
Algol 68 15.2 Algol 68 Genie 2.4.1 -O3, Linux
Perl 23.6 Perl v5.8.0, Linux
Ruby 26.1 Ruby 1.8.3, Linux
JavaScript 27.6
Opera 8.0, Linux
Internet Explorer 6.0.2900, Windows XP
Mozilla Firefox 1.0.6, Linux
QBasic 148.3 MS-DOS QBasic 1.1, Windows XP Console

This is a very impressive performance for a language whose specification continues to be refined and with a compiler under active development. There are few applications where an 8% speed penalty compared to C/C++ will make much of a difference (note, of course, that many systems programming applications do things very different that this floating-point intensive benchmark, and that relative performance measured by this program may not be indicative of what you'll experience on very different tasks such as text processing, management of large data structures, or parallel computation).

Posted at October 26, 2014 00:31