oclUtils.h
Fichier utilitaire
oclUtils.h
— 7.5 KB
Contenu du fichier
/*
Copyright 2011 Peter Thoman, Klaus Kofler and contributors.
(for a full list check the AUTHORS file)
This file is part of uCLbench.
uCLbench is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
uCLbench is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with uCLbench. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef OCLUTILS_H_
#define OCLUTILS_H_
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#define shrTRUE 1
#define shrCheckError(__a, __b) { if((__a)!=(__b)) {\
printf("shrCheckError(" #__a ", " #__b ") failed!\n - line %d in file " __FILE__ "\n - " #__a ": %s\n", __LINE__, oclErrorString(__a)); } }
//////////////////////////////////////////////////////////////////////////////
//! Loads a Program file and prepends the cPreamble to the code.
//!
//! @return the source string if succeeded, 0 otherwise
//! @param cFilename program filename
//! @param cPreamble code that is prepended to the loaded file, typically a set of #defines or a header
//! @param szFinalLength returned length of the code string
//////////////////////////////////////////////////////////////////////////////
char* oclLoadProgSource(const char* cFilename, const char* cPreamble, size_t* szFinalLength)
{
// locals
FILE* pFileStream = NULL;
size_t szSourceLength;
// open the OpenCL source code file
pFileStream = fopen(cFilename, "rb");
if(pFileStream == 0) return NULL;
size_t szPreambleLength = strlen(cPreamble);
// get the length of the source code
fseek(pFileStream, 0, SEEK_END);
szSourceLength = ftell(pFileStream);
fseek(pFileStream, 0, SEEK_SET);
// allocate a buffer for the source code string and read it in
char* cSourceString = (char *)malloc(szSourceLength + szPreambleLength + 1);
memcpy(cSourceString, cPreamble, szPreambleLength);
if(fread((cSourceString) + szPreambleLength, szSourceLength, 1, pFileStream) != 1) {
fclose(pFileStream);
free(cSourceString);
return 0;
}
// close the file and return the total length of the combined (preamble + source) string
fclose(pFileStream);
if(szFinalLength != 0) {
*szFinalLength = szSourceLength + szPreambleLength;
}
cSourceString[szSourceLength + szPreambleLength] = '\0';
return cSourceString;
}
const char* oclErrorString(cl_int error)
{
static const char* errorString[] = {
"CL_SUCCESS",
"CL_DEVICE_NOT_FOUND",
"CL_DEVICE_NOT_AVAILABLE",
"CL_COMPILER_NOT_AVAILABLE",
"CL_MEM_OBJECT_ALLOCATION_FAILURE",
"CL_OUT_OF_RESOURCES",
"CL_OUT_OF_HOST_MEMORY",
"CL_PROFILING_INFO_NOT_AVAILABLE",
"CL_MEM_COPY_OVERLAP",
"CL_IMAGE_FORMAT_MISMATCH",
"CL_IMAGE_FORMAT_NOT_SUPPORTED",
"CL_BUILD_PROGRAM_FAILURE",
"CL_MAP_FAILURE",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"CL_INVALID_VALUE",
"CL_INVALID_DEVICE_TYPE",
"CL_INVALID_PLATFORM",
"CL_INVALID_DEVICE",
"CL_INVALID_CONTEXT",
"CL_INVALID_QUEUE_PROPERTIES",
"CL_INVALID_COMMAND_QUEUE",
"CL_INVALID_HOST_PTR",
"CL_INVALID_MEM_OBJECT",
"CL_INVALID_IMAGE_FORMAT_DESCRIPTOR",
"CL_INVALID_IMAGE_SIZE",
"CL_INVALID_SAMPLER",
"CL_INVALID_BINARY",
"CL_INVALID_BUILD_OPTIONS",
"CL_INVALID_PROGRAM",
"CL_INVALID_PROGRAM_EXECUTABLE",
"CL_INVALID_KERNEL_NAME",
"CL_INVALID_KERNEL_DEFINITION",
"CL_INVALID_KERNEL",
"CL_INVALID_ARG_INDEX",
"CL_INVALID_ARG_VALUE",
"CL_INVALID_ARG_SIZE",
"CL_INVALID_KERNEL_ARGS",
"CL_INVALID_WORK_DIMENSION",
"CL_INVALID_WORK_GROUP_SIZE",
"CL_INVALID_WORK_ITEM_SIZE",
"CL_INVALID_GLOBAL_OFFSET",
"CL_INVALID_EVENT_WAIT_LIST",
"CL_INVALID_EVENT",
"CL_INVALID_OPERATION",
"CL_INVALID_GL_OBJECT",
"CL_INVALID_BUFFER_SIZE",
"CL_INVALID_MIP_LEVEL",
"CL_INVALID_GLOBAL_WORK_SIZE",
};
const int errorCount = sizeof(errorString) / sizeof(errorString[0]);
const int index = -error;
return (index >= 0 && index < errorCount) ? errorString[index] : "";
}
/*
const char* oclErrorString(int err) {
switch(err) {
case CL_SUCCESS: break;
case CL_DEVICE_NOT_FOUND: return "DEVICE NOT FOUND";
case CL_DEVICE_NOT_AVAILABLE: return "DEVICE NOT AVAILABLE";
case CL_COMPILER_NOT_AVAILABLE: return "COMPILER NOT AVAILABLE";
case CL_MEM_OBJECT_ALLOCATION_FAILURE: return "MEM OBJECT ALLOCATION FAILURE";
case CL_OUT_OF_RESOURCES: return "OUT OF RESOURCES";
case CL_OUT_OF_HOST_MEMORY: return "OUT OF HOST MEMORY";
case CL_PROFILING_INFO_NOT_AVAILABLE: return "PROFILING INFO NOT AVAILABLE";
case CL_MEM_COPY_OVERLAP: return "MEM COPY OVERLAP";
case CL_IMAGE_FORMAT_MISMATCH: return "IMAGE FORMAT MISMATCH";
case CL_IMAGE_FORMAT_NOT_SUPPORTED: return "IMAGE FORMAT NOT SUPPORTED";
case CL_BUILD_PROGRAM_FAILURE: return "BUILD PROGRAM FAILURE";
case CL_MAP_FAILURE: return "MAP FAILURE";
case CL_INVALID_DEVICE_TYPE: return "INVALID DEVICE TYPE";
case CL_INVALID_PLATFORM: return "INVALID PLATFORM";
case CL_INVALID_DEVICE: return "INVALID DEVICE";
case CL_INVALID_CONTEXT: return "INVALID CONTEXT";
case CL_INVALID_HOST_PTR: return "INVALID HOST PTR";
case CL_INVALID_MEM_OBJECT: return "INVALID MEM OBJECT";
case CL_INVALID_IMAGE_FORMAT_DESCRIPTOR: return "INVALID IMAGE FORMAT DESCRIPTOR";
case CL_INVALID_IMAGE_SIZE: return "INVALID IMAGE SIZE";
case CL_INVALID_SAMPLER: return "INVALID SAMPLER";
case CL_INVALID_BINARY: return "INVALID BINARY";
case CL_INVALID_BUILD_OPTIONS: return "INVALID BUILD OPTIONS";
case CL_INVALID_PROGRAM: return "INVALID PROGRAM";
case CL_INVALID_PROGRAM_EXECUTABLE: return "INVALID PROGRAM EXECUTABLE";
case CL_INVALID_KERNEL_NAME: return "INVALID KERNEL NAME";
case CL_INVALID_KERNEL_DEFINITION: return "INVALID KERNEL DEFINITION";
case CL_INVALID_KERNEL: return "INVALID KERNEL";
case CL_INVALID_ARG_INDEX: return "INVALID ARG INDEX";
case CL_INVALID_ARG_VALUE: return "INVALID ARG VALUE";
case CL_INVALID_ARG_SIZE: return "INVALID ARG SIZE";
case CL_INVALID_KERNEL_ARGS: return "INVALID KERNEL ARGS";
case CL_INVALID_WORK_DIMENSION: return "INVALID WORK DIMENSION";
case CL_INVALID_WORK_GROUP_SIZE: return "INVALID WORK GROUP SIZE";
case CL_INVALID_GLOBAL_OFFSET: return "INVALID GLOBAL OFFSET";
case CL_INVALID_EVENT_WAIT_LIST: return "INVALID EVENT WAIT LIST";
case CL_INVALID_EVENT: return "INVALID EVENT";
case CL_INVALID_OPERATION: return "INVALID OPERATION";
case CL_INVALID_GL_OBJECT: return "INVALID GL OBJECT";
case CL_INVALID_BUFFER_SIZE: return "INVALID BUFFER SIZE";
case CL_INVALID_MIP_LEVEL: return "INVALID MIP LEVEL";
case CL_INVALID_VALUE: return "INVALID_VALUE";
case CL_INVALID_QUEUE_PROPERTIES: return "INVALID_QUEUE_PROPERTIES";
case CL_INVALID_COMMAND_QUEUE: return "INVALID_COMMAND_QUEUE";
default: return "Unexpected error has occured";
}
}
*/
#endif // OCLUTILS_H_