From e4eb7538faf8c9bf71638ca94b08c15855aadf68 Mon Sep 17 00:00:00 2001 From: "Milczarek, Slawomir" Date: Wed, 23 Jun 2021 14:53:34 +0000 Subject: [PATCH] L0 extension for cache reservation Signed-off-by: Milczarek, Slawomir --- level_zero/CMakeLists.txt | 3 + level_zero/api/core/ze_device.cpp | 19 +- level_zero/core/source/cache/CMakeLists.txt | 13 ++ .../core/source/cache/cache_reservation.h | 29 +++ .../core/source/cache/linux/CMakeLists.txt | 15 ++ .../cache/linux/cache_reservation_impl.cpp | 28 +++ .../cache/linux/cache_reservation_impl.h | 23 +++ .../core/source/cache/windows/CMakeLists.txt | 15 ++ .../cache/windows/cache_reservation_impl.cpp | 28 +++ .../cache/windows/cache_reservation_impl.h | 23 +++ level_zero/core/source/device/device.h | 2 + level_zero/core/source/device/device_imp.cpp | 47 +++++ level_zero/core/source/device/device_imp.h | 4 + .../core/test/unit_tests/mocks/mock_device.h | 11 ++ .../unit_tests/sources/cache/CMakeLists.txt | 11 ++ .../sources/cache/linux/CMakeLists.txt | 12 ++ .../linux/test_cache_reservation_impl.cpp | 56 ++++++ .../sources/cache/windows/CMakeLists.txt | 12 ++ .../windows/test_cache_reservation_impl.cpp | 56 ++++++ .../unit_tests/sources/device/test_device.cpp | 166 +++++++++++++++++- 20 files changed, 571 insertions(+), 2 deletions(-) create mode 100644 level_zero/core/source/cache/CMakeLists.txt create mode 100644 level_zero/core/source/cache/cache_reservation.h create mode 100644 level_zero/core/source/cache/linux/CMakeLists.txt create mode 100644 level_zero/core/source/cache/linux/cache_reservation_impl.cpp create mode 100644 level_zero/core/source/cache/linux/cache_reservation_impl.h create mode 100644 level_zero/core/source/cache/windows/CMakeLists.txt create mode 100644 level_zero/core/source/cache/windows/cache_reservation_impl.cpp create mode 100644 level_zero/core/source/cache/windows/cache_reservation_impl.h create mode 100644 level_zero/core/test/unit_tests/sources/cache/CMakeLists.txt create mode 100644 level_zero/core/test/unit_tests/sources/cache/linux/CMakeLists.txt create mode 100644 level_zero/core/test/unit_tests/sources/cache/linux/test_cache_reservation_impl.cpp create mode 100644 level_zero/core/test/unit_tests/sources/cache/windows/CMakeLists.txt create mode 100644 level_zero/core/test/unit_tests/sources/cache/windows/test_cache_reservation_impl.cpp diff --git a/level_zero/CMakeLists.txt b/level_zero/CMakeLists.txt index d438b8379a..fa7e55b598 100644 --- a/level_zero/CMakeLists.txt +++ b/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 ) diff --git a/level_zero/api/core/ze_device.cpp b/level_zero/api/core/ze_device.cpp index 7d3f8bfc5f..cfc3476af2 100644 --- 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); -} \ No newline at end of file +} + +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 new file mode 100644 index 0000000000..109ed20c3d --- /dev/null +++ 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 new file mode 100644 index 0000000000..4a83068fd3 --- /dev/null +++ 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 + +#include +#include + +namespace L0 { + +struct Device; + +class CacheReservation { + public: + virtual ~CacheReservation() = default; + + static std::unique_ptr 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 \ No newline at end of file diff --git a/level_zero/core/source/cache/linux/CMakeLists.txt b/level_zero/core/source/cache/linux/CMakeLists.txt new file mode 100644 index 0000000000..2095674dbb --- /dev/null +++ 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 new file mode 100644 index 0000000000..586afe2e3b --- /dev/null +++ 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::create(Device &device) { + return std::make_unique(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 new file mode 100644 index 0000000000..01b0918420 --- /dev/null +++ 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 \ No newline at end of file diff --git a/level_zero/core/source/cache/windows/CMakeLists.txt b/level_zero/core/source/cache/windows/CMakeLists.txt new file mode 100644 index 0000000000..437cfe9fdc --- /dev/null +++ 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 new file mode 100644 index 0000000000..d229f4522e --- /dev/null +++ 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::create(Device &device) { + return std::make_unique(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 new file mode 100644 index 0000000000..01b0918420 --- /dev/null +++ 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 \ No newline at end of file diff --git a/level_zero/core/source/device/device.h b/level_zero/core/source/device/device.h index 7a7683417a..d3e5497a76 100644 --- 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 index 8ac4bbba75..2b63001a93 100644 --- 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(pCacheProperties->pNext); + if (extendedProperties->stype == ZE_STRUCTURE_TYPE_CACHE_RESERVATION_EXT_DESC) { + auto cacheReservationProperties = reinterpret_cast(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 index f6fda70948..51207bbe0e 100644 --- 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 builtins = nullptr; std::unique_ptr metricContext = nullptr; + std::unique_ptr cacheReservation = nullptr; uint32_t maxNumHwThreads = 0; uint32_t numSubDevices = 0; std::vector 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 index 6ca13b6ba8..5aea308dbf 100644 --- 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 : 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 new file mode 100644 index 0000000000..a1209b65ad --- /dev/null +++ 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 new file mode 100644 index 0000000000..729219f58c --- /dev/null +++ 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 new file mode 100644 index 0000000000..5f549c771a --- /dev/null +++ b/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(device); + ASSERT_NE(nullptr, deviceImp->cacheReservation.get()); + + cache = deviceImp->cacheReservation.get(); + } + void TearDown() override { + 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/windows/CMakeLists.txt b/level_zero/core/test/unit_tests/sources/cache/windows/CMakeLists.txt new file mode 100644 index 0000000000..35e7604a0f --- /dev/null +++ b/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() 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 new file mode 100644 index 0000000000..5c11bd06dc --- /dev/null +++ b/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(device); + ASSERT_NE(nullptr, deviceImp->cacheReservation.get()); + cache = deviceImp->cacheReservation.get(); + } + void TearDown() override { + 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/device/test_device.cpp b/level_zero/core/test/unit_tests/sources/device/test_device.cpp index a9472d1f7f..87f4491717 100644 --- a/level_zero/core/test/unit_tests/sources/device/test_device.cpp +++ b/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::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 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); + } +} + } // namespace ult } // namespace L0