neptune 0.1.1 → 0.1.2

data/samples/mpi/Makefile

@@ -0,0 +1,22 @@
+CC = mpicc
+CCFLAGS = 
+VLIBS = -L/usr/local/apps/vampirtrace/lib -lVT -lnsl -lm -lpthread
+LIBS =  -lm
+OBJS = hw2.o hw2harness.o
+
+
+all: hw2
+
+hw2: $(OBJS)
+	$(CC) $(CCFLAGS) -o hw2 $(OBJS) $(LIBS)
+
+hw2_v4: $(OBJS)
+	$(CC) $(CCFLAGS) -o hw2_v4 $(OBJS) $(VLIBS)
+
+hw2_v16: $(OBJS)
+	$(CC) $(CCFLAGS) -o hw2_v16 $(OBJS) $(VLIBS)
+
+clean:
+	-rm $(OBJS)
+
+.c.o:;  $(CC) $(CCFLAGS) -c $<

data/samples/mpi/compile_mpi_ring.rb

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

data/samples/mpi/compile_x10_nqueens.rb

@@ -0,0 +1,8 @@
+job "compile" do
+  #@keyname = "cluster"
+  @code = "NQueensDist.x10"
+  @output = "/baz"
+  @lang = "x10"
+  @copy_to = "NQueensCompiled"
+end
+

data/samples/mpi/get_mpi_output.rb

@@ -0,0 +1,5 @@
+
+neptune :type => "output",
+  #@keyname = "neptune"
+  :output => "/bazoutput"
+

data/samples/mpi/get_ring_output.rb

@@ -0,0 +1,5 @@
+output = neptune :type => "output",
+      :keyname => "booscale1",
+      :output => "/baz/output"
+
+puts output

data/samples/mpi/hw2.c

@@ -0,0 +1,205 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+#include "mpi.h"
+#include "hw2harness.h"
+
+
+#define NUM_ITERATIONS 10
+#define FROM_MASTER 0
+
+#define MASTER(rank) (rank == 0)
+#define SLAVE(rank) (!MASTER)
+
+double** A;
+double* x;
+int n, dim;
+
+//-----------------------------------------------------------------------
+void getNFromUser() {
+  //printf("Please enter n, so that we can create an n x n matrix: ");
+  //fflush(stdout);
+  //scanf("%d", &n);
+  
+  n = 3072;
+
+  MPI_Bcast(&n, 1, MPI_INT, FROM_MASTER, MPI_COMM_WORLD); 
+
+  return;
+}
+
+//-----------------------------------------------------------------------
+void receiveN() {
+  MPI_Bcast(&n, 1, MPI_INT, FROM_MASTER, MPI_COMM_WORLD);
+  return;
+}
+
+//-----------------------------------------------------------------------
+int generateMatrix(int p, int rank) {
+  MPI_Barrier(MPI_COMM_WORLD);
+
+  if (MASTER(rank)) {
+    getNFromUser();
+  } else {
+    receiveN();
+  }
+
+  MPI_Barrier(MPI_COMM_WORLD);
+
+  if (n % p != 0) {
+    if (MASTER(rank)) {
+      printf("n doesn't divide p evenly. Please enter n and try again.\n");
+    }
+    return(1);
+  }
+
+  int starting = (n/p) * rank + 1;
+  int ending = (n/p) * (rank + 1);
+  dim = ending - starting + 1;
+  //printf("Proc %d: Generating %d rows, %d through %d\n", rank, dim, starting, ending);
+
+  double* A_tmp = cs240_generateMatrix(n,starting-1,dim);
+  int cnt = 0;
+  
+
+  A = malloc(dim * sizeof(double*));
+  int outer = 0;
+  int inner = 0;
+  for (outer = 0; outer < dim; outer++) {
+    A[outer] = malloc(n * sizeof(double));
+    for (inner = 0; inner < n; inner++) {
+      //A[outer][inner] = 1.0f;
+      A[outer][inner] = A_tmp[cnt];
+      cnt++;
+    }
+  }
+
+  x = malloc(n * sizeof(double));
+  int index = 0;
+  for (index = 0; index < n; index++) {
+    x[index] = 1;
+  }
+
+  return(0);
+}
+
+//-----------------------------------------------------------------------
+double norm() {
+  double theNorm = 0;
+
+  int index = 0;
+
+  for (index = 0; index < n; index++) {
+    theNorm += (x[index] * x[index]);
+  }
+
+  theNorm = sqrt(theNorm);
+
+  return theNorm;
+}
+
+//-----------------------------------------------------------------------
+void matVec(int rank) {
+  int index = 0;
+  MPI_Bcast(x, n, MPI_DOUBLE, FROM_MASTER, MPI_COMM_WORLD);
+  MPI_Barrier(MPI_COMM_WORLD);
+
+  double* result = malloc(dim * sizeof(double));
+  int outer = 0;
+  for (outer = 0; outer < dim; outer++) {
+    double sum = 0;
+    int inner = 0;
+    for (inner = 0; inner < n; inner++) {
+      sum += (A[outer][inner] * x[inner]);
+    }
+    result[outer] = sum;
+  }
+
+  MPI_Barrier(MPI_COMM_WORLD);
+  MPI_Gather(result, dim, MPI_DOUBLE, x, dim, MPI_DOUBLE, FROM_MASTER, MPI_COMM_WORLD);
+  MPI_Barrier(MPI_COMM_WORLD);
+  free(result);
+  return;
+}
+
+//-----------------------------------------------------------------------
+double powerMethod(int rank) {
+  MPI_Barrier(MPI_COMM_WORLD);
+  double xNorm = 0;
+
+  int iteration = 0;
+  for (iteration = 0; iteration < NUM_ITERATIONS; iteration++) {
+    if (MASTER(rank)) {
+      xNorm = norm();
+      //printf("At iteration %d, the norm of x is %f\n", iteration, xNorm);
+
+      int index = 0;
+      for (index = 0; index < n; index++) {
+        x[index] = x[index] / xNorm;
+        //printf("x[%d] = %f\n", index, x[index]);
+      }
+    }
+
+    MPI_Barrier(MPI_COMM_WORLD);
+    matVec(rank);
+    MPI_Barrier(MPI_COMM_WORLD);
+  }
+
+  MPI_Barrier(MPI_COMM_WORLD);
+  return xNorm;
+}
+
+//-----------------------------------------------------------------------
+
+int main(int argc, char *argv[])
+{
+  int rank, size;
+  double start_time,end_time;
+  MPI_Init(&argc,&argv);
+
+  MPI_Comm_size(MPI_COMM_WORLD, &size); // p
+  MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+
+  MPI_Barrier(MPI_COMM_WORLD);
+  int retval = generateMatrix(size, rank);    
+  if (retval != 0) {
+    MPI_Finalize();
+    return retval;  
+  }
+  MPI_Barrier(MPI_COMM_WORLD);
+  // start timing
+  if (MASTER(rank)) {
+    start_time = MPI_Wtime();
+  }
+  double spectralRadius = powerMethod(rank);
+  if (MASTER(rank)) {
+    end_time = MPI_Wtime();
+  }
+  // end timing
+
+  if (MASTER(rank)) {
+    printf("The spectral radius is %f\n", spectralRadius);
+    printf("It took %f seconds\n", end_time-start_time);
+
+    /*
+    int index = 0;
+    for (index = 0; index < n; index++) {
+      printf("%f ", x[index]);
+    }
+    printf("\nsize of n is %d\n", n);
+    */
+    // checking
+    if(cs240_verify(x,n,end_time-start_time)>0){
+        printf("yay, we win!\n");
+    }else{
+        printf("Boo, we lose... again\n");
+    }
+  }
+
+
+  //printf("calling MPI_Finalize()\n");
+  MPI_Finalize();
+  return(0);
+}
+
+//-----------------------------------------------------------------------

data/samples/mpi/hw2harness.c

@@ -0,0 +1,84 @@
+/*
+ *  hw2harness.c
+ *  
+ * I WILL OVERWRITE YOUR COPY OF THIS FILE WITH MY OWN. ANY CHANGES YOU MAKE WILL NOT BE VISIBLE DURING GRADING.
+ */
+
+#include <stdlib.h>
+#include <math.h>
+#include "hw2harness.h"
+
+/*
+Generates a slice of matrix A.
+In grading I may use several different versions of this function to test your code.
+
+arguments:
+  n = the number of columns (and rows) in A
+  startrow = the row to start on
+  numrows = the number of rows to generate
+
+return value:
+  a slice of matrix A in row major order:
+  A[index] => A(row, column)
+  A[0] => A(1, 1)
+  A[1] => A(0, 2)
+  A[n] => A(2, 0)
+  A[2*n+3] => A(3, 4)
+  etc.
+  
+  The reason we don't do a multi-dimensional array is so that multi-row transfers using MPI can be
+  accomplished in a single MPI call.
+*/
+double* cs240_generateMatrix(int n, int startrow, int numrows) {
+    double* A;
+    int i;
+    int diag;
+    
+    A = (double*)calloc(n*numrows, sizeof(double));
+
+    for (i = 0; i < numrows; i++) {
+        diag = startrow + i;
+
+        A[i*n + diag] = n;
+    }
+    
+    return A;
+}
+
+/*
+Call this function at the end of your program. It verifies that the answer you got is correct
+and allows me to have timing results in a convenient format.
+
+arguments:
+  x = the answer your program came up with
+  n = the number of rows and columns of A, and the size of x
+  elapsedTime = the time it took to run your power method. Use MPI_Wtime() to get an initial time, then again to get a finishing time.
+                elapsedTime = final - initial.
+                Please only time your power method, not the entire program.
+                
+returns:
+  1 if the vector is correct, 0 otherwise.
+*/
+int cs240_verify(double* x, int n, double elapsedTime) {
+    int i;
+    double answer = sqrt(n);
+    double diff;
+    int correct = 1;
+    
+    for (i = 0; i < n; i++) {
+        // make sure each element of the vector x equals sqrt(n).
+        // to allow for errors in floating point calculations, close is good enough.
+        diff = x[i] - answer;
+        if (diff < 0)
+            diff = -diff;
+        
+        if (diff > 0.00001) {
+            correct = 0;
+            break;
+        }
+    }
+    
+    // I will be using the elapsedTime argument here.
+    
+    return correct;
+}

data/samples/mpi/hw2harness.h

@@ -0,0 +1,45 @@
+/*
+ *  hw2harness.h
+ *  
+ * I WILL OVERWRITE YOUR COPY OF THIS FILE WITH MY OWN. ANY CHANGES YOU MAKE WILL NOT BE VISIBLE DURING GRADING.
+ *
+ */
+
+/*
+Generates a slice of matrix A.
+In grading I may use several different versions of this function to test your code.
+
+arguments:
+  n = the number of columns (and rows) in A
+  startrow = the row to start on
+  numrows = the number of rows to generate
+
+return value:
+  a slice of matrix A in row major order:
+  A[index] => A(row, column)
+  A[0] => A(1, 1)
+  A[1] => A(0, 2)
+  A[n] => A(2, 0)
+  A[2*n+3] => A(3, 4)
+  etc.
+  
+  The reason we don't do a multi-dimensional array is so that multi-row transfers using MPI can be
+  accomplished in a single MPI call.
+*/
+double* cs240_generateMatrix(int n, int startrow, int numrows);
+
+/*
+Call this function at the end of your program. It verifies that the answer you got is correct
+and allows me to have timing results in a convenient format.
+
+arguments:
+  x = the answer your program came up with
+  n = the number of rows and columns of A, and the size of x
+  elapsedTime = the time it took to run your power method. Use MPI_Wtime() to get an initial time, then again to get a finishing time.
+                elapsedTime = final - initial.
+                Please only time your power method, not the entire program.
+                
+returns:
+  1 if the vector is correct, 0 otherwise.
+*/
+int cs240_verify(double* x, int n, double elapsedTime);

data/samples/mpi/ring/Makefile

@@ -0,0 +1,2 @@
+all:
+	mpicc Ring.c -o Ring -Wall

data/samples/mpi/ring/Ring.c

@@ -0,0 +1,76 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+#include "mpi.h"
+
+#define NUM_MESSAGES 10
+#define FROM_MASTER 0
+
+#define MASTER(rank) (rank == 0)
+#define SLAVE(rank) (!MASTER)
+
+//-----------------------------------------------------------------------
+
+int main(int argc, char *argv[])
+{
+  int rank, size;
+  double start_time = 0;
+  double end_time = 0;
+  MPI_Status status;
+
+  MPI_Init(&argc,&argv);
+
+  MPI_Comm_size(MPI_COMM_WORLD, &size); // p
+  MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+
+  MPI_Barrier(MPI_COMM_WORLD);
+
+  // start timing
+  if (MASTER(rank)) {
+    start_time = MPI_Wtime();
+  }
+
+  char* msg = "hello!";
+
+  MPI_Barrier(MPI_COMM_WORLD);
+
+  int index = 0;
+  for (index = 0; index < NUM_MESSAGES; index++) {
+    if (MASTER(rank)) {
+      //printf("master is sending message to node 1\n");
+      MPI_Send(&msg, 6, MPI_CHAR, 1, FROM_MASTER, MPI_COMM_WORLD);
+
+      //printf("master is waiting for message from node %d\n", size - 1);
+      MPI_Recv(&msg, 6, MPI_CHAR, size - 1, FROM_MASTER, MPI_COMM_WORLD, &status);
+    } else {
+      MPI_Recv(&msg, 6, MPI_CHAR, rank-1, FROM_MASTER, MPI_COMM_WORLD, &status);
+
+      if (rank + 1 == size) {
+        //printf("node %d is sending a message to node 0\n", rank);
+        MPI_Send(&msg, 6, MPI_CHAR, 0, FROM_MASTER, MPI_COMM_WORLD);
+      } else {
+        //printf("node %d is sending a message to node %d\n", rank, rank + 1);
+        MPI_Send(&msg, 6, MPI_CHAR, rank + 1, FROM_MASTER, MPI_COMM_WORLD);
+      }
+    }
+
+    MPI_Barrier(MPI_COMM_WORLD);
+  }
+
+  MPI_Barrier(MPI_COMM_WORLD);
+  if (MASTER(rank)) {
+    end_time = MPI_Wtime();
+  }
+  // end timing
+
+  if (MASTER(rank)) {
+    printf("All done sending %d messages between %d nodes!\n", NUM_MESSAGES, size);
+    printf("It took %f seconds\n", end_time-start_time);
+  }
+
+  //printf("calling MPI_Finalize()\n");
+  MPI_Finalize();
+  return(0);
+}
+
+//-----------------------------------------------------------------------