/mobile Handheld Friendly website

 performance measurements

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

 N  CPU secs Elapsed secs Memory KB Code B ≈ CPU Load
5002.961.4355,744808  39% 92% 32% 46%
3,0007.732.7459,248808  83% 64% 62% 75%
5,50018.765.5364,384808  83% 81% 81% 95%

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

Read spectral-norm benchmark to see what this program should do.

 notes

java version "1.8.0"
Java(TM) SE Runtime Environment (build 1.8.0-b132)
Java HotSpot(TM) 64-Bit Server VM (build 25.0-b70, mixed mode)

Clojure 1.6

 spectral-norm Clojure #6 program source code

;; The Computer Language Benchmarks Game
;; http://benchmarksgame.alioth.debian.org/
;;
;; contributed by Jim Kannampuzha
;; inspired by Jesse Rosenstock
;; modified by Andy Fingerhut (small bug where if input value n was
;;    not a multiple of the number of available processors, the
;;    program would hang.)


(ns spectralnorm
  (:gen-class))

(set! *warn-on-reflection* true)

(defmacro eval-a [ii jj]
  `(let [i# (int ~ii)
         j# (int ~jj)
         n# (unchecked-add i# j#)
         n+1# (unchecked-inc n#)]
     (/ (double 1.0)
        (unchecked-add (bit-shift-right (unchecked-multiply n# n+1#) (int 1))
                       (unchecked-inc i#)))))

(defn multiply-a-v [agent ^doubles v ^doubles av range]
  (let [end (int (second range))]
    (loop [i (int (first range))]
      (if (= i end)
        nil
        (do
          (aset av i (double (areduce v j sum (double 0)
                                      (+ sum (* (eval-a i j) (aget v j))))))
          (recur (unchecked-inc i)))))))

(defn multiply-at-v [agent ^doubles v ^doubles atv range]
  (let [end (int (second range))]
    (loop [i (int (first range))]
      (if (= i end) nil
          (do
            (aset atv i
                  (double (areduce v j sum (double 0)
                   (+ sum (* (eval-a j i) (aget v j))))))
            (recur (unchecked-inc i)))))))

(defn multiply-at-a-v [^doubles v ^doubles tmp ^doubles at-av
                       num-threads workers ranges]
  (dotimes [i num-threads]
    (send (nth workers i) multiply-a-v v tmp (nth ranges i)))
  (apply await workers)
  (dotimes [i num-threads]
    (send (nth workers i) multiply-at-v tmp at-av (nth ranges i)))
  (apply await workers))

(defmacro dot-product [^doubles u ^doubles v]
  `(areduce ~u i# sum# (double 0) (+ sum# (* (aget ~u i#) (aget ~v i#)))))

(defn run-game [size]
  (let [num-threads (int (.availableProcessors (Runtime/getRuntime)))
        workers (vec (repeatedly num-threads #(agent ())))
        chunk-size (int (Math/ceil (/ size num-threads)))
        ranges  (vec (partition 2 1
                                (take (unchecked-inc num-threads)
                                      (iterate #(min (+ chunk-size %) size)
                                               (int 0)))))
        u (double-array size 1.0)
        tmp (double-array size 0.0)
        v (double-array size 0.0)]
    (dotimes [_ 10]
      (multiply-at-a-v u tmp v num-threads workers ranges)
      (multiply-at-a-v v tmp u num-threads workers ranges))
    (let [vbv (dot-product u v)
          vv (dot-product v v)]
      (Math/sqrt (/ vbv vv)))))

(defn -main [& args]
  (let [n (if (empty? args)
            2500
            (Integer/valueOf ^String (first args)))]
    (println (format "%.9f" (run-game n)))
    (shutdown-agents)))

 make, command-line, and program output logs

Fri, 18 Apr 2014 21:06:39 GMT

MAKE:
mv spectralnorm.clojure-6.clojure spectralnorm.clj
/usr/local/src/jdk1.8.0/bin/java -Dclojure.compile.path=. -cp .:/usr/local/src/clojure/clojure-1.6.0.jar clojure.lang.Compile spectralnorm
Compiling spectralnorm to .
1.83s to complete and log all make actions

COMMAND LINE:
/usr/local/src/jdk1.8.0/bin/java -server -XX:+TieredCompilation -XX:+AggressiveOpts -Xmx8m -cp .:/usr/local/src/clojure/clojure-1.6.0.jar spectralnorm 5500

PROGRAM OUTPUT:
1.274224153

Revised BSD license

  Home   Conclusions   License   Play