Use STARPU_UNLIKELY() when checking the return values of the OpenCL functions.

src/core/perfmodel/perfmodel_bus.c

@@ -287,7 +287,7 @@ static void measure_bandwidth_between_host_and_dev_on_cpu_with_opencl(int dev, i
 	cl_ulong maxMemAllocSize;
         starpu_opencl_get_device(dev, &device);
 	err = clGetDeviceInfo(device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof(maxMemAllocSize), &maxMemAllocSize, NULL);
-        if (err != CL_SUCCESS) STARPU_OPENCL_REPORT_ERROR(err);
+        if (STARPU_UNLIKELY(err != CL_SUCCESS)) STARPU_OPENCL_REPORT_ERROR(err);
         if (size > (size_t)maxMemAllocSize/4) size = maxMemAllocSize/4;
 
 	if (_starpu_opencl_get_device_type(dev) == CL_DEVICE_TYPE_CPU)
@@ -303,7 +303,7 @@ static void measure_bandwidth_between_host_and_dev_on_cpu_with_opencl(int dev, i
 	/* Allocate a buffer on the device */
 	cl_mem d_buffer;
 	d_buffer = clCreateBuffer(context, CL_MEM_READ_WRITE, size, NULL, &err);
-	if (err != CL_SUCCESS) STARPU_OPENCL_REPORT_ERROR(err);
+	if (STARPU_UNLIKELY(err != CL_SUCCESS)) STARPU_OPENCL_REPORT_ERROR(err);
 
 	/* hack to avoid third party libs to rebind threads */
 	_starpu_bind_thread_on_cpu(config, cpu);
@@ -317,7 +317,7 @@ static void measure_bandwidth_between_host_and_dev_on_cpu_with_opencl(int dev, i
         /* Fill them */
 	memset(h_buffer, 0, size);
         err = clEnqueueWriteBuffer(queue, d_buffer, CL_TRUE, 0, size, h_buffer, 0, NULL, NULL);
-        if (err != CL_SUCCESS) STARPU_OPENCL_REPORT_ERROR(err);
+        if (STARPU_UNLIKELY(err != CL_SUCCESS)) STARPU_OPENCL_REPORT_ERROR(err);
 	/* hack to avoid third party libs to rebind threads */
 	_starpu_bind_thread_on_cpu(config, cpu);
 
@@ -331,7 +331,7 @@ static void measure_bandwidth_between_host_and_dev_on_cpu_with_opencl(int dev, i
 	for (iter = 0; iter < NITER; iter++)
 	{
                 err = clEnqueueWriteBuffer(queue, d_buffer, CL_TRUE, 0, size, h_buffer, 0, NULL, NULL);
-                if (err != CL_SUCCESS) STARPU_OPENCL_REPORT_ERROR(err);
+                if (STARPU_UNLIKELY(err != CL_SUCCESS)) STARPU_OPENCL_REPORT_ERROR(err);
 	}
 	gettimeofday(&end, NULL);
 	timing = (double)((end.tv_sec - start.tv_sec)*1000000 + (end.tv_usec - start.tv_usec));
@@ -343,7 +343,7 @@ static void measure_bandwidth_between_host_and_dev_on_cpu_with_opencl(int dev, i
 	for (iter = 0; iter < NITER; iter++)
 	{
                 err = clEnqueueReadBuffer(queue, d_buffer, CL_TRUE, 0, size, h_buffer, 0, NULL, NULL);
-                if (err != CL_SUCCESS) STARPU_OPENCL_REPORT_ERROR(err);
+                if (STARPU_UNLIKELY(err != CL_SUCCESS)) STARPU_OPENCL_REPORT_ERROR(err);
 	}
 	gettimeofday(&end, NULL);
 	timing = (double)((end.tv_sec - start.tv_sec)*1000000 + (end.tv_usec - start.tv_usec));

src/datawizard/copy_driver.c

@@ -376,10 +376,10 @@ void _starpu_driver_wait_request_completion(struct _starpu_async_channel *async_
 		if ((*async_channel).event.opencl_event == NULL)
 			STARPU_ABORT();
 		err = clWaitForEvents(1, &((*async_channel).event.opencl_event));
-		if (err != CL_SUCCESS)
+		if (STARPU_UNLIKELY(err != CL_SUCCESS))
 			STARPU_OPENCL_REPORT_ERROR(err);
 		err = clReleaseEvent((*async_channel).event.opencl_event);
-		if (err != CL_SUCCESS)
+		if (STARPU_UNLIKELY(err != CL_SUCCESS))
 			STARPU_OPENCL_REPORT_ERROR(err);
 	      break;
 	}
@@ -423,7 +423,7 @@ unsigned _starpu_driver_test_request_completion(struct _starpu_async_channel *as
 		cl_event opencl_event = (*async_channel).event.opencl_event;
 		if (opencl_event == NULL) STARPU_ABORT();
 		cl_int err = clGetEventInfo(opencl_event, CL_EVENT_COMMAND_EXECUTION_STATUS, sizeof(event_status), &event_status, NULL);
-		if (err != CL_SUCCESS)
+		if (STARPU_UNLIKELY(err != CL_SUCCESS))
 			STARPU_OPENCL_REPORT_ERROR(err);
 		if (event_status < 0)
 			STARPU_OPENCL_REPORT_ERROR(event_status);

src/drivers/opencl/driver_opencl.c

@@ -72,7 +72,7 @@ static void limit_gpu_mem_if_needed(int devid)
 	/* Request the size of the current device's memory */
 	cl_ulong totalGlobalMem;
 	err = clGetDeviceInfo(devices[devid], CL_DEVICE_GLOBAL_MEM_SIZE, sizeof(totalGlobalMem), &totalGlobalMem, NULL);
-	if (err != CL_SUCCESS)
+	if (STARPU_UNLIKELY(err != CL_SUCCESS))
 		STARPU_OPENCL_REPORT_ERROR(err);
 
 	/* How much memory to waste ? */
@@ -84,7 +84,7 @@ static void limit_gpu_mem_if_needed(int devid)
 
 	/* Allocate a large buffer to waste memory and constraint the amount of available memory. */
 	wasted_memory[devid] = clCreateBuffer(contexts[devid], CL_MEM_READ_WRITE, to_waste, NULL, &err);
-	if (err != CL_SUCCESS) STARPU_OPENCL_REPORT_ERROR(err);
+	if (STARPU_UNLIKELY(err != CL_SUCCESS)) STARPU_OPENCL_REPORT_ERROR(err);
 }
 
 static void unlimit_gpu_mem_if_needed(int devid)
@@ -92,7 +92,7 @@ static void unlimit_gpu_mem_if_needed(int devid)
 	if (wasted_memory[devid])
 	{
 		cl_int err = clReleaseMemObject(wasted_memory[devid]);
-		if (err != CL_SUCCESS)
+		if (STARPU_UNLIKELY(err != CL_SUCCESS))
 			STARPU_OPENCL_REPORT_ERROR(err);
 		wasted_memory[devid] = NULL;
 	}
@@ -106,7 +106,7 @@ size_t starpu_opencl_get_global_mem_size(int devid)
 
 	/* Request the size of the current device's memory */
 	err = clGetDeviceInfo(devices[devid], CL_DEVICE_GLOBAL_MEM_SIZE, sizeof(totalGlobalMem), &totalGlobalMem, NULL);
-	if (err != CL_SUCCESS)
+	if (STARPU_UNLIKELY(err != CL_SUCCESS))
 		STARPU_OPENCL_REPORT_ERROR(err);
 
 	return (size_t)totalGlobalMem;
@@ -153,20 +153,20 @@ cl_int _starpu_opencl_init_context(int devid)
         // Create a compute context
 	err = 0;
         contexts[devid] = clCreateContext(NULL, 1, &devices[devid], NULL, NULL, &err);
-        if (err != CL_SUCCESS) STARPU_OPENCL_REPORT_ERROR(err);
+        if (STARPU_UNLIKELY(err != CL_SUCCESS)) STARPU_OPENCL_REPORT_ERROR(err);
 
         // Create execution queue for the given device
         queues[devid] = clCreateCommandQueue(contexts[devid], devices[devid], 0, &err);
-        if (err != CL_SUCCESS) STARPU_OPENCL_REPORT_ERROR(err);
+        if (STARPU_UNLIKELY(err != CL_SUCCESS)) STARPU_OPENCL_REPORT_ERROR(err);
 
         // Create transfer queue for the given device
         cl_command_queue_properties props;
         err = clGetDeviceInfo(devices[devid], CL_DEVICE_QUEUE_PROPERTIES, sizeof(props), &props, NULL);
-	if (err != CL_SUCCESS)
+	if (STARPU_UNLIKELY(err != CL_SUCCESS))
 		STARPU_OPENCL_REPORT_ERROR(err);
         props &= CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE;
         transfer_queues[devid] = clCreateCommandQueue(contexts[devid], devices[devid], props, &err);
-        if (err != CL_SUCCESS) STARPU_OPENCL_REPORT_ERROR(err);
+        if (STARPU_UNLIKELY(err != CL_SUCCESS)) STARPU_OPENCL_REPORT_ERROR(err);
 
 	_STARPU_PTHREAD_MUTEX_UNLOCK(&big_lock);
 
@@ -186,13 +186,13 @@ cl_int _starpu_opencl_deinit_context(int devid)
 	unlimit_gpu_mem_if_needed(devid);
 
         err = clReleaseContext(contexts[devid]);
-        if (err != CL_SUCCESS) STARPU_OPENCL_REPORT_ERROR(err);
+        if (STARPU_UNLIKELY(err != CL_SUCCESS)) STARPU_OPENCL_REPORT_ERROR(err);
 
         err = clReleaseCommandQueue(queues[devid]);
-        if (err != CL_SUCCESS) STARPU_OPENCL_REPORT_ERROR(err);
+        if (STARPU_UNLIKELY(err != CL_SUCCESS)) STARPU_OPENCL_REPORT_ERROR(err);
 
         err = clReleaseCommandQueue(transfer_queues[devid]);
-        if (err != CL_SUCCESS) STARPU_OPENCL_REPORT_ERROR(err);
+        if (STARPU_UNLIKELY(err != CL_SUCCESS)) STARPU_OPENCL_REPORT_ERROR(err);
 
         contexts[devid] = NULL;
 
@@ -346,7 +346,7 @@ void _starpu_opencl_init(void)
 		if (starpu_get_env_number("STARPU_OPENCL_ON_CPUS") > 0)
 		     device_type |= CL_DEVICE_TYPE_CPU;
                 err = clGetPlatformIDs(_STARPU_OPENCL_PLATFORM_MAX, platform_id, &nb_platforms);
-                if (err != CL_SUCCESS) nb_platforms=0;
+                if (STARPU_UNLIKELY(err != CL_SUCCESS)) nb_platforms=0;
                 _STARPU_DEBUG("Platforms detected: %u\n", nb_platforms);
 
                 // Get devices
@@ -367,7 +367,7 @@ void _starpu_opencl_init(void)
 				else
 				{
 					err = clGetPlatformInfo(platform_id[i], CL_PLATFORM_VENDOR, 1024, vendor, NULL);
-					if (err != CL_SUCCESS)
+					if (STARPU_UNLIKELY(err != CL_SUCCESS))
 					{
 						STARPU_OPENCL_REPORT_ERROR_WITH_MSG("clGetPlatformInfo VENDOR", err);
 						platform_valid = 0;
@@ -392,7 +392,7 @@ void _starpu_opencl_init(void)
 					}
 					else
 					{
-						if (err != CL_SUCCESS) STARPU_OPENCL_REPORT_ERROR(err);
+						if (STARPU_UNLIKELY(err != CL_SUCCESS)) STARPU_OPENCL_REPORT_ERROR(err);
 						_STARPU_DEBUG("  %u devices detected\n", num);
 						nb_devices += num;
 					}
@@ -602,7 +602,7 @@ static unsigned _starpu_opencl_get_device_name(int dev, char *name, int lname)
 
 	// Get device name
 	err = clGetDeviceInfo(devices[dev], CL_DEVICE_NAME, lname, name, NULL);
-	if (err != CL_SUCCESS) STARPU_OPENCL_REPORT_ERROR(err);
+	if (STARPU_UNLIKELY(err != CL_SUCCESS)) STARPU_OPENCL_REPORT_ERROR(err);
 
 	_STARPU_DEBUG("Device %d : [%s]\n", dev, name);
 	return EXIT_SUCCESS;
@@ -627,7 +627,7 @@ cl_device_type _starpu_opencl_get_device_type(int devid)
 		_starpu_opencl_init();
 
 	err = clGetDeviceInfo(devices[devid], CL_DEVICE_TYPE, sizeof(cl_device_type), &type, NULL);
-	if (err != CL_SUCCESS)
+	if (STARPU_UNLIKELY(err != CL_SUCCESS))
 		STARPU_OPENCL_REPORT_ERROR(err);
 
 	return type;

src/drivers/opencl/driver_opencl_utils.c

@@ -118,7 +118,7 @@ cl_int starpu_opencl_load_kernel(cl_kernel *kernel, cl_command_queue *queue, str
 
         // Create the compute kernel in the program we wish to run
         *kernel = clCreateKernel(program, kernel_name, &err);
-	if (err != CL_SUCCESS)
+	if (STARPU_UNLIKELY(err != CL_SUCCESS))
 		STARPU_OPENCL_REPORT_ERROR(err);
 
 	return CL_SUCCESS;
@@ -129,7 +129,7 @@ cl_int starpu_opencl_release_kernel(cl_kernel kernel)
 	cl_int err;
 
 	err = clReleaseKernel(kernel);
-	if (err != CL_SUCCESS)
+	if (STARPU_UNLIKELY(err != CL_SUCCESS))
 		STARPU_OPENCL_REPORT_ERROR(err);
 
         return CL_SUCCESS;
@@ -235,7 +235,7 @@ int _starpu_opencl_get_binary_name(char *binary_file_name, size_t maxlen, const
 	if (p == NULL) p=binary_file_name + strlen(binary_file_name);
 
 	err = clGetDeviceInfo(device, CL_DEVICE_VENDOR_ID, sizeof(vendor_id), &vendor_id, NULL);
-	if (err != CL_SUCCESS) STARPU_OPENCL_REPORT_ERROR(err);
+	if (STARPU_UNLIKELY(err != CL_SUCCESS)) STARPU_OPENCL_REPORT_ERROR(err);
 
 	sprintf(p, ".%s.vendor_id_%d_device_id_%d", _starpu_opencl_get_device_type_as_string(dev), (int)vendor_id, dev);
 
@@ -310,14 +310,14 @@ int _starpu_opencl_compile_or_load_opencl_from_string(const char *opencl_program
 			FILE *fh;
 
 			err = _starpu_opencl_get_binary_name(binary_file_name, 1024, source_file_name, dev, device);
-			if (err != CL_SUCCESS) STARPU_OPENCL_REPORT_ERROR(err);
+			if (STARPU_UNLIKELY(err != CL_SUCCESS)) STARPU_OPENCL_REPORT_ERROR(err);
 
 			err = clGetProgramInfo(program, CL_PROGRAM_BINARY_SIZES, sizeof(size_t), &binary_len, NULL);
-			if (err != CL_SUCCESS) STARPU_OPENCL_REPORT_ERROR(err);
+			if (STARPU_UNLIKELY(err != CL_SUCCESS)) STARPU_OPENCL_REPORT_ERROR(err);
 			binary = malloc(binary_len);
 
 			err = clGetProgramInfo(program, CL_PROGRAM_BINARIES, sizeof(binary), &binary, NULL);
-			if (err != CL_SUCCESS) STARPU_OPENCL_REPORT_ERROR(err);
+			if (STARPU_UNLIKELY(err != CL_SUCCESS)) STARPU_OPENCL_REPORT_ERROR(err);
 
 			fh = fopen(binary_file_name, "w");
 			if (fh == NULL)
@@ -431,7 +431,7 @@ int starpu_opencl_load_binary_opencl(const char *kernel_id, struct starpu_opencl
 
 		// Load the binary buffer
 		err = _starpu_opencl_get_binary_name(binary_file_name, 1024, kernel_id, dev, device);
-		if (err != CL_SUCCESS) STARPU_OPENCL_REPORT_ERROR(err);
+		if (STARPU_UNLIKELY(err != CL_SUCCESS)) STARPU_OPENCL_REPORT_ERROR(err);
 		binary = _starpu_opencl_load_program_binary(binary_file_name, &length);
 
                 // Create the compute program from the binary buffer
@@ -486,7 +486,7 @@ int starpu_opencl_unload_opencl(struct starpu_opencl_program *opencl_programs)
 		{
 			cl_int err;
 			err = clReleaseProgram(opencl_programs->programs[dev]);
-			if (err != CL_SUCCESS)
+			if (STARPU_UNLIKELY(err != CL_SUCCESS))
 				STARPU_OPENCL_REPORT_ERROR(err);
 		}
         }
@@ -719,7 +719,7 @@ int starpu_opencl_set_kernel_args(cl_int *error, cl_kernel *kernel, ...)
 
 		cl_mem *ptr = va_arg(ap, cl_mem *);
 		int err = clSetKernelArg(*kernel, i, size, ptr);
-		if (err != CL_SUCCESS)
+		if (STARPU_UNLIKELY(err != CL_SUCCESS))
 		{
 			*error = err;
 			break;