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; }