bones-compiler 1.1.0 → 1.3.1

data/test/examples/benchmarks/PolyBench/doitgen_species.c

@@ -0,0 +1,67 @@
+//
+// This file is part of the Bones source-to-source compiler examples. The C-code
+// is largely identical in terms of functionality and variable naming to the code
+// found in PolyBench/C version 3.2. For more information on PolyBench/C or Bones
+// please use the contact information below.
+//
+// == More information on PolyBench/C
+// Contact............Louis-Noel Pouchet <pouchet@cse.ohio-state.edu>
+// Web address........http://polybench.sourceforge.net/
+// 
+// == More information on Bones
+// Contact............Cedric Nugteren <c.nugteren@tue.nl>
+// Web address........http://parse.ele.tue.nl/bones/
+//
+// == File information
+// Filename...........benchmark/doitgen.c
+// Author.............Cedric Nugteren
+// Last modified on...10-April-2012
+//
+
+#include "common.h"
+
+// This is 'doitgen', a multiresolution analysis kernel
+int main(void) {
+	int i,j,k,p,q,r,s;
+	
+	// Declare arrays on the stack
+	float A[NR][NQ][NP];
+	float sum[NR][NQ][NP];
+	float C4[NP][NP];
+	
+	// Set the input data
+	for (i=0; i<NR; i++) { for (j=0; j<NQ; j++) { for (k=0; k<NP; k++) { A[i][j][k] = ((float) i*j + k) / NP; } } }
+	for (i=0; i<NP; i++) { for (j=0; j<NP; j++) { C4[i][j] = ((float) i*j) / NP; } }
+	
+	// Perform the computation
+	#pragma scop
+	{
+		#pragma species kernel A[0:NR-1,0:NQ-1,0:NP-1]|chunk(0:0,0:0,0:NP-1) ^ C4[0:NP-1,0:NP-1]|chunk(0:NP-1,0:0) -> sum[0:NR-1,0:NQ-1,0:NP-1]|element
+		for (r = 0; r < NR; r++) {
+			for (q = 0; q < NQ; q++) {
+				for (p = 0; p < NP; p++) {
+					sum[r][q][p] = 0;
+					for (s = 0; s < NP; s++) {
+						sum[r][q][p] = sum[r][q][p] + A[r][q][s] * C4[s][p];
+					}
+				}
+			}
+		}
+		#pragma species endkernel doitgen_k1
+		#pragma species kernel sum[0:NR-1,0:NQ-1,0:NP-1]|element -> A[0:NR-1,0:NQ-1,0:NP-1]|element
+		for (r = 0; r < NR; r++) {
+			for (q = 0; q < NQ; q++) {
+				for (p = 0; p < NP; p++) {
+					A[r][q][p] = sum[r][q][p];
+				}
+			}
+		}
+		#pragma species endkernel doitgen_k2
+	}
+	#pragma endscop
+	
+	// Clean-up and exit the function
+	fflush(stdout);
+	return 0;
+}
+

data/test/examples/benchmarks/PolyBench/durbin_species.c

@@ -0,0 +1,80 @@
+//
+// This file is part of the Bones source-to-source compiler examples. The C-code
+// is largely identical in terms of functionality and variable naming to the code
+// found in PolyBench/C version 3.2. For more information on PolyBench/C or Bones
+// please use the contact information below.
+//
+// == More information on PolyBench/C
+// Contact............Louis-Noel Pouchet <pouchet@cse.ohio-state.edu>
+// Web address........http://polybench.sourceforge.net/
+// 
+// == More information on Bones
+// Contact............Cedric Nugteren <c.nugteren@tue.nl>
+// Web address........http://parse.ele.tue.nl/bones/
+//
+// == File information
+// Filename...........benchmark/durbin.c
+// Author.............Cedric Nugteren
+// Last modified on...03-Jul-2012
+//
+
+#include "common.h"
+
+// This is 'durbin', an algorithm to solve an equation involving a Toeplitz matrix using the Levinson-Durbin recursion
+int main(void) {
+	int i,j,k;
+	float alpha_k;
+	
+	// Declare arrays on the stack
+	float alpha[NX];
+	float beta[NX];
+	float r[NX];
+	float y[NX][NX];
+	float sum[NX][NX];
+	float out[NX];
+	
+	// Set the input data
+	for (i=0; i<NX; i++) {
+		alpha[i] = i;
+		beta[i] = (i+1)/NX/2.0;
+		r[i] = (i+1)/NX/4.0;
+		for (j=0; j<NX; j++) {
+			y[i][j] = ((float) i*j) / NX;
+			sum[i][j] = ((float) i*j) / NX;
+		}
+	}
+	
+	// Perform the computation
+	#pragma scop
+	{
+		y[0][0] = r[0];
+		beta[0] = 1;
+		alpha[0] = r[0];
+		for (k = 1; k < NX; k++) {
+			beta[k] = beta[k - 1] - alpha[k - 1] * alpha[k - 1] * beta[k - 1];
+			sum[0][k] = r[k];
+			for (i = 0; i <= k - 1; i++) {
+				sum[i + 1][k] = sum[i][k] + r[k - i - 1] * y[i][k - 1];
+			}
+			alpha[k] = -sum[k][k] * beta[k];
+			alpha_k = alpha[k];
+			#pragma species kernel y[0:k-1,k-1:k-1]|element ^ y[k-1:0,k-1:k-1]|element -> y[0:k-1,k:k]|element
+			for (i = 0; i <= k - 1; i++) {
+				y[i][k] = y[i][k - 1] + alpha_k * y[k - i - 1][k - 1];
+			}
+			#pragma species endkernel durbin_k11
+			y[k][k] = alpha[k];
+		}
+		#pragma species kernel y[0:NX-1,NX-1:NX-1]|element -> out[0:NX-1]|element
+		for (i = 0; i < NX; i++) {
+			out[i] = y[i][NX - 1];
+		}
+		#pragma species endkernel durbin_k5
+	}
+	#pragma endscop
+	
+	// Clean-up and exit the function
+	fflush(stdout);
+	return 0;
+}
+

data/test/examples/benchmarks/PolyBench/dynprog_species.c

@@ -0,0 +1,71 @@
+//
+// This file is part of the Bones source-to-source compiler examples. The C-code
+// is largely identical in terms of functionality and variable naming to the code
+// found in PolyBench/C version 3.2. For more information on PolyBench/C or Bones
+// please use the contact information below.
+//
+// == More information on PolyBench/C
+// Contact............Louis-Noel Pouchet <pouchet@cse.ohio-state.edu>
+// Web address........http://polybench.sourceforge.net/
+// 
+// == More information on Bones
+// Contact............Cedric Nugteren <c.nugteren@tue.nl>
+// Web address........http://parse.ele.tue.nl/bones/
+//
+// == File information
+// Filename...........benchmark/dynprog.c
+// Author.............Cedric Nugteren
+// Last modified on...29-May-2012
+//
+
+#include "common.h"
+
+// This is 'dynprog', a 2D dynamic programming algorithm
+int main(void) {
+	int i,j,k,iter;
+	
+	// Declare arrays on the stack
+	float C[LENGTH][LENGTH];
+	float W[LENGTH][LENGTH];
+	float c[LENGTH][LENGTH];
+	float sum_c[LENGTH][LENGTH][LENGTH];
+	float out;
+	
+	// Set the input data
+	for (i=0; i<LENGTH; i++) {
+		for (j=0; j<LENGTH; j++) {
+			C[i][j] = i*j % 2;
+			W[i][j] = ((float) i-j) / LENGTH;
+		}
+	}
+	
+	// Perform the computation
+	#pragma scop
+	{
+		for (iter = 0; iter < ITER; iter++) {
+			#pragma species kernel 0:0|void -> c[0:LENGTH-1,0:LENGTH-1]|element
+			for (i = 0; i <= LENGTH - 1; i++) {
+				for (j = 0; j <= LENGTH - 1; j++) {
+					c[i][j] = 0;
+				}
+			}
+			#pragma species endkernel dynprog_k2
+			for (i = 0; i <= LENGTH - 2; i++) {
+				for (j = i + 1; j <= LENGTH - 1; j++) {
+					sum_c[i][j][i] = 0;
+					for (k = i + 1; k <= j - 1; k++) {
+						sum_c[i][j][k] = sum_c[i][j][k - 1] + c[i][k] + c[k][j];
+					}
+					c[i][j] = sum_c[i][j][j - 1] + W[i][j];
+				}
+			}
+			out += c[0][LENGTH - 1];
+		}
+	}
+	#pragma endscop
+	
+	// Clean-up and exit the function
+	fflush(stdout);
+	return 0;
+}
+

data/test/examples/benchmarks/PolyBench/fdtd-2d-apml_species.c

@@ -0,0 +1,112 @@
+//
+// This file is part of the Bones source-to-source compiler examples. The C-code
+// is largely identical in terms of functionality and variable naming to the code
+// found in PolyBench/C version 3.2. For more information on PolyBench/C or Bones
+// please use the contact information below.
+//
+// == More information on PolyBench/C
+// Contact............Louis-Noel Pouchet <pouchet@cse.ohio-state.edu>
+// Web address........http://polybench.sourceforge.net/
+// 
+// == More information on Bones
+// Contact............Cedric Nugteren <c.nugteren@tue.nl>
+// Web address........http://parse.ele.tue.nl/bones/
+//
+// == File information
+// Filename...........benchmark/fdtd-2d-apml.c
+// Author.............Cedric Nugteren
+// Last modified on...30-May-2012
+//
+
+#include "common.h"
+
+// This is 'fdtd-2d-apml', a 2D finite different time domain kernel using an anisotropic perfectly matched layer
+int main(void) {
+	int i,j,k;
+	int ix,iy,iz;
+	float clf, tmp;
+	float czm_iz, czp_iz;
+	float cymh_iy, cyph_iy;
+	
+	// Declare arrays on the stack
+	float czm[CZ+1];
+	float czp[CZ+1];
+	float cxmh[CXM+1];
+	float cxph[CXM+1];
+	float cymh[CYM+1];
+	float cyph[CYM+1];
+	float Ry[CZ+1][CYM+1];
+	float Ax[CZ+1][CYM+1];
+	float Ex[CZ+1][CYM+1][CXM+1];
+	float Ey[CZ+1][CYM+1][CXM+1];
+	float Hz[CZ+1][CYM+1][CXM+1];
+	float Bza[CZ+1][CYM+1][CXM+1];
+	
+	// Set the constants
+	float mui = 2341;
+	float ch = 42;
+	
+	// Set the input data
+	for (i=0; i<=CZ; i++) {
+		czm[i] = ((float) i+1) / CXM;
+		czp[i] = ((float) i+2) / CXM;
+	}
+	for (i=0; i<=CXM; i++) {
+		cxmh[i] = ((float) i+3) / CXM;
+		cxph[i] = ((float) i+4) / CXM;
+	}
+	for (i=0; i<=CYM; i++) {
+		cymh[i] = ((float) i+5) / CXM;
+		cyph[i] = ((float) i+6) / CXM;
+	}
+	for (i=0; i<=CZ; i++) {
+		for (j=0; j<=CYM; j++) {
+			Ry[i][j] = ((float) i*(j+1) + 10) / CYM;
+			Ax[i][j] = ((float) i*(j+2) + 11) / CYM;
+			for (k=0; k<=CXM; k++) {
+				Ex[i][j][k] = ((float) i*(j+3) + k+1) / CXM;
+				Ey[i][j][k] = ((float) i*(j+4) + k+2) / CYM;
+				Hz[i][j][k] = ((float) i*(j+5) + k+3) / CZ;
+			}
+		}
+	}
+	
+	// Perform the computation
+	#pragma scop
+	{
+		for (iz = 0; iz < CZ; iz++) {
+			for (iy = 0; iy < CYM; iy++) {
+				czm_iz = czm[iz];
+				czp_iz = czp[iz];
+				cymh_iy = cymh[iy];
+				cyph_iy = cyph[iy];
+				for (ix = 0; ix < CXM; ix++) {
+					clf = Ex[iz][iy][ix] - Ex[iz][iy + 1][ix] + Ey[iz][iy][ix + 1] - Ey[iz][iy][ix];
+					tmp = cymh_iy / cyph_iy * Bza[iz][iy][ix] - ch / cyph_iy * clf;
+					Hz[iz][iy][ix] = Hz[iz][iy][ix] * (cxmh[ix] / cxph[ix]) + mui * czp_iz / cxph[ix] * tmp - mui * czm_iz / cxph[ix] * Bza[iz][iy][ix];
+					Bza[iz][iy][ix] = tmp;
+				}
+				clf = Ex[iz][iy][CXM] - Ex[iz][iy + 1][CXM] + Ry[iz][iy] - Ey[iz][iy][CXM];
+				tmp = cymh_iy / cyph_iy * Bza[iz][iy][CXM] - ch / cyph_iy * clf;
+				Hz[iz][iy][CXM] = cxmh[CXM] / cxph[CXM] * Hz[iz][iy][CXM] + mui * czp_iz / cxph[CXM] * tmp - mui * czm_iz / cxph[CXM] * Bza[iz][iy][CXM];
+				Bza[iz][iy][CXM] = tmp;
+				for (ix = 0; ix < CXM; ix++) {
+					clf = Ex[iz][CYM][ix] - Ax[iz][ix] + Ey[iz][CYM][ix + 1] - Ey[iz][CYM][ix];
+					tmp = cymh[CYM] / cyph_iy * Bza[iz][iy][ix] - ch / cyph_iy * clf;
+					Hz[iz][CYM][ix] = cxmh[ix] / cxph[ix] * Hz[iz][CYM][ix] + mui * czp_iz / cxph[ix] * tmp - mui * czm_iz / cxph[ix] * Bza[iz][CYM][ix];
+					Bza[iz][CYM][ix] = tmp;
+				}
+				clf = Ex[iz][CYM][CXM] - Ax[iz][CXM] + Ry[iz][CYM] - Ey[iz][CYM][CXM];
+				tmp = cymh[CYM] / cyph[CYM] * Bza[iz][CYM][CXM] - ch / cyph[CYM] * clf;
+				Hz[iz][CYM][CXM] = cxmh[CXM] / cxph[CXM] * Hz[iz][CYM][CXM] + mui * czp_iz / cxph[CXM] * tmp - mui * czm_iz / cxph[CXM] * Bza[iz][CYM][CXM];
+				Bza[iz][CYM][CXM] = tmp;
+			}
+		}
+	}
+	#pragma endscop
+	
+	// Clean-up and exit the function
+	fflush(stdout);
+	return 0;
+}
+

data/test/examples/benchmarks/PolyBench/fdtd-2d_species.c

@@ -0,0 +1,78 @@
+//
+// This file is part of the Bones source-to-source compiler examples. The C-code
+// is largely identical in terms of functionality and variable naming to the code
+// found in PolyBench/C version 3.2. For more information on PolyBench/C or Bones
+// please use the contact information below.
+//
+// == More information on PolyBench/C
+// Contact............Louis-Noel Pouchet <pouchet@cse.ohio-state.edu>
+// Web address........http://polybench.sourceforge.net/
+// 
+// == More information on Bones
+// Contact............Cedric Nugteren <c.nugteren@tue.nl>
+// Web address........http://parse.ele.tue.nl/bones/
+//
+// == File information
+// Filename...........benchmark/fdtd-2d.c
+// Author.............Cedric Nugteren
+// Last modified on...08-May-2012
+//
+
+#include "common.h"
+
+// This is 'fdtd-2d', a 2D finite different time domain kernel
+int main(void) {
+	int i,j,t;
+	
+	// Declare arrays on the stack
+	float ex[NI][NJ];
+	float ey[NI][NJ];
+	float hz[NI][NJ];
+	
+	// Set the input data
+	for (i=0; i<NI; i++) {
+		for (j=0; j<NJ; j++) {
+			ex[i][j] = ((float) i*(j+1)) / NI;
+			ey[i][j] = ((float) i*(j+2)) / NJ;
+			hz[i][j] = ((float) i*(j+3)) / NI;
+		}
+	}
+	
+	// Perform the computation
+	#pragma scop
+	{
+		for (t = 0; t < TSTEPS; t++) {
+			#pragma species kernel 0:0|void -> ey[0:0,0:NJ-1]|element
+			for (j = 0; j < NJ; j++) {
+				ey[0][j] = t;
+			}
+			#pragma species endkernel fdtd-2d_k2
+			#pragma species kernel ey[1:NI-1,0:NJ-1]|element ^ hz[0:NI-1,0:NJ-1]|neighbourhood(-1:0,0:0) -> ey[1:NI-1,0:NJ-1]|element
+			for (i = 1; i < NI; i++) {
+				for (j = 0; j < NJ; j++) {
+					ey[i][j] = ey[i][j] - 0.5 * (hz[i][j] - hz[i - 1][j]);
+				}
+			}
+			#pragma species endkernel fdtd-2d_k3
+			#pragma species kernel ex[0:NI-1,1:NJ-1]|element ^ hz[0:NI-1,0:NJ-1]|neighbourhood(0:0,-1:0) -> ex[0:NI-1,1:NJ-1]|element
+			for (i = 0; i < NI; i++) {
+				for (j = 1; j < NJ; j++) {
+					ex[i][j] = ex[i][j] - 0.5 * (hz[i][j] - hz[i][j - 1]);
+				}
+			}
+			#pragma species endkernel fdtd-2d_k4
+			#pragma species kernel hz[0:NI-2,0:NJ-2]|element ^ ex[0:NI-2,0:NJ-1]|neighbourhood(0:0,0:1) ^ ey[0:NI-1,0:NJ-2]|neighbourhood(0:1,0:0) -> hz[0:NI-2,0:NJ-2]|element
+			for (i = 0; i < NI - 1; i++) {
+				for (j = 0; j < NJ - 1; j++) {
+					hz[i][j] = hz[i][j] - 0.7 * (ex[i][j + 1] - ex[i][j] + ey[i + 1][j] - ey[i][j]);
+				}
+			}
+			#pragma species endkernel fdtd-2d_k5
+		}
+	}
+	#pragma endscop
+	
+	// Clean-up and exit the function
+	fflush(stdout);
+	return 0;
+}

data/test/examples/benchmarks/PolyBench/floyd-warshall_species.c

@@ -0,0 +1,54 @@
+//
+// This file is part of the Bones source-to-source compiler examples. The C-code
+// is largely identical in terms of functionality and variable naming to the code
+// found in PolyBench/C version 3.2. For more information on PolyBench/C or Bones
+// please use the contact information below.
+//
+// == More information on PolyBench/C
+// Contact............Louis-Noel Pouchet <pouchet@cse.ohio-state.edu>
+// Web address........http://polybench.sourceforge.net/
+// 
+// == More information on Bones
+// Contact............Cedric Nugteren <c.nugteren@tue.nl>
+// Web address........http://parse.ele.tue.nl/bones/
+//
+// == File information
+// Filename...........benchmark/floyd-warshall.c
+// Author.............Cedric Nugteren
+// Last modified on...10-April-2012
+//
+
+#include "common.h"
+
+// This is 'floyd-warshall', a graph analysis algorithm to find shortest paths in a weighted graph
+int main(void) {
+	int i,j,k;
+	
+	// Declare arrays on the stack
+	float path[N][N];
+	
+	// Set the input data
+	for (i=0; i<N; i++) {
+		for (j=0; j<N; j++) {
+			path[i][j] = ((float) (i+1)*(j+1)) / N;
+		}
+	}
+	
+	// Perform the computation
+	#pragma scop
+	{
+		for (k = 0; k < N; k++) {
+			for (i = 0; i < N; i++) {
+				for (j = 0; j < N; j++) {
+					path[i][j] = path[i][j] < path[i][k] + path[k][j] ? path[i][j] : path[i][k] + path[k][j];
+				}
+			}
+		}
+	}
+	#pragma endscop
+	
+	// Clean-up and exit the function
+	fflush(stdout);
+	return 0;
+}
+