Fix Issue 19075 - rt.util.random.Rand48.defaultSeed should prefer RDTSC or mach_absolute_time or QueryPerformanceCounter to ctime.time

`rt.util.random.Rand48.defaultSeed` generates a seed from the clock
using `ctime.time`. With `D_InlineAsm_X86_64` it would be better to
use the RDTSC instruction because it is much faster as well as being
finer precision. (Finer precision is a benefit not because we care
about accurate time, but because the differences between seeds
generated this way are potentially greater.) The same is true of
`mach_absolute_time` on macOS and `QueryPerformanceCounter` on
Microsoft Windows.

This PR doesn't use RDTSC with `D_InlineAsm_X86` because some x86
processors don't support RDTSC and because on x86 (but not x86-64)
Linux `prctl` can disable a process's ability to use RDTSC.

Author: n8sh

src/rt/util/random.d

@@ -12,10 +12,55 @@ struct Rand48
 
 @safe @nogc nothrow:
 
-    void defaultSeed()
+    void defaultSeed() @trusted
     {
-        import ctime = core.stdc.time : time;
-        seed(cast(uint)ctime.time(null));
+        version(D_InlineAsm_X86_64)
+        {
+            // RDTSC takes around 22 clock cycles.
+            ulong result = void; // Workaround for LDC issue #950, cannot access struct members in DMD asm.
+            asm @nogc nothrow
+            {
+                rdtsc;
+                // RAX: low 32 bits are low bits of timestamp, high 32 bits are 0.
+                // RDX: low 32 bits are high bits of timestamp, high 32 bits are 0.
+                // We combine these into a 48 bit value instead of a full 64 bits
+                // because `front` and `popFront` only make use of the bottom 48
+                // bits of `rng_state`.
+                shl RDX, 16;
+                xor RDX, RAX;
+                mov result, RDX;
+            }
+            rng_state = result;
+            popFront();
+        }
+        //else version(D_InlineAsm_X86)
+        //{
+        //    // We don't use `rdtsc` with version(D_InlineAsm_X86) because
+        //    // some x86 processors don't support `rdtsc` and because on
+        //    // x86 (but not x86-64) Linux `prctl` can disable a process's
+        //    // ability to use `rdtsc`.
+        //    static assert(0);
+        //}
+        else version(Windows)
+        {
+            // QueryPerformanceCounter takes about 1/4 the time of ctime.time.
+            import core.sys.windows.winbase : QueryPerformanceCounter;
+            QueryPerformanceCounter(cast(long*) &rng_state);
+            popFront();
+        }
+        else version(OSX)
+        {
+            // mach_absolute_time is much faster than ctime.time.
+            import core.time : mach_absolute_time;
+            rng_state = mach_absolute_time();
+            popFront();
+        }
+        else
+        {
+            // Fallback to libc timestamp in seconds.
+            import ctime = core.stdc.time : time;
+            seed((cast(uint) ctime.time(null)));
+        }
     }
 
 pure: