/opencl/tools

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <CL/cl.h>

#define SUPPORTED_PLATFORMS 4

#define SUPPORTED_DEVICES 16

#define MAX_PARAM_SIZE 1024

int main() {

    cl_int err;

    cl_int i, j, k;

    cl_uint dim;

    cl_uint num_platforms;

    cl_platform_id platforms[SUPPORTED_PLATFORMS];

    cl_uint num_devices;

    cl_device_id devices[SUPPORTED_DEVICES];

    char param[MAX_PARAM_SIZE];

    err = clGetPlatformIDs(SUPPORTED_PLATFORMS, platforms, &num_platforms);

    if (err != CL_SUCCESS) {

	printf("Can't identify platforms");

	exit(0);

    }

    for (i = 0; i < num_platforms; i++) {

	err = clGetPlatformInfo (platforms[i], CL_PLATFORM_NAME, sizeof(param), param, NULL);

	if (err != CL_SUCCESS) {

	    puts("Unidentified platform");

	    continue;

	} else printf("Platform: %s", param);

	err = clGetPlatformInfo (platforms[i], CL_PLATFORM_VERSION, sizeof(param), param, NULL);

	if (err == CL_SUCCESS) {

	    printf(", Version: %s", param);

	}

	err = clGetPlatformInfo (platforms[i], CL_PLATFORM_PROFILE, sizeof(param), param, NULL);

	if (err == CL_SUCCESS) {

	    printf(", Profile: %s", param);

	}

	printf("\n");

	err = clGetDeviceIDs (platforms[i], CL_DEVICE_TYPE_ALL, SUPPORTED_DEVICES, devices, &num_devices);

	if (err != CL_SUCCESS) {

	    puts(" Device enumeration failed");

	    continue;

	}

	for (j = 0; j < num_devices; j++) {

	    err = clGetDeviceInfo(devices[j], CL_DEVICE_TYPE, sizeof(param), param, NULL);

	    if (err != CL_SUCCESS) {

		puts(" Unknown device");

		continue;

	    }

	    switch (*param&(CL_DEVICE_TYPE_CPU|CL_DEVICE_TYPE_GPU|CL_DEVICE_TYPE_ACCELERATOR)) {

		case CL_DEVICE_TYPE_CPU:

		    printf(" CPU");

		break;

		case CL_DEVICE_TYPE_GPU:

		    printf(" GPU");

		break;

		case CL_DEVICE_TYPE_ACCELERATOR:

		    printf(" ACCELERATOR");

		break;

	    }

	    if ((*param)&CL_DEVICE_TYPE_DEFAULT) printf(" (*)");

	    err = clGetDeviceInfo(devices[j], CL_DEVICE_NAME, sizeof(param), param, NULL);

	    if (err != CL_SUCCESS) {

		puts(" Unknown device");

		continue;

	    } else {

		printf(" %s", param);

	    }

	    err = clGetDeviceInfo(devices[j], CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof(param), param, NULL);

	    if (err == CL_SUCCESS) {

		printf(", %u MHZ", *(cl_uint*)param);

	    }

	    err = clGetDeviceInfo(devices[j], CL_DEVICE_ERROR_CORRECTION_SUPPORT, sizeof(param), param, NULL);

	    if ((err == CL_SUCCESS)&&(*(cl_bool*)param)) {

		printf(", ECC");

	    }

	    printf("\n");

	    err = clGetDeviceInfo(devices[j], CL_DEVICE_GLOBAL_MEM_SIZE, sizeof(param), param, NULL);

	    if (err == CL_SUCCESS) {

		printf("  Global Memory: %u MB\n", (*(cl_ulong*)param)/1024/1024);

	    }

	    err = clGetDeviceInfo(devices[j], CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof(param), param, NULL);

	    if (err == CL_SUCCESS) {

		printf("  Maximum Allocation: %u MB\n", (*(cl_ulong*)param)/1024/1024);

	    }

	    err = clGetDeviceInfo(devices[j], CL_DEVICE_MIN_DATA_TYPE_ALIGN_SIZE, sizeof(param), param, NULL);

	    if (err == CL_SUCCESS) {

		printf("  Sufficient Alignment: %u\n", (*(cl_uint*)param));

	    }

	    err = clGetDeviceInfo(devices[j], CL_DEVICE_LOCAL_MEM_TYPE, sizeof(param), param, NULL);

	    if ((err == CL_SUCCESS)&&(*(cl_device_local_mem_type*)param == CL_LOCAL)) {

		printf("  Local Memory");

	        err = clGetDeviceInfo(devices[j], CL_DEVICE_LOCAL_MEM_SIZE, sizeof(param), param, NULL);

		if (err == CL_SUCCESS) {

		    printf(": %u KB", (*(cl_ulong*)param)/1024);

		}

		printf("\n");

	    }

	    printf("  Constant Memory: ");

	    err = clGetDeviceInfo(devices[j], CL_DEVICE_MAX_CONSTANT_BUFFER_SIZE, sizeof(param), param, NULL);

	    if (err == CL_SUCCESS) {

		printf("%u KB", *(((cl_ulong*)param))/1024);

	    }

	    err = clGetDeviceInfo(devices[j], CL_DEVICE_MAX_CONSTANT_ARGS, sizeof(param), param, NULL);

	    if (err == CL_SUCCESS) {

		printf(" %u parameters max", *(((cl_uint*)param)));

	    }

	    printf("\n");

	    err = clGetDeviceInfo(devices[j], CL_DEVICE_ENDIAN_LITTLE, sizeof(param), param, NULL);

	    if (err == CL_SUCCESS) {

		printf("  Endianess: %s\n", (*(cl_bool*)param)?"Little":"Big");

	    }

	    err = clGetDeviceInfo(devices[j], CL_DRIVER_VERSION, sizeof(param), param, NULL);

	    if (err == CL_SUCCESS) {

		printf("  Driver Version: %s\n", param);

	    }

	    err = clGetDeviceInfo(devices[j], CL_DEVICE_VERSION, sizeof(param), param, NULL);

	    if (err == CL_SUCCESS) {

		printf("  OpenCL Version: %s\n", param);

	    }

	    err = clGetDeviceInfo(devices[j], CL_DEVICE_MAX_COMPUTE_UNITS, sizeof(param), param, NULL);

	    if (err == CL_SUCCESS) {

		printf("  Compute Units: %u\n", *(cl_uint*)param);

	    }

	    err = clGetDeviceInfo(devices[j], CL_DEVICE_ADDRESS_BITS, sizeof(param), param, NULL);

	    if (err == CL_SUCCESS) {

		printf("  Maximum Work-items: 2^%u (global, in one dimmension)\n", *(cl_uint*)param);

	    }

	    err = clGetDeviceInfo(devices[j], CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof(param), param, NULL);

	    if (err == CL_SUCCESS) {

		printf("  Group Size: %u\n", *(size_t*)param);

	    }

	    err = clGetDeviceInfo(devices[j], CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS, sizeof(param), param, NULL);

	    if (err == CL_SUCCESS) {

		dim = *(cl_uint*)param;

		err = clGetDeviceInfo(devices[j], CL_DEVICE_MAX_WORK_ITEM_SIZES, sizeof(param), param, NULL);

		if (err == CL_SUCCESS) {

		    printf("  Dimensions: ");

	    	    for (k = 0; k < dim; k++) {

			if (k) printf(", ");

			printf("%u", *(((size_t*)param)+k));

		    }

		    printf("\n");

		}

	    }

	    err = clGetDeviceInfo(devices[j], CL_DEVICE_EXTENSIONS, sizeof(param), param, NULL);

	    if (err == CL_SUCCESS) {

		printf("  Double Support: ");

		if (strstr(param, "cl_khr_fp64"))

		    printf("Yes");

		else

		    printf("No");

		printf("\n");

//		printf("  Extensions: %s\n", param);

	    } else {

		printf("  Double Support: No\n");

	    }

	}

    }

    return 0;

}