bones-compiler 1.1.0 → 1.3.1

data/examples/benchmarks/{gemver.c → PolyBench/gemver.c}

@@ -40,7 +40,7 @@ int main(void) {
 	int beta = 12313;
 	
 	// Set the input data
-	for (i=0; i<NX; i++) {
+/*	for (i=0; i<NX; i++) {
 		u1[i] = i;
 		u2[i] = (i+1)/NX/2.0;
 		v1[i] = (i+1)/NX/4.0;
@@ -53,8 +53,9 @@ int main(void) {
 			A[i][j] = ((float) i*j) / NX;
 		}
 	}
-	
+*/	
 	// Perform the computation
+	#pragma scop
 	#pragma species kernel 0:NX-1,0:NX-1|element ^ 0:NX-1|element ^ 0:NX-1|element ^ 0:NX-1|element ^ 0:NX-1|element -> 0:NX-1,0:NX-1|element
 	for (i=0; i<NX; i++) {
 		for (j=0; j<NX; j++) {
@@ -81,9 +82,11 @@ int main(void) {
 		}
 	}
 	#pragma species endkernel gemver-part4
+	#pragma endscop
 	
 	// Clean-up and exit the function
 	fflush(stdout);
+	w[9] = w[9];
 	return 0;
 }
 

data/examples/benchmarks/{gesummv.c → PolyBench/gesummv.c}

@@ -36,15 +36,16 @@ int main(void) {
 	float beta = 12313;
 	
 	// Set the input data
-	for (i=0; i<NX; i++) {
+/*	for (i=0; i<NX; i++) {
 		x[i] = ((float) i) / NX;
 		for (j=0; j<NX; j++) {
 			A[i][j] = ((float) i*(j+1)) / NX;
 			B[i][j] = ((float) (i+3)*j) / NX;
 		}
 	}
-	
+*/	
 	// Perform the computation
+	#pragma scop
 	#pragma species kernel 0:NX-1,0:NX-1|chunk(0:0,0:NX-1) ^ 0:NX-1|full ^ 0:NX-1,0:NX-1|chunk(0:0,0:NX-1) -> 0:NX-1|element ^ 0:NX-1|element
 	for (i=0; i<NX; i++) {
 		tmp[i] = 0;
@@ -56,9 +57,11 @@ int main(void) {
 		y[i] = alpha*tmp[i] + beta*y[i];
 	}
 	#pragma species endkernel gesummv
+	#pragma endscop
 	
 	// Clean-up and exit the function
 	fflush(stdout);
+	y[9] = y[9];
 	return 0;
 }
 

data/examples/benchmarks/{gramschmidt.c → PolyBench/gramschmidt.c}

@@ -46,6 +46,7 @@ int main(void) {
 	}
 	
 	// Perform the computation
+	#pragma scop
 	for (k=0; k<NJ; k++) {
 		nrm[0] = 0;
 		#pragma species kernel 0:NI-1,k:k|element -> 0:0|shared
@@ -77,8 +78,10 @@ int main(void) {
 		}
 		#pragma species endkernel gramschmidt-part3
 	}
+	#pragma endscop
 	
 	// Clean-up and exit the function
 	fflush(stdout);
+	A[8][9] = A[8][9];
 	return 0;
 }

data/examples/benchmarks/{jacobi-1d-imper.c → PolyBench/jacobi-1d-imper.c}

@@ -18,6 +18,7 @@
 // Last modified on...03-April-2012
 //
 
+
 #include "common.h"
 
 // This is 'jacobi-1d-imper', a 1D Jacobi stencil computation
@@ -27,14 +28,19 @@ int main(void) {
 	// Declare arrays on the stack
 	float A[LARGE_N];
 	float B[LARGE_N];
+	//printf("A: %p\n", A);
+	//printf("B: %p\n", B);
+	//float *A = (float *)malloc(LARGE_N*sizeof(float));
+	//float *B = (float *)malloc(LARGE_N*sizeof(float));
 	
 	// Set the input data
-	for (i=0; i<LARGE_N; i++) {
+/*	for (i=0; i<LARGE_N; i++) {
 		A[i] = ((float) i+2) / LARGE_N;
 		B[i] = ((float) i+3) / LARGE_N;
 	}
-	
+*/	
 	// Perform the computation
+	#pragma scop
 	for (t=0; t<TSTEPS; t++) {
 		#pragma species kernel 1:LARGE_N-2|neighbourhood(-1:1) -> 1:LARGE_N-2|element
 		for (i=1; i<LARGE_N-1; i++) {
@@ -47,9 +53,11 @@ int main(void) {
 		}
 		#pragma species endkernel jacobi-1d-imper-part2
 	}
+	#pragma endscop
 	
 	// Clean-up and exit the function
 	fflush(stdout);
+	B[9] = B[9];
 	return 0;
 }
 

data/examples/benchmarks/{jacobi-2d-imper.c → PolyBench/jacobi-2d-imper.c}

@@ -29,19 +29,22 @@ int main(void) {
 	float B[N][N];
 	
 	// Set the input data
-	for (i=0; i<N; i++) {
+/*	for (i=0; i<N; i++) {
 		for (j=0; j<N; j++) {
 			A[i][j] = ((float) i*(j+2) + 2) / N;
 			B[i][j] = ((float) i*(j+3) + 3) / N;
 		}
 	}
-	
+*/	
 	// Perform the computation
+	#pragma scop
 	for (t=0; t<TSTEPS; t++) {
 		#pragma species kernel 1:N-2,1:N-2|neighbourhood(-1:1,-1:1) -> 1:N-2,1:N-2|element
 		for (i=1; i<N-1; i++) {
 			for (j=1; j<N-1; j++) {
-				B[i][j] = 0.2 * (A[i][j] + A[i][j-1] + A[i][1+j] + A[1+i][j] + A[i-1][j]);
+				if (i < N-1 && j < N-1) {
+					B[i][j] = 0.2 * (A[i][j] + A[i][j-1] + A[i][1+j] + A[1+i][j] + A[i-1][j]);
+				}
 			}
 		}
 		#pragma species endkernel jacobi-2d-imper-part1
@@ -53,9 +56,11 @@ int main(void) {
 		}
 		#pragma species endkernel jacobi-2d-imper-part2
 	}
+	#pragma endscop
 	
 	// Clean-up and exit the function
 	fflush(stdout);
+	B[8][9] = B[8][9];
 	return 0;
 }
 

data/examples/benchmarks/{lu.c → PolyBench/lu.c}

@@ -35,6 +35,7 @@ int main(void) {
 	}
 	
 	// Perform the computation
+	#pragma scop
 	for (k=0; k<N; k++) {
 		#pragma species kernel k:k,k+1:N-1|element -> k:k,k+1:N-1|element
 		for (j=k+1; j<N; j++) {
@@ -49,9 +50,11 @@ int main(void) {
 		}
 		#pragma species endkernel lu-part2
 	}
+	#pragma endscop
 	
 	// Clean-up and exit the function
 	fflush(stdout);
+	A[8][9] = A[8][9];
 	return 0;
 }
 

data/examples/benchmarks/{ludcmp.c → PolyBench/ludcmp.c}

@@ -42,6 +42,7 @@ int main(void) {
 	}
 	
 	// Perform the computation
+	#pragma scop
 	b[0] = 1.0;
 	for (i=0; i<N; i++) {
 		for (j=i+1; j<=N; j++) {
@@ -83,9 +84,11 @@ int main(void) {
 		//#pragma species endkernel ludcmp-part4
 		x[N-1-i] = w[0] / A[N-1-i][N-1-i];
 	}
+	#pragma endscop
 	
 	// Clean-up and exit the function
 	fflush(stdout);
+	x[9] = x[9];
 	return 0;
 }
 

data/examples/benchmarks/{mvt.c → PolyBench/mvt.c}

@@ -30,7 +30,7 @@ int main(void) {
 	float x2[NX];
 	float y_1[NX];
 	float y_2[NX];
-	
+	/*
 	// Set the input data
 	for (i=0; i<NX; i++) {
 		x1[i] = ((float) i) / NX;
@@ -40,9 +40,10 @@ int main(void) {
 		for (j=0; j<NX; j++) {
 			A[i][j] = ((float) i*j) / NX;
 		}
-	}
+	}*/
 	
 	// Perform the computation
+	#pragma scop
 	#pragma species kernel 0:NX-1|element ^ 0:NX-1,0:NX-1|chunk(0:0,0:NX-1) ^ 0:NX-1|full -> 0:NX-1|element
 	for (i=0; i<NX; i++) {
 		for (j=0; j<NX; j++) {
@@ -57,9 +58,12 @@ int main(void) {
 		}
 	}
 	#pragma species endkernel mvt-part2
+	#pragma endscop
 	
 	// Clean-up and exit the function
 	fflush(stdout);
+	x1[9] = x1[9];
+	x2[9] = x2[9];
 	return 0;
 }
 

data/examples/benchmarks/{reg_detect.c → PolyBench/reg_detect.c}

@@ -42,6 +42,7 @@ int main(void) {
 	}
 	
 	// Perform the computation
+	#pragma scop
 	for (t=0; t<ITER; t++) {
 		#pragma species kernel 0:MAXGRID-1,0:MAXGRID-1|element -> 0:MAXGRID-1,0:MAXGRID-1,0:LENGTH-1|chunk(0:0,0:0,0:LENGTH-1)
 		for (j=0; j<=MAXGRID-1; j++) {
@@ -75,8 +76,10 @@ int main(void) {
 			#pragma species endkernel reg-detect-part3
 		}
 	}
+	#pragma endscop
 	
 	// Clean-up and exit the function
 	fflush(stdout);
+	path[8][9] = path[8][9];
 	return 0;
 }

data/examples/benchmarks/{seidel-2d.c → PolyBench/seidel-2d.c}

@@ -35,6 +35,7 @@ int main(void) {
 	}
 	
 	// Perform the computation
+	#pragma scop
 	for (t=0; t<TSTEPS-1; t++) {
 		for (i=1; i<=N-2; i++) {
 			for (j=1; j<=N-2; j++) {
@@ -44,8 +45,10 @@ int main(void) {
 			}
 		}
 	}
+	#pragma endscop
 	
 	// Clean-up and exit the function
 	fflush(stdout);
+	A[8][9] = A[8][9];
 	return 0;
 }

data/examples/benchmarks/{symm.c → PolyBench/symm.c}

@@ -49,6 +49,7 @@ int main(void) {
 	}
 	
 	// Perform the computation (C := alpha*A*B + beta*C, with A symmetric)
+	#pragma scop
 	for (i=0; i<NI; i++) {
 		for (j=0; j<NJ; j++) {
 			acc[0] = 0;
@@ -66,9 +67,11 @@ int main(void) {
 			C[i][j] = beta*C[i][j] + alpha*A[i][i]*bij + alpha*acc[0];
 		}
 	}
+	#pragma endscop
 	
 	// Clean-up and exit the function
 	fflush(stdout);
+	C[8][9] = C[8][9];
 	return 0;
 }
 

data/examples/benchmarks/{syr2k.c → PolyBench/syr2k.c}

@@ -34,7 +34,7 @@ int main(void) {
 	int beta = 2123;
 	
 	// Set the input data
-	for (i=0; i<NI; i++) {
+/*	for (i=0; i<NI; i++) {
 		for (j=0; j<NJ; j++) {
 			A[i][j] = ((float) i*j) / NI;
 			B[i][j] = ((float) i*j) / NI;
@@ -45,8 +45,9 @@ int main(void) {
 			C[i][j] = ((float) i*j) / NI;
 		}
 	}
-	
+*/	
 	// Perform the computation (C := alpha*A*B' + alpha*B*A' + beta*C)
+	#pragma scop
 	#pragma species kernel 0:NI-1,0:NI-1|element ^ 0:NI-1,0:NJ-1|chunk(0:0,0:NJ-1) ^ 0:NI-1,0:NJ-1|chunk(0:0,0:NJ-1) -> 0:NI-1,0:NI-1|element
 	for (i=0; i<NI; i++) {
 		for (j=0; j<NI; j++) {
@@ -58,8 +59,10 @@ int main(void) {
 		}
 	}
 	#pragma species endkernel syr2k
+	#pragma endscop
 	
 	// Clean-up and exit the function
 	fflush(stdout);
+	C[8][9] = C[8][9];
 	return 0;
 }

data/examples/benchmarks/{syrk.c → PolyBench/syrk.c}

@@ -15,7 +15,7 @@
 // == File information
 // Filename...........benchmark/syrk.c
 // Author.............Cedric Nugteren
-// Last modified on...08-May-2012
+// Last modified on...07-May-2013
 //
 
 #include "common.h"
@@ -33,7 +33,7 @@ int main(void) {
 	float beta = 2123;
 	
 	// Set the input data
-	for (i=0; i<NI; i++) {
+/*	for (i=0; i<NI; i++) {
 		for (j=0; j<NJ; j++) {
 			A[i][j] = ((float) i*j) / NI;
 		}
@@ -43,9 +43,10 @@ int main(void) {
 			C[i][j] = ((float) i*j) / NI;
 		}
 	}
-	
+*/	
 	// Perform the computation (C := alpha*A*A' + beta*C)
-	#pragma species kernel C[0:NI-1,0:NI-1]|element ^ A[0:NI-1,0:NJ-1]|chunk(0:0,0:NJ-1) ^ A[0:NI-1,0:NJ-1]|chunk(0:0,0:NJ-1) -> C[0:NI-1,0:NI-1]|element
+	#pragma scop
+	#pragma species kernel C[0:NI-1,0:NI-1]|element ^ A[0:NI-1,0:NJ-1]|chunk(0:0,0:NJ-1) -> C[0:NI-1,0:NI-1]|element
 	for (i=0; i<NI; i++) {
 		for (j=0; j<NI; j++) {
 			C[i][j] *= beta;
@@ -55,8 +56,10 @@ int main(void) {
 		}
 	}
 	#pragma species endkernel syrk
+	#pragma endscop
 	
 	// Clean-up and exit the function
 	fflush(stdout);
+	C[8][9] = C[8][9];
 	return 0;
 }

data/examples/benchmarks/{trisolv.c → PolyBench/trisolv.c}

@@ -40,6 +40,7 @@ int main(void) {
 	}
 	
 	// Perform the computation
+	#pragma scop
 	for (i=0; i<NX; i++) {
 		x[i] = c[i];
 		A_i_i = A[i][i];
@@ -50,8 +51,10 @@ int main(void) {
 		}
 		//#pragma species endkernel trisolv
 	}
+	#pragma endscop
 	
 	// Clean-up and exit the function
 	fflush(stdout);
+	x[8] = x[8];
 	return 0;
 }

data/examples/benchmarks/{trmm.c → PolyBench/trmm.c}

@@ -40,6 +40,7 @@ int main(void) {
 	}
 	
 	// Perform the computation (B := alpha*A'*B, with A triangular)
+	#pragma scop
 	for (i=1; i<NI; i++) {
 		for (j=0; j<NI; j++) {
 			#pragma species kernel i:i,0:i-1|element ^ j:j,0:i-1|element -> i:i,j:j|shared
@@ -49,9 +50,11 @@ int main(void) {
 			#pragma species endkernel trmm
 		}
 	}
+	#pragma endscop
 	
 	// Clean-up and exit the function
 	fflush(stdout);
+	B[8][9] = B[8][9];
 	return 0;
 }
 

data/examples/benchmarks/Rodinia/cfd.c

@@ -0,0 +1,180 @@
+//
+// This file is part of the Bones source-to-source compiler examples. This C-code
+// demonstrates the use of Bones for an example application: 'Unstructured Grid-
+// Based CFD Solvers', taken from the Rodinia benchmark suite. For more information
+// on the application or on Bones please use the contact information below.
+//
+// == More information on unstructured grid based CFD solvers:
+// Website............http://web.cos.gmu.edu/~acorriga/pubs/gpu_cfd/
+// Article............http://web.cos.gmu.edu/~acorriga/pubs/gpu_cfd/aiaa_2009_4001.pdf
+// Original code......https://www.cs.virginia.edu/~skadron/wiki/rodinia/
+//
+// == More information on Bones
+// Contact............Cedric Nugteren <c.nugteren@tue.nl>
+// Web address........http://parse.ele.tue.nl/bones/
+//
+// == File information
+// Filename...........applications/cfd.c
+// Authors............Cedric Nugteren
+// Original author....Andrew Corrigan
+// Last modified on...10-Aug-2012
+//
+
+//########################################################################
+//### Includes
+//########################################################################
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+
+//########################################################################
+//### Data types
+//########################################################################
+
+typedef struct {
+	float x;
+	float y;
+	float z;
+} float3;
+
+//########################################################################
+//### Forward declarations
+//########################################################################
+
+inline void compute_flux_contribution(float3 momentum, float density_energy, float pressure, float3 velocity, float3 *fc_momentum_x, float3 *fc_momentum_y, float3 *fc_momentum_z, float3 *fc_density_energy);
+
+//########################################################################
+//### Options
+//########################################################################
+
+#define GAMMA 1.4f
+#define iterations 2000
+#define NNB 4
+#define RK 3	// 3rd order RK
+
+#define FF_MACH 1.2f
+#define DEG_ANGLE_OF_ATTACK 0.0f
+#define NDIM 3
+
+//########################################################################
+//### Defines
+//########################################################################
+
+#define VAR_DENSITY 0
+#define VAR_MOMENTUM 1
+#define VAR_DENSITY_ENERGY (VAR_MOMENTUM+NDIM)
+#define NVAR (VAR_DENSITY_ENERGY+1)
+
+//########################################################################
+//### Global variables
+//########################################################################
+
+float ff_variable[NVAR];
+float3 ff_flux_contribution_momentum_x;
+float3 ff_flux_contribution_momentum_y;
+float3 ff_flux_contribution_momentum_z;
+float3 ff_flux_contribution_density_energy;
+
+//########################################################################
+//### Start of the main function
+//########################################################################
+
+int main(void) {
+	
+	// Declare the loop iterators
+	int i,j;
+	
+	// Declare far field variables
+	const float angle_of_attack = (M_PI/180.0f) * DEG_ANGLE_OF_ATTACK;
+	float ff_pressure, ff_speed_of_sound, ff_speed;
+	float3 ff_velocity, ff_momentum;
+	
+	// Declare other domain variables
+	
+	// Declare other/helper variables
+	
+	// Compute the far field
+	printf("\n[cfd] Set the far field conditions"); fflush(stdout);
+	{
+		ff_variable[VAR_DENSITY] = 1.4f;
+		ff_pressure = 1.0f;
+		ff_speed_of_sound = sqrt(GAMMA*ff_pressure / ff_variable[VAR_DENSITY]);
+		ff_speed = FF_MACH*ff_speed_of_sound;
+		
+		// Compute the velocity
+		ff_velocity.x = ff_speed*cos(angle_of_attack);
+		ff_velocity.y = ff_speed*sin(angle_of_attack);
+		ff_velocity.z = 0.0f;
+		
+		// Update the variable
+		ff_variable[VAR_MOMENTUM+0] = ff_variable[VAR_DENSITY] * ff_velocity.x;
+		ff_variable[VAR_MOMENTUM+1] = ff_variable[VAR_DENSITY] * ff_velocity.y;
+		ff_variable[VAR_MOMENTUM+2] = ff_variable[VAR_DENSITY] * ff_velocity.z;
+		ff_variable[VAR_DENSITY_ENERGY] = ff_variable[VAR_DENSITY]*0.5f*ff_speed*ff_speed + (ff_pressure/(GAMMA-1.0f));
+		
+		// Set the momentum
+		ff_momentum.x = ff_variable[VAR_MOMENTUM+0];
+		ff_momentum.y = ff_variable[VAR_MOMENTUM+1];
+		ff_momentum.z = ff_variable[VAR_MOMENTUM+2];
+		
+		// Compute the flux contribution
+		compute_flux_contribution(
+			ff_momentum,
+			ff_variable[VAR_DENSITY_ENERGY],
+			ff_pressure,
+			ff_velocity,
+			&ff_flux_contribution_momentum_x,
+			&ff_flux_contribution_momentum_y,
+			&ff_flux_contribution_momentum_z,
+			&ff_flux_contribution_density_energy
+		);
+	}
+	
+	// Initialising memory
+	printf("\n[cfd] Initialising memory"); fflush(stdout);
+	
+	
+	// Clean-up and exit
+	printf("\n[cfd] Completed\n\n"); fflush(stdout);
+	fflush(stdout);
+	return 0;
+}
+
+//########################################################################
+//### Function to compute the flux contribution
+//########################################################################
+
+inline void compute_flux_contribution(
+		float3 momentum,
+		float density_energy,
+		float pressure,
+		float3 velocity,
+		float3 *fc_momentum_x,
+		float3 *fc_momentum_y,
+		float3 *fc_momentum_z,
+		float3 *fc_density_energy
+	) {
+	
+	// Compute the x-momentum
+	(*fc_momentum_x).x = velocity.x*momentum.x + pressure;
+	(*fc_momentum_x).y = velocity.x*momentum.y;
+	(*fc_momentum_x).z = velocity.x*momentum.z;
+	
+	// Compute the y-momentum
+	(*fc_momentum_y).x = velocity.x*momentum.y;
+	(*fc_momentum_y).y = velocity.y*momentum.y + pressure;
+	(*fc_momentum_y).z = velocity.y*momentum.z;
+	
+	// Compute the z-momentum
+	(*fc_momentum_z).x = velocity.x*momentum.z;
+	(*fc_momentum_z).y = velocity.y*momentum.z;
+	(*fc_momentum_z).z = velocity.z*momentum.z + pressure;
+
+	// Compute energy density
+	(*fc_density_energy).x = velocity.x*density_energy+pressure;
+	(*fc_density_energy).y = velocity.y*density_energy+pressure;
+	(*fc_density_energy).z = velocity.z*density_energy+pressure;
+}
+
+//########################################################################