Ubuntu : Intel® Q6600® one 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 CINT C gcc Clojure C# Mono C++ g++ Dart Erlang HiPE F# Mono Fortran Intel Go Haskell GHC Java 7 JavaScript V8 Lisp SBCL Lua OCaml Pascal Free Pascal Perl PHP Python 3 Racket Ruby 2.0 Ruby JRuby Scala Smalltalk VisualWorks x86 one core x64 quad-core x86 quad-core x64 one core

 performance measurements

Each table row shows performance measurements for this Lisp SBCL program with a particular command-line input value N.

N	CPU secs	Elapsed secs	Memory KB	Code B	≈ CPU Load
500,000	2.98	2.99	20,268	571	0% 1% 1% 100%
5,000,000	30.68	30.70	52,436	571	0% 0% 1% 100%
50,000,000	326.76	327.00	53,688	571	0% 0% 0% 100%

Read the ↓ make, command line, and program output logs to see how this program was run.

Read thread-ring benchmark to see what this program should do.

 notes

This is SBCL 1.1.7, an implementation of ANSI Common Lisp.

 thread-ring Lisp SBCL #2 program source code

;;; The Computer Language Benchmarks Game
;;; http://benchmarksgame.alioth.debian.org/
;;;
;;; contributed by Witali Kusnezow 2008-12-19
;;;     using semaphore synchronization

(defconstant  +threads+ 503)
(defparameter *counter* 0)
(defparameter *current* 0)
(defparameter *semaphore* (sb-thread:make-semaphore))
(defparameter *semaphores*
  (make-array +threads+
              :initial-contents
              (loop for i of-type fixnum below +threads+
                 collect (sb-thread:make-semaphore))))

(declaim (type fixnum *counter* *current*))

(defmacro wait   (semaphore)
  `(sb-thread:wait-on-semaphore ,semaphore))
(defmacro wake (semaphore)
  `(sb-thread:signal-semaphore  ,semaphore))
(defmacro kill   (thread)
  `(handler-case (sb-thread:terminate-thread ,thread)
     (sb-thread:interrupt-thread-error () nil)))

(defun thread-body ()
  (let* ((curr (svref *semaphores* *current*))
         (next (svref *semaphores* (if (= (incf *current*) +threads+) 0 *current*)))
         (number *current*))
    (loop do (wait curr)
       until (zerop (decf *counter*))
       do (wake next)
       finally (format t "~d~%" number) (wake *semaphore*))))

(defun start (n)
  (declare (type fixnum n))
  (setq *counter* (1+ n) *current* 0)
  (loop for i of-type fixnum below +threads+
     collect (sb-thread:make-thread #'thread-body) into threads
     finally
       (wake (svref *semaphores* 0))
       (wait *semaphore*)
       (dolist (i threads) (kill i))))

(defun main ()
  (let ((n (parse-integer (or (car (last #+sbcl sb-ext:*posix-argv*
                                         #+cmu  extensions:*command-line-strings*
                                         #+gcl  si::*command-args*)) "1"))))
    (start n)))

 make, command-line, and program output logs

Fri, 03 May 2013 23:13:00 GMT

MAKE:
cp: ‘threadring.sbcl-2.sbcl’ and ‘./threadring.sbcl-2.sbcl’ are the same file
SBCL built with: /usr/local/bin/sbcl --userinit /dev/null --batch --eval '(load "threadring.sbcl-2.sbcl_compile")'
### START threadring.sbcl-2.sbcl_compile
(handler-bind ((sb-ext:defconstant-uneql      (lambda (c) (abort c))))      (load (compile-file "threadring.sbcl-2.sbcl" ))) (save-lisp-and-die "sbcl.core" :purify t)
### END threadring.sbcl-2.sbcl_compile


; compiling file "/home/dunham/benchmarksgame/bench/threadring/threadring.sbcl-2.sbcl" (written 24 JAN 2013 02:01:16 PM):
; compiling (DEFCONSTANT +THREADS+ ...)
; compiling (DEFPARAMETER *COUNTER* ...)
; compiling (DEFPARAMETER *CURRENT* ...)
; compiling (DEFPARAMETER *SEMAPHORE* ...)
; compiling (DEFPARAMETER *SEMAPHORES* ...)
; compiling (DECLAIM (TYPE FIXNUM ...))
; compiling (DEFMACRO WAIT ...)
; compiling (DEFMACRO WAKE ...)
; compiling (DEFMACRO KILL ...)
; compiling (DEFUN THREAD-BODY ...)
; compiling (DEFUN START ...)
; compiling (DEFUN MAIN ...)

; /home/dunham/benchmarksgame_onecore/threadring/tmp/threadring.sbcl-2.fasl written
; compilation finished in 0:00:00.027
[undoing binding stack and other enclosing state... done]
[saving current Lisp image into sbcl.core:
writing 3512 bytes from the read-only space at 0x0x1000000
writing 2256 bytes from the static space at 0x0x1100000
writing 28250112 bytes from the dynamic space at 0x0x9000000
done]
### START threadring.sbcl-2.sbcl_run
(main) (quit)
### END threadring.sbcl-2.sbcl_run

0.60s to complete and log all make actions

COMMAND LINE:
/usr/local/bin/sbcl   --noinform --core sbcl.core --userinit /dev/null --load threadring.sbcl-2.sbcl_run 50000000

PROGRAM OUTPUT:
292

  Home   Conclusions   License   Play