/opencl/tools

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <CL/cl.h>

#define fail(code, reason) {\

    fprintf(stderr, "%s\n", reason); \

    exit (code); \

}

typedef struct  {

    cl_uint num_devices;

    cl_device_id *devices;

} device_info_t;

static inline cl_program load_app(cl_context ctx, cl_uint num_devices, cl_device_id *devices, const char *name) {

    FILE *f;

    size_t len;

    char *buf;

    device_info_t info = { num_devices, devices }; 

    cl_program app;

    f = fopen(name, "rb");

    if (!f) return NULL;

    fseek(f, 0, SEEK_END); 

    len = ftell(f);

    fseek(f, 0, SEEK_SET); 

    buf = (char*)malloc(len*sizeof(char));

    if (!buf) return NULL;

    if (fread(buf, 1, len, f) != len) {

	free(buf);

	fclose(f);

	return NULL;

    }

    fclose(f);

    int i;

    printf("Compiling for ");

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

	char name[256];

	int err = clGetDeviceInfo(devices[i], CL_DEVICE_NAME, sizeof(name), name, NULL);

	if (err != CL_SUCCESS) puts("Unknown ");

	else printf("%s ", name);

    }

    printf("\n");

    app = clCreateProgramWithSource(ctx, 1, (const char**)&buf, &len, NULL);

    if (app) {

	size_t size;

	char build_log[4096];

	cl_build_status build_status;

	//"-cl-nv-maxrregcount=48"

	//"-cl-nv-opt-level=<N>" (0 - no optimizations, 3 - default)

	//"-cl-nv-arch sm_XX" - selects the target CUDA Compute Level architecture to compile for (sm_10 for 1.0, sm_11 for 1.1, sm_12 for 1.2, sm_13 for 1.3 and sm_20 for 2.0 (Fermi))

	//"--cl-nv-cstd=CLX.X" - selects the target OpenCL C language version (CL1.0 or CL1.1)

	char *build_flags = "-cl-nv-arch sm_20 -cl-nv-verbose -cl-denorms-are-zero -cl-mad-enable -cl-no-signed-zeros -cl-unsafe-math-optimizations -cl-finite-math-only";

	int err = clBuildProgram(app, num_devices, devices, build_flags, NULL, NULL);

	if (err != CL_SUCCESS) printf("Application build failed (%i)\n", err);

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

	    do {

		err = clGetProgramBuildInfo(app, devices[i], CL_PROGRAM_BUILD_STATUS, sizeof(cl_build_status), &build_status, NULL);

	    } while (build_status == CL_BUILD_IN_PROGRESS);

	    err = clGetProgramBuildInfo(app, devices[i], CL_PROGRAM_BUILD_LOG, sizeof(build_log) - 1, &build_log, &size);

	    printf("%i\n", err);

	    if (!err) {

		build_log[size] = 0;

	        if (!err) {

		    if (build_status == CL_BUILD_SUCCESS) {

			if (strlen(build_log) > 2) {

		    	    printf("Build successed for device %i:\n===================\n%s\n--------------------\n\n", i, build_log);

		    	}

		    } else if (build_status == CL_BUILD_ERROR) {

		        printf("Build failed for device %i:\n======================\n%s\n--------------------\n\n", i, build_log);

		    } else {

		        printf("Build failed for device %i\n", i);

		    }

		}

	    }

	}

    } else {

	printf("Program creation failed\n");

    }

    free(buf);

    return app;

}

int main(int argc, char *argv[]) {

    int devid = -1;

    cl_int err;

    cl_device_id devices[16];

    cl_program app;

    char fname[256];    

    unsigned char *binary[16];

    size_t binary_size[16];

    size_t real_size;

    FILE *f;

    if (argc < 2) {

	fprintf(stderr, "Usage: %s <source> [device] [binary] [kernel]\n", argv[0]);

	exit(0);	

    }

    if (argc > 2) {

	devid = atoi(argv[2]);	

    }

    cl_uint max = 0;

    cl_platform_id selected_platform;

    cl_uint i, num_platforms, num_devices;

    cl_platform_id platforms[4];

    clGetPlatformIDs(4, platforms, &num_platforms);

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

	err = clGetDeviceIDs(platforms[i], CL_DEVICE_TYPE_GPU, 0, NULL, &num_devices);

	if ((err == CL_SUCCESS)&&(num_devices > max)) {

	    max = num_devices;

	    selected_platform = platforms[i];

	}

    }

    clGetDeviceIDs(selected_platform, CL_DEVICE_TYPE_GPU, 16, devices, &num_devices);

    if (devid >= (int)num_devices) fail(-1, "Invalid device number is specified");

    cl_context ctx;

    if (devid < 0)

        ctx = clCreateContext(0, num_devices, devices, NULL, NULL, &err);

    else

	ctx = clCreateContext(0, 1, &devices[devid], NULL, NULL, &err);

    if (!ctx) fail(-1, "Failed to create OpenCL context");

//    cl_context ctx = clCreateContextFromType(NULL, CL_DEVICE_TYPE_GPU, NULL, NULL, NULL);

//    if (!ctx) fail(-1, "Failed to create OpenCL context");

//    err = clGetContextInfo(ctx, CL_CONTEXT_DEVICES, 16 * sizeof(cl_device_id), &devices, &num_devices);

//    if (err != CL_SUCCESS) fail(-1, "clGetContextInfo call is failed");

//    num_devices /= sizeof(cl_device_id);

    if (devid < 0)

	app = load_app(ctx, num_devices, devices, argv[1]);

    else

	app = load_app(ctx, 1, &devices[devid], argv[1]);

    if (!app) fail(-1, "Compilation failed");

    if (devid >= 0) num_devices = 1;

    err = clGetProgramInfo(app, CL_PROGRAM_BINARY_SIZES, num_devices * sizeof(size_t), &binary_size, &real_size);

    printf("Status: %i, Sizes: ", err);

    for (i = 0; i < num_devices; i++) printf (" %li", binary_size[i]);

    printf("\n");

    if ((err != CL_SUCCESS)||(real_size != num_devices*sizeof(size_t)))

	fail(-1, "Failed to get binary size");

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

        binary[i] = malloc(binary_size[i] + 1);

	if (!binary[i]) {

	    for (i--; i>=0; i--) free(binary[i]);

	    fail(-1, "allocation failed");

	}

    }

    err = clGetProgramInfo(app, CL_PROGRAM_BINARIES, num_devices * sizeof(unsigned char*), &binary, &real_size);

    if ((err == CL_SUCCESS)&&(real_size == num_devices * sizeof(unsigned char*))) {

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

	    sprintf(fname, "%s.%u", ((argc>3)?argv[3]:"opencl.out"), i);

	    f = fopen(fname, "wb");

	    if (f) {

		fwrite(binary[i], 1, binary_size[i], f);

		fclose(f);

		free(binary[i]);

	    } else {

		for (; i < num_devices; i++)

		    free(binary[i]);

		fail(-1, "Failed to create output file");

	    }

	}

    } else {

	for (i = 0; i < num_devices; i++)

	    free(binary[i]);

	fail(-1, "Binary readout failed")

    }

    if (argc > 4) {

	cl_kernel kern;

	kern = clCreateKernel(app, argv[4], &err);

	if (err == CL_SUCCESS) clReleaseKernel(kern);

	else printf("Error creating kernel (%i)\n", err);

    }

    clReleaseProgram(app);

    clReleaseContext(ctx);

}