bones-compiler 1.1.0

data/skeletons/CPU-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/CPU-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[] = {DIV_CEIL(<parallelism>,8)*8};
+  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/CPU-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/CPU-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/CPU-OPENCL-INTEL/common/epilogue.c

@@ -0,0 +1,3 @@
+  
+  // Clean-up the OpenCL context
+  fflush(stdout);

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

@@ -0,0 +1,154 @@
+#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,"Intel") != 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(NULL,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);
+  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-INTEL/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-INTEL/common/header.c

@@ -0,0 +1,31 @@
+#include <stdlib.h>
+
+// Allocate a 128-byte aligned pointer
+void *bones_malloc_128(size_t bones_size) {
+  char *bones_pointer;
+  char *bones_pointer2;
+  char *bones_aligned_pointer;
+  
+  // Allocate the memory plus a little bit extra
+  bones_pointer = (char *)malloc(bones_size + 128 + sizeof(int));
+  if(bones_pointer==NULL) { return(NULL); }
+  
+  // Create the aligned pointer
+  bones_pointer2 = bones_pointer + sizeof(int);
+  bones_aligned_pointer = bones_pointer2 + (128 - ((size_t)bones_pointer2 & 127));
+  
+  // Set the padding size
+  bones_pointer2 = bones_aligned_pointer - sizeof(int);
+  *((int *)bones_pointer2) = (int)(bones_aligned_pointer - bones_pointer);
+  
+  // Return the 128-byte aligned pointer
+  return (bones_aligned_pointer);
+}
+
+// Free the 128-byte aligned pointer
+void bones_free_128(void *bones_pointer) {
+  int *bones_pointer2 = (int *)bones_pointer - 1;
+  bones_pointer = (char *)bones_pointer - *bones_pointer2;
+  free(bones_pointer);
+}
+

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

@@ -0,0 +1,5 @@
+  
+  // 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);
+  clFinish(bones_queue);

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

@@ -0,0 +1,3 @@
+  
+  //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);

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

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

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

@@ -0,0 +1,4 @@
+  
+  // 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);

data/skeletons/CPU-OPENCL-INTEL/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,"",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-INTEL/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-INTEL/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-INTEL/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-INTEL/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-INTEL/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);