thodg/cgminer/ocl.c

• Show log

  Commit

• Hash : 28880d0d
  Author :
  Date : 2011-08-13T20:54:20
  

  Move the non cl_ variables into the cgpu info struct to allow creating a new cl state on reinit, preserving known GPU variables. Create a new context from scratch in initCQ in case something was corrupted to maximise our chance of succesfully creating a new worker thread.

Download

• ocl.c

• /*
   * Copyright 2011 Con Kolivas
   */
  #include "config.h"
  #ifdef HAVE_OPENCL
  
  #include <signal.h>
  #include <stdlib.h>
  #include <string.h>
  #include <stdio.h>
  #include <sys/types.h>
  
  #ifdef WIN32
  	#include <winsock2.h>
  #else
  	#include <sys/socket.h>
  	#include <netinet/in.h>
  	#include <netdb.h>
  #endif
  
  #include <time.h>
  #include <sys/time.h>
  #include <pthread.h>
  #include <sys/stat.h>
  #include <unistd.h>
  
  #include "findnonce.h"
  #include "ocl.h"
  
  extern int opt_vectors;
  extern int opt_worksize;
  
  char *file_contents(const char *filename, int *length)
  {
  	FILE *f = fopen(filename, "rb");
  	void *buffer;
  
  	if (!f) {
  		applog(LOG_ERR, "Unable to open %s for reading", filename);
  		return NULL;
  	}
  
  	fseek(f, 0, SEEK_END);
  	*length = ftell(f);
  	fseek(f, 0, SEEK_SET);
  
  	buffer = malloc(*length+1);
  	*length = fread(buffer, 1, *length, f);
  	fclose(f);
  	((char*)buffer)[*length] = '\0';
  
  	return (char*)buffer;
  }
  
  static cl_uint numDevices;
  
  int clDevicesNum() {
  	cl_int status = 0;
  
  	cl_uint numPlatforms;
  	cl_platform_id platform = NULL;
  	status = clGetPlatformIDs(0, NULL, &numPlatforms);
  	/* If this fails, assume no GPUs. */
  	if (status != CL_SUCCESS)
  	{
  		applog(LOG_INFO, "clGetPlatformsIDs failed (no GPU?)");
  		return 0;
  	}
  
  	if (numPlatforms > 0)
  	{
  		cl_platform_id* platforms = (cl_platform_id *)malloc(numPlatforms*sizeof(cl_platform_id));
  		status = clGetPlatformIDs(numPlatforms, platforms, NULL);
  		if (status != CL_SUCCESS)
  		{
  			applog(LOG_ERR, "Error: Getting Platform Ids. (clGetPlatformsIDs)");
  			return -1;
  		}
  
  		unsigned int i;
  		for(i=0; i < numPlatforms; ++i)
  		{
  			char pbuff[100];
  			status = clGetPlatformInfo( platforms[i], CL_PLATFORM_VENDOR, sizeof(pbuff), pbuff, NULL);
  			if (status != CL_SUCCESS)
  			{
  				applog(LOG_ERR, "Error: Getting Platform Info. (clGetPlatformInfo)");
  				free(platforms);
  				return -1;
  			}
  			platform = platforms[i];
  			if (!strcmp(pbuff, "Advanced Micro Devices, Inc."))
  			{
  				break;
  			}
  		}
  		free(platforms);
  	}
  
  	if (platform == NULL) {
  		perror("NULL platform found!\n");
  		return -1;
  	}
  
  	cl_uint numDevices;
  	status = clGetDeviceIDs(platform, CL_DEVICE_TYPE_GPU, 0, NULL, &numDevices);
  	if (status != CL_SUCCESS)
  	{
  		applog(LOG_ERR, "Error: Getting Device IDs (num)");
  		return -1;
  	}
  
  	return numDevices;
  }
  
  static cl_platform_id platform = NULL;
  static cl_device_id *devices;
  
  int preinit_devices(void)
  {
  	cl_int status;
  	cl_uint numPlatforms;
  	int i;
  
  	status = clGetPlatformIDs(0, NULL, &numPlatforms);
  	if (status != CL_SUCCESS)
  	{
  		applog(LOG_ERR, "Error: Getting Platforms. (clGetPlatformsIDs)");
  		return -1;
  	}
  
  	if (numPlatforms > 0)
  	{
  		cl_platform_id* platforms = (cl_platform_id *)malloc(numPlatforms*sizeof(cl_platform_id));
  		status = clGetPlatformIDs(numPlatforms, platforms, NULL);
  		if (status != CL_SUCCESS)
  		{
  			applog(LOG_ERR, "Error: Getting Platform Ids. (clGetPlatformsIDs)");
  			return -1;
  		}
  
  		for(i = 0; i < numPlatforms; ++i)
  		{
  			char pbuff[100];
  			status = clGetPlatformInfo( platforms[i], CL_PLATFORM_VENDOR, sizeof(pbuff), pbuff, NULL);
  			if (status != CL_SUCCESS)
  			{
  				applog(LOG_ERR, "Error: Getting Platform Info. (clGetPlatformInfo)");
  				free(platforms);
  				return -1;
  			}
  			platform = platforms[i];
  			if (!strcmp(pbuff, "Advanced Micro Devices, Inc."))
  			{
  				break;
  			}
  		}
  		free(platforms);
  	}
  
  	if (platform == NULL) {
  		perror("NULL platform found!\n");
  		return -1;
  	}
  
  	status = clGetDeviceIDs(platform, CL_DEVICE_TYPE_GPU, 0, NULL, &numDevices);
  	if (status != CL_SUCCESS)
  	{
  		applog(LOG_ERR, "Error: Getting Device IDs (num)");
  		return -1;
  	}
  
  	if (numDevices > 0 ) {
  		devices = (cl_device_id *)malloc(numDevices*sizeof(cl_device_id));
  
  		/* Now, get the device list data */
  
  		status = clGetDeviceIDs(platform, CL_DEVICE_TYPE_GPU, numDevices, devices, NULL);
  		if (status != CL_SUCCESS)
  		{
  			applog(LOG_ERR, "Error: Getting Device IDs (list)");
  			return -1;
  		}
  
  		applog(LOG_INFO, "List of devices:");
  
  		unsigned int i;
  		for(i=0; i<numDevices; i++) {
  			char pbuff[100];
  			status = clGetDeviceInfo(devices[i], CL_DEVICE_NAME, sizeof(pbuff), pbuff, NULL);
  			if (status != CL_SUCCESS)
  			{
  				applog(LOG_ERR, "Error: Getting Device Info");
  				return -1;
  			}
  
  			applog(LOG_INFO, "\t%i\t%s", i, pbuff);
  		}
  
  	} else return -1;
  
  	return 0;
  }
  
  static int advance(char **area, unsigned *remaining, const char *marker)
  {
  	char *find = memmem(*area, *remaining, marker, strlen(marker));
  
  	if (!find) {
  		if (opt_debug)
  			applog(LOG_DEBUG, "Marker \"%s\" not found", marker);
  		return 0;
  	}
  	*remaining -= find - *area;
  	*area = find;
  	return 1;
  }
  
  #define OP3_INST_BFE_UINT	4ULL
  #define OP3_INST_BFE_INT	5ULL
  #define OP3_INST_BFI_INT	6ULL
  #define OP3_INST_BIT_ALIGN_INT	12ULL
  #define OP3_INST_BYTE_ALIGN_INT	13ULL
  
  void patch_opcodes(char *w, unsigned remaining)
  {
  	uint64_t *opcode = (uint64_t *)w;
  	int patched = 0;
  	int count_bfe_int = 0;
  	int count_bfe_uint = 0;
  	int count_byte_align = 0;
  	while (42)
  	{
  		int clamp = (*opcode >> (32 + 31)) & 0x1;
  		int dest_rel = (*opcode >> (32 + 28)) & 0x1;
  		int alu_inst = (*opcode >> (32 + 13)) & 0x1f;
  		int s2_neg = (*opcode >> (32 + 12)) & 0x1;
  		int s2_rel = (*opcode >> (32 + 9)) & 0x1;
  		int pred_sel = (*opcode >> 29) & 0x3;
  		if (!clamp && !dest_rel && !s2_neg && !s2_rel && !pred_sel) {
  			if (alu_inst == OP3_INST_BFE_INT) {
  				count_bfe_int++;
  			} else if (alu_inst == OP3_INST_BFE_UINT) {
  				count_bfe_uint++;
  			} else if (alu_inst == OP3_INST_BYTE_ALIGN_INT) {
  				count_byte_align++;
  				// patch this instruction to BFI_INT
  				*opcode &= 0xfffc1fffffffffffULL;
  				*opcode |= OP3_INST_BFI_INT << (32 + 13);
  				patched++;
  			}
  		}
  		if (remaining <= 8) {
  			break;
  		}
  		opcode++;
  		remaining -= 8;
  	}
  	if (opt_debug) {
  		applog(LOG_DEBUG, "Potential OP3 instructions identified: "
  			"%i BFE_INT, %i BFE_UINT, %i BYTE_ALIGN",
  			count_bfe_int, count_bfe_uint, count_byte_align);
  		applog(LOG_DEBUG, "Patched a total of %i BFI_INT instructions", patched);
  	}
  }
  
  _clState *initCQ(_clState *clState, unsigned int gpu)
  {
  	cl_int status = 0;
  	cl_context_properties cps[3] = { CL_CONTEXT_PLATFORM, (cl_context_properties)platform, 0 };
  
  	clState->context = clCreateContextFromType(cps, CL_DEVICE_TYPE_GPU, NULL, NULL, &status);
  	if (status != CL_SUCCESS)
  	{
  		applog(LOG_ERR, "Error: Creating Context. (clCreateContextFromType)");
  		return NULL;
  	}
  
  	/* create a cl program executable for the device specified */
  	status = clBuildProgram(clState->program, 1, &devices[gpu], NULL, NULL, NULL);
  	if (status != CL_SUCCESS)
  	{
  		applog(LOG_ERR, "Error: Building Program (clBuildProgram)");
  		size_t logSize;
  		status = clGetProgramBuildInfo(clState->program, devices[gpu], CL_PROGRAM_BUILD_LOG, 0, NULL, &logSize);
  
  		char *log = malloc(logSize);
  		status = clGetProgramBuildInfo(clState->program, devices[gpu], CL_PROGRAM_BUILD_LOG, logSize, log, NULL);
  		applog(LOG_INFO, "%s", log);
  		return NULL;
  	}
  
  	/* get a kernel object handle for a kernel with the given name */
  	clState->kernel = clCreateKernel(clState->program, "search", &status);
  	if (status != CL_SUCCESS)
  	{
  		applog(LOG_ERR, "Error: Creating Kernel from program. (clCreateKernel)");
  		return NULL;
  	}
  
  	/////////////////////////////////////////////////////////////////
  	// Create an OpenCL command queue
  	/////////////////////////////////////////////////////////////////
  	clState->commandQueue = clCreateCommandQueue(clState->context, devices[gpu],
  						     CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE, &status);
  	if (status != CL_SUCCESS) /* Try again without OOE enable */
  		clState->commandQueue = clCreateCommandQueue(clState->context, devices[gpu], 0 , &status);
  	if (status != CL_SUCCESS)
  	{
  		applog(LOG_ERR, "Creating Command Queue. (clCreateCommandQueue)");
  		return NULL;
  	}
  
  	clState->outputBuffer = clCreateBuffer(clState->context, CL_MEM_READ_WRITE, BUFFERSIZE, NULL, &status);
  	if (status != CL_SUCCESS) {
  		applog(LOG_ERR, "Error: clCreateBuffer (outputBuffer)");
  		return NULL;
  	}
  
  	return clState;
  }
  
  _clState *initCl(struct cgpu_info *cgpu, char *name, size_t nameSize)
  {
  	unsigned int gpu = cgpu->cpu_gpu;
  	int patchbfi = 0;
  	cl_int status = 0;
  	size_t nDevices;
  
  	_clState *clState = calloc(1, sizeof(_clState));
  
  	cl_context_properties cps[3] = { CL_CONTEXT_PLATFORM, (cl_context_properties)platform, 0 };
  
  	clState->context = clCreateContextFromType(cps, CL_DEVICE_TYPE_GPU, NULL, NULL, &status);
  	if (status != CL_SUCCESS)
  	{
  		applog(LOG_ERR, "Error: Creating Context. (clCreateContextFromType)");
  		return NULL;
  	}
  
  	if (gpu < numDevices) {
  		char pbuff[100];
  		status = clGetDeviceInfo(devices[gpu], CL_DEVICE_NAME, sizeof(pbuff), pbuff, &nDevices);
  		if (status != CL_SUCCESS)
  		{
  			applog(LOG_ERR, "Error: Getting Device Info");
  			return NULL;
  		}
  
  		applog(LOG_INFO, "Selected %i: %s", gpu, pbuff);
  		strncpy(name, pbuff, nameSize);
  	} else {
  		applog(LOG_ERR, "Invalid GPU %i", gpu);
  		return NULL;
  	}
  
  	/* Check for BFI INT support. Hopefully people don't mix devices with
  	 * and without it! */
  	char * extensions = malloc(1024);
  	const char * camo = "cl_amd_media_ops";
  	char *find;
  
  	status = clGetDeviceInfo(devices[gpu], CL_DEVICE_EXTENSIONS, 1024, (void *)extensions, NULL);
  	if (status != CL_SUCCESS) {
  		applog(LOG_ERR, "Error: Failed to clGetDeviceInfo when trying to get CL_DEVICE_EXTENSIONS");
  		return NULL;
  	}
  	find = strstr(extensions, camo);
  	if (find)
  		cgpu->hasBitAlign = patchbfi = 1;
  
  	status = clGetDeviceInfo(devices[gpu], CL_DEVICE_PREFERRED_VECTOR_WIDTH_INT, sizeof(cl_uint), (void *)&clState->preferred_vwidth, NULL);
  	if (status != CL_SUCCESS) {
  		applog(LOG_ERR, "Error: Failed to clGetDeviceInfo when trying to get CL_DEVICE_PREFERRED_VECTOR_WIDTH_INT");
  		return NULL;
  	}
  	if (opt_debug)
  		applog(LOG_DEBUG, "Preferred vector width reported %d", clState->preferred_vwidth);
  
  	status = clGetDeviceInfo(devices[gpu], CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof(size_t), (void *)&cgpu->max_work_size, NULL);
  	if (status != CL_SUCCESS) {
  		applog(LOG_ERR, "Error: Failed to clGetDeviceInfo when trying to get CL_DEVICE_MAX_WORK_GROUP_SIZE");
  		return NULL;
  	}
  	if (opt_debug)
  		applog(LOG_DEBUG, "Max work group size reported %d", cgpu->max_work_size);
  
  	/* For some reason 2 vectors is still better even if the card says
  	 * otherwise, and many cards lie about their max so use 256 as max
  	 * unless explicitly set on the command line */
  	cgpu->vwidth = clState->preferred_vwidth;
  	if (clState->preferred_vwidth > 1)
  		cgpu->vwidth = 2;
  	if (opt_vectors)
  		cgpu->vwidth = opt_vectors;
  	if (opt_worksize && opt_worksize <= cgpu->max_work_size)
  		cgpu->work_size = opt_worksize;
  	else
  		cgpu->work_size = (cgpu->max_work_size <= 256 ? cgpu->max_work_size : 256) /
  				cgpu->vwidth;
  
  	/* Create binary filename based on parameters passed to opencl
  	 * compiler to ensure we only load a binary that matches what would
  	 * have otherwise created. The filename is:
  	 * name + kernelname +/i bitalign + v + vectors + w + work_size + sizeof(long) + .bin
  	 */
  	char binaryfilename[255];
  	char numbuf[10];
  	char filename[16];
  
  	if (chosen_kernel == KL_NONE) {
  		if (cgpu->hasBitAlign)
  			chosen_kernel = KL_PHATK;
  		else
  			chosen_kernel = KL_POCLBM;
  	}
  
  	switch (chosen_kernel) {
  		case KL_POCLBM:
  			strcpy(filename, "poclbm110717.cl");
  			strcpy(binaryfilename, "poclbm110717");
  			break;
  		case KL_NONE: /* Shouldn't happen */
  		case KL_PHATK:
  			strcpy(filename, "phatk110722.cl");
  			strcpy(binaryfilename, "phatk110722");
  			break;
  	}
  
  	FILE *binaryfile;
  	size_t *binary_sizes;
  	char **binaries;
  	int pl;
  	char *source, *rawsource = file_contents(filename, &pl);
  	size_t sourceSize[] = {(size_t)pl};
  
  	source = malloc(pl);
  	if (!source) {
  		applog(LOG_ERR, "Unable to malloc source");
  		return NULL;
  	}
  
  	binary_sizes = (size_t *)malloc(sizeof(size_t)*nDevices);
  	if (unlikely(!binary_sizes)) {
  		applog(LOG_ERR, "Unable to malloc binary_sizes");
  		return NULL;
  	}
  	binaries = (char **)malloc(sizeof(char *)*nDevices);
  	if (unlikely(!binaries)) {
  		applog(LOG_ERR, "Unable to malloc binaries");
  		return NULL;
  	}
  
  	strcat(binaryfilename, name);
  	if (cgpu->hasBitAlign)
  		strcat(binaryfilename, "bitalign");
  
  	strcat(binaryfilename, "v");
  	sprintf(numbuf, "%d", cgpu->vwidth);
  	strcat(binaryfilename, numbuf);
  	strcat(binaryfilename, "w");
  	sprintf(numbuf, "%d", (int)cgpu->work_size);
  	strcat(binaryfilename, numbuf);
  	strcat(binaryfilename, "long");
  	sprintf(numbuf, "%d", (int)sizeof(long));
  	strcat(binaryfilename, numbuf);
  	strcat(binaryfilename, ".bin");
  
  	binaryfile = fopen(binaryfilename, "rb");
  	if (!binaryfile) {
  		if (opt_debug)
  			applog(LOG_DEBUG, "No binary found, generating from source");
  	} else {
  		struct stat binary_stat;
  
  		if (unlikely(stat(binaryfilename, &binary_stat))) {
  			if (opt_debug)
  				applog(LOG_DEBUG, "Unable to stat binary, generating from source");
  			fclose(binaryfile);
  			goto build;
  		}
  		binary_sizes[gpu] = binary_stat.st_size;
  		binaries[gpu] = (char *)malloc(binary_sizes[gpu]);
  		if (unlikely(!binaries[gpu])) {
  			applog(LOG_ERR, "Unable to malloc binaries");
  			fclose(binaryfile);
  			return NULL;
  		}
  
  		if (fread(binaries[gpu], 1, binary_sizes[gpu], binaryfile) != binary_sizes[gpu]) {
  			applog(LOG_ERR, "Unable to fread binaries[gpu]");
  			fclose(binaryfile);
  			goto build;
  		}
  		fclose(binaryfile);
  
  		clState->program = clCreateProgramWithBinary(clState->context, 1, &devices[gpu], &binary_sizes[gpu], (const unsigned char **)&binaries[gpu], &status, NULL);
  		if (status != CL_SUCCESS)
  		{
  			applog(LOG_ERR, "Error: Loading Binary into cl_program (clCreateProgramWithBinary)");
  			return NULL;
  		}
  		if (opt_debug)
  			applog(LOG_DEBUG, "Loaded binary image %s", binaryfilename);
  
  		free(binaries[gpu]);
  		goto built;
  	}
  
  	/////////////////////////////////////////////////////////////////
  	// Load CL file, build CL program object, create CL kernel object
  	/////////////////////////////////////////////////////////////////
  
  build:
  	memcpy(source, rawsource, pl);
  
  	/* Patch the source file with the preferred_vwidth */
  	if (cgpu->vwidth > 1) {
  		char *find = strstr(source, "VECTORSX");
  
  		if (unlikely(!find)) {
  			applog(LOG_ERR, "Unable to find VECTORSX in source");
  			return NULL;
  		}
  		find += 7; // "VECTORS"
  		if (cgpu->vwidth == 2)
  			strncpy(find, "2", 1);
  		else
  			strncpy(find, "4", 1);
  		if (opt_debug)
  			applog(LOG_DEBUG, "Patched source to suit %d vectors", clState->preferred_vwidth);
  	}
  
  	/* Patch the source file defining BITALIGN */
  	if (cgpu->hasBitAlign) {
  		char *find = strstr(source, "BITALIGNX");
  
  		if (unlikely(!find)) {
  			applog(LOG_ERR, "Unable to find BITALIGNX in source");
  			return NULL;
  		}
  		find += 8; // "BITALIGN"
  		strncpy(find, " ", 1);
  		if (opt_debug)
  			applog(LOG_DEBUG, "cl_amd_media_ops found, patched source with BITALIGN");
  	} else if (opt_debug)
  		applog(LOG_DEBUG, "cl_amd_media_ops not found, will not BITALIGN patch");
  
  	if (patchbfi) {
  		char *find = strstr(source, "BFI_INTX");
  
  		if (unlikely(!find)) {
  			applog(LOG_ERR, "Unable to find BFI_INTX in source");
  			return NULL;
  		}
  		find += 7; // "BFI_INT"
  		strncpy(find, " ", 1);
  		if (opt_debug)
  			applog(LOG_DEBUG, "cl_amd_media_ops found, patched source with BFI_INT");
  	} else if (opt_debug)
  		applog(LOG_DEBUG, "cl_amd_media_ops not found, will not BFI_INT patch");
  
  	clState->program = clCreateProgramWithSource(clState->context, 1, (const char **)&source, sourceSize, &status);
  	if (status != CL_SUCCESS)
  	{
  		applog(LOG_ERR, "Error: Loading Binary into cl_program (clCreateProgramWithSource)");
  		return NULL;
  	}
  
  	/* create a cl program executable for all the devices specified */
  	status = clBuildProgram(clState->program, 1, &devices[gpu], NULL, NULL, NULL);
  	if (status != CL_SUCCESS)
  	{
  		applog(LOG_ERR, "Error: Building Program (clBuildProgram)");
  		size_t logSize;
  		status = clGetProgramBuildInfo(clState->program, devices[gpu], CL_PROGRAM_BUILD_LOG, 0, NULL, &logSize);
  
  		char *log = malloc(logSize);
  		status = clGetProgramBuildInfo(clState->program, devices[gpu], CL_PROGRAM_BUILD_LOG, logSize, log, NULL);
  		applog(LOG_INFO, "%s", log);
  		return NULL;
  	}
  
  	/* Create the command queue just so we can flush it to try and avoid
  	 * zero sized binaries */
  	clState->commandQueue = clCreateCommandQueue(clState->context, devices[gpu], 0, &status);
  	if (status != CL_SUCCESS)
  	{
  		applog(LOG_ERR, "Creating Command Queue. (clCreateCommandQueue)");
  		return NULL;
  	}
  	status = clFinish(clState->commandQueue);
  	if (status != CL_SUCCESS)
  	{
  		applog(LOG_ERR, "Finishing command queue. (clFinish)");
  		return NULL;
  	}
  
  	status = clGetProgramInfo( clState->program, CL_PROGRAM_BINARY_SIZES, sizeof(size_t)*nDevices, binary_sizes, NULL );
  	if (unlikely(status != CL_SUCCESS))
  	{
  		applog(LOG_ERR, "Error: Getting program info CL_PROGRAM_BINARY_SIZES. (clGetPlatformInfo)");
  		return NULL;
  	}
  
  	/* copy over all of the generated binaries. */
  	if (opt_debug)
  		applog(LOG_DEBUG, "binary size %d : %d", gpu, binary_sizes[gpu]);
  	if (!binary_sizes[gpu]) {
  		applog(LOG_ERR, "OpenCL compiler generated a zero sized binary, may need to reboot!");
  		return NULL;
  	}
  	binaries[gpu] = (char *)malloc( sizeof(char)*binary_sizes[gpu]);
  	status = clGetProgramInfo( clState->program, CL_PROGRAM_BINARIES, sizeof(char *)*nDevices, binaries, NULL );
  	if (unlikely(status != CL_SUCCESS))
  	{
  		applog(LOG_ERR, "Error: Getting program info. (clGetPlatformInfo)");
  		return NULL;
  	}
  	clReleaseCommandQueue(clState->commandQueue);
  
  	/* Patch the kernel if the hardware supports BFI_INT */
  	if (patchbfi) {
  		unsigned remaining = binary_sizes[gpu];
  		char *w = binaries[gpu];
  		unsigned int start, length;
  
  		/* Find 2nd incidence of .text, and copy the program's
  		* position and length at a fixed offset from that. Then go
  		* back and find the 2nd incidence of \x7ELF (rewind by one
  		* from ELF) and then patch the opcocdes */
  		if (!advance(&w, &remaining, ".text"))
  			{patchbfi = 0; goto build;}
  		w++; remaining--;
  		if (!advance(&w, &remaining, ".text")) {
  			/* 32 bit builds only one ELF */
  			w--; remaining++;
  		}
  		memcpy(&start, w + 285, 4);
  		memcpy(&length, w + 289, 4);
  		w = binaries[gpu]; remaining = binary_sizes[gpu];
  		if (!advance(&w, &remaining, "ELF"))
  			{patchbfi = 0; goto build;}
  		w++; remaining--;
  		if (!advance(&w, &remaining, "ELF")) {
  			/* 32 bit builds only one ELF */
  			w--; remaining++;
  		}
  		w--; remaining++;
  		w += start; remaining -= start;
  		if (opt_debug)
  			applog(LOG_DEBUG, "At %p (%u rem. bytes), to begin patching",
  				w, remaining);
  		patch_opcodes(w, length);
  
  		status = clReleaseProgram(clState->program);
  		if (status != CL_SUCCESS)
  		{
  			applog(LOG_ERR, "Error: Releasing program. (clReleaseProgram)");
  			return NULL;
  		}
  
  		clState->program = clCreateProgramWithBinary(clState->context, 1, &devices[gpu], &binary_sizes[gpu], (const unsigned char **)&binaries[gpu], &status, NULL);
  		if (status != CL_SUCCESS)
  		{
  			applog(LOG_ERR, "Error: Loading Binary into cl_program (clCreateProgramWithBinary)");
  			return NULL;
  		}
  	}
  
  	free(source);
  	free(rawsource);
  
  	/* Save the binary to be loaded next time */
  	binaryfile = fopen(binaryfilename, "wb");
  	if (!binaryfile) {
  		/* Not a fatal problem, just means we build it again next time */
  		if (opt_debug)
  			applog(LOG_DEBUG, "Unable to create file %s", binaryfilename);
  	} else {
  		if (unlikely(fwrite(binaries[gpu], 1, binary_sizes[gpu], binaryfile) != binary_sizes[gpu])) {
  			applog(LOG_ERR, "Unable to fwrite to binaryfile");
  			return NULL;
  		}
  		fclose(binaryfile);
  	}
  	if (binaries[gpu])
  		free(binaries[gpu]);
  built:
  	free(binaries);
  	free(binary_sizes);
  
  	/* We throw everything out now and create the real context we're using in initCQ */
  	clReleaseContext(clState->context);
  
  	applog(LOG_INFO, "Initialising kernel %s with%s BFI_INT patching, %d vectors and worksize %d",
  	       filename, patchbfi ? "" : "out", cgpu->vwidth, cgpu->work_size);
  
  	return initCQ(clState, gpu);
  }
  #endif /* HAVE_OPENCL */
  
  

Download