L0 extension for cache reservation

smilczar · Compute-Runtime-Automation · commit e4eb7538faf8 · 2021-06-29T13:35:23.000+02:00
Signed-off-by: Milczarek, Slawomir &lt;slawomir.milczarek@intel.com&gt;
diff --git a/level_zero/CMakeLists.txt b/level_zero/CMakeLists.txt
@@ -382,18 +382,21 @@ 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
                                    L0_SRCS_OCLOC_SHARED
     )
     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
       )
diff --git a/level_zero/api/core/ze_device.cpp b/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);
+}
diff --git a/level_zero/core/source/cache/CMakeLists.txt b/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})
diff --git a/level_zero/core/source/cache/cache_reservation.h b/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
diff --git a/level_zero/core/source/cache/linux/CMakeLists.txt b/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()
diff --git a/level_zero/core/source/cache/linux/cache_reservation_impl.cpp b/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
diff --git a/level_zero/core/source/cache/linux/cache_reservation_impl.h b/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
diff --git a/level_zero/core/source/cache/windows/CMakeLists.txt b/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()
diff --git a/level_zero/core/source/cache/windows/cache_reservation_impl.cpp b/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
diff --git a/level_zero/core/source/cache/windows/cache_reservation_impl.h b/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
diff --git a/level_zero/core/source/device/device.h b/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;
diff --git a/level_zero/core/source/device/device_imp.cpp b/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();
diff --git a/level_zero/core/source/device/device_imp.h b/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;
diff --git a/level_zero/core/test/unit_tests/mocks/mock_device.h b/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,
diff --git a/level_zero/core/test/unit_tests/sources/cache/CMakeLists.txt b/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()
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
@@ -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()
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
diff --git a/level_zero/core/test/unit_tests/sources/cache/windows/CMakeLists.txt b/level_zero/core/test/unit_tests/sources/cache/windows/CMakeLists.txt
diff --git a/level_zero/core/test/unit_tests/sources/cache/windows/test_cache_reservation_impl.cpp b/level_zero/core/test/unit_tests/sources/cache/windows/test_cache_reservation_impl.cpp
diff --git a/level_zero/core/test/unit_tests/sources/device/test_device.cpp b/level_zero/core/test/unit_tests/sources/device/test_device.cpp
