intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-12-26 07:00:17 +08:00
Code Issues Packages Projects Releases Wiki Activity

Partially move timestamp packet tests to shared

Browse Source 
Signed-off-by: Daniel Chabrowski <daniel.chabrowski@intel.com>
This commit is contained in:
Daniel Chabrowski
2022-06-20 17:25:07 +00:00
committed by Compute-Runtime-Automation
parent 4f8a6138b2
commit 8627340ee0
4 changed files with 198 additions and 143 deletions
Download Patch File Download Diff File Expand all files Collapse all files

125
opencl/test/unit_test/helpers/timestamp_packet_1_tests.cpp
View File

@@ -27,131 +27,6 @@
using namespace NEO;
HWTEST_F(TimestampPacketTests, givenTagNodeWhenSemaphoreIsProgrammedThenUseGpuAddress) {
using MI_SEMAPHORE_WAIT = typename FamilyType::MI_SEMAPHORE_WAIT;
TimestampPackets<uint32_t> tag;
MockTagNode mockNode;
mockNode.tagForCpuAccess = &tag;
mockNode.gpuAddress = 0x1230000;
auto &cmdStream = mockCmdQ->getCS(0);
TimestampPacketHelper::programSemaphore<FamilyType>(cmdStream, mockNode);
HardwareParse hwParser;
hwParser.parseCommands<FamilyType>(cmdStream, 0);
auto it = hwParser.cmdList.begin();
verifySemaphore(genCmdCast<MI_SEMAPHORE_WAIT *>(*it++), &mockNode, 0);
}
HWTEST_F(TimestampPacketTests, givenTagNodeWithPacketsUsed2WhenSemaphoreIsProgrammedThenUseGpuAddress) {
using MI_SEMAPHORE_WAIT = typename FamilyType::MI_SEMAPHORE_WAIT;
TimestampPackets<uint32_t> tag;
MockTagNode mockNode;
mockNode.tagForCpuAccess = &tag;
mockNode.gpuAddress = 0x1230000;
mockNode.setPacketsUsed(2);
auto &cmdStream = mockCmdQ->getCS(0);
TimestampPacketHelper::programSemaphore<FamilyType>(cmdStream, mockNode);
HardwareParse hwParser;
hwParser.parseCommands<FamilyType>(cmdStream, 0);
auto it = hwParser.cmdList.begin();
for (uint32_t packetId = 0; packetId < mockNode.getPacketsUsed(); packetId++) {
verifySemaphore(genCmdCast<MI_SEMAPHORE_WAIT *>(*it++), &mockNode, packetId);
}
}
TEST_F(TimestampPacketTests, givenTagNodeWhatAskingForGpuAddressesThenReturnCorrectValue) {
TimestampPackets<uint32_t> 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<TimestampPacketContainer>::value);
EXPECT_TRUE(std::is_move_assignable<TimestampPacketContainer>::value);
EXPECT_FALSE(std::is_copy_assignable<TimestampPacketContainer>::value);
EXPECT_FALSE(std::is_copy_constructible<TimestampPacketContainer>::value);
struct MockTagNode : public TagNode<TimestampPackets<uint32_t>> {
void returnTag() override {
returnCalls++;
}
using TagNode<TimestampPackets<uint32_t>>::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<MockTimestampPackets32> allocator(0, &memoryManager, 1);
using MockNode = TagNode<MockTimestampPackets32>;
auto firstNode = static_cast<MockNode *>(allocator.getTag());
auto i = 0u;
for (auto &packet : firstNode->tagForCpuAccess->packets) {
packet.contextStart = i++;
packet.globalStart = i++;
packet.contextEnd = i++;
packet.globalEnd = i++;
}
setTagToReadyState<FamilyType>(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;