bones-compiler 1.1.0

data/lib/castaddon/type.rb

@@ -0,0 +1,37 @@
+module C
+	# This class provides an extention to the CAST type class. It
+	# contains a number of functions applicable to types such as
+	# pointers, arrays, structures, floats, integers, etc.
+	#
+	# The provided methods are just helpers to extend the CAST
+	# functionality and to clean-up the Bones classes.
+	class Type
+		
+		# This method is used to determine whether the variable is
+		# an array and/or a pointer. Returns either true or false.
+		def array_or_pointer?
+			((self.class == C::Array) || (self.class == C::Pointer))
+		end
+		
+		# This method recursively searches for the type of a variable.
+		# Recursion is needed when a type is an array or a pointer.
+		# The method eventually returns one of the CAST algorithm
+		# types being either: void, int, float, char, bool, complex
+		# or imaginary.
+		def type_name
+			(self.array_or_pointer?) ? self.type.type_name : self
+		end
+		
+		# This method returns the variable's dimension as an integer.
+		# it uses recursion in case the type is an array or a pointer.
+		# Types that are neither arrays nor pointers have a dimension
+		# of zero. For arrays and pointers, each '*' or '[]' contributes
+		# to one additional dimension.
+		def dimensions(count=0)
+			(self.array_or_pointer?) ? self.type.dimensions(count+1) : count
+		end
+		
+	end
+	
+end
+

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

@@ -0,0 +1,17 @@
+
+// Multiple iterations for measurements
+#define ITERS 1
+
+// Declaration of the original function
+int bones_main(void);
+
+// New main function for initialisation and clean-up
+int main(void) {
+  
+  // Original main function
+  int bones_return = bones_main();
+  
+  // Clean-up
+  return bones_return;
+}
+

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

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

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

@@ -0,0 +1,3 @@
+  
+  // Create a pointer to <array> on the device
+  <type>* device_<array> = <array><flatten>;

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

@@ -0,0 +1,20 @@
+  // Initialize the timer
+  float bones_timer2 = 0;
+  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;
+    }
+  }
+  free(bones_flush_c);
+    
+  // 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

@@ -0,0 +1,8 @@
+    
+    // Stop the timer for the measurement of the kernel execution time
+    gettimeofday(&bones_end_time2, NULL);
+    bones_timer2 += 0.001 * (1000000*(bones_end_time2.tv_sec-bones_start_time2.tv_sec)+bones_end_time2.tv_usec-bones_start_time2.tv_usec);
+  }
+  
+  // Print the measurement data
+  printf(">>>\t\t (<algorithm_basename>): Execution time [kernel       ]: %.3lf ms \n", bones_timer2/((float)ITERS));

data/skeletons/CPU-C/kernel/default.host.c

@@ -0,0 +1,3 @@
+  
+  // Start the kernel
+  bones_kernel_<algorithm_name>_0(<devicenames>, <argument_name>);

data/skeletons/CPU-C/kernel/default.kernel.c

@@ -0,0 +1,15 @@
+/* STARTDEF
+void bones_kernel_<algorithm_name>_0(<devicedefinitions>, <argument_definition>);
+ENDDEF */
+// Start of the <algorithm_name> kernel
+void bones_kernel_<algorithm_name>_0(<devicedefinitions>, <argument_definition>) {
+  for(int bones_global_id=0; bones_global_id<<parallelism>; bones_global_id++) {
+    
+    // Calculate the global ID(s) based on the thread id
+    <ids>
+    
+    // Perform the main computation
+<algorithm_code1>
+  }
+}
+

data/skeletons/CPU-C/skeletons.txt

@@ -0,0 +1,24 @@
+###################################################################
+# 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                 :default                        :00
+D|element+                                     -> D|shared+                :default                        :00
+D|element+                                     -> D|element+ ^ D|shared+   :default                        :00
+D|void                                         -> D|element+               :default                        :00

data/skeletons/CPU-OPENCL-AMD/common/epilogue.c

@@ -0,0 +1,6 @@
+  
+  // Clean-up the OpenCL context
+  //clReleaseCommandQueue(bones_queue);
+  //clReleaseProgram(bones_program);
+  //clReleaseContext(bones_context);
+  fflush(stdout);

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

@@ -0,0 +1,155 @@
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+#include <sys/time.h>
+#include <CL/cl.h>
+
+#define BONES_MIN(a,b) ((a<b) ? a : b)
+#define BONES_MAX(a,b) ((a>b) ? a : b)
+#define DIV_CEIL(a,b)  ((a+b-1)/b)
+#define DIV_FLOOR(a,b) (a/b)
+
+// Multiple iterations for kernel measurements
+#define ITERS 1
+
+// Load the OpenCL kernel from file
+char * get_source(const char* bones_filename) {
+  FILE* bones_fp = fopen(bones_filename,"r");
+  fseek(bones_fp,0,SEEK_END);
+  long bones_size = ftell(bones_fp);
+  rewind(bones_fp);
+  char *bones_source = (char *)malloc(sizeof(char)*(bones_size+1));
+  int bones_temp = fread(bones_source,1,sizeof(char)*bones_size,bones_fp);
+  bones_source[bones_size] = '\0';
+  fclose(bones_fp);
+  return bones_source;
+}
+
+// Print an error if it occurs
+void error_check(cl_int bones_errors) {
+  if(bones_errors != CL_SUCCESS) {
+    switch (bones_errors) {
+      case CL_DEVICE_NOT_FOUND:                 printf("--- Error: Device not found.\n"); break;
+      case CL_DEVICE_NOT_AVAILABLE:             printf("--- Error: Device not available\n"); break;
+      case CL_COMPILER_NOT_AVAILABLE:           printf("--- Error: Compiler not available\n"); break;
+      case CL_MEM_OBJECT_ALLOCATION_FAILURE:    printf("--- Error: Memory object allocation failure\n"); break;
+      case CL_OUT_OF_RESOURCES:                 printf("--- Error: Out of resources\n"); break;
+      case CL_OUT_OF_HOST_MEMORY:               printf("--- Error: Out of host memory\n"); break;
+      case CL_PROFILING_INFO_NOT_AVAILABLE:     printf("--- Error: Profiling information not available\n"); break;
+      case CL_MEM_COPY_OVERLAP:                 printf("--- Error: Memory copy overlap\n"); break;
+      case CL_IMAGE_FORMAT_MISMATCH:            printf("--- Error: Image format mismatch\n"); break;
+      case CL_IMAGE_FORMAT_NOT_SUPPORTED:       printf("--- Error: Image format not supported\n"); break;
+      case CL_BUILD_PROGRAM_FAILURE:            printf("--- Error: Program build failure\n"); break;
+      case CL_MAP_FAILURE:                      printf("--- Error: Map failure\n"); break;
+      case CL_INVALID_VALUE:                    printf("--- Error: Invalid value\n"); break;
+      case CL_INVALID_DEVICE_TYPE:              printf("--- Error: Invalid device type\n"); break;
+      case CL_INVALID_PLATFORM:                 printf("--- Error: Invalid platform\n"); break;
+      case CL_INVALID_DEVICE:                   printf("--- Error: Invalid device\n"); break;
+      case CL_INVALID_CONTEXT:                  printf("--- Error: Invalid context\n"); break;
+      case CL_INVALID_QUEUE_PROPERTIES:         printf("--- Error: Invalid queue properties\n"); break;
+      case CL_INVALID_COMMAND_QUEUE:            printf("--- Error: Invalid command queue\n"); break;
+      case CL_INVALID_HOST_PTR:                 printf("--- Error: Invalid host pointer\n"); break;
+      case CL_INVALID_MEM_OBJECT:               printf("--- Error: Invalid memory object\n"); break;
+      case CL_INVALID_IMAGE_FORMAT_DESCRIPTOR:  printf("--- Error: Invalid image format descriptor\n"); break;
+      case CL_INVALID_IMAGE_SIZE:               printf("--- Error: Invalid image size\n"); break;
+      case CL_INVALID_SAMPLER:                  printf("--- Error: Invalid sampler\n"); break;
+      case CL_INVALID_BINARY:                   printf("--- Error: Invalid binary\n"); break;
+      case CL_INVALID_BUILD_OPTIONS:            printf("--- Error: Invalid build options\n"); break;
+      case CL_INVALID_PROGRAM:                  printf("--- Error: Invalid program\n"); break;
+      case CL_INVALID_PROGRAM_EXECUTABLE:       printf("--- Error: Invalid program executable\n"); break;
+      case CL_INVALID_KERNEL_NAME:              printf("--- Error: Invalid kernel name\n"); break;
+      case CL_INVALID_KERNEL_DEFINITION:        printf("--- Error: Invalid kernel definition\n"); break;
+      case CL_INVALID_KERNEL:                   printf("--- Error: Invalid kernel\n"); break;
+      case CL_INVALID_ARG_INDEX:                printf("--- Error: Invalid argument index\n"); break;
+      case CL_INVALID_ARG_VALUE:                printf("--- Error: Invalid argument value\n"); break;
+      case CL_INVALID_ARG_SIZE:                 printf("--- Error: Invalid argument size\n"); break;
+      case CL_INVALID_KERNEL_ARGS:              printf("--- Error: Invalid kernel arguments\n"); break;
+      case CL_INVALID_WORK_DIMENSION:           printf("--- Error: Invalid work dimensionsension\n"); break;
+      case CL_INVALID_WORK_GROUP_SIZE:          printf("--- Error: Invalid work group size\n"); break;
+      case CL_INVALID_WORK_ITEM_SIZE:           printf("--- Error: Invalid work item size\n"); break;
+      case CL_INVALID_GLOBAL_OFFSET:            printf("--- Error: Invalid global offset\n"); break;
+      case CL_INVALID_EVENT_WAIT_LIST:          printf("--- Error: Invalid event wait list\n"); break;
+      case CL_INVALID_EVENT:                    printf("--- Error: Invalid event\n"); break;
+      case CL_INVALID_OPERATION:                printf("--- Error: Invalid operation\n"); break;
+      case CL_INVALID_GL_OBJECT:                printf("--- Error: Invalid OpenGL object\n"); break;
+      case CL_INVALID_BUFFER_SIZE:              printf("--- Error: Invalid buffer size\n"); break;
+      case CL_INVALID_MIP_LEVEL:                printf("--- Error: Invalid mip-map level\n"); break;
+      default:                                  printf("--- Error: Unknown with code %d\n", bones_errors);
+    }
+    fflush(stdout); exit(0);
+  }
+}
+
+// Use a global variable for the device ID, context and command queue
+cl_device_id bones_device;
+cl_context bones_context;
+cl_command_queue bones_queue;
+
+// Use a global variable to store the name and the binary for the last program
+char bones_last_program[1024];
+cl_program bones_program;
+
+// Function to initialize the OpenCL platform (create to ensure fair measurements afterwards)
+void bones_initialize_target(void) {
+  cl_int bones_errors;
+  
+  // Get OpenCL platform count
+  cl_uint bones_num_platforms;
+  bones_errors = clGetPlatformIDs(0,NULL,&bones_num_platforms); error_check(bones_errors);
+  if (bones_num_platforms == 0) { printf("Error: No OpenCL platforms found.\n"); exit(1); }
+  
+  // Get all OpenCL platform IDs
+  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
+  char bones_buffer[1024];
+  cl_uint bones_platform;
+  for(cl_uint bones_platform_id=0; bones_platform_id<bones_num_platforms; bones_platform_id++) {
+    clGetPlatformInfo(bones_platform_ids[bones_platform_id], CL_PLATFORM_NAME, 1024, bones_buffer, NULL);
+    if(strstr(bones_buffer,"AMD") != NULL) { bones_platform = bones_platform_id; break; }
+  }
+  
+  // Get a CPU device on the platform
+  bones_errors = clGetDeviceIDs(bones_platform_ids[bones_platform], CL_DEVICE_TYPE_CPU, 1, &bones_device, NULL); error_check(bones_errors);
+  bones_errors = clGetDeviceInfo(bones_device, CL_DEVICE_NAME, sizeof(bones_buffer), bones_buffer, NULL); error_check(bones_errors);
+  
+  // Create a context
+  bones_context = clCreateContext(0,1,&bones_device,NULL,NULL,&bones_errors); error_check(bones_errors);
+  
+  // Create a command queue
+  bones_queue = clCreateCommandQueue(bones_context,bones_device,CL_QUEUE_PROFILING_ENABLE,&bones_errors); error_check(bones_errors);
+  
+  // Create space on the device
+  cl_mem bones_device_data = clCreateBuffer(bones_context,CL_MEM_READ_WRITE,4,NULL,&bones_errors); error_check(bones_errors);
+  
+  // Copy something to the device
+  bones_device_data = clCreateBuffer(bones_context,CL_MEM_READ_WRITE|CL_MEM_COPY_HOST_PTR,4,bones_buffer,NULL);
+  
+  // Clean-up the OpenCL context
+  strcpy(bones_last_program,"");
+  clReleaseMemObject(bones_device_data);
+  clReleaseContext(bones_context);
+  fflush(stdout);
+}
+
+// Declaration of the original function
+int bones_main(void);
+
+// New main function for initialisation and clean-up
+int main(void) {
+  
+  // Initialisation
+  bones_initialize_target();
+  
+  // Original main function
+  int bones_return = bones_main();
+  
+  // Clean-up
+  clReleaseCommandQueue(bones_queue);
+  clReleaseProgram(bones_program);
+  clReleaseContext(bones_context);
+  return bones_return;
+}
+

data/skeletons/CPU-OPENCL-AMD/common/globals_kernel.c

@@ -0,0 +1,4 @@
+#define BONES_MIN(a,b) ((a<b) ? a : b)
+#define BONES_MAX(a,b) ((a>b) ? a : b)
+#define DIV_CEIL(a,b)  ((a+b-1)/b)
+#define DIV_FLOOR(a,b) (a/b)

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

@@ -0,0 +1,8 @@
+  
+  // 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);
+  
+  // Perform a copy of <array> from device to host
+  clEnqueueReadBuffer(bones_queue,device_<array>,CL_TRUE,(<offset>)*sizeof(<type>),<variable_dimensions>*sizeof(<type>),<array><flatten>+<offset>,0,NULL,NULL);
+  clFinish(bones_queue);

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

@@ -0,0 +1,4 @@
+  
+  // Copy <array> to the device
+  device_<array> = clCreateBuffer(bones_context,CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR,<variable_dimensions>*sizeof(<type>),<array><flatten>,NULL);
+  clFinish(bones_queue);

data/skeletons/CPU-OPENCL-AMD/common/mem_epilogue.c

@@ -0,0 +1,3 @@
+  
+  // Clean up GPU arrays
+  clReleaseMemObject(device_<array>);

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

@@ -0,0 +1,6 @@
+  
+  // 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);
+  
+  // Create a device pointer for <array>
+  cl_mem device_<array> = clCreateBuffer(bones_context,CL_MEM_READ_WRITE,<variable_dimensions>*sizeof(<type>),NULL,&bones_errors); error_check(bones_errors);

data/skeletons/CPU-OPENCL-AMD/common/prologue.c

@@ -0,0 +1,24 @@
+  fflush(stdout);
+  cl_int bones_errors;
+  cl_event bones_event;
+  
+  // Only compile if this program is different from the last one
+  if (strcmp(bones_last_program,"<algorithm_filename>") != 0) {
+    strcpy(bones_last_program,"<algorithm_filename>");
+    
+    // Load and compile the kernel
+    char *bones_source = get_source("<algorithm_filename>_device.cl");
+    bones_program = clCreateProgramWithSource(bones_context,1,(const char **)&bones_source,NULL,&bones_errors); error_check(bones_errors);
+    bones_errors = clBuildProgram(bones_program,0,NULL,"-cl-single-precision-constant",NULL,NULL);
+    
+    // Get and print the compiler log
+    char* bones_log;
+    size_t bones_log_size;
+    clGetProgramBuildInfo(bones_program,bones_device,CL_PROGRAM_BUILD_LOG,0,NULL,&bones_log_size);
+    bones_log = (char*)malloc((bones_log_size+1)*sizeof(char));
+    clGetProgramBuildInfo(bones_program,bones_device,CL_PROGRAM_BUILD_LOG,bones_log_size,bones_log, NULL);
+    bones_log[bones_log_size] = '\0';
+    //if (strcmp(bones_log,"\n") != 0 && strcmp(bones_log,"") != 0) { printf("--------- \n--- Compilation log:\n--------- \n%s\n",bones_log); }
+    free(bones_log);
+    error_check(bones_errors);
+  }

data/skeletons/CPU-OPENCL-AMD/common/timer_1_start.c

@@ -0,0 +1,5 @@
+  
+  // Start the timer for the measurement of the kernel and memory copy execution time
+  struct timeval bones_start_time1;
+  clFinish(bones_queue);
+  gettimeofday(&bones_start_time1, NULL);

data/skeletons/CPU-OPENCL-AMD/common/timer_1_stop.c

@@ -0,0 +1,9 @@
+  
+  // End the timer for the measurement of the kernel and memory copy execution time
+  #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 (<algorithm_basename>): Execution time [kernel+memcpy]: %.3lf ms \n", bones_timer1);
+  #endif

data/skeletons/CPU-OPENCL-AMD/common/timer_2_start.c

@@ -0,0 +1,16 @@
+  
+  // Start the timer for the measurement of the kernel execution time
+  clFinish(bones_queue);
+  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;
+    }
+  }
+  free(bones_flush_c);

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

@@ -0,0 +1,11 @@
+  
+  }
+  
+  // Stop the timer for the measurement of the kernel execution time
+  clFinish(bones_queue);
+  cl_ulong end2, start2;
+  bones_errors = clWaitForEvents(1, &bones_event); error_check(bones_errors);
+  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);

data/skeletons/CPU-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);