bones-compiler 1.3.1 → 1.6.0

data/examples/benchmarks/Rodinia/nw.c

@@ -0,0 +1,151 @@
+//
+// This file is part of the Bones source-to-source compiler examples. This C-code
+// demonstrates the use of Bones for an example application: 'nw', taken from
+// the Rodinia benchmark suite. For more information on the application or on Bones
+// please use the contact information below.
+//
+// == More information on Hotspot
+// 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/nw.c
+// Authors............Cedric Nugteren
+// Last modified on...01-Jun-2014
+//
+
+//########################################################################
+//### Includes
+//########################################################################
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+
+//########################################################################
+//### Defines
+//########################################################################
+
+// Config
+#define MAX_ROWS (2048+1)
+#define MAX_COLS (2048+1)
+#define PENALTY 10
+
+// Reference
+int blosum62[24][24] = {
+	{ 4, -1, -2, -2,  0, -1, -1,  0, -2, -1, -1, -1, -1, -2, -1,  1,  0, -3, -2,  0, -2, -1,  0, -4},
+	{-1,  5,  0, -2, -3,  1,  0, -2,  0, -3, -2,  2, -1, -3, -2, -1, -1, -3, -2, -3, -1,  0, -1, -4},
+	{-2,  0,  6,  1, -3,  0,  0,  0,  1, -3, -3,  0, -2, -3, -2,  1,  0, -4, -2, -3,  3,  0, -1, -4},
+	{-2, -2,  1,  6, -3,  0,  2, -1, -1, -3, -4, -1, -3, -3, -1,  0, -1, -4, -3, -3,  4,  1, -1, -4},
+	{ 0, -3, -3, -3,  9, -3, -4, -3, -3, -1, -1, -3, -1, -2, -3, -1, -1, -2, -2, -1, -3, -3, -2, -4},
+	{-1,  1,  0,  0, -3,  5,  2, -2,  0, -3, -2,  1,  0, -3, -1,  0, -1, -2, -1, -2,  0,  3, -1, -4},
+	{-1,  0,  0,  2, -4,  2,  5, -2,  0, -3, -3,  1, -2, -3, -1,  0, -1, -3, -2, -2,  1,  4, -1, -4},
+	{ 0, -2,  0, -1, -3, -2, -2,  6, -2, -4, -4, -2, -3, -3, -2,  0, -2, -2, -3, -3, -1, -2, -1, -4},
+	{-2,  0,  1, -1, -3,  0,  0, -2,  8, -3, -3, -1, -2, -1, -2, -1, -2, -2,  2, -3,  0,  0, -1, -4},
+	{-1, -3, -3, -3, -1, -3, -3, -4, -3,  4,  2, -3,  1,  0, -3, -2, -1, -3, -1,  3, -3, -3, -1, -4},
+	{-1, -2, -3, -4, -1, -2, -3, -4, -3,  2,  4, -2,  2,  0, -3, -2, -1, -2, -1,  1, -4, -3, -1, -4},
+	{-1,  2,  0, -1, -3,  1,  1, -2, -1, -3, -2,  5, -1, -3, -1,  0, -1, -3, -2, -2,  0,  1, -1, -4},
+	{-1, -1, -2, -3, -1,  0, -2, -3, -2,  1,  2, -1,  5,  0, -2, -1, -1, -1, -1,  1, -3, -1, -1, -4},
+	{-2, -3, -3, -3, -2, -3, -3, -3, -1,  0,  0, -3,  0,  6, -4, -2, -2,  1,  3, -1, -3, -3, -1, -4},
+	{-1, -2, -2, -1, -3, -1, -1, -2, -2, -3, -3, -1, -2, -4,  7, -1, -1, -4, -3, -2, -2, -1, -2, -4},
+	{ 1, -1,  1,  0, -1,  0,  0,  0, -1, -2, -2,  0, -1, -2, -1,  4,  1, -3, -2, -2,  0,  0,  0, -4},
+	{ 0, -1,  0, -1, -1, -1, -1, -2, -2, -1, -1, -1, -1, -2, -1,  1,  5, -2, -2,  0, -1, -1,  0, -4},
+	{-3, -3, -4, -4, -2, -2, -3, -2, -2, -3, -2, -3, -1,  1, -4, -3, -2, 11,  2, -3, -4, -3, -2, -4},
+	{-2, -2, -2, -3, -2, -1, -2, -3,  2, -1, -1, -2, -1,  3, -3, -2, -2,  2,  7, -1, -3, -2, -1, -4},
+	{ 0, -3, -3, -3, -1, -2, -2, -3, -3,  3,  1, -2,  1, -1, -2, -2,  0, -3, -1,  4, -3, -2, -1, -4},
+	{-2, -1,  3,  4, -3,  0,  1, -1,  0, -3, -4,  0, -3, -3, -2,  0, -1, -4, -3, -3,  4,  1, -1, -4},
+	{-1,  0,  0,  1, -3,  3,  4, -2,  0, -3, -3,  1, -1, -3, -1,  0, -1, -3, -2, -2,  1,  4, -1, -4},
+	{ 0, -1, -1, -1, -2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -2,  0,  0, -2, -1, -1, -1, -1, -1, -4},
+	{-4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4,  1}
+};
+
+//########################################################################
+//### Start of the main function
+//########################################################################
+
+int main(void) {
+	printf("[nw] Start Needleman-Wunsch\n");
+
+	// Arrays
+	int similarity[MAX_ROWS][MAX_COLS];
+	int items[MAX_ROWS][MAX_COLS];
+
+	// Initialize random input data
+	srand (7);
+	for (int i=0; i<MAX_ROWS; i++) {
+		for (int j=0; j<MAX_COLS; j++) {
+			items[i][j] = 0;
+		}
+	}
+	for (int i=1; i<MAX_ROWS; i++) {
+		items[i][0] = rand()%10 + 1;
+	}
+	for (int j=1; j<MAX_COLS; j++) {
+		items[0][j] = rand()%10 + 1;
+	}
+
+	// Initialize reference
+	for (int i=0; i<MAX_ROWS; i++) {
+		for (int j=0; j<MAX_COLS; j++) {
+			similarity[i][j] = blosum62[items[i][0]][items[0][j]];
+		}
+	}
+
+	// Update input with penalty
+	for (int i=1; i<MAX_ROWS; i++) {
+		items[i][0] = -i*PENALTY;
+	}
+	for (int j=1; j<MAX_COLS; j++) {
+		items[0][j] = -j*PENALTY;
+	}
+
+	// Start of computation
+	#pragma scop
+
+	// Compute top-left matrix 
+	for (int i=0; i<MAX_ROWS-2; i++) {
+		for (int idx=0; idx <= i; idx++) {
+			int a = items[idx+0][i+0-idx] + similarity[idx+1][i+1-idx];
+			int b = items[idx+1][i+0-idx] - PENALTY;
+			int c = items[idx+0][i+1-idx] - PENALTY;
+			int max_val = a;
+			if (b > max_val) {
+				max_val = b;
+			}
+			if (c > max_val) {
+				max_val = c;
+			}
+			items[idx+1][i+1-idx] = max_val;
+		}
+	}
+
+	// Compute bottom-right matrix 
+	for (int i=MAX_ROWS-4; i>=0; i--) {
+		for (int idx=0; idx <= i; idx++) {
+			int a = items[MAX_ROWS-idx-3][idx+MAX_COLS-i-3] + similarity[MAX_ROWS-idx-2][idx+MAX_COLS-i-2];
+			int b = items[MAX_ROWS-idx-2][idx+MAX_COLS-i-3] - PENALTY;
+			int c = items[MAX_ROWS-idx-3][idx+MAX_COLS-i-2] - PENALTY;
+			int max_val = a;
+			if (b > max_val) {
+				max_val = b;
+			}
+			if (c > max_val) {
+				max_val = c;
+			}
+			items[MAX_ROWS-idx-2][idx+MAX_COLS-i-2] = max_val;
+		}
+	}
+
+	// End of computation
+	#pragma endscop
+
+	// Clean-up and exit
+	printf("\n[nw] Completed\n\n"); fflush(stdout);
+	fflush(stdout);
+	return 0;
+}
+
+//########################################################################

data/examples/benchmarks/Rodinia/pathfinder.c

@@ -0,0 +1,88 @@
+//
+// This file is part of the Bones source-to-source compiler examples. This C-code
+// demonstrates the use of Bones for an example application: 'pathfinder', taken from
+// the Rodinia benchmark suite. For more information on the application or on Bones
+// please use the contact information below.
+//
+// == More information on Hotspot
+// 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/pathfinder.c
+// Authors............Cedric Nugteren
+// Last modified on...05-Jun-2014
+//
+//########################################################################
+
+// Includes
+#include "common.h"
+
+//########################################################################
+//### Start of the main function
+//########################################################################
+
+int main(void) {
+
+	// Variables
+	unsigned long long cycles;
+	int min;
+
+	// Initialize arrays
+	int wall[PATHROWS][PATHCOLS];
+	int result[PATHCOLS];
+	int input[PATHCOLS];
+
+	// Seed
+	int seed = M_SEED;
+	srand(seed);
+
+	// Set initial values
+	for (int i=0; i<PATHROWS; i++) {
+		for (int j=0; j<PATHCOLS; j++) {
+			wall[i][j] = rand() % 10;
+		}
+	}
+	for (int j=0; j<PATHCOLS; j++) {
+		result[j] = wall[0][j];
+	}
+	
+	// Iterate over the PATHROWS
+	#pragma scop
+	for (int t=1; t<PATHROWS; t++) {
+
+		// Copy result of previous iteration as current input
+		for (int n=0; n<PATHCOLS; n++) {
+			input[n] = result[n];
+		}
+
+		// Iterate over the columns
+		for (int n=0; n<PATHCOLS; n++) {
+			min = input[n];
+			if (n > 0) {
+				int val1 = input[n-1];
+				if (val1 < min) {
+					min = val1;
+				}
+			}
+			if (n < PATHCOLS-1) {
+				int val2 = input[n+1];
+				if (val2 < min) {
+					min = val2;
+				}
+			}
+			result[n] = wall[t][n] + min;
+		}
+	}
+	#pragma endscop
+	
+	// Clean-up and exit
+	printf("\n[pathfinder] Completed\n\n"); fflush(stdout);
+	fflush(stdout);
+	return 0;
+}
+
+//########################################################################

data/examples/benchmarks/Rodinia/srad.c

@@ -17,29 +17,12 @@
 // Filename...........applications/srad.c
 // Authors............Cedric Nugteren
 // Original authors...Rob Janiczek, Drew Gilliam, Lukasz Szafaryn
-// Last modified on...10-Aug-2012
+// Last modified on...05-Jun-2014
 //
-
-//########################################################################
-//### Includes
-//########################################################################
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <math.h>
-
-//########################################################################
-//### Defines
 //########################################################################
 
-#define ROWS 128    // Number of ROWS in the domain
-#define COLS 128    // Number of COLS in the domain
-#define R1 0        // y1 position of the speckle
-#define R2 31       // y2 position of the speckle
-#define C1 0        // x1 position of the speckle
-#define C2 31       // x2 position of the speckle
-#define LAMBDA 0.5  // Lambda value
-#define NITER 2     // Number of iterations
+// Includes
+#include "common.h"
 
 //########################################################################
 //### Start of the main function
@@ -74,19 +57,19 @@ int main(void) {
 	printf("\n[srad] Initialising memory"); fflush(stdout);
 	int size = COLS*ROWS;
 	int size_roi = (R2-R1+1)*(C2-C1+1);
-	float* values     = (float*) malloc(sizeof(float)*size);
-	float* coefficent = (float*) malloc(sizeof(float)*size);
-	float* dN = (float*) malloc(sizeof(float)*size);
-	float* dS = (float*) malloc(sizeof(float)*size);
-	float* dW = (float*) malloc(sizeof(float)*size);
-	float* dE = (float*) malloc(sizeof(float)*size);
+	float values[ROWS][COLS];
+	float coefficent[ROWS][COLS];
+	float dN[ROWS][COLS];
+	float dS[ROWS][COLS];
+	float dW[ROWS][COLS];
+	float dE[ROWS][COLS];
 	
 	// Populate the input matrix
 	printf("\n[srad] Populating the input matrix with random values"); fflush(stdout);
 	for (i=0; i<ROWS; i++) {
 		for (j=0; j<COLS; j++) {
 			temp_value = rand()/(float)RAND_MAX;
-			values[i*COLS+j] = (float)exp(temp_value);
+			values[i][j] = (float)exp(temp_value);
 		}
 	}
 	
@@ -99,7 +82,7 @@ int main(void) {
 		sum2 = 0;
 		for (i=R1; i<=R2; i++) {
 			for (j=C1; j<=C2; j++) {
-				temp_value = values[i*COLS+j];
+				temp_value = values[i][j];
 				sum1 += temp_value;
 				sum2 += temp_value*temp_value;
 			}
@@ -108,61 +91,69 @@ int main(void) {
 		var_roi = (sum2/size_roi) - mean_roi*mean_roi;
 		q0s = var_roi / (mean_roi*mean_roi);
 		
-		// Iterate over the full image and compute
 		#pragma scop
+		// Iterate over the full image and computeΩ
 		for (i=0; i<ROWS; i++) {
 			for (j=0; j<COLS; j++) {
-				index = i*COLS+j;
-				current_value = values[index];
+
+				current_value = values[i][j];
+
+				// Temporary variables
+				float valN = 0;
+				float valS = 0;
+				float valW = 0;
+				float valE = 0;
 
 				// Compute the directional derivates (N,S,W,E)
-				if (i==0)      { dN[index] = 0; }
-				else           { dN[index] = values[(i-1)*COLS + j    ] - current_value; }
-				if (i==ROWS-1) { dS[index] = 0; }
-				else           { dS[index] = values[(i+1)*COLS + j    ] - current_value; }
-				if (j==0)      { dW[index] = 0; }
-				else           { dW[index] = values[i    *COLS + (j-1)] - current_value; }
-				if (j==COLS-1) { dE[index] = 0; }
-				else           { dE[index] = values[i    *COLS + (j+1)] - current_value; }
+				if (i > 0)      { valN = values[i-1][j  ] - current_value; }
+				if (i < ROWS-1) { valS = values[i+1][j  ] - current_value; }
+				if (j > 0)      { valW = values[i  ][j-1] - current_value; }
+				if (j < COLS-1) { valE = values[i  ][j+1] - current_value; }
 
 				// Compute the instantaneous coefficient of variation (qs) (equation 35)
-				G2 = (dN[index]*dN[index] + dS[index]*dS[index] + dW[index]*dW[index] + dE[index]*dE[index]) / (current_value*current_value);
-				L =  (dN[index]           + dS[index]           + dW[index]           + dE[index]          ) / (current_value              );
+				G2 = (valN*valN + valS*valS + valW*valW + valE*valE) / (current_value*current_value);
+				L =  (valN      + valS      + valW      + valE     ) / (current_value              );
 				temp_a = (0.5*G2)-((1.0/16.0)*(L*L));
 				temp_b = 1+(0.25*L);
 				qs = temp_a/(temp_b*temp_b);
 
+				// Write the data
+				dN[i][j] = valN;
+				dS[i][j] = valS;
+				dW[i][j] = valW;
+				dE[i][j] = valE;
+
 				// Set the diffusion coefficent (equation 33)
-				coefficent[index] = 1.0 / (1.0+( (qs-q0s)/(q0s*(1+q0s)) ));
+				float val = 1.0 / (1.0+( (qs-q0s)/(q0s*(1+q0s)) ));
 
 				// Saturate the diffusion coefficent
-				if (coefficent[index] < 0) {
-					coefficent[index] = 0;
+				if (val < 0) {
+					val = 0;
 				}
-				else if (coefficent[index] > 1) {
-					coefficent[index] = 1;
+				else if (val > 1) {
+					val = 1;
 				}
+				coefficent[i][j] = val;
 			}
 		}
-		
+
 		// Iterate over the full image again and compute the final values
 		for (i=0; i<ROWS; i++) {
 			for (j=0; j<COLS; j++) {
-				index = i*COLS+j;
 
 				// Calculate the diffusion coefficent
-				                 cN = coefficent[i    *COLS+j    ];
+				                 cN = coefficent[i  ][j  ];
 				if (i==ROWS-1) { cS = 0; }
-				else           { cS = coefficent[(i+1)*COLS+j    ]; }
-				                 cW = coefficent[i    *COLS+j    ];
+				else           { cS = coefficent[i+1][j  ]; }
+				                 cW = coefficent[i  ][j  ];
 				if (j==COLS-1) { cE = 0; }
-				else           { cE = coefficent[i    *COLS+(j+1)]; }
+				else           { cE = coefficent[i  ][j+1]; }
 
 				// Calculate the divergence (equation 58)
-				divergence = cN*dN[index] + cS*dS[index] + cW*dW[index] + cE*dE[index];
+				divergence = cN*dN[i][j] + cS*dS[i][j] + cW*dW[i][j] + cE*dE[i][j];
 
 				// Update the image accordingly (equation 61)
-				values[index] = values[index] + 0.25*LAMBDA*divergence;
+				values[i][j] = values[i][j] + 0.25*LAMBDA*divergence;
 			}
 		}
 		#pragma endscop
@@ -172,15 +163,15 @@ int main(void) {
 	printf("\n[srad] Printing the output matrix:\n\n"); fflush(stdout);
 	for (i=0; i<ROWS; i++) {
 		for (j=0; j<COLS; j++) {
-			printf("%.5f ", values[i*COLS+j]);
+			if (i == 5 && j == 5) {
+				printf("%.5f ", values[i][j]);
+			}
 		}
-		printf("\n");
+		//printf("\n");
 	}
 	
 	// Clean-up and exit
-	printf("\n[srad] Completed\n\n"); fflush(stdout);
-	free(values); free(coefficent);
-	free(dN); free(dS); free(dW); free(dE);
+	printf("\n[srad] Completed\n\n");
 	fflush(stdout);
 	return 0;
 }

data/examples/chunk/example01.c

@@ -8,14 +8,14 @@
 // Web address........http://parse.ele.tue.nl/bones/
 //
 // == File information
-// Filename...........chunk/example1.c
+// Filename...........chunk/example01.c
 // Author.............Cedric Nugteren
-// Last modified on...16-April-2012
+// Last modified on...10-October-2014
 //
 
 #include <stdio.h>
 
-// This is 'example1', a basic chunk to element example using a 2D tile
+// This is 'example01', a basic chunk to element example using a 2D tile
 int main(void) {
 	int i,j;
 	int i2,j2;
@@ -33,7 +33,8 @@ int main(void) {
 	}
 	
 	// Perform the computation
-	#pragma species kernel 0:559,0:31|chunk(0:9,0:1) -> 0:55,0:15|element
+	#pragma scop
+	#pragma species kernel A[0:559,0:31]|chunk(0:9,0:1) -> B[0:55,0:15]|element
 	for(i=0;i<56;i++) {
 		for(j=0;j<16;j++) {
 			result = 0;
@@ -46,6 +47,7 @@ int main(void) {
 		}
 	}
 	#pragma species endkernel example1
+	#pragma endscop
 	
 	// Clean-up and exit the function
 	fflush(stdout);