bones-compiler 1.1.0 → 1.3.1

data/examples/benchmarks/Rodinia/hotspot.c

@@ -0,0 +1,228 @@
+//
+// This file is part of the Bones source-to-source compiler examples. This C-code
+// demonstrates the use of Bones for an example application: 'Hotspot', 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
+// Article............http://dx.doi.org/10.1109/TVLSI.2006.876103
+// 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/hotspot.c
+// Authors............Cedric Nugteren
+// Last modified on...10-Aug-2012
+//
+
+//########################################################################
+//### Includes
+//########################################################################
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+
+//########################################################################
+//### Input parameters
+//########################################################################
+
+#define GRID_ROWS 64                                        // Number of rows in the grid (positive integer)
+#define GRID_COLS 64                                        // Number of columns in the grid (positive integer)
+#define SIM_TIME 2                                          // Number of iterations
+#define TEMPERATURE_FILE "data/hotspot_temperature_64.txt"  // Name of the file containing the initial temperature values of each cell
+#define POWER_FILE "data/hotspot_power_64.txt"              // Name of the file containing the dissipated power values of each cell
+
+//########################################################################
+//### Defines
+//########################################################################
+
+#define STRING_SIZE 256          // Length of the strings in the temperature and power files
+#define MAX_PD (3.0e6)           // Maximum power density possible (say 300W for a 10mm x 10mm chip)
+#define PRECISION 0.001          // Required precision in degrees
+#define SPEC_HEAT_SI 1.75e6      // 
+#define K_SI 100                 // 
+#define FACTOR_CHIP 0.5          // Capacitance fitting factor
+#define T_CHIP 0.0005            // Chip temperature
+#define CHIP_HEIGHT 0.016        // Chip height
+#define CHIP_WIDTH 0.016         // Chip width
+#define AMB_TEMP 80.0            // Ambient temperature, assuming no package at all
+
+//########################################################################
+//### Forward declarations
+//########################################################################
+
+void read_input(double* array, const char* filename);
+
+//########################################################################
+//### Start of the main function
+//########################################################################
+
+int main(void) {
+	
+	// Declare the loop iterators
+	int r,c,iter;
+	
+	// Declare other/helper variables
+	int index;
+	double delta;
+	int row = GRID_ROWS;
+	int col = GRID_COLS;
+	double grid_height = CHIP_HEIGHT/row;
+	double grid_width = CHIP_WIDTH/col;
+	
+	// Set domain variables
+	double cap = FACTOR_CHIP*SPEC_HEAT_SI*T_CHIP*grid_width*grid_height;
+	double Rx = grid_width / (2.0*K_SI*T_CHIP*grid_height);
+	double Ry = grid_height / (2.0*K_SI*T_CHIP*grid_width);
+	double Rz = T_CHIP / (K_SI*grid_height*grid_width);
+	double max_slope = MAX_PD / (FACTOR_CHIP*T_CHIP*SPEC_HEAT_SI);
+	double step = PRECISION / max_slope;
+	
+	// Initialising memory
+	printf("\n[hotspot] Initialising memory"); fflush(stdout);
+	double* temperature = (double*) calloc(row*col, sizeof(double));
+	double* power       = (double*) calloc(row*col, sizeof(double));
+	double* result      = (double*) calloc(row*col, sizeof(double));
+	
+	// Read initial temperature and power arrays
+	printf("\n[hotspot] Populating memory"); fflush(stdout);
+	read_input(temperature, TEMPERATURE_FILE);
+	read_input(power, POWER_FILE);
+	
+	// Perform the computation a given number of times
+	printf("\n[hotspot] Performing the computation %d times",SIM_TIME); fflush(stdout);
+	#pragma scop
+	for (iter=0; iter<SIM_TIME; iter++) {
+		
+		// Transient solver driver routine: convert the heat transfer differential equations to difference equations
+		// and solve the difference equations by iterating
+		for (r=0; r<row; r++) {
+			for (c=0; c<col; c++) {
+				
+				// Corner 1
+				if ( (r == 0) && (c == 0) ) {
+					delta = (step / cap) * (power[0] + 
+						(temperature[1]   - temperature[0]) / Rx + 
+						(temperature[col] - temperature[0]) / Ry + 
+						(AMB_TEMP         - temperature[0]) / Rz);
+				}
+				// Corner 2
+				else if ((r == 0) && (c == col-1)) {
+					delta = (step / cap) * (power[c] + 
+						(temperature[c-1]   - temperature[c]) / Rx + 
+						(temperature[c+col] - temperature[c]) / Ry + 
+						(AMB_TEMP           - temperature[c]) / Rz);
+				}
+				// Corner 3
+				else if ((r == row-1) && (c == col-1)) {
+					delta = (step / cap) * (power[r*col+c] + 
+						(temperature[r*col+c-1]   - temperature[r*col+c]) / Rx + 
+						(temperature[(r-1)*col+c] - temperature[r*col+c]) / Ry + 
+						(AMB_TEMP                 - temperature[r*col+c]) / Rz);
+				}
+				// Corner 4
+				else if ((r == row-1) && (c == 0)) {
+					delta = (step / cap) * (power[r*col] + 
+						(temperature[r*col+1]   - temperature[r*col]) / Rx + 
+						(temperature[(r-1)*col] - temperature[r*col]) / Ry + 
+						(AMB_TEMP               - temperature[r*col]) / Rz);
+				}
+				// Edge 1
+				else if (r == 0) {
+					delta = (step / cap) * (power[c] + 
+						(temperature[c+1] + temperature[c-1] - 2.0*temperature[c]) / Rx + 
+						(temperature[col+c]                      - temperature[c]) / Ry + 
+						(AMB_TEMP                                - temperature[c]) / Rz);
+				}
+				// Edge 2
+				else if (c == col-1) {
+					delta = (step / cap) * (power[r*col+c] + 
+						(temperature[(r+1)*col+c] + temperature[(r-1)*col+c] - 2.0*temperature[r*col+c]) / Ry + 
+						(temperature[r*col+c-1]                                  - temperature[r*col+c]) / Rx + 
+						(AMB_TEMP                                                - temperature[r*col+c]) / Rz);
+				}
+				// Edge 3
+				else if (r == row-1) {
+					delta = (step / cap) * (power[r*col+c] + 
+						(temperature[r*col+c+1] + temperature[r*col+c-1] - 2.0*temperature[r*col+c]) / Rx + 
+						(temperature[(r-1)*col+c]                            - temperature[r*col+c]) / Ry + 
+						(AMB_TEMP                                            - temperature[r*col+c]) / Rz);
+				}
+				// Edge 4
+				else if (c == 0) {
+					delta = (step / cap) * (power[r*col] + 
+						(temperature[(r+1)*col] + temperature[(r-1)*col] - 2.0*temperature[r*col]) / Ry + 
+						(temperature[r*col+1]                                - temperature[r*col]) / Rx + 
+						(AMB_TEMP                                            - temperature[r*col]) / Rz);
+				}
+				// Inside the chip
+				else {
+					delta = (step / cap) * (power[r*col+c] + 
+						(temperature[(r+1)*col+c] + temperature[(r-1)*col+c] - 2.0*temperature[r*col+c]) / Ry + 
+						(temperature[r*col+c+1]   + temperature[r*col+c-1]   - 2.0*temperature[r*col+c]) / Rx + 
+						(AMB_TEMP                                                - temperature[r*col+c]) / Rz);
+				}
+			
+			// Update the temperatures
+			result[r*col+c] = temperature[r*col+c] + delta;
+			}
+		}
+		
+		// Copy the result as the new temperatures
+		for (r=0; r<row; r++) {
+			for (c=0; c<col; c++) {
+				temperature[r*col+c] = result[r*col+c];
+			}
+		}
+	}
+	#pragma endscop
+	
+	// Print the values matrix
+	printf("\n[hotspot] Printing the final temperatures:\n\n"); fflush(stdout);
+	for (r=0; r<row; r++) {
+		for (c=0; c<col; c++) {
+			index = r*col+c;
+			printf("%6d: %.3lf ", index, temperature[index]);
+		}
+		printf("\n");
+	}
+	
+	// Clean-up and exit
+	printf("\n[hotspot] Completed\n\n"); fflush(stdout);
+	free(temperature); free(power); free(result);
+	fflush(stdout);
+	return 0;
+}
+
+//########################################################################
+//### Function to read an input file (power or temperature values)
+//########################################################################
+
+void read_input(double* array, const char* filename) {
+	int r, c;
+	char string[STRING_SIZE];
+	double value;
+
+	// Open the file
+	FILE* file_pointer = fopen(filename, "r");
+	if (!file_pointer) { printf("\n[hotspot] Error: file '%s' could not be opened for reading\n\n", filename); fflush(stdout); exit(1); }
+
+	// Process the file
+	for (r=0; r<GRID_ROWS; r++) {
+		for (c=0; c<GRID_COLS; c++) {
+			fgets(string, STRING_SIZE, file_pointer);
+			if (feof(file_pointer))                    { printf("\n[hotspot] Error: not enough lines in file '%s'\n\n", filename); fflush(stdout); exit(1); }
+			if ((sscanf(string, "%lf", &value) != 1) ) { printf("\n[hotspot] Error: invalid file format for '%s'\n\n", filename); fflush(stdout); exit(1); }
+			array[r*GRID_COLS+c] = value;
+		}
+	}
+	
+	// Clean-up and return
+	fclose(file_pointer);
+}
+
+//########################################################################

data/examples/benchmarks/Rodinia/kmeans.c

@@ -0,0 +1,164 @@
+//
+// This file is part of the Bones source-to-source compiler examples. This C-code
+// demonstrates the use of Bones for an example application: 'K-means clustering',
+// as also available in the Rodinia benchmark suite. For more information on the
+// application or on Bones please use the contact information below.
+//
+// == This implementation of K-means clustering is inspired by:
+// Author.............Roger Zhang
+// Web address........http://cs.smu.ca/~r_zhang/code/kmeans.c
+//
+// == More information on Bones
+// Contact............Cedric Nugteren <c.nugteren@tue.nl>
+// Web address........http://parse.ele.tue.nl/bones/
+//
+// == File information
+// Filename...........applications/kmeans.c
+// Authors............Cedric Nugteren
+// Last modified on...10-Aug-2012
+//
+
+//########################################################################
+//### Includes
+//########################################################################
+
+#include <stdio.h>
+#include <math.h>
+#include <float.h>
+
+//########################################################################
+//### Defines
+//########################################################################
+
+#define SIZE 512
+#define NUM_CLUSTERS 20
+#define DIMENSIONS 2
+#define THRESHOLD 0.0001
+
+//########################################################################
+//### Start of the main function
+//########################################################################
+int main(void) {
+	
+	// Declare the loop iterators
+	int i,j,k;
+	
+	// Declare the error variables
+	double error = DBL_MAX;
+	double old_error;
+	int iterations = 0;
+	
+	// Declare the distance variables and arrays
+	double distance[1];
+	double min_distance[1];
+	double distances[SIZE];
+	
+	// Initialising memory
+	printf("\n[k-means] Initialising memory"); fflush(stdout);
+	double input[SIZE][DIMENSIONS];
+	double centroids[NUM_CLUSTERS][DIMENSIONS];
+	double centroids_temp[NUM_CLUSTERS][DIMENSIONS];
+	int output[SIZE];
+	int counts[NUM_CLUSTERS];
+	
+	// Set the input data
+	printf("\n[k-means] Populating memory"); fflush(stdout);
+	for (i=0; i<SIZE; i++) {
+		input[i][0] = (i/16);
+		input[i][1] = i%4;
+	}
+	
+	// Pick k initial centroids
+	printf("\n[k-means] Setting 'k' initial centroids"); fflush(stdout);
+	for (k=0; k<NUM_CLUSTERS; k++) {
+		for (j=0; j<DIMENSIONS; j++) {
+			centroids[k][j] = input[(SIZE/NUM_CLUSTERS)*k][j];
+		}
+	}
+	
+	// Perform the k-means clustering algorithm, end when the error is not becoming smaller
+	printf("\n[k-means] Perform the clustering algorithm"); fflush(stdout);
+	do {
+		#pragma scop
+		
+		// Save the error from the last step
+		old_error = error;
+		error = 0;
+		
+		// Clear old counts and temporary centroids
+		for (k=0; k<NUM_CLUSTERS; k++) {
+			counts[k] = 0;
+			for (j=0; j<DIMENSIONS; j++) {
+				centroids_temp[k][j] = 0;
+			}
+		}
+		
+		// Iterate over all data points
+		for (i=0; i<SIZE; i++) {
+			
+			// Find the closest cluster
+			min_distance[0] = DBL_MAX;
+			for (k=0; k<NUM_CLUSTERS; k++) {
+				distance[0] = 0;
+				for (j=0; j<DIMENSIONS; j++) {
+					distance[0] += pow(input[i][j]-centroids[k][j],2);
+				}
+				if (distance[0] < min_distance[0]) {
+					output[i] = k;
+					min_distance[0] = distance[0];
+				}
+			}
+			
+			// Update the size and temporary centroid of the destination cluster
+			for (j=0; j<DIMENSIONS; j++) {
+				centroids_temp[output[i]][j] += input[i][j];
+			}
+			counts[output[i]] += 1;
+			
+			// Store the resulting distance
+			distances[i] = min_distance[0];
+		}
+		
+		// Update the standard error
+		for (i=0; i<SIZE; i++) {
+			error += distances[i];
+		}
+		
+		// Update all centroids
+		for (k=0; k<NUM_CLUSTERS; k++) {
+			for (j=0; j<DIMENSIONS; j++) {
+				if (counts[k]) {
+					centroids[k][j] = centroids_temp[k][j] / counts[k];
+				}
+				else {
+					centroids[k][j] = centroids_temp[k][j];
+				}
+			}
+		}
+		
+		// Go to the next iteration
+		iterations += 1;
+		
+		#pragma endscop
+	} while (fabs(error-old_error) > THRESHOLD);
+	
+	// Print the results
+	printf("\n[k-means] Algorithm finished in %d iterations with an error of %.3lf", iterations, error); fflush(stdout);
+	printf("\n[k-means] Printing the results: \n\n"); fflush(stdout);
+	for (k=0; k<NUM_CLUSTERS; k++) {
+		printf("Cluster %2i: ", k);
+		for (i=0; i<SIZE; i++) {
+			if (output[i] == k) {
+				printf("%3i ", i);
+			}
+		}
+		printf("\n");
+	}
+	
+	// Clean-up and exit the function
+	printf("\n[k-means] Completed\n\n"); fflush(stdout);
+	fflush(stdout);
+	return 0;
+}
+
+//########################################################################

data/examples/benchmarks/Rodinia/srad.c

@@ -0,0 +1,188 @@
+//
+// This file is part of the Bones source-to-source compiler examples. This C-code
+// demonstrates the use of Bones for an example application: 'Speckle Reducing
+// Anisotropic Diffusion' or 'SRAD', taken from the Rodinia benchmark suite. For
+// more information on the application or on Bones please use the contact infor-
+// mation below.
+//
+// == More information on SRAD (Speckle Reducing Anisotropic Diffusion):
+// Article............http://dx.doi.org/10.1109/TIP.2002.804276
+// 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/srad.c
+// Authors............Cedric Nugteren
+// Original authors...Rob Janiczek, Drew Gilliam, Lukasz Szafaryn
+// Last modified on...10-Aug-2012
+//
+
+//########################################################################
+//### 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
+
+//########################################################################
+//### Start of the main function
+//########################################################################
+
+int main(void) {
+	
+	// Declare the loop iterators
+	int i,j,iter;
+	
+	// Declare domain variables
+	float mean_roi, var_roi;
+	float q0s, qs;
+	float divergence;
+	float cN, cS, cW, cE;
+	float G2, L;
+	
+	// Declare other/helper variables
+	int index;
+	float temp_value;
+	float sum1, sum2;
+	float current_value;
+	float temp_a, temp_b;
+	
+	// Check for valid row and column sizes
+	if ((ROWS%16 != 0 ) || (COLS%16 != 0)) {
+		printf("[srad] Error: the number of rows and columns must be multiples of 16\n");
+		fflush(stdout); exit(1);
+	}
+	
+	// Initialising memory
+	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);
+	
+	// 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);
+		}
+	}
+	
+	// Perform the computation a given number of times
+	printf("\n[srad] Performing the computation %d times",NITER); fflush(stdout);
+	for (iter=0; iter<NITER; iter++) {
+		
+		// Compute the mean, the variance and the speckle scale function (q0s) of the region of interest (ROI)
+		sum1 = 0;
+		sum2 = 0;
+		for (i=R1; i<=R2; i++) {
+			for (j=C1; j<=C2; j++) {
+				temp_value = values[i*COLS+j];
+				sum1 += temp_value;
+				sum2 += temp_value*temp_value;
+			}
+		}
+		mean_roi = sum1/size_roi;
+		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
+		for (i=0; i<ROWS; i++) {
+			for (j=0; j<COLS; j++) {
+				index = i*COLS+j;
+				current_value = values[index];
+
+				// 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; }
+
+				// 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              );
+				temp_a = (0.5*G2)-((1.0/16.0)*(L*L));
+				temp_b = 1+(0.25*L);
+				qs = temp_a/(temp_b*temp_b);
+
+				// Set the diffusion coefficent (equation 33)
+				coefficent[index] = 1.0 / (1.0+( (qs-q0s)/(q0s*(1+q0s)) ));
+
+				// Saturate the diffusion coefficent
+				if (coefficent[index] < 0) {
+					coefficent[index] = 0;
+				}
+				else if (coefficent[index] > 1) {
+					coefficent[index] = 1;
+				}
+			}
+		}
+		
+		// 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    ];
+				if (i==ROWS-1) { cS = 0; }
+				else           { cS = coefficent[(i+1)*COLS+j    ]; }
+				                 cW = coefficent[i    *COLS+j    ];
+				if (j==COLS-1) { cE = 0; }
+				else           { cE = coefficent[i    *COLS+(j+1)]; }
+
+				// Calculate the divergence (equation 58)
+				divergence = cN*dN[index] + cS*dS[index] + cW*dW[index] + cE*dE[index];
+
+				// Update the image accordingly (equation 61)
+				values[index] = values[index] + 0.25*LAMBDA*divergence;
+			}
+		}
+		#pragma endscop
+	}
+	
+	// Print the values matrix
+	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]);
+		}
+		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);
+	fflush(stdout);
+	return 0;
+}
+
+//########################################################################