bones-compiler 1.3.1 → 1.6.0

data/CHANGELOG

@@ -1,3 +1,65 @@
+###################
+### v1.6.0      ###
+###################
+
+General:
+- Add support for multiple scops in a file
+
+Bug fixes:
+- Fixed mismatch in kernel arguments of the OpenMP D-element-to-1 skeleton
+- Fixed the empty-scop bug in A-Darwin
+
+Miscellaneous:
+- Updated the documentation to include the latest Bones publication "Bones: An Automatic Skeleton-Based C-to-CUDA Compiler for GPUs"
+
+###################
+### v1.5.0c     ###
+###################
+
+Bug fixes:
+- Remove CAST gem, only include fixes
+- Update examples and tests
+
+###################
+### v1.5.0b     ###
+###################
+
+Bug fixes:
+- Fix filename parsing when directory or filename contains a '.'
+- Include updated CAST gem in bones which preserves literal suffixes
+
+###################
+### v1.5        ###
+###################
+
+Bug fixes:
+- Adjusted the examples to include pragma scop and named species (to make them work again with Bones)
+- Fixed a bug where input/output variables of species with 'shared' where not properly handled
+- Removed warning from Rakefile
+- Fixed a bug requiring Bones to be executed from the folder containing the 'lib' directory
+- Fixed a filename issue on non-Unix systems
+- The pre-processor now understands block-comments
+
+Various:
+- Added .gitignore file
+- Improved clarity of Rakefile stub targets
+- Improved error handling of incorrect names
+- Improved error handling of incorrect species
+
+###################
+### v1.4        ###
+###################
+
+A-Darwin:
+- Handles additional cases of copyin/out-to-outer-loop movement
+
+Skeletons:
+- Improved performance of the memory-copy thread ('scheduler')
+- Minor changes to skeletons mapping file
+
+Examples:
+- Added 6 examples benchmarks from the Rodinia suite
+
 ###################
 ### v1.3        ###
 ###################

data/README.rdoc

@@ -116,7 +116,18 @@ Code documentation can be generated automatically using RDoc. Navigate to the in
 == Scientific publications
 Scientific publications related to Bones/A-Darwin can be obtained from http://www.cedricnugteren.nl/publications. Several publications are relevant:
 
-1. <b>Algorithmic Species Revisited: A Program Code Classification Based on Array References</b>, which provides details on the algorithm classification (the species) and A-Darwin (the tool). When refering to the algorithm classification in scientific work, you are kindly asked to include the following citation:
+1. <b>Bones: An Automatic Skeleton-Based C-to-CUDA Compiler for GPUs</b>, which provides details on the Bones source-to-source compiler, including optimizations in host-accelerator transfer and loop fusion in kernel code. When referring to GPU code generation using Bones, loop fusion or optimizations in host-accelerator transfer in scientific work, you are kindly asked to include the following citation:
+
+    @INPROCEEDINGS{Nugteren2015a,
+       author = {Cedric Nugteren and and Henk Corporaal},
+       title = {Bones: An Automatic Skeleton-Based C-to-CUDA Compiler for GPUs},
+       journal = {ACM Trans. Archit. Code Optim.},
+       volume = {11},
+       number = {4},
+       year = {2015},
+    }
+
+2. <b>Algorithmic Species Revisited: A Program Code Classification Based on Array References</b>, which provides details on the algorithm classification (the species) and A-Darwin (the tool). When referring to the algorithm classification in scientific work, you are kindly asked to include the following citation:
 
     @INPROCEEDINGS{Nugteren2013a,
        author = {Cedric Nugteren and Rosilde Corvino and Henk Corporaal},
@@ -125,7 +136,7 @@ Scientific publications related to Bones/A-Darwin can be obtained from http://ww
        year = {2013},
     }
 
-2. <b>Automatic Skeleton-Based Compilation through Integration with an Algorithm Classification</b>, which discusses the Bones source-to-source compiler. When refering to Bones in scientific work, you are kindly asked to include the following citation:
+3. <b>Automatic Skeleton-Based Compilation through Integration with an Algorithm Classification</b>, which discusses the Bones source-to-source compiler. When referring to Bones in scientific work, you are kindly asked to include the following citation:
 
     @INPROCEEDINGS{Nugteren2013b,
       author    = {Cedric Nugteren and Pieter Custers and Henk Corporaal},
@@ -148,4 +159,4 @@ With rake, A-Darwin can be tested on a set of examples '<tt>rake adarwin_test</t
 
 
 = Questions
-Questions can be directed by email. You can find contact details on the personal page of the author at http://www.cedricnugteren.nl/ or http://parse.ele.tue.nl/cnugteren/ or on the project page at github.
+Questions can be directed by email. You can find contact details on the personal page of the author at http://www.cedricnugteren.nl/ or on the project page at GitHub.

data/Rakefile

@@ -37,7 +37,7 @@ TARGET = TARGETS[0]
 MEASUREMENTS = true
 VERIFICATION = false
 MEMORY_OPTIMISATIONS = true
-ADARWIN_OPTIONS = MEMORY_OPTIMISATIONS ? '-r -f -b -l' : ''
+ADARWIN_OPTIONS_BONES = MEMORY_OPTIMISATIONS ? '-r -f -b -l' : ''
 
 # Small helper function to display text on screen
 def display(text)
@@ -62,7 +62,7 @@ namespace :examples do
 		bones_options = (MEASUREMENTS ? '-m ' : '') + (VERIFICATION ? '-c ' : '')
 		args.with_defaults(:file => EXAMPLES)
 		Dir[args.file].sort.each do |file|
-			sh "bin/adarwin -a #{file} #{ADARWIN_OPTIONS}"
+			sh "bin/adarwin -a #{file} #{ADARWIN_OPTIONS_BONES}"
 			split = file.split('.')
 			file = split[0]+'_species'+'.'+split[1]
 			sh "bin/bones -a #{file} -t #{TARGET} #{bones_options}"
@@ -100,15 +100,15 @@ namespace :examples do
 		end
 	end
 
-	# Helper function to compile code
-	#def compile(file,target)
-		# (system-specific, to be filled in by the user)
-	#end
+	# Helper function to compile code (NOTE: this task is a stub)
+	def compile(file,target)
+		puts "[Rake] ### Compiling the code is system-specific, to be filled in..."
+	end
 
-	# Helper function to execute code
-	#def execute(file,target)
-		# (system-specific, to be filled in by the user)
-	#end
+	# Helper function to execute code (NOTE: this task is a stub)
+	def execute(file,target)
+		puts "[Rake] ### Executing the code is system-specific, to be filled in..."
+	end
 	
 end
 task :examples => ['examples:generate']
@@ -172,11 +172,12 @@ end
 
 # Generate HTML documentation using RDoc
 RDoc::Task.new do |rdoc|
-	rdoc.title = 'Bones'
+	version = File.read('VERSION')
+	rdoc.title = 'Bones - %s' % version
 	rdoc.options << '--line-numbers'
 	rdoc.rdoc_files.include(File.join('lib','**','*.rb'))
 	rdoc.rdoc_files.include('README.rdoc')
+	rdoc.rdoc_files.include('VERSION')
 	rdoc.rdoc_dir = 'rdoc'
 	rdoc.main = 'README.rdoc'
 end
-

data/VERSION

@@ -1 +1 @@
-1.3.1
+1.6.0

data/examples/applications/ffos.c

@@ -15,7 +15,7 @@
 // == File information
 // Filename...........applications/ffos.c
 // Author.............Cedric Nugteren
-// Last modified on...22-May-2012
+// Last modified on...11-October-2014
 //
 
 //########################################################################
@@ -104,13 +104,15 @@ int main(void) {
 	//########################################################################
 	if (messages >= 1) { printf("### PART1: Histogramming.\n"); fflush(stdout); }
 	
-	#pragma species kernel 0:height-1,0:width-1|element -> 0:255|shared
+	#pragma scop
+	#pragma species kernel image0[0:height-1,0:width-1]|element -> hist[0:255]|shared
 	for (h=0;h<height;h++) {
 		for (w=0;w<width;w++) {
 			hist[image0[h][w]] = hist[image0[h][w]] + 1;
 		}
 	}
 	#pragma species endkernel histogram
+	#pragma endscop
 	
 	//########################################################################
 	//### Between class variance (CPU)
@@ -168,14 +170,22 @@ int main(void) {
 	//########################################################################
 	if (messages >= 1) { printf("### PART4: Binarization with treshold at %d.\n",threshold); fflush(stdout); }
 	
-	#pragma species kernel 0:height-1,0:width-1|element -> 0:height-1,0:width-1|element
+	unsigned char val;
+	#pragma scop
+	#pragma species kernel image0[0:height-1,0:width-1]|element -> image1[0:height-1,0:width-1]|element
 	for (h=0;h<height;h++) {
 		for (w=0;w<width;w++) {
-			if (image0[h][w] > threshold) { image1[h][w] = 1; }
-			else {                          image1[h][w] = 0; }
+			if (image0[h][w] > threshold) {
+				val = 1;
+			}
+			else {
+				val = 0;
+			}
+			image1[h][w] = val;
 		}
 	}
 	#pragma species endkernel threshold
+	#pragma endscop
 	
 	//########################################################################
 	//### PART5: Erosion 7x7 (accelerated)
@@ -183,7 +193,8 @@ int main(void) {
 	if (messages >= 1) { printf("### PART5: Perform the erode kernel.\n"); fflush(stdout); }
 	
 	int condition;
-	#pragma species kernel 7:height-8,7:width-8|neighbourhood(-3:3,-3:3) -> 0:height-1,0:width-1|element
+	#pragma scop
+	#pragma species kernel image1[7:height-8,7:width-8]|neighbourhood(-3:3,-3:3) -> image2[0:height-1,0:width-1]|element
 	for (h=0;h<height;h++) {
 		for (w=0;w<width;w++) {
 			if (w >= 7 && h >= 7 && w <= width-7 && h <= height-7) {
@@ -208,6 +219,7 @@ int main(void) {
 		}
 	}
 	#pragma species endkernel erosion
+	#pragma endscop
 	
 	//########################################################################
 	//### PART6: 1D erosion(7) synthetic example (accelerated)
@@ -251,7 +263,8 @@ int main(void) {
 	if (messages >= 1) { printf("### PART7: Starting the Y-projection algorithm.\n"); fflush(stdout); }
 	
 	int result_yp;
-	#pragma species kernel 0:height-1,0:width-1|chunk(0:height-1,0:0) -> 0:width-1|element
+	#pragma scop
+	#pragma species kernel image2[0:height-1,0:width-1]|chunk(0:height-1,0:0) -> Yvector[0:width-1]|element
 	for (w=0;w<width;w++) {
 		result_yp = 0;
 		for (h=0;h<height;h++) {
@@ -262,6 +275,7 @@ int main(void) {
 		Yvector[w] = result_yp;
 	}
 	#pragma species endkernel y_projection
+	#pragma endscop
 	
 	//########################################################################
 	//### PART8: X-projection (accelerated)
@@ -269,7 +283,8 @@ int main(void) {
 	if (messages >= 1) { printf("### PART8: Starting the X-projection algorithm.\n"); fflush(stdout); }
 	
 	int result_xp;
-	#pragma species kernel 0:height-1,0:width-1|chunk(0:0,0:width-1) -> 0:height-1|element
+	#pragma scop
+	#pragma species kernel image2[0:height-1,0:width-1]|chunk(0:0,0:width-1) -> Xvector[0:height-1]|element
 	for (h=0;h<height;h++) {
 		result_xp = 0;
 		for (w=0;w<width;w++) {
@@ -280,6 +295,7 @@ int main(void) {
 		Xvector[h] = result_xp;
 	}
 	#pragma species endkernel x_projection
+	#pragma endscop
 	
 	//########################################################################
 	//### Search for the centers of the projection vectors (CPU)

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

@@ -43,8 +43,10 @@ int main(void) {
 	#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++) {
-			B[i] = 0.33333 * (A[i-1] + A[i] + A[i+1]);
+		for (i=0; i<LARGE_N; i++) {
+			if (i > 0 && i < LARGE_N-1) {
+				B[i] = 0.33333 * (A[i-1] + A[i] + A[i+1]);
+			}
 		}
 		#pragma species endkernel jacobi-1d-imper-part1
 		#pragma species kernel 1:LARGE_N-2|element -> 1:LARGE_N-2|element

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

@@ -42,7 +42,7 @@ int main(void) {
 		#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++) {
-				if (i < N-1 && j < N-1) {
+				if (i > 0 && j > 0 && 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]);
 				}
 			}

data/examples/benchmarks/Rodinia/bfs.c

@@ -0,0 +1,143 @@
+//
+// This file is part of the Bones source-to-source compiler examples. This C-code
+// demonstrates the use of Bones for an example application: 'bfs', 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/bfs.c
+// Authors............Cedric Nugteren
+// Last modified on...08-Jun-2014
+//
+//########################################################################
+
+// Includes
+#include "common.h"
+
+//########################################################################
+//### Start of the main function
+//########################################################################
+
+int main(void) {
+	int no_of_nodes;
+
+	// Read input data
+	printf("[bfs] Reading File\n");
+	FILE* fp = fopen(FILENAME, "r");
+	if (!fp) {
+		printf("[bfs] Error Reading graph file\n");
+		return 1;
+	}
+	fscanf(fp,"%d",&no_of_nodes);
+
+	// Arrays
+	int h_graph_nodes_start[MAX_NODES];
+	int h_graph_nodes_edges[MAX_NODES];
+	int h_graph_mask[MAX_NODES];
+	int h_updating_graph_mask[MAX_NODES];
+	int h_graph_visited[MAX_NODES];
+
+	// Initialize
+	int start;
+	int edges;
+	for (int i=0; i<no_of_nodes; i++) {
+		fscanf(fp, "%d %d", &start, &edges);
+		h_graph_nodes_start[i] = start;
+		h_graph_nodes_edges[i] = edges;
+		h_graph_mask[i] = 0;
+		h_updating_graph_mask[i] = 0;
+		h_graph_visited[i] = 0;
+	}
+
+	// Read the source node from the file
+	int source = 0;
+	fscanf(fp, "%d", &source);
+	source = 0;
+
+	// Set the source node as true in the mask
+	h_graph_mask[source] = 1;
+	h_graph_visited[source] = 1;
+
+	// Get the edge list
+	int id;
+	int cost;
+	int edge_list_size;
+	fscanf(fp,"%d",&edge_list_size);
+	int h_graph_edges[MAX_NODES];
+	for(int i=0; i<edge_list_size; i++) {
+		fscanf(fp, "%d", &id);
+		fscanf(fp, "%d", &cost);
+		h_graph_edges[i] = id;
+	}
+
+	// Memory for the result
+	int h_cost[MAX_NODES];
+	for(int i=0; i<MAX_NODES; i++) {
+		h_cost[i] = -1;
+	}
+	h_cost[source] = 0;
+	
+	// Start the computation
+	printf("[bfs] Start traversing the tree\n");
+	int k = 0;
+	int stop[1];
+
+	// If no thread changes this value then the loop stops
+	stop[0] = 0;
+
+	#pragma scop
+	for (unsigned t=0; t<10; t++) {
+	//do {
+
+		// Atomic update loop
+		for(int tid=0; tid<no_of_nodes; tid++) {
+			int val1 = h_graph_mask[tid];
+			if (val1 == 1) { 
+				h_graph_mask[tid] = 0;
+				int val2 = h_graph_nodes_start[tid];
+				int val3 = h_graph_nodes_edges[tid];
+				for (int i=val2; i<(val3 + val2); i++) {
+					int id = h_graph_edges[i];
+					int val4 = h_graph_visited[id];
+					if (val4 == 0) {
+						h_cost[id] = h_cost[tid] + 1;
+						h_updating_graph_mask[id] = 1;
+					}
+				}
+			}
+		}
+
+		// Atomic update loop
+		for (int tid=0; tid<no_of_nodes; tid++) {
+			int val1 = h_updating_graph_mask[tid];
+			if (val1 == 1) {
+				h_graph_mask[tid] = 1;
+				h_graph_visited[tid] = 1;
+				h_updating_graph_mask[tid] = 0;
+				stop[0] = 1;
+			}
+		}
+
+		// Next iteration
+		//k++;
+	//} while(stop[0] != 0);
+	}
+	#pragma endscop
+
+	// Clean-up and exit
+	if (fp) {
+		fclose(fp);
+	}
+	printf("\n[bfs] Completed\n\n"); fflush(stdout);
+	fflush(stdout);
+	return 0;
+}
+
+//########################################################################