cpu_hog: don't use non-reentrant rand() in threads, do smth with result

Previously, stress -c did a terrible job at actually loading the CPU; it
was idle most of the times:

```
$> perf stat stress -c 16 -t 5
stress: info: [526148] dispatching hogs: 16 cpu, 0 io, 0 vm, 0 hdd
stress: info: [526148] successful run completed in 5s

 Performance counter stats for 'stress -c 16 -t 5':

         79,580.45 msec task-clock:u                     #   15.910 CPUs utilized
                 0      context-switches:u               #    0.000 /sec
                 0      cpu-migrations:u                 #    0.000 /sec
               309      page-faults:u                    #    3.883 /sec
   418,716,815,425      cycles:u                         #    5.262 GHz
   262,176,845,042      stalled-cycles-frontend:u        #   62.61% frontend cycles idle
   617,055,840,870      instructions:u                   #    1.47  insn per cycle
                                                  #    0.42  stalled cycles per insn
   175,186,890,751      branches:u                       #    2.201 G/sec
       269,450,686      branch-misses:u                  #    0.15% of all branches

       5.001799550 seconds time elapsed

      79.463002000 seconds user
       0.007854000 seconds sys
```

This means that in more than half of the cycles, the CPU frontend
couldn't do something. Why? A `perf record -g` trace of the same
invocation tells us that the CPU is spending > 99% of its time in
__random, waiting for an integer comparison that involves a data load.

No surprise there: rand() relies on global state that needs to get
synchronized.

With this percentage in mind, it's not so bad that the result of sqrt
never got used.

This commit changes both:

- stores the result of sqrt in a volatile double
- to stay portable, and use a very small-state algorithm for
  pseudo-random number generation, we just inline xoroshiro128+ [1],
  which is under a MIT-0 style "dedication to public domain" license.

We still don't "spin on sqrt()", because floating point sqrt is very
very fast on modern desktop/server CPUs; but at least we actually make
the CPU do its rounds.

[1] https://prng.di.unimi.it/

Signed-off-by: Marcus Müller <mueller_foss_stress@baseband.digital>

Author: Marcus Müller

src/stress.c

@@ -3,6 +3,7 @@
  * Copyright 2001-2010 Amos Waterland <apw@rossby.metr.ou.edu>
  * Copyright 2021-2023 Joao Eriberto Mota Filho <eriberto@eriberto.pro.br>
  * Copyright 2023      Vratislav Bendel <vbendel@redhat.com>
+ * Copyright 2025      Marcus Müller <mueller_foss_stress@baseband.digital>
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
@@ -23,6 +24,7 @@
 #include <errno.h>
 #include <libgen.h>
 #include <math.h>
+#include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -479,9 +481,47 @@ void worker_init(void)
 int
 hogcpu (void)
 {
-    while (1)
-        sqrt (rand ());
-
+    /* initial state for PRNG */
+    static uint32_t s[] = {
+        4 /* chosen by fair dice roll */,
+        42 /* the answer */,
+        3 /* pi */,
+        0xCAFECA4E /* because who doesn't like cake? */
+    };
+    while (1) {
+        /* START xoroshirp128plus:
+         Written in 2018 by David Blackman and Sebastiano Vigna (vigna@acm.org)
+
+        To the extent possible under law, the author has dedicated all copyright
+        and related and neighboring rights to this software to the public domain
+        worldwide.
+
+        Permission to use, copy, modify, and/or distribute this software for any
+        purpose with or without fee is hereby granted.
+
+        THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+        WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+        MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+        ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+        WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+        ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
+        IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+        */
+
+        const uint32_t result = s[0] + s[3];
+        const uint32_t t = s[1] << 9;
+
+        s[2] ^= s[0];
+        s[3] ^= s[1];
+        s[1] ^= s[2];
+        s[0] ^= s[3];
+
+        s[2] ^= t;
+
+        s[3] = (s[3] << 11) | (s[3]>> (32-11));
+        /* END xoroshirp128plus */
+        volatile double value = sqrt ((double)(result));
+    }
     return 0;
 }