diff --git a/level_zero/core/source/cache/linux/CMakeLists.txt b/level_zero/core/source/cache/linux/CMakeLists.txt index f4a9bbff88..28583c9b29 100644 --- a/level_zero/core/source/cache/linux/CMakeLists.txt +++ b/level_zero/core/source/cache/linux/CMakeLists.txt @@ -8,7 +8,19 @@ if(UNIX) target_sources(${L0_STATIC_LIB_NAME} PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt - ${CMAKE_CURRENT_SOURCE_DIR}${BRANCH_DIR_SUFFIX}cache_reservation_impl.cpp - ${CMAKE_CURRENT_SOURCE_DIR}${BRANCH_DIR_SUFFIX}cache_reservation_impl.h ) + + if(NEO_ENABLE_i915_PRELIM_DETECTION) + target_sources(${L0_STATIC_LIB_NAME} + PRIVATE + ${CMAKE_CURRENT_SOURCE_DIR}/cache_reservation_impl_prelim.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/cache_reservation_impl_prelim.h + ) + else() + target_sources(${L0_STATIC_LIB_NAME} + PRIVATE + ${CMAKE_CURRENT_SOURCE_DIR}/cache_reservation_impl_upstream.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/cache_reservation_impl_upstream.h + ) + endif() endif() diff --git a/level_zero/core/source/cache/linux/cache_reservation_impl_prelim.cpp b/level_zero/core/source/cache/linux/cache_reservation_impl_prelim.cpp new file mode 100644 index 0000000000..3ec531bfdd --- /dev/null +++ b/level_zero/core/source/cache/linux/cache_reservation_impl_prelim.cpp @@ -0,0 +1,76 @@ +/* + * Copyright (C) 2021-2024 Intel Corporation + * + * SPDX-License-Identifier: MIT + * + */ + +#include "level_zero/core/source/cache/linux/cache_reservation_impl_prelim.h" + +#include "shared/source/memory_manager/unified_memory_manager.h" +#include "shared/source/os_interface/linux/cache_info.h" +#include "shared/source/os_interface/linux/drm_allocation.h" +#include "shared/source/os_interface/linux/drm_neo.h" + +#include "level_zero/core/source/device/device.h" +#include "level_zero/core/source/driver/driver_handle.h" + +namespace L0 { + +std::unique_ptr CacheReservation::create(Device &device) { + return std::make_unique(device); +} + +bool CacheReservationImpl::reserveCache(size_t cacheLevel, size_t cacheReservationSize) { + auto drm = device.getOsInterface().getDriverModel()->as(); + + auto cacheInfo = drm->getCacheInfo(); + + if (cacheReservationSize == 0) { + cacheInfo->freeCacheRegion(this->reservedCacheRegion); + this->reservedCacheRegion = NEO::CacheRegion::none; + this->reservedCacheSize = 0; + return true; + } + + auto cacheRegion = cacheInfo->reserveCacheRegion(cacheReservationSize); + if (cacheRegion == NEO::CacheRegion::none) { + return false; + } + + this->reservedCacheRegion = cacheRegion; + this->reservedCacheSize = cacheReservationSize; + + return true; +} + +bool CacheReservationImpl::setCacheAdvice(void *ptr, [[maybe_unused]] size_t regionSize, ze_cache_ext_region_t cacheRegion) { + auto cacheRegionIdx = NEO::CacheRegion::defaultRegion; + size_t cacheRegionSize = 0; + + if (cacheRegion == ze_cache_ext_region_t::ZE_CACHE_EXT_REGION_ZE_CACHE_RESERVE_REGION) { + cacheRegionIdx = this->reservedCacheRegion; + cacheRegionSize = this->reservedCacheSize; + } + + auto allocData = device.getDriverHandle()->getSvmAllocsManager()->getSVMAlloc(ptr); + if (allocData == nullptr) { + return false; + } + + auto drm = device.getOsInterface().getDriverModel()->as(); + + auto gpuAllocation = allocData->gpuAllocations.getGraphicsAllocation(device.getRootDeviceIndex()); + auto drmAllocation = static_cast(gpuAllocation); + + return drmAllocation->setCacheAdvice(drm, cacheRegionSize, cacheRegionIdx, !drmAllocation->isAllocatedInLocalMemoryPool()); +} + +size_t CacheReservationImpl::getMaxCacheReservationSize() { + auto drm = device.getOsInterface().getDriverModel()->as(); + + auto cacheInfo = drm->getCacheInfo(); + return cacheInfo->getMaxReservationCacheSize(); +} + +} // namespace L0 diff --git a/level_zero/core/source/cache/linux/cache_reservation_impl_prelim.h b/level_zero/core/source/cache/linux/cache_reservation_impl_prelim.h new file mode 100644 index 0000000000..839a97bdaf --- /dev/null +++ b/level_zero/core/source/cache/linux/cache_reservation_impl_prelim.h @@ -0,0 +1,31 @@ +/* + * Copyright (C) 2021-2024 Intel Corporation + * + * SPDX-License-Identifier: MIT + * + */ + +#pragma once +#include "shared/source/helpers/common_types.h" +#include "shared/source/os_interface/linux/cache_info.h" + +#include "level_zero/core/source/cache/cache_reservation.h" + +namespace L0 { + +class CacheReservationImpl : public CacheReservation { + public: + ~CacheReservationImpl() override = default; + CacheReservationImpl(Device &device) : device(device){}; + + bool reserveCache(size_t cacheLevel, size_t cacheReservationSize) override; + bool setCacheAdvice(void *ptr, size_t regionSize, ze_cache_ext_region_t cacheRegion) override; + size_t getMaxCacheReservationSize() override; + + protected: + Device &device; + NEO::CacheRegion reservedCacheRegion = NEO::CacheRegion::none; + size_t reservedCacheSize = 0; +}; + +} // namespace L0 diff --git a/level_zero/core/source/cache/linux/cache_reservation_impl.cpp b/level_zero/core/source/cache/linux/cache_reservation_impl_upstream.cpp similarity index 97% rename from level_zero/core/source/cache/linux/cache_reservation_impl.cpp rename to level_zero/core/source/cache/linux/cache_reservation_impl_upstream.cpp index 6adf3b96dc..ca877737f8 100644 --- a/level_zero/core/source/cache/linux/cache_reservation_impl.cpp +++ b/level_zero/core/source/cache/linux/cache_reservation_impl_upstream.cpp @@ -5,7 +5,7 @@ * */ -#include "level_zero/core/source/cache/linux/cache_reservation_impl.h" +#include "level_zero/core/source/cache/linux/cache_reservation_impl_upstream.h" namespace L0 { diff --git a/level_zero/core/source/cache/linux/cache_reservation_impl.h b/level_zero/core/source/cache/linux/cache_reservation_impl_upstream.h similarity index 96% rename from level_zero/core/source/cache/linux/cache_reservation_impl.h rename to level_zero/core/source/cache/linux/cache_reservation_impl_upstream.h index 36908cfd0a..821b5134f1 100644 --- a/level_zero/core/source/cache/linux/cache_reservation_impl.h +++ b/level_zero/core/source/cache/linux/cache_reservation_impl_upstream.h @@ -20,4 +20,4 @@ class CacheReservationImpl : public CacheReservation { size_t getMaxCacheReservationSize() override; }; -} // namespace L0 \ No newline at end of file +} // namespace L0 diff --git a/level_zero/core/source/device/device_imp.cpp b/level_zero/core/source/device/device_imp.cpp index 70cffd4ad1..98342c6726 100644 --- a/level_zero/core/source/device/device_imp.cpp +++ b/level_zero/core/source/device/device_imp.cpp @@ -21,6 +21,7 @@ #include "shared/source/helpers/bindless_heaps_helper.h" #include "shared/source/helpers/compiler_product_helper.h" #include "shared/source/helpers/constants.h" +#include "shared/source/helpers/driver_model_type.h" #include "shared/source/helpers/engine_node_helper.h" #include "shared/source/helpers/gfx_core_helper.h" #include "shared/source/helpers/hw_info.h" @@ -1146,6 +1147,10 @@ ze_result_t DeviceImp::getCacheProperties(uint32_t *pCount, ze_device_cache_prop } ze_result_t DeviceImp::reserveCache(size_t cacheLevel, size_t cacheReservationSize) { + if (getOsInterface().getDriverModel()->getDriverModelType() != NEO::DriverModelType::drm) { + return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; + } + if (cacheReservation->getMaxCacheReservationSize() == 0) { return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; } @@ -1163,6 +1168,10 @@ ze_result_t DeviceImp::reserveCache(size_t cacheLevel, size_t cacheReservationSi } ze_result_t DeviceImp::setCacheAdvice(void *ptr, size_t regionSize, ze_cache_ext_region_t cacheRegion) { + if (getOsInterface().getDriverModel()->getDriverModelType() != NEO::DriverModelType::drm) { + return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; + } + if (cacheReservation->getMaxCacheReservationSize() == 0) { return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; } diff --git a/level_zero/core/test/unit_tests/sources/cache/linux/CMakeLists.txt b/level_zero/core/test/unit_tests/sources/cache/linux/CMakeLists.txt index 090848006d..d3d05995ec 100644 --- a/level_zero/core/test/unit_tests/sources/cache/linux/CMakeLists.txt +++ b/level_zero/core/test/unit_tests/sources/cache/linux/CMakeLists.txt @@ -4,9 +4,9 @@ # SPDX-License-Identifier: MIT # -if(UNIX) +if(UNIX AND NEO_ENABLE_i915_PRELIM_DETECTION) target_sources(${TARGET_NAME} PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt - ${CMAKE_CURRENT_SOURCE_DIR}${BRANCH_DIR_SUFFIX}test_cache_reservation_impl.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/test_cache_reservation_impl_prelim.cpp ) endif() diff --git a/level_zero/core/test/unit_tests/sources/cache/linux/test_cache_reservation_impl.cpp b/level_zero/core/test/unit_tests/sources/cache/linux/test_cache_reservation_impl.cpp deleted file mode 100644 index 15c8c0b933..0000000000 --- a/level_zero/core/test/unit_tests/sources/cache/linux/test_cache_reservation_impl.cpp +++ /dev/null @@ -1,56 +0,0 @@ -/* - * Copyright (C) 2021-2024 Intel Corporation - * - * SPDX-License-Identifier: MIT - * - */ - -#include "shared/test/common/test_macros/test.h" - -#include "level_zero/core/source/cache/linux/cache_reservation_impl.h" -#include "level_zero/core/test/unit_tests/fixtures/device_fixture.h" - -using namespace NEO; - -namespace L0 { -namespace ult { - -class CacheReservationFixture : public DeviceFixture { - public: - void setUp() { - DeviceFixture::setUp(); - auto deviceImp = static_cast(device); - ASSERT_NE(nullptr, deviceImp->cacheReservation.get()); - - cache = deviceImp->cacheReservation.get(); - } - void tearDown() { - DeviceFixture::tearDown(); - } - CacheReservation *cache = nullptr; -}; - -using CacheReservationTest = Test; - -TEST_F(CacheReservationTest, GivenCacheReservationCreatedWhenCallingReserveCacheThenReturnFalse) { - size_t cacheLevel = 3; - size_t cacheReservationSize = 1024; - - auto result = cache->reserveCache(cacheLevel, cacheReservationSize); - EXPECT_FALSE(result); -} - -TEST_F(CacheReservationTest, GivenCacheReservationCreatedWhenCallingSetCacheAdviceThenReturnFalse) { - void *ptr = reinterpret_cast(0x123456789); - size_t regionSize = 512; - ze_cache_ext_region_t cacheRegion = ze_cache_ext_region_t::ZE_CACHE_EXT_REGION_ZE_CACHE_REGION_DEFAULT; - - auto result = cache->setCacheAdvice(ptr, regionSize, cacheRegion); - EXPECT_FALSE(result); -} - -TEST_F(CacheReservationTest, GivenCacheReservationCreatedWhenCallingGetMaxCacheReservationSizeThenReturnZero) { - EXPECT_EQ(0u, cache->getMaxCacheReservationSize()); -} -} // namespace ult -} // namespace L0 diff --git a/level_zero/core/test/unit_tests/sources/cache/linux/test_cache_reservation_impl_prelim.cpp b/level_zero/core/test/unit_tests/sources/cache/linux/test_cache_reservation_impl_prelim.cpp new file mode 100644 index 0000000000..9c522bf325 --- /dev/null +++ b/level_zero/core/test/unit_tests/sources/cache/linux/test_cache_reservation_impl_prelim.cpp @@ -0,0 +1,233 @@ +/* + * Copyright (C) 2021-2024 Intel Corporation + * + * SPDX-License-Identifier: MIT + * + */ + +#include "shared/test/common/mocks/linux/mock_drm_allocation.h" +#include "shared/test/common/mocks/mock_device.h" +#include "shared/test/common/os_interface/linux/drm_mock_cache_info.h" +#include "shared/test/common/os_interface/linux/drm_mock_extended.h" +#include "shared/test/common/test_macros/hw_test.h" +#include "shared/test/common/test_macros/test.h" + +#include "level_zero/core/source/cache/linux/cache_reservation_impl_prelim.h" +#include "level_zero/core/test/unit_tests/fixtures/device_fixture.h" + +using namespace NEO; + +struct IsCacheReservationSupported { + template + static constexpr bool isMatched() { + if constexpr (IGFX_DG1 == productFamily) { + return false; + } else { + return true; + } + } +}; + +namespace L0 { +namespace ult { + +class MockCacheReservationImpl : public CacheReservationImpl { + public: + using CacheReservationImpl::reservedCacheRegion; + using CacheReservationImpl::reservedCacheSize; +}; + +class CacheReservationFixture : public DeviceFixture { + public: + void setUp() { + DeviceFixture::setUp(); + + auto &rootDeviceEnvironment{*neoDevice->executionEnvironment->rootDeviceEnvironments[0]}; + const PRODUCT_FAMILY productFamily{rootDeviceEnvironment.getHardwareInfo()->platform.eProductFamily}; + + mockDrm = new DrmMockExtended(rootDeviceEnvironment); + mockDrm->ioctlHelper = IoctlHelper::getI915Helper(productFamily, "2.0", *mockDrm); + mockDrm->ioctlHelper->initialize(); + + mockDrm->cacheInfo.reset(new MockCacheInfo(*mockDrm, 1024, 1, 32)); + rootDeviceEnvironment.osInterface.reset(new NEO::OSInterface); + rootDeviceEnvironment.osInterface->setDriverModel(std::unique_ptr(mockDrm)); + rootDeviceEnvironment.initGmm(); + + cache = static_cast(device)->cacheReservation.get(); + ASSERT_NE(nullptr, cache); + } + void tearDown() { + DeviceFixture::tearDown(); + } + + CacheReservation *cache = nullptr; + DrmMockExtended *mockDrm = nullptr; +}; + +using CacheReservationTest = Test; + +HWTEST2_F(CacheReservationTest, GivenCacheReservationSupportedWhenCallingReserveCacheWithZeroSizeThenRemovePriorReservation, IsCacheReservationSupported) { + size_t cacheLevel = 3; + size_t cacheReservationSize = 0; + + auto result = cache->reserveCache(cacheLevel, cacheReservationSize); + EXPECT_TRUE(result); + + auto cacheImpl = static_cast(cache); + EXPECT_EQ(CacheRegion::none, cacheImpl->reservedCacheRegion); + EXPECT_EQ(0u, cacheImpl->reservedCacheSize); +} + +HWTEST2_F(CacheReservationTest, GivenCacheReservationSupportedWhenCallingReserveCacheWithInvalidSizeThenDontReserveCacheRegion, IsCacheReservationSupported) { + size_t cacheLevel = 3; + size_t cacheReservationSize = 2048; + ASSERT_GT(cacheReservationSize, mockDrm->getCacheInfo()->getMaxReservationCacheSize()); + + auto result = cache->reserveCache(cacheLevel, cacheReservationSize); + EXPECT_FALSE(result); + + auto cacheImpl = static_cast(cache); + EXPECT_EQ(CacheRegion::none, cacheImpl->reservedCacheRegion); + EXPECT_EQ(0u, cacheImpl->reservedCacheSize); +} + +HWTEST2_F(CacheReservationTest, GivenCacheReservationSupportedWhenCallingReserveCacheWithValidSizeThenReserveCacheRegionWithGivenSize, IsCacheReservationSupported) { + size_t cacheLevel = 3; + size_t cacheReservationSize = 1024; + ASSERT_LE(cacheReservationSize, mockDrm->getCacheInfo()->getMaxReservationCacheSize()); + + auto result = cache->reserveCache(cacheLevel, cacheReservationSize); + EXPECT_TRUE(result); + + auto cacheImpl = static_cast(cache); + EXPECT_NE(CacheRegion::none, cacheImpl->reservedCacheRegion); + EXPECT_EQ(1024u, cacheImpl->reservedCacheSize); +} + +HWTEST2_F(CacheReservationTest, GivenCacheReservationSupportedWhenCallingSetCacheAdviceWithInvalidPointerThenReturnFalse, IsCacheReservationSupported) { + size_t cacheLevel = 3; + size_t cacheReservationSize = 1024; + auto result = cache->reserveCache(cacheLevel, cacheReservationSize); + EXPECT_TRUE(result); + + void *ptr = reinterpret_cast(0x123456789); + size_t size = 16384; + ze_cache_ext_region_t cacheRegion = ze_cache_ext_region_t::ZE_CACHE_EXT_REGION_ZE_CACHE_REGION_DEFAULT; + + result = cache->setCacheAdvice(ptr, size, cacheRegion); + EXPECT_FALSE(result); +} + +HWTEST2_F(CacheReservationTest, GivenCacheReservationSupportedWhenCallingSetCacheAdviceOnReservedRegionWithoutPriorCacheReservationThenReturnFalse, IsCacheReservationSupported) { + auto cacheImpl = static_cast(cache); + EXPECT_EQ(CacheRegion::none, cacheImpl->reservedCacheRegion); + EXPECT_EQ(0u, cacheImpl->reservedCacheSize); + + uint64_t gpuAddress = 0x1200; + void *ptr = reinterpret_cast(gpuAddress); + size_t size = 16384; + + MockDrmAllocation mockAllocation(rootDeviceIndex, AllocationType::unifiedSharedMemory, MemoryPool::localMemory); + MockBufferObject bo(rootDeviceIndex, mockDrm, 3, 0, 0, 1); + mockAllocation.bufferObjects[0] = &bo; + mockAllocation.setCpuPtrAndGpuAddress(ptr, gpuAddress); + + NEO::SvmAllocationData allocData(0); + allocData.size = size; + allocData.gpuAllocations.addAllocation(&mockAllocation); + device->getDriverHandle()->getSvmAllocsManager()->insertSVMAlloc(allocData); + + ze_cache_ext_region_t cacheRegion = ze_cache_ext_region_t::ZE_CACHE_EXT_REGION_ZE_CACHE_RESERVE_REGION; + + auto result = cache->setCacheAdvice(ptr, size, cacheRegion); + EXPECT_FALSE(result); +} + +HWTEST2_F(CacheReservationTest, GivenCacheReservationSupportedWhenCallingSetCacheAdviceOnReservedCacheRegionThenSetCacheRegionCorrectly, IsCacheReservationSupported) { + auto &gfxCoreHelper = neoDevice->getGfxCoreHelper(); + if (gfxCoreHelper.getNumCacheRegions() == 0) { + GTEST_SKIP(); + } + size_t cacheLevel = 3; + size_t cacheReservationSize = 1024; + auto result = cache->reserveCache(cacheLevel, cacheReservationSize); + EXPECT_TRUE(result); + + uint64_t gpuAddress = 0x1200; + void *ptr = reinterpret_cast(gpuAddress); + size_t size = 16384; + + MockDrmAllocation mockAllocation(rootDeviceIndex, AllocationType::unifiedSharedMemory, MemoryPool::localMemory); + MockBufferObject bo(rootDeviceIndex, mockDrm, 3, 0, 0, 1); + mockAllocation.bufferObjects[0] = &bo; + mockAllocation.setCpuPtrAndGpuAddress(ptr, gpuAddress); + + NEO::SvmAllocationData allocData(0); + allocData.size = size; + allocData.gpuAllocations.addAllocation(&mockAllocation); + device->getDriverHandle()->getSvmAllocsManager()->insertSVMAlloc(allocData); + + ze_cache_ext_region_t cacheRegion = ze_cache_ext_region_t::ZE_CACHE_EXT_REGION_ZE_CACHE_RESERVE_REGION; + + result = cache->setCacheAdvice(ptr, size, cacheRegion); + EXPECT_TRUE(result); + + auto svmData = device->getDriverHandle()->getSvmAllocsManager()->getSVMAlloc(ptr); + ASSERT_NE(nullptr, svmData); + + auto drmAllocation = static_cast(svmData->gpuAllocations.getGraphicsAllocation(device->getRootDeviceIndex())); + for (auto bo : drmAllocation->getBOs()) { + if (bo != nullptr) { + EXPECT_NE(CacheRegion::defaultRegion, bo->peekCacheRegion()); + EXPECT_EQ(static_cast(cache)->reservedCacheRegion, bo->peekCacheRegion()); + } + } +} + +HWTEST2_F(CacheReservationTest, GivenCacheReservationSupportedWhenCallingSetCacheAdviceOnNonReservedCacheRegionThenSetCacheRegionCorrectly, IsCacheReservationSupported) { + auto &gfxCoreHelper = neoDevice->getGfxCoreHelper(); + if (gfxCoreHelper.getNumCacheRegions() == 0) { + GTEST_SKIP(); + } + size_t cacheLevel = 3; + size_t cacheReservationSize = 1024; + auto result = cache->reserveCache(cacheLevel, cacheReservationSize); + EXPECT_TRUE(result); + + uint64_t gpuAddress = 0x1200; + void *ptr = reinterpret_cast(gpuAddress); + size_t size = 16384; + + MockDrmAllocation mockAllocation(rootDeviceIndex, AllocationType::unifiedSharedMemory, MemoryPool::localMemory); + MockBufferObject bo(rootDeviceIndex, mockDrm, 3, 0, 0, 1); + mockAllocation.bufferObjects[0] = &bo; + mockAllocation.setCpuPtrAndGpuAddress(ptr, gpuAddress); + + NEO::SvmAllocationData allocData(0); + allocData.size = size; + allocData.gpuAllocations.addAllocation(&mockAllocation); + device->getDriverHandle()->getSvmAllocsManager()->insertSVMAlloc(allocData); + + ze_cache_ext_region_t cacheRegion = ze_cache_ext_region_t::ZE_CACHE_EXT_REGION_ZE_CACHE_NON_RESERVED_REGION; + + result = cache->setCacheAdvice(ptr, size, cacheRegion); + EXPECT_TRUE(result); + + auto svmData = device->getDriverHandle()->getSvmAllocsManager()->getSVMAlloc(ptr); + ASSERT_NE(nullptr, svmData); + + auto drmAllocation = static_cast(svmData->gpuAllocations.getGraphicsAllocation(device->getRootDeviceIndex())); + for (auto bo : drmAllocation->getBOs()) { + if (bo != nullptr) { + EXPECT_EQ(CacheRegion::defaultRegion, bo->peekCacheRegion()); + } + } +} + +HWTEST2_F(CacheReservationTest, GivenCacheReservationCreatedWhenCallingGetMaxCacheReservationSizeThenReturnZero, IsCacheReservationSupported) { + EXPECT_EQ(mockDrm->getCacheInfo()->getMaxReservationCacheSize(), cache->getMaxCacheReservationSize()); +} + +} // namespace ult +} // namespace L0 diff --git a/level_zero/core/test/unit_tests/sources/device/device_drm_or_wddm/test_device_exensions.cpp b/level_zero/core/test/unit_tests/sources/device/device_drm_or_wddm/test_device_exensions.cpp index 118774ac4c..e688475361 100644 --- a/level_zero/core/test/unit_tests/sources/device/device_drm_or_wddm/test_device_exensions.cpp +++ b/level_zero/core/test/unit_tests/sources/device/device_drm_or_wddm/test_device_exensions.cpp @@ -1,5 +1,5 @@ /* - * Copyright (C) 2023 Intel Corporation + * Copyright (C) 2023-2024 Intel Corporation * * SPDX-License-Identifier: MIT * @@ -11,7 +11,9 @@ #include "shared/source/os_interface/os_interface.h" #include "shared/test/common/mocks/mock_device.h" #include "shared/test/common/mocks/mock_execution_environment.h" +#include "shared/test/common/os_interface/linux/drm_mock_extended.h" +#include "level_zero/core/source/cache/cache_reservation.h" #include "level_zero/core/test/unit_tests/fixtures/device_fixture.h" #include "level_zero/core/test/unit_tests/mocks/mock_driver_handle.h" @@ -141,5 +143,232 @@ TEST_F(DeviceExtensionTest, whenGetExternalMemoryPropertiesWithoutOsInterfaceIsC EXPECT_FALSE(externalMemoryProperties.memoryAllocationImportTypes & ZE_EXTERNAL_MEMORY_TYPE_FLAG_OPAQUE_WIN32); EXPECT_FALSE(externalMemoryProperties.memoryAllocationImportTypes & ZE_EXTERNAL_MEMORY_TYPE_FLAG_DMA_BUF); } + +class MockCacheReservation : public CacheReservation { + public: + ~MockCacheReservation() override = default; + MockCacheReservation(L0::Device &device, bool initialize) : isInitialized(initialize){}; + + bool reserveCache(size_t cacheLevel, size_t cacheReservationSize) override { + receivedCacheLevel = cacheLevel; + return isInitialized; + } + bool setCacheAdvice(void *ptr, size_t regionSize, ze_cache_ext_region_t cacheRegion) override { + receivedCacheRegion = cacheRegion; + return isInitialized; + } + size_t getMaxCacheReservationSize() override { + return maxCacheReservationSize; + } + + static size_t maxCacheReservationSize; + + bool isInitialized = false; + size_t receivedCacheLevel = 3; + ze_cache_ext_region_t receivedCacheRegion = ze_cache_ext_region_t::ZE_CACHE_EXT_REGION_ZE_CACHE_REGION_DEFAULT; +}; + +size_t MockCacheReservation::maxCacheReservationSize = 1024; + +struct zeDeviceCacheReservationTest : public ::testing::Test { + void SetUp() override { + neoDevice = NEO::MockDevice::createWithNewExecutionEnvironment(NEO::defaultHwInfo.get(), rootDeviceIndex); + execEnv = neoDevice->getExecutionEnvironment(); + execEnv->incRefInternal(); + NEO::DeviceVector devices; + devices.push_back(std::unique_ptr(neoDevice)); + driverHandle = std::make_unique>(); + driverHandle->initialize(std::move(devices)); + device = driverHandle->devices[0]; + + auto &rootDeviceEnvironment{neoDevice->getRootDeviceEnvironmentRef()}; + rootDeviceEnvironment.osInterface.reset(new NEO::OSInterface); + mockDriverModel = new DrmMockExtended(rootDeviceEnvironment); + rootDeviceEnvironment.osInterface->setDriverModel(std::unique_ptr(mockDriverModel)); + } + + void TearDown() override { + driverHandle.reset(nullptr); + execEnv->decRefInternal(); + } + + DrmMockExtended *mockDriverModel = nullptr; + std::unique_ptr> driverHandle; + NEO::ExecutionEnvironment *execEnv; + NEO::Device *neoDevice = nullptr; + L0::Device *device = nullptr; + const uint32_t rootDeviceIndex = 1u; +}; + +TEST_F(zeDeviceCacheReservationTest, givenDeviceCacheExtendedDescriptorWhenGetCachePropertiesCalledWithIncorrectStructureTypeThenReturnErrorUnsupportedEnumeration) { + ze_cache_reservation_ext_desc_t cacheReservationExtDesc = {}; + + ze_device_cache_properties_t deviceCacheProperties = {}; + deviceCacheProperties.pNext = &cacheReservationExtDesc; + + uint32_t count = 1; + ze_result_t res = device->getCacheProperties(&count, &deviceCacheProperties); + EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_ENUMERATION, res); +} + +TEST_F(zeDeviceCacheReservationTest, givenGreaterThanOneCountOfDeviceCachePropertiesWhenGetCachePropertiesIsCalledThenSetCountToOne) { + static_cast(device)->cacheReservation.reset(new MockCacheReservation(*device, true)); + ze_device_cache_properties_t deviceCacheProperties = {}; + + uint32_t count = 10; + ze_result_t res = device->getCacheProperties(&count, &deviceCacheProperties); + EXPECT_EQ(ZE_RESULT_SUCCESS, res); + EXPECT_EQ(count, 1u); +} + +TEST_F(zeDeviceCacheReservationTest, givenDeviceCacheExtendedDescriptorWhenGetCachePropertiesCalledOnDeviceWithNoSupportForCacheReservationThenReturnZeroMaxCacheReservationSize) { + VariableBackup maxCacheReservationSizeBackup{&MockCacheReservation::maxCacheReservationSize, 0}; + static_cast(device)->cacheReservation.reset(new MockCacheReservation(*device, true)); + + ze_cache_reservation_ext_desc_t cacheReservationExtDesc = {}; + cacheReservationExtDesc.stype = ZE_STRUCTURE_TYPE_CACHE_RESERVATION_EXT_DESC; + + ze_device_cache_properties_t deviceCacheProperties = {}; + deviceCacheProperties.pNext = &cacheReservationExtDesc; + + uint32_t count = 1; + ze_result_t res = device->getCacheProperties(&count, &deviceCacheProperties); + EXPECT_EQ(ZE_RESULT_SUCCESS, res); + + EXPECT_EQ(0u, cacheReservationExtDesc.maxCacheReservationSize); +} + +TEST_F(zeDeviceCacheReservationTest, givenDeviceCacheExtendedDescriptorWhenGetCachePropertiesCalledOnDeviceWithSupportForCacheReservationThenReturnNonZeroMaxCacheReservationSize) { + static_cast(device)->cacheReservation.reset(new MockCacheReservation(*device, true)); + + ze_cache_reservation_ext_desc_t cacheReservationExtDesc = {}; + cacheReservationExtDesc.stype = ZE_STRUCTURE_TYPE_CACHE_RESERVATION_EXT_DESC; + + ze_device_cache_properties_t deviceCacheProperties = {}; + deviceCacheProperties.pNext = &cacheReservationExtDesc; + + uint32_t count = 1; + ze_result_t res = device->getCacheProperties(&count, &deviceCacheProperties); + EXPECT_EQ(ZE_RESULT_SUCCESS, res); + + EXPECT_NE(0u, cacheReservationExtDesc.maxCacheReservationSize); +} + +TEST_F(zeDeviceCacheReservationTest, WhenCallingZeDeviceReserveCacheExtOnDeviceWithNoSupportForCacheReservationThenReturnErrorUnsupportedFeature) { + VariableBackup maxCacheReservationSizeBackup{&MockCacheReservation::maxCacheReservationSize, 0}; + static_cast(device)->cacheReservation.reset(new MockCacheReservation(*device, true)); + + size_t cacheLevel = 3; + size_t cacheReservationSize = 1024; + + auto result = zeDeviceReserveCacheExt(device->toHandle(), cacheLevel, cacheReservationSize); + EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, result); +} + +TEST_F(zeDeviceCacheReservationTest, WhenCallingZeDeviceReserveCacheExtWithCacheLevel0ThenDriverShouldDefaultToCacheLevel3) { + auto mockCacheReservation = new MockCacheReservation(*device, true); + static_cast(device)->cacheReservation.reset(mockCacheReservation); + + size_t cacheLevel = 0; + size_t cacheReservationSize = 1024; + + auto result = zeDeviceReserveCacheExt(device->toHandle(), cacheLevel, cacheReservationSize); + EXPECT_EQ(ZE_RESULT_SUCCESS, result); + + EXPECT_EQ(3u, mockCacheReservation->receivedCacheLevel); +} + +TEST_F(zeDeviceCacheReservationTest, WhenCallingZeDeviceReserveCacheExtFailsToReserveCacheOnDeviceThenReturnErrorUninitialized) { + size_t cacheLevel = 3; + size_t cacheReservationSize = 1024; + + for (auto initialize : {false, true}) { + auto mockCacheReservation = new MockCacheReservation(*device, initialize); + static_cast(device)->cacheReservation.reset(mockCacheReservation); + + auto result = zeDeviceReserveCacheExt(device->toHandle(), cacheLevel, cacheReservationSize); + + if (initialize) { + EXPECT_EQ(ZE_RESULT_SUCCESS, result); + } else { + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, result); + } + + EXPECT_EQ(3u, mockCacheReservation->receivedCacheLevel); + } +} + +TEST_F(zeDeviceCacheReservationTest, givenNonDrmDriverModelWhenCallingZeDeviceReserveCacheExtThenUnsupportedFeatureFlagReturned) { + size_t cacheLevel = 3; + size_t cacheReservationSize = 1024; + + auto mockCacheReservation = new MockCacheReservation(*device, true); + static_cast(device)->cacheReservation.reset(mockCacheReservation); + mockDriverModel->getDriverModelTypeCallBase = false; + + auto result = zeDeviceReserveCacheExt(device->toHandle(), cacheLevel, cacheReservationSize); + EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, result); +} + +TEST_F(zeDeviceCacheReservationTest, WhenCallingZeDeviceSetCacheAdviceExtWithDefaultCacheRegionThenDriverShouldDefaultToNonReservedRegion) { + auto mockCacheReservation = new MockCacheReservation(*device, true); + static_cast(device)->cacheReservation.reset(mockCacheReservation); + + void *ptr = reinterpret_cast(0x123456789); + size_t regionSize = 512; + ze_cache_ext_region_t cacheRegion = ze_cache_ext_region_t::ZE_CACHE_EXT_REGION_ZE_CACHE_REGION_DEFAULT; + + auto result = zeDeviceSetCacheAdviceExt(device->toHandle(), ptr, regionSize, cacheRegion); + EXPECT_EQ(ZE_RESULT_SUCCESS, result); + + EXPECT_EQ(ze_cache_ext_region_t::ZE_CACHE_EXT_REGION_ZE_CACHE_NON_RESERVED_REGION, mockCacheReservation->receivedCacheRegion); +} + +TEST_F(zeDeviceCacheReservationTest, givenNonDrmDriverModelWhenCallingZeDeviceSetCacheAdviceExtThenUnsupportedFeatureFlagReturned) { + auto mockCacheReservation = new MockCacheReservation(*device, true); + static_cast(device)->cacheReservation.reset(mockCacheReservation); + + void *ptr = reinterpret_cast(0x123456789); + size_t regionSize = 512; + ze_cache_ext_region_t cacheRegion = ze_cache_ext_region_t::ZE_CACHE_EXT_REGION_ZE_CACHE_REGION_DEFAULT; + mockDriverModel->getDriverModelTypeCallBase = false; + + auto result = zeDeviceSetCacheAdviceExt(device->toHandle(), ptr, regionSize, cacheRegion); + EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, result); +} + +TEST_F(zeDeviceCacheReservationTest, WhenCallingZeDeviceSetCacheAdviceExtOnDeviceWithNoSupportForCacheReservationThenReturnErrorUnsupportedFeature) { + VariableBackup maxCacheReservationSizeBackup{&MockCacheReservation::maxCacheReservationSize, 0}; + static_cast(device)->cacheReservation.reset(new MockCacheReservation(*device, true)); + + void *ptr = reinterpret_cast(0x123456789); + size_t regionSize = 512; + ze_cache_ext_region_t cacheRegion = ze_cache_ext_region_t::ZE_CACHE_EXT_REGION_ZE_CACHE_REGION_DEFAULT; + + auto result = zeDeviceSetCacheAdviceExt(device->toHandle(), ptr, regionSize, cacheRegion); + EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, result); +} + +TEST_F(zeDeviceCacheReservationTest, WhenCallingZeDeviceSetCacheAdviceExtFailsToSetCacheRegionThenReturnErrorUnitialized) { + void *ptr = reinterpret_cast(0x123456789); + size_t regionSize = 512; + ze_cache_ext_region_t cacheRegion = ze_cache_ext_region_t::ZE_CACHE_EXT_REGION_ZE_CACHE_RESERVE_REGION; + + for (auto initialize : {false, true}) { + auto mockCacheReservation = new MockCacheReservation(*device, initialize); + static_cast(device)->cacheReservation.reset(mockCacheReservation); + + auto result = zeDeviceSetCacheAdviceExt(device->toHandle(), ptr, regionSize, cacheRegion); + + if (initialize) { + EXPECT_EQ(ZE_RESULT_SUCCESS, result); + } else { + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, result); + } + + EXPECT_EQ(ze_cache_ext_region_t::ZE_CACHE_EXT_REGION_ZE_CACHE_RESERVE_REGION, mockCacheReservation->receivedCacheRegion); + } +} + } // namespace ult } // namespace L0 \ No newline at end of file diff --git a/level_zero/core/test/unit_tests/sources/device/test_l0_device.cpp b/level_zero/core/test/unit_tests/sources/device/test_l0_device.cpp index 8367086fd7..946b4463e8 100644 --- a/level_zero/core/test/unit_tests/sources/device/test_l0_device.cpp +++ b/level_zero/core/test/unit_tests/sources/device/test_l0_device.cpp @@ -4983,179 +4983,6 @@ TEST(zeDevice, givenNoImagesSupportedWhenCreatingImageErrorReturns) { EXPECT_EQ(nullptr, image); } -class MockCacheReservation : public CacheReservation { - public: - ~MockCacheReservation() override = default; - MockCacheReservation(L0::Device &device, bool initialize) : isInitialized(initialize){}; - - bool reserveCache(size_t cacheLevel, size_t cacheReservationSize) override { - receivedCacheLevel = cacheLevel; - return isInitialized; - } - bool setCacheAdvice(void *ptr, size_t regionSize, ze_cache_ext_region_t cacheRegion) override { - receivedCacheRegion = cacheRegion; - return isInitialized; - } - size_t getMaxCacheReservationSize() override { - return maxCacheReservationSize; - } - - static size_t maxCacheReservationSize; - - bool isInitialized = false; - size_t receivedCacheLevel = 3; - ze_cache_ext_region_t receivedCacheRegion = ze_cache_ext_region_t::ZE_CACHE_EXT_REGION_ZE_CACHE_REGION_DEFAULT; -}; - -size_t MockCacheReservation::maxCacheReservationSize = 1024; - -using zeDeviceCacheReservationTest = DeviceTest; - -TEST_F(zeDeviceCacheReservationTest, givenDeviceCacheExtendedDescriptorWhenGetCachePropertiesCalledWithIncorrectStructureTypeThenReturnErrorUnsupportedEnumeration) { - ze_cache_reservation_ext_desc_t cacheReservationExtDesc = {}; - - ze_device_cache_properties_t deviceCacheProperties = {}; - deviceCacheProperties.pNext = &cacheReservationExtDesc; - - uint32_t count = 1; - ze_result_t res = device->getCacheProperties(&count, &deviceCacheProperties); - EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_ENUMERATION, res); -} - -TEST_F(zeDeviceCacheReservationTest, givenGreaterThanOneCountOfDeviceCachePropertiesWhenGetCachePropertiesIsCalledThenSetCountToOne) { - static_cast(device)->cacheReservation.reset(new MockCacheReservation(*device, true)); - ze_device_cache_properties_t deviceCacheProperties = {}; - - uint32_t count = 10; - ze_result_t res = device->getCacheProperties(&count, &deviceCacheProperties); - EXPECT_EQ(ZE_RESULT_SUCCESS, res); - EXPECT_EQ(count, 1u); -} - -TEST_F(zeDeviceCacheReservationTest, givenDeviceCacheExtendedDescriptorWhenGetCachePropertiesCalledOnDeviceWithNoSupportForCacheReservationThenReturnZeroMaxCacheReservationSize) { - VariableBackup maxCacheReservationSizeBackup{&MockCacheReservation::maxCacheReservationSize, 0}; - static_cast(device)->cacheReservation.reset(new MockCacheReservation(*device, true)); - - ze_cache_reservation_ext_desc_t cacheReservationExtDesc = {}; - cacheReservationExtDesc.stype = ZE_STRUCTURE_TYPE_CACHE_RESERVATION_EXT_DESC; - - ze_device_cache_properties_t deviceCacheProperties = {}; - deviceCacheProperties.pNext = &cacheReservationExtDesc; - - uint32_t count = 1; - ze_result_t res = device->getCacheProperties(&count, &deviceCacheProperties); - EXPECT_EQ(ZE_RESULT_SUCCESS, res); - - EXPECT_EQ(0u, cacheReservationExtDesc.maxCacheReservationSize); -} - -TEST_F(zeDeviceCacheReservationTest, givenDeviceCacheExtendedDescriptorWhenGetCachePropertiesCalledOnDeviceWithSupportForCacheReservationThenReturnNonZeroMaxCacheReservationSize) { - static_cast(device)->cacheReservation.reset(new MockCacheReservation(*device, true)); - - ze_cache_reservation_ext_desc_t cacheReservationExtDesc = {}; - cacheReservationExtDesc.stype = ZE_STRUCTURE_TYPE_CACHE_RESERVATION_EXT_DESC; - - ze_device_cache_properties_t deviceCacheProperties = {}; - deviceCacheProperties.pNext = &cacheReservationExtDesc; - - uint32_t count = 1; - ze_result_t res = device->getCacheProperties(&count, &deviceCacheProperties); - EXPECT_EQ(ZE_RESULT_SUCCESS, res); - - EXPECT_NE(0u, cacheReservationExtDesc.maxCacheReservationSize); -} - -TEST_F(zeDeviceCacheReservationTest, WhenCallingZeDeviceReserveCacheExtOnDeviceWithNoSupportForCacheReservationThenReturnErrorUnsupportedFeature) { - VariableBackup maxCacheReservationSizeBackup{&MockCacheReservation::maxCacheReservationSize, 0}; - static_cast(device)->cacheReservation.reset(new MockCacheReservation(*device, true)); - - size_t cacheLevel = 3; - size_t cacheReservationSize = 1024; - - auto result = zeDeviceReserveCacheExt(device->toHandle(), cacheLevel, cacheReservationSize); - EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, result); -} - -TEST_F(zeDeviceCacheReservationTest, WhenCallingZeDeviceReserveCacheExtWithCacheLevel0ThenDriverShouldDefaultToCacheLevel3) { - auto mockCacheReservation = new MockCacheReservation(*device, true); - static_cast(device)->cacheReservation.reset(mockCacheReservation); - - size_t cacheLevel = 0; - size_t cacheReservationSize = 1024; - - auto result = zeDeviceReserveCacheExt(device->toHandle(), cacheLevel, cacheReservationSize); - EXPECT_EQ(ZE_RESULT_SUCCESS, result); - - EXPECT_EQ(3u, mockCacheReservation->receivedCacheLevel); -} - -TEST_F(zeDeviceCacheReservationTest, WhenCallingZeDeviceReserveCacheExtFailsToReserveCacheOnDeviceThenReturnErrorUninitialized) { - size_t cacheLevel = 3; - size_t cacheReservationSize = 1024; - - for (auto initialize : {false, true}) { - auto mockCacheReservation = new MockCacheReservation(*device, initialize); - static_cast(device)->cacheReservation.reset(mockCacheReservation); - - auto result = zeDeviceReserveCacheExt(device->toHandle(), cacheLevel, cacheReservationSize); - - if (initialize) { - EXPECT_EQ(ZE_RESULT_SUCCESS, result); - } else { - EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, result); - } - - EXPECT_EQ(3u, mockCacheReservation->receivedCacheLevel); - } -} - -TEST_F(zeDeviceCacheReservationTest, WhenCallingZeDeviceSetCacheAdviceExtWithDefaultCacheRegionThenDriverShouldDefaultToNonReservedRegion) { - auto mockCacheReservation = new MockCacheReservation(*device, true); - static_cast(device)->cacheReservation.reset(mockCacheReservation); - - void *ptr = reinterpret_cast(0x123456789); - size_t regionSize = 512; - ze_cache_ext_region_t cacheRegion = ze_cache_ext_region_t::ZE_CACHE_EXT_REGION_ZE_CACHE_REGION_DEFAULT; - - auto result = zeDeviceSetCacheAdviceExt(device->toHandle(), ptr, regionSize, cacheRegion); - EXPECT_EQ(ZE_RESULT_SUCCESS, result); - - EXPECT_EQ(ze_cache_ext_region_t::ZE_CACHE_EXT_REGION_ZE_CACHE_NON_RESERVED_REGION, mockCacheReservation->receivedCacheRegion); -} - -TEST_F(zeDeviceCacheReservationTest, WhenCallingZeDeviceSetCacheAdviceExtOnDeviceWithNoSupportForCacheReservationThenReturnErrorUnsupportedFeature) { - VariableBackup maxCacheReservationSizeBackup{&MockCacheReservation::maxCacheReservationSize, 0}; - static_cast(device)->cacheReservation.reset(new MockCacheReservation(*device, true)); - - void *ptr = reinterpret_cast(0x123456789); - size_t regionSize = 512; - ze_cache_ext_region_t cacheRegion = ze_cache_ext_region_t::ZE_CACHE_EXT_REGION_ZE_CACHE_REGION_DEFAULT; - - auto result = zeDeviceSetCacheAdviceExt(device->toHandle(), ptr, regionSize, cacheRegion); - EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, result); -} - -TEST_F(zeDeviceCacheReservationTest, WhenCallingZeDeviceSetCacheAdviceExtFailsToSetCacheRegionThenReturnErrorUnitialized) { - void *ptr = reinterpret_cast(0x123456789); - size_t regionSize = 512; - ze_cache_ext_region_t cacheRegion = ze_cache_ext_region_t::ZE_CACHE_EXT_REGION_ZE_CACHE_RESERVE_REGION; - - for (auto initialize : {false, true}) { - auto mockCacheReservation = new MockCacheReservation(*device, initialize); - static_cast(device)->cacheReservation.reset(mockCacheReservation); - - auto result = zeDeviceSetCacheAdviceExt(device->toHandle(), ptr, regionSize, cacheRegion); - - if (initialize) { - EXPECT_EQ(ZE_RESULT_SUCCESS, result); - } else { - EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, result); - } - - EXPECT_EQ(ze_cache_ext_region_t::ZE_CACHE_EXT_REGION_ZE_CACHE_RESERVE_REGION, mockCacheReservation->receivedCacheRegion); - } -} - using zeDeviceSystemBarrierTest = DeviceTest; TEST_F(zeDeviceSystemBarrierTest, whenCallingSystemBarrierThenReturnErrorUnsupportedFeature) { diff --git a/shared/source/os_interface/os_interface.h b/shared/source/os_interface/os_interface.h index eca968e7f9..743deb5fe3 100644 --- a/shared/source/os_interface/os_interface.h +++ b/shared/source/os_interface/os_interface.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 2018-2023 Intel Corporation + * Copyright (C) 2018-2024 Intel Corporation * * SPDX-License-Identifier: MIT * @@ -74,7 +74,7 @@ class DriverModel : public NonCopyableClass { virtual uint32_t getDeviceHandle() const = 0; - DriverModelType getDriverModelType() const { + MOCKABLE_VIRTUAL DriverModelType getDriverModelType() const { return driverModelType; } diff --git a/shared/test/common/os_interface/linux/drm_mock_extended.h b/shared/test/common/os_interface/linux/drm_mock_extended.h index fef42e6a7c..b8d17a5038 100644 --- a/shared/test/common/os_interface/linux/drm_mock_extended.h +++ b/shared/test/common/os_interface/linux/drm_mock_extended.h @@ -17,6 +17,7 @@ #include "shared/test/common/helpers/default_hw_info.h" #include "shared/test/common/libult/linux/drm_mock.h" #include "shared/test/common/os_interface/linux/drm_mock_device_blob.h" +#include "shared/test/common/test_macros/mock_method_macros.h" #include @@ -26,16 +27,20 @@ class DrmMockExtended : public DrmMock { public: using Drm::cacheInfo; using Drm::engineInfo; + using Drm::ioctlHelper; using Drm::memoryInfo; using Drm::pageFaultSupported; using Drm::rootDeviceEnvironment; using DrmMock::DrmMock; + using BaseClass = DriverModel; DrmMockExtended(RootDeviceEnvironment &rootDeviceEnvironment) : DrmMockExtended(rootDeviceEnvironment, defaultHwInfo.get()) {} DrmMockExtended(RootDeviceEnvironment &rootDeviceEnvironmentIn, const HardwareInfo *inputHwInfo); int handleRemainingRequests(DrmIoctl request, void *arg) override; + ADDMETHOD_CONST(getDriverModelType, DriverModelType, true, DriverModelType::unknown, (), ()) + static constexpr uint32_t maxEngineCount = 9u; ContextEnginesLoadBalance receivedContextEnginesLoadBalance{}; ContextParamEngines<1 + maxEngineCount> receivedContextParamEngines{};