diff --git a/opencl/test/unit_test/CMakeLists.txt b/opencl/test/unit_test/CMakeLists.txt index fe73e0e772..6458bede4d 100644 --- a/opencl/test/unit_test/CMakeLists.txt +++ b/opencl/test/unit_test/CMakeLists.txt @@ -107,8 +107,6 @@ add_executable(igdrcl_tests ${IGDRCL_SRCS_tests_local} ) -include(${NEO_SOURCE_DIR}/opencl/test/unit_test/core_unit_tests_files.cmake) - hide_subdir(gen_common) add_subdirectory(gen_common) diff --git a/opencl/test/unit_test/command_stream/CMakeLists.txt b/opencl/test/unit_test/command_stream/CMakeLists.txt index 24e6f2f8a9..94044680b9 100644 --- a/opencl/test/unit_test/command_stream/CMakeLists.txt +++ b/opencl/test/unit_test/command_stream/CMakeLists.txt @@ -35,10 +35,5 @@ set(IGDRCL_SRCS_tests_command_stream ${CMAKE_CURRENT_SOURCE_DIR}/compute_mode_tests.h ) -get_property(NEO_CORE_SRCS_tests_preemption GLOBAL PROPERTY NEO_CORE_SRCS_tests_preemption) -list(APPEND IGDRCL_SRCS_tests_command_stream - ${NEO_CORE_SRCS_tests_preemption} -) - target_sources(igdrcl_tests PRIVATE ${IGDRCL_SRCS_tests_command_stream}) add_subdirectories() diff --git a/opencl/test/unit_test/core_unit_tests_files.cmake b/opencl/test/unit_test/core_unit_tests_files.cmake deleted file mode 100644 index 2776e50450..0000000000 --- a/opencl/test/unit_test/core_unit_tests_files.cmake +++ /dev/null @@ -1,30 +0,0 @@ -# -# Copyright (C) 2019-2020 Intel Corporation -# -# SPDX-License-Identifier: MIT -# - -target_sources(igdrcl_tests PRIVATE ${NEO_SOURCE_DIR}/opencl/test/unit_test/core_unit_tests_files.cmake) - -append_sources_from_properties(NEO_CORE_UNIT_TESTS_SOURCES - NEO_CORE_ENCODERS_TESTS - NEO_CORE_IMAGE_TESTS - NEO_CORE_MEMORY_MANAGER_TESTS -) - -if(WIN32) - append_sources_from_properties(NEO_CORE_UNIT_TESTS_SOURCES - NEO_CORE_DIRECT_SUBMISSION_WINDOWS_TESTS - NEO_CORE_OS_INTERFACE_TESTS_WINDOWS - ) -else() - append_sources_from_properties(NEO_CORE_UNIT_TESTS_SOURCES - NEO_CORE_DIRECT_SUBMISSION_LINUX_TESTS - NEO_CORE_OS_INTERFACE_TESTS_LINUX - ) - -endif() - -set_property(GLOBAL PROPERTY NEO_CORE_UNIT_TESTS_SOURCES ${NEO_CORE_UNIT_TESTS_SOURCES}) - -target_sources(igdrcl_tests PRIVATE ${NEO_CORE_UNIT_TESTS_SOURCES}) diff --git a/opencl/test/unit_test/fixtures/CMakeLists.txt b/opencl/test/unit_test/fixtures/CMakeLists.txt index bb8c2f031b..49119704b6 100644 --- a/opencl/test/unit_test/fixtures/CMakeLists.txt +++ b/opencl/test/unit_test/fixtures/CMakeLists.txt @@ -8,6 +8,8 @@ set(IGDRCL_SRCS_tests_fixtures ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt ${CMAKE_CURRENT_SOURCE_DIR}/aub_command_stream_receiver_fixture.h ${CMAKE_CURRENT_SOURCE_DIR}/buffer_enqueue_fixture.h + ${CMAKE_CURRENT_SOURCE_DIR}/cl_preemption_fixture.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/cl_preemption_fixture.h ${CMAKE_CURRENT_SOURCE_DIR}/context_fixture.cpp ${CMAKE_CURRENT_SOURCE_DIR}/context_fixture.h ${CMAKE_CURRENT_SOURCE_DIR}/d3d_test_fixture.h @@ -48,11 +50,6 @@ set(IGDRCL_SRCS_tests_fixtures ${CMAKE_CURRENT_SOURCE_DIR}/ult_command_stream_receiver_fixture.h ) -get_property(NEO_CORE_tests_fixtures GLOBAL PROPERTY NEO_CORE_tests_fixtures) -list(APPEND IGDRCL_SRCS_tests_fixtures - ${NEO_CORE_tests_fixtures} -) - target_sources(igdrcl_tests PRIVATE ${IGDRCL_SRCS_tests_fixtures}) set_property(GLOBAL PROPERTY IGDRCL_SRCS_tests_fixtures ${IGDRCL_SRCS_tests_fixtures}) add_subdirectories() diff --git a/opencl/test/unit_test/fixtures/cl_preemption_fixture.cpp b/opencl/test/unit_test/fixtures/cl_preemption_fixture.cpp new file mode 100644 index 0000000000..fcb74f0614 --- /dev/null +++ b/opencl/test/unit_test/fixtures/cl_preemption_fixture.cpp @@ -0,0 +1,100 @@ +/* + * Copyright (C) 2018-2020 Intel Corporation + * + * SPDX-License-Identifier: MIT + * + */ + +#include "opencl/test/unit_test/fixtures/cl_preemption_fixture.h" + +#include "shared/source/command_stream/preemption.h" +#include "shared/source/helpers/hw_info.h" +#include "shared/test/unit_test/cmd_parse/hw_parse.h" +#include "shared/test/unit_test/mocks/mock_device.h" + +#include "opencl/source/command_queue/enqueue_common.h" +#include "opencl/source/command_queue/enqueue_kernel.h" +#include "opencl/source/command_queue/enqueue_marker.h" +#include "opencl/source/helpers/dispatch_info.h" +#include "opencl/source/scheduler/scheduler_kernel.h" +#include "opencl/test/unit_test/fixtures/hello_world_fixture.h" +#include "opencl/test/unit_test/mocks/mock_command_queue.h" +#include "opencl/test/unit_test/mocks/mock_context.h" +#include "opencl/test/unit_test/mocks/mock_kernel.h" +#include "test.h" + +#include "gtest/gtest.h" + +using namespace NEO; + +DevicePreemptionTests::DevicePreemptionTests() = default; +DevicePreemptionTests::~DevicePreemptionTests() = default; + +void DevicePreemptionTests::SetUp() { + if (dbgRestore == nullptr) { + dbgRestore.reset(new DebugManagerStateRestore()); + } + const cl_queue_properties properties[3] = {CL_QUEUE_PROPERTIES, 0, 0}; + kernelInfo = std::make_unique(); + device = std::make_unique(MockDevice::createWithNewExecutionEnvironment(nullptr)); + context.reset(new MockContext(device.get())); + cmdQ.reset(new MockCommandQueue(context.get(), device.get(), properties)); + executionEnvironment.reset(new SPatchExecutionEnvironment); + memset(executionEnvironment.get(), 0, sizeof(SPatchExecutionEnvironment)); + kernelInfo->patchInfo.executionEnvironment = executionEnvironment.get(); + program = std::make_unique(*device->getExecutionEnvironment()); + kernel.reset(new MockKernel(program.get(), *kernelInfo, *device)); + dispatchInfo.reset(new DispatchInfo(kernel.get(), 1, Vec3(1, 1, 1), Vec3(1, 1, 1), Vec3(0, 0, 0))); + + ASSERT_NE(nullptr, device); + ASSERT_NE(nullptr, context); + ASSERT_NE(nullptr, cmdQ); + + waTable = &device->getRootDeviceEnvironment().getMutableHardwareInfo()->workaroundTable; +} + +void DevicePreemptionTests::TearDown() { + dbgRestore.reset(); + kernel.reset(); + kernelInfo.reset(); + dispatchInfo.reset(); + cmdQ.reset(); + context.reset(); + device.reset(); +} + +void ThreadGroupPreemptionEnqueueKernelTest::SetUp() { + dbgRestore.reset(new DebugManagerStateRestore()); + DebugManager.flags.ForcePreemptionMode.set(static_cast(PreemptionMode::ThreadGroup)); + + globalHwInfo = defaultHwInfo.get(); + originalPreemptionMode = globalHwInfo->capabilityTable.defaultPreemptionMode; + globalHwInfo->capabilityTable.defaultPreemptionMode = PreemptionMode::ThreadGroup; + + HelloWorldFixture::SetUp(); + pDevice->setPreemptionMode(PreemptionMode::ThreadGroup); +} + +void ThreadGroupPreemptionEnqueueKernelTest::TearDown() { + globalHwInfo->capabilityTable.defaultPreemptionMode = originalPreemptionMode; + + HelloWorldFixture::TearDown(); +} + +void MidThreadPreemptionEnqueueKernelTest::SetUp() { + dbgRestore.reset(new DebugManagerStateRestore()); + DebugManager.flags.ForcePreemptionMode.set(static_cast(PreemptionMode::MidThread)); + + globalHwInfo = defaultHwInfo.get(); + originalPreemptionMode = globalHwInfo->capabilityTable.defaultPreemptionMode; + globalHwInfo->capabilityTable.defaultPreemptionMode = PreemptionMode::MidThread; + + HelloWorldFixture::SetUp(); + pDevice->setPreemptionMode(PreemptionMode::MidThread); +} + +void MidThreadPreemptionEnqueueKernelTest::TearDown() { + globalHwInfo->capabilityTable.defaultPreemptionMode = originalPreemptionMode; + + HelloWorldFixture::TearDown(); +} diff --git a/opencl/test/unit_test/fixtures/cl_preemption_fixture.h b/opencl/test/unit_test/fixtures/cl_preemption_fixture.h new file mode 100644 index 0000000000..75222a85f3 --- /dev/null +++ b/opencl/test/unit_test/fixtures/cl_preemption_fixture.h @@ -0,0 +1,76 @@ +/* + * Copyright (C) 2018-2020 Intel Corporation + * + * SPDX-License-Identifier: MIT + * + */ + +#pragma once + +#include "shared/test/unit_test/helpers/debug_manager_state_restore.h" + +#include "opencl/test/unit_test/fixtures/hello_world_fixture.h" +#include "test.h" + +#include "gtest/gtest.h" + +#include + +namespace iOpenCL { +struct SPatchExecutionEnvironment; +} + +namespace NEO { +class DispatchInfo; +class MockCommandQueue; +class MockContext; +class MockDevice; +class MockKernel; +class MockProgram; +struct KernelInfo; +struct WorkaroundTable; + +using PreemptionEnqueueKernelFixture = HelloWorldFixture; +using PreemptionEnqueueKernelTest = Test; +} // namespace NEO + +class DevicePreemptionTests : public ::testing::Test { + public: + void SetUp() override; + void TearDown() override; + + DevicePreemptionTests(); + ~DevicePreemptionTests() override; + + NEO::PreemptionMode preemptionMode; + NEO::WorkaroundTable *waTable = nullptr; + std::unique_ptr dispatchInfo; + std::unique_ptr kernel; + std::unique_ptr cmdQ; + std::unique_ptr device; + std::unique_ptr context; + std::unique_ptr dbgRestore; + std::unique_ptr executionEnvironment; + std::unique_ptr program; + std::unique_ptr kernelInfo; +}; + +struct ThreadGroupPreemptionEnqueueKernelTest : NEO::PreemptionEnqueueKernelTest { + void SetUp() override; + void TearDown() override; + + NEO::HardwareInfo *globalHwInfo = nullptr; + NEO::PreemptionMode originalPreemptionMode = NEO::PreemptionMode::Initial; + + std::unique_ptr dbgRestore; +}; + +struct MidThreadPreemptionEnqueueKernelTest : NEO::PreemptionEnqueueKernelTest { + void SetUp() override; + void TearDown() override; + + NEO::HardwareInfo *globalHwInfo = nullptr; + NEO::PreemptionMode originalPreemptionMode = NEO::PreemptionMode::Initial; + + std::unique_ptr dbgRestore; +}; diff --git a/opencl/test/unit_test/gen12lp/gen12lp_tests_wrapper.cpp b/opencl/test/unit_test/gen12lp/gen12lp_tests_wrapper.cpp index 02b25edf0d..c078157046 100644 --- a/opencl/test/unit_test/gen12lp/gen12lp_tests_wrapper.cpp +++ b/opencl/test/unit_test/gen12lp/gen12lp_tests_wrapper.cpp @@ -5,8 +5,6 @@ * */ -#include "shared/test/unit_test/gen12lp/test_preemption_gen12lp.inl" - #include "opencl/test/unit_test/gen12lp/aub_command_stream_receiver_tests_gen12lp.inl" #include "opencl/test/unit_test/gen12lp/coherency_tests_gen12lp.inl" #include "opencl/test/unit_test/gen12lp/command_stream_receiver_hw_tests_gen12lp.inl" diff --git a/opencl/test/unit_test/gen8/CMakeLists.txt b/opencl/test/unit_test/gen8/CMakeLists.txt index 6bb5fcd228..952b558077 100644 --- a/opencl/test/unit_test/gen8/CMakeLists.txt +++ b/opencl/test/unit_test/gen8/CMakeLists.txt @@ -19,6 +19,7 @@ if(TESTS_GEN8) ${CMAKE_CURRENT_SOURCE_DIR}/test_device_caps_gen8.cpp ${CMAKE_CURRENT_SOURCE_DIR}/test_device_queue_hw_gen8.cpp ${CMAKE_CURRENT_SOURCE_DIR}/test_platform_caps_gen8.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/test_preemption_gen8.cpp ${CMAKE_CURRENT_SOURCE_DIR}/test_sample_gen8.cpp ${CMAKE_CURRENT_SOURCE_DIR}/unit_test_helper_gen8.cpp ) diff --git a/opencl/test/unit_test/gen8/test_preemption_gen8.cpp b/opencl/test/unit_test/gen8/test_preemption_gen8.cpp new file mode 100644 index 0000000000..61eff6ba77 --- /dev/null +++ b/opencl/test/unit_test/gen8/test_preemption_gen8.cpp @@ -0,0 +1,106 @@ +/* + * Copyright (C) 2020 Intel Corporation + * + * SPDX-License-Identifier: MIT + * + */ + +#include "shared/source/command_stream/preemption.h" +#include "shared/test/unit_test/cmd_parse/hw_parse.h" +#include "shared/test/unit_test/mocks/mock_command_stream_receiver.h" + +#include "opencl/source/event/user_event.h" +#include "opencl/test/unit_test/fixtures/cl_preemption_fixture.h" +#include "opencl/test/unit_test/libult/ult_command_stream_receiver.h" + +using namespace NEO; + +using Gen8PreemptionEnqueueKernelTest = PreemptionEnqueueKernelTest; +using Gen8ClPreemptionTests = DevicePreemptionTests; + +GEN8TEST_F(Gen8ClPreemptionTests, allowThreadGroupPreemptionReturnsTrue) { + PreemptionFlags flags = {}; + PreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), kernel.get()); + EXPECT_TRUE(PreemptionHelper::allowThreadGroupPreemption(flags)); +} + +GEN8TEST_F(Gen8PreemptionEnqueueKernelTest, givenSecondEnqueueWithTheSamePreemptionRequestThenDontReprogram) { + pDevice->setPreemptionMode(PreemptionMode::ThreadGroup); + auto &csr = pDevice->getUltCommandStreamReceiver(); + csr.getMemoryManager()->setForce32BitAllocations(false); + csr.setMediaVFEStateDirty(false); + size_t off[3] = {0, 0, 0}; + size_t gws[3] = {1, 1, 1}; + + MockKernelWithInternals mockKernel(*pClDevice); + + HardwareParse hwParser; + pCmdQ->enqueueKernel(mockKernel.mockKernel, 1, off, gws, nullptr, 0, nullptr, nullptr); + hwParser.parseCommands(csr.commandStream); + auto offset = csr.commandStream.getUsed(); + pCmdQ->enqueueKernel(mockKernel.mockKernel, 1, off, gws, nullptr, 0, nullptr, nullptr); + pCmdQ->flush(); + hwParser.parseCommands(csr.commandStream, offset); + + size_t numMmiosFound = countMmio(hwParser.cmdList.begin(), hwParser.cmdList.end(), 0x2248u); + EXPECT_EQ(1U, numMmiosFound); +} + +GEN8TEST_F(Gen8PreemptionEnqueueKernelTest, givenValidKernelForPreemptionWhenEnqueueKernelCalledThenPassDevicePreemptionMode) { + pDevice->setPreemptionMode(PreemptionMode::ThreadGroup); + auto mockCsr = new MockCsrHw2(*pDevice->executionEnvironment, pDevice->getRootDeviceIndex()); + pDevice->resetCommandStreamReceiver(mockCsr); + + MockKernelWithInternals mockKernel(*pClDevice); + PreemptionFlags flags = {}; + MultiDispatchInfo multiDispatch(mockKernel.mockKernel); + EXPECT_EQ(PreemptionMode::ThreadGroup, PreemptionHelper::taskPreemptionMode(*pDevice, multiDispatch)); + + size_t gws[3] = {1, 0, 0}; + pCmdQ->enqueueKernel(mockKernel.mockKernel, 1, nullptr, gws, nullptr, 0, nullptr, nullptr); + pCmdQ->flush(); + + EXPECT_EQ(1, mockCsr->flushCalledCount); + EXPECT_EQ(PreemptionMode::ThreadGroup, mockCsr->passedDispatchFlags.preemptionMode); +} + +GEN8TEST_F(Gen8PreemptionEnqueueKernelTest, givenValidKernelForPreemptionWhenEnqueueKernelCalledAndBlockedThenPassDevicePreemptionMode) { + pDevice->setPreemptionMode(PreemptionMode::ThreadGroup); + auto mockCsr = new MockCsrHw2(*pDevice->executionEnvironment, pDevice->getRootDeviceIndex()); + pDevice->resetCommandStreamReceiver(mockCsr); + + MockKernelWithInternals mockKernel(*pClDevice); + PreemptionFlags flags = {}; + PreemptionHelper::setPreemptionLevelFlags(flags, *pDevice, mockKernel.mockKernel); + EXPECT_EQ(PreemptionMode::ThreadGroup, PreemptionHelper::taskPreemptionMode(pDevice->getPreemptionMode(), flags)); + + UserEvent userEventObj; + cl_event userEvent = &userEventObj; + size_t gws[3] = {1, 0, 0}; + pCmdQ->enqueueKernel(mockKernel.mockKernel, 1, nullptr, gws, nullptr, 1, &userEvent, nullptr); + pCmdQ->flush(); + EXPECT_EQ(0, mockCsr->flushCalledCount); + + userEventObj.setStatus(CL_COMPLETE); + pCmdQ->flush(); + EXPECT_EQ(1, mockCsr->flushCalledCount); + EXPECT_EQ(PreemptionMode::ThreadGroup, mockCsr->passedDispatchFlags.preemptionMode); +} + +GEN8TEST_F(Gen8PreemptionEnqueueKernelTest, givenDisabledPreemptionWhenEnqueueKernelCalledThenPassDisabledPreemptionMode) { + pDevice->setPreemptionMode(PreemptionMode::Disabled); + auto mockCsr = new MockCsrHw2(*pDevice->executionEnvironment, pDevice->getRootDeviceIndex()); + pDevice->resetCommandStreamReceiver(mockCsr); + + MockKernelWithInternals mockKernel(*pClDevice); + PreemptionFlags flags = {}; + PreemptionHelper::setPreemptionLevelFlags(flags, *pDevice, mockKernel.mockKernel); + EXPECT_EQ(PreemptionMode::Disabled, PreemptionHelper::taskPreemptionMode(pDevice->getPreemptionMode(), flags)); + + size_t gws[3] = {1, 0, 0}; + pCmdQ->enqueueKernel(mockKernel.mockKernel, 1, nullptr, gws, nullptr, 0, nullptr, nullptr); + pCmdQ->flush(); + + EXPECT_EQ(1, mockCsr->flushCalledCount); + EXPECT_EQ(PreemptionMode::Disabled, mockCsr->passedDispatchFlags.preemptionMode); +} diff --git a/opencl/test/unit_test/gen9/CMakeLists.txt b/opencl/test/unit_test/gen9/CMakeLists.txt index a1fc11c0af..6226a1f490 100644 --- a/opencl/test/unit_test/gen9/CMakeLists.txt +++ b/opencl/test/unit_test/gen9/CMakeLists.txt @@ -21,6 +21,7 @@ if(TESTS_GEN9) ${CMAKE_CURRENT_SOURCE_DIR}/test_device_caps_gen9.cpp ${CMAKE_CURRENT_SOURCE_DIR}/test_device_queue_hw_gen9.cpp ${CMAKE_CURRENT_SOURCE_DIR}/test_platform_caps_gen9.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/test_preemption_gen9.cpp ${CMAKE_CURRENT_SOURCE_DIR}/test_sample_gen9.cpp ${CMAKE_CURRENT_SOURCE_DIR}/unit_test_helper_gen9.cpp ) diff --git a/opencl/test/unit_test/gen9/test_preemption_gen9.cpp b/opencl/test/unit_test/gen9/test_preemption_gen9.cpp new file mode 100644 index 0000000000..31fc6c5385 --- /dev/null +++ b/opencl/test/unit_test/gen9/test_preemption_gen9.cpp @@ -0,0 +1,390 @@ +/* + * Copyright (C) 2020 Intel Corporation + * + * SPDX-License-Identifier: MIT + * + */ + +#include "shared/source/command_stream/preemption.h" +#include "shared/test/unit_test/cmd_parse/hw_parse.h" +#include "shared/test/unit_test/mocks/mock_command_stream_receiver.h" + +#include "opencl/test/unit_test/command_queue/enqueue_fixture.h" +#include "opencl/test/unit_test/fixtures/cl_preemption_fixture.h" +#include "opencl/test/unit_test/mocks/mock_command_queue.h" + +namespace NEO { + +template <> +void HardwareParse::findCsrBaseAddress() { + typedef typename GEN9::GPGPU_CSR_BASE_ADDRESS GPGPU_CSR_BASE_ADDRESS; + itorGpgpuCsrBaseAddress = find(cmdList.begin(), itorWalker); + if (itorGpgpuCsrBaseAddress != itorWalker) { + cmdGpgpuCsrBaseAddress = *itorGpgpuCsrBaseAddress; + } +} +} // namespace NEO + +using namespace NEO; + +using Gen9PreemptionEnqueueKernelTest = PreemptionEnqueueKernelTest; +using Gen9MidThreadPreemptionEnqueueKernelTest = MidThreadPreemptionEnqueueKernelTest; +using Gen9ThreadGroupPreemptionEnqueueKernelTest = ThreadGroupPreemptionEnqueueKernelTest; + +GEN9TEST_F(Gen9ThreadGroupPreemptionEnqueueKernelTest, givenSecondEnqueueWithTheSamePreemptionRequestThenDontReprogramThreadGroupNoWa) { + pDevice->setPreemptionMode(PreemptionMode::ThreadGroup); + + pDevice->getRootDeviceEnvironment().getMutableHardwareInfo()->workaroundTable.waModifyVFEStateAfterGPGPUPreemption = false; + auto &csr = pDevice->getUltCommandStreamReceiver(); + csr.getMemoryManager()->setForce32BitAllocations(false); + csr.setMediaVFEStateDirty(false); + auto csrSurface = csr.getPreemptionAllocation(); + EXPECT_EQ(nullptr, csrSurface); + size_t off[3] = {0, 0, 0}; + size_t gws[3] = {1, 1, 1}; + + MockKernelWithInternals mockKernel(*pClDevice); + + HardwareParse hwParserCsr; + HardwareParse hwParserCmdQ; + pCmdQ->enqueueKernel(mockKernel.mockKernel, 1, off, gws, nullptr, 0, nullptr, nullptr); + hwParserCsr.parseCommands(csr.commandStream); + hwParserCmdQ.parseCommands(pCmdQ->getCS(1024)); + auto offsetCsr = csr.commandStream.getUsed(); + auto offsetCmdQ = pCmdQ->getCS(1024).getUsed(); + pCmdQ->enqueueKernel(mockKernel.mockKernel, 1, off, gws, nullptr, 0, nullptr, nullptr); + pCmdQ->flush(); + hwParserCsr.parseCommands(csr.commandStream, offsetCsr); + hwParserCmdQ.parseCommands(pCmdQ->getCS(1024), offsetCmdQ); + + EXPECT_EQ(1U, countMmio(hwParserCsr.cmdList.begin(), hwParserCsr.cmdList.end(), 0x2580u)); + EXPECT_EQ(0U, countMmio(hwParserCsr.cmdList.begin(), hwParserCsr.cmdList.end(), 0x2600u)); + EXPECT_EQ(0U, countMmio(hwParserCmdQ.cmdList.begin(), hwParserCmdQ.cmdList.end(), 0x2580u)); + EXPECT_EQ(0U, countMmio(hwParserCmdQ.cmdList.begin(), hwParserCmdQ.cmdList.end(), 0x2600u)); +} + +GEN9TEST_F(Gen9ThreadGroupPreemptionEnqueueKernelTest, givenSecondEnqueueWithTheSamePreemptionRequestThenDontReprogramThreadGroupWa) { + pDevice->setPreemptionMode(PreemptionMode::ThreadGroup); + + pDevice->getRootDeviceEnvironment().getMutableHardwareInfo()->workaroundTable.waModifyVFEStateAfterGPGPUPreemption = true; + auto &csr = pDevice->getUltCommandStreamReceiver(); + csr.getMemoryManager()->setForce32BitAllocations(false); + csr.setMediaVFEStateDirty(false); + auto csrSurface = csr.getPreemptionAllocation(); + EXPECT_EQ(nullptr, csrSurface); + HardwareParse hwCsrParser; + HardwareParse hwCmdQParser; + size_t off[3] = {0, 0, 0}; + size_t gws[3] = {1, 1, 1}; + + MockKernelWithInternals mockKernel(*pClDevice); + + pCmdQ->enqueueKernel(mockKernel.mockKernel, 1, off, gws, nullptr, 0, nullptr, nullptr); + hwCsrParser.parseCommands(csr.commandStream); + hwCsrParser.findHardwareCommands(); + hwCmdQParser.parseCommands(pCmdQ->getCS(1024)); + hwCmdQParser.findHardwareCommands(); + auto offsetCsr = csr.commandStream.getUsed(); + auto offsetCmdQ = pCmdQ->getCS(1024).getUsed(); + + bool foundOne = false; + for (auto it : hwCsrParser.lriList) { + auto cmd = genCmdCast(it); + if (cmd->getRegisterOffset() == 0x2580u) { + EXPECT_FALSE(foundOne); + foundOne = true; + } + } + EXPECT_TRUE(foundOne); + hwCsrParser.cmdList.clear(); + hwCsrParser.lriList.clear(); + + int foundWaLri = 0; + int foundWaLriBegin = 0; + int foundWaLriEnd = 0; + for (auto it : hwCmdQParser.lriList) { + auto cmd = genCmdCast(it); + if (cmd->getRegisterOffset() == 0x2600u) { + foundWaLri++; + if (cmd->getDataDword() == 0xFFFFFFFF) { + foundWaLriBegin++; + } + if (cmd->getDataDword() == 0x0) { + foundWaLriEnd++; + } + } + } + EXPECT_EQ(2, foundWaLri); + EXPECT_EQ(1, foundWaLriBegin); + EXPECT_EQ(1, foundWaLriEnd); + hwCmdQParser.cmdList.clear(); + hwCmdQParser.lriList.clear(); + + pCmdQ->enqueueKernel(mockKernel.mockKernel, 1, off, gws, nullptr, 0, nullptr, nullptr); + hwCsrParser.parseCommands(csr.commandStream, offsetCsr); + hwCsrParser.findHardwareCommands(); + + hwCmdQParser.parseCommands(pCmdQ->getCS(1024), offsetCmdQ); + hwCmdQParser.findHardwareCommands(); + + for (auto it : hwCsrParser.lriList) { + auto cmd = genCmdCast(it); + EXPECT_FALSE(cmd->getRegisterOffset() == 0x2580u); + } + + foundWaLri = 0; + foundWaLriBegin = 0; + foundWaLriEnd = 0; + for (auto it : hwCmdQParser.lriList) { + auto cmd = genCmdCast(it); + if (cmd->getRegisterOffset() == 0x2600u) { + foundWaLri++; + if (cmd->getDataDword() == 0xFFFFFFFF) { + foundWaLriBegin++; + } + if (cmd->getDataDword() == 0x0) { + foundWaLriEnd++; + } + } + } + EXPECT_EQ(2, foundWaLri); + EXPECT_EQ(1, foundWaLriBegin); + EXPECT_EQ(1, foundWaLriEnd); +} + +GEN9TEST_F(Gen9PreemptionEnqueueKernelTest, givenValidKernelForPreemptionWhenEnqueueKernelCalledThenPassDevicePreemptionModeThreadGroup) { + pDevice->setPreemptionMode(PreemptionMode::ThreadGroup); + + auto mockCsr = new MockCsrHw2(*pDevice->executionEnvironment, pDevice->getRootDeviceIndex()); + pDevice->resetCommandStreamReceiver(mockCsr); + + MockKernelWithInternals mockKernel(*pClDevice); + MultiDispatchInfo multiDispatch(mockKernel.mockKernel); + EXPECT_EQ(PreemptionMode::ThreadGroup, PreemptionHelper::taskPreemptionMode(*pDevice, multiDispatch)); + + size_t gws[3] = {1, 0, 0}; + pCmdQ->enqueueKernel(mockKernel.mockKernel, 1, nullptr, gws, nullptr, 0, nullptr, nullptr); + pCmdQ->flush(); + + EXPECT_EQ(1, mockCsr->flushCalledCount); + EXPECT_EQ(PreemptionMode::ThreadGroup, mockCsr->passedDispatchFlags.preemptionMode); +} + +GEN9TEST_F(Gen9PreemptionEnqueueKernelTest, givenValidKernelForPreemptionWhenEnqueueKernelCalledAndBlockedThenPassDevicePreemptionModeThreadGroup) { + pDevice->setPreemptionMode(PreemptionMode::ThreadGroup); + + auto mockCsr = new MockCsrHw2(*pDevice->executionEnvironment, pDevice->getRootDeviceIndex()); + pDevice->resetCommandStreamReceiver(mockCsr); + + MockKernelWithInternals mockKernel(*pClDevice); + MultiDispatchInfo multiDispatch(mockKernel.mockKernel); + EXPECT_EQ(PreemptionMode::ThreadGroup, PreemptionHelper::taskPreemptionMode(*pDevice, multiDispatch)); + + UserEvent userEventObj; + cl_event userEvent = &userEventObj; + size_t gws[3] = {1, 0, 0}; + pCmdQ->enqueueKernel(mockKernel.mockKernel, 1, nullptr, gws, nullptr, 1, &userEvent, nullptr); + pCmdQ->flush(); + EXPECT_EQ(0, mockCsr->flushCalledCount); + + userEventObj.setStatus(CL_COMPLETE); + pCmdQ->flush(); + EXPECT_EQ(1, mockCsr->flushCalledCount); + EXPECT_EQ(PreemptionMode::ThreadGroup, mockCsr->passedDispatchFlags.preemptionMode); +} + +GEN9TEST_F(Gen9MidThreadPreemptionEnqueueKernelTest, givenSecondEnqueueWithTheSamePreemptionRequestThenDontReprogramMidThreadNoWa) { + typedef typename FamilyType::MI_LOAD_REGISTER_IMM MI_LOAD_REGISTER_IMM; + typedef typename FamilyType::GPGPU_CSR_BASE_ADDRESS GPGPU_CSR_BASE_ADDRESS; + + pDevice->getRootDeviceEnvironment().getMutableHardwareInfo()->workaroundTable.waModifyVFEStateAfterGPGPUPreemption = false; + + auto &csr = pDevice->getUltCommandStreamReceiver(); + csr.getMemoryManager()->setForce32BitAllocations(false); + csr.setMediaVFEStateDirty(false); + auto csrSurface = csr.getPreemptionAllocation(); + ASSERT_NE(nullptr, csrSurface); + HardwareParse hwCsrParser; + HardwareParse hwCmdQParser; + size_t off[3] = {0, 0, 0}; + size_t gws[3] = {1, 1, 1}; + + MockKernelWithInternals mockKernel(*pClDevice); + + pCmdQ->enqueueKernel(mockKernel.mockKernel, 1, off, gws, nullptr, 0, nullptr, nullptr); + hwCsrParser.parseCommands(csr.commandStream); + hwCsrParser.findHardwareCommands(); + hwCmdQParser.parseCommands(pCmdQ->getCS(1024)); + hwCmdQParser.findHardwareCommands(); + auto offsetCsr = csr.commandStream.getUsed(); + auto offsetCmdQ = pCmdQ->getCS(1024).getUsed(); + + bool foundOneLri = false; + for (auto it : hwCsrParser.lriList) { + auto cmdLri = genCmdCast(it); + if (cmdLri->getRegisterOffset() == 0x2580u) { + EXPECT_FALSE(foundOneLri); + foundOneLri = true; + } + } + EXPECT_TRUE(foundOneLri); + + bool foundWaLri = false; + for (auto it : hwCmdQParser.lriList) { + auto cmdLri = genCmdCast(it); + if (cmdLri->getRegisterOffset() == 0x2600u) { + foundWaLri = true; + } + } + EXPECT_FALSE(foundWaLri); + + hwCsrParser.findCsrBaseAddress(); + ASSERT_NE(nullptr, hwCsrParser.cmdGpgpuCsrBaseAddress); + auto cmdCsr = genCmdCast(hwCsrParser.cmdGpgpuCsrBaseAddress); + ASSERT_NE(nullptr, cmdCsr); + EXPECT_EQ(csrSurface->getGpuAddressToPatch(), cmdCsr->getGpgpuCsrBaseAddress()); + + hwCsrParser.cmdList.clear(); + hwCsrParser.lriList.clear(); + hwCsrParser.cmdGpgpuCsrBaseAddress = nullptr; + hwCmdQParser.cmdList.clear(); + hwCmdQParser.lriList.clear(); + + pCmdQ->enqueueKernel(mockKernel.mockKernel, 1, off, gws, nullptr, 0, nullptr, nullptr); + hwCsrParser.parseCommands(csr.commandStream, offsetCsr); + hwCsrParser.findHardwareCommands(); + hwCmdQParser.parseCommands(csr.commandStream, offsetCmdQ); + hwCmdQParser.findHardwareCommands(); + + for (auto it : hwCsrParser.lriList) { + auto cmd = genCmdCast(it); + EXPECT_FALSE(cmd->getRegisterOffset() == 0x2580u); + } + + hwCsrParser.findCsrBaseAddress(); + EXPECT_EQ(nullptr, hwCsrParser.cmdGpgpuCsrBaseAddress); + + for (auto it : hwCmdQParser.lriList) { + auto cmd = genCmdCast(it); + EXPECT_FALSE(cmd->getRegisterOffset() == 0x2600u); + } +} + +GEN9TEST_F(Gen9MidThreadPreemptionEnqueueKernelTest, givenSecondEnqueueWithTheSamePreemptionRequestThenDontReprogramMidThreadWa) { + typedef typename FamilyType::MI_LOAD_REGISTER_IMM MI_LOAD_REGISTER_IMM; + typedef typename FamilyType::GPGPU_CSR_BASE_ADDRESS GPGPU_CSR_BASE_ADDRESS; + + pDevice->getRootDeviceEnvironment().getMutableHardwareInfo()->workaroundTable.waModifyVFEStateAfterGPGPUPreemption = true; + + auto &csr = pDevice->getUltCommandStreamReceiver(); + csr.getMemoryManager()->setForce32BitAllocations(false); + csr.setMediaVFEStateDirty(false); + auto csrSurface = csr.getPreemptionAllocation(); + ASSERT_NE(nullptr, csrSurface); + HardwareParse hwCsrParser; + HardwareParse hwCmdQParser; + size_t off[3] = {0, 0, 0}; + size_t gws[3] = {1, 1, 1}; + + MockKernelWithInternals mockKernel(*pClDevice); + + pCmdQ->enqueueKernel(mockKernel.mockKernel, 1, off, gws, nullptr, 0, nullptr, nullptr); + hwCsrParser.parseCommands(csr.commandStream); + hwCsrParser.findHardwareCommands(); + hwCmdQParser.parseCommands(pCmdQ->getCS(1024)); + hwCmdQParser.findHardwareCommands(); + auto offsetCsr = csr.commandStream.getUsed(); + auto offsetCmdQ = pCmdQ->getCS(1024).getUsed(); + + bool foundOneLri = false; + for (auto it : hwCsrParser.lriList) { + auto cmdLri = genCmdCast(it); + if (cmdLri->getRegisterOffset() == 0x2580u) { + EXPECT_FALSE(foundOneLri); + foundOneLri = true; + } + } + EXPECT_TRUE(foundOneLri); + + int foundWaLri = 0; + int foundWaLriBegin = 0; + int foundWaLriEnd = 0; + for (auto it : hwCmdQParser.lriList) { + auto cmdLri = genCmdCast(it); + if (cmdLri->getRegisterOffset() == 0x2600u) { + foundWaLri++; + if (cmdLri->getDataDword() == 0xFFFFFFFF) { + foundWaLriBegin++; + } + if (cmdLri->getDataDword() == 0x0) { + foundWaLriEnd++; + } + } + } + EXPECT_EQ(2, foundWaLri); + EXPECT_EQ(1, foundWaLriBegin); + EXPECT_EQ(1, foundWaLriEnd); + + hwCsrParser.findCsrBaseAddress(); + ASSERT_NE(nullptr, hwCsrParser.cmdGpgpuCsrBaseAddress); + auto cmdCsr = genCmdCast(hwCsrParser.cmdGpgpuCsrBaseAddress); + ASSERT_NE(nullptr, cmdCsr); + EXPECT_EQ(csrSurface->getGpuAddressToPatch(), cmdCsr->getGpgpuCsrBaseAddress()); + + hwCsrParser.cmdList.clear(); + hwCsrParser.lriList.clear(); + hwCsrParser.cmdGpgpuCsrBaseAddress = nullptr; + hwCmdQParser.cmdList.clear(); + hwCmdQParser.lriList.clear(); + + pCmdQ->enqueueKernel(mockKernel.mockKernel, 1, off, gws, nullptr, 0, nullptr, nullptr); + hwCsrParser.parseCommands(csr.commandStream, offsetCsr); + hwCsrParser.findHardwareCommands(); + hwCmdQParser.parseCommands(pCmdQ->getCS(1024), offsetCmdQ); + hwCmdQParser.findHardwareCommands(); + + for (auto it : hwCsrParser.lriList) { + auto cmd = genCmdCast(it); + EXPECT_FALSE(cmd->getRegisterOffset() == 0x2580u); + } + + hwCsrParser.findCsrBaseAddress(); + EXPECT_EQ(nullptr, hwCsrParser.cmdGpgpuCsrBaseAddress); + + foundWaLri = 0; + foundWaLriBegin = 0; + foundWaLriEnd = 0; + for (auto it : hwCmdQParser.lriList) { + auto cmd = genCmdCast(it); + if (cmd->getRegisterOffset() == 0x2600u) { + foundWaLri++; + if (cmd->getDataDword() == 0xFFFFFFFF) { + foundWaLriBegin++; + } + if (cmd->getDataDword() == 0x0) { + foundWaLriEnd++; + } + } + } + EXPECT_EQ(2, foundWaLri); + EXPECT_EQ(1, foundWaLriBegin); + EXPECT_EQ(1, foundWaLriEnd); +} + +GEN9TEST_F(Gen9PreemptionEnqueueKernelTest, givenDisabledPreemptionWhenEnqueueKernelCalledThenPassDisabledPreemptionMode) { + pDevice->setPreemptionMode(PreemptionMode::Disabled); + + auto mockCsr = new MockCsrHw2(*pDevice->executionEnvironment, pDevice->getRootDeviceIndex()); + pDevice->resetCommandStreamReceiver(mockCsr); + + MockKernelWithInternals mockKernel(*pClDevice); + MultiDispatchInfo multiDispatch(mockKernel.mockKernel); + EXPECT_EQ(PreemptionMode::Disabled, PreemptionHelper::taskPreemptionMode(*pDevice, multiDispatch)); + + size_t gws[3] = {1, 0, 0}; + pCmdQ->enqueueKernel(mockKernel.mockKernel, 1, nullptr, gws, nullptr, 0, nullptr, nullptr); + pCmdQ->flush(); + + EXPECT_EQ(1, mockCsr->flushCalledCount); + EXPECT_EQ(PreemptionMode::Disabled, mockCsr->passedDispatchFlags.preemptionMode); +} diff --git a/opencl/test/unit_test/mocks/CMakeLists.txt b/opencl/test/unit_test/mocks/CMakeLists.txt index 8997c1da3f..41b9b49a97 100644 --- a/opencl/test/unit_test/mocks/CMakeLists.txt +++ b/opencl/test/unit_test/mocks/CMakeLists.txt @@ -104,6 +104,7 @@ if(WIN32) ${CMAKE_CURRENT_SOURCE_DIR}/mock_wddm_residency_logger.h ${CMAKE_CURRENT_SOURCE_DIR}/wddm_mock_helpers.h ${IGDRCL_SRC_tests_mock_wddm} + ${NEO_SOURCE_DIR}/shared/test/unit_test/os_interface/windows/mock_gdi_interface.cpp ) else() list(APPEND IGDRCL_SRCS_tests_mocks diff --git a/opencl/test/unit_test/perf_tests/fixtures/CMakeLists.txt b/opencl/test/unit_test/perf_tests/fixtures/CMakeLists.txt index 0f11e3d864..b71be41736 100644 --- a/opencl/test/unit_test/perf_tests/fixtures/CMakeLists.txt +++ b/opencl/test/unit_test/perf_tests/fixtures/CMakeLists.txt @@ -6,8 +6,8 @@ set(IGDRCL_SRCS_perf_tests_fixtures "${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt" - "${CMAKE_CURRENT_SOURCE_DIR}/cl_device_fixture.cpp" - "${CMAKE_CURRENT_SOURCE_DIR}/cl_device_fixture.h" + "${CMAKE_CURRENT_SOURCE_DIR}/device_fixture.cpp" + "${CMAKE_CURRENT_SOURCE_DIR}/device_fixture.h" "${CMAKE_CURRENT_SOURCE_DIR}/command_queue_fixture.cpp" "${CMAKE_CURRENT_SOURCE_DIR}/command_queue_fixture.h" "${CMAKE_CURRENT_SOURCE_DIR}/platform_fixture.cpp" diff --git a/opencl/test/unit_test/preemption/CMakeLists.txt b/opencl/test/unit_test/preemption/CMakeLists.txt new file mode 100644 index 0000000000..d9e8f2492c --- /dev/null +++ b/opencl/test/unit_test/preemption/CMakeLists.txt @@ -0,0 +1,12 @@ +# +# Copyright (C) 2020 Intel Corporation +# +# SPDX-License-Identifier: MIT +# + +target_sources(igdrcl_tests PRIVATE + ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt + ${CMAKE_CURRENT_SOURCE_DIR}/preemption_tests.cpp +) + +add_subdirectories() diff --git a/opencl/test/unit_test/preemption/preemption_tests.cpp b/opencl/test/unit_test/preemption/preemption_tests.cpp new file mode 100644 index 0000000000..f9e98fd848 --- /dev/null +++ b/opencl/test/unit_test/preemption/preemption_tests.cpp @@ -0,0 +1,291 @@ +/* + * Copyright (C) 2020 Intel Corporation + * + * SPDX-License-Identifier: MIT + * + */ + +#include "shared/source/command_stream/preemption.h" + +#include "opencl/test/unit_test/fixtures/cl_preemption_fixture.h" + +#include "gmock/gmock.h" + +using namespace NEO; + +class ThreadGroupPreemptionTests : public DevicePreemptionTests { + void SetUp() override { + dbgRestore.reset(new DebugManagerStateRestore()); + DebugManager.flags.ForcePreemptionMode.set(static_cast(PreemptionMode::ThreadGroup)); + preemptionMode = PreemptionMode::ThreadGroup; + DevicePreemptionTests::SetUp(); + } +}; + +class MidThreadPreemptionTests : public DevicePreemptionTests { + public: + void SetUp() override { + dbgRestore.reset(new DebugManagerStateRestore()); + DebugManager.flags.ForcePreemptionMode.set(static_cast(PreemptionMode::MidThread)); + preemptionMode = PreemptionMode::MidThread; + DevicePreemptionTests::SetUp(); + } +}; + +TEST_F(ThreadGroupPreemptionTests, disallowByKMD) { + PreemptionFlags flags = {}; + waTable->waDisablePerCtxtPreemptionGranularityControl = 1; + PreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), kernel.get()); + EXPECT_FALSE(PreemptionHelper::allowThreadGroupPreemption(flags)); + EXPECT_EQ(PreemptionMode::MidBatch, PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags)); +} + +TEST_F(ThreadGroupPreemptionTests, disallowByDevice) { + PreemptionFlags flags = {}; + device->setPreemptionMode(PreemptionMode::MidThread); + PreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), kernel.get()); + EXPECT_TRUE(PreemptionHelper::allowThreadGroupPreemption(flags)); + EXPECT_EQ(PreemptionMode::MidThread, PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags)); +} + +TEST_F(ThreadGroupPreemptionTests, disallowByReadWriteFencesWA) { + PreemptionFlags flags = {}; + executionEnvironment->UsesFencesForReadWriteImages = 1u; + waTable->waDisableLSQCROPERFforOCL = 1; + PreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), kernel.get()); + EXPECT_FALSE(PreemptionHelper::allowThreadGroupPreemption(flags)); + EXPECT_EQ(PreemptionMode::MidBatch, PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags)); +} + +TEST_F(ThreadGroupPreemptionTests, disallowBySchedulerKernel) { + PreemptionFlags flags = {}; + kernel.reset(new MockKernel(program.get(), *kernelInfo, *device, true)); + PreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), kernel.get()); + EXPECT_FALSE(PreemptionHelper::allowThreadGroupPreemption(flags)); + EXPECT_EQ(PreemptionMode::MidBatch, PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags)); +} + +TEST_F(ThreadGroupPreemptionTests, disallowByVmeKernel) { + PreemptionFlags flags = {}; + kernelInfo->isVmeWorkload = true; + kernel.reset(new MockKernel(program.get(), *kernelInfo, *device)); + PreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), kernel.get()); + EXPECT_FALSE(PreemptionHelper::allowThreadGroupPreemption(flags)); + EXPECT_EQ(PreemptionMode::MidBatch, PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags)); +} + +TEST_F(ThreadGroupPreemptionTests, simpleAllow) { + PreemptionFlags flags = {}; + EXPECT_TRUE(PreemptionHelper::allowThreadGroupPreemption(flags)); + EXPECT_EQ(PreemptionMode::ThreadGroup, PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags)); +} + +TEST_F(ThreadGroupPreemptionTests, allowDefaultModeForNonKernelRequest) { + PreemptionFlags flags = {}; + PreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), nullptr); + EXPECT_EQ(PreemptionMode::ThreadGroup, PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags)); +} + +TEST_F(ThreadGroupPreemptionTests, givenKernelWithNoEnvironmentPatchSetWhenLSQCWaIsTurnedOnThenThreadGroupPreemptionIsBeingSelected) { + PreemptionFlags flags = {}; + kernelInfo.get()->patchInfo.executionEnvironment = nullptr; + waTable->waDisableLSQCROPERFforOCL = 1; + PreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), kernel.get()); + EXPECT_TRUE(PreemptionHelper::allowThreadGroupPreemption(flags)); + EXPECT_EQ(PreemptionMode::ThreadGroup, PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags)); +} + +TEST_F(ThreadGroupPreemptionTests, givenKernelWithEnvironmentPatchSetWhenLSQCWaIsTurnedOnThenThreadGroupPreemptionIsBeingSelected) { + PreemptionFlags flags = {}; + executionEnvironment.get()->UsesFencesForReadWriteImages = 0; + waTable->waDisableLSQCROPERFforOCL = 1; + PreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), kernel.get()); + EXPECT_TRUE(PreemptionHelper::allowThreadGroupPreemption(flags)); + EXPECT_EQ(PreemptionMode::ThreadGroup, PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags)); +} + +TEST_F(ThreadGroupPreemptionTests, givenKernelWithEnvironmentPatchSetWhenLSQCWaIsTurnedOffThenThreadGroupPreemptionIsBeingSelected) { + PreemptionFlags flags = {}; + executionEnvironment.get()->UsesFencesForReadWriteImages = 1; + waTable->waDisableLSQCROPERFforOCL = 0; + PreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), kernel.get()); + EXPECT_TRUE(PreemptionHelper::allowThreadGroupPreemption(flags)); + EXPECT_EQ(PreemptionMode::ThreadGroup, PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags)); +} + +TEST_F(ThreadGroupPreemptionTests, allowMidBatch) { + PreemptionFlags flags = {}; + device->setPreemptionMode(PreemptionMode::MidBatch); + PreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), nullptr); + EXPECT_EQ(PreemptionMode::MidBatch, PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags)); +} + +TEST_F(ThreadGroupPreemptionTests, disallowWhenAdjustedDisabled) { + PreemptionFlags flags = {}; + device->setPreemptionMode(PreemptionMode::Disabled); + PreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), nullptr); + EXPECT_EQ(PreemptionMode::Disabled, PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags)); +} + +TEST_F(ThreadGroupPreemptionTests, returnDefaultDeviceModeForZeroSizedMdi) { + MultiDispatchInfo multiDispatchInfo; + EXPECT_EQ(PreemptionMode::ThreadGroup, PreemptionHelper::taskPreemptionMode(device->getDevice(), multiDispatchInfo)); +} + +TEST_F(ThreadGroupPreemptionTests, returnDefaultDeviceModeForValidKernelsInMdi) { + MultiDispatchInfo multiDispatchInfo; + multiDispatchInfo.push(*dispatchInfo); + multiDispatchInfo.push(*dispatchInfo); + EXPECT_EQ(PreemptionMode::ThreadGroup, PreemptionHelper::taskPreemptionMode(device->getDevice(), multiDispatchInfo)); +} + +TEST_F(ThreadGroupPreemptionTests, disallowDefaultDeviceModeForValidKernelsInMdiAndDisabledPremption) { + device->setPreemptionMode(PreemptionMode::Disabled); + MultiDispatchInfo multiDispatchInfo; + multiDispatchInfo.push(*dispatchInfo); + multiDispatchInfo.push(*dispatchInfo); + EXPECT_EQ(PreemptionMode::Disabled, PreemptionHelper::taskPreemptionMode(device->getDevice(), multiDispatchInfo)); +} + +TEST_F(ThreadGroupPreemptionTests, disallowDefaultDeviceModeWhenAtLeastOneInvalidKernelInMdi) { + MockKernel schedulerKernel(program.get(), *kernelInfo, *device, true); + DispatchInfo schedulerDispatchInfo(&schedulerKernel, 1, Vec3(1, 1, 1), Vec3(1, 1, 1), Vec3(0, 0, 0)); + + PreemptionFlags flags = {}; + PreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), &schedulerKernel); + EXPECT_EQ(PreemptionMode::MidBatch, PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags)); + + MultiDispatchInfo multiDispatchInfo; + multiDispatchInfo.push(*dispatchInfo); + multiDispatchInfo.push(schedulerDispatchInfo); + multiDispatchInfo.push(*dispatchInfo); + + EXPECT_EQ(PreemptionMode::MidBatch, PreemptionHelper::taskPreemptionMode(device->getDevice(), multiDispatchInfo)); +} + +TEST_F(MidThreadPreemptionTests, allowMidThreadPreemption) { + PreemptionFlags flags = {}; + device->setPreemptionMode(PreemptionMode::MidThread); + executionEnvironment->DisableMidThreadPreemption = 0; + PreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), kernel.get()); + EXPECT_TRUE(PreemptionHelper::allowMidThreadPreemption(flags)); +} + +TEST_F(MidThreadPreemptionTests, allowMidThreadPreemptionNullKernel) { + PreemptionFlags flags = {}; + device->setPreemptionMode(PreemptionMode::MidThread); + PreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), nullptr); + EXPECT_TRUE(PreemptionHelper::allowMidThreadPreemption(flags)); +} + +TEST_F(MidThreadPreemptionTests, allowMidThreadPreemptionDeviceSupportPreemptionOnVmeKernel) { + PreemptionFlags flags = {}; + device->setPreemptionMode(PreemptionMode::MidThread); + device->sharedDeviceInfo.vmeAvcSupportsPreemption = true; + kernelInfo->isVmeWorkload = true; + kernel.reset(new MockKernel(program.get(), *kernelInfo, *device)); + PreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), kernel.get()); + EXPECT_TRUE(PreemptionHelper::allowMidThreadPreemption(flags)); +} + +TEST_F(MidThreadPreemptionTests, disallowMidThreadPreemptionByDevice) { + PreemptionFlags flags = {}; + device->setPreemptionMode(PreemptionMode::ThreadGroup); + executionEnvironment->DisableMidThreadPreemption = 0; + PreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), kernel.get()); + EXPECT_TRUE(PreemptionHelper::allowMidThreadPreemption(flags)); + EXPECT_EQ(PreemptionMode::ThreadGroup, PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags)); +} + +TEST_F(MidThreadPreemptionTests, disallowMidThreadPreemptionByKernel) { + PreemptionFlags flags = {}; + device->setPreemptionMode(PreemptionMode::MidThread); + executionEnvironment->DisableMidThreadPreemption = 1; + PreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), kernel.get()); + EXPECT_FALSE(PreemptionHelper::allowMidThreadPreemption(flags)); +} + +TEST_F(MidThreadPreemptionTests, disallowMidThreadPreemptionByVmeKernel) { + PreemptionFlags flags = {}; + device->setPreemptionMode(PreemptionMode::MidThread); + device->sharedDeviceInfo.vmeAvcSupportsPreemption = false; + kernelInfo->isVmeWorkload = true; + kernel.reset(new MockKernel(program.get(), *kernelInfo, *device)); + PreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), kernel.get()); + EXPECT_FALSE(PreemptionHelper::allowMidThreadPreemption(flags)); +} + +TEST_F(MidThreadPreemptionTests, taskPreemptionDisallowMidThreadByDevice) { + PreemptionFlags flags = {}; + executionEnvironment->DisableMidThreadPreemption = 0; + device->setPreemptionMode(PreemptionMode::ThreadGroup); + PreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), kernel.get()); + PreemptionMode outMode = PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags); + EXPECT_EQ(PreemptionMode::ThreadGroup, outMode); +} + +TEST_F(MidThreadPreemptionTests, taskPreemptionDisallowMidThreadByKernel) { + PreemptionFlags flags = {}; + executionEnvironment->DisableMidThreadPreemption = 1; + device->setPreemptionMode(PreemptionMode::MidThread); + PreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), kernel.get()); + PreemptionMode outMode = PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags); + EXPECT_EQ(PreemptionMode::ThreadGroup, outMode); +} + +TEST_F(MidThreadPreemptionTests, taskPreemptionDisallowMidThreadByVmeKernel) { + PreemptionFlags flags = {}; + kernelInfo->isVmeWorkload = true; + device->sharedDeviceInfo.vmeAvcSupportsPreemption = false; + kernel.reset(new MockKernel(program.get(), *kernelInfo, *device)); + device->setPreemptionMode(PreemptionMode::MidThread); + PreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), kernel.get()); + PreemptionMode outMode = PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags); + //VME disables mid thread and thread group when device does not support it + EXPECT_EQ(PreemptionMode::MidBatch, outMode); +} + +TEST_F(MidThreadPreemptionTests, taskPreemptionAllow) { + PreemptionFlags flags = {}; + executionEnvironment->DisableMidThreadPreemption = 0; + device->setPreemptionMode(PreemptionMode::MidThread); + PreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), kernel.get()); + PreemptionMode outMode = PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags); + EXPECT_EQ(PreemptionMode::MidThread, outMode); +} + +TEST_F(MidThreadPreemptionTests, taskPreemptionAllowDeviceSupportsPreemptionOnVmeKernel) { + PreemptionFlags flags = {}; + executionEnvironment->DisableMidThreadPreemption = 0; + kernelInfo->isVmeWorkload = true; + kernel.reset(new MockKernel(program.get(), *kernelInfo, *device)); + device->sharedDeviceInfo.vmeAvcSupportsPreemption = true; + device->setPreemptionMode(PreemptionMode::MidThread); + PreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), kernel.get()); + PreemptionMode outMode = PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags); + EXPECT_EQ(PreemptionMode::MidThread, outMode); +} + +TEST_F(ThreadGroupPreemptionTests, GivenDebugKernelPreemptionWhenDeviceSupportsThreadGroupThenExpectDebugKeyMidThreadValue) { + DebugManager.flags.ForceKernelPreemptionMode.set(static_cast(PreemptionMode::MidThread)); + + EXPECT_EQ(PreemptionMode::ThreadGroup, device->getPreemptionMode()); + + PreemptionFlags flags = {}; + kernel.reset(new MockKernel(program.get(), *kernelInfo, *device)); + PreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), kernel.get()); + PreemptionMode outMode = PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags); + EXPECT_EQ(PreemptionMode::MidThread, outMode); +} + +TEST_F(MidThreadPreemptionTests, GivenDebugKernelPreemptionWhenDeviceSupportsMidThreadThenExpectDebugKeyMidBatchValue) { + DebugManager.flags.ForceKernelPreemptionMode.set(static_cast(PreemptionMode::MidBatch)); + + EXPECT_EQ(PreemptionMode::MidThread, device->getPreemptionMode()); + + PreemptionFlags flags = {}; + kernel.reset(new MockKernel(program.get(), *kernelInfo, *device)); + PreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), kernel.get()); + PreemptionMode outMode = PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags); + EXPECT_EQ(PreemptionMode::MidBatch, outMode); +} diff --git a/shared/test/unit_test/CMakeLists.txt b/shared/test/unit_test/CMakeLists.txt index bde4ec8521..dde00abd5e 100644 --- a/shared/test/unit_test/CMakeLists.txt +++ b/shared/test/unit_test/CMakeLists.txt @@ -44,12 +44,11 @@ if(NOT SKIP_NEO_UNIT_TESTS AND NOT SKIP_UNIT_TESTS) ${CMAKE_CURRENT_SOURCE_DIR}/main.cpp ${CMAKE_CURRENT_SOURCE_DIR}/test_mode.h ${CMAKE_CURRENT_SOURCE_DIR}/tests_configuration.h - ${CMAKE_CURRENT_SOURCE_DIR}/fixtures/device_fixture.cpp - ${CMAKE_CURRENT_SOURCE_DIR}/fixtures/device_fixture.h ${CMAKE_CURRENT_SOURCE_DIR}/mocks/mock_dispatch_kernel_encoder_interface.cpp ${CMAKE_CURRENT_SOURCE_DIR}/mocks/mock_dispatch_kernel_encoder_interface.h ${CORE_ENABLERS} ${NEO_SOURCE_DIR}/opencl/source/compiler_interface/default_cache_config.cpp + ${NEO_SOURCE_DIR}/opencl/test/unit_test/fixtures/mock_execution_environment_gmm_fixture.cpp ${NEO_SOURCE_DIR}/opencl/test/unit_test/global_environment.cpp ${NEO_SOURCE_DIR}/opencl/test/unit_test/helpers/kernel_binary_helper_hash_value.cpp ${NEO_SOURCE_DIR}/opencl/test/unit_test/libult/create_command_stream.cpp @@ -105,6 +104,7 @@ if(NOT SKIP_NEO_UNIT_TESTS AND NOT SKIP_UNIT_TESTS) if(MSVC) set_target_properties(${TARGET_NAME} PROPERTIES VS_DEBUGGER_COMMAND_ARGUMENTS "--gtest_filter=* --gtest_catch_exceptions=0 --enable_default_listener --disable_pagefaulting_tests" + VS_DEBUGGER_WORKING_DIRECTORY "$(OutDir)" ) endif() diff --git a/shared/test/unit_test/direct_submission/dispatchers/render_dispatcher_tests.cpp b/shared/test/unit_test/direct_submission/dispatchers/render_dispatcher_tests.cpp index e902fdb121..88dc4e1f4b 100644 --- a/shared/test/unit_test/direct_submission/dispatchers/render_dispatcher_tests.cpp +++ b/shared/test/unit_test/direct_submission/dispatchers/render_dispatcher_tests.cpp @@ -12,11 +12,11 @@ #include "test.h" -using RenderDispatcheTest = Test; +using RenderDispatcherTest = Test; using namespace NEO; -HWTEST_F(RenderDispatcheTest, givenRenderWhenAskingForPreemptionCmdSizeThenReturnSetMmioCmdSize) { +HWTEST_F(RenderDispatcherTest, givenRenderWhenAskingForPreemptionCmdSizeThenReturnSetMmioCmdSize) { using MI_LOAD_REGISTER_IMM = typename FamilyType::MI_LOAD_REGISTER_IMM; size_t expectedCmdSize = 0u; @@ -26,7 +26,7 @@ HWTEST_F(RenderDispatcheTest, givenRenderWhenAskingForPreemptionCmdSizeThenRetur EXPECT_EQ(expectedCmdSize, RenderDispatcher::getSizePreemption()); } -HWTEST_F(RenderDispatcheTest, givenRenderWhenAddingPreemptionCmdThenExpectProperMmioAddress) { +HWTEST_F(RenderDispatcherTest, givenRenderWhenAddingPreemptionCmdThenExpectProperMmioAddress) { using MI_LOAD_REGISTER_IMM = typename FamilyType::MI_LOAD_REGISTER_IMM; auto preemptionDetails = GetPreemptionTestHwDetails(); @@ -49,13 +49,13 @@ HWTEST_F(RenderDispatcheTest, givenRenderWhenAddingPreemptionCmdThenExpectProper } } -HWTEST_F(RenderDispatcheTest, givenRenderWhenAskingForMonitorFenceCmdSizeThenReturnRequiredPipeControlCmdSize) { +HWTEST_F(RenderDispatcherTest, givenRenderWhenAskingForMonitorFenceCmdSizeThenReturnRequiredPipeControlCmdSize) { size_t expectedSize = MemorySynchronizationCommands::getSizeForPipeControlWithPostSyncOperation(hardwareInfo); EXPECT_EQ(expectedSize, RenderDispatcher::getSizeMonitorFence(hardwareInfo)); } -HWTEST_F(RenderDispatcheTest, givenRenderWhenAddingMonitorFenceCmdThenExpectPipeControlWithProperAddressAndValue) { +HWTEST_F(RenderDispatcherTest, givenRenderWhenAddingMonitorFenceCmdThenExpectPipeControlWithProperAddressAndValue) { using PIPE_CONTROL = typename FamilyType::PIPE_CONTROL; using POST_SYNC_OPERATION = typename FamilyType::PIPE_CONTROL::POST_SYNC_OPERATION; @@ -86,14 +86,14 @@ HWTEST_F(RenderDispatcheTest, givenRenderWhenAddingMonitorFenceCmdThenExpectPipe EXPECT_TRUE(foundMonitorFence); } -HWTEST_F(RenderDispatcheTest, givenRenderWhenAskingForCacheFlushCmdSizeThenReturnSetRequiredPipeControls) { +HWTEST_F(RenderDispatcherTest, givenRenderWhenAskingForCacheFlushCmdSizeThenReturnSetRequiredPipeControls) { size_t expectedSize = MemorySynchronizationCommands::getSizeForFullCacheFlush(); size_t actualSize = RenderDispatcher::getSizeCacheFlush(hardwareInfo); EXPECT_EQ(expectedSize, actualSize); } -HWTEST_F(RenderDispatcheTest, givenRenderWhenAddingCacheFlushCmdThenExpectPipeControlWithProperFields) { +HWTEST_F(RenderDispatcherTest, givenRenderWhenAddingCacheFlushCmdThenExpectPipeControlWithProperFields) { using PIPE_CONTROL = typename FamilyType::PIPE_CONTROL; RenderDispatcher::dispatchCacheFlush(cmdBuffer, hardwareInfo); diff --git a/shared/test/unit_test/direct_submission/linux/CMakeLists.txt b/shared/test/unit_test/direct_submission/linux/CMakeLists.txt index af377f6301..2b6ee439d1 100644 --- a/shared/test/unit_test/direct_submission/linux/CMakeLists.txt +++ b/shared/test/unit_test/direct_submission/linux/CMakeLists.txt @@ -11,4 +11,8 @@ set(NEO_CORE_DIRECT_SUBMISSION_LINUX_TESTS set_property(GLOBAL PROPERTY NEO_CORE_DIRECT_SUBMISSION_LINUX_TESTS ${NEO_CORE_DIRECT_SUBMISSION_LINUX_TESTS}) -add_subdirectories() \ No newline at end of file +if(UNIX) + target_sources(${TARGET_NAME} PRIVATE + ${NEO_CORE_DIRECT_SUBMISSION_LINUX_TESTS} + ) +endif() diff --git a/shared/test/unit_test/direct_submission/linux/drm_direct_submission_tests.cpp b/shared/test/unit_test/direct_submission/linux/drm_direct_submission_tests.cpp index fc31a0c014..42bb9dcb5b 100644 --- a/shared/test/unit_test/direct_submission/linux/drm_direct_submission_tests.cpp +++ b/shared/test/unit_test/direct_submission/linux/drm_direct_submission_tests.cpp @@ -8,23 +8,23 @@ #include "shared/source/direct_submission/dispatchers/render_dispatcher.h" #include "shared/source/direct_submission/linux/drm_direct_submission.h" #include "shared/source/os_interface/linux/os_context_linux.h" +#include "shared/test/unit_test/fixtures/device_fixture.h" -#include "opencl/test/unit_test/fixtures/cl_device_fixture.h" #include "opencl/test/unit_test/os_interface/linux/drm_mock.h" #include "test.h" #include -struct DrmDirectSubmissionFixture : public ClDeviceFixture { +struct DrmDirectSubmissionFixture : public DeviceFixture { void SetUp() { - ClDeviceFixture::SetUp(); + DeviceFixture::SetUp(); osContext = std::make_unique(drmMock, 0u, 0u, aub_stream::ENGINE_RCS, PreemptionMode::ThreadGroup, false, false, false); } void TearDown() { - ClDeviceFixture::TearDown(); + DeviceFixture::TearDown(); } std::unique_ptr osContext; diff --git a/shared/test/unit_test/direct_submission/windows/CMakeLists.txt b/shared/test/unit_test/direct_submission/windows/CMakeLists.txt index b70eba71b8..6ae6fbb5eb 100644 --- a/shared/test/unit_test/direct_submission/windows/CMakeLists.txt +++ b/shared/test/unit_test/direct_submission/windows/CMakeLists.txt @@ -11,4 +11,8 @@ set(NEO_CORE_DIRECT_SUBMISSION_WINDOWS_TESTS set_property(GLOBAL PROPERTY NEO_CORE_DIRECT_SUBMISSION_WINDOWS_TESTS ${NEO_CORE_DIRECT_SUBMISSION_WINDOWS_TESTS}) -add_subdirectories() \ No newline at end of file +if(WIN32) + target_sources(${TARGET_NAME} PRIVATE + ${NEO_CORE_DIRECT_SUBMISSION_WINDOWS_TESTS} + ) +endif() diff --git a/shared/test/unit_test/encoders/CMakeLists.txt b/shared/test/unit_test/encoders/CMakeLists.txt index 68721b1cce..3e1ce632d1 100644 --- a/shared/test/unit_test/encoders/CMakeLists.txt +++ b/shared/test/unit_test/encoders/CMakeLists.txt @@ -4,7 +4,7 @@ # SPDX-License-Identifier: MIT # -set(NEO_CORE_ENCODERS_TESTS +target_sources(${TARGET_NAME} PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt ${CMAKE_CURRENT_SOURCE_DIR}/test_encode_atomic.cpp ${CMAKE_CURRENT_SOURCE_DIR}/test_encode_command_buffer.cpp @@ -16,5 +16,5 @@ set(NEO_CORE_ENCODERS_TESTS ${CMAKE_CURRENT_SOURCE_DIR}/test_encode_set_mmio.cpp ${CMAKE_CURRENT_SOURCE_DIR}/test_encode_states.cpp ) + add_subdirectories() -set_property(GLOBAL PROPERTY NEO_CORE_ENCODERS_TESTS ${NEO_CORE_ENCODERS_TESTS}) diff --git a/shared/test/unit_test/encoders/test_encode_command_buffer.cpp b/shared/test/unit_test/encoders/test_encode_command_buffer.cpp index a0debd303f..90fe11bbb0 100644 --- a/shared/test/unit_test/encoders/test_encode_command_buffer.cpp +++ b/shared/test/unit_test/encoders/test_encode_command_buffer.cpp @@ -8,13 +8,13 @@ #include "shared/source/command_container/cmdcontainer.h" #include "shared/source/command_container/command_encoder.h" #include "shared/test/unit_test/cmd_parse/gen_cmd_parse.h" +#include "shared/test/unit_test/fixtures/device_fixture.h" -#include "opencl/test/unit_test/fixtures/cl_device_fixture.h" #include "test.h" using namespace NEO; -using EncodeBatchBufferStartOrEndTest = Test; +using EncodeBatchBufferStartOrEndTest = Test; HWTEST_F(EncodeBatchBufferStartOrEndTest, givenCommandContainerWhenEncodeBBEndThenCommandIsAdded) { CommandContainer cmdContainer; diff --git a/shared/test/unit_test/encoders/test_encode_math.cpp b/shared/test/unit_test/encoders/test_encode_math.cpp index cbe993aa8a..9362cac1bd 100644 --- a/shared/test/unit_test/encoders/test_encode_math.cpp +++ b/shared/test/unit_test/encoders/test_encode_math.cpp @@ -8,8 +8,8 @@ #include "shared/source/command_container/command_encoder.h" #include "shared/source/helpers/register_offsets.h" #include "shared/test/unit_test/cmd_parse/gen_cmd_parse.h" +#include "shared/test/unit_test/fixtures/device_fixture.h" -#include "opencl/test/unit_test/fixtures/cl_device_fixture.h" #include "test.h" using namespace NEO; @@ -99,7 +99,7 @@ HWTEST_F(EncodeMathMMIOTest, encodeAluSubStoreCarryHasCorrectOpcodesOperands) { EXPECT_EQ(aluParam[4].DW0.Value, 0u); } -using CommandEncoderMathTest = Test; +using CommandEncoderMathTest = Test; HWTEST_F(CommandEncoderMathTest, commandReserve) { using MI_MATH = typename FamilyType::MI_MATH; diff --git a/shared/test/unit_test/encoders/test_encode_set_mmio.cpp b/shared/test/unit_test/encoders/test_encode_set_mmio.cpp index 2d43aebf2c..35b43ebe94 100644 --- a/shared/test/unit_test/encoders/test_encode_set_mmio.cpp +++ b/shared/test/unit_test/encoders/test_encode_set_mmio.cpp @@ -7,22 +7,22 @@ #include "shared/source/command_container/command_encoder.h" #include "shared/test/unit_test/cmd_parse/gen_cmd_parse.h" +#include "shared/test/unit_test/fixtures/device_fixture.h" -#include "opencl/test/unit_test/fixtures/cl_device_fixture.h" #include "test.h" using namespace NEO; -class CommandSetMMIOFixture : public ClDeviceFixture { +class CommandSetMMIOFixture : public DeviceFixture { public: void SetUp() { - ClDeviceFixture::SetUp(); + DeviceFixture::SetUp(); cmdContainer = std::make_unique(); cmdContainer->initialize(pDevice); } void TearDown() { cmdContainer.reset(); - ClDeviceFixture::TearDown(); + DeviceFixture::TearDown(); } std::unique_ptr cmdContainer; }; diff --git a/shared/test/unit_test/fixtures/CMakeLists.txt b/shared/test/unit_test/fixtures/CMakeLists.txt index ad049cfa49..8e56d73622 100644 --- a/shared/test/unit_test/fixtures/CMakeLists.txt +++ b/shared/test/unit_test/fixtures/CMakeLists.txt @@ -4,7 +4,7 @@ # SPDX-License-Identifier: MIT # -set(NEO_CORE_tests_fixtures +target_sources(${TARGET_NAME} PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt ${CMAKE_CURRENT_SOURCE_DIR}/command_container_fixture.h ${CMAKE_CURRENT_SOURCE_DIR}/device_fixture.cpp @@ -12,5 +12,3 @@ set(NEO_CORE_tests_fixtures ${CMAKE_CURRENT_SOURCE_DIR}/preemption_fixture.cpp ${CMAKE_CURRENT_SOURCE_DIR}/preemption_fixture.h ) - -set_property(GLOBAL PROPERTY NEO_CORE_tests_fixtures ${NEO_CORE_tests_fixtures}) diff --git a/shared/test/unit_test/fixtures/preemption_fixture.cpp b/shared/test/unit_test/fixtures/preemption_fixture.cpp index b80d1954f9..39686d1ca1 100644 --- a/shared/test/unit_test/fixtures/preemption_fixture.cpp +++ b/shared/test/unit_test/fixtures/preemption_fixture.cpp @@ -12,13 +12,6 @@ #include "shared/test/unit_test/cmd_parse/hw_parse.h" #include "shared/test/unit_test/mocks/mock_device.h" -#include "opencl/source/command_queue/enqueue_common.h" -#include "opencl/source/command_queue/enqueue_kernel.h" -#include "opencl/source/command_queue/enqueue_marker.h" -#include "opencl/source/helpers/dispatch_info.h" -#include "opencl/source/scheduler/scheduler_kernel.h" -#include "opencl/test/unit_test/fixtures/hello_world_fixture.h" -#include "opencl/test/unit_test/mocks/mock_command_queue.h" #include "opencl/test/unit_test/mocks/mock_context.h" #include "opencl/test/unit_test/mocks/mock_kernel.h" #include "test.h" @@ -34,67 +27,17 @@ void DevicePreemptionTests::SetUp() { if (dbgRestore == nullptr) { dbgRestore.reset(new DebugManagerStateRestore()); } - const cl_queue_properties properties[3] = {CL_QUEUE_PROPERTIES, 0, 0}; - kernelInfo = std::make_unique(); - device = std::make_unique(MockDevice::createWithNewExecutionEnvironment(nullptr)); - context.reset(new MockContext(device.get())); - cmdQ.reset(new MockCommandQueue(context.get(), device.get(), properties)); + + device = std::unique_ptr(MockDevice::createWithNewExecutionEnvironment(nullptr)); executionEnvironment.reset(new SPatchExecutionEnvironment); memset(executionEnvironment.get(), 0, sizeof(SPatchExecutionEnvironment)); - kernelInfo->patchInfo.executionEnvironment = executionEnvironment.get(); program = std::make_unique(*device->getExecutionEnvironment()); - kernel.reset(new MockKernel(program.get(), *kernelInfo, *device)); - dispatchInfo.reset(new DispatchInfo(kernel.get(), 1, Vec3(1, 1, 1), Vec3(1, 1, 1), Vec3(0, 0, 0))); ASSERT_NE(nullptr, device); - ASSERT_NE(nullptr, context); - ASSERT_NE(nullptr, cmdQ); waTable = &device->getRootDeviceEnvironment().getMutableHardwareInfo()->workaroundTable; } void DevicePreemptionTests::TearDown() { dbgRestore.reset(); - kernel.reset(); - kernelInfo.reset(); - dispatchInfo.reset(); - cmdQ.reset(); - context.reset(); - device.reset(); -} - -void ThreadGroupPreemptionEnqueueKernelTest::SetUp() { - dbgRestore.reset(new DebugManagerStateRestore()); - DebugManager.flags.ForcePreemptionMode.set(static_cast(PreemptionMode::ThreadGroup)); - - globalHwInfo = defaultHwInfo.get(); - originalPreemptionMode = globalHwInfo->capabilityTable.defaultPreemptionMode; - globalHwInfo->capabilityTable.defaultPreemptionMode = PreemptionMode::ThreadGroup; - - HelloWorldFixture::SetUp(); - pDevice->setPreemptionMode(PreemptionMode::ThreadGroup); -} - -void ThreadGroupPreemptionEnqueueKernelTest::TearDown() { - globalHwInfo->capabilityTable.defaultPreemptionMode = originalPreemptionMode; - - HelloWorldFixture::TearDown(); -} - -void MidThreadPreemptionEnqueueKernelTest::SetUp() { - dbgRestore.reset(new DebugManagerStateRestore()); - DebugManager.flags.ForcePreemptionMode.set(static_cast(PreemptionMode::MidThread)); - - globalHwInfo = defaultHwInfo.get(); - originalPreemptionMode = globalHwInfo->capabilityTable.defaultPreemptionMode; - globalHwInfo->capabilityTable.defaultPreemptionMode = PreemptionMode::MidThread; - - HelloWorldFixture::SetUp(); - pDevice->setPreemptionMode(PreemptionMode::MidThread); -} - -void MidThreadPreemptionEnqueueKernelTest::TearDown() { - globalHwInfo->capabilityTable.defaultPreemptionMode = originalPreemptionMode; - - HelloWorldFixture::TearDown(); } diff --git a/shared/test/unit_test/fixtures/preemption_fixture.h b/shared/test/unit_test/fixtures/preemption_fixture.h index 624698676d..69504c3ac3 100644 --- a/shared/test/unit_test/fixtures/preemption_fixture.h +++ b/shared/test/unit_test/fixtures/preemption_fixture.h @@ -7,9 +7,9 @@ #pragma once +#include "shared/source/command_stream/preemption_mode.h" #include "shared/test/unit_test/helpers/debug_manager_state_restore.h" -#include "opencl/test/unit_test/fixtures/hello_world_fixture.h" #include "test.h" #include "gtest/gtest.h" @@ -24,17 +24,12 @@ struct SPatchExecutionEnvironment; } namespace NEO { -class DispatchInfo; class MockCommandQueue; class MockContext; class MockDevice; -class MockKernel; class MockProgram; struct KernelInfo; struct WorkaroundTable; - -using PreemptionEnqueueKernelFixture = HelloWorldFixture; -using PreemptionEnqueueKernelTest = Test; } // namespace NEO class DevicePreemptionTests : public ::testing::Test { @@ -47,35 +42,10 @@ class DevicePreemptionTests : public ::testing::Test { NEO::PreemptionMode preemptionMode; NEO::WorkaroundTable *waTable = nullptr; - std::unique_ptr dispatchInfo; - std::unique_ptr kernel; - std::unique_ptr cmdQ; - std::unique_ptr device; - std::unique_ptr context; + std::unique_ptr device; std::unique_ptr dbgRestore; std::unique_ptr executionEnvironment; std::unique_ptr program; - std::unique_ptr kernelInfo; -}; - -struct ThreadGroupPreemptionEnqueueKernelTest : NEO::PreemptionEnqueueKernelTest { - void SetUp() override; - void TearDown() override; - - NEO::HardwareInfo *globalHwInfo; - NEO::PreemptionMode originalPreemptionMode; - - std::unique_ptr dbgRestore; -}; - -struct MidThreadPreemptionEnqueueKernelTest : NEO::PreemptionEnqueueKernelTest { - void SetUp() override; - void TearDown() override; - - NEO::HardwareInfo *globalHwInfo; - NEO::PreemptionMode originalPreemptionMode; - - std::unique_ptr dbgRestore; }; struct PreemptionTestHwDetails { diff --git a/shared/test/unit_test/gen11/CMakeLists.txt b/shared/test/unit_test/gen11/CMakeLists.txt index 414c065b8f..210f7a13a8 100644 --- a/shared/test/unit_test/gen11/CMakeLists.txt +++ b/shared/test/unit_test/gen11/CMakeLists.txt @@ -8,20 +8,17 @@ if(TESTS_GEN11) set(NEO_CORE_TESTS_GEN11 ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt - ${CMAKE_CURRENT_SOURCE_DIR}/image_surface_state_tests_gen11.cpp ${CMAKE_CURRENT_SOURCE_DIR}/preamble_tests_gen11.cpp - ${CMAKE_CURRENT_SOURCE_DIR}/preemption_test_hw_details_gen11.h ${CMAKE_CURRENT_SOURCE_DIR}/simd_helper_tests_gen11.cpp ${CMAKE_CURRENT_SOURCE_DIR}/test_preamble_gen11.cpp - ${CMAKE_CURRENT_SOURCE_DIR}/test_preemption_gen11.cpp ) set_property(GLOBAL PROPERTY NEO_CORE_TESTS_GEN11 ${NEO_CORE_TESTS_GEN11}) add_subdirectories() target_sources(${TARGET_NAME} PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt - ${CMAKE_CURRENT_SOURCE_DIR}/gen11.cpp - ${CMAKE_CURRENT_SOURCE_DIR}/preemption_test_hw_details_gen11.h + ${CMAKE_CURRENT_SOURCE_DIR}/image_surface_state_tests_gen11.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/test_preemption_gen11.cpp ${COMPUTE_RUNTIME_ULT_GEN11} ${NEO_SOURCE_DIR}/opencl/test/unit_test/gen11/unit_test_helper_gen11.cpp ) diff --git a/shared/test/unit_test/gen11/gen11.cpp b/shared/test/unit_test/gen11/gen11.cpp deleted file mode 100644 index fd6fe142b4..0000000000 --- a/shared/test/unit_test/gen11/gen11.cpp +++ /dev/null @@ -1,8 +0,0 @@ -/* - * Copyright (C) 2020 Intel Corporation - * - * SPDX-License-Identifier: MIT - * - */ - -#include "preemption_test_hw_details_gen11.h" diff --git a/shared/test/unit_test/gen11/preemption_test_hw_details_gen11.h b/shared/test/unit_test/gen11/preemption_test_hw_details_gen11.h deleted file mode 100644 index a4c2c07434..0000000000 --- a/shared/test/unit_test/gen11/preemption_test_hw_details_gen11.h +++ /dev/null @@ -1,20 +0,0 @@ -/* - * Copyright (C) 2020 Intel Corporation - * - * SPDX-License-Identifier: MIT - * - */ - -#pragma once -#include "shared/test/unit_test/fixtures/preemption_fixture.h" - -template <> -PreemptionTestHwDetails GetPreemptionTestHwDetails() { - PreemptionTestHwDetails ret; - ret.modeToRegValueMap[PreemptionMode::ThreadGroup] = DwordBuilder::build(1, true) | DwordBuilder::build(2, true, false); - ret.modeToRegValueMap[PreemptionMode::MidBatch] = DwordBuilder::build(2, true) | DwordBuilder::build(1, true, false); - ret.modeToRegValueMap[PreemptionMode::MidThread] = DwordBuilder::build(2, true, false) | DwordBuilder::build(1, true, false); - ret.defaultRegValue = ret.modeToRegValueMap[PreemptionMode::MidBatch]; - ret.regAddress = 0x2580u; - return ret; -} diff --git a/shared/test/unit_test/gen11/test_preemption_gen11.cpp b/shared/test/unit_test/gen11/test_preemption_gen11.cpp index 463550664a..467725b155 100644 --- a/shared/test/unit_test/gen11/test_preemption_gen11.cpp +++ b/shared/test/unit_test/gen11/test_preemption_gen11.cpp @@ -10,21 +10,31 @@ #include "shared/source/helpers/hw_helper.h" #include "shared/test/unit_test/cmd_parse/hw_parse.h" #include "shared/test/unit_test/fixtures/preemption_fixture.h" - -#include "preemption_test_hw_details_gen11.h" +#include "shared/test/unit_test/mocks/mock_device.h" using namespace NEO; +template <> +PreemptionTestHwDetails GetPreemptionTestHwDetails() { + PreemptionTestHwDetails ret; + ret.modeToRegValueMap[PreemptionMode::ThreadGroup] = DwordBuilder::build(1, true) | DwordBuilder::build(2, true, false); + ret.modeToRegValueMap[PreemptionMode::MidBatch] = DwordBuilder::build(2, true) | DwordBuilder::build(1, true, false); + ret.modeToRegValueMap[PreemptionMode::MidThread] = DwordBuilder::build(2, true, false) | DwordBuilder::build(1, true, false); + ret.defaultRegValue = ret.modeToRegValueMap[PreemptionMode::MidBatch]; + ret.regAddress = 0x2580u; + return ret; +} + using Gen11PreemptionTests = DevicePreemptionTests; GEN11TEST_F(Gen11PreemptionTests, whenMidThreadPreemptionIsNotAvailableThenDoesNotProgramStateSip) { device->setPreemptionMode(PreemptionMode::ThreadGroup); - size_t requiredSize = PreemptionHelper::getRequiredPreambleSize(device->getDevice()); + size_t requiredSize = PreemptionHelper::getRequiredPreambleSize(*device); EXPECT_EQ(0U, requiredSize); LinearStream cmdStream{nullptr, 0}; - PreemptionHelper::getRequiredStateSipCmdSize(device->getDevice()); + PreemptionHelper::getRequiredStateSipCmdSize(*device); EXPECT_EQ(0U, cmdStream.getUsed()); } @@ -34,7 +44,7 @@ GEN11TEST_F(Gen11PreemptionTests, whenMidThreadPreemptionIsAvailableThenStateSip device->setPreemptionMode(PreemptionMode::MidThread); executionEnvironment->DisableMidThreadPreemption = 0; - size_t requiredCmdStreamSize = PreemptionHelper::getRequiredStateSipCmdSize(device->getDevice()); + size_t requiredCmdStreamSize = PreemptionHelper::getRequiredStateSipCmdSize(*device); size_t expectedPreambleSize = sizeof(STATE_SIP); EXPECT_EQ(expectedPreambleSize, requiredCmdStreamSize); @@ -42,19 +52,19 @@ GEN11TEST_F(Gen11PreemptionTests, whenMidThreadPreemptionIsAvailableThenStateSip ASSERT_LE(requiredCmdStreamSize, streamStorage.size()); LinearStream cmdStream{streamStorage.begin(), streamStorage.size()}; - PreemptionHelper::programStateSip(cmdStream, device->getDevice()); + PreemptionHelper::programStateSip(cmdStream, *device); HardwareParse hwParsePreamble; hwParsePreamble.parseCommands(cmdStream); auto stateSipCmd = hwParsePreamble.getCommand(); ASSERT_NE(nullptr, stateSipCmd); - EXPECT_EQ(device->getBuiltIns()->getSipKernel(SipKernelType::Csr, device->getDevice()).getSipAllocation()->getGpuAddressToPatch(), stateSipCmd->getSystemInstructionPointer()); + EXPECT_EQ(device->getBuiltIns()->getSipKernel(SipKernelType::Csr, *device).getSipAllocation()->getGpuAddressToPatch(), stateSipCmd->getSystemInstructionPointer()); } GEN11TEST_F(Gen11PreemptionTests, getRequiredCmdQSize) { size_t expectedSize = 0; - EXPECT_EQ(expectedSize, PreemptionHelper::getPreemptionWaCsSize(device->getDevice())); + EXPECT_EQ(expectedSize, PreemptionHelper::getPreemptionWaCsSize(*device)); } GEN11TEST_F(Gen11PreemptionTests, applyPreemptionWaCmds) { @@ -62,9 +72,9 @@ GEN11TEST_F(Gen11PreemptionTests, applyPreemptionWaCmds) { StackVec streamStorage(1024); LinearStream cmdStream{streamStorage.begin(), streamStorage.size()}; - PreemptionHelper::applyPreemptionWaCmdsBegin(&cmdStream, device->getDevice()); + PreemptionHelper::applyPreemptionWaCmdsBegin(&cmdStream, *device); EXPECT_EQ(usedSize, cmdStream.getUsed()); - PreemptionHelper::applyPreemptionWaCmdsEnd(&cmdStream, device->getDevice()); + PreemptionHelper::applyPreemptionWaCmdsEnd(&cmdStream, *device); EXPECT_EQ(usedSize, cmdStream.getUsed()); } diff --git a/shared/test/unit_test/gen12lp/CMakeLists.txt b/shared/test/unit_test/gen12lp/CMakeLists.txt index 6afd4e8c9a..d5a6982723 100644 --- a/shared/test/unit_test/gen12lp/CMakeLists.txt +++ b/shared/test/unit_test/gen12lp/CMakeLists.txt @@ -8,20 +8,17 @@ if(TESTS_GEN12LP) set(NEO_CORE_TESTS_GEN12LP ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt - ${CMAKE_CURRENT_SOURCE_DIR}/image_surface_state_tests_gen12lp.cpp - ${CMAKE_CURRENT_SOURCE_DIR}/preemption_test_hw_details_gen12lp.h ${CMAKE_CURRENT_SOURCE_DIR}/simd_helper_tests_gen12lp.cpp ${CMAKE_CURRENT_SOURCE_DIR}/test_preamble_gen12lp.cpp ${CMAKE_CURRENT_SOURCE_DIR}/test_command_encoder_gen12lp.cpp - ${CMAKE_CURRENT_SOURCE_DIR}/test_preemption_gen12lp.inl ) set_property(GLOBAL PROPERTY NEO_CORE_TESTS_GEN12LP ${NEO_CORE_TESTS_GEN12LP}) add_subdirectories() target_sources(${TARGET_NAME} PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt - ${CMAKE_CURRENT_SOURCE_DIR}/gen12lp.cpp - ${CMAKE_CURRENT_SOURCE_DIR}/preemption_test_hw_details_gen12lp.h + ${CMAKE_CURRENT_SOURCE_DIR}/image_surface_state_tests_gen12lp.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/test_preemption_gen12lp.cpp ${COMPUTE_RUNTIME_ULT_GEN12LP} ${NEO_SOURCE_DIR}/opencl/test/unit_test/gen12lp/special_ult_helper_gen12lp.cpp ${NEO_SOURCE_DIR}/opencl/test/unit_test/gen12lp/unit_test_helper_gen12lp.cpp diff --git a/shared/test/unit_test/gen12lp/gen12lp.cpp b/shared/test/unit_test/gen12lp/gen12lp.cpp deleted file mode 100644 index 62a7d466bc..0000000000 --- a/shared/test/unit_test/gen12lp/gen12lp.cpp +++ /dev/null @@ -1,8 +0,0 @@ -/* - * Copyright (C) 2020 Intel Corporation - * - * SPDX-License-Identifier: MIT - * - */ - -#include "preemption_test_hw_details_gen12lp.h" diff --git a/shared/test/unit_test/gen12lp/preemption_test_hw_details_gen12lp.h b/shared/test/unit_test/gen12lp/preemption_test_hw_details_gen12lp.h deleted file mode 100644 index 9b91b19ce9..0000000000 --- a/shared/test/unit_test/gen12lp/preemption_test_hw_details_gen12lp.h +++ /dev/null @@ -1,20 +0,0 @@ -/* - * Copyright (C) 2020 Intel Corporation - * - * SPDX-License-Identifier: MIT - * - */ - -#pragma once -#include "shared/test/unit_test/fixtures/preemption_fixture.h" - -template <> -PreemptionTestHwDetails GetPreemptionTestHwDetails() { - PreemptionTestHwDetails ret; - ret.modeToRegValueMap[PreemptionMode::ThreadGroup] = DwordBuilder::build(1, true) | DwordBuilder::build(2, true, false); - ret.modeToRegValueMap[PreemptionMode::MidBatch] = DwordBuilder::build(2, true) | DwordBuilder::build(1, true, false); - ret.modeToRegValueMap[PreemptionMode::MidThread] = DwordBuilder::build(2, true, false) | DwordBuilder::build(1, true, false); - ret.defaultRegValue = ret.modeToRegValueMap[PreemptionMode::MidBatch]; - ret.regAddress = 0x2580u; - return ret; -} diff --git a/shared/test/unit_test/gen12lp/test_preemption_gen12lp.inl b/shared/test/unit_test/gen12lp/test_preemption_gen12lp.cpp similarity index 81% rename from shared/test/unit_test/gen12lp/test_preemption_gen12lp.inl rename to shared/test/unit_test/gen12lp/test_preemption_gen12lp.cpp index 966f407787..e5bfea59ff 100644 --- a/shared/test/unit_test/gen12lp/test_preemption_gen12lp.inl +++ b/shared/test/unit_test/gen12lp/test_preemption_gen12lp.cpp @@ -6,27 +6,38 @@ */ #include "shared/source/command_stream/preemption.h" +#include "shared/source/helpers/hw_helper.h" #include "shared/test/unit_test/cmd_parse/gen_cmd_parse.h" #include "shared/test/unit_test/fixtures/preemption_fixture.h" - -#include "preemption_test_hw_details_gen12lp.h" +#include "shared/test/unit_test/mocks/mock_device.h" using namespace NEO; +template <> +PreemptionTestHwDetails GetPreemptionTestHwDetails() { + PreemptionTestHwDetails ret; + ret.modeToRegValueMap[PreemptionMode::ThreadGroup] = DwordBuilder::build(1, true) | DwordBuilder::build(2, true, false); + ret.modeToRegValueMap[PreemptionMode::MidBatch] = DwordBuilder::build(2, true) | DwordBuilder::build(1, true, false); + ret.modeToRegValueMap[PreemptionMode::MidThread] = DwordBuilder::build(2, true, false) | DwordBuilder::build(1, true, false); + ret.defaultRegValue = ret.modeToRegValueMap[PreemptionMode::MidBatch]; + ret.regAddress = 0x2580u; + return ret; +} + using Gen12LpPreemptionTests = DevicePreemptionTests; GEN12LPTEST_F(Gen12LpPreemptionTests, whenProgramStateSipIsCalledThenStateSipCmdIsNotAddedToStream) { - size_t requiredSize = PreemptionHelper::getRequiredStateSipCmdSize(device->getDevice()); + size_t requiredSize = PreemptionHelper::getRequiredStateSipCmdSize(*device); EXPECT_EQ(0U, requiredSize); LinearStream cmdStream{nullptr, 0}; - PreemptionHelper::programStateSip(cmdStream, device->getDevice()); + PreemptionHelper::programStateSip(cmdStream, *device); EXPECT_EQ(0U, cmdStream.getUsed()); } GEN12LPTEST_F(Gen12LpPreemptionTests, getRequiredCmdQSize) { size_t expectedSize = 0; - EXPECT_EQ(expectedSize, PreemptionHelper::getPreemptionWaCsSize(device->getDevice())); + EXPECT_EQ(expectedSize, PreemptionHelper::getPreemptionWaCsSize(*device)); } GEN12LPTEST_F(Gen12LpPreemptionTests, applyPreemptionWaCmds) { @@ -34,9 +45,9 @@ GEN12LPTEST_F(Gen12LpPreemptionTests, applyPreemptionWaCmds) { StackVec streamStorage(1024); LinearStream cmdStream{streamStorage.begin(), streamStorage.size()}; - PreemptionHelper::applyPreemptionWaCmdsBegin(&cmdStream, device->getDevice()); + PreemptionHelper::applyPreemptionWaCmdsBegin(&cmdStream, *device); EXPECT_EQ(usedSize, cmdStream.getUsed()); - PreemptionHelper::applyPreemptionWaCmdsEnd(&cmdStream, device->getDevice()); + PreemptionHelper::applyPreemptionWaCmdsEnd(&cmdStream, *device); EXPECT_EQ(usedSize, cmdStream.getUsed()); } diff --git a/shared/test/unit_test/gen8/CMakeLists.txt b/shared/test/unit_test/gen8/CMakeLists.txt index 0a6a2961dd..d9f68da009 100644 --- a/shared/test/unit_test/gen8/CMakeLists.txt +++ b/shared/test/unit_test/gen8/CMakeLists.txt @@ -8,20 +8,17 @@ if(TESTS_GEN8) set(NEO_CORE_TESTS_GEN8 ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt - ${CMAKE_CURRENT_SOURCE_DIR}/image_surface_state_tests_gen8.cpp - ${CMAKE_CURRENT_SOURCE_DIR}/preemption_test_hw_details_gen8.h ${CMAKE_CURRENT_SOURCE_DIR}/simd_helper_tests_gen8.cpp ${CMAKE_CURRENT_SOURCE_DIR}/state_base_address_tests_gen8.cpp ${CMAKE_CURRENT_SOURCE_DIR}/test_preamble_gen8.cpp - ${CMAKE_CURRENT_SOURCE_DIR}/test_preemption_gen8.cpp ) set_property(GLOBAL PROPERTY NEO_CORE_TESTS_GEN8 ${NEO_CORE_TESTS_GEN8}) add_subdirectories() target_sources(${TARGET_NAME} PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt - ${CMAKE_CURRENT_SOURCE_DIR}/gen8.cpp - ${CMAKE_CURRENT_SOURCE_DIR}/preemption_test_hw_details_gen8.h + ${CMAKE_CURRENT_SOURCE_DIR}/image_surface_state_tests_gen8.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/test_preemption_gen8.cpp ${COMPUTE_RUNTIME_ULT_GEN8} ${NEO_SOURCE_DIR}/opencl/test/unit_test/gen8/unit_test_helper_gen8.cpp ) diff --git a/shared/test/unit_test/gen8/gen8.cpp b/shared/test/unit_test/gen8/gen8.cpp deleted file mode 100644 index 49032ffa01..0000000000 --- a/shared/test/unit_test/gen8/gen8.cpp +++ /dev/null @@ -1,8 +0,0 @@ -/* - * Copyright (C) 2020 Intel Corporation - * - * SPDX-License-Identifier: MIT - * - */ - -#include "preemption_test_hw_details_gen8.h" diff --git a/shared/test/unit_test/gen8/preemption_test_hw_details_gen8.h b/shared/test/unit_test/gen8/preemption_test_hw_details_gen8.h deleted file mode 100644 index dfa9ccb73d..0000000000 --- a/shared/test/unit_test/gen8/preemption_test_hw_details_gen8.h +++ /dev/null @@ -1,19 +0,0 @@ -/* - * Copyright (C) 2020 Intel Corporation - * - * SPDX-License-Identifier: MIT - * - */ - -#pragma once -#include "shared/test/unit_test/fixtures/preemption_fixture.h" - -template <> -PreemptionTestHwDetails GetPreemptionTestHwDetails() { - PreemptionTestHwDetails ret; - ret.modeToRegValueMap[PreemptionMode::ThreadGroup] = 0; - ret.modeToRegValueMap[PreemptionMode::MidBatch] = (1 << 2); - ret.defaultRegValue = ret.modeToRegValueMap[PreemptionMode::MidBatch]; - ret.regAddress = 0x2248u; - return ret; -} diff --git a/shared/test/unit_test/gen8/test_preemption_gen8.cpp b/shared/test/unit_test/gen8/test_preemption_gen8.cpp index b95b1e6bd6..c8e3dea7b0 100644 --- a/shared/test/unit_test/gen8/test_preemption_gen8.cpp +++ b/shared/test/unit_test/gen8/test_preemption_gen8.cpp @@ -11,119 +11,35 @@ #include "shared/source/helpers/hw_helper.h" #include "shared/test/unit_test/cmd_parse/hw_parse.h" #include "shared/test/unit_test/fixtures/preemption_fixture.h" -#include "shared/test/unit_test/mocks/mock_command_stream_receiver.h" - -#include "opencl/test/unit_test/command_queue/enqueue_fixture.h" -#include "opencl/test/unit_test/fixtures/hello_world_fixture.h" -#include "opencl/test/unit_test/libult/ult_command_stream_receiver.h" - -#include "preemption_test_hw_details_gen8.h" +#include "shared/test/unit_test/mocks/mock_device.h" using namespace NEO; -using Gen8PreemptionTests = DevicePreemptionTests; -using Gen8PreemptionEnqueueKernelTest = PreemptionEnqueueKernelTest; - -GEN8TEST_F(Gen8PreemptionTests, allowThreadGroupPreemptionReturnsTrue) { - PreemptionFlags flags = {}; - PreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), kernel.get()); - EXPECT_TRUE(PreemptionHelper::allowThreadGroupPreemption(flags)); +template <> +PreemptionTestHwDetails GetPreemptionTestHwDetails() { + PreemptionTestHwDetails ret; + ret.modeToRegValueMap[PreemptionMode::ThreadGroup] = 0; + ret.modeToRegValueMap[PreemptionMode::MidBatch] = (1 << 2); + ret.defaultRegValue = ret.modeToRegValueMap[PreemptionMode::MidBatch]; + ret.regAddress = 0x2248u; + return ret; } +using Gen8PreemptionTests = DevicePreemptionTests; + GEN8TEST_F(Gen8PreemptionTests, whenProgramStateSipIsCalledThenNoCmdsAreProgrammed) { - size_t requiredSize = PreemptionHelper::getRequiredStateSipCmdSize(device->getDevice()); + size_t requiredSize = PreemptionHelper::getRequiredStateSipCmdSize(*device); EXPECT_EQ(0U, requiredSize); LinearStream cmdStream{nullptr, 0}; - PreemptionHelper::programStateSip(cmdStream, device->getDevice()); + PreemptionHelper::programStateSip(cmdStream, *device); EXPECT_EQ(0U, cmdStream.getUsed()); } -GEN8TEST_F(Gen8PreemptionEnqueueKernelTest, givenSecondEnqueueWithTheSamePreemptionRequestThenDontReprogram) { - pDevice->setPreemptionMode(PreemptionMode::ThreadGroup); - auto &csr = pDevice->getUltCommandStreamReceiver(); - csr.getMemoryManager()->setForce32BitAllocations(false); - csr.setMediaVFEStateDirty(false); - size_t off[3] = {0, 0, 0}; - size_t gws[3] = {1, 1, 1}; - - MockKernelWithInternals mockKernel(*pClDevice); - - HardwareParse hwParser; - pCmdQ->enqueueKernel(mockKernel.mockKernel, 1, off, gws, nullptr, 0, nullptr, nullptr); - hwParser.parseCommands(csr.commandStream); - auto offset = csr.commandStream.getUsed(); - pCmdQ->enqueueKernel(mockKernel.mockKernel, 1, off, gws, nullptr, 0, nullptr, nullptr); - pCmdQ->flush(); - hwParser.parseCommands(csr.commandStream, offset); - - size_t numMmiosFound = countMmio(hwParser.cmdList.begin(), hwParser.cmdList.end(), 0x2248u); - EXPECT_EQ(1U, numMmiosFound); -} - -GEN8TEST_F(Gen8PreemptionEnqueueKernelTest, givenValidKernelForPreemptionWhenEnqueueKernelCalledThenPassDevicePreemptionMode) { - pDevice->setPreemptionMode(PreemptionMode::ThreadGroup); - auto mockCsr = new MockCsrHw2(*pDevice->executionEnvironment, pDevice->getRootDeviceIndex()); - pDevice->resetCommandStreamReceiver(mockCsr); - - MockKernelWithInternals mockKernel(*pClDevice); - PreemptionFlags flags = {}; - MultiDispatchInfo multiDispatch(mockKernel.mockKernel); - EXPECT_EQ(PreemptionMode::ThreadGroup, PreemptionHelper::taskPreemptionMode(*pDevice, multiDispatch)); - - size_t gws[3] = {1, 0, 0}; - pCmdQ->enqueueKernel(mockKernel.mockKernel, 1, nullptr, gws, nullptr, 0, nullptr, nullptr); - pCmdQ->flush(); - - EXPECT_EQ(1, mockCsr->flushCalledCount); - EXPECT_EQ(PreemptionMode::ThreadGroup, mockCsr->passedDispatchFlags.preemptionMode); -} - -GEN8TEST_F(Gen8PreemptionEnqueueKernelTest, givenValidKernelForPreemptionWhenEnqueueKernelCalledAndBlockedThenPassDevicePreemptionMode) { - pDevice->setPreemptionMode(PreemptionMode::ThreadGroup); - auto mockCsr = new MockCsrHw2(*pDevice->executionEnvironment, pDevice->getRootDeviceIndex()); - pDevice->resetCommandStreamReceiver(mockCsr); - - MockKernelWithInternals mockKernel(*pClDevice); - PreemptionFlags flags = {}; - PreemptionHelper::setPreemptionLevelFlags(flags, *pDevice, mockKernel.mockKernel); - EXPECT_EQ(PreemptionMode::ThreadGroup, PreemptionHelper::taskPreemptionMode(pDevice->getPreemptionMode(), flags)); - - UserEvent userEventObj; - cl_event userEvent = &userEventObj; - size_t gws[3] = {1, 0, 0}; - pCmdQ->enqueueKernel(mockKernel.mockKernel, 1, nullptr, gws, nullptr, 1, &userEvent, nullptr); - pCmdQ->flush(); - EXPECT_EQ(0, mockCsr->flushCalledCount); - - userEventObj.setStatus(CL_COMPLETE); - pCmdQ->flush(); - EXPECT_EQ(1, mockCsr->flushCalledCount); - EXPECT_EQ(PreemptionMode::ThreadGroup, mockCsr->passedDispatchFlags.preemptionMode); -} - -GEN8TEST_F(Gen8PreemptionEnqueueKernelTest, givenDisabledPreemptionWhenEnqueueKernelCalledThenPassDisabledPreemptionMode) { - pDevice->setPreemptionMode(PreemptionMode::Disabled); - auto mockCsr = new MockCsrHw2(*pDevice->executionEnvironment, pDevice->getRootDeviceIndex()); - pDevice->resetCommandStreamReceiver(mockCsr); - - MockKernelWithInternals mockKernel(*pClDevice); - PreemptionFlags flags = {}; - PreemptionHelper::setPreemptionLevelFlags(flags, *pDevice, mockKernel.mockKernel); - EXPECT_EQ(PreemptionMode::Disabled, PreemptionHelper::taskPreemptionMode(pDevice->getPreemptionMode(), flags)); - - size_t gws[3] = {1, 0, 0}; - pCmdQ->enqueueKernel(mockKernel.mockKernel, 1, nullptr, gws, nullptr, 0, nullptr, nullptr); - pCmdQ->flush(); - - EXPECT_EQ(1, mockCsr->flushCalledCount); - EXPECT_EQ(PreemptionMode::Disabled, mockCsr->passedDispatchFlags.preemptionMode); -} - GEN8TEST_F(Gen8PreemptionTests, getPreemptionWaCsSizeMidBatch) { size_t expectedSize = 0; device->setPreemptionMode(PreemptionMode::MidBatch); - size_t size = PreemptionHelper::getPreemptionWaCsSize(device->getDevice()); + size_t size = PreemptionHelper::getPreemptionWaCsSize(*device); EXPECT_EQ(expectedSize, size); } @@ -131,7 +47,7 @@ GEN8TEST_F(Gen8PreemptionTests, getPreemptionWaCsSizeThreadGroupNoWa) { size_t expectedSize = 0; device->setPreemptionMode(PreemptionMode::ThreadGroup); device->getRootDeviceEnvironment().getMutableHardwareInfo()->workaroundTable.waModifyVFEStateAfterGPGPUPreemption = false; - size_t size = PreemptionHelper::getPreemptionWaCsSize(device->getDevice()); + size_t size = PreemptionHelper::getPreemptionWaCsSize(*device); EXPECT_EQ(expectedSize, size); } @@ -140,7 +56,7 @@ GEN8TEST_F(Gen8PreemptionTests, getPreemptionWaCsSizeThreadGroupWa) { size_t expectedSize = 2 * sizeof(MI_LOAD_REGISTER_IMM); device->setPreemptionMode(PreemptionMode::ThreadGroup); device->getRootDeviceEnvironment().getMutableHardwareInfo()->workaroundTable.waModifyVFEStateAfterGPGPUPreemption = true; - size_t size = PreemptionHelper::getPreemptionWaCsSize(device->getDevice()); + size_t size = PreemptionHelper::getPreemptionWaCsSize(*device); EXPECT_EQ(expectedSize, size); } @@ -148,7 +64,7 @@ GEN8TEST_F(Gen8PreemptionTests, getPreemptionWaCsSizeMidThreadNoWa) { size_t expectedSize = 0; device->setPreemptionMode(PreemptionMode::MidThread); device->getRootDeviceEnvironment().getMutableHardwareInfo()->workaroundTable.waModifyVFEStateAfterGPGPUPreemption = false; - size_t size = PreemptionHelper::getPreemptionWaCsSize(device->getDevice()); + size_t size = PreemptionHelper::getPreemptionWaCsSize(*device); EXPECT_EQ(expectedSize, size); } @@ -157,7 +73,7 @@ GEN8TEST_F(Gen8PreemptionTests, getPreemptionWaCsSizeMidThreadWa) { size_t expectedSize = 2 * sizeof(MI_LOAD_REGISTER_IMM); device->setPreemptionMode(PreemptionMode::MidThread); device->getRootDeviceEnvironment().getMutableHardwareInfo()->workaroundTable.waModifyVFEStateAfterGPGPUPreemption = true; - size_t size = PreemptionHelper::getPreemptionWaCsSize(device->getDevice()); + size_t size = PreemptionHelper::getPreemptionWaCsSize(*device); EXPECT_EQ(expectedSize, size); } @@ -207,27 +123,27 @@ struct Gen8PreemptionTestsLinearStream : public Gen8PreemptionTests { GEN8TEST_F(Gen8PreemptionTestsLinearStream, givenMidBatchPreemptionWhenProgrammingWaCmdsBeginThenExpectNoCmds) { device->setPreemptionMode(PreemptionMode::MidBatch); - PreemptionHelper::applyPreemptionWaCmdsBegin(&cmdBuffer, device->getDevice()); + PreemptionHelper::applyPreemptionWaCmdsBegin(&cmdBuffer, *device); EXPECT_EQ(0u, cmdBuffer.getUsed()); } GEN8TEST_F(Gen8PreemptionTestsLinearStream, givenMidBatchPreemptionWhenProgrammingWaCmdsEndThenExpectNoCmds) { device->setPreemptionMode(PreemptionMode::MidBatch); - PreemptionHelper::applyPreemptionWaCmdsEnd(&cmdBuffer, device->getDevice()); + PreemptionHelper::applyPreemptionWaCmdsEnd(&cmdBuffer, *device); EXPECT_EQ(0u, cmdBuffer.getUsed()); } GEN8TEST_F(Gen8PreemptionTestsLinearStream, givenThreadGroupPreemptionNoWaSetWhenProgrammingWaCmdsBeginThenExpectNoCmd) { device->setPreemptionMode(PreemptionMode::ThreadGroup); device->getRootDeviceEnvironment().getMutableHardwareInfo()->workaroundTable.waModifyVFEStateAfterGPGPUPreemption = false; - PreemptionHelper::applyPreemptionWaCmdsBegin(&cmdBuffer, device->getDevice()); + PreemptionHelper::applyPreemptionWaCmdsBegin(&cmdBuffer, *device); EXPECT_EQ(0u, cmdBuffer.getUsed()); } GEN8TEST_F(Gen8PreemptionTestsLinearStream, givenThreadGroupPreemptionNoWaSetWhenProgrammingWaCmdsEndThenExpectNoCmd) { device->setPreemptionMode(PreemptionMode::ThreadGroup); device->getRootDeviceEnvironment().getMutableHardwareInfo()->workaroundTable.waModifyVFEStateAfterGPGPUPreemption = false; - PreemptionHelper::applyPreemptionWaCmdsEnd(&cmdBuffer, device->getDevice()); + PreemptionHelper::applyPreemptionWaCmdsEnd(&cmdBuffer, *device); EXPECT_EQ(0u, cmdBuffer.getUsed()); } @@ -235,7 +151,7 @@ GEN8TEST_F(Gen8PreemptionTestsLinearStream, givenThreadGroupPreemptionWaSetWhenP using MI_LOAD_REGISTER_IMM = typename FamilyType::MI_LOAD_REGISTER_IMM; device->setPreemptionMode(PreemptionMode::ThreadGroup); device->getRootDeviceEnvironment().getMutableHardwareInfo()->workaroundTable.waModifyVFEStateAfterGPGPUPreemption = true; - PreemptionHelper::applyPreemptionWaCmdsBegin(&cmdBuffer, device->getDevice()); + PreemptionHelper::applyPreemptionWaCmdsBegin(&cmdBuffer, *device); cmdBufferParser.parseCommands(cmdBuffer); cmdBufferParser.findHardwareCommands(); @@ -250,7 +166,7 @@ GEN8TEST_F(Gen8PreemptionTestsLinearStream, givenThreadGroupPreemptionWaSetWhenP using MI_LOAD_REGISTER_IMM = typename FamilyType::MI_LOAD_REGISTER_IMM; device->setPreemptionMode(PreemptionMode::ThreadGroup); device->getRootDeviceEnvironment().getMutableHardwareInfo()->workaroundTable.waModifyVFEStateAfterGPGPUPreemption = true; - PreemptionHelper::applyPreemptionWaCmdsEnd(&cmdBuffer, device->getDevice()); + PreemptionHelper::applyPreemptionWaCmdsEnd(&cmdBuffer, *device); cmdBufferParser.parseCommands(cmdBuffer); cmdBufferParser.findHardwareCommands(); @@ -264,14 +180,14 @@ GEN8TEST_F(Gen8PreemptionTestsLinearStream, givenThreadGroupPreemptionWaSetWhenP GEN8TEST_F(Gen8PreemptionTestsLinearStream, givenMidThreadPreemptionNoWaSetWhenProgrammingWaCmdsBeginThenExpectNoCmd) { device->setPreemptionMode(PreemptionMode::MidThread); device->getRootDeviceEnvironment().getMutableHardwareInfo()->workaroundTable.waModifyVFEStateAfterGPGPUPreemption = false; - PreemptionHelper::applyPreemptionWaCmdsBegin(&cmdBuffer, device->getDevice()); + PreemptionHelper::applyPreemptionWaCmdsBegin(&cmdBuffer, *device); EXPECT_EQ(0u, cmdBuffer.getUsed()); } GEN8TEST_F(Gen8PreemptionTestsLinearStream, givenMidThreadPreemptionNoWaSetWhenProgrammingWaCmdsEndThenExpectNoCmd) { device->setPreemptionMode(PreemptionMode::MidThread); device->getRootDeviceEnvironment().getMutableHardwareInfo()->workaroundTable.waModifyVFEStateAfterGPGPUPreemption = false; - PreemptionHelper::applyPreemptionWaCmdsEnd(&cmdBuffer, device->getDevice()); + PreemptionHelper::applyPreemptionWaCmdsEnd(&cmdBuffer, *device); EXPECT_EQ(0u, cmdBuffer.getUsed()); } @@ -279,7 +195,7 @@ GEN8TEST_F(Gen8PreemptionTestsLinearStream, givenMidThreadPreemptionWaSetWhenPro using MI_LOAD_REGISTER_IMM = typename FamilyType::MI_LOAD_REGISTER_IMM; device->setPreemptionMode(PreemptionMode::MidThread); device->getRootDeviceEnvironment().getMutableHardwareInfo()->workaroundTable.waModifyVFEStateAfterGPGPUPreemption = true; - PreemptionHelper::applyPreemptionWaCmdsBegin(&cmdBuffer, device->getDevice()); + PreemptionHelper::applyPreemptionWaCmdsBegin(&cmdBuffer, *device); cmdBufferParser.parseCommands(cmdBuffer); cmdBufferParser.findHardwareCommands(); @@ -294,7 +210,7 @@ GEN8TEST_F(Gen8PreemptionTestsLinearStream, givenMidThreadPreemptionWaSetWhenPro using MI_LOAD_REGISTER_IMM = typename FamilyType::MI_LOAD_REGISTER_IMM; device->setPreemptionMode(PreemptionMode::MidThread); device->getRootDeviceEnvironment().getMutableHardwareInfo()->workaroundTable.waModifyVFEStateAfterGPGPUPreemption = true; - PreemptionHelper::applyPreemptionWaCmdsEnd(&cmdBuffer, device->getDevice()); + PreemptionHelper::applyPreemptionWaCmdsEnd(&cmdBuffer, *device); cmdBufferParser.parseCommands(cmdBuffer); cmdBufferParser.findHardwareCommands(); diff --git a/shared/test/unit_test/gen9/CMakeLists.txt b/shared/test/unit_test/gen9/CMakeLists.txt index a86a213f1f..4fa2ff7342 100644 --- a/shared/test/unit_test/gen9/CMakeLists.txt +++ b/shared/test/unit_test/gen9/CMakeLists.txt @@ -8,20 +8,17 @@ if(TESTS_GEN9) set(NEO_CORE_TESTS_GEN9 ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt - ${CMAKE_CURRENT_SOURCE_DIR}/image_surface_state_tests_gen9.cpp ${CMAKE_CURRENT_SOURCE_DIR}/preamble_tests_gen9.cpp - ${CMAKE_CURRENT_SOURCE_DIR}/preemption_test_hw_details_gen9.h ${CMAKE_CURRENT_SOURCE_DIR}/simd_helper_tests_gen9.cpp ${CMAKE_CURRENT_SOURCE_DIR}/test_command_encoder_gen9.cpp - ${CMAKE_CURRENT_SOURCE_DIR}/test_preemption_gen9.cpp ) set_property(GLOBAL PROPERTY NEO_CORE_TESTS_GEN9 ${NEO_CORE_TESTS_GEN9}) add_subdirectories() target_sources(${TARGET_NAME} PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt - ${CMAKE_CURRENT_SOURCE_DIR}/gen9.cpp - ${CMAKE_CURRENT_SOURCE_DIR}/preemption_test_hw_details_gen9.h + ${CMAKE_CURRENT_SOURCE_DIR}/image_surface_state_tests_gen9.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/test_preemption_gen9.cpp ${COMPUTE_RUNTIME_ULT_GEN9} ${NEO_SOURCE_DIR}/opencl/test/unit_test/gen9/unit_test_helper_gen9.cpp ) diff --git a/shared/test/unit_test/gen9/gen9.cpp b/shared/test/unit_test/gen9/gen9.cpp deleted file mode 100644 index f2cbc793ce..0000000000 --- a/shared/test/unit_test/gen9/gen9.cpp +++ /dev/null @@ -1,8 +0,0 @@ -/* - * Copyright (C) 2020 Intel Corporation - * - * SPDX-License-Identifier: MIT - * - */ - -#include "preemption_test_hw_details_gen9.h" diff --git a/shared/test/unit_test/gen9/preemption_test_hw_details_gen9.h b/shared/test/unit_test/gen9/preemption_test_hw_details_gen9.h deleted file mode 100644 index 7e5a20f08f..0000000000 --- a/shared/test/unit_test/gen9/preemption_test_hw_details_gen9.h +++ /dev/null @@ -1,20 +0,0 @@ -/* - * Copyright (C) 2020 Intel Corporation - * - * SPDX-License-Identifier: MIT - * - */ - -#pragma once -#include "shared/test/unit_test/fixtures/preemption_fixture.h" - -template <> -PreemptionTestHwDetails GetPreemptionTestHwDetails() { - PreemptionTestHwDetails ret; - ret.modeToRegValueMap[PreemptionMode::ThreadGroup] = DwordBuilder::build(1, true) | DwordBuilder::build(2, true, false); - ret.modeToRegValueMap[PreemptionMode::MidBatch] = DwordBuilder::build(2, true) | DwordBuilder::build(1, true, false); - ret.modeToRegValueMap[PreemptionMode::MidThread] = DwordBuilder::build(2, true, false) | DwordBuilder::build(1, true, false); - ret.defaultRegValue = ret.modeToRegValueMap[PreemptionMode::MidBatch]; - ret.regAddress = 0x2580u; - return ret; -} diff --git a/shared/test/unit_test/gen9/test_preemption_gen9.cpp b/shared/test/unit_test/gen9/test_preemption_gen9.cpp index 743aee906b..6eeb78aae0 100644 --- a/shared/test/unit_test/gen9/test_preemption_gen9.cpp +++ b/shared/test/unit_test/gen9/test_preemption_gen9.cpp @@ -11,40 +11,33 @@ #include "shared/test/unit_test/cmd_parse/hw_parse.h" #include "shared/test/unit_test/fixtures/preemption_fixture.h" #include "shared/test/unit_test/mocks/mock_command_stream_receiver.h" +#include "shared/test/unit_test/mocks/mock_device.h" -#include "opencl/test/unit_test/command_queue/enqueue_fixture.h" -#include "opencl/test/unit_test/libult/ult_command_stream_receiver.h" #include "opencl/test/unit_test/mocks/mock_graphics_allocation.h" -#include "preemption_test_hw_details_gen9.h" - -namespace NEO { - -template <> -void HardwareParse::findCsrBaseAddress() { - typedef typename GEN9::GPGPU_CSR_BASE_ADDRESS GPGPU_CSR_BASE_ADDRESS; - itorGpgpuCsrBaseAddress = find(cmdList.begin(), itorWalker); - if (itorGpgpuCsrBaseAddress != itorWalker) { - cmdGpgpuCsrBaseAddress = *itorGpgpuCsrBaseAddress; - } -} -} // namespace NEO - using namespace NEO; +template <> +PreemptionTestHwDetails GetPreemptionTestHwDetails() { + PreemptionTestHwDetails ret; + ret.modeToRegValueMap[PreemptionMode::ThreadGroup] = DwordBuilder::build(1, true) | DwordBuilder::build(2, true, false); + ret.modeToRegValueMap[PreemptionMode::MidBatch] = DwordBuilder::build(2, true) | DwordBuilder::build(1, true, false); + ret.modeToRegValueMap[PreemptionMode::MidThread] = DwordBuilder::build(2, true, false) | DwordBuilder::build(1, true, false); + ret.defaultRegValue = ret.modeToRegValueMap[PreemptionMode::MidBatch]; + ret.regAddress = 0x2580u; + return ret; +} + using Gen9PreemptionTests = DevicePreemptionTests; -using Gen9PreemptionEnqueueKernelTest = PreemptionEnqueueKernelTest; -using Gen9MidThreadPreemptionEnqueueKernelTest = MidThreadPreemptionEnqueueKernelTest; -using Gen9ThreadGroupPreemptionEnqueueKernelTest = ThreadGroupPreemptionEnqueueKernelTest; GEN9TEST_F(Gen9PreemptionTests, whenMidThreadPreemptionIsNotAvailableThenDoesNotProgramPreamble) { device->setPreemptionMode(PreemptionMode::ThreadGroup); - size_t requiredSize = PreemptionHelper::getRequiredStateSipCmdSize(device->getDevice()); + size_t requiredSize = PreemptionHelper::getRequiredStateSipCmdSize(*device); EXPECT_EQ(0U, requiredSize); LinearStream cmdStream{nullptr, 0}; - PreemptionHelper::programStateSip(cmdStream, device->getDevice()); + PreemptionHelper::programStateSip(cmdStream, *device); EXPECT_EQ(0U, cmdStream.getUsed()); } @@ -58,7 +51,7 @@ GEN9TEST_F(Gen9PreemptionTests, whenMidThreadPreemptionIsAvailableThenStateSipIs uint64_t minCsrAlignment = 2 * 256 * MemoryConstants::kiloByte; MockGraphicsAllocation csrSurface((void *)minCsrAlignment, minCsrSize); - size_t requiredCmdStreamSize = PreemptionHelper::getRequiredStateSipCmdSize(device->getDevice()); + size_t requiredCmdStreamSize = PreemptionHelper::getRequiredStateSipCmdSize(*device); size_t expectedPreambleSize = sizeof(STATE_SIP); EXPECT_EQ(expectedPreambleSize, requiredCmdStreamSize); @@ -66,378 +59,20 @@ GEN9TEST_F(Gen9PreemptionTests, whenMidThreadPreemptionIsAvailableThenStateSipIs ASSERT_LE(requiredCmdStreamSize, streamStorage.size()); LinearStream cmdStream{streamStorage.begin(), streamStorage.size()}; - PreemptionHelper::programStateSip(cmdStream, device->getDevice()); + PreemptionHelper::programStateSip(cmdStream, *device); HardwareParse hwParsePreamble; hwParsePreamble.parseCommands(cmdStream); auto stateSipCmd = hwParsePreamble.getCommand(); ASSERT_NE(nullptr, stateSipCmd); - EXPECT_EQ(device->getBuiltIns()->getSipKernel(SipKernelType::Csr, device->getDevice()).getSipAllocation()->getGpuAddressToPatch(), stateSipCmd->getSystemInstructionPointer()); -} - -GEN9TEST_F(Gen9ThreadGroupPreemptionEnqueueKernelTest, givenSecondEnqueueWithTheSamePreemptionRequestThenDontReprogramThreadGroupNoWa) { - pDevice->setPreemptionMode(PreemptionMode::ThreadGroup); - - pDevice->getRootDeviceEnvironment().getMutableHardwareInfo()->workaroundTable.waModifyVFEStateAfterGPGPUPreemption = false; - auto &csr = pDevice->getUltCommandStreamReceiver(); - csr.getMemoryManager()->setForce32BitAllocations(false); - csr.setMediaVFEStateDirty(false); - auto csrSurface = csr.getPreemptionAllocation(); - EXPECT_EQ(nullptr, csrSurface); - size_t off[3] = {0, 0, 0}; - size_t gws[3] = {1, 1, 1}; - - MockKernelWithInternals mockKernel(*pClDevice); - - HardwareParse hwParserCsr; - HardwareParse hwParserCmdQ; - pCmdQ->enqueueKernel(mockKernel.mockKernel, 1, off, gws, nullptr, 0, nullptr, nullptr); - hwParserCsr.parseCommands(csr.commandStream); - hwParserCmdQ.parseCommands(pCmdQ->getCS(1024)); - auto offsetCsr = csr.commandStream.getUsed(); - auto offsetCmdQ = pCmdQ->getCS(1024).getUsed(); - pCmdQ->enqueueKernel(mockKernel.mockKernel, 1, off, gws, nullptr, 0, nullptr, nullptr); - pCmdQ->flush(); - hwParserCsr.parseCommands(csr.commandStream, offsetCsr); - hwParserCmdQ.parseCommands(pCmdQ->getCS(1024), offsetCmdQ); - - EXPECT_EQ(1U, countMmio(hwParserCsr.cmdList.begin(), hwParserCsr.cmdList.end(), 0x2580u)); - EXPECT_EQ(0U, countMmio(hwParserCsr.cmdList.begin(), hwParserCsr.cmdList.end(), 0x2600u)); - EXPECT_EQ(0U, countMmio(hwParserCmdQ.cmdList.begin(), hwParserCmdQ.cmdList.end(), 0x2580u)); - EXPECT_EQ(0U, countMmio(hwParserCmdQ.cmdList.begin(), hwParserCmdQ.cmdList.end(), 0x2600u)); -} - -GEN9TEST_F(Gen9ThreadGroupPreemptionEnqueueKernelTest, givenSecondEnqueueWithTheSamePreemptionRequestThenDontReprogramThreadGroupWa) { - pDevice->setPreemptionMode(PreemptionMode::ThreadGroup); - - pDevice->getRootDeviceEnvironment().getMutableHardwareInfo()->workaroundTable.waModifyVFEStateAfterGPGPUPreemption = true; - auto &csr = pDevice->getUltCommandStreamReceiver(); - csr.getMemoryManager()->setForce32BitAllocations(false); - csr.setMediaVFEStateDirty(false); - auto csrSurface = csr.getPreemptionAllocation(); - EXPECT_EQ(nullptr, csrSurface); - HardwareParse hwCsrParser; - HardwareParse hwCmdQParser; - size_t off[3] = {0, 0, 0}; - size_t gws[3] = {1, 1, 1}; - - MockKernelWithInternals mockKernel(*pClDevice); - - pCmdQ->enqueueKernel(mockKernel.mockKernel, 1, off, gws, nullptr, 0, nullptr, nullptr); - hwCsrParser.parseCommands(csr.commandStream); - hwCsrParser.findHardwareCommands(); - hwCmdQParser.parseCommands(pCmdQ->getCS(1024)); - hwCmdQParser.findHardwareCommands(); - auto offsetCsr = csr.commandStream.getUsed(); - auto offsetCmdQ = pCmdQ->getCS(1024).getUsed(); - - bool foundOne = false; - for (auto it : hwCsrParser.lriList) { - auto cmd = genCmdCast(it); - if (cmd->getRegisterOffset() == 0x2580u) { - EXPECT_FALSE(foundOne); - foundOne = true; - } - } - EXPECT_TRUE(foundOne); - hwCsrParser.cmdList.clear(); - hwCsrParser.lriList.clear(); - - int foundWaLri = 0; - int foundWaLriBegin = 0; - int foundWaLriEnd = 0; - for (auto it : hwCmdQParser.lriList) { - auto cmd = genCmdCast(it); - if (cmd->getRegisterOffset() == 0x2600u) { - foundWaLri++; - if (cmd->getDataDword() == 0xFFFFFFFF) { - foundWaLriBegin++; - } - if (cmd->getDataDword() == 0x0) { - foundWaLriEnd++; - } - } - } - EXPECT_EQ(2, foundWaLri); - EXPECT_EQ(1, foundWaLriBegin); - EXPECT_EQ(1, foundWaLriEnd); - hwCmdQParser.cmdList.clear(); - hwCmdQParser.lriList.clear(); - - pCmdQ->enqueueKernel(mockKernel.mockKernel, 1, off, gws, nullptr, 0, nullptr, nullptr); - hwCsrParser.parseCommands(csr.commandStream, offsetCsr); - hwCsrParser.findHardwareCommands(); - - hwCmdQParser.parseCommands(pCmdQ->getCS(1024), offsetCmdQ); - hwCmdQParser.findHardwareCommands(); - - for (auto it : hwCsrParser.lriList) { - auto cmd = genCmdCast(it); - EXPECT_FALSE(cmd->getRegisterOffset() == 0x2580u); - } - - foundWaLri = 0; - foundWaLriBegin = 0; - foundWaLriEnd = 0; - for (auto it : hwCmdQParser.lriList) { - auto cmd = genCmdCast(it); - if (cmd->getRegisterOffset() == 0x2600u) { - foundWaLri++; - if (cmd->getDataDword() == 0xFFFFFFFF) { - foundWaLriBegin++; - } - if (cmd->getDataDword() == 0x0) { - foundWaLriEnd++; - } - } - } - EXPECT_EQ(2, foundWaLri); - EXPECT_EQ(1, foundWaLriBegin); - EXPECT_EQ(1, foundWaLriEnd); -} - -GEN9TEST_F(Gen9PreemptionEnqueueKernelTest, givenValidKernelForPreemptionWhenEnqueueKernelCalledThenPassDevicePreemptionModeThreadGroup) { - pDevice->setPreemptionMode(PreemptionMode::ThreadGroup); - - auto mockCsr = new MockCsrHw2(*pDevice->executionEnvironment, pDevice->getRootDeviceIndex()); - pDevice->resetCommandStreamReceiver(mockCsr); - - MockKernelWithInternals mockKernel(*pClDevice); - MultiDispatchInfo multiDispatch(mockKernel.mockKernel); - EXPECT_EQ(PreemptionMode::ThreadGroup, PreemptionHelper::taskPreemptionMode(*pDevice, multiDispatch)); - - size_t gws[3] = {1, 0, 0}; - pCmdQ->enqueueKernel(mockKernel.mockKernel, 1, nullptr, gws, nullptr, 0, nullptr, nullptr); - pCmdQ->flush(); - - EXPECT_EQ(1, mockCsr->flushCalledCount); - EXPECT_EQ(PreemptionMode::ThreadGroup, mockCsr->passedDispatchFlags.preemptionMode); -} - -GEN9TEST_F(Gen9PreemptionEnqueueKernelTest, givenValidKernelForPreemptionWhenEnqueueKernelCalledAndBlockedThenPassDevicePreemptionModeThreadGroup) { - pDevice->setPreemptionMode(PreemptionMode::ThreadGroup); - - auto mockCsr = new MockCsrHw2(*pDevice->executionEnvironment, pDevice->getRootDeviceIndex()); - pDevice->resetCommandStreamReceiver(mockCsr); - - MockKernelWithInternals mockKernel(*pClDevice); - MultiDispatchInfo multiDispatch(mockKernel.mockKernel); - EXPECT_EQ(PreemptionMode::ThreadGroup, PreemptionHelper::taskPreemptionMode(*pDevice, multiDispatch)); - - UserEvent userEventObj; - cl_event userEvent = &userEventObj; - size_t gws[3] = {1, 0, 0}; - pCmdQ->enqueueKernel(mockKernel.mockKernel, 1, nullptr, gws, nullptr, 1, &userEvent, nullptr); - pCmdQ->flush(); - EXPECT_EQ(0, mockCsr->flushCalledCount); - - userEventObj.setStatus(CL_COMPLETE); - pCmdQ->flush(); - EXPECT_EQ(1, mockCsr->flushCalledCount); - EXPECT_EQ(PreemptionMode::ThreadGroup, mockCsr->passedDispatchFlags.preemptionMode); -} - -GEN9TEST_F(Gen9MidThreadPreemptionEnqueueKernelTest, givenSecondEnqueueWithTheSamePreemptionRequestThenDontReprogramMidThreadNoWa) { - typedef typename FamilyType::MI_LOAD_REGISTER_IMM MI_LOAD_REGISTER_IMM; - typedef typename FamilyType::GPGPU_CSR_BASE_ADDRESS GPGPU_CSR_BASE_ADDRESS; - - pDevice->getRootDeviceEnvironment().getMutableHardwareInfo()->workaroundTable.waModifyVFEStateAfterGPGPUPreemption = false; - - auto &csr = pDevice->getUltCommandStreamReceiver(); - csr.getMemoryManager()->setForce32BitAllocations(false); - csr.setMediaVFEStateDirty(false); - auto csrSurface = csr.getPreemptionAllocation(); - ASSERT_NE(nullptr, csrSurface); - HardwareParse hwCsrParser; - HardwareParse hwCmdQParser; - size_t off[3] = {0, 0, 0}; - size_t gws[3] = {1, 1, 1}; - - MockKernelWithInternals mockKernel(*pClDevice); - - pCmdQ->enqueueKernel(mockKernel.mockKernel, 1, off, gws, nullptr, 0, nullptr, nullptr); - hwCsrParser.parseCommands(csr.commandStream); - hwCsrParser.findHardwareCommands(); - hwCmdQParser.parseCommands(pCmdQ->getCS(1024)); - hwCmdQParser.findHardwareCommands(); - auto offsetCsr = csr.commandStream.getUsed(); - auto offsetCmdQ = pCmdQ->getCS(1024).getUsed(); - - bool foundOneLri = false; - for (auto it : hwCsrParser.lriList) { - auto cmdLri = genCmdCast(it); - if (cmdLri->getRegisterOffset() == 0x2580u) { - EXPECT_FALSE(foundOneLri); - foundOneLri = true; - } - } - EXPECT_TRUE(foundOneLri); - - bool foundWaLri = false; - for (auto it : hwCmdQParser.lriList) { - auto cmdLri = genCmdCast(it); - if (cmdLri->getRegisterOffset() == 0x2600u) { - foundWaLri = true; - } - } - EXPECT_FALSE(foundWaLri); - - hwCsrParser.findCsrBaseAddress(); - ASSERT_NE(nullptr, hwCsrParser.cmdGpgpuCsrBaseAddress); - auto cmdCsr = genCmdCast(hwCsrParser.cmdGpgpuCsrBaseAddress); - ASSERT_NE(nullptr, cmdCsr); - EXPECT_EQ(csrSurface->getGpuAddressToPatch(), cmdCsr->getGpgpuCsrBaseAddress()); - - hwCsrParser.cmdList.clear(); - hwCsrParser.lriList.clear(); - hwCsrParser.cmdGpgpuCsrBaseAddress = nullptr; - hwCmdQParser.cmdList.clear(); - hwCmdQParser.lriList.clear(); - - pCmdQ->enqueueKernel(mockKernel.mockKernel, 1, off, gws, nullptr, 0, nullptr, nullptr); - hwCsrParser.parseCommands(csr.commandStream, offsetCsr); - hwCsrParser.findHardwareCommands(); - hwCmdQParser.parseCommands(csr.commandStream, offsetCmdQ); - hwCmdQParser.findHardwareCommands(); - - for (auto it : hwCsrParser.lriList) { - auto cmd = genCmdCast(it); - EXPECT_FALSE(cmd->getRegisterOffset() == 0x2580u); - } - - hwCsrParser.findCsrBaseAddress(); - EXPECT_EQ(nullptr, hwCsrParser.cmdGpgpuCsrBaseAddress); - - for (auto it : hwCmdQParser.lriList) { - auto cmd = genCmdCast(it); - EXPECT_FALSE(cmd->getRegisterOffset() == 0x2600u); - } -} - -GEN9TEST_F(Gen9MidThreadPreemptionEnqueueKernelTest, givenSecondEnqueueWithTheSamePreemptionRequestThenDontReprogramMidThreadWa) { - typedef typename FamilyType::MI_LOAD_REGISTER_IMM MI_LOAD_REGISTER_IMM; - typedef typename FamilyType::GPGPU_CSR_BASE_ADDRESS GPGPU_CSR_BASE_ADDRESS; - - pDevice->getRootDeviceEnvironment().getMutableHardwareInfo()->workaroundTable.waModifyVFEStateAfterGPGPUPreemption = true; - - auto &csr = pDevice->getUltCommandStreamReceiver(); - csr.getMemoryManager()->setForce32BitAllocations(false); - csr.setMediaVFEStateDirty(false); - auto csrSurface = csr.getPreemptionAllocation(); - ASSERT_NE(nullptr, csrSurface); - HardwareParse hwCsrParser; - HardwareParse hwCmdQParser; - size_t off[3] = {0, 0, 0}; - size_t gws[3] = {1, 1, 1}; - - MockKernelWithInternals mockKernel(*pClDevice); - - pCmdQ->enqueueKernel(mockKernel.mockKernel, 1, off, gws, nullptr, 0, nullptr, nullptr); - hwCsrParser.parseCommands(csr.commandStream); - hwCsrParser.findHardwareCommands(); - hwCmdQParser.parseCommands(pCmdQ->getCS(1024)); - hwCmdQParser.findHardwareCommands(); - auto offsetCsr = csr.commandStream.getUsed(); - auto offsetCmdQ = pCmdQ->getCS(1024).getUsed(); - - bool foundOneLri = false; - for (auto it : hwCsrParser.lriList) { - auto cmdLri = genCmdCast(it); - if (cmdLri->getRegisterOffset() == 0x2580u) { - EXPECT_FALSE(foundOneLri); - foundOneLri = true; - } - } - EXPECT_TRUE(foundOneLri); - - int foundWaLri = 0; - int foundWaLriBegin = 0; - int foundWaLriEnd = 0; - for (auto it : hwCmdQParser.lriList) { - auto cmdLri = genCmdCast(it); - if (cmdLri->getRegisterOffset() == 0x2600u) { - foundWaLri++; - if (cmdLri->getDataDword() == 0xFFFFFFFF) { - foundWaLriBegin++; - } - if (cmdLri->getDataDword() == 0x0) { - foundWaLriEnd++; - } - } - } - EXPECT_EQ(2, foundWaLri); - EXPECT_EQ(1, foundWaLriBegin); - EXPECT_EQ(1, foundWaLriEnd); - - hwCsrParser.findCsrBaseAddress(); - ASSERT_NE(nullptr, hwCsrParser.cmdGpgpuCsrBaseAddress); - auto cmdCsr = genCmdCast(hwCsrParser.cmdGpgpuCsrBaseAddress); - ASSERT_NE(nullptr, cmdCsr); - EXPECT_EQ(csrSurface->getGpuAddressToPatch(), cmdCsr->getGpgpuCsrBaseAddress()); - - hwCsrParser.cmdList.clear(); - hwCsrParser.lriList.clear(); - hwCsrParser.cmdGpgpuCsrBaseAddress = nullptr; - hwCmdQParser.cmdList.clear(); - hwCmdQParser.lriList.clear(); - - pCmdQ->enqueueKernel(mockKernel.mockKernel, 1, off, gws, nullptr, 0, nullptr, nullptr); - hwCsrParser.parseCommands(csr.commandStream, offsetCsr); - hwCsrParser.findHardwareCommands(); - hwCmdQParser.parseCommands(pCmdQ->getCS(1024), offsetCmdQ); - hwCmdQParser.findHardwareCommands(); - - for (auto it : hwCsrParser.lriList) { - auto cmd = genCmdCast(it); - EXPECT_FALSE(cmd->getRegisterOffset() == 0x2580u); - } - - hwCsrParser.findCsrBaseAddress(); - EXPECT_EQ(nullptr, hwCsrParser.cmdGpgpuCsrBaseAddress); - - foundWaLri = 0; - foundWaLriBegin = 0; - foundWaLriEnd = 0; - for (auto it : hwCmdQParser.lriList) { - auto cmd = genCmdCast(it); - if (cmd->getRegisterOffset() == 0x2600u) { - foundWaLri++; - if (cmd->getDataDword() == 0xFFFFFFFF) { - foundWaLriBegin++; - } - if (cmd->getDataDword() == 0x0) { - foundWaLriEnd++; - } - } - } - EXPECT_EQ(2, foundWaLri); - EXPECT_EQ(1, foundWaLriBegin); - EXPECT_EQ(1, foundWaLriEnd); -} - -GEN9TEST_F(Gen9PreemptionEnqueueKernelTest, givenDisabledPreemptionWhenEnqueueKernelCalledThenPassDisabledPreemptionMode) { - pDevice->setPreemptionMode(PreemptionMode::Disabled); - - auto mockCsr = new MockCsrHw2(*pDevice->executionEnvironment, pDevice->getRootDeviceIndex()); - pDevice->resetCommandStreamReceiver(mockCsr); - - MockKernelWithInternals mockKernel(*pClDevice); - MultiDispatchInfo multiDispatch(mockKernel.mockKernel); - EXPECT_EQ(PreemptionMode::Disabled, PreemptionHelper::taskPreemptionMode(*pDevice, multiDispatch)); - - size_t gws[3] = {1, 0, 0}; - pCmdQ->enqueueKernel(mockKernel.mockKernel, 1, nullptr, gws, nullptr, 0, nullptr, nullptr); - pCmdQ->flush(); - - EXPECT_EQ(1, mockCsr->flushCalledCount); - EXPECT_EQ(PreemptionMode::Disabled, mockCsr->passedDispatchFlags.preemptionMode); + EXPECT_EQ(device->getBuiltIns()->getSipKernel(SipKernelType::Csr, *device).getSipAllocation()->getGpuAddressToPatch(), stateSipCmd->getSystemInstructionPointer()); } GEN9TEST_F(Gen9PreemptionTests, getPreemptionWaCsSizeMidBatch) { size_t expectedSize = 0; device->setPreemptionMode(PreemptionMode::MidBatch); - size_t size = PreemptionHelper::getPreemptionWaCsSize(device->getDevice()); + size_t size = PreemptionHelper::getPreemptionWaCsSize(*device); EXPECT_EQ(expectedSize, size); } @@ -445,7 +80,7 @@ GEN9TEST_F(Gen9PreemptionTests, getPreemptionWaCsSizeThreadGroupNoWa) { size_t expectedSize = 0; device->setPreemptionMode(PreemptionMode::ThreadGroup); device->getRootDeviceEnvironment().getMutableHardwareInfo()->workaroundTable.waModifyVFEStateAfterGPGPUPreemption = false; - size_t size = PreemptionHelper::getPreemptionWaCsSize(device->getDevice()); + size_t size = PreemptionHelper::getPreemptionWaCsSize(*device); EXPECT_EQ(expectedSize, size); } @@ -454,7 +89,7 @@ GEN9TEST_F(Gen9PreemptionTests, getPreemptionWaCsSizeThreadGroupWa) { size_t expectedSize = 2 * sizeof(MI_LOAD_REGISTER_IMM); device->setPreemptionMode(PreemptionMode::ThreadGroup); device->getRootDeviceEnvironment().getMutableHardwareInfo()->workaroundTable.waModifyVFEStateAfterGPGPUPreemption = true; - size_t size = PreemptionHelper::getPreemptionWaCsSize(device->getDevice()); + size_t size = PreemptionHelper::getPreemptionWaCsSize(*device); EXPECT_EQ(expectedSize, size); } @@ -462,7 +97,7 @@ GEN9TEST_F(Gen9PreemptionTests, getPreemptionWaCsSizeMidThreadNoWa) { size_t expectedSize = 0; device->setPreemptionMode(PreemptionMode::MidThread); device->getRootDeviceEnvironment().getMutableHardwareInfo()->workaroundTable.waModifyVFEStateAfterGPGPUPreemption = false; - size_t size = PreemptionHelper::getPreemptionWaCsSize(device->getDevice()); + size_t size = PreemptionHelper::getPreemptionWaCsSize(*device); EXPECT_EQ(expectedSize, size); } @@ -471,7 +106,7 @@ GEN9TEST_F(Gen9PreemptionTests, getPreemptionWaCsSizeMidThreadWa) { size_t expectedSize = 2 * sizeof(MI_LOAD_REGISTER_IMM); device->setPreemptionMode(PreemptionMode::MidThread); device->getRootDeviceEnvironment().getMutableHardwareInfo()->workaroundTable.waModifyVFEStateAfterGPGPUPreemption = true; - size_t size = PreemptionHelper::getPreemptionWaCsSize(device->getDevice()); + size_t size = PreemptionHelper::getPreemptionWaCsSize(*device); EXPECT_EQ(expectedSize, size); } diff --git a/shared/test/unit_test/image/CMakeLists.txt b/shared/test/unit_test/image/CMakeLists.txt index 4435df15d6..5f6d3407f7 100644 --- a/shared/test/unit_test/image/CMakeLists.txt +++ b/shared/test/unit_test/image/CMakeLists.txt @@ -4,12 +4,8 @@ # SPDX-License-Identifier: MIT # -set(NEO_CORE_IMAGE_TESTS +target_sources(${TARGET_NAME} PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt ${CMAKE_CURRENT_SOURCE_DIR}/image_surface_state_fixture.h ${CMAKE_CURRENT_SOURCE_DIR}/image_surface_state_tests.cpp ) - -set_property(GLOBAL PROPERTY NEO_CORE_IMAGE_TESTS ${NEO_CORE_IMAGE_TESTS}) - -add_subdirectories() \ No newline at end of file diff --git a/shared/test/unit_test/image/image_surface_state_fixture.h b/shared/test/unit_test/image/image_surface_state_fixture.h index 6ef4694d25..ce7e5638f9 100644 --- a/shared/test/unit_test/image/image_surface_state_fixture.h +++ b/shared/test/unit_test/image/image_surface_state_fixture.h @@ -12,32 +12,26 @@ #include "shared/source/image/image_surface_state.h" #include "shared/source/memory_manager/graphics_allocation.h" #include "shared/source/memory_manager/surface.h" +#include "shared/test/unit_test/fixtures/device_fixture.h" -#include "opencl/source/helpers/surface_formats.h" -#include "opencl/source/kernel/kernel.h" -#include "opencl/source/mem_obj/image.h" -#include "opencl/test/unit_test/fixtures/cl_device_fixture.h" -#include "opencl/test/unit_test/fixtures/image_fixture.h" #include "opencl/test/unit_test/mocks/mock_gmm.h" -#include "opencl/test/unit_test/mocks/mock_gmm_resource_info.h" -#include "opencl/test/unit_test/mocks/mock_graphics_allocation.h" #include "test.h" #include namespace NEO { -class ImageSurfaceStateTests : public ClDeviceFixture, +class ImageSurfaceStateTests : public DeviceFixture, public testing::Test { public: ImageSurfaceStateTests() = default; void SetUp() override { - ClDeviceFixture::SetUp(); + DeviceFixture::SetUp(); gmmHelper = pDevice->getGmmHelper(); } void TearDown() override { - ClDeviceFixture::TearDown(); + DeviceFixture::TearDown(); } MockGmm mockGmm; diff --git a/shared/test/unit_test/main.cpp b/shared/test/unit_test/main.cpp index 80725967f8..6e05024e59 100644 --- a/shared/test/unit_test/main.cpp +++ b/shared/test/unit_test/main.cpp @@ -328,6 +328,16 @@ int main(int argc, char **argv) { gtSystemInfo.IsDynamicallyPopulated = false; // clang-format on + binaryNameSuffix.append(familyName[hwInfoForTests.platform.eRenderCoreFamily]); + binaryNameSuffix.append(hwInfoForTests.capabilityTable.platformType); + + std::string testBinaryFiles = getRunPath(argv[0]); + testBinaryFiles.append("/"); + testBinaryFiles.append(binaryNameSuffix); + testBinaryFiles.append("/"); + testBinaryFiles.append(testFiles); + testFiles = testBinaryFiles; + std::string executionDirectory(hardwarePrefix[productFamily]); executionDirectory += NEO::executionDirectorySuffix; // _aub for aub_tests, empty otherwise @@ -417,7 +427,12 @@ int main(int argc, char **argv) { GmmInterface::initialize(nullptr, nullptr); } + GlobalMockSipProgram::initSipProgram(); + NEO::MockSipData::mockSipKernel.reset(new NEO::MockSipKernel()); + retVal = RUN_ALL_TESTS(); + GlobalMockSipProgram::shutDownSipProgram(); + return retVal; } diff --git a/shared/test/unit_test/memory_manager/CMakeLists.txt b/shared/test/unit_test/memory_manager/CMakeLists.txt index 2a07b94a1a..4e39f34b29 100644 --- a/shared/test/unit_test/memory_manager/CMakeLists.txt +++ b/shared/test/unit_test/memory_manager/CMakeLists.txt @@ -4,9 +4,7 @@ # SPDX-License-Identifier: MIT # -set(NEO_CORE_MEMORY_MANAGER_TESTS +target_sources(${TARGET_NAME} PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt ${CMAKE_CURRENT_SOURCE_DIR}/multi_graphics_allocation_tests.cpp ) - -set_property(GLOBAL PROPERTY NEO_CORE_MEMORY_MANAGER_TESTS ${NEO_CORE_MEMORY_MANAGER_TESTS}) diff --git a/shared/test/unit_test/os_interface/linux/CMakeLists.txt b/shared/test/unit_test/os_interface/linux/CMakeLists.txt index 562634c995..54eccfb8e3 100644 --- a/shared/test/unit_test/os_interface/linux/CMakeLists.txt +++ b/shared/test/unit_test/os_interface/linux/CMakeLists.txt @@ -10,3 +10,9 @@ set(NEO_CORE_OS_INTERFACE_TESTS_LINUX ) set_property(GLOBAL PROPERTY NEO_CORE_OS_INTERFACE_TESTS_LINUX ${NEO_CORE_OS_INTERFACE_TESTS_LINUX}) + +if(UNIX) + target_sources(${TARGET_NAME} PRIVATE + ${NEO_CORE_OS_INTERFACE_TESTS_LINUX} + ) +endif() diff --git a/shared/test/unit_test/os_interface/windows/CMakeLists.txt b/shared/test/unit_test/os_interface/windows/CMakeLists.txt index 72e7719fa0..9914205940 100644 --- a/shared/test/unit_test/os_interface/windows/CMakeLists.txt +++ b/shared/test/unit_test/os_interface/windows/CMakeLists.txt @@ -12,4 +12,11 @@ set(NEO_CORE_OS_INTERFACE_TESTS_WINDOWS ${CMAKE_CURRENT_SOURCE_DIR}/mock_gdi_interface.h ${CMAKE_CURRENT_SOURCE_DIR}/wddm_preemption_tests.cpp ) + set_property(GLOBAL PROPERTY NEO_CORE_OS_INTERFACE_TESTS_WINDOWS ${NEO_CORE_OS_INTERFACE_TESTS_WINDOWS}) + +if(WIN32) + target_sources(${TARGET_NAME} PRIVATE + ${NEO_CORE_OS_INTERFACE_TESTS_WINDOWS} + ) +endif() diff --git a/shared/test/unit_test/preemption/CMakeLists.txt b/shared/test/unit_test/preemption/CMakeLists.txt index 0d03f6da24..d3514fa903 100644 --- a/shared/test/unit_test/preemption/CMakeLists.txt +++ b/shared/test/unit_test/preemption/CMakeLists.txt @@ -4,10 +4,9 @@ # SPDX-License-Identifier: MIT # -set(NEO_CORE_SRCS_tests_preemption +target_sources(${TARGET_NAME} PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt ${CMAKE_CURRENT_SOURCE_DIR}/preemption_tests.cpp ) -set_property(GLOBAL PROPERTY NEO_CORE_SRCS_tests_preemption ${NEO_CORE_SRCS_tests_preemption}) -add_subdirectories() \ No newline at end of file +add_subdirectories() diff --git a/shared/test/unit_test/preemption/preemption_tests.cpp b/shared/test/unit_test/preemption/preemption_tests.cpp index 217aea5ad0..4796bdcccd 100644 --- a/shared/test/unit_test/preemption/preemption_tests.cpp +++ b/shared/test/unit_test/preemption/preemption_tests.cpp @@ -25,15 +25,6 @@ using namespace NEO; -class ThreadGroupPreemptionTests : public DevicePreemptionTests { - void SetUp() override { - dbgRestore.reset(new DebugManagerStateRestore()); - DebugManager.flags.ForcePreemptionMode.set(static_cast(PreemptionMode::ThreadGroup)); - preemptionMode = PreemptionMode::ThreadGroup; - DevicePreemptionTests::SetUp(); - } -}; - class MidThreadPreemptionTests : public DevicePreemptionTests { public: void SetUp() override { @@ -44,264 +35,6 @@ class MidThreadPreemptionTests : public DevicePreemptionTests { } }; -TEST_F(ThreadGroupPreemptionTests, disallowByKMD) { - PreemptionFlags flags = {}; - waTable->waDisablePerCtxtPreemptionGranularityControl = 1; - PreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), kernel.get()); - EXPECT_FALSE(PreemptionHelper::allowThreadGroupPreemption(flags)); - EXPECT_EQ(PreemptionMode::MidBatch, PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags)); -} - -TEST_F(ThreadGroupPreemptionTests, disallowByDevice) { - PreemptionFlags flags = {}; - device->setPreemptionMode(PreemptionMode::MidThread); - PreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), kernel.get()); - EXPECT_TRUE(PreemptionHelper::allowThreadGroupPreemption(flags)); - EXPECT_EQ(PreemptionMode::MidThread, PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags)); -} - -TEST_F(ThreadGroupPreemptionTests, disallowByReadWriteFencesWA) { - PreemptionFlags flags = {}; - executionEnvironment->UsesFencesForReadWriteImages = 1u; - waTable->waDisableLSQCROPERFforOCL = 1; - PreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), kernel.get()); - EXPECT_FALSE(PreemptionHelper::allowThreadGroupPreemption(flags)); - EXPECT_EQ(PreemptionMode::MidBatch, PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags)); -} - -TEST_F(ThreadGroupPreemptionTests, disallowBySchedulerKernel) { - PreemptionFlags flags = {}; - kernel.reset(new MockKernel(program.get(), *kernelInfo, *device, true)); - PreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), kernel.get()); - EXPECT_FALSE(PreemptionHelper::allowThreadGroupPreemption(flags)); - EXPECT_EQ(PreemptionMode::MidBatch, PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags)); -} - -TEST_F(ThreadGroupPreemptionTests, disallowByVmeKernel) { - PreemptionFlags flags = {}; - kernelInfo->isVmeWorkload = true; - kernel.reset(new MockKernel(program.get(), *kernelInfo, *device)); - PreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), kernel.get()); - EXPECT_FALSE(PreemptionHelper::allowThreadGroupPreemption(flags)); - EXPECT_EQ(PreemptionMode::MidBatch, PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags)); -} - -TEST_F(ThreadGroupPreemptionTests, simpleAllow) { - PreemptionFlags flags = {}; - EXPECT_TRUE(PreemptionHelper::allowThreadGroupPreemption(flags)); - EXPECT_EQ(PreemptionMode::ThreadGroup, PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags)); -} - -TEST_F(ThreadGroupPreemptionTests, allowDefaultModeForNonKernelRequest) { - PreemptionFlags flags = {}; - PreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), nullptr); - EXPECT_EQ(PreemptionMode::ThreadGroup, PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags)); -} - -TEST_F(ThreadGroupPreemptionTests, givenKernelWithNoEnvironmentPatchSetWhenLSQCWaIsTurnedOnThenThreadGroupPreemptionIsBeingSelected) { - PreemptionFlags flags = {}; - kernelInfo.get()->patchInfo.executionEnvironment = nullptr; - waTable->waDisableLSQCROPERFforOCL = 1; - PreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), kernel.get()); - EXPECT_TRUE(PreemptionHelper::allowThreadGroupPreemption(flags)); - EXPECT_EQ(PreemptionMode::ThreadGroup, PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags)); -} - -TEST_F(ThreadGroupPreemptionTests, givenKernelWithEnvironmentPatchSetWhenLSQCWaIsTurnedOnThenThreadGroupPreemptionIsBeingSelected) { - PreemptionFlags flags = {}; - executionEnvironment.get()->UsesFencesForReadWriteImages = 0; - waTable->waDisableLSQCROPERFforOCL = 1; - PreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), kernel.get()); - EXPECT_TRUE(PreemptionHelper::allowThreadGroupPreemption(flags)); - EXPECT_EQ(PreemptionMode::ThreadGroup, PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags)); -} - -TEST_F(ThreadGroupPreemptionTests, givenKernelWithEnvironmentPatchSetWhenLSQCWaIsTurnedOffThenThreadGroupPreemptionIsBeingSelected) { - PreemptionFlags flags = {}; - executionEnvironment.get()->UsesFencesForReadWriteImages = 1; - waTable->waDisableLSQCROPERFforOCL = 0; - PreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), kernel.get()); - EXPECT_TRUE(PreemptionHelper::allowThreadGroupPreemption(flags)); - EXPECT_EQ(PreemptionMode::ThreadGroup, PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags)); -} - -TEST_F(ThreadGroupPreemptionTests, allowMidBatch) { - PreemptionFlags flags = {}; - device->setPreemptionMode(PreemptionMode::MidBatch); - PreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), nullptr); - EXPECT_EQ(PreemptionMode::MidBatch, PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags)); -} - -TEST_F(ThreadGroupPreemptionTests, disallowWhenAdjustedDisabled) { - PreemptionFlags flags = {}; - device->setPreemptionMode(PreemptionMode::Disabled); - PreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), nullptr); - EXPECT_EQ(PreemptionMode::Disabled, PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags)); -} - -TEST_F(ThreadGroupPreemptionTests, returnDefaultDeviceModeForZeroSizedMdi) { - MultiDispatchInfo multiDispatchInfo; - EXPECT_EQ(PreemptionMode::ThreadGroup, PreemptionHelper::taskPreemptionMode(device->getDevice(), multiDispatchInfo)); -} - -TEST_F(ThreadGroupPreemptionTests, returnDefaultDeviceModeForValidKernelsInMdi) { - MultiDispatchInfo multiDispatchInfo; - multiDispatchInfo.push(*dispatchInfo); - multiDispatchInfo.push(*dispatchInfo); - EXPECT_EQ(PreemptionMode::ThreadGroup, PreemptionHelper::taskPreemptionMode(device->getDevice(), multiDispatchInfo)); -} - -TEST_F(ThreadGroupPreemptionTests, disallowDefaultDeviceModeForValidKernelsInMdiAndDisabledPremption) { - device->setPreemptionMode(PreemptionMode::Disabled); - MultiDispatchInfo multiDispatchInfo; - multiDispatchInfo.push(*dispatchInfo); - multiDispatchInfo.push(*dispatchInfo); - EXPECT_EQ(PreemptionMode::Disabled, PreemptionHelper::taskPreemptionMode(device->getDevice(), multiDispatchInfo)); -} - -TEST_F(ThreadGroupPreemptionTests, disallowDefaultDeviceModeWhenAtLeastOneInvalidKernelInMdi) { - MockKernel schedulerKernel(program.get(), *kernelInfo, *device, true); - DispatchInfo schedulerDispatchInfo(&schedulerKernel, 1, Vec3(1, 1, 1), Vec3(1, 1, 1), Vec3(0, 0, 0)); - - PreemptionFlags flags = {}; - PreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), &schedulerKernel); - EXPECT_EQ(PreemptionMode::MidBatch, PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags)); - - MultiDispatchInfo multiDispatchInfo; - multiDispatchInfo.push(*dispatchInfo); - multiDispatchInfo.push(schedulerDispatchInfo); - multiDispatchInfo.push(*dispatchInfo); - - EXPECT_EQ(PreemptionMode::MidBatch, PreemptionHelper::taskPreemptionMode(device->getDevice(), multiDispatchInfo)); -} - -TEST_F(MidThreadPreemptionTests, allowMidThreadPreemption) { - PreemptionFlags flags = {}; - device->setPreemptionMode(PreemptionMode::MidThread); - executionEnvironment->DisableMidThreadPreemption = 0; - PreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), kernel.get()); - EXPECT_TRUE(PreemptionHelper::allowMidThreadPreemption(flags)); -} - -TEST_F(MidThreadPreemptionTests, allowMidThreadPreemptionNullKernel) { - PreemptionFlags flags = {}; - device->setPreemptionMode(PreemptionMode::MidThread); - PreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), nullptr); - EXPECT_TRUE(PreemptionHelper::allowMidThreadPreemption(flags)); -} - -TEST_F(MidThreadPreemptionTests, allowMidThreadPreemptionDeviceSupportPreemptionOnVmeKernel) { - PreemptionFlags flags = {}; - device->setPreemptionMode(PreemptionMode::MidThread); - device->sharedDeviceInfo.vmeAvcSupportsPreemption = true; - kernelInfo->isVmeWorkload = true; - kernel.reset(new MockKernel(program.get(), *kernelInfo, *device)); - PreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), kernel.get()); - EXPECT_TRUE(PreemptionHelper::allowMidThreadPreemption(flags)); -} - -TEST_F(MidThreadPreemptionTests, disallowMidThreadPreemptionByDevice) { - PreemptionFlags flags = {}; - device->setPreemptionMode(PreemptionMode::ThreadGroup); - executionEnvironment->DisableMidThreadPreemption = 0; - PreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), kernel.get()); - EXPECT_TRUE(PreemptionHelper::allowMidThreadPreemption(flags)); - EXPECT_EQ(PreemptionMode::ThreadGroup, PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags)); -} - -TEST_F(MidThreadPreemptionTests, disallowMidThreadPreemptionByKernel) { - PreemptionFlags flags = {}; - device->setPreemptionMode(PreemptionMode::MidThread); - executionEnvironment->DisableMidThreadPreemption = 1; - PreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), kernel.get()); - EXPECT_FALSE(PreemptionHelper::allowMidThreadPreemption(flags)); -} - -TEST_F(MidThreadPreemptionTests, disallowMidThreadPreemptionByVmeKernel) { - PreemptionFlags flags = {}; - device->setPreemptionMode(PreemptionMode::MidThread); - device->sharedDeviceInfo.vmeAvcSupportsPreemption = false; - kernelInfo->isVmeWorkload = true; - kernel.reset(new MockKernel(program.get(), *kernelInfo, *device)); - PreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), kernel.get()); - EXPECT_FALSE(PreemptionHelper::allowMidThreadPreemption(flags)); -} - -TEST_F(MidThreadPreemptionTests, taskPreemptionDisallowMidThreadByDevice) { - PreemptionFlags flags = {}; - executionEnvironment->DisableMidThreadPreemption = 0; - device->setPreemptionMode(PreemptionMode::ThreadGroup); - PreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), kernel.get()); - PreemptionMode outMode = PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags); - EXPECT_EQ(PreemptionMode::ThreadGroup, outMode); -} - -TEST_F(MidThreadPreemptionTests, taskPreemptionDisallowMidThreadByKernel) { - PreemptionFlags flags = {}; - executionEnvironment->DisableMidThreadPreemption = 1; - device->setPreemptionMode(PreemptionMode::MidThread); - PreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), kernel.get()); - PreemptionMode outMode = PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags); - EXPECT_EQ(PreemptionMode::ThreadGroup, outMode); -} - -TEST_F(MidThreadPreemptionTests, taskPreemptionDisallowMidThreadByVmeKernel) { - PreemptionFlags flags = {}; - kernelInfo->isVmeWorkload = true; - device->sharedDeviceInfo.vmeAvcSupportsPreemption = false; - kernel.reset(new MockKernel(program.get(), *kernelInfo, *device)); - device->setPreemptionMode(PreemptionMode::MidThread); - PreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), kernel.get()); - PreemptionMode outMode = PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags); - //VME disables mid thread and thread group when device does not support it - EXPECT_EQ(PreemptionMode::MidBatch, outMode); -} - -TEST_F(MidThreadPreemptionTests, taskPreemptionAllow) { - PreemptionFlags flags = {}; - executionEnvironment->DisableMidThreadPreemption = 0; - device->setPreemptionMode(PreemptionMode::MidThread); - PreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), kernel.get()); - PreemptionMode outMode = PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags); - EXPECT_EQ(PreemptionMode::MidThread, outMode); -} - -TEST_F(MidThreadPreemptionTests, taskPreemptionAllowDeviceSupportsPreemptionOnVmeKernel) { - PreemptionFlags flags = {}; - executionEnvironment->DisableMidThreadPreemption = 0; - kernelInfo->isVmeWorkload = true; - kernel.reset(new MockKernel(program.get(), *kernelInfo, *device)); - device->sharedDeviceInfo.vmeAvcSupportsPreemption = true; - device->setPreemptionMode(PreemptionMode::MidThread); - PreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), kernel.get()); - PreemptionMode outMode = PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags); - EXPECT_EQ(PreemptionMode::MidThread, outMode); -} - -TEST_F(ThreadGroupPreemptionTests, GivenDebugKernelPreemptionWhenDeviceSupportsThreadGroupThenExpectDebugKeyMidThreadValue) { - DebugManager.flags.ForceKernelPreemptionMode.set(static_cast(PreemptionMode::MidThread)); - - EXPECT_EQ(PreemptionMode::ThreadGroup, device->getPreemptionMode()); - - PreemptionFlags flags = {}; - kernel.reset(new MockKernel(program.get(), *kernelInfo, *device)); - PreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), kernel.get()); - PreemptionMode outMode = PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags); - EXPECT_EQ(PreemptionMode::MidThread, outMode); -} - -TEST_F(MidThreadPreemptionTests, GivenDebugKernelPreemptionWhenDeviceSupportsMidThreadThenExpectDebugKeyMidBatchValue) { - DebugManager.flags.ForceKernelPreemptionMode.set(static_cast(PreemptionMode::MidBatch)); - - EXPECT_EQ(PreemptionMode::MidThread, device->getPreemptionMode()); - - PreemptionFlags flags = {}; - kernel.reset(new MockKernel(program.get(), *kernelInfo, *device)); - PreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), kernel.get()); - PreemptionMode outMode = PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags); - EXPECT_EQ(PreemptionMode::MidBatch, outMode); -} - TEST_F(DevicePreemptionTests, setDefaultMidThreadPreemption) { RuntimeCapabilityTable devCapabilities = {}; @@ -609,8 +342,9 @@ HWCMDTEST_F(IGFX_GEN8_CORE, MidThreadPreemptionTests, givenDirtyCsrStateWhenStat auto &csr = mockDevice->getUltCommandStreamReceiver(); csr.isPreambleSent = true; - CommandQueueHw commandQueue(nullptr, device.get(), 0, false); - auto &commandStream = commandQueue.getCS(4096u); + auto requiredSize = PreemptionHelper::getRequiredStateSipCmdSize(*mockDevice); + StackVec buff(requiredSize); + LinearStream commandStream(buff.begin(), buff.size()); DispatchFlags dispatchFlags = DispatchFlagsHelper::createDefaultDispatchFlags(); @@ -655,8 +389,9 @@ HWCMDTEST_F(IGFX_GEN8_CORE, MidThreadPreemptionTests, givenPreemptionProgrammedA auto &csr = mockDevice->getUltCommandStreamReceiver(); csr.isPreambleSent = true; - CommandQueueHw commandQueue(nullptr, device.get(), 0, false); - auto &commandStream = commandQueue.getCS(4096u); + auto requiredSize = PreemptionHelper::getRequiredStateSipCmdSize(*mockDevice); + StackVec buff(requiredSize); + LinearStream commandStream(buff.begin(), buff.size()); DispatchFlags dispatchFlags = DispatchFlagsHelper::createDefaultDispatchFlags();