neptune 0.1.1 → 0.1.2

data/samples/mpi/run_mpi_cpi.rb

@@ -0,0 +1,10 @@
+
+neptune(
+  :type => "mpi",
+  #:keyname => "neptune",
+  #:input => "baz",
+  #:output => "mpi-output.txt",
+  :code => "cpi"
+  #:filesystem => "nfs"
+)
+

data/samples/mpi/run_mpi_nqueens.np

@@ -0,0 +1,6 @@
+
+neptune :type => "mpi",
+  :keyname => "cluster",
+  :code => "MpiQueen",
+  :nodes_to_use => 2
+

data/samples/mpi/run_mpi_powermethod.rb

@@ -0,0 +1,8 @@
+
+neptune :type => "mpi"
+  #:keyname = "neptune",
+  #:input = "baz",
+  :output = "/mpi-output.txt",
+  :code = "powermethod",
+  :nodes_to_use = 4
+

data/samples/mpi/run_mpi_ring.rb

@@ -0,0 +1,12 @@
+
+output = neptune (
+  :type => "mpi",
+  :keyname => "booscale1",
+  :code => "ring-compiled/Ring",
+  :nodes_to_use => 4,
+  :procs_to_use => 4,
+  :output => "/baz/output"
+)
+
+puts "job started? #{output[:result]}"
+puts "message = #{output[:msg]}"

data/samples/r/compile_hello.rb

@@ -0,0 +1,10 @@
+result = neptune :type => "compile",
+  :code => "hello",
+  :main => "hello.r",
+  :output => "/neptune-testbin/helloR",
+  :copy_to => "hello-compiled",
+  :storage => "s3"
+
+
+puts "out = #{result[:out]}"
+puts "err = #{result[:err]}"

data/samples/r/get_hello_output.rb

@@ -0,0 +1,6 @@
+
+output = neptune :type => "output",
+  :storage => "s3",
+  :output => "/neptune-testbin/helloR/output.txt"
+
+puts output.inspect

data/samples/r/hello/hello.r

@@ -0,0 +1 @@
+"hello world"

data/samples/r/put_input.rb

@@ -0,0 +1,8 @@
+result = neptune( :type => "input",
+ :local => "hello",
+ :remote => "/neptune-testbin/helloR",
+ :storage => "s3"
+)
+
+puts result.inspect
+

data/samples/r/run_hello.rb

@@ -0,0 +1,9 @@
+result = neptune(
+  :type => :r,
+  :output => "/neptune-testbin/helloR/output.txt",
+  :code => "/neptune-testbin/helloR/hello.r",
+  :storage => "s3"
+)
+
+puts result.inspect
+

data/samples/upc/compile_upc_helloworld.rb

@@ -0,0 +1,10 @@
+result = neptune (
+  :type => "compile",
+  #:keyname = "cluster",
+  :code = "helloworld",
+  :output = "/baz",
+  :copy_to = "helloworld-compiled"
+)
+
+puts "out = #{result[:out]}"
+puts "err = #{result[:err]}"

data/samples/upc/compile_upc_ring.rb

@@ -0,0 +1,11 @@
+result = neptune (
+  :type => "compile",
+  #:keyname => "cluster",
+  :code => "ring2",
+  :main => "Ring.c",
+  :output => "/baz",
+  :copy_to => "ring-compiled"
+)
+
+puts "out = #{result[:out]}"
+puts "err = #{result[:err]}"

data/samples/upc/get_mpi_output.rb

@@ -0,0 +1,8 @@
+
+result = neptune (
+  :type => "output",
+  #:keyname => "cluster",
+  :output => "/baz/output"
+)
+
+puts result

data/samples/upc/helloworld/HelloWorld.c

@@ -0,0 +1,9 @@
+#include <upc_relaxed.h>
+#include <stdio.h>
+
+int main() {
+  printf("Hello from thread %i/%i\n", MYTHREAD, THREADS);
+  upc_barrier;
+  return 0;
+}
+

data/samples/upc/helloworld/Makefile

@@ -0,0 +1,3 @@
+all:
+	/usr/local/berkeley_upc-2.12.1/upcc -o HelloWorld HelloWorld.c
+

data/samples/upc/ring/Makefile

@@ -0,0 +1,3 @@
+all:
+	/usr/local/berkeley_upc-2.12.1/upcc --network=mpi -o Ring Ring.c
+

data/samples/upc/ring/Ring.c

@@ -0,0 +1,116 @@
+#include <upc.h>
+#include <upc_strict.h>
+//#include <upc_relaxed.h>
+#include <stdio.h>
+
+#define NUM_MESSAGES 100
+
+#define FROM_MASTER 0
+
+#define size THREADS
+#define rank MYTHREAD
+
+#define MASTER(rank) (rank == 0)
+#define SLAVE(rank) (!MASTER)
+
+#define SUCCESS 0
+#define FAILURE 1
+
+#define DEBUG 0
+
+shared int* a;
+shared int* alldone;
+
+int sendM(target, value) {
+  a[target] = value;
+  if (DEBUG) printf("[node %d] wrote value %d to location %d\n", rank, value, target);
+
+  return 0;
+}
+
+int recvM(from, value) {
+  int tempa = a[from];
+
+  if (DEBUG) printf("[node %d] value at location %d is currently %d (should be %d)\n", rank, from, tempa, value);
+
+  if (tempa == value) {
+    if (DEBUG) printf("[node %d] returns success\n", rank);
+    return SUCCESS;
+  }
+  else {
+    if (DEBUG) printf("[node %d] returns failure\n", rank);
+    return FAILURE;
+  }
+}
+
+int main() {
+  clock_t start_time, end_time;
+
+  // start timing
+  if (MASTER(rank)) {
+    start_time = clock();
+  }
+
+  a = (shared int*) upc_all_alloc(size, sizeof(int));
+  alldone = (shared int*) upc_all_alloc(1, sizeof(int));
+  upc_barrier;
+
+  if (MASTER(rank)) {
+    int i = 0;
+    for(i = 0; i < size; i++) {
+      a[i] = 0;
+      if (DEBUG) printf("A[%d] = %d\n", i, a[i]);
+    }
+  }
+
+  alldone[0] = FAILURE;
+  upc_barrier;
+
+  int curr_msg = 1;
+  for(curr_msg = 1; curr_msg <= NUM_MESSAGES; curr_msg++) {
+    if (MASTER(rank)) a[0] = curr_msg;
+    int msg_send = FAILURE;
+    while(1) {
+      int received = recvM(rank, curr_msg);
+      if ((received == SUCCESS) && (rank + 1 == size)) {
+          if (DEBUG) printf("got last message\n");
+          alldone[0] = SUCCESS;
+      } else if (received == SUCCESS) { 
+        if (msg_send == FAILURE) {
+          if (DEBUG) printf("[node %d] sends a message\n", rank);
+          sendM(rank+1, curr_msg);
+          msg_send = SUCCESS;
+        }
+        sleep(0.01);
+      }
+
+      upc_barrier;
+      if (alldone[0] == SUCCESS) break;
+    }
+
+    upc_barrier;
+    if (rank + 1 == size) alldone[0] = FAILURE;
+    upc_barrier;
+  }
+
+  upc_barrier;
+  if (DEBUG) {
+    int i = 0;
+    for(i = 0; i < size; i++) {
+      printf("[node %d] says A[%d] = %d\n", rank, i, a[i]);
+    }
+  }
+
+  // end timing
+  if (MASTER(rank)) {
+    end_time = clock();
+  }
+
+  if (MASTER(rank)) {
+    double total_time = (double)(end_time - start_time) / CLOCKS_PER_SEC;
+    printf("Total time taken to send %d messages across %d machines was %f\n", NUM_MESSAGES, size, total_time);
+  }
+  upc_barrier;
+  return 0;
+}
+

data/samples/upc/run_upc_helloworld.rb

@@ -0,0 +1,12 @@
+
+output = neptune (
+  :type => "mpi",
+  #@keyname = "cluster"
+  :code => "helloworld-compiled/HelloWorld",
+  :nodes_to_use => 4,
+  :procs_to_use => 8,
+  :output => "/baz/output2"
+)
+
+puts "job started? #{output[:result]}"
+puts "message = #{output[:msg]}"

data/samples/upc/run_upc_ring.rb

@@ -0,0 +1,12 @@
+
+output = neptune(
+  :type => "mpi",
+  #:keyname => "cluster",
+  :code => "ring-compiled/Ring",
+  :nodes_to_use => 4,
+  :procs_to_use => 4,
+  :output => "/baz/output"
+)
+
+puts "job started? #{output[:result]}"
+puts "message = #{output[:msg]}"

data/samples/x10/MyPowerMethod.x10

@@ -0,0 +1,236 @@
+import x10.lang.Math;
+import x10.util.Timer;
+
+public class MyPowerMethod {
+
+	static val SUCCESS = 0;
+	static val ERROR = 1;
+	
+	static val NUM_ITERATIONS = 30;
+	static val EPSILON = 0.00001;
+	
+	static val N = 6400;
+	static val P = Place.MAX_PLACES;
+	
+	/*
+	 * X vector is of size n x 1 and lives on the first processor
+	 * is initialized to one
+	 */
+
+	static val R1 <: Region = (0..N-1);
+	static val D1 <: Dist = R1 -> Place.FIRST_PLACE;
+	//static val F0 <: (Point(1)) => Double = ([i]:Point(1)) => 0.0;
+	static val F1 <: (Point(1)) => Double = ([i]:Point(1)) => 1.0;
+	static val X <: DistArray[Double] = DistArray.make[Double](D1, F1);
+	
+	/*
+	 * A matrix is of size n x n and lives on all processors
+	 * each proc gets a block of size (n/p) x n where p is the
+	 * number of processors
+	 * is initialized to zero
+	 */
+
+	static val R2 <: Region = (0..N-1) * (0..N-1);
+	static val D2 <: Dist = Dist.makeBlock(R2);	
+	static val F2 <: (Point(2)) => Double = ([i, j]:Point(2)) => 0.0;	
+	static val A <: DistArray[Double] = DistArray.make[Double](D2, F2);
+		
+	public static def norm() {
+		var theNorm : Double = 0.0;
+		
+		for (var index : Int = 0; index < N; index++) {
+			theNorm += (X(index) * X(index));
+		}
+		
+		return Math.sqrt(theNorm);
+	}	
+
+	public static def matVec() {
+		// new way - should be nice and fast
+		val D0 <: Dist = Dist.makeBlock(R1);
+		val F0 <: (Point(1)) => Double = ([i]:Point(1)) => 0.0;
+		val XTemp = DistArray.make[Double](D0, F0);
+
+		finish {
+			for (place in A.dist().places()) {
+				async at (place) {
+          				val DHere <: Dist = R1 -> here;
+					val XCopy = DistArray.make[Double](DHere, F0);
+					for (var i : Int = 0; i < N; i++) {
+ 						val index = i;
+						XCopy(index) = at (Place.FIRST_PLACE) { X(index) };
+ 					}
+
+					//Console.OUT.printf("my place id is %d, next id is %d\n", place.id, place.next().id);
+
+					var startRow : Int = place.id * N / P;
+					var endRow : Int = (place.id + 1) * N / P;
+					//if (endRow == 0) { endRow = startRow + N / P; }
+				
+					//Console.OUT.printf("start row is %d, end row is %d\n", startRow, endRow);
+	
+					for (var row : Int = startRow; row < endRow; row++) {
+						var sum : Double = 0;
+						for (var col : Int = 0; col < N; col++) {
+							val inner = col;
+     							sum += (A(row,col) * XCopy(col));
+							//val XPoint = at (Place.FIRST_PLACE) { X(inner) };
+							//sum += (A(row,col) * XPoint);
+    							//Console.OUT.printf("A(%d,%d) * X(%d) = %d * %d\n", row, col, inner, A(row,col), XPoint);
+						}
+						XTemp(row) = sum;
+						//Console.OUT.printf("setting x(%d) to %f\n", row, sum);
+					}
+				}
+			}
+		}
+
+		for (var index : Int = 0; index < N; index++) {
+			val row = Point.make(index);
+			val correctPlace = XTemp.dist.apply(row);
+			val XNew = at (correctPlace) { XTemp(row) };
+			X(index) = XNew;
+			//Console.OUT.printf("actually setting x(%d) to %f\n", index, XNew);
+		}
+
+		// old way - slow on big sizes of N
+		/* 	
+		val D0 <: Dist = R1 -> here;
+		val F0 <: (Point(1)) => Double = ([i]:Point(1)) => 0.0;
+		val XTemp = DistArray.make[Double](D0, F0);		
+		for (var outer : Int = 0; outer < N; outer++) {
+			val sum : Array[Double](1) = new Array[Double](1);
+			sum(0) = 0;
+			for (var inner : Int = 0; inner < N; inner++) {
+				val inner1DPoint = Point.make(inner);
+				val inner2DPoint = Point.make(outer,inner);
+				val correctPlace = A.dist.apply(inner2DPoint);
+				val XPoint = X(inner1DPoint);
+				sum(0) += at (correctPlace) {
+					(A(inner2DPoint) * XPoint)
+				};
+				//Console.OUT.printf("[out] sum is now %f\n", sum(0));
+			}
+			XTemp(outer) = sum(0);
+			//Console.OUT.printf("XTemp(%d) is now %f\n", outer, sum(0));
+		}
+		 
+		//Console.OUT.println("After Matvec:");
+		for (var index : Int = 0; index < N; index++) {
+			X(index) = XTemp(index);
+	        //Console.OUT.printf("x[%d] = %f\n", index, X(index));
+		} 
+	*/
+		return;
+	}	
+	
+	 public static def powerMethod() {
+		var xNorm : Double = 0;		
+
+		for (var iter : Int = 0; iter < NUM_ITERATIONS; iter++) {
+			xNorm = norm();
+			Console.OUT.printf("At iteration %d, the norm of x is %f\n", iter, xNorm);
+			
+			for (var index : Int = 0; index < N; index++) {
+				val myIndex = index;
+				val myXNorm = xNorm;
+				X(myIndex) = X(myIndex) / myXNorm;
+				//Console.OUT.printf("x[%d] = %f\n", index, X(index));
+			}
+		 	Console.OUT.printf("entering matvec\n");	
+			matVec();
+		}
+
+		for (var index : Int = 0; index < N; index++) {
+			val myIndex = index;
+			val myXNorm = xNorm;
+			//Console.OUT.printf("final x[%d] = %f\n", index, X(index));
+		}
+
+		return xNorm;
+	 }
+
+	public static def generateMatrix() {
+		if (N % P != 0) {
+			Console.OUT.println("n doesn't divide p evenly. Please enter n and try again.");
+			return ERROR;
+		}		
+		
+		// put the value N at the diagonals
+		finish {	
+			for (var i : Int = 0; i < N; i++) {
+				val diagonal = Point.make(i, i);
+				val correctPlace = A.dist.apply(diagonal);
+				async at (correctPlace) {
+					A(diagonal) = N;
+				}
+			}
+		}
+
+		return SUCCESS;
+	}
+	
+	public static def verify() {
+		val answer = Math.sqrt(N + 0.0f);
+		for (var i : Int = 0; i < N; i++) {
+			val diff = Math.abs(X(i) - answer);
+			if (diff > EPSILON) {
+				Console.OUT.printf("X(%d)'s value, %f, was too far away from %f\n", i, X(i), answer);
+				return ERROR;
+			}
+		}
+		
+		return SUCCESS;
+	}
+	
+	public static def printArray[T](array:DistArray[T]) {
+		for (place in array.dist.places()) {
+			at (place) {
+				for (point in array.dist | here ) {
+					val myPoint : String = "[" + point(0) + ", " + point(1) + "] ->" + array(point);
+					Console.OUT.println(myPoint);
+				}
+			}
+		}
+		
+		return;
+	} 
+
+    public static def main(args:Array[String](1)) {
+    	//Console.OUT.println("str(x) = " + X);
+    	//printArray(X);
+    	//Console.OUT.println("str(a) = " + A);
+    	//printArray(A);
+
+		Console.OUT.println("n is " + N);
+		Console.OUT.println("p is " + P);
+		
+    	val retval = generateMatrix();
+    	if (retval == ERROR) {
+    		Console.OUT.println("ERROR");
+    		return;
+    	}
+    	
+       	//Console.OUT.println("str(x) = " + X);
+    	//printArray(X);
+    	//Console.OUT.println("str(a) = " + A);
+    	//printArray(A);
+
+    	val startTime = Timer.milliTime();
+    	val spectralRadius = powerMethod();
+    	val endTime = Timer.milliTime();
+    	val totalTime = (endTime - startTime) / 1000.0;
+    	   
+    	Console.OUT.printf("The spectral radius is %f\n", spectralRadius);
+   		Console.OUT.printf("It took %f seconds\n", totalTime);
+
+   		//printArray(X);
+
+   		val result = verify();
+   		if (result == SUCCESS) {
+   			Console.OUT.printf("Yay, we win!\n");
+   		} else {
+   			Console.OUT.printf("Boo, we lose... again\n");
+   		}   			
+	}
+}