feature: add support for L3-cache reservation

Resolves: NEO-7849

Signed-off-by: Maciej Bielski <maciej.bielski@intel.com>

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()

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> CacheReservation::create(Device &device) {
+    return std::make_unique<CacheReservationImpl>(device);
+}
+
+bool CacheReservationImpl::reserveCache(size_t cacheLevel, size_t cacheReservationSize) {
+    auto drm = device.getOsInterface().getDriverModel()->as<NEO::Drm>();
+
+    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<NEO::Drm>();
+
+    auto gpuAllocation = allocData->gpuAllocations.getGraphicsAllocation(device.getRootDeviceIndex());
+    auto drmAllocation = static_cast<NEO::DrmAllocation *>(gpuAllocation);
+
+    return drmAllocation->setCacheAdvice(drm, cacheRegionSize, cacheRegionIdx, !drmAllocation->isAllocatedInLocalMemoryPool());
+}
+
+size_t CacheReservationImpl::getMaxCacheReservationSize() {
+    auto drm = device.getOsInterface().getDriverModel()->as<NEO::Drm>();
+
+    auto cacheInfo = drm->getCacheInfo();
+    return cacheInfo->getMaxReservationCacheSize();
+}
+
+} // namespace L0

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

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 {
 

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
+} // namespace L0

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;
     }

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()

level_zero/core/test/unit_tests/sources/cache/linux/test_cache_reservation_impl.cpp

@@ -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<DeviceImp *>(device);
-        ASSERT_NE(nullptr, deviceImp->cacheReservation.get());
-
-        cache = deviceImp->cacheReservation.get();
-    }
-    void tearDown() {
-        DeviceFixture::tearDown();
-    }
-    CacheReservation *cache = nullptr;
-};
-
-using CacheReservationTest = Test<CacheReservationFixture>;
-
-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<void *>(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

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 <PRODUCT_FAMILY productFamily>
+    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<DriverModel>(mockDrm));
+        rootDeviceEnvironment.initGmm();
+
+        cache = static_cast<DeviceImp *>(device)->cacheReservation.get();
+        ASSERT_NE(nullptr, cache);
+    }
+    void tearDown() {
+        DeviceFixture::tearDown();
+    }
+
+    CacheReservation *cache = nullptr;
+    DrmMockExtended *mockDrm = nullptr;
+};
+
+using CacheReservationTest = Test<CacheReservationFixture>;
+
+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<MockCacheReservationImpl *>(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<MockCacheReservationImpl *>(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<MockCacheReservationImpl *>(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<void *>(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<MockCacheReservationImpl *>(cache);
+    EXPECT_EQ(CacheRegion::none, cacheImpl->reservedCacheRegion);
+    EXPECT_EQ(0u, cacheImpl->reservedCacheSize);
+
+    uint64_t gpuAddress = 0x1200;
+    void *ptr = reinterpret_cast<void *>(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<void *>(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<DrmAllocation *>(svmData->gpuAllocations.getGraphicsAllocation(device->getRootDeviceIndex()));
+    for (auto bo : drmAllocation->getBOs()) {
+        if (bo != nullptr) {
+            EXPECT_NE(CacheRegion::defaultRegion, bo->peekCacheRegion());
+            EXPECT_EQ(static_cast<MockCacheReservationImpl *>(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<void *>(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<DrmAllocation *>(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

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::MockDevice>(NEO::defaultHwInfo.get(), rootDeviceIndex);
+        execEnv = neoDevice->getExecutionEnvironment();
+        execEnv->incRefInternal();
+        NEO::DeviceVector devices;
+        devices.push_back(std::unique_ptr<NEO::Device>(neoDevice));
+        driverHandle = std::make_unique<Mock<L0::DriverHandleImp>>();
+        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<DriverModel>(mockDriverModel));
+    }
+
+    void TearDown() override {
+        driverHandle.reset(nullptr);
+        execEnv->decRefInternal();
+    }
+
+    DrmMockExtended *mockDriverModel = nullptr;
+    std::unique_ptr<Mock<L0::DriverHandleImp>> 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<DeviceImp *>(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<size_t> maxCacheReservationSizeBackup{&MockCacheReservation::maxCacheReservationSize, 0};
+    static_cast<DeviceImp *>(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<DeviceImp *>(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<size_t> maxCacheReservationSizeBackup{&MockCacheReservation::maxCacheReservationSize, 0};
+    static_cast<DeviceImp *>(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<DeviceImp *>(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<DeviceImp *>(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<DeviceImp *>(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<DeviceImp *>(device)->cacheReservation.reset(mockCacheReservation);
+
+    void *ptr = reinterpret_cast<void *>(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<DeviceImp *>(device)->cacheReservation.reset(mockCacheReservation);
+
+    void *ptr = reinterpret_cast<void *>(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<size_t> maxCacheReservationSizeBackup{&MockCacheReservation::maxCacheReservationSize, 0};
+    static_cast<DeviceImp *>(device)->cacheReservation.reset(new MockCacheReservation(*device, true));
+
+    void *ptr = reinterpret_cast<void *>(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<void *>(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<DeviceImp *>(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

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<DeviceImp *>(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<size_t> maxCacheReservationSizeBackup{&MockCacheReservation::maxCacheReservationSize, 0};
-    static_cast<DeviceImp *>(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<DeviceImp *>(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<size_t> maxCacheReservationSizeBackup{&MockCacheReservation::maxCacheReservationSize, 0};
-    static_cast<DeviceImp *>(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<DeviceImp *>(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<DeviceImp *>(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<DeviceImp *>(device)->cacheReservation.reset(mockCacheReservation);
-
-    void *ptr = reinterpret_cast<void *>(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<size_t> maxCacheReservationSizeBackup{&MockCacheReservation::maxCacheReservationSize, 0};
-    static_cast<DeviceImp *>(device)->cacheReservation.reset(new MockCacheReservation(*device, true));
-
-    void *ptr = reinterpret_cast<void *>(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<void *>(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<DeviceImp *>(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) {