bones-compiler 1.1.0

data/skeletons/GPU-OPENCL-AMD/kernel/D-element-to-1-shared.host.c

@@ -0,0 +1,67 @@
+  
+  // Store the initial value
+  cl_mem bones_initial_value = clCreateBuffer(bones_context,CL_MEM_READ_WRITE|CL_MEM_COPY_HOST_PTR,sizeof(<out0_type>),<out0_name>,&bones_errors); error_check(bones_errors);
+  
+  // Create the kernels
+  cl_kernel bones_kernel_<algorithm_name>_0 = clCreateKernel(bones_program, "bones_kernel_<algorithm_name>_0", &bones_errors); error_check(bones_errors);
+  cl_kernel bones_kernel_<algorithm_name>_1 = clCreateKernel(bones_program, "bones_kernel_<algorithm_name>_1", &bones_errors); error_check(bones_errors);
+  cl_kernel bones_kernel_<algorithm_name>_2 = clCreateKernel(bones_program, "bones_kernel_<algorithm_name>_2", &bones_errors); error_check(bones_errors);
+  
+  // Run either one kernel or multiple kernels
+  if (<in0_dimensions> <= 512) {
+    
+    // Set all the arguments to the kernel function
+    int bones_num_args = 3;
+    int bones_dimensions = <in0_dimensions>;
+    clSetKernelArg(bones_kernel_<algorithm_name>_0,0,sizeof(bones_dimensions),(void*)&bones_dimensions);
+    clSetKernelArg(bones_kernel_<algorithm_name>_0,1,sizeof(<in0_devicename>),(void*)&<in0_devicename>);
+    clSetKernelArg(bones_kernel_<algorithm_name>_0,2,sizeof(<out0_devicename>),(void*)&<out0_devicename>);
+    <kernel_argument_list_constants>
+    // Start only one kernel
+    const int bones_num_threads = DIV_CEIL(<in0_dimensions>,2);
+    size_t bones_local_worksize1[] = {bones_num_threads};
+    size_t bones_global_worksize1[] = {bones_num_threads};
+    bones_errors = clEnqueueNDRangeKernel(bones_queue,bones_kernel_<algorithm_name>_0,1,NULL,bones_global_worksize1,bones_local_worksize1,0,NULL,&bones_event); error_check(bones_errors);
+    
+  }
+  else {
+    
+    // Allocate space for an intermediate array
+    cl_mem bones_device_temp = clCreateBuffer(bones_context,CL_MEM_READ_WRITE,128*sizeof(<out0_type>),NULL,&bones_errors); error_check(bones_errors);
+    
+    // Set all the arguments to the kernel function
+    int bones_num_args = 3;
+    int bones_dimensions = <in0_dimensions>;
+    clSetKernelArg(bones_kernel_<algorithm_name>_0,0,sizeof(bones_dimensions),(void*)&bones_dimensions);
+    clSetKernelArg(bones_kernel_<algorithm_name>_0,1,sizeof(<in0_devicename>),(void*)&<in0_devicename>);
+    clSetKernelArg(bones_kernel_<algorithm_name>_0,2,sizeof(bones_device_temp),(void*)&bones_device_temp);
+    <kernel_argument_list_constants>
+    // Start the first kernel
+    size_t bones_local_worksize1[] = {256};
+    size_t bones_global_worksize1[] = {256*128};
+    bones_errors = clEnqueueNDRangeKernel(bones_queue,bones_kernel_<algorithm_name>_0,1,NULL,bones_global_worksize1,bones_local_worksize1,0,NULL,&bones_event); error_check(bones_errors);
+    
+    // Set all the arguments to the kernel function
+    clSetKernelArg(bones_kernel_<algorithm_name>_1,0,sizeof(bones_device_temp),(void*)&bones_device_temp);
+    clSetKernelArg(bones_kernel_<algorithm_name>_1,1,sizeof(<out0_devicename>),(void*)&<out0_devicename>);
+    // Start the second kernel
+    size_t bones_local_worksize2[] = {128};
+    size_t bones_global_worksize2[] = {128};
+    bones_errors = clEnqueueNDRangeKernel(bones_queue,bones_kernel_<algorithm_name>_1,1,NULL,bones_global_worksize2,bones_local_worksize2,0,NULL,&bones_event); error_check(bones_errors);
+    clReleaseMemObject(bones_device_temp);
+  }
+  
+  // Set all the arguments to the kernel function
+  clSetKernelArg(bones_kernel_<algorithm_name>_2,0,sizeof(bones_initial_value),(void*)&bones_initial_value);
+  clSetKernelArg(bones_kernel_<algorithm_name>_2,1,sizeof(<out0_devicename>),(void*)&<out0_devicename>);
+  // Perform the last computation (only needed if there is an initial value)
+  size_t bones_local_worksize3[] = {1};
+  size_t bones_global_worksize3[] = {1};
+  bones_errors = clEnqueueNDRangeKernel(bones_queue,bones_kernel_<algorithm_name>_2,1,NULL,bones_global_worksize3,bones_local_worksize3,0,NULL,&bones_event); error_check(bones_errors);
+  clReleaseMemObject(bones_initial_value);
+  
+  // Synchronize and clean-up the kernels
+  clFinish(bones_queue);
+  clReleaseKernel(bones_kernel_<algorithm_name>_0);
+  clReleaseKernel(bones_kernel_<algorithm_name>_1);
+  clReleaseKernel(bones_kernel_<algorithm_name>_2);

data/skeletons/GPU-OPENCL-AMD/kernel/D-element-to-1-shared.kernel.cl

@@ -0,0 +1,72 @@
+
+// Start of the <algorithm_name> kernel (main, not unrolled kernel)
+__kernel void bones_kernel_<algorithm_name>_0(int bones_input_size, __global <in0_type><in0_devicepointer> <in0_name>, __global <out0_type><out0_devicepointer> <out0_name>, <argument_definition>) {
+  const int bones_threadblock_work = DIV_CEIL(bones_input_size,get_num_groups(0));
+  const int bones_parallel_work = BONES_MIN(get_local_size(0),bones_threadblock_work);
+  const int bones_sequential_work = DIV_CEIL(bones_threadblock_work,bones_parallel_work);
+  const int bones_local_id = get_local_id(0);
+  const int bones_global_id = get_global_id(0);
+  <ids>
+  int bones_iter_id = <in0_flatindex>;
+  
+  // Load data into thread private memory and perform the first computation(s) sequentially
+  <in0_type> bones_temporary = <in0_name>[bones_iter_id];
+  <in0_type> bones_private_memory = <algorithm_code3>;
+  for(int c=1; c<bones_sequential_work; c++) {
+    bones_iter_id = bones_iter_id + bones_parallel_work*get_num_groups(0)<factors>;
+    if (bones_iter_id <= <in0_to>) {
+      bones_temporary = <in0_name>[bones_iter_id];
+      bones_private_memory = <algorithm_code1>;
+    }
+  }
+  // Initialize the local memory
+  volatile __local <in0_type> bones_local_memory[256];
+  bones_local_memory[bones_local_id] = bones_private_memory;
+  barrier(CLK_LOCAL_MEM_FENCE);
+  
+  // Perform the remainder of the computations in parallel using a parallel reduction tree
+  int bones_offset_id;
+  for (int c=256; c>=2; c=c>>1) {
+    if ((2*bones_parallel_work > c) && (get_local_id(0) < c/2)) {
+      bones_offset_id = get_local_id(0)+c/2;
+      if (bones_offset_id < bones_parallel_work) {
+        bones_local_memory[bones_local_id] = <algorithm_code2>;
+      }
+    }
+    barrier(CLK_LOCAL_MEM_FENCE);
+  }
+  
+  // Write the final result back to the global memory
+  if (get_local_id(0) == 0) { <out0_name>[get_group_id(0)] = bones_local_memory[0]; }
+}
+
+// Start of the <algorithm_name> kernel (secondary, not unrolled kernel)
+__kernel void bones_kernel_<algorithm_name>_1(__global <in0_type><in0_devicepointer> <in0_name>, __global <out0_type><out0_devicepointer> <out0_name>) {
+  const int bones_local_id = get_local_id(0);
+  const int bones_global_id = get_local_id(0);
+  
+  // Initialize the local memory
+  volatile __local <in0_type> bones_local_memory[128];
+  bones_local_memory[bones_local_id] = <in0_name>[bones_global_id];
+  barrier(CLK_LOCAL_MEM_FENCE);
+  
+  // Perform reduction using a parallel reduction tree
+  int bones_offset_id;
+  for (int c=128; c>=2; c=c>>1) {
+    if (get_local_id(0) < c/2) {
+      bones_offset_id = get_local_id(0)+c/2;
+      bones_local_memory[bones_local_id] = <algorithm_code2>;
+    }
+    barrier(CLK_LOCAL_MEM_FENCE);
+  }
+  
+  // Write the final result back to the global memory
+  if (get_local_id(0) == 0) { <out0_name>[0] = bones_local_memory[0]; }
+}
+
+// Start of the <algorithm_name> kernel (final, initial value kernel)
+__kernel void bones_kernel_<algorithm_name>_2(__global <out0_type><out0_devicepointer> bones_initial_value, __global <out0_type><out0_devicepointer> <out0_name>) {
+  <out0_type> bones_private_memory = <out0_name>[0];
+  <out0_type> bones_temporary = bones_initial_value[0];
+  <out0_name>[0] = <algorithm_code4>;
+}

data/skeletons/GPU-OPENCL-AMD/kernel/default.host.c

@@ -0,0 +1,14 @@
+  
+  // Create the kernel
+  cl_kernel bones_kernel_<algorithm_name>_0 = clCreateKernel(bones_program, "bones_kernel_<algorithm_name>_0", &bones_errors); error_check(bones_errors);
+  
+  // Set all the arguments to the kernel function
+  int bones_num_args = 0;
+  <kernel_argument_list>
+  // Start the kernel
+  size_t bones_global_worksize[] = {<parallelism>};
+  bones_errors = clEnqueueNDRangeKernel(bones_queue,bones_kernel_<algorithm_name>_0,1,NULL,bones_global_worksize,NULL,0,NULL,&bones_event); error_check(bones_errors);
+  
+  // Synchronize and clean-up the kernel
+  clFinish(bones_queue);
+  clReleaseKernel(bones_kernel_<algorithm_name>_0);

data/skeletons/GPU-OPENCL-AMD/kernel/default.kernel.cl

@@ -0,0 +1,13 @@
+
+// Start of the <algorithm_name> kernel
+__kernel void bones_kernel_<algorithm_name>_0(<devicedefinitionsopencl>, <argument_definition>) {
+  const int bones_global_id = get_global_id(0);
+  if (bones_global_id < (<parallelism>)) {
+    
+    // Calculate the global ID(s) based on the thread id
+    <ids>
+    
+    // Start the computation
+<algorithm_code1>
+  }
+}

data/skeletons/GPU-OPENCL-AMD/skeletons.txt

@@ -0,0 +1,26 @@
+###################################################################
+# Each line holds one mapping from species to skeleton
+# The ordering is always ['chunk','neighbourhood','element','shared','void']
+# The pattern 'full' is omitted from matching (will thus always match)
+# 'D' denotes any ranges (e.g. D|element can be any dimension)
+# 'N' denotes any range (e.g. N,N|element must be 2D)
+# '+' denotes one or more of these patterns
+###################################################################
+D|chunk(D)+                                    -> D|chunk(D)+              :default                        :00
+D|chunk(D)+                                    -> D|chunk(D)+ ^ D|element+ :default                        :00
+D|chunk(D)+ ^ D|element+                       -> D|chunk(D)+              :default                        :00
+D|chunk(D)+ ^ D|element+                       -> D|chunk(D)+ ^ D|element+ :default                        :00
+D|chunk(D)+                                    -> D|element+               :default                        :00
+D|chunk(D)+ ^ D|neighbourhood(D)+ ^ D|element+ -> D|element+               :default                        :00
+D|chunk(D)+ ^ D|element+                       -> D|element+               :default                        :00
+N|neighbourhood(N)+                            -> N|element+               :default                        :00
+D|neighbourhood(D)+                            -> D|element+               :default                        :00
+D|neighbourhood(D)+ ^ D|element+               -> D|element+               :default                        :00
+D|element+                                     -> D|chunk(D)+              :default                        :00
+D|element+                                     -> D|element+               :default                        :00
+D|element                                      -> 1|shared                 :D-element-to-1-shared          :02 03 04 05
+D|void                                         -> D|element+               :default                        :00
+
+#D|element+                                     -> D|shared+                :default                        :09
+#D|element+                                     -> D|element+ ^ D|shared+   :default                        :09
+

data/skeletons/verification/header.c

@@ -0,0 +1,2 @@
+#include <string.h>
+#include <math.h>

data/skeletons/verification/timer_start.c

@@ -0,0 +1,4 @@
+  
+  // Start the timer for the measurement of the original code's execution time
+  struct timeval bones_start_time;
+  gettimeofday(&bones_start_time, NULL);

data/skeletons/verification/timer_stop.c

@@ -0,0 +1,6 @@
+  
+  // Stop the timer for the measurement of the original code's execution time
+  struct timeval bones_end_time;
+  gettimeofday(&bones_end_time, NULL);
+  float bones_timer = 0.001 * (1000000*(bones_end_time.tv_sec-bones_start_time.tv_sec)+bones_end_time.tv_usec-bones_start_time.tv_usec);
+  printf(">>>\t\t\t Execution time [original     ]: %.3lf ms.\n", bones_timer);

data/skeletons/verification/verify_results.c

@@ -0,0 +1,23 @@
+/* STARTDEF
+void bones_verify_results_<name>(<type> *bones_a, <type> *bones_b, <argument_definition>);
+ENDDEF */
+void bones_verify_results_<name>(<type> *bones_a, <type> *bones_b, <argument_definition>) {
+  long bones_m=0;
+  long bones_e=0;
+  for (int bones_global_id=0; bones_global_id<<dimensions>; bones_global_id++) {
+    <verifyids>
+    int bones_id = <flatindex>;
+    if (fabs(bones_a[bones_id]) > 0.000000001 ) {
+      if ((fabs((bones_b[bones_id]/bones_a[bones_id])-1) < 0.001)) { bones_m++; } else { bones_e++; }
+    } else {
+      if (fabs(bones_a[bones_id]-bones_b[bones_id]) < 0.001) { bones_m++; } else { bones_e++; }
+    }
+    //printf("%.3lf versus %.3lf\n",bones_a[bones_id],bones_b[bones_id]);
+    //printf("%d versus %d\n",bones_a[bones_id],bones_b[bones_id]);
+  }
+  printf("*** Verification ");
+  if (bones_e == 0) { printf("complete: no errors found.\n"); }
+  else { printf("warning: found %li (%.1lf%%) error(s).\n", bones_e, (bones_e*100.0)/(bones_e+bones_m)); }
+  
+}
+

data/test/bones/test_algorithm.rb

@@ -0,0 +1,40 @@
+# Include the test helper
+require File.dirname(__FILE__) + '/../test_helper'
+
+# Test class for the primitive class.
+class TestAlgorithm < Test::Unit::TestCase
+	
+	# Create a list of known examples and the results.
+	def setup
+		
+		# Create a comprehensive list of known tribes
+		list = setup_species
+		@examples = list[:examples]
+		@defines = []
+		
+		# Create a list of corresponding preprocessors and code
+		@primitives_list, original_code_list, @arrays_list = setup_algorithms(@examples)
+		
+		# Use the preprocessor and the 'CAST' gem to create an AST of the original code
+		original_ast_list = []
+		original_code_list.each do |original_code|
+			preprocessor = Bones::Preprocessor.new(original_code,'','')
+			preprocessor.process
+			@defines.push(preprocessor.defines)
+			original_ast_list.push(C.parse(preprocessor.target_code))
+		end
+		
+		# Populate the contents of the primitives
+		@primitives_list.each_with_index do |primitives,index|
+			primitives.each do |algorithm|
+				algorithm.populate_lists()
+				#algorithm.populate_hash()
+			end
+		end
+	end
+	
+	def test_nothing
+	end
+	
+end
+

data/test/bones/test_common.rb

@@ -0,0 +1,54 @@
+# Include the test helper
+require File.dirname(__FILE__) + '/../test_helper'
+
+# Test class for the primitive class.
+class TestCommon < Test::Unit::TestCase
+	
+	# Set the test up.
+	def setup
+		@common = Bones::Common.new
+	end
+	
+	def test_brackets
+		tests   = ['(4)','(var_16)','a+(5)','b1+(var*16)','a-(-4)']
+		results = ['4'  ,'var_16'  ,'a+5'  ,'b1+(var*16)','a+4'   ]
+		tests.each_with_index do |test,index|
+			assert_equal(results[index], @common.simplify(test))
+		end
+	end
+	
+	def test_alu_constants
+		tests   = ['4+1','4*(4+3)','a+5','b1+(3*11)','(6-12)-2','(12-6)*3','-2-2-2','a-a','a-b']
+		results = ['5'  ,'28'     ,'a+5','b1+33'    ,'-8'      ,'18'      ,'-6'    ,'0'  ,'a-b']
+		tests.each_with_index do |test,index|
+			assert_equal(results[index], @common.simplify(test))
+		end
+	end
+	
+	def test_division_removal
+		tests   = ['2/10','4*(2/1)','2/(1*4)']
+		results = ['2/10','8'      ,'2/4'    ]
+		tests.each_with_index do |test,index|
+			assert_equal(results[index], @common.simplify(test))
+		end
+	end
+	
+	def test_division
+		tests   = ['(2048/2)-1','4*(2/1)','2/2','2/(1*4)','var+(13/3)+(12/3)']
+		results = ['1023'      ,'8'      ,'1'  ,'2/4'    ,'var+(13/3)+4'     ]
+		tests.each_with_index do |test,index|
+			assert_equal(results[index], @common.simplify(test))
+		end
+	end
+	
+	
+	def test_general
+		tests   = ['((3)-(2)+1)+0','((2+0)-(1)+1)','(((id/(1))%(2/1)))+2','(0+id/(2))+1']
+		results = ['2'            ,'2'            ,'(id%2)+2'            ,'(id/2)+1']
+		tests.each_with_index do |test,index|
+			assert_equal(results[index], @common.simplify(test))
+		end
+	end
+	
+end
+

data/test/bones/test_preprocessor.rb

@@ -0,0 +1,46 @@
+# Include the test helper
+require File.dirname(__FILE__) + '/../test_helper'
+
+# Test class for the preprocessor class.
+class TestPreprocessor < Test::Unit::TestCase
+	
+	# Create a list of known examples and reference results.
+	def setup
+		
+		# Create a comprehensive list of known speciess
+		list = setup_species
+		@examples = list[:examples]
+		
+		# Create a list of corresponding algorithms and code
+		@algorithms_list, code_list = setup_algorithms(@examples)
+		
+		# Create and execute the preprocessors
+		@preprocessors = []
+		code_list.each_index do |index|
+			preprocessor = Bones::Preprocessor.new(code_list[index],'','')
+			preprocessor.process
+			@preprocessors.push(preprocessor)
+		end
+	end
+	
+	# Method to test the found algorithms (species part).
+	def test_algorithms_species
+		@preprocessors.each_with_index do |preprocessor,index1|
+			reference_algorithms = @algorithms_list[index1]
+			preprocessor.algorithms.each_with_index do |algorithm,index2|
+				assert_equal(reference_algorithms[index2].species.prefix,algorithm.species.prefix)
+			end
+		end
+	end
+	
+	# Method to test the found algorithms (code part).
+	def test_algorithms_code
+		@preprocessors.each_with_index do |preprocessor,index1|
+			reference_algorithms = @algorithms_list[index1]
+			preprocessor.algorithms.each_with_index do |algorithm,index2|
+				assert_equal(reference_algorithms[index2].code,algorithm.code)
+			end
+		end
+	end
+end
+

data/test/bones/test_species.rb

@@ -0,0 +1,21 @@
+# Include the test helper
+require File.dirname(__FILE__) + '/../test_helper'
+
+# Test class for the species class
+class TestSpecies < Test::Unit::TestCase
+	
+	# Create a comprehensive list of known species.
+	def setup
+		list = setup_species
+		@dimensions = list[:dimensions]
+		@inputs = list[:inputs]
+		@outputs = list[:outputs]
+		@patterns = list[:patterns]
+		@prefixes = list[:prefixes]
+		@species = list[:species]
+	end
+	
+	def test_nothing
+	end
+	
+end

data/test/bones/test_variable.rb

@@ -0,0 +1,84 @@
+# Include the test helper
+require File.dirname(__FILE__) + '/../test_helper'
+
+# Test class for the variable class
+class TestVariable < Test::Unit::TestCase
+	
+	# Some constants to test against.
+	NAME = 'example'
+	
+	# Method to create variable examples from code examples.
+	def setup
+		@variables = []
+		@dimensions = []
+		parser = C::Parser.new
+		prefix = 'void main() {'
+		suffix = '}'
+		
+		# Create code examples
+		code_examples = []
+		@types = []
+		typeprefixes = ['int','float','int *','int **','int ***','unsigned char *']
+		typesuffixes = ['','[10]','[N]','[10][10]']
+		typeprefixes.each do |typeprefix|
+			typesuffixes.each do |typesuffix|
+				@types.push([typeprefix,typesuffix])
+				@types.push([typeprefix,typesuffix])
+			end
+		end
+		@types.each_with_index do |type,index|
+			if index.odd?
+				definition = type[0]+' '+NAME+type[1]
+				code_examples.push(parser.parse([prefix,definition+' = 3;',suffix].join("\n")))
+				code_examples.push(parser.parse([prefix,definition+';','int a = '+NAME+';',suffix].join("\n")))
+			end
+			@dimensions.push(type[0].scan('*').length + type[1].scan('[').length)
+		end
+		
+		# Create variables
+		code_examples.each do |code|
+			@variables.push(Bones::Variable.new(NAME,code.variable_type(NAME),code.size(NAME),Bones::INPUT,'0',false)) 
+		end
+	end
+	
+	# Test whether the typename of the variable is recognized correctly.
+	def test_typename
+		@variables.each_index do |index|
+			assert_equal(@types[index][0].gsub('*','').strip,@variables[index].type_name)
+		end
+	end
+	
+	# Test whether the device pointer is obtained correctly.
+	def test_device_pointer
+		@variables.each_index do |index|
+			expected_result = (@dimensions[index] == 0) ? '' : '*'
+			assert_equal(expected_result,@variables[index].device_pointer)
+		end
+	end
+	
+	# Test whether the dimension of a variable is obtained correctly.
+	def test_dimension
+		@variables.each_index do |index|
+			assert_equal(@dimensions[index],@variables[index].dimensions)
+		end
+	end
+	
+	# Test to see if the flattened array is obtained correctly.
+	def test_flatten
+		@variables.each_index do |index|
+			if @variables[index].dimensions > 1
+				expected_result = ''+'[0]'*(@dimensions[index]-1)
+				assert_equal(expected_result,@variables[index].flatten)
+			end
+		end
+	end
+	
+	# Test whether the variable definition is obtained correctly.
+	def test_definition
+		@variables.each_index do |index|
+			expected_result = @types[index][0]+' '+NAME+@types[index][1]
+			assert_equal(expected_result,@variables[index].definition)
+		end
+	end
+	
+end