]> git.rm.cloudns.org Git - xonotic/gmqcc.git/commitdiff
Remove my MT impl for PRNG, it's full of buffer overflows that I don't want to fix...
authorDale Weiler <killfieldengine@gmail.com>
Wed, 14 Aug 2013 06:22:32 +0000 (06:22 +0000)
committerDale Weiler <killfieldengine@gmail.com>
Wed, 14 Aug 2013 06:22:32 +0000 (06:22 +0000)
util.c

diff --git a/util.c b/util.c
index 32edbbd73b3baf59cf69026a804d2ae712067597..7d6e034e613441843c6f3d83cae51aa94149b59d 100644 (file)
--- a/util.c
+++ b/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();
 }