/*
- * Copyright (C) 2012
+ * Copyright (C) 2012, 2013
* Dale Weiler
* Wolfgang Bumiller
*
uint64_t mem_db = 0;
uint64_t mem_at = 0;
uint64_t mem_dt = 0;
+uint64_t mem_pk = 0;
+uint64_t mem_hw = 0;
struct memblock_t {
const char *file;
struct memblock_t *prev;
};
+#define PEAK_MEM \
+ do { \
+ if (mem_hw > mem_pk) \
+ mem_pk = mem_hw; \
+ } while (0)
+
static struct memblock_t *mem_start = NULL;
void *util_memory_a(size_t byte, unsigned int line, const char *file) {
- struct memblock_t *info = malloc(sizeof(struct memblock_t) + byte);
+ struct memblock_t *info = (struct memblock_t*)malloc(sizeof(struct memblock_t) + byte);
void *data = (void*)(info+1);
if (!info) return NULL;
info->line = line;
mem_start->prev = info;
mem_start = info;
- util_debug("MEM", "allocation: % 8u (bytes) address 0x%08X @ %s:%u\n", byte, data, file, line);
mem_at++;
mem_ab += info->byte;
+ mem_hw += info->byte;
+
+ PEAK_MEM;
return data;
}
-void util_memory_d(void *ptrn, unsigned int line, const char *file) {
+void util_memory_d(void *ptrn) {
struct memblock_t *info = NULL;
if (!ptrn) return;
info = ((struct memblock_t*)ptrn - 1);
- util_debug("MEM", "released: % 8u (bytes) address 0x%08X @ %s:%u\n", info->byte, ptrn, file, line);
mem_db += info->byte;
+ mem_hw -= info->byte;
mem_dt++;
if (info->prev)
if (!ptrn)
return util_memory_a(byte, line, file);
if (!byte) {
- util_memory_d(ptrn, line, file);
+ util_memory_d(ptrn);
return NULL;
}
oldinfo = ((struct memblock_t*)ptrn - 1);
newinfo = ((struct memblock_t*)malloc(sizeof(struct memblock_t) + byte));
- util_debug("MEM", "reallocation: % 8u -> %u (bytes) address 0x%08X -> 0x%08X @ %s:%u\n", oldinfo->byte, byte, ptrn, (void*)(newinfo+1), file, line);
-
/* new data */
if (!newinfo) {
- util_memory_d(oldinfo+1, line, file);
+ util_memory_d(oldinfo+1);
return NULL;
}
mem_start = newinfo;
mem_ab -= oldinfo->byte;
+ mem_hw -= oldinfo->byte;
mem_ab += newinfo->byte;
+ mem_hw += newinfo->byte;
+
+ PEAK_MEM;
free(oldinfo);
return newinfo+1;
}
+static void util_dumpmem(struct memblock_t *memory, uint16_t cols) {
+ uint32_t i, j;
+ for (i = 0; i < memory->byte + ((memory->byte % cols) ? (cols - memory->byte % cols) : 0); i++) {
+ if (i % cols == 0) con_out(" 0x%06X: ", i);
+ if (i < memory->byte) con_out("%02X " , 0xFF & ((char*)(memory + 1))[i]);
+ else con_out(" ");
+
+ if ((uint16_t)(i % cols) == (cols - 1)) {
+ for (j = i - (cols - 1); j <= i; j++) {
+ con_out("%c",
+ (j >= memory->byte)
+ ? ' '
+ : (isprint(((char*)(memory + 1))[j]))
+ ? 0xFF & ((char*)(memory + 1)) [j]
+ : '.'
+ );
+ }
+ con_out("\n");
+ }
+ }
+}
+
void util_meminfo() {
struct memblock_t *info;
- if (!opts.memchk)
- return;
- for (info = mem_start; info; info = info->next) {
- util_debug("MEM", "lost: % 8u (bytes) at %s:%u\n",
- info->byte,
- info->file,
- info->line);
+ if (OPTS_OPTION_BOOL(OPTION_DEBUG)) {
+ for (info = mem_start; info; info = info->next) {
+ con_out("lost: %u (bytes) at %s:%u\n",
+ info->byte,
+ info->file,
+ info->line);
+
+ util_dumpmem(info, OPTS_OPTION_U16(OPTION_MEMDUMPCOLS));
+ }
}
- util_debug("MEM", "Memory information:\n\
- Total allocations: %llu\n\
- Total deallocations: %llu\n\
- Total allocated: %llu (bytes)\n\
- Total deallocated: %llu (bytes)\n\
- Leaks found: lost %llu (bytes) in %d allocations\n",
- mem_at, mem_dt,
- mem_ab, mem_db,
- (mem_ab - mem_db),
- (mem_at - mem_dt)
- );
+ if (OPTS_OPTION_BOOL(OPTION_DEBUG) ||
+ OPTS_OPTION_BOOL(OPTION_MEMCHK)) {
+ con_out("Memory information:\n\
+ Total allocations: %llu\n\
+ Total deallocations: %llu\n\
+ Total allocated: %f (MB)\n\
+ Total deallocated: %f (MB)\n\
+ Total peak memory: %f (MB)\n\
+ Total leaked memory: %f (MB) in %llu allocations\n",
+ mem_at,
+ mem_dt,
+ (float)(mem_ab) / 1048576.0f,
+ (float)(mem_db) / 1048576.0f,
+ (float)(mem_pk) / 1048576.0f,
+ (float)(mem_ab - mem_db) / 1048576.0f,
+
+ /* could be more clever */
+ (mem_at - mem_dt)
+ );
+ }
}
/*
* Some string utility functions, because strdup uses malloc, and we want
* to track all memory (without replacing malloc).
*/
-char *util_strdup(const char *s) {
+char *_util_Estrdup(const char *s, const char *file, size_t line) {
+ size_t len = 0;
+ char *ptr = NULL;
+
+ /* in case of -DNOTRACK */
+ (void)file;
+ (void)line;
+
+ if (!s)
+ return NULL;
+
+ if ((len = strlen(s)) && (ptr = (char*)mem_af(len+1, line, file))) {
+ memcpy(ptr, s, len);
+ ptr[len] = '\0';
+ }
+ return ptr;
+}
+
+char *_util_Estrdup_empty(const char *s, const char *file, size_t line) {
size_t len = 0;
char *ptr = NULL;
+ /* in case of -DNOTRACK */
+ (void)file;
+ (void)line;
+
if (!s)
return NULL;
- if ((len = strlen(s)) && (ptr = mem_a(len+1))) {
+ len = strlen(s);
+ if ((ptr = (char*)mem_af(len+1, line, file))) {
memcpy(ptr, s, len);
ptr[len] = '\0';
}
void util_debug(const char *area, const char *ms, ...) {
va_list va;
- if (!opts.debug)
+ if (!OPTS_OPTION_BOOL(OPTION_DEBUG))
return;
- if (!strcmp(area, "MEM") && !opts.memchk)
+ if (!strcmp(area, "MEM") && !OPTS_OPTION_BOOL(OPTION_MEMCHK))
return;
va_start(va, ms);
* data.
*/
#if PLATFORM_BYTE_ORDER == GMQCC_BYTE_ORDER_BIG
- static void util_swap16(uint16_t *d, size_t l) {
+ static GMQCC_INLINE void util_swap16(uint16_t *d, size_t l) {
while (l--) {
d[l] = (d[l] << 8) | (d[l] >> 8);
}
}
- static void util_swap32(uint32_t *d, size_t l) {
+ static GMQCC_INLINE void util_swap32(uint32_t *d, size_t l) {
while (l--) {
uint32_t v;
v = ((d[l] << 8) & 0xFF00FF00) | ((d[l] >> 8) & 0x00FF00FF);
/* Some strange system doesn't like constants that big, AND doesn't recognize an ULL suffix
* so let's go the safe way
*/
- static void util_swap64(uint32_t *d, size_t l) {
+ static GMQCC_INLINE void util_swap64(uint32_t *d, size_t l) {
/*
while (l--) {
uint64_t v;
util_swap64((uint32_t*)_data, length>>3);
return;
- default: abort(); /* please blow the fuck up! */
+ default: exit(EXIT_FAILURE); /* please blow the fuck up! */
}
# endif
#endif
/* TODO: rewrite ... when I redo the ve cleanup */
void _util_vec_grow(void **a, size_t i, size_t s) {
- size_t m = *a ? 2*_vec_beg(*a)+i : i+1;
- void *p = mem_r((*a ? _vec_raw(*a) : NULL), s * m + sizeof(size_t)*2);
+ vector_t *d = vec_meta(*a);
+ size_t m = *a ? 2 * d->allocated +i : i+1;
+ void *p = mem_r((*a ? d : NULL), s * m + sizeof(vector_t));
+
if (!*a)
- ((size_t*)p)[1] = 0;
- *a = (void*)((size_t*)p + 2);
- _vec_beg(*a) = m;
+ ((vector_t*)p)->used = 0;
+ *a = (vector_t*)p + 1;
+
+ vec_meta(*a)->allocated = m;
}
/*
hash_node_t *_util_htnewpair(const char *key, void *value) {
hash_node_t *node;
- if (!(node = mem_a(sizeof(hash_node_t))))
+ if (!(node = (hash_node_t*)mem_a(sizeof(hash_node_t))))
return NULL;
- if (!(node->key = util_strdup(key))) {
+ if (!(node->key = util_strdupe(key))) {
mem_d(node);
return NULL;
}
if (size < 1)
return NULL;
- if (!(hashtable = mem_a(sizeof(hash_table_t))))
+ if (!(hashtable = (hash_table_t*)mem_a(sizeof(hash_table_t))))
return NULL;
- if (!(hashtable->table = mem_a(sizeof(hash_node_t*) * size))) {
+ if (!(hashtable->table = (hash_node_t**)mem_a(sizeof(hash_node_t*) * size))) {
mem_d(hashtable);
return NULL;
}
return util_htgeth(ht, key, util_hthash(ht, key));
}
+void *code_util_str_htgeth(hash_table_t *ht, const char *key, size_t bin) {
+ hash_node_t *pair;
+ size_t len, keylen;
+ int cmp;
+
+ keylen = strlen(key);
+
+ pair = ht->table[bin];
+ while (pair && pair->key) {
+ len = strlen(pair->key);
+ if (len < keylen) {
+ pair = pair->next;
+ continue;
+ }
+ if (keylen == len) {
+ cmp = strcmp(key, pair->key);
+ if (cmp == 0)
+ return pair->value;
+ if (cmp < 0)
+ return NULL;
+ pair = pair->next;
+ continue;
+ }
+ cmp = strcmp(key, pair->key + len - keylen);
+ if (cmp == 0) {
+ uintptr_t up = (uintptr_t)pair->value;
+ up += len - keylen;
+ return (void*)up;
+ }
+ pair = pair->next;
+ }
+ return NULL;
+}
+
/*
* Free all allocated data in a hashtable, this is quite the amount
* of work.
*/
-void util_htdel(hash_table_t *ht) {
+void util_htrem(hash_table_t *ht, void (*callback)(void *data)) {
size_t i = 0;
for (; i < ht->size; i++) {
hash_node_t *n = ht->table[i];
while (n) {
if (n->key)
mem_d(n->key);
+ if (callback)
+ callback(n->value);
p = n;
n = n->next;
mem_d(p);
mem_d(ht->table);
mem_d(ht);
}
+
+void util_htrmh(hash_table_t *ht, const char *key, size_t bin, void (*cb)(void*)) {
+ hash_node_t **pair = &ht->table[bin];
+ hash_node_t *tmp;
+
+ while (*pair && (*pair)->key && strcmp(key, (*pair)->key) > 0)
+ pair = &(*pair)->next;
+
+ tmp = *pair;
+ if (!tmp || !tmp->key || strcmp(key, tmp->key) != 0)
+ return;
+
+ if (cb)
+ (*cb)(tmp->value);
+
+ *pair = tmp->next;
+ mem_d(tmp->key);
+ mem_d(tmp);
+}
+
+void util_htrm(hash_table_t *ht, const char *key, void (*cb)(void*)) {
+ util_htrmh(ht, key, util_hthash(ht, key), cb);
+}
+
+void util_htdel(hash_table_t *ht) {
+ util_htrem(ht, NULL);
+}
+
+/*
+ * A basic implementation of a hash-set. Unlike a hashtable, a hash
+ * set doesn't maintain key-value pairs. It simply maintains a key
+ * that can be set, removed, and checked for.
+ *
+ * See EXPOSED interface comment below
+ */
+#define GMQCC_HASHSET_PRIME0 0x0049
+#define GMQCC_HASHSET_PRIME1 0x1391
+
+static int util_hsput(hash_set_t *set, void *item) {
+ size_t hash = (size_t)item; /* shouldn't drop the bits */
+ size_t iter;
+
+ /* a == 0 || a == 1 */
+ if (hash >> 1)
+ return -1;
+
+ iter = set->mask & (GMQCC_HASHSET_PRIME0 * hash);
+
+ /* while (set->items[iter] != 0 && set->items[iter] != 1) */
+ while (!(set->items[iter] >> 1)) {
+ if (set->items[iter] == hash)
+ return 0;
+
+ iter = set->mask & (iter + GMQCC_HASHSET_PRIME1);
+ }
+
+ set->total ++;
+ set->items[iter] = hash;
+
+ return 1;
+}
+
+static void util_hsupdate(hash_set_t *set) {
+ size_t *old;
+ size_t end;
+ size_t itr;
+
+ /* time to rehash? */
+ if ((float)set->total >= (size_t)((double)set->capacity * 0.85)) {
+ old = set->items;
+ end = set->capacity;
+
+ set->bits ++;
+ set->capacity = (size_t)(1 << set->bits);
+ set->mask = set->capacity - 1;
+ set->items = (size_t*)mem_a(set->capacity * sizeof(size_t));
+ set->total = 0;
+
+ /*assert(set->items);*/
+
+ /*
+ * this shouldn't be slow? if so unroll it a little perhaps
+ * (shouldn't be though)
+ */
+ for (itr = 0; itr < end; itr++)
+ util_hsput(set, (void*)old[itr]);
+
+ mem_d(old);
+ }
+}
+
+/*
+ * EXPOSED interface: all of these functions are exposed to the outside
+ * for use. The stuff above is static because it's the "internal" mechanics
+ * for syncronizing the set for updating, and putting data into the set.
+ */
+int util_hsadd(hash_set_t *set, void *item) {
+ int run = util_hsput(set, item); /* inlined */
+ util_hsupdate(set);
+
+ return run;
+}
+
+/* remove item in set */
+int util_hsrem(hash_set_t *set, void *item) {
+ size_t hash = (size_t)item;
+ size_t iter = set->mask & (GMQCC_HASHSET_PRIME0 * hash);
+
+ while (set->items[iter]) {
+ if (set->items[iter] == hash) {
+ set->items[iter] = 1;
+ set->total --;
+
+ return 1;
+ }
+ iter = set->mask & (iter + GMQCC_HASHSET_PRIME1);
+ }
+
+ return 0;
+}
+
+/* check if item is set */
+int util_hshas(hash_set_t *set, void *item) {
+ size_t hash = (size_t)item;
+ size_t iter = set->mask & (GMQCC_HASHSET_PRIME0 * hash);
+
+ while (set->items[iter]) {
+ if (set->items[iter] == hash)
+ return 1;
+
+ iter = set->mask & (iter + GMQCC_HASHSET_PRIME1);
+ }
+
+ return 0;
+}
+
+hash_set_t *util_hsnew(void) {
+ hash_set_t *set;
+
+ if (!(set = (hash_set_t*)mem_a(sizeof(hash_set_t))))
+ return NULL;
+
+ set->bits = 3;
+ set->total = 0;
+ set->capacity = (size_t)(1 << set->bits);
+ set->mask = set->capacity - 1;
+ set->items = (size_t*)mem_a(set->capacity * sizeof(size_t));
+
+ if (!set->items) {
+ util_hsdel(set);
+ return NULL;
+ }
+
+ return set;
+}
+
+void util_hsdel(hash_set_t *set) {
+ if (!set) return;
+
+ if (set->items)
+ mem_d(set->items);
+
+ mem_d(set);
+}
+#undef GMQCC_HASHSET_PRIME0
+#undef GMQCC_HASHSET_PRIME1
+
+
+/*
+ * Portable implementation of vasprintf/asprintf. Assumes vsnprintf
+ * exists, otherwise compiler error.
+ *
+ * TODO: fix for MSVC ....
+ */
+int util_vasprintf(char **dat, const char *fmt, va_list args) {
+ int ret;
+ int len;
+ char *tmp = NULL;
+
+ /*
+ * For visuals tido _vsnprintf doesn't tell you the length of a
+ * formatted string if it overflows. However there is a MSVC
+ * intrinsic (which is documented wrong) called _vcsprintf which
+ * will return the required amount to allocate.
+ */
+ #ifdef _MSC_VER
+ char *str;
+ if ((len = _vscprintf(fmt, args)) < 0) {
+ *dat = NULL;
+ return -1;
+ }
+
+ tmp = mem_a(len + 1);
+ if ((ret = _vsnprintf(tmp, len+1, fmt, args)) != len) {
+ mem_d(tmp);
+ *dat = NULL;
+ return -1;
+ }
+ *dat = tmp;
+ return len;
+ #else
+ /*
+ * For everything else we have a decent conformint vsnprintf that
+ * returns the number of bytes needed. We give it a try though on
+ * a short buffer, since efficently speaking, it could be nice to
+ * above a second vsnprintf call.
+ */
+ char buf[128];
+ va_list cpy;
+ va_copy(cpy, args);
+ len = vsnprintf(buf, sizeof(buf), fmt, cpy);
+ va_end (cpy);
+
+ if (len < (int)sizeof(buf)) {
+ *dat = util_strdup(buf);
+ return len;
+ }
+
+ /* not large enough ... */
+ tmp = (char*)mem_a(len + 1);
+ if ((ret = vsnprintf(tmp, len + 1, fmt, args)) != len) {
+ mem_d(tmp);
+ *dat = NULL;
+ return -1;
+ }
+
+ *dat = tmp;
+ return len;
+ #endif
+}
+int util_asprintf(char **ret, const char *fmt, ...) {
+ va_list args;
+ int read;
+ va_start(args, fmt);
+ read = util_vasprintf(ret, fmt, args);
+ va_end (args);
+
+ return read;
+}
+
+/*
+ * 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() {
+ /*
+ * 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; ++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 - 1) {
+ /*
+ * 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;
+}
+
+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;
+}
projects / xonotic / gmqcc.git / blobdiff