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

src/datawizard/interfaces/block_interface.c

@@ -741,24 +741,16 @@ static int copy_opencl_to_ram_async(void *src_interface, unsigned src_node __att
 {
 	starpu_block_interface_t *src_block = src_interface;
 	starpu_block_interface_t *dst_block = dst_interface;
-        int err,ret=EAGAIN;
+        int err, ret;
 
 	/* XXX non contiguous buffers are not properly supported yet. (TODO) */
 	STARPU_ASSERT((src_block->nx == src_block->ldy) && (src_block->ldy == dst_block->ldy));
 
-        err = _starpu_opencl_copy_from_opencl((cl_mem)src_block->dev_handle, (void*)dst_block->ptr,
-                                              src_block->nx*src_block->ny*src_block->nz*src_block->elemsize,
-                                              src_block->offset, (cl_event*)_event);
-	if (STARPU_UNLIKELY(err)) {
-                if (_event) {
-                        err = _starpu_opencl_copy_from_opencl((cl_mem)src_block->dev_handle, (void*)dst_block->ptr,
-                                                              src_block->nx*src_block->ny*src_block->nz*src_block->elemsize,
-                                                              src_block->offset, NULL);
-                        ret = 0;
-                }
-                if (STARPU_UNLIKELY(err))
-                        STARPU_OPENCL_REPORT_ERROR(err);
-        }
+        err = _starpu_opencl_copy_from_opencl_async_sync((cl_mem)src_block->dev_handle, (void*)dst_block->ptr,
+                                                         src_block->nx*src_block->ny*src_block->nz*src_block->elemsize,
+                                                         src_block->offset, (cl_event*)_event, &ret);
+        if (STARPU_UNLIKELY(err))
+                STARPU_OPENCL_REPORT_ERROR(err);
 
 	STARPU_TRACE_DATA_COPY(src_node, dst_node, src_block->nx*src_block->ny*src_block->nz*src_block->elemsize);
 

src/datawizard/interfaces/matrix_interface.c

@@ -490,25 +490,17 @@ static int copy_opencl_to_ram_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_from_opencl((cl_mem)src_matrix->dev_handle, (void*)dst_matrix->ptr,
-                                              src_matrix->nx*src_matrix->ny*src_matrix->elemsize,
-                                              src_matrix->offset, (cl_event*)_event);
-
-	if (STARPU_UNLIKELY(err)) {
-                if (_event) {
-                        err = _starpu_opencl_copy_from_opencl((cl_mem)src_matrix->dev_handle, (void*)dst_matrix->ptr,
-                                                              src_matrix->nx*src_matrix->ny*src_matrix->elemsize,
-                                                              src_matrix->offset, NULL);
-                        ret = 0;
-                }
-                if (STARPU_UNLIKELY(err))
-                        STARPU_OPENCL_REPORT_ERROR(err);
-        }
+        err = _starpu_opencl_copy_from_opencl_async_sync((cl_mem)src_matrix->dev_handle, (void*)dst_matrix->ptr,
+                                                         src_matrix->nx*src_matrix->ny*src_matrix->elemsize,
+                                                         src_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

@@ -376,20 +376,13 @@ static int copy_opencl_to_ram_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;
-
-	err = _starpu_opencl_copy_from_opencl((cl_mem)src_variable->ptr, (void*)dst_variable->ptr, src_variable->elemsize,
-                                              0, (cl_event*)_event);
-
-	if (STARPU_UNLIKELY(err)) {
-                if (_event) {
-                        err = _starpu_opencl_copy_from_opencl((cl_mem)src_variable->ptr, (void*)dst_variable->ptr, src_variable->elemsize,
-                                                              0, NULL);
-                        ret = 0;
-                }
-                if (STARPU_UNLIKELY(err))
-                        STARPU_OPENCL_REPORT_ERROR(err);
-        }
+        int err, ret;
+
+	err = _starpu_opencl_copy_from_opencl_async_sync((cl_mem)src_variable->ptr, (void*)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

@@ -417,19 +417,12 @@ static int copy_opencl_to_ram_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;
-
-	err = _starpu_opencl_copy_from_opencl((cl_mem)src_vector->dev_handle, (void*)dst_vector->ptr, src_vector->nx*src_vector->elemsize,
-                                              src_vector->offset, (cl_event *)_event);
-	if (STARPU_UNLIKELY(err)) {
-                if (_event) {
-                        err = _starpu_opencl_copy_from_opencl((cl_mem)src_vector->dev_handle, (void*)dst_vector->ptr, src_vector->nx*src_vector->elemsize,
-                                                              src_vector->offset, NULL);
-                        ret = 0;
-                }
-                if (STARPU_UNLIKELY(err))
-                        STARPU_OPENCL_REPORT_ERROR(err);
-        }
+        int err, ret;
+
+	err = _starpu_opencl_copy_from_opencl_async_sync((cl_mem)src_vector->dev_handle, (void*)dst_vector->ptr, src_vector->nx*src_vector->elemsize,
+                                                         src_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

@@ -141,6 +141,36 @@ int _starpu_opencl_copy_to_opencl(void *ptr, cl_mem buffer, size_t size, size_t
         return EXIT_SUCCESS;
 }
 
+int _starpu_opencl_copy_from_opencl_async_sync(cl_mem buffer, void *ptr, 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 = clEnqueueReadBuffer(queues[worker->devid], buffer, CL_TRUE, offset, size, ptr, 0, NULL, NULL);
+        }
+        else {
+                err = clEnqueueReadBuffer(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 = clEnqueueReadBuffer(queues[worker->devid], buffer, CL_TRUE, 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;
+        }
+
+        return EXIT_SUCCESS;
+}
+
 int _starpu_opencl_copy_from_opencl(cl_mem buffer, void *ptr, size_t size, size_t offset, cl_event *event)
 {
         int err;

src/drivers/opencl/driver_opencl.h

@@ -45,6 +45,9 @@ 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
+int _starpu_opencl_copy_from_opencl_async_sync(cl_mem buffer, void *ptr, size_t size, size_t offset, cl_event *event, int *ret);
+
+extern
 void _starpu_opencl_init(void);
 
 extern