Dolphin now uses the first OpenCL device found on the system.

Added cast in TextureDecoder.cl to satisfy the OpenCL compiler (thanks, Orphis).

git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@4718 8ced0084-cf51-0410-be5f-012b33b47a6e

1 files changed, 126 insertions, 89 deletions

diff --git a/Source/Core/Common/Src/OpenCL.cpp b/Source/Core/Common/Src/OpenCL.cpp
index 37ffb9d028..7eaa44355f 100644
--- a/Source/Core/Common/Src/OpenCL.cpp
+++ b/Source/Core/Common/Src/OpenCL.cpp
@@ -42,34 +42,74 @@ bool Initialize()
 		return false;

 	int err;                            // error code returned from api calls

 	

-            

-    // Connect to a compute device

-    //

-    int gpu = 1; // I think we should use CL_DEVICE_TYPE_ALL

-    err = clGetDeviceIDs(NULL, gpu ? CL_DEVICE_TYPE_GPU : CL_DEVICE_TYPE_CPU, 1, &device_id, NULL);

-    if (err != CL_SUCCESS)

-    {

-        HandleCLError(err, "Failed to create a device group!");

-        return false;

-    }

-  

-    // Create a compute context 

-    //

-    g_context = clCreateContext(0, 1, &device_id, NULL, NULL, &err);

-    if (!g_context)

-    {

-        HandleCLError(err, "Failed to create a compute context!");

-        return false;

-    }

-

-    // Create a command commands

-    //

-    g_cmdq = clCreateCommandQueue(g_context, device_id, 0, &err);

-    if (!g_cmdq)

-    {

-        HandleCLError(err, "Failed to create a command commands!");

-        return false;

-    }

+	// Connect to a compute device

+	cl_uint numPlatforms;

+	cl_platform_id platform = NULL;

+	err = clGetPlatformIDs(0, NULL, &numPlatforms);

+

+	if (err != CL_SUCCESS)

+	{

+		HandleCLError(err, "clGetPlatformIDs failed.");

+		return false;

+	}

+

+	if (0 < numPlatforms) 

+	{

+		cl_platform_id* platforms = new cl_platform_id[numPlatforms];

+		err = clGetPlatformIDs(numPlatforms, platforms, NULL);

+

+		if (err != CL_SUCCESS)

+		{

+			HandleCLError(err, "clGetPlatformIDs failed.");

+			return false;

+		}

+

+		char pbuf[100];

+		err = clGetPlatformInfo(platforms[0], CL_PLATFORM_VENDOR, sizeof(pbuf), pbuf, NULL);

+

+		if (err != CL_SUCCESS)

+		{

+			HandleCLError(err, "clGetPlatformInfo failed.");

+			return false;

+		}

+

+		platform = platforms[0];

+		delete[] platforms;

+	}

+	else

+	{

+		PanicAlert("No OpenCL platform found.");

+		return false;

+	}

+

+	cl_context_properties cps[3] = {CL_CONTEXT_PLATFORM, (cl_context_properties)platform, 0};

+

+	cl_context_properties* cprops = (NULL == platform) ? NULL : cps;

+

+	int gpu = 1; // I think we should use CL_DEVICE_TYPE_ALL

+

+	err = clGetDeviceIDs(platform, gpu ? CL_DEVICE_TYPE_GPU : CL_DEVICE_TYPE_CPU, 1, &device_id, NULL);

+	if (err != CL_SUCCESS)

+	{

+		HandleCLError(err, "Failed to create a device group!");

+		return false;

+	}

+

+	// Create a compute context 

+	g_context = clCreateContext(cprops, 1, &device_id, NULL, NULL, &err);

+	if (!g_context)

+	{

+		HandleCLError(err, "Failed to create a compute context!");

+		return false;

+	}

+

+	// Create a command commands

+	g_cmdq = clCreateCommandQueue(g_context, device_id, 0, &err);

+	if (!g_cmdq)

+	{

+		HandleCLError(err, "Failed to create a command commands!");

+		return false;

+	}

 

 	NOTICE_LOG(COMMON, "Initialized OpenCL!");

 	g_bInitialized = true;

@@ -103,13 +143,12 @@ cl_program CompileProgram(const char *Kernel)
 	}

 

 	// Build the program executable

-	//

 	err = clBuildProgram(program , 0, NULL, NULL, NULL, NULL);

 	if(err != CL_SUCCESS) {

 		char *errors[16384] = {0};

 		err = clGetProgramBuildInfo(program, OpenCL::device_id, CL_PROGRAM_BUILD_LOG, sizeof(errors),

 									errors, NULL);

-		PanicAlert("Error log:\n%s\n", errors);

+		ERROR_LOG(COMMON, "Error log:\n%s\n", errors);

 		return NULL;

 	}

 

@@ -121,8 +160,8 @@ cl_kernel CompileKernel(cl_program program, const char *Function)
 {

 	u32 compileStart = timeGetTime();

 	int err;

+

 	// Create the compute kernel in the program we wish to run

-	//

 	cl_kernel kernel = clCreateKernel(program, Function, &err);

 	if (!kernel || err != CL_SUCCESS)

 	{

@@ -148,65 +187,63 @@ void HandleCLError(cl_int error, char* str)
 {

 #if defined(HAVE_OPENCL) && HAVE_OPENCL

 

-    char* name;

-    switch(error)

-    {

+	char* name;

+	switch(error)

+	{

 #define CL_ERROR(x) case (x): name = #x; break

-        CL_ERROR(CL_SUCCESS);

-        CL_ERROR(CL_DEVICE_NOT_FOUND);

-        CL_ERROR(CL_DEVICE_NOT_AVAILABLE);

-        CL_ERROR(CL_COMPILER_NOT_AVAILABLE);

-        CL_ERROR(CL_MEM_OBJECT_ALLOCATION_FAILURE);

-        CL_ERROR(CL_OUT_OF_RESOURCES);

-        CL_ERROR(CL_OUT_OF_HOST_MEMORY);

-        CL_ERROR(CL_PROFILING_INFO_NOT_AVAILABLE);

-        CL_ERROR(CL_MEM_COPY_OVERLAP);

-        CL_ERROR(CL_IMAGE_FORMAT_MISMATCH);

-        CL_ERROR(CL_IMAGE_FORMAT_NOT_SUPPORTED);

-        CL_ERROR(CL_BUILD_PROGRAM_FAILURE);

-        CL_ERROR(CL_MAP_FAILURE);

-        CL_ERROR(CL_INVALID_VALUE);

-        CL_ERROR(CL_INVALID_DEVICE_TYPE);

-        CL_ERROR(CL_INVALID_PLATFORM);

-        CL_ERROR(CL_INVALID_DEVICE);

-        CL_ERROR(CL_INVALID_CONTEXT);

-        CL_ERROR(CL_INVALID_QUEUE_PROPERTIES);

-        CL_ERROR(CL_INVALID_COMMAND_QUEUE);

-        CL_ERROR(CL_INVALID_HOST_PTR);

-        CL_ERROR(CL_INVALID_MEM_OBJECT);

-        CL_ERROR(CL_INVALID_IMAGE_FORMAT_DESCRIPTOR);

-        CL_ERROR(CL_INVALID_IMAGE_SIZE);

-        CL_ERROR(CL_INVALID_SAMPLER);

-        CL_ERROR(CL_INVALID_BINARY);

-        CL_ERROR(CL_INVALID_BUILD_OPTIONS);

-        CL_ERROR(CL_INVALID_PROGRAM);

-        CL_ERROR(CL_INVALID_PROGRAM_EXECUTABLE);

-        CL_ERROR(CL_INVALID_KERNEL_NAME);

-        CL_ERROR(CL_INVALID_KERNEL_DEFINITION);

-        CL_ERROR(CL_INVALID_KERNEL);

-        CL_ERROR(CL_INVALID_ARG_INDEX);

-        CL_ERROR(CL_INVALID_ARG_VALUE);

-        CL_ERROR(CL_INVALID_ARG_SIZE);

-        CL_ERROR(CL_INVALID_KERNEL_ARGS);

-        CL_ERROR(CL_INVALID_WORK_DIMENSION);

-        CL_ERROR(CL_INVALID_WORK_GROUP_SIZE);

-        CL_ERROR(CL_INVALID_WORK_ITEM_SIZE);

-        CL_ERROR(CL_INVALID_GLOBAL_OFFSET);

-        CL_ERROR(CL_INVALID_EVENT_WAIT_LIST);

-        CL_ERROR(CL_INVALID_EVENT);

-        CL_ERROR(CL_INVALID_OPERATION);

-        CL_ERROR(CL_INVALID_GL_OBJECT);

-        CL_ERROR(CL_INVALID_BUFFER_SIZE);

-        CL_ERROR(CL_INVALID_MIP_LEVEL);

+		CL_ERROR(CL_SUCCESS);

+		CL_ERROR(CL_DEVICE_NOT_FOUND);

+		CL_ERROR(CL_DEVICE_NOT_AVAILABLE);

+		CL_ERROR(CL_COMPILER_NOT_AVAILABLE);

+		CL_ERROR(CL_MEM_OBJECT_ALLOCATION_FAILURE);

+		CL_ERROR(CL_OUT_OF_RESOURCES);

+		CL_ERROR(CL_OUT_OF_HOST_MEMORY);

+		CL_ERROR(CL_PROFILING_INFO_NOT_AVAILABLE);

+		CL_ERROR(CL_MEM_COPY_OVERLAP);

+		CL_ERROR(CL_IMAGE_FORMAT_MISMATCH);

+		CL_ERROR(CL_IMAGE_FORMAT_NOT_SUPPORTED);

+		CL_ERROR(CL_BUILD_PROGRAM_FAILURE);

+		CL_ERROR(CL_MAP_FAILURE);

+		CL_ERROR(CL_INVALID_VALUE);

+		CL_ERROR(CL_INVALID_DEVICE_TYPE);

+		CL_ERROR(CL_INVALID_PLATFORM);

+		CL_ERROR(CL_INVALID_DEVICE);

+		CL_ERROR(CL_INVALID_CONTEXT);

+		CL_ERROR(CL_INVALID_QUEUE_PROPERTIES);

+		CL_ERROR(CL_INVALID_COMMAND_QUEUE);

+		CL_ERROR(CL_INVALID_HOST_PTR);

+		CL_ERROR(CL_INVALID_MEM_OBJECT);

+		CL_ERROR(CL_INVALID_IMAGE_FORMAT_DESCRIPTOR);

+		CL_ERROR(CL_INVALID_IMAGE_SIZE);

+		CL_ERROR(CL_INVALID_SAMPLER);

+		CL_ERROR(CL_INVALID_BINARY);

+		CL_ERROR(CL_INVALID_BUILD_OPTIONS);

+		CL_ERROR(CL_INVALID_PROGRAM);

+		CL_ERROR(CL_INVALID_PROGRAM_EXECUTABLE);

+		CL_ERROR(CL_INVALID_KERNEL_NAME);

+		CL_ERROR(CL_INVALID_KERNEL_DEFINITION);

+		CL_ERROR(CL_INVALID_KERNEL);

+		CL_ERROR(CL_INVALID_ARG_INDEX);

+		CL_ERROR(CL_INVALID_ARG_VALUE);

+		CL_ERROR(CL_INVALID_ARG_SIZE);

+		CL_ERROR(CL_INVALID_KERNEL_ARGS);

+		CL_ERROR(CL_INVALID_WORK_DIMENSION);

+		CL_ERROR(CL_INVALID_WORK_GROUP_SIZE);

+		CL_ERROR(CL_INVALID_WORK_ITEM_SIZE);

+		CL_ERROR(CL_INVALID_GLOBAL_OFFSET);

+		CL_ERROR(CL_INVALID_EVENT_WAIT_LIST);

+		CL_ERROR(CL_INVALID_EVENT);

+		CL_ERROR(CL_INVALID_OPERATION);

+		CL_ERROR(CL_INVALID_GL_OBJECT);

+		CL_ERROR(CL_INVALID_BUFFER_SIZE);

+		CL_ERROR(CL_INVALID_MIP_LEVEL);

 #undef CL_ERROR

-    default:

-        name = "Unknown error code";

-    }

-    if(!str)

-        str = "";

-    PanicAlert("OpenCL error: %s %s (%d)", str, name, error);

-

+	default:

+		name = "Unknown error code";

+	}

+	if(!str)

+		str = "";

+	ERROR_LOG(COMMON, "OpenCL error: %s %s (%d)", str, name, error);

 #endif

-}

-

+	}

 }