From 64873a5dd29ade730a9860ee7a99890208f581e0 Mon Sep 17 00:00:00 2001 From: Mateusz Jablonski Date: Wed, 24 Jul 2024 11:28:59 +0000 Subject: [PATCH] test: remove dependency of i915 from mock ioctl helper Signed-off-by: Mateusz Jablonski --- .../common/mocks/linux/mock_ioctl_helper.h | 74 +++++---------- .../linux/drm_buffer_object_tests.cpp | 26 ++---- .../os_interface/linux/drm_tests.cpp | 92 +++---------------- .../linux/ioctl_helper_tests_prelim.cpp | 62 +++++++++++++ 4 files changed, 107 insertions(+), 147 deletions(-) diff --git a/shared/test/common/mocks/linux/mock_ioctl_helper.h b/shared/test/common/mocks/linux/mock_ioctl_helper.h index 8662025352..469f1b835d 100644 --- a/shared/test/common/mocks/linux/mock_ioctl_helper.h +++ b/shared/test/common/mocks/linux/mock_ioctl_helper.h @@ -7,7 +7,6 @@ #pragma once #include "shared/source/helpers/constants.h" -#include "shared/source/os_interface/linux/i915.h" #include "shared/source/os_interface/linux/ioctl_helper.h" #include "shared/source/os_interface/linux/memory_info.h" #include "shared/test/common/test_macros/mock_method_macros.h" @@ -24,68 +23,47 @@ constexpr uint64_t unallocatedSizeRegionOne = 12 * MemoryConstants::gigaByte; constexpr uint64_t unallocatedSizeRegionFour = 4 * MemoryConstants::gigaByte; class MockIoctlHelper : public IoctlHelperPrelim20 { + static constexpr int memoryClassSystem = 0x123; + static constexpr int memoryClassDevice = 0x124; + public: using IoctlHelperPrelim20::IoctlHelperPrelim20; ADDMETHOD_CONST_NOBASE(isImmediateVmBindRequired, bool, false, ()); - unsigned int getIoctlRequestValue(DrmIoctl ioctlRequest) const override { - return ioctlRequestValue; - }; + ADDMETHOD_CONST_NOBASE(getIoctlRequestValue, unsigned int, 1234u, (DrmIoctl)); + ADDMETHOD_CONST_NOBASE(isWaitBeforeBindRequired, bool, false, (bool)); + + ADDMETHOD_NOBASE(vmBind, int, 0, (const VmBindParams &)); + ADDMETHOD_NOBASE(vmUnbind, int, 0, (const VmBindParams &)); + ADDMETHOD_NOBASE(allocateInterrupt, bool, true, (uint32_t &)); + ADDMETHOD_NOBASE(createMediaContext, bool, true, (void *, uint32_t, void *, uint32_t, uint64_t &)); + ADDMETHOD_NOBASE(releaseMediaContext, bool, true, (uint64_t)); int getDrmParamValue(DrmParam drmParam) const override { - if (drmParam == DrmParam::memoryClassSystem || drmParam == DrmParam::memoryClassDevice) { - return IoctlHelperPrelim20::getDrmParamValue(drmParam); + if (drmParam == DrmParam::memoryClassSystem) { + return memoryClassSystem; } - return drmParamValue; - } - int vmBind(const VmBindParams &vmBindParams) override { - if (failBind.has_value()) - return *failBind ? -1 : 0; - else - return IoctlHelperPrelim20::vmBind(vmBindParams); - } - int vmUnbind(const VmBindParams &vmBindParams) override { - if (failBind.has_value()) - return *failBind ? -1 : 0; - else - return IoctlHelperPrelim20::vmUnbind(vmBindParams); - } - bool isWaitBeforeBindRequired(bool bind) const override { - if (waitBeforeBindRequired.has_value()) - return *waitBeforeBindRequired; - else - return IoctlHelperPrelim20::isWaitBeforeBindRequired(bind); - } - - bool allocateInterrupt(uint32_t &handle) override { - allocateInterruptCalled++; - return IoctlHelperPrelim20::allocateInterrupt(handle); + if (drmParam == DrmParam::memoryClassDevice) { + return memoryClassDevice; + } + return getDrmParamValueResult; } bool releaseInterrupt(uint32_t handle) override { releaseInterruptCalled++; latestReleaseInterruptHandle = handle; - return IoctlHelperPrelim20::releaseInterrupt(handle); - } - - bool createMediaContext(void *controlSharedMemoryBuffer, uint32_t controlSharedMemoryBufferSize, void *controlBatchBuffer, uint32_t controlBatchBufferSize, uint64_t &outDoorbell) override { - createMediaContextCalled++; - return IoctlHelperPrelim20::createMediaContext(controlSharedMemoryBuffer, controlSharedMemoryBufferSize, controlBatchBuffer, controlBatchBufferSize, outDoorbell); - } - bool releaseMediaContext(uint64_t doorbellHandle) override { - releaseMediaContextCalled++; - return IoctlHelperPrelim20::releaseMediaContext(doorbellHandle); + return releaseInterruptResult; } std::unique_ptr createMemoryInfo() override { std::vector regionInfo(3); - regionInfo[0].region = {drm_i915_gem_memory_class::I915_MEMORY_CLASS_SYSTEM, 0}; + regionInfo[0].region = {memoryClassSystem, 0}; regionInfo[0].probedSize = probedSizeRegionZero; regionInfo[0].unallocatedSize = unallocatedSizeRegionZero; - regionInfo[1].region = {drm_i915_gem_memory_class::I915_MEMORY_CLASS_DEVICE, 0}; + regionInfo[1].region = {memoryClassDevice, 0}; regionInfo[1].probedSize = probedSizeRegionOne; regionInfo[1].unallocatedSize = unallocatedSizeRegionOne; - regionInfo[2].region = {drm_i915_gem_memory_class::I915_MEMORY_CLASS_DEVICE, 1}; + regionInfo[2].region = {memoryClassDevice, 1}; regionInfo[2].probedSize = probedSizeRegionFour; regionInfo[2].unallocatedSize = unallocatedSizeRegionFour; @@ -93,14 +71,10 @@ class MockIoctlHelper : public IoctlHelperPrelim20 { return memoryInfo; } - unsigned int ioctlRequestValue = 1234u; - int drmParamValue = 1234; - std::optional failBind{}; - std::optional waitBeforeBindRequired{}; - uint32_t allocateInterruptCalled = 0; + int getDrmParamValueResult = 1234; uint32_t releaseInterruptCalled = 0; uint32_t latestReleaseInterruptHandle = InterruptId::notUsed; - uint32_t createMediaContextCalled = 0; - uint32_t releaseMediaContextCalled = 0; + + bool releaseInterruptResult = true; }; } // namespace NEO diff --git a/shared/test/unit_test/os_interface/linux/drm_buffer_object_tests.cpp b/shared/test/unit_test/os_interface/linux/drm_buffer_object_tests.cpp index 03aed56278..276910a56c 100644 --- a/shared/test/unit_test/os_interface/linux/drm_buffer_object_tests.cpp +++ b/shared/test/unit_test/os_interface/linux/drm_buffer_object_tests.cpp @@ -585,8 +585,8 @@ TEST(DrmBufferObject, givenDrmWhenBindOperationFailsThenFenceValueNotGrow) { drm->requirePerContextVM = false; drm->isVMBindImmediateSupported = true; auto ioctlHelper = std::make_unique(*drm); - ioctlHelper->failBind = true; - ioctlHelper->waitBeforeBindRequired = true; + ioctlHelper->vmBindResult = -1; + ioctlHelper->isWaitBeforeBindRequiredResult = true; drm->ioctlHelper.reset(ioctlHelper.release()); executionEnvironment->rootDeviceEnvironments[0]->osInterface->setDriverModel(std::unique_ptr(drm)); @@ -617,8 +617,7 @@ TEST(DrmBufferObject, givenDrmWhenBindOperationSucceedsThenFenceValueGrow) { drm->requirePerContextVM = false; drm->isVMBindImmediateSupported = true; auto ioctlHelper = std::make_unique(*drm); - ioctlHelper->failBind = false; - ioctlHelper->waitBeforeBindRequired = true; + ioctlHelper->isWaitBeforeBindRequiredResult = true; drm->ioctlHelper.reset(ioctlHelper.release()); executionEnvironment->rootDeviceEnvironments[0]->osInterface->setDriverModel(std::unique_ptr(drm)); @@ -649,8 +648,8 @@ TEST(DrmBufferObject, givenDrmWhenUnBindOperationFailsThenFenceValueNotGrow) { drm->requirePerContextVM = false; drm->isVMBindImmediateSupported = true; auto ioctlHelper = std::make_unique(*drm); - ioctlHelper->failBind = true; - ioctlHelper->waitBeforeBindRequired = true; + ioctlHelper->vmUnbindResult = -1; + ioctlHelper->isWaitBeforeBindRequiredResult = true; drm->ioctlHelper.reset(ioctlHelper.release()); executionEnvironment->rootDeviceEnvironments[0]->osInterface->setDriverModel(std::unique_ptr(drm)); @@ -681,8 +680,7 @@ TEST(DrmBufferObject, givenDrmWhenUnBindOperationSucceedsThenFenceValueGrow) { drm->requirePerContextVM = false; drm->isVMBindImmediateSupported = true; auto ioctlHelper = std::make_unique(*drm); - ioctlHelper->failBind = false; - ioctlHelper->waitBeforeBindRequired = true; + ioctlHelper->isWaitBeforeBindRequiredResult = true; drm->ioctlHelper.reset(ioctlHelper.release()); executionEnvironment->rootDeviceEnvironments[0]->osInterface->setDriverModel(std::unique_ptr(drm)); @@ -717,8 +715,7 @@ TEST(DrmBufferObject, givenDrmWhenUnBindOperationSucceedsAndForceUserFenceUponUn drm->requirePerContextVM = false; drm->isVMBindImmediateSupported = true; auto ioctlHelper = std::make_unique(*drm); - ioctlHelper->failBind = false; - ioctlHelper->waitBeforeBindRequired = true; + ioctlHelper->isWaitBeforeBindRequiredResult = true; drm->ioctlHelper.reset(ioctlHelper.release()); executionEnvironment->rootDeviceEnvironments[0]->osInterface->setDriverModel(std::unique_ptr(drm)); @@ -769,8 +766,7 @@ TEST(DrmBufferObject, givenDrmWhenUnBindOperationSucceedsAndForceFenceWaitThenFe drm->requirePerContextVM = false; drm->isVMBindImmediateSupported = true; auto ioctlHelper = std::make_unique(*drm); - ioctlHelper->failBind = false; - ioctlHelper->waitBeforeBindRequired = true; + ioctlHelper->isWaitBeforeBindRequiredResult = true; drm->ioctlHelper.reset(ioctlHelper.release()); auto osContext = new MockOsContextLinuxUnbind(*drm, 0, 0u, EngineDescriptorHelper::getDefaultDescriptor()); @@ -825,8 +821,7 @@ TEST(DrmBufferObject, givenDrmWhenUnBindOperationSucceedsWaitBeforeBindFalseAndF drm->requirePerContextVM = false; drm->isVMBindImmediateSupported = true; auto ioctlHelper = std::make_unique(*drm); - ioctlHelper->failBind = false; - ioctlHelper->waitBeforeBindRequired = false; + ioctlHelper->isWaitBeforeBindRequiredResult = false; drm->ioctlHelper.reset(ioctlHelper.release()); auto osContext = new MockOsContextLinuxUnbind(*drm, 0, 0u, EngineDescriptorHelper::getDefaultDescriptor()); @@ -881,8 +876,7 @@ TEST(DrmBufferObject, givenDrmWhenUnBindOperationSucceedsWaitBeforeBindTrueAndFo drm->requirePerContextVM = false; drm->isVMBindImmediateSupported = false; auto ioctlHelper = std::make_unique(*drm); - ioctlHelper->failBind = false; - ioctlHelper->waitBeforeBindRequired = true; + ioctlHelper->isWaitBeforeBindRequiredResult = true; drm->ioctlHelper.reset(ioctlHelper.release()); auto osContext = new MockOsContextLinuxUnbind(*drm, 0, 0u, EngineDescriptorHelper::getDefaultDescriptor()); diff --git a/shared/test/unit_test/os_interface/linux/drm_tests.cpp b/shared/test/unit_test/os_interface/linux/drm_tests.cpp index fc78f3691f..838959b767 100644 --- a/shared/test/unit_test/os_interface/linux/drm_tests.cpp +++ b/shared/test/unit_test/os_interface/linux/drm_tests.cpp @@ -11,6 +11,7 @@ #include "shared/source/helpers/hw_info.h" #include "shared/source/os_interface/device_factory.h" #include "shared/source/os_interface/driver_info.h" +#include "shared/source/os_interface/linux/i915.h" #include "shared/source/os_interface/linux/memory_info.h" #include "shared/source/os_interface/linux/os_context_linux.h" #include "shared/source/os_interface/linux/os_inc.h" @@ -348,36 +349,6 @@ TEST(DrmTest, GivenDrmWhenAskedForGttSizeThenReturnCorrectValue) { EXPECT_EQ(0u, queryGttSize); } -TEST(DrmTest, GivenDrmWhenAskedForPreemptionThenCorrectValueReturned) { - auto executionEnvironment = std::make_unique(); - DrmMock *pDrm = new DrmMock(*executionEnvironment->rootDeviceEnvironments[0]); - pDrm->storedRetVal = 0; - pDrm->storedPreemptionSupport = - I915_SCHEDULER_CAP_ENABLED | - I915_SCHEDULER_CAP_PRIORITY | - I915_SCHEDULER_CAP_PREEMPTION; - pDrm->checkPreemptionSupport(); - EXPECT_TRUE(pDrm->isPreemptionSupported()); - - pDrm->storedPreemptionSupport = 0; - pDrm->checkPreemptionSupport(); - EXPECT_FALSE(pDrm->isPreemptionSupported()); - - pDrm->storedRetVal = -1; - pDrm->storedPreemptionSupport = - I915_SCHEDULER_CAP_ENABLED | - I915_SCHEDULER_CAP_PRIORITY | - I915_SCHEDULER_CAP_PREEMPTION; - pDrm->checkPreemptionSupport(); - EXPECT_FALSE(pDrm->isPreemptionSupported()); - - pDrm->storedPreemptionSupport = 0; - pDrm->checkPreemptionSupport(); - EXPECT_FALSE(pDrm->isPreemptionSupported()); - - delete pDrm; -} - TEST(DrmTest, GivenDrmWhenAskedForContextThatFailsThenFalseIsReturned) { auto executionEnvironment = std::make_unique(); DrmMock *pDrm = new DrmMock(*executionEnvironment->rootDeviceEnvironments[0]); @@ -481,36 +452,6 @@ TEST(DrmTest, givenDrmAndNegativeCheckNonPersistentContextsSupportWhenOsContextI } } -TEST(DrmTest, givenDrmPreemptionEnabledAndLowPriorityEngineWhenCreatingOsContextThenCallSetContextPriorityIoctl) { - auto executionEnvironment = std::make_unique(); - executionEnvironment->rootDeviceEnvironments[0]->setHwInfoAndInitHelpers(defaultHwInfo.get()); - executionEnvironment->rootDeviceEnvironments[0]->initGmm(); - - DrmMock drmMock(*executionEnvironment->rootDeviceEnvironments[0]); - drmMock.preemptionSupported = false; - - OsContextLinux osContext1(drmMock, 0, 0u, EngineDescriptorHelper::getDefaultDescriptor()); - osContext1.ensureContextInitialized(false); - OsContextLinux osContext2(drmMock, 0, 0u, EngineDescriptorHelper::getDefaultDescriptor({aub_stream::ENGINE_RCS, EngineUsage::lowPriority})); - osContext2.ensureContextInitialized(false); - - EXPECT_EQ(4u, drmMock.receivedContextParamRequestCount); - - drmMock.preemptionSupported = true; - - OsContextLinux osContext3(drmMock, 0, 0u, EngineDescriptorHelper::getDefaultDescriptor()); - osContext3.ensureContextInitialized(false); - EXPECT_EQ(6u, drmMock.receivedContextParamRequestCount); - - OsContextLinux osContext4(drmMock, 0, 0u, EngineDescriptorHelper::getDefaultDescriptor({aub_stream::ENGINE_RCS, EngineUsage::lowPriority})); - osContext4.ensureContextInitialized(false); - EXPECT_EQ(9u, drmMock.receivedContextParamRequestCount); - EXPECT_EQ(drmMock.storedDrmContextId, drmMock.receivedContextParamRequest.contextId); - EXPECT_EQ(static_cast(I915_CONTEXT_PARAM_PRIORITY), drmMock.receivedContextParamRequest.param); - EXPECT_EQ(static_cast(-1023), drmMock.receivedContextParamRequest.value); - EXPECT_EQ(0u, drmMock.receivedContextParamRequest.size); -} - TEST(DrmTest, WhenEnablingTurboBoostThenSucceeds) { auto executionEnvironment = std::make_unique(); DrmMock *pDrm = new DrmMock(*executionEnvironment->rootDeviceEnvironments[0]); @@ -1760,10 +1701,10 @@ TEST(DrmWrapperTest, whenGettingDrmParamOrIoctlRequestValueThenUseIoctlHelperWhe DrmMock drm{*executionEnvironment->rootDeviceEnvironments[0]}; MockIoctlHelper ioctlHelper{drm}; - EXPECT_EQ(getIoctlRequestValue(DrmIoctl::getparam, &ioctlHelper), ioctlHelper.ioctlRequestValue); + EXPECT_EQ(getIoctlRequestValue(DrmIoctl::getparam, &ioctlHelper), ioctlHelper.getIoctlRequestValueResult); EXPECT_NE(getIoctlRequestValue(DrmIoctl::getparam, nullptr), getIoctlRequestValue(DrmIoctl::getparam, &ioctlHelper)); - EXPECT_EQ(getDrmParamValue(DrmParam::paramChipsetId, &ioctlHelper), ioctlHelper.drmParamValue); + EXPECT_EQ(getDrmParamValue(DrmParam::paramChipsetId, &ioctlHelper), ioctlHelper.getDrmParamValueResult); EXPECT_NE(getDrmParamValue(DrmParam::paramChipsetId, nullptr), getDrmParamValue(DrmParam::paramChipsetId, &ioctlHelper)); } @@ -1829,20 +1770,6 @@ TEST(DrmWrapperTest, givenErrorWhenCheckingIfReinvokeRequiredThenFalseIsReturned EXPECT_FALSE(checkIfIoctlReinvokeRequired(ENOENT, DrmIoctl::getparam, nullptr)); } -TEST(IoctlHelperTest, whenGettingDrmParamValueThenProperValueIsReturned) { - auto executionEnvironment = std::make_unique(); - DrmMock drm{*executionEnvironment->rootDeviceEnvironments[0]}; - auto ioctlHelper = drm.getIoctlHelper(); - EXPECT_EQ(static_cast(drm_i915_gem_engine_class::I915_ENGINE_CLASS_RENDER), ioctlHelper->getDrmParamValue(DrmParam::engineClassRender)); - EXPECT_EQ(static_cast(drm_i915_gem_engine_class::I915_ENGINE_CLASS_COPY), ioctlHelper->getDrmParamValue(DrmParam::engineClassCopy)); - EXPECT_EQ(static_cast(drm_i915_gem_engine_class::I915_ENGINE_CLASS_VIDEO), ioctlHelper->getDrmParamValue(DrmParam::engineClassVideo)); - EXPECT_EQ(static_cast(drm_i915_gem_engine_class::I915_ENGINE_CLASS_VIDEO_ENHANCE), ioctlHelper->getDrmParamValue(DrmParam::engineClassVideoEnhance)); - EXPECT_EQ(static_cast(drm_i915_gem_engine_class::I915_ENGINE_CLASS_INVALID), ioctlHelper->getDrmParamValue(DrmParam::engineClassInvalid)); - EXPECT_EQ(static_cast(I915_ENGINE_CLASS_INVALID_NONE), ioctlHelper->getDrmParamValue(DrmParam::engineClassInvalidNone)); - - EXPECT_THROW(ioctlHelper->getDrmParamValueBase(DrmParam::engineClassCompute), std::runtime_error); -} - TEST(IoctlHelperTest, whenGettingFileNameForFrequencyFilesThenProperStringIsReturned) { auto executionEnvironment = std::make_unique(); DrmMock drm{*executionEnvironment->rootDeviceEnvironments[0]}; @@ -1878,11 +1805,14 @@ TEST(DistanceInfoTest, givenDistanceInfosWhenAssignRegionsFromDistancesThenCorre DrmMock drm{*executionEnvironment->rootDeviceEnvironments[0]}; auto ioctlHelper = drm.getIoctlHelper(); + auto memoryClassSystem = static_cast(ioctlHelper->getDrmParamValue(DrmParam::memoryClassSystem)); + auto memoryClassDevice = static_cast(ioctlHelper->getDrmParamValue(DrmParam::memoryClassDevice)); + std::vector memRegions(4); - memRegions[0] = {{drm_i915_gem_memory_class::I915_MEMORY_CLASS_SYSTEM, 0}, 1024, 0}; - memRegions[1] = {{drm_i915_gem_memory_class::I915_MEMORY_CLASS_DEVICE, 0}, 1024, 0}; - memRegions[2] = {{drm_i915_gem_memory_class::I915_MEMORY_CLASS_DEVICE, 1}, 1024, 0}; - memRegions[3] = {{drm_i915_gem_memory_class::I915_MEMORY_CLASS_DEVICE, 2}, 1024, 0}; + memRegions[0] = {{memoryClassSystem, 0}, 1024, 0}; + memRegions[1] = {{memoryClassDevice, 0}, 1024, 0}; + memRegions[2] = {{memoryClassDevice, 1}, 1024, 0}; + memRegions[3] = {{memoryClassDevice, 2}, 1024, 0}; auto memoryInfo = std::make_unique(memRegions, drm); std::vector engines(3); @@ -1892,7 +1822,7 @@ TEST(DistanceInfoTest, givenDistanceInfosWhenAssignRegionsFromDistancesThenCorre auto distances = std::vector(); for (const auto ®ion : memRegions) { - if (region.region.memoryClass == drm_i915_gem_memory_class::I915_MEMORY_CLASS_SYSTEM) { + if (region.region.memoryClass == memoryClassSystem) { continue; } for (const auto &engine : engines) { diff --git a/shared/test/unit_test/os_interface/linux/ioctl_helper_tests_prelim.cpp b/shared/test/unit_test/os_interface/linux/ioctl_helper_tests_prelim.cpp index d0752310ef..77d0c40d2a 100644 --- a/shared/test/unit_test/os_interface/linux/ioctl_helper_tests_prelim.cpp +++ b/shared/test/unit_test/os_interface/linux/ioctl_helper_tests_prelim.cpp @@ -10,9 +10,11 @@ #include "shared/source/os_interface/linux/drm_neo.h" #include "shared/source/os_interface/linux/i915_prelim.h" #include "shared/source/os_interface/linux/ioctl_helper.h" +#include "shared/source/os_interface/linux/os_context_linux.h" #include "shared/source/os_interface/linux/sys_calls.h" #include "shared/source/os_interface/product_helper.h" #include "shared/test/common/helpers/debug_manager_state_restore.h" +#include "shared/test/common/helpers/engine_descriptor_helper.h" #include "shared/test/common/helpers/variable_backup.h" #include "shared/test/common/libult/linux/drm_mock.h" #include "shared/test/common/mocks/linux/mock_os_time_linux.h" @@ -1007,3 +1009,63 @@ TEST_F(IoctlPrelimHelperTests, whenCallingGetStatusAndFlagsForResetStatsThenExpe EXPECT_TRUE(ioctlHelper.validPageFault(static_cast(I915_RESET_STATS_FAULT_VALID))); EXPECT_FALSE(ioctlHelper.validPageFault(0u)); } + +TEST(DrmTest, GivenDrmWhenAskedForPreemptionThenCorrectValueReturned) { + auto executionEnvironment = std::make_unique(); + DrmMock *pDrm = new DrmMock(*executionEnvironment->rootDeviceEnvironments[0]); + pDrm->storedRetVal = 0; + pDrm->storedPreemptionSupport = + I915_SCHEDULER_CAP_ENABLED | + I915_SCHEDULER_CAP_PRIORITY | + I915_SCHEDULER_CAP_PREEMPTION; + pDrm->checkPreemptionSupport(); + EXPECT_TRUE(pDrm->isPreemptionSupported()); + + pDrm->storedPreemptionSupport = 0; + pDrm->checkPreemptionSupport(); + EXPECT_FALSE(pDrm->isPreemptionSupported()); + + pDrm->storedRetVal = -1; + pDrm->storedPreemptionSupport = + I915_SCHEDULER_CAP_ENABLED | + I915_SCHEDULER_CAP_PRIORITY | + I915_SCHEDULER_CAP_PREEMPTION; + pDrm->checkPreemptionSupport(); + EXPECT_FALSE(pDrm->isPreemptionSupported()); + + pDrm->storedPreemptionSupport = 0; + pDrm->checkPreemptionSupport(); + EXPECT_FALSE(pDrm->isPreemptionSupported()); + + delete pDrm; +} + +TEST(DrmTest, givenDrmPreemptionEnabledAndLowPriorityEngineWhenCreatingOsContextThenCallSetContextPriorityIoctl) { + auto executionEnvironment = std::make_unique(); + executionEnvironment->rootDeviceEnvironments[0]->setHwInfoAndInitHelpers(defaultHwInfo.get()); + executionEnvironment->rootDeviceEnvironments[0]->initGmm(); + + DrmMock drmMock(*executionEnvironment->rootDeviceEnvironments[0]); + drmMock.preemptionSupported = false; + + OsContextLinux osContext1(drmMock, 0, 0u, EngineDescriptorHelper::getDefaultDescriptor()); + osContext1.ensureContextInitialized(false); + OsContextLinux osContext2(drmMock, 0, 0u, EngineDescriptorHelper::getDefaultDescriptor({aub_stream::ENGINE_RCS, EngineUsage::lowPriority})); + osContext2.ensureContextInitialized(false); + + EXPECT_EQ(4u, drmMock.receivedContextParamRequestCount); + + drmMock.preemptionSupported = true; + + OsContextLinux osContext3(drmMock, 0, 0u, EngineDescriptorHelper::getDefaultDescriptor()); + osContext3.ensureContextInitialized(false); + EXPECT_EQ(6u, drmMock.receivedContextParamRequestCount); + + OsContextLinux osContext4(drmMock, 0, 0u, EngineDescriptorHelper::getDefaultDescriptor({aub_stream::ENGINE_RCS, EngineUsage::lowPriority})); + osContext4.ensureContextInitialized(false); + EXPECT_EQ(9u, drmMock.receivedContextParamRequestCount); + EXPECT_EQ(drmMock.storedDrmContextId, drmMock.receivedContextParamRequest.contextId); + EXPECT_EQ(static_cast(I915_CONTEXT_PARAM_PRIORITY), drmMock.receivedContextParamRequest.param); + EXPECT_EQ(static_cast(-1023), drmMock.receivedContextParamRequest.value); + EXPECT_EQ(0u, drmMock.receivedContextParamRequest.size); +}