🗐 Interpreter Benchmark Results


The Euphoria interpreter seems to be the world's fastest!

Although it provides subscript checking, uninitialized variable checking, full dynamic storage allocation, flexible generic data types, and integer overflow checking, it still manages to "blow away" all other programming language interpreters that we know of.

The results below are based on the prime sieve benchmark from the Great Computer Language Shootout by Doug Bagley. The numbers are taken from the WIN32 version of the Shootout at:

    http://dada.perl.it/shootout

We chose sieve because it was CPU-intensive, and less trivial than some of the other benchmarks. It's also integer-based, as most real programs are. Naturally, you should perform your own benchmarks, based on the type of programs that are important to you.

Our Methodology:

We measured the speed of Euphoria on the version of sieve used in the Shootout. We measured both the Euphoria interpreter, and the Euphoria To C Translator. The machine used in the WIN32 Shootout was a Pentium-4 1.6GHz running Windows XP. Our machine for the Euphoria measurements was a Pentium-4 1.8GHz, also running Windows XP. We thus adjusted our times upward by 1.8/1.6, i.e. we added 12.5%. As a check, we downloaded Python 2.1 and ran sieve with N=900 on our machine. Python was only about 3% faster on our machine, probably because CPU speed is not the only factor. Level-2 cache access time may also be important. To be fair, we nevertheless scaled up all of our Euphoria times by the full 12.5%.

We ran the Euphoria sieves with N=90000 to get accurate timings. For comparison, we divided by 100 to match the N=900 used on the WIN32 shootout, and we added 12.5%.

The Shootout used an external timer on the programs, that necessarily included start-up times. We used an internal timer in the Euphoria programs, because it's more accurate, and because we lacked a good external timing mechanism. To eliminate the start-up times of the other languages, we subtracted their time for N=1 from their time for N=900. In most cases the N=1 start-up time was just a tiny percentage of the full N=900 time. (So we were actually only timing 899 iterations for the other languages.)


The Results:

Euphoria interpreter, exw.exe:
For N=90000 on 1.8GHz machine: 41.39 seconds

scaled to N=900 (divide by 100): .4139 seconds

adjusted +12.5% to compare with 1.6 GHz: .4656

Euphoria To C Translator (with C compilation by Watcom for WIN32):
For N=90000 on 1.8GHz machine: 11.28 seconds

scaled to N=900 (divide by 100): .1128 seconds

adjusted +12.5% to compare with 1.6 GHz: .1269

From dada.perl.it/shootout/
prime sieve benchmark (interpreted languages)

N=900 iterations. Start-up time (N=1) was subtracted out
Pentium-4 1.6 GHz

Interpreters, sorted by seconds taken:
(EtoC added for comparison)
---------------------------------------
 Euphoria  0.13  - EtoC Translator / Watcom
 Euphoria  0.47  - Interpreted with exw.exe
 pliant    0.68
 gforth    0.75
 parrot    2.98
 ocamlb    3.21
 poplisp   3.34
 eu in eu  7.15  - PD source Euphoria translated/compiled to eu.exe
 erlang    7.16
 lua       8.70
 pike     10.36
 python   14.33
 icon     15.12
 perl     16.36
 elastic  16.88
 guile    18.64
 cygperl  19.22
 ruby     27.59
 mawk     28.00
 vbscript 32.02
 php      67.32
 jscript  77.43
 tcl      83.10
 gawk    158.49
 rexx    166.85


Conclusions
-----------

  1. Euphoria (interpreted) beats all of the other interpreted languages in the Shootout. All of the well-known languages are beaten by a huge margin. For instance, Perl is 16.36/.4656 = 35 times slower than interpreted Euphoria. Python is 31 times slower.

  2. If you want even greater speed, the Euphoria to C Translator can give you a factor of .4656/.1269 = 3.7 versus the already-fast interpreter. In fact, EtoC easily beats many compiled languages such as Java and C-Sharp (C#) on this benchmark, and it comes close to hand-coded, fully-optimized C. This is remarkable, since Euphoria code is *much* easier to write and debug than C. EtoC beats both Perl and Python by a factor of more than 100!

  3. If you are looking for an open source language to modify, observe that even the Public Domain source version of Euphoria, written 100% in Euphoria, can run twice as fast as Python or Perl which are both written in C. Which source would you prefer to modify and debug? Which speed would you like to have for your modified interpreter?