AI/rocm-systems
2
0
Fork 0
Koodi Ongelmat Pull-pyynnöt Actions Paketit Projektit Julkaisut Wiki Toiminta

kfdtest: Consolidate logic for ASSERT vs EXPECT

Selaa lähdekoodia 
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


[ROCm/ROCR-Runtime commit: fe33461622]
This commit is contained in:
Kent Russell
2018-08-20 09:54:26 -04:00
vanhempi b86f145610
commit 52536ba23b
17 muutettua tiedostoa jossa 208 lisäystä ja 209 poistoa
Download Patch File Download Diff File Expand all files Collapse all files
projects/rocr-runtime/tests/kfdtest/src/KFDBaseComponentTest.cpp
+2 -2
Näytä tiedosto
@@ -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
}
projects/rocr-runtime/tests/kfdtest/src/KFDCWSRTest.cpp
+2 -2
Näytä tiedosto
@@ -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();
projects/rocr-runtime/tests/kfdtest/src/KFDDBGTest.cpp
+4 -4
Näytä tiedosto
@@ -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;
}
projects/rocr-runtime/tests/kfdtest/src/KFDEventTest.cpp
+5 -6
Näytä tiedosto
@@ -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]));
projects/rocr-runtime/tests/kfdtest/src/KFDEvictTest.cpp
+7 -7
Näytä tiedosto
@@ -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();
projects/rocr-runtime/tests/kfdtest/src/KFDExceptionTest.cpp
+16 -16
Näytä tiedosto
@@ -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);
}
}
projects/rocr-runtime/tests/kfdtest/src/KFDGraphicsInterop.cpp
+16 -16
Näytä tiedosto
@@ -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
}
projects/rocr-runtime/tests/kfdtest/src/KFDIPCTest.cpp
+21 -21
Näytä tiedosto
@@ -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
}
projects/rocr-runtime/tests/kfdtest/src/KFDLocalMemoryTest.cpp
+10 -10
Näytä tiedosto
@@ -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
}
projects/rocr-runtime/tests/kfdtest/src/KFDMemoryTest.cpp
+58 -58
Näytä tiedosto
@@ -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-"
projects/rocr-runtime/tests/kfdtest/src/KFDPMTest.cpp
+7 -7
Näytä tiedosto
@@ -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
}
projects/rocr-runtime/tests/kfdtest/src/KFDPNPTest.cpp
+2 -2
Näytä tiedosto
@@ -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
projects/rocr-runtime/tests/kfdtest/src/KFDPerfCounters.cpp
+4 -4
Näytä tiedosto
@@ -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
}
projects/rocr-runtime/tests/kfdtest/src/KFDQMTest.cpp
+50 -50
Näytä tiedosto
@@ -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
}
projects/rocr-runtime/tests/kfdtest/src/KFDTestUtil.cpp
+1 -1
Näytä tiedosto
@@ -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);
}
projects/rocr-runtime/tests/kfdtest/src/PM4Packet.cpp
+1 -1
Näytä tiedosto
@@ -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;
projects/rocr-runtime/tests/kfdtest/src/RDMATest.cpp
+2 -2
Näytä tiedosto
@@ -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();