OpenCL driver: new internal function _starpu_opencl_copy_to_opencl_async_sync() that first tries to copy data asynchronously and reverts to synchronous copy on failure

src/datawizard/interfaces/matrix_interface.c

@@ -470,24 +470,16 @@ static int copy_ram_to_opencl_async(void *src_interface, unsigned src_node __att
 {
 	starpu_matrix_interface_t *src_matrix = src_interface;
 	starpu_matrix_interface_t *dst_matrix = dst_interface;
-        int err,ret=EAGAIN;
+        int err,ret;
 
 	/* XXX non contiguous matrices are not supported with OpenCL yet ! (TODO) */
 	STARPU_ASSERT((src_matrix->ld == src_matrix->nx) && (dst_matrix->ld == dst_matrix->nx));
 
-	err = _starpu_opencl_copy_to_opencl((void*)src_matrix->ptr, (cl_mem)dst_matrix->dev_handle, src_matrix->nx*src_matrix->ny*src_matrix->elemsize,
-                                            dst_matrix->offset, (cl_event*)_event);
-
-	if (STARPU_UNLIKELY(err)) {
-                if (_event) {
-                        err = _starpu_opencl_copy_to_opencl((void*)src_matrix->ptr, (cl_mem)dst_matrix->dev_handle,
-                                                            src_matrix->nx*src_matrix->ny*src_matrix->elemsize,
-                                                            dst_matrix->offset, NULL);
-                        ret = 0;
-                }
-                if (STARPU_UNLIKELY(err))
-                        STARPU_OPENCL_REPORT_ERROR(err);
-        }
+	err = _starpu_opencl_copy_to_opencl_async_sync((void*)src_matrix->ptr, (cl_mem)dst_matrix->dev_handle,
+                                                       src_matrix->nx*src_matrix->ny*src_matrix->elemsize,
+                                                       dst_matrix->offset, (cl_event*)_event, &ret);
+        if (STARPU_UNLIKELY(err))
+                STARPU_OPENCL_REPORT_ERROR(err);
 
 	STARPU_TRACE_DATA_COPY(src_node, dst_node, src_matrix->nx*src_matrix->ny*src_matrix->elemsize);
 

src/datawizard/interfaces/variable_interface.c

@@ -360,19 +360,12 @@ static int copy_ram_to_opencl_async(void *src_interface, unsigned src_node __att
 {
 	starpu_variable_interface_t *src_variable = src_interface;
 	starpu_variable_interface_t *dst_variable = dst_interface;
-        int err,ret=EAGAIN;
+        int err,ret;
 
-	err = _starpu_opencl_copy_to_opencl((void*)src_variable->ptr, (cl_mem)dst_variable->ptr, src_variable->elemsize,
-                                            0, (cl_event*)_event);
-	if (STARPU_UNLIKELY(err)) {
-                if (_event) {
-                        err = _starpu_opencl_copy_to_opencl((void*)src_variable->ptr, (cl_mem)dst_variable->ptr, src_variable->elemsize,
-                                                            0, NULL);
-                        ret = 0;
-                }
-                if (STARPU_UNLIKELY(err))
-                        STARPU_OPENCL_REPORT_ERROR(err);
-        }
+        err = _starpu_opencl_copy_to_opencl_async_sync((void*)src_variable->ptr, (cl_mem)dst_variable->ptr, src_variable->elemsize,
+                                                       0, (cl_event*)_event, &ret);
+        if (STARPU_UNLIKELY(err))
+                STARPU_OPENCL_REPORT_ERROR(err);
 
 	STARPU_TRACE_DATA_COPY(src_node, dst_node, src_variable->elemsize);
 

src/datawizard/interfaces/vector_interface.c

@@ -399,19 +399,13 @@ static int copy_ram_to_opencl_async(void *src_interface, unsigned src_node __att
 {
 	starpu_vector_interface_t *src_vector = src_interface;
 	starpu_vector_interface_t *dst_vector = dst_interface;
-        int err, ret=EAGAIN;
+        int err, ret;
 
-	err = _starpu_opencl_copy_to_opencl((void*)src_vector->ptr, (cl_mem)dst_vector->dev_handle, src_vector->nx*src_vector->elemsize,
-                                            dst_vector->offset, (cl_event*)_event);
-        if (STARPU_UNLIKELY(err)) {
-                if (_event) {
-                        err = _starpu_opencl_copy_to_opencl((void*)src_vector->ptr, (cl_mem)dst_vector->dev_handle, src_vector->nx*src_vector->elemsize,
-                                                            dst_vector->offset, NULL);
-                        ret = 0;
-                }
-                if (STARPU_UNLIKELY(err))
-                        STARPU_OPENCL_REPORT_ERROR(err);
-        }
+	err = _starpu_opencl_copy_to_opencl_async_sync((void*)src_vector->ptr, (cl_mem)dst_vector->dev_handle,
+                                                       src_vector->nx*src_vector->elemsize,
+                                                       dst_vector->offset, (cl_event*)_event, &ret);
+        if (STARPU_UNLIKELY(err))
+                STARPU_OPENCL_REPORT_ERROR(err);
 
 	STARPU_TRACE_DATA_COPY(src_node, dst_node, src_vector->nx*src_vector->elemsize);
 

src/drivers/opencl/driver_opencl.c

@@ -97,6 +97,34 @@ int _starpu_opencl_allocate_memory(void **addr, size_t size, cl_mem_flags flags)
         return EXIT_SUCCESS;
 }
 
+int _starpu_opencl_copy_to_opencl_async_sync(void *ptr, cl_mem buffer, size_t size, size_t offset, cl_event *event, int *ret)
+{
+        int err;
+        struct starpu_worker_s *worker = _starpu_get_local_worker_key();
+
+        if (event == NULL) {
+                err = clEnqueueWriteBuffer(queues[worker->devid], buffer, CL_TRUE, offset, size, ptr, 0, NULL, NULL);
+        }
+        else {
+                err = clEnqueueWriteBuffer(queues[worker->devid], buffer, CL_FALSE, offset, size, ptr, 0, NULL, event);
+                if (STARPU_LIKELY(err == CL_SUCCESS)) {
+                        *ret = EAGAIN;
+                        return EXIT_SUCCESS;
+                }
+                else {
+                        err = clEnqueueWriteBuffer(queues[worker->devid], buffer, CL_FALSE, offset, size, ptr, 0, NULL, NULL);
+                }
+        }
+        if (STARPU_UNLIKELY(err != CL_SUCCESS)) {
+                STARPU_OPENCL_REPORT_ERROR(err);
+                return err;
+        }
+        else {
+                *ret = 0;
+                return EXIT_SUCCESS;
+        }
+}
+
 int _starpu_opencl_copy_to_opencl(void *ptr, cl_mem buffer, size_t size, size_t offset, cl_event *event)
 {
         int err;
@@ -110,7 +138,7 @@ int _starpu_opencl_copy_to_opencl(void *ptr, cl_mem buffer, size_t size, size_t
         }
         if (err != CL_SUCCESS) STARPU_OPENCL_REPORT_ERROR(err);
 
-      return EXIT_SUCCESS;
+        return EXIT_SUCCESS;
 }
 
 int _starpu_opencl_copy_from_opencl(cl_mem buffer, void *ptr, size_t size, size_t offset, cl_event *event)

src/drivers/opencl/driver_opencl.h

@@ -42,6 +42,9 @@ extern
 int _starpu_opencl_copy_from_opencl(cl_mem buffer, void *ptr, size_t size, size_t offset, cl_event *event);
 
 extern
+int _starpu_opencl_copy_to_opencl_async_sync(void *ptr, cl_mem buffer, size_t size, size_t offset, cl_event *event, int *ret);
+
+extern
 void _starpu_opencl_init(void);
 
 extern