Revert "src/drivers/opencl/driver_opencl.c: fix indentation"

Revert "src/datawizard/interfaces/variable_interface.c: fix indentation"
Revert "OpenCL on CPU hack for SOCL"

src/datawizard/interfaces/variable_interface.c

@@ -1,7 +1,7 @@
 /* StarPU --- Runtime system for heterogeneous multicore architectures.
  *
  * Copyright (C) 2010-2012  Université de Bordeaux 1
- * Copyright (C) 2010, 2011, 2012, 2013  Centre National de la Recherche Scientifique
+ * Copyright (C) 2010, 2011, 2012  Centre National de la Recherche Scientifique
  *
  * StarPU is free software; you can redistribute it and/or modify
  * it under the terms of the GNU Lesser General Public License as published by
@@ -326,78 +326,35 @@ static int copy_cuda_to_cuda_async(void *src_interface, unsigned src_node, void
 
 #ifdef STARPU_USE_OPENCL
 static int copy_ram_to_opencl_async(void *src_interface, unsigned src_node STARPU_ATTRIBUTE_UNUSED, void *dst_interface,
-                                    unsigned dst_node, cl_event *event)
+                                    unsigned dst_node STARPU_ATTRIBUTE_UNUSED, cl_event *event)
 {
 	struct starpu_variable_interface *src_variable = src_interface;
 	struct starpu_variable_interface *dst_variable = dst_interface;
-	int err,ret;
+        int err,ret;
 
-	int devid = _starpu_memory_node_to_devid(dst_node);
-	cl_device_type dt = _starpu_opencl_get_device_type(devid);
+        err = starpu_opencl_copy_ram_to_opencl((void*)src_variable->ptr, src_node, (cl_mem)dst_variable->ptr, dst_node, src_variable->elemsize,
+					       0, event, &ret);
+        if (STARPU_UNLIKELY(err))
+                STARPU_OPENCL_REPORT_ERROR(err);
 
-	if (starpu_cpu_worker_get_count() == 0 && dt == CL_DEVICE_TYPE_CPU)
-	{
-		cl_mem dst = (cl_mem)dst_variable->ptr;
-		cl_context ctx;
-		starpu_opencl_get_context(devid, &ctx);;
-
-		err = clGetMemObjectInfo(dst, CL_MEM_CONTEXT, sizeof(ctx), &ctx, NULL);
-		if (STARPU_UNLIKELY(err))
-			STARPU_OPENCL_REPORT_ERROR(err);
-
-		clReleaseMemObject(dst);
-		dst_variable->ptr = (uintptr_t)clCreateBuffer(ctx, CL_MEM_READ_WRITE | CL_MEM_USE_HOST_PTR, src_variable->elemsize, (void*)src_variable->ptr, &err);
-
-		if (event != NULL)
-			*event = NULL;
-	}
-	else
-	{
-		assert(src_variable->ptr != NULL);
-
-		err = starpu_opencl_copy_ram_to_opencl((void*)src_variable->ptr, src_node, (cl_mem)dst_variable->ptr, dst_node, src_variable->elemsize,
-				0, event, &ret);
-		if (STARPU_UNLIKELY(err))
-			STARPU_OPENCL_REPORT_ERROR(err);
-
-		_STARPU_TRACE_DATA_COPY(src_node, dst_node, src_variable->elemsize);
-	}
+	_STARPU_TRACE_DATA_COPY(src_node, dst_node, src_variable->elemsize);
 
 	return ret;
 }
 
-static int copy_opencl_to_ram_async(void *src_interface, unsigned src_node, void *dst_interface, unsigned dst_node STARPU_ATTRIBUTE_UNUSED, cl_event *event)
+static int copy_opencl_to_ram_async(void *src_interface, unsigned src_node STARPU_ATTRIBUTE_UNUSED, void *dst_interface, unsigned dst_node STARPU_ATTRIBUTE_UNUSED, cl_event *event)
 {
 	struct starpu_variable_interface *src_variable = src_interface;
 	struct starpu_variable_interface *dst_variable = dst_interface;
         int err, ret;
 
-	int devid = _starpu_memory_node_to_devid(src_node);
-	cl_device_type dt = _starpu_opencl_get_device_type(devid);
-
-	if (starpu_cpu_worker_get_count() == 0 && dt == CL_DEVICE_TYPE_CPU)
-	{
-		cl_mem dst = (cl_mem)src_variable->ptr;
-		void * ptr;
-
-		err = clGetMemObjectInfo(dst, CL_MEM_HOST_PTR, sizeof(ptr), &ptr, NULL);
-		if (STARPU_UNLIKELY(err))
-			STARPU_OPENCL_REPORT_ERROR(err);
+	err = starpu_opencl_copy_opencl_to_ram((cl_mem)src_variable->ptr, src_node, (void*)dst_variable->ptr, dst_node, src_variable->elemsize,
+					       0, event, &ret);
 
-		dst_variable->ptr = (uintptr_t)ptr;
+        if (STARPU_UNLIKELY(err))
+                STARPU_OPENCL_REPORT_ERROR(err);
 
-		if (event != NULL)
-			*event = NULL;
-	}
-	else
-	{
-		err = starpu_opencl_copy_opencl_to_ram((cl_mem)src_variable->ptr, src_node, (void*)dst_variable->ptr, dst_node, src_variable->elemsize,
-						       0, event, &ret);
-		if (STARPU_UNLIKELY(err))
-			STARPU_OPENCL_REPORT_ERROR(err);
-
-		_STARPU_TRACE_DATA_COPY(src_node, dst_node, src_variable->elemsize);
-	}
+	_STARPU_TRACE_DATA_COPY(src_node, dst_node, src_variable->elemsize);
 
 	return ret;
 }

src/drivers/opencl/driver_opencl.c

@@ -2,7 +2,7 @@
  *
  * Copyright (C) 2010-2012  Université de Bordeaux 1
  * Copyright (C) 2010  Mehdi Juhoor <mjuhoor@gmail.com>
- * Copyright (C) 2010, 2011, 2012, 2013  Centre National de la Recherche Scientifique
+ * Copyright (C) 2010, 2011, 2012  Centre National de la Recherche Scientifique
  * Copyright (C) 2011  Télécom-SudParis
  *
  * StarPU is free software; you can redistribute it and/or modify
@@ -249,37 +249,38 @@ cl_int starpu_opencl_allocate_memory(cl_mem *mem STARPU_ATTRIBUTE_UNUSED, size_t
 
 cl_int starpu_opencl_copy_ram_to_opencl(void *ptr, unsigned src_node STARPU_ATTRIBUTE_UNUSED, cl_mem buffer, unsigned dst_node STARPU_ATTRIBUTE_UNUSED, size_t size, size_t offset, cl_event *event, int *ret)
 {
-	cl_int err;
-	struct _starpu_worker *worker = _starpu_get_local_worker_key();
-
-	if (event)
-		_STARPU_TRACE_START_DRIVER_COPY_ASYNC(src_node, dst_node);
-
-	cl_event ev;
-	err = clEnqueueWriteBuffer(transfer_queues[worker->devid], buffer, CL_FALSE, offset, size, ptr, 0, NULL, &ev);
-
-	if (event)
-		_STARPU_TRACE_END_DRIVER_COPY_ASYNC(src_node, dst_node);
-
-	if (STARPU_LIKELY(err == CL_SUCCESS))
-	{
-	     if (event == NULL)
-	     {
-		  /* We want a synchronous copy, let's synchronise the queue */
-		  clWaitForEvents(1, &ev);
-		  clReleaseEvent(ev);
-	     }
-	     else
-	     {
-		  *event = ev;
-	     }
-
-	     if (ret)
-	     {
-		  *ret = (event == NULL) ? 0 : -EAGAIN;
-	     }
-	}
-	return err;
+   cl_int err;
+   struct _starpu_worker *worker = _starpu_get_local_worker_key();
+
+
+   if (event)
+      _STARPU_TRACE_START_DRIVER_COPY_ASYNC(src_node, dst_node);
+
+   cl_event ev;
+   err = clEnqueueWriteBuffer(transfer_queues[worker->devid], buffer, CL_FALSE, offset, size, ptr, 0, NULL, &ev);
+
+   if (event)
+      _STARPU_TRACE_END_DRIVER_COPY_ASYNC(src_node, dst_node);
+
+
+   if (STARPU_LIKELY(err == CL_SUCCESS))
+   {
+      if (event == NULL)
+      {
+         /* We want a synchronous copy, let's synchronise the queue */
+         clWaitForEvents(1, &ev);
+         clReleaseEvent(ev);
+      }
+      else {
+         *event = ev;
+      }
+
+      if (ret)
+      {
+         *ret = (event == NULL) ? 0 : -EAGAIN;
+      }
+   }
+   return err;
 }
 
 cl_int starpu_opencl_copy_opencl_to_ram(cl_mem buffer, unsigned src_node STARPU_ATTRIBUTE_UNUSED, void *ptr, unsigned dst_node STARPU_ATTRIBUTE_UNUSED, size_t size, size_t offset, cl_event *event, int *ret)
@@ -289,30 +290,27 @@ cl_int starpu_opencl_copy_opencl_to_ram(cl_mem buffer, unsigned src_node STARPU_
 
 	if (event)
 		_STARPU_TRACE_START_DRIVER_COPY_ASYNC(src_node, dst_node);
-
 	cl_event ev;
 	err = clEnqueueReadBuffer(transfer_queues[worker->devid], buffer, CL_FALSE, offset, size, ptr, 0, NULL, &ev);
 	if (event)
 		_STARPU_TRACE_END_DRIVER_COPY_ASYNC(src_node, dst_node);
-
 	if (STARPU_LIKELY(err == CL_SUCCESS))
 	{
-	     if (event == NULL)
-	     {
-		  /* We want a synchronous copy, let's synchronise the queue */
-		  clWaitForEvents(1, &ev);
-		  clReleaseEvent(ev);
-	     }
-	     else
-	     {
+	  if (event == NULL)
+	  {
+		 /* We want a synchronous copy, let's synchronise the queue */
+		 clWaitForEvents(1, &ev);
+		 clReleaseEvent(ev);
+	 }
+	  else {
 		  *event = ev;
-	     }
+	  }
 
-	     if (ret)
-	     {
-		  *ret = (event == NULL) ? 0 : -EAGAIN;
-	     }
-	}
+	  if (ret)
+	  {
+		 *ret = (event == NULL) ? 0 : -EAGAIN;
+	 }
+  }
 	return err;
 }
 
@@ -321,7 +319,7 @@ cl_int _starpu_opencl_copy_rect_opencl_to_ram(cl_mem buffer, unsigned src_node S
                                               const size_t region[3], size_t buffer_row_pitch, size_t buffer_slice_pitch,
                                               size_t host_row_pitch, size_t host_slice_pitch, cl_event *event)
 {
-	cl_int err;
+        cl_int err;
         struct _starpu_worker *worker = _starpu_get_local_worker_key();
         cl_bool blocking;