Media/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-09-15 13:01:45 +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;

34
opencl/test/unit_test/helpers/timestamp_packet_tests.h
View File

@ -20,24 +20,7 @@
using namespace NEO;
struct TimestampPacketSimpleTests : public ::testing::Test {
template <typename FamilyType>
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<TimestampPackets<uint32_t>> {
using TagNode<TimestampPackets<uint32_t>>::gpuAddress;
};
@ -74,6 +57,21 @@ struct TimestampPacketTests : public TimestampPacketSimpleTests {
EXPECT_EQ(dataAddress, semaphoreCmd->getSemaphoreGraphicsAddress());
};
template <typename FamilyType>
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<MockClDevice> device;
MockContext *context;