183 lines
27 KiB
C++
183 lines
27 KiB
C++
/*
|
|
* Copyright (C) 2020-2023 Intel Corporation
|
|
*
|
|
* SPDX-License-Identifier: MIT
|
|
*
|
|
*/
|
|
|
|
#pragma once
|
|
#include "shared/source/device/device_info.h"
|
|
|
|
#include "opencl/extensions/public/cl_ext_private.h"
|
|
#include "opencl/source/cl_device/cl_device.h"
|
|
#include "opencl/source/cl_device/cl_device_info.h"
|
|
|
|
#include "CL/cl_ext.h"
|
|
#include <CL/cl.h>
|
|
|
|
namespace NEO {
|
|
|
|
namespace ClDeviceInfoTable {
|
|
|
|
template <cl_device_info Param, typename _Type, _Type ClDeviceInfo::*val>
|
|
struct ClMapBase {
|
|
enum { param = Param };
|
|
typedef _Type Type;
|
|
enum { size = sizeof(Type) };
|
|
|
|
static const Type &getValue(const NEO::ClDevice &clDevice) {
|
|
return clDevice.getDeviceInfo().*val;
|
|
}
|
|
};
|
|
|
|
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 NEO::ClDevice &clDevice) {
|
|
return clDevice.getSharedDeviceInfo().*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
|
|
// 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_AVC_ME_SUPPORTS_PREEMPTION_INTEL> : public MapBase<CL_DEVICE_AVC_ME_SUPPORTS_PREEMPTION_INTEL, uint32_t, &DeviceInfo::vmeAvcSupportsPreemption> {};
|
|
template<> struct Map<CL_DEVICE_ERROR_CORRECTION_SUPPORT > : public MapBase<CL_DEVICE_ERROR_CORRECTION_SUPPORT, uint32_t, &DeviceInfo::errorCorrectionSupport> {};
|
|
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_SIZE > : public MapBase<CL_DEVICE_GLOBAL_MEM_SIZE, uint64_t, &DeviceInfo::globalMemSize> {};
|
|
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_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_SUPPORT > : public MapBase<CL_DEVICE_IMAGE_SUPPORT, uint32_t, &DeviceInfo::imageSupport> {};
|
|
template<> struct Map<CL_DEVICE_LOCAL_MEM_SIZE > : public MapBase<CL_DEVICE_LOCAL_MEM_SIZE, uint64_t, &DeviceInfo::localMemSize> {};
|
|
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_MEM_ALLOC_SIZE > : public MapBase<CL_DEVICE_MAX_MEM_ALLOC_SIZE, uint64_t, &DeviceInfo::maxMemAllocSize> {};
|
|
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_READ_IMAGE_ARGS > : public MapBase<CL_DEVICE_MAX_READ_IMAGE_ARGS, uint32_t, &DeviceInfo::maxReadImageArgs> {};
|
|
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_WRITE_IMAGE_ARGS > : public MapBase<CL_DEVICE_MAX_WRITE_IMAGE_ARGS, uint32_t, &DeviceInfo::maxWriteImageArgs> {};
|
|
template<> struct Map<CL_DEVICE_PRINTF_BUFFER_SIZE > : public MapBase<CL_DEVICE_PRINTF_BUFFER_SIZE, size_t, &DeviceInfo::printfBufferSize> {};
|
|
template<> struct Map<CL_DEVICE_PROFILING_TIMER_RESOLUTION > : public MapBase<CL_DEVICE_PROFILING_TIMER_RESOLUTION, size_t, &DeviceInfo::outProfilingTimerResolution> {};
|
|
template<> struct Map<CL_DEVICE_VENDOR_ID > : public MapBase<CL_DEVICE_VENDOR_ID, uint32_t, &DeviceInfo::vendorId> {};
|
|
|
|
template<> struct Map<CL_DEVICE_ATOMIC_FENCE_CAPABILITIES > : public ClMapBase<CL_DEVICE_ATOMIC_FENCE_CAPABILITIES, uint64_t, &ClDeviceInfo::atomicFenceCapabilities> {};
|
|
template<> struct Map<CL_DEVICE_ATOMIC_MEMORY_CAPABILITIES > : public ClMapBase<CL_DEVICE_ATOMIC_MEMORY_CAPABILITIES, uint64_t, &ClDeviceInfo::atomicMemoryCapabilities> {};
|
|
template<> struct Map<CL_DEVICE_AVAILABLE > : public ClMapBase<CL_DEVICE_AVAILABLE, uint32_t, &ClDeviceInfo::deviceAvailable> {};
|
|
template<> struct Map<CL_DEVICE_AVC_ME_SUPPORTS_TEXTURE_SAMPLER_USE_INTEL > : public ClMapBase<CL_DEVICE_AVC_ME_SUPPORTS_TEXTURE_SAMPLER_USE_INTEL, uint32_t, &ClDeviceInfo::vmeAvcSupportsTextureSampler> {};
|
|
template<> struct Map<CL_DEVICE_AVC_ME_VERSION_INTEL > : public ClMapBase<CL_DEVICE_AVC_ME_VERSION_INTEL, uint32_t, &ClDeviceInfo::vmeAvcVersion> {};
|
|
template<> struct Map<CL_DEVICE_BUILT_IN_KERNELS > : public ClMapBase<CL_DEVICE_BUILT_IN_KERNELS, const char *, &ClDeviceInfo::builtInKernels> {};
|
|
template<> struct Map<CL_DEVICE_COMPILER_AVAILABLE > : public ClMapBase<CL_DEVICE_COMPILER_AVAILABLE, uint32_t, &ClDeviceInfo::compilerAvailable> {};
|
|
template<> struct Map<CL_DEVICE_CROSS_DEVICE_SHARED_MEM_CAPABILITIES_INTEL > : public ClMapBase<CL_DEVICE_CROSS_DEVICE_SHARED_MEM_CAPABILITIES_INTEL, uint64_t, &ClDeviceInfo::crossDeviceSharedMemCapabilities> {};
|
|
template<> struct Map<CL_DEVICE_DEVICE_ENQUEUE_CAPABILITIES > : public ClMapBase<CL_DEVICE_DEVICE_ENQUEUE_CAPABILITIES, uint64_t, &ClDeviceInfo::deviceEnqueueSupport> {};
|
|
template<> struct Map<CL_DEVICE_DEVICE_MEM_CAPABILITIES_INTEL > : public ClMapBase<CL_DEVICE_DEVICE_MEM_CAPABILITIES_INTEL, uint64_t, &ClDeviceInfo::deviceMemCapabilities> {};
|
|
template<> struct Map<CL_DEVICE_DOUBLE_FP_ATOMIC_CAPABILITIES_EXT > : public ClMapBase<CL_DEVICE_DOUBLE_FP_ATOMIC_CAPABILITIES_EXT, uint64_t, &ClDeviceInfo::doubleFpAtomicCapabilities> {};
|
|
template<> struct Map<CL_DEVICE_DOUBLE_FP_CONFIG > : public ClMapBase<CL_DEVICE_DOUBLE_FP_CONFIG, uint64_t, &ClDeviceInfo::doubleFpConfig> {};
|
|
template<> struct Map<CL_DEVICE_DRIVER_VERSION_INTEL > : public ClMapBase<CL_DEVICE_DRIVER_VERSION_INTEL, uint32_t, &ClDeviceInfo::internalDriverVersion> {};
|
|
template<> struct Map<CL_DEVICE_ENDIAN_LITTLE > : public ClMapBase<CL_DEVICE_ENDIAN_LITTLE, uint32_t, &ClDeviceInfo::endianLittle> {};
|
|
template<> struct Map<CL_DEVICE_EXECUTION_CAPABILITIES > : public ClMapBase<CL_DEVICE_EXECUTION_CAPABILITIES, uint64_t, &ClDeviceInfo::executionCapabilities> {};
|
|
template<> struct Map<CL_DEVICE_EXTENSIONS > : public ClMapBase<CL_DEVICE_EXTENSIONS, const char *, &ClDeviceInfo::deviceExtensions> {};
|
|
template<> struct Map<CL_DEVICE_GENERIC_ADDRESS_SPACE_SUPPORT > : public ClMapBase<CL_DEVICE_GENERIC_ADDRESS_SPACE_SUPPORT, uint32_t, &ClDeviceInfo::genericAddressSpaceSupport> {};
|
|
template<> struct Map<CL_DEVICE_GLOBAL_MEM_CACHE_SIZE > : public ClMapBase<CL_DEVICE_GLOBAL_MEM_CACHE_SIZE, uint64_t, &ClDeviceInfo::globalMemCacheSize> {};
|
|
template<> struct Map<CL_DEVICE_GLOBAL_MEM_CACHE_TYPE > : public ClMapBase<CL_DEVICE_GLOBAL_MEM_CACHE_TYPE, uint32_t, &ClDeviceInfo::globalMemCacheType> {};
|
|
template<> struct Map<CL_DEVICE_GLOBAL_VARIABLE_PREFERRED_TOTAL_SIZE > : public ClMapBase<CL_DEVICE_GLOBAL_VARIABLE_PREFERRED_TOTAL_SIZE, size_t, &ClDeviceInfo::globalVariablePreferredTotalSize> {};
|
|
template<> struct Map<CL_DEVICE_HALF_FP_ATOMIC_CAPABILITIES_EXT > : public ClMapBase<CL_DEVICE_HALF_FP_ATOMIC_CAPABILITIES_EXT, uint64_t, &ClDeviceInfo::halfFpAtomicCapabilities> {};
|
|
template<> struct Map<CL_DEVICE_HALF_FP_CONFIG > : public ClMapBase<CL_DEVICE_HALF_FP_CONFIG, uint64_t, &ClDeviceInfo::halfFpConfig> {};
|
|
template<> struct Map<CL_DEVICE_HOST_MEM_CAPABILITIES_INTEL > : public ClMapBase<CL_DEVICE_HOST_MEM_CAPABILITIES_INTEL, uint64_t, &ClDeviceInfo::hostMemCapabilities> {};
|
|
template<> struct Map<CL_DEVICE_HOST_UNIFIED_MEMORY > : public ClMapBase<CL_DEVICE_HOST_UNIFIED_MEMORY, uint32_t, &ClDeviceInfo::hostUnifiedMemory> {};
|
|
template<> struct Map<CL_DEVICE_ILS_WITH_VERSION > : public ClMapBase<CL_DEVICE_ILS_WITH_VERSION, cl_name_version[1], &ClDeviceInfo::ilsWithVersion> {};
|
|
template<> struct Map<CL_DEVICE_IMAGE3D_MAX_HEIGHT > : public ClMapBase<CL_DEVICE_IMAGE3D_MAX_HEIGHT, size_t, &ClDeviceInfo::image3DMaxHeight> {};
|
|
template<> struct Map<CL_DEVICE_IMAGE3D_MAX_WIDTH > : public ClMapBase<CL_DEVICE_IMAGE3D_MAX_WIDTH, size_t, &ClDeviceInfo::image3DMaxWidth> {};
|
|
template<> struct Map<CL_DEVICE_IMAGE_BASE_ADDRESS_ALIGNMENT > : public ClMapBase<CL_DEVICE_IMAGE_BASE_ADDRESS_ALIGNMENT, uint32_t, &ClDeviceInfo::imageBaseAddressAlignment> {};
|
|
template<> struct Map<CL_DEVICE_IMAGE_PITCH_ALIGNMENT > : public ClMapBase<CL_DEVICE_IMAGE_PITCH_ALIGNMENT, uint32_t, &ClDeviceInfo::imagePitchAlignment> {};
|
|
template<> struct Map<CL_DEVICE_LATEST_CONFORMANCE_VERSION_PASSED > : public ClMapBase<CL_DEVICE_LATEST_CONFORMANCE_VERSION_PASSED, const char *, &ClDeviceInfo::latestConformanceVersionPassed> {};
|
|
template<> struct Map<CL_DEVICE_LINKER_AVAILABLE > : public ClMapBase<CL_DEVICE_LINKER_AVAILABLE, uint32_t, &ClDeviceInfo::linkerAvailable> {};
|
|
template<> struct Map<CL_DEVICE_LOCAL_MEM_TYPE > : public ClMapBase<CL_DEVICE_LOCAL_MEM_TYPE, uint32_t, &ClDeviceInfo::localMemType> {};
|
|
template<> struct Map<CL_DEVICE_MAX_COMPUTE_UNITS > : public ClMapBase<CL_DEVICE_MAX_COMPUTE_UNITS, uint32_t, &ClDeviceInfo::maxComputUnits> {};
|
|
template<> struct Map<CL_DEVICE_MAX_CONSTANT_ARGS > : public ClMapBase<CL_DEVICE_MAX_CONSTANT_ARGS, uint32_t, &ClDeviceInfo::maxConstantArgs> {};
|
|
template<> struct Map<CL_DEVICE_MAX_CONSTANT_BUFFER_SIZE > : public ClMapBase<CL_DEVICE_MAX_CONSTANT_BUFFER_SIZE, uint64_t, &ClDeviceInfo::maxConstantBufferSize> {};
|
|
template<> struct Map<CL_DEVICE_MAX_GLOBAL_VARIABLE_SIZE > : public ClMapBase<CL_DEVICE_MAX_GLOBAL_VARIABLE_SIZE, size_t, &ClDeviceInfo::maxGlobalVariableSize> {};
|
|
template<> struct Map<CL_DEVICE_MAX_NUM_SUB_GROUPS > : public ClMapBase<CL_DEVICE_MAX_NUM_SUB_GROUPS, uint32_t, &ClDeviceInfo::maxNumOfSubGroups> {};
|
|
template<> struct Map<CL_DEVICE_MAX_ON_DEVICE_EVENTS > : public ClMapBase<CL_DEVICE_MAX_ON_DEVICE_EVENTS, uint32_t, &ClDeviceInfo::maxOnDeviceEvents> {};
|
|
template<> struct Map<CL_DEVICE_MAX_PIPE_ARGS > : public ClMapBase<CL_DEVICE_MAX_PIPE_ARGS, uint32_t, &ClDeviceInfo::maxPipeArgs> {};
|
|
template<> struct Map<CL_DEVICE_MAX_READ_WRITE_IMAGE_ARGS > : public ClMapBase<CL_DEVICE_MAX_READ_WRITE_IMAGE_ARGS, uint32_t, &ClDeviceInfo::maxReadWriteImageArgs> {};
|
|
template<> struct Map<CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS > : public ClMapBase<CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS, uint32_t, &ClDeviceInfo::maxWorkItemDimensions> {};
|
|
template<> struct Map<CL_DEVICE_MEM_BASE_ADDR_ALIGN > : public ClMapBase<CL_DEVICE_MEM_BASE_ADDR_ALIGN, uint32_t, &ClDeviceInfo::memBaseAddressAlign> {};
|
|
template<> struct Map<CL_DEVICE_ME_VERSION_INTEL > : public ClMapBase<CL_DEVICE_ME_VERSION_INTEL, uint32_t, &ClDeviceInfo::vmeVersion> {};
|
|
template<> struct Map<CL_DEVICE_MIN_DATA_TYPE_ALIGN_SIZE > : public ClMapBase<CL_DEVICE_MIN_DATA_TYPE_ALIGN_SIZE, uint32_t, &ClDeviceInfo::minDataTypeAlignSize> {};
|
|
template<> struct Map<CL_DEVICE_NAME > : public ClMapBase<CL_DEVICE_NAME, const char *, &ClDeviceInfo::name> {};
|
|
template<> struct Map<CL_DEVICE_NATIVE_VECTOR_WIDTH_CHAR > : public ClMapBase<CL_DEVICE_NATIVE_VECTOR_WIDTH_CHAR, uint32_t, &ClDeviceInfo::nativeVectorWidthChar> {};
|
|
template<> struct Map<CL_DEVICE_NATIVE_VECTOR_WIDTH_DOUBLE > : public ClMapBase<CL_DEVICE_NATIVE_VECTOR_WIDTH_DOUBLE, uint32_t, &ClDeviceInfo::nativeVectorWidthDouble> {};
|
|
template<> struct Map<CL_DEVICE_NATIVE_VECTOR_WIDTH_FLOAT > : public ClMapBase<CL_DEVICE_NATIVE_VECTOR_WIDTH_FLOAT, uint32_t, &ClDeviceInfo::nativeVectorWidthFloat> {};
|
|
template<> struct Map<CL_DEVICE_NATIVE_VECTOR_WIDTH_HALF > : public ClMapBase<CL_DEVICE_NATIVE_VECTOR_WIDTH_HALF, uint32_t, &ClDeviceInfo::nativeVectorWidthHalf> {};
|
|
template<> struct Map<CL_DEVICE_NATIVE_VECTOR_WIDTH_INT > : public ClMapBase<CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, uint32_t, &ClDeviceInfo::nativeVectorWidthInt> {};
|
|
template<> struct Map<CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG > : public ClMapBase<CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, uint32_t, &ClDeviceInfo::nativeVectorWidthLong> {};
|
|
template<> struct Map<CL_DEVICE_NATIVE_VECTOR_WIDTH_SHORT > : public ClMapBase<CL_DEVICE_NATIVE_VECTOR_WIDTH_SHORT, uint32_t, &ClDeviceInfo::nativeVectorWidthShort> {};
|
|
template<> struct Map<CL_DEVICE_NON_UNIFORM_WORK_GROUP_SUPPORT > : public ClMapBase<CL_DEVICE_NON_UNIFORM_WORK_GROUP_SUPPORT, uint32_t, &ClDeviceInfo::nonUniformWorkGroupSupport> {};
|
|
template<> struct Map<CL_DEVICE_NUMERIC_VERSION > : public ClMapBase<CL_DEVICE_NUMERIC_VERSION, uint32_t, &ClDeviceInfo::numericClVersion> {};
|
|
template<> struct Map<CL_DEVICE_OPENCL_C_VERSION > : public ClMapBase<CL_DEVICE_OPENCL_C_VERSION, const char *, &ClDeviceInfo::clCVersion> {};
|
|
template<> struct Map<CL_DEVICE_PARENT_DEVICE > : public ClMapBase<CL_DEVICE_PARENT_DEVICE, cl_device_id, &ClDeviceInfo::parentDevice> {};
|
|
template<> struct Map<CL_DEVICE_PARTITION_AFFINITY_DOMAIN > : public ClMapBase<CL_DEVICE_PARTITION_AFFINITY_DOMAIN, uint64_t, &ClDeviceInfo::partitionAffinityDomain> {};
|
|
template<> struct Map<CL_DEVICE_PARTITION_MAX_SUB_DEVICES > : public ClMapBase<CL_DEVICE_PARTITION_MAX_SUB_DEVICES, uint32_t, &ClDeviceInfo::partitionMaxSubDevices> {};
|
|
template<> struct Map<CL_DEVICE_PARTITION_PROPERTIES > : public ClMapBase<CL_DEVICE_PARTITION_PROPERTIES, cl_device_partition_property[2], &ClDeviceInfo::partitionProperties> {};
|
|
template<> struct Map<CL_DEVICE_PARTITION_TYPE > : public ClMapBase<CL_DEVICE_PARTITION_TYPE, cl_device_partition_property[3], &ClDeviceInfo::partitionType> {};
|
|
template<> struct Map<CL_DEVICE_PIPE_MAX_ACTIVE_RESERVATIONS > : public ClMapBase<CL_DEVICE_PIPE_MAX_ACTIVE_RESERVATIONS, uint32_t, &ClDeviceInfo::pipeMaxActiveReservations> {};
|
|
template<> struct Map<CL_DEVICE_PIPE_MAX_PACKET_SIZE > : public ClMapBase<CL_DEVICE_PIPE_MAX_PACKET_SIZE, uint32_t, &ClDeviceInfo::pipeMaxPacketSize> {};
|
|
template<> struct Map<CL_DEVICE_PIPE_SUPPORT > : public ClMapBase<CL_DEVICE_PIPE_SUPPORT, uint32_t, &ClDeviceInfo::pipeSupport> {};
|
|
template<> struct Map<CL_DEVICE_PLANAR_YUV_MAX_HEIGHT_INTEL > : public ClMapBase<CL_DEVICE_PLANAR_YUV_MAX_HEIGHT_INTEL, size_t, &ClDeviceInfo::planarYuvMaxHeight> {};
|
|
template<> struct Map<CL_DEVICE_PLANAR_YUV_MAX_WIDTH_INTEL > : public ClMapBase<CL_DEVICE_PLANAR_YUV_MAX_WIDTH_INTEL, size_t, &ClDeviceInfo::planarYuvMaxWidth> {};
|
|
template<> struct Map<CL_DEVICE_PREFERRED_GLOBAL_ATOMIC_ALIGNMENT > : public ClMapBase<CL_DEVICE_PREFERRED_GLOBAL_ATOMIC_ALIGNMENT, uint32_t, &ClDeviceInfo::preferredGlobalAtomicAlignment> {};
|
|
template<> struct Map<CL_DEVICE_PREFERRED_INTEROP_USER_SYNC > : public ClMapBase<CL_DEVICE_PREFERRED_INTEROP_USER_SYNC, uint32_t, &ClDeviceInfo::preferredInteropUserSync> {};
|
|
template<> struct Map<CL_DEVICE_PREFERRED_LOCAL_ATOMIC_ALIGNMENT > : public ClMapBase<CL_DEVICE_PREFERRED_LOCAL_ATOMIC_ALIGNMENT, uint32_t, &ClDeviceInfo::preferredLocalAtomicAlignment> {};
|
|
template<> struct Map<CL_DEVICE_PREFERRED_PLATFORM_ATOMIC_ALIGNMENT > : public ClMapBase<CL_DEVICE_PREFERRED_PLATFORM_ATOMIC_ALIGNMENT, uint32_t, &ClDeviceInfo::preferredPlatformAtomicAlignment> {};
|
|
template<> struct Map<CL_DEVICE_PREFERRED_VECTOR_WIDTH_CHAR > : public ClMapBase<CL_DEVICE_PREFERRED_VECTOR_WIDTH_CHAR, uint32_t, &ClDeviceInfo::preferredVectorWidthChar> {};
|
|
template<> struct Map<CL_DEVICE_PREFERRED_VECTOR_WIDTH_DOUBLE > : public ClMapBase<CL_DEVICE_PREFERRED_VECTOR_WIDTH_DOUBLE, uint32_t, &ClDeviceInfo::preferredVectorWidthDouble> {};
|
|
template<> struct Map<CL_DEVICE_PREFERRED_VECTOR_WIDTH_FLOAT > : public ClMapBase<CL_DEVICE_PREFERRED_VECTOR_WIDTH_FLOAT, uint32_t, &ClDeviceInfo::preferredVectorWidthFloat> {};
|
|
template<> struct Map<CL_DEVICE_PREFERRED_VECTOR_WIDTH_HALF > : public ClMapBase<CL_DEVICE_PREFERRED_VECTOR_WIDTH_HALF, uint32_t, &ClDeviceInfo::preferredVectorWidthHalf> {};
|
|
template<> struct Map<CL_DEVICE_PREFERRED_VECTOR_WIDTH_INT > : public ClMapBase<CL_DEVICE_PREFERRED_VECTOR_WIDTH_INT, uint32_t, &ClDeviceInfo::preferredVectorWidthInt> {};
|
|
template<> struct Map<CL_DEVICE_PREFERRED_VECTOR_WIDTH_LONG > : public ClMapBase<CL_DEVICE_PREFERRED_VECTOR_WIDTH_LONG, uint32_t, &ClDeviceInfo::preferredVectorWidthLong> {};
|
|
template<> struct Map<CL_DEVICE_PREFERRED_VECTOR_WIDTH_SHORT > : public ClMapBase<CL_DEVICE_PREFERRED_VECTOR_WIDTH_SHORT, uint32_t, &ClDeviceInfo::preferredVectorWidthShort> {};
|
|
template<> struct Map<CL_DEVICE_PREFERRED_WORK_GROUP_SIZE_MULTIPLE > : public ClMapBase<CL_DEVICE_PREFERRED_WORK_GROUP_SIZE_MULTIPLE, size_t, &ClDeviceInfo::preferredWorkGroupSizeMultiple> {};
|
|
template<> struct Map<CL_DEVICE_PROFILE > : public ClMapBase<CL_DEVICE_PROFILE, const char *, &ClDeviceInfo::profile> {};
|
|
template<> struct Map<CL_DEVICE_QUEUE_ON_DEVICE_MAX_SIZE > : public ClMapBase<CL_DEVICE_QUEUE_ON_DEVICE_MAX_SIZE, uint32_t, &ClDeviceInfo::queueOnDeviceMaxSize> {};
|
|
template<> struct Map<CL_DEVICE_MAX_ON_DEVICE_QUEUES > : public ClMapBase<CL_DEVICE_MAX_ON_DEVICE_QUEUES, uint32_t, &ClDeviceInfo::maxOnDeviceQueues> {};
|
|
template<> struct Map<CL_DEVICE_QUEUE_ON_DEVICE_PREFERRED_SIZE > : public ClMapBase<CL_DEVICE_QUEUE_ON_DEVICE_PREFERRED_SIZE, uint32_t, &ClDeviceInfo::queueOnDevicePreferredSize> {};
|
|
template<> struct Map<CL_DEVICE_QUEUE_ON_DEVICE_PROPERTIES > : public ClMapBase<CL_DEVICE_QUEUE_ON_DEVICE_PROPERTIES, uint64_t, &ClDeviceInfo::queueOnDeviceProperties> {};
|
|
template<> struct Map<CL_DEVICE_QUEUE_ON_HOST_PROPERTIES > : public ClMapBase<CL_DEVICE_QUEUE_ON_HOST_PROPERTIES, uint64_t, &ClDeviceInfo::queueOnHostProperties> {};
|
|
template<> struct Map<CL_DEVICE_SHARED_SYSTEM_MEM_CAPABILITIES_INTEL > : public ClMapBase<CL_DEVICE_SHARED_SYSTEM_MEM_CAPABILITIES_INTEL, uint64_t, &ClDeviceInfo::sharedSystemMemCapabilities> {};
|
|
template<> struct Map<CL_DEVICE_SINGLE_DEVICE_SHARED_MEM_CAPABILITIES_INTEL > : public ClMapBase<CL_DEVICE_SINGLE_DEVICE_SHARED_MEM_CAPABILITIES_INTEL, uint64_t, &ClDeviceInfo::singleDeviceSharedMemCapabilities> {};
|
|
template<> struct Map<CL_DEVICE_SINGLE_FP_ATOMIC_CAPABILITIES_EXT > : public ClMapBase<CL_DEVICE_SINGLE_FP_ATOMIC_CAPABILITIES_EXT, uint64_t, &ClDeviceInfo::singleFpAtomicCapabilities> {};
|
|
template<> struct Map<CL_DEVICE_SINGLE_FP_CONFIG > : public ClMapBase<CL_DEVICE_SINGLE_FP_CONFIG, uint64_t, &ClDeviceInfo::singleFpConfig> {};
|
|
template<> struct Map<CL_DEVICE_SLICE_COUNT_INTEL > : public ClMapBase<CL_DEVICE_SLICE_COUNT_INTEL, size_t, &ClDeviceInfo::maxSliceCount> {};
|
|
template<> struct Map<CL_DEVICE_SPIR_VERSIONS > : public ClMapBase<CL_DEVICE_SPIR_VERSIONS, const char *, &ClDeviceInfo::spirVersions> {};
|
|
template<> struct Map<CL_DEVICE_SUB_GROUP_INDEPENDENT_FORWARD_PROGRESS > : public ClMapBase<CL_DEVICE_SUB_GROUP_INDEPENDENT_FORWARD_PROGRESS, uint32_t, &ClDeviceInfo::independentForwardProgress> {};
|
|
template<> struct Map<CL_DEVICE_SVM_CAPABILITIES > : public ClMapBase<CL_DEVICE_SVM_CAPABILITIES, uint64_t, &ClDeviceInfo::svmCapabilities> {};
|
|
template<> struct Map<CL_DEVICE_TYPE > : public ClMapBase<CL_DEVICE_TYPE, uint64_t, &ClDeviceInfo::deviceType> {};
|
|
template<> struct Map<CL_DEVICE_VENDOR > : public ClMapBase<CL_DEVICE_VENDOR, const char *, &ClDeviceInfo::vendor> {};
|
|
template<> struct Map<CL_DEVICE_VERSION > : public ClMapBase<CL_DEVICE_VERSION, const char *, &ClDeviceInfo::clVersion> {};
|
|
template<> struct Map<CL_DRIVER_VERSION > : public ClMapBase<CL_DRIVER_VERSION, const char *, &ClDeviceInfo::driverVersion> {};
|
|
template<> struct Map<CL_DRIVER_UUID_KHR > : public ClMapBase<CL_DRIVER_UUID_KHR, const char *, &ClDeviceInfo::driverVersion> {};
|
|
template<> struct Map<CL_DEVICE_WORK_GROUP_COLLECTIVE_FUNCTIONS_SUPPORT > : public ClMapBase<CL_DEVICE_WORK_GROUP_COLLECTIVE_FUNCTIONS_SUPPORT, uint32_t, &ClDeviceInfo::workGroupCollectiveFunctionsSupport> {};
|
|
// clang-format on
|
|
|
|
} // namespace ClDeviceInfoTable
|
|
|
|
} // namespace NEO
|