static QList<QCLDevice> qt_cl_getDevicesForPlatform
(QCLDevice::DeviceTypes types, const QCLPlatform &platform, bool break_on_first)
{
QList<QCLDevice> devs;
QList<QCLPlatform> platforms;
if (platform.isNull())
platforms = QCLPlatform::platforms();
else
platforms.append(platform);
for (int plat = 0; plat < platforms.size(); ++plat) {
cl_uint size;
if (clGetDeviceIDs(platforms[plat].platformId(), cl_device_type(types),
0, 0, &size) != CL_SUCCESS)
continue;
if (!size)
continue;
QVarLengthArray<cl_device_id> buf(size);
clGetDeviceIDs(platforms[plat].platformId(), cl_device_type(types),
size, buf.data(), &size);
for (int index = 0; index < buf.size(); ++index)
devs.append(QCLDevice(buf[index]));
if (break_on_first) break;
}
return devs;
}
//------------------------------------------------------------------------------
void print_devices(cl_platform_id pid) {
cl_uint numDevices = 0;
cl_int status = clGetDeviceIDs(pid, CL_DEVICE_TYPE_ALL,
0, 0, &numDevices );
if(status != CL_SUCCESS) {
std::cerr << "ERROR - clGetDeviceIDs" << std::endl;
exit(EXIT_FAILURE);
}
if(numDevices < 1) return;
typedef std::vector< cl_device_id > DeviceIds;
DeviceIds devices(numDevices);
status = clGetDeviceIDs(pid, CL_DEVICE_TYPE_ALL,
devices.size(), &devices[ 0 ], 0 );
if(status != CL_SUCCESS) {
std::cerr << "ERROR - clGetDeviceIDs" << std::endl;
exit(EXIT_FAILURE);
}
std::vector< char > buf(0x10000, char(0));
cl_uint d;
std::cout << "Number of devices: " << devices.size() << std::endl;
int dev = 0;
for(DeviceIds::const_iterator i = devices.begin();
i != devices.end(); ++i, ++dev) {
std::cout << "Device " << dev << std::endl;
// device type
cl_device_type dt = cl_device_type();
status = clGetDeviceInfo(*i, CL_DEVICE_TYPE,
sizeof(cl_device_type), &dt, 0);
if(status != CL_SUCCESS) {
std::cerr << "ERROR - clGetDeviceInfo(CL_DEVICE_TYPE)" << std::endl;
exit(EXIT_FAILURE);
}
std::cout << " Type: ";
if( dt & CL_DEVICE_TYPE_DEFAULT ) std::cout << "Default ";
if( dt & CL_DEVICE_TYPE_CPU ) std::cout << "CPU ";
if( dt & CL_DEVICE_TYPE_GPU ) std::cout << "GPU ";
if( dt & CL_DEVICE_TYPE_ACCELERATOR ) std::cout << "Accelerator ";
std::cout << std::endl;
// device name
status = clGetDeviceInfo(*i, CL_DEVICE_NAME,
buf.size(), &buf[0], 0);
if(status != CL_SUCCESS) {
std::cerr << "ERROR - clGetDeviceInfo(CL_DEVICE_NAME)" << std::endl;
exit(EXIT_FAILURE);
}
std::cout << " Name: " << &buf[0] << std::endl;
// device version
status = clGetDeviceInfo(*i, CL_DEVICE_VERSION,
buf.size(), &buf[0], 0);
if(status != CL_SUCCESS) {
std::cerr << "ERROR - clGetDeviceInfo(CL_DEVICE_VERSION)"
<< std::endl;
exit(EXIT_FAILURE);
}
std::cout << " Version: " << &buf[0] << std::endl;
// device vendor
status = clGetDeviceInfo(*i, CL_DEVICE_VENDOR,
buf.size(), &buf[0], 0);
if(status != CL_SUCCESS) {
std::cerr << "ERROR - clGetDeviceInfo(CL_DEVICE_VENDOR)"
<< std::endl;
exit(EXIT_FAILURE);
}
std::cout << " Vendor: " << &buf[0] << std::endl;
// device profile
status = clGetDeviceInfo(*i, CL_DEVICE_PROFILE,
buf.size(), &buf[0], 0);
if(status != CL_SUCCESS) {
std::cerr << "ERROR - clGetDeviceInfo(CL_DEVICE_PROFILE)"
<< std::endl;
exit(EXIT_FAILURE);
}
std::cout << " Profile: " << &buf[0] << std::endl;
// # compute units
status = clGetDeviceInfo(*i, CL_DEVICE_MAX_COMPUTE_UNITS,
sizeof(cl_uint), &d, 0);
if(status != CL_SUCCESS) {
std::cerr << "ERROR - clGetDeviceInfo(CL_DEVICE_MAX_COMPUTE_UNITS)"
<< std::endl;
exit(EXIT_FAILURE);
}
std::cout << " Compute units: " << d << std::endl;
// # work item dimensions
cl_uint maxWIDim = 0;
status = clGetDeviceInfo(*i, CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS,
sizeof(cl_uint), &maxWIDim, 0);
if(status != CL_SUCCESS) {
std::cerr << "ERROR - "
<< "clGetDeviceInfo(CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS)"
<< std::endl;
exit(EXIT_FAILURE);
}
std::cout << " Max work item dim: " << maxWIDim << std::endl;
// # work item sizes
std::vector< size_t > wiSizes(maxWIDim, size_t(0));
status = clGetDeviceInfo(*i, CL_DEVICE_MAX_WORK_ITEM_SIZES,
sizeof(size_t)*wiSizes.size(),
&wiSizes[0], 0);
if(status != CL_SUCCESS) {
std::cerr << "ERROR - "
<< "clGetDeviceInfo(CL_DEVICE_MAX_WORK_ITEM_SIZES)"
<< std::endl;
exit(EXIT_FAILURE);
}
std::cout << " Work item sizes:";
for(std::vector< size_t >::const_iterator s = wiSizes.begin();
s != wiSizes.end(); ++s) {
std::cout << ' ' << *s;
}
std::cout << std::endl;
// max clock frequency
status = clGetDeviceInfo(*i, CL_DEVICE_MAX_CLOCK_FREQUENCY,
sizeof(cl_uint), &d, 0);
if(status != CL_SUCCESS) {
std::cerr << "ERROR - "
<< "clGetDeviceInfo(CL_DEVICE_MAX_CLOCK_FREQUENCY)"
<< std::endl;
exit(EXIT_FAILURE);
}
std::cout << " Max clock freq: " << d << " MHz" << std::endl;
// global memory
cl_ulong m = 0;
status = clGetDeviceInfo(*i, CL_DEVICE_GLOBAL_MEM_SIZE,
sizeof(cl_ulong), &m, 0);
if(status != CL_SUCCESS) {
std::cerr << "ERROR - clGetDeviceInfo(CL_DEVICE_GLOBAL_MEM_SIZE)"
<< std::endl;
exit(EXIT_FAILURE);
}
std::cout << " Global memory: " << m << " bytes" << std::endl;
// local memory
m = 0;
status = clGetDeviceInfo(*i, CL_DEVICE_LOCAL_MEM_SIZE,
sizeof(cl_ulong), &m, 0);
if(status != CL_SUCCESS) {
std::cerr << "ERROR - clGetDeviceInfo(CL_DEVICE_LOCAL_MEM_SIZE)"
<< std::endl;
exit(EXIT_FAILURE);
}
std::cout << " Local memory: " << m << " bytes" << std::endl;
// max allocation size
m = 0;
status = clGetDeviceInfo(*i, CL_DEVICE_MAX_MEM_ALLOC_SIZE,
sizeof(cl_ulong), &m, 0);
if(status != CL_SUCCESS) {
std::cerr << "ERROR - clGetDeviceInfo(CL_DEVICE_MAX_MEM_ALLOC_SIZE)"
<< std::endl;
exit(EXIT_FAILURE);
}
std::cout << " Maximum size of allocatable object: " << m << " bytes" << std::endl;
}
}
