Use _starpu_allocate_buffer_on_node and _starpu_free_buffer_on_node in all interfaces

src/datawizard/interfaces/bcsr_interface.c

@@ -261,8 +261,7 @@ static size_t bcsr_interface_get_size(starpu_data_handle_t handle)
 /* returns the size of the allocated area */
 static ssize_t allocate_bcsr_buffer_on_node(void *data_interface_, uint32_t dst_node)
 {
-	uintptr_t addr_nzval = 0;
-	uint32_t *addr_colind = NULL, *addr_rowptr = NULL;
+	uintptr_t addr_nzval, addr_colind, addr_rowptr;
 	ssize_t allocated_memory;
 
 	/* we need the 3 arrays to be allocated */
@@ -275,67 +274,15 @@ static ssize_t allocate_bcsr_buffer_on_node(void *data_interface_, uint32_t dst_
 	uint32_t r = bcsr_interface->r;
 	uint32_t c = bcsr_interface->c;
 
-	enum starpu_node_kind kind = starpu_node_get_kind(dst_node);
-
-	switch(kind)
-	{
-		case STARPU_CPU_RAM:
-			addr_nzval = (uintptr_t)malloc(nnz*r*c*elemsize);
-			if (!addr_nzval)
-				goto fail_nzval;
-
-			addr_colind = (uint32_t *) malloc(nnz*sizeof(uint32_t));
-			if (!addr_colind)
-				goto fail_colind;
-
-			addr_rowptr = (uint32_t *) malloc((nrow+1)*sizeof(uint32_t));
-			if (!addr_rowptr)
-				goto fail_rowptr;
-
-			break;
-#ifdef STARPU_USE_CUDA
-		case STARPU_CUDA_RAM:
-		{
-			cudaError_t err;
-			err = cudaMalloc((void **)&addr_nzval, nnz*r*c*elemsize);
-			if (STARPU_UNLIKELY(err != cudaSuccess || !addr_nzval))
-				goto fail_nzval;
-
-			err = cudaMalloc((void **)&addr_colind, nnz*sizeof(uint32_t));
-			if (STARPU_UNLIKELY(err != cudaSuccess || !addr_colind))
-				goto fail_colind;
-
-			err = cudaMalloc((void **)&addr_rowptr, (nrow+1)*sizeof(uint32_t));
-			if (STARPU_UNLIKELY(err != cudaSuccess || !addr_rowptr))
-				goto fail_rowptr;
-
-			break;
-		}
-#endif
-#ifdef STARPU_USE_OPENCL
-		case STARPU_OPENCL_RAM:
-		{
-			int ret;
-			cl_mem ptr;
-
-			ret = starpu_opencl_allocate_memory(&ptr, nnz*r*c*elemsize, CL_MEM_READ_WRITE);
-			addr_nzval = (uintptr_t)ptr;
-			if (ret) goto fail_nzval;
-
-			ret = starpu_opencl_allocate_memory(&ptr, nnz*sizeof(uint32_t), CL_MEM_READ_WRITE);
-			addr_colind = (void*) ptr;
-			if (ret) goto fail_colind;
-
-			ret = starpu_opencl_allocate_memory(&ptr, (nrow+1)*sizeof(uint32_t), CL_MEM_READ_WRITE);
-			addr_rowptr = (void*) ptr;
-			if (ret) goto fail_rowptr;
-
-			break;
-		}
-#endif
-		default:
-			STARPU_ABORT();
-	}
+	addr_nzval = _starpu_allocate_buffer_on_node(dst_node, nnz*r*c*elemsize);
+	if (!addr_nzval)
+		goto fail_nzval;
+	addr_colind = _starpu_allocate_buffer_on_node(dst_node, nnz*sizeof(uint32_t));
+	if (!addr_colind)
+		goto fail_colind;
+	addr_rowptr = _starpu_allocate_buffer_on_node(dst_node, (nrow+1)*sizeof(uint32_t));
+	if (!addr_rowptr)
+		goto fail_rowptr;
 
 	/* allocation succeeded */
 	allocated_memory =
@@ -343,73 +290,16 @@ static ssize_t allocate_bcsr_buffer_on_node(void *data_interface_, uint32_t dst_
 
 	/* update the data properly in consequence */
 	bcsr_interface->nzval = addr_nzval;
-	bcsr_interface->colind = addr_colind;
-	bcsr_interface->rowptr = addr_rowptr;
+	bcsr_interface->colind = (uint32_t*) addr_colind;
+	bcsr_interface->rowptr = (uint32_t*) addr_rowptr;
 
 	return allocated_memory;
 
 fail_rowptr:
-	switch(kind)
-	{
-		case STARPU_CPU_RAM:
-			free((void *)addr_colind);
-			break;
-#ifdef STARPU_USE_CUDA
-		case STARPU_CUDA_RAM:
-		{
-			cudaError_t err;
-			err = cudaFree((void*)addr_colind);
-			if (STARPU_UNLIKELY(err != cudaSuccess))
-				STARPU_CUDA_REPORT_ERROR(err);
-			break;
-		}
-#endif
-#ifdef STARPU_USE_OPENCL
-		case STARPU_OPENCL_RAM:
-		{
-			cl_int err;
-			err = clReleaseMemObject((void*)addr_colind);
-			if (STARPU_UNLIKELY(err != CL_SUCCESS))
-				STARPU_OPENCL_REPORT_ERROR(err);
-			break;
-		}
-#endif
-		default:
-			STARPU_ABORT();
-	}
-
+	_starpu_free_buffer_on_node(dst_node, addr_colind);
 fail_colind:
-	switch(kind)
-	{
-		case STARPU_CPU_RAM:
-			free((void *)addr_nzval);
-			break;
-#ifdef STARPU_USE_CUDA
-		case STARPU_CUDA_RAM:
-		{
-			cudaError_t err;
-			err = cudaFree((void*)addr_nzval);
-			if (STARPU_UNLIKELY(err != cudaSuccess))
-				STARPU_CUDA_REPORT_ERROR(err);
-			break;
-		}
-#endif
-#ifdef STARPU_USE_OPENCL
-		case STARPU_OPENCL_RAM:
-		{
-			cl_int err;
-			err = clReleaseMemObject((void*)addr_nzval);
-			if (STARPU_UNLIKELY(err != CL_SUCCESS))
-				STARPU_OPENCL_REPORT_ERROR(err);
-			break;
-		}
-#endif
-		default:
-			STARPU_ABORT();
-	}
-
+	_starpu_free_buffer_on_node(dst_node, addr_nzval);
 fail_nzval:
-
 	/* allocation failed */
 	return -ENOMEM;
 }
@@ -418,49 +308,9 @@ static void free_bcsr_buffer_on_node(void *data_interface, uint32_t node)
 {
 	struct starpu_bcsr_interface *bcsr_interface = (struct starpu_bcsr_interface *) data_interface;
 
-	enum starpu_node_kind kind = starpu_node_get_kind(node);
-	switch(kind)
-	{
-		case STARPU_CPU_RAM:
-			free((void*)bcsr_interface->nzval);
-			free((void*)bcsr_interface->colind);
-			free((void*)bcsr_interface->rowptr);
-			break;
-#ifdef STARPU_USE_CUDA
-		case STARPU_CUDA_RAM:
-		{
-			cudaError_t err;
-			err = cudaFree((void*)bcsr_interface->nzval);
-			if (STARPU_UNLIKELY(err != cudaSuccess))
-				STARPU_CUDA_REPORT_ERROR(err);
-			err = cudaFree((void*)bcsr_interface->colind);
-			if (STARPU_UNLIKELY(err != cudaSuccess))
-				STARPU_CUDA_REPORT_ERROR(err);
-			err = cudaFree((void*)bcsr_interface->rowptr);
-			if (STARPU_UNLIKELY(err != cudaSuccess))
-				STARPU_CUDA_REPORT_ERROR(err);
-			break;
-		}
-#endif
-#ifdef STARPU_USE_OPENCL
-		case STARPU_OPENCL_RAM:
-		{
-			cl_int err;
-			err = clReleaseMemObject((void*)bcsr_interface->nzval);
-			if (STARPU_UNLIKELY(err != CL_SUCCESS))
-				STARPU_OPENCL_REPORT_ERROR(err);
-			err = clReleaseMemObject((void*)bcsr_interface->colind);
-			if (STARPU_UNLIKELY(err != CL_SUCCESS))
-				STARPU_OPENCL_REPORT_ERROR(err);
-			err = clReleaseMemObject((void*)bcsr_interface->rowptr);
-			if (STARPU_UNLIKELY(err != CL_SUCCESS))
-				STARPU_OPENCL_REPORT_ERROR(err);
-			break;
-		}
-#endif
-		default:
-			STARPU_ABORT();
-	}
+	_starpu_free_buffer_on_node(node, bcsr_interface->nzval);
+	_starpu_free_buffer_on_node(node, (uintptr_t) bcsr_interface->colind);
+	_starpu_free_buffer_on_node(node, (uintptr_t) bcsr_interface->rowptr);
 }
 
 #ifdef STARPU_USE_CUDA

src/datawizard/interfaces/block_interface.c

@@ -293,13 +293,8 @@ size_t starpu_block_get_elemsize(starpu_data_handle_t handle)
 /* returns the size of the allocated area */
 static ssize_t allocate_block_buffer_on_node(void *data_interface_, uint32_t dst_node)
 {
-	uintptr_t addr = 0, handle = 0;
-	unsigned fail = 0;
-	ssize_t allocated_memory;
+	uintptr_t addr = 0, handle;
 
-#ifdef STARPU_USE_CUDA
-	cudaError_t status;
-#endif
 	struct starpu_block_interface *dst_block = (struct starpu_block_interface *) data_interface_;
 
 	uint32_t nx = dst_block->nx;
@@ -307,68 +302,24 @@ static ssize_t allocate_block_buffer_on_node(void *data_interface_, uint32_t dst
 	uint32_t nz = dst_block->nz;
 	size_t elemsize = dst_block->elemsize;
 
-	enum starpu_node_kind kind = starpu_node_get_kind(dst_node);
+	ssize_t allocated_memory;
 
-	switch(kind)
-	{
-		case STARPU_CPU_RAM:
-			handle = addr = (uintptr_t)malloc(nx*ny*nz*elemsize);
-			if (!addr)
-				fail = 1;
+	handle = _starpu_allocate_buffer_on_node(dst_node, nx*ny*nz*elemsize);
 
-			break;
-#ifdef STARPU_USE_CUDA
-		case STARPU_CUDA_RAM:
-			status = cudaMalloc((void **)&addr, nx*ny*nz*elemsize);
+	if (!handle)
+		return -ENOMEM;
 
-			//_STARPU_DEBUG("cudaMalloc -> addr %p\n", addr);
+	if (starpu_node_get_kind(dst_node) != STARPU_OPENCL_RAM)
+		addr = handle;
 
-			if (!addr || status != cudaSuccess)
-			{
-				if (STARPU_UNLIKELY(status != cudaErrorMemoryAllocation))
-					STARPU_CUDA_REPORT_ERROR(status);
+	allocated_memory = nx*ny*nz*elemsize;
 
-				fail = 1;
-			}
-			handle = addr;
-
-			break;
-#endif
-#ifdef STARPU_USE_OPENCL
-	        case STARPU_OPENCL_RAM:
-			{
-                                int ret;
-				cl_mem mem;
-                                ret = starpu_opencl_allocate_memory(&mem, nx*ny*nz*elemsize, CL_MEM_READ_WRITE);
-				handle = (uintptr_t)mem;
-				if (ret)
-				{
-					fail = 1;
-				}
-				break;
-			}
-#endif
-		default:
-			STARPU_ABORT();
-	}
-
-	if (!fail)
-	{
-		/* allocation succeeded */
-		allocated_memory = nx*ny*nz*elemsize;
-
-		/* update the data properly in consequence */
-		dst_block->ptr = addr;
-		dst_block->dev_handle = handle;
-                dst_block->offset = 0;
-		dst_block->ldy = nx;
-		dst_block->ldz = nx*ny;
-	}
-	else
-	{
-		/* allocation failed */
-		allocated_memory = -ENOMEM;
-	}
+	/* update the data properly in consequence */
+	dst_block->ptr = addr;
+	dst_block->dev_handle = handle;
+	dst_block->offset = 0;
+	dst_block->ldy = nx;
+	dst_block->ldz = nx*ny;
 
 	return allocated_memory;
 }
@@ -377,37 +328,7 @@ static void free_block_buffer_on_node(void *data_interface, uint32_t node)
 {
 	struct starpu_block_interface *block_interface = (struct starpu_block_interface *) data_interface;
 
-#ifdef STARPU_USE_CUDA
-	cudaError_t status;
-#endif
-
-	enum starpu_node_kind kind = starpu_node_get_kind(node);
-	switch(kind)
-	{
-		case STARPU_CPU_RAM:
-			free((void*)block_interface->ptr);
-			break;
-#ifdef STARPU_USE_CUDA
-		case STARPU_CUDA_RAM:
-			status = cudaFree((void*)block_interface->ptr);
-			if (STARPU_UNLIKELY(status))
-				STARPU_CUDA_REPORT_ERROR(status);
-
-			break;
-#endif
-#ifdef STARPU_USE_OPENCL
-                case STARPU_OPENCL_RAM:
-		{
-			cl_int err;
-			err = clReleaseMemObject((void *)block_interface->dev_handle);
-			if (STARPU_UNLIKELY(err != CL_SUCCESS))
-				STARPU_OPENCL_REPORT_ERROR(err);
-                        break;
-		}
-#endif
-		default:
-			STARPU_ABORT();
-	}
+	_starpu_free_buffer_on_node(node, block_interface->ptr);
 }
 
 #ifdef STARPU_USE_CUDA

src/datawizard/interfaces/coo_interface.c

@@ -16,6 +16,7 @@
 
 #include <starpu.h>
 #include <common/fxt.h>
+#include <datawizard/memalloc.h>
 
 static int
 copy_ram_to_ram(void *src_interface, STARPU_ATTRIBUTE_UNUSED unsigned src_node,
@@ -361,141 +362,27 @@ allocate_coo_buffer_on_node(void *data_interface, uint32_t dst_node)
 
 	uint32_t n_values = coo_interface->n_values;
 	size_t elemsize = coo_interface->elemsize;
-	size_t size = 0, allocated_memory = 0;
 
-	switch (starpu_node_get_kind(dst_node))
-	{
-	case STARPU_CPU_RAM:
-	{
-		addr_columns = malloc(n_values * sizeof(coo_interface->columns[0]));
-		if (STARPU_UNLIKELY(addr_columns == NULL))
-			goto fail_columns;
-		addr_rows = malloc(n_values * sizeof(coo_interface->rows[0]));
-		if (STARPU_UNLIKELY(addr_rows == NULL))
-			goto fail_rows;
-		addr_values = (uintptr_t) malloc(n_values * elemsize);
-		if (STARPU_UNLIKELY(addr_values == (uintptr_t) NULL))
-			goto fail_values;
-		break;
-	}
-#ifdef STARPU_USE_CUDA
-	case STARPU_CUDA_RAM:
-	{
-		cudaError_t err;
-		err = cudaMalloc((void **) &addr_columns,
-				 n_values * sizeof(coo_interface->columns[0]));
-		if (STARPU_UNLIKELY(err != cudaSuccess))
-			goto fail_columns;
-		err = cudaMalloc((void **) &addr_rows,
-				 n_values * sizeof(coo_interface->rows[0]));
-		if (STARPU_UNLIKELY(err != cudaSuccess))
-			goto fail_rows;
-		err = cudaMalloc((void **) &addr_values,
-				 n_values * elemsize);
-		if (STARPU_UNLIKELY(err != cudaSuccess))
-			goto fail_values;
-		break;
-	}
-#endif /* !STARPU_USE_CUDA */
-#ifdef STARPU_USE_OPENCL
-	case STARPU_OPENCL_RAM:
-	{
-		cl_int ret;
-		cl_mem ptr;
-		const cl_mem_flags flags = CL_MEM_READ_WRITE;
-
-		size = n_values * sizeof(uint32_t);
-		ret = starpu_opencl_allocate_memory(&ptr, size, flags);
-		if (STARPU_UNLIKELY(ret != CL_SUCCESS))
-			goto fail_columns;
-		addr_columns = (uint32_t *) ptr;
-		allocated_memory += size;
-
-		ret = starpu_opencl_allocate_memory(&ptr, size, flags);
-		if (STARPU_UNLIKELY(ret != CL_SUCCESS))
-			goto fail_rows;
-		addr_rows = (uint32_t *) ptr;
-		allocated_memory += size;
-
-		size = n_values * elemsize;
-		ret = starpu_opencl_allocate_memory(&ptr, size, flags);
-		if (STARPU_UNLIKELY(ret != CL_SUCCESS))
-			goto fail_values;
-		addr_values = (uintptr_t) ptr;
-		allocated_memory += size;
-		break;
-	}
-#endif /* !STARPU_USE_OPENCL */
-	default:
-		STARPU_ABORT();
-	}
+	addr_columns = (void*) _starpu_allocate_buffer_on_node(dst_node, n_values * sizeof(coo_interface->columns[0]));
+	if (STARPU_UNLIKELY(addr_columns == NULL))
+		goto fail_columns;
+	addr_rows = (void*) _starpu_allocate_buffer_on_node(dst_node, n_values * sizeof(coo_interface->rows[0]));
+	if (STARPU_UNLIKELY(addr_rows == NULL))
+		goto fail_rows;
+	addr_values = _starpu_allocate_buffer_on_node(dst_node, n_values * elemsize);
+	if (STARPU_UNLIKELY(addr_values == (uintptr_t) NULL))
+		goto fail_values;
 
 	coo_interface->columns = addr_columns;
 	coo_interface->rows = addr_rows;
 	coo_interface->values = addr_values;
 
-	return allocated_memory;
+	return n_values * (sizeof(coo_interface->columns[0]) + sizeof(coo_interface->rows[0]) + elemsize);
 
 fail_values:
-	switch (starpu_node_get_kind(dst_node))
-	{
-	case STARPU_CPU_RAM:
-		free((void *) coo_interface->rows);
-		break;
-#ifdef STARPU_USE_CUDA
-	case STARPU_CUDA_RAM:
-	{
-		cudaError_t err;
-		err = cudaFree((void *) coo_interface->rows);
-		if (STARPU_UNLIKELY(err != cudaSuccess))
-			STARPU_CUDA_REPORT_ERROR(err);
-		break;
-	}
-#endif /* !STARPU_USE_CUDA */
-#ifdef STARPU_USE_OPENCL
-	case STARPU_OPENCL_RAM:
-	{
-		cl_int err;
-		err = clReleaseMemObject((void *) coo_interface->rows);
-		if (STARPU_UNLIKELY(err != CL_SUCCESS))
-			STARPU_OPENCL_REPORT_ERROR(err);
-		break;
-	}
-#endif /* !STARPU_USE_OPENCL */
-	default:
-		STARPU_ABORT();
-	}
-
+	_starpu_free_buffer_on_node(dst_node, (uintptr_t) addr_rows);
 fail_rows:
-	switch (starpu_node_get_kind(dst_node))
-	{
-	case STARPU_CPU_RAM:
-		free((void *) coo_interface->columns);
-		break;
-#ifdef STARPU_USE_CUDA
-	case STARPU_CUDA_RAM:
-	{
-		cudaError_t err;
-		err = cudaFree((void *) coo_interface->columns);
-		if (STARPU_UNLIKELY(err != cudaSuccess))
-			STARPU_CUDA_REPORT_ERROR(err);
-		break;
-	}
-#endif /* !STARPU_USE_CUDA */
-#ifdef STARPU_USE_OPENCL
-	case STARPU_OPENCL_RAM:
-	{
-		cl_int err;
-		err = clReleaseMemObject((void *) coo_interface->columns);
-		if (STARPU_UNLIKELY(err != CL_SUCCESS))
-			STARPU_OPENCL_REPORT_ERROR(err);
-		break;
-	}
-#endif /* !STARPU_USE_OPENCL */
-	default:
-		STARPU_ABORT();
-	}
-
+	_starpu_free_buffer_on_node(dst_node, (uintptr_t) addr_columns);
 fail_columns:
 	return -ENOMEM;
 }
@@ -506,48 +393,9 @@ free_coo_buffer_on_node(void *data_interface, uint32_t node)
 	struct starpu_coo_interface *coo_interface =
 		(struct starpu_coo_interface *) data_interface;
 
-	switch (starpu_node_get_kind(node))
-	{
-	case STARPU_CPU_RAM:
-		free((void *) coo_interface->columns);
-		free((void *) coo_interface->rows);
-		free((void *) coo_interface->values);
-		break;
-#ifdef STARPU_USE_CUDA
-	case STARPU_CUDA_RAM:
-	{
-		cudaError_t err;
-		err = cudaFree((void *) coo_interface->columns);
-		if (STARPU_UNLIKELY(err != cudaSuccess))
-			STARPU_CUDA_REPORT_ERROR(err);
-		err = cudaFree((void *) coo_interface->rows);
-		if (STARPU_UNLIKELY(err != cudaSuccess))
-			STARPU_CUDA_REPORT_ERROR(err);
-		err = cudaFree((void *) coo_interface->values);
-		if (STARPU_UNLIKELY(err != cudaSuccess))
-			STARPU_CUDA_REPORT_ERROR(err);
-		break;
-	}
-#endif /* !STARPU_USE_CUDA */
-#ifdef STARPU_USE_OPENCL
-	case STARPU_OPENCL_RAM:
-	{
-		cl_int err;
-		err = clReleaseMemObject((void *) coo_interface->columns);
-		if (STARPU_UNLIKELY(err != CL_SUCCESS))
-			STARPU_OPENCL_REPORT_ERROR(err);
-		err = clReleaseMemObject((void *) coo_interface->rows);
-		if (STARPU_UNLIKELY(err != CL_SUCCESS))
-			STARPU_OPENCL_REPORT_ERROR(err);
-		err = clReleaseMemObject((void *) coo_interface->values);
-		if (STARPU_UNLIKELY(err != CL_SUCCESS))
-			STARPU_OPENCL_REPORT_ERROR(err);
-		break;
-	}
-#endif /* !STARPU_USE_OPENCL */
-	default:
-		STARPU_ABORT();
-	}
+	_starpu_free_buffer_on_node(node, (uintptr_t) coo_interface->columns);
+	_starpu_free_buffer_on_node(node, (uintptr_t) coo_interface->rows);
+	_starpu_free_buffer_on_node(node, coo_interface->values);
 }
 
 static size_t

src/datawizard/interfaces/csr_interface.c

@@ -249,67 +249,15 @@ static ssize_t allocate_csr_buffer_on_node(void *data_interface_, uint32_t dst_n
 	uint32_t nrow = csr_interface->nrow;
 	size_t elemsize = csr_interface->elemsize;
 
-	enum starpu_node_kind kind = starpu_node_get_kind(dst_node);
-
-	switch(kind)
-	{
-		case STARPU_CPU_RAM:
-			addr_nzval = (uintptr_t)malloc(nnz*elemsize);
-			if (!addr_nzval)
-				goto fail_nzval;
-
-			addr_colind = (uint32_t *) malloc(nnz*sizeof(uint32_t));
-			if (!addr_colind)
-				goto fail_colind;
-
-			addr_rowptr = (uint32_t *) malloc((nrow+1)*sizeof(uint32_t));
-			if (!addr_rowptr)
-				goto fail_rowptr;
-
-			break;
-#ifdef STARPU_USE_CUDA
-		case STARPU_CUDA_RAM:
-		{
-			cudaError_t err;
-			err = cudaMalloc((void **)&addr_nzval, nnz*elemsize);
-			if (STARPU_UNLIKELY(err != cudaSuccess ||!addr_nzval))
-				goto fail_nzval;
-
-			err = cudaMalloc((void **)&addr_colind, nnz*sizeof(uint32_t));
-			if (STARPU_UNLIKELY(err != cudaSuccess || !addr_colind))
-				goto fail_colind;
-
-			err = cudaMalloc((void **)&addr_rowptr, (nrow+1)*sizeof(uint32_t));
-			if (STARPU_UNLIKELY(err != cudaSuccess || !addr_rowptr))
-				goto fail_rowptr;
-
-			break;
-		}
-#endif
-#ifdef STARPU_USE_OPENCL
-	        case STARPU_OPENCL_RAM:
-			{
-                                int ret;
-				cl_mem ptr;
-
-                                ret = starpu_opencl_allocate_memory(&ptr, nnz*elemsize, CL_MEM_READ_WRITE);
-                                addr_nzval = (uintptr_t)ptr;
-				if (ret) goto fail_nzval;
-
-                                ret = starpu_opencl_allocate_memory(&ptr, nnz*sizeof(uint32_t), CL_MEM_READ_WRITE);
-                                addr_colind = (void*) ptr;
-				if (ret) goto fail_colind;
-
-                                ret = starpu_opencl_allocate_memory(&ptr, (nrow+1)*sizeof(uint32_t), CL_MEM_READ_WRITE);
-                                addr_rowptr = (void*) ptr;
-				if (ret) goto fail_rowptr;
-
-				break;
-			}
-#endif
-		default:
-			STARPU_ABORT();
-	}
+	addr_nzval = _starpu_allocate_buffer_on_node(dst_node, nnz*elemsize);
+	if (!addr_nzval)
+		goto fail_nzval;
+	addr_colind = (uint32_t*) _starpu_allocate_buffer_on_node(dst_node, nnz*sizeof(uint32_t));
+	if (!addr_colind)
+		goto fail_colind;
+	addr_rowptr = (uint32_t*) _starpu_allocate_buffer_on_node(dst_node, (nrow+1)*sizeof(uint32_t));
+	if (!addr_rowptr)
+		goto fail_rowptr;
 
 	/* allocation succeeded */
 	allocated_memory =
@@ -323,67 +271,10 @@ static ssize_t allocate_csr_buffer_on_node(void *data_interface_, uint32_t dst_n
 	return allocated_memory;
 
 fail_rowptr:
-	switch(kind)
-	{
-		case STARPU_CPU_RAM:
-			free((void *)addr_colind);
-			break;
-#ifdef STARPU_USE_CUDA
-		case STARPU_CUDA_RAM:
-		{
-			cudaError_t err;
-			err = cudaFree((void*)addr_colind);
-			if (STARPU_UNLIKELY(err != cudaSuccess))
-				STARPU_CUDA_REPORT_ERROR(err);
-			break;
-		}
-#endif
-#ifdef STARPU_USE_OPENCL
-		case STARPU_OPENCL_RAM:
-		{
-			cl_int err;
-			err = clReleaseMemObject((void*)addr_colind);
-			if (STARPU_UNLIKELY(err != CL_SUCCESS))
-				STARPU_OPENCL_REPORT_ERROR(err);
-			break;
-		}
-#endif
-		default:
-			STARPU_ABORT();
-	}
-
+	_starpu_free_buffer_on_node(dst_node, (uintptr_t) addr_colind);
 fail_colind:
-	switch(kind)
-	{
-		case STARPU_CPU_RAM:
-			free((void *)addr_nzval);
-			break;
-#ifdef STARPU_USE_CUDA
-		case STARPU_CUDA_RAM:
-		{
-			cudaError_t err;
-			err = cudaFree((void*)addr_nzval);
-			if (STARPU_UNLIKELY(err != cudaSuccess))
-				STARPU_CUDA_REPORT_ERROR(err);
-			break;
-		}
-#endif
-#ifdef STARPU_USE_OPENCL
-		case STARPU_OPENCL_RAM:
-		{
-			cl_int err;
-			err = clReleaseMemObject((void*)addr_nzval);
-			if (STARPU_UNLIKELY(err != CL_SUCCESS))
-				STARPU_OPENCL_REPORT_ERROR(err);
-			break;
-		}
-#endif
-		default:
-			STARPU_ABORT();
-	}
-
+	_starpu_free_buffer_on_node(dst_node, addr_nzval);
 fail_nzval:
-
 	/* allocation failed */
 	return -ENOMEM;
 }
@@ -392,49 +283,9 @@ static void free_csr_buffer_on_node(void *data_interface, uint32_t node)
 {
 	struct starpu_csr_interface *csr_interface = (struct starpu_csr_interface *) data_interface;
 
-	enum starpu_node_kind kind = starpu_node_get_kind(node);
-	switch(kind)
-	{
-		case STARPU_CPU_RAM:
-			free((void*)csr_interface->nzval);
-			free((void*)csr_interface->colind);
-			free((void*)csr_interface->rowptr);
-			break;
-#ifdef STARPU_USE_CUDA
-		case STARPU_CUDA_RAM:
-		{
-			cudaError_t err;
-			err = cudaFree((void*)csr_interface->nzval);
-			if (STARPU_UNLIKELY(err != cudaSuccess))
-				STARPU_CUDA_REPORT_ERROR(err);
-			err = cudaFree((void*)csr_interface->colind);
-			if (STARPU_UNLIKELY(err != cudaSuccess))
-				STARPU_CUDA_REPORT_ERROR(err);
-			err = cudaFree((void*)csr_interface->rowptr);
-			if (STARPU_UNLIKELY(err != cudaSuccess))
-				STARPU_CUDA_REPORT_ERROR(err);
-			break;
-		}
-#endif
-#ifdef STARPU_USE_OPENCL
-		case STARPU_OPENCL_RAM:
-		{
-			cl_int err;
-			err = clReleaseMemObject((void*)csr_interface->nzval);
-			if (STARPU_UNLIKELY(err != CL_SUCCESS))
-				STARPU_OPENCL_REPORT_ERROR(err);
-			err = clReleaseMemObject((void*)csr_interface->colind);
-			if (STARPU_UNLIKELY(err != CL_SUCCESS))
-				STARPU_OPENCL_REPORT_ERROR(err);
-			err = clReleaseMemObject((void*)csr_interface->rowptr);
-			if (STARPU_UNLIKELY(err != CL_SUCCESS))
-				STARPU_OPENCL_REPORT_ERROR(err);
-			break;
-		}
-#endif
-		default:
-			STARPU_ABORT();
-	}
+	_starpu_free_buffer_on_node(node, csr_interface->nzval);
+	_starpu_free_buffer_on_node(node, (uintptr_t) csr_interface->colind);
+	_starpu_free_buffer_on_node(node, (uintptr_t) csr_interface->rowptr);
 }
 
 #ifdef STARPU_USE_CUDA

src/datawizard/interfaces/matrix_interface.c

@@ -272,13 +272,7 @@ size_t starpu_matrix_get_elemsize(starpu_data_handle_t handle)
 /* returns the size of the allocated area */
 static ssize_t allocate_matrix_buffer_on_node(void *data_interface_, uint32_t dst_node)
 {
-	uintptr_t addr = 0, handle = 0;
-	unsigned fail = 0;
-	ssize_t allocated_memory;
-
-#ifdef STARPU_USE_CUDA
-	cudaError_t status;
-#endif
+	uintptr_t addr = 0, handle;
 
 	struct starpu_matrix_interface *matrix_interface = (struct starpu_matrix_interface *) data_interface_;
 
@@ -287,66 +281,23 @@ static ssize_t allocate_matrix_buffer_on_node(void *data_interface_, uint32_t ds
 	uint32_t ld = nx; // by default
 	size_t elemsize = matrix_interface->elemsize;
 
-	enum starpu_node_kind kind = starpu_node_get_kind(dst_node);
+	ssize_t allocated_memory;
 
-	switch(kind)
-	{
-		case STARPU_CPU_RAM:
-			handle = addr = (uintptr_t)malloc((size_t)nx*ny*elemsize);
-			if (!addr)
-				fail = 1;
+	handle = _starpu_allocate_buffer_on_node(dst_node, nx*ny*elemsize);
 
-			break;
-#ifdef STARPU_USE_CUDA
-		case STARPU_CUDA_RAM:
-			status = cudaMalloc((void **)&addr, (size_t)nx*ny*elemsize);
-			if (!addr || status != cudaSuccess)
-			{
-				if (STARPU_UNLIKELY(status != cudaErrorMemoryAllocation))
-					 STARPU_CUDA_REPORT_ERROR(status);
+	if (!handle)
+		return -ENOMEM;
 
-				fail = 1;
-			}
-			handle = addr;
+	if (starpu_node_get_kind(dst_node) != STARPU_OPENCL_RAM)
+		addr = handle;
 
-			ld = nx;
+	allocated_memory = (size_t)nx*ny*elemsize;
 
-			break;
-#endif
-#ifdef STARPU_USE_OPENCL
-	        case STARPU_OPENCL_RAM:
-			{
-                                int ret;
-				cl_mem mem;
-                                ret = starpu_opencl_allocate_memory(&mem, nx*ny*elemsize, CL_MEM_READ_WRITE);
-				handle = (uintptr_t)mem;
-				if (ret)
-				{
-					fail = 1;
-				}
-				break;
-			}
-#endif
-		default:
-			STARPU_ABORT();
-	}
-
-	if (!fail)
-	{
-		/* allocation succeeded */
-		allocated_memory = (size_t)nx*ny*elemsize;
-
-		/* update the data properly in consequence */
-		matrix_interface->ptr = addr;
-		matrix_interface->dev_handle = handle;
-                matrix_interface->offset = 0;
-		matrix_interface->ld = ld;
-	}
-	else
-	{
-		/* allocation failed */
-		allocated_memory = -ENOMEM;
-	}
+	/* update the data properly in consequence */
+	matrix_interface->ptr = addr;
+	matrix_interface->dev_handle = handle;
+	matrix_interface->offset = 0;
+	matrix_interface->ld = ld;
 
 	return allocated_memory;
 }
@@ -355,37 +306,7 @@ static void free_matrix_buffer_on_node(void *data_interface, uint32_t node)
 {
 	struct starpu_matrix_interface *matrix_interface = (struct starpu_matrix_interface *) data_interface;
 
-#ifdef STARPU_USE_CUDA
-	cudaError_t status;
-#endif
-
-	enum starpu_node_kind kind = starpu_node_get_kind(node);
-	switch(kind)
-	{
-		case STARPU_CPU_RAM:
-			free((void*)matrix_interface->ptr);
-			break;
-#ifdef STARPU_USE_CUDA
-		case STARPU_CUDA_RAM:
-			status = cudaFree((void*)matrix_interface->ptr);
-			if (STARPU_UNLIKELY(status))
-				STARPU_CUDA_REPORT_ERROR(status);
-
-			break;
-#endif
-#ifdef STARPU_USE_OPENCL
-                case STARPU_OPENCL_RAM:
-		{
-			cl_int err;
-			err = clReleaseMemObject((void *)matrix_interface->dev_handle);
-			if (STARPU_UNLIKELY(err != CL_SUCCESS))
-				STARPU_OPENCL_REPORT_ERROR(err);
-                        break;
-		}
-#endif
-		default:
-			STARPU_ABORT();
-	}
+	_starpu_free_buffer_on_node(node, matrix_interface->ptr);
 }
 
 #ifdef STARPU_USE_CUDA

src/datawizard/interfaces/multiformat_interface.c

@@ -239,157 +239,68 @@ uint32_t starpu_multiformat_get_nx(starpu_data_handle_t handle)
 	return multiformat_interface->nx;
 }
 
-static void free_multiformat_buffer_on_node(void *data_interface, uint32_t node)
-{
-	struct starpu_multiformat_interface *multiformat_interface;
-	multiformat_interface = (struct starpu_multiformat_interface *) data_interface;
-	enum starpu_node_kind kind = starpu_node_get_kind(node);
-
-	switch(kind)
-	{
-		case STARPU_CPU_RAM:
-			free(multiformat_interface->cpu_ptr);
-			multiformat_interface->cpu_ptr = NULL;
-			break;
-#ifdef STARPU_USE_CUDA
-		case STARPU_CUDA_RAM:
-		{
-			cudaError_t err;
-			if (multiformat_interface->cpu_ptr)
-			{
-				err = cudaFree(multiformat_interface->cpu_ptr);
-				if (STARPU_UNLIKELY(err != cudaSuccess))
-					STARPU_CUDA_REPORT_ERROR(err);
-				multiformat_interface->cpu_ptr = NULL;
-			}
-			if (multiformat_interface->cuda_ptr)
-			{
-				err = cudaFree(multiformat_interface->cuda_ptr);
-				if (STARPU_UNLIKELY(err != cudaSuccess))
-					STARPU_CUDA_REPORT_ERROR(err);
-				multiformat_interface->cuda_ptr = NULL;
-			}
-			break;
-		}
-#endif
-#ifdef STARPU_USE_OPENCL
-		case STARPU_OPENCL_RAM:
-			if (multiformat_interface->cpu_ptr)
-			{
-				cl_int err = clReleaseMemObject(multiformat_interface->cpu_ptr);
-				if (err != CL_SUCCESS)
-					STARPU_OPENCL_REPORT_ERROR(err);
-				multiformat_interface->cpu_ptr = NULL;
-			}
-			if (multiformat_interface->opencl_ptr)
-			{
-				cl_int err = clReleaseMemObject(multiformat_interface->opencl_ptr);
-				if (err != CL_SUCCESS)
-					STARPU_OPENCL_REPORT_ERROR(err);
-				multiformat_interface->opencl_ptr = NULL;
-			}
-			break;
-#endif
-		default:
-			STARPU_ABORT();
-	}
-}
-
 static ssize_t allocate_multiformat_buffer_on_node(void *data_interface_, uint32_t dst_node)
 {
 	struct starpu_multiformat_interface *multiformat_interface;
 	multiformat_interface = (struct starpu_multiformat_interface *) data_interface_;
-	unsigned fail = 0;
 	uintptr_t addr = 0;
 	ssize_t allocated_memory = 0;
+	size_t size;
 
-	enum starpu_node_kind kind = starpu_node_get_kind(dst_node);
-	switch(kind)
-	{
-		case STARPU_CPU_RAM:
-			allocated_memory = multiformat_interface->nx * multiformat_interface->ops->cpu_elemsize;
-			addr = (uintptr_t)malloc(allocated_memory);
-			if (!addr)
-			{
-				fail = 1;
-			}
-			else
-			{
-				multiformat_interface->cpu_ptr = (void *) addr;
-			}
-
+	size = multiformat_interface->nx * multiformat_interface->ops->cpu_elemsize;
+	allocated_memory += size;
+	addr = _starpu_allocate_buffer_on_node(dst_node, size);
+	if (!addr)
+		goto fail_cpu;
+	multiformat_interface->cpu_ptr = (void *) addr;
 #ifdef STARPU_USE_CUDA
-			multiformat_interface->cuda_ptr = malloc(multiformat_interface->nx * multiformat_interface->ops->cuda_elemsize);
-			STARPU_ASSERT(multiformat_interface->cuda_ptr != NULL);
+	size = multiformat_interface->nx * multiformat_interface->ops->cuda_elemsize;
+	allocated_memory += size;
+	addr = _starpu_allocate_buffer_on_node(dst_node, size);
+	if (!addr)
+		goto fail_cuda;
+	multiformat_interface->cuda_ptr = (void *) addr;
 #endif
 #ifdef STARPU_USE_OPENCL
-			multiformat_interface->opencl_ptr = malloc(multiformat_interface->nx * multiformat_interface->ops->opencl_elemsize);
-			STARPU_ASSERT(multiformat_interface->opencl_ptr != NULL);
+	size = multiformat_interface->nx * multiformat_interface->ops->opencl_elemsize;
+	allocated_memory += size;
+	addr = _starpu_allocate_buffer_on_node(dst_node, size);
+	if (!addr)
+		goto fail_opencl;
+	multiformat_interface->opencl_ptr = (void *) addr;
 #endif
-			break;
+
+	return allocated_memory;
+
+#ifdef STARPU_USE_OPENCL
+fail_opencl:
 #ifdef STARPU_USE_CUDA
-		case STARPU_CUDA_RAM:
-			{
-				allocated_memory = multiformat_interface->nx * multiformat_interface->ops->cuda_elemsize;
-				cudaError_t status = cudaMalloc((void **)&addr, allocated_memory);
-				if (STARPU_UNLIKELY(status))
-				{
-					STARPU_CUDA_REPORT_ERROR(status);
-				}
-				else
-				{
-					multiformat_interface->cuda_ptr = (void *)addr;
-				}
-
-				allocated_memory = multiformat_interface->nx * multiformat_interface->ops->cpu_elemsize;
-				status = cudaMalloc((void **)&multiformat_interface->cpu_ptr, allocated_memory);
-				if (STARPU_UNLIKELY(status != cudaSuccess))
-					STARPU_CUDA_REPORT_ERROR(status);
-				break;
-			}
+	_starpu_free_buffer_on_node(dst_node, (uintptr_t) multiformat_interface->cuda_ptr);
 #endif
-#ifdef STARPU_USE_OPENCL
-		case STARPU_OPENCL_RAM:
-			{
-                                int ret;
-				cl_mem ptr;
-				allocated_memory = multiformat_interface->nx * multiformat_interface->ops->opencl_elemsize;
-                                ret = starpu_opencl_allocate_memory(&ptr, allocated_memory, CL_MEM_READ_WRITE);
-                                addr = (uintptr_t)ptr;
-				if (ret)
-				{
-					fail = 1;
-				}
-				else
-				{
-					multiformat_interface->opencl_ptr = (void *)addr;
-
-				}
-
-				ret = starpu_opencl_allocate_memory(&ptr,
-							multiformat_interface->nx * multiformat_interface->ops->cpu_elemsize,
-							CL_MEM_READ_WRITE);
-				addr = (uintptr_t)ptr;
-				if (ret)
-				{
-					fail = 1;
-				}
-				else
-				{
-					multiformat_interface->cpu_ptr = (void *) addr;
-				}
-				
-				break;
-			}
 #endif
-		default:
-			STARPU_ABORT();
-	}
+#ifdef STARPU_USE_CUDA
+fail_cuda:
+#endif
+	_starpu_free_buffer_on_node(dst_node, (uintptr_t) multiformat_interface->cpu_ptr);
+fail_cpu:
+	return -ENOMEM;
+}
 
-	if (fail)
-		return -ENOMEM;
+static void free_multiformat_buffer_on_node(void *data_interface, uint32_t node)
+{
+	struct starpu_multiformat_interface *multiformat_interface;
+	multiformat_interface = (struct starpu_multiformat_interface *) data_interface;
 
-	return allocated_memory;
+	_starpu_free_buffer_on_node(node, (uintptr_t) multiformat_interface->cpu_ptr);
+	multiformat_interface->cpu_ptr = NULL;
+#ifdef STARPU_USE_CUDA
+	_starpu_free_buffer_on_node(node, (uintptr_t) multiformat_interface->cuda_ptr);
+	multiformat_interface->cuda_ptr = NULL;
+#endif
+#ifdef STARPU_USE_OPENCL
+	_starpu_free_buffer_on_node(node, (uintptr_t) multiformat_interface->opencl_ptr);
+	multiformat_interface->opencl_ptr = NULL;
+#endif
 }
 
 

src/datawizard/interfaces/vector_interface.c

@@ -233,63 +233,22 @@ size_t starpu_vector_get_elemsize(starpu_data_handle_t handle)
 /* returns the size of the allocated area */
 static ssize_t allocate_vector_buffer_on_node(void *data_interface_, uint32_t dst_node)
 {
-	struct starpu_vector_interface *vector_interface = (struct starpu_vector_interface *) data_interface_;
+	uintptr_t addr = 0, handle;
 
-	unsigned fail = 0;
-	uintptr_t addr = 0, handle = 0;
-	ssize_t allocated_memory;
+	struct starpu_vector_interface *vector_interface = (struct starpu_vector_interface *) data_interface_;
 
 	uint32_t nx = vector_interface->nx;
 	size_t elemsize = vector_interface->elemsize;
 
-	enum starpu_node_kind kind = starpu_node_get_kind(dst_node);
-
-#ifdef STARPU_USE_CUDA
-	cudaError_t status;
-#endif
-
-	switch(kind)
-	{
-		case STARPU_CPU_RAM:
-			addr = handle = (uintptr_t)malloc(nx*elemsize);
-			if (!addr)
-				fail = 1;
-			break;
-#ifdef STARPU_USE_CUDA
-		case STARPU_CUDA_RAM:
-			status = cudaMalloc((void **)&addr, nx*elemsize);
-			if (!addr || (status != cudaSuccess))
-			{
-				if (STARPU_UNLIKELY(status != cudaErrorMemoryAllocation))
-					STARPU_CUDA_REPORT_ERROR(status);
-
-				fail = 1;
-			}
-			handle = addr;
-			break;
-#endif
-#ifdef STARPU_USE_OPENCL
-	        case STARPU_OPENCL_RAM:
-			{
-                                int ret;
-				cl_mem mem;
-                                ret = starpu_opencl_allocate_memory(&mem, nx*elemsize, CL_MEM_READ_WRITE);
-				handle = (uintptr_t)mem;
-				if (ret)
-				{
-					fail = 1;
-				}
-				break;
-			}
-#endif
-		default:
-			STARPU_ABORT();
-	}
+	ssize_t allocated_memory;
 
-	if (fail)
+	handle = _starpu_allocate_buffer_on_node(dst_node, nx*elemsize);
+	if (!handle)
 		return -ENOMEM;
 
-	/* allocation succeeded */
+	if (starpu_node_get_kind(dst_node) != STARPU_OPENCL_RAM)
+		addr = handle;
+
 	allocated_memory = nx*elemsize;
 
 	/* update the data properly in consequence */
@@ -304,35 +263,7 @@ static void free_vector_buffer_on_node(void *data_interface, uint32_t node)
 {
 	struct starpu_vector_interface *vector_interface = (struct starpu_vector_interface *) data_interface;
 
-#ifdef STARPU_USE_CUDA
-	cudaError_t cures;
-#endif
-
-	enum starpu_node_kind kind = starpu_node_get_kind(node);
-	switch(kind)
-	{
-		case STARPU_CPU_RAM:
-			free((void*)vector_interface->ptr);
-			break;
-#ifdef STARPU_USE_CUDA
-		case STARPU_CUDA_RAM:
-			cures = cudaFree((void*)vector_interface->ptr);
-			STARPU_ASSERT(cures == cudaSuccess);
-			break;
-#endif
-#ifdef STARPU_USE_OPENCL
-                case STARPU_OPENCL_RAM:
-		{
-			cl_int err;
-			err = clReleaseMemObject((cl_mem)vector_interface->dev_handle);
-			if (STARPU_UNLIKELY(err != CL_SUCCESS))
-				STARPU_OPENCL_REPORT_ERROR(err);
-                        break;
-		}
-#endif
-		default:
-			STARPU_ABORT();
-	}
+	_starpu_free_buffer_on_node(node, vector_interface->ptr);
 }
 
 #ifdef STARPU_USE_CUDA