PostgreSQL Source Code  git master
erand48.c
Go to the documentation of this file.
1 /*-------------------------------------------------------------------------
2  *
3  * erand48.c
4  *
5  * This file supplies pg_erand48() and related functions, which except
6  * for the names are just like the POSIX-standard erand48() family.
7  * (We don't supply the full set though, only the ones we have found use
8  * for in Postgres. In particular, we do *not* implement lcong48(), so
9  * that there is no need for the multiplier and addend to be variable.)
10  *
11  * We used to test for an operating system version rather than
12  * unconditionally using our own, but (1) some versions of Cygwin have a
13  * buggy erand48() that always returns zero and (2) as of 2011, glibc's
14  * erand48() is strangely coded to be almost-but-not-quite thread-safe,
15  * which doesn't matter for the backend but is important for pgbench.
16  *
17  * Portions Copyright (c) 1996-2019, PostgreSQL Global Development Group
18  *
19  * Portions Copyright (c) 1993 Martin Birgmeier
20  * All rights reserved.
21  *
22  * You may redistribute unmodified or modified versions of this source
23  * code provided that the above copyright notice and this and the
24  * following conditions are retained.
25  *
26  * This software is provided ``as is'', and comes with no warranties
27  * of any kind. I shall in no event be liable for anything that happens
28  * to anyone/anything when using this software.
29  *
30  * IDENTIFICATION
31  * src/port/erand48.c
32  *
33  *-------------------------------------------------------------------------
34  */
35 
36 #include "c.h"
37 
38 #include <math.h>
39 
40 /* These values are specified by POSIX */
41 #define RAND48_MULT UINT64CONST(0x0005deece66d)
42 #define RAND48_ADD UINT64CONST(0x000b)
43 
44 /* POSIX specifies 0x330e's use in srand48, but the other bits are arbitrary */
45 #define RAND48_SEED_0 (0x330e)
46 #define RAND48_SEED_1 (0xabcd)
47 #define RAND48_SEED_2 (0x1234)
48 
49 static unsigned short _rand48_seed[3] = {
53 };
54 
55 
56 /*
57  * Advance the 48-bit value stored in xseed[] to the next "random" number.
58  *
59  * Also returns the value of that number --- without masking it to 48 bits.
60  * If caller uses the result, it must mask off the bits it wants.
61  */
62 static uint64
63 _dorand48(unsigned short xseed[3])
64 {
65  /*
66  * We do the arithmetic in uint64; any type wider than 48 bits would work.
67  */
68  uint64 in;
69  uint64 out;
70 
71  in = (uint64) xseed[2] << 32 | (uint64) xseed[1] << 16 | (uint64) xseed[0];
72 
73  out = in * RAND48_MULT + RAND48_ADD;
74 
75  xseed[0] = out & 0xFFFF;
76  xseed[1] = (out >> 16) & 0xFFFF;
77  xseed[2] = (out >> 32) & 0xFFFF;
78 
79  return out;
80 }
81 
82 
83 /*
84  * Generate a random floating-point value using caller-supplied state.
85  * Values are uniformly distributed over the interval [0.0, 1.0).
86  */
87 double
88 pg_erand48(unsigned short xseed[3])
89 {
90  uint64 x = _dorand48(xseed);
91 
92  return ldexp((double) (x & UINT64CONST(0xFFFFFFFFFFFF)), -48);
93 }
94 
95 /*
96  * Generate a random non-negative integral value using internal state.
97  * Values are uniformly distributed over the interval [0, 2^31).
98  */
99 long
101 {
102  uint64 x = _dorand48(_rand48_seed);
103 
104  return (x >> 17) & UINT64CONST(0x7FFFFFFF);
105 }
106 
107 /*
108  * Generate a random signed integral value using caller-supplied state.
109  * Values are uniformly distributed over the interval [-2^31, 2^31).
110  */
111 long
112 pg_jrand48(unsigned short xseed[3])
113 {
114  uint64 x = _dorand48(xseed);
115 
116  return (int32) ((x >> 16) & UINT64CONST(0xFFFFFFFF));
117 }
118 
119 /*
120  * Initialize the internal state using the given seed.
121  *
122  * Per POSIX, this uses only 32 bits from "seed" even if "long" is wider.
123  * Hence, the set of possible seed values is smaller than it could be.
124  * Better practice is to use caller-supplied state and initialize it with
125  * random bits obtained from a high-quality source of random bits.
126  *
127  * Note: POSIX specifies a function seed48() that allows all 48 bits
128  * of the internal state to be set, but we don't currently support that.
129  */
130 void
131 pg_srand48(long seed)
132 {
134  _rand48_seed[1] = (unsigned short) seed;
135  _rand48_seed[2] = (unsigned short) (seed >> 16);
136 }
static unsigned short _rand48_seed[3]
Definition: erand48.c:49
#define RAND48_SEED_0
Definition: erand48.c:45
void pg_srand48(long seed)
Definition: erand48.c:131
#define RAND48_ADD
Definition: erand48.c:42
signed int int32
Definition: c.h:346
long pg_lrand48(void)
Definition: erand48.c:100
#define RAND48_SEED_2
Definition: erand48.c:47
#define RAND48_SEED_1
Definition: erand48.c:46
#define RAND48_MULT
Definition: erand48.c:41
static uint64 _dorand48(unsigned short xseed[3])
Definition: erand48.c:63
long pg_jrand48(unsigned short xseed[3])
Definition: erand48.c:112
double pg_erand48(unsigned short xseed[3])
Definition: erand48.c:88