bones-compiler 1.1.0

data/skeletons/GPU-CUDA/kernel/N-N-chunk-1-N-to-D-element.host.c

@@ -0,0 +1,3 @@
+  
+  // Start the CUDA function
+  bones_prekernel_<algorithm_name>_0(<devicenames>, <argument_name>);

data/skeletons/GPU-CUDA/kernel/N-N-chunk-1-N-to-D-element.kernel.cu

@@ -0,0 +1,69 @@
+/* STARTDEF
+void bones_prekernel_<algorithm_name>_0(<devicedefinitions>, <argument_definition>);
+ENDDEF */
+#define SHUFFLE_X 16
+#define SHUFFLE_Y 16
+
+// Start of the <algorithm_name> kernel
+__global__ void bones_kernel_<algorithm_name>_0(<devicedefinitions>, <argument_definition>) {
+  const int bones_global_id = blockIdx.x*blockDim.x + threadIdx.x;
+  if (bones_global_id < (<parallelism>)) {
+    
+    // Calculate the global ID(s) based on the thread id
+    <ids>
+    
+    // Start the computation
+<algorithm_code1>
+  }
+}
+
+// Start of the <algorithm_name> kernel (pre-kernel for shuffling)
+__global__ void bones_kernel_<algorithm_name>_1(<in0_type><in0_devicepointer> <in0_name>, <in0_type><in0_devicepointer> shuffled_<in0_name>, <argument_definition>) {
+  const int bones_global_id_0 = blockIdx.x*blockDim.x + threadIdx.x;
+  const int bones_global_id_1 = blockIdx.y*blockDim.y + threadIdx.y;
+  
+  // Set-up the local memory for shuffling
+  __shared__ <in0_type> buffer[SHUFFLE_X][SHUFFLE_Y];
+  
+  // Swap the x and y coordinates to perform the rotation (coalesced)
+  if (bones_global_id_0 < ((<in0_dimensions>)/(<in0_parameters>)) && bones_global_id_1 < (<in0_parameters>)) {
+    buffer[threadIdx.y][threadIdx.x] = <in0_name>[bones_global_id_0 + bones_global_id_1 * ((<in0_dimensions>)/(<in0_parameters>))];
+  }
+  
+  // Synchronize all threads in the threadblock
+  __syncthreads();
+  
+  // We don't have to swap the x and y thread indices here, because that's already done in the local memory
+  const int bones_global_id_0_new = blockIdx.y*blockDim.y + threadIdx.x;
+  const int bones_global_id_1_new = blockIdx.x*blockDim.x + threadIdx.y;
+  
+  // Store the shuffled result (coalesced)
+  if (bones_global_id_0_new < ((<in0_dimensions>)/(<in0_parameters>)) && bones_global_id_1_new < (<in0_parameters>)) {
+    shuffled_<in0_name>[bones_global_id_0_new + bones_global_id_1_new * <in0_parameters>] =  buffer[threadIdx.x][threadIdx.y];
+  }
+}
+
+// Function to start the kernel
+extern "C" void bones_prekernel_<algorithm_name>_0(<devicedefinitions>, <argument_definition>) {
+  int bones_block_size;
+  if      (<parallelism> >= 64*512) { bones_block_size = 512;}
+  else if (<parallelism> >= 64*256) { bones_block_size = 256;}
+  else if (<parallelism> >= 64*128) { bones_block_size = 128;}
+  else if (<parallelism> >= 64*64 ) { bones_block_size = 64; }
+  else { bones_block_size = 32; }
+  
+  // First perform some pre-shuffling
+  <in0_type>* shuffled_<in0_name> = 0;
+  cudaMalloc((void**)&shuffled_<in0_name>, <in0_dimensions>*sizeof(<in0_type>));
+  dim3 bones_threads1(SHUFFLE_X,SHUFFLE_Y);
+  dim3 bones_grid1(DIV_CEIL(((<in0_dimensions>)/(<in0_parameters>)),SHUFFLE_X),DIV_CEIL(<in0_parameters>,SHUFFLE_Y));
+  bones_kernel_<algorithm_name>_1<<< bones_grid1, bones_threads1 >>>(<in0_name>, shuffled_<in0_name>, <argument_name>);
+  <in0_type>* temp_<in0_name> = <in0_name>;
+  <in0_name> = shuffled_<in0_name>;
+  cudaFree(temp_<in0_name>);
+  
+  // Then run the original kernel
+  dim3 bones_threads0(bones_block_size);
+  dim3 bones_grid0(DIV_CEIL(<parallelism>,bones_block_size));
+  bones_kernel_<algorithm_name>_0<<< bones_grid0, bones_threads0 >>>(<names>, <argument_name>);
+}

data/skeletons/GPU-CUDA/kernel/N-neighbourhood-N-to-N-element.host.c

@@ -0,0 +1,3 @@
+  
+  // Start the CUDA function
+  bones_prekernel_<algorithm_name>_0(<devicenames>, <argument_name>);

data/skeletons/GPU-CUDA/kernel/N-neighbourhood-N-to-N-element.kernel.cu

@@ -0,0 +1,42 @@
+/* STARTDEF
+void bones_prekernel_<algorithm_name>_0(<devicedefinitions>, <argument_definition>);
+ENDDEF */
+// Start of the <algorithm_name> kernel
+__global__ void bones_kernel_<algorithm_name>_0(<devicedefinitions>, <argument_definition>) {
+  const int bones_global_id = blockIdx.x*blockDim.x + threadIdx.x;
+  int bones_local_id = threadIdx.x;
+  if (bones_global_id < <in0_dimensions>) {
+    
+    // Calculate the local and global ID(s) based on the thread id
+    int bones_local_id_0 = bones_local_id;
+    <out0_ids>
+    
+    // Load the input data into local memory
+    __shared__ <in0_type> bones_local_memory_<in0_name>[512+<in0_parameter0_sum>];
+    bones_local_id_0 = bones_local_id_0-(<in0_parameter0_from>);
+    bones_local_memory_<in0_name>[bones_local_id_0] = <in0_name>[bones_global_id_0];
+    
+    // Load the left border into local memory
+    if (threadIdx.x < -(<in0_parameter0_from>)) {
+      bones_local_memory_<in0_name>[bones_local_id_0+<in0_parameter0_from>] = <in0_name>[bones_global_id_0+<in0_parameter0_from>];
+    }
+    
+    // Load the right border into local memory
+    if ((threadIdx.x >= 512-<in0_parameter0_to>) || (bones_global_id_0 >= <in0_dimensions>-<in0_parameter0_to>)) {
+      bones_local_memory_<in0_name>[bones_local_id_0+<in0_parameter0_to>] = <in0_name>[bones_global_id_0+<in0_parameter0_to>];
+    }
+    
+    // Synchronize all the threads in a threadblock
+    __syncthreads();
+    
+    // Perform the main computation
+<algorithm_code1>
+  }
+}
+
+// Function to start the kernel
+extern "C" void bones_prekernel_<algorithm_name>_0(<devicedefinitions>, <argument_definition>) {
+  dim3 bones_threads(512);
+  dim3 bones_grid(DIV_CEIL(<in0_dimensions>,512));
+  bones_kernel_<algorithm_name>_0<<< bones_grid, bones_threads >>>(<names>, <argument_name>);
+}

data/skeletons/GPU-CUDA/kernel/default.host.c

@@ -0,0 +1,3 @@
+  
+  // Start the CUDA function
+  bones_prekernel_<algorithm_name>_0(<devicenames>, <argument_name>);

data/skeletons/GPU-CUDA/kernel/default.kernel.cu

@@ -0,0 +1,28 @@
+/* STARTDEF
+void bones_prekernel_<algorithm_name>_0(<devicedefinitions>, <argument_definition>);
+ENDDEF */
+// Start of the <algorithm_name> kernel
+__global__ void bones_kernel_<algorithm_name>_0(<devicedefinitions>, <argument_definition>) {
+  const int bones_global_id = blockIdx.x*blockDim.x + threadIdx.x;
+  if (bones_global_id < (<parallelism>)) {
+    
+    // Calculate the global ID(s) based on the thread id
+    <ids>
+    
+    // Start the computation
+<algorithm_code1>
+  }
+}
+
+// Function to start the kernel
+extern "C" void bones_prekernel_<algorithm_name>_0(<devicedefinitions>, <argument_definition>) {
+  int bones_block_size;
+  if      (<parallelism> >= 64*512) { bones_block_size = 512;}
+  else if (<parallelism> >= 64*256) { bones_block_size = 256;}
+  else if (<parallelism> >= 64*128) { bones_block_size = 128;}
+  else if (<parallelism> >= 64*64 ) { bones_block_size = 64; }
+  else { bones_block_size = 32; }
+  dim3 bones_threads(bones_block_size);
+  dim3 bones_grid(DIV_CEIL(<parallelism>,bones_block_size));
+  bones_kernel_<algorithm_name>_0<<< bones_grid, bones_threads >>>(<names>, <argument_name>);
+}

data/skeletons/GPU-CUDA/skeletons.txt

@@ -0,0 +1,30 @@
+###################################################################
+# 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
+N,N|chunk(1,N) ^ N,N|chunk(1,N)+               -> D|element+               :2xN-N-chunk-1-N-to-D-element        :30
+N,N|chunk(1,N) ^ N,N|chunk(1,N)+ ^ D|element+  -> D|element+               :2xN-N-chunk-1-N-to-D-element        :30
+N,N|chunk(1,N)+                                -> D|element+               :N-N-chunk-1-N-to-D-element          :20
+N,N|chunk(1,N)+ ^ D|element+                   -> D|element+               :N-N-chunk-1-N-to-D-element          :20
+N,N|chunk(D)+                                  -> N,N|element+             :default                             :40
+N,N|chunk(D)+ ^ N,N|element+                   -> N,N|element+             :default                             :40
+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+               :N-neighbourhood-N-to-N-element      :10
+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|element+                                     -> D|shared+                :default                             :08
+D|element+                                     -> D|element+ ^ D|shared+   :default                             :08
+D|void                                         -> D|element+               :default                             :00

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

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

data/skeletons/GPU-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_GPU, 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/GPU-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/GPU-OPENCL-AMD/common/mem_copy_D2H.c

@@ -0,0 +1,4 @@
+  
+  // 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/GPU-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/GPU-OPENCL-AMD/common/mem_epilogue.c

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

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

@@ -0,0 +1,3 @@
+  
+  // 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/GPU-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/GPU-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/GPU-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/GPU-OPENCL-AMD/common/timer_2_start.c

@@ -0,0 +1,4 @@
+  
+  // Start the timer for the measurement of the kernel execution time
+  clFinish(bones_queue);
+  for (int bones_iter=0; bones_iter<ITERS; bones_iter++) {

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