Changeset 60191 in vbox

Timestamp:

Mar 25, 2016 4:59:31 PM (9 years ago)

Author:

vboxsync

Message:

tstRTPrf: Converted to iprt/test.h and added a little off topic comparison between CPU register and memory based code.

Location:

trunk/src/VBox/Runtime/testcase

Files:

• Makefile.kmk (modified) (1 diff)
• tstPrfRT.cpp (modified) (4 diffs)
• tstRTPrfA.asm (added)

trunk/src/VBox/Runtime/testcase/Makefile.kmk

@@ -543 +543 @@
 tstPrfRT_TEMPLATE = VBOXR3TSTEXE
 tstPrfRT_SOURCES = tstPrfRT.cpp
+tstPrfRT_SOURCES.x86 = tstRTPrfA.asm
+tstPrfRT_SOURCES.amd64 = tstRTPrfA.asm
 
 tstRTPrfIO_TEMPLATE = VBOXR3TSTEXE

trunk/src/VBox/Runtime/testcase/tstPrfRT.cpp

@@ -32 +32 @@
 #include <iprt/time.h>
 #include <iprt/log.h>
-#include <iprt/stream.h>
+#include <iprt/test.h>
 #include <iprt/thread.h>
 #if defined(RT_ARCH_AMD64) || defined(RT_ARCH_X86)
 # include <iprt/asm-amd64-x86.h>
-
+#endif
+
+
+/*********************************************************************************************************************************
+*   Internal Functions                                                                                                           *
+*********************************************************************************************************************************/
+#if defined(RT_ARCH_AMD64) || defined(RT_ARCH_X86)
+DECLASM(void) tstRTPRfAMemoryAccess(void);
+DECLASM(void) tstRTPRfARegisterAccess(void);
+DECLASM(void) tstRTPRfAMemoryUnalignedAccess(void);
+#endif
+
+
+/*********************************************************************************************************************************
+*   Global Variables                                                                                                             *
+*********************************************************************************************************************************/
+static RTTEST g_hTest;
+
+
+#if defined(RT_ARCH_AMD64) || defined(RT_ARCH_X86)
 
 void PrintResult(uint64_t u64Ticks, uint64_t u64MaxTicks, uint64_t u64MinTicks, unsigned cTimes, const char *pszOperation)
 {
-    RTPrintf("tstPrfRT: %-32s %5lld / %5lld / %5lld ticks per call (%u calls %lld ticks)\n",
-             pszOperation, u64MinTicks, u64Ticks / (uint64_t)cTimes, u64MaxTicks, cTimes, u64Ticks);
+    //RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS,
+    //             "%-32s %5lld / %5lld / %5lld ticks per call (%u calls %lld ticks)\n",
+    //             pszOperation, u64MinTicks, u64Ticks / (uint64_t)cTimes, u64MaxTicks, cTimes, u64Ticks);
+    //RTTestValueF(g_hTest, u64MinTicks,                  RTTESTUNIT_NONE, "%s min ticks", pszOperation);
+    RTTestValueF(g_hTest, u64Ticks / (uint64_t)cTimes,  RTTESTUNIT_NONE, "%s avg ticks", pszOperation);
+    //RTTestValueF(g_hTest, u64MaxTicks,                  RTTESTUNIT_NONE, "%s max ticks", pszOperation);
 }
 
@@ -91 +114 @@
 void PrintResult(uint64_t cNs, uint64_t cNsMax, uint64_t cNsMin, unsigned cTimes, const char *pszOperation)
 {
-    RTPrintf("tstPrfRT: %-32s %5lld / %5lld / %5lld ns per call (%u calls %lld ns)\n",
-             pszOperation, cNsMin, cNs / (uint64_t)cTimes, cNsMax, cTimes, cNs);
+    //RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS,
+    //             "%-32s %5lld / %5lld / %5lld ns per call (%u calls %lld ns)\n",
+    //             pszOperation, cNsMin, cNs / (uint64_t)cTimes, cNsMax, cTimes, cNs);
+    //RTTestValueF(g_hTest, cNsMin,                  RTTESTUNIT_NS_PER_CALL, "%s min", pszOperation);
+    RTTestValueF(g_hTest, cNs / (uint64_t)cTimes,  RTTESTUNIT_NS_PER_CALL, "%s avg", pszOperation);
+    //RTTestValueF(g_hTest, cNsMax,                  RTTESTUNIT_NS_PER_CALL, "%s max", pszOperation);
 }
 
@@ -125 +152 @@
     unsigned    i;
 
-    RTR3InitExeNoArguments(argc == 2 ? RTR3INIT_FLAGS_SUPLIB : 0);
-    RTPrintf("tstPrfRT: TESTING...\n");
+    RTEXITCODE rcExit = RTTestInitExAndCreate(argc, &argv, argc == 2 ? RTR3INIT_FLAGS_SUPLIB : 0, "tstRTPrf", &g_hTest);
+    if (rcExit != RTEXITCODE_SUCCESS)
+        return rcExit;
+    RTTestBanner(g_hTest);
 
     /*
@@ -165 +194 @@
     PrintResult(u64TotalTS, u64MaxTS, u64MinTS, i, "RTThreadNativeSelf");
 
-    RTPrintf("tstPrtRT: DONE\n");
-    return 0;
+#if defined(RT_ARCH_X86) || defined(RT_ARCH_AMD64)
+    /*
+     * Registers vs stack.
+     */
+    ITERATE(RT_NOTHING, tstRTPRfARegisterAccess();, RT_NOTHING, 1000);
+    uint64_t const cRegTotal = u64TotalTS;
+    //PrintResult(u64TotalTS, u64MaxTS, u64MinTS, i, "Register only algorithm");
+
+    ITERATE(RT_NOTHING, tstRTPRfAMemoryAccess();, RT_NOTHING, 1000);
+    uint64_t const cMemTotal = u64TotalTS;
+    //PrintResult(u64TotalTS, u64MaxTS, u64MinTS, i, "Memory only algorithm");
+
+    ITERATE(RT_NOTHING, tstRTPRfAMemoryUnalignedAccess();, RT_NOTHING, 1000);
+    uint64_t const cMemUnalignedTotal = u64TotalTS;
+    //PrintResult(u64TotalTS, u64MaxTS, u64MinTS, i, "Memory only algorithm");
+
+    uint64_t const cSlower100 = cMemTotal * 100 / cRegTotal;
+    RTTestValue(g_hTest, "Memory instead of registers slowdown", cSlower100, RTTESTUNIT_PCT);
+    uint64_t const cUnalignedSlower100 = cMemUnalignedTotal * 100 / cRegTotal;
+    RTTestValue(g_hTest, "Unaligned memory instead of registers slowdown", cUnalignedSlower100, RTTESTUNIT_PCT);
+#endif
+
+    return RTTestSummaryAndDestroy(g_hTest);
 }