Add all code from original repo

Author: dmiller

.gitignore

@@ -2,4 +2,7 @@ pom.xml
 *jar
 /lib/
 /classes/
+.lein-failures
 .lein-deps-sum
+.#*
+.DS_Store

README.md

@@ -1,4 +1,134 @@
-clojure-cise-2012
-=================
+# Clojure examples for Computing in Science and Engineering article, 2012
+
+Wherein we investigate parallelism in Clojure to pique the interests of Fortran/C++ coders.
+
+## Installation
+
+We recommend installing Leiningen. Leiningen will help install Clojure and it make it easy to run tests and start a REPL. For more information on Leiningen, including installation instructions,
+go to [http://github.com/technomancy/leiningen].
+
+Buttons to download a .zip or a .tar.gz of the contents can be found [the download page](https://github.com/dmiller/clojure-cise-2012/downloads) of our Github repository.  Download and unzip to somewhere.  Start a terminal/cmd/whatever you call it and cd to where you unzipped the code.
+
+To run the tests, 
+
+   $ lein test
+
+To start a REPL,
+
+   $ lein repl
+
+Once you have the REPL going:
+
+    user=> (load "cise/core")
+    nil
+    user=> (in-ns 'cise.core)
+    #<Namespace cise.core>
+    cise.core=> 
+
+To test the _stats_ program:
+
+    cise.core=> (test-sum 1000)
+    [1000 500.34570874019175 0.5003457087401918]
+
+To test the _poisson_ program:
+
+    cise.core=> (def a (double-array 100))  ; double array, size 100, all 0  
+    #'cise.core/a
+     
+    cise.core=> (aset a 50 1.0)             ; let's get at least one non-zero value in there                                  
+    1.0
+     
+    cise.core=> (def r (agent-solver a 5 200))    ;  5 slices, 200 iterations
+    #'cise.core/r
+     
+    cise.core=> (aget r 50)
+    5.634847900925116
+     
+    cise.core=> (aget r 49)
+    5.163022140429744
+
+Time to get serious:
+
+    cise.core=> (def a (double-array 1000000))
+    #'cise.core/a
+     
+    cise.core=> (aset a 500000 1.0)
+    1.0
+     
+    cise.core=> (time (agent-solver a 1 1000))  ; 1,000,000 points, 1 thread, 1000 iterations
+    "Elapsed time: 6271.475 msecs"
+     
+    cise.core=> (time (agent-solver a 2 1000))  ; 2 threads
+    "Elapsed time: 4152.594 msecs"
+     
+    cise.core=> (time (agent-solver a 4 1000))
+    "Elapsed time: 3212.367 msecs"
+     
+    cise.core=> (time (agent-solver a 5 1000))
+    "Elapsed time: 3272.189 msecs"
+     
+     cise.core=> (time (agent-solver a 6 1000))
+     "Elapsed time: 3130.349 msecs"
+      
+     cise.core=> (time (agent-solver a 7 1000))
+     "Elapsed time: 3124.874 msecs"
+      
+     cise.core=> (time (agent-solver a 8 1000))
+     "Elapsed time: 3130.097 msecs"
+       
+     cise.core=> (time (agent-solver a 16 1000))
+     "Elapsed time: 3132.442 msecs"
+
+On a four-core machine, max speedup occurs at around 6 or 7 slices -- NumCores+2 is not unexpected.  The thread pooler throttles us from there.
+
+To run the _sim_ program, it is best to move to the cise.sim namespace.
+
+    cise.core=> (in-ns 'cise.sim)
+    #<Namespace cise.sim>
+
+We have left in some print statements so that you can see the ants behaving.  After you start the simulation running, you stop it by evaluating
+
+    (def running false)
+
+However, you will be trying to type that while the output is scrolling, so good luck!   After you've typed, all running agents will do one more iteration and shut down. You can then ask for report on the status of all the ants.
+
+    cise.sim=> (start)
+    "Creating ant at " [4 5]
+    "Creating ant at " [5 1]
+    "Creating ant at " [3 2]
+    ...    
+    nil
+
+    cise.sim=> 
+    5 ": Behaving at " [7 4]
+    0 ": Behaving at " [4 5]
+    4 ": Behaving at " [9 0]
+    5 ": From " [7 4] " to " [7 5] ": " [7 5]
+    4 ": From " [9 0] " to " [0 0] ": " [0 0]
+    0 ": From " [4 5] " to " [3 4] ": " [3 4]
+    2 ": Behaving at " [3 2]
+    2 ": From " [3 2] " to " [2 3] ": " [2 3]
+    3 ": Behaving at " [5 1]
+    3 ": From " [5 1] " to " [6 0] ": " [6 0]
+    6 ": From " [9 4] " to " [9 3] ": " [9 3]
+    7 ": From " [0 0] " to " [9 1] ": " [9 1]
+    ...
+
+The number on the left of each line is the ant id.
+Somewhere along the way, I typed (def running false), and eventually output ceased.
+
+    cise.sim=> 
+    cise.sim=> (report)
+    ({:moves 21, :stays 2, :id 2} {:moves 18, :stays 4, :id 8} 
+     {:moves 23, :stays 0, :id 6} {:moves 22, :stays 1, :id 3} 
+     ...)
+
+
+Type Ctrl-C to get out of the REPL.
+
+## License
+
+Copyright (C) 2012 Marty Kalin and David Miller
+
+Distributed under the Eclipse Public License, the same as Clojure.
 
-Code for Computing in Science &amp; Engineering article on Clojure, Vol 14, No 6 (Nov/Dec 2012)

project.clj

@@ -0,0 +1,4 @@
+(defproject cise2012 "1.0.0-SNAPSHOT"
+  :description "Sample solver for 1D Poisson problems"
+  :url "https://github.com/dmiller/clojure-cise-2012"
+  :dependencies [[org.clojure/clojure "1.3.0"]])

src/cise/agents.clj

@@ -0,0 +1,57 @@
+(ns cise.agents
+  (:use [cise.simple :only (step-slice)]
+        [cise.poisson :only (slice-sizes)]))
+  
+(set! *warn-on-reflection* true)
+  
+;; Agent-based approach #1
+;; Requires two copies of the array, current and next
+;; Works one iteration at a time
+;;
+;; Agent state is a map with the following
+;;  :agent-idx -- index of the agent for this slice, for debugging primarily
+;;  :start-idx  -- index of first position of slice106
+;;  :end-idx -- index of first position of next slice
+;;  :src -- array with current values
+;;  :dest -- array to put next iteration in
+;;  :rhos -- yep
+;;
+;;  The src, dest, and rhos array could be passed in def'd vars,
+;;    but I'd rather put them in the state.
+;;
+;; This will be a case-2 solution -- we will put the end values in position 0,n-1.
+;; Assume we are handed the initial array with this satisfied.  Rhos also.
+;; Thus the first slice will have :start-idx == 1
+;; And  the last  slice will have   :end-idx == n-1
+;;
+;; We will swap src & dest at each iteration.
+
+(defn step-agent1-slice [slice]
+  (let [src (:src slice)
+        dest (:dest slice)]
+    (step-slice src
+                dest
+                (:rhos slice)
+                (:start-idx slice)
+                (:end-idx slice))
+    (assoc slice :src dest :dest src)))
+
+(defn agent1-solver [init-array rhos num-slices num-iters ]
+  (let [n (count init-array)
+        arr2 (double-array n)
+        sizes (slice-sizes (- n 2) num-slices)
+        start-indexes (reductions + 1 sizes)        
+        make-slice (fn [i start-idx end-idx]
+                     {:agt-idx i            ; for debugging
+                      :start-idx start-idx
+                      :end-idx end-idx
+                      :src init-array
+                      :dest arr2
+                      :rhos rhos})
+        slices (map make-slice (range num-slices) start-indexes (rest start-indexes))
+        agts (map agent slices)]
+    (dotimes [i num-iters]
+      (doseq [a agts] (send a step-agent1-slice))
+      (apply await agts))
+    (:src @(first agts))))
+  

src/cise/core.clj

@@ -0,0 +1,6 @@
+(ns cise.core
+ (use [cise stats poisson sim agents futures simple]))
+
+;; This namespace just pulls in all the other namespaces to play with.
+
+

src/cise/futures.clj

@@ -0,0 +1,29 @@
+(ns cise.futures
+  (:use [cise.poisson :only (slice-sizes)]
+        [cise.simple :only (step-slice)]))
+
+(set! *warn-on-reflection* true)
+
+;; iterative solves 1-D Poisson problem
+;; rhos is a (Java) array of doubles.
+;; requires dummy values in first and last position
+;; Does num-iters iteration to solve
+;; Number of threads = num-slices
+;; On each iteration
+;;    create a future on each slice
+;;     Wait for each future to be computed 
+;;    Swap source and destination arrays for next iteration
+
+(defn future-solver [rhos num-slices num-iters]
+  (let [n (count rhos)
+        dest1 (double-array n)
+        dest2 (double-array n)
+        sizes (slice-sizes (- n 2) num-slices)
+        start-indexes (reductions + 1 sizes)
+        end-indexes (rest start-indexes)]
+    (loop [i 0 src dest1 dest dest2]
+           (if (< i num-iters)
+             (let [fs (doall (map #(future (step-slice src dest rhos %1 %2)) start-indexes end-indexes))]
+               (doseq [f fs] @f)
+               (recur (inc i) dest src))
+               src))))

src/cise/poisson.clj

@@ -0,0 +1,143 @@
+(ns cise.poisson)
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;;  Agent example
+;;
+;; Compute a solution to 1D Poisson problem.
+;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+
+(set! *warn-on-reflection* true)
+
+;; Compute the next value at a location (unhinted version)
+(defn next-value-no-hint  [rho left right]
+  (* 0.5 (+ (+ left right) rho)))
+
+;; Compute the next value at a location (unhinted version)
+(defn next-value
+  ^double [^double rho ^double left ^double right]
+  (* 0.5 (+ (+ left right) rho)))
+
+;; Update the slice [start-index, end-index) in array arr
+(defn step-slice-in-place [^doubles arr ^doubles rhos start-index end-index lval rval]
+  (let [last-idx (unchecked-dec (int end-index))]
+    (loop [old-val (double lval)
+           i (int start-index)]
+      (if (< i last-idx)
+        (let [cur-val (aget arr i)]
+          (aset arr i (next-value (aget rhos i) old-val (aget arr (inc i))))
+          (recur cur-val (unchecked-inc i)))
+        (aset arr last-idx (next-value (aget rhos i) old-val (double rval)))))))
+
+;; Agent state is a map with the following:
+;;   :agent-idx -- index of the agent for this slice
+;;   :start-idx -- index of first position of slice
+;;   :end-idx -- index of first position of next slice
+;;   :niters -- the number of iterations to perform
+;;   :iter -- current iteration number
+;;   :lq -- queue of values coming from the slice to the left
+;;   :rq -- queue of values coming from the slice to the right
+;;
+;;   Careful analysis shows that no slice can be more than one ahead of any other slice,
+;;     so a queue never gets larger than 2.  But it can be two.
+
+
+(def agents (ref nil))   ; a vector of agents 
+(def rhos   (ref nil))   ; an array of doubles
+(def arr    (ref nil))   ; an array of doubles, the work vector
+(def latch  (ref nil))   ; a countdown latch
+
+
+(defn agt-at [i]
+  (get @agents i))
+
+(defn left-agt [i]
+  (agt-at (dec i)))
+
+(defn right-agt [i]
+  (agt-at (inc i)))
+
+
+(defn step-slice-data [slice lval rval]
+  ;; (:key map) is equivalent to (get map :key)
+  (step-slice-in-place @arr @rhos (:start-idx slice) (:end-idx slice) lval rval))
+
+(declare update-slice)
+
+(defn enqueue-left [slice value]
+  (update-slice (assoc slice :lq (conj (:lq slice) value))))
+
+(defn enqueue-right [slice value]
+  (update-slice (assoc slice :rq (conj (:rq slice) value))))
+
+(defn notify-neighbors [i lval rval]
+  (let [lagt (left-agt i)
+        ragt (right-agt i)
+        agt (agt-at i)]
+    (if (nil? lagt)
+      (send agt enqueue-left 0.0)
+      (send lagt enqueue-right lval))
+    (if (nil? ragt)
+      (send agt enqueue-right 0.0)
+      (send ragt enqueue-left rval))))
+
+
+(defn update-slice [slice]
+ (let [{:keys [lq rq iter niters agt-idx start-idx end-idx]} slice
+       lval (peek lq)
+       rval (peek rq)]
+   (if (or (nil? lval) (nil? rval) (>= iter niters))
+     slice
+     (do
+       (step-slice-data slice lval rval)
+       (notify-neighbors agt-idx
+                         (aget ^doubles @arr start-idx)
+                         (aget ^doubles @arr (dec end-idx)))
+       (when (= (inc iter) niters)
+         (swap! @latch dec))
+       (assoc slice :iter (inc iter) :lq (pop lq) :rq (pop rq))))))
+
+
+(defn slice-sizes [n num-slices]
+  (let [r (rem n num-slices)
+        d (quot n num-slices)]
+    (concat (repeat r (inc d)) (repeat (- num-slices r) d))))
+
+ 
+(defn create-agents [nvals nslices niters]
+  (let [start-indexes (reductions + 0 (slice-sizes nvals nslices))
+        q0 (conj clojure.lang.PersistentQueue/EMPTY 0.0)           ;; immutable, so all can share
+        make-slice (fn [i start-idx end-idx]
+                     {:agt-idx i
+                      :start-idx start-idx
+                      :end-idx end-idx
+                      :niters niters
+                      :iter 0
+                      :lq q0
+                      :rq q0})
+        slices (map make-slice (range nvals) start-indexes (rest start-indexes))]
+    (into [] (map agent slices))))
+
+
+(defn start-agents [agts]
+  (doseq [a agts]
+    (send a update-slice)))
+
+(defn agent-solver [rs nslices niters]
+  (let [nvals (count rs)
+        agts (create-agents nvals nslices niters)
+        p (promise)
+        a-watch (fn [key a old-val new-val]
+                  (when (zero? new-val)
+                    (deliver p true)))]
+    (dosync
+     (ref-set agents agts)
+     (ref-set arr (double-array nvals))
+     (ref-set rhos rs)
+     (ref-set latch (atom nslices)))    
+    (add-watch @latch :zero a-watch)
+    (start-agents agts)
+    @p
+    @arr))