bones-compiler 1.3.1 → 1.6.0

data/examples/benchmarks/Rodinia/common.h

@@ -0,0 +1,78 @@
+
+//########################################################################
+//### Includes
+//########################################################################
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+#include <float.h>
+
+//########################################################################
+//### Hotspot
+//########################################################################
+
+// Parameters
+#define GRID_ROWS 512                                       // Number of rows in the grid (positive integer)
+#define GRID_COLS 512                                       // Number of columns in the grid (positive integer)
+#define SIM_TIME 10                                         // Number of iterations
+#define TEMPERATURE_FILE "data/hotspot_temperature_512.txt" // Name of the file containing the initial temperature values of each cell
+#define POWER_FILE "data/hotspot_power_512.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
+
+//########################################################################
+//### Srad
+//########################################################################
+
+// Defines
+#define ROWS 256    // Number of ROWS in the domain
+#define COLS 256    // 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 4     // Number of iterations
+
+//########################################################################
+//### Pathfinder
+//########################################################################
+
+// Configuration
+#define PATHCOLS 100000
+#define PATHROWS 100
+
+// Seed
+#define M_SEED 9
+
+//########################################################################
+//### Kmeans
+//########################################################################
+
+#define SIZE (494020)
+#define NUM_CLUSTERS 20
+#define DIMENSIONS 2
+#define THRESHOLD 0.001
+
+//########################################################################
+//### BFS
+//########################################################################
+
+// Settings
+#define MAX_NODES 1000000
+
+// Config
+#define FILENAME "/home/cnugteren/software/rodinia_2.4/data/bfs/graph1MW_6.txt"
+
+//########################################################################

data/examples/benchmarks/Rodinia/hotspot.c

@@ -15,47 +15,12 @@
 // == File information
 // Filename...........applications/hotspot.c
 // Authors............Cedric Nugteren
-// Last modified on...10-Aug-2012
+// Last modified on...06-Jun-2014
 //
-
-//########################################################################
-//### 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);
+// Includes
+#include "common.h"
 
 //########################################################################
 //### Start of the main function
@@ -64,15 +29,13 @@ void read_input(double* array, const char* filename);
 int main(void) {
 	
 	// Declare the loop iterators
-	int r,c,iter;
+	int r,c;
+	int iter = 0;
 	
 	// 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;
+	double grid_height = CHIP_HEIGHT/GRID_ROWS;
+	double grid_width = CHIP_WIDTH/GRID_COLS;
 	
 	// Set domain variables
 	double cap = FACTOR_CHIP*SPEC_HEAT_SI*T_CHIP*grid_width*grid_height;
@@ -84,14 +47,38 @@ int main(void) {
 	
 	// 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));
+	double temperature[GRID_ROWS][GRID_COLS];
+	double power[GRID_ROWS][GRID_COLS];
+	double result[GRID_ROWS][GRID_COLS];
 	
-	// Read initial temperature and power arrays
+	// Read initial temperature array
 	printf("\n[hotspot] Populating memory"); fflush(stdout);
-	read_input(temperature, TEMPERATURE_FILE);
-	read_input(power, POWER_FILE);
+	char string[STRING_SIZE];
+	double value;
+	FILE* file_pointer1 = fopen(TEMPERATURE_FILE, "r");
+	if (!file_pointer1) { printf("\n[hotspot] Error: file '%s' could not be opened for reading\n\n", TEMPERATURE_FILE); fflush(stdout); exit(1); }
+	for (r=0; r<GRID_ROWS; r++) {
+		for (c=0; c<GRID_COLS; c++) {
+			fgets(string, STRING_SIZE, file_pointer1);
+			if (feof(file_pointer1))                    { printf("\n[hotspot] Error: not enough lines in file '%s'\n\n", TEMPERATURE_FILE); fflush(stdout); exit(1); }
+			if ((sscanf(string, "%lf", &value) != 1) ) { printf("\n[hotspot] Error: invalid file format for '%s'\n\n", TEMPERATURE_FILE); fflush(stdout); exit(1); }
+			temperature[r][c] = value;
+		}
+	}
+	fclose(file_pointer1);
+
+	// Read initial power array
+	FILE* file_pointer2 = fopen(POWER_FILE, "r");
+	if (!file_pointer2) { printf("\n[hotspot] Error: file '%s' could not be opened for reading\n\n", POWER_FILE); fflush(stdout); exit(1); }
+	for (r=0; r<GRID_ROWS; r++) {
+		for (c=0; c<GRID_COLS; c++) {
+			fgets(string, STRING_SIZE, file_pointer2);
+			if (feof(file_pointer2))                    { printf("\n[hotspot] Error: not enough lines in file '%s'\n\n", POWER_FILE); fflush(stdout); exit(1); }
+			if ((sscanf(string, "%lf", &value) != 1) ) { printf("\n[hotspot] Error: invalid file format for '%s'\n\n", POWER_FILE); fflush(stdout); exit(1); }
+			power[r][c] = value;
+		}
+	}
+	fclose(file_pointer2);
 	
 	// Perform the computation a given number of times
 	printf("\n[hotspot] Performing the computation %d times",SIM_TIME); fflush(stdout);
@@ -100,100 +87,112 @@ int main(void) {
 		
 		// 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++) {
+		for (r=0; r<GRID_ROWS; r++) {
+			for (c=0; c<GRID_COLS; c++) {
+
+				// Load the temperatures from memory
+				double temp_r_c = temperature[r][c];
+				double temp_rp1_c = 0;
+				if (r < GRID_ROWS-1) { temp_rp1_c = temperature[r+1][c]; }
+				double temp_rm1_c = 0;
+				if (r > 0) { temp_rm1_c = temperature[r-1][c]; }
+				double temp_r_cp1 = 0;
+				if (c < GRID_COLS-1) { temp_r_cp1 = temperature[r][c+1]; }
+				double temp_r_cm1 = 0;
+				if (c > 0) { temp_r_cm1 = temperature[r][c-1]; }
+
+				// Load the power
+				double power_r_c = power[r][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);
+					delta = (step / cap) * (power_r_c + 
+						(temp_r_cp1 - temp_r_c) / Rx + 
+						(temp_rp1_c - temp_r_c) / Ry + 
+						(AMB_TEMP   - temp_r_c) / 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);
+				else if ((r == 0) && (c == GRID_COLS-1)) {
+					delta = (step / cap) * (power_r_c + 
+						(temp_r_cm1 - temp_r_c) / Rx + 
+						(temp_rp1_c - temp_r_c) / Ry + 
+						(AMB_TEMP   - temp_r_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);
+				else if ((r == GRID_ROWS-1) && (c == GRID_COLS-1)) {
+					delta = (step / cap) * (power_r_c + 
+						(temp_r_cm1 - temp_r_c) / Rx + 
+						(temp_rm1_c - temp_r_c) / Ry + 
+						(AMB_TEMP   - temp_r_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);
+				else if ((r == GRID_ROWS-1) && (c == 0)) {
+					delta = (step / cap) * (power_r_c + 
+						(temp_r_cp1 - temp_r_c) / Rx + 
+						(temp_rm1_c - temp_r_c) / Ry + 
+						(AMB_TEMP   - temp_r_c) / 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);
+					delta = (step / cap) * (power_r_c + 
+						(temp_r_cp1 + temp_r_cm1 - 2.0*temp_r_c) / Rx + 
+						(temp_rp1_c              -     temp_r_c) / Ry + 
+						(AMB_TEMP                -     temp_r_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);
+				else if (c == GRID_COLS-1) {
+					delta = (step / cap) * (power_r_c + 
+						(temp_rp1_c + temp_rm1_c - 2.0*temp_r_c) / Ry + 
+						(temp_r_cm1              -     temp_r_c) / Rx + 
+						(AMB_TEMP                -     temp_r_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);
+				else if (r == GRID_ROWS-1) {
+					delta = (step / cap) * (power_r_c + 
+						(temp_r_cp1 + temp_r_cm1 - 2.0*temp_r_c) / Rx + 
+						(temp_rm1_c              -     temp_r_c) / Ry + 
+						(AMB_TEMP                -     temp_r_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);
+					delta = (step / cap) * (power_r_c + 
+						(temp_rp1_c + temp_rm1_c - 2.0*temp_r_c) / Ry + 
+						(temp_r_cp1              -     temp_r_c) / Rx + 
+						(AMB_TEMP                -     temp_r_c) / 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);
+					delta = (step / cap) * (power_r_c + 
+						(temp_rp1_c + temp_rm1_c - 2.0*temp_r_c) / Ry + 
+						(temp_r_cp1 + temp_r_cm1 - 2.0*temp_r_c) / Rx + 
+						(AMB_TEMP                -     temp_r_c) / Rz);
 				}
 			
 			// Update the temperatures
-			result[r*col+c] = temperature[r*col+c] + delta;
+			result[r][c] = temperature[r][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];
+		for (r=0; r<GRID_ROWS; r++) {
+			for (c=0; c<GRID_COLS; c++) {
+				temperature[r][c] = result[r][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");
-	}
+	//printf("\n[hotspot] Printing the final temperatures:\n\n"); fflush(stdout);
+	//for (r=0; r<GRID_ROWS; r++) {
+	//	for (c=0; c<GRID_COLS; c++) {
+	//		printf("%6d: %.3lf ", r*GRID_COLS+c, temperature[r][c]);
+	//	}
+	//	printf("\n");
+	//}
 	
 	// Clean-up and exit
 	printf("\n[hotspot] Completed\n\n"); fflush(stdout);
-	free(temperature); free(power); free(result);
 	fflush(stdout);
 	return 0;
 }
@@ -202,27 +201,8 @@ int main(void) {
 //### 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;
+void read_input(double array[GRID_ROWS][GRID_COLS], const char* filename) {
 
-	// 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

@@ -1,164 +1,157 @@
-//
-// 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;
-}
-
-//########################################################################
+//
+// 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...06-Jun-2014
+//
+//########################################################################
+
+// Includes
+#include "common.h"
+
+//########################################################################
+//### Start of the main function
+//########################################################################
+int main(void) {
+	
+	// Declare the loop iterators
+	int i,j,k;
+	
+	// Declare the error variables
+	float error[1] = { 100000.0 };
+	float old_error;
+	int iterations = 0;
+	
+	// Declare the distance variables and arrays
+	float distances[SIZE];
+	
+	// Initialising memory
+	printf("\n[k-means] Initialising memory"); fflush(stdout);
+	float input[SIZE][DIMENSIONS];
+	float centroids[NUM_CLUSTERS][DIMENSIONS];
+	float 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 {
+	//for (int iters=0; iters<10; iters++) {
+		
+		// Start of the scop
+		#pragma scop
+		
+		// Save the error from the last step
+		old_error = error[0];
+		error[0] = 0;
+
+		// Clear old counts and temporary centroids
+		for (k=0; k<NUM_CLUSTERS; k++) {
+			counts[k] = 0;
+		}
+		for (k=0; k<NUM_CLUSTERS; k++) {
+			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
+			float min_distance = 100000.0;
+			for (k=0; k<NUM_CLUSTERS; k++) {
+				float distance = 0;
+				for (j=0; j<DIMENSIONS; j++) {
+					float val = (input[i][j]-centroids[k][j]);
+					distance += val * val;
+				}
+				if (distance < min_distance) {
+					output[i] = k;
+					min_distance = distance;
+				}
+			}
+			
+			// Update the size and temporary centroid of the destination cluster
+			int cluster_index = output[i];
+			for (j=0; j<DIMENSIONS; j++) {
+				centroids_temp[cluster_index][j] += input[i][j];
+			}
+			counts[cluster_index] += 1;
+			
+			// Store the resulting distance
+			distances[i] = min_distance;
+		}
+		
+		// Update the standard error
+		for (i=0; i<SIZE; i++) {
+			error[0] += distances[i];
+		}
+		
+		// Update all centroids
+		for (k=0; k<NUM_CLUSTERS; k++) {
+			for (j=0; j<DIMENSIONS; j++) {
+				int count = counts[k];
+				float val;
+				if (count > 0) {
+					val = centroids_temp[k][j] / count;
+				}
+				else {
+					val = centroids_temp[k][j];
+				}
+				centroids[k][j] = val;
+			}
+		}
+		
+		// Go to the next iteration
+		iterations += 1;
+		#pragma endscop
+	//}
+	} while (fabs(error[0]-old_error) > THRESHOLD);
+	
+	// Print the results
+	printf("\n[k-means] Algorithm finished in %d iterations with an error of %.3lf", iterations, error[0]); 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;
+}
+//########################################################################