From 8627340ee02de058771c1c09eae7700067e66447 Mon Sep 17 00:00:00 2001 From: Daniel Chabrowski Date: Mon, 20 Jun 2022 17:25:07 +0000 Subject: [PATCH] Partially move timestamp packet tests to shared Signed-off-by: Daniel Chabrowski --- .../helpers/timestamp_packet_1_tests.cpp | 125 ------------ .../helpers/timestamp_packet_tests.h | 34 ++-- shared/test/unit_test/helpers/CMakeLists.txt | 1 + .../helpers/timestamp_packet_tests.cpp | 181 ++++++++++++++++++ 4 files changed, 198 insertions(+), 143 deletions(-) create mode 100644 shared/test/unit_test/helpers/timestamp_packet_tests.cpp diff --git a/opencl/test/unit_test/helpers/timestamp_packet_1_tests.cpp b/opencl/test/unit_test/helpers/timestamp_packet_1_tests.cpp index a0f42e0c58..1ae4669d2f 100644 --- a/opencl/test/unit_test/helpers/timestamp_packet_1_tests.cpp +++ b/opencl/test/unit_test/helpers/timestamp_packet_1_tests.cpp @@ -27,131 +27,6 @@ using namespace NEO; -HWTEST_F(TimestampPacketTests, givenTagNodeWhenSemaphoreIsProgrammedThenUseGpuAddress) { - using MI_SEMAPHORE_WAIT = typename FamilyType::MI_SEMAPHORE_WAIT; - - TimestampPackets tag; - MockTagNode mockNode; - mockNode.tagForCpuAccess = &tag; - mockNode.gpuAddress = 0x1230000; - auto &cmdStream = mockCmdQ->getCS(0); - - TimestampPacketHelper::programSemaphore(cmdStream, mockNode); - - HardwareParse hwParser; - hwParser.parseCommands(cmdStream, 0); - auto it = hwParser.cmdList.begin(); - verifySemaphore(genCmdCast(*it++), &mockNode, 0); -} - -HWTEST_F(TimestampPacketTests, givenTagNodeWithPacketsUsed2WhenSemaphoreIsProgrammedThenUseGpuAddress) { - using MI_SEMAPHORE_WAIT = typename FamilyType::MI_SEMAPHORE_WAIT; - - TimestampPackets tag; - MockTagNode mockNode; - mockNode.tagForCpuAccess = &tag; - mockNode.gpuAddress = 0x1230000; - mockNode.setPacketsUsed(2); - auto &cmdStream = mockCmdQ->getCS(0); - - TimestampPacketHelper::programSemaphore(cmdStream, mockNode); - - HardwareParse hwParser; - hwParser.parseCommands(cmdStream, 0); - auto it = hwParser.cmdList.begin(); - for (uint32_t packetId = 0; packetId < mockNode.getPacketsUsed(); packetId++) { - verifySemaphore(genCmdCast(*it++), &mockNode, packetId); - } -} - -TEST_F(TimestampPacketTests, givenTagNodeWhatAskingForGpuAddressesThenReturnCorrectValue) { - TimestampPackets tag; - MockTagNode mockNode; - mockNode.tagForCpuAccess = &tag; - mockNode.gpuAddress = 0x1230000; - - auto expectedEndAddress = mockNode.getGpuAddress() + (2 * sizeof(uint32_t)); - EXPECT_EQ(expectedEndAddress, TimestampPacketHelper::getContextEndGpuAddress(mockNode)); -} - -TEST_F(TimestampPacketSimpleTests, givenTimestampPacketContainerWhenMovedThenMoveAllNodes) { - EXPECT_TRUE(std::is_move_constructible::value); - EXPECT_TRUE(std::is_move_assignable::value); - EXPECT_FALSE(std::is_copy_assignable::value); - EXPECT_FALSE(std::is_copy_constructible::value); - - struct MockTagNode : public TagNode> { - void returnTag() override { - returnCalls++; - } - using TagNode>::refCount; - uint32_t returnCalls = 0; - }; - - MockTagNode node0; - MockTagNode node1; - - { - TimestampPacketContainer timestampPacketContainer0; - TimestampPacketContainer timestampPacketContainer1; - - timestampPacketContainer0.add(&node0); - timestampPacketContainer0.add(&node1); - - timestampPacketContainer1 = std::move(timestampPacketContainer0); - EXPECT_EQ(0u, node0.returnCalls); - EXPECT_EQ(0u, node1.returnCalls); - EXPECT_EQ(2u, timestampPacketContainer1.peekNodes().size()); - EXPECT_EQ(&node0, timestampPacketContainer1.peekNodes()[0]); - EXPECT_EQ(&node1, timestampPacketContainer1.peekNodes()[1]); - } - EXPECT_EQ(1u, node0.returnCalls); - EXPECT_EQ(1u, node1.returnCalls); -} - -HWTEST_F(TimestampPacketSimpleTests, whenNewTagIsTakenThenReinitialize) { - MockExecutionEnvironment executionEnvironment(defaultHwInfo.get()); - MockMemoryManager memoryManager(executionEnvironment); - MockTagAllocator allocator(0, &memoryManager, 1); - - using MockNode = TagNode; - - auto firstNode = static_cast(allocator.getTag()); - auto i = 0u; - for (auto &packet : firstNode->tagForCpuAccess->packets) { - packet.contextStart = i++; - packet.globalStart = i++; - packet.contextEnd = i++; - packet.globalEnd = i++; - } - - setTagToReadyState(firstNode); - allocator.returnTag(firstNode); - - auto secondNode = allocator.getTag(); - EXPECT_EQ(secondNode, firstNode); - - for (const auto &packet : firstNode->tagForCpuAccess->packets) { - EXPECT_EQ(1u, packet.contextStart); - EXPECT_EQ(1u, packet.globalStart); - EXPECT_EQ(1u, packet.contextEnd); - EXPECT_EQ(1u, packet.globalEnd); - } - EXPECT_EQ(1u, firstNode->getPacketsUsed()); -} - -TEST_F(TimestampPacketSimpleTests, whenObjectIsCreatedThenInitializeAllStamps) { - MockTimestampPackets32 timestampPacketStorage; - EXPECT_EQ(TimestampPacketSizeControl::preferredPacketCount * sizeof(timestampPacketStorage.packets[0]), sizeof(timestampPacketStorage.packets)); - - for (const auto &packet : timestampPacketStorage.packets) { - EXPECT_EQ(1u, packet.contextStart); - EXPECT_EQ(1u, packet.globalStart); - EXPECT_EQ(1u, packet.contextEnd); - EXPECT_EQ(1u, packet.globalEnd); - } -} - HWTEST_F(TimestampPacketTests, givenCommandStreamReceiverHwWhenObtainingPreferredTagPoolSizeThenReturnCorrectValue) { OsContext &osContext = *executionEnvironment->memoryManager->getRegisteredEngines()[0].osContext; diff --git a/opencl/test/unit_test/helpers/timestamp_packet_tests.h b/opencl/test/unit_test/helpers/timestamp_packet_tests.h index 96499f5faf..7c8a81dcad 100644 --- a/opencl/test/unit_test/helpers/timestamp_packet_tests.h +++ b/opencl/test/unit_test/helpers/timestamp_packet_tests.h @@ -20,24 +20,7 @@ using namespace NEO; -struct TimestampPacketSimpleTests : public ::testing::Test { - template - void setTagToReadyState(TagNodeBase *tagNode) { - auto packetsUsed = tagNode->getPacketsUsed(); - tagNode->initialize(); - - typename FamilyType::TimestampPacketType zeros[4] = {}; - - for (uint32_t i = 0; i < TimestampPacketSizeControl::preferredPacketCount; i++) { - tagNode->assignDataToAllTimestamps(i, zeros); - } - tagNode->setPacketsUsed(packetsUsed); - } - - const size_t gws[3] = {1, 1, 1}; -}; - -struct TimestampPacketTests : public TimestampPacketSimpleTests { +struct TimestampPacketTests : public ::testing::Test { struct MockTagNode : public TagNode> { using TagNode>::gpuAddress; }; @@ -74,6 +57,21 @@ struct TimestampPacketTests : public TimestampPacketSimpleTests { EXPECT_EQ(dataAddress, semaphoreCmd->getSemaphoreGraphicsAddress()); }; + template + void setTagToReadyState(TagNodeBase *tagNode) { + auto packetsUsed = tagNode->getPacketsUsed(); + tagNode->initialize(); + + typename FamilyType::TimestampPacketType zeros[4] = {}; + + for (uint32_t i = 0; i < TimestampPacketSizeControl::preferredPacketCount; i++) { + tagNode->assignDataToAllTimestamps(i, zeros); + } + tagNode->setPacketsUsed(packetsUsed); + } + + const size_t gws[3] = {1, 1, 1}; + ExecutionEnvironment *executionEnvironment; std::unique_ptr device; MockContext *context; diff --git a/shared/test/unit_test/helpers/CMakeLists.txt b/shared/test/unit_test/helpers/CMakeLists.txt index cc0dff85e0..88b1e0c120 100644 --- a/shared/test/unit_test/helpers/CMakeLists.txt +++ b/shared/test/unit_test/helpers/CMakeLists.txt @@ -29,6 +29,7 @@ set(IGDRCL_SRCS_tests_helpers ${CMAKE_CURRENT_SOURCE_DIR}/static_size3.h ${CMAKE_CURRENT_SOURCE_DIR}/test_debug_variables.inl ${CMAKE_CURRENT_SOURCE_DIR}/test_hw_info_config.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/timestamp_packet_tests.cpp ${CMAKE_CURRENT_SOURCE_DIR}/ult_limits.h ) diff --git a/shared/test/unit_test/helpers/timestamp_packet_tests.cpp b/shared/test/unit_test/helpers/timestamp_packet_tests.cpp new file mode 100644 index 0000000000..8f2588353c --- /dev/null +++ b/shared/test/unit_test/helpers/timestamp_packet_tests.cpp @@ -0,0 +1,181 @@ +/* + * Copyright (C) 2022 Intel Corporation + * + * SPDX-License-Identifier: MIT + * + */ + +#include "shared/source/command_stream/command_stream_receiver_hw.h" +#include "shared/source/helpers/timestamp_packet.h" +#include "shared/source/utilities/tag_allocator.h" +#include "shared/test/common/cmd_parse/hw_parse.h" +#include "shared/test/common/helpers/debug_manager_state_restore.h" +#include "shared/test/common/mocks/mock_execution_environment.h" +#include "shared/test/common/mocks/mock_memory_manager.h" +#include "shared/test/common/mocks/mock_timestamp_container.h" +#include "shared/test/common/mocks/mock_timestamp_packet.h" +#include "shared/test/common/test_macros/test.h" + +#include + +using namespace NEO; + +struct TimestampPacketTests : public ::testing::Test { + struct MockTagNode : public TagNode> { + using TagNode>::gpuAddress; + }; + + template + void verifySemaphore(MI_SEMAPHORE_WAIT *semaphoreCmd, TagNodeBase *timestampPacketNode, uint32_t packetId) { + EXPECT_NE(nullptr, semaphoreCmd); + EXPECT_EQ(semaphoreCmd->getCompareOperation(), MI_SEMAPHORE_WAIT::COMPARE_OPERATION::COMPARE_OPERATION_SAD_NOT_EQUAL_SDD); + EXPECT_EQ(1u, semaphoreCmd->getSemaphoreDataDword()); + + uint64_t compareOffset = packetId * TimestampPackets::getSinglePacketSize(); + auto dataAddress = TimestampPacketHelper::getContextEndGpuAddress(*timestampPacketNode) + compareOffset; + + EXPECT_EQ(dataAddress, semaphoreCmd->getSemaphoreGraphicsAddress()); + }; + + template + void setTagToReadyState(TagNodeBase *tagNode) { + auto packetsUsed = tagNode->getPacketsUsed(); + tagNode->initialize(); + + typename FamilyType::TimestampPacketType zeros[4] = {}; + + for (uint32_t i = 0; i < TimestampPacketSizeControl::preferredPacketCount; i++) { + tagNode->assignDataToAllTimestamps(i, zeros); + } + tagNode->setPacketsUsed(packetsUsed); + } +}; + +HWTEST_F(TimestampPacketTests, givenTagNodeWhenSemaphoreIsProgrammedThenUseGpuAddress) { + using MI_SEMAPHORE_WAIT = typename FamilyType::MI_SEMAPHORE_WAIT; + + TimestampPackets tag; + MockTagNode mockNode; + mockNode.tagForCpuAccess = &tag; + mockNode.gpuAddress = 0x1230000; + + StackVec buffer(4096); + LinearStream cmdStream(buffer.begin(), buffer.size()); + + TimestampPacketHelper::programSemaphore(cmdStream, mockNode); + + HardwareParse hwParser; + hwParser.parseCommands(cmdStream, 0); + auto it = hwParser.cmdList.begin(); + verifySemaphore(genCmdCast(*it++), &mockNode, 0); +} + +HWTEST_F(TimestampPacketTests, givenTagNodeWithPacketsUsed2WhenSemaphoreIsProgrammedThenUseGpuAddress) { + using MI_SEMAPHORE_WAIT = typename FamilyType::MI_SEMAPHORE_WAIT; + + TimestampPackets tag; + MockTagNode mockNode; + mockNode.tagForCpuAccess = &tag; + mockNode.gpuAddress = 0x1230000; + mockNode.setPacketsUsed(2); + + StackVec buffer(4096); + LinearStream cmdStream(buffer.begin(), buffer.size()); + + TimestampPacketHelper::programSemaphore(cmdStream, mockNode); + + HardwareParse hwParser; + hwParser.parseCommands(cmdStream, 0); + auto it = hwParser.cmdList.begin(); + for (uint32_t packetId = 0; packetId < mockNode.getPacketsUsed(); packetId++) { + verifySemaphore(genCmdCast(*it++), &mockNode, packetId); + } +} + +TEST_F(TimestampPacketTests, givenTagNodeWhatAskingForGpuAddressesThenReturnCorrectValue) { + TimestampPackets tag; + MockTagNode mockNode; + mockNode.tagForCpuAccess = &tag; + mockNode.gpuAddress = 0x1230000; + + auto expectedEndAddress = mockNode.getGpuAddress() + (2 * sizeof(uint32_t)); + EXPECT_EQ(expectedEndAddress, TimestampPacketHelper::getContextEndGpuAddress(mockNode)); +} + +TEST_F(TimestampPacketTests, givenTimestampPacketContainerWhenMovedThenMoveAllNodes) { + EXPECT_TRUE(std::is_move_constructible::value); + EXPECT_TRUE(std::is_move_assignable::value); + EXPECT_FALSE(std::is_copy_assignable::value); + EXPECT_FALSE(std::is_copy_constructible::value); + + struct MockTagNode : public TagNode> { + void returnTag() override { + returnCalls++; + } + using TagNode>::refCount; + uint32_t returnCalls = 0; + }; + + MockTagNode node0; + MockTagNode node1; + + { + TimestampPacketContainer timestampPacketContainer0; + TimestampPacketContainer timestampPacketContainer1; + + timestampPacketContainer0.add(&node0); + timestampPacketContainer0.add(&node1); + + timestampPacketContainer1 = std::move(timestampPacketContainer0); + EXPECT_EQ(0u, node0.returnCalls); + EXPECT_EQ(0u, node1.returnCalls); + EXPECT_EQ(2u, timestampPacketContainer1.peekNodes().size()); + EXPECT_EQ(&node0, timestampPacketContainer1.peekNodes()[0]); + EXPECT_EQ(&node1, timestampPacketContainer1.peekNodes()[1]); + } + EXPECT_EQ(1u, node0.returnCalls); + EXPECT_EQ(1u, node1.returnCalls); +} + +HWTEST_F(TimestampPacketTests, whenNewTagIsTakenThenReinitialize) { + MockExecutionEnvironment executionEnvironment(defaultHwInfo.get()); + MockMemoryManager memoryManager(executionEnvironment); + MockTagAllocator allocator(0, &memoryManager, 1); + + using MockNode = TagNode; + + auto firstNode = static_cast(allocator.getTag()); + auto i = 0u; + for (auto &packet : firstNode->tagForCpuAccess->packets) { + packet.contextStart = i++; + packet.globalStart = i++; + packet.contextEnd = i++; + packet.globalEnd = i++; + } + + setTagToReadyState(firstNode); + allocator.returnTag(firstNode); + + auto secondNode = allocator.getTag(); + EXPECT_EQ(secondNode, firstNode); + + for (const auto &packet : firstNode->tagForCpuAccess->packets) { + EXPECT_EQ(1u, packet.contextStart); + EXPECT_EQ(1u, packet.globalStart); + EXPECT_EQ(1u, packet.contextEnd); + EXPECT_EQ(1u, packet.globalEnd); + } + EXPECT_EQ(1u, firstNode->getPacketsUsed()); +} + +TEST_F(TimestampPacketTests, whenObjectIsCreatedThenInitializeAllStamps) { + MockTimestampPackets32 timestampPacketStorage; + EXPECT_EQ(TimestampPacketSizeControl::preferredPacketCount * sizeof(timestampPacketStorage.packets[0]), sizeof(timestampPacketStorage.packets)); + + for (const auto &packet : timestampPacketStorage.packets) { + EXPECT_EQ(1u, packet.contextStart); + EXPECT_EQ(1u, packet.globalStart); + EXPECT_EQ(1u, packet.contextEnd); + EXPECT_EQ(1u, packet.globalEnd); + } +}