mirror of https://github.com/postgres/postgres
Standardize on xoroshiro128** as our basic PRNG algorithm, eliminating a bunch of platform dependencies as well as fundamentally-obsolete PRNG code. In addition, this API replacement will ease replacing the algorithm again in future, should that become necessary. xoroshiro128** is a few percent slower than the drand48 family, but it can produce full-width 64-bit random values not only 48-bit, and it should be much more trustworthy. It's likely to be noticeably faster than the platform's random(), depending on which platform you are thinking about; and we can have non-global state vectors easily, unlike with random(). It is not cryptographically strong, but neither are the functions it replaces. Fabien Coelho, reviewed by Dean Rasheed, Aleksander Alekseev, and myself Discussion: https://postgr.es/m/alpine.DEB.2.22.394.2105241211230.165418@pseudopull/73/head
Tom Lane
4 years ago
parent
f44ceb46ec
commit
3804539e48
@ -0,0 +1,247 @@ |
||||
/*-------------------------------------------------------------------------
|
||||
* |
||||
* Pseudo-Random Number Generator |
||||
* |
||||
* We use Blackman and Vigna's xoroshiro128** 1.0 algorithm |
||||
* to have a small, fast PRNG suitable for generating reasonably |
||||
* good-quality 64-bit data. This should not be considered |
||||
* cryptographically strong, however. |
||||
* |
||||
* About these generators: https://prng.di.unimi.it/
|
||||
* See also https://en.wikipedia.org/wiki/List_of_random_number_generators
|
||||
* |
||||
* Copyright (c) 2021, PostgreSQL Global Development Group |
||||
* |
||||
* src/common/pg_prng.c |
||||
* |
||||
*------------------------------------------------------------------------- |
||||
*/ |
||||
|
||||
#include "c.h" |
||||
|
||||
#include <math.h> /* for ldexp() */ |
||||
|
||||
#include "common/pg_prng.h" |
||||
#include "port/pg_bitutils.h" |
||||
|
||||
/* process-wide state vector */ |
||||
pg_prng_state pg_global_prng_state; |
||||
|
||||
|
||||
/*
|
||||
* 64-bit rotate left |
||||
*/ |
||||
static inline uint64 |
||||
rotl(uint64 x, int bits) |
||||
{ |
||||
return (x << bits) | (x >> (64 - bits)); |
||||
} |
||||
|
||||
/*
|
||||
* The basic xoroshiro128** algorithm. |
||||
* Generates and returns a 64-bit uniformly distributed number, |
||||
* updating the state vector for next time. |
||||
* |
||||
* Note: the state vector must not be all-zeroes, as that is a fixed point. |
||||
*/ |
||||
static uint64 |
||||
xoroshiro128ss(pg_prng_state *state) |
||||
{ |
||||
uint64 s0 = state->s0, |
||||
sx = state->s1 ^ s0, |
||||
val = rotl(s0 * 5, 7) * 9; |
||||
|
||||
/* update state */ |
||||
state->s0 = rotl(s0, 24) ^ sx ^ (sx << 16); |
||||
state->s1 = rotl(sx, 37); |
||||
|
||||
return val; |
||||
} |
||||
|
||||
/*
|
||||
* We use this generator just to fill the xoroshiro128** state vector |
||||
* from a 64-bit seed. |
||||
*/ |
||||
static uint64 |
||||
splitmix64(uint64 *state) |
||||
{ |
||||
/* state update */ |
||||
uint64 val = (*state += UINT64CONST(0x9E3779B97f4A7C15)); |
||||
|
||||
/* value extraction */ |
||||
val = (val ^ (val >> 30)) * UINT64CONST(0xBF58476D1CE4E5B9); |
||||
val = (val ^ (val >> 27)) * UINT64CONST(0x94D049BB133111EB); |
||||
|
||||
return val ^ (val >> 31); |
||||
} |
||||
|
||||
/*
|
||||
* Initialize the PRNG state from a 64-bit integer, |
||||
* taking care that we don't produce all-zeroes. |
||||
*/ |
||||
void |
||||
pg_prng_seed(pg_prng_state *state, uint64 seed) |
||||
{ |
||||
state->s0 = splitmix64(&seed); |
||||
state->s1 = splitmix64(&seed); |
||||
/* Let's just make sure we didn't get all-zeroes */ |
||||
(void) pg_prng_seed_check(state); |
||||
} |
||||
|
||||
/*
|
||||
* Initialize the PRNG state from a double in the range [-1.0, 1.0], |
||||
* taking care that we don't produce all-zeroes. |
||||
*/ |
||||
void |
||||
pg_prng_fseed(pg_prng_state *state, double fseed) |
||||
{ |
||||
/* Assume there's about 52 mantissa bits; the sign contributes too. */ |
||||
int64 seed = ((double) ((UINT64CONST(1) << 52) - 1)) * fseed; |
||||
|
||||
pg_prng_seed(state, (uint64) seed); |
||||
} |
||||
|
||||
/*
|
||||
* Validate a PRNG seed value. |
||||
*/ |
||||
bool |
||||
pg_prng_seed_check(pg_prng_state *state) |
||||
{ |
||||
/*
|
||||
* If the seeding mechanism chanced to produce all-zeroes, insert |
||||
* something nonzero. Anything would do; use Knuth's LCG parameters. |
||||
*/ |
||||
if (unlikely(state->s0 == 0 && state->s1 == 0)) |
||||
{ |
||||
state->s0 = UINT64CONST(0x5851F42D4C957F2D); |
||||
state->s1 = UINT64CONST(0x14057B7EF767814F); |
||||
} |
||||
|
||||
/* As a convenience for the pg_prng_strong_seed macro, return true */ |
||||
return true; |
||||
} |
||||
|
||||
/*
|
||||
* Select a random uint64 uniformly from the range [0, PG_UINT64_MAX]. |
||||
*/ |
||||
uint64 |
||||
pg_prng_uint64(pg_prng_state *state) |
||||
{ |
||||
return xoroshiro128ss(state); |
||||
} |
||||
|
||||
/*
|
||||
* Select a random uint64 uniformly from the range [rmin, rmax]. |
||||
* If the range is empty, rmin is always produced. |
||||
*/ |
||||
uint64 |
||||
pg_prng_uint64_range(pg_prng_state *state, uint64 rmin, uint64 rmax) |
||||
{ |
||||
uint64 val; |
||||
|
||||
if (likely(rmax > rmin)) |
||||
{ |
||||
/*
|
||||
* Use bitmask rejection method to generate an offset in 0..range. |
||||
* Each generated val is less than twice "range", so on average we |
||||
* should not have to iterate more than twice. |
||||
*/ |
||||
uint64 range = rmax - rmin; |
||||
uint32 rshift = 63 - pg_leftmost_one_pos64(range); |
||||
|
||||
do |
||||
{ |
||||
val = xoroshiro128ss(state) >> rshift; |
||||
} while (val > range); |
||||
} |
||||
else |
||||
val = 0; |
||||
|
||||
return rmin + val; |
||||
} |
||||
|
||||
/*
|
||||
* Select a random int64 uniformly from the range [PG_INT64_MIN, PG_INT64_MAX]. |
||||
*/ |
||||
int64 |
||||
pg_prng_int64(pg_prng_state *state) |
||||
{ |
||||
return (int64) xoroshiro128ss(state); |
||||
} |
||||
|
||||
/*
|
||||
* Select a random int64 uniformly from the range [0, PG_INT64_MAX]. |
||||
*/ |
||||
int64 |
||||
pg_prng_int64p(pg_prng_state *state) |
||||
{ |
||||
return (int64) (xoroshiro128ss(state) & UINT64CONST(0x7FFFFFFFFFFFFFFF)); |
||||
} |
||||
|
||||
/*
|
||||
* Select a random uint32 uniformly from the range [0, PG_UINT32_MAX]. |
||||
*/ |
||||
uint32 |
||||
pg_prng_uint32(pg_prng_state *state) |
||||
{ |
||||
/*
|
||||
* Although xoroshiro128** is not known to have any weaknesses in |
||||
* randomness of low-order bits, we prefer to use the upper bits of its |
||||
* result here and below. |
||||
*/ |
||||
uint64 v = xoroshiro128ss(state); |
||||
|
||||
return (uint32) (v >> 32); |
||||
} |
||||
|
||||
/*
|
||||
* Select a random int32 uniformly from the range [PG_INT32_MIN, PG_INT32_MAX]. |
||||
*/ |
||||
int32 |
||||
pg_prng_int32(pg_prng_state *state) |
||||
{ |
||||
uint64 v = xoroshiro128ss(state); |
||||
|
||||
return (int32) (v >> 32); |
||||
} |
||||
|
||||
/*
|
||||
* Select a random int32 uniformly from the range [0, PG_INT32_MAX]. |
||||
*/ |
||||
int32 |
||||
pg_prng_int32p(pg_prng_state *state) |
||||
{ |
||||
uint64 v = xoroshiro128ss(state); |
||||
|
||||
return (int32) (v >> 33); |
||||
} |
||||
|
||||
/*
|
||||
* Select a random double uniformly from the range [0.0, 1.0). |
||||
* |
||||
* Note: if you want a result in the range (0.0, 1.0], the standard way |
||||
* to get that is "1.0 - pg_prng_double(state)". |
||||
*/ |
||||
double |
||||
pg_prng_double(pg_prng_state *state) |
||||
{ |
||||
uint64 v = xoroshiro128ss(state); |
||||
|
||||
/*
|
||||
* As above, assume there's 52 mantissa bits in a double. This result |
||||
* could round to 1.0 if double's precision is less than that; but we |
||||
* assume IEEE float arithmetic elsewhere in Postgres, so this seems OK. |
||||
*/ |
||||
return ldexp((double) (v >> (64 - 52)), -52); |
||||
} |
||||
|
||||
/*
|
||||
* Select a random boolean value. |
||||
*/ |
||||
bool |
||||
pg_prng_bool(pg_prng_state *state) |
||||
{ |
||||
uint64 v = xoroshiro128ss(state); |
||||
|
||||
return (bool) (v >> 63); |
||||
} |
||||
@ -0,0 +1,60 @@ |
||||
/*-------------------------------------------------------------------------
|
||||
* |
||||
* Pseudo-Random Number Generator |
||||
* |
||||
* Copyright (c) 2021, PostgreSQL Global Development Group |
||||
* |
||||
* src/include/common/pg_prng.h |
||||
* |
||||
*------------------------------------------------------------------------- |
||||
*/ |
||||
#ifndef PG_PRNG_H |
||||
#define PG_PRNG_H |
||||
|
||||
/*
|
||||
* State vector for PRNG generation. Callers should treat this as an |
||||
* opaque typedef, but we expose its definition to allow it to be |
||||
* embedded in other structs. |
||||
*/ |
||||
typedef struct pg_prng_state |
||||
{ |
||||
uint64 s0, |
||||
s1; |
||||
} pg_prng_state; |
||||
|
||||
/*
|
||||
* Callers not needing local PRNG series may use this global state vector, |
||||
* after initializing it with one of the pg_prng_...seed functions. |
||||
*/ |
||||
extern PGDLLIMPORT pg_prng_state pg_global_prng_state; |
||||
|
||||
extern void pg_prng_seed(pg_prng_state *state, uint64 seed); |
||||
extern void pg_prng_fseed(pg_prng_state *state, double fseed); |
||||
extern bool pg_prng_seed_check(pg_prng_state *state); |
||||
|
||||
/*
|
||||
* Initialize the PRNG state from the pg_strong_random source, |
||||
* taking care that we don't produce all-zeroes. If this returns false, |
||||
* caller should initialize the PRNG state from some other random seed, |
||||
* using pg_prng_[f]seed. |
||||
* |
||||
* We implement this as a macro, so that the pg_strong_random() call is |
||||
* in the caller. If it were in pg_prng.c, programs using pg_prng.c |
||||
* but not needing strong seeding would nonetheless be forced to pull in |
||||
* pg_strong_random.c and thence OpenSSL. |
||||
*/ |
||||
#define pg_prng_strong_seed(state) \ |
||||
(pg_strong_random((void *) (state), sizeof(pg_prng_state)) ? \
|
||||
pg_prng_seed_check(state) : false) |
||||
|
||||
extern uint64 pg_prng_uint64(pg_prng_state *state); |
||||
extern uint64 pg_prng_uint64_range(pg_prng_state *state, uint64 rmin, uint64 rmax); |
||||
extern int64 pg_prng_int64(pg_prng_state *state); |
||||
extern int64 pg_prng_int64p(pg_prng_state *state); |
||||
extern uint32 pg_prng_uint32(pg_prng_state *state); |
||||
extern int32 pg_prng_int32(pg_prng_state *state); |
||||
extern int32 pg_prng_int32p(pg_prng_state *state); |
||||
extern double pg_prng_double(pg_prng_state *state); |
||||
extern bool pg_prng_bool(pg_prng_state *state); |
||||
|
||||
#endif /* PG_PRNG_H */ |
||||
@ -1,136 +0,0 @@ |
||||
/*-------------------------------------------------------------------------
|
||||
* |
||||
* erand48.c |
||||
* |
||||
* This file supplies pg_erand48() and related functions, which except |
||||
* for the names are just like the POSIX-standard erand48() family. |
||||
* (We don't supply the full set though, only the ones we have found use |
||||
* for in Postgres. In particular, we do *not* implement lcong48(), so |
||||
* that there is no need for the multiplier and addend to be variable.) |
||||
* |
||||
* We used to test for an operating system version rather than |
||||
* unconditionally using our own, but (1) some versions of Cygwin have a |
||||
* buggy erand48() that always returns zero and (2) as of 2011, glibc's |
||||
* erand48() is strangely coded to be almost-but-not-quite thread-safe, |
||||
* which doesn't matter for the backend but is important for pgbench. |
||||
* |
||||
* Portions Copyright (c) 1996-2021, PostgreSQL Global Development Group |
||||
* |
||||
* Portions Copyright (c) 1993 Martin Birgmeier |
||||
* All rights reserved. |
||||
* |
||||
* You may redistribute unmodified or modified versions of this source |
||||
* code provided that the above copyright notice and this and the |
||||
* following conditions are retained. |
||||
* |
||||
* This software is provided ``as is'', and comes with no warranties |
||||
* of any kind. I shall in no event be liable for anything that happens |
||||
* to anyone/anything when using this software. |
||||
* |
||||
* IDENTIFICATION |
||||
* src/port/erand48.c |
||||
* |
||||
*------------------------------------------------------------------------- |
||||
*/ |
||||
|
||||
#include "c.h" |
||||
|
||||
#include <math.h> |
||||
|
||||
/* These values are specified by POSIX */ |
||||
#define RAND48_MULT UINT64CONST(0x0005deece66d) |
||||
#define RAND48_ADD UINT64CONST(0x000b) |
||||
|
||||
/* POSIX specifies 0x330e's use in srand48, but the other bits are arbitrary */ |
||||
#define RAND48_SEED_0 (0x330e) |
||||
#define RAND48_SEED_1 (0xabcd) |
||||
#define RAND48_SEED_2 (0x1234) |
||||
|
||||
static unsigned short _rand48_seed[3] = { |
||||
RAND48_SEED_0, |
||||
RAND48_SEED_1, |
||||
RAND48_SEED_2 |
||||
}; |
||||
|
||||
|
||||
/*
|
||||
* Advance the 48-bit value stored in xseed[] to the next "random" number. |
||||
* |
||||
* Also returns the value of that number --- without masking it to 48 bits. |
||||
* If caller uses the result, it must mask off the bits it wants. |
||||
*/ |
||||
static uint64 |
||||
_dorand48(unsigned short xseed[3]) |
||||
{ |
||||
/*
|
||||
* We do the arithmetic in uint64; any type wider than 48 bits would work. |
||||
*/ |
||||
uint64 in; |
||||
uint64 out; |
||||
|
||||
in = (uint64) xseed[2] << 32 | (uint64) xseed[1] << 16 | (uint64) xseed[0]; |
||||
|
||||
out = in * RAND48_MULT + RAND48_ADD; |
||||
|
||||
xseed[0] = out & 0xFFFF; |
||||
xseed[1] = (out >> 16) & 0xFFFF; |
||||
xseed[2] = (out >> 32) & 0xFFFF; |
||||
|
||||
return out; |
||||
} |
||||
|
||||
|
||||
/*
|
||||
* Generate a random floating-point value using caller-supplied state. |
||||
* Values are uniformly distributed over the interval [0.0, 1.0). |
||||
*/ |
||||
double |
||||
pg_erand48(unsigned short xseed[3]) |
||||
{ |
||||
uint64 x = _dorand48(xseed); |
||||
|
||||
return ldexp((double) (x & UINT64CONST(0xFFFFFFFFFFFF)), -48); |
||||
} |
||||
|
||||
/*
|
||||
* Generate a random non-negative integral value using internal state. |
||||
* Values are uniformly distributed over the interval [0, 2^31). |
||||
*/ |
||||
long |
||||
pg_lrand48(void) |
||||
{ |
||||
uint64 x = _dorand48(_rand48_seed); |
||||
|
||||
return (x >> 17) & UINT64CONST(0x7FFFFFFF); |
||||
} |
||||
|
||||
/*
|
||||
* Generate a random signed integral value using caller-supplied state. |
||||
* Values are uniformly distributed over the interval [-2^31, 2^31). |
||||
*/ |
||||
long |
||||
pg_jrand48(unsigned short xseed[3]) |
||||
{ |
||||
uint64 x = _dorand48(xseed); |
||||
|
||||
return (int32) ((x >> 16) & UINT64CONST(0xFFFFFFFF)); |
||||
} |
||||
|
||||
/*
|
||||
* Initialize the internal state using the given seed. |
||||
* |
||||
* Per POSIX, this uses only 32 bits from "seed" even if "long" is wider. |
||||
* Hence, the set of possible seed values is smaller than it could be. |
||||
* Better practice is to use caller-supplied state and initialize it with |
||||
* random bits obtained from a high-quality source of random bits. |
||||
* |
||||
* Note: POSIX specifies a function seed48() that allows all 48 bits |
||||
* of the internal state to be set, but we don't currently support that. |
||||
*/ |
||||
void |
||||
pg_srand48(long seed) |
||||
{ |
||||
_rand48_seed[0] = RAND48_SEED_0; |
||||
_rand48_seed[1] = (unsigned short) seed; |
||||
_rand48_seed[2] = (unsigned short) (seed >> 16); |
||||
} |
||||
@ -1,25 +0,0 @@ |
||||
/*-------------------------------------------------------------------------
|
||||
* |
||||
* random.c |
||||
* random() wrapper |
||||
* |
||||
* Portions Copyright (c) 1996-2021, PostgreSQL Global Development Group |
||||
* Portions Copyright (c) 1994, Regents of the University of California |
||||
* |
||||
* |
||||
* IDENTIFICATION |
||||
* src/port/random.c |
||||
* |
||||
*------------------------------------------------------------------------- |
||||
*/ |
||||
|
||||
#include "c.h" |
||||
|
||||
#include <math.h> |
||||
|
||||
|
||||
long |
||||
random(void) |
||||
{ |
||||
return pg_lrand48(); |
||||
} |
||||
@ -1,25 +0,0 @@ |
||||
/*-------------------------------------------------------------------------
|
||||
* |
||||
* srandom.c |
||||
* srandom() wrapper |
||||
* |
||||
* Portions Copyright (c) 1996-2021, PostgreSQL Global Development Group |
||||
* Portions Copyright (c) 1994, Regents of the University of California |
||||
* |
||||
* |
||||
* IDENTIFICATION |
||||
* src/port/srandom.c |
||||
* |
||||
*------------------------------------------------------------------------- |
||||
*/ |
||||
|
||||
#include "c.h" |
||||
|
||||
#include <math.h> |
||||
|
||||
|
||||
void |
||||
srandom(unsigned int seed) |
||||
{ |
||||
pg_srand48((long int) seed); |
||||
} |
||||
Loading…
Reference in new issue