src/random.h

   1 // Copyright (c) 2009-2010 Satoshi Nakamoto
   2 // Copyright (c) 2009-2014 The Bitcoin Core developers
   3 // Distributed under the MIT software license, see the accompanying
   4 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
   5
   6 #ifndef BITCOIN_RANDOM_H
   7 #define BITCOIN_RANDOM_H
   8
   9 #include "uint256.h"
  10
  11 #include <functional>
  12 #include <stdint.h>
  13
  14 /**
  15  * Seed OpenSSL PRNG with additional entropy data
  16  */
  17 void RandAddSeed();
  18 void RandAddSeedPerfmon();
  19
  20 /**
  21  * Functions to gather random data via the OpenSSL PRNG
  22  */
  23 void GetRandBytes(unsigned char* buf, int num);
  24 uint64_t GetRand(uint64_t nMax);
  25 int GetRandInt(int nMax);
  26 uint256 GetRandHash();
  27
  28 /**
  29  * Rearranges the elements in the range [first,first+len) randomly, assuming
  30  * that gen is a uniform random number generator. Follows the same algorithm as
  31  * std::shuffle in C++11 (a Durstenfeld shuffle).
  32  *
  33  * The elements in the range [mapFirst,mapFirst+len) are rearranged according to
  34  * the same permutation, enabling the permutation to be tracked by the caller.
  35  *
  36  * gen takes an integer n and produces a uniform random output in [0,n).
  37  */
  38 template <typename RandomAccessIterator, typename MapRandomAccessIterator>
  39 void MappedShuffle(RandomAccessIterator first,
  40                    MapRandomAccessIterator mapFirst,
  41                    size_t len,
  42                    std::function<int(int)> gen)
  43 {
  44     for (size_t i = len-1; i > 0; --i) {
  45         auto r = gen(i+1);
  46         assert(r >= 0);
  47         assert(r <= i);
  48         std::swap(first[i], first[r]);
  49         std::swap(mapFirst[i], mapFirst[r]);
  50     }
  51 }
  52
  53 /**
  54  * Seed insecure_rand using the random pool.
  55  * @param Deterministic Use a deterministic seed
  56  */
  57 void seed_insecure_rand(bool fDeterministic = false);
  58
  59 /**
  60  * MWC RNG of George Marsaglia
  61  * This is intended to be fast. It has a period of 2^59.3, though the
  62  * least significant 16 bits only have a period of about 2^30.1.
  63  *
  64  * @return random value
  65  */
  66 extern uint32_t insecure_rand_Rz;
  67 extern uint32_t insecure_rand_Rw;
  68 static inline uint32_t insecure_rand(void)
  69 {
  70     insecure_rand_Rz = 36969 * (insecure_rand_Rz & 65535) + (insecure_rand_Rz >> 16);
  71     insecure_rand_Rw = 18000 * (insecure_rand_Rw & 65535) + (insecure_rand_Rw >> 16);
  72     return (insecure_rand_Rw << 16) + insecure_rand_Rz;
  73 }
  74
  75 #endif // BITCOIN_RANDOM_H