Function getOpenCLCDeviceVersion

src/backend/opencl/platform.cpp:339–770

}

vector<Version> getOpenCLCDeviceVersion(const Device& device) {
    // For OpenCL-HPP >= v2023.12.14 type is cl::Platform instead of
    // cl_platform_id
    Platform device_platform;
    device_platform = device.getInfo<CL_DEVICE_PLATFORM>();

    auto platform_version = device_platform.getInfo<CL_PLATFORM_VERSION>();
    vector<Version> out;

    /// The ifdef allows us to support BUILDING ArrayFire with older
    /// versions of OpenCL where as the if condition in the ifdef allows us
    /// to support older versions of OpenCL at runtime
#ifdef CL_DEVICE_OPENCL_C_ALL_VERSIONS
    if (platform_version.substr(7).c_str()[0] >= '3') {
        vector<cl_name_version> device_versions =
            device.getInfo<CL_DEVICE_OPENCL_C_ALL_VERSIONS>();
        sort(begin(device_versions), end(device_versions),
             [](const auto& lhs, const auto& rhs) {
                 return lhs.version < rhs.version;
             });
        transform(begin(device_versions), end(device_versions),
                  std::back_inserter(out), [](const cl_name_version& version) {
                      return Version(CL_VERSION_MAJOR(version.version),
                                     CL_VERSION_MINOR(version.version),
                                     CL_VERSION_PATCH(version.version));
                  });
    } else {
#endif
        auto device_version = device.getInfo<CL_DEVICE_OPENCL_C_VERSION>();
        int major           = atoi(device_version.substr(9, 1).c_str());
        int minor           = atoi(device_version.substr(11, 1).c_str());
        out.emplace_back(major, minor);
#ifdef CL_DEVICE_OPENCL_C_ALL_VERSIONS
    }
#endif
    return out;
}

size_t getDeviceMemorySize(int device) {
    DeviceManager& devMngr = DeviceManager::getInstance();

    cl::Device dev;
    {
        common::lock_guard_t lock(devMngr.deviceMutex);
        // Assuming devices don't deallocate or are invalidated during execution
        dev = *devMngr.mDevices[device];
    }
    size_t msize = dev.getInfo<CL_DEVICE_GLOBAL_MEM_SIZE>();
    return msize;
}

size_t getHostMemorySize() { return common::getHostMemorySize(); }

cl_device_type getDeviceType() {
    const cl::Device& device = getDevice();
    cl_device_type type      = device.getInfo<CL_DEVICE_TYPE>();
    return type;
}