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 API for querying number of slices

Browse Source 
Related-To: NEO-3426

Change-Id: I2893be858de9f0f6516ca6ded61123c2c15f1494
Signed-off-by: Mateusz Jablonski <mateusz.jablonski@intel.com>
This commit is contained in:
Mateusz Jablonski
2019-07-15 11:13:40 +02:00
committed by sys_ocldev
parent dda6e29254
commit 1114361994
6 changed files with 65 additions and 21 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
public/cl_ext_private.h
View File

@ -110,3 +110,13 @@ using cl_unified_shared_memory_capabilities_intel = cl_bitfield;
#define CL_COMMAND_MEMCPY_INTEL 0x4205
#define CL_COMMAND_MIGRATEMEM_INTEL 0x4206
#define CL_COMMAND_MEMADVISE_INTEL 0x4207
/******************************
* SLICE COUNT SELECTING *
*******************************/
/* cl_device_info */
#define CL_DEVICE_SLICE_COUNT_INTEL 0x10020
/* cl_queue_properties */
#define CL_QUEUE_SLICE_COUNT_INTEL 0x10021

1
runtime/device/device_caps.cpp
View File

@ -247,6 +247,7 @@ void Device::initializeCaps() {
deviceInfo.maxComputUnits = systemInfo.EUCount;
deviceInfo.maxConstantArgs = 8;
deviceInfo.maxNumEUsPerSubSlice = 0;
deviceInfo.maxSliceCount = systemInfo.SliceCount;
deviceInfo.numThreadsPerEU = 0;
auto simdSizeUsed = DebugManager.flags.UseMaxSimdSizeToDeduceMaxWorkgroupSize.get() ? 32 : 8;

21
runtime/device/device_info.cpp
View File

@ -74,15 +74,19 @@ cl_int Device::getDeviceInfo(cl_device_info paramName,
const void *src = nullptr;
// clang-format off
// please keep alphabetical order
switch (paramName) {
case CL_DEVICE_ADDRESS_BITS: getCap<CL_DEVICE_ADDRESS_BITS >(src, srcSize, retSize); break;
case CL_DEVICE_AVAILABLE: getCap<CL_DEVICE_AVAILABLE >(src, srcSize, retSize); break;
case CL_DEVICE_AVC_ME_VERSION_INTEL: getCap<CL_DEVICE_AVC_ME_VERSION_INTEL >(src, srcSize, retSize); break;
case CL_DEVICE_AVC_ME_SUPPORTS_TEXTURE_SAMPLER_USE_INTEL: getCap<CL_DEVICE_AVC_ME_SUPPORTS_TEXTURE_SAMPLER_USE_INTEL >(src, srcSize, retSize); break;
case CL_DEVICE_AVC_ME_SUPPORTS_PREEMPTION_INTEL: getCap<CL_DEVICE_AVC_ME_SUPPORTS_PREEMPTION_INTEL >(src, srcSize, retSize); break;
case CL_DEVICE_AVC_ME_SUPPORTS_TEXTURE_SAMPLER_USE_INTEL: getCap<CL_DEVICE_AVC_ME_SUPPORTS_TEXTURE_SAMPLER_USE_INTEL >(src, srcSize, retSize); break;
case CL_DEVICE_AVC_ME_VERSION_INTEL: getCap<CL_DEVICE_AVC_ME_VERSION_INTEL >(src, srcSize, retSize); break;
case CL_DEVICE_BUILT_IN_KERNELS: getStr<CL_DEVICE_BUILT_IN_KERNELS >(src, srcSize, retSize); break;
case CL_DEVICE_COMPILER_AVAILABLE: getCap<CL_DEVICE_COMPILER_AVAILABLE >(src, srcSize, retSize); break;
case CL_DEVICE_CROSS_DEVICE_SHARED_MEM_CAPABILITIES_INTEL: getCap<CL_DEVICE_CROSS_DEVICE_SHARED_MEM_CAPABILITIES_INTEL >(src, srcSize, retSize); break;
case CL_DEVICE_DEVICE_MEM_CAPABILITIES_INTEL: getCap<CL_DEVICE_DEVICE_MEM_CAPABILITIES_INTEL >(src, srcSize, retSize); break;
case CL_DEVICE_DOUBLE_FP_CONFIG: getCap<CL_DEVICE_DOUBLE_FP_CONFIG >(src, srcSize, retSize); break;
case CL_DEVICE_DRIVER_VERSION_INTEL: getCap<CL_DEVICE_DRIVER_VERSION_INTEL >(src, srcSize, retSize); break;
case CL_DEVICE_ENDIAN_LITTLE: getCap<CL_DEVICE_ENDIAN_LITTLE >(src, srcSize, retSize); break;
case CL_DEVICE_ERROR_CORRECTION_SUPPORT: getCap<CL_DEVICE_ERROR_CORRECTION_SUPPORT >(src, srcSize, retSize); break;
case CL_DEVICE_EXECUTION_CAPABILITIES: getCap<CL_DEVICE_EXECUTION_CAPABILITIES >(src, srcSize, retSize); break;
@ -93,6 +97,7 @@ cl_int Device::getDeviceInfo(cl_device_info paramName,
case CL_DEVICE_GLOBAL_MEM_SIZE: getCap<CL_DEVICE_GLOBAL_MEM_SIZE >(src, srcSize, retSize); break;
case CL_DEVICE_GLOBAL_VARIABLE_PREFERRED_TOTAL_SIZE: getCap<CL_DEVICE_GLOBAL_VARIABLE_PREFERRED_TOTAL_SIZE >(src, srcSize, retSize); break;
case CL_DEVICE_HALF_FP_CONFIG: getCap<CL_DEVICE_HALF_FP_CONFIG >(src, srcSize, retSize); break;
case CL_DEVICE_HOST_MEM_CAPABILITIES_INTEL: getCap<CL_DEVICE_HOST_MEM_CAPABILITIES_INTEL >(src, srcSize, retSize); break;
case CL_DEVICE_HOST_UNIFIED_MEMORY: getCap<CL_DEVICE_HOST_UNIFIED_MEMORY >(src, srcSize, retSize); break;
case CL_DEVICE_IL_VERSION: getStr<CL_DEVICE_IL_VERSION >(src, srcSize, retSize); break;
case CL_DEVICE_IMAGE2D_MAX_HEIGHT: getCap<CL_DEVICE_IMAGE2D_MAX_HEIGHT >(src, srcSize, retSize); break;
@ -164,7 +169,10 @@ cl_int Device::getDeviceInfo(cl_device_info paramName,
case CL_DEVICE_QUEUE_ON_DEVICE_PREFERRED_SIZE: getCap<CL_DEVICE_QUEUE_ON_DEVICE_PREFERRED_SIZE >(src, srcSize, retSize); break;
case CL_DEVICE_QUEUE_ON_DEVICE_PROPERTIES: getCap<CL_DEVICE_QUEUE_ON_DEVICE_PROPERTIES >(src, srcSize, retSize); break;
case CL_DEVICE_QUEUE_ON_HOST_PROPERTIES: getCap<CL_DEVICE_QUEUE_ON_HOST_PROPERTIES >(src, srcSize, retSize); break;
case CL_DEVICE_SHARED_SYSTEM_MEM_CAPABILITIES_INTEL: getCap<CL_DEVICE_SHARED_SYSTEM_MEM_CAPABILITIES_INTEL >(src, srcSize, retSize); break;
case CL_DEVICE_SINGLE_DEVICE_SHARED_MEM_CAPABILITIES_INTEL: getCap<CL_DEVICE_SINGLE_DEVICE_SHARED_MEM_CAPABILITIES_INTEL >(src, srcSize, retSize); break;
case CL_DEVICE_SINGLE_FP_CONFIG: getCap<CL_DEVICE_SINGLE_FP_CONFIG >(src, srcSize, retSize); break;
case CL_DEVICE_SLICE_COUNT_INTEL: getCap<CL_DEVICE_SLICE_COUNT_INTEL >(src, srcSize, retSize); break;
case CL_DEVICE_SPIR_VERSIONS: getStr<CL_DEVICE_SPIR_VERSIONS >(src, srcSize, retSize); break;
case CL_DEVICE_SUB_GROUP_INDEPENDENT_FORWARD_PROGRESS: getCap<CL_DEVICE_SUB_GROUP_INDEPENDENT_FORWARD_PROGRESS >(src, srcSize, retSize); break;
case CL_DEVICE_SUB_GROUP_SIZES_INTEL: getCap<CL_DEVICE_SUB_GROUP_SIZES_INTEL >(src, srcSize, retSize); break;
@ -173,14 +181,7 @@ cl_int Device::getDeviceInfo(cl_device_info paramName,
case CL_DEVICE_VENDOR: getStr<CL_DEVICE_VENDOR >(src, srcSize, retSize); break;
case CL_DEVICE_VENDOR_ID: getCap<CL_DEVICE_VENDOR_ID >(src, srcSize, retSize); break;
case CL_DEVICE_VERSION: getStr<CL_DEVICE_VERSION >(src, srcSize, retSize); break;
case CL_DRIVER_VERSION: getStr<CL_DRIVER_VERSION >(src, srcSize, retSize); break;
case CL_DEVICE_DRIVER_VERSION_INTEL: getCap<CL_DEVICE_DRIVER_VERSION_INTEL >(src, srcSize, retSize); break;
case CL_DEVICE_HOST_MEM_CAPABILITIES_INTEL: getCap<CL_DEVICE_HOST_MEM_CAPABILITIES_INTEL >(src, srcSize, retSize); break;
case CL_DEVICE_DEVICE_MEM_CAPABILITIES_INTEL: getCap<CL_DEVICE_DEVICE_MEM_CAPABILITIES_INTEL >(src, srcSize, retSize); break;
case CL_DEVICE_SINGLE_DEVICE_SHARED_MEM_CAPABILITIES_INTEL: getCap<CL_DEVICE_SINGLE_DEVICE_SHARED_MEM_CAPABILITIES_INTEL >(src, srcSize, retSize); break;
case CL_DEVICE_CROSS_DEVICE_SHARED_MEM_CAPABILITIES_INTEL: getCap<CL_DEVICE_CROSS_DEVICE_SHARED_MEM_CAPABILITIES_INTEL >(src, srcSize, retSize); break;
case CL_DEVICE_SHARED_SYSTEM_MEM_CAPABILITIES_INTEL: getCap<CL_DEVICE_SHARED_SYSTEM_MEM_CAPABILITIES_INTEL >(src, srcSize, retSize); break;
// clang-format on
case CL_DRIVER_VERSION: getStr<CL_DRIVER_VERSION >(src, srcSize, retSize); break; // clang-format on
case CL_DEVICE_NUM_SIMULTANEOUS_INTEROPS_INTEL:
if (simultaneousInterops.size() > 1u) {
srcSize = retSize = sizeof(cl_uint);

1
runtime/device/device_info.h
View File

@ -18,6 +18,7 @@ struct DeviceInfo {
cl_device_type deviceType;
size_t maxWorkGroupSize;
size_t maxNumEUsPerSubSlice;
size_t maxSliceCount;
cl_ulong maxMemAllocSize;
size_t imageMaxBufferSize;
size_t image2DMaxWidth;

21
runtime/device/device_info_map.h
View File

@ -36,14 +36,18 @@ struct Map {};
// 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_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_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> {};
@ -54,6 +58,7 @@ template<> struct Map<CL_DEVICE_GLOBAL_MEM_CACHE_TYPE > :
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> {};
@ -124,21 +129,17 @@ template<> struct Map<CL_DEVICE_QUEUE_ON_DEVICE_MAX_SIZE > :
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_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_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_DRIVER_VERSION_INTEL > : public MapBase<CL_DEVICE_DRIVER_VERSION_INTEL, uint32_t, &DeviceInfo::internalDriverVersion> {};
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_DEVICE_MEM_CAPABILITIES_INTEL > : public MapBase<CL_DEVICE_DEVICE_MEM_CAPABILITIES_INTEL, uint64_t, &DeviceInfo::deviceMemCapabilities> {};
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_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_SHARED_SYSTEM_MEM_CAPABILITIES_INTEL > : public MapBase<CL_DEVICE_SHARED_SYSTEM_MEM_CAPABILITIES_INTEL, uint64_t, &DeviceInfo::sharedSystemMemCapabilities> {};
// clang-format on
} // namespace DeviceInfoTable

32
unit_tests/api/cl_get_device_info_tests.inl
View File

@ -14,10 +14,40 @@
using namespace NEO;
typedef api_tests clGetDeviceInfoTests;
using clGetDeviceInfoTests = api_tests;
namespace ULT {
TEST_F(clGetDeviceInfoTests, givenNeoDeviceWhenAskedForSliceCountThenNumberOfSlicesIsReturned) {
cl_device_info paramName = 0;
size_t paramSize = 0;
void *paramValue = nullptr;
size_t paramRetSize = 0;
size_t numSlices = 0;
paramName = CL_DEVICE_SLICE_COUNT_INTEL;
retVal = clGetDeviceInfo(
devices[0],
paramName,
0,
nullptr,
&paramRetSize);
EXPECT_EQ(sizeof(size_t), paramRetSize);
paramSize = paramRetSize;
paramValue = &numSlices;
retVal = clGetDeviceInfo(
devices[0],
paramName,
paramSize,
paramValue,
&paramRetSize);
EXPECT_EQ(platformDevices[0]->gtSystemInfo.SliceCount, numSlices);
}
TEST_F(clGetDeviceInfoTests, GivenGpuDeviceWhenGettingDeviceInfoThenDeviceTypeGpuIsReturned) {
cl_device_info paramName = 0;
size_t paramSize = 0;