socl: fix code to follow coding conventions

socl/src/cl_buildprogram.c

@@ -16,103 +16,107 @@
 
 #include "socl.h"
 
-struct bp_data {
-   cl_program program;
-   char * options;
-   const cl_device_id * device_list;
-   cl_uint num_devices;
+struct bp_data
+{
+	cl_program program;
+	char * options;
+	const cl_device_id * device_list;
+	cl_uint num_devices;
 };
 
-static void soclBuildProgram_task(void *data) {
-   struct bp_data *d = (struct bp_data*)data;
-   cl_device_id device;
-   cl_int err;
-   unsigned int i;
-
-   int wid = starpu_worker_get_id_check();
-
-   /* Check if the kernel has to be built for this device */
-   for (i=0; i <= d->num_devices; i++) {
-      if (i == d->num_devices)
-         return;
-
-      if (d->device_list[i]->worker_id == wid)
-        break;
-   }
-
-   int range = starpu_worker_get_range();
-   starpu_opencl_get_device(wid, &device);
-
-   DEBUG_MSG("[Worker %d] Building program...\n", wid);
-
-   cl_device_type dev_type;
-   clGetDeviceInfo(device, CL_DEVICE_TYPE, sizeof(cl_device_type), &dev_type, NULL);
-   char * dev_type_str = (dev_type == CL_DEVICE_TYPE_CPU ? "CPU" :
-                          dev_type == CL_DEVICE_TYPE_GPU ? "GPU" :
-                          dev_type == CL_DEVICE_TYPE_ACCELERATOR ? "ACCELERATOR" : "UNKNOWN");
-
-   char opts[4096];
-   sprintf(opts, "-DSOCL_DEVICE_TYPE_%s %s",
-    dev_type_str, (d->options != NULL ? d->options : ""));
-
-   err = clBuildProgram(d->program->cl_programs[range], 1, &device, opts, NULL, NULL);
-   if (err != CL_SUCCESS) {
-      size_t len;
-      clGetProgramBuildInfo(d->program->cl_programs[range], device, CL_PROGRAM_BUILD_LOG, 0, NULL, &len);
-      char * buffer = malloc(len+1);
-      buffer[len] = '\0';
-      clGetProgramBuildInfo(d->program->cl_programs[range], device, CL_PROGRAM_BUILD_LOG, len, buffer, NULL);
-      DEBUG_CL("clBuildProgram", err);
-      ERROR_MSG("clBuildProgram: %s\n Aborting.\n", buffer);
-      free(buffer);
-   }
-
-   DEBUG_MSG("[Worker %d] Done building.\n", wid);
+static void soclBuildProgram_task(void *data)
+{
+	struct bp_data *d = (struct bp_data*)data;
+	cl_device_id device;
+	cl_int err;
+	unsigned int i;
+
+	int wid = starpu_worker_get_id_check();
+
+	/* Check if the kernel has to be built for this device */
+	for (i=0; i <= d->num_devices; i++)
+	{
+		if (i == d->num_devices)
+			return;
+
+		if (d->device_list[i]->worker_id == wid)
+			break;
+	}
+
+	int range = starpu_worker_get_range();
+	starpu_opencl_get_device(wid, &device);
+
+	DEBUG_MSG("[Worker %d] Building program...\n", wid);
+
+	cl_device_type dev_type;
+	clGetDeviceInfo(device, CL_DEVICE_TYPE, sizeof(cl_device_type), &dev_type, NULL);
+	char * dev_type_str = (dev_type == CL_DEVICE_TYPE_CPU ? "CPU" :
+			       dev_type == CL_DEVICE_TYPE_GPU ? "GPU" :
+			       dev_type == CL_DEVICE_TYPE_ACCELERATOR ? "ACCELERATOR" : "UNKNOWN");
+
+	char opts[4096];
+	sprintf(opts, "-DSOCL_DEVICE_TYPE_%s %s",
+		dev_type_str, (d->options != NULL ? d->options : ""));
+
+	err = clBuildProgram(d->program->cl_programs[range], 1, &device, opts, NULL, NULL);
+	if (err != CL_SUCCESS)
+	{
+		size_t len;
+		clGetProgramBuildInfo(d->program->cl_programs[range], device, CL_PROGRAM_BUILD_LOG, 0, NULL, &len);
+		char * buffer = malloc(len+1);
+		buffer[len] = '\0';
+		clGetProgramBuildInfo(d->program->cl_programs[range], device, CL_PROGRAM_BUILD_LOG, len, buffer, NULL);
+		DEBUG_CL("clBuildProgram", err);
+		ERROR_MSG("clBuildProgram: %s\n Aborting.\n", buffer);
+		free(buffer);
+	}
+
+	DEBUG_MSG("[Worker %d] Done building.\n", wid);
 }
 
-
 CL_API_ENTRY cl_int CL_API_CALL
 soclBuildProgram(cl_program         program,
-               cl_uint              num_devices,
-               const cl_device_id * device_list,
-               const char *         options, 
-               void (*pfn_notify)(cl_program program, void * user_data),
-               void *               user_data) CL_API_SUFFIX__VERSION_1_0
+		 cl_uint              num_devices,
+		 const cl_device_id * device_list,
+		 const char *         options, 
+		 void (*pfn_notify)(cl_program program, void * user_data),
+		 void *               user_data) CL_API_SUFFIX__VERSION_1_0
 {
-   struct bp_data *data;
-
-   program->options = options != NULL ? strdup(options) : NULL;
-   program->options_size = options != NULL ? strlen(options)+1 : 0;
-
-   data = (struct bp_data*)malloc(sizeof(struct bp_data));
-   gc_entity_store(&data->program, program);
-   data->options = (char*)options;
-
-   /* If the device list is empty, we compile for every device in the context associated to the program */
-   if (device_list == NULL) {
-      num_devices = program->context->num_devices;
-      device_list = program->context->devices;
-   }
-
-   data->num_devices = num_devices;
-   data->device_list = device_list;
-
-   /*FIXME: starpu_execute_on_specific_workers is synchronous.
-    * However pfn_notify is useful only because build is supposed to be asynchronous
-    */
-   unsigned workers[num_devices];
-   unsigned i;
-   for (i=0; i<num_devices; i++) {
-      workers[i] = device_list[i]->worker_id;
-   }
-   starpu_execute_on_specific_workers(soclBuildProgram_task, data, num_devices, workers, "SOCL_BUILD_PROGRAM");
-
-
-   if (pfn_notify != NULL)
-      pfn_notify(program, user_data);
-
-   gc_entity_unstore(&data->program);
-   free(data);
-
-   return CL_SUCCESS;
+	struct bp_data *data;
+
+	program->options = options != NULL ? strdup(options) : NULL;
+	program->options_size = options != NULL ? strlen(options)+1 : 0;
+
+	data = (struct bp_data*)malloc(sizeof(struct bp_data));
+	gc_entity_store(&data->program, program);
+	data->options = (char*)options;
+
+	/* If the device list is empty, we compile for every device in the context associated to the program */
+	if (device_list == NULL)
+	{
+		num_devices = program->context->num_devices;
+		device_list = program->context->devices;
+	}
+
+	data->num_devices = num_devices;
+	data->device_list = device_list;
+
+	/*FIXME: starpu_execute_on_specific_workers is synchronous.
+	 * However pfn_notify is useful only because build is supposed to be asynchronous
+	 */
+	unsigned workers[num_devices];
+	unsigned i;
+	for (i=0; i<num_devices; i++)
+	{
+		workers[i] = device_list[i]->worker_id;
+	}
+	starpu_execute_on_specific_workers(soclBuildProgram_task, data, num_devices, workers, "SOCL_BUILD_PROGRAM");
+
+	if (pfn_notify != NULL)
+		pfn_notify(program, user_data);
+
+	gc_entity_unstore(&data->program);
+	free(data);
+
+	return CL_SUCCESS;
 }

socl/src/cl_createbuffer.c

@@ -16,23 +16,23 @@
 
 #include "socl.h"
 
-static void release_callback_memobject(void * e) {
-  cl_mem mem = (cl_mem)e;
+static void release_callback_memobject(void * e)
+{
+	cl_mem mem = (cl_mem)e;
 
-  /* Release references */
-  gc_entity_unstore(&mem->context);
+	/* Release references */
+	gc_entity_unstore(&mem->context);
 
-  //Delete this mem_object from the mem_object list
-  mem_object_release(mem);
+	//Delete this mem_object from the mem_object list
+	mem_object_release(mem);
 
-  /* Destruct object */
-  starpu_data_unregister_submit(mem->handle);
+	/* Destruct object */
+	starpu_data_unregister_submit(mem->handle);
 
-  if (!(mem->flags & CL_MEM_USE_HOST_PTR))
-    free(mem->ptr);
+	if (!(mem->flags & CL_MEM_USE_HOST_PTR))
+		free(mem->ptr);
 }
 
-
 /**
  * \brief Create a buffer
  *
@@ -42,102 +42,108 @@ static void release_callback_memobject(void * e) {
  *
  * If CL_MEM_USE_HOST_PTR or CL_MEM_ALLOC_HOST_PTR are set, memory pointed by host_ptr
  * is not coherent. To enforce coherency, you have to map the buffer (clEnqueueMapBuffer).
- * 
+ *
  * If CL_MEM_COPY_HOST_PTR is set, the buffer will be duplicated in host memory. You
  * should avoid it.
  *
  */
 CL_API_ENTRY cl_mem CL_API_CALL
 soclCreateBuffer(cl_context   context,
-               cl_mem_flags flags,
-               size_t       size,
-               void *       host_ptr,
-               cl_int *     errcode_ret) CL_API_SUFFIX__VERSION_1_0
+		 cl_mem_flags flags,
+		 size_t       size,
+		 void *       host_ptr,
+		 cl_int *     errcode_ret) CL_API_SUFFIX__VERSION_1_0
 {
-   cl_mem mem;
-
-   if (errcode_ret != NULL)
-      *errcode_ret = CL_SUCCESS;
-
-   //Check flags
-   if (((flags & CL_MEM_READ_ONLY) && (flags & CL_MEM_WRITE_ONLY))
-      || ((flags & CL_MEM_READ_WRITE) && (flags & CL_MEM_READ_ONLY))
-      || ((flags & CL_MEM_READ_WRITE) && (flags & CL_MEM_WRITE_ONLY))
-      || ((flags & CL_MEM_USE_HOST_PTR) && (flags & CL_MEM_ALLOC_HOST_PTR))
-      || ((flags & CL_MEM_USE_HOST_PTR) && (flags & CL_MEM_COPY_HOST_PTR))) {
-      if (errcode_ret != NULL)
-         *errcode_ret = CL_INVALID_VALUE;
-      return NULL;
-   }
-
-   if (size == 0) {
-      if (errcode_ret != NULL)
-         *errcode_ret = CL_INVALID_BUFFER_SIZE;
-      return NULL;
-   }
-
-   if ((host_ptr == NULL && (flags & (CL_MEM_USE_HOST_PTR | CL_MEM_COPY_HOST_PTR)))
-      || (host_ptr != NULL && !(flags & (CL_MEM_USE_HOST_PTR | CL_MEM_COPY_HOST_PTR)))) {
-      if (errcode_ret != NULL)
-         *errcode_ret = CL_INVALID_HOST_PTR;
-      return NULL;
-   }
-
-
-   //Alloc cl_mem structure
-   mem = (cl_mem)gc_entity_alloc(sizeof(struct _cl_mem), release_callback_memobject, "buffer");
-   if (mem == NULL) {
-      if (errcode_ret != NULL)
-         *errcode_ret = CL_OUT_OF_HOST_MEMORY;
-      return NULL;
-   }
-   
-   mem->ptr = NULL;
-   mem->map_count = 0;
-   gc_entity_store(&mem->context, context);
-   mem->flags = flags;
-   mem->size = size;
-   mem->host_ptr = host_ptr;
-
-   #ifdef DEBUG
-   static int id = 0;
-   mem->id = id++;
-   #endif
-
-   mem_object_store(mem);
-
-   //TODO: we shouldn't allocate the buffer ourselves. StarPU allocates it if a NULL pointer is given
-
-   // If not MEM_USE_HOST_PTR, we need to alloc the buffer ourselves
-   if (!(flags & CL_MEM_USE_HOST_PTR)) {
-      mem->ptr = valloc(size);
-      if (mem->ptr == NULL) {
-         if (errcode_ret != NULL)
-            *errcode_ret = CL_MEM_OBJECT_ALLOCATION_FAILURE;
-         free(mem);
-         return NULL;
-      }
-      //The buffer doesn't contain meaningful data
-      mem->scratch = 1;
-   }
-   else {
-      //The buffer may contain meaningful data
-      mem->scratch = 0;
-      mem->ptr = host_ptr;
-   }
-
-   // Access mode
-   mem->mode = (flags & CL_MEM_READ_ONLY) ? CL_MEM_READ_ONLY :
-	   (flags & CL_MEM_WRITE_ONLY) ? CL_MEM_WRITE_ONLY : CL_MEM_READ_WRITE;
-
-   // Perform data copy if necessary
-   if (flags & CL_MEM_COPY_HOST_PTR)
-      memcpy(mem->ptr, host_ptr, size);
-   
-   // Create StarPU buffer (on home node? what's this?)
-   starpu_variable_data_register(&mem->handle, STARPU_MAIN_RAM, (uintptr_t)mem->ptr, size); 
-
-   DEBUG_MSG("[Buffer %d] Initialized (cl_mem %p handle %p)\n", mem->id, mem, mem->handle);
-   
-   return mem;
+	cl_mem mem;
+
+	if (errcode_ret != NULL)
+		*errcode_ret = CL_SUCCESS;
+
+	//Check flags
+	if (((flags & CL_MEM_READ_ONLY) && (flags & CL_MEM_WRITE_ONLY))
+	    || ((flags & CL_MEM_READ_WRITE) && (flags & CL_MEM_READ_ONLY))
+	    || ((flags & CL_MEM_READ_WRITE) && (flags & CL_MEM_WRITE_ONLY))
+	    || ((flags & CL_MEM_USE_HOST_PTR) && (flags & CL_MEM_ALLOC_HOST_PTR))
+	    || ((flags & CL_MEM_USE_HOST_PTR) && (flags & CL_MEM_COPY_HOST_PTR)))
+	{
+		if (errcode_ret != NULL)
+			*errcode_ret = CL_INVALID_VALUE;
+		return NULL;
+	}
+
+	if (size == 0)
+	{
+		if (errcode_ret != NULL)
+			*errcode_ret = CL_INVALID_BUFFER_SIZE;
+		return NULL;
+	}
+
+	if ((host_ptr == NULL && (flags & (CL_MEM_USE_HOST_PTR | CL_MEM_COPY_HOST_PTR)))
+	    || (host_ptr != NULL && !(flags & (CL_MEM_USE_HOST_PTR | CL_MEM_COPY_HOST_PTR))))
+	{
+		if (errcode_ret != NULL)
+			*errcode_ret = CL_INVALID_HOST_PTR;
+		return NULL;
+	}
+
+	//Alloc cl_mem structure
+	mem = (cl_mem)gc_entity_alloc(sizeof(struct _cl_mem), release_callback_memobject, "buffer");
+	if (mem == NULL)
+	{
+		if (errcode_ret != NULL)
+			*errcode_ret = CL_OUT_OF_HOST_MEMORY;
+		return NULL;
+	}
+
+	mem->ptr = NULL;
+	mem->map_count = 0;
+	gc_entity_store(&mem->context, context);
+	mem->flags = flags;
+	mem->size = size;
+	mem->host_ptr = host_ptr;
+
+#ifdef DEBUG
+	static int id = 0;
+	mem->id = id++;
+#endif
+
+	mem_object_store(mem);
+
+	//TODO: we shouldn't allocate the buffer ourselves. StarPU allocates it if a NULL pointer is given
+
+	// If not MEM_USE_HOST_PTR, we need to alloc the buffer ourselves
+	if (!(flags & CL_MEM_USE_HOST_PTR))
+	{
+		mem->ptr = valloc(size);
+		if (mem->ptr == NULL)
+		{
+			if (errcode_ret != NULL)
+				*errcode_ret = CL_MEM_OBJECT_ALLOCATION_FAILURE;
+			free(mem);
+			return NULL;
+		}
+		//The buffer doesn't contain meaningful data
+		mem->scratch = 1;
+	}
+	else
+	{
+		//The buffer may contain meaningful data
+		mem->scratch = 0;
+		mem->ptr = host_ptr;
+	}
+
+	// Access mode
+	mem->mode = (flags & CL_MEM_READ_ONLY) ? CL_MEM_READ_ONLY :
+		(flags & CL_MEM_WRITE_ONLY) ? CL_MEM_WRITE_ONLY : CL_MEM_READ_WRITE;
+
+	// Perform data copy if necessary
+	if (flags & CL_MEM_COPY_HOST_PTR)
+		memcpy(mem->ptr, host_ptr, size);
+
+	// Create StarPU buffer (on home node? what's this?)
+	starpu_variable_data_register(&mem->handle, STARPU_MAIN_RAM, (uintptr_t)mem->ptr, size);
+
+	DEBUG_MSG("[Buffer %d] Initialized (cl_mem %p handle %p)\n", mem->id, mem, mem->handle);
+
+	return mem;
 }

socl/src/cl_createcommandqueue.c

@@ -16,67 +16,69 @@
 
 #include "socl.h"
 
-static void release_callback_command_queue(void * e) {
-  cl_command_queue cq = (cl_command_queue)e;
+static void release_callback_command_queue(void * e)
+{
+	cl_command_queue cq = (cl_command_queue)e;
 
-  //Disable StarPU profiling if necessary
-  if (cq->properties & CL_QUEUE_PROFILING_ENABLE) {
-    profiling_queue_count -= 1;
-    if (profiling_queue_count == 0)
-      starpu_profiling_status_set(STARPU_PROFILING_DISABLE);
-  }
+	//Disable StarPU profiling if necessary
+	if (cq->properties & CL_QUEUE_PROFILING_ENABLE)
+	{
+		profiling_queue_count -= 1;
+		if (profiling_queue_count == 0)
+			starpu_profiling_status_set(STARPU_PROFILING_DISABLE);
+	}
 
-  /* Release references */
-  gc_entity_unstore(&cq->context);
+	/* Release references */
+	gc_entity_unstore(&cq->context);
 
-  /* Destruct object */
-  STARPU_PTHREAD_MUTEX_DESTROY(&cq->mutex);
+	/* Destruct object */
+	STARPU_PTHREAD_MUTEX_DESTROY(&cq->mutex);
 }
 
-
-
 CL_API_ENTRY cl_command_queue CL_API_CALL
-soclCreateCommandQueue(cl_context                   context, 
-                     cl_device_id                   device, 
-                     cl_command_queue_properties    properties,
-                     cl_int *                       errcode_ret) CL_API_SUFFIX__VERSION_1_0
+soclCreateCommandQueue(cl_context                   context,
+		       cl_device_id                   device,
+		       cl_command_queue_properties    properties,
+		       cl_int *                       errcode_ret) CL_API_SUFFIX__VERSION_1_0
 {
-   cl_command_queue cq;
-
-   cq = (cl_command_queue)gc_entity_alloc(sizeof(struct _cl_command_queue),
-                                          release_callback_command_queue, "command_queue");
-   if (cq == NULL) {
-      if (errcode_ret != NULL)
-         *errcode_ret = CL_OUT_OF_HOST_MEMORY;
-      return NULL;
-   }
-
-   cq->properties = properties;
-   gc_entity_store(&cq->context, context);
-
-   char * fd = getenv("SOCL_FORCE_DYNAMIC");
-   int force_dynamic = fd == NULL ? 0 : atoi(fd);
-
-   cq->device = force_dynamic ? NULL : device;
-
-   #ifdef DEBUG
-   static int id = 0;
-   cq->id = id++;
-   #endif
-
-   //Enable StarPU profiling if necessary
-   if (properties & CL_QUEUE_PROFILING_ENABLE) {
-      if (profiling_queue_count == 0)
-         starpu_profiling_status_set(STARPU_PROFILING_ENABLE);
-      profiling_queue_count += 1;
-   }
-
-   cq->commands = NULL;
-   cq->barrier = NULL;
-   STARPU_PTHREAD_MUTEX_INIT(&cq->mutex, NULL);
-
-   if (errcode_ret != NULL)
-      *errcode_ret = CL_SUCCESS;
-
-   return cq;
+	cl_command_queue cq;
+
+	cq = (cl_command_queue)gc_entity_alloc(sizeof(struct _cl_command_queue),
+					       release_callback_command_queue, "command_queue");
+	if (cq == NULL)
+	{
+		if (errcode_ret != NULL)
+			*errcode_ret = CL_OUT_OF_HOST_MEMORY;
+		return NULL;
+	}
+
+	cq->properties = properties;
+	gc_entity_store(&cq->context, context);
+
+	char * fd = getenv("SOCL_FORCE_DYNAMIC");
+	int force_dynamic = fd == NULL ? 0 : atoi(fd);
+
+	cq->device = force_dynamic ? NULL : device;
+
+#ifdef DEBUG
+	static int id = 0;
+	cq->id = id++;
+#endif
+
+	//Enable StarPU profiling if necessary
+	if (properties & CL_QUEUE_PROFILING_ENABLE)
+	{
+		if (profiling_queue_count == 0)
+			starpu_profiling_status_set(STARPU_PROFILING_ENABLE);
+		profiling_queue_count += 1;
+	}
+
+	cq->commands = NULL;
+	cq->barrier = NULL;
+	STARPU_PTHREAD_MUTEX_INIT(&cq->mutex, NULL);
+
+	if (errcode_ret != NULL)
+		*errcode_ret = CL_SUCCESS;
+
+	return cq;
 }

socl/src/cl_createcontext.c

@@ -16,135 +16,143 @@
 
 #include "socl.h"
 
-static void release_callback_context(void * e) {
-  cl_context context = (cl_context)e;
+static void release_callback_context(void * e)
+{
+	cl_context context = (cl_context)e;
 
-  /* Destruct object */
-  if (context->properties != NULL)
-    free(context->properties);
+	/* Destruct object */
+	if (context->properties != NULL)
+		free(context->properties);
 
-  //FIXME: should we free StarPU contexts?
-  //starpu_sched_ctx_finished_submit(context->sched_ctx);
+	//FIXME: should we free StarPU contexts?
+	//starpu_sched_ctx_finished_submit(context->sched_ctx);
 
-  free(context->devices);
+	free(context->devices);
 }
 
-
 static char * defaultScheduler = "dmda";
 static char * defaultName = "default";
 
 CL_API_ENTRY cl_context CL_API_CALL
 soclCreateContext(const cl_context_properties * properties,
-                cl_uint                       num_devices,
-                const cl_device_id *          devices,
-                void (*pfn_notify)(const char *, const void *, size_t, void *),
-                void *                        user_data,
-                cl_int *                      errcode_ret) CL_API_SUFFIX__VERSION_1_0
+		  cl_uint                       num_devices,
+		  const cl_device_id *          devices,
+		  void (*pfn_notify)(const char *, const void *, size_t, void *),
+		  void *                        user_data,
+		  cl_int *                      errcode_ret) CL_API_SUFFIX__VERSION_1_0
 {
-
-   if (pfn_notify == NULL && user_data != NULL) {
-      if (errcode_ret != NULL)
-         *errcode_ret = CL_INVALID_VALUE;
-      return NULL;
-   }
-
-   //Check properties
-   if (properties != NULL) {
-      const cl_context_properties *p = properties;
-      int i = 0;
-      while (p[i] != 0) {
-         switch (p[i]) {
-            case CL_CONTEXT_PLATFORM:
-               i++;
-               if (p[i] != (cl_context_properties)&socl_platform) {
-                  if (errcode_ret != NULL)
-                     *errcode_ret = CL_INVALID_PLATFORM;
-                  return NULL;
-               }
-               break;
-
-            case CL_CONTEXT_SCHEDULER_SOCL:
-            case CL_CONTEXT_NAME_SOCL:
-               i++;
-               if (p[i] == 0) {
-                  if (errcode_ret != NULL)
-                     *errcode_ret = CL_INVALID_PROPERTY;
-                  return NULL;
-               }
-               break;
-         }
-         i++;
-      }
-   }
-
-
-   cl_context ctx;
-   ctx = (cl_context)gc_entity_alloc(sizeof(struct _cl_context), release_callback_context, "context");
-   if (ctx == NULL) {
-      if (errcode_ret != NULL)
-         *errcode_ret = CL_OUT_OF_HOST_MEMORY;
-      return NULL;
-   }
-
-   ctx->num_properties = 0;
-   ctx->properties = NULL;
-
-   char * sched = getenv("STARPU_SCHED");
-   char * scheduler = sched == NULL ? defaultScheduler : sched;
-
-   char * name = defaultName;
-
-   // Properties
-   if (properties != NULL) {
-
-      //Count properties
-      const cl_context_properties * p = properties;
-      do {
-         ctx->num_properties++;
-         p++;
-      } while (*p != 0);
-
-      //Copy properties
-      ctx->properties = malloc(sizeof(cl_context_properties) * ctx->num_properties);
-      memcpy(ctx->properties, properties, sizeof(cl_context_properties) * ctx->num_properties);
-
-      //Selected scheduler
-      cl_uint i = 0;
-      for (i=0; i<ctx->num_properties; i++) {
-         if (p[i] == CL_CONTEXT_SCHEDULER_SOCL) {
-            i++;
-            scheduler = (char*)p[i];
-         }
-         if (p[i] == CL_CONTEXT_NAME_SOCL) {
-            i++;
-            name = (char*)p[i];
-         }
-      }
-
-   }
-
-   ctx->pfn_notify = pfn_notify;
-   ctx->user_data = user_data;
-   ctx->num_devices = num_devices;
-
-   #ifdef DEBUG
-   static int id = 0;
-   ctx->id = id++;
-   #endif
-
-   ctx->devices = malloc(sizeof(cl_device_id) * num_devices);
-   memcpy(ctx->devices, devices, sizeof(cl_device_id)*num_devices);
-
-   // Create context
-   int workers[num_devices];
-   unsigned int i;
-   for (i=0; i<num_devices; i++) {
-      workers[i] = ctx->devices[i]->worker_id;
-   }
-   ctx->sched_ctx = starpu_sched_ctx_create(workers, num_devices, name, STARPU_SCHED_CTX_POLICY_NAME, scheduler, 0);
-
-   if (errcode_ret != NULL)
-      *errcode_ret = CL_SUCCESS;
-
-   return ctx;
+	if (pfn_notify == NULL && user_data != NULL)
+	{
+		if (errcode_ret != NULL)
+			*errcode_ret = CL_INVALID_VALUE;
+		return NULL;
+	}
+
+	//Check properties
+	if (properties != NULL)
+	{
+		const cl_context_properties *p = properties;
+		int i = 0;
+		while (p[i] != 0)
+		{
+			switch (p[i])
+			{
+			case CL_CONTEXT_PLATFORM:
+				i++;
+				if (p[i] != (cl_context_properties)&socl_platform)
+				{
+					if (errcode_ret != NULL)
+						*errcode_ret = CL_INVALID_PLATFORM;
+					return NULL;
+				}
+				break;
+
+			case CL_CONTEXT_SCHEDULER_SOCL:
+			case CL_CONTEXT_NAME_SOCL:
+				i++;
+				if (p[i] == 0)
+				{
+					if (errcode_ret != NULL)
+						*errcode_ret = CL_INVALID_PROPERTY;
+					return NULL;
+				}
+				break;
+			}
+			i++;
+		}
+	}
+
+	cl_context ctx;
+	ctx = (cl_context)gc_entity_alloc(sizeof(struct _cl_context), release_callback_context, "context");
+	if (ctx == NULL)
+	{
+		if (errcode_ret != NULL)
+			*errcode_ret = CL_OUT_OF_HOST_MEMORY;
+		return NULL;
+	}
+
+	ctx->num_properties = 0;
+	ctx->properties = NULL;
+
+	char * sched = getenv("STARPU_SCHED");
+	char * scheduler = sched == NULL ? defaultScheduler : sched;
+	char * name = defaultName;
+
+	// Properties
+	if (properties != NULL)
+	{
+		//Count properties
+		const cl_context_properties * p = properties;
+		do
+		{
+			ctx->num_properties++;
+			p++;
+		} while (*p != 0);
+
+		//Copy properties
+		ctx->properties = malloc(sizeof(cl_context_properties) * ctx->num_properties);
+		memcpy(ctx->properties, properties, sizeof(cl_context_properties) * ctx->num_properties);
+
+		//Selected scheduler
+		cl_uint i = 0;
+		for (i=0; i<ctx->num_properties; i++)
+		{
+			if (p[i] == CL_CONTEXT_SCHEDULER_SOCL)
+			{
+				i++;
+				scheduler = (char*)p[i];
+			}
+			if (p[i] == CL_CONTEXT_NAME_SOCL)
+			{
+				i++;
+				name = (char*)p[i];
+			}
+		}
+	}
+
+	ctx->pfn_notify = pfn_notify;
+	ctx->user_data = user_data;
+	ctx->num_devices = num_devices;
+
+#ifdef DEBUG
+	static int id = 0;
+	ctx->id = id++;
+#endif
+
+	ctx->devices = malloc(sizeof(cl_device_id) * num_devices);
+	memcpy(ctx->devices, devices, sizeof(cl_device_id)*num_devices);
+
+	// Create context
+	int workers[num_devices];
+	unsigned int i;
+	for (i=0; i<num_devices; i++)
+	{
+		workers[i] = ctx->devices[i]->worker_id;
+	}
+	ctx->sched_ctx = starpu_sched_ctx_create(workers, num_devices, name, STARPU_SCHED_CTX_POLICY_NAME, scheduler, 0);
+
+	if (errcode_ret != NULL)
+		*errcode_ret = CL_SUCCESS;
+
+	return ctx;
 }

socl/src/cl_createcontextfromtype.c

@@ -21,23 +21,21 @@
 
 CL_API_ENTRY cl_context CL_API_CALL
 soclCreateContextFromType(const cl_context_properties * properties,
-                        cl_device_type                device_type,
-                        void (*pfn_notify)(const char *, const void *, size_t, void *),
-                        void *                        user_data,
-                        cl_int *                      errcode_ret) CL_API_SUFFIX__VERSION_1_0
+			  cl_device_type                device_type,
+			  void (*pfn_notify)(const char *, const void *, size_t, void *),
+			  void *                        user_data,
+			  cl_int *                      errcode_ret) CL_API_SUFFIX__VERSION_1_0
 {
-    if (socl_init_starpu() < 0)
-      return NULL;
+	if (socl_init_starpu() < 0)
+		return NULL;
 
+	//TODO: appropriate error messages
 
-   //TODO: appropriate error messages
+	cl_uint num_devices;
+	soclGetDeviceIDs(&socl_platform, device_type, 0, NULL, &num_devices);
 
-   cl_uint num_devices;
+	cl_device_id devices[num_devices];
+	soclGetDeviceIDs(&socl_platform, device_type, num_devices, devices, NULL);
 
-   soclGetDeviceIDs(&socl_platform, device_type, 0, NULL, &num_devices);
-
-   cl_device_id devices[num_devices];
-   soclGetDeviceIDs(&socl_platform, device_type, num_devices, devices, NULL);
-   
-   return soclCreateContext(properties, num_devices, devices, pfn_notify, user_data, errcode_ret);
+	return soclCreateContext(properties, num_devices, devices, pfn_notify, user_data, errcode_ret);
 }

socl/src/cl_createimage2d.c

@@ -18,15 +18,15 @@
 
 CL_API_ENTRY cl_mem CL_API_CALL
 soclCreateImage2D(cl_context              UNUSED(context),
-                cl_mem_flags            UNUSED(flags),
-                const cl_image_format * UNUSED(image_format),
-                size_t                  UNUSED(image_width),
-                size_t                  UNUSED(image_height),
-                size_t                  UNUSED(image_row_pitch), 
-                void *                  UNUSED(host_ptr),
-                cl_int *                errcode_ret) CL_API_SUFFIX__VERSION_1_0
+		  cl_mem_flags            UNUSED(flags),
+		  const cl_image_format * UNUSED(image_format),
+		  size_t                  UNUSED(image_width),
+		  size_t                  UNUSED(image_height),
+		  size_t                  UNUSED(image_row_pitch),
+		  void *                  UNUSED(host_ptr),
+		  cl_int *                errcode_ret) CL_API_SUFFIX__VERSION_1_0
 {
-   if (errcode_ret != NULL)
-      *errcode_ret = CL_INVALID_OPERATION;
-   return NULL;
+	if (errcode_ret != NULL)
+		*errcode_ret = CL_INVALID_OPERATION;
+	return NULL;
 }

socl/src/cl_createimage3d.c

@@ -18,17 +18,17 @@
 
 CL_API_ENTRY cl_mem CL_API_CALL
 soclCreateImage3D(cl_context              UNUSED(context),
-                cl_mem_flags            UNUSED(flags),
-                const cl_image_format * UNUSED(image_format),
-                size_t                  UNUSED(image_width), 
-                size_t                  UNUSED(image_height),
-                size_t                  UNUSED(image_depth), 
-                size_t                  UNUSED(image_row_pitch), 
-                size_t                  UNUSED(image_slice_pitch), 
-                void *                  UNUSED(host_ptr),
-                cl_int *                errcode_ret) CL_API_SUFFIX__VERSION_1_0
+		  cl_mem_flags            UNUSED(flags),
+		  const cl_image_format * UNUSED(image_format),
+		  size_t                  UNUSED(image_width),
+		  size_t                  UNUSED(image_height),
+		  size_t                  UNUSED(image_depth),
+		  size_t                  UNUSED(image_row_pitch),
+		  size_t                  UNUSED(image_slice_pitch),
+		  void *                  UNUSED(host_ptr),
+		  cl_int *                errcode_ret) CL_API_SUFFIX__VERSION_1_0
 {
-   if (errcode_ret != NULL)
-      *errcode_ret = CL_INVALID_OPERATION;
-   return NULL;
+	if (errcode_ret != NULL)
+		*errcode_ret = CL_INVALID_OPERATION;
+	return NULL;
 }

socl/src/cl_createkernel.c

@@ -17,177 +17,195 @@
 
 #include "socl.h"
 
-static void soclCreateKernel_task(void *data) {
-   struct _cl_kernel *k = (struct _cl_kernel *)data;
-
-   int range = starpu_worker_get_range();
-   cl_int err;
-
-   if (k->program->cl_programs[range] == NULL) {
-      k->errcodes[range] = CL_SUCCESS;
-      DEBUG_MSG("[Device %u] Kernel creation skipped: program has not been built for this device.\n", starpu_worker_get_id_check());
-      return;
-   }
-
-   DEBUG_MSG("[Device %u] Creating kernel...\n", starpu_worker_get_id_check());
-   k->cl_kernels[range] = clCreateKernel(k->program->cl_programs[range], k->kernel_name, &err);
-   if (err != CL_SUCCESS) {
-      k->errcodes[range] = err;
-      ERROR_STOP("[Device %u] Unable to create kernel. Error %d. Aborting.\n", starpu_worker_get_id_check(), err);
-      return;
-   }
-
-   /* One worker creates argument structures */
-   if (__sync_bool_compare_and_swap(&k->num_args, 0, 666)) {
-      unsigned int i;
-      cl_uint num_args;
-
-      err = clGetKernelInfo(k->cl_kernels[range], CL_KERNEL_NUM_ARGS, sizeof(num_args), &num_args, NULL);
-      if (err != CL_SUCCESS) {
-         DEBUG_CL("clGetKernelInfo", err);
-         ERROR_STOP("Unable to get kernel argument count. Aborting.\n");
-      }
-      k->num_args = num_args;
-      DEBUG_MSG("Kernel has %d arguments\n", num_args);
-
-      k->arg_size = (size_t*)malloc(sizeof(size_t) * num_args);
-      k->arg_value = (void**)malloc(sizeof(void*) * num_args);
-      k->arg_type = (enum kernel_arg_type*)malloc(sizeof(enum kernel_arg_type) * num_args);
-      /* Settings default type to NULL */
-      for (i=0; i<num_args; i++) {
-         k->arg_value[i] = NULL;
-         k->arg_type[i] = Null;
-      }
-   }
+static void soclCreateKernel_task(void *data)
+{
+	struct _cl_kernel *k = (struct _cl_kernel *)data;
+
+	int range = starpu_worker_get_range();
+	cl_int err;
+	
+	if (k->program->cl_programs[range] == NULL)
+	{
+		k->errcodes[range] = CL_SUCCESS;
+		DEBUG_MSG("[Device %u] Kernel creation skipped: program has not been built for this device.\n", starpu_worker_get_id_check());
+		return;
+	}
+
+	DEBUG_MSG("[Device %u] Creating kernel...\n", starpu_worker_get_id_check());
+	k->cl_kernels[range] = clCreateKernel(k->program->cl_programs[range], k->kernel_name, &err);
+	if (err != CL_SUCCESS)
+	{
+		k->errcodes[range] = err;
+		ERROR_STOP("[Device %u] Unable to create kernel. Error %d. Aborting.\n", starpu_worker_get_id_check(), err);
+		return;
+	}
+
+	/* One worker creates argument structures */
+	if (__sync_bool_compare_and_swap(&k->num_args, 0, 666))
+	{
+		unsigned int i;
+		cl_uint num_args;
+
+		err = clGetKernelInfo(k->cl_kernels[range], CL_KERNEL_NUM_ARGS, sizeof(num_args), &num_args, NULL);
+		if (err != CL_SUCCESS)
+		{
+			DEBUG_CL("clGetKernelInfo", err);
+			ERROR_STOP("Unable to get kernel argument count. Aborting.\n");
+		}
+		k->num_args = num_args;
+		DEBUG_MSG("Kernel has %d arguments\n", num_args);
+
+		k->arg_size = (size_t*)malloc(sizeof(size_t) * num_args);
+		k->arg_value = (void**)malloc(sizeof(void*) * num_args);
+		k->arg_type = (enum kernel_arg_type*)malloc(sizeof(enum kernel_arg_type) * num_args);
+		/* Settings default type to NULL */
+		for (i=0; i<num_args; i++)
+		{
+			k->arg_value[i] = NULL;
+			k->arg_type[i] = Null;
+		}
+	}
 }
 
-static void release_callback_kernel(void * e) {
-  cl_kernel kernel = (cl_kernel)e;
-
-  //Free args
-  unsigned int i;
-  for (i=0; i<kernel->num_args; i++) {
-    switch (kernel->arg_type[i]) {
-      case Null:
-      case Buffer:
-        break;
-      case Immediate:
-        free(kernel->arg_value[i]);
-        break;
-    }
-  }
-  if (kernel->arg_size != NULL)
-    free(kernel->arg_size);
-  if (kernel->arg_value != NULL)
-    free(kernel->arg_value);
-  if (kernel->arg_type != NULL)
-    free(kernel->arg_type);
-
-  //Release real kernels...
-  for (i=0; i<socl_device_count; i++) {
-     if (kernel->cl_kernels[i] != NULL) {
-        cl_int err = clReleaseKernel(kernel->cl_kernels[i]);
-        if (err != CL_SUCCESS)
-           DEBUG_CL("clReleaseKernel", err);
-     }
-  }
-
-  //Release perfmodel
-  //FIXME: we cannot release performance models before StarPU shutdown as it
-  //will use them to store kernel execution times
-
-  //free(kernel->perfmodel);
-  //free(kernel->kernel_name);
-
-  gc_entity_unstore(&kernel->program);
-
-  free(kernel->cl_kernels);
-  free(kernel->errcodes);
+static void release_callback_kernel(void * e)
+{
+	cl_kernel kernel = (cl_kernel)e;
+
+	//Free args
+	unsigned int i;
+	for (i=0; i<kernel->num_args; i++)
+	{
+		switch (kernel->arg_type[i])
+		{
+		case Null:
+		case Buffer:
+			break;
+		case Immediate:
+			free(kernel->arg_value[i]);
+			break;
+		}
+	}
+	if (kernel->arg_size != NULL)
+		free(kernel->arg_size);
+	if (kernel->arg_value != NULL)
+		free(kernel->arg_value);
+	if (kernel->arg_type != NULL)
+		free(kernel->arg_type);
+
+	//Release real kernels...
+	for (i=0; i<socl_device_count; i++)
+	{
+		if (kernel->cl_kernels[i] != NULL)
+		{
+			cl_int err = clReleaseKernel(kernel->cl_kernels[i]);
+			if (err != CL_SUCCESS)
+				DEBUG_CL("clReleaseKernel", err);
+		}
+	}
+
+	//Release perfmodel
+	//FIXME: we cannot release performance models before StarPU shutdown as it
+	//will use them to store kernel execution times
+
+	//free(kernel->perfmodel);
+	//free(kernel->kernel_name);
+
+	gc_entity_unstore(&kernel->program);
+
+	free(kernel->cl_kernels);
+	free(kernel->errcodes);
 }
 
 CL_API_ENTRY cl_kernel CL_API_CALL
 soclCreateKernel(cl_program    program,
-               const char *    kernel_name,
-               cl_int *        errcode_ret) CL_API_SUFFIX__VERSION_1_0
+		 const char *    kernel_name,
+		 cl_int *        errcode_ret) CL_API_SUFFIX__VERSION_1_0
 {
-   cl_kernel k;
-
-   if (program == NULL) {
-      if (errcode_ret != NULL)
-         *errcode_ret = CL_INVALID_PROGRAM;
-      return NULL;
-   }
-
-   //TODO: check programs (see opencl specs)
-
-   /* Create Kernel structure */
-   k = (cl_kernel)gc_entity_alloc(sizeof(struct _cl_kernel), release_callback_kernel, "kernel");
-   if (k == NULL) {
-      if (errcode_ret != NULL)
-         *errcode_ret = CL_OUT_OF_HOST_MEMORY;
-      return NULL;
-   }
+	cl_kernel k;
+
+	if (program == NULL)
+	{
+		if (errcode_ret != NULL)
+			*errcode_ret = CL_INVALID_PROGRAM;
+		return NULL;
+	}
+
+	//TODO: check programs (see opencl specs)
+
+	/* Create Kernel structure */
+	k = (cl_kernel)gc_entity_alloc(sizeof(struct _cl_kernel), release_callback_kernel, "kernel");
+	if (k == NULL)
+	{
+		if (errcode_ret != NULL)
+			*errcode_ret = CL_OUT_OF_HOST_MEMORY;
+		return NULL;
+	}
    
-   gc_entity_store(&k->program, program);
-   k->kernel_name = strdup(kernel_name);
-
-   k->perfmodel = malloc(sizeof(struct starpu_perfmodel));
-   memset(k->perfmodel, 0, sizeof(struct starpu_perfmodel));
-   k->perfmodel->type = STARPU_HISTORY_BASED;
-   k->perfmodel->symbol = k->kernel_name;
-
-   k->num_args = 0;
-   k->arg_value = NULL;
-   k->arg_size = NULL;
-
-   k->split_func = NULL;
-   k->split_space = 0;
-   k->split_data = NULL;
-   k->split_perfs = NULL;
-   STARPU_PTHREAD_MUTEX_INIT(&k->split_lock, NULL);
-
-   #ifdef DEBUG
-   static int id = 0;
-   k->id = id++;
-   #endif
+	gc_entity_store(&k->program, program);
+	k->kernel_name = strdup(kernel_name);
+
+	k->perfmodel = malloc(sizeof(struct starpu_perfmodel));
+	memset(k->perfmodel, 0, sizeof(struct starpu_perfmodel));
+	k->perfmodel->type = STARPU_HISTORY_BASED;
+	k->perfmodel->symbol = k->kernel_name;
+
+	k->num_args = 0;
+	k->arg_value = NULL;
+	k->arg_size = NULL;
+
+	k->split_func = NULL;
+	k->split_space = 0;
+	k->split_data = NULL;
+	k->split_perfs = NULL;
+	STARPU_PTHREAD_MUTEX_INIT(&k->split_lock, NULL);
+
+#ifdef DEBUG
+	static int id = 0;
+	k->id = id++;
+#endif
    
-   k->cl_kernels = (cl_kernel*)malloc(socl_device_count * sizeof(cl_kernel));
-   k->errcodes = (cl_int*)malloc(socl_device_count * sizeof(cl_int));
-
-   {
-      unsigned int i;
-      for (i=0; i<socl_device_count; i++) {
-         k->cl_kernels[i] = NULL;
-         k->errcodes[i] = -9999;
-      }
-   }
-
-   /* Create kernel on each device */
-   DEBUG_MSG("[Kernel %d] Create %u kernels (name \"%s\")\n", k->id, socl_device_count, kernel_name);
-   starpu_execute_on_each_worker_ex(soclCreateKernel_task, k, STARPU_OPENCL, "SOCL_CREATE_KERNEL");
-
-   if (errcode_ret != NULL) {
-      unsigned int i;
-      *errcode_ret = CL_SUCCESS;
-      for (i=0; i<socl_device_count; i++) {
-         switch (k->errcodes[i]) {
-            #define CASE_RET(e) case e: *errcode_ret = e; return k;
-            CASE_RET(CL_INVALID_PROGRAM)
-            CASE_RET(CL_INVALID_PROGRAM_EXECUTABLE)
-            CASE_RET(CL_INVALID_KERNEL_NAME)
-            CASE_RET(CL_INVALID_KERNEL_DEFINITION)
-            CASE_RET(CL_INVALID_VALUE)
-            CASE_RET(CL_OUT_OF_RESOURCES)
-            CASE_RET(CL_OUT_OF_HOST_MEMORY)
-            #undef CASE_RET
-         }
-      }
-
-      if (k->num_args == 666) {
-         *errcode_ret = CL_INVALID_PROGRAM_EXECUTABLE;
-         return k;
-      }
-   }
-
-   return k;
+	k->cl_kernels = (cl_kernel*)malloc(socl_device_count * sizeof(cl_kernel));
+	k->errcodes = (cl_int*)malloc(socl_device_count * sizeof(cl_int));
+
+	{
+		unsigned int i;
+		for (i=0; i<socl_device_count; i++)
+		{
+			k->cl_kernels[i] = NULL;
+			k->errcodes[i] = -9999;
+		}
+	}
+
+	/* Create kernel on each device */
+	DEBUG_MSG("[Kernel %d] Create %u kernels (name \"%s\")\n", k->id, socl_device_count, kernel_name);
+	starpu_execute_on_each_worker_ex(soclCreateKernel_task, k, STARPU_OPENCL, "SOCL_CREATE_KERNEL");
+
+	if (errcode_ret != NULL)
+	{
+		unsigned int i;
+		*errcode_ret = CL_SUCCESS;
+		for (i=0; i<socl_device_count; i++)
+		{
+			switch (k->errcodes[i])
+			{
+#define CASE_RET(e) case e: *errcode_ret = e; return k
+				CASE_RET(CL_INVALID_PROGRAM);
+				CASE_RET(CL_INVALID_PROGRAM_EXECUTABLE);
+				CASE_RET(CL_INVALID_KERNEL_NAME);
+				CASE_RET(CL_INVALID_KERNEL_DEFINITION);
+				CASE_RET(CL_INVALID_VALUE);
+				CASE_RET(CL_OUT_OF_RESOURCES);
+				CASE_RET(CL_OUT_OF_HOST_MEMORY);
+#undef CASE_RET
+			}
+		}
+
+		if (k->num_args == 666)
+		{
+			*errcode_ret = CL_INVALID_PROGRAM_EXECUTABLE;
+			return k;
+		}
+	}
+
+	return k;
 }

socl/src/cl_createkernelsinprogram.c

@@ -18,10 +18,10 @@
 
 CL_API_ENTRY cl_int CL_API_CALL
 soclCreateKernelsInProgram(cl_program   UNUSED(program),
-                         cl_uint        UNUSED(num_kernels),
-                         cl_kernel *    UNUSED(kernels),
-                         cl_uint *      UNUSED(num_kernels_ret)) CL_API_SUFFIX__VERSION_1_0
+			   cl_uint        UNUSED(num_kernels),
+			   cl_kernel *    UNUSED(kernels),
+			   cl_uint *      UNUSED(num_kernels_ret)) CL_API_SUFFIX__VERSION_1_0
 {
-   //TODO
-   return CL_INVALID_OPERATION;
+	//TODO
+	return CL_INVALID_OPERATION;
 }

socl/src/cl_createprogramwithbinary.c

@@ -18,16 +18,16 @@
 
 CL_API_ENTRY cl_program CL_API_CALL
 soclCreateProgramWithBinary(cl_context                     UNUSED(context),
-                          cl_uint                        UNUSED(num_devices),
-                          const cl_device_id *           UNUSED(device_list),
-                          const size_t *                 UNUSED(lengths),
-                          const unsigned char **         UNUSED(binaries),
-                          cl_int *                       UNUSED(binary_status),
-                          cl_int *                       errcode_ret) CL_API_SUFFIX__VERSION_1_0
+			    cl_uint                        UNUSED(num_devices),
+			    const cl_device_id *           UNUSED(device_list),
+			    const size_t *                 UNUSED(lengths),
+			    const unsigned char **         UNUSED(binaries),
+			    cl_int *                       UNUSED(binary_status),
+			    cl_int *                       errcode_ret) CL_API_SUFFIX__VERSION_1_0
 {
-   //TODO
-   if (errcode_ret != NULL)
-      *errcode_ret = CL_INVALID_OPERATION;
+	//TODO
+	if (errcode_ret != NULL)
+		*errcode_ret = CL_INVALID_OPERATION;
 
-   return NULL;
+	return NULL;
 }

socl/src/cl_createprogramwithsource.c

@@ -17,140 +17,150 @@
 
 #include "socl.h"
 
-struct cpws_data {
-   struct _cl_program *program;
-   cl_int *errcodes;
-   cl_uint count;
-   char **strings;
-   size_t *lengths;
+struct cpws_data
+{
+	struct _cl_program *program;
+	cl_int *errcodes;
+	cl_uint count;
+	char **strings;
+	size_t *lengths;
 };
 
-static void soclCreateProgramWithSource_task(void *data) {
-   struct cpws_data *d = (struct cpws_data*)data;
-
-   cl_context context;
-   int wid = starpu_worker_get_id_check();
-   DEBUG_MSG("Worker id: %d\n", wid);
+static void soclCreateProgramWithSource_task(void *data)
+{
+	struct cpws_data *d = (struct cpws_data*)data;
 
-   int range = starpu_worker_get_range();
+	cl_context context;
+	int wid = starpu_worker_get_id_check();
+	DEBUG_MSG("Worker id: %d\n", wid);
 
-   starpu_opencl_get_context(wid, &context);
+	int range = starpu_worker_get_range();
 
-   d->program->cl_programs[range] = clCreateProgramWithSource(context, d->count, (const char**)d->strings, d->lengths, &d->errcodes[range]);
+	starpu_opencl_get_context(wid, &context);
 
+	d->program->cl_programs[range] = clCreateProgramWithSource(context, d->count, (const char**)d->strings, d->lengths, &d->errcodes[range]);
 }
 
-static void release_callback_program(void * e) {
-  cl_program program = (cl_program)e;
-
-  unsigned int i;
-  for (i=0; i<socl_device_count; i++) {
-     if (program->cl_programs[i] != NULL) {
-        cl_int err = clReleaseProgram(program->cl_programs[i]);
-        if (err != CL_SUCCESS)
-           DEBUG_CL("clReleaseProgram", err);
-     }
-  }
-
-  /* Release references */
-  gc_entity_unstore(&program->context);
-
-  free(program->cl_programs);
-
-  if (program->options != NULL)
-    free(program->options);
+static void release_callback_program(void * e)
+{
+	cl_program program = (cl_program)e;
+
+	unsigned int i;
+	for (i=0; i<socl_device_count; i++)
+	{
+		if (program->cl_programs[i] != NULL)
+		{
+			cl_int err = clReleaseProgram(program->cl_programs[i]);
+			if (err != CL_SUCCESS)
+				DEBUG_CL("clReleaseProgram", err);
+		}
+	}
+
+	/* Release references */
+	gc_entity_unstore(&program->context);
+
+	free(program->cl_programs);
+
+	if (program->options != NULL)
+		free(program->options);
 }
 
-
 CL_API_ENTRY cl_program CL_API_CALL
 soclCreateProgramWithSource(cl_context      context,
-                          cl_uint           count,
-                          const char **     strings,
-                          const size_t *    lengths,
-                          cl_int *          errcode_ret) CL_API_SUFFIX__VERSION_1_0
+			    cl_uint           count,
+			    const char **     strings,
+			    const size_t *    lengths,
+			    cl_int *          errcode_ret) CL_API_SUFFIX__VERSION_1_0
 {
-   cl_program p;
-   struct cpws_data *data;
-   unsigned int i;
-
-   if (errcode_ret != NULL)
-      *errcode_ret = CL_SUCCESS;
-
-   /* Check arguments */
-   if (count == 0 || strings == NULL) {
-      if (errcode_ret != NULL)
-         *errcode_ret = CL_INVALID_VALUE;
-      return NULL;
-   }
-
-   /* Alloc cl_program structure */
-   p = (cl_program)gc_entity_alloc(sizeof(struct _cl_program), release_callback_program, "program");
-   if (p == NULL) {
-      if (errcode_ret != NULL)
-         *errcode_ret = CL_OUT_OF_HOST_MEMORY;
-      return NULL;
-   }
-
-   gc_entity_store(&p->context, context);
-   p->options = NULL;
-
-   #ifdef DEBUG
-   static int id = 0;
-   p->id = id++;
-   #endif
-
-
-   p->cl_programs = (cl_program*)malloc(sizeof(cl_program) * socl_device_count);
-   if (p->cl_programs == NULL) {
-      if (errcode_ret != NULL)
-         *errcode_ret = CL_OUT_OF_HOST_MEMORY;
-      return NULL;
-   }
-
-   {
-      for (i=0; i<socl_device_count; i++)
-         p->cl_programs[i] = NULL;
-   }
-
-   /* Construct structure to pass arguments to workers */
-   data = (struct cpws_data*)malloc(sizeof(struct cpws_data));
-   if (data == NULL) {
-      if (errcode_ret != NULL)
-         *errcode_ret = CL_OUT_OF_HOST_MEMORY;
-      return NULL;
-   }
-   data->count = count;
-   data->program = p;
-   data->strings = (char**)strings;
-   data->lengths = (size_t*)lengths;
-
-   data->errcodes = (cl_int*)malloc(sizeof(cl_int) * socl_device_count);
-   for (i=0; i<socl_device_count; i++) {
-      data->errcodes[i] = CL_SUCCESS;
-   }
-
-
-   /* Init real cl_program for each OpenCL device */
-   unsigned workers[context->num_devices];
-   for (i=0; i<context->num_devices; i++) {
-      workers[i] = context->devices[i]->worker_id;
-   }
-   starpu_execute_on_specific_workers(soclCreateProgramWithSource_task, data, context->num_devices, workers, "SOCL_CREATE_PROGRAM");
-
-   if (errcode_ret != NULL) {
-      *errcode_ret = CL_SUCCESS;
-      for (i=0; i<socl_device_count; i++) {
-         if (data->errcodes[i] != CL_SUCCESS) {
-            DEBUG_MSG("Worker [%u] failed\n", i);
-            DEBUG_CL("clCreateProgramWithSource", data->errcodes[i]);
-            *errcode_ret = data->errcodes[i];
-            break;
-         }
-      }
-   }
-
-   free(data->errcodes);
-   free(data);
-   
-   return p;
+	cl_program p;
+	struct cpws_data *data;
+	unsigned int i;
+
+	if (errcode_ret != NULL)
+		*errcode_ret = CL_SUCCESS;
+
+	/* Check arguments */
+	if (count == 0 || strings == NULL)
+	{
+		if (errcode_ret != NULL)
+			*errcode_ret = CL_INVALID_VALUE;
+		return NULL;
+	}
+
+	/* Alloc cl_program structure */
+	p = (cl_program)gc_entity_alloc(sizeof(struct _cl_program), release_callback_program, "program");
+	if (p == NULL)
+	{
+		if (errcode_ret != NULL)
+			*errcode_ret = CL_OUT_OF_HOST_MEMORY;
+		return NULL;
+	}
+
+	gc_entity_store(&p->context, context);
+	p->options = NULL;
+
+#ifdef DEBUG
+	static int id = 0;
+	p->id = id++;
+#endif
+
+	p->cl_programs = (cl_program*)malloc(sizeof(cl_program) * socl_device_count);
+	if (p->cl_programs == NULL)
+	{
+		if (errcode_ret != NULL)
+			*errcode_ret = CL_OUT_OF_HOST_MEMORY;
+		return NULL;
+	}
+
+	{
+		for (i=0; i<socl_device_count; i++)
+			p->cl_programs[i] = NULL;
+	}
+
+	/* Construct structure to pass arguments to workers */
+	data = (struct cpws_data*)malloc(sizeof(struct cpws_data));
+	if (data == NULL)
+	{
+		if (errcode_ret != NULL)
+			*errcode_ret = CL_OUT_OF_HOST_MEMORY;
+		return NULL;
+	}
+	data->count = count;
+	data->program = p;
+	data->strings = (char**)strings;
+	data->lengths = (size_t*)lengths;
+
+	data->errcodes = (cl_int*)malloc(sizeof(cl_int) * socl_device_count);
+	for (i=0; i<socl_device_count; i++)
+	{
+		data->errcodes[i] = CL_SUCCESS;
+	}
+
+	/* Init real cl_program for each OpenCL device */
+	unsigned workers[context->num_devices];
+	for (i=0; i<context->num_devices; i++)
+	{
+		workers[i] = context->devices[i]->worker_id;
+	}
+	starpu_execute_on_specific_workers(soclCreateProgramWithSource_task, data, context->num_devices, workers, "SOCL_CREATE_PROGRAM");
+
+	if (errcode_ret != NULL)
+	{
+		*errcode_ret = CL_SUCCESS;
+		for (i=0; i<socl_device_count; i++)
+		{
+			if (data->errcodes[i] != CL_SUCCESS)
+			{
+				DEBUG_MSG("Worker [%u] failed\n", i);
+				DEBUG_CL("clCreateProgramWithSource", data->errcodes[i]);
+				*errcode_ret = data->errcodes[i];
+				break;
+			}
+		}
+	}
+
+	free(data->errcodes);
+	free(data);
+
+	return p;
 }

socl/src/cl_createsampler.c

@@ -18,12 +18,12 @@
 
 CL_API_ENTRY cl_sampler CL_API_CALL
 soclCreateSampler(cl_context          UNUSED(context),
-                cl_bool             UNUSED(normalized_coords), 
-                cl_addressing_mode  UNUSED(addressing_mode), 
-                cl_filter_mode      UNUSED(filter_mode),
-                cl_int *            errcode_ret) CL_API_SUFFIX__VERSION_1_0
+		  cl_bool             UNUSED(normalized_coords), 
+		  cl_addressing_mode  UNUSED(addressing_mode), 
+		  cl_filter_mode      UNUSED(filter_mode),
+		  cl_int *            errcode_ret) CL_API_SUFFIX__VERSION_1_0
 {
-   if (errcode_ret != NULL)
-      *errcode_ret = CL_INVALID_OPERATION;
-   return NULL;
+	if (errcode_ret != NULL)
+		*errcode_ret = CL_INVALID_OPERATION;
+	return NULL;
 }

socl/src/cl_enqueuebarrier.c

@@ -26,7 +26,8 @@ soclEnqueueBarrier(cl_command_queue cq) CL_API_SUFFIX__VERSION_1_0
 	return CL_SUCCESS;
 }
 
-cl_int command_barrier_submit(command_barrier cmd) {
+cl_int command_barrier_submit(command_barrier cmd)
+{
 	struct starpu_task *task;
 	task = task_create(CL_COMMAND_BARRIER);
 

socl/src/cl_enqueuebarrierwithwaitlist.c

@@ -18,13 +18,13 @@
 
 CL_API_ENTRY cl_int CL_API_CALL
 soclEnqueueBarrierWithWaitList(cl_command_queue  cq,
-                cl_uint num_events,
-                const cl_event * events,
-                cl_event *          event) CL_API_SUFFIX__VERSION_1_2
+			       cl_uint num_events,
+			       const cl_event * events,
+			       cl_event *          event) CL_API_SUFFIX__VERSION_1_2
 {
 	command_barrier cmd = command_barrier_create();
 
-   cl_event ev = command_event_get(cmd);
+	cl_event ev = command_event_get(cmd);
 
 	command_queue_enqueue(cq, cmd, num_events, events);
 

socl/src/cl_enqueuecopybuffer.c

@@ -17,60 +17,64 @@
 
 #include "socl.h"
 
-static void soclEnqueueCopyBuffer_opencl_task(void *descr[], void *args) {
-   int wid;
-   cl_command_queue cq;
-   cl_event ev;
-   command_copy_buffer cmd = (command_copy_buffer)args;
+static void soclEnqueueCopyBuffer_opencl_task(void *descr[], void *args)
+{
+	int wid;
+	cl_command_queue cq;
+	cl_event ev;
+	command_copy_buffer cmd = (command_copy_buffer)args;
 
-  cl_event event = command_event_get(cmd);
-  event->prof_start = _socl_nanotime();
-  gc_entity_release(event);
+	cl_event event = command_event_get(cmd);
+	event->prof_start = _socl_nanotime();
+	gc_entity_release(event);
 
-   wid = starpu_worker_get_id_check();
-   starpu_opencl_get_queue(wid, &cq);
+	wid = starpu_worker_get_id_check();
+	starpu_opencl_get_queue(wid, &cq);
 
-   cl_mem src = (cl_mem)STARPU_VARIABLE_GET_PTR(descr[0]);
-   cl_mem dst = (cl_mem)STARPU_VARIABLE_GET_PTR(descr[1]);
+	cl_mem src = (cl_mem)STARPU_VARIABLE_GET_PTR(descr[0]);
+	cl_mem dst = (cl_mem)STARPU_VARIABLE_GET_PTR(descr[1]);
 
-   clEnqueueCopyBuffer(cq, src,dst, cmd->src_offset, cmd->dst_offset, cmd->cb, 0, NULL, &ev);
-   clWaitForEvents(1, &ev);
-   clReleaseEvent(ev);
+	clEnqueueCopyBuffer(cq, src,dst, cmd->src_offset, cmd->dst_offset, cmd->cb, 0, NULL, &ev);
+	clWaitForEvents(1, &ev);
+	clReleaseEvent(ev);
 
-   gc_entity_release_cmd(cmd);
+	gc_entity_release_cmd(cmd);
 }
 
-static void soclEnqueueCopyBuffer_cpu_task(void *descr[], void *args) {
-   command_copy_buffer cmd = (command_copy_buffer)args;
+static void soclEnqueueCopyBuffer_cpu_task(void *descr[], void *args)
+{
+	command_copy_buffer cmd = (command_copy_buffer)args;
 
-  cl_event ev = command_event_get(cmd);
-  ev->prof_start = _socl_nanotime();
-  gc_entity_release(ev);
+	cl_event ev = command_event_get(cmd);
+	ev->prof_start = _socl_nanotime();
+	gc_entity_release(ev);
 
-   char * src = (void*)STARPU_VARIABLE_GET_PTR(descr[0]);
-   char * dst = (void*)STARPU_VARIABLE_GET_PTR(descr[1]);
+	char * src = (void*)STARPU_VARIABLE_GET_PTR(descr[0]);
+	char * dst = (void*)STARPU_VARIABLE_GET_PTR(descr[1]);
 
-   memcpy(dst+cmd->dst_offset, src+cmd->src_offset, cmd->cb);
+	memcpy(dst+cmd->dst_offset, src+cmd->src_offset, cmd->cb);
 
-   gc_entity_release_cmd(cmd);
+	gc_entity_release_cmd(cmd);
 }
 
-static struct starpu_perfmodel copy_buffer_perfmodel = {
-  .type = STARPU_HISTORY_BASED,
-  .symbol = "SOCL_COPY_BUFFER"
+static struct starpu_perfmodel copy_buffer_perfmodel =
+{
+	.type = STARPU_HISTORY_BASED,
+	.symbol = "SOCL_COPY_BUFFER"
 };
 
-static struct starpu_codelet codelet_copybuffer = {
-   .where = STARPU_CPU | STARPU_OPENCL,
-   .model = &copy_buffer_perfmodel,
-   .cpu_funcs = { &soclEnqueueCopyBuffer_cpu_task },
-   .opencl_funcs = { &soclEnqueueCopyBuffer_opencl_task },
-   .modes = {STARPU_R, STARPU_RW},
-   .nbuffers = 2
+static struct starpu_codelet codelet_copybuffer =
+{
+	.where = STARPU_CPU | STARPU_OPENCL,
+	.model = &copy_buffer_perfmodel,
+	.cpu_funcs = { &soclEnqueueCopyBuffer_cpu_task },
+	.opencl_funcs = { &soclEnqueueCopyBuffer_opencl_task },
+	.modes = {STARPU_R, STARPU_RW},
+	.nbuffers = 2
 };
 
-cl_int command_copy_buffer_submit(command_copy_buffer cmd) {
-
+cl_int command_copy_buffer_submit(command_copy_buffer cmd)
+{
 	struct starpu_task * task = task_create(CL_COMMAND_COPY_BUFFER);
 
 	task->handles[0] = cmd->src_buffer->handle;
@@ -78,9 +82,10 @@ cl_int command_copy_buffer_submit(command_copy_buffer cmd) {
 	task->cl = &codelet_copybuffer;
 
 	/* Execute the task on a specific worker? */
-	if (cmd->_command.event->cq->device != NULL) {
-	  task->execute_on_a_specific_worker = 1;
-	  task->workerid = cmd->_command.event->cq->device->worker_id;
+	if (cmd->_command.event->cq->device != NULL)
+	{
+		task->execute_on_a_specific_worker = 1;
+		task->workerid = cmd->_command.event->cq->device->worker_id;
 	}
 
 	gc_entity_store_cmd(&task->cl_arg, cmd);
@@ -93,21 +98,20 @@ cl_int command_copy_buffer_submit(command_copy_buffer cmd) {
 	return CL_SUCCESS;
 }
 
-
 CL_API_ENTRY cl_int CL_API_CALL
-soclEnqueueCopyBuffer(cl_command_queue  cq, 
-                    cl_mem              src_buffer,
-                    cl_mem              dst_buffer, 
-                    size_t              src_offset,
-                    size_t              dst_offset,
-                    size_t              cb, 
-                    cl_uint             num_events,
-                    const cl_event *    events,
-                    cl_event *          event) CL_API_SUFFIX__VERSION_1_0
+soclEnqueueCopyBuffer(cl_command_queue  cq,
+		      cl_mem              src_buffer,
+		      cl_mem              dst_buffer,
+		      size_t              src_offset,
+		      size_t              dst_offset,
+		      size_t              cb,
+		      cl_uint             num_events,
+		      const cl_event *    events,
+		      cl_event *          event) CL_API_SUFFIX__VERSION_1_0
 {
 	command_copy_buffer cmd = command_copy_buffer_create(src_buffer, dst_buffer, src_offset, dst_offset, cb);
 
-   cl_event ev = command_event_get(cmd);
+	cl_event ev = command_event_get(cmd);
 
 	command_queue_enqueue(cq, cmd, num_events, events);
 

socl/src/cl_enqueuecopybuffertoimage.c

@@ -18,14 +18,14 @@
 
 CL_API_ENTRY cl_int CL_API_CALL
 soclEnqueueCopyBufferToImage(cl_command_queue UNUSED(command_queue),
-                           cl_mem           UNUSED(src_buffer),
-                           cl_mem           UNUSED(dst_image), 
-                           size_t           UNUSED(src_offset),
-                           const size_t *   UNUSED(dst_origin),
-                           const size_t *   UNUSED(region), 
-                           cl_uint          UNUSED(num_events_in_wait_list),
-                           const cl_event * UNUSED(event_wait_list),
-                           cl_event *       UNUSED(event)) CL_API_SUFFIX__VERSION_1_0
+			     cl_mem           UNUSED(src_buffer),
+			     cl_mem           UNUSED(dst_image),
+			     size_t           UNUSED(src_offset),
+			     const size_t *   UNUSED(dst_origin),
+			     const size_t *   UNUSED(region),
+			     cl_uint          UNUSED(num_events_in_wait_list),
+			     const cl_event * UNUSED(event_wait_list),
+			     cl_event *       UNUSED(event)) CL_API_SUFFIX__VERSION_1_0
 {
-   return CL_INVALID_OPERATION;
+	return CL_INVALID_OPERATION;
 }

socl/src/cl_enqueuecopyimage.c

@@ -18,14 +18,14 @@
 
 CL_API_ENTRY cl_int CL_API_CALL
 soclEnqueueCopyImage(cl_command_queue   UNUSED(command_queue),
-                   cl_mem               UNUSED(src_image),
-                   cl_mem               UNUSED(dst_image), 
-                   const size_t *       UNUSED(src_origin),
-                   const size_t *       UNUSED(dst_origin),
-                   const size_t *       UNUSED(region), 
-                   cl_uint              UNUSED(num_events_in_wait_list),
-                   const cl_event *     UNUSED(event_wait_list),
-                   cl_event *           UNUSED(event)) CL_API_SUFFIX__VERSION_1_0
+		     cl_mem               UNUSED(src_image),
+		     cl_mem               UNUSED(dst_image),
+		     const size_t *       UNUSED(src_origin),
+		     const size_t *       UNUSED(dst_origin),
+		     const size_t *       UNUSED(region),
+		     cl_uint              UNUSED(num_events_in_wait_list),
+		     const cl_event *     UNUSED(event_wait_list),
+		     cl_event *           UNUSED(event)) CL_API_SUFFIX__VERSION_1_0
 {
-   return CL_INVALID_OPERATION;
+	return CL_INVALID_OPERATION;
 }

socl/src/cl_enqueuecopyimagetobuffer.c

@@ -18,14 +18,14 @@
 
 CL_API_ENTRY cl_int CL_API_CALL
 soclEnqueueCopyImageToBuffer(cl_command_queue UNUSED(command_queue),
-                           cl_mem           UNUSED(src_image),
-                           cl_mem           UNUSED(dst_buffer), 
-                           const size_t *   UNUSED(src_origin),
-                           const size_t *   UNUSED(region), 
-                           size_t           UNUSED(dst_offset),
-                           cl_uint          UNUSED(num_events_in_wait_list),
-                           const cl_event * UNUSED(event_wait_list),
-                           cl_event *       UNUSED(event)) CL_API_SUFFIX__VERSION_1_0
+			     cl_mem           UNUSED(src_image),
+			     cl_mem           UNUSED(dst_buffer),
+			     const size_t *   UNUSED(src_origin),
+			     const size_t *   UNUSED(region),
+			     size_t           UNUSED(dst_offset),
+			     cl_uint          UNUSED(num_events_in_wait_list),
+			     const cl_event * UNUSED(event_wait_list),
+			     cl_event *       UNUSED(event)) CL_API_SUFFIX__VERSION_1_0
 {
-   return CL_INVALID_OPERATION;
+	return CL_INVALID_OPERATION;
 }

socl/src/cl_enqueuemapbuffer.c

@@ -16,25 +16,27 @@
 
 #include "socl.h"
 
-static void mapbuffer_task(void *args) {
+static void mapbuffer_task(void *args)
+{
 	command_map_buffer cmd = (command_map_buffer)args;
 
-  cl_event ev = command_event_get(cmd);
-  ev->prof_start = _socl_nanotime();
-  gc_entity_release(ev);
+	cl_event ev = command_event_get(cmd);
+	ev->prof_start = _socl_nanotime();
+	gc_entity_release(ev);
 
 	enum starpu_data_access_mode mode = (cmd->map_flags == CL_MAP_READ ? STARPU_R : STARPU_RW);
 
 	starpu_data_acquire_cb(cmd->buffer->handle, mode, command_completed_task_callback, cmd);
 }
 
-static struct starpu_codelet codelet_mapbuffer = {
-   .name = "SOCL_MAP_BUFFER"
+static struct starpu_codelet codelet_mapbuffer =
+{
+	.name = "SOCL_MAP_BUFFER"
 };
 
-cl_int command_map_buffer_submit(command_map_buffer cmd) {
-
-   gc_entity_retain(cmd);
+cl_int command_map_buffer_submit(command_map_buffer cmd)
+{
+	gc_entity_retain(cmd);
 
 	cpu_task_submit(cmd, mapbuffer_task, cmd, 0, 0, &codelet_mapbuffer, 0, NULL);
 
@@ -43,20 +45,19 @@ cl_int command_map_buffer_submit(command_map_buffer cmd) {
 
 CL_API_ENTRY void * CL_API_CALL
 soclEnqueueMapBuffer(cl_command_queue cq,
-                   cl_mem           buffer,
-                   cl_bool          blocking, 
-                   cl_map_flags     map_flags,
-                   size_t           offset, 
-                   size_t           cb,
-                   cl_uint          num_events,
-                   const cl_event * events,
-                   cl_event *       event,
-                   cl_int *         errcode_ret) CL_API_SUFFIX__VERSION_1_0
+		     cl_mem           buffer,
+		     cl_bool          blocking,
+		     cl_map_flags     map_flags,
+		     size_t           offset,
+		     size_t           cb,
+		     cl_uint          num_events,
+		     const cl_event * events,
+		     cl_event *       event,
+		     cl_int *         errcode_ret) CL_API_SUFFIX__VERSION_1_0
 {
-
 	command_map_buffer cmd = command_map_buffer_create(buffer, map_flags, offset, cb);
 
-   cl_event ev = command_event_get(cmd);
+	cl_event ev = command_event_get(cmd);
 
 	command_queue_enqueue(cq, cmd, num_events, events);
 

socl/src/cl_enqueuemapimage.c

@@ -18,20 +18,20 @@
 
 CL_API_ENTRY void * CL_API_CALL
 soclEnqueueMapImage(cl_command_queue  UNUSED(command_queue),
-                  cl_mem            UNUSED(image), 
-                  cl_bool           UNUSED(blocking_map), 
-                  cl_map_flags      UNUSED(map_flags), 
-                  const size_t *    UNUSED(origin),
-                  const size_t *    UNUSED(region),
-                  size_t *          UNUSED(image_row_pitch),
-                  size_t *          UNUSED(image_slice_pitch),
-                  cl_uint           UNUSED(num_events_in_wait_list),
-                  const cl_event *  UNUSED(event_wait_list),
-                  cl_event *        UNUSED(event),
-                  cl_int *          errcode_ret) CL_API_SUFFIX__VERSION_1_0
+		    cl_mem            UNUSED(image),
+		    cl_bool           UNUSED(blocking_map),
+		    cl_map_flags      UNUSED(map_flags),
+		    const size_t *    UNUSED(origin),
+		    const size_t *    UNUSED(region),
+		    size_t *          UNUSED(image_row_pitch),
+		    size_t *          UNUSED(image_slice_pitch),
+		    cl_uint           UNUSED(num_events_in_wait_list),
+		    const cl_event *  UNUSED(event_wait_list),
+		    cl_event *        UNUSED(event),
+		    cl_int *          errcode_ret) CL_API_SUFFIX__VERSION_1_0
 {
-   if (errcode_ret != NULL)
-      *errcode_ret = CL_INVALID_OPERATION;
+	if (errcode_ret != NULL)
+		*errcode_ret = CL_INVALID_OPERATION;
 
-   return NULL;
+	return NULL;
 }

socl/src/cl_enqueuemarker.c

@@ -25,7 +25,7 @@ soclEnqueueMarker(cl_command_queue  cq,
 
 	command_marker cmd = command_marker_create();
 
-   cl_event ev = command_event_get(cmd);
+	cl_event ev = command_event_get(cmd);
 
 	command_queue_enqueue(cq, cmd, 0, NULL);
 
@@ -34,7 +34,8 @@ soclEnqueueMarker(cl_command_queue  cq,
 	return CL_SUCCESS;
 }
 
-cl_int command_marker_submit(command_marker cmd) {
+cl_int command_marker_submit(command_marker cmd)
+{
 	struct starpu_task *task;
 	task = task_create(CL_COMMAND_MARKER);
 

socl/src/cl_enqueuemarkerwithwaitlist.c

@@ -18,16 +18,16 @@
 
 CL_API_ENTRY cl_int CL_API_CALL
 soclEnqueueMarkerWithWaitList(cl_command_queue  cq,
-                cl_uint num_events,
-                const cl_event * events,
-                cl_event *          event) CL_API_SUFFIX__VERSION_1_2
+			      cl_uint num_events,
+			      const cl_event * events,
+			      cl_event *          event) CL_API_SUFFIX__VERSION_1_2
 {
 	if (events == NULL)
 		return soclEnqueueBarrierWithWaitList(cq, num_events, events, event);
-	
+
 	command_marker cmd = command_marker_create();
 
-   cl_event ev = command_event_get(cmd);
+	cl_event ev = command_event_get(cmd);
 
 	command_queue_enqueue(cq, cmd, num_events, events);
 

socl/src/cl_enqueuenativekernel.c

@@ -18,15 +18,15 @@
 
 CL_API_ENTRY cl_int CL_API_CALL
 soclEnqueueNativeKernel(cl_command_queue  UNUSED(command_queue),
-					       __attribute__((unused)) void (*user_func)(void *), 
-                      void *            UNUSED(args),
-                      size_t            UNUSED(cb_args), 
-                      cl_uint           UNUSED(num_mem_objects),
-                      const cl_mem *    UNUSED(mem_list),
-                      const void **     UNUSED(args_mem_loc),
-                      cl_uint           UNUSED(num_events_in_wait_list),
-                      const cl_event *  UNUSED(event_wait_list),
-                      cl_event *        UNUSED(event)) CL_API_SUFFIX__VERSION_1_0
+			__attribute__((unused)) void (*user_func)(void *),
+			void *            UNUSED(args),
+			size_t            UNUSED(cb_args),
+			cl_uint           UNUSED(num_mem_objects),
+			const cl_mem *    UNUSED(mem_list),
+			const void **     UNUSED(args_mem_loc),
+			cl_uint           UNUSED(num_events_in_wait_list),
+			const cl_event *  UNUSED(event_wait_list),
+			cl_event *        UNUSED(event)) CL_API_SUFFIX__VERSION_1_0
 {
-   return CL_INVALID_OPERATION;
+	return CL_INVALID_OPERATION;
 }

socl/src/cl_enqueuendrangekernel.c

@@ -18,79 +18,85 @@
 #include "socl.h"
 #include "event.h"
 
-
-void soclEnqueueNDRangeKernel_task(void *descr[], void *args) {
+void soclEnqueueNDRangeKernel_task(void *descr[], void *args)
+{
 	command_ndrange_kernel cmd = (command_ndrange_kernel)args;
 
-   cl_command_queue cq;
-   int wid;
-   cl_int err;
-
-  cl_event ev = command_event_get(cmd);
-  ev->prof_start = _socl_nanotime();
-  gc_entity_release(ev);
-
-   wid = starpu_worker_get_id_check();
-   starpu_opencl_get_queue(wid, &cq);
-
-   DEBUG_MSG("[worker %d] [kernel %d] Executing kernel...\n", wid, cmd->kernel->id);
-
-   int range = starpu_worker_get_range();
-
-   /* Set arguments */
-   {
-	   unsigned int i;
-	   int buf = 0;
-	   for (i=0; i<cmd->num_args; i++) {
-		   switch (cmd->arg_types[i]) {
-			   case Null:
-				   err = clSetKernelArg(cmd->kernel->cl_kernels[range], i, cmd->arg_sizes[i], NULL);
-				   break;
-			   case Buffer: {
-						cl_mem mem;  
-						mem = (cl_mem)STARPU_VARIABLE_GET_PTR(descr[buf]);
-						err = clSetKernelArg(cmd->kernel->cl_kernels[range], i, cmd->arg_sizes[i], &mem);
-						buf++;
-					}
-					break;
-			   case Immediate:
-					err = clSetKernelArg(cmd->kernel->cl_kernels[range], i, cmd->arg_sizes[i], cmd->args[i]);
-					break;
-		   }
-		   if (err != CL_SUCCESS) {
-			   DEBUG_CL("clSetKernelArg", err);
-			   DEBUG_ERROR("Aborting\n");
-		   }
-	   }
-   }
-
-   /* Calling Kernel */
-   cl_event event;
-   err = clEnqueueNDRangeKernel(cq, cmd->kernel->cl_kernels[range], cmd->work_dim, cmd->global_work_offset, cmd->global_work_size, cmd->local_work_size, 0, NULL, &event);
-
-   if (err != CL_SUCCESS) {
-	   ERROR_MSG("Worker[%d] Unable to Enqueue kernel (error %d)\n", wid, err);
-	   DEBUG_CL("clEnqueueNDRangeKernel", err);
-	   DEBUG_MSG("Workdim %u, global_work_offset %p, global_work_size %p, local_work_size %p\n",
-			   cmd->work_dim, cmd->global_work_offset, cmd->global_work_size, cmd->local_work_size);
-	   DEBUG_MSG("Global work size: %ld %ld %ld\n", (long)cmd->global_work_size[0],
-		     (long)(cmd->work_dim > 1 ? cmd->global_work_size[1] : 1), (long)(cmd->work_dim > 2 ? cmd->global_work_size[2] : 1)); 
-	   if (cmd->local_work_size != NULL)
-		   DEBUG_MSG("Local work size: %ld %ld %ld\n", (long)cmd->local_work_size[0],
-			     (long)(cmd->work_dim > 1 ? cmd->local_work_size[1] : 1), (long)(cmd->work_dim > 2 ? cmd->local_work_size[2] : 1)); 
-   }
-   else {
-      /* Waiting for kernel to terminate */
-      clWaitForEvents(1, &event);
-      clReleaseEvent(event);
-   }
+	cl_command_queue cq;
+	int wid;
+	cl_int err;
+
+	cl_event ev = command_event_get(cmd);
+	ev->prof_start = _socl_nanotime();
+	gc_entity_release(ev);
+
+	wid = starpu_worker_get_id_check();
+	starpu_opencl_get_queue(wid, &cq);
+
+	DEBUG_MSG("[worker %d] [kernel %d] Executing kernel...\n", wid, cmd->kernel->id);
+
+	int range = starpu_worker_get_range();
+
+	/* Set arguments */
+	{
+		unsigned int i;
+		int buf = 0;
+		for (i=0; i<cmd->num_args; i++)
+		{
+			switch (cmd->arg_types[i])
+			{
+			case Null:
+				err = clSetKernelArg(cmd->kernel->cl_kernels[range], i, cmd->arg_sizes[i], NULL);
+				break;
+			case Buffer:
+			{
+				cl_mem mem;
+				mem = (cl_mem)STARPU_VARIABLE_GET_PTR(descr[buf]);
+				err = clSetKernelArg(cmd->kernel->cl_kernels[range], i, cmd->arg_sizes[i], &mem);
+				buf++;
+			}
+			break;
+			case Immediate:
+				err = clSetKernelArg(cmd->kernel->cl_kernels[range], i, cmd->arg_sizes[i], cmd->args[i]);
+				break;
+			}
+			if (err != CL_SUCCESS)
+			{
+				DEBUG_CL("clSetKernelArg", err);
+				DEBUG_ERROR("Aborting\n");
+			}
+		}
+	}
+
+	/* Calling Kernel */
+	cl_event event;
+	err = clEnqueueNDRangeKernel(cq, cmd->kernel->cl_kernels[range], cmd->work_dim, cmd->global_work_offset, cmd->global_work_size, cmd->local_work_size, 0, NULL, &event);
+
+	if (err != CL_SUCCESS)
+	{
+		ERROR_MSG("Worker[%d] Unable to Enqueue kernel (error %d)\n", wid, err);
+		DEBUG_CL("clEnqueueNDRangeKernel", err);
+		DEBUG_MSG("Workdim %u, global_work_offset %p, global_work_size %p, local_work_size %p\n",
+			  cmd->work_dim, cmd->global_work_offset, cmd->global_work_size, cmd->local_work_size);
+		DEBUG_MSG("Global work size: %ld %ld %ld\n", (long)cmd->global_work_size[0],
+			  (long)(cmd->work_dim > 1 ? cmd->global_work_size[1] : 1), (long)(cmd->work_dim > 2 ? cmd->global_work_size[2] : 1));
+		if (cmd->local_work_size != NULL)
+			DEBUG_MSG("Local work size: %ld %ld %ld\n", (long)cmd->local_work_size[0],
+				  (long)(cmd->work_dim > 1 ? cmd->local_work_size[1] : 1), (long)(cmd->work_dim > 2 ? cmd->local_work_size[2] : 1));
+	}
+	else
+	{
+		/* Waiting for kernel to terminate */
+		clWaitForEvents(1, &event);
+		clReleaseEvent(event);
+	}
 }
 
 /**
  * Real kernel enqueuing command
  */
-cl_int command_ndrange_kernel_submit(command_ndrange_kernel cmd) {
-
+cl_int command_ndrange_kernel_submit(command_ndrange_kernel cmd)
+{
 	starpu_task task = task_create();
 	task->cl = &cmd->codelet;
 	task->cl->model = cmd->kernel->perfmodel;
@@ -98,9 +104,10 @@ cl_int command_ndrange_kernel_submit(command_ndrange_kernel cmd) {
 	task->cl_arg_size = sizeof(cmd);
 
 	/* Execute the task on a specific worker? */
-	if (cmd->_command.event->cq->device != NULL) {
-	  task->execute_on_a_specific_worker = 1;
-	  task->workerid = cmd->_command.event->cq->device->worker_id;
+	if (cmd->_command.event->cq->device != NULL)
+	{
+		task->execute_on_a_specific_worker = 1;
+		task->workerid = cmd->_command.event->cq->device->worker_id;
 	}
 
 	struct starpu_codelet * codelet = task->cl;
@@ -111,9 +118,10 @@ cl_int command_ndrange_kernel_submit(command_ndrange_kernel cmd) {
 	cmd->buffers = malloc(sizeof(cl_mem) * cmd->num_args);
 
 	unsigned int i;
-	for (i=0; i<cmd->num_args; i++) {
-		if (cmd->arg_types[i] == Buffer) {
-
+	for (i=0; i<cmd->num_args; i++)
+	{
+		if (cmd->arg_types[i] == Buffer)
+		{
 			cl_mem buf = *(cl_mem*)cmd->args[i];
 
 			gc_entity_store(&cmd->buffers[cmd->num_buffers], buf);
@@ -123,19 +131,22 @@ cl_int command_ndrange_kernel_submit(command_ndrange_kernel cmd) {
 			int mode;
 			if (buf->mode == CL_MEM_READ_ONLY)
 				mode = STARPU_R;
-			else if (buf->mode == CL_MEM_WRITE_ONLY) {
+			else if (buf->mode == CL_MEM_WRITE_ONLY)
+			{
 				mode = STARPU_W;
 				buf->scratch = 0;
 			}
-			else if (buf->scratch) { //RW but never accessed in RW or W mode
+			else if (buf->scratch)
+			{ //RW but never accessed in RW or W mode
 				mode = STARPU_W;
 				buf->scratch = 0;
 			}
-			else {
+			else
+			{
 				mode = STARPU_RW;
 				buf->scratch = 0;
 			}
-			codelet->modes[cmd->num_buffers] = mode; 
+			codelet->modes[cmd->num_buffers] = mode;
 
 			cmd->num_buffers += 1;
 		}
@@ -147,87 +158,91 @@ cl_int command_ndrange_kernel_submit(command_ndrange_kernel cmd) {
 	return CL_SUCCESS;
 }
 
-
 CL_API_ENTRY cl_int CL_API_CALL
 soclEnqueueNDRangeKernel(cl_command_queue cq,
-		cl_kernel        kernel,
-		cl_uint          work_dim,
-		const size_t *   global_work_offset,
-		const size_t *   global_work_size,
-		const size_t *   local_work_size,
-		cl_uint          num_events,
-		const cl_event * events,
-		cl_event *       event) CL_API_SUFFIX__VERSION_1_1
+			 cl_kernel        kernel,
+			 cl_uint          work_dim,
+			 const size_t *   global_work_offset,
+			 const size_t *   global_work_size,
+			 const size_t *   local_work_size,
+			 cl_uint          num_events,
+			 const cl_event * events,
+			 cl_event *       event) CL_API_SUFFIX__VERSION_1_1
 {
+	if (kernel->split_func != NULL && !STARPU_PTHREAD_MUTEX_TRYLOCK(&kernel->split_lock))
+	{
+		cl_event beforeEvent, afterEvent, totalEvent;
+
+		totalEvent = event_create();
+		gc_entity_store(&totalEvent->cq, cq);
+
+		command_marker cmd = command_marker_create();
+		beforeEvent = command_event_get(cmd);
+		command_queue_enqueue(cq, cmd, num_events, events);
+
+		cl_uint iter = 1;
+		cl_uint split_min = CL_UINT_MAX;
+		cl_uint split_min_iter = 1;
+		while (iter < kernel->split_space && kernel->split_perfs[iter] != 0)
+		{
+			if (kernel->split_perfs[iter] < split_min)
+			{
+				split_min = kernel->split_perfs[iter];
+				split_min_iter = iter;
+			}
+			iter++;
+		}
 
-   if (kernel->split_func != NULL && !STARPU_PTHREAD_MUTEX_TRYLOCK(&kernel->split_lock)) {
-
-      cl_event beforeEvent, afterEvent, totalEvent;
-
-      totalEvent = event_create();
-      gc_entity_store(&totalEvent->cq, cq);
-
-      command_marker cmd = command_marker_create();
-      beforeEvent = command_event_get(cmd);
-      command_queue_enqueue(cq, cmd, num_events, events);
-   
-      cl_uint iter = 1;
-      cl_uint split_min = CL_UINT_MAX;
-      cl_uint split_min_iter = 1;
-      while (iter < kernel->split_space && kernel->split_perfs[iter] != 0) {
-         if (kernel->split_perfs[iter] < split_min) {
-            split_min = kernel->split_perfs[iter];
-            split_min_iter = iter;
-         }
-         iter++;
-      }
-
-      if (iter == kernel->split_space) {
-         iter = split_min_iter;
-      }
-
-      cl_int ret = kernel->split_func(cq, iter, kernel->split_data, beforeEvent, &afterEvent);
+		if (iter == kernel->split_space)
+		{
+			iter = split_min_iter;
+		}
 
-      if (ret == CL_SUCCESS) {
-         //FIXME: blocking call
-         soclWaitForEvents(1, &afterEvent);
+		cl_int ret = kernel->split_func(cq, iter, kernel->split_data, beforeEvent, &afterEvent);
 
-         /* Store perf */
-         cl_ulong start,end;
-         soclGetEventProfilingInfo(beforeEvent, CL_PROFILING_COMMAND_END, sizeof(cl_ulong), &start, NULL);
-         soclGetEventProfilingInfo(afterEvent, CL_PROFILING_COMMAND_END, sizeof(cl_ulong), &end, NULL);
-         soclReleaseEvent(afterEvent);
+		if (ret == CL_SUCCESS)
+		{
+			//FIXME: blocking call
+			soclWaitForEvents(1, &afterEvent);
 
-         kernel->split_perfs[iter] = end-start;
+			/* Store perf */
+			cl_ulong start,end;
+			soclGetEventProfilingInfo(beforeEvent, CL_PROFILING_COMMAND_END, sizeof(cl_ulong), &start, NULL);
+			soclGetEventProfilingInfo(afterEvent, CL_PROFILING_COMMAND_END, sizeof(cl_ulong), &end, NULL);
+			soclReleaseEvent(afterEvent);
 
-         STARPU_PTHREAD_MUTEX_UNLOCK(&kernel->split_lock);
+			kernel->split_perfs[iter] = end-start;
 
-         event_complete(totalEvent);
+			STARPU_PTHREAD_MUTEX_UNLOCK(&kernel->split_lock);
 
-         totalEvent->prof_start = start;
-         totalEvent->prof_submit = start;
-         totalEvent->prof_queued = start;
-         totalEvent->prof_end = end;
+			event_complete(totalEvent);
 
-         RETURN_EVENT(totalEvent,event);
-      } else {
-         STARPU_PTHREAD_MUTEX_UNLOCK(&kernel->split_lock);
-         soclReleaseEvent(totalEvent);
-      }
+			totalEvent->prof_start = start;
+			totalEvent->prof_submit = start;
+			totalEvent->prof_queued = start;
+			totalEvent->prof_end = end;
 
-      return ret;
-   }
-   else {
+			RETURN_EVENT(totalEvent,event);
+		}
+		else
+		{
+			STARPU_PTHREAD_MUTEX_UNLOCK(&kernel->split_lock);
+			soclReleaseEvent(totalEvent);
+		}
 
-      command_ndrange_kernel cmd = command_ndrange_kernel_create(kernel, work_dim,
-            global_work_offset, global_work_size, local_work_size);
+		return ret;
+	}
+	else
+	{
+		command_ndrange_kernel cmd = command_ndrange_kernel_create(kernel, work_dim,
+									   global_work_offset, global_work_size, local_work_size);
 
-      cl_event ev = command_event_get(cmd);
+		cl_event ev = command_event_get(cmd);
 
-      command_queue_enqueue(cq, cmd, num_events, events);
+		command_queue_enqueue(cq, cmd, num_events, events);
 
-      RETURN_EVENT(ev, event);
-   }
+		RETURN_EVENT(ev, event);
+	}
 
 	return CL_SUCCESS;
 }

socl/src/cl_enqueuereadbuffer.c

@@ -17,75 +17,80 @@
 
 #include "socl.h"
 
-static void soclEnqueueReadBuffer_cpu_task(void *descr[], void *args) {
-   command_read_buffer cmd = (command_read_buffer)args;
+static void soclEnqueueReadBuffer_cpu_task(void *descr[], void *args)
+{
+	command_read_buffer cmd = (command_read_buffer)args;
 
-  cl_event ev = command_event_get(cmd);
-  ev->prof_start = _socl_nanotime();
-  gc_entity_release(ev);
+	cl_event ev = command_event_get(cmd);
+	ev->prof_start = _socl_nanotime();
+	gc_entity_release(ev);
 
-   char * ptr = (void*)STARPU_VARIABLE_GET_PTR(descr[0]);
-   DEBUG_MSG("[Buffer %d] Reading %ld bytes from %p to %p\n", cmd->buffer->id, (long)cmd->cb, ptr+cmd->offset, cmd->ptr);
+	char * ptr = (void*)STARPU_VARIABLE_GET_PTR(descr[0]);
+	DEBUG_MSG("[Buffer %d] Reading %ld bytes from %p to %p\n", cmd->buffer->id, (long)cmd->cb, ptr+cmd->offset, cmd->ptr);
 
-   //This fix is for people who use USE_HOST_PTR and still use ReadBuffer to sync the buffer in host mem at host_ptr.
-   //They should use buffer mapping facilities instead.
-   if (ptr+cmd->offset != cmd->ptr)
-      memcpy(cmd->ptr, ptr+cmd->offset, cmd->cb);
+	//This fix is for people who use USE_HOST_PTR and still use ReadBuffer to sync the buffer in host mem at host_ptr.
+	//They should use buffer mapping facilities instead.
+	if (ptr+cmd->offset != cmd->ptr)
+		memcpy(cmd->ptr, ptr+cmd->offset, cmd->cb);
 
-   gc_entity_release_cmd(cmd);
+	gc_entity_release_cmd(cmd);
 }
 
-static void soclEnqueueReadBuffer_opencl_task(void *descr[], void *args) {
-   command_read_buffer cmd = (command_read_buffer)args;
+static void soclEnqueueReadBuffer_opencl_task(void *descr[], void *args)
+{
+	command_read_buffer cmd = (command_read_buffer)args;
 
-  cl_event event = command_event_get(cmd);
-  event->prof_start = _socl_nanotime();
-  gc_entity_release(event);
+	cl_event event = command_event_get(cmd);
+	event->prof_start = _socl_nanotime();
+	gc_entity_release(event);
 
-   cl_mem mem = (cl_mem)STARPU_VARIABLE_GET_PTR(descr[0]);
+	cl_mem mem = (cl_mem)STARPU_VARIABLE_GET_PTR(descr[0]);
 
-   DEBUG_MSG("[Buffer %d] Reading %ld bytes from offset %ld into %p\n", cmd->buffer->id, (long)cmd->cb, (long)cmd->offset, cmd->ptr);
+	DEBUG_MSG("[Buffer %d] Reading %ld bytes from offset %ld into %p\n", cmd->buffer->id, (long)cmd->cb, (long)cmd->offset, cmd->ptr);
 
-   int wid = starpu_worker_get_id_check();
-   cl_command_queue cq;
-   starpu_opencl_get_queue(wid, &cq);
+	int wid = starpu_worker_get_id_check();
+	cl_command_queue cq;
+	starpu_opencl_get_queue(wid, &cq);
 
-   cl_event ev;
-   cl_int ret = clEnqueueReadBuffer(cq, mem, CL_TRUE, cmd->offset, cmd->cb, cmd->ptr, 0, NULL, &ev);
-   if (ret != CL_SUCCESS)
-      ERROR_CL("clEnqueueReadBuffer", ret);
+	cl_event ev;
+	cl_int ret = clEnqueueReadBuffer(cq, mem, CL_TRUE, cmd->offset, cmd->cb, cmd->ptr, 0, NULL, &ev);
+	if (ret != CL_SUCCESS)
+		ERROR_CL("clEnqueueReadBuffer", ret);
 
-   clWaitForEvents(1, &ev);
-   clReleaseEvent(ev);
+	clWaitForEvents(1, &ev);
+	clReleaseEvent(ev);
 
-   gc_entity_release_cmd(cmd);
+	gc_entity_release_cmd(cmd);
 }
 
-static struct starpu_perfmodel read_buffer_perfmodel = {
-  .type = STARPU_HISTORY_BASED,
-  .symbol = "SOCL_READ_BUFFER"
+static struct starpu_perfmodel read_buffer_perfmodel =
+{
+	.type = STARPU_HISTORY_BASED,
+	.symbol = "SOCL_READ_BUFFER"
 };
 
-static struct starpu_codelet codelet_readbuffer = {
-   .where = STARPU_OPENCL,
-   .model = &read_buffer_perfmodel,
-   .cpu_funcs = { &soclEnqueueReadBuffer_cpu_task },
-   .opencl_funcs = { &soclEnqueueReadBuffer_opencl_task },
-   .modes = {STARPU_R},
-   .nbuffers = 1
+static struct starpu_codelet codelet_readbuffer =
+{
+	.where = STARPU_OPENCL,
+	.model = &read_buffer_perfmodel,
+	.cpu_funcs = { &soclEnqueueReadBuffer_cpu_task },
+	.opencl_funcs = { &soclEnqueueReadBuffer_opencl_task },
+	.modes = {STARPU_R},
+	.nbuffers = 1
 };
 
-cl_int command_read_buffer_submit(command_read_buffer cmd) {
-
+cl_int command_read_buffer_submit(command_read_buffer cmd)
+{
 	struct starpu_task * task = task_create(CL_COMMAND_READ_BUFFER);
 
 	task->handles[0] = cmd->buffer->handle;
 	task->cl = &codelet_readbuffer;
 
 	/* Execute the task on a specific worker? */
-	if (cmd->_command.event->cq->device != NULL) {
-	  task->execute_on_a_specific_worker = 1;
-	  task->workerid = cmd->_command.event->cq->device->worker_id;
+	if (cmd->_command.event->cq->device != NULL)
+	{
+		task->execute_on_a_specific_worker = 1;
+		task->workerid = cmd->_command.event->cq->device->worker_id;
 	}
 
 	gc_entity_store_cmd(&task->cl_arg, cmd);
@@ -96,22 +101,20 @@ cl_int command_read_buffer_submit(command_read_buffer cmd) {
 	return CL_SUCCESS;
 }
 
-
 CL_API_ENTRY cl_int CL_API_CALL
 soclEnqueueReadBuffer(cl_command_queue  cq,
-                    cl_mem              buffer,
-                    cl_bool             blocking,
-                    size_t              offset,
-                    size_t              cb, 
-                    void *              ptr,
-                    cl_uint             num_events,
-                    const cl_event *    events,
-                    cl_event *          event) CL_API_SUFFIX__VERSION_1_0
-{ 
-
+		      cl_mem              buffer,
+		      cl_bool             blocking,
+		      size_t              offset,
+		      size_t              cb,
+		      void *              ptr,
+		      cl_uint             num_events,
+		      const cl_event *    events,
+		      cl_event *          event) CL_API_SUFFIX__VERSION_1_0
+{
 	command_read_buffer cmd = command_read_buffer_create(buffer, offset, cb, ptr);
 
-   cl_event ev = command_event_get(cmd);
+	cl_event ev = command_event_get(cmd);
 
 	command_queue_enqueue(cq, cmd, num_events, events);
 

socl/src/cl_enqueuereadimage.c

@@ -18,16 +18,16 @@
 
 CL_API_ENTRY cl_int CL_API_CALL
 soclEnqueueReadImage(cl_command_queue   UNUSED(command_queue),
-                   cl_mem               UNUSED(image),
-                   cl_bool              UNUSED(blocking_read), 
-                   const size_t *       UNUSED(origin),
-                   const size_t *       UNUSED(region),
-                   size_t               UNUSED(row_pitch),
-                   size_t               UNUSED(slice_pitch), 
-                   void *               UNUSED(ptr),
-                   cl_uint              UNUSED(num_events_in_wait_list),
-                   const cl_event *     UNUSED(event_wait_list),
-                   cl_event *           UNUSED(event)) CL_API_SUFFIX__VERSION_1_0
+		     cl_mem               UNUSED(image),
+		     cl_bool              UNUSED(blocking_read),
+		     const size_t *       UNUSED(origin),
+		     const size_t *       UNUSED(region),
+		     size_t               UNUSED(row_pitch),
+		     size_t               UNUSED(slice_pitch),
+		     void *               UNUSED(ptr),
+		     cl_uint              UNUSED(num_events_in_wait_list),
+		     const cl_event *     UNUSED(event_wait_list),
+		     cl_event *           UNUSED(event)) CL_API_SUFFIX__VERSION_1_0
 {
-   return CL_INVALID_OPERATION;
+	return CL_INVALID_OPERATION;
 }

socl/src/cl_enqueuetask.c

@@ -18,15 +18,15 @@
 
 CL_API_ENTRY cl_int CL_API_CALL
 soclEnqueueTask(cl_command_queue cq,
-              cl_kernel         kernel,
-              cl_uint           num_events,
-              const cl_event *  events,
-              cl_event *        event) CL_API_SUFFIX__VERSION_1_0
+		cl_kernel         kernel,
+		cl_uint           num_events,
+		const cl_event *  events,
+		cl_event *        event) CL_API_SUFFIX__VERSION_1_0
 {
 	command_ndrange_kernel cmd = command_task_create(kernel);
 
-   cl_event ev = command_event_get(cmd);
-	
+	cl_event ev = command_event_get(cmd);
+
 	command_queue_enqueue(cq, cmd, num_events, events);
 
 	RETURN_EVENT(ev, event);

socl/src/cl_enqueueunmapmemobject.c

@@ -16,11 +16,13 @@
 
 #include "socl.h"
 
-cl_int command_unmap_mem_object_submit(command_unmap_mem_object cmd) {
+cl_int command_unmap_mem_object_submit(command_unmap_mem_object cmd)
+{
 	/* Aliases */
 	cl_mem buffer = cmd->buffer;
 
-	static struct starpu_codelet codelet = {
+	static struct starpu_codelet codelet =
+	{
 		.name = "SOCL_UNMAP_MEM_OBJECT"
 	};
 	cpu_task_submit(cmd, (void(*)(void*))starpu_data_release, buffer->handle, 0, 1, &codelet, 0, NULL);
@@ -30,15 +32,15 @@ cl_int command_unmap_mem_object_submit(command_unmap_mem_object cmd) {
 
 CL_API_ENTRY cl_int CL_API_CALL
 soclEnqueueUnmapMemObject(cl_command_queue cq,
-                        cl_mem            buffer,
-                        void *            ptr,
-                        cl_uint           num_events,
-                        const cl_event *  events,
-                        cl_event *        event) CL_API_SUFFIX__VERSION_1_0
+			  cl_mem            buffer,
+			  void *            ptr,
+			  cl_uint           num_events,
+			  const cl_event *  events,
+			  cl_event *        event) CL_API_SUFFIX__VERSION_1_0
 {
 	command_unmap_mem_object cmd = command_unmap_mem_object_create(buffer, ptr);
 
-   cl_event ev = command_event_get(cmd);
+	cl_event ev = command_event_get(cmd);
 
 	command_queue_enqueue(cq, cmd, num_events, events);
 

socl/src/cl_enqueuewaitforevents.c

@@ -18,10 +18,9 @@
 
 CL_API_ENTRY cl_int CL_API_CALL
 soclEnqueueWaitForEvents(cl_command_queue cq,
-                       cl_uint          num_events,
-                       const cl_event * events) CL_API_SUFFIX__VERSION_1_0
+			 cl_uint          num_events,
+			 const cl_event * events) CL_API_SUFFIX__VERSION_1_0
 {
-
 	command_marker cmd = command_marker_create();
 
 	command_queue_enqueue(cq, cmd, num_events, events);

socl/src/cl_enqueuewritebuffer.c

@@ -17,100 +17,105 @@
 
 #include "socl.h"
 
+static void soclEnqueueWriteBuffer_cpu_task(void *descr[], void *args)
+{
+	command_write_buffer cmd = (command_write_buffer)args;
 
-static void soclEnqueueWriteBuffer_cpu_task(void *descr[], void *args) {
-   command_write_buffer cmd = (command_write_buffer)args;
+	cl_event ev = command_event_get(cmd);
+	ev->prof_start = _socl_nanotime();
+	gc_entity_release(ev);
 
-  cl_event ev = command_event_get(cmd);
-  ev->prof_start = _socl_nanotime();
-  gc_entity_release(ev);
+	char * ptr = (void*)STARPU_VARIABLE_GET_PTR(descr[0]);
+	DEBUG_MSG("[Buffer %d] Writing %ld bytes from %p to %p\n", cmd->buffer->id, (long)cmd->cb, cmd->ptr, ptr+cmd->offset);
 
-   char * ptr = (void*)STARPU_VARIABLE_GET_PTR(descr[0]);
-   DEBUG_MSG("[Buffer %d] Writing %ld bytes from %p to %p\n", cmd->buffer->id, (long)cmd->cb, cmd->ptr, ptr+cmd->offset);
+	//FIXME: Fix for people who use USE_HOST_PTR, modify data at host_ptr and use WriteBuffer to commit the change.
+	// StarPU may have erased host mem at host_ptr (for instance by retrieving current buffer data at host_ptr)
+	// Buffer mapping facilities should be used instead
+	// Maybe we should report the bug here... for now, we just avoid memcpy crash due to overlapping regions...
+	if (ptr+cmd->offset != cmd->ptr)
+		memcpy(ptr+cmd->offset, cmd->ptr, cmd->cb);
 
-   //FIXME: Fix for people who use USE_HOST_PTR, modify data at host_ptr and use WriteBuffer to commit the change.
-   // StarPU may have erased host mem at host_ptr (for instance by retrieving current buffer data at host_ptr)
-   // Buffer mapping facilities should be used instead
-   // Maybe we should report the bug here... for now, we just avoid memcpy crash due to overlapping regions...
-   if (ptr+cmd->offset != cmd->ptr)
-      memcpy(ptr+cmd->offset, cmd->ptr, cmd->cb);
-
-   gc_entity_release_cmd(cmd);
+	gc_entity_release_cmd(cmd);
 }
 
-static void soclEnqueueWriteBuffer_opencl_task(void *descr[], void *args) {
-   command_write_buffer cmd = (command_write_buffer)args;
+static void soclEnqueueWriteBuffer_opencl_task(void *descr[], void *args)
+{
+	command_write_buffer cmd = (command_write_buffer)args;
 
-  cl_event event = command_event_get(cmd);
-  event->prof_start = _socl_nanotime();
-  gc_entity_release(event);
+	cl_event event = command_event_get(cmd);
+	event->prof_start = _socl_nanotime();
+	gc_entity_release(event);
 
-   cl_mem mem = (cl_mem)STARPU_VARIABLE_GET_PTR(descr[0]);
+	cl_mem mem = (cl_mem)STARPU_VARIABLE_GET_PTR(descr[0]);
 
-   DEBUG_MSG("[Buffer %d] Writing %ld bytes to offset %ld from %p\n", cmd->buffer->id, (long)cmd->cb, (long)cmd->offset, cmd->ptr);
+	DEBUG_MSG("[Buffer %d] Writing %ld bytes to offset %ld from %p\n", cmd->buffer->id, (long)cmd->cb, (long)cmd->offset, cmd->ptr);
 
-   int wid = starpu_worker_get_id_check();
-   cl_command_queue cq;
-   starpu_opencl_get_queue(wid, &cq);
+	int wid = starpu_worker_get_id_check();
+	cl_command_queue cq;
+	starpu_opencl_get_queue(wid, &cq);
 
-   cl_event ev;
+	cl_event ev;
 
-   cl_int err = clEnqueueWriteBuffer(cq, mem, CL_TRUE, cmd->offset, cmd->cb, cmd->ptr, 0, NULL, &ev);
-   if (err != CL_SUCCESS)
-      ERROR_CL("clEnqueueWriteBuffer", err);
+	cl_int err = clEnqueueWriteBuffer(cq, mem, CL_TRUE, cmd->offset, cmd->cb, cmd->ptr, 0, NULL, &ev);
+	if (err != CL_SUCCESS)
+		ERROR_CL("clEnqueueWriteBuffer", err);
 
-   clWaitForEvents(1, &ev);
-   clReleaseEvent(ev);
+	clWaitForEvents(1, &ev);
+	clReleaseEvent(ev);
 
-   gc_entity_release_cmd(cmd);
+	gc_entity_release_cmd(cmd);
 }
 
-static struct starpu_perfmodel write_buffer_perfmodel = {
-  .type = STARPU_HISTORY_BASED,
-  .symbol = "SOCL_WRITE_BUFFER"
+static struct starpu_perfmodel write_buffer_perfmodel =
+{
+	.type = STARPU_HISTORY_BASED,
+	.symbol = "SOCL_WRITE_BUFFER"
 };
 
-static struct starpu_codelet codelet_writebuffer = {
-   .where = STARPU_OPENCL,
-   .model = &write_buffer_perfmodel,
-   .cpu_funcs = { &soclEnqueueWriteBuffer_cpu_task },
-   .opencl_funcs = { &soclEnqueueWriteBuffer_opencl_task },
-   .modes = {STARPU_W},
-   .nbuffers = 1
+static struct starpu_codelet codelet_writebuffer =
+{
+	.where = STARPU_OPENCL,
+	.model = &write_buffer_perfmodel,
+	.cpu_funcs = { &soclEnqueueWriteBuffer_cpu_task },
+	.opencl_funcs = { &soclEnqueueWriteBuffer_opencl_task },
+	.modes = {STARPU_W},
+	.nbuffers = 1
 };
 
-static struct starpu_codelet codelet_writebuffer_partial = {
-   .where = STARPU_OPENCL,
-   .model = &write_buffer_perfmodel,
-   .cpu_funcs = { &soclEnqueueWriteBuffer_cpu_task },
-   .opencl_funcs = { &soclEnqueueWriteBuffer_opencl_task },
-   .modes = {STARPU_RW},
-   .nbuffers = 1
+static struct starpu_codelet codelet_writebuffer_partial =
+{
+	.where = STARPU_OPENCL,
+	.model = &write_buffer_perfmodel,
+	.cpu_funcs = { &soclEnqueueWriteBuffer_cpu_task },
+	.opencl_funcs = { &soclEnqueueWriteBuffer_opencl_task },
+	.modes = {STARPU_RW},
+	.nbuffers = 1
 };
 
-cl_int command_write_buffer_submit(command_write_buffer cmd) {
+cl_int command_write_buffer_submit(command_write_buffer cmd)
+{
 	/* Aliases */
 	cl_mem buffer = cmd->buffer;
 	size_t cb = cmd->cb;
 
 	struct starpu_task *task;
-
 	task = task_create(CL_COMMAND_WRITE_BUFFER);
 
 	task->handles[0] = buffer->handle;
 	//If only a subpart of the buffer is written, RW access mode is required
 	if (cb != buffer->size)
 		task->cl = &codelet_writebuffer_partial;
-	else 
+	else
 		task->cl = &codelet_writebuffer;
 
 	gc_entity_store_cmd(&task->cl_arg, cmd);
 	task->cl_arg_size = sizeof(*cmd);
 
 	/* Execute the task on a specific worker? */
-	if (cmd->_command.event->cq->device != NULL) {
-	  task->execute_on_a_specific_worker = 1;
-	  task->workerid = cmd->_command.event->cq->device->worker_id;
+	if (cmd->_command.event->cq->device != NULL)
+	{
+		task->execute_on_a_specific_worker = 1;
+		task->workerid = cmd->_command.event->cq->device->worker_id;
 	}
 
 	//The buffer now contains meaningful data
@@ -122,19 +127,19 @@ cl_int command_write_buffer_submit(command_write_buffer cmd) {
 }
 
 CL_API_ENTRY cl_int CL_API_CALL
-soclEnqueueWriteBuffer(cl_command_queue cq, 
-                     cl_mem             buffer, 
-                     cl_bool            blocking, 
-                     size_t             offset, 
-                     size_t             cb, 
-                     const void *       ptr, 
-                     cl_uint            num_events, 
-                     const cl_event *   events, 
-                     cl_event *         event) CL_API_SUFFIX__VERSION_1_0
-{ 
+soclEnqueueWriteBuffer(cl_command_queue cq,
+		       cl_mem             buffer,
+		       cl_bool            blocking,
+		       size_t             offset,
+		       size_t             cb,
+		       const void *       ptr,
+		       cl_uint            num_events,
+		       const cl_event *   events,
+		       cl_event *         event) CL_API_SUFFIX__VERSION_1_0
+{
 	command_write_buffer cmd = command_write_buffer_create(buffer, offset, cb, ptr);
 
-   cl_event ev = command_event_get(cmd);
+	cl_event ev = command_event_get(cmd);
 
 	command_queue_enqueue(cq, cmd, num_events, events);
 

socl/src/cl_enqueuewriteimage.c

@@ -18,16 +18,16 @@
 
 CL_API_ENTRY cl_int CL_API_CALL
 soclEnqueueWriteImage(cl_command_queue  UNUSED(command_queue),
-                    cl_mem              UNUSED(image),
-                    cl_bool             UNUSED(blocking_write), 
-                    const size_t *      UNUSED(origin),
-                    const size_t *      UNUSED(region),
-                    size_t              UNUSED(input_row_pitch),
-                    size_t              UNUSED(input_slice_pitch), 
-                    const void *        UNUSED(ptr),
-                    cl_uint             UNUSED(num_events_in_wait_list),
-                    const cl_event *    UNUSED(event_wait_list),
-                    cl_event *          UNUSED(event)) CL_API_SUFFIX__VERSION_1_0
+		      cl_mem              UNUSED(image),
+		      cl_bool             UNUSED(blocking_write),
+		      const size_t *      UNUSED(origin),
+		      const size_t *      UNUSED(region),
+		      size_t              UNUSED(input_row_pitch),
+		      size_t              UNUSED(input_slice_pitch),
+		      const void *        UNUSED(ptr),
+		      cl_uint             UNUSED(num_events_in_wait_list),
+		      const cl_event *    UNUSED(event_wait_list),
+		      cl_event *          UNUSED(event)) CL_API_SUFFIX__VERSION_1_0
 {
-   return CL_INVALID_OPERATION;
+	return CL_INVALID_OPERATION;
 }

socl/src/cl_finish.c

@@ -17,11 +17,11 @@
 #include "socl.h"
 
 CL_API_ENTRY cl_int CL_API_CALL
-soclFinish(cl_command_queue cq) CL_API_SUFFIX__VERSION_1_0 {
-
+soclFinish(cl_command_queue cq) CL_API_SUFFIX__VERSION_1_0
+{
 	command_barrier cmd = command_barrier_create();
 
-   cl_event ev = command_event_get(cmd);
+	cl_event ev = command_event_get(cmd);
 
 	command_queue_enqueue(cq, cmd, 0, NULL);
 

socl/src/cl_flush.c

@@ -19,5 +19,5 @@
 CL_API_ENTRY cl_int CL_API_CALL
 soclFlush(cl_command_queue UNUSED(command_queue)) CL_API_SUFFIX__VERSION_1_0
 {
-   return CL_SUCCESS;
+	return CL_SUCCESS;
 }

socl/src/cl_getcommandqueueinfo.c

@@ -19,22 +19,23 @@
 
 CL_API_ENTRY cl_int CL_API_CALL
 soclGetCommandQueueInfo(cl_command_queue    cq,
-                      cl_command_queue_info param_name,
-                      size_t                param_value_size,
-                      void *                param_value,
-                      size_t *              param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
+			cl_command_queue_info param_name,
+			size_t                param_value_size,
+			void *                param_value,
+			size_t *              param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
 {
-   if (cq == NULL)
-      return CL_INVALID_COMMAND_QUEUE;
+	if (cq == NULL)
+		return CL_INVALID_COMMAND_QUEUE;
 
-   switch (param_name) {
-      INFO_CASE(CL_QUEUE_CONTEXT, cq->context);
-      INFO_CASE(CL_QUEUE_DEVICE, cq->device);
-      INFO_CASE(CL_QUEUE_REFERENCE_COUNT, cq->_entity.refs);
-      INFO_CASE(CL_QUEUE_PROPERTIES, cq->properties);
-      default:
-         return CL_INVALID_VALUE;
-   }
+	switch (param_name)
+	{
+		INFO_CASE(CL_QUEUE_CONTEXT, cq->context);
+		INFO_CASE(CL_QUEUE_DEVICE, cq->device);
+		INFO_CASE(CL_QUEUE_REFERENCE_COUNT, cq->_entity.refs);
+		INFO_CASE(CL_QUEUE_PROPERTIES, cq->properties);
+	default:
+		return CL_INVALID_VALUE;
+	}
 
-   return CL_SUCCESS; 
+	return CL_SUCCESS;
 }

socl/src/cl_getcontextinfo.c

@@ -18,22 +18,23 @@
 #include "getinfo.h"
 
 CL_API_ENTRY cl_int CL_API_CALL
-soclGetContextInfo(cl_context       context, 
-                 cl_context_info    param_name, 
-                 size_t             param_value_size, 
-                 void *             param_value, 
-                 size_t *           param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
+soclGetContextInfo(cl_context       context,
+		   cl_context_info    param_name,
+		   size_t             param_value_size,
+		   void *             param_value,
+		   size_t *           param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
 {
-   if (context == NULL)
-      return CL_INVALID_CONTEXT;
-   
-   switch (param_name) {
-      INFO_CASE(CL_CONTEXT_REFERENCE_COUNT, context->_entity.refs);
-      INFO_CASE_EX(CL_CONTEXT_DEVICES, context->devices, context->num_devices * sizeof(cl_device_id));
-      INFO_CASE_EX(CL_CONTEXT_PROPERTIES, context->properties, context->num_properties * sizeof(cl_device_id));
-      default:
-         return CL_INVALID_VALUE;
-   }
+	if (context == NULL)
+		return CL_INVALID_CONTEXT;
 
-   return CL_SUCCESS;
+	switch (param_name)
+	{
+		INFO_CASE(CL_CONTEXT_REFERENCE_COUNT, context->_entity.refs);
+		INFO_CASE_EX(CL_CONTEXT_DEVICES, context->devices, context->num_devices * sizeof(cl_device_id));
+		INFO_CASE_EX(CL_CONTEXT_PROPERTIES, context->properties, context->num_properties * sizeof(cl_device_id));
+	default:
+		return CL_INVALID_VALUE;
+	}
+
+	return CL_SUCCESS;
 }

socl/src/cl_getdeviceids.c

@@ -26,67 +26,71 @@
  */
 CL_API_ENTRY cl_int CL_API_CALL
 soclGetDeviceIDs(cl_platform_id   platform,
-               cl_device_type   device_type,
-               cl_uint          num_entries,
-               cl_device_id *   devices,
-               cl_uint *        num_devices) CL_API_SUFFIX__VERSION_1_0
+		 cl_device_type   device_type,
+		 cl_uint          num_entries,
+		 cl_device_id *   devices,
+		 cl_uint *        num_devices) CL_API_SUFFIX__VERSION_1_0
 {
-    if (socl_init_starpu() < 0)
-    {
-       *num_devices = 0;
-       return CL_SUCCESS;
-    }
+	if (socl_init_starpu() < 0)
+	{
+		*num_devices = 0;
+		return CL_SUCCESS;
+	}
 
-   if (_starpu_init_failed) {
-      *num_devices = 0;
-      return CL_SUCCESS;
-   }
+	if (_starpu_init_failed)
+	{
+		*num_devices = 0;
+		return CL_SUCCESS;
+	}
 
-   if (platform != NULL && platform != &socl_platform)
-      return CL_INVALID_PLATFORM;
+	if (platform != NULL && platform != &socl_platform)
+		return CL_INVALID_PLATFORM;
 
-   if ((devices != NULL && num_entries == 0)
-      || (devices == NULL && num_devices == NULL))
-      return CL_INVALID_VALUE;
+	if ((devices != NULL && num_entries == 0)
+	    || (devices == NULL && num_devices == NULL))
+		return CL_INVALID_VALUE;
 
-   if (!(device_type & (CL_DEVICE_TYPE_CPU | CL_DEVICE_TYPE_GPU | CL_DEVICE_TYPE_ACCELERATOR | CL_DEVICE_TYPE_DEFAULT))
-      && (device_type != CL_DEVICE_TYPE_ALL))
-      return CL_INVALID_DEVICE_TYPE;
+	if (!(device_type & (CL_DEVICE_TYPE_CPU | CL_DEVICE_TYPE_GPU | CL_DEVICE_TYPE_ACCELERATOR | CL_DEVICE_TYPE_DEFAULT))
+	    && (device_type != CL_DEVICE_TYPE_ALL))
+		return CL_INVALID_DEVICE_TYPE;
 
-   int ndevs = starpu_worker_get_count_by_type(STARPU_OPENCL_WORKER);
+	int ndevs = starpu_worker_get_count_by_type(STARPU_OPENCL_WORKER);
 
-   int workers[ndevs];
-   starpu_worker_get_ids_by_type(STARPU_OPENCL_WORKER, workers, ndevs);
+	int workers[ndevs];
+	starpu_worker_get_ids_by_type(STARPU_OPENCL_WORKER, workers, ndevs);
 
-   if (socl_devices == NULL) {
-      socl_device_count = ndevs;
-      socl_devices = malloc(sizeof(struct _cl_device_id) * ndevs);
-      int i;
-      for (i=0; i < ndevs; i++) {
-         int devid = starpu_worker_get_devid(workers[i]);
-         socl_devices[i].dispatch = &socl_master_dispatch;
-         socl_devices[i].worker_id = workers[i];
-         socl_devices[i].device_id = devid;
-      }
-   }
-  
+	if (socl_devices == NULL)
+	{
+		socl_device_count = ndevs;
+		socl_devices = malloc(sizeof(struct _cl_device_id) * ndevs);
+		int i;
+		for (i=0; i < ndevs; i++)
+		{
+			int devid = starpu_worker_get_devid(workers[i]);
+			socl_devices[i].dispatch = &socl_master_dispatch;
+			socl_devices[i].worker_id = workers[i];
+			socl_devices[i].device_id = devid;
+		}
+	}
 
-   int i;
-   unsigned int num = 0;
-   for (i=0; i < ndevs; i++) {
-      int devid = socl_devices[i].device_id;
-      cl_device_id dev;
-      starpu_opencl_get_device(devid, &dev);
-      cl_device_type typ;
-      clGetDeviceInfo(dev, CL_DEVICE_TYPE, sizeof(typ), &typ, NULL);
-      if (typ & device_type) {
-         if (devices != NULL && num < num_entries) devices[num] = &socl_devices[i];
-         num++;
-      }
-   }
+	int i;
+	unsigned int num = 0;
+	for (i=0; i < ndevs; i++)
+	{
+		int devid = socl_devices[i].device_id;
+		cl_device_id dev;
+		starpu_opencl_get_device(devid, &dev);
+		cl_device_type typ;
+		clGetDeviceInfo(dev, CL_DEVICE_TYPE, sizeof(typ), &typ, NULL);
+		if (typ & device_type)
+		{
+			if (devices != NULL && num < num_entries) devices[num] = &socl_devices[i];
+			num++;
+		}
+	}
 
-   if (num_devices != NULL)
-      *num_devices = num;
+	if (num_devices != NULL)
+		*num_devices = num;
 
-   return CL_SUCCESS;
+	return CL_SUCCESS;
 }

socl/src/cl_getdeviceinfo.c

@@ -17,39 +17,39 @@
 #include "socl.h"
 #include "getinfo.h"
 
-
 CL_API_ENTRY cl_int CL_API_CALL
 soclGetDeviceInfo(cl_device_id    device,
-                cl_device_info  param_name, 
-                size_t          param_value_size, 
-                void *          param_value,
-                size_t *        param_value_size_ret) CL_API_SUFFIX__VERSION_1_0 
+		  cl_device_info  param_name,
+		  size_t          param_value_size,
+		  void *          param_value,
+		  size_t *        param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
 {
-
-   //FIXME: we do not check if the device is valid
-   /* if (device != &socl_virtual_device && device is not a valid StarPU worker identifier)
-      return CL_INVALID_DEVICE;*/
-
-  int devid = device->device_id;
-
-  cl_device_id dev;
-  starpu_opencl_get_device(devid, &dev);
-
-  int ret = CL_SUCCESS;
-
-  switch (param_name) {
-    case CL_DEVICE_PLATFORM: {
-      cl_platform_id p = &socl_platform;
-      INFO_CASE_EX2(p);
-    }
-    case CL_DEVICE_IMAGE_SUPPORT: {
-      cl_bool res = CL_FALSE;
-      INFO_CASE_EX2(res);
-    }
-    default:
-      ret = clGetDeviceInfo(dev, param_name, param_value_size, param_value, param_value_size_ret);
-  }
-
-  return ret;
-
+	//FIXME: we do not check if the device is valid
+	/* if (device != &socl_virtual_device && device is not a valid StarPU worker identifier)
+	   return CL_INVALID_DEVICE;*/
+
+	int devid = device->device_id;
+
+	cl_device_id dev;
+	starpu_opencl_get_device(devid, &dev);
+
+	int ret = CL_SUCCESS;
+
+	switch (param_name)
+	{
+	case CL_DEVICE_PLATFORM:
+	{
+		cl_platform_id p = &socl_platform;
+		INFO_CASE_EX2(p);
+	}
+	case CL_DEVICE_IMAGE_SUPPORT:
+	{
+		cl_bool res = CL_FALSE;
+		INFO_CASE_EX2(res);
+	}
+	default:
+		ret = clGetDeviceInfo(dev, param_name, param_value_size, param_value, param_value_size_ret);
+	}
+
+	return ret;
 }

socl/src/cl_geteventinfo.c

@@ -17,29 +17,29 @@
 #include "socl.h"
 #include "getinfo.h"
 
-
 CL_API_ENTRY cl_int CL_API_CALL
 soclGetEventInfo(cl_event       event,
-               cl_event_info    param_name,
-               size_t           param_value_size,
-               void *           param_value,
-               size_t *         param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
+		 cl_event_info    param_name,
+		 size_t           param_value_size,
+		 void *           param_value,
+		 size_t *         param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
 {
-   if (event == NULL)
-      return CL_INVALID_EVENT;
+	if (event == NULL)
+		return CL_INVALID_EVENT;
 
-   #define STAT_CASE(starpu,opencl) case starpu: \
-      status = opencl; \
-      break;
+#define STAT_CASE(starpu,opencl) case starpu:	\
+	status = opencl;			\
+	break;
 
-   switch (param_name) {
-      INFO_CASE(CL_EVENT_COMMAND_QUEUE, event->cq);
-      INFO_CASE(CL_EVENT_COMMAND_TYPE, event->command->typ);
-      INFO_CASE(CL_EVENT_COMMAND_EXECUTION_STATUS, event->status);
-      INFO_CASE(CL_EVENT_REFERENCE_COUNT, event->_entity.refs);
-      default:
-         return CL_INVALID_VALUE;
-   }
+	switch (param_name)
+	{
+		INFO_CASE(CL_EVENT_COMMAND_QUEUE, event->cq);
+		INFO_CASE(CL_EVENT_COMMAND_TYPE, event->command->typ);
+		INFO_CASE(CL_EVENT_COMMAND_EXECUTION_STATUS, event->status);
+		INFO_CASE(CL_EVENT_REFERENCE_COUNT, event->_entity.refs);
+	default:
+		return CL_INVALID_VALUE;
+	}
 
-   return CL_SUCCESS; 
+	return CL_SUCCESS;
 }

socl/src/cl_geteventprofilinginfo.c

@@ -19,19 +19,20 @@
 
 CL_API_ENTRY cl_int CL_API_CALL
 soclGetEventProfilingInfo(cl_event          event,
-                        cl_profiling_info   param_name,
-                        size_t              param_value_size,
-                        void *              param_value,
-                        size_t *            param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
+			  cl_profiling_info   param_name,
+			  size_t              param_value_size,
+			  void *              param_value,
+			  size_t *            param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
 {
-   switch (param_name) {
-      INFO_CASE_VALUE(CL_PROFILING_COMMAND_QUEUED, cl_ulong, event->prof_queued);
-      INFO_CASE_VALUE(CL_PROFILING_COMMAND_SUBMIT, cl_ulong, event->prof_submit);
-      INFO_CASE_VALUE(CL_PROFILING_COMMAND_START, cl_ulong, event->prof_start);
-      INFO_CASE_VALUE(CL_PROFILING_COMMAND_END, cl_ulong, event->prof_end);
-      default:
-         return CL_INVALID_VALUE;
-   }
+	switch (param_name)
+	{
+		INFO_CASE_VALUE(CL_PROFILING_COMMAND_QUEUED, cl_ulong, event->prof_queued);
+		INFO_CASE_VALUE(CL_PROFILING_COMMAND_SUBMIT, cl_ulong, event->prof_submit);
+		INFO_CASE_VALUE(CL_PROFILING_COMMAND_START, cl_ulong, event->prof_start);
+		INFO_CASE_VALUE(CL_PROFILING_COMMAND_END, cl_ulong, event->prof_end);
+	default:
+		return CL_INVALID_VALUE;
+	}
 
-   return CL_SUCCESS;
+	return CL_SUCCESS;
 }

socl/src/cl_getextensionfunctionaddress.c

@@ -23,26 +23,26 @@
 CL_API_ENTRY void * CL_API_CALL
 soclGetExtensionFunctionAddress(const char * func_name) CL_API_SUFFIX__VERSION_1_0
 {
-   if (func_name != NULL && strcmp(func_name, "clShutdown") == 0) {
-      return (void*)soclShutdown;
-   }
+	if (func_name != NULL && strcmp(func_name, "clShutdown") == 0)
+	{
+		return (void*)soclShutdown;
+	}
 
-   return NULL;
+	return NULL;
 }
 
 CL_API_ENTRY void * CL_API_CALL
 soclGetExtensionFunctionAddressForPlatform(cl_platform_id p, const char * func_name) CL_API_SUFFIX__VERSION_1_2
 {
+	if (p != &socl_platform)
+		return NULL;
 
-   if (p != &socl_platform) 
-      return NULL;
-
-   return soclGetExtensionFunctionAddress(func_name);
+	return soclGetExtensionFunctionAddress(func_name);
 }
 
-CL_API_ENTRY void * CL_API_CALL clGetExtensionFunctionAddress(
-             const char *   func_name) CL_API_SUFFIX__VERSION_1_0 {
-  if( func_name != NULL &&  strcmp("clIcdGetPlatformIDsKHR", func_name) == 0 )
-    return (void *)soclIcdGetPlatformIDsKHR;
-  return NULL;
+CL_API_ENTRY void * CL_API_CALL clGetExtensionFunctionAddress(const char * func_name) CL_API_SUFFIX__VERSION_1_0
+{
+	if( func_name != NULL &&  strcmp("clIcdGetPlatformIDsKHR", func_name) == 0 )
+		return (void *)soclIcdGetPlatformIDsKHR;
+	return NULL;
 }

socl/src/cl_getimageinfo.c

@@ -19,10 +19,10 @@
 
 CL_API_ENTRY cl_int CL_API_CALL
 soclGetImageInfo(cl_mem           UNUSED(image),
-               cl_image_info    UNUSED(param_name), 
-               size_t           UNUSED(param_value_size),
-               void *           UNUSED(param_value),
-               size_t *         UNUSED(param_value_size_ret)) CL_API_SUFFIX__VERSION_1_0
+		 cl_image_info    UNUSED(param_name),
+		 size_t           UNUSED(param_value_size),
+		 void *           UNUSED(param_value),
+		 size_t *         UNUSED(param_value_size_ret)) CL_API_SUFFIX__VERSION_1_0
 {
-   return CL_INVALID_OPERATION;
+	return CL_INVALID_OPERATION;
 }

socl/src/cl_getkernelinfo.c

@@ -19,23 +19,24 @@
 
 CL_API_ENTRY cl_int CL_API_CALL
 soclGetKernelInfo(cl_kernel       kernel,
-                cl_kernel_info  param_name,
-                size_t          param_value_size,
-                void *          param_value,
-                size_t *        param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
+		  cl_kernel_info  param_name,
+		  size_t          param_value_size,
+		  void *          param_value,
+		  size_t *        param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
 {
-   if (kernel == NULL)
-      return CL_INVALID_KERNEL;
+	if (kernel == NULL)
+		return CL_INVALID_KERNEL;
 
-   switch (param_name) {
-      INFO_CASE_EX(CL_KERNEL_FUNCTION_NAME, kernel->kernel_name, strlen(kernel->kernel_name)+1)
-      INFO_CASE(CL_KERNEL_NUM_ARGS, kernel->num_args)
-      INFO_CASE(CL_KERNEL_REFERENCE_COUNT, kernel->_entity.refs)
-      INFO_CASE(CL_KERNEL_PROGRAM, kernel->program)
-      INFO_CASE(CL_KERNEL_CONTEXT, kernel->program->context)
-      default:
-         return CL_INVALID_VALUE;
-   }
+	switch (param_name)
+	{
+		INFO_CASE_EX(CL_KERNEL_FUNCTION_NAME, kernel->kernel_name, strlen(kernel->kernel_name)+1);
+		INFO_CASE(CL_KERNEL_NUM_ARGS, kernel->num_args);
+		INFO_CASE(CL_KERNEL_REFERENCE_COUNT, kernel->_entity.refs);
+		INFO_CASE(CL_KERNEL_PROGRAM, kernel->program);
+		INFO_CASE(CL_KERNEL_CONTEXT, kernel->program->context);
+	default:
+		return CL_INVALID_VALUE;
+	}
 
-   return CL_SUCCESS;
+	return CL_SUCCESS;
 }

socl/src/cl_getkernelworkgroupinfo.c

@@ -18,18 +18,16 @@
 
 CL_API_ENTRY cl_int CL_API_CALL
 soclGetKernelWorkGroupInfo(cl_kernel                kernel,
-                         cl_device_id               device,
-                         cl_kernel_work_group_info  param_name,
-                         size_t                     param_value_size,
-                         void *                     param_value,
-                         size_t *                   param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
+			   cl_device_id               device,
+			   cl_kernel_work_group_info  param_name,
+			   size_t                     param_value_size,
+			   void *                     param_value,
+			   size_t *                   param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
 {
-   int range = starpu_worker_get_range_by_id(device->worker_id);
-   cl_device_id dev;
-   starpu_opencl_get_device(device->device_id, &dev);
+	int range = starpu_worker_get_range_by_id(device->worker_id);
+	cl_device_id dev;
+	starpu_opencl_get_device(device->device_id, &dev);
 
-   return clGetKernelWorkGroupInfo(kernel->cl_kernels[range], dev, 
-      param_name, param_value_size, param_value, param_value_size_ret);
+	return clGetKernelWorkGroupInfo(kernel->cl_kernels[range], dev,
+					param_name, param_value_size, param_value, param_value_size_ret);
 }
-
-

socl/src/cl_getmemobjectinfo.c

@@ -19,24 +19,25 @@
 
 CL_API_ENTRY cl_int CL_API_CALL
 soclGetMemObjectInfo(cl_mem           mem,
-                   cl_mem_info      param_name, 
-                   size_t           param_value_size,
-                   void *           param_value,
-                   size_t *         param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
+		     cl_mem_info      param_name,
+		     size_t           param_value_size,
+		     void *           param_value,
+		     size_t *         param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
 {
-   static cl_mem_object_type mot = CL_MEM_OBJECT_BUFFER;
+	static cl_mem_object_type mot = CL_MEM_OBJECT_BUFFER;
 
-   switch (param_name) {
-      INFO_CASE(CL_MEM_TYPE, mot)
-      INFO_CASE(CL_MEM_FLAGS, mem->flags)
-      INFO_CASE(CL_MEM_SIZE, mem->size)
-      INFO_CASE(CL_MEM_HOST_PTR, mem->host_ptr)
-      INFO_CASE(CL_MEM_MAP_COUNT, mem->map_count)
-      INFO_CASE(CL_MEM_REFERENCE_COUNT, mem->_entity.refs)
-      INFO_CASE(CL_MEM_CONTEXT, mem->context)
-      default:
-         return CL_INVALID_VALUE;
-   }
+	switch (param_name)
+	{
+		INFO_CASE(CL_MEM_TYPE, mot);
+		INFO_CASE(CL_MEM_FLAGS, mem->flags);
+		INFO_CASE(CL_MEM_SIZE, mem->size);
+		INFO_CASE(CL_MEM_HOST_PTR, mem->host_ptr);
+		INFO_CASE(CL_MEM_MAP_COUNT, mem->map_count);
+		INFO_CASE(CL_MEM_REFERENCE_COUNT, mem->_entity.refs);
+		INFO_CASE(CL_MEM_CONTEXT, mem->context);
+	default:
+		return CL_INVALID_VALUE;
+	}
 
-   return CL_SUCCESS;
+	return CL_SUCCESS;
 }

socl/src/cl_getplatformids.c

@@ -23,27 +23,27 @@ extern int _starpu_init_failed;
  */
 CL_API_ENTRY cl_int CL_API_CALL
 soclGetPlatformIDs(cl_uint          num_entries,
-                 cl_platform_id * platforms,
-                 cl_uint *        num_platforms) CL_API_SUFFIX__VERSION_1_0
+		   cl_platform_id * platforms,
+		   cl_uint *        num_platforms) CL_API_SUFFIX__VERSION_1_0
 {
-     if (_starpu_init_failed)
-     {
-	  if (num_platforms != NULL)
-	       *num_platforms = 0;
-	  return CL_SUCCESS;
-     }
+	if (_starpu_init_failed)
+	{
+		if (num_platforms != NULL)
+			*num_platforms = 0;
+		return CL_SUCCESS;
+	}
 
-     if ((num_entries == 0 && platforms != NULL)
-	 || (num_platforms == NULL && platforms == NULL))
-	  return CL_INVALID_VALUE;
+	if ((num_entries == 0 && platforms != NULL)
+	    || (num_platforms == NULL && platforms == NULL))
+		return CL_INVALID_VALUE;
+	else
+	{
+		if (platforms != NULL)
+			platforms[0] = &socl_platform;
 
-     else {
-	  if (platforms != NULL)
-	       platforms[0] = &socl_platform;
+		if (num_platforms != NULL)
+			*num_platforms = 1;
+	}
 
-	  if (num_platforms != NULL)
-	       *num_platforms = 1;
-     }
-
-   return CL_SUCCESS;
+	return CL_SUCCESS;
 }

socl/src/cl_getplatforminfo.c

@@ -24,27 +24,27 @@
  *
  * \param[in] platform StarPU platform ID or NULL
  */
-CL_API_ENTRY cl_int CL_API_CALL 
-soclGetPlatformInfo(cl_platform_id   platform, 
-                  cl_platform_info param_name,
-                  size_t           param_value_size, 
-                  void *           param_value,
-                  size_t *         param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
+CL_API_ENTRY cl_int CL_API_CALL
+soclGetPlatformInfo(cl_platform_id   platform,
+		    cl_platform_info param_name,
+		    size_t           param_value_size,
+		    void *           param_value,
+		    size_t *         param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
 {
-   if (platform != NULL && platform != &socl_platform)
-	return CL_INVALID_PLATFORM;
+	if (platform != NULL && platform != &socl_platform)
+		return CL_INVALID_PLATFORM;
 
-   switch (param_name)
-   {
-	INFO_CASE_STRING(CL_PLATFORM_PROFILE, SOCL_PROFILE);
-	INFO_CASE_STRING(CL_PLATFORM_VERSION, SOCL_VERSION);
-	INFO_CASE_STRING(CL_PLATFORM_NAME,    SOCL_PLATFORM_NAME);
-	INFO_CASE_STRING(CL_PLATFORM_VENDOR,  SOCL_VENDOR);
-	INFO_CASE_STRING(CL_PLATFORM_EXTENSIONS, SOCL_PLATFORM_EXTENSIONS);
-	INFO_CASE_STRING(CL_PLATFORM_ICD_SUFFIX_KHR, SOCL_PLATFORM_ICD_SUFFIX_KHR);
-   default:
-         return CL_INVALID_VALUE;
-   }
+	switch (param_name)
+	{
+		INFO_CASE_STRING(CL_PLATFORM_PROFILE, SOCL_PROFILE);
+		INFO_CASE_STRING(CL_PLATFORM_VERSION, SOCL_VERSION);
+		INFO_CASE_STRING(CL_PLATFORM_NAME,    SOCL_PLATFORM_NAME);
+		INFO_CASE_STRING(CL_PLATFORM_VENDOR,  SOCL_VENDOR);
+		INFO_CASE_STRING(CL_PLATFORM_EXTENSIONS, SOCL_PLATFORM_EXTENSIONS);
+		INFO_CASE_STRING(CL_PLATFORM_ICD_SUFFIX_KHR, SOCL_PLATFORM_ICD_SUFFIX_KHR);
+	default:
+		return CL_INVALID_VALUE;
+	}
 
-   return CL_SUCCESS;
+	return CL_SUCCESS;
 }

socl/src/cl_getprogrambuildinfo.c

@@ -19,25 +19,25 @@
 
 CL_API_ENTRY cl_int CL_API_CALL
 soclGetProgramBuildInfo(cl_program          program,
-                      cl_device_id          UNUSED(device),
-                      cl_program_build_info param_name,
-                      size_t                param_value_size,
-                      void *                param_value,
-                      size_t *              param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
+			cl_device_id          UNUSED(device),
+			cl_program_build_info param_name,
+			size_t                param_value_size,
+			void *                param_value,
+			size_t *              param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
 {
-   if (program == NULL)
-      return CL_INVALID_PROGRAM;
+	if (program == NULL)
+		return CL_INVALID_PROGRAM;
 
+	switch (param_name)
+	{
+		//TODO
+		//INFO_CASE(CL_PROGRAM_BUILD_STATUS, program->build_status);
+		INFO_CASE_EX(CL_PROGRAM_BUILD_OPTIONS, program->options, program->options_size);
+		//TODO
+		//INFO_CASE(CL_PROGRAM_BUILD_LOG, program->build_log);
+	default:
+		return CL_INVALID_VALUE;
+	}
 
-   switch (param_name) {
-      //TODO
-      //INFO_CASE(CL_PROGRAM_BUILD_STATUS, program->build_status);
-      INFO_CASE_EX(CL_PROGRAM_BUILD_OPTIONS, program->options, program->options_size);
-      //TODO
-      //INFO_CASE(CL_PROGRAM_BUILD_LOG, program->build_log);
-      default:
-         return CL_INVALID_VALUE;
-   }
-
-   return CL_SUCCESS;
+	return CL_SUCCESS;
 }

socl/src/cl_getprograminfo.c

@@ -19,26 +19,27 @@
 
 CL_API_ENTRY cl_int CL_API_CALL
 soclGetProgramInfo(cl_program       program,
-                 cl_program_info    param_name,
-                 size_t             param_value_size,
-                 void *             param_value,
-                 size_t *           param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
+		   cl_program_info    param_name,
+		   size_t             param_value_size,
+		   void *             param_value,
+		   size_t *           param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
 {
-   if (program == NULL)
-      return CL_INVALID_PROGRAM;
+	if (program == NULL)
+		return CL_INVALID_PROGRAM;
 
-   switch (param_name) {
-      INFO_CASE(CL_PROGRAM_REFERENCE_COUNT, program->_entity.refs);
-      INFO_CASE(CL_PROGRAM_CONTEXT, program->context);
-      INFO_CASE(CL_PROGRAM_NUM_DEVICES, program->context->num_devices);
-      INFO_CASE_EX(CL_PROGRAM_DEVICES, program->context->devices, sizeof(cl_device_id)*program->context->num_devices);
-      //TODO
-      /*INFO_CASE(CL_PROGRAM_SOURCE, program->source);
-      INFO_CASE(CL_PROGRAM_BINARY_SIZE, program->binary_sizes);
-      INFO_CASE(CL_PROGRAM_BINARIES, program->binaries);*/
-      default:
-         return CL_INVALID_VALUE;
-   }
+	switch (param_name)
+	{
+		INFO_CASE(CL_PROGRAM_REFERENCE_COUNT, program->_entity.refs);
+		INFO_CASE(CL_PROGRAM_CONTEXT, program->context);
+		INFO_CASE(CL_PROGRAM_NUM_DEVICES, program->context->num_devices);
+		INFO_CASE_EX(CL_PROGRAM_DEVICES, program->context->devices, sizeof(cl_device_id)*program->context->num_devices);
+		//TODO
+		/*INFO_CASE(CL_PROGRAM_SOURCE, program->source);
+		  INFO_CASE(CL_PROGRAM_BINARY_SIZE, program->binary_sizes);
+		  INFO_CASE(CL_PROGRAM_BINARIES, program->binaries);*/
+	default:
+		return CL_INVALID_VALUE;
+	}
 
-   return CL_SUCCESS;
+	return CL_SUCCESS;
 }

socl/src/cl_getsamplerinfo.c

@@ -19,10 +19,10 @@
 
 CL_API_ENTRY cl_int CL_API_CALL
 soclGetSamplerInfo(cl_sampler       UNUSED(sampler),
-                 cl_sampler_info    UNUSED(param_name),
-                 size_t             UNUSED(param_value_size),
-                 void *             UNUSED(param_value),
-                 size_t *           UNUSED(param_value_size_ret)) CL_API_SUFFIX__VERSION_1_0
+		   cl_sampler_info    UNUSED(param_name),
+		   size_t             UNUSED(param_value_size),
+		   void *             UNUSED(param_value),
+		   size_t *           UNUSED(param_value_size_ret)) CL_API_SUFFIX__VERSION_1_0
 {
-   return CL_INVALID_OPERATION;
+	return CL_INVALID_OPERATION;
 }

socl/src/cl_getsupportedimageformats.c

@@ -18,11 +18,11 @@
 
 CL_API_ENTRY cl_int CL_API_CALL
 soclGetSupportedImageFormats(cl_context           UNUSED(context),
-                           cl_mem_flags         UNUSED(flags),
-                           cl_mem_object_type   UNUSED(image_type),
-                           cl_uint              UNUSED(num_entries),
-                           cl_image_format *    UNUSED(image_formats),
-                           cl_uint *            UNUSED(num_image_formats)) CL_API_SUFFIX__VERSION_1_0
+			     cl_mem_flags         UNUSED(flags),
+			     cl_mem_object_type   UNUSED(image_type),
+			     cl_uint              UNUSED(num_entries),
+			     cl_image_format *    UNUSED(image_formats),
+			     cl_uint *            UNUSED(num_image_formats)) CL_API_SUFFIX__VERSION_1_0
 {
-   return CL_INVALID_OPERATION;
+	return CL_INVALID_OPERATION;
 }

socl/src/cl_icdgetplatformidskhr.c

@@ -20,21 +20,21 @@
 
 extern int _starpu_init_failed;
 
-CL_API_ENTRY cl_int CL_API_CALL soclIcdGetPlatformIDsKHR(
-             cl_uint num_entries,
-             cl_platform_id *platforms,
-             cl_uint *num_platforms) CL_EXT_SUFFIX__VERSION_1_0{
-     if ((num_entries == 0 && platforms != NULL)
-	 || (num_platforms == NULL && platforms == NULL))
-	  return CL_INVALID_VALUE;
+CL_API_ENTRY cl_int CL_API_CALL soclIcdGetPlatformIDsKHR(cl_uint num_entries,
+							 cl_platform_id *platforms,
+							 cl_uint *num_platforms) CL_EXT_SUFFIX__VERSION_1_0
+{
+	if ((num_entries == 0 && platforms != NULL)
+	    || (num_platforms == NULL && platforms == NULL))
+		return CL_INVALID_VALUE;
+	else
+	{
+		if (platforms != NULL)
+			platforms[0] = &socl_platform;
 
-     else {
-	  if (platforms != NULL)
-	       platforms[0] = &socl_platform;
+		if (num_platforms != NULL)
+			*num_platforms = 1;
+	}
 
-	  if (num_platforms != NULL)
-	       *num_platforms = 1;
-     }
-
-   return CL_SUCCESS;
+	return CL_SUCCESS;
 }

socl/src/cl_releasecommandqueue.c

@@ -19,8 +19,7 @@
 CL_API_ENTRY cl_int CL_API_CALL
 soclReleaseCommandQueue(cl_command_queue cq) CL_API_SUFFIX__VERSION_1_0
 {
+	gc_entity_release(cq);
 
-  gc_entity_release(cq);
-
-  return CL_SUCCESS;
+	return CL_SUCCESS;
 }

socl/src/cl_releasecontext.c

@@ -19,11 +19,10 @@
 CL_API_ENTRY cl_int CL_API_CALL
 soclReleaseContext(cl_context context) CL_API_SUFFIX__VERSION_1_0
 {
+	if (context == NULL)
+		return CL_INVALID_CONTEXT;
 
-  if (context == NULL)
-    return CL_INVALID_CONTEXT;
+	gc_entity_release(context);
 
-  gc_entity_release(context);
-
-  return CL_SUCCESS;
+	return CL_SUCCESS;
 }

socl/src/cl_releaseevent.c

@@ -19,10 +19,10 @@
 CL_API_ENTRY cl_int CL_API_CALL
 soclReleaseEvent(cl_event event) CL_API_SUFFIX__VERSION_1_0
 {
-  if (event == NULL)
-    return CL_INVALID_EVENT;
+	if (event == NULL)
+		return CL_INVALID_EVENT;
 
-  gc_entity_release(event);
+	gc_entity_release(event);
 
-  return CL_SUCCESS;
+	return CL_SUCCESS;
 }

socl/src/cl_releasekernel.c

@@ -19,10 +19,10 @@
 CL_API_ENTRY cl_int CL_API_CALL
 soclReleaseKernel(cl_kernel kernel) CL_API_SUFFIX__VERSION_1_0
 {
-  if (kernel == NULL)
-    return CL_INVALID_KERNEL;
+	if (kernel == NULL)
+		return CL_INVALID_KERNEL;
 
-  gc_entity_release(kernel);
+	gc_entity_release(kernel);
 
-  return CL_SUCCESS;
+	return CL_SUCCESS;
 }

socl/src/cl_releasememobject.c

@@ -19,7 +19,7 @@
 CL_API_ENTRY cl_int CL_API_CALL
 soclReleaseMemObject(cl_mem mem) CL_API_SUFFIX__VERSION_1_0
 {
-  gc_entity_release(mem);
+	gc_entity_release(mem);
 
-  return CL_SUCCESS;
+	return CL_SUCCESS;
 }

socl/src/cl_releaseprogram.c

@@ -19,10 +19,10 @@
 CL_API_ENTRY cl_int CL_API_CALL
 soclReleaseProgram(cl_program program) CL_API_SUFFIX__VERSION_1_0
 {
-  if (program == NULL)
-    return CL_INVALID_PROGRAM;
+	if (program == NULL)
+		return CL_INVALID_PROGRAM;
 
-  gc_entity_release(program);
+	gc_entity_release(program);
 
-  return CL_SUCCESS;
+	return CL_SUCCESS;
 }

socl/src/cl_releasesampler.c

@@ -19,5 +19,5 @@
 CL_API_ENTRY cl_int CL_API_CALL
 soclReleaseSampler(cl_sampler UNUSED(sampler)) CL_API_SUFFIX__VERSION_1_0
 {
-   return CL_INVALID_OPERATION;
+	return CL_INVALID_OPERATION;
 }

socl/src/cl_retaincommandqueue.c

@@ -19,10 +19,10 @@
 CL_API_ENTRY cl_int CL_API_CALL
 soclRetainCommandQueue(cl_command_queue cq) CL_API_SUFFIX__VERSION_1_0
 {
-   if (cq == NULL)
-      return CL_INVALID_COMMAND_QUEUE;
+	if (cq == NULL)
+	   return CL_INVALID_COMMAND_QUEUE;
 
-   gc_entity_retain(cq);
+	gc_entity_retain(cq);
 
-   return CL_SUCCESS;
+	return CL_SUCCESS;
 }

socl/src/cl_retaincontext.c

@@ -19,10 +19,10 @@
 CL_API_ENTRY cl_int CL_API_CALL
 soclRetainContext(cl_context context) CL_API_SUFFIX__VERSION_1_0
 {
-   if (context == NULL)
-      return CL_INVALID_CONTEXT;
+	if (context == NULL)
+	   return CL_INVALID_CONTEXT;
 
-   gc_entity_retain(context);
+	gc_entity_retain(context);
 
-   return CL_SUCCESS;
+	return CL_SUCCESS;
 }

socl/src/cl_retainevent.c

@@ -19,10 +19,10 @@
 CL_API_ENTRY cl_int CL_API_CALL
 soclRetainEvent(cl_event event) CL_API_SUFFIX__VERSION_1_0
 {
-   if (event == NULL)
-      return CL_INVALID_EVENT;
+	if (event == NULL)
+		return CL_INVALID_EVENT;
 
-   gc_entity_retain(event);
+	gc_entity_retain(event);
 
-   return CL_SUCCESS;
+	return CL_SUCCESS;
 }

socl/src/cl_retainkernel.c

@@ -19,10 +19,10 @@
 CL_API_ENTRY cl_int CL_API_CALL
 soclRetainKernel(cl_kernel    kernel) CL_API_SUFFIX__VERSION_1_0
 {
-   if (kernel == NULL)
-      return CL_INVALID_KERNEL;
+	if (kernel == NULL)
+		return CL_INVALID_KERNEL;
 
-   gc_entity_retain(kernel);
+	gc_entity_retain(kernel);
 
-   return CL_SUCCESS;
+	return CL_SUCCESS;
 }

socl/src/cl_retainmemobject.c

@@ -19,10 +19,10 @@
 CL_API_ENTRY cl_int CL_API_CALL
 soclRetainMemObject(cl_mem mem) CL_API_SUFFIX__VERSION_1_0
 {
-   if (mem == NULL)
-      return CL_INVALID_MEM_OBJECT;
+	if (mem == NULL)
+		return CL_INVALID_MEM_OBJECT;
 
-   gc_entity_retain(mem);
-   
-   return CL_SUCCESS;
+	gc_entity_retain(mem);
+
+	return CL_SUCCESS;
 }

socl/src/cl_retainprogram.c

@@ -19,10 +19,10 @@
 CL_API_ENTRY cl_int CL_API_CALL
 soclRetainProgram(cl_program program) CL_API_SUFFIX__VERSION_1_0
 {
-   if (program == NULL)
-      return CL_INVALID_PROGRAM;
+	if (program == NULL)
+		return CL_INVALID_PROGRAM;
 
-   gc_entity_retain(program);
+	gc_entity_retain(program);
 
-   return CL_SUCCESS;
+	return CL_SUCCESS;
 }

socl/src/cl_retainsampler.c

@@ -19,5 +19,5 @@
 CL_API_ENTRY cl_int CL_API_CALL
 soclRetainSampler(cl_sampler UNUSED(sampler)) CL_API_SUFFIX__VERSION_1_0
 {
-   return CL_INVALID_OPERATION;
+	return CL_INVALID_OPERATION;
 }

socl/src/cl_setcommandqueueproperty.c

@@ -18,35 +18,40 @@
 
 CL_API_ENTRY cl_int CL_API_CALL
 soclSetCommandQueueProperty(cl_command_queue            command_queue,
-                          cl_command_queue_properties   properties, 
-                          cl_bool                       enable,
-                          cl_command_queue_properties * old_properties) CL_API_SUFFIX__VERSION_1_0
+			    cl_command_queue_properties   properties,
+			    cl_bool                       enable,
+			    cl_command_queue_properties * old_properties) CL_API_SUFFIX__VERSION_1_0
 {
-   if (command_queue == NULL)
-      return CL_INVALID_COMMAND_QUEUE;
+	if (command_queue == NULL)
+		return CL_INVALID_COMMAND_QUEUE;
 
-   if (old_properties != NULL)
-      *old_properties = command_queue->properties;
+	if (old_properties != NULL)
+		*old_properties = command_queue->properties;
 
-   if (enable) {
-      //Enable StarPU profiling if necessary
-      if (properties & (~command_queue->properties) & CL_QUEUE_PROFILING_ENABLE) {
-         if (profiling_queue_count == 0)
-            starpu_profiling_status_set(STARPU_PROFILING_ENABLE);
-         profiling_queue_count += 1;
-      }  
-      //Set new properties
-      command_queue->properties |= properties;
-   } else {
-      //Disable StarPU profiling if necessary
-      if ((~properties) & command_queue->properties & CL_QUEUE_PROFILING_ENABLE) {
-         profiling_queue_count -= 1;
-         if (profiling_queue_count == 0)
-            starpu_profiling_status_set(STARPU_PROFILING_DISABLE);
-      }  
-      //Set new properties
-      command_queue->properties &= ~properties;
-   }
+	if (enable)
+	{
+		//Enable StarPU profiling if necessary
+		if (properties & (~command_queue->properties) & CL_QUEUE_PROFILING_ENABLE)
+		{
+			if (profiling_queue_count == 0)
+				starpu_profiling_status_set(STARPU_PROFILING_ENABLE);
+			profiling_queue_count += 1;
+		}
+		//Set new properties
+		command_queue->properties |= properties;
+	}
+	else
+	{
+		//Disable StarPU profiling if necessary
+		if ((~properties) & command_queue->properties & CL_QUEUE_PROFILING_ENABLE)
+		{
+			profiling_queue_count -= 1;
+			if (profiling_queue_count == 0)
+				starpu_profiling_status_set(STARPU_PROFILING_DISABLE);
+		}
+		//Set new properties
+		command_queue->properties &= ~properties;
+	}
 
-   return CL_SUCCESS;
+	return CL_SUCCESS;
 }

socl/src/cl_setkernelarg.c

@@ -18,76 +18,84 @@
 
 CL_API_ENTRY cl_int CL_API_CALL
 soclSetKernelArg(cl_kernel  kernel,
-               cl_uint      arg_index,
-               size_t       arg_size,
-               const void * arg_value) CL_API_SUFFIX__VERSION_1_0
+		 cl_uint      arg_index,
+		 size_t       arg_size,
+		 const void * arg_value) CL_API_SUFFIX__VERSION_1_0
 {
-   if (kernel == NULL)
-      return CL_INVALID_KERNEL;
+	if (kernel == NULL)
+		return CL_INVALID_KERNEL;
 
-   if (arg_index == (cl_uint)-1) {
-      kernel->split_func = arg_value;
-      return CL_SUCCESS;
-   }
-   else if (arg_index == (cl_uint)-2) {
-      kernel->split_space = *(cl_uint*)arg_value;
-      if (kernel->split_perfs != NULL) {
-         free(kernel->split_perfs);
-      }
-      kernel->split_perfs = calloc(kernel->split_space, sizeof(cl_ulong));
-      return CL_SUCCESS;
-   }
-   else if (arg_index == (cl_uint)-3) {
-      kernel->split_data = (void *)arg_value;
-      return CL_SUCCESS;
-   }
+	if (arg_index == (cl_uint)-1)
+	{
+		kernel->split_func = arg_value;
+		return CL_SUCCESS;
+	}
+	else if (arg_index == (cl_uint)-2)
+	{
+		kernel->split_space = *(cl_uint*)arg_value;
+		if (kernel->split_perfs != NULL)
+		{
+			free(kernel->split_perfs);
+		}
+		kernel->split_perfs = calloc(kernel->split_space, sizeof(cl_ulong));
+		return CL_SUCCESS;
+	}
+	else if (arg_index == (cl_uint)-3)
+	{
+		kernel->split_data = (void *)arg_value;
+		return CL_SUCCESS;
+	}
 
-   if (arg_index >= kernel->num_args)
-      return CL_INVALID_ARG_INDEX;
+	if (arg_index >= kernel->num_args)
+		return CL_INVALID_ARG_INDEX;
 
-   //FIXME: we don't return CL_INVALID_ARG_VALUE if "arg_value is NULL for an argument that is not declared with __local qualifier or vice-versa"
-   //FIXME: we don't return CL_INVALID_MEM_OBJECT
-   //FIXME: we don't return CL_INVALID_ARG_SIZE
+	//FIXME: we don't return CL_INVALID_ARG_VALUE if "arg_value is NULL for an argument that is not declared with __local qualifier or vice-versa"
+	//FIXME: we don't return CL_INVALID_MEM_OBJECT
+	//FIXME: we don't return CL_INVALID_ARG_SIZE
 
-   /* Free previous argument (set to NULL) */
-   switch (kernel->arg_type[arg_index]) {
-      case Null:
-         break;
-      case Buffer:
-         kernel->arg_type[arg_index] = Null;
-         free(kernel->arg_value[arg_index]);
-         kernel->arg_value[arg_index] = NULL;
-         break;
-      case Immediate:
-         free(kernel->arg_value[arg_index]);
-         kernel->arg_type[arg_index] = Null;
-         kernel->arg_value[arg_index] = NULL;
-         break;
-   }
+	/* Free previous argument (set to NULL) */
+	switch (kernel->arg_type[arg_index])
+	{
+	case Null:
+		break;
+	case Buffer:
+		kernel->arg_type[arg_index] = Null;
+		free(kernel->arg_value[arg_index]);
+		kernel->arg_value[arg_index] = NULL;
+		break;
+	case Immediate:
+		free(kernel->arg_value[arg_index]);
+		kernel->arg_type[arg_index] = Null;
+		kernel->arg_value[arg_index] = NULL;
+		break;
+	}
 
-   kernel->arg_type[arg_index] = Null;
-   kernel->arg_size[arg_index] = arg_size;
+	kernel->arg_type[arg_index] = Null;
+	kernel->arg_size[arg_index] = arg_size;
 
-   DEBUG_MSG("[Kernel %d] Set argument %d: argsize %ld argvalue %p\n", kernel->id, arg_index, (long)arg_size, arg_value);
+	DEBUG_MSG("[Kernel %d] Set argument %d: argsize %ld argvalue %p\n", kernel->id, arg_index, (long)arg_size, arg_value);
 
-   /* Argument is not Null */
-   if (arg_value != NULL) {
-      cl_mem buf = NULL;
-      /* Check if argument is a memory object */
-      if ((arg_size == sizeof(cl_mem)) && ((buf = mem_object_fetch(arg_value)) != NULL)) {
-         DEBUG_MSG("Found buffer %d \n", buf->id);
-         kernel->arg_type[arg_index] = Buffer;
-         kernel->arg_value[arg_index] = malloc(sizeof(void*));
-         *(cl_mem*)kernel->arg_value[arg_index] = buf; //We do not use gc_entity_store here because kernels do not hold reference on buffers (see OpenCL spec)
-      }
-      else {
-         /* Argument must be an immediate buffer  */
-         DEBUG_MSG("Immediate data\n");
-         kernel->arg_type[arg_index] = Immediate;
-         kernel->arg_value[arg_index] = malloc(arg_size);
-         memcpy(kernel->arg_value[arg_index], arg_value, arg_size);
-      }
-   }
+	/* Argument is not Null */
+	if (arg_value != NULL)
+	{
+		cl_mem buf = NULL;
+		/* Check if argument is a memory object */
+		if ((arg_size == sizeof(cl_mem)) && ((buf = mem_object_fetch(arg_value)) != NULL))
+		{
+			DEBUG_MSG("Found buffer %d \n", buf->id);
+			kernel->arg_type[arg_index] = Buffer;
+			kernel->arg_value[arg_index] = malloc(sizeof(void*));
+			*(cl_mem*)kernel->arg_value[arg_index] = buf; //We do not use gc_entity_store here because kernels do not hold reference on buffers (see OpenCL spec)
+		}
+		else
+		{
+			/* Argument must be an immediate buffer  */
+			DEBUG_MSG("Immediate data\n");
+			kernel->arg_type[arg_index] = Immediate;
+			kernel->arg_value[arg_index] = malloc(arg_size);
+			memcpy(kernel->arg_value[arg_index], arg_value, arg_size);
+		}
+	}
 
-   return CL_SUCCESS;
+	return CL_SUCCESS;
 }

socl/src/cl_unloadcompiler.c

@@ -19,5 +19,5 @@
 CL_API_ENTRY cl_int CL_API_CALL
 soclUnloadCompiler(void) CL_API_SUFFIX__VERSION_1_0
 {
-   return CL_SUCCESS;
+	return CL_SUCCESS;
 }

socl/src/cl_waitforevents.c

@@ -20,20 +20,21 @@ CL_API_ENTRY cl_int CL_API_CALL
 soclWaitForEvents(cl_uint           num_events,
                 const cl_event *    event_list) CL_API_SUFFIX__VERSION_1_0
 {
-   unsigned int i;
+	unsigned int i;
 
-   #ifdef DEBUG
-   DEBUG_MSG("Waiting for events: ");
-   for (i=0; i<num_events; i++) {
-      char * sep = i == (num_events-1) ? "" : ", ";
-      DEBUG_MSG_NOHEAD("%d%s", event_list[i]->id, sep);
-   }
-   DEBUG_MSG_NOHEAD("\n");
-   #endif
+#ifdef DEBUG
+	DEBUG_MSG("Waiting for events: ");
+	for (i=0; i<num_events; i++)
+	{
+		char * sep = i == (num_events-1) ? "" : ", ";
+		DEBUG_MSG_NOHEAD("%d%s", event_list[i]->id, sep);
+	}
+	DEBUG_MSG_NOHEAD("\n");
+#endif
 
-   for (i=0; i<num_events; i++)
-      starpu_tag_wait(event_list[i]->id);
+	for (i=0; i<num_events; i++)
+		starpu_tag_wait(event_list[i]->id);
 
-   DEBUG_MSG("Stop waiting :)\n");
-   return CL_SUCCESS;
+	DEBUG_MSG("Stop waiting :)\n");
+	return CL_SUCCESS;
 }

socl/src/command.c

@@ -20,52 +20,57 @@
 /* Forward extern declaration */
 extern void soclEnqueueNDRangeKernel_task(void *descr[], void *args);
 
-cl_event command_event_get_ex(cl_command cmd) {
-   cl_event ev = cmd->event;
-   gc_entity_retain(ev);
-   return ev;
+cl_event command_event_get_ex(cl_command cmd)
+{
+	cl_event ev = cmd->event;
+	gc_entity_retain(ev);
+	return ev;
 }
 
-static void command_release_callback(void *a) {
-  cl_command cmd = (cl_command)a;
-
-  // Call command specific release callback
-  if (cmd->release_callback != NULL)
-     cmd->release_callback(cmd);
-
-  // Generic command destructor
-  cl_uint i;
-  for (i=0; i<cmd->num_events; i++) {
-     gc_entity_unstore(&cmd->events[i]);
-  }
-  cmd->num_events = 0;
-  free(cmd->events);
-
-  /* Remove from command queue */
-  cl_command_queue cq = cmd->event->cq;
-  if (cq != NULL) {
-    /* Lock command queue */
-    STARPU_PTHREAD_MUTEX_LOCK(&cq->mutex);
-
-    /* Remove barrier if applicable */
-    if (cq->barrier == cmd)
-      cq->barrier = NULL;
-
-    /* Remove from the list of out-of-order commands */
-    cq->commands = command_list_remove(cq->commands, cmd);
-
-    /* Unlock command queue */
-    STARPU_PTHREAD_MUTEX_UNLOCK(&cq->mutex);
-  }
-
-  // Events may survive to commands that created them
-  cmd->event->command = NULL;
-  gc_entity_unstore(&cmd->event); 
+static void command_release_callback(void *a)
+{
+	cl_command cmd = (cl_command)a;
+
+	// Call command specific release callback
+	if (cmd->release_callback != NULL)
+		cmd->release_callback(cmd);
+
+	// Generic command destructor
+	cl_uint i;
+	for (i=0; i<cmd->num_events; i++)
+	{
+		gc_entity_unstore(&cmd->events[i]);
+	}
+	cmd->num_events = 0;
+	free(cmd->events);
+
+	/* Remove from command queue */
+	cl_command_queue cq = cmd->event->cq;
+	if (cq != NULL)
+	{
+		/* Lock command queue */
+		STARPU_PTHREAD_MUTEX_LOCK(&cq->mutex);
+
+		/* Remove barrier if applicable */
+		if (cq->barrier == cmd)
+			cq->barrier = NULL;
+
+		/* Remove from the list of out-of-order commands */
+		cq->commands = command_list_remove(cq->commands, cmd);
+
+		/* Unlock command queue */
+		STARPU_PTHREAD_MUTEX_UNLOCK(&cq->mutex);
+	}
+
+	// Events may survive to commands that created them
+	cmd->event->command = NULL;
+	gc_entity_unstore(&cmd->event);
 }
 
-void command_init_ex(cl_command cmd, cl_command_type typ, void (*cb)(void*)) {
+void command_init_ex(cl_command cmd, cl_command_type typ, void (*cb)(void*))
+{
 	gc_entity_init(&cmd->_entity, command_release_callback, "command");
-   cmd->release_callback = cb;
+	cmd->release_callback = cb;
 	cmd->typ = typ;
 	cmd->num_events = 0;
 	cmd->events = NULL;
@@ -75,42 +80,45 @@ void command_init_ex(cl_command cmd, cl_command_type typ, void (*cb)(void*)) {
 	cmd->submitted = 0;
 }
 
-void command_submit_ex(cl_command cmd) {
-#define SUBMIT(typ,name) case typ:\
-	name##_submit((name)cmd);\
+void command_submit_ex(cl_command cmd)
+{
+#define SUBMIT(typ,name) case typ:		\
+	name##_submit((name)cmd);		\
 	break;
 
 	assert(cmd->submitted == 0);
 
-	switch(cmd->typ) {
-		SUBMIT(CL_COMMAND_NDRANGE_KERNEL, command_ndrange_kernel)
-		SUBMIT(CL_COMMAND_TASK, command_ndrange_kernel)
-		SUBMIT(CL_COMMAND_READ_BUFFER, command_read_buffer)
-		SUBMIT(CL_COMMAND_WRITE_BUFFER, command_write_buffer)
-		SUBMIT(CL_COMMAND_COPY_BUFFER, command_copy_buffer)
-		SUBMIT(CL_COMMAND_MAP_BUFFER, command_map_buffer)
-		SUBMIT(CL_COMMAND_UNMAP_MEM_OBJECT, command_unmap_mem_object)
-		SUBMIT(CL_COMMAND_MARKER, command_marker)
-		SUBMIT(CL_COMMAND_BARRIER, command_barrier)
-		default:
-			ERROR_STOP("Trying to submit unknown command (type %x)", cmd->typ);
+	switch(cmd->typ)
+	{
+		SUBMIT(CL_COMMAND_NDRANGE_KERNEL, command_ndrange_kernel);
+		SUBMIT(CL_COMMAND_TASK, command_ndrange_kernel);
+		SUBMIT(CL_COMMAND_READ_BUFFER, command_read_buffer);
+		SUBMIT(CL_COMMAND_WRITE_BUFFER, command_write_buffer);
+		SUBMIT(CL_COMMAND_COPY_BUFFER, command_copy_buffer);
+		SUBMIT(CL_COMMAND_MAP_BUFFER, command_map_buffer);
+		SUBMIT(CL_COMMAND_UNMAP_MEM_OBJECT, command_unmap_mem_object);
+		SUBMIT(CL_COMMAND_MARKER, command_marker);
+		SUBMIT(CL_COMMAND_BARRIER, command_barrier);
+	default:
+		ERROR_STOP("Trying to submit unknown command (type %x)", cmd->typ);
 	}
 
 	cmd->submitted = 1;
 #undef SUBMIT
 }
 
-cl_int command_submit_deep_ex(cl_command cmd) {
+cl_int command_submit_deep_ex(cl_command cmd)
+{
 	if (cmd->submitted == 1)
 		return CL_SUCCESS;
-	
+
 	/* We set this in order to avoid cyclic dependencies */
 	cmd->submitted = 1;
 
 	unsigned int i;
 	for (i=0; i<cmd->num_events; i++)
 		command_submit_deep(cmd->events[i]->command);
-	
+
 	cmd->submitted = 0;
 
 	command_submit_ex(cmd);
@@ -118,36 +126,34 @@ cl_int command_submit_deep_ex(cl_command cmd) {
 	return CL_SUCCESS;
 }
 
-void command_graph_dump_ex(cl_command cmd) {
-
+void command_graph_dump_ex(cl_command cmd)
+{
 	unsigned int i;
 	for (i=0; i<cmd->num_events; i++)
 		command_graph_dump_ex(cmd->events[i]->command);
 
 	const char * typ_str = (cmd->typ == CL_COMMAND_NDRANGE_KERNEL ? "ndrange_kernel" :
-			cmd->typ == CL_COMMAND_TASK           ? "task"           :
-			cmd->typ == CL_COMMAND_READ_BUFFER    ? "read_buffer"    :
-			cmd->typ == CL_COMMAND_WRITE_BUFFER   ? "write_buffer"   :
-			cmd->typ == CL_COMMAND_COPY_BUFFER    ? "copy_buffer"    :
-			cmd->typ == CL_COMMAND_MAP_BUFFER     ? "map_buffer"     :
-			cmd->typ == CL_COMMAND_UNMAP_MEM_OBJECT ? "unmap_mem_object" :
-			cmd->typ == CL_COMMAND_MARKER         ? "marker"         :
-			cmd->typ == CL_COMMAND_BARRIER        ? "barrier"        : "unknown");
-
-
+				cmd->typ == CL_COMMAND_TASK           ? "task"           :
+				cmd->typ == CL_COMMAND_READ_BUFFER    ? "read_buffer"    :
+				cmd->typ == CL_COMMAND_WRITE_BUFFER   ? "write_buffer"   :
+				cmd->typ == CL_COMMAND_COPY_BUFFER    ? "copy_buffer"    :
+				cmd->typ == CL_COMMAND_MAP_BUFFER     ? "map_buffer"     :
+				cmd->typ == CL_COMMAND_UNMAP_MEM_OBJECT ? "unmap_mem_object" :
+				cmd->typ == CL_COMMAND_MARKER         ? "marker"         :
+				cmd->typ == CL_COMMAND_BARRIER        ? "barrier"        : "unknown");
 
 	printf("CMD %p TYPE %s DEPS", cmd, typ_str);
 	for (i=0; i<cmd->num_events; i++)
 		printf(" %p", cmd->events[i]->command);
 	printf("\n");
-
 }
 
 #define nullOrDup(name,size) cmd->name = memdup_safe(name,size)
 #define nullOrFree(name) if (cmd->name != NULL) free((void*)cmd->name)
 #define dup(name) cmd->name = name
 
-void command_ndrange_kernel_release(void * arg) {
+void command_ndrange_kernel_release(void * arg)
+{
 	command_ndrange_kernel cmd = (command_ndrange_kernel)arg;
 
 	gc_entity_unstore(&cmd->kernel);
@@ -157,10 +163,11 @@ void command_ndrange_kernel_release(void * arg) {
 	free(cmd->arg_sizes);
 	free(cmd->arg_types);
 	unsigned int i;
-	for (i=0; i<cmd->num_args; i++) {
+	for (i=0; i<cmd->num_args; i++)
+	{
 		free(cmd->args[i]);
-      cmd->args[i] = NULL;
-   }
+		cmd->args[i] = NULL;
+	}
 	free(cmd->args);
 
 	for (i=0; i<cmd->num_buffers; i++)
@@ -169,12 +176,11 @@ void command_ndrange_kernel_release(void * arg) {
 	free(cmd->buffers);
 }
 
-command_ndrange_kernel command_ndrange_kernel_create (
-		cl_kernel        kernel,
-		cl_uint          work_dim,
-		const size_t *   global_work_offset,
-		const size_t *   global_work_size,
-		const size_t *   local_work_size)
+command_ndrange_kernel command_ndrange_kernel_create(cl_kernel        kernel,
+						     cl_uint          work_dim,
+						     const size_t *   global_work_offset,
+						     const size_t *   global_work_size,
+						     const size_t *   local_work_size)
 {
 	command_ndrange_kernel cmd = calloc(1, sizeof(struct command_ndrange_kernel_t));
 	command_init(cmd, CL_COMMAND_NDRANGE_KERNEL, command_ndrange_kernel_release);
@@ -200,16 +206,15 @@ command_ndrange_kernel command_ndrange_kernel_create (
 	return cmd;
 }
 
-command_ndrange_kernel command_task_create (cl_kernel kernel) {
-
+command_ndrange_kernel command_task_create (cl_kernel kernel)
+{
 	static cl_uint task_work_dim = 3;
 	static const size_t task_global_work_offset[3] = {0,0,0};
 	static const size_t task_global_work_size[3] = {1,1,1};
 	static const size_t * task_local_work_size = NULL;
 
-	command_ndrange_kernel cmd = command_ndrange_kernel_create(
-			kernel, task_work_dim, task_global_work_offset,
-			task_global_work_size, task_local_work_size);
+	command_ndrange_kernel cmd = command_ndrange_kernel_create(kernel, task_work_dim, task_global_work_offset,
+								   task_global_work_size, task_local_work_size);
 
 	/* This is the only difference with command_ndrange_kernel_create */
 	cmd->_command.typ = CL_COMMAND_TASK;
@@ -217,34 +222,34 @@ command_ndrange_kernel command_task_create (cl_kernel kernel) {
 	return cmd;
 }
 
-command_barrier command_barrier_create () {
-
+command_barrier command_barrier_create ()
+{
 	command_barrier cmd = malloc(sizeof(struct command_barrier_t));
 	command_init(cmd, CL_COMMAND_BARRIER, NULL);
 
 	return cmd;
 }
 
-command_marker command_marker_create () {
-
+command_marker command_marker_create ()
+{
 	command_marker cmd = malloc(sizeof(struct command_marker_t));
 	command_init(cmd, CL_COMMAND_MARKER, NULL);
 
 	return cmd;
 }
 
-void command_map_buffer_release(void * UNUSED(arg)) {
+void command_map_buffer_release(void * UNUSED(arg))
+{
 	/* We DO NOT unstore (release) the buffer as unmap will do it
-	  gc_entity_unstore(&cmd->buffer); */
+	   gc_entity_unstore(&cmd->buffer); */
 }
 
-command_map_buffer command_map_buffer_create(
-		cl_mem buffer,
-		cl_map_flags map_flags,
-		size_t offset,
-		size_t cb
-		) {
-
+command_map_buffer command_map_buffer_create(cl_mem buffer,
+					     cl_map_flags map_flags,
+					     size_t offset,
+					     size_t cb
+					     )
+{
 	command_map_buffer cmd = malloc(sizeof(struct command_map_buffer_t));
 	command_init(cmd, CL_COMMAND_MAP_BUFFER, command_map_buffer_release);
 
@@ -256,7 +261,8 @@ command_map_buffer command_map_buffer_create(
 	return cmd;
 }
 
-void command_unmap_mem_object_release(void * arg) {
+void command_unmap_mem_object_release(void * arg)
+{
 	command_unmap_mem_object cmd = (command_unmap_mem_object)arg;
 
 	/* We release the buffer twice because map buffer command did not */
@@ -264,7 +270,8 @@ void command_unmap_mem_object_release(void * arg) {
 	gc_entity_unstore(&cmd->buffer);
 }
 
-command_unmap_mem_object command_unmap_mem_object_create(cl_mem buffer, void * ptr) {
+command_unmap_mem_object command_unmap_mem_object_create(cl_mem buffer, void * ptr)
+{
 	command_unmap_mem_object cmd = malloc(sizeof(struct command_unmap_mem_object_t));
 	command_init(cmd, CL_COMMAND_UNMAP_MEM_OBJECT, command_unmap_mem_object_release);
 
@@ -274,13 +281,14 @@ command_unmap_mem_object command_unmap_mem_object_create(cl_mem buffer, void * p
 	return cmd;
 }
 
-void command_read_buffer_release(void *arg) {
+void command_read_buffer_release(void *arg)
+{
 	command_read_buffer cmd = (command_read_buffer)arg;
 	gc_entity_unstore(&cmd->buffer);
 }
 
-command_read_buffer command_read_buffer_create(cl_mem buffer, size_t offset, size_t cb, void * ptr) {
-
+command_read_buffer command_read_buffer_create(cl_mem buffer, size_t offset, size_t cb, void * ptr)
+{
 	command_read_buffer cmd = malloc(sizeof(struct command_read_buffer_t));
 	command_init(cmd, CL_COMMAND_READ_BUFFER, command_read_buffer_release);
 
@@ -292,13 +300,14 @@ command_read_buffer command_read_buffer_create(cl_mem buffer, size_t offset, siz
 	return cmd;
 }
 
-void command_write_buffer_release(void *arg) {
+void command_write_buffer_release(void *arg)
+{
 	command_write_buffer cmd = (command_write_buffer)arg;
 	gc_entity_unstore(&cmd->buffer);
 }
 
-command_write_buffer command_write_buffer_create(cl_mem buffer, size_t offset, size_t cb, const void * ptr) {
-
+command_write_buffer command_write_buffer_create(cl_mem buffer, size_t offset, size_t cb, const void * ptr)
+{
 	command_write_buffer cmd = malloc(sizeof(struct command_write_buffer_t));
 	command_init(cmd, CL_COMMAND_WRITE_BUFFER, command_write_buffer_release);
 
@@ -310,14 +319,15 @@ command_write_buffer command_write_buffer_create(cl_mem buffer, size_t offset, s
 	return cmd;
 }
 
-void command_copy_buffer_release(void *arg) {
+void command_copy_buffer_release(void *arg)
+{
 	command_copy_buffer cmd = (command_copy_buffer)arg;
 	gc_entity_unstore(&cmd->src_buffer);
 	gc_entity_unstore(&cmd->dst_buffer);
 }
 
 command_copy_buffer command_copy_buffer_create( cl_mem src_buffer, cl_mem dst_buffer,
-		size_t src_offset, size_t dst_offset, size_t cb)
+						size_t src_offset, size_t dst_offset, size_t cb)
 {
 	command_copy_buffer cmd = malloc(sizeof(struct command_copy_buffer_t));
 	command_init(cmd, CL_COMMAND_COPY_BUFFER, command_copy_buffer_release);
@@ -336,4 +346,3 @@ command_copy_buffer command_copy_buffer_create( cl_mem src_buffer, cl_mem dst_bu
 #undef dup
 #undef nodeDup
 #undef memdup
-

socl/src/command.h

@@ -31,7 +31,7 @@ typedef struct cl_command_t * cl_command;
  * Implicit and explicit dependencies must be passed as parameters
  */
 void command_init_ex(cl_command cmd, cl_command_type typ, void (*cb)(void*));
-#define command_init(cmd,typ,cb) \
+#define command_init(cmd,typ,cb)		\
 	command_init_ex((cl_command)cmd,typ,cb)
 
 void command_release(cl_command cmd);
@@ -51,7 +51,8 @@ void command_graph_dump_ex(cl_command cmd);
 /**************************
  * OpenCL Commands
  **************************/
-struct cl_command_t {
+struct cl_command_t
+{
 	CL_ENTITY;
 	cl_command_type	typ;	 	/* Command type */
 	cl_uint 	num_events;	/* Number of dependencies */
@@ -76,7 +77,8 @@ cl_event command_event_get_ex(cl_command cmd);
 
 #define CL_COMMAND struct cl_command_t _command;
 
-typedef struct command_ndrange_kernel_t {
+typedef struct command_ndrange_kernel_t
+{
 	CL_COMMAND
 
 	cl_kernel        kernel;
@@ -94,17 +96,18 @@ typedef struct command_ndrange_kernel_t {
 } * command_ndrange_kernel;
 
 
-typedef struct command_read_buffer_t {
+typedef struct command_read_buffer_t
+{
 	CL_COMMAND
-	
+
 	cl_mem buffer;
 	size_t offset;
 	size_t cb;
 	void * ptr;
 } * command_read_buffer;
 
-
-typedef struct command_write_buffer_t {
+typedef struct command_write_buffer_t
+{
 	CL_COMMAND
 
 	cl_mem buffer;
@@ -113,10 +116,10 @@ typedef struct command_write_buffer_t {
 	const void * ptr;
 } * command_write_buffer;
 
-
-typedef struct command_copy_buffer_t {
+typedef struct command_copy_buffer_t
+{
 	CL_COMMAND
-	
+
 	cl_mem src_buffer;
 	cl_mem dst_buffer;
 	size_t src_offset;
@@ -124,8 +127,8 @@ typedef struct command_copy_buffer_t {
 	size_t cb;
 } * command_copy_buffer;
 
-
-typedef struct command_map_buffer_t {
+typedef struct command_map_buffer_t
+{
 	CL_COMMAND
 
 	cl_mem buffer;
@@ -134,20 +137,21 @@ typedef struct command_map_buffer_t {
 	size_t cb;
 } * command_map_buffer;
 
-
-typedef struct command_unmap_mem_object_t {
+typedef struct command_unmap_mem_object_t
+{
 	CL_COMMAND
 
 	cl_mem buffer;
 	void * ptr;
 } * command_unmap_mem_object;
 
-
-typedef struct command_marker_t {
+typedef struct command_marker_t
+{
 	CL_COMMAND
 } * command_marker;
 
-typedef struct command_barrier_t {
+typedef struct command_barrier_t
+{
 	CL_COMMAND
 } * command_barrier;
 
@@ -155,12 +159,11 @@ typedef struct command_barrier_t {
  * Constructor functions
  *************************/
 
-command_ndrange_kernel command_ndrange_kernel_create (
-		cl_kernel        kernel,
-		cl_uint          work_dim,
-		const size_t *   global_work_offset,
-		const size_t *   global_work_size,
-		const size_t *   local_work_size);
+command_ndrange_kernel command_ndrange_kernel_create (cl_kernel        kernel,
+						      cl_uint          work_dim,
+						      const size_t *   global_work_offset,
+						      const size_t *   global_work_size,
+						      const size_t *   local_work_size);
 
 command_ndrange_kernel command_task_create (cl_kernel kernel);
 
@@ -168,34 +171,29 @@ command_barrier command_barrier_create ();
 
 command_marker command_marker_create ();
 
-command_map_buffer command_map_buffer_create(
-		cl_mem buffer,
-		cl_map_flags map_flags,
-		size_t offset,
-		size_t cb);
-
-command_unmap_mem_object command_unmap_mem_object_create(
-		cl_mem buffer,
-		void * ptr);
-
-command_read_buffer command_read_buffer_create(
-		cl_mem buffer,
-		size_t offset,
-		size_t cb,
-		void * ptr);
-
-command_write_buffer command_write_buffer_create(
-		cl_mem buffer,
-		size_t offset,
-		size_t cb,
-		const void * ptr);
-
-command_copy_buffer command_copy_buffer_create(
-		cl_mem src_buffer,
-		cl_mem dst_buffer,
-		size_t src_offset,
-		size_t dst_offset,
-		size_t cb);
+command_map_buffer command_map_buffer_create(cl_mem buffer,
+					     cl_map_flags map_flags,
+					     size_t offset,
+					     size_t cb);
+
+command_unmap_mem_object command_unmap_mem_object_create(cl_mem buffer,
+							 void * ptr);
+
+command_read_buffer command_read_buffer_create(cl_mem buffer,
+					       size_t offset,
+					       size_t cb,
+					       void * ptr);
+
+command_write_buffer command_write_buffer_create(cl_mem buffer,
+						 size_t offset,
+						 size_t cb,
+						 const void * ptr);
+
+command_copy_buffer command_copy_buffer_create(cl_mem src_buffer,
+					       cl_mem dst_buffer,
+					       size_t src_offset,
+					       size_t dst_offset,
+					       size_t cb);
 
 /*************************
  * Submit functions
@@ -211,4 +209,3 @@ cl_int command_barrier_submit(command_barrier cmd);
 
 
 #endif /* SOCL_COMMANDS_H */
-

socl/src/command_list.c

@@ -16,35 +16,41 @@
 
 #include "socl.h"
 
-command_list command_list_cons(cl_command cmd, command_list ls) {
-   command_list e = malloc(sizeof(struct command_list_t));
-   e->cmd = cmd;
-   e->next = ls;
-   e->prev = NULL;
-   if (ls != NULL)
-      ls->prev = e;
-   return e;
+command_list command_list_cons(cl_command cmd, command_list ls)
+{
+	command_list e = malloc(sizeof(struct command_list_t));
+	e->cmd = cmd;
+	e->next = ls;
+	e->prev = NULL;
+	if (ls != NULL)
+		ls->prev = e;
+	return e;
 }
 
 /**
  * Remove every occurence of cmd in the list l
  */
-command_list command_list_remove(command_list l, cl_command cmd) {
-   command_list e = l;
-   while (e != NULL) {
-      if (e->cmd == cmd) {
-         if (e->prev != NULL) e->prev->next = e->next;
-         if (e->next != NULL) e->next->prev = e->prev;
-         command_list old = e;
-         if (l == old) { // list head has been removed
-            l = old->next;
-         }
-         e = old->next;
-         free(old);
-      }
-      else {
-         e = e->next;
-      }
-   }
-   return l;
+command_list command_list_remove(command_list l, cl_command cmd)
+{
+	command_list e = l;
+	while (e != NULL)
+	{
+		if (e->cmd == cmd)
+		{
+			if (e->prev != NULL) e->prev->next = e->next;
+			if (e->next != NULL) e->next->prev = e->prev;
+			command_list old = e;
+			if (l == old)
+			{ // list head has been removed
+				l = old->next;
+			}
+			e = old->next;
+			free(old);
+		}
+		else
+		{
+			e = e->next;
+		}
+	}
+	return l;
 }

socl/src/command_list.h

@@ -18,7 +18,8 @@
 
 typedef struct command_list_t * command_list;
 
-struct command_list_t {
+struct command_list_t
+{
 	cl_command cmd;
 	command_list next;
 	command_list prev;

socl/src/command_queue.c

@@ -26,12 +26,11 @@
  * its command queue.
  */
 
-
-void command_queue_enqueue_ex(cl_command_queue cq, cl_command cmd, cl_uint num_events, const cl_event * events) {
-
-  cl_event ev = command_event_get_ex(cmd);
-  ev->prof_queued = _socl_nanotime();
-  gc_entity_release(ev);
+void command_queue_enqueue_ex(cl_command_queue cq, cl_command cmd, cl_uint num_events, const cl_event * events)
+{
+	cl_event ev = command_event_get_ex(cmd);
+	ev->prof_queued = _socl_nanotime();
+	gc_entity_release(ev);
 
 	/* Check if the command is a barrier */
 	int is_barrier = (cmd->typ == CL_COMMAND_BARRIER || !(cq->properties & CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE));
@@ -50,9 +49,11 @@ void command_queue_enqueue_ex(cl_command_queue cq, cl_command cmd, cl_uint num_e
 		ndeps++;
 
 	/* Add dependencies to out-of-order events (if any) */
-	if (is_barrier) {
+	if (is_barrier)
+	{
 		command_list cl = cq->commands;
-		while (cl != NULL) {
+		while (cl != NULL)
+		{
 			ndeps++;
 			cl = cl->next;
 		}
@@ -64,13 +65,15 @@ void command_queue_enqueue_ex(cl_command_queue cq, cl_command cmd, cl_uint num_e
 	int n = 0;
 
 	/* Add dependency to last barrier if applicable */
-	if (cq->barrier != NULL) 
-      gc_entity_store(&deps[n++], cq->barrier->event);
+	if (cq->barrier != NULL)
+		gc_entity_store(&deps[n++], cq->barrier->event);
 
 	/* Add dependencies to out-of-order events (if any) */
-	if (is_barrier) {
+	if (is_barrier)
+	{
 		command_list cl = cq->commands;
-		while (cl != NULL) {
+		while (cl != NULL)
+		{
 			gc_entity_store(&deps[n++], cl->cmd->event);
 			cl = cl->next;
 		}
@@ -78,7 +81,8 @@ void command_queue_enqueue_ex(cl_command_queue cq, cl_command cmd, cl_uint num_e
 
 	/* Add explicit dependencies */
 	unsigned i;
-	for (i=0; i<num_events; i++) {
+	for (i=0; i<num_events; i++)
+	{
 		gc_entity_store(&deps[n++], events[i]);
 	}
 
@@ -87,18 +91,20 @@ void command_queue_enqueue_ex(cl_command_queue cq, cl_command cmd, cl_uint num_e
 	cmd->events = deps;
 
 	/* Insert command in the queue */
-	if (is_barrier) {
+	if (is_barrier)
+	{
 		/* Remove out-of-order commands */
 		cq->commands = NULL;
 		/* Register the command as the last barrier */
 		cq->barrier = cmd;
 	}
-	else {
+	else
+	{
 		/* Add command to the list of out-of-order commands */
 		cq->commands = command_list_cons(cmd, cq->commands);
 	}
 
-	/* Submit command 
+	/* Submit command
 	 * We need to do it before unlocking because we don't want events to get
 	 * released while we use them to set dependencies
 	 */

socl/src/command_queue.h

@@ -17,12 +17,11 @@
 #ifndef SOCL_COMMAND_QUEUE_H
 #define SOCL_COMMAND_QUEUE_H
 
-void command_queue_enqueue_ex(
-	cl_command_queue 	cq,		/* Command queue */
-	cl_command		cmd,		/* Command to enqueue */
-	cl_uint			num_events,	/* Number of explicit dependencies */
-	const cl_event *	events		/* Explicit dependencies */
-	);
+void command_queue_enqueue_ex(cl_command_queue 	cq,		/* Command queue */
+			      cl_command		cmd,		/* Command to enqueue */
+			      cl_uint			num_events,	/* Number of explicit dependencies */
+			      const cl_event *	events		/* Explicit dependencies */
+			      );
 
 #define command_queue_enqueue(cq, cmd, num_events, events)\
 	command_queue_enqueue_ex(cq, (cl_command)cmd, num_events, events)

socl/src/debug.c

@@ -17,58 +17,58 @@
 #include "socl.h"
 
 void ERROR_CL(char *s, cl_int err) {
-   #define ERR_CASE(a) case a: ERROR_MSG("[OpenCL] %s CL error: %s\n", s, #a); break;
-   switch(err) {
-      case CL_SUCCESS:
-         DEBUG_MSG("[OpenCL] %s SUCCESS.\n", s);
-         break;
-      ERR_CASE(CL_DEVICE_NOT_FOUND)
-      ERR_CASE(CL_DEVICE_NOT_AVAILABLE)
-      ERR_CASE(CL_COMPILER_NOT_AVAILABLE)
-      ERR_CASE(CL_MEM_OBJECT_ALLOCATION_FAILURE)
-      ERR_CASE(CL_OUT_OF_RESOURCES)
-      ERR_CASE(CL_OUT_OF_HOST_MEMORY)
-      ERR_CASE(CL_PROFILING_INFO_NOT_AVAILABLE)
-      ERR_CASE(CL_MEM_COPY_OVERLAP)
-      ERR_CASE(CL_IMAGE_FORMAT_MISMATCH)
-      ERR_CASE(CL_IMAGE_FORMAT_NOT_SUPPORTED)
-      ERR_CASE(CL_BUILD_PROGRAM_FAILURE)
-      ERR_CASE(CL_MAP_FAILURE)
-      ERR_CASE(CL_INVALID_VALUE)
-      ERR_CASE(CL_INVALID_DEVICE_TYPE)
-      ERR_CASE(CL_INVALID_PLATFORM)
-      ERR_CASE(CL_INVALID_DEVICE)
-      ERR_CASE(CL_INVALID_CONTEXT)
-      ERR_CASE(CL_INVALID_QUEUE_PROPERTIES)
-      ERR_CASE(CL_INVALID_COMMAND_QUEUE)
-      ERR_CASE(CL_INVALID_HOST_PTR)
-      ERR_CASE(CL_INVALID_MEM_OBJECT)
-      ERR_CASE(CL_INVALID_IMAGE_FORMAT_DESCRIPTOR)
-      ERR_CASE(CL_INVALID_IMAGE_SIZE)
-      ERR_CASE(CL_INVALID_SAMPLER)
-      ERR_CASE(CL_INVALID_BINARY)
-      ERR_CASE(CL_INVALID_BUILD_OPTIONS)
-      ERR_CASE(CL_INVALID_PROGRAM)
-      ERR_CASE(CL_INVALID_PROGRAM_EXECUTABLE)
-      ERR_CASE(CL_INVALID_KERNEL_NAME)
-      ERR_CASE(CL_INVALID_KERNEL_DEFINITION)
-      ERR_CASE(CL_INVALID_KERNEL)
-      ERR_CASE(CL_INVALID_ARG_INDEX)
-      ERR_CASE(CL_INVALID_ARG_VALUE)
-      ERR_CASE(CL_INVALID_ARG_SIZE)
-      ERR_CASE(CL_INVALID_KERNEL_ARGS)
-      ERR_CASE(CL_INVALID_WORK_DIMENSION)
-      ERR_CASE(CL_INVALID_WORK_GROUP_SIZE)
-      ERR_CASE(CL_INVALID_WORK_ITEM_SIZE)
-      ERR_CASE(CL_INVALID_GLOBAL_OFFSET)
-      ERR_CASE(CL_INVALID_EVENT_WAIT_LIST)
-      ERR_CASE(CL_INVALID_EVENT)
-      ERR_CASE(CL_INVALID_OPERATION)
-      ERR_CASE(CL_INVALID_GL_OBJECT)
-      ERR_CASE(CL_INVALID_BUFFER_SIZE)
-      ERR_CASE(CL_INVALID_MIP_LEVEL)
-      ERR_CASE(CL_INVALID_GLOBAL_WORK_SIZE)
-      default:
-         ERROR_MSG("%s CL error: Error message not supported by ERROR_CL function (%d).\n", s, err);
-   }
+#define ERR_CASE(a) case a: ERROR_MSG("[OpenCL] %s CL error: %s\n", s, #a); break;
+	switch(err) {
+	case CL_SUCCESS:
+		DEBUG_MSG("[OpenCL] %s SUCCESS.\n", s);
+		break;
+		ERR_CASE(CL_DEVICE_NOT_FOUND);
+		ERR_CASE(CL_DEVICE_NOT_AVAILABLE);
+		ERR_CASE(CL_COMPILER_NOT_AVAILABLE);
+		ERR_CASE(CL_MEM_OBJECT_ALLOCATION_FAILURE);
+		ERR_CASE(CL_OUT_OF_RESOURCES);
+		ERR_CASE(CL_OUT_OF_HOST_MEMORY);
+		ERR_CASE(CL_PROFILING_INFO_NOT_AVAILABLE);
+		ERR_CASE(CL_MEM_COPY_OVERLAP);
+		ERR_CASE(CL_IMAGE_FORMAT_MISMATCH);
+		ERR_CASE(CL_IMAGE_FORMAT_NOT_SUPPORTED);
+		ERR_CASE(CL_BUILD_PROGRAM_FAILURE);
+		ERR_CASE(CL_MAP_FAILURE);
+		ERR_CASE(CL_INVALID_VALUE);
+		ERR_CASE(CL_INVALID_DEVICE_TYPE);
+		ERR_CASE(CL_INVALID_PLATFORM);
+		ERR_CASE(CL_INVALID_DEVICE);
+		ERR_CASE(CL_INVALID_CONTEXT);
+		ERR_CASE(CL_INVALID_QUEUE_PROPERTIES);
+		ERR_CASE(CL_INVALID_COMMAND_QUEUE);
+		ERR_CASE(CL_INVALID_HOST_PTR);
+		ERR_CASE(CL_INVALID_MEM_OBJECT);
+		ERR_CASE(CL_INVALID_IMAGE_FORMAT_DESCRIPTOR);
+		ERR_CASE(CL_INVALID_IMAGE_SIZE);
+		ERR_CASE(CL_INVALID_SAMPLER);
+		ERR_CASE(CL_INVALID_BINARY);
+		ERR_CASE(CL_INVALID_BUILD_OPTIONS);
+		ERR_CASE(CL_INVALID_PROGRAM);
+		ERR_CASE(CL_INVALID_PROGRAM_EXECUTABLE);
+		ERR_CASE(CL_INVALID_KERNEL_NAME);
+		ERR_CASE(CL_INVALID_KERNEL_DEFINITION);
+		ERR_CASE(CL_INVALID_KERNEL);
+		ERR_CASE(CL_INVALID_ARG_INDEX);
+		ERR_CASE(CL_INVALID_ARG_VALUE);
+		ERR_CASE(CL_INVALID_ARG_SIZE);
+		ERR_CASE(CL_INVALID_KERNEL_ARGS);
+		ERR_CASE(CL_INVALID_WORK_DIMENSION);
+		ERR_CASE(CL_INVALID_WORK_GROUP_SIZE);
+		ERR_CASE(CL_INVALID_WORK_ITEM_SIZE);
+		ERR_CASE(CL_INVALID_GLOBAL_OFFSET);
+		ERR_CASE(CL_INVALID_EVENT_WAIT_LIST);
+		ERR_CASE(CL_INVALID_EVENT);
+		ERR_CASE(CL_INVALID_OPERATION);
+		ERR_CASE(CL_INVALID_GL_OBJECT);
+		ERR_CASE(CL_INVALID_BUFFER_SIZE);
+		ERR_CASE(CL_INVALID_MIP_LEVEL);
+		ERR_CASE(CL_INVALID_GLOBAL_WORK_SIZE);
+	default:
+		ERROR_MSG("%s CL error: Error message not supported by ERROR_CL function (%d).\n", s, err);
+	}
 }

socl/src/debug.h

@@ -22,16 +22,15 @@
 #ifdef STARPU_VERBOSE
 #define DEBUG
 #include <stdio.h>
-  #define DEBUG_MSG(...) do { if (!getenv("STARPU_SILENT")) { fprintf(stderr, "[SOCL] [%s] ", __starpu_func__); fprintf(stderr, __VA_ARGS__);}} while (0)
-  #define DEBUG_MSG_NOHEAD(...) do { if (!getenv("STARPU_SILENT")) { fprintf(stderr, __VA_ARGS__);}} while (0);
-  #define DEBUG_ERROR(...) do { if (!getenv("STARPU_SILENT")) { fprintf(stderr, "[SOCL] ERROR: "__VA_ARGS__); } exit(1); } while (0)
+#define DEBUG_MSG(...) do { if (!getenv("STARPU_SILENT")) { fprintf(stderr, "[SOCL] [%s] ", __starpu_func__); fprintf(stderr, __VA_ARGS__);}} while (0)
+#define DEBUG_MSG_NOHEAD(...) do { if (!getenv("STARPU_SILENT")) { fprintf(stderr, __VA_ARGS__);}} while (0);
+#define DEBUG_ERROR(...) do { if (!getenv("STARPU_SILENT")) { fprintf(stderr, "[SOCL] ERROR: "__VA_ARGS__); } exit(1); } while (0)
 #else
-   #define DEBUG_MSG(...) while(0)
-   #define DEBUG_MSG_NOHEAD(...) while(0)
-   #define DEBUG_ERROR(...) while(0)
+#define DEBUG_MSG(...) while(0)
+#define DEBUG_MSG_NOHEAD(...) while(0)
+#define DEBUG_ERROR(...) while(0)
 #endif
 
-
 #define ERROR_MSG(...) do { fprintf(stderr, "[SOCL] [%s] ERROR: ", __starpu_func__); fprintf(stderr, __VA_ARGS__); } while (0)
 #define ERROR_MSG_NOHEAD(...) fprintf(stderr, __VA_ARGS__)
 #define ERROR_STOP(...) do { ERROR_MSG(__VA_ARGS__); exit(1); } while(0)
@@ -39,9 +38,9 @@
 void ERROR_CL(char *s, cl_int err);
 
 #ifdef STARPU_VERBOSE
-   #define DEBUG_CL(args...) ERROR_CL(args)
+#define DEBUG_CL(args...) ERROR_CL(args)
 #else
-   #define DEBUG_CL(...) while(0)
+#define DEBUG_CL(...) while(0)
 #endif
 
 #ifdef DEBUG

socl/src/event.c

@@ -20,10 +20,11 @@
 
 static void release_callback_event(void * e);
 
-int event_unique_id() {
-   static int id = 1;
+int event_unique_id()
+{
+	static int id = 1;
 
-   return __sync_fetch_and_add(&id,1);
+	return __sync_fetch_and_add(&id,1);
 }
 
 /**
@@ -31,39 +32,41 @@ int event_unique_id() {
  *
  * Events have one-to-one relation with tag. Tag number is event ID
  */
-cl_event event_create(void) {
-   cl_event ev;
-   ev = gc_entity_alloc(sizeof(struct _cl_event), release_callback_event, "event");
+cl_event event_create(void)
+{
+	cl_event ev;
+	ev = gc_entity_alloc(sizeof(struct _cl_event), release_callback_event, "event");
 
-   ev->id = event_unique_id();
-   ev->status = CL_SUBMITTED;
-   ev->command = NULL;
-   ev->prof_queued = 0L;
-   ev->prof_submit = 0L;
-   ev->prof_start = 0L;
-   ev->prof_end = 0L;
-   ev->cq = NULL;
+	ev->id = event_unique_id();
+	ev->status = CL_SUBMITTED;
+	ev->command = NULL;
+	ev->prof_queued = 0L;
+	ev->prof_submit = 0L;
+	ev->prof_start = 0L;
+	ev->prof_end = 0L;
+	ev->cq = NULL;
 
-   return ev;
+	return ev;
 }
 
-void event_complete(cl_event ev) {
-  ev->status = CL_COMPLETE;
-  
-  ev->prof_end = _socl_nanotime();
+void event_complete(cl_event ev)
+{
+	ev->status = CL_COMPLETE;
 
-  /* Trigger the tag associated to the command event */
-  DEBUG_MSG("Trigger event %d\n", ev->id);
-  starpu_tag_notify_from_apps(ev->id);
+	ev->prof_end = _socl_nanotime();
+
+	/* Trigger the tag associated to the command event */
+	DEBUG_MSG("Trigger event %d\n", ev->id);
+	starpu_tag_notify_from_apps(ev->id);
 }
 
-static void release_callback_event(void * e) {
-  cl_event event = (cl_event)e;
+static void release_callback_event(void * e)
+{
+	cl_event event = (cl_event)e;
 
-  gc_entity_unstore(&event->cq);
+	gc_entity_unstore(&event->cq);
 
-  /* Destruct object */
-  //FIXME
-  //starpu_tag_remove(event->id);
+	/* Destruct object */
+	//FIXME
+	//starpu_tag_remove(event->id);
 }
-

socl/src/gc.c

@@ -43,158 +43,164 @@ static volatile int gc_stop_required = 0;
 #define GC_UNLOCK_NO_SIGNAL STARPU_PTHREAD_MUTEX_UNLOCK(&gc_mutex)
 
 /* Thread routine */
-static void * gc_thread_routine(void *UNUSED(arg)) {
-  
-  GC_LOCK;
-
-  do {
-    /* Make a copy of the gc_list to allow callbacks to add things into it */
-    entity rs = gc_list;
-    gc_list = NULL;
-
-    GC_UNLOCK_NO_SIGNAL;
-
-    entity r = rs;
-    while (r != NULL) {
-      /* Call entity release callback */
-      if (r->release_callback != NULL) {
-        r->release_callback(r);
-      }
-
-      /* Release entity */
-      entity next = r->next;
-      free(r);
-
-      r = next;
-    }
-
-    GC_LOCK;
-
-    /* Check if new entities have been added */
-    if (gc_list != NULL)
-      continue;
-
-    /* Stop if required */
-    if (gc_stop_required) {
-      GC_UNLOCK_NO_SIGNAL;
-      break;
-    }
-
-    /* Otherwise we sleep */
-    STARPU_PTHREAD_COND_WAIT(&gc_cond, &gc_mutex);
-
-  } while (1);
-
-  starpu_pthread_exit(NULL);
+static void * gc_thread_routine(void *UNUSED(arg))
+{
+	GC_LOCK;
+
+	do
+	{
+		/* Make a copy of the gc_list to allow callbacks to add things into it */
+		entity rs = gc_list;
+		gc_list = NULL;
+
+		GC_UNLOCK_NO_SIGNAL;
+
+		entity r = rs;
+		while (r != NULL)
+		{
+			/* Call entity release callback */
+			if (r->release_callback != NULL)
+			{
+				r->release_callback(r);
+			}
+
+			/* Release entity */
+			entity next = r->next;
+			free(r);
+
+			r = next;
+		}
+
+		GC_LOCK;
+
+		/* Check if new entities have been added */
+		if (gc_list != NULL)
+			continue;
+
+		/* Stop if required */
+		if (gc_stop_required)
+		{
+			GC_UNLOCK_NO_SIGNAL;
+			break;
+		}
+
+		/* Otherwise we sleep */
+		STARPU_PTHREAD_COND_WAIT(&gc_cond, &gc_mutex);
+	} while (1);
+
+	starpu_pthread_exit(NULL);
 }
 
 static starpu_pthread_t gc_thread;
 
 /* Start garbage collection */
-void gc_start(void) {
-  STARPU_PTHREAD_CREATE(&gc_thread, NULL, gc_thread_routine, NULL);
+void gc_start(void)
+{
+	STARPU_PTHREAD_CREATE(&gc_thread, NULL, gc_thread_routine, NULL);
 }
 
 /* Stop garbage collection */
-void gc_stop(void) {
-  GC_LOCK;
+void gc_stop(void)
+{
+	GC_LOCK;
 
-  gc_stop_required = 1;
+	gc_stop_required = 1;
 
-  GC_UNLOCK;
+	GC_UNLOCK;
 
-  STARPU_PTHREAD_JOIN(gc_thread, NULL);
+	STARPU_PTHREAD_JOIN(gc_thread, NULL);
 }
 
-int gc_entity_release_ex(entity e, const char * DEBUG_PARAM(caller)) {
-
-  DEBUG_MSG("[%s] Decrementing refcount of %s %p to ", caller, e->name, (void *)e);
+int gc_entity_release_ex(entity e, const char * DEBUG_PARAM(caller))
+{
+	DEBUG_MSG("[%s] Decrementing refcount of %s %p to ", caller, e->name, (void *)e);
 
-  /* Decrement reference count */
-  int refs = __sync_sub_and_fetch(&e->refs, 1);
+	/* Decrement reference count */
+	int refs = __sync_sub_and_fetch(&e->refs, 1);
 
-  DEBUG_MSG_NOHEAD("%d\n", refs);
+	DEBUG_MSG_NOHEAD("%d\n", refs);
 
-  assert(refs >= 0);
+	assert(refs >= 0);
 
-  if (refs != 0)
-    return 0;
+	if (refs != 0)
+		return 0;
 
-  DEBUG_MSG("[%s] Releasing %s %p\n", caller, e->name, (void *)e);
+	DEBUG_MSG("[%s] Releasing %s %p\n", caller, e->name, (void *)e);
 
-  GC_LOCK;
+	GC_LOCK;
 
-  /* Remove entity from the entities list */
-  if (e->prev != NULL)
-    e->prev->next = e->next;
-  if (e->next != NULL)
-    e->next->prev = e->prev;
-  if (entities == e)
-    entities = e->next;
+	/* Remove entity from the entities list */
+	if (e->prev != NULL)
+		e->prev->next = e->next;
+	if (e->next != NULL)
+		e->next->prev = e->prev;
+	if (entities == e)
+		entities = e->next;
 
-  /* Put entity in the release queue */
-  e->next = gc_list;
-  gc_list = e;
+	/* Put entity in the release queue */
+	e->next = gc_list;
+	gc_list = e;
 
-  GC_UNLOCK;
+	GC_UNLOCK;
 
-  return 1;
+	return 1;
 }
 
-
-
 /**
  * Initialize entity
  */
-void gc_entity_init(void *arg, void (*release_callback)(void*), char * name) {
-
-  DEBUG_MSG("Initializing entity %p (%s)\n", arg, name);
+void gc_entity_init(void *arg, void (*release_callback)(void*), char * name)
+{
+	DEBUG_MSG("Initializing entity %p (%s)\n", arg, name);
 
-  struct entity * e = (entity)arg;
+	struct entity * e = (entity)arg;
 
-  e->dispatch = &socl_master_dispatch;
-  e->refs = 1;
-  e->release_callback = release_callback;
-  e->prev = NULL;
-  e->name = name;
+	e->dispatch = &socl_master_dispatch;
+	e->refs = 1;
+	e->release_callback = release_callback;
+	e->prev = NULL;
+	e->name = name;
 
-  GC_LOCK;
+	GC_LOCK;
 
-  e->next = entities;
-  if (entities != NULL)
-    entities->prev = e;
-  entities = e;
+	e->next = entities;
+	if (entities != NULL)
+		entities->prev = e;
+	entities = e;
 
-  GC_UNLOCK_NO_SIGNAL;
+	GC_UNLOCK_NO_SIGNAL;
 }
 
 /**
  * Allocate and initialize entity
  */
-void * gc_entity_alloc(unsigned int size, void (*release_callback)(void*), char * name) {
-  void * e = malloc(size);
-  gc_entity_init(e, release_callback, name);
-  return e;
+void * gc_entity_alloc(unsigned int size, void (*release_callback)(void*), char * name)
+{
+	void * e = malloc(size);
+	gc_entity_init(e, release_callback, name);
+	return e;
 }
 
 /** Retain entity */
-void gc_entity_retain_ex(void *arg, const char * DEBUG_PARAM(caller)) {
+void gc_entity_retain_ex(void *arg, const char * DEBUG_PARAM(caller))
+{
 	struct entity * e = (entity)arg;
 
-   #ifdef DEBUG
+#ifdef DEBUG
 	int refs =
-   #endif
-      __sync_add_and_fetch(&e->refs, 1);
-
+#endif
+		__sync_add_and_fetch(&e->refs, 1);
 
-   DEBUG_MSG("[%s] Incrementing refcount of %s %p to %d\n", caller, e->name, e, refs);
+	DEBUG_MSG("[%s] Incrementing refcount of %s %p to %d\n", caller, e->name, e, refs);
 }
 
-int gc_active_entity_count(void) {
+int gc_active_entity_count(void)
+{
 	int i = 0;
 
 	entity e = entities;
-	while (e != NULL) {
+	while (e != NULL)
+	{
 		i++;
 		e = e->next;
 	}
@@ -202,18 +208,20 @@ int gc_active_entity_count(void) {
 	return i;
 }
 
-void gc_print_remaining_entities(void) {
-   DEBUG_MSG("Remaining entities:\n");
+void gc_print_remaining_entities(void)
+{
+	DEBUG_MSG("Remaining entities:\n");
 
-   GC_LOCK;
+	GC_LOCK;
 
-   entity e = entities;
-   while (e != NULL) {
-      DEBUG_MSG("  - %s %p\n", e->name, (void *)e);
-      e = e->next;
-   }
+	entity e = entities;
+	while (e != NULL)
+	{
+		DEBUG_MSG("  - %s %p\n", e->name, (void *)e);
+		e = e->next;
+	}
 
-   GC_UNLOCK;
+	GC_UNLOCK;
 }
 
 #undef GC_LOCK

socl/src/init.c

@@ -29,116 +29,118 @@ static starpu_pthread_cond_t _socl_cond = STARPU_PTHREAD_COND_INITIALIZER;
 static pthread_t _socl_thread_init;
 static struct starpu_conf conf;
 
-int socl_init_starpu(void) {
-  STARPU_PTHREAD_MUTEX_LOCK(&_socl_mutex);
-  if (_socl_init == INITIALIZED)
-  {
-    STARPU_PTHREAD_MUTEX_UNLOCK(&_socl_mutex);
-    return 0;
-  }
-
-  if (_socl_init == CHANGING)
-  {
-    /* Avoid recursion when starpu_init calls hwloc initialization which uses its opencl plugin */
-    if (pthread_equal(_socl_thread_init, pthread_self()))
-    {
-      STARPU_PTHREAD_MUTEX_UNLOCK(&_socl_mutex);
-      return -1;
-    }
-
-    /* Somebody else is initializing already, wait for him */
-    while (_socl_init != INITIALIZED)
-      STARPU_PTHREAD_COND_WAIT(&_socl_cond, &_socl_mutex);
-    STARPU_PTHREAD_MUTEX_UNLOCK(&_socl_mutex);
-    return 0;
-  }
-  _socl_init = CHANGING;
-  _socl_thread_init = pthread_self();
-  STARPU_PTHREAD_MUTEX_UNLOCK(&_socl_mutex);
-
-  starpu_conf_init(&conf);
-  unsetenv("STARPU_NCPU");
-  unsetenv("STARPU_NCUDA");
-  conf.ncuda = 0;
-  conf.ncpus = 0;
-
-
-  _starpu_init_failed = starpu_init(&conf);
-  if (_starpu_init_failed != 0)
-  {
-     DEBUG_MSG("Error when calling starpu_init: %d\n", _starpu_init_failed);
-  }
-  else {
-     if (starpu_opencl_worker_get_count() == 0)
-     {
-	  DEBUG_MSG("StarPU didn't find any OpenCL device. Try disabling CUDA support in StarPU (export STARPU_NCUDA=0).\n");
-	  _starpu_init_failed = -ENODEV;
-     }
-  }
-
-  /* Disable dataflow implicit dependencies */
-  starpu_data_set_default_sequential_consistency_flag(0);
-
-  STARPU_PTHREAD_MUTEX_LOCK(&_socl_mutex);
-  _socl_init = INITIALIZED;
-  STARPU_PTHREAD_COND_BROADCAST(&_socl_cond);
-  STARPU_PTHREAD_MUTEX_UNLOCK(&_socl_mutex);
-
-  return 0;
+int socl_init_starpu(void)
+{
+	STARPU_PTHREAD_MUTEX_LOCK(&_socl_mutex);
+	if (_socl_init == INITIALIZED)
+	{
+		STARPU_PTHREAD_MUTEX_UNLOCK(&_socl_mutex);
+		return 0;
+	}
+
+	if (_socl_init == CHANGING)
+	{
+		/* Avoid recursion when starpu_init calls hwloc initialization which uses its opencl plugin */
+		if (pthread_equal(_socl_thread_init, pthread_self()))
+		{
+			STARPU_PTHREAD_MUTEX_UNLOCK(&_socl_mutex);
+			return -1;
+		}
+
+		/* Somebody else is initializing already, wait for him */
+		while (_socl_init != INITIALIZED)
+			STARPU_PTHREAD_COND_WAIT(&_socl_cond, &_socl_mutex);
+		STARPU_PTHREAD_MUTEX_UNLOCK(&_socl_mutex);
+		return 0;
+	}
+	_socl_init = CHANGING;
+	_socl_thread_init = pthread_self();
+	STARPU_PTHREAD_MUTEX_UNLOCK(&_socl_mutex);
+
+	starpu_conf_init(&conf);
+	unsetenv("STARPU_NCPU");
+	unsetenv("STARPU_NCUDA");
+	conf.ncuda = 0;
+	conf.ncpus = 0;
+
+	_starpu_init_failed = starpu_init(&conf);
+	if (_starpu_init_failed != 0)
+	{
+		DEBUG_MSG("Error when calling starpu_init: %d\n", _starpu_init_failed);
+	}
+	else
+	{
+		if (starpu_opencl_worker_get_count() == 0)
+		{
+			DEBUG_MSG("StarPU didn't find any OpenCL device. Try disabling CUDA support in StarPU (export STARPU_NCUDA=0).\n");
+			_starpu_init_failed = -ENODEV;
+		}
+	}
+
+	/* Disable dataflow implicit dependencies */
+	starpu_data_set_default_sequential_consistency_flag(0);
+
+	STARPU_PTHREAD_MUTEX_LOCK(&_socl_mutex);
+	_socl_init = INITIALIZED;
+	STARPU_PTHREAD_COND_BROADCAST(&_socl_cond);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&_socl_mutex);
+
+	return 0;
 }
 /**
  * Initialize SOCL
  */
-__attribute__((constructor)) static void socl_init() {
+__attribute__((constructor)) static void socl_init()
+{
+	mem_object_init();
 
-
-  mem_object_init();
-
-  gc_start();
+	gc_start();
 }
 
+void soclShutdown()
+{
+	static int shutdown = 0;
 
-void soclShutdown() {
-   static int shutdown = 0;
-
-   if (!shutdown) {
-      shutdown = 1;
+	if (!shutdown)
+	{
+		shutdown = 1;
 
-      STARPU_PTHREAD_MUTEX_LOCK(&_socl_mutex);
-      if( _socl_init )
-         starpu_task_wait_for_all();
+		STARPU_PTHREAD_MUTEX_LOCK(&_socl_mutex);
+		if( _socl_init )
+			starpu_task_wait_for_all();
 
-      gc_stop();
+		gc_stop();
 
-      if( _socl_init )
-         starpu_task_wait_for_all();
+		if( _socl_init )
+			starpu_task_wait_for_all();
 
-      int active_entities = gc_active_entity_count();
+		int active_entities = gc_active_entity_count();
 
-      if (active_entities != 0) {
-         DEBUG_MSG("Unreleased entities: %d\n", active_entities);
-         gc_print_remaining_entities();
-      }
+		if (active_entities != 0)
+		{
+			DEBUG_MSG("Unreleased entities: %d\n", active_entities);
+			gc_print_remaining_entities();
+		}
 
-      if( _socl_init && _starpu_init_failed != -ENODEV)
-         starpu_shutdown();
-      STARPU_PTHREAD_MUTEX_UNLOCK(&_socl_mutex);
+		if( _socl_init && _starpu_init_failed != -ENODEV)
+			starpu_shutdown();
+		STARPU_PTHREAD_MUTEX_UNLOCK(&_socl_mutex);
 
-      if (socl_devices != NULL) {
-         free(socl_devices);
-         socl_devices = NULL;
-      }
-   }
+		if (socl_devices != NULL)
+		{
+			free(socl_devices);
+			socl_devices = NULL;
+		}
+	}
 }
 
 /**
  * Shutdown SOCL
  */
-__attribute__((destructor)) static void socl_shutdown() {
-
-  char * skip_str = getenv("SOCL_SKIP_DESTRUCTOR");
-  int skip = (skip_str != NULL ? atoi(skip_str) : 0);
-
-  if (!skip) soclShutdown();
+__attribute__((destructor)) static void socl_shutdown()
+{
+	char * skip_str = getenv("SOCL_SKIP_DESTRUCTOR");
+	int skip = (skip_str != NULL ? atoi(skip_str) : 0);
 
+	if (!skip) soclShutdown();
 }

socl/src/mem_objects.c

@@ -25,67 +25,75 @@ static starpu_pthread_spinlock_t p_mem_objects_spinlock[mem_object_hash_key];
 #define LOCK(i) starpu_pthread_spin_lock(&p_mem_objects_spinlock[i]);
 #define UNLOCK(i) starpu_pthread_spin_unlock(&p_mem_objects_spinlock[i]);
 
-void mem_object_init(void) {
-  int i;
-  for (i=0; i<mem_object_hash_key; i++) {
-    starpu_pthread_spin_init(&p_mem_objects_spinlock[i], 0);
-  }
+void mem_object_init(void)
+{
+	int i;
+	for (i=0; i<mem_object_hash_key; i++)
+	{
+		starpu_pthread_spin_init(&p_mem_objects_spinlock[i], 0);
+	}
 }
 
-static int mem_object_hash(const void * addr) {
-  uintptr_t t = (uintptr_t)addr;
-  uintptr_t t2 = t >> 4;
-  uintptr_t t3 = t2 % mem_object_hash_key;
-  return (int)t3;
+static int mem_object_hash(const void * addr)
+{
+	uintptr_t t = (uintptr_t)addr;
+	uintptr_t t2 = t >> 4;
+	uintptr_t t3 = t2 % mem_object_hash_key;
+	return (int)t3;
 }
 
-void mem_object_store(cl_mem m) {
-   int hash = mem_object_hash(m);
+void mem_object_store(cl_mem m)
+{
+	int hash = mem_object_hash(m);
 
-   LOCK(hash);
+	LOCK(hash);
 
-   m->prev = NULL;
-   m->next = p_mem_objects[hash];
-   if (p_mem_objects[hash] != NULL)
-      p_mem_objects[hash]->prev = m;
-   p_mem_objects[hash] = m;
+	m->prev = NULL;
+	m->next = p_mem_objects[hash];
+	if (p_mem_objects[hash] != NULL)
+		p_mem_objects[hash]->prev = m;
+	p_mem_objects[hash] = m;
 
-   UNLOCK(hash);
+	UNLOCK(hash);
 }
 
-void mem_object_release(cl_mem m) {
+void mem_object_release(cl_mem m)
+{
+	int hash = mem_object_hash(m);
 
-   int hash = mem_object_hash(m);
+	LOCK(hash);
 
-   LOCK(hash);
+	if (m->prev != NULL)
+		m->prev->next = m->next;
+	if (m->next != NULL)
+		m->next->prev = m->prev;
 
-   if (m->prev != NULL)
-     m->prev->next = m->next;
-   if (m->next != NULL)
-     m->next->prev = m->prev;
+	if (p_mem_objects[hash] == m)
+	{
+		p_mem_objects[hash] = m->next;
+	}
 
-   if (p_mem_objects[hash] == m) {
-      p_mem_objects[hash] = m->next;
-   }
-
-   UNLOCK(hash)
+	UNLOCK(hash)
 }
 
-cl_mem mem_object_fetch(const void * addr) {
-   int hash = mem_object_hash(*(cl_mem*)addr);
+cl_mem mem_object_fetch(const void * addr)
+{
+	int hash = mem_object_hash(*(cl_mem*)addr);
 
-   LOCK(hash);
+	LOCK(hash);
 
-   cl_mem buf;
-   for (buf = p_mem_objects[hash]; buf != NULL; buf = buf->next) {
-      if (*(cl_mem*)addr == buf) {
-         UNLOCK(hash);
-         return buf;
-      }
-   }
+	cl_mem buf;
+	for (buf = p_mem_objects[hash]; buf != NULL; buf = buf->next)
+	{
+		if (*(cl_mem*)addr == buf)
+		{
+			UNLOCK(hash);
+			return buf;
+		}
+	}
 
-   UNLOCK(hash);
-   return NULL;
+	UNLOCK(hash);
+	return NULL;
 }
 
 #undef LOCK

socl/src/socl.c

@@ -18,132 +18,132 @@
 
 #include "socl.h"
 
-struct _cl_icd_dispatch socl_master_dispatch = {
-  soclGetPlatformIDs,
-  soclGetPlatformInfo,
-  soclGetDeviceIDs,
-  soclGetDeviceInfo,
-  soclCreateContext,
-  soclCreateContextFromType,
-  soclRetainContext,
-  soclReleaseContext,
-  soclGetContextInfo,
-  soclCreateCommandQueue,
-  soclRetainCommandQueue,
-  soclReleaseCommandQueue,
-  soclGetCommandQueueInfo,
-  soclSetCommandQueueProperty,
-  soclCreateBuffer,
-  soclCreateImage2D,
-  soclCreateImage3D,
-  soclRetainMemObject,
-  soclReleaseMemObject,
-  soclGetSupportedImageFormats,
-  soclGetMemObjectInfo,
-  soclGetImageInfo,
-  soclCreateSampler,
-  soclRetainSampler,
-  soclReleaseSampler,
-  soclGetSamplerInfo,
-  soclCreateProgramWithSource,
-  soclCreateProgramWithBinary,
-  soclRetainProgram,
-  soclReleaseProgram,
-  soclBuildProgram,
-  soclUnloadCompiler,
-  soclGetProgramInfo,
-  soclGetProgramBuildInfo,
-  soclCreateKernel,
-  soclCreateKernelsInProgram,
-  soclRetainKernel,
-  soclReleaseKernel,
-  soclSetKernelArg,
-  soclGetKernelInfo,
-  soclGetKernelWorkGroupInfo,
-  soclWaitForEvents,
-  soclGetEventInfo,
-  soclRetainEvent,
-  soclReleaseEvent,
-  soclGetEventProfilingInfo,
-  soclFlush,
-  soclFinish,
-  soclEnqueueReadBuffer,
-  soclEnqueueWriteBuffer,
-  soclEnqueueCopyBuffer,
-  soclEnqueueReadImage,
-  soclEnqueueWriteImage,
-  soclEnqueueCopyImage,
-  soclEnqueueCopyImageToBuffer,
-  soclEnqueueCopyBufferToImage,
-  soclEnqueueMapBuffer,
-  soclEnqueueMapImage,
-  soclEnqueueUnmapMemObject,
-  soclEnqueueNDRangeKernel,
-  soclEnqueueTask,
-  soclEnqueueNativeKernel,
-  soclEnqueueMarker,
-  soclEnqueueWaitForEvents,
-  soclEnqueueBarrier,
-  soclGetExtensionFunctionAddress,
-  (void *) NULL, //  clCreateFromGLBuffer,
-  (void *) NULL, //  clCreateFromGLTexture2D,
-  (void *) NULL, //  clCreateFromGLTexture3D,
-  (void *) NULL, //  clCreateFromGLRenderbuffer,
-  (void *) NULL, //  clGetGLObjectInfo,
-  (void *) NULL, //  clGetGLTextureInfo,
-  (void *) NULL, //  clEnqueueAcquireGLObjects,
-  (void *) NULL, //  clEnqueueReleaseGLObjects,
-  (void *) NULL, //  clGetGLContextInfoKHR,
-  (void *) NULL, //
-  (void *) NULL,
-  (void *) NULL,
-  (void *) NULL,
-  (void *) NULL,
-  (void *) NULL,
-  (void *) NULL, //  clSetEventCallback,
-  (void *) NULL, //  clCreateSubBuffer,
-  (void *) NULL, //  clSetMemObjectDestructorCallback,
-  (void *) NULL, //  clCreateUserEvent,
-  (void *) NULL, //  clSetUserEventStatus,
-  (void *) NULL, //  clEnqueueReadBufferRect,
-  (void *) NULL, //  clEnqueueWriteBufferRect,
-  (void *) NULL, //  clEnqueueCopyBufferRect,
-  (void *) NULL, //  clCreateSubDevicesEXT,
-  (void *) NULL, //  clRetainDeviceEXT,
-  (void *) NULL, //  clReleaseDeviceEXT,
-  (void *) NULL,
-  (void *) NULL, //  clCreateSubDevices,
-  (void *) NULL, //  clRetainDevice,
-  (void *) NULL, //  clReleaseDevice,
-  (void *) NULL, //  clCreateImage,
-  (void *) NULL, //  clCreateProgramWithBuiltInKernels,
-  (void *) NULL, //  clCompileProgram,
-  (void *) NULL, //  clLinkProgram,
-  (void *) NULL, //  clUnloadPlatformCompiler,
-  (void *) NULL, //  clGetKernelArgInfo,
-  (void *) NULL, //  clEnqueueFillBuffer,
-  (void *) NULL, //  clEnqueueFillImage,
-  (void *) NULL, //  clEnqueueMigrateMemObjects,
-  soclEnqueueMarkerWithWaitList, //  clEnqueueMarkerWithWaitList,
-  soclEnqueueBarrierWithWaitList, //  clEnqueueBarrierWithWaitList,
-  soclGetExtensionFunctionAddressForPlatform, //  clGetExtensionFunctionAddressForPlatform,
-  (void *) NULL, //  clCreateFromGLTexture,
-  (void *) NULL,
-  (void *) NULL,
-  (void *) NULL,
-  (void *) NULL,
-  (void *) NULL,
-  (void *) NULL,
-  (void *) NULL,
-  (void *) NULL,
-  (void *) NULL,
-  (void *) NULL,
-  (void *) NULL,
-  (void *) NULL,
-  (void *) NULL
+struct _cl_icd_dispatch socl_master_dispatch =
+{
+	soclGetPlatformIDs,
+	soclGetPlatformInfo,
+	soclGetDeviceIDs,
+	soclGetDeviceInfo,
+	soclCreateContext,
+	soclCreateContextFromType,
+	soclRetainContext,
+	soclReleaseContext,
+	soclGetContextInfo,
+	soclCreateCommandQueue,
+	soclRetainCommandQueue,
+	soclReleaseCommandQueue,
+	soclGetCommandQueueInfo,
+	soclSetCommandQueueProperty,
+	soclCreateBuffer,
+	soclCreateImage2D,
+	soclCreateImage3D,
+	soclRetainMemObject,
+	soclReleaseMemObject,
+	soclGetSupportedImageFormats,
+	soclGetMemObjectInfo,
+	soclGetImageInfo,
+	soclCreateSampler,
+	soclRetainSampler,
+	soclReleaseSampler,
+	soclGetSamplerInfo,
+	soclCreateProgramWithSource,
+	soclCreateProgramWithBinary,
+	soclRetainProgram,
+	soclReleaseProgram,
+	soclBuildProgram,
+	soclUnloadCompiler,
+	soclGetProgramInfo,
+	soclGetProgramBuildInfo,
+	soclCreateKernel,
+	soclCreateKernelsInProgram,
+	soclRetainKernel,
+	soclReleaseKernel,
+	soclSetKernelArg,
+	soclGetKernelInfo,
+	soclGetKernelWorkGroupInfo,
+	soclWaitForEvents,
+	soclGetEventInfo,
+	soclRetainEvent,
+	soclReleaseEvent,
+	soclGetEventProfilingInfo,
+	soclFlush,
+	soclFinish,
+	soclEnqueueReadBuffer,
+	soclEnqueueWriteBuffer,
+	soclEnqueueCopyBuffer,
+	soclEnqueueReadImage,
+	soclEnqueueWriteImage,
+	soclEnqueueCopyImage,
+	soclEnqueueCopyImageToBuffer,
+	soclEnqueueCopyBufferToImage,
+	soclEnqueueMapBuffer,
+	soclEnqueueMapImage,
+	soclEnqueueUnmapMemObject,
+	soclEnqueueNDRangeKernel,
+	soclEnqueueTask,
+	soclEnqueueNativeKernel,
+	soclEnqueueMarker,
+	soclEnqueueWaitForEvents,
+	soclEnqueueBarrier,
+	soclGetExtensionFunctionAddress,
+	(void *) NULL, //  clCreateFromGLBuffer,
+	(void *) NULL, //  clCreateFromGLTexture2D,
+	(void *) NULL, //  clCreateFromGLTexture3D,
+	(void *) NULL, //  clCreateFromGLRenderbuffer,
+	(void *) NULL, //  clGetGLObjectInfo,
+	(void *) NULL, //  clGetGLTextureInfo,
+	(void *) NULL, //  clEnqueueAcquireGLObjects,
+	(void *) NULL, //  clEnqueueReleaseGLObjects,
+	(void *) NULL, //  clGetGLContextInfoKHR,
+	(void *) NULL, //
+	(void *) NULL,
+	(void *) NULL,
+	(void *) NULL,
+	(void *) NULL,
+	(void *) NULL,
+	(void *) NULL, //  clSetEventCallback,
+	(void *) NULL, //  clCreateSubBuffer,
+	(void *) NULL, //  clSetMemObjectDestructorCallback,
+	(void *) NULL, //  clCreateUserEvent,
+	(void *) NULL, //  clSetUserEventStatus,
+	(void *) NULL, //  clEnqueueReadBufferRect,
+	(void *) NULL, //  clEnqueueWriteBufferRect,
+	(void *) NULL, //  clEnqueueCopyBufferRect,
+	(void *) NULL, //  clCreateSubDevicesEXT,
+	(void *) NULL, //  clRetainDeviceEXT,
+	(void *) NULL, //  clReleaseDeviceEXT,
+	(void *) NULL,
+	(void *) NULL, //  clCreateSubDevices,
+	(void *) NULL, //  clRetainDevice,
+	(void *) NULL, //  clReleaseDevice,
+	(void *) NULL, //  clCreateImage,
+	(void *) NULL, //  clCreateProgramWithBuiltInKernels,
+	(void *) NULL, //  clCompileProgram,
+	(void *) NULL, //  clLinkProgram,
+	(void *) NULL, //  clUnloadPlatformCompiler,
+	(void *) NULL, //  clGetKernelArgInfo,
+	(void *) NULL, //  clEnqueueFillBuffer,
+	(void *) NULL, //  clEnqueueFillImage,
+	(void *) NULL, //  clEnqueueMigrateMemObjects,
+	soclEnqueueMarkerWithWaitList, //  clEnqueueMarkerWithWaitList,
+	soclEnqueueBarrierWithWaitList, //  clEnqueueBarrierWithWaitList,
+	soclGetExtensionFunctionAddressForPlatform, //  clGetExtensionFunctionAddressForPlatform,
+	(void *) NULL, //  clCreateFromGLTexture,
+	(void *) NULL,
+	(void *) NULL,
+	(void *) NULL,
+	(void *) NULL,
+	(void *) NULL,
+	(void *) NULL,
+	(void *) NULL,
+	(void *) NULL,
+	(void *) NULL,
+	(void *) NULL,
+	(void *) NULL,
+	(void *) NULL,
+	(void *) NULL
 };
 
-
 struct _cl_platform_id socl_platform = {&socl_master_dispatch};
 
 const char * __attribute__ ((aligned (16))) SOCL_PROFILE = "FULL_PROFILE";

socl/src/task.c

@@ -18,101 +18,104 @@
 #include "gc.h"
 #include "event.h"
 
-void command_completed(cl_command cmd) {
-  starpu_task task = cmd->task;
-  
-  cl_event ev = command_event_get_ex(cmd);
-  ev->status = CL_COMPLETE;
-  
-  ev->prof_end = _socl_nanotime();
-
-  /* Commands without codelets (marker, barrier, unmap...) take no time */
-  if (task->cl == NULL) 
-    ev->prof_start = ev->prof_end;
-
-  /* Trigger the tag associated to the command event */
-  DEBUG_MSG("Trigger event %d\n", ev->id);
-  starpu_tag_notify_from_apps(ev->id);
-
-  gc_entity_release(ev);
-}
+void command_completed(cl_command cmd)
+{
+	starpu_task task = cmd->task;
+
+	cl_event ev = command_event_get_ex(cmd);
+	ev->status = CL_COMPLETE;
+
+	ev->prof_end = _socl_nanotime();
 
-void command_completed_task_callback(void *arg) {
-  cl_command cmd = (cl_command)arg;
+	/* Commands without codelets (marker, barrier, unmap...) take no time */
+	if (task->cl == NULL)
+		ev->prof_start = ev->prof_end;
+
+	/* Trigger the tag associated to the command event */
+	DEBUG_MSG("Trigger event %d\n", ev->id);
+	starpu_tag_notify_from_apps(ev->id);
+
+	gc_entity_release(ev);
+}
 
-  command_completed(cmd);
+void command_completed_task_callback(void *arg)
+{
+	cl_command cmd = (cl_command)arg;
 
-  /* Release the command stored task callback parameter */
-  gc_entity_release(cmd);
+	command_completed(cmd);
 
+	/* Release the command stored task callback parameter */
+	gc_entity_release(cmd);
 }
 
 /*
  * Create a StarPU task
  */
-starpu_task task_create() {
-  struct starpu_task * task;
+starpu_task task_create()
+{
+	struct starpu_task * task;
 
-  /* Create StarPU task */
-  task = starpu_task_create();
+	/* Create StarPU task */
+	task = starpu_task_create();
 
-  /* Set task common settings */
-  task->destroy = 0;
-  task->detach = 0;
+	/* Set task common settings */
+	task->destroy = 0;
+	task->detach = 0;
 
-  task->use_tag = 1;
-  task->tag_id = event_unique_id();
+	task->use_tag = 1;
+	task->tag_id = event_unique_id();
 
-  return task;
+	return task;
 }
 
+void task_depends_on(starpu_task task, cl_uint num_events, cl_event *events)
+{
+	if (num_events != 0)
+	{
+		cl_uint i;
 
-void task_depends_on(starpu_task task, cl_uint num_events, cl_event *events) {
+		starpu_tag_t * tags = malloc(num_events * sizeof(starpu_tag_t));
 
-  if (num_events != 0) {
-    cl_uint i;
+		DEBUG_MSG("Task %p depends on events:", task);
+		for (i=0; i<num_events; i++)
+		{
+			tags[i] = events[i]->id;
+			DEBUG_MSG_NOHEAD(" %d", events[i]->id);
+		}
+		DEBUG_MSG_NOHEAD("\n");
 
-    starpu_tag_t * tags = malloc(num_events * sizeof(starpu_tag_t));	
+		starpu_tag_declare_deps_array(task->tag_id, num_events, tags);
 
-    DEBUG_MSG("Task %p depends on events:", task);
-    for (i=0; i<num_events; i++) {
-       tags[i] = events[i]->id;
-       DEBUG_MSG_NOHEAD(" %d", events[i]->id);
-    }
-    DEBUG_MSG_NOHEAD("\n");
-
-    starpu_tag_declare_deps_array(task->tag_id, num_events, tags);
-
-    free(tags);
-  }
+		free(tags);
+	}
 }
 
-cl_int task_submit_ex(starpu_task task, cl_command cmd) {
-
-  /* Associated the task to the command */
-  cmd->task = task;
+cl_int task_submit_ex(starpu_task task, cl_command cmd)
+{
+	/* Associated the task to the command */
+	cmd->task = task;
 
-  cl_uint num_events = command_num_events_get_ex(cmd);
-  cl_event * events = command_events_get_ex(cmd);
+	cl_uint num_events = command_num_events_get_ex(cmd);
+	cl_event * events = command_events_get_ex(cmd);
 
-  task_depends_on(task, num_events, events);
+	task_depends_on(task, num_events, events);
 
-  task->callback_func = command_completed_task_callback;
-  gc_entity_store(&task->callback_arg, cmd);
+	task->callback_func = command_completed_task_callback;
+	gc_entity_store(&task->callback_arg, cmd);
 
-  cl_event ev = command_event_get_ex(cmd);
-  ev->prof_submit = _socl_nanotime();
-  gc_entity_release(ev);
+	cl_event ev = command_event_get_ex(cmd);
+	ev->prof_submit = _socl_nanotime();
+	gc_entity_release(ev);
 
-  /* Submit task */
-  int ret = (task->cl != NULL && task->where == STARPU_OPENCL ?
-        starpu_task_submit_to_ctx(task, cmd->event->cq->context->sched_ctx) :
-        starpu_task_submit(task));
+	/* Submit task */
+	int ret = (task->cl != NULL && task->where == STARPU_OPENCL ?
+		   starpu_task_submit_to_ctx(task, cmd->event->cq->context->sched_ctx) :
+		   starpu_task_submit(task));
 
-  if (ret != 0)
-     DEBUG_ERROR("Unable to submit a task. Error %d\n", ret);
+	if (ret != 0)
+		DEBUG_ERROR("Unable to submit a task. Error %d\n", ret);
 
-  return CL_SUCCESS;
+	return CL_SUCCESS;
 }
 
 
@@ -120,56 +123,58 @@ cl_int task_submit_ex(starpu_task task, cl_command cmd) {
  * CPU task helper
  *********************************/
 
-struct cputask_arg {
-  void (*callback)(void*);
-  void * arg;
-  int free_arg;
-  cl_command cmd;
-  int complete_cmd;
+struct cputask_arg
+{
+	void (*callback)(void*);
+	void * arg;
+	int free_arg;
+	cl_command cmd;
+	int complete_cmd;
 };
 
-static void cputask_task(void *args) {
-  struct cputask_arg * arg = (struct cputask_arg*)args;
+static void cputask_task(void *args)
+{
+	struct cputask_arg * arg = (struct cputask_arg*)args;
 
-  arg->callback(arg->arg);
+	arg->callback(arg->arg);
 
-  if (arg->complete_cmd)
-     command_completed(arg->cmd);
+	if (arg->complete_cmd)
+		command_completed(arg->cmd);
 
-  if (arg->free_arg) {
-    assert(arg->arg != NULL);
-    free(arg->arg);
-    arg->arg = NULL;
-  }
-
-  gc_entity_unstore(&arg->cmd);
-  free(arg);
+	if (arg->free_arg)
+	{
+		assert(arg->arg != NULL);
+		free(arg->arg);
+		arg->arg = NULL;
+	}
 
+	gc_entity_unstore(&arg->cmd);
+	free(arg);
 }
 
-void cpu_task_submit_ex(cl_command cmd, void (*callback)(void*), void *arg, int free_arg, int complete_cmd, struct starpu_codelet * codelet, unsigned num_events, cl_event * events) {
-  
-  struct cputask_arg * a = malloc(sizeof(struct cputask_arg));
-  a->callback = callback;
-  a->arg = arg;
-  a->free_arg = free_arg;
-  gc_entity_store(&a->cmd, cmd);
-  a->complete_cmd = complete_cmd;
+void cpu_task_submit_ex(cl_command cmd, void (*callback)(void*), void *arg, int free_arg, int complete_cmd, struct starpu_codelet * codelet, unsigned num_events, cl_event * events)
+{
+	struct cputask_arg * a = malloc(sizeof(struct cputask_arg));
+	a->callback = callback;
+	a->arg = arg;
+	a->free_arg = free_arg;
+	gc_entity_store(&a->cmd, cmd);
+	a->complete_cmd = complete_cmd;
 
-  codelet->where = STARPU_OPENCL | STARPU_CPU | STARPU_CUDA;
+	codelet->where = STARPU_OPENCL | STARPU_CPU | STARPU_CUDA;
 
-  starpu_task task = task_create();
-  if (num_events != 0) {
-     task_depends_on(task, num_events, events);
-  }
+	starpu_task task = task_create();
+	if (num_events != 0)
+	{
+		task_depends_on(task, num_events, events);
+	}
 
-  task->callback_func = cputask_task;
-  task->callback_arg = a;
+	task->callback_func = cputask_task;
+	task->callback_arg = a;
 
-  cmd->task = task;
+	cmd->task = task;
 
-  int ret = starpu_task_submit(task);
-  if (ret != 0)
-     DEBUG_ERROR("Unable to submit a task. Error %d\n", ret);
+	int ret = starpu_task_submit(task);
+	if (ret != 0)
+		DEBUG_ERROR("Unable to submit a task. Error %d\n", ret);
 }
-

socl/src/util.c

@@ -18,46 +18,53 @@
 #include "socl.h"
 #include "common/timing.h"
 
+int starpu_worker_get_range_by_id(int id)
+{
+	int i, oid = 0;
+	for (i=0; i<id; i++)
+		if (starpu_worker_get_type(i) == STARPU_OPENCL_WORKER) oid++;
 
-int starpu_worker_get_range_by_id(int id) {
-   int i, oid = 0;
-   for (i=0; i<id; i++)
-      if (starpu_worker_get_type(i) == STARPU_OPENCL_WORKER) oid++;
-
-   return oid;
+	return oid;
 }
 
-int starpu_worker_get_range() {
-   int id = starpu_worker_get_id_check();
-   return starpu_worker_get_range_by_id(id);
+int starpu_worker_get_range()
+{
+	int id = starpu_worker_get_id_check();
+	return starpu_worker_get_range_by_id(id);
 }
 
-void * memdupa(const void *p, size_t size) {
+void * memdupa(const void *p, size_t size)
+{
 	void * s = malloc(size);
 	memcpy(s,p,size);
 	return s;
 }
 
-void ** memdup_deep_safea(const void **p, unsigned n, size_t size) {
+void ** memdup_deep_safea(const void **p, unsigned n, size_t size)
+{
 	void ** s = (void**)malloc(sizeof(void*) * n);
 	unsigned i;
-	for (i=0; i<n; i++) {
+	for (i=0; i<n; i++)
+	{
 		s[i] = memdup_safe((void*)p[i], size);
 	}
 	return s;
 }
 
-void ** memdup_deep_varsize_safea(const void **p, unsigned n, size_t * size) {
+void ** memdup_deep_varsize_safea(const void **p, unsigned n, size_t * size)
+{
 	void ** s = (void**)malloc(sizeof(void*) * n);
 	unsigned i;
-	for (i=0; i<n; i++) {
+	for (i=0; i<n; i++)
+	{
 		s[i] = memdup_safe((void*)p[i], size[i]);
 	}
 	return s;
 }
 
-cl_ulong _socl_nanotime() {
-   struct timespec ts;
-   _starpu_clock_gettime(&ts);
-   return (ts.tv_sec * 1e9 + ts.tv_nsec);
+cl_ulong _socl_nanotime()
+{
+	struct timespec ts;
+	_starpu_clock_gettime(&ts);
+	return (ts.tv_sec * 1e9 + ts.tv_nsec);
 }