mirror of
https://github.com/DarkPlacesEngine/gmqcc.git
synced 2024-11-23 20:33:05 +00:00
Remove my MT impl for PRNG, it's full of buffer overflows that I don't want to fix. Just fallback to using srand/rand
This commit is contained in:
Dale Weiler
parent
1201f06a55
commit
0a5353532b
1 changed files with 2 additions and 165 deletions
167
util.c
167
util.c
|
|
@ -409,173 +409,10 @@ int util_asprintf(char **ret, const char *fmt, ...) {
|
|||
|
||||
#endif /*! _MSC_VER */
|
||||
|
||||
/*
|
||||
* Implementation of the Mersenne twister PRNG (pseudo random numer
|
||||
* generator). Implementation of MT19937. Has a period of 2^19937-1
|
||||
* which is a Mersenne Prime (hence the name).
|
||||
*
|
||||
* Implemented from specification and original paper:
|
||||
* http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/ARTICLES/mt.pdf
|
||||
*
|
||||
* This code is placed in the public domain by me personally
|
||||
* (Dale Weiler, a.k.a graphitemaster).
|
||||
*/
|
||||
|
||||
#define MT_SIZE 624
|
||||
#define MT_PERIOD 397
|
||||
#define MT_SPACE (MT_SIZE - MT_PERIOD)
|
||||
|
||||
static uint32_t mt_state[MT_SIZE];
|
||||
static size_t mt_index = 0;
|
||||
|
||||
static GMQCC_INLINE void mt_generate(void) {
|
||||
/*
|
||||
* The loop has been unrolled here: the original paper and implemenation
|
||||
* Called for the following code:
|
||||
* for (register unsigned i = 0; i < MT_SIZE; ++i) {
|
||||
* register uint32_t load;
|
||||
* load = (0x80000000 & mt_state[i]) // most significant 32nd bit
|
||||
* load |= (0x7FFFFFFF & mt_state[(i + 1) % MT_SIZE]) // least significant 31nd bit
|
||||
*
|
||||
* mt_state[i] = mt_state[(i + MT_PERIOD) % MT_SIZE] ^ (load >> 1);
|
||||
*
|
||||
* if (load & 1) mt_state[i] ^= 0x9908B0DF;
|
||||
* }
|
||||
*
|
||||
* This essentially is a waste: we have two modulus operations, and
|
||||
* a branch that is executed every iteration from [0, MT_SIZE).
|
||||
*
|
||||
* Please see: http://www.quadibloc.com/crypto/co4814.htm for more
|
||||
* information on how this clever trick works.
|
||||
*/
|
||||
static const uint32_t matrix[2] = {
|
||||
0x00000000,
|
||||
0x9908B0Df
|
||||
};
|
||||
/*
|
||||
* This register gives up a little more speed by instructing the compiler
|
||||
* to force these into CPU registers (they're counters for indexing mt_state
|
||||
* which we can force the compiler to generate prefetch instructions for)
|
||||
*/
|
||||
register uint32_t y;
|
||||
register uint32_t i;
|
||||
|
||||
/*
|
||||
* Said loop has been unrolled for MT_SPACE (226 iterations), opposed
|
||||
* to [0, MT_SIZE) (634 iterations).
|
||||
*/
|
||||
for (i = 0; i < MT_SPACE-1; ++i) {
|
||||
y = (0x80000000 & mt_state[i]) | (0x7FFFFFF & mt_state[i + 1]);
|
||||
mt_state[i] = mt_state[i + MT_PERIOD] ^ (y >> 1) ^ matrix[y & 1];
|
||||
|
||||
i ++; /* loop unroll */
|
||||
|
||||
y = (0x80000000 & mt_state[i]) | (0x7FFFFFF & mt_state[i + 1]);
|
||||
mt_state[i] = mt_state[i + MT_PERIOD] ^ (y >> 1) ^ matrix[y & 1];
|
||||
}
|
||||
|
||||
/*
|
||||
* collapsing the walls unrolled (evenly dividing 396 [632-227 = 396
|
||||
* = 2*2*3*3*11])
|
||||
*/
|
||||
i = MT_SPACE;
|
||||
while (i < MT_SIZE-2) {
|
||||
/*
|
||||
* We expand this 11 times .. manually, no macros are required
|
||||
* here. This all fits in the CPU cache.
|
||||
*/
|
||||
y = (0x80000000 & mt_state[i]) | (0x7FFFFFFF & mt_state[i + 1]);
|
||||
mt_state[i] = mt_state[i - MT_SPACE] ^ (y >> 1) ^ matrix[y & 1];
|
||||
++i;
|
||||
y = (0x80000000 & mt_state[i]) | (0x7FFFFFFF & mt_state[i + 1]);
|
||||
mt_state[i] = mt_state[i - MT_SPACE] ^ (y >> 1) ^ matrix[y & 1];
|
||||
++i;
|
||||
y = (0x80000000 & mt_state[i]) | (0x7FFFFFFF & mt_state[i + 1]);
|
||||
mt_state[i] = mt_state[i - MT_SPACE] ^ (y >> 1) ^ matrix[y & 1];
|
||||
++i;
|
||||
y = (0x80000000 & mt_state[i]) | (0x7FFFFFFF & mt_state[i + 1]);
|
||||
mt_state[i] = mt_state[i - MT_SPACE] ^ (y >> 1) ^ matrix[y & 1];
|
||||
++i;
|
||||
y = (0x80000000 & mt_state[i]) | (0x7FFFFFFF & mt_state[i + 1]);
|
||||
mt_state[i] = mt_state[i - MT_SPACE] ^ (y >> 1) ^ matrix[y & 1];
|
||||
++i;
|
||||
y = (0x80000000 & mt_state[i]) | (0x7FFFFFFF & mt_state[i + 1]);
|
||||
mt_state[i] = mt_state[i - MT_SPACE] ^ (y >> 1) ^ matrix[y & 1];
|
||||
++i;
|
||||
y = (0x80000000 & mt_state[i]) | (0x7FFFFFFF & mt_state[i + 1]);
|
||||
mt_state[i] = mt_state[i - MT_SPACE] ^ (y >> 1) ^ matrix[y & 1];
|
||||
++i;
|
||||
y = (0x80000000 & mt_state[i]) | (0x7FFFFFFF & mt_state[i + 1]);
|
||||
mt_state[i] = mt_state[i - MT_SPACE] ^ (y >> 1) ^ matrix[y & 1];
|
||||
++i;
|
||||
y = (0x80000000 & mt_state[i]) | (0x7FFFFFFF & mt_state[i + 1]);
|
||||
mt_state[i] = mt_state[i - MT_SPACE] ^ (y >> 1) ^ matrix[y & 1];
|
||||
++i;
|
||||
y = (0x80000000 & mt_state[i]) | (0x7FFFFFFF & mt_state[i + 1]);
|
||||
mt_state[i] = mt_state[i - MT_SPACE] ^ (y >> 1) ^ matrix[y & 1];
|
||||
++i;
|
||||
y = (0x80000000 & mt_state[i]) | (0x7FFFFFFF & mt_state[i + 1]);
|
||||
mt_state[i] = mt_state[i - MT_SPACE] ^ (y >> 1) ^ matrix[y & 1];
|
||||
++i;
|
||||
}
|
||||
|
||||
/* i = mt_state[623] */
|
||||
y = (0x80000000 & mt_state[MT_SIZE - 1]) | (0x7FFFFFFF & mt_state[MT_SIZE - 1]);
|
||||
mt_state[MT_SIZE - 1] = mt_state[MT_PERIOD - 1] ^ (y >> 1) ^ matrix[y & 1];
|
||||
}
|
||||
|
||||
void util_seed(uint32_t value) {
|
||||
/*
|
||||
* We seed the mt_state with a LCG (linear congruential generator)
|
||||
* We're operating exactly on exactly m=32, so there is no need to
|
||||
* use modulus.
|
||||
*
|
||||
* The multipler of choice is 0x6C07865, also knows as the Borosh-
|
||||
* Niederreiter multipler used for modulus 2^32. More can be read
|
||||
* about this in Knuth's TAOCP Volume 2, page 106.
|
||||
*
|
||||
* If you don't own TAOCP something is wrong with you :-) .. so I
|
||||
* also provided a link to the original paper by Borosh and
|
||||
* Niederreiter. It's called "Optional Multipliers for PRNG by The
|
||||
* Linear Congruential Method" (1983).
|
||||
* http://en.wikipedia.org/wiki/Linear_congruential_generator
|
||||
*
|
||||
* From said page, it says the following:
|
||||
* "A common Mersenne twister implementation, interestingly enough
|
||||
* used an LCG to generate seed data."
|
||||
*
|
||||
* Remarks:
|
||||
* The data we're operating on is 32-bits for the mt_state array, so
|
||||
* there is no masking required with 0xFFFFFFFF
|
||||
*/
|
||||
register size_t i;
|
||||
|
||||
mt_state[0] = value;
|
||||
for (i = 1; i < MT_SIZE; ++i)
|
||||
mt_state[i] = 0x6C078965 * (mt_state[i - 1] ^ mt_state[i - 1] >> 30) + i;
|
||||
srand((int)value);
|
||||
}
|
||||
|
||||
uint32_t util_rand() {
|
||||
register uint32_t y;
|
||||
|
||||
/*
|
||||
* This is inlined with any sane compiler (I checked)
|
||||
* for some reason though, SubC seems to be generating invalid
|
||||
* code when it inlines this.
|
||||
*/
|
||||
if (!mt_index)
|
||||
mt_generate();
|
||||
|
||||
y = mt_state[mt_index];
|
||||
|
||||
/* Standard tempering */
|
||||
y ^= y >> 11; /* +7 */
|
||||
y ^= y << 7 & 0x9D2C5680; /* +4 */
|
||||
y ^= y << 15 & 0xEFC60000; /* -4 */
|
||||
y ^= y >> 18; /* -7 */
|
||||
|
||||
if(++mt_index == MT_SIZE)
|
||||
mt_index = 0;
|
||||
|
||||
return y;
|
||||
return rand();
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in a new issue