Some dynamic language benchmarks

00-TL-DR.md

The results

Note that only the C "control" example has type information; every other implementation either uses inference or generic arithmetic.

Implementation	Language	Time (ms)	Time rel. C	Arithmetic	Compilation model
GCC	C	20.3	1	mod 2^n	AOT
SBCL	Common Lisp	36.4	1.79	bignum	AOT
SpiderMonkey	JavaScript	56.0	2.75	float	JIT
Chez	Scheme	93.7	4.62	bignum	AOT
PyPy	Python	153	7.54	bignum	JIT
Guile	Scheme	220	10.8	bignum	JIT
OpenSmalltalk	Squeak	236	11.6	bignum	JIT
MRI --jit	Ruby	1224	60.3	bignum	JIT
MRI	Ruby	1670	82.2	bignum	Interpreter
MicroPython	Python	3840	189	bignum	Interpreter
CPython	Python	4409	217	bignum	Interpreter

bytes.c

#define true 1
#define false 0
#define size 8190
#define sizepl 8191

#include <stdio.h>

char flags[sizepl];

int main() {
    int i, prime, k, count, iter; 
    for (iter = 1;iter <= 100000; iter++) {
        count=0;
        for (i = 0;i <= size;i++)
            flags[i] = true; 
        for (i = 0;i <= size;i ++) { 
            if (flags[i]) {
                prime = i + i + 3; 
                k = i + prime; 
                while (k <= size) { 
                    flags[k] = false; 
                    k += prime; 
                }
                count = count + 1;
            }
        }
    }
    printf("\n%d primes", count);
}

/*
  $ gcc -O3 bench.c -o bench
  $ time ./bench ⇒ real	0m2.029s i.e. 20.3 milliseconds / mille
*/

bytes.js

const size = 8190;
const sizepl = size + 1;

const flags = new Array(sizepl);

function main() {
    let prime, k, count;
    for (let iter = 1; iter <= 100000; iter++) {
        count = 0;
        for (let i = 0; i <= size; i++)
            flags[i] = true; 
        for (let i = 0; i <= size; i++) { 
            if (flags[i]) {
                prime = i + i + 3; 
                k = i + prime; 
                while (k <= size) { 
                    flags[k] = false; 
                    k += prime; 
                }
                count = count + 1;
            }
        }
    }
    console.log(count, "primes");
}
main();

/*
SpiderMonkey JavaScript-C78.5.0
$ time js78 bytes.js ⇒ real 0m5.598s i.e. 
*/

bytes.lisp

;;; On SBCL 2.0.10

(defun test ()
  (let* ((size 8190)
         (sizepl 8191)
         (flags (make-array sizepl :initial-element nil))
         (count 0))
    (dotimes (n 1000)
      (setf count 0)
      (fill flags t)
      (loop for i from 0 to size
            when (aref flags i)
              do (let* ((prime (+ i i 3))
                        (k (+ i prime)))
                   (loop while (<= k size)
                         do (setf (aref flags k) nil)
                            (incf k prime))
                   (incf count))))
    #+(or)
    (format t "~&~d primes" count)))

;;; (the-cost-of-nothing:bench (test)) ⇒ 36.44 milliseconds

bytes.py

size = 8190
sizepl = 8191

flags = [0] * sizepl
for i in range(1000):
    count = 0
    for i in range(0, size + 1):
        flags[i] = True
    for i in range(0, size + 1):
        if flags[i]:
            prime = i + i + 3
            k = i + prime
            while k <= size:
                flags[k] = False
                k += prime
            count = count + 1
print("{} primes".format(count))

# Python 3.8.6
# $ time python sieve.py ⇒ real	0m4.409s
# PyPy 7.3.3-beta0
# $ time pypy sieve.py ⇒ real 0m0.153s
# MicroPython v1.14-25-g7ed99544e
# $ time micropython sieve.py ⇒ real 0m3.840s

bytes.rb

# ruby 2.7.2p137 (2020-10-01 revision 5445e04352) [x86_64-linux]
size = 8190
flags = Array.new(8191)

for i in 1..1000 do
  count = 0
  for n in 0..size do
    flags[n] = true
  end
  for n in 0..size do
    if flags[n] then
      prime = n + n + 3
      k = n + prime
      while k <= size do
        flags[k] = false
        k = k + prime
      end
      count = count + 1
    end
  end
end
print count

#time ruby bytes.rb ⇒ real 0m1.670s
#time ruby --jit bytes.rb ⇒ real 0m1.224s

bytes.scm

(define (test)
  (let* ((size 8190)
         (sizepl 8191)
         (flags (make-vector sizepl #f))
         (count 0))
    (do ((n 0 (add1 n)))
        ((= n 1000))
      (set! count 0)
      (vector-fill! flags #t)
      (do ((i 0 (add1 i)))
          ((> i size))
        (when (vector-ref flags i)
          (let* ((prime (+ i i 3))
                 (k (+ i prime)))
            (do ((k k (+ k prime)))
                ((> k size))
              (vector-set! flags k #f))
            (set! count (add1 count))))))
    count))

#|
Chez 9.5.2
> (time (test))
    0.093714337s elapsed cpu time

Guile
(define-syntax time
  (syntax-rules ()
    [(time FORM)
     (let ([start (get-internal-real-time)])
       FORM
       (/ (- (get-internal-real-time) start) 1.0 internal-time-units-per-second))]))
> (time (test)) => 210ms
|#

bytes.st

"In Squeak 5.3, 5.0-202003021730 OpenSmalltalk"

testWith: flags
| size sizepl count |
size := 8190.
sizepl := 8191.

count := 0.
0 to: size do: [ :i | flags at: i + 1 put: true ].
0 to: size do: [ :i | 
	(flags at: i + 1) ifTrue: [
		| prime k |
		prime := i + i + 3.
		k := i + prime.
		[ k <= size ] whileTrue: [
			flags at: k + 1 put: false.
			k := k + prime
		].
		count := count + 1
	]
].
^count

"| flags |
flags := (Array new: 8191) collect: [ :x | false ].
Time microsecondsToRun: [ 1 to: 1000 do: [ :x | SieveBenchmark testWith: flags. ] ] ⇒ 236875"