void Platform::getInfo(cl_platform_info paramName, size_t paramValueSize, void *paramValue) const
{
cl_int err = 0;
err = clGetPlatformInfo(platformID(), paramName, paramValueSize, paramValue, nullptr);
if(err != CL_SUCCESS) {
throw OpenCLException(err);
}
}
void Program::getBuildInfo(cl_program_build_info paramName, const Device& device, size_t paramValueSize, void *paramValue) const
{
cl_int err = 0;
size_t written = 0;
err = clGetProgramBuildInfo(programHandle(), device.deviceID(), paramName, paramValueSize, paramValue, &written);
if(err != CL_SUCCESS) {
throw OpenCLException(err);
}
}
void Program::getInfo(cl_program_info paramName, size_t paramValueSize, void *paramValue) const
{
cl_int err = 0;
size_t written = 0;
err = clGetProgramInfo(programHandle(), paramName, paramValueSize, paramValue, &written);
if(err != CL_SUCCESS) {
throw OpenCLException(err);
}
}
Kernel Program::createKernel(const Epic::Core::ASCIIString& kernelName) const
{
cl_int err = 0;
cl_kernel kernel = clCreateKernel(programHandle(), kernelName.data(), &err);
if(err != CL_SUCCESS) {
throw OpenCLException(err);
}
return Kernel(kernel);
}
void Kernel::getInfo(cl_kernel_info paramName, size_t paramValueSize, void *paramValue) const
{
cl_int err = 0;
size_t written = 0;
err = clGetKernelInfo(kernelHandle(), paramName, paramValueSize, paramValue, &written);
if(err != CL_SUCCESS) {
throw OpenCLException(err);
}
}
size_t Platform::getInfoSize(cl_platform_info paramName) const
{
size_t ret;
cl_int err = 0;
err = clGetPlatformInfo(platformID(), paramName, 0, nullptr, &ret);
if(err != CL_SUCCESS) {
throw OpenCLException(err);
}
return ret;
}
size_t Program::getBuildInfoSize(cl_program_build_info paramName, const Device& device) const
{
size_t ret;
cl_int err = 0;
err = clGetProgramBuildInfo(programHandle(), device.deviceID(), paramName, 0, nullptr, &ret);
if(err != CL_SUCCESS) {
throw OpenCLException(err);
}
return ret;
}
size_t Program::getInfoSize(cl_program_info paramName) const
{
size_t ret;
cl_int err = 0;
err = clGetProgramInfo(programHandle(), paramName, 0, nullptr, &ret);
if(err != CL_SUCCESS) {
throw OpenCLException(err);
}
return ret;
}
size_t Kernel::getInfoSize(cl_kernel_info paramName) const
{
size_t ret;
cl_int err = 0;
err = clGetKernelInfo(kernelHandle(), paramName, 0, nullptr, &ret);
if(err != CL_SUCCESS) {
throw OpenCLException(err);
}
return ret;
}
bool Program::build(const Epic::Core::Array<Device>& devices,
const Epic::Core::ASCIIString& options) const
{
Array<cl_device_id> deviceArray;
size_t numDevices = 0;
if(devices.isEmpty()) {
numDevices = devices.count();
deviceArray = deviceIDHelper(devices);
}
cl_int err = clBuildProgram(programHandle(), numDevices, deviceArray.data(), options.data(), nullptr, nullptr);
/* Skip CL_BUILD_PROGRAM_FAILURE error, will be handled later in this code. */
if((err != CL_BUILD_PROGRAM_FAILURE) && (err != CL_SUCCESS)) {
throw OpenCLException(err);
}
Epic::Core::Array<Device> devs;
bool ret = true;
if(devices.isEmpty()) {
devs = this->devices();
} else {
devs = devices;
}
for(size_t i = 0; i < devs.count(); i++) {
cl_build_status status = buildStatus(devs[i]);
cout << "Build log for device " << devs[i].deviceID() << endl;
cout << buildLog(devs[i]) << endl;
while(status == CL_BUILD_IN_PROGRESS) {
status = buildStatus(devs[i]);
}
if(status == CL_BUILD_SUCCESS) {
cout << "Program compilation successful" << endl;
} else {
cout << "Program compilation failed" << endl;
}
ret &= (status == CL_BUILD_SUCCESS);
}
return ret;
}
Buffer::Buffer(const Context& context,
BufferKernelAccess kernelAccess,
size_t size)
{
cl_int errNum;
cl_mem_flags flags = cl_mem_flags(kernelAccess);
_handle = clCreateBuffer(context.getHandle(),
flags,
size,
nullptr,
&errNum);
if (errNum != CL_SUCCESS)
throw OpenCLException(errNum);
}
Buffer::Buffer(const Context& context,
BufferKernelAccess kernelAccess,
BufferStorage storage,
void* data,
size_t size)
{
cl_int errNum;
cl_mem_flags flags = cl_mem_flags(kernelAccess) | cl_mem_flags(storage);
_handle = clCreateBuffer(context.getHandle(),
flags,
size,
data,
&errNum);
if (errNum != CL_SUCCESS)
throw OpenCLException(errNum);
}
Epic::Core::Array<Device> Platform::devices(cl_device_type deviceType) const
{
Epic::Core::Array<Device> ret;
cl_uint numDevices = 0;
clGetDeviceIDs(platformID(), deviceType, 0, nullptr, &numDevices);
if(numDevices > 0) {
cl_device_id *devices = new cl_device_id[numDevices];
int err = clGetDeviceIDs(platformID(), deviceType, numDevices, devices, nullptr);
if(err != CL_SUCCESS) {
throw OpenCLException(err);
}
ret = deviceIDToDeviceHelper(devices, numDevices);
delete [] devices;
}
return ret;
}
Epic::Core::Array<Platform> Platform::getPlatformIDs()
{
Epic::Core::Array<Platform> ret;
cl_uint numPlatforms = 0;
clGetPlatformIDs(0, nullptr, &numPlatforms);
if(numPlatforms > 0) {
cl_platform_id *platforms = new cl_platform_id[numPlatforms];
int err = clGetPlatformIDs(numPlatforms, platforms, nullptr);
if(err != CL_SUCCESS) {
throw OpenCLException(err);
}
for(cl_uint i = 0; i < numPlatforms; i++) {
ret << Platform(platforms[i]);
}
delete [] platforms;
}
return ret;
}
