From 98d7258a0b4f3c9c226ae6292c82f253b335b2c4 Mon Sep 17 00:00:00 2001 From: Szymon Morek Date: Fri, 10 Dec 2021 12:55:55 +0000 Subject: [PATCH] Add prelim ioctls for clos Add several prelim ioctls related to clos for IoctlHelper Related-To: NEO-6510 Signed-off-by: Szymon Morek --- .../linux/ioctl_helper_tests_prelim.cpp | 83 ++++++++++++++++++- .../linux/ioctl_helper_tests_upstream.cpp | 33 ++++++++ .../os_interface/linux/prelim_helper_func.cpp | 7 +- .../source/os_interface/linux/ioctl_helper.h | 26 ++++-- .../linux/ioctl_helper_prelim.cpp | 52 ++++++++++++ .../linux/ioctl_helper_upstream.cpp | 13 +++ 6 files changed, 201 insertions(+), 13 deletions(-) diff --git a/opencl/test/unit_test/os_interface/linux/ioctl_helper_tests_prelim.cpp b/opencl/test/unit_test/os_interface/linux/ioctl_helper_tests_prelim.cpp index 18130b124d..71f904308a 100644 --- a/opencl/test/unit_test/os_interface/linux/ioctl_helper_tests_prelim.cpp +++ b/opencl/test/unit_test/os_interface/linux/ioctl_helper_tests_prelim.cpp @@ -15,7 +15,7 @@ using namespace NEO; -extern int handlePrelimRequests(unsigned long request, void *arg); +extern int handlePrelimRequests(unsigned long request, void *arg, int ioctlRetVal); class DrmPrelimMock : public DrmMock { public: @@ -25,12 +25,14 @@ class DrmPrelimMock : public DrmMock { rootDeviceEnvironment.getMutableHardwareInfo()->platform.eProductFamily = IGFX_UNKNOWN; } + int ioctlRetVal = 0; + void getPrelimVersion(std::string &prelimVersion) override { prelimVersion = "2.0"; } int handleRemainingRequests(unsigned long request, void *arg) override { - return handlePrelimRequests(request, arg); + return handlePrelimRequests(request, arg, ioctlRetVal); } }; @@ -86,7 +88,7 @@ TEST(IoctlHelperTestsPrelim, givenPrelimsWhenTranslateIfRequiredThenReturnSameDa EXPECT_EQ(ret.get(), data); } -TEST(IoctlHelperTestsDefault, givenPrelimsWhenCallIoctlThenProperIoctlRegistered) { +TEST(IoctlHelperTestsPrelim, givenPrelimsWhenCallIoctlThenProperIoctlRegistered) { auto executionEnvironment = std::make_unique(); executionEnvironment->prepareRootDeviceEnvironments(1); auto drm = std::make_unique(*executionEnvironment->rootDeviceEnvironments[0]); @@ -95,3 +97,78 @@ TEST(IoctlHelperTestsDefault, givenPrelimsWhenCallIoctlThenProperIoctlRegistered EXPECT_EQ(0u, ret); EXPECT_EQ(1u, drm->ioctlCallsCount); } + +TEST(IoctlHelperTestsPrelim, givenPrelimsWhenClosAllocThenReturnCorrectRegion) { + auto executionEnvironment = std::make_unique(); + executionEnvironment->prepareRootDeviceEnvironments(1); + auto drm = std::make_unique(*executionEnvironment->rootDeviceEnvironments[0]); + + auto ioctlHelper = IoctlHelper::get(drm.get()); + auto cacheRegion = ioctlHelper->closAlloc(drm.get()); + + EXPECT_EQ(CacheRegion::Region1, cacheRegion); + EXPECT_EQ(1u, drm->ioctlCallsCount); +} + +TEST(IoctlHelperTestsPrelim, givenPrelimsAndInvalidIoctlReturnValWhenClosAllocThenReturnNone) { + auto executionEnvironment = std::make_unique(); + executionEnvironment->prepareRootDeviceEnvironments(1); + auto drm = std::make_unique(*executionEnvironment->rootDeviceEnvironments[0]); + drm->ioctlRetVal = -1; + + auto ioctlHelper = IoctlHelper::get(drm.get()); + auto cacheRegion = ioctlHelper->closAlloc(drm.get()); + + EXPECT_EQ(CacheRegion::None, cacheRegion); + EXPECT_EQ(1u, drm->ioctlCallsCount); +} + +TEST(IoctlHelperTestsPrelim, givenPrelimsWhenClosFreeThenReturnCorrectRegion) { + auto executionEnvironment = std::make_unique(); + executionEnvironment->prepareRootDeviceEnvironments(1); + auto drm = std::make_unique(*executionEnvironment->rootDeviceEnvironments[0]); + + auto ioctlHelper = IoctlHelper::get(drm.get()); + auto cacheRegion = ioctlHelper->closFree(drm.get(), CacheRegion::Region2); + + EXPECT_EQ(CacheRegion::Region2, cacheRegion); + EXPECT_EQ(1u, drm->ioctlCallsCount); +} + +TEST(IoctlHelperTestsPrelim, givenPrelimsAndInvalidIoctlReturnValWhenClosFreeThenReturnNone) { + auto executionEnvironment = std::make_unique(); + executionEnvironment->prepareRootDeviceEnvironments(1); + auto drm = std::make_unique(*executionEnvironment->rootDeviceEnvironments[0]); + drm->ioctlRetVal = -1; + + auto ioctlHelper = IoctlHelper::get(drm.get()); + auto cacheRegion = ioctlHelper->closFree(drm.get(), CacheRegion::Region2); + + EXPECT_EQ(CacheRegion::None, cacheRegion); + EXPECT_EQ(1u, drm->ioctlCallsCount); +} + +TEST(IoctlHelperTestsPrelim, givenPrelimsWhenClosAllocWaysThenReturnCorrectRegion) { + auto executionEnvironment = std::make_unique(); + executionEnvironment->prepareRootDeviceEnvironments(1); + auto drm = std::make_unique(*executionEnvironment->rootDeviceEnvironments[0]); + + auto ioctlHelper = IoctlHelper::get(drm.get()); + auto numWays = ioctlHelper->closAllocWays(drm.get(), CacheRegion::Region2, 3, 10); + + EXPECT_EQ(10u, numWays); + EXPECT_EQ(1u, drm->ioctlCallsCount); +} + +TEST(IoctlHelperTestsPrelim, givenPrelimsAndInvalidIoctlReturnValWhenClosAllocWaysThenReturnNone) { + auto executionEnvironment = std::make_unique(); + executionEnvironment->prepareRootDeviceEnvironments(1); + auto drm = std::make_unique(*executionEnvironment->rootDeviceEnvironments[0]); + drm->ioctlRetVal = -1; + + auto ioctlHelper = IoctlHelper::get(drm.get()); + auto numWays = ioctlHelper->closAllocWays(drm.get(), CacheRegion::Region2, 3, 10); + + EXPECT_EQ(0u, numWays); + EXPECT_EQ(1u, drm->ioctlCallsCount); +} diff --git a/opencl/test/unit_test/os_interface/linux/ioctl_helper_tests_upstream.cpp b/opencl/test/unit_test/os_interface/linux/ioctl_helper_tests_upstream.cpp index a679d23655..7c15fdfc0c 100644 --- a/opencl/test/unit_test/os_interface/linux/ioctl_helper_tests_upstream.cpp +++ b/opencl/test/unit_test/os_interface/linux/ioctl_helper_tests_upstream.cpp @@ -58,3 +58,36 @@ TEST(IoctlHelperTestsUpstream, givenUpstreamWhenCreateGemExtWithDebugFlagThenPri std::string expectedOutput("Performing GEM_CREATE_EXT with { size: 1024, memory class: 1, memory instance: 0 }\nGEM_CREATE_EXT with EXT_MEMORY_REGIONS has returned: 0 BO-1 with size: 1024\n"); EXPECT_EQ(expectedOutput, output); } + +TEST(IoctlHelperTestsUpstream, givenUpstreamWhenClosAllocThenReturnNoneRegion) { + auto executionEnvironment = std::make_unique(); + executionEnvironment->prepareRootDeviceEnvironments(1); + auto drm = std::make_unique(*executionEnvironment->rootDeviceEnvironments[0]); + + auto ioctlHelper = IoctlHelper::get(drm.get()); + auto cacheRegion = ioctlHelper->closAlloc(drm.get()); + + EXPECT_EQ(CacheRegion::None, cacheRegion); +} + +TEST(IoctlHelperTestsUpstream, givenUpstreamWhenClosFreeThenReturnNoneRegion) { + auto executionEnvironment = std::make_unique(); + executionEnvironment->prepareRootDeviceEnvironments(1); + auto drm = std::make_unique(*executionEnvironment->rootDeviceEnvironments[0]); + + auto ioctlHelper = IoctlHelper::get(drm.get()); + auto cacheRegion = ioctlHelper->closFree(drm.get(), CacheRegion::Region2); + + EXPECT_EQ(CacheRegion::None, cacheRegion); +} + +TEST(IoctlHelperTestsUpstream, givenUpstreamWhenClosAllocWaysThenReturnZeroWays) { + auto executionEnvironment = std::make_unique(); + executionEnvironment->prepareRootDeviceEnvironments(1); + auto drm = std::make_unique(*executionEnvironment->rootDeviceEnvironments[0]); + + auto ioctlHelper = IoctlHelper::get(drm.get()); + auto cacheRegion = ioctlHelper->closAllocWays(drm.get(), CacheRegion::Region2, 3, 10); + + EXPECT_EQ(0, cacheRegion); +} diff --git a/opencl/test/unit_test/os_interface/linux/prelim_helper_func.cpp b/opencl/test/unit_test/os_interface/linux/prelim_helper_func.cpp index f4a6980dfc..fbee40bc74 100644 --- a/opencl/test/unit_test/os_interface/linux/prelim_helper_func.cpp +++ b/opencl/test/unit_test/os_interface/linux/prelim_helper_func.cpp @@ -9,7 +9,7 @@ #include "third_party/uapi/prelim/drm/i915_drm.h" -int handlePrelimRequests(unsigned long request, void *arg) { +int handlePrelimRequests(unsigned long request, void *arg, int ioctlRetVal) { if (request == PRELIM_DRM_IOCTL_I915_GEM_CREATE_EXT) { auto createExtParams = static_cast(arg); if (createExtParams->size == 0) { @@ -36,6 +36,9 @@ int handlePrelimRequests(unsigned long request, void *arg) { if ((data->memory_class != PRELIM_I915_MEMORY_CLASS_SYSTEM) && (data->memory_class != PRELIM_I915_MEMORY_CLASS_DEVICE)) { return EINVAL; } + } else if (request == PRELIM_DRM_IOCTL_I915_GEM_CLOS_RESERVE) { + auto closReserveArg = static_cast(arg); + closReserveArg->clos_index = 1u; } - return 0; + return ioctlRetVal; } diff --git a/shared/source/os_interface/linux/ioctl_helper.h b/shared/source/os_interface/linux/ioctl_helper.h index dcd342f412..de7e671447 100644 --- a/shared/source/os_interface/linux/ioctl_helper.h +++ b/shared/source/os_interface/linux/ioctl_helper.h @@ -15,21 +15,34 @@ namespace NEO { class Drm; class IoctlHelper; +enum class CacheRegion : uint16_t; extern IoctlHelper *ioctlHelperFactory[IGFX_MAX_PRODUCT]; class IoctlHelper { public: virtual ~IoctlHelper() {} - static IoctlHelper *get(Drm *product); + static IoctlHelper *get(Drm *drm); static uint32_t ioctl(Drm *drm, unsigned long request, void *arg); virtual uint32_t createGemExt(Drm *drm, void *data, uint32_t dataSize, size_t allocSize, uint32_t &handle) = 0; virtual std::unique_ptr translateIfRequired(uint8_t *dataQuery, int32_t length) = 0; + virtual CacheRegion closAlloc(Drm *drm) = 0; + virtual uint16_t closAllocWays(Drm *drm, CacheRegion closIndex, uint16_t cacheLevel, uint16_t numWays) = 0; + virtual CacheRegion closFree(Drm *drm, CacheRegion closIndex) = 0; +}; + +class IoctlHelperUpstream : public IoctlHelper { + public: + virtual uint32_t createGemExt(Drm *drm, void *data, uint32_t dataSize, size_t allocSize, uint32_t &handle) override; + virtual std::unique_ptr translateIfRequired(uint8_t *dataQuery, int32_t length) override; + CacheRegion closAlloc(Drm *drm) override; + uint16_t closAllocWays(Drm *drm, CacheRegion closIndex, uint16_t cacheLevel, uint16_t numWays) override; + CacheRegion closFree(Drm *drm, CacheRegion closIndex) override; }; template -class IoctlHelperImpl : public IoctlHelper { +class IoctlHelperImpl : public IoctlHelperUpstream { public: static IoctlHelper *get() { static IoctlHelperImpl instance; @@ -39,16 +52,13 @@ class IoctlHelperImpl : public IoctlHelper { std::unique_ptr translateIfRequired(uint8_t *dataQuery, int32_t length) override; }; -class IoctlHelperUpstream : public IoctlHelper { - public: - uint32_t createGemExt(Drm *drm, void *data, uint32_t dataSize, size_t allocSize, uint32_t &handle) override; - std::unique_ptr translateIfRequired(uint8_t *dataQuery, int32_t length) override; -}; - class IoctlHelperPrelim20 : public IoctlHelper { public: uint32_t createGemExt(Drm *drm, void *data, uint32_t dataSize, size_t allocSize, uint32_t &handle) override; std::unique_ptr translateIfRequired(uint8_t *dataQuery, int32_t length) override; + CacheRegion closAlloc(Drm *drm) override; + uint16_t closAllocWays(Drm *drm, CacheRegion closIndex, uint16_t cacheLevel, uint16_t numWays) override; + CacheRegion closFree(Drm *drm, CacheRegion closIndex) override; }; } // namespace NEO diff --git a/shared/source/os_interface/linux/ioctl_helper_prelim.cpp b/shared/source/os_interface/linux/ioctl_helper_prelim.cpp index d663ed79ad..e92a72474d 100644 --- a/shared/source/os_interface/linux/ioctl_helper_prelim.cpp +++ b/shared/source/os_interface/linux/ioctl_helper_prelim.cpp @@ -6,10 +6,15 @@ */ #include "shared/source/debug_settings/debug_settings_manager.h" +#include "shared/source/helpers/debug_helpers.h" +#include "shared/source/os_interface/linux/cache_info.h" #include "shared/source/os_interface/linux/ioctl_helper.h" #include "third_party/uapi/prelim/drm/i915_drm.h" +#include +#include + namespace NEO { uint32_t IoctlHelperPrelim20::createGemExt(Drm *drm, void *data, uint32_t dataSize, size_t allocSize, uint32_t &handle) { @@ -49,4 +54,51 @@ std::unique_ptr IoctlHelperPrelim20::translateIfRequired(uint8_t *dat return std::unique_ptr(dataQuery); } +CacheRegion IoctlHelperPrelim20::closAlloc(Drm *drm) { + struct prelim_drm_i915_gem_clos_reserve clos = {}; + + int ret = IoctlHelper::ioctl(drm, PRELIM_DRM_IOCTL_I915_GEM_CLOS_RESERVE, &clos); + if (ret != 0) { + int err = errno; + printDebugString(DebugManager.flags.PrintDebugMessages.get(), stderr, "ioctl(I915_GEM_CLOS_RESERVE) failed with %d. errno=%d(%s)\n", ret, err, strerror(err)); + DEBUG_BREAK_IF(true); + return CacheRegion::None; + } + + return static_cast(clos.clos_index); +} + +uint16_t IoctlHelperPrelim20::closAllocWays(Drm *drm, CacheRegion closIndex, uint16_t cacheLevel, uint16_t numWays) { + struct prelim_drm_i915_gem_cache_reserve cache = {}; + + cache.clos_index = static_cast(closIndex); + cache.cache_level = cacheLevel; + cache.num_ways = numWays; + + int ret = IoctlHelper::ioctl(drm, PRELIM_DRM_IOCTL_I915_GEM_CACHE_RESERVE, &cache); + if (ret != 0) { + int err = errno; + PRINT_DEBUG_STRING(DebugManager.flags.PrintDebugMessages.get(), stderr, "ioctl(I915_GEM_CACHE_RESERVE) failed with %d. errno=%d(%s)\n", ret, err, strerror(err)); + return 0; + } + + return cache.num_ways; +} + +CacheRegion IoctlHelperPrelim20::closFree(Drm *drm, CacheRegion closIndex) { + struct prelim_drm_i915_gem_clos_free clos = {}; + + clos.clos_index = static_cast(closIndex); + + int ret = IoctlHelper::ioctl(drm, PRELIM_DRM_IOCTL_I915_GEM_CLOS_FREE, &clos); + if (ret != 0) { + int err = errno; + printDebugString(DebugManager.flags.PrintDebugMessages.get(), stderr, "ioctl(I915_GEM_CLOS_FREE) failed with %d. errno=%d(%s)\n", ret, err, strerror(err)); + DEBUG_BREAK_IF(true); + return CacheRegion::None; + } + + return closIndex; +} + } // namespace NEO diff --git a/shared/source/os_interface/linux/ioctl_helper_upstream.cpp b/shared/source/os_interface/linux/ioctl_helper_upstream.cpp index 6b17be1228..38d152f6e1 100644 --- a/shared/source/os_interface/linux/ioctl_helper_upstream.cpp +++ b/shared/source/os_interface/linux/ioctl_helper_upstream.cpp @@ -6,6 +6,7 @@ */ #include "shared/source/debug_settings/debug_settings_manager.h" +#include "shared/source/os_interface/linux/cache_info.h" #include "shared/source/os_interface/linux/ioctl_helper.h" #include "third_party/uapi/drm/i915_drm.h" @@ -45,4 +46,16 @@ std::unique_ptr IoctlHelperUpstream::translateIfRequired(uint8_t *dat return std::unique_ptr(dataQuery); } +CacheRegion IoctlHelperUpstream::closAlloc(Drm *drm) { + return CacheRegion::None; +} + +uint16_t IoctlHelperUpstream::closAllocWays(Drm *drm, CacheRegion closIndex, uint16_t cacheLevel, uint16_t numWays) { + return 0; +} + +CacheRegion IoctlHelperUpstream::closFree(Drm *drm, CacheRegion closIndex) { + return CacheRegion::None; +} + } // namespace NEO