bones-compiler 1.1.0

data/skeletons/CPU-OPENCL-INTEL/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-INTEL/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-INTEL/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-INTEL/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-OPENMP/common/globals.c

@@ -0,0 +1,37 @@
+#include <omp.h>
+#include <stdlib.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
+
+// Function to initialize the CPU platform (for fair measurements)
+void bones_initialize_target(void) {
+  int bones_thread_count = omp_get_num_procs();
+  omp_set_num_threads(bones_thread_count);
+  #pragma omp parallel
+  {
+    int bones_thread_id = omp_get_thread_num();
+  }
+}
+
+// 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
+  return bones_return;
+}
+

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

@@ -0,0 +1,6 @@
+#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)
+
+#include <math.h>

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

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

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

@@ -0,0 +1,12 @@
+  
+  // 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_start.c

@@ -0,0 +1,18 @@
+  // 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)
+    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);
+    
+    // Start the timer for the measurement of the kernel execution time
+    gettimeofday(&bones_start_time2, NULL);

data/skeletons/CPU-OPENMP/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-OPENMP/kernel/D-element-to-1-shared.host.c

@@ -0,0 +1,27 @@
+  
+  if (<in0_dimensions> > 0) {
+    
+    // Store the initial value
+    <out0_type> bones_initial_value = <out0_name>[0];
+    
+    // Create a temporary array to store intermediate data
+    int bones_thread_count = BONES_MIN(omp_get_num_procs(),<in0_dimensions>);
+    <out0_type>* bones_temporary = (<out0_type>*)malloc(bones_thread_count*sizeof(<out0_type>));
+    
+    // Run multiple OpenMP threads
+    omp_set_num_threads(bones_thread_count);
+    #pragma omp parallel
+    {
+      int bones_thread_id = omp_get_thread_num();
+      
+      // Perform the major part of the computation in parallel
+      bones_kernel_<algorithm_name>_0(bones_thread_id, bones_thread_count, <in0_dimensions>, <in_devicenames>, bones_temporary, <argument_name>);
+    }
+    
+    // Compute the second part of the algorithm with only one thread
+    bones_kernel_<algorithm_name>_1(bones_thread_count, bones_temporary, <out_devicenames>, <argument_name>);
+    free(bones_temporary);
+    
+    // Perform the last computation (only needed if there is an initial value)
+    bones_kernel_<algorithm_name>_2(bones_initial_value,<out0_name>,<argument_name>);
+  }

data/skeletons/CPU-OPENMP/kernel/D-element-to-1-shared.kernel.c

@@ -0,0 +1,46 @@
+/* STARTDEF
+void bones_kernel_<algorithm_name>_0(int bones_thread_id, int bones_thread_count, int bones_size, <devicedefinitions>, <argument_definition>);
+void bones_kernel_<algorithm_name>_1(int bones_size, <devicedefinitions>, <argument_definition>);
+void bones_kernel_<algorithm_name>_2(<out0_type> bones_initial_value, <out0_type><out0_devicepointer> <out0_name>, <argument_definition>);
+ENDDEF */
+// Start of the <algorithm_name> kernel (main part)
+void bones_kernel_<algorithm_name>_0(int bones_thread_id, int bones_thread_count, int bones_size, <devicedefinitions>, <argument_definition>) {
+  const int bones_work = DIV_CEIL(bones_size,bones_thread_count);
+  const int bones_global_id = bones_thread_id;
+  <ids>
+  int bones_iter_id = <in0_flatindex>;
+  
+  // Use a thread private memory to perform the per-thread computation(s)
+  <in0_type> bones_temporary = <in0_name>[bones_iter_id];
+  <in0_type> bones_private_memory = <algorithm_code2>;
+  for(int c=1; c<bones_work; c++) {
+    bones_iter_id = bones_iter_id + bones_thread_count<factors>;
+    if (bones_iter_id <= <in0_to>) {
+      bones_temporary = <in0_name>[bones_iter_id];
+      bones_private_memory = <algorithm_code1>;
+    }
+  }
+  
+  // Store the result
+  <out0_name>[bones_thread_id] = bones_private_memory;
+}
+
+// Start of the <algorithm_name> kernel (secondary part)
+void bones_kernel_<algorithm_name>_1(int bones_size, <devicedefinitions>, <argument_definition>) {
+  
+  // Use a private memory to perform the sequential computation(s)
+  <in0_type> bones_private_memory = <in0_name>[0];
+  for(int bones_iter_id=1; bones_iter_id<bones_size; bones_iter_id++) {
+    bones_private_memory = bones_private_memory + <in0_name>[bones_iter_id];
+  }
+  
+  // Store the result
+  <out0_name>[0] = bones_private_memory;
+}
+
+// Start of the <algorithm_name> kernel (final, initial value kernel)
+void bones_kernel_<algorithm_name>_2(<out0_type> bones_initial_value, <out0_type><out0_devicepointer> <out0_name>, <argument_definition>) {
+  <out0_type> bones_private_memory = <out0_name>[0];
+  <out0_type> bones_temporary = bones_initial_value;
+  <out0_name>[0] = <algorithm_code3>;
+}

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

@@ -0,0 +1,11 @@
+  
+  // Run multiple OpenMP threads
+  int bones_thread_count = omp_get_num_procs();
+  omp_set_num_threads(bones_thread_count);
+  #pragma omp parallel
+  {
+    int bones_thread_id = omp_get_thread_num();
+    
+    // Start the kernel
+    bones_kernel_<algorithm_name>_0(bones_thread_id, bones_thread_count, <devicenames>, <argument_name>);
+  }

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

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

data/skeletons/CPU-OPENMP/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 04 05
+D|void                                         -> D|element+               :default                        :00
+
+#D|element+                                     -> D|shared+                :default                        :00
+#D|element+                                     -> D|element+ ^ D|shared+   :default                        :00
+

data/skeletons/GPU-CUDA/common/globals.c

@@ -0,0 +1,31 @@
+#include <stdio.h>
+#include <cuda_runtime.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)
+
+// Function to initialize the GPU (for fair measurements)
+void bones_initialize_target(void) {
+  int* bones_temporary = 0;
+  cudaMalloc((void**)&bones_temporary, sizeof(int));
+  cudaFree(bones_temporary);
+}
+
+// Declaration of the original function
+int bones_main(void);
+
+// New main function for initialisation and clean-up
+int main(void) {
+  
+  // Initialisation of the target
+  bones_initialize_target();
+  
+  // Original main function
+  int bones_return = bones_main();
+  
+  // Clean-up
+  return bones_return;
+}
+

data/skeletons/GPU-CUDA/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-CUDA/common/mem_copy_D2H.c

@@ -0,0 +1,3 @@
+  
+  // Copy <array> from device to host
+  cudaMemcpy(<array><flatten>+<offset>, device_<array>+<offset>, <variable_dimensions>*sizeof(<type>), cudaMemcpyDeviceToHost);

data/skeletons/GPU-CUDA/common/mem_copy_H2D.c

@@ -0,0 +1,3 @@
+  
+  // Copy <array> to the device
+  cudaMemcpy(device_<array>, <array><flatten>, <variable_dimensions>*sizeof(<type>), cudaMemcpyHostToDevice);

data/skeletons/GPU-CUDA/common/mem_epilogue.c

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

data/skeletons/GPU-CUDA/common/mem_prologue.c

@@ -0,0 +1,5 @@
+  
+  // Create space for <array> on the device
+  <type>* device_<array> = 0;
+  cudaMalloc((void**)&device_<array>, <variable_dimensions>*sizeof(<type>));
+  cudaMemset((void*)device_<array>, 0, <variable_dimensions>*sizeof(<type>));