Rewrite rng component using <random> as reference

Incorporate interface for <random> engines and std::seed_seq into single struct.
Use operator()() and operator()(uint32_t) to retrieve unbounded and bounded results.

Melissa's PCG is unbiased, so <random> is not required in order to use the RNG struct as is.
Use generate(It start, It end) to fill target range with data (as per std::seed_seq).
Use seed functions with something like std::seed_seq with a generate function to fill the internal state of the PCG with random data.
Or alternatively use the seed function with an integer to select a fairly random PCG stream.

Author: Andersama

src/CMakeLists.txt

@@ -684,7 +684,6 @@ set(INCLUDE_FILES
         buttonhandler/ButtonHandler.h
         touchhandler/TouchHandler.h
         utility/Math.h
-        pcg-cpp/include/pcg_random.hpp
         )
 
 include_directories(

src/components/rng/PCG.cpp

@@ -1,22 +1,107 @@
 #include "components/rng/PCG.h"
 
-Pinetime::Controllers::RNG::State Pinetime::Controllers::RNG::Seed(Pinetime::Controllers::RNG::rng_uint s,
-                                                                   Pinetime::Controllers::RNG::rng_uint i) {
-  return rng = State(s, i);
-}
+using namespace Pinetime::Controllers;
 
-Pinetime::Controllers::RNG::State Pinetime::Controllers::RNG::Seed() {
-  using namespace Pinetime::Controllers;
-  Pinetime::Controllers::RNG::State new_rng((uint64_t) Generate() << 32 ^ (uint64_t) Generate(),
-                                            (uint64_t) Generate() << 32 ^ (uint64_t) Generate());
-  return new_rng;
-}
+//pcg_state_setseq_64::pcg_state_setseq_64(uint64_t s, uint64_t i) : state(s), inc(i) {};
+//RNG::RNG() : rng {0x853c49e6748fea9bULL, 0xda3e39cb94b95bdbULL} {};
 
-Pinetime::Controllers::RNG::rng_out Pinetime::Controllers::RNG::Generate() {
-  return rng();
+RNG::RNG(result_type value) {
+  // pcg32_srandom_r(&rng, 0x853c49e6748fea9bULL, value);
+  rng.state = 0U;
+  rng.inc = (value << 1u) | 1u;
+  (*this)(); // pcg32_random_r(rng);
+  rng.state += 0x853c49e6748fea9bULL;
+  (*this)(); // pcg32_random_r(rng);
 };
 
-// See pcg-cpp/sample/codebook.cpp
-Pinetime::Controllers::RNG::rng_out Pinetime::Controllers::RNG::GenerateBounded(Pinetime::Controllers::RNG::rng_out range) {
-  return rng(range);
+RNG& RNG::operator=(const pcg32_random_t& other) {
+  rng.state = other.state;
+  rng.inc   = other.inc | 1;
+  return *this;
+};
+
+template <class SeedSeq>
+RNG::RNG(SeedSeq& seq) {
+  seed(seq);
+};
+/*
+RNG::RNG(const RNG& other) {
+  RNG tmp = other;
+  RNG::result_type* ptr = (RNG::result_type*) this;
+  tmp.generate(ptr, ptr + (sizeof(RNG) / sizeof(RNG::result_type)));
+};
+*/
+template <typename SeedSeq>
+void RNG::seed(SeedSeq& seq) {
+  RNG::result_type* ptr = (RNG::result_type*) this;
+  seq.generate(ptr, ptr + (sizeof(RNG) / sizeof(RNG::result_type)));
+  rng.inc |= 1;
+};
+
+void RNG::seed(RNG& other) {
+  RNG::result_type* ptr = (RNG::result_type*) this;
+  other.generate(ptr, ptr + (sizeof(RNG) / sizeof(RNG::result_type)));
+  rng.inc |= 1;
+};
+
+RNG::result_type RNG::operator()() {
+  // return pcg32_random_r(&rng);
+  uint64_t oldstate = rng.state;
+  rng.state = oldstate * 6364136223846793005ULL + rng.inc;
+  uint32_t xorshifted = ((oldstate >> 18u) ^ oldstate) >> 27u;
+  uint32_t rot = oldstate >> 59u;
+  return (xorshifted >> rot) | (xorshifted << ((-rot) & 31));
+};
+
+RNG::result_type RNG::operator()(RNG::result_type bound) {
+  // return pcg32_boundedrand_r(&rng, bounds);
+  //   To avoid bias, we need to make the range of the RNG a multiple of
+  //  bound, which we do by dropping output less than a threshold.
+  //  A naive scheme to calculate the threshold would be to do
+  //
+  //      uint32_t threshold = 0x100000000ull % bound;
+  //
+  //  but 64-bit div/mod is slower than 32-bit div/mod (especially on
+  //  32-bit platforms).  In essence, we do
+  //
+  //      uint32_t threshold = (0x100000000ull-bound) % bound;
+  //
+  //  because this version will calculate the same modulus, but the LHS
+  //  value is less than 2^32.
+
+  uint32_t threshold = -bound % bound;
+
+  // Uniformity guarantees that this loop will terminate.  In practice, it
+  // should usually terminate quickly; on average (assuming all bounds are
+  // equally likely), 82.25% of the time, we can expect it to require just
+  // one iteration.  In the worst case, someone passes a bound of 2^31 + 1
+  // (i.e., 2147483649), which invalidates almost 50% of the range.  In
+  // practice, bounds are typically small and only a tiny amount of the range
+  // is eliminated.
+  for (;;) {
+    uint32_t r = (*this)(); // pcg32_random_r(rng);
+    if (r >= threshold)
+      return r % bound;
+  }
+};
+
+// std::seed_seq interface
+template <typename It>
+void RNG::generate(It start, It end) {
+  for (; start != end; ++start)
+    *start = (*this)();
+};
+
+std::size_t RNG::size() const noexcept {
+  return sizeof(rng) / sizeof(RNG::result_type);
+};
+
+template <class OutputIt>
+void RNG::param(OutputIt dest) const {
+  std::size_t i = 0;
+  const std::size_t n = size();
+  RNG::result_type* ptr = (RNG::result_type*) this;
+  for (; i < n; ++i, ++dest, ++ptr) {
+    *dest = ptr;
+  }
 };

src/components/rng/PCG.h

@@ -3,44 +3,80 @@
 #include <FreeRTOS.h>
 #include <timers.h>
 #include "components/motion/MotionController.h"
-#include "pcg-cpp/include/pcg_random.hpp"
 
 namespace Pinetime {
   namespace Controllers {
+    /*
+     * PCG Random Number Generation for C.
+     *
+     * Copyright 2014 Melissa O'Neill <[email protected]>
+     *
+     * Licensed under the Apache License, Version 2.0 (the "License");
+     * you may not use this file except in compliance with the License.
+     * You may obtain a copy of the License at
+     *
+     *     http://www.apache.org/licenses/LICENSE-2.0
+     *
+     * Unless required by applicable law or agreed to in writing, software
+     * distributed under the License is distributed on an "AS IS" BASIS,
+     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     * See the License for the specific language governing permissions and
+     * limitations under the License.
+     *
+     * For additional information about the PCG random number generation scheme,
+     * including its license and other licensing options, visit
+     *
+     *     http://www.pcg-random.org
+     */
+
+    struct pcg_state_setseq_64 { // Internals are *Private*.
+      uint64_t state = 0x853c49e6748fea9bULL; // RNG state.  All values are possible.
+      uint64_t inc   = 0xda3e39cb94b95bdbULL; // Controls which RNG sequence (stream) is
+                                 // selected. Must *always* be odd.
+      //pcg_state_setseq_64() = default;
+      //pcg_state_setseq_64(uint64_t s, uint64_t i);
+    };
+    typedef struct pcg_state_setseq_64 pcg32_random_t;
+
     struct RNG {
+      pcg32_random_t rng = {};
+      // <random> interface
+      using result_type = uint32_t;
 
-      /*
-      struct pcg_random_t {
-        rng_uint state = {};
-        rng_uint inc = {};
-      };
-      */
-      using State = pcg32;
-      using rng_uint = State::state_type;// uint32_t;
-      using rng_out = State::result_type;// uint16_t;
-
-      State rng = {};
-
-      State Seed(rng_uint s, rng_uint i);
-      // Generate another RNG struct with data generated via this one
-      State Seed();
-      // Produces an unsigned result within the full range of the data type
-      rng_out Generate();
-      // Produces an unsigned result within [0, range)
-      rng_out GenerateBounded(rng_out range);
-
-      RNG() : rng() {};
-
-      RNG& operator=(const State& pcg_state) {
-        rng = pcg_state;
-        return *this;
+      static constexpr result_type min() {
+        return result_type {};
       };
 
-      RNG(State pcg_state) {
-        rng = pcg_state;
+      static constexpr result_type max() {
+        return ~result_type {0UL};
       };
 
-      ~RNG() = default;
+      // Constructors
+      // RNG();
+      RNG() = default;
+      explicit RNG(result_type value);
+
+      template <class SeedSeq>
+      explicit RNG(SeedSeq& seq);
+
+      RNG& operator=(const pcg32_random_t& other);
+      //RNG(const RNG& other);
+      
+      template <typename SeedSeq>
+      void seed(SeedSeq& seq);
+
+      void seed(RNG& other);
+
+      result_type operator()();
+      result_type operator()(result_type bound);
+      // std::seed_seq interface
+      template <typename It>
+      void generate(It start, It end);
+
+      std::size_t size() const noexcept;
+
+      template <class OutputIt>
+      void param(OutputIt dest) const;
     };
   }
 }

src/displayapp/Controllers.h

@@ -26,7 +26,7 @@ namespace Pinetime {
     class Timer;
     class MusicService;
     class NavigationService;
-    class RNG;
+    struct RNG;
   }
 
   namespace System {

src/displayapp/screens/Dice.cpp

@@ -44,7 +44,7 @@ Dice::Dice(Controllers::MotionController& motionController,
            Controllers::Settings& settingsController,
            Controllers::RNG& prngController)
   : motorController {motorController}, motionController {motionController}, settingsController {settingsController} {
-  rng = prngController.Seed();
+  rng.seed(prngController);
 
   lv_obj_t* nCounterLabel = MakeLabel(&jetbrains_mono_bold_20,
                                       LV_COLOR_WHITE,
@@ -76,7 +76,7 @@ Dice::Dice(Controllers::MotionController& motionController,
   lv_obj_align(dCounter.GetObject(), dCounterLabel, LV_ALIGN_OUT_BOTTOM_MID, 0, 10);
   dCounter.SetValue(6);
 
-  currentColorIndex = rng.GenerateBounded(resultColors.size());
+  currentColorIndex = rng(resultColors.size());
 
   resultTotalLabel = MakeLabel(&jetbrains_mono_42,
                                resultColors[currentColorIndex],
@@ -156,7 +156,7 @@ void Dice::Roll() {
   lv_label_set_text(resultIndividualLabel, "");
 
   if (nCounter.GetValue() == 1) {
-    resultTotal = rng.GenerateBounded(dCounter.GetValue()) + 1;
+    resultTotal = rng(dCounter.GetValue()) + 1;
     if (dCounter.GetValue() == 2) {
       switch (resultTotal) {
         case 1:
@@ -169,7 +169,7 @@ void Dice::Roll() {
     }
   } else {
     for (uint8_t i = 0; i < nCounter.GetValue(); i++) {
-      resultIndividual = rng.GenerateBounded(dCounter.GetValue()) + 1;
+      resultIndividual = rng(dCounter.GetValue()) + 1;
       resultTotal += resultIndividual;
       lv_label_ins_text(resultIndividualLabel, LV_LABEL_POS_LAST, std::to_string(resultIndividual).c_str());
       if (i < (nCounter.GetValue() - 1)) {

src/displayapp/screens/Twos.cpp

@@ -6,7 +6,7 @@
 using namespace Pinetime::Applications::Screens;
 
 Twos::Twos(Pinetime::Controllers::RNG& prngController) {
-  rng = prngController.Seed();
+  rng.seed(prngController); // Pinetime::Controllers::RNG {prngController(), prngController()}; // = prngController.Seed();
 
   struct colorPair {
     lv_color_t bg;
@@ -87,9 +87,9 @@ bool Twos::placeNewTile() {
     return false; // game lost
   }
 
-  int random = rng.GenerateBounded(nEmpty);
+  int random = rng(nEmpty);
 
-  if (rng.GenerateBounded(100) < 90) {
+  if (rng(100) < 90) {
     grid[emptyCells[random] / nCols][emptyCells[random] % nCols].value = 2;
   } else {
     grid[emptyCells[random] / nCols][emptyCells[random] % nCols].value = 4;

src/main.cpp

@@ -364,12 +364,11 @@ int main() {
   systemTask.Start();
   nimble_port_init();
   // ble_ll functions should probably be called after ble_ll_init which is called from nimble_port_init
-  Pinetime::Controllers::RNG::State prngBleInit;
+  Pinetime::Controllers::RNG prngBleInit;
   ble_ll_rand_data_get((uint8_t*) &prngBleInit, sizeof(prngBleInit));
   // TODO: Seed with lifetime stats
   *((uint32_t*) &prngBleInit) ^= xTaskGetTickCount();
-  prngBleInit();
-  systemTask.prngController.rng = prngBleInit;
+  systemTask.prngController = prngBleInit;
 
   vTaskStartScheduler();