move C99-ism from cuda/opencl helper headers to libstarpu itself.

include/starpu_cuda.h

@@ -29,55 +29,13 @@
 extern "C" {
 #endif
 
-#if defined(__CUDACC__) && defined(STARPU_HAVE_WINDOWS)
-#define STARPU_CUBLAS_OOPS() do { \
-		printf("oops  %s \n", errormsg); \
-		*(int*)NULL = 0; \
-	} while (0);
-#else
-#define STARPU_CUBLAS_OOPS() do { \
-		printf("oops  in %s ... %s \n", __starpu_func__, errormsg); \
-		assert(0);						\
-	} while (0);
-#endif
-
-#define STARPU_CUBLAS_REPORT_ERROR(status) 					\
-	do {								\
-		char *errormsg;						\
-		switch (status) {					\
-			case CUBLAS_STATUS_SUCCESS:			\
-				errormsg = "success";			\
-				break;					\
-			case CUBLAS_STATUS_NOT_INITIALIZED:		\
-				errormsg = "not initialized";		\
-				break;					\
-			case CUBLAS_STATUS_ALLOC_FAILED:		\
-				errormsg = "alloc failed";		\
-				break;					\
-			case CUBLAS_STATUS_INVALID_VALUE:		\
-				errormsg = "invalid value";		\
-				break;					\
-			case CUBLAS_STATUS_ARCH_MISMATCH:		\
-				errormsg = "arch mismatch";		\
-				break;					\
-			case CUBLAS_STATUS_EXECUTION_FAILED:		\
-				errormsg = "execution failed";		\
-				break;					\
-			case CUBLAS_STATUS_INTERNAL_ERROR:		\
-				errormsg = "internal error";		\
-				break;					\
-			default:					\
-				errormsg = "unknown error";		\
-				break;					\
-		}							\
-		STARPU_CUBLAS_OOPS();					\
-	} while (0)
+void starpu_cublas_report_error(const char *func, cublasStatus status);
+#define STARPU_CUBLAS_REPORT_ERROR(status) \
+	starpu_cublas_report_error(__starpu_func__, status)
 
-#define STARPU_CUDA_REPORT_ERROR(status) 				\
-	do {								\
-		const char *errormsg = cudaGetErrorString(status);	\
-		STARPU_CUBLAS_OOPS();					\
-	} while (0)
+void starpu_cuda_report_error(const char *func, CUresult status);
+#define STARPU_CUDA_REPORT_ERROR(status) \
+	starpu_cuda_report_error(__starpu_func__, status)
 
 cudaStream_t starpu_cuda_get_local_stream(void);
 

include/starpu_opencl.h

@@ -30,160 +30,17 @@
 extern "C" {
 #endif
 
-#define STARPU_OPENCL_DISPLAY_ERROR(status)                                     \
-	do {                                                            \
-                const char *errormsg;                                   \
-		switch (status) {                                       \
-		case CL_SUCCESS:                                        \
-			errormsg = "success";                           \
-			break;                                          \
-		case CL_DEVICE_NOT_FOUND:				\
-			errormsg = "Device not found";                  \
-			break;                                          \
-		case CL_DEVICE_NOT_AVAILABLE:				\
-			errormsg = "Device not available";              \
-			break;                                          \
-		case CL_COMPILER_NOT_AVAILABLE:				\
-			errormsg = "Compiler not available";            \
-			break;                                          \
-		case CL_MEM_OBJECT_ALLOCATION_FAILURE:			\
-			errormsg = "Memory object allocation failure";  \
-			break;                                          \
-		case CL_OUT_OF_RESOURCES:				\
-			errormsg = "Out of resources";                  \
-			break;                                          \
-		case CL_OUT_OF_HOST_MEMORY:				\
-			errormsg = "Out of host memory";                \
-			break;                                          \
-		case CL_PROFILING_INFO_NOT_AVAILABLE:			\
-			errormsg = "Profiling info not available";      \
-			break;                                          \
-		case CL_MEM_COPY_OVERLAP:				\
-			errormsg = "Memory copy overlap";               \
-			break;                                          \
-		case CL_IMAGE_FORMAT_MISMATCH:				\
-			errormsg = "Image format mismatch";             \
-			break;                                          \
-		case CL_IMAGE_FORMAT_NOT_SUPPORTED:			\
-			errormsg = "Image format not supported";        \
-			break;                                          \
-		case CL_BUILD_PROGRAM_FAILURE:				\
-			errormsg = "Build program failure";             \
-			break;                                          \
-		case CL_MAP_FAILURE:				        \
-			errormsg = "Map failure";                       \
-			break;                                          \
-		case CL_INVALID_VALUE:				        \
-			errormsg = "Invalid value";                     \
-			break;                                          \
-		case CL_INVALID_DEVICE_TYPE:				\
-			errormsg = "Invalid device type";               \
-			break;                                          \
-		case CL_INVALID_PLATFORM:				\
-			errormsg = "Invalid platform";                  \
-			break;                                          \
-		case CL_INVALID_DEVICE:				        \
-			errormsg = "Invalid device";                    \
-			break;                                          \
-		case CL_INVALID_CONTEXT:				\
-			errormsg = "Invalid context";                   \
-			break;                                          \
-		case CL_INVALID_QUEUE_PROPERTIES:			\
-			errormsg = "Invalid queue properties";          \
-			break;                                          \
-		case CL_INVALID_COMMAND_QUEUE:				\
-			errormsg = "Invalid command queue";             \
-			break;                                          \
-		case CL_INVALID_HOST_PTR:				\
-			errormsg = "Invalid host pointer";              \
-			break;                                          \
-		case CL_INVALID_MEM_OBJECT:				\
-			errormsg = "Invalid memory object";             \
-			break;                                          \
-		case CL_INVALID_IMAGE_FORMAT_DESCRIPTOR:		\
-			errormsg = "Invalid image format descriptor";   \
-			break;                                          \
-		case CL_INVALID_IMAGE_SIZE:				\
-			errormsg = "Invalid image size";                \
-			break;                                          \
-		case CL_INVALID_SAMPLER:				\
-			errormsg = "Invalid sampler";                   \
-			break;                                          \
-		case CL_INVALID_BINARY:				        \
-			errormsg = "Invalid binary";                    \
-			break;                                          \
-		case CL_INVALID_BUILD_OPTIONS:				\
-			errormsg = "Invalid build options";             \
-			break;                                          \
-		case CL_INVALID_PROGRAM:				\
-			errormsg = "Invalid program";                   \
-			break;                                          \
-		case CL_INVALID_PROGRAM_EXECUTABLE:			\
-			errormsg = "Invalid program executable";        \
-			break;                                          \
-		case CL_INVALID_KERNEL_NAME:				\
-			errormsg = "Invalid kernel name";               \
-			break;                                          \
-		case CL_INVALID_KERNEL_DEFINITION:			\
-			errormsg = "Invalid kernel definition";         \
-			break;                                          \
-		case CL_INVALID_KERNEL:				        \
-			errormsg = "Invalid kernel";                    \
-			break;                                          \
-		case CL_INVALID_ARG_INDEX:				\
-			errormsg = "Invalid argument index";            \
-			break;                                          \
-		case CL_INVALID_ARG_VALUE:				\
-			errormsg = "Invalid argument value";            \
-			break;                                          \
-		case CL_INVALID_ARG_SIZE:				\
-			errormsg = "Invalid argument size";             \
-			break;                                          \
-		case CL_INVALID_KERNEL_ARGS:				\
-			errormsg = "Invalid kernel arguments";          \
-			break;                                          \
-		case CL_INVALID_WORK_DIMENSION:				\
-			errormsg = "Invalid work dimension";            \
-			break;                                          \
-		case CL_INVALID_WORK_GROUP_SIZE:			\
-			errormsg = "Invalid work group size";           \
-			break;                                          \
-		case CL_INVALID_WORK_ITEM_SIZE:				\
-			errormsg = "Invalid work item size";            \
-			break;                                          \
-		case CL_INVALID_GLOBAL_OFFSET:				\
-			errormsg = "Invalid global offset";             \
-			break;                                          \
-		case CL_INVALID_EVENT_WAIT_LIST:			\
-			errormsg = "Invalid event wait list";           \
-			break;                                          \
-		case CL_INVALID_EVENT:				        \
-			errormsg = "Invalid event";                     \
-			break;                                          \
-		case CL_INVALID_OPERATION:				\
-			errormsg = "Invalid operation";                 \
-			break;                                          \
-		case CL_INVALID_GL_OBJECT:				\
-			errormsg = "Invalid GL object";                 \
-			break;                                          \
-		case CL_INVALID_BUFFER_SIZE:				\
-			errormsg = "Invalid buffer size";               \
-			break;                                          \
-		case CL_INVALID_MIP_LEVEL:				\
-			errormsg = "Invalid MIP level";                 \
-			break;                                          \
-		default:						\
-			errormsg = "unknown error";			\
-			break;			                        \
-		}                                                       \
-		printf("oops in %s ... <%s> (%d) \n", __starpu_func__, errormsg, status); \
-	} while (0)
+void starpu_opencl_display_error(const char *func, cl_int status);
+#define STARPU_OPENCL_DISPLAY_ERROR(status) \
+	starpu_opencl_display_error(__starpu_func__, status)
 
-#define STARPU_OPENCL_REPORT_ERROR(status)                                     \
-	do {                                                            \
-        	STARPU_OPENCL_DISPLAY_ERROR(status);			\
-		assert(0);	                                        \
-	} while (0)
+static inline void starpu_opencl_report_error(const char *func, cl_int status)
+{
+        starpu_opencl_display_error(func, status);
+        assert(0);
+}
+#define STARPU_OPENCL_REPORT_ERROR(status)                              \
+	starpu_opencl_display_error(__starpu_func__, status)
 
 struct starpu_opencl_program {
         cl_program programs[STARPU_MAXOPENCLDEVS];

src/drivers/cuda/driver_cuda.c

@@ -348,3 +348,43 @@ void *_starpu_cuda_worker(void *arg)
 	return NULL;
 
 }
+
+void starpu_cublas_report_error(const char *func, cublasStatus status)
+{
+	char *errormsg;
+	switch (status) {
+		case CUBLAS_STATUS_SUCCESS:
+			errormsg = "success";
+			break;
+		case CUBLAS_STATUS_NOT_INITIALIZED:
+			errormsg = "not initialized";
+			break;
+		case CUBLAS_STATUS_ALLOC_FAILED:
+			errormsg = "alloc failed";
+			break;
+		case CUBLAS_STATUS_INVALID_VALUE:
+			errormsg = "invalid value";
+			break;
+		case CUBLAS_STATUS_ARCH_MISMATCH:
+			errormsg = "arch mismatch";
+			break;
+		case CUBLAS_STATUS_EXECUTION_FAILED:
+			errormsg = "execution failed";
+			break;
+		case CUBLAS_STATUS_INTERNAL_ERROR:
+			errormsg = "internal error";
+			break;
+		default:
+			errormsg = "unknown error";
+			break;
+	}
+	printf("oops in %s ... %s \n", func, errormsg);
+	assert(0);
+}
+
+void starpu_cuda_report_error(const char *func, CUresult status)
+{
+	const char *errormsg = cudaGetErrorString(status);
+	printf("oops in %s ... %s \n", func, errormsg);
+	assert(0);
+}

src/drivers/opencl/driver_opencl_utils.c

@@ -250,3 +250,152 @@ int starpu_opencl_collect_stats(cl_event event __attribute__((unused)))
 
 	return 0;
 }
+
+void starpu_opencl_display_error(const char *func, cl_int status)
+{
+	const char *errormsg;
+	switch (status) {
+	case CL_SUCCESS:
+		errormsg = "success";
+		break;
+	case CL_DEVICE_NOT_FOUND:
+		errormsg = "Device not found";
+		break;
+	case CL_DEVICE_NOT_AVAILABLE:
+		errormsg = "Device not available";
+		break;
+	case CL_COMPILER_NOT_AVAILABLE:
+		errormsg = "Compiler not available";
+		break;
+	case CL_MEM_OBJECT_ALLOCATION_FAILURE:
+		errormsg = "Memory object allocation failure";
+		break;
+	case CL_OUT_OF_RESOURCES:
+		errormsg = "Out of resources";
+		break;
+	case CL_OUT_OF_HOST_MEMORY:
+		errormsg = "Out of host memory";
+		break;
+	case CL_PROFILING_INFO_NOT_AVAILABLE:
+		errormsg = "Profiling info not available";
+		break;
+	case CL_MEM_COPY_OVERLAP:
+		errormsg = "Memory copy overlap";
+		break;
+	case CL_IMAGE_FORMAT_MISMATCH:
+		errormsg = "Image format mismatch";
+		break;
+	case CL_IMAGE_FORMAT_NOT_SUPPORTED:
+		errormsg = "Image format not supported";
+		break;
+	case CL_BUILD_PROGRAM_FAILURE:
+		errormsg = "Build program failure";
+		break;
+	case CL_MAP_FAILURE:
+		errormsg = "Map failure";
+		break;
+	case CL_INVALID_VALUE:
+		errormsg = "Invalid value";
+		break;
+	case CL_INVALID_DEVICE_TYPE:
+		errormsg = "Invalid device type";
+		break;
+	case CL_INVALID_PLATFORM:
+		errormsg = "Invalid platform";
+		break;
+	case CL_INVALID_DEVICE:
+		errormsg = "Invalid device";
+		break;
+	case CL_INVALID_CONTEXT:
+		errormsg = "Invalid context";
+		break;
+	case CL_INVALID_QUEUE_PROPERTIES:
+		errormsg = "Invalid queue properties";
+		break;
+	case CL_INVALID_COMMAND_QUEUE:
+		errormsg = "Invalid command queue";
+		break;
+	case CL_INVALID_HOST_PTR:
+		errormsg = "Invalid host pointer";
+		break;
+	case CL_INVALID_MEM_OBJECT:
+		errormsg = "Invalid memory object";
+		break;
+	case CL_INVALID_IMAGE_FORMAT_DESCRIPTOR:
+		errormsg = "Invalid image format descriptor";
+		break;
+	case CL_INVALID_IMAGE_SIZE:
+		errormsg = "Invalid image size";
+		break;
+	case CL_INVALID_SAMPLER:
+		errormsg = "Invalid sampler";
+		break;
+	case CL_INVALID_BINARY:
+		errormsg = "Invalid binary";
+		break;
+	case CL_INVALID_BUILD_OPTIONS:
+		errormsg = "Invalid build options";
+		break;
+	case CL_INVALID_PROGRAM:
+		errormsg = "Invalid program";
+		break;
+	case CL_INVALID_PROGRAM_EXECUTABLE:
+		errormsg = "Invalid program executable";
+		break;
+	case CL_INVALID_KERNEL_NAME:
+		errormsg = "Invalid kernel name";
+		break;
+	case CL_INVALID_KERNEL_DEFINITION:
+		errormsg = "Invalid kernel definition";
+		break;
+	case CL_INVALID_KERNEL:
+		errormsg = "Invalid kernel";
+		break;
+	case CL_INVALID_ARG_INDEX:
+		errormsg = "Invalid argument index";
+		break;
+	case CL_INVALID_ARG_VALUE:
+		errormsg = "Invalid argument value";
+		break;
+	case CL_INVALID_ARG_SIZE:
+		errormsg = "Invalid argument size";
+		break;
+	case CL_INVALID_KERNEL_ARGS:
+		errormsg = "Invalid kernel arguments";
+		break;
+	case CL_INVALID_WORK_DIMENSION:
+		errormsg = "Invalid work dimension";
+		break;
+	case CL_INVALID_WORK_GROUP_SIZE:
+		errormsg = "Invalid work group size";
+		break;
+	case CL_INVALID_WORK_ITEM_SIZE:
+		errormsg = "Invalid work item size";
+		break;
+	case CL_INVALID_GLOBAL_OFFSET:
+		errormsg = "Invalid global offset";
+		break;
+	case CL_INVALID_EVENT_WAIT_LIST:
+		errormsg = "Invalid event wait list";
+		break;
+	case CL_INVALID_EVENT:
+		errormsg = "Invalid event";
+		break;
+	case CL_INVALID_OPERATION:
+		errormsg = "Invalid operation";
+		break;
+	case CL_INVALID_GL_OBJECT:
+		errormsg = "Invalid GL object";
+		break;
+	case CL_INVALID_BUFFER_SIZE:
+		errormsg = "Invalid buffer size";
+		break;
+	case CL_INVALID_MIP_LEVEL:
+		errormsg = "Invalid MIP level";
+		break;
+	default:
+		errormsg = "unknown error";
+		break;
+	}
+	printf("oops in %s ... <%s> (%d) \n", func, errormsg, status);
+}