« 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

Time Details 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

1.077 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

22.7 LuaJIT 2.0.3, Linux

Lua 5.2.3, Linux Python 2.633

30.0 PyPy 2.2.1 (Python 2.7.3), Linux

Python 2.7.6, Linux Erlang 3.663

9.335 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

19.8 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

46.3 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

39.1

46.9 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