From: adash <adash>
Date: Tue, 12 Feb 2008 23:53:16 +0000 (+0000)
Subject: Add SOR benchmark
X-Git-Tag: preEdgeChange~282
X-Git-Url: http://plrg.eecs.uci.edu/git/?a=commitdiff_plain;h=caac57be7a28bcd3ef5da2d0b4f36a67aeb9a340;p=IRC.git

Add SOR benchmark
---

diff --git a/Robust/src/Benchmarks/Prefetch/SOR/JGFInstrumentor.java b/Robust/src/Benchmarks/Prefetch/SOR/JGFInstrumentor.java
new file mode 100644
index 00000000..b48928d6
--- /dev/null
+++ b/Robust/src/Benchmarks/Prefetch/SOR/JGFInstrumentor.java
@@ -0,0 +1,178 @@
+public class JGFInstrumentor{
+
+	private HashMap timers;
+	private HashMap data; 
+
+	public JGFInstrumentor() {
+		timers = new HashMap();
+		data = new HashMap(); 
+	}
+	public static void addTimer (String name, String opname, int size){
+
+		if (timers.containsKey(name)) {
+			System.printString("JGFInstrumentor.addTimer: warning -  timer " + name +
+					" already exists");
+		}
+		else {
+			timers.put(name, new JGFTimer(name,opname,size));
+		}
+
+	}
+
+	public static void startTimer(String name){
+		if (timers.containsKey(name)) {
+			((JGFTimer) timers.get(name)).start();
+		}
+		else {
+			System.printString("JGFInstrumentor.startTimer: failed -  timer " + name + 
+					" does not exist");
+		}
+
+	}
+
+	public static void stopTimer(String name){
+		if (timers.containsKey(name)) {
+			((JGFTimer) timers.get(name)).stop();
+		}
+		else {
+			System.printString("JGFInstrumentor.stopTimer: failed -  timer " + name + 
+					" does not exist");
+		}
+	}
+
+	public static void addOpsToTimer(String name, double count){
+		if (timers.containsKey(name)) {
+			((JGFTimer) timers.get(name)).addops(count);
+		}
+		else {
+			System.printString("JGFInstrumentor.addOpsToTimer: failed -  timer " + name + 
+					" does not exist");
+		}
+	}  
+
+	public static void printTimer(String name){
+		if (timers.containsKey(name)) {
+			((JGFTimer) timers.get(name)).print();
+		}
+		else {
+			System.printString("JGFInstrumentor.printTimer: failed -  timer " + name +
+					" does not exist");
+		}
+	}
+
+	public static void printHeader(int section, int size,int nthreads) {
+
+		String header = new String("");
+		String base = new String("Java Grande Forum Thread Benchmark Suite - Version 1.0 - Section "); 
+
+		if(section == 1) {
+				header = base + "1";
+		} else if(section ==2) {
+			if(size == 0) {
+				header = base + "2 - Size A";
+			} else if(size == 1) {
+				header = base + "2 - Size B";
+			} else if(size == 2) {
+				header = base + "2 - Size C";
+			}
+		} else if(section == 3) {
+			if(size == 0) {
+				header = base + "3 - Size A";
+			} else if(size == 1) {
+				header = base + "3 - Size B";
+			}
+		} else {
+			System.printString("Error\n");
+		}
+
+		System.printString(header); 
+
+		if (nthreads == 1) {
+			System.printString("Executing on " + nthreads + " thread");
+		}
+		else {
+			System.printString("Executing on " + nthreads + " threads");
+		}
+
+		System.printString("");
+
+	} 
+
+	/*
+	public static void addTimeToTimer(String name, double added_time){
+		if (timers.containsKey(name)) {
+			((JGFTimer) timers.get(name)).addtime(added_time);
+		}
+		else {
+			System.printString("JGFInstrumentor.addTimeToTimer: failed -  timer " + name +
+					" does not exist");
+		}
+
+
+
+	}
+
+	public static double readTimer(String name){
+		double time; 
+		if (timers.containsKey(name)) {
+			time = ((JGFTimer) timers.get(name)).time;
+		}
+		else {
+			System.printString("JGFInstrumentor.readTimer: failed -  timer " + name + 
+					" does not exist");
+			time = 0.0; 
+		}
+		return time; 
+	}  
+
+	public static void resetTimer(String name){
+		if (timers.containsKey(name)) {
+			((JGFTimer) timers.get(name)).reset();
+		}
+		else {
+			System.printString("JGFInstrumentor.resetTimer: failed -  timer " + name +
+					" does not exist");
+		}
+	}
+
+
+	public static void printperfTimer(String name){
+		if (timers.containsKey(name)) {
+			((JGFTimer) timers.get(name)).printperf();
+		}
+		else {
+			System.printString("JGFInstrumentor.printTimer: failed -  timer " + name +
+					" does not exist");
+		}
+	}
+
+	public static void storeData(String name, Object obj){
+		data.put(name,obj); 
+	}
+
+	public static void retrieveData(String name, Object obj){
+		obj = data.get(name); 
+	}
+	public static void addTimer (String name){
+
+		if (timers.containsKey(name)) {
+			System.printString("JGFInstrumentor.addTimer: warning -  timer " + name + 
+					" already exists");
+		}
+		else {
+			timers.put(name, new JGFTimer(name));
+		}
+	}
+
+	public static void addTimer (String name, String opname){
+		if (timers.containsKey(name)) {
+			System.printString("JGFInstrumentor.addTimer: warning -  timer " + name + 
+					" already exists");
+		}
+		else {
+			timers.put(name, new JGFTimer(name,opname));
+		}
+
+	}
+	*/
+}
diff --git a/Robust/src/Benchmarks/Prefetch/SOR/JGFSORBench.java b/Robust/src/Benchmarks/Prefetch/SOR/JGFSORBench.java
new file mode 100644
index 00000000..28a65fdc
--- /dev/null
+++ b/Robust/src/Benchmarks/Prefetch/SOR/JGFSORBench.java
@@ -0,0 +1,88 @@
+public class JGFSORBench extends SOR{ 
+
+	private int size; 
+	private int[] datasize;
+	private final int JACOBI_NUM_ITER;
+	private final long RANDOM_SEED;
+	public int nthreads;
+	Random R;
+
+	public JGFSORBench() {
+		JACOBI_NUM_ITER = 100;
+		RANDOM_SEED = 10101010;
+		R = new Random(RANDOM_SEED);
+	}
+
+	public JGFSORBench(int nthreads){
+		this.nthreads = nthreads;
+		int datasizes[] = new int[3];
+		datasizes[0]= 1000;
+		datasizes[1]= 1500;
+		datasizes[2]= 2000;
+	}
+
+	public void JGFsetsize(int size){
+		this.size = size;
+	}
+
+	public void JGFinitialise(){
+
+	}
+
+	public void JGFkernel(){
+
+		double G[][] = RandomMatrix(datasizes[size], datasizes[size],R);
+
+		SORrun(1.25, G, JACOBI_NUM_ITER, nthreads);
+
+
+	}
+
+	public void JGFvalidate(){
+
+		double refval[] = new double[3];
+		refval[0] = 0.498574406322512;
+		refval[1] = 1.1234778980135105;
+		refval[2] = 1.9954895063582696;
+		double dev = Math.abs(Gtotal - refval[size]);
+		if (dev > 1.0e-12 ){
+			System.out.println("Validation failed");
+			System.out.println("Gtotal = " + Gtotal + "  " + dev + "  " + size);
+		}
+	}
+
+	public void JGFtidyup(){
+		//System.gc();
+	}  
+
+	public void JGFrun(int size){
+
+
+		JGFInstrumentor.addTimer("Section2:SOR:Kernel", "Iterations",size);
+
+		JGFsetsize(size); 
+		JGFinitialise(); 
+		JGFkernel(); 
+		JGFvalidate(); 
+		JGFtidyup(); 
+
+
+		JGFInstrumentor.addOpsToTimer("Section2:SOR:Kernel", (double) (JACOBI_NUM_ITER));
+
+		JGFInstrumentor.printTimer("Section2:SOR:Kernel"); 
+	}
+
+	private static double[][] RandomMatrix(int M, int N, java.util.Random R)
+	{
+		double A[][] = new double[M][N];
+
+		for (int i=0; i<N; i++)
+			for (int j=0; j<N; j++)
+			{
+				A[i][j] = R.nextDouble() * 1e-6;
+			}      
+		return A;
+	}
+
+
+}
diff --git a/Robust/src/Benchmarks/Prefetch/SOR/JGFSORBenchSizeA.java b/Robust/src/Benchmarks/Prefetch/SOR/JGFSORBenchSizeA.java
new file mode 100644
index 00000000..34bf53a1
--- /dev/null
+++ b/Robust/src/Benchmarks/Prefetch/SOR/JGFSORBenchSizeA.java
@@ -0,0 +1,22 @@
+public class JGFSORBenchSizeA{ 
+	public int nthreads;
+	public static void main(String argv[]){
+
+		if(argv.length != 0 ) {
+			nthreads = Integer.parseInt(argv[0]);
+		} else {
+			System.printString("The no of threads has not been specified, defaulting to 1");
+			System.printString("  ");
+			nthreads = 1;
+		}
+
+		JGFInstrumentor.printHeader(2,0,nthreads);
+		JGFSORBench sor = null;
+		atomic {
+			sor = global new JGFSORBench(nthreads); 
+			sor.JGFrun(0);
+		}
+
+	}
+}
+
diff --git a/Robust/src/Benchmarks/Prefetch/SOR/JGFTimer.java b/Robust/src/Benchmarks/Prefetch/SOR/JGFTimer.java
new file mode 100644
index 00000000..71856551
--- /dev/null
+++ b/Robust/src/Benchmarks/Prefetch/SOR/JGFTimer.java
@@ -0,0 +1,108 @@
+public class JGFTimer {
+
+	public String name; 
+	public String opname; 
+	public double time; 
+	public double opcount; 
+	public long calls; 
+	public int size;
+
+	private long start_time;
+	private boolean on; 
+
+	public JGFTimer(String name, String opname){
+		this.name = name;
+		this.opname = opname;
+		this.size = -1;
+		reset(); 
+	}
+
+	public JGFTimer(String name, String opname, int size){
+		this.name = name;
+		this.opname = opname;
+		this.size = size;
+		reset();
+	}
+
+	/*
+	public JGFTimer(String name){
+		this(name,""); 
+	}
+	*/
+
+	public void start(){
+		if (on) 
+			System.printString("Warning timer " + name + " was already turned on");
+		on = true; 
+		start_time = System.currentTimeMillis();
+	}
+
+	public void stop(){
+		time += (double) (System.currentTimeMillis()-start_time) / 1000.;
+		if (!on) System.printString("Warning timer " + name + " wasn't turned on");
+		calls++;
+		on = false;  
+	}
+
+	public void addops(double count){
+		opcount += count;
+	} 
+
+	public void addtime(double added_time){
+		time += added_time;
+	}
+
+	public void reset(){
+		time = 0.0; 
+		calls = 0; 
+		opcount = 0; 
+		on = false;
+	}
+
+	public double perf(){
+		return opcount / time; 
+	}
+
+	public void longprint(){
+		System.printString("Timer            Calls         Time(s)       Performance("+opname+"/s)");   
+		System.printString(name + "           " + calls +    "           "  +  time + "        " + this.perf());
+	}
+
+	public void print(){
+		if (opname.equals("")) {
+			System.printString(name + "   " + time + " (s)");
+		}
+		else {
+
+			if(size == 0) {
+					System.printString(name + ":SizeA" + "\t" + time + " (s) \t " + (float)this.perf() + "\t"
+							+ " ("+opname+"/s)");
+			} else if(size == 1) {
+					System.printString(name + ":SizeB" + "\t" + time + " (s) \t " + (float)this.perf() + "\t"
+							+ " ("+opname+"/s)");
+			} else if(size ==2) {
+					System.printString(name + ":SizeC" + "\t" + time + " (s) \t " + (float)this.perf() + "\t"
+							+ " ("+opname+"/s)");
+			} else {
+					System.printString(name + "\t" + time + " (s) \t " + (float)this.perf() + "\t"
+							+ " ("+opname+"/s)");
+			}
+
+		}
+	}
+
+
+	public void printperf(){
+
+		String name;
+		name = this.name; 
+
+		// pad name to 40 characters
+		while ( name.length() < 40 ) 
+			name = name + " "; 
+
+		System.printString(name + "\t" + (float)this.perf() + "\t"
+				+ " ("+opname+"/s)");  
+	}
+
+}
diff --git a/Robust/src/Benchmarks/Prefetch/SOR/SOR.java b/Robust/src/Benchmarks/Prefetch/SOR/SOR.java
new file mode 100644
index 00000000..9b033d89
--- /dev/null
+++ b/Robust/src/Benchmarks/Prefetch/SOR/SOR.java
@@ -0,0 +1,166 @@
+public class SOR{
+	public double Gtotal;
+	public final int cachelinesize;
+	public long[][] sync;
+
+	public SOR() {
+		Gtotal = 0.0;
+		cachelinesize = 128;
+		sync = null;
+	}
+
+	public static final void SORrun(double omega, double G[][], int num_iterations)
+	{
+		int M = G.length;
+		int N = G[0].length;
+
+		double omega_over_four = omega * 0.25;
+		double one_minus_omega = 1.0 - omega;
+
+
+		// update interior points
+		//
+		int Mm1 = M-1;
+		int Nm1 = N-1;
+
+		SORRunner thobjects[] = new SORRunner[JGFSORBench.nthreads];
+		Thread th[] = new Thread[JGFSORBench.nthreads];
+		sync = init_sync(JGFSORBench.nthreads);
+
+		JGFInstrumentor.startTimer("Section2:SOR:Kernel"); 
+
+		for(int i=1;i<JGFSORBench.nthreads;i++) {
+			thobjects[i] = new SORRunner(i,omega,G,num_iterations,sync);
+			th[i] = new Thread(thobjects[i]);
+			th[i].start();
+		}
+
+		thobjects[0] = new SORRunner(0,omega,G,num_iterations,sync);
+		thobjects[0].run();
+
+
+		for(int i=1;i<JGFSORBench.nthreads;i++) {
+			th[i].join();
+		}
+
+
+
+		JGFInstrumentor.stopTimer("Section2:SOR:Kernel");
+
+		for (int i=1; i<Nm1; i++) {
+			for (int j=1; j<Nm1; j++) {
+				Gtotal += G[i][j];
+			}
+		}               
+
+	}
+
+	private static long[][] init_sync(int nthreads) {
+		long sync[][] = new long [JGFSORBench.nthreads][cachelinesize];
+		for (int i = 0; i<JGFSORBench.nthreads; i++)
+			sync[i][0] = 0;
+		return sync;
+	}
+
+}
+
+
+class SORRunner extends Thread {
+
+	int id,num_iterations;
+	double[][] G;
+	double omega;
+	long[][] sync;
+
+	public SORRunner(int id, double omega, double G[][], int num_iterations,long[][] sync) {
+		this.id = id;
+		this.omega=omega;
+		this.G=G;
+		this.num_iterations=num_iterations;
+		this.sync=sync;
+	}
+
+	public void run() {
+
+		int M = G.length;
+		int N = G[0].length;
+
+		double omega_over_four = omega * 0.25;
+		double one_minus_omega = 1.0 - omega;
+
+		// update interior points
+		//
+		int Mm1 = M-1;
+		int Nm1 = N-1;
+
+
+		int ilow, iupper, slice, tslice, ttslice;
+
+		tslice = (Mm1) / 2;
+		ttslice = (tslice + JGFSORBench.nthreads-1)/JGFSORBench.nthreads;
+		slice = ttslice*2;
+
+		ilow=id*slice+1;
+		iupper = ((id+1)*slice)+1;
+		if (iupper > Mm1) iupper =  Mm1+1;
+		if (id == (JGFSORBench.nthreads-1)) iupper = Mm1+1;
+
+		for (int p=0; p<2*num_iterations; p++) {
+			for (int i=ilow+(p%2); i<iupper; i=i+2) {
+
+
+				double [] Gi = G[i];
+				double [] Gim1 = G[i-1];
+
+
+				if(i == 1) { 
+					double [] Gip1 = G[i+1];
+
+					for (int j=1; j<Nm1; j=j+2){
+						Gi[j] = omega_over_four * (Gim1[j] + Gip1[j] + Gi[j-1]
+								+ Gi[j+1]) + one_minus_omega * Gi[j];
+
+					}
+				} else if (i == Mm1) {
+
+					double [] Gim2 = G[i-2];
+
+					for (int j=1; j<Nm1; j=j+2){
+						if((j+1) != Nm1) {
+							Gim1[j+1]=omega_over_four * (Gim2[j+1] + Gi[j+1] + Gim1[j]
+									+ Gim1[j+2]) + one_minus_omega * Gim1[j+1];
+						}
+					}
+
+				} else {
+
+					double [] Gip1 = G[i+1];
+					double [] Gim2 = G[i-2];
+
+					for (int j=1; j<Nm1; j=j+2){
+						Gi[j] = omega_over_four * (Gim1[j] + Gip1[j] + Gi[j-1]
+								+ Gi[j+1]) + one_minus_omega * Gi[j];
+
+						if((j+1) != Nm1) {
+							Gim1[j+1]=omega_over_four * (Gim2[j+1] + Gi[j+1] + Gim1[j]
+									+ Gim1[j+2]) + one_minus_omega * Gim1[j+1];
+						}
+					}
+				}
+
+			}
+
+			// Signal this thread has done iteration
+			sync[id][0]++;
+
+			// Wait for neighbours;
+			if (id > 0) {
+				while (sync[id-1][0] < sync[id][0]) ;
+			}
+			if (id < JGFSORBench.nthreads -1) {
+				while (sync[id+1][0] < sync[id][0]) ;
+			}
+		}
+
+	}
+}
diff --git a/Robust/src/Benchmarks/Prefetch/SOR/makefile b/Robust/src/Benchmarks/Prefetch/SOR/makefile
new file mode 100644
index 00000000..01022f32
--- /dev/null
+++ b/Robust/src/Benchmarks/Prefetch/SOR/makefile
@@ -0,0 +1,5 @@
+MAINCLASS=JGFSORBenchSizeA
+SRC=${MAINCLASS}.java  JGFInstrumentor.java JGFTimer.java JGFSORBench.java SOR.java Random.java
+FLAGS=-dsm -prefetch -nooptimize -debug -mainclass ${MAINCLASS} -o ${MAINCLASS}
+default:
+	../../../buildscript ${FLAGS} ${SRC}