std::vector<cl_platform_id> get_platform_ids()
{
cl_uint numPlatforms;
::clGetPlatformIDs(0, NULL, &numPlatforms);
std::vector<cl_platform_id> platformIDs(numPlatforms);
::clGetPlatformIDs(numPlatforms, &platformIDs[0], NULL);
return platformIDs;
//std::vector<cl_platform_id> platformIDs;
//for(PlatformMap::const_iterator pItr = gPlatforms.begin(); pItr != gPlatforms.end(); ++pItr)
//{
// platformIDs.push_back(pItr->first);
//}
//return platformIDs;
}
//------------------------------------------------------------------------------
// returns context associated with single device only,
// to make it support multiple devices, a list of
// <device type, device num> pairs is required
cl_context create_cl_context(const std::string& platformName,
const std::string& deviceTypeName,
int deviceNum) {
cl_int status = 0;
//1) get platfors and search for platform matching platformName
cl_uint numPlatforms = 0;
status = clGetPlatformIDs(0, 0, &numPlatforms);
check_cl_error(status, "clGetPlatformIDs");
if(numPlatforms < 1) {
std::cout << "No OpenCL platforms found" << std::endl;
exit(EXIT_SUCCESS);
}
typedef std::vector< cl_platform_id > PlatformIDs;
PlatformIDs platformIDs(numPlatforms);
status = clGetPlatformIDs(numPlatforms, &platformIDs[0], 0);
check_cl_error(status, "clGetPlatformIDs");
std::vector< char > buf(0x10000, char(0));
cl_platform_id platformID;
PlatformIDs::const_iterator pi = platformIDs.begin();
for(; pi != platformIDs.end(); ++pi) {
status = clGetPlatformInfo(*pi, CL_PLATFORM_NAME,
buf.size(), &buf[0], 0);
check_cl_error(status, "clGetPlatformInfo");
if(platformName == &buf[0]) {
platformID = *pi;
break;
}
}
if(pi == platformIDs.end()) {
std::cerr << "ERROR - Couldn't find platform "
<< platformName << std::endl;
exit(EXIT_FAILURE);
}
//2) get devices of deviceTypeName type and store their ids into
// an array then select device id at position deviceNum
cl_device_type deviceType;
if(deviceTypeName == "default")
deviceType = CL_DEVICE_TYPE_DEFAULT;
else if(deviceTypeName == "cpu")
deviceType = CL_DEVICE_TYPE_CPU;
else if(deviceTypeName == "gpu")
deviceType = CL_DEVICE_TYPE_GPU;
else if(deviceTypeName == "acc")
deviceType = CL_DEVICE_TYPE_ACCELERATOR;
else if(deviceTypeName == "all")
deviceType = CL_DEVICE_TYPE_CPU;
else {
std::cerr << "ERROR - device type " << deviceTypeName << " unknown"
<< std::endl;
exit(EXIT_FAILURE);
}
cl_uint numDevices = 0;
status = clGetDeviceIDs(platformID, deviceType, 0, 0, &numDevices);
check_cl_error(status, "clGetDeviceIDs");
if(numDevices < 1) {
std::cerr << "ERROR - Cannot find device of type "
<< deviceTypeName << std::endl;
exit(EXIT_FAILURE);
}
typedef std::vector< cl_device_id > DeviceIDs;
DeviceIDs deviceIDs(numDevices);
status = clGetDeviceIDs(platformID, deviceType, numDevices,
&deviceIDs[0], 0);
check_cl_error(status, "clGetDeviceIDs");
if(deviceNum < 0 || deviceNum >= numDevices) {
std::cerr << "ERROR - device number out of range: [0,"
<< (numDevices - 1) << ']' << std::endl;
exit(EXIT_FAILURE);
}
cl_device_id deviceID = deviceIDs[deviceNum];
//3) create and return context
cl_context_properties ctxProps[] = {
CL_CONTEXT_PLATFORM,
cl_context_properties(platformID),
0
};
//only a single device supported
cl_context ctx = clCreateContext(ctxProps, 1, &deviceID,
&context_callback, 0, &status);
check_cl_error(status, "clCreateContext");
return ctx;
}
int XdevLComputeDeviceCL::init() {
cl_int ret;
cl_uint numPlatforms;
ret = clGetPlatformIDs(1, &m_platformID, &numPlatforms);
if(CL_SUCCESS != ret) {
XDEVL_MODULEX_ERROR(XdevLComputeDeviceCL, "clGetPlatformIDs failed: " << clErrorAsString(ret) << std::endl);
return -1;
}
std::vector<cl_platform_id> platformIDs(numPlatforms);
ret = clGetPlatformIDs(1, platformIDs.data(), nullptr);
for(auto platform : platformIDs) {
XdevLPlatformInfo info;
info.id = platform;
std::size_t size;
ret = clGetPlatformInfo(platform, CL_PLATFORM_PROFILE, sizeof(info.profile), (void*)info.profile, &size);
ret = clGetPlatformInfo(platform, CL_PLATFORM_VERSION, sizeof(info.version), (void*)info.version, &size);
ret = clGetPlatformInfo(platform, CL_PLATFORM_NAME, sizeof(info.name), (void*)info.name, &size);
ret = clGetPlatformInfo(platform, CL_PLATFORM_VENDOR, sizeof(info.vendor), (void*)info.vendor, &size);
if(CL_SUCCESS != ret) {
XDEVL_MODULEX_ERROR(XdevLComputeDeviceCL, "clGetPlatformInfo failed: " << clErrorAsString(ret) << std::endl);
return -1;
}
std::cout << "Platform Name : " << info.name << std::endl;
std::cout << "Platform Profile : " << info.profile << std::endl;
std::cout << "Platform Version : " << info.version << std::endl;
std::cout << "Platform Vendor : " << info.vendor << std::endl;
m_platforms.push_back(std::move(info));
}
for(auto platform : m_platforms) {
cl_uint numDevices;
ret = clGetDeviceIDs(platform.id, CL_DEVICE_TYPE_ALL, 1, &m_deviceID, &numDevices);
if(CL_SUCCESS != ret) {
XDEVL_MODULEX_ERROR(XdevLComputeDeviceCL, "clGetDeviceIDs failed: " << clErrorAsString(ret) << std::endl);
return -1;
}
std::cout << "OpenCL Number of devices: " << numDevices << ", ID: " << m_deviceID << std::endl;
XdevLDeviceInfo device;
device.id = m_deviceID;
std::size_t size;
ret = clGetDeviceInfo(m_deviceID, CL_DEVICE_NAME, sizeof(device.name), (void*)device.name, &size);
ret = clGetDeviceInfo(m_deviceID, CL_DEVICE_VENDOR, sizeof(device.vendor), (void*)device.vendor, &size);
ret = clGetDeviceInfo(m_deviceID, CL_DRIVER_VERSION, sizeof(device.version), (void*)device.version, &size);
ret = clGetDeviceInfo(m_deviceID, CL_DEVICE_PROFILE, sizeof(device.profile), (void*)device.profile, &size);
if(CL_SUCCESS != ret) {
return -1;
}
std::cout << "Device Profile : " << device.profile << std::endl;
std::cout << "Device Name : " << device.name << std::endl;
std::cout << "Device Version : " << device.version << std::endl;
std::cout << "Device Vendor : " << device.vendor << std::endl;
m_devices.push_back(std::move(device));
}
return 0;
}
