Changeset 11347

Timestamp:

08/11/08 23:12:55 (3 months ago)

Author:

vboxsync

Message:

iprt/rand: Added a generic RTRandAdv API for use with any random number generator. Implemented the classic Park-Miller pseudo random number generator.

Files:

• trunk/include/iprt/rand.h (modified) (1 diff)
• trunk/include/iprt/types.h (modified) (1 diff)
• trunk/src/VBox/Runtime/Makefile.kmk (modified) (1 diff)
• trunk/src/VBox/Runtime/common/rand/randparkmiller.cpp (added)
• trunk/src/VBox/Runtime/include/internal/magics.h (modified) (1 diff)
• trunk/src/VBox/Runtime/include/internal/rand.h (modified) (2 diffs)
• trunk/src/VBox/Runtime/testcase/tstRand.cpp (modified) (6 diffs)

trunk/include/iprt/rand.h

@@ -113 +113 @@
-RTDECL(uint64_t) RTRandU64(void) RT_NO_THROW;
-
+
+/**
+ * Create an instance of the default random number generator.
+ *
+ * @returns IPRT status code.
+ * @param   hRand       Handle to the random number generator.
+ */
+RTDECL(int) RTRandAdvCreate(PRTRAND phRand) RT_NO_THROW;
+
+/**
+ * Create an instance of the default pseudo random number generator.
+ *
+ * @returns IPRT status code.
+ * @param   phRand      Where to store the handle to the generator.
+ */
+RTDECL(int) RTRandAdvCreatePseudo(PRTRAND phRand) RT_NO_THROW;
+
+
+/**
+ * Create an instance of the Park-Miller pseudo random number generator.
+ *
+ * @returns IPRT status code.
+ * @param   phRand      Where to store the handle to the generator.
+ */
+RTDECL(int) RTRandAdvCreateParkMiller(PRTRAND phRand) RT_NO_THROW;
+
+/**
+ * Destroys a random number generator.
+ *
+ * @returns IPRT status code.
+ * @param   hRand       Handle to the random number generator.
+ */
+RTDECL(int) RTRandAdvDestroy(RTRAND hRand) RT_NO_THROW;
+
+/**
+ * Generic method for seeding of a random number generator.
+ *
+ * The different generators may have specialized methods for
+ * seeding, use one of those if you desire better control
+ * over ther result.
+ *
+ * @returns IPRT status code.
+ * @param   hRand       Handle to the random number generator.
+ * @param   u64Seed     Seed.
+ */
+RTDECL(int) RTRandAdvSeed(RTRAND hRand, uint64_t u64Seed) RT_NO_THROW;
+
+/**
+ * Fills a buffer with random bytes.
+ *
+ * @param   hRand       Handle to the random number generator.
+ * @param   pv  Where to store the random bytes.
+ * @param   cb  Number of bytes to generate.
+ */
+RTDECL(void) RTRandAdvBytes(RTRAND hRand, void *pv, size_t cb) RT_NO_THROW;
+
+/**
+ * Generate a 32-bit signed random number in the set [i32First..i32Last].
+ *
+ * @returns The random number.
+ * @param   hRand       Handle to the random number generator.
+ * @param   i32First    First number in the set.
+ * @param   i32Last     Last number in the set.
+ */
+RTDECL(int32_t) RTRandAdvS32Ex(RTRAND hRand, int32_t i32First, int32_t i32Last) RT_NO_THROW;
+
+/**
+ * Generate a 32-bit signed random number.
+ *
+ * @returns The random number.
+ * @param   hRand       Handle to the random number generator.
+ */
+RTDECL(int32_t) RTRandAdvS32(RTRAND hRand) RT_NO_THROW;
+
+/**
+ * Generate a 32-bit unsigned random number in the set [u32First..u32Last].
+ *
+ * @returns The random number.
+ * @param   hRand       Handle to the random number generator.
+ * @param   u32First    First number in the set.
+ * @param   u32Last     Last number in the set.
+ */
+RTDECL(uint32_t) RTRandAdvU32Ex(RTRAND hRand, uint32_t u32First, uint32_t u32Last) RT_NO_THROW;
+
+/**
+ * Generate a 32-bit unsigned random number.
+ *
+ * @returns The random number.
+ * @param   hRand       Handle to the random number generator.
+ */
+RTDECL(uint32_t) RTRandAdvU32(RTRAND hRand) RT_NO_THROW;
+
+/**
+ * Generate a 64-bit signed random number in the set [i64First..i64Last].
+ *
+ * @returns The random number.
+ * @param   hRand       Handle to the random number generator.
+ * @param   i64First    First number in the set.
+ * @param   i64Last     Last number in the set.
+ */
+RTDECL(int64_t) RTRandAdvS64Ex(RTRAND hRand, int64_t i64First, int64_t i64Last) RT_NO_THROW;
+
+/**
+ * Generate a 64-bit signed random number.
+ *
+ * @returns The random number.
+ */
+RTDECL(int64_t) RTRandAdvS64(RTRAND hRand) RT_NO_THROW;
+
+/**
+ * Generate a 64-bit unsigned random number in the set [u64First..u64Last].
+ *
+ * @returns The random number.
+ * @param   hRand       Handle to the random number generator.
+ * @param   u64First    First number in the set.
+ * @param   u64Last     Last number in the set.
+ */
+RTDECL(uint64_t) RTRandAdvU64Ex(RTRAND hRand, uint64_t u64First, uint64_t u64Last) RT_NO_THROW;
+
+/**
+ * Generate a 64-bit unsigned random number.
+ *
+ * @returns The random number.
+ * @param   hRand       Handle to the random number generator.
+ */
+RTDECL(uint64_t) RTRandAdvU64(RTRAND hRand) RT_NO_THROW;
+
+
-/** @} */
-

trunk/include/iprt/types.h

@@ -1147 +1147 @@
-#define NIL_RTTIMERLR                               ((RTTIMERLR)0)
-
+/** Handle to a random number generator. */
+typedef struct RTRANDINT                           *RTRAND;
+/** Pointer to a random number generator handle. */
+typedef RTRAND                                     *PRTRAND;
+/** NIL random number genrator handle value. */
+#define NIL_RTRAND                                  ((RTRAND)0)
+
-
-/**

trunk/src/VBox/Runtime/Makefile.kmk

@@ -197 +197 @@
-        common/misc/zip.cpp \
-        common/rand/rand.cpp \
+        common/rand/randadv.cpp \
+        common/rand/randparkmiller.cpp \
-        common/string/RTStrNLen.cpp \
-        common/string/RTStrNLenEx.cpp \

trunk/src/VBox/Runtime/include/internal/magics.h

@@ -55 +55 @@
-/** RTR0MEMOBJ::u32Magic. (Masakazu Katsura) */
-#define RTR0MEMOBJ_MAGIC            0x19611210
+/** RTRANDINT::u32Magic. (Alan Moore) */
+#define RTRANDINT_MAGIC             0x19531118
-/** Magic for the event semaphore structure. (Neil Gaiman) */
-#define RTSEMEVENT_MAGIC            0x19601110

trunk/src/VBox/Runtime/include/internal/rand.h

@@ -33 +33 @@
-
-#include <iprt/types.h>
+#include <iprt/critsect.h>
+
+/** Pointer to a random number generator instance. */
+typedef struct RTRANDINT *PRTRANDINT;
+
+/**
+ * Random number generator instance.
+ *
+ * @remarks Not sure if it makes sense to have three random getters...
+ */
+typedef struct RTRANDINT
+{
+    /** Magic value (RTRANDINT_MAGIC). */
+    uint32_t    u32Magic;
+#if 0 /** @todo later. */
+    /** Fast mutex semaphore that serializes the access, this is optional. */
+    PRTCRITSECT pCritSect;
+#endif
+
+    /**
+     * Generates random bytes.
+     *
+     * @param   pThis       Pointer to the instance data.
+     * @param   pb          Where to store the bytes.
+     * @param   cb          The number of bytes to produce.
+     */
+    DECLCALLBACKMEMBER(void ,    pfnGetBytes)(PRTRANDINT pThis, uint8_t *pb, size_t cb);
+
+    /**
+     * Generates a unsigned 32-bit random number.
+     *
+     * @returns The random number.
+     * @param   pThis       Pointer to the instance data.
+     * @param   u32First    The first number in the range.
+     * @param   u32Last     The last number in the range (i.e. inclusive).
+     */
+    DECLCALLBACKMEMBER(uint32_t, pfnGetU32)(PRTRANDINT pThis, uint32_t u32First, uint32_t u32Last);
+
+    /**
+     * Generates a unsigned 64-bit random number.
+     *
+     * @returns The random number.
+     * @param   pThis       Pointer to the instance data.
+     * @param   u64First    The first number in the range.
+     * @param   u64Last     The last number in the range (i.e. inclusive).
+     */
+    DECLCALLBACKMEMBER(uint64_t, pfnGetU64)(PRTRANDINT pThis, uint64_t u64First, uint64_t u64Last);
+
+    /**
+     * Generic seeding.
+     *
+     * @returns IPRT status code.
+     * @param   pThis       Pointer to the instance data.
+     * @param   u64Seed     The seed.
+     */
+    DECLCALLBACKMEMBER(int, pfnSeed)(PRTRANDINT pThis, uint64_t u64Seed);
+
+    /**
+     * Destroys the instance.
+     *
+     * The callee is responsible for freeing all resources, including
+     * the instance data.
+     *
+     * @returns IPRT status code. State undefined on failure.
+     * @param   pThis       Pointer to the instance data.
+     */
+    DECLCALLBACKMEMBER(int, pfnDestroy)(PRTRANDINT pThis);
+
+    /** Union containing the specific state info for each generator. */
+    union
+    {
+        struct RTRandParkMiller
+        {
+            /** The context. */
+            uint32_t    u32Ctx;
+            /** The number of single bits used to fill in the 31st bit. */
+            uint32_t    u32Bits;
+            /** The number bits in u32Bits. */
+            uint32_t    cBits;
+        } ParkMiller;
+    } u;
+} RTRANDINT;
+
-
-__BEGIN_DECLS
@@ -52 +135 @@
-void rtRandGenBytesFallback(void *pv, size_t cb) RT_NO_THROW;
-
+DECLCALLBACK(void)      rtRandAdvSynthesizeBytesFromU32(PRTRANDINT pThis, uint8_t *pb, size_t cb);
+DECLCALLBACK(void)      rtRandAdvSynthesizeBytesFromU64(PRTRANDINT pThis, uint8_t *pb, size_t cb);
+DECLCALLBACK(uint32_t)  rtRandAdvSynthesizeU32FromBytes(PRTRANDINT pThis, uint32_t u32First, uint32_t u32Last);
+DECLCALLBACK(uint32_t)  rtRandAdvSynthesizeU32FromU64(PRTRANDINT pThis, uint32_t u32First, uint32_t u32Last);
+DECLCALLBACK(uint64_t)  rtRandAdvSynthesizeU64FromBytes(PRTRANDINT pThis, uint64_t u64First, uint64_t u64Last);
+DECLCALLBACK(uint64_t)  rtRandAdvSynthesizeU64FromU32(PRTRANDINT pThis, uint64_t u64First, uint64_t u64Last);
+
-__END_DECLS
-
-#endif
+

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

@@ -101 +101 @@
-
-
-int main(
+static int tstRandAdv(RTRAND hRand
-{
-    RTR3Init(false);
-    RTPrintf("tstRand: TESTING...\n");
-
-    /*
-     * Do some smoke tests first?
-     */
-    /** @todo RTRand smoke testing. */
-
-    /*
-     * Test distribution.
@@ -139 +131 @@
-        uint32_t const uRange = uLast - uFirst; Assert(uLast >= uFirst);
-        uint32_t const uDivisor = uRange / TST_RAND_SAMPLE_RANGES + 1;
-TESTING RTRandU32Ex(
-
-
-U32Ex(
+  TESTING RTRandAdvU32Ex(,
+
+
+AdvU32Ex(hRand, 
-            CHECK_EXPR_MSG(uRand >= uFirst, ("%#RX32 %#RX32\n", uRand, uFirst));
-            CHECK_EXPR_MSG(uRand <= uLast,  ("%#RX32 %#RX32\n", uRand, uLast));
@@ -184 +176 @@
-        uint64_t const uRange = uLast - uFirst;  Assert(uLast >= uFirst);
-        uint64_t const uDivisor = uRange / TST_RAND_SAMPLE_RANGES + 1;
-TESTING RTRandU64Ex(
-
-
-U64Ex(
+  TESTING RTRandAdvU64Ex(,
+
+
+AdvU64Ex(hRand, 
-            CHECK_EXPR_MSG(uRand >= uFirst, ("%#RX64 %#RX64\n", uRand, uFirst));
-            CHECK_EXPR_MSG(uRand <= uLast,  ("%#RX64 %#RX64\n", uRand, uLast));
@@ -242 +234 @@
-        uint32_t const uRange = iLast - iFirst; AssertMsg(iLast >= iFirst, ("%d\n", iTest));
-        uint32_t const uDivisor = (uRange ? uRange : UINT32_MAX) / TST_RAND_SAMPLE_RANGES + 1;
-TESTING RTRandS32Ex(
-
-
-S32Ex(
+  TESTING RTRandAdvS32Ex(,
+
+
+AdvS32Ex(hRand, 
-            CHECK_EXPR_MSG(iRand >= iFirst, ("%#RI32 %#RI32\n", iRand, iFirst));
-            CHECK_EXPR_MSG(iRand <= iLast,  ("%#RI32 %#RI32\n", iRand, iLast));
@@ -311 +303 @@
-        uint64_t const uRange = iLast - iFirst; AssertMsg(iLast >= iFirst, ("%d\n", iTest));
-        uint64_t const uDivisor = (uRange ? uRange : UINT64_MAX) / TST_RAND_SAMPLE_RANGES + 1;
+        RTPrintf("tstRand:   TESTING RTRandAdvS64Ex(,%#RI64, %#RI64) distribution... [div=%#RX64 range=%#016RX64]\n", iFirst, iLast, uDivisor, uRange);
+        for (unsigned iSample = 0; iSample < TST_RAND_SAMPLE_RANGES * 10240; iSample++)
+        {
+            int64_t iRand = RTRandAdvS64Ex(hRand, iFirst, iLast);
+            CHECK_EXPR_MSG(iRand >= iFirst, ("%#RI64 %#RI64\n", iRand, iFirst));
+            CHECK_EXPR_MSG(iRand <= iLast,  ("%#RI64 %#RI64\n", iRand, iLast));
+            uint64_t off = iRand - iFirst;
+            acHits[off / uDivisor]++;
+        }
+        tstRandCheckDist(acHits, iTest);
+    }
+#endif
+
+    /*
+     * Destroy it.
+     */
+    int rc = RTRandAdvDestroy(hRand);
+    CHECK_EXPR_MSG(rc == VINF_SUCCESS,  ("RTRandAdvDestroy(%p) -> %Rrc (%d)\n", (uintptr_t)hRand, rc, rc));
+
+    return 0;
+}
+
+
+
+int main()
+{
+    RTR3Init(false);
+    RTPrintf("tstRand: TESTING...\n");
+
+    /*
+     * Do some smoke tests first?
+     */
+    /** @todo RTRand smoke testing. */
+
+#if 1
+    /*
+     * Test distribution.
+     */
+#if 1
+    /* unsigned 32-bit */
+    static const struct
+    {
+        uint32_t u32First;
+        uint32_t u32Last;
+    } s_aU32Tests[] =
+    {
+        { 0, UINT32_MAX },
+        { 0, UINT32_MAX / 2 + UINT32_MAX / 4 },
+        { 0, UINT32_MAX / 2 + UINT32_MAX / 8 },
+        { 0, UINT32_MAX / 2 + UINT32_MAX / 16 },
+        { 0, UINT32_MAX / 2 + UINT32_MAX / 64 },
+        { 0, UINT32_MAX / 2 },
+        { UINT32_MAX / 4, UINT32_MAX / 4 * 3 },
+        { 0, TST_RAND_SAMPLE_RANGES - 1 },
+        { 1234, 1234 + TST_RAND_SAMPLE_RANGES - 1 },
+    };
+    for (unsigned iTest = 0; iTest < RT_ELEMENTS(s_aU32Tests); iTest++)
+    {
+        uint32_t       acHits[TST_RAND_SAMPLE_RANGES] = {0};
+        uint32_t const uFirst = s_aU32Tests[iTest].u32First;
+        uint32_t const uLast  = s_aU32Tests[iTest].u32Last;
+        uint32_t const uRange = uLast - uFirst; Assert(uLast >= uFirst);
+        uint32_t const uDivisor = uRange / TST_RAND_SAMPLE_RANGES + 1;
+        RTPrintf("tstRand: TESTING RTRandU32Ex(%#RX32, %#RX32) distribution... [div=%#RX32 range=%#RX32]\n", uFirst, uLast, uDivisor, uRange);
+        for (unsigned iSample = 0; iSample < TST_RAND_SAMPLE_RANGES * 10240; iSample++)
+        {
+            uint32_t uRand = RTRandU32Ex(uFirst, uLast);
+            CHECK_EXPR_MSG(uRand >= uFirst, ("%#RX32 %#RX32\n", uRand, uFirst));
+            CHECK_EXPR_MSG(uRand <= uLast,  ("%#RX32 %#RX32\n", uRand, uLast));
+            uint32_t off = uRand - uFirst;
+            acHits[off / uDivisor]++;
+        }
+        tstRandCheckDist(acHits, iTest);
+    }
+#endif
+
+#if 1
+    /* unsigned 64-bit */
+    static const struct
+    {
+        uint64_t u64First;
+        uint64_t u64Last;
+    } s_aU64Tests[] =
+    {
+        { 0, UINT64_MAX },
+        { 0, UINT64_MAX / 2 + UINT64_MAX / 4 },
+        { 0, UINT64_MAX / 2 + UINT64_MAX / 8 },
+        { 0, UINT64_MAX / 2 + UINT64_MAX / 16 },
+        { 0, UINT64_MAX / 2 + UINT64_MAX / 64 },
+        { 0, UINT64_MAX / 2 },
+        { UINT64_MAX / 4, UINT64_MAX / 4 * 3 },
+        { 0, UINT32_MAX },
+        { 0, UINT32_MAX / 2 + UINT32_MAX / 4 },
+        { 0, UINT32_MAX / 2 + UINT32_MAX / 8 },
+        { 0, UINT32_MAX / 2 + UINT32_MAX / 16 },
+        { 0, UINT32_MAX / 2 + UINT32_MAX / 64 },
+        { 0, UINT32_MAX / 2 },
+        { UINT32_MAX / 4, UINT32_MAX / 4 * 3 },
+        { 0, TST_RAND_SAMPLE_RANGES - 1 },
+        { 1234, 1234 + TST_RAND_SAMPLE_RANGES - 1 },
+    };
+    for (unsigned iTest = 0; iTest < RT_ELEMENTS(s_aU64Tests); iTest++)
+    {
+        uint32_t       acHits[TST_RAND_SAMPLE_RANGES] = {0};
+        uint64_t const uFirst = s_aU64Tests[iTest].u64First;
+        uint64_t const uLast  = s_aU64Tests[iTest].u64Last;
+        uint64_t const uRange = uLast - uFirst;  Assert(uLast >= uFirst);
+        uint64_t const uDivisor = uRange / TST_RAND_SAMPLE_RANGES + 1;
+        RTPrintf("tstRand: TESTING RTRandU64Ex(%#RX64, %#RX64) distribution... [div=%#RX64 range=%#RX64]\n", uFirst, uLast, uDivisor, uRange);
+        for (unsigned iSample = 0; iSample < TST_RAND_SAMPLE_RANGES * 10240; iSample++)
+        {
+            uint64_t uRand = RTRandU64Ex(uFirst, uLast);
+            CHECK_EXPR_MSG(uRand >= uFirst, ("%#RX64 %#RX64\n", uRand, uFirst));
+            CHECK_EXPR_MSG(uRand <= uLast,  ("%#RX64 %#RX64\n", uRand, uLast));
+            uint64_t off = uRand - uFirst;
+            acHits[off / uDivisor]++;
+        }
+        tstRandCheckDist(acHits, iTest);
+    }
+#endif
+
+#if 1
+    /* signed 32-bit */
+    static const struct
+    {
+        int32_t i32First;
+        int32_t i32Last;
+    } s_aS32Tests[] =
+    {
+        { -429496729, 429496729 },
+        { INT32_MIN, INT32_MAX },
+        { INT32_MIN, INT32_MAX / 2 },
+        { -0x20000000, INT32_MAX },
+        { -0x10000000, INT32_MAX },
+        { -0x080000000, INT32_MAX },
+        { -0x008000000, INT32_MAX },
+        { -0x000800000, INT32_MAX },
+        { -0x000080000, INT32_MAX },
+        { -0x000008000, INT32_MAX },
+        { 2, INT32_MAX / 2 },
+        { 4000000, INT32_MAX / 2 },
+        { -4000000, INT32_MAX / 2 },
+        { INT32_MIN / 2, INT32_MAX / 2 },
+        { INT32_MIN / 3, INT32_MAX / 2 },
+        { INT32_MIN / 3, INT32_MAX / 3 },
+        { INT32_MIN / 3, INT32_MAX / 4 },
+        { INT32_MIN / 4, INT32_MAX / 4 },
+        { INT32_MIN / 5, INT32_MAX / 5 },
+        { INT32_MIN / 6, INT32_MAX / 6 },
+        { INT32_MIN / 7, INT32_MAX / 6 },
+        { INT32_MIN / 7, INT32_MAX / 7 },
+        { INT32_MIN / 7, INT32_MAX / 8 },
+        { INT32_MIN / 8, INT32_MAX / 8 },
+        { INT32_MIN / 9, INT32_MAX / 9 },
+        { INT32_MIN / 9, INT32_MAX / 12 },
+        { INT32_MIN / 12, INT32_MAX / 12 },
+        { 0, TST_RAND_SAMPLE_RANGES - 1 },
+        { -TST_RAND_SAMPLE_RANGES / 2, TST_RAND_SAMPLE_RANGES / 2 - 1 },
+    };
+    for (unsigned iTest = 0; iTest < RT_ELEMENTS(s_aS32Tests); iTest++)
+    {
+        uint32_t       acHits[TST_RAND_SAMPLE_RANGES] = {0};
+        int32_t const  iFirst = s_aS32Tests[iTest].i32First;
+        int32_t const  iLast  = s_aS32Tests[iTest].i32Last;
+        uint32_t const uRange = iLast - iFirst; AssertMsg(iLast >= iFirst, ("%d\n", iTest));
+        uint32_t const uDivisor = (uRange ? uRange : UINT32_MAX) / TST_RAND_SAMPLE_RANGES + 1;
+        RTPrintf("tstRand: TESTING RTRandS32Ex(%#RI32, %#RI32) distribution... [div=%#RX32 range=%#RX32]\n", iFirst, iLast, uDivisor, uRange);
+        for (unsigned iSample = 0; iSample < TST_RAND_SAMPLE_RANGES * 10240; iSample++)
+        {
+            int32_t iRand = RTRandS32Ex(iFirst, iLast);
+            CHECK_EXPR_MSG(iRand >= iFirst, ("%#RI32 %#RI32\n", iRand, iFirst));
+            CHECK_EXPR_MSG(iRand <= iLast,  ("%#RI32 %#RI32\n", iRand, iLast));
+            uint32_t off = iRand - iFirst;
+            acHits[off / uDivisor]++;
+        }
+        tstRandCheckDist(acHits, iTest);
+    }
+#endif
+
+#if 1
+    /* signed 64-bit */
+    static const struct
+    {
+        int64_t i64First;
+        int64_t i64Last;
+    } s_aS64Tests[] =
+    {
+        { INT64_MIN, INT64_MAX },
+        { INT64_MIN, INT64_MAX / 2 },
+        { INT64_MIN / 2, INT64_MAX / 2 },
+        { INT64_MIN / 2 + INT64_MIN / 4, INT64_MAX / 2 },
+        { INT64_MIN / 2 + INT64_MIN / 8, INT64_MAX / 2 },
+        { INT64_MIN / 2 + INT64_MIN / 16, INT64_MAX / 2 },
+        { INT64_MIN / 2 + INT64_MIN / 64, INT64_MAX / 2 },
+        { INT64_MIN / 2 + INT64_MIN / 64, INT64_MAX / 2 + INT64_MAX / 64 },
+        { INT64_MIN / 2, INT64_MAX / 2 + INT64_MAX / 64 },
+        { INT64_MIN / 2, INT64_MAX / 2 + INT64_MAX / 8 },
+        { INT64_MIN / 2, INT64_MAX / 2 - INT64_MAX / 8 },
+        { INT64_MIN / 2 - INT64_MIN / 4, INT64_MAX / 2 - INT64_MAX / 4 },
+        { INT64_MIN / 2 - INT64_MIN / 4, INT64_MAX / 2 - INT64_MAX / 8 },
+        { INT64_MIN / 2 - INT64_MIN / 8, INT64_MAX / 2 - INT64_MAX / 8 },
+        { INT64_MIN / 2 - INT64_MIN / 16, INT64_MAX / 2 - INT64_MAX / 8 },
+        { INT64_MIN / 2 - INT64_MIN / 16, INT64_MAX / 2 - INT64_MAX / 16 },
+        { INT64_MIN / 2 - INT64_MIN / 32, INT64_MAX / 2 - INT64_MAX / 16 },
+        { INT64_MIN / 2 - INT64_MIN / 32, INT64_MAX / 2 - INT64_MAX / 32 },
+        { INT64_MIN / 2 - INT64_MIN / 64, INT64_MAX / 2 - INT64_MAX / 64 },
+        { INT64_MIN / 2 - INT64_MIN / 8, INT64_MAX / 2 },
+        { INT64_MIN / 4, INT64_MAX / 4 },
+        { INT64_MIN / 5, INT64_MAX / 5 },
+        { INT64_MIN / 6, INT64_MAX / 6 },
+        { INT64_MIN / 7, INT64_MAX / 7 },
+        { INT64_MIN / 8, INT64_MAX / 8 },
+        { INT32_MIN, INT32_MAX },
+        { INT32_MIN, INT32_MAX / 2 },
+        { -0x20000000, INT32_MAX },
+        { -0x10000000, INT32_MAX },
+        { -0x7f000000, INT32_MAX },
+        { -0x08000000, INT32_MAX },
+        { -0x00800000, INT32_MAX },
+        { -0x00080000, INT32_MAX },
+        { -0x00008000, INT32_MAX },
+        { 2, INT32_MAX / 2 },
+        { 4000000, INT32_MAX / 2 },
+        { -4000000, INT32_MAX / 2 },
+        { INT32_MIN / 2, INT32_MAX / 2 },
+        { 0, TST_RAND_SAMPLE_RANGES - 1 },
+        { -TST_RAND_SAMPLE_RANGES / 2, TST_RAND_SAMPLE_RANGES / 2 - 1 }
+    };
+    for (unsigned iTest = 0; iTest < RT_ELEMENTS(s_aS64Tests); iTest++)
+    {
+        uint32_t       acHits[TST_RAND_SAMPLE_RANGES] = {0};
+        int64_t const  iFirst = s_aS64Tests[iTest].i64First;
+        int64_t const  iLast  = s_aS64Tests[iTest].i64Last;
+        uint64_t const uRange = iLast - iFirst; AssertMsg(iLast >= iFirst, ("%d\n", iTest));
+        uint64_t const uDivisor = (uRange ? uRange : UINT64_MAX) / TST_RAND_SAMPLE_RANGES + 1;
-        RTPrintf("tstRand: TESTING RTRandS64Ex(%#RI64, %#RI64) distribution... [div=%#RX64 range=%#016RX64]\n", iFirst, iLast, uDivisor, uRange);
-        for (unsigned iSample = 0; iSample < TST_RAND_SAMPLE_RANGES * 10240; iSample++)
@@ -323 +550 @@
-    }
-#endif
+#endif /* Testing RTRand */
+
+#if 1
+    /*
+     * Test the various random generators.
+     */
+    RTPrintf("tstRand: TESTING RTRandAdvCreateParkerMiller\n");
+    RTRAND hRand;
+    int rc = RTRandAdvCreateParkMiller(&hRand);
+    CHECK_EXPR_MSG(rc == VINF_SUCCESS, ("rc=%Rrc\n", rc));
+    if (RT_SUCCESS(rc))
+        if (tstRandAdv(hRand))
+            return 1;
+
+#endif /* Testing RTRandAdv */
-
-    /*