bones-compiler 1.1.0 → 1.3.1

data/lib/common.rb

@@ -0,0 +1,216 @@
+
+# Bones/Aset require 'fileutils' from the Ruby standard library.
+require 'fileutils'
+
+# Bones/Aset use the 'trollop' gem to parse command line options.
+require 'rubygems'
+require 'trollop'
+require 'symbolic'
+
+# Extending the Ruby standard string class to support some
+# additional methods. This includes a hack of the gsub! command.
+class String #:nodoc:
+	
+	# Extend the Ruby string class to be able to chain 'gsub!'
+	#-commands. This code is taken from the web.
+	meth = 'gsub!'
+	orig_meth = "orig_#{meth}"
+	alias_method orig_meth, meth
+	define_method(meth) do |*args|
+		self.send(orig_meth, *args)
+		self
+	end
+	
+end
+
+# Set the newline character
+NL = "\n"
+# Set the tab size (currently: 2 spaces)
+INDENT = "\t"
+
+# A string representing the combination character ('^') of a species.
+WEDGE = '^'
+# A string representing the production character ('->') of a species.
+ARROW = '->'
+# A string representing the pipe character ('|') of a species.
+PIPE = '|'
+# A string representing the colon character (':') to separate ranges in dimensions.
+RANGE_SEP = ':'
+# A string representing the comma character (',') to separate different ranges.
+DIM_SEP = ','
+
+# Value to assume a variable to be
+ASSUME_VAL = '1000'
+
+
+# Helper method to evaluate mathematical expressions, possibly containing
+# symbols. This method is only used for readability, without it the code
+# is functionally correct, but expressions might be larger than needed.
+def simplify(expr)
+	raise_error('Invalid expression to simplify') if !expr
+	expr = expr.gsub(' ','')
+	
+	# Immediately return if there is an array index in the expression
+	return expr if expr =~ /\[/
+	
+	# Handle min/max functions
+	if expr =~ /max/ || expr =~ /min/
+		return expr
+	end
+	
+	# Get all the variables
+	vars = get_vars(expr)
+	
+	# Set all the variables
+	hash = {}
+	vars.uniq.each do |var_name|
+		hash[var_name.to_sym] = var :name => var_name
+		expr = expr.gsub(/\b#{var_name}\b/,"hash[:#{var_name}]")
+	end
+	
+	# Simplify the string using the 'symbolic' gem.
+	symbolic_expr = eval(expr)
+	
+	# Return the result as a string
+	return symbolic_expr.to_s
+end
+
+# Get the variables in an expression
+def get_vars(expr)
+	expr.split(/\W+/).reject{ |s| (s.to_i.to_s == s || s.to_f.to_s == s || s == "") }
+end
+
+# Solve a linear equality (work in progress)
+def solve(equality,variable,forbidden_vars)
+	return "" if equality == ""
+	
+	# Perform the subtitution of the current variable
+	expr = '-('+equality.gsub('=','-(').gsub(/\b#{variable}\b/,"0")+'))'
+	
+	# Simplify the result
+	result = simplify(expr)
+	
+	# Return the result or nothing (if it still contains forbidden variables)
+	vars = get_vars(result)
+	if vars & forbidden_vars == []
+		return result
+	else
+		return ""
+	end
+end
+
+# Find the maximum value of 2 expressions
+def max(expr1,expr2,assumptions=[])
+	return expr1 if expr2 == ""
+	comparison = simplify("(#{expr1})-(#{expr2})")
+	
+	# Process the assumptions
+	assumptions.each do |assumption|
+		comparison = simplify(comparison.gsub(assumption[0],assumption[1]))
+	end
+	
+	# Test to find the maximum
+	if (comparison.to_i.to_s == comparison || comparison.to_f.to_s == comparison)
+		return expr1 if (comparison.to_i == 0)
+		return expr1 if (comparison.to_i > 0)
+		return expr2 if (comparison.to_i < 0)
+	else
+	
+		# Handle min/max functions
+		if comparison =~ /max/ || comparison =~ /min/
+			return "max(#{expr1},#{expr2})"
+		end
+		
+		# Find the maximum based on a guess
+		var = get_vars(comparison).first
+		assumptions << [var,ASSUME_VAL]
+		#puts "WARNING: Don't know how to find the max/min of '(#{expr1})' and '(#{expr2})', assuming: #{var}=#{ASSUME_VAL}"
+		return max(expr1,expr2,assumptions)
+	end
+end
+
+# Find the minimum value of 2 expressions (based on the max method)
+def min(expr1,expr2)
+	return expr1 if expr2 == ""
+	s1 = simplify(expr1)
+	s2 = simplify(expr2)
+	comparison = simplify("(#{s1})-(#{s2})")
+	
+	# Handle min/max functions
+	if comparison =~ /max/ || comparison =~ /min/
+		return s1 if s2 =~ /^max\(#{s1},.*\)$/ || s2 =~ /^max\(.*,#{s1}\)$/
+		return s2 if s1 =~ /^max\(#{s2},.*\)$/ || s1 =~ /^max\(.*,#{s2}\)$/
+		return "min(#{expr1},#{expr2})"
+	end
+	
+	# Run the 'max' method
+	maximum = max(expr1,expr2)
+	return (maximum == expr1) ? expr2 : ( (maximum == expr2) ? expr1 : maximum.gsub('max(','min(') )
+end
+
+# Find the exact maximum value of 2 expressions
+def exact_max(expr1,expr2)
+	return expr1 if expr1 == expr2
+	comparison = simplify("(#{expr1})-(#{expr2})")
+	if (comparison.to_i.to_s == comparison || comparison.to_f.to_s == comparison)
+		return expr1 if (comparison.to_i == 0)
+		return expr1 if (comparison.to_i > 0)
+		return expr2 if (comparison.to_i < 0)
+	else
+		return "max(#{expr1},#{expr2})"
+	end
+end
+
+# Find the exact minimum value of 2 expressions (based on the exact_max method)
+def exact_min(expr1,expr2)
+	return expr1 if expr1 == expr2
+	maximum = exact_max(expr1,expr2)
+	return (maximum == expr1) ? expr2 : ( (maximum == expr2) ? expr1 : maximum.gsub('max(','min(') )
+end
+
+
+# Return the absolute value (if possible)
+def abs(expr)
+	return expr.to_i.abs.to_s if expr.to_i.to_s == expr
+	return expr
+end
+
+# Compare two expressions
+def compare(expr1,expr2,loop_data,assumptions=[])
+	comparison = simplify("(#{expr1})-(#{expr2})")
+	
+	# Handle min/max functions
+	if comparison =~ /max/ || comparison =~ /min/
+		return comparison
+	end
+	
+	# Process the assumptions
+	assumptions.each do |assumption|
+		comparison = simplify(comparison.gsub(assumption[0],assumption[1]))
+	end
+	
+	# Known comparison
+	if (comparison.to_i.to_s == comparison || comparison.to_f.to_s == comparison)
+		return 'eq' if (comparison.to_i == 0)
+		return 'gt' if (comparison.to_i > 0)
+		return 'lt' if (comparison.to_i < 0)
+	else
+		
+		# Comparison based on loop data
+		get_vars(comparison).each do |var|
+			loop_data.each do |loop_datum|
+				if loop_datum[:var] == var
+					assumptions << [var,loop_datum[:min]]
+					#puts "WARNING: Modifying expression '(#{expr1}) vs (#{expr2})', assuming: #{var}=#{loop_datum[:min]}"
+					return compare(expr1,expr2,loop_data,assumptions)
+				end
+			end
+		end
+		
+		# Comparison based on a guess
+		var = get_vars(comparison).first
+		assumptions << [var,ASSUME_VAL]
+		#puts "WARNING: Don't know how to compare '(#{expr1})' and '(#{expr2})', assuming: #{var}=#{ASSUME_VAL}"
+		return compare(expr1,expr2,loop_data,assumptions)
+	end
+end

data/skeletons/CPU-C/common/header.c

@@ -0,0 +1,3 @@
+
+void bones_timer_start();
+void bones_timer_stop();

data/skeletons/CPU-C/common/timer_2_start.c

@@ -3,18 +3,16 @@
   struct timeval bones_start_time2;
   struct timeval bones_end_time2;
   for (int bones_iter=0; bones_iter<ITERS; bones_iter++) {
-  
-  // Flush the CPU cache (for measurement purposes only)
-  const int bones_flush_size = 4*1024*1024; // (16MB)
-  int bones_flush_i;
-  int bones_flush_j;
-  char *bones_flush_c = (char *)malloc(bones_flush_size);
-  for (bones_flush_i=0; bones_flush_i<10; bones_flush_i++) {
-    for (bones_flush_j=0; bones_flush_j<bones_flush_size; bones_flush_j++) {
-      bones_flush_c[bones_flush_j] = bones_flush_i*bones_flush_j;
+    
+    // Flush the CPU cache (for measurement purposes only)
+    const int bones_flush_size = 4*1024*1024; // (16MB)
+    char *bones_flush_c = (char *)malloc(bones_flush_size);
+    for (int i=0; i<10; i++) {
+      for (int j=0; j<bones_flush_size; j++) {
+        bones_flush_c[j] = i*j;
+      }
     }
-  }
-  free(bones_flush_c);
+    free(bones_flush_c);
     
-  // Start the timer for the measurement of the kernel execution time
-  gettimeofday(&bones_start_time2, NULL);
+    // Start the timer for the measurement of the kernel execution time
+    gettimeofday(&bones_start_time2, NULL);

data/skeletons/CPU-C/common/timer_2_stop.c

@@ -5,4 +5,4 @@
   }
   
   // Print the measurement data
-  printf(">>>\t\t (<algorithm_basename>): Execution time [kernel       ]: %.3lf ms \n", bones_timer2/((float)ITERS));
+  printf(">>>\t\t Execution time [kernel <algorithm_basename>]: %.3lf ms \n", bones_timer2/((float)ITERS));

data/skeletons/CPU-C/common/timer_globals.c

@@ -0,0 +1,29 @@
+////////////////////////////////////////
+//////////// Timers ////////////////////
+////////////////////////////////////////
+
+// Timer
+struct timeval bones_start_time1;
+
+// Start the timer for the measurement of the whole scop
+void bones_timer_start() {
+  const int bones_flush_size = 4*1024*1024; // (16MB)
+  char *bones_flush_c = (char *)malloc(bones_flush_size);
+  for (int i=0; i<10; i++) {
+    for (int j=0; j<bones_flush_size; j++) {
+      bones_flush_c[j] = i*j;
+    }
+  }
+  free(bones_flush_c);
+  gettimeofday(&bones_start_time1, NULL);
+}
+
+// End the timer for the measurement of the whole scop
+void bones_timer_stop() {
+  #if (ITERS == 1)
+    struct timeval bones_end_time1;
+    gettimeofday(&bones_end_time1, NULL);
+    float bones_timer1 = 0.001 * (1000000*(bones_end_time1.tv_sec-bones_start_time1.tv_sec)+bones_end_time1.tv_usec-bones_start_time1.tv_usec);
+    printf(">>>\t\t Execution time [full scop]: %.3lf ms \n", bones_timer1);
+  #endif
+}

data/skeletons/CPU-OPENCL-INTEL/common/globals.c

@@ -103,7 +103,7 @@ void bones_initialize_target(void) {
   cl_platform_id bones_platform_ids[10];
   bones_errors = clGetPlatformIDs(bones_num_platforms,bones_platform_ids,NULL); error_check(bones_errors);  
   
-  // Select the AMD APP platform
+  // Select the Intel SDK platform
   char bones_buffer[1024];
   cl_uint bones_platform;
   for(cl_uint bones_platform_id=0; bones_platform_id<bones_num_platforms; bones_platform_id++) {

data/skeletons/CPU-OPENCL-INTEL/common/header.c

@@ -1,5 +1,8 @@
 #include <stdlib.h>
 
+void bones_timer_start();
+void bones_timer_stop();
+
 // Allocate a 128-byte aligned pointer
 void *bones_malloc_128(size_t bones_size) {
   char *bones_pointer;

data/skeletons/CPU-OPENCL-INTEL/common/mem_copy_D2H.c

@@ -1,5 +1,10 @@
   
   // Perform a zero-copy of <array> from device to host
-  void* bones_pointer_to_<array> = clEnqueueMapBuffer(bones_queue,device_<array>,CL_TRUE,CL_MAP_READ,<offset>,<variable_dimensions>*sizeof(<type>),0,NULL,NULL,&bones_errors); error_check(bones_errors);
-  clEnqueueUnmapMemObject(bones_queue,device_<array>,bones_pointer_to_<array>,0,NULL,NULL);
+  #if ZEROCOPY == 1
+    printf("Copying back from device_<array> to <array>\n");
+    void* bones_pointer_to_<array> = clEnqueueMapBuffer(bones_queue,device_<array>,CL_TRUE,CL_MAP_READ,0,<variable_dimensions>*sizeof(<type>),0,NULL,NULL,&bones_errors); error_check(bones_errors);
+    clEnqueueUnmapMemObject(bones_queue,device_<array>,bones_pointer_to_<array>,0,NULL,NULL);
+  #elif ZEROCOPY == 0
+    bones_errors = clEnqueueReadBuffer(bones_queue,device_<array>,CL_TRUE,(0)*sizeof(<type>),<variable_dimensions>*sizeof(<type>),<array><flatten>+0,0,NULL,NULL); error_check(bones_errors);
+  #endif
   clFinish(bones_queue);

data/skeletons/CPU-OPENCL-INTEL/common/mem_copy_H2D.c

@@ -1,3 +1,5 @@
   
-  //bones_errors = clEnqueueWriteBuffer(bones_queue, device_<array>, CL_TRUE, 0, <variable_dimensions>*sizeof(<type>), <array><flatten>, 0, NULL, NULL); error_check(bones_errors);
-  //clFinish(bones_queue);
+  #if ZEROCOPY == 0
+    device_<array> = clCreateBuffer(bones_context,CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR,<variable_dimensions>*sizeof(<type>),<array><flatten>, &bones_errors); error_check(bones_errors);
+    clFinish(bones_queue);
+  #endif

data/skeletons/CPU-OPENCL-INTEL/common/mem_prologue.c

@@ -1,4 +1,7 @@
   
-  // Create a device pointer for <array> (zero-copy)
-  cl_mem device_<array> = clCreateBuffer(bones_context, CL_MEM_READ_WRITE|CL_MEM_USE_HOST_PTR, <variable_dimensions>*sizeof(<type>), <array><flatten>, &bones_errors); error_check(bones_errors);
-  //cl_mem device_<array> = clCreateBuffer(bones_context, CL_MEM_READ_WRITE, <variable_dimensions>*sizeof(<type>), NULL, &bones_errors); error_check(bones_errors);
+  // Create a device pointer for <array>
+  #if ZEROCOPY == 1
+    cl_mem device_<array> = clCreateBuffer(bones_context, CL_MEM_READ_WRITE|CL_MEM_USE_HOST_PTR, <variable_dimensions>*sizeof(<type>), <array><flatten>, &bones_errors); error_check(bones_errors);
+  #elif ZEROCOPY == 0
+    cl_mem device_<array> = clCreateBuffer(bones_context, CL_MEM_READ_WRITE, <variable_dimensions>*sizeof(<type>), NULL, &bones_errors); error_check(bones_errors);
+  #endif

data/skeletons/CPU-OPENCL-INTEL/common/timer_2_stop.c

@@ -8,4 +8,4 @@
   bones_errors = clGetEventProfilingInfo(bones_event, CL_PROFILING_COMMAND_END, sizeof(cl_ulong), &end2, 0); error_check(bones_errors);
   bones_errors = clGetEventProfilingInfo(bones_event, CL_PROFILING_COMMAND_START, sizeof(cl_ulong), &start2, 0); error_check(bones_errors);
   float bones_timer2 = 0.000001 * (end2-start2);
-  printf(">>>\t\t (<algorithm_basename>): Execution time [kernel       ]: %.3lf ms \n", bones_timer2);
+  printf(">>>\t\t Execution time [kernel <algorithm_basename>]: %.3lf ms \n", bones_timer2);

data/skeletons/CPU-OPENCL-INTEL/common/timer_globals.c

@@ -0,0 +1,24 @@
+
+////////////////////////////////////////
+//////////// Timers ////////////////////
+////////////////////////////////////////
+
+// Timer
+struct timeval bones_start_time1;
+
+// Start the timer for the measurement of the whole scop
+void bones_timer_start() {
+  clFinish(bones_queue);
+  gettimeofday(&bones_start_time1, NULL);
+}
+
+// End the timer for the measurement of the whole scop
+void bones_timer_stop() {
+  #if (ITERS == 1)
+    clFinish(bones_queue);
+    struct timeval bones_end_time1;
+    gettimeofday(&bones_end_time1, NULL);
+    float bones_timer1 = 0.001 * (1000000*(bones_end_time1.tv_sec-bones_start_time1.tv_sec)+bones_end_time1.tv_usec-bones_start_time1.tv_usec);
+    printf(">>>\t\t Execution time [full scop]: %.3lf ms \n", bones_timer1);
+  #endif
+}

data/skeletons/CPU-OPENMP/common/globals.c

@@ -1,5 +1,6 @@
 #include <omp.h>
 #include <stdlib.h>
+#include <stdio.h>
 
 #define BONES_MIN(a,b) ((a<b) ? a : b)
 #define BONES_MAX(a,b) ((a>b) ? a : b)

data/skeletons/CPU-OPENMP/common/header.c

@@ -0,0 +1,3 @@
+
+void bones_timer_start();
+void bones_timer_stop();

data/skeletons/CPU-OPENMP/common/timer_1_start.c

@@ -1,12 +0,0 @@
-  
-  // Flush the CPU cache (for measurement purposes only)
-  const int bones_flush_size = 4*1024*1024; // (16MB)
-  int bones_flush_i;
-  int bones_flush_j;
-  char *bones_flush_c = (char *)malloc(bones_flush_size);
-  for (bones_flush_i=0; bones_flush_i<10; bones_flush_i++) {
-    for (bones_flush_j=0; bones_flush_j<bones_flush_size; bones_flush_j++) {
-      bones_flush_c[bones_flush_j] = bones_flush_i*bones_flush_j;
-    }
-  }
-  free(bones_flush_c);

data/skeletons/CPU-OPENMP/common/timer_2_stop.c

@@ -5,4 +5,4 @@
   }
   
   // Print the measurement data
-  printf(">>>\t\t (<algorithm_basename>): Execution time [kernel       ]: %.3lf ms \n", bones_timer2/((float)ITERS));
+  printf(">>>\t\t Execution time [kernel <algorithm_basename>]: %.3lf ms \n", bones_timer2/((float)ITERS));

data/skeletons/CPU-OPENMP/common/timer_globals.c

@@ -0,0 +1,33 @@
+////////////////////////////////////////
+//////////// Timers ////////////////////
+////////////////////////////////////////
+
+// Includes
+#include <stdio.h>
+
+// Timer
+struct timeval bones_start_time1;
+
+// Start the timer for the measurement of the whole scop
+void bones_timer_start() {
+  /*
+  const int bones_flush_size = 4*1024*1024; // (16MB)
+  char *bones_flush_c = (char *)malloc(bones_flush_size);
+  for (int i=0; i<10; i++) {
+    for (int j=0; j<bones_flush_size; j++) {
+      bones_flush_c[j] = i*j;
+    }
+  }
+  free(bones_flush_c);*/
+  gettimeofday(&bones_start_time1, NULL);
+}
+
+// End the timer for the measurement of the whole scop
+void bones_timer_stop() {
+  #if (ITERS == 1)
+    struct timeval bones_end_time1;
+    gettimeofday(&bones_end_time1, NULL);
+    float bones_timer1 = 0.001 * (1000000*(bones_end_time1.tv_sec-bones_start_time1.tv_sec)+bones_end_time1.tv_usec-bones_start_time1.tv_usec);
+    printf(">>>\t\t Execution time [full scop]: %.3lf ms \n", bones_timer1);
+  #endif
+}