L0 extension for cache reservation

Signed-off-by: Milczarek, Slawomir <slawomir.milczarek@intel.com>

level_zero/CMakeLists.txt

@@ -382,6 +382,7 @@ if(BUILD_WITH_L0)
                                    L0_API
                                    L0_SOURCES_LINUX
                                    L0_SOURCES_WINDOWS
+                                   L0_SRCS_CACHE_RESERVATION
                                    L0_SRCS_COMPILER_INTERFACE
                                    L0_SRCS_DEBUGGER
                                    L0_SRCS_DRIVER
@@ -389,11 +390,13 @@ if(BUILD_WITH_L0)
     )
     if(WIN32)
       append_sources_from_properties(L0_RUNTIME_SOURCES
+                                     L0_SRCS_CACHE_RESERVATION_WINDOWS
                                      L0_SRCS_DEBUGGER_WINDOWS
                                      L0_SRCS_DRIVER_WINDOWS
       )
     else()
       append_sources_from_properties(L0_RUNTIME_SOURCES
+                                     L0_SRCS_CACHE_RESERVATION_LINUX
                                      L0_SRCS_DEBUGGER_LINUX
                                      L0_SRCS_DRIVER_LINUX
       )

level_zero/api/core/ze_device.cpp

@@ -121,4 +121,21 @@ zeDeviceGetGlobalTimestamps(
     uint64_t *hostTimestamp,
     uint64_t *deviceTimestamp) {
     return L0::Device::fromHandle(hDevice)->getGlobalTimestamps(hostTimestamp, deviceTimestamp);
-}
+}
+
+ZE_APIEXPORT ze_result_t ZE_APICALL
+zeDeviceReserveCacheExt(
+    ze_device_handle_t hDevice,
+    size_t cacheLevel,
+    size_t cacheReservationSize) {
+    return L0::Device::fromHandle(hDevice)->reserveCache(cacheLevel, cacheReservationSize);
+}
+
+ZE_APIEXPORT ze_result_t ZE_APICALL
+zeDeviceSetCacheAdviceExt(
+    ze_device_handle_t hDevice,
+    void *ptr,
+    size_t regionSize,
+    ze_cache_ext_region_t cacheRegion) {
+    return L0::Device::fromHandle(hDevice)->setCacheAdvice(ptr, regionSize, cacheRegion);
+}

level_zero/core/source/cache/CMakeLists.txt

@@ -0,0 +1,13 @@
+#
+# Copyright (C) 2021 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+#
+
+set(L0_SRCS_CACHE_RESERVATION
+    ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
+    ${CMAKE_CURRENT_SOURCE_DIR}/cache_reservation.h
+)
+
+add_subdirectories()
+set_property(GLOBAL PROPERTY L0_SRCS_CACHE_RESERVATION ${L0_SRCS_CACHE_RESERVATION})

level_zero/core/source/cache/cache_reservation.h

@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2021 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#pragma once
+#include <level_zero/zet_api.h>
+
+#include <memory>
+#include <stdint.h>
+
+namespace L0 {
+
+struct Device;
+
+class CacheReservation {
+  public:
+    virtual ~CacheReservation() = default;
+
+    static std::unique_ptr<CacheReservation> create(Device &device);
+
+    virtual bool reserveCache(size_t cacheLevel, size_t cacheReservationSize) = 0;
+    virtual bool setCacheAdvice(void *ptr, size_t regionSize, ze_cache_ext_region_t cacheRegion) = 0;
+    virtual size_t getMaxCacheReservationSize() = 0;
+};
+
+} // namespace L0

level_zero/core/source/cache/linux/CMakeLists.txt

@@ -0,0 +1,15 @@
+#
+# Copyright (C) 2021 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+#
+
+set(L0_SRCS_CACHE_RESERVATION_LINUX
+    ${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(UNIX)
+  set_property(GLOBAL PROPERTY L0_SRCS_CACHE_RESERVATION_LINUX ${L0_SRCS_CACHE_RESERVATION_LINUX})
+endif()

level_zero/core/source/cache/linux/cache_reservation_impl.cpp

@@ -0,0 +1,28 @@
+/*
+ * Copyright (C) 2021 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "level_zero/core/source/cache/linux/cache_reservation_impl.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) {
+    return false;
+}
+
+bool CacheReservationImpl::setCacheAdvice(void *ptr, size_t regionSize, ze_cache_ext_region_t cacheRegion) {
+    return false;
+}
+
+size_t CacheReservationImpl::getMaxCacheReservationSize() {
+    return 0;
+}
+
+} // namespace L0

level_zero/core/source/cache/linux/cache_reservation_impl.h

@@ -0,0 +1,23 @@
+/*
+ * Copyright (C) 2021 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#pragma once
+#include "level_zero/core/source/cache/cache_reservation.h"
+
+namespace L0 {
+
+class CacheReservationImpl : public CacheReservation {
+  public:
+    ~CacheReservationImpl() override = default;
+    CacheReservationImpl(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;
+};
+
+} // namespace L0

level_zero/core/source/cache/windows/CMakeLists.txt

@@ -0,0 +1,15 @@
+#
+# Copyright (C) 2021 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+#
+
+set(L0_SRCS_CACHE_RESERVATION_WINDOWS
+    ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
+    ${CMAKE_CURRENT_SOURCE_DIR}/cache_reservation_impl.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/cache_reservation_impl.h
+)
+
+if(WIN32)
+  set_property(GLOBAL PROPERTY L0_SRCS_CACHE_RESERVATION_WINDOWS ${L0_SRCS_CACHE_RESERVATION_WINDOWS})
+endif()

level_zero/core/source/cache/windows/cache_reservation_impl.cpp

@@ -0,0 +1,28 @@
+/*
+ * Copyright (C) 2021 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "level_zero/core/source/cache/windows/cache_reservation_impl.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) {
+    return false;
+}
+
+bool CacheReservationImpl::setCacheAdvice(void *ptr, size_t regionSize, ze_cache_ext_region_t cacheRegion) {
+    return false;
+}
+
+size_t CacheReservationImpl::getMaxCacheReservationSize() {
+    return 0;
+}
+
+} // namespace L0

level_zero/core/source/cache/windows/cache_reservation_impl.h

@@ -0,0 +1,23 @@
+/*
+ * Copyright (C) 2021 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#pragma once
+#include "level_zero/core/source/cache/cache_reservation.h"
+
+namespace L0 {
+
+class CacheReservationImpl : public CacheReservation {
+  public:
+    ~CacheReservationImpl() override = default;
+    CacheReservationImpl(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;
+};
+
+} // namespace L0

level_zero/core/source/device/device.h

@@ -67,6 +67,8 @@ struct Device : _ze_device_handle_t {
     virtual ze_result_t getProperties(ze_device_properties_t *pDeviceProperties) = 0;
     virtual ze_result_t getSubDevices(uint32_t *pCount, ze_device_handle_t *phSubdevices) = 0;
     virtual ze_result_t getCacheProperties(uint32_t *pCount, ze_device_cache_properties_t *pCacheProperties) = 0;
+    virtual ze_result_t reserveCache(size_t cacheLevel, size_t cacheReservationSize) = 0;
+    virtual ze_result_t setCacheAdvice(void *ptr, size_t regionSize, ze_cache_ext_region_t cacheRegion) = 0;
     virtual ze_result_t imageGetProperties(const ze_image_desc_t *desc, ze_image_properties_t *pImageProperties) = 0;
     virtual ze_result_t getDeviceImageProperties(ze_device_image_properties_t *pDeviceImageProperties) = 0;
     virtual ze_result_t getExternalMemoryProperties(ze_device_external_memory_properties_t *pExternalMemoryProperties) = 0;

level_zero/core/source/device/device_imp.cpp

@@ -31,6 +31,7 @@
 #include "opencl/source/program/program.h"
 
 #include "level_zero/core/source/builtin/builtin_functions_lib.h"
+#include "level_zero/core/source/cache/cache_reservation.h"
 #include "level_zero/core/source/cmdlist/cmdlist.h"
 #include "level_zero/core/source/cmdqueue/cmdqueue.h"
 #include "level_zero/core/source/driver/driver_handle_imp.h"
@@ -505,6 +506,50 @@ ze_result_t DeviceImp::getCacheProperties(uint32_t *pCount, ze_device_cache_prop
     pCacheProperties[0].cacheSize = hardwareInfo.gtSystemInfo.L3BankCount * 128 * KB;
     pCacheProperties[0].flags = 0;
 
+    if (pCacheProperties->pNext) {
+        auto extendedProperties = reinterpret_cast<ze_device_cache_properties_t *>(pCacheProperties->pNext);
+        if (extendedProperties->stype == ZE_STRUCTURE_TYPE_CACHE_RESERVATION_EXT_DESC) {
+            auto cacheReservationProperties = reinterpret_cast<ze_cache_reservation_ext_desc_t *>(extendedProperties);
+            cacheReservationProperties->maxCacheReservationSize = cacheReservation->getMaxCacheReservationSize();
+        } else {
+            return ZE_RESULT_ERROR_UNSUPPORTED_ENUMERATION;
+        }
+    }
+
+    return ZE_RESULT_SUCCESS;
+}
+
+ze_result_t DeviceImp::reserveCache(size_t cacheLevel, size_t cacheReservationSize) {
+    if (cacheReservation->getMaxCacheReservationSize() == 0) {
+        return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
+    }
+
+    if (cacheLevel == 0) {
+        cacheLevel = 3;
+    }
+
+    auto result = cacheReservation->reserveCache(cacheLevel, cacheReservationSize);
+    if (result == false) {
+        return ZE_RESULT_ERROR_UNINITIALIZED;
+    }
+
+    return ZE_RESULT_SUCCESS;
+}
+
+ze_result_t DeviceImp::setCacheAdvice(void *ptr, size_t regionSize, ze_cache_ext_region_t cacheRegion) {
+    if (cacheReservation->getMaxCacheReservationSize() == 0) {
+        return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
+    }
+
+    if (cacheRegion == ze_cache_ext_region_t::ZE_CACHE_EXT_REGION_ZE_CACHE_REGION_DEFAULT) {
+        cacheRegion = ze_cache_ext_region_t::ZE_CACHE_EXT_REGION_ZE_CACHE_NON_RESERVED_REGION;
+    }
+
+    auto result = cacheReservation->setCacheAdvice(ptr, regionSize, cacheRegion);
+    if (result == false) {
+        return ZE_RESULT_ERROR_UNINITIALIZED;
+    }
+
     return ZE_RESULT_SUCCESS;
 }
 
@@ -609,6 +654,7 @@ Device *Device::create(DriverHandle *driverHandle, NEO::Device *neoDevice, uint3
     device->metricContext = MetricContext::create(*device);
     device->builtins = BuiltinFunctionsLib::create(
         device, neoDevice->getBuiltIns());
+    device->cacheReservation = CacheReservation::create(*device);
     device->maxNumHwThreads = NEO::HwHelper::getMaxThreadsForVfe(neoDevice->getHardwareInfo());
 
     const bool allocateDebugSurface = (device->getL0Debugger() || neoDevice->getDeviceInfo().debuggerActive) && !isSubDevice;
@@ -716,6 +762,7 @@ void DeviceImp::releaseResources() {
     }
     metricContext.reset();
     builtins.reset();
+    cacheReservation.reset();
 
     if (getSourceLevelDebugger()) {
         getSourceLevelDebugger()->notifyDeviceDestruction();

level_zero/core/source/device/device_imp.h

@@ -10,6 +10,7 @@
 #include "shared/source/utilities/spinlock.h"
 
 #include "level_zero/core/source/builtin/builtin_functions_lib.h"
+#include "level_zero/core/source/cache/cache_reservation.h"
 #include "level_zero/core/source/cmdlist/cmdlist.h"
 #include "level_zero/core/source/device/device.h"
 #include "level_zero/core/source/driver/driver_handle.h"
@@ -45,6 +46,8 @@ struct DeviceImp : public Device {
     ze_result_t getProperties(ze_device_properties_t *pDeviceProperties) override;
     ze_result_t getSubDevices(uint32_t *pCount, ze_device_handle_t *phSubdevices) override;
     ze_result_t getCacheProperties(uint32_t *pCount, ze_device_cache_properties_t *pCacheProperties) override;
+    ze_result_t reserveCache(size_t cacheLevel, size_t cacheReservationSize) override;
+    ze_result_t setCacheAdvice(void *ptr, size_t regionSize, ze_cache_ext_region_t cacheRegion) override;
     ze_result_t imageGetProperties(const ze_image_desc_t *desc, ze_image_properties_t *pImageProperties) override;
     ze_result_t getDeviceImageProperties(ze_device_image_properties_t *pDeviceImageProperties) override;
     ze_result_t getCommandQueueGroupProperties(uint32_t *pCount,
@@ -97,6 +100,7 @@ struct DeviceImp : public Device {
     void *execEnvironment = nullptr;
     std::unique_ptr<BuiltinFunctionsLib> builtins = nullptr;
     std::unique_ptr<MetricContext> metricContext = nullptr;
+    std::unique_ptr<CacheReservation> cacheReservation = nullptr;
     uint32_t maxNumHwThreads = 0;
     uint32_t numSubDevices = 0;
     std::vector<Device *> subDevices;

level_zero/core/test/unit_tests/mocks/mock_device.h

@@ -113,6 +113,17 @@ struct Mock<Device> : public Device {
                 (uint32_t * pCount,
                  ze_device_cache_properties_t *pCacheProperties),
                 (override));
+    MOCK_METHOD(ze_result_t,
+                reserveCache,
+                (size_t cacheLevel,
+                 size_t cacheReservationSize),
+                (override));
+    MOCK_METHOD(ze_result_t,
+                setCacheAdvice,
+                (void *ptr,
+                 size_t regionSize,
+                 ze_cache_ext_region_t cacheRegion),
+                (override));
     MOCK_METHOD(ze_result_t,
                 imageGetProperties,
                 (const ze_image_desc_t *desc,

level_zero/core/test/unit_tests/sources/cache/CMakeLists.txt

@@ -0,0 +1,11 @@
+#
+# Copyright (C) 2021 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+#
+
+target_sources(${TARGET_NAME} PRIVATE
+               ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
+)
+
+add_subdirectories()

level_zero/core/test/unit_tests/sources/cache/linux/CMakeLists.txt

@@ -0,0 +1,12 @@
+#
+# Copyright (C) 2021 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+#
+
+if(UNIX)
+  target_sources(${TARGET_NAME} PRIVATE
+                 ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
+                 ${CMAKE_CURRENT_SOURCE_DIR}${BRANCH_DIR_SUFFIX}/test_cache_reservation_impl.cpp
+  )
+endif()

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

@@ -0,0 +1,56 @@
+/*
+ * Copyright (C) 2021 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "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() override {
+        DeviceFixture::SetUp();
+        auto deviceImp = static_cast<DeviceImp *>(device);
+        ASSERT_NE(nullptr, deviceImp->cacheReservation.get());
+
+        cache = deviceImp->cacheReservation.get();
+    }
+    void TearDown() override {
+        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/windows/CMakeLists.txt

@@ -0,0 +1,12 @@
+#
+# Copyright (C) 2021 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+#
+
+if(WIN32)
+  target_sources(${TARGET_NAME} PRIVATE
+                 ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
+                 ${CMAKE_CURRENT_SOURCE_DIR}/test_cache_reservation_impl.cpp
+  )
+endif()

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

@@ -0,0 +1,56 @@
+/*
+ * Copyright (C) 2021 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "test.h"
+
+#include "level_zero/core/source/cache/windows/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() override {
+        DeviceFixture::SetUp();
+        auto deviceImp = static_cast<DeviceImp *>(device);
+        ASSERT_NE(nullptr, deviceImp->cacheReservation.get());
+        cache = deviceImp->cacheReservation.get();
+    }
+    void TearDown() override {
+        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/device/test_device.cpp

@@ -342,7 +342,8 @@ TEST_F(DeviceTest, givenKernelPropertiesStructureWhenKernelPropertiesCalledThenA
 }
 
 TEST_F(DeviceTest, givenDeviceCachePropertiesThenAllPropertiesAreAssigned) {
-    ze_device_cache_properties_t deviceCacheProperties, deviceCachePropertiesBefore;
+    ze_device_cache_properties_t deviceCacheProperties = {};
+    ze_device_cache_properties_t deviceCachePropertiesBefore = {};
 
     deviceCacheProperties.cacheSize = std::numeric_limits<size_t>::max();
 
@@ -1341,5 +1342,168 @@ TEST(zeDevice, givenNoImagesSupportedWhenGettingImagePropertiesThenZeroValuesAre
     EXPECT_EQ(0u, properties.maxWriteImageArgs);
 }
 
+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, 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);
+    }
+}
+
 } // namespace ult
 } // namespace L0