Time::HiRes.xs don't Win32's QueryPerformanceFrequency() over and over

-It is a boot time constant. It will not change without a motherboard or
 CPU swap and then rebooting. The actual 64 bit integer returned, reflects
 if the NT Kernel wants to use Intel's APIC Timer or Intel's 8253/8254 PIT
 Timer, or Intel's RDTSC instruction. NT Kernel will only use RDTSC backend
 if both the CPU and Northbridge swear upon a holy book, that they will
 fire an interrupt at every Intel/AMD SpeedSwitch/TurboBoost transition.
 The dynamic CPU speed correction factor logic lives inside the machine
 code of QueryPerformanceCounter(). Not inside QueryPerformanceFrequency()
 which has been part of MS;s frozen Public API since 1993.
-the test:

 if (!QueryPerformanceFrequency(&l_tick_frequency)) croak("WT???");

 can probably be removed one day, only Win2K or NT4 or Win95/98, running
 on any 32-bit CISC or 32-but RISC CPU arch, are capable of retval FALSE.
 The test is added out of paranoia. IDK what in real life on real HW can
 cause retval FALSE.
-calc and save var unsigned __int64 qpc_res_ns; and
 unsigned __int64 qpc_res_ns_realtime; exactly once instead of re-calcing
 in the runloop, why not? HiRes.dll's .data section is only 0x650 bytes
 long and granularity is 0x1000/4096 bytes.
-the BOOT: initialization code of the 3 true C static global vars, is
 written, to assume 2 ithreads, or 2 my_perl ptrs, or 2 different
 embbeding consumers of perl5XX.dll inside 1 OS process, can
 simultaneously call Dynaloader::bootstrap() or Time::HiRes::bootstrap()
 on 2 different CPU cores. This is unrealistic paranoia IMO, but CPU op
 lock xchg reg, [addr]; and mov [addr], reg; are both 7 bytes long.
 Maybe Windows >= 8.0 on ARM32/ARM64, want their memory fence/barrier
 formalities writing to an aligned 64 bit integer. So why not?
-#define S_InterlockedExchange64(_d,_s) has S_ prefix, so no assumptions
 are made on MSVC and Mingw GCC, if InterlockedExchange64() is a macro or
 a symbol. Any age, any version, any build number, any FOSS project code
 owner, or any FOSS binary packager, of those 2 C compiler families.

Author: bulk88

dist/Time-HiRes/HiRes.xs

@@ -135,11 +135,17 @@ typedef union {
 typedef struct {
     unsigned long run_count;
     unsigned __int64 base_ticks;
-    unsigned __int64 tick_frequency;
     FT_t base_systime_as_filetime;
     unsigned __int64 reset_time;
 } my_cxt_t;
 
+static unsigned __int64 tick_frequency = 0;
+static unsigned __int64 qpc_res_ns = 0;
+static unsigned __int64 qpc_res_ns_realtime = 0;
+
+#define S_InterlockedExchange64(_d,_s) \
+    InterlockedExchange64((LONG64 volatile *)(_d),(LONG64)(_s))
+
 /* Visual C++ 2013 and older don't have the timespec structure.
  * Neither do mingw.org compilers with MinGW runtimes older than 3.22. */
 #  if((defined(_MSC_VER) && _MSC_VER < 1900) || \
@@ -220,7 +226,6 @@ _GetSystemTimePreciseAsFileTime(pTHX_ FILETIME *out)
     if (MY_CXT.run_count++ == 0 ||
         MY_CXT.base_systime_as_filetime.ft_i64 > MY_CXT.reset_time) {
 
-        QueryPerformanceFrequency((LARGE_INTEGER*)&MY_CXT.tick_frequency);
         QueryPerformanceCounter((LARGE_INTEGER*)&MY_CXT.base_ticks);
         GetSystemTimeAsFileTime(&MY_CXT.base_systime_as_filetime.ft_val);
         ft.ft_i64 = MY_CXT.base_systime_as_filetime.ft_i64;
@@ -232,8 +237,8 @@ _GetSystemTimePreciseAsFileTime(pTHX_ FILETIME *out)
         QueryPerformanceCounter((LARGE_INTEGER*)&ticks);
         ticks -= MY_CXT.base_ticks;
         ft.ft_i64 = MY_CXT.base_systime_as_filetime.ft_i64
-                    + Const64(IV_1E7) * (ticks / MY_CXT.tick_frequency)
-                    +(Const64(IV_1E7) * (ticks % MY_CXT.tick_frequency)) / MY_CXT.tick_frequency;
+                    + Const64(IV_1E7) * (ticks / tick_frequency)
+                    +(Const64(IV_1E7) * (ticks % tick_frequency)) / tick_frequency;
         diff = ft.ft_i64 - MY_CXT.base_systime_as_filetime.ft_i64;
         if (diff < -MAX_PERF_COUNTER_SKEW || diff > MAX_PERF_COUNTER_SKEW) {
             MY_CXT.base_ticks += ticks;
@@ -278,13 +283,12 @@ _clock_gettime(pTHX_ clockid_t clock_id, struct timespec *tp)
         break;
     }
     case CLOCK_MONOTONIC: {
-        unsigned __int64 freq, ticks;
+        unsigned __int64 ticks;
 
-        QueryPerformanceFrequency((LARGE_INTEGER*)&freq);
         QueryPerformanceCounter((LARGE_INTEGER*)&ticks);
 
-        tp->tv_sec = (time_t)(ticks / freq);
-        tp->tv_nsec = (long)((IV_1E9 * (ticks % freq)) / freq);
+        tp->tv_sec = (time_t)(ticks / tick_frequency);
+        tp->tv_nsec = (long)((IV_1E9 * (ticks % tick_frequency)) / tick_frequency);
         break;
     }
     default:
@@ -298,17 +302,10 @@ _clock_gettime(pTHX_ clockid_t clock_id, struct timespec *tp)
 static int
 _clock_getres(clockid_t clock_id, struct timespec *tp)
 {
-    unsigned __int64 freq, qpc_res_ns;
-
-    QueryPerformanceFrequency((LARGE_INTEGER*)&freq);
-    qpc_res_ns = IV_1E9 > freq ? IV_1E9 / freq : 1;
-
     switch (clock_id) {
     case CLOCK_REALTIME:
         tp->tv_sec = 0;
-        /* the resolution can't be smaller than 100ns because our implementation
-         * of CLOCK_REALTIME is using FILETIME internally */
-        tp->tv_nsec = (long)(qpc_res_ns > 100 ? qpc_res_ns : 100);
+        tp->tv_nsec = (long)qpc_res_ns_realtime;
         break;
 
     case CLOCK_MONOTONIC:
@@ -929,6 +926,28 @@ BOOT:
 #ifdef MY_CXT_KEY
         MY_CXT_INIT;
 #endif
+#if defined(WIN32) || defined(CYGWIN_WITH_W32API)
+        if (tick_frequency == 0) { /* no DllMain() in very rare static Perls */
+            unsigned __int64 l_tick_frequency;
+/* from MSDN: >= WinXP, function will always succeed and never return zero */
+            if (!QueryPerformanceFrequency((LARGE_INTEGER*)&l_tick_frequency))
+                croak("%s(): unimplemented in this platform", "QueryPerformanceFrequency");
+             /* 32-bit CPU anti-sharding paranoia */
+            S_InterlockedExchange64(&tick_frequency, l_tick_frequency);
+        }
+        if (qpc_res_ns == 0) {
+            unsigned __int64 l_qpc_res_ns =
+                IV_1E9 > tick_frequency ? IV_1E9 / tick_frequency : 1;
+            S_InterlockedExchange64(&qpc_res_ns, l_qpc_res_ns);
+        }
+        if (qpc_res_ns_realtime == 0) {
+        /* the resolution can't be smaller than 100ns because our implementation
+         * of CLOCK_REALTIME is using FILETIME internally */
+            unsigned __int64 l_qpc_res_ns_realtime =
+                qpc_res_ns > 100 ? qpc_res_ns : 100;
+            S_InterlockedExchange64(&qpc_res_ns_realtime, l_qpc_res_ns_realtime);
+        }
+#endif
 #ifdef HAS_GETTIMEOFDAY
         {
             (void) hv_store(PL_modglobal, "Time::NVtime", 12,