Media/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-09-15 13:01:45 +08:00
Code Issues Packages Projects Releases Wiki Activity

Add ClDeviceInfo

Browse Source 
DeviceInfo contains a subset of ClDeviceInfo values.

Related-To: NEO-3938

Change-Id: Idae4fae4d25e1fb3106d8b95294fa70ebc6281df
Signed-off-by: Filip Hazubski <filip.hazubski@intel.com>
This commit is contained in:
Filip Hazubski
2020-03-05 18:13:32 +01:00
committed by sys_ocldev
parent c5454d6cce
commit 5ac8d8e667
83 changed files with 682 additions and 554 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
opencl/source/context/context.cpp
View File

@ -279,8 +279,8 @@ cl_int Context::getSupportedImageFormats(
cl_image_format *imageFormats,
cl_uint *numImageFormatsReturned) {
size_t numImageFormats = 0;
const bool nv12ExtensionEnabled = device->getDeviceInfo().nv12Extension;
const bool packedYuvExtensionEnabled = device->getDeviceInfo().packedYuvExtension;
const bool nv12ExtensionEnabled = device->getSpecializedDevice<ClDevice>()->getDeviceInfo().nv12Extension;
const bool packedYuvExtensionEnabled = device->getSpecializedDevice<ClDevice>()->getDeviceInfo().packedYuvExtension;
auto appendImageFormats = [&](ArrayRef<const ClSurfaceFormatInfo> formats) {
if (imageFormats) {

30
opencl/source/device/cl_device.cpp
View File

@ -14,6 +14,7 @@
#include "shared/source/program/sync_buffer_handler.h"
#include "shared/source/source_level_debugger/source_level_debugger.h"
#include "opencl/source/device/driver_info.h"
#include "opencl/source/platform/extensions.h"
#include "opencl/source/platform/platform.h"
@ -22,15 +23,23 @@ namespace NEO {
ClDevice::ClDevice(Device &device, Platform *platform) : device(device), platformId(platform) {
device.incRefInternal();
device.setSpecializedDevice(this);
deviceExtensions.reserve(1000);
name.reserve(100);
auto osInterface = getRootDeviceEnvironment().osInterface.get();
driverInfo.reset(DriverInfo::create(osInterface));
initializeCaps();
compilerExtensions = convertEnabledExtensionsToCompilerInternalOptions(getDeviceInfo().deviceExtensions);
compilerExtensions = convertEnabledExtensionsToCompilerInternalOptions(deviceInfo.deviceExtensions);
auto numAvailableDevices = device.getNumAvailableDevices();
if (numAvailableDevices > 1) {
for (uint32_t i = 0; i < numAvailableDevices; i++) {
auto &coreSubDevice = static_cast<SubDevice &>(*device.getDeviceById(i));
auto &deviceInfo = coreSubDevice.getMutableDeviceInfo();
deviceInfo.parentDevice = device.getSpecializedDevice<ClDevice>();
auto pClSubDevice = std::make_unique<ClDevice>(coreSubDevice, platform);
pClSubDevice->incRefInternal();
pClSubDevice->decRefApi();
auto &deviceInfo = pClSubDevice->deviceInfo;
deviceInfo.parentDevice = this;
deviceInfo.partitionMaxSubDevices = 0;
deviceInfo.partitionProperties[0] = 0;
deviceInfo.partitionAffinityDomain = 0;
@ -38,13 +47,10 @@ ClDevice::ClDevice(Device &device, Platform *platform) : device(device), platfor
deviceInfo.partitionType[1] = CL_DEVICE_AFFINITY_DOMAIN_NUMA;
deviceInfo.partitionType[2] = 0;
auto pClSubDevice = std::make_unique<ClDevice>(coreSubDevice, platform);
pClSubDevice->incRefInternal();
pClSubDevice->decRefApi();
subDevices.push_back(std::move(pClSubDevice));
}
}
if (device.getDeviceInfo().debuggerActive) {
if (deviceInfo.debuggerActive) {
auto osInterface = device.getRootDeviceEnvironment().osInterface.get();
getSourceLevelDebugger()->notifyNewDevice(osInterface ? osInterface->getDeviceHandle() : 0);
}
@ -52,7 +58,7 @@ ClDevice::ClDevice(Device &device, Platform *platform) : device(device), platfor
ClDevice::~ClDevice() {
if (device.getDeviceInfo().debuggerActive && getSourceLevelDebugger()) {
if (deviceInfo.debuggerActive) {
getSourceLevelDebugger()->notifyDeviceDestruction();
}
@ -71,11 +77,10 @@ void ClDevice::allocateSyncBufferHandler() {
}
}
unsigned int ClDevice::getEnabledClVersion() const { return device.getEnabledClVersion(); }
unsigned int ClDevice::getSupportedClVersion() const { return device.getSupportedClVersion(); }
void ClDevice::retainApi() {
auto parentDeviceId = device.getDeviceInfo().parentDevice;
auto parentDeviceId = deviceInfo.parentDevice;
if (parentDeviceId) {
auto pParentClDevice = static_cast<ClDevice *>(parentDeviceId);
pParentClDevice->incRefInternal();
@ -83,7 +88,7 @@ void ClDevice::retainApi() {
}
};
unique_ptr_if_unused<ClDevice> ClDevice::releaseApi() {
auto parentDeviceId = device.getDeviceInfo().parentDevice;
auto parentDeviceId = deviceInfo.parentDevice;
if (!parentDeviceId) {
return unique_ptr_if_unused<ClDevice>(this, false);
}
@ -103,7 +108,6 @@ ClDevice *ClDevice::getDeviceById(uint32_t deviceId) {
bool ClDevice::getDeviceAndHostTimer(uint64_t *deviceTimestamp, uint64_t *hostTimestamp) const { return device.getDeviceAndHostTimer(deviceTimestamp, hostTimestamp); }
bool ClDevice::getHostTimer(uint64_t *hostTimestamp) const { return device.getHostTimer(hostTimestamp); }
const HardwareInfo &ClDevice::getHardwareInfo() const { return device.getHardwareInfo(); }
const DeviceInfo &ClDevice::getDeviceInfo() const { return device.getDeviceInfo(); }
EngineControl &ClDevice::getEngine(aub_stream::EngineType engineType, bool lowPriority) { return device.getEngine(engineType, lowPriority); }
EngineControl &ClDevice::getDefaultEngine() { return device.getDefaultEngine(); }
EngineControl &ClDevice::getInternalEngine() { return device.getInternalEngine(); }
@ -118,6 +122,7 @@ GFXCORE_FAMILY ClDevice::getRenderCoreFamily() const { return device.getRenderCo
PerformanceCounters *ClDevice::getPerformanceCounters() { return device.getPerformanceCounters(); }
PreemptionMode ClDevice::getPreemptionMode() const { return device.getPreemptionMode(); }
bool ClDevice::isDebuggerActive() const { return device.isDebuggerActive(); }
Debugger *ClDevice::getDebugger() { return device.getDebugger(); }
SourceLevelDebugger *ClDevice::getSourceLevelDebugger() { return reinterpret_cast<SourceLevelDebugger *>(device.getDebugger()); }
ExecutionEnvironment *ClDevice::getExecutionEnvironment() const { return device.getExecutionEnvironment(); }
const RootDeviceEnvironment &ClDevice::getRootDeviceEnvironment() const { return device.getRootDeviceEnvironment(); }
@ -147,4 +152,5 @@ void ClDeviceVector::toDeviceIDs(std::vector<cl_device_id> &devIDs) {
const std::string &ClDevice::peekCompilerExtensions() const {
return compilerExtensions;
}
} // namespace NEO

26
opencl/source/device/cl_device.h
View File

@ -19,19 +19,21 @@
#include <vector>
namespace NEO {
class Debugger;
class Device;
class DriverInfo;
class ExecutionEnvironment;
class GmmHelper;
class GmmClientContext;
class MemoryManager;
class PerformanceCounters;
class Platform;
class SourceLevelDebugger;
class SyncBufferHandler;
struct EngineControl;
struct HardwareCapabilities;
struct HardwareInfo;
struct RootDeviceEnvironment;
class Platform;
template <>
struct OpenCLObjectMapper<_cl_device_id> {
@ -48,7 +50,7 @@ class ClDevice : public BaseObject<_cl_device_id> {
explicit ClDevice(Device &device, Platform *platformId);
~ClDevice() override;
unsigned int getEnabledClVersion() const; //CL
unsigned int getEnabledClVersion() const { return enabledClVersion; };
unsigned int getSupportedClVersion() const;
void retainApi();
@ -57,7 +59,6 @@ class ClDevice : public BaseObject<_cl_device_id> {
bool getDeviceAndHostTimer(uint64_t *deviceTimestamp, uint64_t *hostTimestamp) const;
bool getHostTimer(uint64_t *hostTimestamp) const;
const HardwareInfo &getHardwareInfo() const;
const DeviceInfo &getDeviceInfo() const;
EngineControl &getEngine(aub_stream::EngineType engineType, bool lowPriority);
EngineControl &getDefaultEngine();
EngineControl &getInternalEngine();
@ -73,6 +74,7 @@ class ClDevice : public BaseObject<_cl_device_id> {
PerformanceCounters *getPerformanceCounters();
PreemptionMode getPreemptionMode() const;
bool isDebuggerActive() const;
Debugger *getDebugger();
SourceLevelDebugger *getSourceLevelDebugger();
ExecutionEnvironment *getExecutionEnvironment() const;
const RootDeviceEnvironment &getRootDeviceEnvironment() const;
@ -105,18 +107,30 @@ class ClDevice : public BaseObject<_cl_device_id> {
size_t &retSize);
Device &getDevice() const noexcept { return device; }
const ClDeviceInfo &getDeviceInfo() const { return deviceInfo; }
ClDevice *getDeviceById(uint32_t deviceId);
void initializeCaps();
const std::string &peekCompilerExtensions() const;
std::unique_ptr<SyncBufferHandler> syncBufferHandler;
protected:
void copyCommonCapsFromDevice();
void initializeCaps();
void initializeExtraCaps();
void setupFp64Flags();
Device &device;
std::vector<std::unique_ptr<ClDevice>> subDevices;
cl_platform_id platformId;
std::string name;
std::unique_ptr<DriverInfo> driverInfo;
unsigned int enabledClVersion = 0u;
std::string deviceExtensions;
std::string exposedBuiltinKernels = "";
ClDeviceInfo deviceInfo = {};
std::vector<unsigned int> simultaneousInterops = {0};
void appendOSExtensions(std::string &deviceExtensions);
std::string compilerExtensions;
};
@ -124,7 +138,7 @@ template <cl_device_info Param>
inline void ClDevice::getCap(const void *&src,
size_t &size,
size_t &retSize) {
src = &DeviceInfoTable::Map<Param>::getValue(getDeviceInfo());
src = &DeviceInfoTable::Map<Param>::getValue(deviceInfo);
retSize = size = DeviceInfoTable::Map<Param>::size;
}

242
opencl/source/device/device_caps.cpp
View File

@ -14,6 +14,7 @@
#include "shared/source/os_interface/os_interface.h"
#include "shared/source/source_level_debugger/source_level_debugger.h"
#include "opencl/source/device/cl_device.h"
#include "opencl/source/device/driver_info.h"
#include "opencl/source/platform/extensions.h"
#include "opencl/source/sharings/sharing_factory.h"
@ -45,7 +46,7 @@ static constexpr cl_device_fp_config defaultFpFlags = static_cast<cl_device_fp_c
bool releaseFP64Override();
void Device::setupFp64Flags() {
void ClDevice::setupFp64Flags() {
auto &hwInfo = getHardwareInfo();
if (releaseFP64Override() || DebugManager.flags.OverrideDefaultFP64Settings.get() == 1) {
@ -69,15 +70,166 @@ void Device::setupFp64Flags() {
}
void Device::initializeCaps() {
auto &hwInfo = getHardwareInfo();
auto hwInfoConfig = HwInfoConfig::get(hwInfo.platform.eProductFamily);
auto addressing32bitAllowed = is64bit;
auto &hwHelper = HwHelper::get(hwInfo.platform.eRenderCoreFamily);
deviceInfo.ilVersion = "";
auto enabledClVersion = hwInfo.capabilityTable.clVersionSupport;
if (DebugManager.flags.ForceOCLVersion.get() != 0) {
enabledClVersion = DebugManager.flags.ForceOCLVersion.get();
}
switch (enabledClVersion) {
case 21:
deviceInfo.ilVersion = spirvVersion;
addressing32bitAllowed = false;
break;
case 20:
addressing32bitAllowed = false;
break;
}
deviceInfo.vendorId = 0x8086;
deviceInfo.maxReadImageArgs = 128;
deviceInfo.maxWriteImageArgs = 128;
deviceInfo.maxParameterSize = 1024;
deviceInfo.addressBits = 64;
//copy system info to prevent misaligned reads
const auto systemInfo = hwInfo.gtSystemInfo;
deviceInfo.globalMemCachelineSize = 64;
deviceInfo.globalMemSize = getMemoryManager()->isLocalMemorySupported(this->getRootDeviceIndex())
? getMemoryManager()->getLocalMemorySize(this->getRootDeviceIndex())
: getMemoryManager()->getSystemSharedMemory(this->getRootDeviceIndex());
deviceInfo.globalMemSize = std::min(deviceInfo.globalMemSize, getMemoryManager()->getMaxApplicationAddress() + 1);
deviceInfo.globalMemSize = static_cast<uint64_t>(static_cast<double>(deviceInfo.globalMemSize) * 0.8);
if (DebugManager.flags.Force32bitAddressing.get() || addressing32bitAllowed || is32bit) {
deviceInfo.globalMemSize = std::min(deviceInfo.globalMemSize, static_cast<uint64_t>(4 * GB * 0.8));
deviceInfo.addressBits = 32;
deviceInfo.force32BitAddressess = is64bit;
}
deviceInfo.globalMemSize = alignDown(deviceInfo.globalMemSize, MemoryConstants::pageSize);
deviceInfo.profilingTimerResolution = getProfilingTimerResolution();
deviceInfo.outProfilingTimerResolution = static_cast<size_t>(deviceInfo.profilingTimerResolution);
deviceInfo.maxOnDeviceQueues = 1;
// OpenCL 1.2 requires 128MB minimum
deviceInfo.maxMemAllocSize = std::min(std::max(deviceInfo.globalMemSize / 2, static_cast<uint64_t>(128llu * MB)), this->hardwareCapabilities.maxMemAllocSize);
static const int maxPixelSize = 16;
deviceInfo.imageMaxBufferSize = static_cast<size_t>(deviceInfo.maxMemAllocSize / maxPixelSize);
deviceInfo.maxNumEUsPerSubSlice = 0;
deviceInfo.numThreadsPerEU = 0;
auto simdSizeUsed = DebugManager.flags.UseMaxSimdSizeToDeduceMaxWorkgroupSize.get() ? 32u : hwHelper.getMinimalSIMDSize();
deviceInfo.maxNumEUsPerSubSlice = (systemInfo.EuCountPerPoolMin == 0 || hwInfo.featureTable.ftrPooledEuEnabled == 0)
? (systemInfo.EUCount / systemInfo.SubSliceCount)
: systemInfo.EuCountPerPoolMin;
deviceInfo.numThreadsPerEU = systemInfo.ThreadCount / systemInfo.EUCount;
auto maxWS = hwHelper.getMaxThreadsForWorkgroup(hwInfo, static_cast<uint32_t>(deviceInfo.maxNumEUsPerSubSlice)) * simdSizeUsed;
maxWS = Math::prevPowerOfTwo(maxWS);
deviceInfo.maxWorkGroupSize = std::min(maxWS, 1024u);
if (DebugManager.flags.OverrideMaxWorkgroupSize.get() != -1) {
deviceInfo.maxWorkGroupSize = DebugManager.flags.OverrideMaxWorkgroupSize.get();
}
deviceInfo.maxWorkItemSizes[0] = deviceInfo.maxWorkGroupSize;
deviceInfo.maxWorkItemSizes[1] = deviceInfo.maxWorkGroupSize;
deviceInfo.maxWorkItemSizes[2] = deviceInfo.maxWorkGroupSize;
deviceInfo.maxSamplers = 16;
deviceInfo.computeUnitsUsedForScratch = hwHelper.getComputeUnitsUsedForScratch(&hwInfo);
deviceInfo.maxFrontEndThreads = HwHelper::getMaxThreadsForVfe(hwInfo);
deviceInfo.localMemSize = hwInfo.capabilityTable.slmSize * KB;
deviceInfo.imageSupport = hwInfo.capabilityTable.supportsImages;
deviceInfo.image2DMaxWidth = 16384;
deviceInfo.image2DMaxHeight = 16384;
deviceInfo.image3DMaxDepth = 2048;
deviceInfo.imageMaxArraySize = 2048;
deviceInfo.printfBufferSize = 4 * 1024 * 1024;
deviceInfo.maxClockFrequency = hwInfo.capabilityTable.maxRenderFrequency;
deviceInfo.maxSubGroups = hwHelper.getDeviceSubGroupSizes();
deviceInfo.vmeAvcSupportsPreemption = hwInfo.capabilityTable.ftrSupportsVmeAvcPreemption;
deviceInfo.debuggerActive = (executionEnvironment->debugger) ? executionEnvironment->debugger->isDebuggerActive() : false;
if (deviceInfo.debuggerActive) {
this->preemptionMode = PreemptionMode::Disabled;
}
deviceInfo.sharedSystemAllocationsSupport = hwInfoConfig->getSharedSystemMemCapabilities();
if (DebugManager.flags.EnableSharedSystemUsmSupport.get() != -1) {
deviceInfo.sharedSystemAllocationsSupport = DebugManager.flags.EnableSharedSystemUsmSupport.get();
}
}
void ClDevice::copyCommonCapsFromDevice() {
auto &sourceDeviceInfo = device.getDeviceInfo();
deviceInfo.maxSubGroups = sourceDeviceInfo.maxSubGroups;
deviceInfo.debuggerActive = sourceDeviceInfo.debuggerActive;
deviceInfo.errorCorrectionSupport = sourceDeviceInfo.errorCorrectionSupport;
deviceInfo.force32BitAddressess = sourceDeviceInfo.force32BitAddressess;
deviceInfo.imageSupport = sourceDeviceInfo.imageSupport;
deviceInfo.vmeAvcSupportsPreemption = sourceDeviceInfo.vmeAvcSupportsPreemption;
deviceInfo.ilVersion = sourceDeviceInfo.ilVersion;
deviceInfo.profilingTimerResolution = sourceDeviceInfo.profilingTimerResolution;
deviceInfo.addressBits = sourceDeviceInfo.addressBits;
deviceInfo.computeUnitsUsedForScratch = sourceDeviceInfo.computeUnitsUsedForScratch;
deviceInfo.globalMemCachelineSize = sourceDeviceInfo.globalMemCachelineSize;
deviceInfo.maxClockFrequency = sourceDeviceInfo.maxClockFrequency;
deviceInfo.maxFrontEndThreads = sourceDeviceInfo.maxFrontEndThreads;
deviceInfo.maxOnDeviceQueues = sourceDeviceInfo.maxOnDeviceQueues;
deviceInfo.maxReadImageArgs = sourceDeviceInfo.maxReadImageArgs;
deviceInfo.maxSamplers = sourceDeviceInfo.maxSamplers;
deviceInfo.maxWriteImageArgs = sourceDeviceInfo.maxWriteImageArgs;
deviceInfo.numThreadsPerEU = sourceDeviceInfo.numThreadsPerEU;
deviceInfo.vendorId = sourceDeviceInfo.vendorId;
deviceInfo.globalMemSize = sourceDeviceInfo.globalMemSize;
deviceInfo.image2DMaxHeight = static_cast<size_t>(sourceDeviceInfo.image2DMaxHeight);
deviceInfo.image2DMaxWidth = static_cast<size_t>(sourceDeviceInfo.image2DMaxWidth);
deviceInfo.image3DMaxDepth = static_cast<size_t>(sourceDeviceInfo.image3DMaxDepth);
deviceInfo.imageMaxArraySize = static_cast<size_t>(sourceDeviceInfo.imageMaxArraySize);
deviceInfo.imageMaxBufferSize = static_cast<size_t>(sourceDeviceInfo.imageMaxBufferSize);
deviceInfo.localMemSize = sourceDeviceInfo.localMemSize;
deviceInfo.maxMemAllocSize = sourceDeviceInfo.maxMemAllocSize;
deviceInfo.maxNumEUsPerSubSlice = static_cast<size_t>(sourceDeviceInfo.maxNumEUsPerSubSlice);
deviceInfo.maxParameterSize = static_cast<size_t>(sourceDeviceInfo.maxParameterSize);
deviceInfo.maxWorkGroupSize = static_cast<size_t>(sourceDeviceInfo.maxWorkGroupSize);
deviceInfo.maxWorkItemSizes[0] = static_cast<size_t>(sourceDeviceInfo.maxWorkItemSizes[0]);
deviceInfo.maxWorkItemSizes[1] = static_cast<size_t>(sourceDeviceInfo.maxWorkItemSizes[1]);
deviceInfo.maxWorkItemSizes[2] = static_cast<size_t>(sourceDeviceInfo.maxWorkItemSizes[2]);
deviceInfo.outProfilingTimerResolution = static_cast<size_t>(sourceDeviceInfo.outProfilingTimerResolution);
deviceInfo.printfBufferSize = static_cast<size_t>(sourceDeviceInfo.printfBufferSize);
}
void ClDevice::initializeCaps() {
copyCommonCapsFromDevice();
auto &hwInfo = getHardwareInfo();
auto hwInfoConfig = HwInfoConfig::get(hwInfo.platform.eProductFamily);
deviceExtensions.clear();
deviceExtensions.append(deviceExtensionsList);
// Add our graphics family name to the device name
auto addressing32bitAllowed = is64bit;
driverVersion = TOSTR(NEO_DRIVER_VERSION);
// Add our graphics family name to the device name
name += "Intel(R) ";
name += familyName[hwInfo.platform.eRenderCoreFamily];
name += " HD Graphics NEO";
@ -96,7 +248,6 @@ void Device::initializeCaps() {
deviceInfo.vendor = vendor.c_str();
deviceInfo.profile = profile.c_str();
deviceInfo.ilVersion = "";
enabledClVersion = hwInfo.capabilityTable.clVersionSupport;
if (DebugManager.flags.ForceOCLVersion.get() != 0) {
enabledClVersion = DebugManager.flags.ForceOCLVersion.get();
@ -105,13 +256,10 @@ void Device::initializeCaps() {
case 21:
deviceInfo.clVersion = "OpenCL 2.1 NEO ";
deviceInfo.clCVersion = "OpenCL C 2.0 ";
deviceInfo.ilVersion = spirvVersion;
addressing32bitAllowed = false;
break;
case 20:
deviceInfo.clVersion = "OpenCL 2.0 NEO ";
deviceInfo.clCVersion = "OpenCL C 2.0 ";
addressing32bitAllowed = false;
break;
case 12:
default:
@ -205,7 +353,6 @@ void Device::initializeCaps() {
deviceInfo.builtInKernels = exposedBuiltinKernels.c_str();
deviceInfo.deviceType = CL_DEVICE_TYPE_GPU;
deviceInfo.vendorId = 0x8086;
deviceInfo.endianLittle = 1;
deviceInfo.hostUnifiedMemory = (false == hwHelper.isLocalMemoryEnabled(hwInfo));
deviceInfo.deviceAvailable = CL_TRUE;
@ -236,43 +383,20 @@ void Device::initializeCaps() {
deviceInfo.nativeVectorWidthFloat = 1;
deviceInfo.nativeVectorWidthDouble = 1;
deviceInfo.nativeVectorWidthHalf = 8;
deviceInfo.maxReadImageArgs = 128;
deviceInfo.maxWriteImageArgs = 128;
deviceInfo.maxReadWriteImageArgs = 128;
deviceInfo.maxParameterSize = 1024;
deviceInfo.executionCapabilities = CL_EXEC_KERNEL;
deviceInfo.addressBits = 64;
//copy system info to prevent misaligned reads
const auto systemInfo = hwInfo.gtSystemInfo;
deviceInfo.globalMemCachelineSize = 64;
deviceInfo.globalMemCacheSize = systemInfo.L3BankCount * 128 * KB;
deviceInfo.grfSize = hwInfo.capabilityTable.grfSize;
deviceInfo.globalMemSize = getMemoryManager()->isLocalMemorySupported(this->getRootDeviceIndex())
? getMemoryManager()->getLocalMemorySize(this->getRootDeviceIndex())
: getMemoryManager()->getSystemSharedMemory(this->getRootDeviceIndex());
deviceInfo.globalMemSize = std::min(deviceInfo.globalMemSize, (cl_ulong)(getMemoryManager()->getMaxApplicationAddress() + 1));
deviceInfo.globalMemSize = (cl_ulong)((double)deviceInfo.globalMemSize * 0.8);
if (DebugManager.flags.Force32bitAddressing.get() || addressing32bitAllowed || is32bit) {
deviceInfo.globalMemSize = std::min(deviceInfo.globalMemSize, (uint64_t)(4 * GB * 0.8));
deviceInfo.addressBits = 32;
deviceInfo.force32BitAddressess = is64bit;
}
deviceInfo.globalMemSize = alignDown(deviceInfo.globalMemSize, MemoryConstants::pageSize);
deviceInfo.globalMemCacheType = CL_READ_WRITE_CACHE;
deviceInfo.profilingTimerResolution = getProfilingTimerResolution();
deviceInfo.outProfilingTimerResolution = static_cast<size_t>(deviceInfo.profilingTimerResolution);
deviceInfo.memBaseAddressAlign = 1024;
deviceInfo.minDataTypeAlignSize = 128;
deviceInfo.maxOnDeviceEvents = 1024;
deviceInfo.maxOnDeviceQueues = 1;
deviceInfo.queueOnDeviceMaxSize = 64 * MB;
deviceInfo.queueOnDevicePreferredSize = 128 * KB;
deviceInfo.queueOnDeviceProperties = CL_QUEUE_PROFILING_ENABLE | CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE;
@ -280,47 +404,25 @@ void Device::initializeCaps() {
deviceInfo.preferredInteropUserSync = 1u;
// OpenCL 1.2 requires 128MB minimum
deviceInfo.maxMemAllocSize = std::min(std::max(deviceInfo.globalMemSize / 2, static_cast<uint64_t>(128llu * MB)), this->hardwareCapabilities.maxMemAllocSize);
deviceInfo.maxConstantBufferSize = deviceInfo.maxMemAllocSize;
static const int maxPixelSize = 16;
deviceInfo.imageMaxBufferSize = static_cast<size_t>(deviceInfo.maxMemAllocSize / maxPixelSize);
deviceInfo.maxWorkItemDimensions = 3;
deviceInfo.maxComputUnits = systemInfo.EUCount;
deviceInfo.maxConstantArgs = 8;
deviceInfo.maxNumEUsPerSubSlice = 0;
deviceInfo.maxSliceCount = systemInfo.SliceCount;
deviceInfo.numThreadsPerEU = 0;
auto simdSizeUsed = DebugManager.flags.UseMaxSimdSizeToDeduceMaxWorkgroupSize.get() ? 32u : hwHelper.getMinimalSIMDSize();
deviceInfo.maxNumEUsPerSubSlice = (systemInfo.EuCountPerPoolMin == 0 || hwInfo.featureTable.ftrPooledEuEnabled == 0)
? (systemInfo.EUCount / systemInfo.SubSliceCount)
: systemInfo.EuCountPerPoolMin;
deviceInfo.numThreadsPerEU = systemInfo.ThreadCount / systemInfo.EUCount;
auto maxWS = hwHelper.getMaxThreadsForWorkgroup(hwInfo, static_cast<uint32_t>(deviceInfo.maxNumEUsPerSubSlice)) * simdSizeUsed;
maxWS = Math::prevPowerOfTwo(maxWS);
deviceInfo.maxWorkGroupSize = std::min(maxWS, 1024u);
if (DebugManager.flags.OverrideMaxWorkgroupSize.get() != -1) {
deviceInfo.maxWorkGroupSize = DebugManager.flags.OverrideMaxWorkgroupSize.get();
}
// calculate a maximum number of subgroups in a workgroup (for the required SIMD size)
deviceInfo.maxNumOfSubGroups = static_cast<uint32_t>(deviceInfo.maxWorkGroupSize / simdSizeUsed);
deviceInfo.maxWorkItemSizes[0] = deviceInfo.maxWorkGroupSize;
deviceInfo.maxWorkItemSizes[1] = deviceInfo.maxWorkGroupSize;
deviceInfo.maxWorkItemSizes[2] = deviceInfo.maxWorkGroupSize;
deviceInfo.maxSamplers = 16;
deviceInfo.singleFpConfig |= defaultFpFlags;
deviceInfo.halfFpConfig = defaultFpFlags;
printDebugString(DebugManager.flags.PrintDebugMessages.get(), stderr, "computeUnitsUsedForScratch: %d\n", deviceInfo.computeUnitsUsedForScratch);
printDebugString(DebugManager.flags.PrintDebugMessages.get(), stderr, "hwInfo: {%d, %d}: (%d, %d, %d)\n",
systemInfo.EUCount,
systemInfo.ThreadCount,
@ -328,21 +430,10 @@ void Device::initializeCaps() {
systemInfo.MaxSlicesSupported,
systemInfo.MaxSubSlicesSupported);
deviceInfo.computeUnitsUsedForScratch = hwHelper.getComputeUnitsUsedForScratch(&hwInfo);
deviceInfo.maxFrontEndThreads = HwHelper::getMaxThreadsForVfe(hwInfo);
printDebugString(DebugManager.flags.PrintDebugMessages.get(), stderr, "computeUnitsUsedForScratch: %d\n", deviceInfo.computeUnitsUsedForScratch);
deviceInfo.localMemType = CL_LOCAL;
deviceInfo.localMemSize = hwInfo.capabilityTable.slmSize * KB;
deviceInfo.imageSupport = hwInfo.capabilityTable.supportsImages;
deviceInfo.image2DMaxWidth = 16384;
deviceInfo.image2DMaxHeight = 16384;
deviceInfo.image3DMaxWidth = this->hardwareCapabilities.image3DMaxWidth;
deviceInfo.image3DMaxHeight = this->hardwareCapabilities.image3DMaxHeight;
deviceInfo.image3DMaxDepth = 2048;
deviceInfo.imageMaxArraySize = 2048;
deviceInfo.image3DMaxWidth = this->getHardwareCapabilities().image3DMaxWidth;
deviceInfo.image3DMaxHeight = this->getHardwareCapabilities().image3DMaxHeight;
// cl_khr_image2d_from_buffer
deviceInfo.imagePitchAlignment = hwHelper.getPitchAlignmentForImage(&hwInfo);
@ -352,11 +443,6 @@ void Device::initializeCaps() {
deviceInfo.pipeMaxActiveReservations = 1;
deviceInfo.queueOnHostProperties = CL_QUEUE_PROFILING_ENABLE | CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE;
deviceInfo.printfBufferSize = 4 * 1024 * 1024;
deviceInfo.maxClockFrequency = hwInfo.capabilityTable.maxRenderFrequency;
deviceInfo.maxSubGroups = hwHelper.getDeviceSubGroupSizes();
deviceInfo.linkerAvailable = true;
deviceInfo.svmCapabilities = hwInfo.capabilityTable.ftrSvm * CL_DEVICE_SVM_COARSE_GRAIN_BUFFER;
deviceInfo.svmCapabilities |= static_cast<cl_device_svm_capabilities>(
@ -364,12 +450,11 @@ void Device::initializeCaps() {
(CL_DEVICE_SVM_FINE_GRAIN_BUFFER | CL_DEVICE_SVM_ATOMICS));
deviceInfo.preemptionSupported = false;
deviceInfo.maxGlobalVariableSize = 64 * 1024;
deviceInfo.globalVariablePreferredTotalSize = (size_t)deviceInfo.maxMemAllocSize;
deviceInfo.globalVariablePreferredTotalSize = static_cast<size_t>(deviceInfo.maxMemAllocSize);
deviceInfo.planarYuvMaxWidth = 16384;
deviceInfo.planarYuvMaxHeight = 16352;
deviceInfo.vmeAvcSupportsPreemption = hwInfo.capabilityTable.ftrSupportsVmeAvcPreemption;
deviceInfo.vmeAvcSupportsTextureSampler = hwInfo.capabilityTable.ftrSupportsVmeAvcTextureSampler;
if (hwInfo.capabilityTable.supportsVme) {
deviceInfo.vmeAvcVersion = CL_AVC_ME_VERSION_1_INTEL;
@ -383,11 +468,6 @@ void Device::initializeCaps() {
deviceInfo.preferredLocalAtomicAlignment = MemoryConstants::cacheLineSize;
deviceInfo.preferredPlatformAtomicAlignment = MemoryConstants::cacheLineSize;
deviceInfo.debuggerActive = (executionEnvironment->debugger) ? executionEnvironment->debugger->isDebuggerActive() : false;
if (deviceInfo.debuggerActive) {
this->preemptionMode = PreemptionMode::Disabled;
}
deviceInfo.hostMemCapabilities = hwInfoConfig->getHostMemCapabilities();
deviceInfo.deviceMemCapabilities = hwInfoConfig->getDeviceMemCapabilities();
deviceInfo.singleDeviceSharedMemCapabilities = hwInfoConfig->getSingleDeviceSharedMemCapabilities();
@ -400,6 +480,8 @@ void Device::initializeCaps() {
deviceInfo.sharedSystemMemCapabilities = CL_UNIFIED_SHARED_MEMORY_ACCESS_INTEL | CL_UNIFIED_SHARED_MEMORY_ATOMIC_ACCESS_INTEL | CL_UNIFIED_SHARED_MEMORY_CONCURRENT_ACCESS_INTEL | CL_UNIFIED_SHARED_MEMORY_CONCURRENT_ATOMIC_ACCESS_INTEL;
}
}
initializeExtraCaps();
}
} // namespace NEO

14
opencl/source/device/device_info.cpp
View File

@ -26,16 +26,16 @@ template <cl_device_info Param>
inline void ClDevice::getStr(const void *&src,
size_t &size,
size_t &retSize) {
src = Map<Param>::getValue(device.getDeviceInfo());
retSize = size = strlen(Map<Param>::getValue(device.getDeviceInfo())) + 1;
src = Map<Param>::getValue(deviceInfo);
retSize = size = strlen(Map<Param>::getValue(deviceInfo)) + 1;
}
template <>
inline void ClDevice::getCap<CL_DEVICE_MAX_WORK_ITEM_SIZES>(const void *&src,
size_t &size,
size_t &retSize) {
src = device.getDeviceInfo().maxWorkItemSizes;
retSize = size = sizeof(device.getDeviceInfo().maxWorkItemSizes);
src = deviceInfo.maxWorkItemSizes;
retSize = size = sizeof(deviceInfo.maxWorkItemSizes);
}
template <>
@ -184,7 +184,7 @@ cl_int ClDevice::getDeviceInfo(cl_device_info paramName,
break;
}
default:
if (getDeviceInfoForImage(paramName, src, srcSize, retSize) && !device.getDeviceInfo().imageSupport) {
if (getDeviceInfoForImage(paramName, src, srcSize, retSize) && !deviceInfo.imageSupport) {
src = &value;
break;
}
@ -243,14 +243,14 @@ bool ClDevice::getDeviceInfoForImage(cl_device_info paramName,
getCap<CL_DEVICE_IMAGE_PITCH_ALIGNMENT>(src, srcSize, retSize);
break;
case CL_DEVICE_PLANAR_YUV_MAX_WIDTH_INTEL:
if (getDeviceInfo().nv12Extension) {
if (deviceInfo.nv12Extension) {
getCap<CL_DEVICE_PLANAR_YUV_MAX_WIDTH_INTEL>(src, srcSize, retSize);
break;
}
retVal = false;
break;
case CL_DEVICE_PLANAR_YUV_MAX_HEIGHT_INTEL:
if (getDeviceInfo().nv12Extension) {
if (deviceInfo.nv12Extension) {
getCap<CL_DEVICE_PLANAR_YUV_MAX_HEIGHT_INTEL>(src, srcSize, retSize);
break;
}

39
opencl/source/device/device_info.h
View File

@ -16,7 +16,7 @@
#include <cstdint>
// clang-format off
struct DeviceInfo {
struct ClDeviceInfo {
StackVec<size_t, 3> maxSubGroups;
cl_device_type deviceType;
size_t maxWorkGroupSize;
@ -146,3 +146,40 @@ struct DeviceInfo {
cl_unified_shared_memory_capabilities_intel sharedSystemMemCapabilities;
};
// clang-format on
struct DeviceInfo {
StackVec<size_t, 3> maxSubGroups;
bool debuggerActive;
bool errorCorrectionSupport;
bool force32BitAddressess;
bool imageSupport;
bool sharedSystemAllocationsSupport;
bool vmeAvcSupportsPreemption;
const char *ilVersion;
double profilingTimerResolution;
uint32_t addressBits;
uint32_t computeUnitsUsedForScratch;
uint32_t globalMemCachelineSize;
uint32_t maxClockFrequency;
uint32_t maxFrontEndThreads;
uint32_t maxOnDeviceQueues;
uint32_t maxReadImageArgs;
uint32_t maxSamplers;
uint32_t maxWriteImageArgs;
uint32_t numThreadsPerEU;
uint32_t vendorId;
uint64_t globalMemSize;
uint64_t image2DMaxHeight;
uint64_t image2DMaxWidth;
uint64_t image3DMaxDepth;
uint64_t imageMaxArraySize;
uint64_t imageMaxBufferSize;
uint64_t localMemSize;
uint64_t maxMemAllocSize;
uint64_t maxNumEUsPerSubSlice;
uint64_t maxParameterSize;
uint64_t maxWorkGroupSize;
uint64_t maxWorkItemSizes[3];
uint64_t outProfilingTimerResolution;
uint64_t printfBufferSize;
};

214
opencl/source/device/device_info_map.h
View File

@ -14,13 +14,13 @@
#include <CL/cl_ext.h>
namespace DeviceInfoTable {
template <cl_device_info Param, typename _Type, _Type DeviceInfo::*val>
template <cl_device_info Param, typename _Type, _Type ClDeviceInfo::*val>
struct MapBase {
enum { param = Param };
typedef _Type Type;
enum { size = sizeof(Type) };
static const Type &getValue(const DeviceInfo &deviceInfo) {
static const Type &getValue(const ClDeviceInfo &deviceInfo) {
return deviceInfo.*val;
}
};
@ -37,110 +37,110 @@ struct Map {};
//////////////////////////////////////////////////////
// clang-format off
// please keep alphabetical order
template<> struct Map<CL_DEVICE_ADDRESS_BITS > : public MapBase<CL_DEVICE_ADDRESS_BITS, unsigned int, &DeviceInfo::addressBits> {};
template<> struct Map<CL_DEVICE_AVAILABLE > : public MapBase<CL_DEVICE_AVAILABLE, uint32_t, &DeviceInfo::deviceAvailable> {};
template<> struct Map<CL_DEVICE_AVC_ME_SUPPORTS_PREEMPTION_INTEL > : public MapBase<CL_DEVICE_AVC_ME_SUPPORTS_PREEMPTION_INTEL, uint32_t, &DeviceInfo::vmeAvcSupportsPreemption> {};
template<> struct Map<CL_DEVICE_AVC_ME_SUPPORTS_TEXTURE_SAMPLER_USE_INTEL > : public MapBase<CL_DEVICE_AVC_ME_SUPPORTS_TEXTURE_SAMPLER_USE_INTEL, uint32_t, &DeviceInfo::vmeAvcSupportsTextureSampler> {};
template<> struct Map<CL_DEVICE_AVC_ME_VERSION_INTEL > : public MapBase<CL_DEVICE_AVC_ME_VERSION_INTEL, uint32_t, &DeviceInfo::vmeAvcVersion> {};
template<> struct Map<CL_DEVICE_BUILT_IN_KERNELS > : public MapBase<CL_DEVICE_BUILT_IN_KERNELS, const char *, &DeviceInfo::builtInKernels> {};
template<> struct Map<CL_DEVICE_COMPILER_AVAILABLE > : public MapBase<CL_DEVICE_COMPILER_AVAILABLE, uint32_t, &DeviceInfo::compilerAvailable> {};
template<> struct Map<CL_DEVICE_CROSS_DEVICE_SHARED_MEM_CAPABILITIES_INTEL > : public MapBase<CL_DEVICE_CROSS_DEVICE_SHARED_MEM_CAPABILITIES_INTEL, uint64_t, &DeviceInfo::crossDeviceSharedMemCapabilities> {};
template<> struct Map<CL_DEVICE_DEVICE_MEM_CAPABILITIES_INTEL > : public MapBase<CL_DEVICE_DEVICE_MEM_CAPABILITIES_INTEL, uint64_t, &DeviceInfo::deviceMemCapabilities> {};
template<> struct Map<CL_DEVICE_DOUBLE_FP_CONFIG > : public MapBase<CL_DEVICE_DOUBLE_FP_CONFIG, uint64_t, &DeviceInfo::doubleFpConfig> {};
template<> struct Map<CL_DEVICE_DRIVER_VERSION_INTEL > : public MapBase<CL_DEVICE_DRIVER_VERSION_INTEL, uint32_t, &DeviceInfo::internalDriverVersion> {};
template<> struct Map<CL_DEVICE_ENDIAN_LITTLE > : public MapBase<CL_DEVICE_ENDIAN_LITTLE, uint32_t, &DeviceInfo::endianLittle> {};
template<> struct Map<CL_DEVICE_ERROR_CORRECTION_SUPPORT > : public MapBase<CL_DEVICE_ERROR_CORRECTION_SUPPORT, uint32_t, &DeviceInfo::errorCorrectionSupport> {};
template<> struct Map<CL_DEVICE_EXECUTION_CAPABILITIES > : public MapBase<CL_DEVICE_EXECUTION_CAPABILITIES, uint64_t, &DeviceInfo::executionCapabilities> {};
template<> struct Map<CL_DEVICE_EXTENSIONS > : public MapBase<CL_DEVICE_EXTENSIONS, const char *, &DeviceInfo::deviceExtensions> {};
template<> struct Map<CL_DEVICE_GLOBAL_MEM_CACHELINE_SIZE > : public MapBase<CL_DEVICE_GLOBAL_MEM_CACHELINE_SIZE, unsigned int, &DeviceInfo::globalMemCachelineSize> {};
template<> struct Map<CL_DEVICE_GLOBAL_MEM_CACHE_SIZE > : public MapBase<CL_DEVICE_GLOBAL_MEM_CACHE_SIZE, uint64_t, &DeviceInfo::globalMemCacheSize> {};
template<> struct Map<CL_DEVICE_GLOBAL_MEM_CACHE_TYPE > : public MapBase<CL_DEVICE_GLOBAL_MEM_CACHE_TYPE, uint32_t, &DeviceInfo::globalMemCacheType> {};
template<> struct Map<CL_DEVICE_GLOBAL_MEM_SIZE > : public MapBase<CL_DEVICE_GLOBAL_MEM_SIZE, uint64_t, &DeviceInfo::globalMemSize> {};
template<> struct Map<CL_DEVICE_GLOBAL_VARIABLE_PREFERRED_TOTAL_SIZE > : public MapBase<CL_DEVICE_GLOBAL_VARIABLE_PREFERRED_TOTAL_SIZE, size_t, &DeviceInfo::globalVariablePreferredTotalSize> {};
template<> struct Map<CL_DEVICE_HALF_FP_CONFIG > : public MapBase<CL_DEVICE_HALF_FP_CONFIG, uint64_t, &DeviceInfo::halfFpConfig> {};
template<> struct Map<CL_DEVICE_HOST_MEM_CAPABILITIES_INTEL > : public MapBase<CL_DEVICE_HOST_MEM_CAPABILITIES_INTEL, uint64_t, &DeviceInfo::hostMemCapabilities> {};
template<> struct Map<CL_DEVICE_HOST_UNIFIED_MEMORY > : public MapBase<CL_DEVICE_HOST_UNIFIED_MEMORY, uint32_t, &DeviceInfo::hostUnifiedMemory> {};
template<> struct Map<CL_DEVICE_IL_VERSION > : public MapBase<CL_DEVICE_IL_VERSION, const char *, &DeviceInfo::ilVersion> {};
template<> struct Map<CL_DEVICE_IMAGE2D_MAX_HEIGHT > : public MapBase<CL_DEVICE_IMAGE2D_MAX_HEIGHT, size_t, &DeviceInfo::image2DMaxHeight> {};
template<> struct Map<CL_DEVICE_IMAGE2D_MAX_WIDTH > : public MapBase<CL_DEVICE_IMAGE2D_MAX_WIDTH, size_t, &DeviceInfo::image2DMaxWidth> {};
template<> struct Map<CL_DEVICE_IMAGE3D_MAX_DEPTH > : public MapBase<CL_DEVICE_IMAGE3D_MAX_DEPTH, size_t, &DeviceInfo::image3DMaxDepth> {};
template<> struct Map<CL_DEVICE_IMAGE3D_MAX_HEIGHT > : public MapBase<CL_DEVICE_IMAGE3D_MAX_HEIGHT, size_t, &DeviceInfo::image3DMaxHeight> {};
template<> struct Map<CL_DEVICE_IMAGE3D_MAX_WIDTH > : public MapBase<CL_DEVICE_IMAGE3D_MAX_WIDTH, size_t, &DeviceInfo::image3DMaxWidth> {};
template<> struct Map<CL_DEVICE_IMAGE_BASE_ADDRESS_ALIGNMENT > : public MapBase<CL_DEVICE_IMAGE_BASE_ADDRESS_ALIGNMENT, uint32_t, &DeviceInfo::imageBaseAddressAlignment> {};
template<> struct Map<CL_DEVICE_IMAGE_MAX_ARRAY_SIZE > : public MapBase<CL_DEVICE_IMAGE_MAX_ARRAY_SIZE, size_t, &DeviceInfo::imageMaxArraySize> {};
template<> struct Map<CL_DEVICE_IMAGE_MAX_BUFFER_SIZE > : public MapBase<CL_DEVICE_IMAGE_MAX_BUFFER_SIZE, size_t, &DeviceInfo::imageMaxBufferSize> {};
template<> struct Map<CL_DEVICE_IMAGE_PITCH_ALIGNMENT > : public MapBase<CL_DEVICE_IMAGE_PITCH_ALIGNMENT, uint32_t, &DeviceInfo::imagePitchAlignment> {};
template<> struct Map<CL_DEVICE_IMAGE_SUPPORT > : public MapBase<CL_DEVICE_IMAGE_SUPPORT, uint32_t, &DeviceInfo::imageSupport> {};
template<> struct Map<CL_DEVICE_LINKER_AVAILABLE > : public MapBase<CL_DEVICE_LINKER_AVAILABLE, uint32_t, &DeviceInfo::linkerAvailable> {};
template<> struct Map<CL_DEVICE_LOCAL_MEM_SIZE > : public MapBase<CL_DEVICE_LOCAL_MEM_SIZE, uint64_t, &DeviceInfo::localMemSize> {};
template<> struct Map<CL_DEVICE_LOCAL_MEM_TYPE > : public MapBase<CL_DEVICE_LOCAL_MEM_TYPE, uint32_t, &DeviceInfo::localMemType> {};
template<> struct Map<CL_DEVICE_MAX_CLOCK_FREQUENCY > : public MapBase<CL_DEVICE_MAX_CLOCK_FREQUENCY, uint32_t, &DeviceInfo::maxClockFrequency> {};
template<> struct Map<CL_DEVICE_MAX_COMPUTE_UNITS > : public MapBase<CL_DEVICE_MAX_COMPUTE_UNITS, uint32_t, &DeviceInfo::maxComputUnits> {};
template<> struct Map<CL_DEVICE_MAX_CONSTANT_ARGS > : public MapBase<CL_DEVICE_MAX_CONSTANT_ARGS, uint32_t, &DeviceInfo::maxConstantArgs> {};
template<> struct Map<CL_DEVICE_MAX_CONSTANT_BUFFER_SIZE > : public MapBase<CL_DEVICE_MAX_CONSTANT_BUFFER_SIZE, uint64_t, &DeviceInfo::maxConstantBufferSize> {};
template<> struct Map<CL_DEVICE_MAX_GLOBAL_VARIABLE_SIZE > : public MapBase<CL_DEVICE_MAX_GLOBAL_VARIABLE_SIZE, size_t, &DeviceInfo::maxGlobalVariableSize> {};
template<> struct Map<CL_DEVICE_MAX_MEM_ALLOC_SIZE > : public MapBase<CL_DEVICE_MAX_MEM_ALLOC_SIZE, uint64_t, &DeviceInfo::maxMemAllocSize> {};
template<> struct Map<CL_DEVICE_MAX_NUM_SUB_GROUPS > : public MapBase<CL_DEVICE_MAX_NUM_SUB_GROUPS, uint32_t, &DeviceInfo::maxNumOfSubGroups> {};
template<> struct Map<CL_DEVICE_MAX_ON_DEVICE_EVENTS > : public MapBase<CL_DEVICE_MAX_ON_DEVICE_EVENTS, uint32_t, &DeviceInfo::maxOnDeviceEvents> {};
template<> struct Map<CL_DEVICE_MAX_ON_DEVICE_QUEUES > : public MapBase<CL_DEVICE_MAX_ON_DEVICE_QUEUES, uint32_t, &DeviceInfo::maxOnDeviceQueues> {};
template<> struct Map<CL_DEVICE_MAX_PARAMETER_SIZE > : public MapBase<CL_DEVICE_MAX_PARAMETER_SIZE, size_t, &DeviceInfo::maxParameterSize> {};
template<> struct Map<CL_DEVICE_MAX_PIPE_ARGS > : public MapBase<CL_DEVICE_MAX_PIPE_ARGS, uint32_t, &DeviceInfo::maxPipeArgs> {};
template<> struct Map<CL_DEVICE_MAX_READ_IMAGE_ARGS > : public MapBase<CL_DEVICE_MAX_READ_IMAGE_ARGS, uint32_t, &DeviceInfo::maxReadImageArgs> {};
template<> struct Map<CL_DEVICE_MAX_READ_WRITE_IMAGE_ARGS > : public MapBase<CL_DEVICE_MAX_READ_WRITE_IMAGE_ARGS, uint32_t, &DeviceInfo::maxReadWriteImageArgs> {};
template<> struct Map<CL_DEVICE_MAX_SAMPLERS > : public MapBase<CL_DEVICE_MAX_SAMPLERS, uint32_t, &DeviceInfo::maxSamplers> {};
template<> struct Map<CL_DEVICE_MAX_WORK_GROUP_SIZE > : public MapBase<CL_DEVICE_MAX_WORK_GROUP_SIZE, size_t, &DeviceInfo::maxWorkGroupSize> {};
template<> struct Map<CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS > : public MapBase<CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS, uint32_t, &DeviceInfo::maxWorkItemDimensions> {};
template<> struct Map<CL_DEVICE_MAX_WRITE_IMAGE_ARGS > : public MapBase<CL_DEVICE_MAX_WRITE_IMAGE_ARGS, uint32_t, &DeviceInfo::maxWriteImageArgs> {};
template<> struct Map<CL_DEVICE_MEM_BASE_ADDR_ALIGN > : public MapBase<CL_DEVICE_MEM_BASE_ADDR_ALIGN, uint32_t, &DeviceInfo::memBaseAddressAlign> {};
template<> struct Map<CL_DEVICE_ME_VERSION_INTEL > : public MapBase<CL_DEVICE_ME_VERSION_INTEL, uint32_t, &DeviceInfo::vmeVersion> {};
template<> struct Map<CL_DEVICE_MIN_DATA_TYPE_ALIGN_SIZE > : public MapBase<CL_DEVICE_MIN_DATA_TYPE_ALIGN_SIZE, uint32_t, &DeviceInfo::minDataTypeAlignSize> {};
template<> struct Map<CL_DEVICE_NAME > : public MapBase<CL_DEVICE_NAME, const char *, &DeviceInfo::name> {};
template<> struct Map<CL_DEVICE_NATIVE_VECTOR_WIDTH_CHAR > : public MapBase<CL_DEVICE_NATIVE_VECTOR_WIDTH_CHAR, uint32_t, &DeviceInfo::nativeVectorWidthChar> {};
template<> struct Map<CL_DEVICE_NATIVE_VECTOR_WIDTH_DOUBLE > : public MapBase<CL_DEVICE_NATIVE_VECTOR_WIDTH_DOUBLE, uint32_t, &DeviceInfo::nativeVectorWidthDouble> {};
template<> struct Map<CL_DEVICE_NATIVE_VECTOR_WIDTH_FLOAT > : public MapBase<CL_DEVICE_NATIVE_VECTOR_WIDTH_FLOAT, uint32_t, &DeviceInfo::nativeVectorWidthFloat> {};
template<> struct Map<CL_DEVICE_NATIVE_VECTOR_WIDTH_HALF > : public MapBase<CL_DEVICE_NATIVE_VECTOR_WIDTH_HALF, uint32_t, &DeviceInfo::nativeVectorWidthHalf> {};
template<> struct Map<CL_DEVICE_NATIVE_VECTOR_WIDTH_INT > : public MapBase<CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, uint32_t, &DeviceInfo::nativeVectorWidthInt> {};
template<> struct Map<CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG > : public MapBase<CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, uint32_t, &DeviceInfo::nativeVectorWidthLong> {};
template<> struct Map<CL_DEVICE_NATIVE_VECTOR_WIDTH_SHORT > : public MapBase<CL_DEVICE_NATIVE_VECTOR_WIDTH_SHORT, uint32_t, &DeviceInfo::nativeVectorWidthShort> {};
template<> struct Map<CL_DEVICE_OPENCL_C_VERSION > : public MapBase<CL_DEVICE_OPENCL_C_VERSION, const char *, &DeviceInfo::clCVersion> {};
template<> struct Map<CL_DEVICE_PARENT_DEVICE > : public MapBase<CL_DEVICE_PARENT_DEVICE, cl_device_id, &DeviceInfo::parentDevice> {};
template<> struct Map<CL_DEVICE_PARTITION_AFFINITY_DOMAIN > : public MapBase<CL_DEVICE_PARTITION_AFFINITY_DOMAIN, uint64_t, &DeviceInfo::partitionAffinityDomain> {};
template<> struct Map<CL_DEVICE_PARTITION_MAX_SUB_DEVICES > : public MapBase<CL_DEVICE_PARTITION_MAX_SUB_DEVICES, uint32_t, &DeviceInfo::partitionMaxSubDevices> {};
template<> struct Map<CL_DEVICE_PARTITION_PROPERTIES > : public MapBase<CL_DEVICE_PARTITION_PROPERTIES, cl_device_partition_property[2], &DeviceInfo::partitionProperties> {};
template<> struct Map<CL_DEVICE_PARTITION_TYPE > : public MapBase<CL_DEVICE_PARTITION_TYPE, cl_device_partition_property[3], &DeviceInfo::partitionType> {};
template<> struct Map<CL_DEVICE_PIPE_MAX_ACTIVE_RESERVATIONS > : public MapBase<CL_DEVICE_PIPE_MAX_ACTIVE_RESERVATIONS, uint32_t, &DeviceInfo::pipeMaxActiveReservations> {};
template<> struct Map<CL_DEVICE_PIPE_MAX_PACKET_SIZE > : public MapBase<CL_DEVICE_PIPE_MAX_PACKET_SIZE, uint32_t, &DeviceInfo::pipeMaxPacketSize> {};
template<> struct Map<CL_DEVICE_PLANAR_YUV_MAX_HEIGHT_INTEL > : public MapBase<CL_DEVICE_PLANAR_YUV_MAX_HEIGHT_INTEL, size_t, &DeviceInfo::planarYuvMaxHeight> {};
template<> struct Map<CL_DEVICE_PLANAR_YUV_MAX_WIDTH_INTEL > : public MapBase<CL_DEVICE_PLANAR_YUV_MAX_WIDTH_INTEL, size_t, &DeviceInfo::planarYuvMaxWidth> {};
template<> struct Map<CL_DEVICE_PREFERRED_GLOBAL_ATOMIC_ALIGNMENT > : public MapBase<CL_DEVICE_PREFERRED_GLOBAL_ATOMIC_ALIGNMENT, uint32_t, &DeviceInfo::preferredGlobalAtomicAlignment> {};
template<> struct Map<CL_DEVICE_PREFERRED_INTEROP_USER_SYNC > : public MapBase<CL_DEVICE_PREFERRED_INTEROP_USER_SYNC, uint32_t, &DeviceInfo::preferredInteropUserSync> {};
template<> struct Map<CL_DEVICE_PREFERRED_LOCAL_ATOMIC_ALIGNMENT > : public MapBase<CL_DEVICE_PREFERRED_LOCAL_ATOMIC_ALIGNMENT, uint32_t, &DeviceInfo::preferredLocalAtomicAlignment> {};
template<> struct Map<CL_DEVICE_PREFERRED_PLATFORM_ATOMIC_ALIGNMENT > : public MapBase<CL_DEVICE_PREFERRED_PLATFORM_ATOMIC_ALIGNMENT, uint32_t, &DeviceInfo::preferredPlatformAtomicAlignment> {};
template<> struct Map<CL_DEVICE_PREFERRED_VECTOR_WIDTH_CHAR > : public MapBase<CL_DEVICE_PREFERRED_VECTOR_WIDTH_CHAR, uint32_t, &DeviceInfo::preferredVectorWidthChar> {};
template<> struct Map<CL_DEVICE_PREFERRED_VECTOR_WIDTH_DOUBLE > : public MapBase<CL_DEVICE_PREFERRED_VECTOR_WIDTH_DOUBLE, uint32_t, &DeviceInfo::preferredVectorWidthDouble> {};
template<> struct Map<CL_DEVICE_PREFERRED_VECTOR_WIDTH_FLOAT > : public MapBase<CL_DEVICE_PREFERRED_VECTOR_WIDTH_FLOAT, uint32_t, &DeviceInfo::preferredVectorWidthFloat> {};
template<> struct Map<CL_DEVICE_PREFERRED_VECTOR_WIDTH_HALF > : public MapBase<CL_DEVICE_PREFERRED_VECTOR_WIDTH_HALF, uint32_t, &DeviceInfo::preferredVectorWidthHalf> {};
template<> struct Map<CL_DEVICE_PREFERRED_VECTOR_WIDTH_INT > : public MapBase<CL_DEVICE_PREFERRED_VECTOR_WIDTH_INT, uint32_t, &DeviceInfo::preferredVectorWidthInt> {};
template<> struct Map<CL_DEVICE_PREFERRED_VECTOR_WIDTH_LONG > : public MapBase<CL_DEVICE_PREFERRED_VECTOR_WIDTH_LONG, uint32_t, &DeviceInfo::preferredVectorWidthLong> {};
template<> struct Map<CL_DEVICE_PREFERRED_VECTOR_WIDTH_SHORT > : public MapBase<CL_DEVICE_PREFERRED_VECTOR_WIDTH_SHORT, uint32_t, &DeviceInfo::preferredVectorWidthShort> {};
template<> struct Map<CL_DEVICE_PRINTF_BUFFER_SIZE > : public MapBase<CL_DEVICE_PRINTF_BUFFER_SIZE, size_t, &DeviceInfo::printfBufferSize> {};
template<> struct Map<CL_DEVICE_PROFILE > : public MapBase<CL_DEVICE_PROFILE, const char *, &DeviceInfo::profile> {};
template<> struct Map<CL_DEVICE_PROFILING_TIMER_RESOLUTION > : public MapBase<CL_DEVICE_PROFILING_TIMER_RESOLUTION, size_t, &DeviceInfo::outProfilingTimerResolution> {};
template<> struct Map<CL_DEVICE_QUEUE_ON_DEVICE_MAX_SIZE > : public MapBase<CL_DEVICE_QUEUE_ON_DEVICE_MAX_SIZE, uint32_t, &DeviceInfo::queueOnDeviceMaxSize> {};
template<> struct Map<CL_DEVICE_QUEUE_ON_DEVICE_PREFERRED_SIZE > : public MapBase<CL_DEVICE_QUEUE_ON_DEVICE_PREFERRED_SIZE, uint32_t, &DeviceInfo::queueOnDevicePreferredSize> {};
template<> struct Map<CL_DEVICE_QUEUE_ON_DEVICE_PROPERTIES > : public MapBase<CL_DEVICE_QUEUE_ON_DEVICE_PROPERTIES, uint64_t, &DeviceInfo::queueOnDeviceProperties> {};
template<> struct Map<CL_DEVICE_QUEUE_ON_HOST_PROPERTIES > : public MapBase<CL_DEVICE_QUEUE_ON_HOST_PROPERTIES, uint64_t, &DeviceInfo::queueOnHostProperties> {};
template<> struct Map<CL_DEVICE_SHARED_SYSTEM_MEM_CAPABILITIES_INTEL > : public MapBase<CL_DEVICE_SHARED_SYSTEM_MEM_CAPABILITIES_INTEL, uint64_t, &DeviceInfo::sharedSystemMemCapabilities> {};
template<> struct Map<CL_DEVICE_SINGLE_DEVICE_SHARED_MEM_CAPABILITIES_INTEL > : public MapBase<CL_DEVICE_SINGLE_DEVICE_SHARED_MEM_CAPABILITIES_INTEL, uint64_t, &DeviceInfo::singleDeviceSharedMemCapabilities> {};
template<> struct Map<CL_DEVICE_SINGLE_FP_CONFIG > : public MapBase<CL_DEVICE_SINGLE_FP_CONFIG, uint64_t, &DeviceInfo::singleFpConfig> {};
template<> struct Map<CL_DEVICE_SLICE_COUNT_INTEL > : public MapBase<CL_DEVICE_SLICE_COUNT_INTEL, size_t, &DeviceInfo::maxSliceCount> {};
template<> struct Map<CL_DEVICE_SPIR_VERSIONS > : public MapBase<CL_DEVICE_SPIR_VERSIONS, const char *, &DeviceInfo::spirVersions> {};
template<> struct Map<CL_DEVICE_SUB_GROUP_INDEPENDENT_FORWARD_PROGRESS > : public MapBase<CL_DEVICE_SUB_GROUP_INDEPENDENT_FORWARD_PROGRESS, uint32_t, &DeviceInfo::independentForwardProgress> {};
template<> struct Map<CL_DEVICE_SVM_CAPABILITIES > : public MapBase<CL_DEVICE_SVM_CAPABILITIES, uint64_t, &DeviceInfo::svmCapabilities> {};
template<> struct Map<CL_DEVICE_TYPE > : public MapBase<CL_DEVICE_TYPE, uint64_t, &DeviceInfo::deviceType> {};
template<> struct Map<CL_DEVICE_VENDOR > : public MapBase<CL_DEVICE_VENDOR, const char *, &DeviceInfo::vendor> {};
template<> struct Map<CL_DEVICE_VENDOR_ID > : public MapBase<CL_DEVICE_VENDOR_ID, uint32_t, &DeviceInfo::vendorId> {};
template<> struct Map<CL_DEVICE_VERSION > : public MapBase<CL_DEVICE_VERSION, const char *, &DeviceInfo::clVersion> {};
template<> struct Map<CL_DRIVER_VERSION > : public MapBase<CL_DRIVER_VERSION, const char *, &DeviceInfo::driverVersion> {};
template<> struct Map<CL_DEVICE_ADDRESS_BITS > : public MapBase<CL_DEVICE_ADDRESS_BITS, unsigned int, &ClDeviceInfo::addressBits> {};
template<> struct Map<CL_DEVICE_AVAILABLE > : public MapBase<CL_DEVICE_AVAILABLE, uint32_t, &ClDeviceInfo::deviceAvailable> {};
template<> struct Map<CL_DEVICE_AVC_ME_SUPPORTS_PREEMPTION_INTEL > : public MapBase<CL_DEVICE_AVC_ME_SUPPORTS_PREEMPTION_INTEL, uint32_t, &ClDeviceInfo::vmeAvcSupportsPreemption> {};
template<> struct Map<CL_DEVICE_AVC_ME_SUPPORTS_TEXTURE_SAMPLER_USE_INTEL > : public MapBase<CL_DEVICE_AVC_ME_SUPPORTS_TEXTURE_SAMPLER_USE_INTEL, uint32_t, &ClDeviceInfo::vmeAvcSupportsTextureSampler> {};
template<> struct Map<CL_DEVICE_AVC_ME_VERSION_INTEL > : public MapBase<CL_DEVICE_AVC_ME_VERSION_INTEL, uint32_t, &ClDeviceInfo::vmeAvcVersion> {};
template<> struct Map<CL_DEVICE_BUILT_IN_KERNELS > : public MapBase<CL_DEVICE_BUILT_IN_KERNELS, const char *, &ClDeviceInfo::builtInKernels> {};
template<> struct Map<CL_DEVICE_COMPILER_AVAILABLE > : public MapBase<CL_DEVICE_COMPILER_AVAILABLE, uint32_t, &ClDeviceInfo::compilerAvailable> {};
template<> struct Map<CL_DEVICE_CROSS_DEVICE_SHARED_MEM_CAPABILITIES_INTEL > : public MapBase<CL_DEVICE_CROSS_DEVICE_SHARED_MEM_CAPABILITIES_INTEL, uint64_t, &ClDeviceInfo::crossDeviceSharedMemCapabilities> {};
template<> struct Map<CL_DEVICE_DEVICE_MEM_CAPABILITIES_INTEL > : public MapBase<CL_DEVICE_DEVICE_MEM_CAPABILITIES_INTEL, uint64_t, &ClDeviceInfo::deviceMemCapabilities> {};
template<> struct Map<CL_DEVICE_DOUBLE_FP_CONFIG > : public MapBase<CL_DEVICE_DOUBLE_FP_CONFIG, uint64_t, &ClDeviceInfo::doubleFpConfig> {};
template<> struct Map<CL_DEVICE_DRIVER_VERSION_INTEL > : public MapBase<CL_DEVICE_DRIVER_VERSION_INTEL, uint32_t, &ClDeviceInfo::internalDriverVersion> {};
template<> struct Map<CL_DEVICE_ENDIAN_LITTLE > : public MapBase<CL_DEVICE_ENDIAN_LITTLE, uint32_t, &ClDeviceInfo::endianLittle> {};
template<> struct Map<CL_DEVICE_ERROR_CORRECTION_SUPPORT > : public MapBase<CL_DEVICE_ERROR_CORRECTION_SUPPORT, uint32_t, &ClDeviceInfo::errorCorrectionSupport> {};
template<> struct Map<CL_DEVICE_EXECUTION_CAPABILITIES > : public MapBase<CL_DEVICE_EXECUTION_CAPABILITIES, uint64_t, &ClDeviceInfo::executionCapabilities> {};
template<> struct Map<CL_DEVICE_EXTENSIONS > : public MapBase<CL_DEVICE_EXTENSIONS, const char *, &ClDeviceInfo::deviceExtensions> {};
template<> struct Map<CL_DEVICE_GLOBAL_MEM_CACHELINE_SIZE > : public MapBase<CL_DEVICE_GLOBAL_MEM_CACHELINE_SIZE, unsigned int, &ClDeviceInfo::globalMemCachelineSize> {};
template<> struct Map<CL_DEVICE_GLOBAL_MEM_CACHE_SIZE > : public MapBase<CL_DEVICE_GLOBAL_MEM_CACHE_SIZE, uint64_t, &ClDeviceInfo::globalMemCacheSize> {};
template<> struct Map<CL_DEVICE_GLOBAL_MEM_CACHE_TYPE > : public MapBase<CL_DEVICE_GLOBAL_MEM_CACHE_TYPE, uint32_t, &ClDeviceInfo::globalMemCacheType> {};
template<> struct Map<CL_DEVICE_GLOBAL_MEM_SIZE > : public MapBase<CL_DEVICE_GLOBAL_MEM_SIZE, uint64_t, &ClDeviceInfo::globalMemSize> {};
template<> struct Map<CL_DEVICE_GLOBAL_VARIABLE_PREFERRED_TOTAL_SIZE > : public MapBase<CL_DEVICE_GLOBAL_VARIABLE_PREFERRED_TOTAL_SIZE, size_t, &ClDeviceInfo::globalVariablePreferredTotalSize> {};
template<> struct Map<CL_DEVICE_HALF_FP_CONFIG > : public MapBase<CL_DEVICE_HALF_FP_CONFIG, uint64_t, &ClDeviceInfo::halfFpConfig> {};
template<> struct Map<CL_DEVICE_HOST_MEM_CAPABILITIES_INTEL > : public MapBase<CL_DEVICE_HOST_MEM_CAPABILITIES_INTEL, uint64_t, &ClDeviceInfo::hostMemCapabilities> {};
template<> struct Map<CL_DEVICE_HOST_UNIFIED_MEMORY > : public MapBase<CL_DEVICE_HOST_UNIFIED_MEMORY, uint32_t, &ClDeviceInfo::hostUnifiedMemory> {};
template<> struct Map<CL_DEVICE_IL_VERSION > : public MapBase<CL_DEVICE_IL_VERSION, const char *, &ClDeviceInfo::ilVersion> {};
template<> struct Map<CL_DEVICE_IMAGE2D_MAX_HEIGHT > : public MapBase<CL_DEVICE_IMAGE2D_MAX_HEIGHT, size_t, &ClDeviceInfo::image2DMaxHeight> {};
template<> struct Map<CL_DEVICE_IMAGE2D_MAX_WIDTH > : public MapBase<CL_DEVICE_IMAGE2D_MAX_WIDTH, size_t, &ClDeviceInfo::image2DMaxWidth> {};
template<> struct Map<CL_DEVICE_IMAGE3D_MAX_DEPTH > : public MapBase<CL_DEVICE_IMAGE3D_MAX_DEPTH, size_t, &ClDeviceInfo::image3DMaxDepth> {};
template<> struct Map<CL_DEVICE_IMAGE3D_MAX_HEIGHT > : public MapBase<CL_DEVICE_IMAGE3D_MAX_HEIGHT, size_t, &ClDeviceInfo::image3DMaxHeight> {};
template<> struct Map<CL_DEVICE_IMAGE3D_MAX_WIDTH > : public MapBase<CL_DEVICE_IMAGE3D_MAX_WIDTH, size_t, &ClDeviceInfo::image3DMaxWidth> {};
template<> struct Map<CL_DEVICE_IMAGE_BASE_ADDRESS_ALIGNMENT > : public MapBase<CL_DEVICE_IMAGE_BASE_ADDRESS_ALIGNMENT, uint32_t, &ClDeviceInfo::imageBaseAddressAlignment> {};
template<> struct Map<CL_DEVICE_IMAGE_MAX_ARRAY_SIZE > : public MapBase<CL_DEVICE_IMAGE_MAX_ARRAY_SIZE, size_t, &ClDeviceInfo::imageMaxArraySize> {};
template<> struct Map<CL_DEVICE_IMAGE_MAX_BUFFER_SIZE > : public MapBase<CL_DEVICE_IMAGE_MAX_BUFFER_SIZE, size_t, &ClDeviceInfo::imageMaxBufferSize> {};
template<> struct Map<CL_DEVICE_IMAGE_PITCH_ALIGNMENT > : public MapBase<CL_DEVICE_IMAGE_PITCH_ALIGNMENT, uint32_t, &ClDeviceInfo::imagePitchAlignment> {};
template<> struct Map<CL_DEVICE_IMAGE_SUPPORT > : public MapBase<CL_DEVICE_IMAGE_SUPPORT, uint32_t, &ClDeviceInfo::imageSupport> {};
template<> struct Map<CL_DEVICE_LINKER_AVAILABLE > : public MapBase<CL_DEVICE_LINKER_AVAILABLE, uint32_t, &ClDeviceInfo::linkerAvailable> {};
template<> struct Map<CL_DEVICE_LOCAL_MEM_SIZE > : public MapBase<CL_DEVICE_LOCAL_MEM_SIZE, uint64_t, &ClDeviceInfo::localMemSize> {};
template<> struct Map<CL_DEVICE_LOCAL_MEM_TYPE > : public MapBase<CL_DEVICE_LOCAL_MEM_TYPE, uint32_t, &ClDeviceInfo::localMemType> {};
template<> struct Map<CL_DEVICE_MAX_CLOCK_FREQUENCY > : public MapBase<CL_DEVICE_MAX_CLOCK_FREQUENCY, uint32_t, &ClDeviceInfo::maxClockFrequency> {};
template<> struct Map<CL_DEVICE_MAX_COMPUTE_UNITS > : public MapBase<CL_DEVICE_MAX_COMPUTE_UNITS, uint32_t, &ClDeviceInfo::maxComputUnits> {};
template<> struct Map<CL_DEVICE_MAX_CONSTANT_ARGS > : public MapBase<CL_DEVICE_MAX_CONSTANT_ARGS, uint32_t, &ClDeviceInfo::maxConstantArgs> {};
template<> struct Map<CL_DEVICE_MAX_CONSTANT_BUFFER_SIZE > : public MapBase<CL_DEVICE_MAX_CONSTANT_BUFFER_SIZE, uint64_t, &ClDeviceInfo::maxConstantBufferSize> {};
template<> struct Map<CL_DEVICE_MAX_GLOBAL_VARIABLE_SIZE > : public MapBase<CL_DEVICE_MAX_GLOBAL_VARIABLE_SIZE, size_t, &ClDeviceInfo::maxGlobalVariableSize> {};
template<> struct Map<CL_DEVICE_MAX_MEM_ALLOC_SIZE > : public MapBase<CL_DEVICE_MAX_MEM_ALLOC_SIZE, uint64_t, &ClDeviceInfo::maxMemAllocSize> {};
template<> struct Map<CL_DEVICE_MAX_NUM_SUB_GROUPS > : public MapBase<CL_DEVICE_MAX_NUM_SUB_GROUPS, uint32_t, &ClDeviceInfo::maxNumOfSubGroups> {};
template<> struct Map<CL_DEVICE_MAX_ON_DEVICE_EVENTS > : public MapBase<CL_DEVICE_MAX_ON_DEVICE_EVENTS, uint32_t, &ClDeviceInfo::maxOnDeviceEvents> {};
template<> struct Map<CL_DEVICE_MAX_ON_DEVICE_QUEUES > : public MapBase<CL_DEVICE_MAX_ON_DEVICE_QUEUES, uint32_t, &ClDeviceInfo::maxOnDeviceQueues> {};
template<> struct Map<CL_DEVICE_MAX_PARAMETER_SIZE > : public MapBase<CL_DEVICE_MAX_PARAMETER_SIZE, size_t, &ClDeviceInfo::maxParameterSize> {};
template<> struct Map<CL_DEVICE_MAX_PIPE_ARGS > : public MapBase<CL_DEVICE_MAX_PIPE_ARGS, uint32_t, &ClDeviceInfo::maxPipeArgs> {};
template<> struct Map<CL_DEVICE_MAX_READ_IMAGE_ARGS > : public MapBase<CL_DEVICE_MAX_READ_IMAGE_ARGS, uint32_t, &ClDeviceInfo::maxReadImageArgs> {};
template<> struct Map<CL_DEVICE_MAX_READ_WRITE_IMAGE_ARGS > : public MapBase<CL_DEVICE_MAX_READ_WRITE_IMAGE_ARGS, uint32_t, &ClDeviceInfo::maxReadWriteImageArgs> {};
template<> struct Map<CL_DEVICE_MAX_SAMPLERS > : public MapBase<CL_DEVICE_MAX_SAMPLERS, uint32_t, &ClDeviceInfo::maxSamplers> {};
template<> struct Map<CL_DEVICE_MAX_WORK_GROUP_SIZE > : public MapBase<CL_DEVICE_MAX_WORK_GROUP_SIZE, size_t, &ClDeviceInfo::maxWorkGroupSize> {};
template<> struct Map<CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS > : public MapBase<CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS, uint32_t, &ClDeviceInfo::maxWorkItemDimensions> {};
template<> struct Map<CL_DEVICE_MAX_WRITE_IMAGE_ARGS > : public MapBase<CL_DEVICE_MAX_WRITE_IMAGE_ARGS, uint32_t, &ClDeviceInfo::maxWriteImageArgs> {};
template<> struct Map<CL_DEVICE_MEM_BASE_ADDR_ALIGN > : public MapBase<CL_DEVICE_MEM_BASE_ADDR_ALIGN, uint32_t, &ClDeviceInfo::memBaseAddressAlign> {};
template<> struct Map<CL_DEVICE_ME_VERSION_INTEL > : public MapBase<CL_DEVICE_ME_VERSION_INTEL, uint32_t, &ClDeviceInfo::vmeVersion> {};
template<> struct Map<CL_DEVICE_MIN_DATA_TYPE_ALIGN_SIZE > : public MapBase<CL_DEVICE_MIN_DATA_TYPE_ALIGN_SIZE, uint32_t, &ClDeviceInfo::minDataTypeAlignSize> {};
template<> struct Map<CL_DEVICE_NAME > : public MapBase<CL_DEVICE_NAME, const char *, &ClDeviceInfo::name> {};
template<> struct Map<CL_DEVICE_NATIVE_VECTOR_WIDTH_CHAR > : public MapBase<CL_DEVICE_NATIVE_VECTOR_WIDTH_CHAR, uint32_t, &ClDeviceInfo::nativeVectorWidthChar> {};
template<> struct Map<CL_DEVICE_NATIVE_VECTOR_WIDTH_DOUBLE > : public MapBase<CL_DEVICE_NATIVE_VECTOR_WIDTH_DOUBLE, uint32_t, &ClDeviceInfo::nativeVectorWidthDouble> {};
template<> struct Map<CL_DEVICE_NATIVE_VECTOR_WIDTH_FLOAT > : public MapBase<CL_DEVICE_NATIVE_VECTOR_WIDTH_FLOAT, uint32_t, &ClDeviceInfo::nativeVectorWidthFloat> {};
template<> struct Map<CL_DEVICE_NATIVE_VECTOR_WIDTH_HALF > : public MapBase<CL_DEVICE_NATIVE_VECTOR_WIDTH_HALF, uint32_t, &ClDeviceInfo::nativeVectorWidthHalf> {};
template<> struct Map<CL_DEVICE_NATIVE_VECTOR_WIDTH_INT > : public MapBase<CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, uint32_t, &ClDeviceInfo::nativeVectorWidthInt> {};
template<> struct Map<CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG > : public MapBase<CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, uint32_t, &ClDeviceInfo::nativeVectorWidthLong> {};
template<> struct Map<CL_DEVICE_NATIVE_VECTOR_WIDTH_SHORT > : public MapBase<CL_DEVICE_NATIVE_VECTOR_WIDTH_SHORT, uint32_t, &ClDeviceInfo::nativeVectorWidthShort> {};
template<> struct Map<CL_DEVICE_OPENCL_C_VERSION > : public MapBase<CL_DEVICE_OPENCL_C_VERSION, const char *, &ClDeviceInfo::clCVersion> {};
template<> struct Map<CL_DEVICE_PARENT_DEVICE > : public MapBase<CL_DEVICE_PARENT_DEVICE, cl_device_id, &ClDeviceInfo::parentDevice> {};
template<> struct Map<CL_DEVICE_PARTITION_AFFINITY_DOMAIN > : public MapBase<CL_DEVICE_PARTITION_AFFINITY_DOMAIN, uint64_t, &ClDeviceInfo::partitionAffinityDomain> {};
template<> struct Map<CL_DEVICE_PARTITION_MAX_SUB_DEVICES > : public MapBase<CL_DEVICE_PARTITION_MAX_SUB_DEVICES, uint32_t, &ClDeviceInfo::partitionMaxSubDevices> {};
template<> struct Map<CL_DEVICE_PARTITION_PROPERTIES > : public MapBase<CL_DEVICE_PARTITION_PROPERTIES, cl_device_partition_property[2], &ClDeviceInfo::partitionProperties> {};
template<> struct Map<CL_DEVICE_PARTITION_TYPE > : public MapBase<CL_DEVICE_PARTITION_TYPE, cl_device_partition_property[3], &ClDeviceInfo::partitionType> {};
template<> struct Map<CL_DEVICE_PIPE_MAX_ACTIVE_RESERVATIONS > : public MapBase<CL_DEVICE_PIPE_MAX_ACTIVE_RESERVATIONS, uint32_t, &ClDeviceInfo::pipeMaxActiveReservations> {};
template<> struct Map<CL_DEVICE_PIPE_MAX_PACKET_SIZE > : public MapBase<CL_DEVICE_PIPE_MAX_PACKET_SIZE, uint32_t, &ClDeviceInfo::pipeMaxPacketSize> {};
template<> struct Map<CL_DEVICE_PLANAR_YUV_MAX_HEIGHT_INTEL > : public MapBase<CL_DEVICE_PLANAR_YUV_MAX_HEIGHT_INTEL, size_t, &ClDeviceInfo::planarYuvMaxHeight> {};
template<> struct Map<CL_DEVICE_PLANAR_YUV_MAX_WIDTH_INTEL > : public MapBase<CL_DEVICE_PLANAR_YUV_MAX_WIDTH_INTEL, size_t, &ClDeviceInfo::planarYuvMaxWidth> {};
template<> struct Map<CL_DEVICE_PREFERRED_GLOBAL_ATOMIC_ALIGNMENT > : public MapBase<CL_DEVICE_PREFERRED_GLOBAL_ATOMIC_ALIGNMENT, uint32_t, &ClDeviceInfo::preferredGlobalAtomicAlignment> {};
template<> struct Map<CL_DEVICE_PREFERRED_INTEROP_USER_SYNC > : public MapBase<CL_DEVICE_PREFERRED_INTEROP_USER_SYNC, uint32_t, &ClDeviceInfo::preferredInteropUserSync> {};
template<> struct Map<CL_DEVICE_PREFERRED_LOCAL_ATOMIC_ALIGNMENT > : public MapBase<CL_DEVICE_PREFERRED_LOCAL_ATOMIC_ALIGNMENT, uint32_t, &ClDeviceInfo::preferredLocalAtomicAlignment> {};
template<> struct Map<CL_DEVICE_PREFERRED_PLATFORM_ATOMIC_ALIGNMENT > : public MapBase<CL_DEVICE_PREFERRED_PLATFORM_ATOMIC_ALIGNMENT, uint32_t, &ClDeviceInfo::preferredPlatformAtomicAlignment> {};
template<> struct Map<CL_DEVICE_PREFERRED_VECTOR_WIDTH_CHAR > : public MapBase<CL_DEVICE_PREFERRED_VECTOR_WIDTH_CHAR, uint32_t, &ClDeviceInfo::preferredVectorWidthChar> {};
template<> struct Map<CL_DEVICE_PREFERRED_VECTOR_WIDTH_DOUBLE > : public MapBase<CL_DEVICE_PREFERRED_VECTOR_WIDTH_DOUBLE, uint32_t, &ClDeviceInfo::preferredVectorWidthDouble> {};
template<> struct Map<CL_DEVICE_PREFERRED_VECTOR_WIDTH_FLOAT > : public MapBase<CL_DEVICE_PREFERRED_VECTOR_WIDTH_FLOAT, uint32_t, &ClDeviceInfo::preferredVectorWidthFloat> {};
template<> struct Map<CL_DEVICE_PREFERRED_VECTOR_WIDTH_HALF > : public MapBase<CL_DEVICE_PREFERRED_VECTOR_WIDTH_HALF, uint32_t, &ClDeviceInfo::preferredVectorWidthHalf> {};
template<> struct Map<CL_DEVICE_PREFERRED_VECTOR_WIDTH_INT > : public MapBase<CL_DEVICE_PREFERRED_VECTOR_WIDTH_INT, uint32_t, &ClDeviceInfo::preferredVectorWidthInt> {};
template<> struct Map<CL_DEVICE_PREFERRED_VECTOR_WIDTH_LONG > : public MapBase<CL_DEVICE_PREFERRED_VECTOR_WIDTH_LONG, uint32_t, &ClDeviceInfo::preferredVectorWidthLong> {};
template<> struct Map<CL_DEVICE_PREFERRED_VECTOR_WIDTH_SHORT > : public MapBase<CL_DEVICE_PREFERRED_VECTOR_WIDTH_SHORT, uint32_t, &ClDeviceInfo::preferredVectorWidthShort> {};
template<> struct Map<CL_DEVICE_PRINTF_BUFFER_SIZE > : public MapBase<CL_DEVICE_PRINTF_BUFFER_SIZE, size_t, &ClDeviceInfo::printfBufferSize> {};
template<> struct Map<CL_DEVICE_PROFILE > : public MapBase<CL_DEVICE_PROFILE, const char *, &ClDeviceInfo::profile> {};
template<> struct Map<CL_DEVICE_PROFILING_TIMER_RESOLUTION > : public MapBase<CL_DEVICE_PROFILING_TIMER_RESOLUTION, size_t, &ClDeviceInfo::outProfilingTimerResolution> {};
template<> struct Map<CL_DEVICE_QUEUE_ON_DEVICE_MAX_SIZE > : public MapBase<CL_DEVICE_QUEUE_ON_DEVICE_MAX_SIZE, uint32_t, &ClDeviceInfo::queueOnDeviceMaxSize> {};
template<> struct Map<CL_DEVICE_QUEUE_ON_DEVICE_PREFERRED_SIZE > : public MapBase<CL_DEVICE_QUEUE_ON_DEVICE_PREFERRED_SIZE, uint32_t, &ClDeviceInfo::queueOnDevicePreferredSize> {};
template<> struct Map<CL_DEVICE_QUEUE_ON_DEVICE_PROPERTIES > : public MapBase<CL_DEVICE_QUEUE_ON_DEVICE_PROPERTIES, uint64_t, &ClDeviceInfo::queueOnDeviceProperties> {};
template<> struct Map<CL_DEVICE_QUEUE_ON_HOST_PROPERTIES > : public MapBase<CL_DEVICE_QUEUE_ON_HOST_PROPERTIES, uint64_t, &ClDeviceInfo::queueOnHostProperties> {};
template<> struct Map<CL_DEVICE_SHARED_SYSTEM_MEM_CAPABILITIES_INTEL > : public MapBase<CL_DEVICE_SHARED_SYSTEM_MEM_CAPABILITIES_INTEL, uint64_t, &ClDeviceInfo::sharedSystemMemCapabilities> {};
template<> struct Map<CL_DEVICE_SINGLE_DEVICE_SHARED_MEM_CAPABILITIES_INTEL > : public MapBase<CL_DEVICE_SINGLE_DEVICE_SHARED_MEM_CAPABILITIES_INTEL, uint64_t, &ClDeviceInfo::singleDeviceSharedMemCapabilities> {};
template<> struct Map<CL_DEVICE_SINGLE_FP_CONFIG > : public MapBase<CL_DEVICE_SINGLE_FP_CONFIG, uint64_t, &ClDeviceInfo::singleFpConfig> {};
template<> struct Map<CL_DEVICE_SLICE_COUNT_INTEL > : public MapBase<CL_DEVICE_SLICE_COUNT_INTEL, size_t, &ClDeviceInfo::maxSliceCount> {};
template<> struct Map<CL_DEVICE_SPIR_VERSIONS > : public MapBase<CL_DEVICE_SPIR_VERSIONS, const char *, &ClDeviceInfo::spirVersions> {};
template<> struct Map<CL_DEVICE_SUB_GROUP_INDEPENDENT_FORWARD_PROGRESS > : public MapBase<CL_DEVICE_SUB_GROUP_INDEPENDENT_FORWARD_PROGRESS, uint32_t, &ClDeviceInfo::independentForwardProgress> {};
template<> struct Map<CL_DEVICE_SVM_CAPABILITIES > : public MapBase<CL_DEVICE_SVM_CAPABILITIES, uint64_t, &ClDeviceInfo::svmCapabilities> {};
template<> struct Map<CL_DEVICE_TYPE > : public MapBase<CL_DEVICE_TYPE, uint64_t, &ClDeviceInfo::deviceType> {};
template<> struct Map<CL_DEVICE_VENDOR > : public MapBase<CL_DEVICE_VENDOR, const char *, &ClDeviceInfo::vendor> {};
template<> struct Map<CL_DEVICE_VENDOR_ID > : public MapBase<CL_DEVICE_VENDOR_ID, uint32_t, &ClDeviceInfo::vendorId> {};
template<> struct Map<CL_DEVICE_VERSION > : public MapBase<CL_DEVICE_VERSION, const char *, &ClDeviceInfo::clVersion> {};
template<> struct Map<CL_DRIVER_VERSION > : public MapBase<CL_DRIVER_VERSION, const char *, &ClDeviceInfo::driverVersion> {};
// clang-format on
} // namespace DeviceInfoTable

2
opencl/source/device_queue/device_queue_hw_bdw_plus.inl
View File

@ -213,7 +213,7 @@ void DeviceQueueHw<GfxFamily>::setupIndirectState(IndirectHeap &surfaceStateHeap
DEBUG_BREAK_IF(nullptr == threadPayload);
auto numChannels = PerThreadDataHelper::getNumLocalIdChannels(*threadPayload);
auto grfSize = this->getDevice().getDeviceInfo().grfSize;
auto grfSize = device->getDeviceInfo().grfSize;
auto sizePerThreadData = getPerThreadSizeLocalIDs(simd, grfSize, numChannels);
auto numGrfPerThreadData = static_cast<uint32_t>(sizePerThreadData / grfSize);

2
opencl/source/os_interface/linux/device_caps_init_linux.cpp
View File

@ -9,6 +9,6 @@
namespace NEO {
void ClDevice::initializeCaps() {
void ClDevice::initializeExtraCaps() {
}
} // namespace NEO

2
opencl/source/os_interface/linux/driver_info.cpp
View File

@ -12,4 +12,4 @@ namespace NEO {
DriverInfo *DriverInfo::create(OSInterface *osInterface) {
return new DriverInfo();
};
} // namespace NEO
} // namespace NEO

5
opencl/source/os_interface/windows/device_caps_init_win.cpp
View File

@ -13,8 +13,9 @@
namespace NEO {
void ClDevice::initializeCaps() {
device.appendOSExtensions("cl_intel_simultaneous_sharing ");
void ClDevice::initializeExtraCaps() {
deviceExtensions += "cl_intel_simultaneous_sharing ";
deviceInfo.deviceExtensions = deviceExtensions.c_str();
simultaneousInterops = {CL_GL_CONTEXT_KHR,
CL_WGL_HDC_KHR,