139 lines
22 KiB
C++
139 lines
22 KiB
C++
/*
|
|
* Copyright (C) 2017-2019 Intel Corporation
|
|
*
|
|
* SPDX-License-Identifier: MIT
|
|
*
|
|
*/
|
|
|
|
#pragma once
|
|
#include "public/cl_ext_private.h"
|
|
#include "runtime/device/device_info.h"
|
|
|
|
#include "CL/cl_ext_intel.h"
|
|
#include <CL/cl.h>
|
|
#include <CL/cl_ext.h>
|
|
|
|
namespace DeviceInfoTable {
|
|
template <cl_device_info Param, typename _Type, _Type DeviceInfo::*val>
|
|
struct MapBase {
|
|
enum { param = Param };
|
|
typedef _Type Type;
|
|
enum { size = sizeof(Type) };
|
|
|
|
static const Type &getValue(const DeviceInfo &deviceInfo) {
|
|
return deviceInfo.*val;
|
|
}
|
|
};
|
|
|
|
template <cl_device_info Param>
|
|
struct Map {};
|
|
|
|
//////////////////////////////////////////////////////
|
|
// DeviceInfo mapping table
|
|
// Map<Param>::param - i.e. CL_DEVICE_ADDRESS_BITS
|
|
// Map<Param>::Type - i.e. cl_uint
|
|
// Map<Param>::size - ie. sizeof( cl_uint )
|
|
// Map<Param>::getValue - ie. return deviceInfo.AddressBits
|
|
//////////////////////////////////////////////////////
|
|
// clang-format off
|
|
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_VERSION_INTEL > : public MapBase<CL_DEVICE_AVC_ME_VERSION_INTEL, uint32_t, &DeviceInfo::vmeAvcVersion> {};
|
|
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_SUPPORTS_PREEMPTION_INTEL > : public MapBase<CL_DEVICE_AVC_ME_SUPPORTS_PREEMPTION_INTEL, uint32_t, &DeviceInfo::vmeAvcSupportsPreemption> {};
|
|
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_DOUBLE_FP_CONFIG > : public MapBase<CL_DEVICE_DOUBLE_FP_CONFIG, uint64_t, &DeviceInfo::doubleFpConfig> {};
|
|
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_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_TYPE > : public MapBase<CL_DEVICE_PARTITION_TYPE, cl_device_partition_property*, &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_SINGLE_FP_CONFIG > : public MapBase<CL_DEVICE_SINGLE_FP_CONFIG, uint64_t, &DeviceInfo::singleFpConfig> {};
|
|
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_ID > : public MapBase<CL_DEVICE_VENDOR_ID, uint32_t, &DeviceInfo::vendorId> {};
|
|
template<> struct Map<CL_DEVICE_VENDOR > : public MapBase<CL_DEVICE_VENDOR, const char *, &DeviceInfo::vendor> {};
|
|
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_DRIVER_VERSION_INTEL > : public MapBase<CL_DEVICE_DRIVER_VERSION_INTEL, uint32_t, &DeviceInfo::internalDriverVersion> {};
|
|
// clang-format on
|
|
} // namespace DeviceInfoTable
|