Changeset 72549 in vbox

Timestamp:

Jun 13, 2018 5:58:19 PM (7 years ago)

Author:

vboxsync

Message:

ValidationKit/rdtsc: Rewrote the rdtsc testcase to (hopefully) work with more than just 32-bit MSC. Need this to test TSC during pausing of NEM/win (bugref:9044).

Location:

trunk/src/VBox/ValidationKit/utils/cpu

Files:

• Makefile.kmk (modified) (1 diff)
• rdtsc-asm.asm (added)
• rdtsc.cpp (modified) (1 diff)

trunk/src/VBox/ValidationKit/utils/cpu/Makefile.kmk

@@ -58 +58 @@
 cidet-app_VBOX_IMPORT_CHECKER.win.x86 = $(NO_SUCH_VARIABLE) # doesn't work on NT4 yet.
 
-#PROGRAMS += rdtsc
-#rdtsc_TEMPLATE = VBoxValidationKitR3
-#rdtsc_SOURCES  = rdtsc.cpp rdtsc-asm.asm
+PROGRAMS += rdtsc
+rdtsc_TEMPLATE = VBoxValidationKitR3
+rdtsc_SOURCES  = rdtsc.cpp rdtsc-asm.asm
 
 

trunk/src/VBox/ValidationKit/utils/cpu/rdtsc.cpp

@@ -26 +26 @@
 
 
+/*********************************************************************************************************************************
+*   Header Files                                                                                                                 *
+*********************************************************************************************************************************/
+#include <iprt/types.h>
+#include <stdlib.h>
 #include <stdio.h>
-
-int main()
+#include <time.h>
+
+
+/*********************************************************************************************************************************
+*   Structures and Typedefs                                                                                                      *
+*********************************************************************************************************************************/
+typedef struct RDTSCRESULT
 {
-    int i;
-    int cMatches = 0;
-    for (i = 0; i < 10000000; i++)
+    RTCCUINTREG uLow, uHigh;
+} RDTSCRESULT;
+
+
+/*********************************************************************************************************************************
+*   Global Variables                                                                                                             *
+*********************************************************************************************************************************/
+extern "C" RDTSCRESULT g_aRdTscResults[]; /* rdtsc-asm.asm */
+
+
+/*********************************************************************************************************************************
+*   Internal Functions                                                                                                           *
+*********************************************************************************************************************************/
+/**
+ * Does 3 (32-bit) or 6 (64-bit) fast TSC reads and stores the result
+ * in g_aRdTscResults, starting with the 2nd entry.
+ *
+ * Starting the result storing at g_aRdTscResults[1] make it easy to do the
+ * comparisons in a loop.
+ *
+ * @returns Number of results read into g_aRdTscResults[1] and onwards.
+ */
+DECLASM(uint32_t) DoTscReads(void);
+
+
+
+
+int main(int argc, char **argv)
+{
+
+    /*
+     * Tunables.
+     */
+    uint64_t        offJumpThreshold  = _4G * 2;
+    unsigned        cMaxLoops         = 10000000;
+    unsigned        cStatusEvery      = 2000000;
+    unsigned        cMinSeconds       = 0;
+
+    for (int i = 1; i < argc; i++)
     {
-        int cMatchedNow = 0;
-        __asm
+        const char *psz = argv[i];
+        if (*psz == '-')
         {
-            rdtsc
-            mov ebx, eax
-            mov ecx, edx
-            rdtsc
-            mov esi, eax
-            mov edi, edx
-            rdtsc
-
-            cmp eax, ebx
-            jnz l_ok1
-            cmp edx, ecx
-            jnz l_ok1
-            inc [cMatchedNow]
-        l_ok1:
-
-            cmp eax, esi
-            jnz l_ok2
-            cmp edx, edi
-            jnz l_ok2
-            inc [cMatchedNow]
-            jmp l_ok3
-        l_ok2:
-
-            cmp ebx, esi
-            jnz l_ok3
-            cmp ecx, edi
-            jnz l_ok3
-            inc [cMatchedNow]
-        l_ok3:
+            psz++;
+            char chOpt;
+            while ((chOpt = *psz++) != '\0')
+            {
+                /* Option value. */
+                const char *pszValue = NULL;
+                unsigned long uValue = 0;
+                switch (chOpt)
+                {
+                    case 'l':
+                    case 's':
+                    case 'm':
+                        if (*psz == '\0')
+                        {
+                            if (i + 1 >= argc)
+                            {
+                                printf("syntax error: The %c option requires a value\n", chOpt);
+                                return RTEXITCODE_SYNTAX;
+                            }
+                            pszValue = argv[++i];
+                        }
+                        else
+                            pszValue = psz + (*psz == ':' || *psz == '=');
+                        switch (chOpt)
+                        {
+                            case 'l':
+                            case 's':
+                            case 'm':
+                            {
+                                char *pszNext = NULL;
+                                uValue = strtoul(pszValue, &pszNext, 0);
+                                if (pszNext && *pszNext != '\0')
+                                    if (*pszNext == 'M'&& pszNext[1] == '\0')
+                                        uValue *= _1M;
+                                    else if (*pszNext == 'K' && pszNext[1] == '\0')
+                                        uValue *= _1K;
+                                    else if (*pszNext == 'G' && pszNext[1] == '\0')
+                                        uValue *= _1G;
+                                    else
+                                    {
+                                        printf("syntax error: Bad value format for option %c: %s\n", chOpt, pszValue);
+                                        return RTEXITCODE_SYNTAX;
+                                    }
+                                break;
+                            }
+                        }
+                        break;
+                }
+
+                /* handle the option. */
+                switch (chOpt)
+                {
+                    case 'l':
+                        cMaxLoops = uValue;
+                        break;
+
+                    case 'm':
+                        cMinSeconds = uValue;
+                        break;
+
+                    case 's':
+                        cStatusEvery = uValue;
+                        break;
+
+                    case 'h':
+                    case '?':
+                        printf("usage: rdtsc [-l <loops>] [-s <loops-between-status>]\n"
+                               "             [-m <minimum-seconds-to-run>]\n");
+                        return RTEXITCODE_SUCCESS;
+
+                    default:
+                        printf("syntax error: Unknown option %c (argument %d)\n", chOpt, i);
+                        return RTEXITCODE_SYNTAX;
+                }
+            }
         }
-        if (cMatchedNow)
+        else
         {
-            printf("%08d: %d\n", i, cMatchedNow);
-            cMatches += cMatchedNow;
+            printf("synatx error: argument %d (%s): not an option\n", i, psz);
+            return RTEXITCODE_SYNTAX;
         }
     }
-    printf("done: %d matches\n", cMatches);
-    return !!cMatches;
+
+    /*
+     * Do the job.
+     */
+    time_t          uSecStart;
+    time(&uSecStart);
+    unsigned        cOuterLoops        = 0;
+    unsigned        cLoopsToNextStatus = cStatusEvery;
+    unsigned        cRdTscInstructions = 0;
+    unsigned        cBackwards         = 0;
+    unsigned        cSame              = 0;
+    unsigned        cBadValues         = 0;
+    unsigned        cJumps             = 0;
+    uint64_t        offMaxJump         = 0;
+    uint64_t        offMinIncr         = UINT64_MAX;
+    uint64_t        offMaxIncr         = 0;
+
+    g_aRdTscResults[0] = g_aRdTscResults[DoTscReads() - 1];
+
+    for (;;)
+    {
+        for (unsigned iLoop = 0; iLoop < cMaxLoops; iLoop++)
+        {
+            uint32_t const cResults = DoTscReads();
+            cRdTscInstructions += cResults;
+
+            for (uint32_t i = 0; i < cResults; i++)
+            {
+                uint64_t uPrev = RT_MAKE_U64((uint32_t)g_aRdTscResults[i    ].uLow, (uint32_t)g_aRdTscResults[i    ].uHigh);
+                uint64_t uCur  = RT_MAKE_U64((uint32_t)g_aRdTscResults[i + 1].uLow, (uint32_t)g_aRdTscResults[i + 1].uHigh);
+                if (RT_LIKELY(uCur != uPrev))
+                {
+                    int64_t offDelta = uCur - uPrev;
+                    if (RT_LIKELY(offDelta >= 0))
+                    {
+                        if (RT_LIKELY((uint64_t)offDelta < offJumpThreshold))
+                        {
+                            if ((uint64_t)offDelta < offMinIncr)
+                                offMinIncr = offDelta;
+                            if ((uint64_t)offDelta > offMaxIncr && i != 0)
+                                offMaxIncr = offDelta;
+                        }
+                        else
+                        {
+                            cJumps++;
+                            if ((uint64_t)offDelta > offMaxJump)
+                                offMaxJump = offDelta;
+                            printf("%u/%u: Jump: %#010x`%08x -> %#010x`%08x\n", cOuterLoops, iLoop,
+                                   (unsigned)g_aRdTscResults[i].uHigh, (unsigned)g_aRdTscResults[i].uLow,
+                                   (unsigned)g_aRdTscResults[i + 1].uHigh, (unsigned)g_aRdTscResults[i + 1].uLow);
+                        }
+                    }
+                    else
+                    {
+                        cBackwards++;
+                        printf("%u/%u: Back: %#010x`%08x -> %#010x`%08x\n", cOuterLoops, iLoop,
+                               (unsigned)g_aRdTscResults[i].uHigh, (unsigned)g_aRdTscResults[i].uLow,
+                               (unsigned)g_aRdTscResults[i + 1].uHigh, (unsigned)g_aRdTscResults[i + 1].uLow);
+                    }
+                }
+                else
+                {
+                    cSame++;
+                    printf("%u/%u: Same: %#010x`%08x -> %#010x`%08x\n", cOuterLoops, iLoop,
+                           (unsigned)g_aRdTscResults[i].uHigh, (unsigned)g_aRdTscResults[i].uLow,
+                           (unsigned)g_aRdTscResults[i + 1].uHigh, (unsigned)g_aRdTscResults[i + 1].uLow);
+                }
+#if ARCH_BITS == 64
+                if ((g_aRdTscResults[i + 1].uLow >> 32) || (g_aRdTscResults[i + 1].uHigh >> 32))
+                    cBadValues++;
+#endif
+            }
+
+            /* Copy the last value for the next iteration. */
+            g_aRdTscResults[0] = g_aRdTscResults[cResults];
+
+            /* Display status. */
+            if (RT_LIKELY(--cLoopsToNextStatus > 0))
+            { /* likely */ }
+            else
+            {
+                cLoopsToNextStatus = cStatusEvery;
+                printf("%u/%u: %#010x`%08x\n", cOuterLoops, iLoop,
+                       (unsigned)g_aRdTscResults[cResults].uHigh, (unsigned)g_aRdTscResults[cResults].uLow);
+            }
+        }
+
+        /*
+         * Check minimum number of seconds.
+         */
+        cOuterLoops++;
+        if (!cMinSeconds)
+            break;
+        time_t uSecNow;
+        if (   time(&uSecNow) == -1
+            || cMinSeconds == -1
+            || uSecNow - uSecStart >= cMinSeconds)
+            break;
+    }
+
+    /*
+     * Summary.
+     */
+    if (cBackwards == 0 && cSame == 0 && cJumps == 0 && cBadValues == 0)
+    {
+        printf("rdtsc: Success (%u RDTSC over %u*%u loops, deltas: %#x`%08x..%#x`%08x)\n",
+               cRdTscInstructions, cOuterLoops, cMaxLoops,
+               (unsigned)(offMinIncr >> 32), (unsigned)offMinIncr, (unsigned)(offMaxIncr >> 32), (unsigned)offMaxIncr);
+        return RTEXITCODE_SUCCESS;
+    }
+    printf("RDTSC instructions: %u\n", cRdTscInstructions);
+    printf("Loops:              %u * %u => %u\n", cMaxLoops, cOuterLoops, cOuterLoops * cMaxLoops);
+    printf("Backwards:          %u\n", cBackwards);
+    printf("Jumps:              %u\n", cJumps);
+    printf("Max jumps:          %#010x`%08x\n", (unsigned)(offMaxJump >> 32), (unsigned)offMaxJump);
+    printf("Same value:         %u\n", cSame);
+    printf("Bad values:         %u\n", cBadValues);
+    printf("Min increment:      %#010x`%08x\n", (unsigned)(offMinIncr >> 32), (unsigned)offMinIncr);
+    printf("Max increment:      %#010x`%08x\n", (unsigned)(offMaxIncr >> 32), (unsigned)offMaxIncr);
+    return RTEXITCODE_FAILURE;
 }
+