SEXP getDeviceIDs(SEXP sPlatformID){
resetError("ROpenCL::getDeviceIDs");
Rcpp::XPtr<cl_platform_id> platformID(sPlatformID);
cl_uint num_GPUs = 0;
logError( clGetDeviceIDs(*platformID, CL_DEVICE_TYPE_GPU, 0, 0, &num_GPUs) );
std::vector<cl_device_id> gpus(num_GPUs);
logError( clGetDeviceIDs(*platformID, CL_DEVICE_TYPE_GPU, num_GPUs, gpus.empty() ? NULL : &gpus.front(), &num_GPUs) );
cl_uint num_nonGPUs = 0;
logError( clGetDeviceIDs(*platformID, ~CL_DEVICE_TYPE_GPU, 0, 0, &num_nonGPUs) );
std::vector<cl_device_id> devices(num_nonGPUs);
logError( clGetDeviceIDs(*platformID, ~CL_DEVICE_TYPE_GPU, num_nonGPUs, devices.empty() ? NULL : &devices.front(), &num_nonGPUs) );
//for each device in devices add its pointer to the return list
Rcpp::List result(gpus.size() + devices.size());
//To be more compatible with the previous version of this function, put GPUs first in the result list.
for (int i=0; i<gpus.size(); i++){
cl_device_id *tempDeviceID = new cl_device_id;
*tempDeviceID = gpus[i];
Rcpp::XPtr<cl_device_id> tempXPtr(tempDeviceID);
result[i] = tempXPtr;
}
for (int i=0; i<devices.size(); i++){
cl_device_id *tempDeviceID = new cl_device_id;
*tempDeviceID = devices[i];
Rcpp::XPtr<cl_device_id> tempXPtr(tempDeviceID);
result[i+gpus.size()] = tempXPtr;
}
PRINTONERROR();
return result;
}
SEXP createBufferFloatVector(SEXP sContext, SEXP sMemFlag, SEXP sGlobalWorkSize){
Rcpp::XPtr<cl_context> context(sContext);
std::string memFlag = Rcpp::as<std::string>(sMemFlag);
int globalWorkSize = Rcpp::as<int>(sGlobalWorkSize);
cl_mem *memBuffer = new cl_mem;
cl_int ciErr1;
if(memFlag == "CL_MEM_READ_ONLY"){
//clCreateBuffer(cxGPUContext, CL_MEM_READ_ONLY, sizeof(cl_float) * szGlobalWorkSize, NULL, &ciErr2);
*memBuffer = clCreateBuffer(*context, CL_MEM_READ_ONLY, sizeof(cl_float) * globalWorkSize, NULL, &ciErr1);
if (ciErr1 != CL_SUCCESS){ std::cout << "error creating buffer float vector\n"; };
if (ciErr1 == CL_INVALID_CONTEXT){std::cout << "invalid context";};
if (ciErr1 == CL_INVALID_VALUE){std::cout << "invalid value";};
if (ciErr1 == CL_INVALID_BUFFER_SIZE){std::cout << "invalid buffer size";};
if (ciErr1 == CL_INVALID_HOST_PTR){std::cout << "invalid host ptr";};
if (ciErr1 == CL_MEM_OBJECT_ALLOCATION_FAILURE){std::cout << "mem object allocation fail";};
if (ciErr1 == CL_OUT_OF_RESOURCES){std::cout << "OOR";};
if (ciErr1 == CL_OUT_OF_HOST_MEMORY){std::cout << "OOHM";};
}
if(memFlag == "CL_MEM_WRITE_ONLY"){
*memBuffer = clCreateBuffer(*context, CL_MEM_WRITE_ONLY, sizeof(cl_float) * globalWorkSize, NULL, &ciErr1);
if (ciErr1 != CL_SUCCESS){ std::cout << "error creating buffer float vector\n"; };
if (ciErr1 == CL_INVALID_CONTEXT){std::cout << "invalid context";};
if (ciErr1 == CL_INVALID_VALUE){std::cout << "invalid value";};
if (ciErr1 == CL_INVALID_BUFFER_SIZE){std::cout << "invalid buffer size";};
if (ciErr1 == CL_INVALID_HOST_PTR){std::cout << "invalid host ptr";};
if (ciErr1 == CL_MEM_OBJECT_ALLOCATION_FAILURE){std::cout << "mem object allocation fail";};
if (ciErr1 == CL_OUT_OF_RESOURCES){std::cout << "OOR";};
if (ciErr1 == CL_OUT_OF_HOST_MEMORY){std::cout << "OOHM";};
}
Rcpp::XPtr<cl_mem> tempXPtr(memBuffer);
return tempXPtr;
}
SEXP buildProgram(SEXP sProgram){
Rcpp::XPtr<cl_program> program(sProgram);
cl_int ciErr1 = clBuildProgram(*program, 0, NULL, NULL, NULL, NULL);
printOnError(ciErr1,"ROpenCL::buildProgram()");
Rcpp::XPtr<cl_program> tempXPtr(program);
return tempXPtr;
}
SEXP createContext(SEXP sDeviceID){
Rcpp::XPtr<cl_device_id> deviceID(sDeviceID);
cl_context *context = new cl_context;
*context = clCreateContext(0, 1, deviceID, NULL, NULL, NULL);
Rcpp::XPtr<cl_context> tempXPtr(context);
return tempXPtr;
}
SEXP createCommandQueue(SEXP sContext, SEXP sDeviceID){
Rcpp::XPtr<cl_context> context(sContext);
Rcpp::XPtr<cl_device_id> deviceID(sDeviceID);
cl_command_queue *queue = new cl_command_queue;
*queue = clCreateCommandQueue(*context, *deviceID, 0, NULL);
Rcpp::XPtr<cl_command_queue> tempXPtr(queue);
return tempXPtr;
}
SEXP createKernel(SEXP sProgram, SEXP sKernelName){
Rcpp::XPtr<cl_program> program(sProgram);
std::string kernelName = Rcpp::as<std::string>(sKernelName);
cl_kernel *kernel = new cl_kernel;
*kernel = clCreateKernel(*program, kernelName.data(), NULL);
Rcpp::XPtr<cl_kernel> tempXPtr(kernel);
return tempXPtr;
}
SEXP createProgramWithSource(SEXP sContext, SEXP sKernelSrc){
Rcpp::XPtr<cl_context> context(sContext);
std::string kernelSrc = Rcpp::as<std::string>(sKernelSrc);
const char* tmpKernelSrc = kernelSrc.data();
cl_program *program = new cl_program;
*program = clCreateProgramWithSource(*context, 1, &tmpKernelSrc, NULL, NULL);
Rcpp::XPtr<cl_program> tempXPtr(program);
return tempXPtr;
}
SEXP createContextFromType(SEXP deviceType){
//We need to look at this, because this does not seem to work...
std::string deviceString = Rcpp::as<std::string>(deviceType);
cl_context *context = new cl_context;
if(deviceString == "CL_DEVICE_TYPE_GPU"){
*context = clCreateContextFromType(NULL, CL_DEVICE_TYPE_GPU, NULL, NULL, NULL);
}
Rcpp::XPtr<cl_context> tempXPtr(context);
return tempXPtr;
}
SEXP setKernelArgInt(SEXP sKernel, SEXP sIndex, SEXP sIntegerValue){
Rcpp::XPtr<cl_kernel> kernel(sKernel);
int argNr = Rcpp::as<int>(sIndex);
int integerValue = Rcpp::as<int>(sIntegerValue);
cl_int ciErr1 = clSetKernelArg(*kernel, argNr, sizeof(cl_int), (void*)&integerValue);
if (ciErr1 != CL_SUCCESS){ std::cout << "error setting kernel arguments\n"; };
Rcpp::XPtr<cl_kernel> tempXPtr(kernel);
return tempXPtr;
}
SEXP setKernelArgFloat(SEXP sKernel, SEXP sIndex, SEXP sFloatValue){
Rcpp::XPtr<cl_kernel> kernel(sKernel);
int argNr = Rcpp::as<int>(sIndex);
float floatValue = Rcpp::as<float>(sFloatValue);
cl_int ciErr1 = clSetKernelArg(*kernel, argNr, sizeof(float), (void*)&floatValue);
printOnError(ciErr1,"ROpenCL::setKernelArgFloat()");
Rcpp::XPtr<cl_kernel> tempXPtr(kernel);
return tempXPtr;
}
SEXP setKernelArgMem(SEXP sKernel, SEXP sIndex, SEXP sBuffer){
Rcpp::XPtr<cl_kernel> kernel(sKernel);
int argNr = Rcpp::as<int>(sIndex);
Rcpp::XPtr<cl_mem> memObject(sBuffer);
cl_int ciErr1 = clSetKernelArg(*kernel, argNr, sizeof(cl_mem), memObject);
printOnError(ciErr1,"ROpenCL::setKernelArgMem()");
Rcpp::XPtr<cl_kernel> tempXPtr(kernel);
return tempXPtr;
}
SEXP createBufferIntegerVector(SEXP sContext, SEXP sMemFlag, SEXP sGlobalWorkSize){
Rcpp::XPtr<cl_context> context(sContext);
int globalWorkSize = Rcpp::as<int>(sGlobalWorkSize);
cl_mem_flags flags = getMemFlags(sMemFlag);
cl_mem *memBuffer = new cl_mem;
cl_int ciErr1 = CL_SUCCESS;
*memBuffer = clCreateBuffer(*context, flags, sizeof(int) * globalWorkSize, NULL, &ciErr1);
printOnError(ciErr1,"ROpenCL::createBufferIntegerVector()");
Rcpp::XPtr<cl_mem> tempXPtr(memBuffer);
return tempXPtr;
}
SEXP getPlatformIDs(){
//returns a list of platform ids
cl_uint num_platforms = 0;
clGetPlatformIDs(0, 0, &num_platforms);
std::vector<cl_platform_id> platforms(num_platforms);
clGetPlatformIDs(num_platforms, platforms.empty() ? NULL : &platforms.front(), &num_platforms);
//for each platform in platforms add its pointer to the return list
Rcpp::List result(platforms.size());
for (int i=0; i<platforms.size(); i++){
cl_platform_id *tempPlatformID = new cl_platform_id;
*tempPlatformID = platforms[i];
Rcpp::XPtr<cl_platform_id> tempXPtr(tempPlatformID);
result[i] = tempXPtr;
}
return result;
}
SEXP getDeviceIDs(SEXP sPlatformID){
Rcpp::XPtr<cl_platform_id> platformID(sPlatformID);
cl_uint num_devices = 0;
clGetDeviceIDs(*platformID, CL_DEVICE_TYPE_GPU, 0, 0, &num_devices);
std::vector<cl_device_id> devices(num_devices);
clGetDeviceIDs(*platformID, CL_DEVICE_TYPE_GPU, num_devices, devices.empty() ? NULL : &devices.front(), &num_devices);
//for each platform in platforms add its pointer to the return list
Rcpp::List result(devices.size());
for (int i=0; i<devices.size(); i++){
cl_device_id *tempDeviceID = new cl_device_id;
*tempDeviceID = devices[i];
Rcpp::XPtr<cl_device_id> tempXPtr(tempDeviceID);
result[i] = tempXPtr;
}
return result;
}
SEXP setKernelArgMem(SEXP sKernel, SEXP sIndex, SEXP sBuffer){
Rcpp::XPtr<cl_kernel> kernel(sKernel);
int argNr = Rcpp::as<int>(sIndex);
Rcpp::XPtr<cl_mem> memObject(sBuffer);
cl_int ciErr1 = clSetKernelArg(*kernel, argNr, sizeof(cl_mem), memObject);
if (ciErr1 != CL_SUCCESS){ std::cout << "error setting kernel arguments\n"; };
if (ciErr1 == CL_INVALID_KERNEL){std::cout << "invalid kernel";};
if (ciErr1 == CL_INVALID_ARG_INDEX){std::cout << "invalid arg index";};
if (ciErr1 == CL_INVALID_ARG_VALUE){std::cout << "invalid arg value";};
if (ciErr1 == CL_INVALID_MEM_OBJECT){std::cout << "invalid mem object";};
if (ciErr1 == CL_INVALID_SAMPLER){std::cout << "invalid sampler";};
if (ciErr1 == CL_INVALID_ARG_SIZE){std::cout << "invalid arg size";};
if (ciErr1 == CL_OUT_OF_RESOURCES){std::cout << "OOR";};
if (ciErr1 == CL_OUT_OF_HOST_MEMORY){std::cout << "OOHM";};
Rcpp::XPtr<cl_kernel> tempXPtr(kernel);
return tempXPtr;
}
SEXP buildProgram(SEXP sProgram){
Rcpp::XPtr<cl_program> program(sProgram);
cl_int ciErr1 = clBuildProgram(*program, 0, NULL, NULL, NULL, NULL);
if (ciErr1 != CL_SUCCESS)
{
std::cout << "error building program";
}
if (ciErr1 == CL_INVALID_PROGRAM){std::cout << "invalid program";};
if (ciErr1 == CL_INVALID_VALUE){std::cout << "invalid value";};
if (ciErr1 == CL_INVALID_DEVICE){std::cout << "invalid device";};
if (ciErr1 == CL_INVALID_BUILD_OPTIONS){std::cout << "invalid build options";};
if (ciErr1 == CL_INVALID_OPERATION){std::cout << "invalid operation";};
if (ciErr1 == CL_COMPILER_NOT_AVAILABLE){std::cout << "compiler NA";};
if (ciErr1 == CL_BUILD_PROGRAM_FAILURE){std::cout << "build program fail";};
if (ciErr1 == CL_OUT_OF_RESOURCES){std::cout << "OOR";};
if (ciErr1 == CL_OUT_OF_HOST_MEMORY){std::cout << "OOHM";};
Rcpp::XPtr<cl_program> tempXPtr(program);
return tempXPtr;
}
