bones-compiler 1.1.0 → 1.3.1

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

@@ -1,24 +1,42 @@
-#include <stdio.h>
-#include <cuda_runtime.h>
+
+////////////////////////////////////////
+//////////// Globals ///////////////////
+////////////////////////////////////////
 
 #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)
+// CUDA timers
+cudaEvent_t bones_start2;
+cudaEvent_t bones_stop2;
+
+// Function to initialize the GPU (for fair measurements, streams, timers)
 void bones_initialize_target(void) {
   int* bones_temporary = 0;
   cudaMalloc((void**)&bones_temporary, sizeof(int));
   cudaFree(bones_temporary);
+  cudaStreamCreate(&kernel_stream);
+  cudaEventCreate(&bones_start2);
+  cudaEventCreate(&bones_stop2);
 }
 
 // Declaration of the original function
 int bones_main(void);
 
+////////////////////////////////////////
+//////////// Main function /////////////
+////////////////////////////////////////
+
 // New main function for initialisation and clean-up
 int main(void) {
   
+  // Initialisation of the scheduler
+  bones_initialize_scheduler();
+  pthread_t bones_scheduler_thread;
+  pthread_create(&bones_scheduler_thread, NULL, bones_scheduler, NULL);
+  
   // Initialisation of the target
   bones_initialize_target();
   
@@ -26,6 +44,12 @@ int main(void) {
   int bones_return = bones_main();
   
   // Clean-up
+  bones_scheduler_done = 1;
+  pthread_join(bones_scheduler_thread, NULL);
+  cudaStreamDestroy(kernel_stream);
   return bones_return;
 }
 
+////////////////////////////////////////
+////////// Accelerated functions ///////
+////////////////////////////////////////

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

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

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

@@ -0,0 +1,6 @@
+
+// Create space for <array> on the device
+void bones_alloc_<id>_<array>(void) {
+  cudaMalloc((void**)&device_<array>, <variable_dimensions>*sizeof(<type>));
+  cudaMemset((void*)device_<array>, 0, <variable_dimensions>*sizeof(<type>));
+}

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

@@ -0,0 +1,6 @@
+
+// Copy <array> to the device
+void bones_copy<direction>_<id>_<array>(<definition>) {
+  cudaStreamSynchronize(kernel_stream);
+  bones_memcpy(device_<array>, <array><flatten>, <variable_dimensions>*sizeof(<type>), cudaMemcpyHostToDevice, <state>, <index>);
+}

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

@@ -0,0 +1,6 @@
+
+// Copy <array> from device to host
+void bones_copy<direction>_<id>_<array>(<definition>) {
+  cudaStreamSynchronize(kernel_stream);
+  bones_memcpy(<array><flatten>+<offset>, device_<array>+<offset>, <variable_dimensions>*sizeof(<type>), cudaMemcpyDeviceToHost, <state>, <index>);
+}

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

@@ -0,0 +1,6 @@
+
+// Clean up array <array> from the device
+void bones_free_<id>_<array>(void) {
+  cudaStreamSynchronize(kernel_stream);
+  cudaFree(device_<array>);
+}

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

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

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

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

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

@@ -0,0 +1 @@
+<type>* device_<array>;

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

@@ -1,5 +1,4 @@
   
   // 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>));
+  //cudaMemset((void*)device_<array>, 0, <variable_dimensions>*sizeof(<type>));

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

@@ -0,0 +1,86 @@
+
+#include <stdio.h>
+#include <pthread.h>
+
+////////////////////////////////////////
+////////// Thread scheduler ////////////
+////////////////////////////////////////
+
+// Memory copy and kernel streams
+cudaStream_t kernel_stream;
+cudaStream_t memory_stream;
+
+// Task structure
+typedef struct {
+  void *dst;
+  void *src;
+  int size;
+  enum cudaMemcpyKind direction;
+  int deadline;
+  volatile int status;
+} Task;
+
+// Task list
+#define BONES_MAX_TASKS 100
+Task tasks[BONES_MAX_TASKS];
+
+// Scheduler status
+volatile int bones_scheduler_done;
+
+// Create synchronisation points
+void bones_synchronize(int deadline) {
+  cudaStreamSynchronize(kernel_stream);
+  printf("Reached: syncpoint %d [worker]\n",deadline); fflush(stdout);
+  for (int t = 0; t <= BONES_MAX_TASKS; t++) {
+    if (tasks[t].deadline == deadline && tasks[t].status == 1) {
+      while(tasks[t].status != 2) { }
+    }
+  }
+  printf("Reached: syncpoint %d [all]\n",deadline); fflush(stdout);
+}
+
+// Add a new task
+void bones_memcpy(void *dst, void *src, int size, enum cudaMemcpyKind direction, int deadline, int task_id) {
+  Task new_task = { .dst = dst, .src = src, .size = size, .direction = direction, .deadline = deadline, .status = 1 };
+  tasks[task_id] = new_task;
+}
+
+// Perform a task (CUDA memory copy)
+void bones_scheduler_copy(Task current_task) {
+  usleep(400);
+  cudaMemcpyAsync(current_task.dst, current_task.src, current_task.size, current_task.direction, memory_stream);
+  cudaStreamSynchronize(memory_stream);
+}
+
+// Initialize the scheduler
+void bones_initialize_scheduler(void) {
+  bones_scheduler_done = 0;
+}
+
+// The scheduler (infinite loop)
+#define LARGE_INT 1000
+void* bones_scheduler(void* ptr) {
+  cudaStreamCreate(&memory_stream);
+  while (bones_scheduler_done != 1) {
+    
+    // Find the ready task with the earliest deadline
+    int found_deadline = LARGE_INT;
+    int found_task = LARGE_INT;
+    for (int t = 0; t <= BONES_MAX_TASKS; t++) {
+      if (tasks[t].status == 1) {
+        if (tasks[t].deadline < found_deadline) {
+          found_task = t;
+          found_deadline = tasks[t].deadline;
+        }
+      }
+    }
+    
+    // Perform the found task
+    if (found_task != LARGE_INT) {
+      printf("Performing task %d, dl %d [scheduler]\n",found_task,tasks[found_task].deadline);
+      bones_scheduler_copy(tasks[found_task]);
+      tasks[found_task].status = 2;
+    }
+  }
+  cudaStreamDestroy(memory_stream);
+}

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

@@ -1,6 +1,4 @@
   
   // Start the timer for the measurement of the kernel execution time
-  cudaThreadSynchronize();
-  cudaEvent_t bones_start2;
-  cudaEventCreate(&bones_start2);
-  cudaEventRecord(bones_start2,0);
+  //cudaStreamSynchronize(kernel_stream);
+  cudaEventRecord(bones_start2,kernel_stream);

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

@@ -1,10 +1,8 @@
   
   // Stop the timer for the measurement of the kernel execution time
-  cudaThreadSynchronize();
-  cudaEvent_t bones_stop2;
-  cudaEventCreate(&bones_stop2);
-  cudaEventRecord(bones_stop2,0);
+  //cudaStreamSynchronize(kernel_stream);
+  cudaEventRecord(bones_stop2,kernel_stream);
   cudaEventSynchronize(bones_stop2);
   float bones_timer2 = 0;
   cudaEventElapsedTime(&bones_timer2,bones_start2,bones_stop2);
-  printf(">>>\t\t (<algorithm_basename>): Execution time [kernel       ]: %.3lf ms \n", bones_timer2);
+  printf(">>>\t\t Execution time [kernel <algorithm_basename>]: %.3lf ms \n", bones_timer2);

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

@@ -0,0 +1,26 @@
+
+////////////////////////////////////////
+//////////// Timers ////////////////////
+////////////////////////////////////////
+
+// Timer
+cudaEvent_t bones_start1;
+
+// Start the timer for the measurement of the whole scop
+void bones_timer_start() {
+  cudaDeviceSynchronize();
+  cudaEventCreate(&bones_start1);
+  cudaEventRecord(bones_start1,kernel_stream);
+}
+
+// End the timer for the measurement of the whole scop
+void bones_timer_stop() {
+  cudaDeviceSynchronize();
+  cudaEvent_t bones_stop1;
+  cudaEventCreate(&bones_stop1);
+  cudaEventRecord(bones_stop1,kernel_stream);
+  cudaEventSynchronize(bones_stop1);
+  float bones_timer1 = 0;
+  cudaEventElapsedTime(&bones_timer1,bones_start1,bones_stop1);
+  printf(">>>\t\t Execution time [full scop]: %.3lf ms \n", bones_timer1);
+}

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

@@ -72,11 +72,9 @@ __global__ void bones_kernel_<algorithm_name>_2(<in1_type><in1_devicepointer> <i
 // 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; }
+  if      (<parallelism> >= 64*512 ) { bones_block_size = 512; }
+  else if (<parallelism> >= 64*256 ) { bones_block_size = 256; }
+  else                               { bones_block_size = 128; }
   
   // First perform some pre-shuffling (for the first input)
   <in0_type>* shuffled_<in0_name> = 0;
@@ -86,7 +84,7 @@ extern "C" void bones_prekernel_<algorithm_name>_0(<devicedefinitions>, <argumen
   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>);
+  //cudaFree(temp_<in0_name>);
   
   // First perform some pre-shuffling (for the second input)
   <in0_type>* shuffled_<in1_name> = 0;
@@ -96,7 +94,7 @@ extern "C" void bones_prekernel_<algorithm_name>_0(<devicedefinitions>, <argumen
   bones_kernel_<algorithm_name>_2<<< bones_grid2, bones_threads2 >>>(<in1_name>, shuffled_<in1_name>, <argument_name>);
   <in1_type>* temp_<in1_name> = <in1_name>;
   <in1_name> = shuffled_<in1_name>;
-  cudaFree(temp_<in1_name>);
+  //cudaFree(temp_<in1_name>);
   
   // Then run the original kernel
   dim3 bones_threads0(bones_block_size);

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

@@ -46,11 +46,9 @@ __global__ void bones_kernel_<algorithm_name>_1(<in0_type><in0_devicepointer> <i
 // 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; }
+  if      (<parallelism> >= 64*512 ) { bones_block_size = 512; }
+  else if (<parallelism> >= 64*256 ) { bones_block_size = 256; }
+  else                               { bones_block_size = 128; }
   
   // First perform some pre-shuffling
   <in0_type>* shuffled_<in0_name> = 0;
@@ -60,7 +58,7 @@ extern "C" void bones_prekernel_<algorithm_name>_0(<devicedefinitions>, <argumen
   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>);
+  //cudaFree(temp_<in0_name>);
   
   // Then run the original kernel
   dim3 bones_threads0(bones_block_size);

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

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

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

@@ -1,5 +1,5 @@
 /* STARTDEF
-void bones_prekernel_<algorithm_name>_0(<devicedefinitions>, <argument_definition>);
+void bones_prekernel_<algorithm_name>_0(cudaStream_t kernel_stream, <devicedefinitions>, <argument_definition>);
 ENDDEF */
 // Start of the <algorithm_name> kernel
 __global__ void bones_kernel_<algorithm_name>_0(<devicedefinitions>, <argument_definition>) {
@@ -15,14 +15,12 @@ __global__ void bones_kernel_<algorithm_name>_0(<devicedefinitions>, <argument_d
 }
 
 // Function to start the kernel
-extern "C" void bones_prekernel_<algorithm_name>_0(<devicedefinitions>, <argument_definition>) {
+extern "C" void bones_prekernel_<algorithm_name>_0(cudaStream_t kernel_stream, <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; }
+  if      (<parallelism> >= 64*512 ) { bones_block_size = 512; }
+  else if (<parallelism> >= 64*256 ) { bones_block_size = 256; }
+  else                               { bones_block_size = 128; }
   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>);
+  bones_kernel_<algorithm_name>_0<<< bones_grid, bones_threads, 0, kernel_stream >>>(<names>, <argument_name>);
 }

data/skeletons/GPU-CUDA/skeletons.txt

@@ -19,12 +19,13 @@ N,N|chunk(D)+ ^ N,N|element+                   -> N,N|element+             :defa
 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|neighbourhood(D)+                            -> D|element+               :default                             :40
+D|neighbourhood(D)+ ^ D|element+               -> D|element+               :default                             :40
 D|element+                                     -> D|chunk(D)+              :default                             :00
-D|element+                                     -> D|element+               :default                             :00
+D|element+                                     -> D|element+               :default                             :40
 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
+D|void                                         -> D|element+               :default                             :40
+
+N|neighbourhood(N)+                            -> N|element+               :N-neighbourhood-N-to-N-element      :10

data/{examples/benchmarks/2mm.c → test/examples/benchmarks/PolyBench/2mm_species.c}

@@ -42,26 +42,30 @@ int main(void) {
 	for (i=0; i<NI; i++) { for (j=0; j<NL; j++) { D[i][j] = ((float) i*(j+2)) / NK; } }
 	
 	// Perform the computation (E := alpha*A*B*C + beta*D)
-	#pragma species kernel 0:NI-1,0:NK-1|chunk(0:0,0:NK-1) ^ 0:NK-1,0:NJ-1|chunk(0:NK-1,0:0) -> 0:NI-1,0:NJ-1|element
-	for (i=0; i<NI; i++) {
-		for (j=0; j<NJ; j++) {
-			tmp[i][j] = 0;
-			for (k=0; k<NK; k++) {
-				tmp[i][j] += alpha * A[i][k] * B[k][j];
+	#pragma scop
+	{
+		#pragma species kernel A[0:NI-1,0:NK-1]|chunk(0:0,0:NK-1) ^ B[0:NK-1,0:NJ-1]|chunk(0:NK-1,0:0) -> tmp[0:NI-1,0:NJ-1]|element
+		for (i = 0; i < NI; i++) {
+			for (j = 0; j < NJ; j++) {
+				tmp[i][j] = 0;
+				for (k = 0; k < NK; k++) {
+					tmp[i][j] += alpha * A[i][k] * B[k][j];
+				}
 			}
 		}
-	}
-	#pragma species endkernel 2mm-part1
-	#pragma species kernel 0:NI-1,0:NL-1|element ^ 0:NI-1,0:NJ-1|chunk(0:0,0:NJ-1) ^ 0:NJ-1,0:NL-1|chunk(0:NJ-1,0:0) -> 0:NI-1,0:NL-1|element
-	for (i=0; i<NI; i++) {
-		for (j=0; j<NL; j++) {
-			D[i][j] *= beta;
-			for (k=0; k<NJ; k++) {
-				D[i][j] += tmp[i][k] * C[k][j];
+		#pragma species endkernel 2mm_k1
+		#pragma species kernel D[0:NI-1,0:NL-1]|element ^ tmp[0:NI-1,0:NJ-1]|chunk(0:0,0:NJ-1) ^ C[0:NJ-1,0:NL-1]|chunk(0:NJ-1,0:0) -> D[0:NI-1,0:NL-1]|element
+		for (i = 0; i < NI; i++) {
+			for (j = 0; j < NL; j++) {
+				D[i][j] *= beta;
+				for (k = 0; k < NJ; k++) {
+					D[i][j] += tmp[i][k] * C[k][j];
+				}
 			}
 		}
+		#pragma species endkernel 2mm_k2
 	}
-	#pragma species endkernel 2mm-part2
+	#pragma endscop
 	
 	// Clean-up and exit the function
 	fflush(stdout);

data/test/examples/benchmarks/PolyBench/3mm_species.c

@@ -0,0 +1,82 @@
+//
+// This file is part of the Bones source-to-source compiler examples. The C-code
+// is largely identical in terms of functionality and variable naming to the code
+// found in PolyBench/C version 3.2. For more information on PolyBench/C or Bones
+// please use the contact information below.
+//
+// == More information on PolyBench/C
+// Contact............Louis-Noel Pouchet <pouchet@cse.ohio-state.edu>
+// Web address........http://polybench.sourceforge.net/
+// 
+// == More information on Bones
+// Contact............Cedric Nugteren <c.nugteren@tue.nl>
+// Web address........http://parse.ele.tue.nl/bones/
+//
+// == File information
+// Filename...........benchmark/3mm.c
+// Author.............Cedric Nugteren
+// Last modified on...03-April-2012
+//
+
+#include "common.h"
+
+// This is '3mm', a 3 matrix multiply kernel
+int main(void) {
+	int i,j,k;
+	
+	// Declare arrays on the stack
+	float A[NI][NK];
+	float B[NK][NJ];
+	float C[NJ][NM];
+	float D[NM][NL];
+	float E[NI][NJ];
+	float F[NJ][NL];
+	float G[NI][NL];
+	
+	// Set the input data
+	for (i=0; i<NI; i++) { for (j=0; j<NK; j++) { A[i][j] = ((float) i*j) / NI; } }
+	for (i=0; i<NK; i++) { for (j=0; j<NJ; j++) { B[i][j] = ((float) i*(j+1)) / NJ; } }
+	for (i=0; i<NL; i++) { for (j=0; j<NJ; j++) { C[i][j] = ((float) i*(j+3)) / NL; } }
+	for (i=0; i<NI; i++) { for (j=0; j<NL; j++) { D[i][j] = ((float) i*(j+2)) / NK; } }
+	
+	// Perform the computation (G := E*F, with E := A*B and F := C*D)
+	#pragma scop
+	{
+		#pragma species kernel A[0:NI-1,0:NK-1]|chunk(0:0,0:NK-1) ^ B[0:NK-1,0:NJ-1]|chunk(0:NK-1,0:0) -> E[0:NI-1,0:NJ-1]|element
+		for (i = 0; i < NI; i++) {
+			for (j = 0; j < NJ; j++) {
+				E[i][j] = 0;
+				for (k = 0; k < NK; k++) {
+					E[i][j] += A[i][k] * B[k][j];
+				}
+			}
+		}
+		#pragma species endkernel 3mm_k1
+		#pragma species kernel C[0:NJ-1,0:NM-1]|chunk(0:0,0:NM-1) ^ D[0:NM-1,0:NL-1]|chunk(0:NM-1,0:0) -> F[0:NJ-1,0:NL-1]|element
+		for (i = 0; i < NJ; i++) {
+			for (j = 0; j < NL; j++) {
+				F[i][j] = 0;
+				for (k = 0; k < NM; k++) {
+					F[i][j] += C[i][k] * D[k][j];
+				}
+			}
+		}
+		#pragma species endkernel 3mm_k2
+		#pragma species kernel E[0:NI-1,0:NJ-1]|chunk(0:0,0:NJ-1) ^ F[0:NJ-1,0:NL-1]|chunk(0:NJ-1,0:0) -> G[0:NI-1,0:NL-1]|element
+		for (i = 0; i < NI; i++) {
+			for (j = 0; j < NL; j++) {
+				G[i][j] = 0;
+				for (k = 0; k < NJ; k++) {
+					G[i][j] += E[i][k] * F[k][j];
+				}
+			}
+		}
+		#pragma species endkernel 3mm_k3
+	}
+	#pragma endscop
+	
+	// Clean-up and exit the function
+	fflush(stdout);
+	return 0;
+}
+