AI/rocm-systems
2
0 Derivar 0
Código Questões Pedidos de integração Operações (Actions) Pacotes Planeamentos Lançamentos Wiki Trabalho

kfdtest: Consolidate logic for ASSERT vs EXPECT

Ver a proveniência 
ASSERT failures result in immediate termination of the test. EXPECT
returns a failure but continues execution. Reserve ASSERT for required
functionality (node initialization, queue creation, etc) where the rest
of the test cannot run if that call fails. Use EXPECT everywhere else

Change-Id: I1c11326fc3ae22b50fa83b07b3b49af1e1f4e69e
Este cometimento está contido em:
Kent Russell cometeu 2018-08-23 06:20:18 -04:00
1 ascendente 414042abf7
cometimento fe33461622
17 ficheiros modificados
+208 -209
Descarregar ficheiro patch Descarregar ficheiro diff Expandir todos os ficheiros Colapsar todos os ficheiros

Não existem ficheiros que correspondam à sua pesquisa

tests/kfdtest/src/KFDBaseComponentTest.cpp
+2 -2
Ver ficheiro
@@ -79,8 +79,8 @@ void KFDBaseComponentTest::TearDown() {
drmClose(m_RenderNodes[i].fd);
}
ASSERT_SUCCESS(hsaKmtReleaseSystemProperties());
ASSERT_SUCCESS(hsaKmtCloseKFD());
EXPECT_SUCCESS(hsaKmtReleaseSystemProperties());
EXPECT_SUCCESS(hsaKmtCloseKFD());
ROUTINE_END
}
tests/kfdtest/src/KFDCWSRTest.cpp
+2 -2
Ver ficheiro
@@ -135,7 +135,7 @@ TEST_F(KFDCWSRTest, BasicTest) {
PM4Queue queue1, queue2;
EXPECT_SUCCESS(queue1.Create(defaultGPUNode));
ASSERT_SUCCESS(queue1.Create(defaultGPUNode));
Dispatch *dispatch1, *dispatch2;
@@ -153,7 +153,7 @@ TEST_F(KFDCWSRTest, BasicTest) {
// Submit the shader, queue1
dispatch1->Submit(queue1);
// Create queue2 during queue1 still running will trigger the CWSR
EXPECT_SUCCESS(queue2.Create(defaultGPUNode));
ASSERT_SUCCESS(queue2.Create(defaultGPUNode));
// Submit the shader
dispatch2->Submit(queue2);
dispatch1->Sync();
tests/kfdtest/src/KFDDBGTest.cpp
+4 -4
Ver ficheiro
@@ -163,11 +163,11 @@ TEST_F(KFDDBGTest, BasicAddressWatch) {
dispatch.Sync(g_TestTimeOut);
// Check that we got trap handler calls due to add watch triggers
ASSERT_GE(*(tmaBuf.As<unsigned int*>()+ TMA_TRAP_COUNT_OFFSET), TMA_TRAP_COUNT_VALUE);
EXPECT_GE(*(tmaBuf.As<unsigned int*>()+ TMA_TRAP_COUNT_OFFSET), TMA_TRAP_COUNT_VALUE);
ASSERT_SUCCESS(hsaKmtDbgUnregister(defaultGPUNode));
ASSERT_SUCCESS(queue.Destroy());
ASSERT_SUCCESS(queue_flush.Destroy());
EXPECT_SUCCESS(hsaKmtDbgUnregister(defaultGPUNode));
EXPECT_SUCCESS(queue.Destroy());
EXPECT_SUCCESS(queue_flush.Destroy());
} else {
LOG() << "Skipping test: Test not supported on family ID 0x" << m_FamilyId << "." << std::endl;
}
tests/kfdtest/src/KFDEventTest.cpp
+5 -6
Ver ficheiro
@@ -99,9 +99,9 @@ TEST_F(KFDEventTest, SignalEvent) {
queue.Wait4PacketConsumption();
ASSERT_SUCCESS(hsaKmtWaitOnEvent(m_pHsaEvent, g_TestTimeOut));
EXPECT_SUCCESS(hsaKmtWaitOnEvent(m_pHsaEvent, g_TestTimeOut));
ASSERT_SUCCESS(queue.Destroy());
EXPECT_SUCCESS(queue.Destroy());
TEST_END;
}
@@ -184,8 +184,7 @@ exit:
uint64_t minTime = ULONG_MAX, maxTime = 0;
uint64_t minLat = ULONG_MAX, maxLat = 0;
r = queueAndSignalEvents(node, mNumEvents, time, latency);
ASSERT_EQ(r, HSAKMT_STATUS_SUCCESS);
ASSERT_EQ(queueAndSignalEvents(node, mNumEvents, time, latency), HSAKMT_STATUS_SUCCESS);
mTimeHistory[mHistorySlot%HISTORY_SIZE] = time;
mLatHistory[mHistorySlot%HISTORY_SIZE] = latency;
@@ -275,9 +274,9 @@ TEST_F(KFDEventTest, SignalMultipleEventsWaitForAll) {
Delay(WAIT_BETWEEN_SUBMISSIONS_MS);
}
ASSERT_SUCCESS(hsaKmtWaitOnMultipleEvents(pHsaEvent, EVENT_NUMBER, true, g_TestTimeOut));
EXPECT_SUCCESS(hsaKmtWaitOnMultipleEvents(pHsaEvent, EVENT_NUMBER, true, g_TestTimeOut));
ASSERT_SUCCESS(queue.Destroy());
EXPECT_SUCCESS(queue.Destroy());
for (i = 0; i < EVENT_NUMBER; i++)
EXPECT_SUCCESS(hsaKmtDestroyEvent(pHsaEvent[i]));
tests/kfdtest/src/KFDEvictTest.cpp
+7 -7
Ver ficheiro
@@ -227,16 +227,16 @@ void KFDEvictTest::AmdgpuCommandSubmissionComputeNop(int rn) {
fenceStatus.ring = 0;
fenceStatus.fence = ibsRequest.seq_no;
ASSERT_EQ(0, amdgpu_cs_query_fence_status(&fenceStatus,
EXPECT_EQ(0, amdgpu_cs_query_fence_status(&fenceStatus,
g_TestTimeOut,
0, &expired));
ASSERT_EQ(0, amdgpu_bo_list_destroy(boList));
EXPECT_EQ(0, amdgpu_bo_list_destroy(boList));
ASSERT_EQ(0, amdgpu_bo_unmap_and_free(ibResultHandle, vaHandle,
EXPECT_EQ(0, amdgpu_bo_unmap_and_free(ibResultHandle, vaHandle,
ibResultMcAddress, PAGE_SIZE));
ASSERT_EQ(0, amdgpu_cs_ctx_free(contextHandle));
EXPECT_EQ(0, amdgpu_cs_ctx_free(contextHandle));
}
void KFDEvictTest::ForkChildProcesses(int nprocesses) {
@@ -283,7 +283,7 @@ void KFDEvictTest::WaitChildProcesses() {
m_ChildPids.erase(m_ChildPids.begin());
}
ASSERT_EQ(childExitOkNum, size);
EXPECT_EQ(childExitOkNum, size);
}
/* Child process or parent process finished successfully */
@@ -598,7 +598,7 @@ TEST_F(KFDEvictTest, QueueTest) {
/* Wait for shader to finish or timeout if shader has vm page fault */
dispatch0.SyncWithStatus(120000);
ASSERT_SUCCESS(pm4Queue.Destroy());
EXPECT_SUCCESS(pm4Queue.Destroy());
FreeAmdgpuBo(handle);
@@ -610,7 +610,7 @@ TEST_F(KFDEvictTest, QueueTest) {
/* Check if all wavefronts finished successfully */
for (i = 0; i < wavefront_num; i++)
ASSERT_EQ(0x5678, *(result + i));
EXPECT_EQ(0x5678, *(result + i));
WaitChildProcesses();
tests/kfdtest/src/KFDExceptionTest.cpp
+16 -16
Ver ficheiro
@@ -144,11 +144,11 @@ TEST_F(KFDExceptionTest, InvalidBadAddress) {
waitpid(m_ChildPid, &childStatus, 0);
if (is_dgpu()) {
ASSERT_EQ(WIFEXITED(childStatus), true);
ASSERT_EQ(WEXITSTATUS(childStatus), HSAKMT_STATUS_SUCCESS);
EXPECT_EQ(WIFEXITED(childStatus), true);
EXPECT_EQ(WEXITSTATUS(childStatus), HSAKMT_STATUS_SUCCESS);
} else {
ASSERT_EQ(WIFSIGNALED(childStatus), true);
ASSERT_EQ(WTERMSIG(childStatus), SIGSEGV);
EXPECT_EQ(WIFSIGNALED(childStatus), true);
EXPECT_EQ(WTERMSIG(childStatus), SIGSEGV);
}
}
@@ -204,8 +204,8 @@ TEST_F(KFDExceptionTest, InvalidPPRWriteProtection) {
int childStatus;
waitpid(m_ChildPid, &childStatus, 0);
ASSERT_EQ(WIFSIGNALED(childStatus), true);
ASSERT_EQ(WTERMSIG(childStatus), SIGSEGV);
EXPECT_EQ(WIFSIGNALED(childStatus), true);
EXPECT_EQ(WTERMSIG(childStatus), SIGSEGV);
}
TEST_END
@@ -254,8 +254,8 @@ TEST_F(KFDExceptionTest, InvalidPPRReadProtection) {
int childStatus;
waitpid(m_ChildPid, &childStatus, 0);
ASSERT_EQ(WIFSIGNALED(childStatus), true);
ASSERT_EQ(WTERMSIG(childStatus), SIGSEGV);
EXPECT_EQ(WIFSIGNALED(childStatus), true);
EXPECT_EQ(WTERMSIG(childStatus), SIGSEGV);
}
TEST_END
@@ -298,11 +298,11 @@ TEST_F(KFDExceptionTest, InvalidWriteAddress) {
waitpid(m_ChildPid, &childStatus, 0);
if (is_dgpu()) {
ASSERT_EQ(WIFEXITED(childStatus), true);
ASSERT_EQ(WEXITSTATUS(childStatus), HSAKMT_STATUS_SUCCESS);
EXPECT_EQ(WIFEXITED(childStatus), true);
EXPECT_EQ(WEXITSTATUS(childStatus), HSAKMT_STATUS_SUCCESS);
} else {
ASSERT_EQ(WIFSIGNALED(childStatus), true);
ASSERT_EQ(WTERMSIG(childStatus), SIGSEGV);
EXPECT_EQ(WIFSIGNALED(childStatus), true);
EXPECT_EQ(WTERMSIG(childStatus), SIGSEGV);
}
}
@@ -340,11 +340,11 @@ TEST_F(KFDExceptionTest, FaultStorm) {
waitpid(m_ChildPid, &childStatus, 0);
if (is_dgpu()) {
ASSERT_EQ(WIFEXITED(childStatus), true);
ASSERT_EQ(WEXITSTATUS(childStatus), HSAKMT_STATUS_SUCCESS);
EXPECT_EQ(WIFEXITED(childStatus), true);
EXPECT_EQ(WEXITSTATUS(childStatus), HSAKMT_STATUS_SUCCESS);
} else {
ASSERT_EQ(WIFSIGNALED(childStatus), true);
ASSERT_EQ(WTERMSIG(childStatus), SIGSEGV);
EXPECT_EQ(WIFSIGNALED(childStatus), true);
EXPECT_EQ(WTERMSIG(childStatus), SIGSEGV);
}
}
tests/kfdtest/src/KFDGraphicsInterop.cpp
+16 -16
Ver ficheiro
@@ -66,17 +66,17 @@ TEST_F(KFDGraphicsInterop, RegisterGraphicsHandle) {
void *pCpuMap;
ASSERT_EQ(0, amdgpu_bo_cpu_map(handle, &pCpuMap));
memset(pCpuMap, 0xaa, PAGE_SIZE);
ASSERT_EQ(0, amdgpu_bo_cpu_unmap(handle));
EXPECT_EQ(0, amdgpu_bo_cpu_unmap(handle));
struct amdgpu_bo_metadata meta;
meta.flags = 0;
meta.tiling_info = 0;
meta.size_metadata = metadata_size;
memcpy(meta.umd_metadata, metadata, metadata_size);
ASSERT_EQ(0, amdgpu_bo_set_metadata(handle, &meta));
EXPECT_EQ(0, amdgpu_bo_set_metadata(handle, &meta));
uint32_t dmabufFd;
ASSERT_EQ(0, amdgpu_bo_export(handle, amdgpu_bo_handle_type_dma_buf_fd, &dmabufFd));
EXPECT_EQ(0, amdgpu_bo_export(handle, amdgpu_bo_handle_type_dma_buf_fd, &dmabufFd));
// Register it with HSA
HsaGraphicsResourceInfo info;
@@ -86,13 +86,13 @@ TEST_F(KFDGraphicsInterop, RegisterGraphicsHandle) {
/* DMA buffer handle and GEM handle are no longer needed, KFD
* should have taken a reference to the BO
*/
ASSERT_EQ(0, close(dmabufFd));
ASSERT_EQ(0, amdgpu_bo_free(handle));
EXPECT_EQ(0, close(dmabufFd));
EXPECT_EQ(0, amdgpu_bo_free(handle));
// Check that buffer size and metadata match
ASSERT_EQ(info.SizeInBytes, alloc.alloc_size);
ASSERT_EQ(info.MetadataSizeInBytes, metadata_size);
ASSERT_EQ(0, strcmp(metadata, (const char *)info.Metadata));
EXPECT_EQ(info.SizeInBytes, alloc.alloc_size);
EXPECT_EQ(info.MetadataSizeInBytes, metadata_size);
EXPECT_EQ(0, strcmp(metadata, (const char *)info.Metadata));
// Map the buffer
ASSERT_SUCCESS(hsaKmtMapMemoryToGPU(info.MemoryAddress,
@@ -113,9 +113,9 @@ TEST_F(KFDGraphicsInterop, RegisterGraphicsHandle) {
dispatch.Submit(queue);
dispatch.Sync(g_TestTimeOut);
ASSERT_SUCCESS(queue.Destroy());
EXPECT_SUCCESS(queue.Destroy());
ASSERT_EQ(dstBuffer.As<unsigned int *>()[0], 0xaaaaaaaa);
EXPECT_EQ(dstBuffer.As<unsigned int *>()[0], 0xaaaaaaaa);
// Test QueryMem before the cleanup
HsaPointerInfo ptrInfo;
@@ -126,8 +126,8 @@ TEST_F(KFDGraphicsInterop, RegisterGraphicsHandle) {
EXPECT_EQ(ptrInfo.SizeInBytes, alloc.alloc_size);
// Cleanup
ASSERT_SUCCESS(hsaKmtUnmapMemoryToGPU(info.MemoryAddress));
ASSERT_SUCCESS(hsaKmtDeregisterMemory(info.MemoryAddress));
EXPECT_SUCCESS(hsaKmtUnmapMemoryToGPU(info.MemoryAddress));
EXPECT_SUCCESS(hsaKmtDeregisterMemory(info.MemoryAddress));
TEST_END
}
@@ -214,11 +214,11 @@ TEST_F(KFDGraphicsInterop, RegisterForeignDeviceMem) {
dispatch.Submit(queue);
dispatch.Sync(g_TestTimeOut);
ASSERT_SUCCESS(queue.Destroy());
ASSERT_EQ(dstBuffer.As<HSAuint32*>()[0], 0xAAAAAAAA);
EXPECT_SUCCESS(queue.Destroy());
EXPECT_EQ(dstBuffer.As<HSAuint32*>()[0], 0xAAAAAAAA);
ASSERT_EQ(0, amdgpu_bo_cpu_unmap(handle));
ASSERT_EQ(0, amdgpu_bo_free(handle));
EXPECT_EQ(0, amdgpu_bo_cpu_unmap(handle));
EXPECT_EQ(0, amdgpu_bo_free(handle));
TEST_END
}
tests/kfdtest/src/KFDIPCTest.cpp
+21 -21
Ver ficheiro
@@ -89,16 +89,16 @@ void KFDIPCTest::BasicTestChildProcess(int defaultGPUNode, int *pipefd) {
sdmaQueue.PlaceAndSubmitPacket(SDMACopyDataPacket(tempSysBuffer.As<HSAuint32*>(),
sharedLocalBuffer, size));
sdmaQueue.Wait4PacketConsumption();
ASSERT_TRUE(WaitOnValue(tempSysBuffer.As<HSAuint32*>(), 0xAAAAAAAA));
EXPECT_TRUE(WaitOnValue(tempSysBuffer.As<HSAuint32*>(), 0xAAAAAAAA));
/* Fill in the Local Memory with different pattern */
sdmaQueue.PlaceAndSubmitPacket(SDMAWriteDataPacket(sharedLocalBuffer, 0xBBBBBBBB));
sdmaQueue.Wait4PacketConsumption();
/* Clean up */
ASSERT_SUCCESS(sdmaQueue.Destroy());
ASSERT_SUCCESS(hsaKmtUnmapMemoryToGPU(sharedLocalBuffer));
ASSERT_SUCCESS(hsaKmtDeregisterMemory(sharedLocalBuffer));
EXPECT_SUCCESS(sdmaQueue.Destroy());
EXPECT_SUCCESS(hsaKmtUnmapMemoryToGPU(sharedLocalBuffer));
EXPECT_SUCCESS(hsaKmtDeregisterMemory(sharedLocalBuffer));
}
/* Fill a pattern into Local Memory and share with the child process.
@@ -133,18 +133,18 @@ void KFDIPCTest::BasicTestParentProcess(int defaultGPUNode, pid_t cpid, int *pip
/* Wait for the child to finish */
waitpid(cpid, &status, 0);
ASSERT_EQ(WIFEXITED(status), 1);
ASSERT_EQ(WEXITSTATUS(status), 0);
EXPECT_EQ(WIFEXITED(status), 1);
EXPECT_EQ(WEXITSTATUS(status), 0);
/* Check for the new pattern filled in by child process */
sdmaQueue.PlaceAndSubmitPacket(SDMACopyDataPacket(tempSysBuffer.As<HSAuint32*>(),
toShareLocalBuffer.As<HSAuint32*>(), size));
sdmaQueue.Wait4PacketConsumption();
ASSERT_TRUE(WaitOnValue(tempSysBuffer.As<HSAuint32*>(), 0xBBBBBBBB));
EXPECT_TRUE(WaitOnValue(tempSysBuffer.As<HSAuint32*>(), 0xBBBBBBBB));
/* Clean up */
ASSERT_SUCCESS(hsaKmtUnmapMemoryToGPU(toShareLocalBuffer.As<void*>()));
ASSERT_SUCCESS(sdmaQueue.Destroy());
EXPECT_SUCCESS(hsaKmtUnmapMemoryToGPU(toShareLocalBuffer.As<void*>()));
EXPECT_SUCCESS(sdmaQueue.Destroy());
}
/* Test IPC memory.
@@ -620,23 +620,23 @@ TEST_F(KFDIPCTest, CrossMemoryAttachTest) {
/* Child Process */
status = CrossMemoryAttachChildProcess(defaultGPUNode, pipeCtoP[1],
pipePtoC[0], CMA_READ_TEST);
ASSERT_EQ(status, CMA_TEST_SUCCESS) << "Child: Read Test Fail";
EXPECT_EQ(status, CMA_TEST_SUCCESS) << "Child: Read Test Fail";
status = CrossMemoryAttachChildProcess(defaultGPUNode, pipeCtoP[1],
pipePtoC[0], CMA_WRITE_TEST);
ASSERT_EQ(status, CMA_TEST_SUCCESS) << "Child: Write Test Fail";
EXPECT_EQ(status, CMA_TEST_SUCCESS) << "Child: Write Test Fail";
} else {
int childStatus;
status = CrossMemoryAttachParentProcess(defaultGPUNode, m_ChildPid,
pipePtoC[1], pipeCtoP[0], CMA_READ_TEST); /* Parent proces */
ASSERT_EQ(status, CMA_TEST_SUCCESS) << "Parent: Read Test Fail";
EXPECT_EQ(status, CMA_TEST_SUCCESS) << "Parent: Read Test Fail";
status = CrossMemoryAttachParentProcess(defaultGPUNode, m_ChildPid,
pipePtoC[1], pipeCtoP[0], CMA_WRITE_TEST);
ASSERT_EQ(status, CMA_TEST_SUCCESS) << "Parent: Write Test Fail";
EXPECT_EQ(status, CMA_TEST_SUCCESS) << "Parent: Write Test Fail";
waitpid(m_ChildPid, &childStatus, 0);
ASSERT_EQ(WIFEXITED(childStatus), true);
ASSERT_EQ(WEXITSTATUS(childStatus), 0);
EXPECT_EQ(WIFEXITED(childStatus), true);
EXPECT_EQ(WEXITSTATUS(childStatus), 0);
}
/* Code path executed by both parent and child with respective fds */
@@ -690,10 +690,10 @@ TEST_F(KFDIPCTest, CMABasicTest) {
dstRange.MemoryAddress = testLocalBuffer.As<void*>();
dstRange.SizeInBytes = size;
ASSERT_SUCCESS(hsaKmtProcessVMRead(getpid(), &dstRange, 1, &srcRange, 1, &copied));
ASSERT_EQ(copied, size);
EXPECT_EQ(copied, size);
ASSERT_TRUE(testLocalBuffer.IsPattern(0, PATTERN1, sdmaQueue, tmp));
ASSERT_TRUE(testLocalBuffer.IsPattern(size - 4, PATTERN2, sdmaQueue, tmp));
EXPECT_TRUE(testLocalBuffer.IsPattern(0, PATTERN1, sdmaQueue, tmp));
EXPECT_TRUE(testLocalBuffer.IsPattern(size - 4, PATTERN2, sdmaQueue, tmp));
/* Test2. Test unaligned byte copy. Write 3 bytes to an unaligned destination address */
@@ -712,10 +712,10 @@ TEST_F(KFDIPCTest, CMABasicTest) {
dstRange.MemoryAddress = reinterpret_cast<void *>(testLocalBuffer.As<char*>() + (size / 2) + unaligned_offset);
dstRange.SizeInBytes = unaligned_size;
ASSERT_SUCCESS(hsaKmtProcessVMRead(getpid(), &dstRange, 1, &srcRange, 1, &copied));
ASSERT_EQ(copied, unaligned_size);
EXPECT_EQ(copied, unaligned_size);
expected_pattern = (PATTERN2 & ~unaligned_mask | (PATTERN1 & unaligned_mask));
ASSERT_TRUE(testLocalBuffer.IsPattern(size/2, expected_pattern, sdmaQueue, tmp));
EXPECT_TRUE(testLocalBuffer.IsPattern(size/2, expected_pattern, sdmaQueue, tmp));
/* Test3. Test overflow and expect failure */
@@ -727,7 +727,7 @@ TEST_F(KFDIPCTest, CMABasicTest) {
EXPECT_NE(status, HSAKMT_STATUS_SUCCESS);
EXPECT_LE(copied, (size - 4));
ASSERT_SUCCESS(sdmaQueue.Destroy());
EXPECT_SUCCESS(sdmaQueue.Destroy());
TEST_END
}
tests/kfdtest/src/KFDLocalMemoryTest.cpp
+10 -10
Ver ficheiro
@@ -96,11 +96,11 @@ TEST_F(KFDLocalMemoryTest, BasicTest) {
dispatch.Submit(queue);
dispatch.Sync(g_TestTimeOut);
ASSERT_SUCCESS(queue.Destroy());
EXPECT_SUCCESS(queue.Destroy());
ASSERT_SUCCESS(hsaKmtUnmapMemoryToGPU(srcLocalBuffer.As<void*>()));
ASSERT_SUCCESS(hsaKmtUnmapMemoryToGPU(dstLocalBuffer.As<void*>()));
ASSERT_EQ(destSysBuffer.As<unsigned int*>()[0], 0x01010101);
EXPECT_SUCCESS(hsaKmtUnmapMemoryToGPU(srcLocalBuffer.As<void*>()));
EXPECT_SUCCESS(hsaKmtUnmapMemoryToGPU(dstLocalBuffer.As<void*>()));
EXPECT_EQ(destSysBuffer.As<unsigned int*>()[0], 0x01010101);
TEST_END
}
@@ -142,17 +142,17 @@ TEST_F(KFDLocalMemoryTest, VerifyContentsAfterUnmapAndMap) {
dispatch.Submit(queue);
dispatch.Sync(g_TestTimeOut);
ASSERT_SUCCESS(hsaKmtUnmapMemoryToGPU(LocalBuffer.As<void*>()));
ASSERT_SUCCESS(hsaKmtMapMemoryToGPU(LocalBuffer.As<void*>(), LocalBuffer.Size(), &AlternateVAGPU));
EXPECT_SUCCESS(hsaKmtUnmapMemoryToGPU(LocalBuffer.As<void*>()));
EXPECT_SUCCESS(hsaKmtMapMemoryToGPU(LocalBuffer.As<void*>(), LocalBuffer.Size(), &AlternateVAGPU));
dispatch.SetArgs(LocalBuffer.As<void*>(), SysBufferB.As<void*>());
dispatch.Submit(queue);
dispatch.Sync(g_TestTimeOut);
ASSERT_SUCCESS(queue.Destroy());
ASSERT_EQ(SysBufferB.As<unsigned int*>()[0], 0x01010101);
EXPECT_SUCCESS(queue.Destroy());
EXPECT_EQ(SysBufferB.As<unsigned int*>()[0], 0x01010101);
if (!is_dgpu())
ASSERT_SUCCESS(hsaKmtUnmapMemoryToGPU(LocalBuffer.As<void*>()));
EXPECT_SUCCESS(hsaKmtUnmapMemoryToGPU(LocalBuffer.As<void*>()));
TEST_END
}
@@ -378,7 +378,7 @@ TEST_F(KFDLocalMemoryTest, Fragmentation) {
delete[] pages[order].pointers;
}
ASSERT_SUCCESS(queue.Destroy());
EXPECT_SUCCESS(queue.Destroy());
TEST_END
}
tests/kfdtest/src/KFDMemoryTest.cpp
+58 -58
Ver ficheiro
@@ -177,8 +177,8 @@ TEST_F(KFDMemoryTest, MMapLarge) {
<< "GB system memory to gpu" << std::endl;
while (i--) {
ASSERT_SUCCESS(hsaKmtUnmapMemoryToGPU(reinterpret_cast<void*>(AlternateVAGPU[i])));
ASSERT_SUCCESS(hsaKmtDeregisterMemory(reinterpret_cast<void*>(AlternateVAGPU[i])));
EXPECT_SUCCESS(hsaKmtUnmapMemoryToGPU(reinterpret_cast<void*>(AlternateVAGPU[i])));
EXPECT_SUCCESS(hsaKmtDeregisterMemory(reinterpret_cast<void*>(AlternateVAGPU[i])));
}
munmap(addr, s);
@@ -253,8 +253,8 @@ TEST_F(KFDMemoryTest, MapUnmapToNodes) {
/* Fill src buffer so shader quits */
srcBuffer.Fill(0x5678);
WaitOnValue(dstBuffer.As<uint32_t *>(), 0x5678);
ASSERT_EQ(*dstBuffer.As<uint32_t *>(), 0x5678);
ASSERT_SUCCESS(pm4Queue.Destroy());
EXPECT_EQ(*dstBuffer.As<uint32_t *>(), 0x5678);
EXPECT_SUCCESS(pm4Queue.Destroy());
TEST_END
}
@@ -273,9 +273,9 @@ TEST_F(KFDMemoryTest , MapMemoryToGPU) {
// verify that pDb is not null before it's being used
ASSERT_NE(nullPtr, pDb) << "hsaKmtAllocMemory returned a null pointer";
ASSERT_SUCCESS(hsaKmtMapMemoryToGPU(pDb, PAGE_SIZE, NULL));
ASSERT_SUCCESS(hsaKmtUnmapMemoryToGPU(pDb));
EXPECT_SUCCESS(hsaKmtUnmapMemoryToGPU(pDb));
// Release the buffers
ASSERT_SUCCESS(hsaKmtFreeMemory(pDb, PAGE_SIZE));
EXPECT_SUCCESS(hsaKmtFreeMemory(pDb, PAGE_SIZE));
TEST_END
}
@@ -335,7 +335,7 @@ TEST_F(KFDMemoryTest, AccessPPRMem) {
WaitOnValue(destBuf, 0xABCDEF09);
WaitOnValue(destBuf + 1, 0x12345678);
ASSERT_SUCCESS(queue.Destroy());
EXPECT_SUCCESS(queue.Destroy());
/* This sleep hides the dmesg PPR message storm on Raven, which happens
* when the CPU buffer is freed before the excessive PPRs are all
@@ -402,7 +402,7 @@ TEST_F(KFDMemoryTest, MemoryRegister) {
sdmaQueue.PlaceAndSubmitPacket(SDMAWriteDataPacket(sdmaBuffer.As<HSAuint32 *>(), 0x12345678));
sdmaQueue.Wait4PacketConsumption();
ASSERT_TRUE(WaitOnValue(&stackData[sdmaOffset], 0x12345678));
EXPECT_TRUE(WaitOnValue(&stackData[sdmaOffset], 0x12345678));
/* Fork a child process to mark pages as COW */
pid_t pid = fork();
@@ -446,12 +446,12 @@ TEST_F(KFDMemoryTest, MemoryRegister) {
sdmaQueue.PlaceAndSubmitPacket(SDMAWriteDataPacket(sdmaBuffer.As<HSAuint32 *>(), 0xD0BED0BE));
sdmaQueue.Wait4PacketConsumption();
ASSERT_SUCCESS(pm4Queue.Destroy());
ASSERT_SUCCESS(sdmaQueue.Destroy());
EXPECT_SUCCESS(pm4Queue.Destroy());
EXPECT_SUCCESS(sdmaQueue.Destroy());
ASSERT_EQ(0xD00BED00, globalData);
ASSERT_EQ(0xD00BED00, stackData[dstOffset]);
ASSERT_EQ(0xD0BED0BE, stackData[sdmaOffset]);
EXPECT_EQ(0xD00BED00, globalData);
EXPECT_EQ(0xD00BED00, stackData[dstOffset]);
EXPECT_EQ(0xD0BED0BE, stackData[sdmaOffset]);
TEST_END
}
@@ -557,9 +557,9 @@ TEST_F(KFDMemoryTest, FlatScratchAccess) {
ASSERT_SUCCESS(hsaKmtMapMemoryToGPU(scratchBuffer.As<char*>() + SCRATCH_SLICE_OFFSET(1),
SCRATCH_SLICE_SIZE, NULL));
ASSERT_SUCCESS(hsaKmtUnmapMemoryToGPU(scratchBuffer.As<char*>() + SCRATCH_SLICE_OFFSET(1)));
ASSERT_SUCCESS(hsaKmtUnmapMemoryToGPU(scratchBuffer.As<char*>() + SCRATCH_SLICE_OFFSET(2)));
ASSERT_SUCCESS(hsaKmtUnmapMemoryToGPU(scratchBuffer.As<char*>() + SCRATCH_SLICE_OFFSET(0)));
EXPECT_SUCCESS(hsaKmtUnmapMemoryToGPU(scratchBuffer.As<char*>() + SCRATCH_SLICE_OFFSET(1)));
EXPECT_SUCCESS(hsaKmtUnmapMemoryToGPU(scratchBuffer.As<char*>() + SCRATCH_SLICE_OFFSET(2)));
EXPECT_SUCCESS(hsaKmtUnmapMemoryToGPU(scratchBuffer.As<char*>() + SCRATCH_SLICE_OFFSET(0)));
// Map everything for test below
ASSERT_SUCCESS(hsaKmtMapMemoryToGPU(scratchBuffer.As<char*>(), SCRATCH_SIZE, NULL));
@@ -622,7 +622,7 @@ TEST_F(KFDMemoryTest, FlatScratchAccess) {
dispatchScratchToDst.Sync();
// Check that the scratch buffer contents were correctly copied over to the system memory buffer
ASSERT_EQ(dstMemBuffer.As<unsigned int*>()[0], 0x01010101);
EXPECT_EQ(dstMemBuffer.As<unsigned int*>()[0], 0x01010101);
}
}
@@ -701,12 +701,12 @@ void KFDMemoryTest::BigBufferSystemMemory(int defaultGPUNode, HSAuint64 granular
ret = hsaKmtMapMemoryToGPUNodes(pDb, size, &AlternateVAGPU,
mapFlags, 1, reinterpret_cast<HSAuint32 *>(&defaultGPUNode));
if (ret) {
ASSERT_SUCCESS(hsaKmtFreeMemory(pDb, size));
EXPECT_SUCCESS(hsaKmtFreeMemory(pDb, size));
highMB = sizeMB;
continue;
}
ASSERT_SUCCESS(hsaKmtUnmapMemoryToGPU(pDb));
ASSERT_SUCCESS(hsaKmtFreeMemory(pDb, size));
EXPECT_SUCCESS(hsaKmtUnmapMemoryToGPU(pDb));
EXPECT_SUCCESS(hsaKmtFreeMemory(pDb, size));
lowMB = sizeMB;
lastTestedSize = sizeMB;
@@ -757,12 +757,12 @@ void KFDMemoryTest::BigBufferVRAM(int defaultGPUNode, HSAuint64 granularityMB,
ret = hsaKmtMapMemoryToGPUNodes(pDb, size, &AlternateVAGPU,
mapFlags, 1, reinterpret_cast<HSAuint32 *>(&defaultGPUNode));
if (ret) {
ASSERT_SUCCESS(hsaKmtFreeMemory(pDb, size));
EXPECT_SUCCESS(hsaKmtFreeMemory(pDb, size));
highMB = sizeMB;
continue;
}
ASSERT_SUCCESS(hsaKmtUnmapMemoryToGPU(pDb));
ASSERT_SUCCESS(hsaKmtFreeMemory(pDb, size));
EXPECT_SUCCESS(hsaKmtUnmapMemoryToGPU(pDb));
EXPECT_SUCCESS(hsaKmtFreeMemory(pDb, size));
lowMB = sizeMB;
lastTestedSize = sizeMB;
@@ -828,7 +828,7 @@ TEST_F(KFDMemoryTest, BigBufferStressTest) {
ret = hsaKmtMapMemoryToGPUNodes(pDb_array[i], block_size,
&AlternateVAGPU, mapFlags, 1, reinterpret_cast<HSAuint32 *>(&defaultGPUNode));
if (ret) {
ASSERT_SUCCESS(hsaKmtFreeMemory(pDb_array[i], block_size));
EXPECT_SUCCESS(hsaKmtFreeMemory(pDb_array[i], block_size));
break;
}
} while (++i < ARRAY_ENTRIES);
@@ -837,8 +837,8 @@ TEST_F(KFDMemoryTest, BigBufferStressTest) {
<< block_size_mb << "MB" << std::endl;
while (i--) {
ASSERT_SUCCESS(hsaKmtUnmapMemoryToGPU(pDb_array[i]));
ASSERT_SUCCESS(hsaKmtFreeMemory(pDb_array[i], block_size));
EXPECT_SUCCESS(hsaKmtUnmapMemoryToGPU(pDb_array[i]));
EXPECT_SUCCESS(hsaKmtFreeMemory(pDb_array[i], block_size));
}
TEST_END
@@ -954,7 +954,7 @@ TEST_F(KFDMemoryTest, MMBench) {
/* Unmap from GPU */
start = GetSystemTickCountInMicroSec();
for (i = 0; i < nBufs; i++) {
ASSERT_SUCCESS(hsaKmtUnmapMemoryToGPU(bufs[i]));
EXPECT_SUCCESS(hsaKmtUnmapMemoryToGPU(bufs[i]));
INTERLEAVE_SDMA();
}
unmap1Time = GetSystemTickCountInMicroSec() - start;
@@ -972,7 +972,7 @@ TEST_F(KFDMemoryTest, MMBench) {
/* Unmap from all GPUs */
start = GetSystemTickCountInMicroSec();
for (i = 0; i < nBufs; i++) {
ASSERT_SUCCESS(hsaKmtUnmapMemoryToGPU(bufs[i]));
EXPECT_SUCCESS(hsaKmtUnmapMemoryToGPU(bufs[i]));
INTERLEAVE_SDMA();
}
unmapAllTime = GetSystemTickCountInMicroSec() - start;
@@ -981,7 +981,7 @@ TEST_F(KFDMemoryTest, MMBench) {
/* Free */
start = GetSystemTickCountInMicroSec();
for (i = 0; i < nBufs; i++) {
ASSERT_SUCCESS(hsaKmtFreeMemory(bufs[i], bufSize));
EXPECT_SUCCESS(hsaKmtFreeMemory(bufs[i], bufSize));
INTERLEAVE_SDMA();
}
freeTime = GetSystemTickCountInMicroSec() - start;
@@ -1182,8 +1182,8 @@ TEST_F(KFDMemoryTest, PtraceAccess) {
HSAuint8 *addr = reinterpret_cast<HSAuint8 *>(reinterpret_cast<long *>(mem[0]) + i) + i;
errno = 0;
long data = ptrace(PTRACE_PEEKDATA, tracePid, addr, NULL);
ASSERT_EQ(0, errno);
ASSERT_EQ(0, ptrace(PTRACE_POKEDATA, tracePid, addr + PAGE_SIZE,
EXPECT_EQ(0, errno);
EXPECT_EQ(0, ptrace(PTRACE_POKEDATA, tracePid, addr + PAGE_SIZE,
reinterpret_cast<void *>(data)));
if (mem[1] == NULL)
@@ -1192,8 +1192,8 @@ TEST_F(KFDMemoryTest, PtraceAccess) {
addr = reinterpret_cast<HSAuint8 *>(reinterpret_cast<long *>(mem[1]) + i) + i;
errno = 0;
data = ptrace(PTRACE_PEEKDATA, tracePid, addr, NULL);
ASSERT_EQ(0, errno);
ASSERT_EQ(0, ptrace(PTRACE_POKEDATA, tracePid, addr + PAGE_SIZE,
EXPECT_EQ(0, errno);
EXPECT_EQ(0, ptrace(PTRACE_POKEDATA, tracePid, addr + PAGE_SIZE,
reinterpret_cast<void *>(data)));
}
} catch (...) {
@@ -1321,17 +1321,17 @@ TEST_F(KFDMemoryTest, PtraceAccessInvisibleVram) {
/* Peek the memory */
errno = 0;
HSAint64 data0 = ptrace(PTRACE_PEEKDATA, tracePid, mem0, NULL);
ASSERT_EQ(0, errno);
ASSERT_EQ(data[0], data0);
EXPECT_EQ(0, errno);
EXPECT_EQ(data[0], data0);
HSAint64 data1 = ptrace(PTRACE_PEEKDATA, tracePid, mem1, NULL);
ASSERT_EQ(0, errno);
ASSERT_EQ(data[1], data1);
EXPECT_EQ(0, errno);
EXPECT_EQ(data[1], data1);
/* Swap mem0 and mem1 by poking */
ASSERT_EQ(0, ptrace(PTRACE_POKEDATA, tracePid, mem0, reinterpret_cast<void *>(data[1])));
ASSERT_EQ(0, errno);
ASSERT_EQ(0, ptrace(PTRACE_POKEDATA, tracePid, mem1, reinterpret_cast<void *>(data[0])));
ASSERT_EQ(0, errno);
EXPECT_EQ(0, ptrace(PTRACE_POKEDATA, tracePid, mem0, reinterpret_cast<void *>(data[1])));
EXPECT_EQ(0, errno);
EXPECT_EQ(0, ptrace(PTRACE_POKEDATA, tracePid, mem1, reinterpret_cast<void *>(data[0])));
EXPECT_EQ(0, errno);
} catch (...) {
err = 1;
}
@@ -1360,19 +1360,19 @@ TEST_F(KFDMemoryTest, PtraceAccessInvisibleVram) {
dispatch0.SetArgs(mem0, dstBuffer.As<void*>());
dispatch0.Submit(queue);
dispatch0.Sync();
ASSERT_EQ(data1[0], dstBuffer.As<unsigned int*>()[0]);
EXPECT_EQ(data1[0], dstBuffer.As<unsigned int*>()[0]);
Dispatch dispatch1(isaBuffer);
dispatch1.SetArgs(mem1, dstBuffer.As<int*>());
dispatch1.Submit(queue);
dispatch1.Sync();
WaitOnValue(dstBuffer.As<uint32_t *>(), data0[0]);
ASSERT_EQ(data0[0], dstBuffer.As<unsigned int*>()[0]);
EXPECT_EQ(data0[0], dstBuffer.As<unsigned int*>()[0]);
// Clean up
ASSERT_SUCCESS(hsaKmtUnmapMemoryToGPU(mem));
ASSERT_SUCCESS(hsaKmtFreeMemory(mem, size));
ASSERT_SUCCESS(queue.Destroy());
EXPECT_SUCCESS(hsaKmtUnmapMemoryToGPU(mem));
EXPECT_SUCCESS(hsaKmtFreeMemory(mem, size));
EXPECT_SUCCESS(queue.Destroy());
TEST_END
}
@@ -1414,12 +1414,12 @@ TEST_F(KFDMemoryTest, SignalHandling) {
ASSERT_SUCCESS(hsaKmtAllocMemory(0 /* system */, size, m_MemoryFlags, reinterpret_cast<void**>(&pDb)));
// Verify that pDb is not null before it's being used
ASSERT_NE(nullPtr, pDb) << "hsaKmtAllocMemory returned a null pointer";
EXPECT_NE(nullPtr, pDb) << "hsaKmtAllocMemory returned a null pointer";
pid_t childPid = fork();
ASSERT_GE(childPid, 0);
if (childPid == 0) {
ASSERT_EQ(0, kill(ParentPid, SIGUSR1));
EXPECT_EQ(0, kill(ParentPid, SIGUSR1));
exit(0);
} else {
LOG() << "Start Memory Mapping..." << std::endl;
@@ -1428,21 +1428,21 @@ TEST_F(KFDMemoryTest, SignalHandling) {
int childStatus;
// Parent process, just wait for the child to finish
ASSERT_EQ(childPid, waitpid(childPid, &childStatus, 0));
ASSERT_NE(0, WIFEXITED(childStatus));
ASSERT_EQ(0, WEXITSTATUS(childStatus));
EXPECT_EQ(childPid, waitpid(childPid, &childStatus, 0));
EXPECT_NE(0, WIFEXITED(childStatus));
EXPECT_EQ(0, WEXITSTATUS(childStatus));
}
pDb[0] = 0x02020202;
ASSERT_SUCCESS(queue.Create(defaultGPUNode));
queue.PlaceAndSubmitPacket(SDMAWriteDataPacket(pDb, 0x01010101) );
queue.Wait4PacketConsumption();
ASSERT_TRUE(WaitOnValue(pDb, 0x01010101));
ASSERT_SUCCESS(queue.Destroy());
EXPECT_TRUE(WaitOnValue(pDb, 0x01010101));
EXPECT_SUCCESS(queue.Destroy());
ASSERT_SUCCESS(hsaKmtUnmapMemoryToGPU(pDb));
EXPECT_SUCCESS(hsaKmtUnmapMemoryToGPU(pDb));
// Release the buffers
ASSERT_SUCCESS(hsaKmtFreeMemory(pDb, size));
EXPECT_SUCCESS(hsaKmtFreeMemory(pDb, size));
TEST_END
}
@@ -1497,7 +1497,7 @@ TEST_F(KFDMemoryTest, CheckZeroInitializationSysMem) {
EXPECT_EQ(0, pDb[size-1]);
pDb[size-1] = size;
ASSERT_SUCCESS(hsaKmtFreeMemory(pDb, sysBufSize));
EXPECT_SUCCESS(hsaKmtFreeMemory(pDb, sysBufSize));
}
TEST_END
@@ -1561,7 +1561,7 @@ TEST_F(KFDMemoryTest, MMBandWidth) {
MAP_ANONYMOUS | MAP_PRIVATE,
-1,
0);
ASSERT_NE(tmp, MAP_FAILED);
EXPECT_NE(tmp, MAP_FAILED);
memset(tmp, 0, tmpBufferSize);
LOG() << "Test (avg. ns)\t memcpyRTime memcpyWTime accessRTime accessWTime" << std::endl;
@@ -1616,7 +1616,7 @@ TEST_F(KFDMemoryTest, MMBandWidth) {
accessRTime = GetSystemTickCountInMicroSec() - start;
for (i = 0; i < nBufs; i++)
ASSERT_SUCCESS(hsaKmtFreeMemory(bufs[i], bufSize));
EXPECT_SUCCESS(hsaKmtFreeMemory(bufs[i], bufSize));
LOG() << std::dec << std::setiosflags(std::ios::right)
<< std::setw(3) << (bufSize >> 10) << "K-"
tests/kfdtest/src/KFDPMTest.cpp
+7 -7
Ver ficheiro
@@ -64,7 +64,7 @@ void KFDPMTest::TearDown() {
TEST_F(KFDPMTest, SuspendWithActiveProcess) {
TEST_START(TESTPROFILE_RUNALL)
ASSERT_EQ(true, SuspendAndWakeUp());
EXPECT_EQ(true, SuspendAndWakeUp());
TEST_END
}
@@ -78,9 +78,9 @@ TEST_F(KFDPMTest, SuspendWithIdleQueue) {
ASSERT_SUCCESS(queue.Create(defaultGPUNode));
ASSERT_EQ(true, SuspendAndWakeUp());
EXPECT_EQ(true, SuspendAndWakeUp());
ASSERT_SUCCESS(queue.Destroy());
EXPECT_SUCCESS(queue.Destroy());
TEST_END
}
@@ -103,18 +103,18 @@ TEST_F(KFDPMTest, SuspendWithIdleQueueAfterWork) {
destBuffer.Fill(0);
ASSERT_EQ(true, SuspendAndWakeUp());
EXPECT_EQ(true, SuspendAndWakeUp());
queue.PlaceAndSubmitPacket(PM4WriteDataPacket(&(destBuffer.As<unsigned int*>()[2]), 0x3, 0x4));
queue.Wait4PacketConsumption();
ASSERT_EQ(destBuffer.As<unsigned int*>()[0], 0);
ASSERT_EQ(destBuffer.As<unsigned int*>()[1], 0);
EXPECT_EQ(destBuffer.As<unsigned int*>()[0], 0);
EXPECT_EQ(destBuffer.As<unsigned int*>()[1], 0);
WaitOnValue(&(destBuffer.As<unsigned int*>()[2]), 0x3);
WaitOnValue(&(destBuffer.As<unsigned int*>()[3]), 0x4);
ASSERT_SUCCESS(queue.Destroy());
EXPECT_SUCCESS(queue.Destroy());
TEST_END
}
tests/kfdtest/src/KFDPNPTest.cpp
+2 -2
Ver ficheiro
@@ -88,12 +88,12 @@ TEST_F(KFDPNPTest, DisableAndCreateQueue) {
WaitOnValue(&(destBuffer.As<unsigned int*>()[0]), 0x1);
WaitOnValue(&(destBuffer.As<unsigned int*>()[1]), 0x2);
ASSERT_SUCCESS(queue.Destroy());
EXPECT_SUCCESS(queue.Destroy());
DisableKfd();
EnableKfd();
ASSERT_NE(HSAKMT_STATUS_SUCCESS, queue.Create(defaultGPUNode))
EXPECT_NE(HSAKMT_STATUS_SUCCESS, queue.Create(defaultGPUNode))
<< "Queue creation should fail after a topology change.";
TEST_END
tests/kfdtest/src/KFDPerfCounters.cpp
+4 -4
Ver ficheiro
@@ -176,7 +176,7 @@ TEST_F(KFDPerfCountersTest, RegisterTrace) {
block->NumConcurrent,
block->Counters,
&root));
ASSERT_SUCCESS(hsaKmtPmcUnregisterTrace(defaultGPUNode, root.TraceId));
EXPECT_SUCCESS(hsaKmtPmcUnregisterTrace(defaultGPUNode, root.TraceId));
TEST_END
}
@@ -237,7 +237,7 @@ TEST_F(KFDPerfCountersTest, StartStopQueryTrace) {
/* Delay between START and STOP tracing */
Delay(START_STOP_DELAY);
/* Stopping th trace */
/* Stopping the trace */
ASSERT_SUCCESS(hsaKmtPmcStopTrace(root.TraceId));
/* Querying the trace */
@@ -247,9 +247,9 @@ TEST_F(KFDPerfCountersTest, StartStopQueryTrace) {
LOG() << "Counter " << std::dec << i << ": " << *buf << std::endl;
/* Releasing the trace */
ASSERT_SUCCESS(hsaKmtPmcReleaseTraceAccess(0, root.TraceId));
EXPECT_SUCCESS(hsaKmtPmcReleaseTraceAccess(0, root.TraceId));
ASSERT_SUCCESS(hsaKmtPmcUnregisterTrace(defaultGPUNode, root.TraceId));
EXPECT_SUCCESS(hsaKmtPmcUnregisterTrace(defaultGPUNode, root.TraceId));
TEST_END
}
tests/kfdtest/src/KFDQMTest.cpp
+50 -50
Ver ficheiro
@@ -74,7 +74,7 @@ TEST_F(KFDQMTest, CreateCpQueue) {
WaitOnValue(destBuf.As<unsigned int*>(), 0);
ASSERT_SUCCESS(queue.Destroy());
EXPECT_SUCCESS(queue.Destroy());
TEST_END
}
@@ -97,9 +97,9 @@ TEST_F(KFDQMTest, CreateSdmaQueue) {
queue.Wait4PacketConsumption();
ASSERT_TRUE(WaitOnValue(destBuf.As<unsigned int*>(), 0x02020202));
EXPECT_TRUE(WaitOnValue(destBuf.As<unsigned int*>(), 0x02020202));
ASSERT_SUCCESS(queue.Destroy());
EXPECT_SUCCESS(queue.Destroy());
TEST_END
}
@@ -137,14 +137,14 @@ TEST_F(KFDQMTest, CreateMultipleSdmaQueues) {
queues[qidx].Wait4PacketConsumption();
ASSERT_TRUE(WaitOnValue(destBuf.As<unsigned int*>() + bufSize/4, 0x02020202));
EXPECT_TRUE(WaitOnValue(destBuf.As<unsigned int*>() + bufSize/4, 0x02020202));
ASSERT_SUCCESS(memcmp(
EXPECT_SUCCESS(memcmp(
destBuf.As<unsigned int*>(), srcBuf.As<unsigned int*>(), bufSize));
}
for (unsigned int qidx = 0; qidx < MAX_SDMA_QUEUES; ++qidx)
ASSERT_SUCCESS(queues[qidx].Destroy());
EXPECT_SUCCESS(queues[qidx].Destroy());
TEST_END
}
@@ -205,9 +205,9 @@ TEST_F(KFDQMTest, SdmaConcurrentCopies) {
queue.PlaceAndSubmitPacket(SDMAWriteDataPacket(srcBuf.As<unsigned *>(), 0x02020202));
queue.Wait4PacketConsumption();
ASSERT_TRUE(WaitOnValue(srcBuf.As<unsigned int*>(), 0x02020202));
EXPECT_TRUE(WaitOnValue(srcBuf.As<unsigned int*>(), 0x02020202));
ASSERT_SUCCESS(queue.Destroy());
EXPECT_SUCCESS(queue.Destroy());
TEST_END
}
@@ -238,7 +238,7 @@ TEST_F(KFDQMTest, CreateMultipleCpQueues) {
}
for (unsigned int qidx = 0; qidx < MAX_CP_QUEUES; ++qidx)
ASSERT_SUCCESS(queues[qidx].Destroy());
EXPECT_SUCCESS(queues[qidx].Destroy());
TEST_END
}
@@ -265,23 +265,23 @@ TEST_F(KFDQMTest, DisableCpQueueByUpdateWithNullAddress) {
destBuf.Fill(0xFFFFFFFF);
ASSERT_SUCCESS(queue.Update(BaseQueue::DEFAULT_QUEUE_PERCENTAGE, BaseQueue::DEFAULT_PRIORITY, true));
EXPECT_SUCCESS(queue.Update(BaseQueue::DEFAULT_QUEUE_PERCENTAGE, BaseQueue::DEFAULT_PRIORITY, true));
queue.PlaceAndSubmitPacket(PM4WriteDataPacket(destBuf.As<unsigned int*>(), 1, 1));
// Don't sync since we don't expect rptr to change when the queue is disabled.
Delay(2000);
ASSERT_EQ(destBuf.As<unsigned int*>()[0], 0xFFFFFFFF)
EXPECT_EQ(destBuf.As<unsigned int*>()[0], 0xFFFFFFFF)
<< "Packet executed even though the queue is supposed to be disabled!";
ASSERT_SUCCESS(queue.Update(BaseQueue::DEFAULT_QUEUE_PERCENTAGE, BaseQueue::DEFAULT_PRIORITY, false));
EXPECT_SUCCESS(queue.Update(BaseQueue::DEFAULT_QUEUE_PERCENTAGE, BaseQueue::DEFAULT_PRIORITY, false));
queue.Wait4PacketConsumption();
WaitOnValue(destBuf.As<unsigned int*>(), 1);
ASSERT_SUCCESS(queue.Destroy());
EXPECT_SUCCESS(queue.Destroy());
TEST_END
}
@@ -306,23 +306,23 @@ TEST_F(KFDQMTest, DisableSdmaQueueByUpdateWithNullAddress) {
destBuf.Fill(0xFFFFFFFF);
ASSERT_SUCCESS(queue.Update(BaseQueue::DEFAULT_QUEUE_PERCENTAGE, BaseQueue::DEFAULT_PRIORITY, true));
EXPECT_SUCCESS(queue.Update(BaseQueue::DEFAULT_QUEUE_PERCENTAGE, BaseQueue::DEFAULT_PRIORITY, true));
queue.PlaceAndSubmitPacket(SDMAWriteDataPacket(destBuf.As<void*>(), 0));
// Don't sync since we don't expect rptr to change when the queue is disabled.
Delay(2000);
ASSERT_EQ(destBuf.As<unsigned int*>()[0], 0xFFFFFFFF)
EXPECT_EQ(destBuf.As<unsigned int*>()[0], 0xFFFFFFFF)
<< "Packet executed even though the queue is supposed to be disabled!";
ASSERT_SUCCESS(queue.Update(BaseQueue::DEFAULT_QUEUE_PERCENTAGE, BaseQueue::DEFAULT_PRIORITY, false));
EXPECT_SUCCESS(queue.Update(BaseQueue::DEFAULT_QUEUE_PERCENTAGE, BaseQueue::DEFAULT_PRIORITY, false));
queue.Wait4PacketConsumption();
WaitOnValue(destBuf.As<unsigned int*>(), 0);
ASSERT_SUCCESS(queue.Destroy());
EXPECT_SUCCESS(queue.Destroy());
TEST_END
}
@@ -353,23 +353,23 @@ TEST_F(KFDQMTest, DisableCpQueueByUpdateWithZeroPercentage) {
destBuf.Fill(0xFFFFFFFF);
ASSERT_SUCCESS(queue.Update(0/*percentage*/, BaseQueue::DEFAULT_PRIORITY, false));
EXPECT_SUCCESS(queue.Update(0/*percentage*/, BaseQueue::DEFAULT_PRIORITY, false));
queue.PlaceAndSubmitPacket(packet2);
// Don't sync since we don't expect rptr to change when the queue is disabled.
Delay(2000);
ASSERT_EQ(destBuf.As<unsigned int*>()[0], 0xFFFFFFFF)
EXPECT_EQ(destBuf.As<unsigned int*>()[0], 0xFFFFFFFF)
<< "Packet executed even though the queue is supposed to be disabled!";
ASSERT_SUCCESS(queue.Update(BaseQueue::DEFAULT_QUEUE_PERCENTAGE, BaseQueue::DEFAULT_PRIORITY, false));
EXPECT_SUCCESS(queue.Update(BaseQueue::DEFAULT_QUEUE_PERCENTAGE, BaseQueue::DEFAULT_PRIORITY, false));
queue.Wait4PacketConsumption();
WaitOnValue(destBuf.As<unsigned int*>(), 1);
ASSERT_SUCCESS(queue.Destroy());
EXPECT_SUCCESS(queue.Destroy());
TEST_END
}
@@ -401,8 +401,8 @@ TEST_F(KFDQMTest, CreateQueueStressSingleThreaded) {
ASSERT_SUCCESS(queues[firstToCreate]->Create(defaultGPUNode));
ASSERT_SUCCESS(queues[secondToCreate]->Create(defaultGPUNode));
ASSERT_SUCCESS(queues[firstToDestroy]->Destroy());
ASSERT_SUCCESS(queues[secondToDestroy]->Destroy());
EXPECT_SUCCESS(queues[firstToDestroy]->Destroy());
EXPECT_SUCCESS(queues[secondToDestroy]->Destroy());
delete queues[0];
delete queues[1];
@@ -453,10 +453,10 @@ TEST_F(KFDQMTest, OverSubscribeCpQueues) {
Delay(5000);
for (unsigned int qidx = 0; qidx < MAX_CP_QUEUES; ++qidx)
ASSERT_TRUE(queues[qidx].AllPacketsSubmitted())<< "QueueId=" << qidx;;
EXPECT_TRUE(queues[qidx].AllPacketsSubmitted())<< "QueueId=" << qidx;;
for (unsigned int qidx = 0; qidx < MAX_CP_QUEUES; ++qidx)
ASSERT_SUCCESS(queues[qidx].Destroy());
EXPECT_SUCCESS(queues[qidx].Destroy());
TEST_END
}
@@ -658,7 +658,7 @@ TEST_F(KFDQMTest, BasicCuMaskingLinear) {
LOG() << std::setprecision(2) << CuNegVariance << " <= " << std::fixed << std::setprecision(8)
<< ratio << " <= " << std::setprecision(2) << CuPosVariance << std::endl;
ASSERT_TRUE((ratio >= CuNegVariance) && (ratio <= CuPosVariance));
EXPECT_TRUE((ratio >= CuNegVariance) && (ratio <= CuPosVariance));
}
} else {
LOG() << "Skipping test: Test not supported for family ID 0x" << m_FamilyId << "." << std::endl;
@@ -729,7 +729,7 @@ TEST_F(KFDQMTest, BasicCuMaskingEven) {
LOG() << std::setprecision(2) << CuNegVariance << " <= " << std::fixed << std::setprecision(8)
<< ratio << " <= " << std::setprecision(2) << CuPosVariance << std::endl;
ASSERT_TRUE((ratio >= CuNegVariance) && (ratio <= CuPosVariance));
EXPECT_TRUE((ratio >= CuNegVariance) && (ratio <= CuPosVariance));
}
} else {
LOG() << "Skipping test: Test not supported for family ID 0x" << m_FamilyId << "." << std::endl;
@@ -772,7 +772,7 @@ TEST_F(KFDQMTest, QueuePriorityOnDifferentPipe) {
for (i = 0; i < 2; i++) {
syncBuffer[i] = -1;
EXPECT_SUCCESS(queue[i].Create(node));
ASSERT_SUCCESS(queue[i].Create(node));
queue[i].Update(BaseQueue::DEFAULT_QUEUE_PERCENTAGE, priority[i], false);
pHsaEvent[i] = dispatch[i].GetHsaEvent();
pHsaEvent[i]->EventData.EventData.SyncVar.SyncVar.UserData = &syncBuffer[i];
@@ -899,7 +899,7 @@ void KFDQMTest::SyncDispatch(const HsaMemoryBuffer& isaBuffer, void* pSrcBuf, vo
dispatch.Submit(queue);
dispatch.Sync();
ASSERT_SUCCESS(queue.Destroy());
EXPECT_SUCCESS(queue.Destroy());
}
TEST_F(KFDQMTest, EmptyDispatch) {
@@ -933,7 +933,7 @@ TEST_F(KFDQMTest, SimpleWriteDispatch) {
SyncDispatch(isaBuffer, srcBuffer.As<void*>(), destBuffer.As<void*>());
ASSERT_EQ(destBuffer.As<unsigned int*>()[0], 0x01010101);
EXPECT_EQ(destBuffer.As<unsigned int*>()[0], 0x01010101);
TEST_END
}
@@ -982,7 +982,7 @@ TEST_F(KFDQMTest, MultipleCpQueuesStressDispatch) {
}
for (i = 0; i < MAX_CP_QUEUES; ++i) {
dispatch[i]->Sync();
ASSERT_EQ(dst[i], src[i]);
EXPECT_EQ(dst[i], src[i]);
delete dispatch[i];
}
++numIter;
@@ -993,7 +993,7 @@ TEST_F(KFDQMTest, MultipleCpQueuesStressDispatch) {
LOG() << "Total iterated : " << std::dec << numIter << std::endl;
for (i = 0; i < MAX_CP_QUEUES; ++i)
ASSERT_SUCCESS(queues[i].Destroy());
EXPECT_SUCCESS(queues[i].Destroy());
TEST_END
}
@@ -1051,7 +1051,7 @@ TEST_F(KFDQMTest, CreateAqlCpQueue) {
ASSERT_SUCCESS(queue.Create(defaultGPUNode, PAGE_SIZE, pointers.As<HSAuint64 *>()));
ASSERT_SUCCESS(queue.Destroy());
EXPECT_SUCCESS(queue.Destroy());
TEST_END
}
@@ -1126,7 +1126,7 @@ TEST_F(KFDQMTest, QueueLatency) {
do {
HSAint64 queue_latency = qts[i] - ts[i].GPUClockCounter;
ASSERT_GE(queue_latency, 0);
EXPECT_GE(queue_latency, 0);
queue_latency_arr[i] = queue_latency;
if (i >= skip)
@@ -1155,7 +1155,7 @@ TEST_F(KFDQMTest, QueueLatency) {
workload = qts[slots - 1] - qts[skip];
workload /= (slots - 1 - skip);
ASSERT_GE(workload, 0);
EXPECT_GE(workload, 0);
i = 0;
do {
@@ -1207,7 +1207,7 @@ TEST_F(KFDQMTest, CpQueueWraparound) {
WaitOnValue(destBuf.As<unsigned int*>(), pktIdx);
}
ASSERT_SUCCESS(queue.Destroy());
EXPECT_SUCCESS(queue.Destroy());
TEST_END
}
@@ -1235,9 +1235,9 @@ TEST_F(KFDQMTest, SdmaQueueWraparound) {
SDMAWriteDataPacket(destBuf.As<unsigned int*>() + bufSize/4, 0x02020202));
queue.Wait4PacketConsumption();
ASSERT_TRUE(WaitOnValue(destBuf.As<unsigned int*>() + bufSize/4, 0x02020202));
EXPECT_TRUE(WaitOnValue(destBuf.As<unsigned int*>() + bufSize/4, 0x02020202));
ASSERT_SUCCESS(memcmp(
EXPECT_SUCCESS(memcmp(
destBuf.As<unsigned int*>(), srcBuf.As<unsigned int*>(), bufSize));
}
@@ -1247,7 +1247,7 @@ TEST_F(KFDQMTest, SdmaQueueWraparound) {
WaitOnValue(destBuf.As<unsigned int*>(), pktIdx);
}
ASSERT_SUCCESS(queue.Destroy());
EXPECT_SUCCESS(queue.Destroy());
TEST_END
}
@@ -1355,7 +1355,7 @@ TEST_F(KFDQMTest, mGPUShareBO) {
m_pIsaGen->GetCopyDwordIsa(isaBufferDst);
SyncDispatch(isaBufferDst, shared_addr.As<void *>(), dstNodeMem.As<void*>(), dst_node);
ASSERT_EQ(dstNodeMem.As<unsigned int*>()[0], 0x05050505);
EXPECT_EQ(dstNodeMem.As<unsigned int*>()[0], 0x05050505);
EXPECT_SUCCESS(shared_addr.UnmapMemToNodes(&dst_node, 1));
@@ -1370,7 +1370,7 @@ static void sdma_copy(HSAint32 node, void *src, void *const dst[], int n, unsign
ASSERT_SUCCESS(sdmaQueue.Create(node));
sdmaQueue.PlaceAndSubmitPacket(SDMACopyDataPacket(dst, src, n, size));
sdmaQueue.Wait4PacketConsumption();
ASSERT_SUCCESS(sdmaQueue.Destroy());
EXPECT_SUCCESS(sdmaQueue.Destroy());
ROUTINE_END;
}
@@ -1382,7 +1382,7 @@ static void sdma_fill(HSAint32 node, void *dst, unsigned int data, unsigned int
ASSERT_SUCCESS(sdmaQueue.Create(node));
sdmaQueue.PlaceAndSubmitPacket(SDMAFillDataPacket(dst, data, size));
sdmaQueue.Wait4PacketConsumption();
ASSERT_SUCCESS(sdmaQueue.Destroy());
EXPECT_SUCCESS(sdmaQueue.Destroy());
ROUTINE_END;
}
@@ -1485,8 +1485,8 @@ TEST_F(KFDQMTest, P2PTest) {
sdma_copy(cur, src, dst_array, n, size);
/* Verify the data*/
ASSERT_EQ(sysBuf[0], MAGIC_NUM);
ASSERT_EQ(sysBuf[end], MAGIC_NUM);
EXPECT_EQ(sysBuf[0], MAGIC_NUM);
EXPECT_EQ(sysBuf[end], MAGIC_NUM);
LOG() << "PASS " << cur << " -> " << next << std::endl;
@@ -1522,11 +1522,11 @@ TEST_F(KFDQMTest, SdmaEventInterrupt) {
queue.Wait4PacketConsumption();
ASSERT_SUCCESS(hsaKmtWaitOnEvent(event, g_TestTimeOut));
EXPECT_SUCCESS(hsaKmtWaitOnEvent(event, g_TestTimeOut));
hsaKmtDestroyEvent(event);
ASSERT_SUCCESS(queue.Destroy());
EXPECT_SUCCESS(queue.Destroy());
TEST_END
}
@@ -1610,11 +1610,11 @@ TEST_F(KFDQMTest, GPUDoorbellWrite) {
}
/* Check that the PM4 packet has been executed */
ASSERT_TRUE(WaitOnValue(destBuf.As<unsigned int *>(), 0x12345678));
ASSERT_TRUE(WaitOnValue(destBuf.As<unsigned int *>()+1, 0x87654321));
EXPECT_TRUE(WaitOnValue(destBuf.As<unsigned int *>(), 0x12345678));
EXPECT_TRUE(WaitOnValue(destBuf.As<unsigned int *>()+1, 0x87654321));
ASSERT_SUCCESS(pm4Queue.Destroy());
ASSERT_SUCCESS(otherQueue.Destroy());
EXPECT_SUCCESS(pm4Queue.Destroy());
EXPECT_SUCCESS(otherQueue.Destroy());
TEST_END
}
tests/kfdtest/src/KFDTestUtil.cpp
+1 -1
Ver ficheiro
@@ -233,7 +233,7 @@ void HsaMemoryBuffer::Fill(HSAuint32 value, BaseQueue& baseQueue, HSAuint64 offs
baseQueue.PlacePacket(SDMAFillDataPacket((reinterpret_cast<void *>(this->As<char*>() + offset)), value, size));
baseQueue.PlacePacket(SDMAFencePacket(reinterpret_cast<void*>(event->EventData.HWData2), event->EventId));
baseQueue.PlaceAndSubmitPacket(SDMATrapPacket(event->EventId));
ASSERT_SUCCESS(hsaKmtWaitOnEvent(event, g_TestTimeOut));
EXPECT_SUCCESS(hsaKmtWaitOnEvent(event, g_TestTimeOut));
hsaKmtDestroyEvent(event);
}
tests/kfdtest/src/PM4Packet.cpp
+1 -1
Ver ficheiro
@@ -254,7 +254,7 @@ void PM4SetShaderRegPacket::InitPacket(unsigned int baseOffset, const unsigned i
*/
m_pPacketData = reinterpret_cast<PM4SET_SH_REG *>(malloc(m_packetSize));
ASSERT_NOTNULL(m_pPacketData);
EXPECT_NOTNULL(m_pPacketData);
m_packetDataAllocated = true;
tests/kfdtest/src/RDMATest.cpp
+2 -2
Ver ficheiro
@@ -89,7 +89,7 @@ TEST_F(RDMATest, GPUDirect) {
dispatch.Submit(queue);
dispatch.Sync(g_TestTimeOut); // GPU executed the command
ASSERT_SUCCESS(queue.Destroy());
EXPECT_SUCCESS(queue.Destroy());
LocalMemoryAccess Rdma;
@@ -109,7 +109,7 @@ TEST_F(RDMATest, GPUDirect) {
/* Read the memory to confirm that application can read the local memory
* correctly from the mapped address.
*/
ASSERT_EQ(memcmp(gpuAddr, srcSysBuffer.As<void*>(), 4), 0);
EXPECT_EQ(memcmp(gpuAddr, srcSysBuffer.As<void*>(), 4), 0);
Rdma.UnMap(gpuAddr, PAGE_SIZE);
Rdma.Close();