X-Git-Url: https://git.kernel.dk/?a=blobdiff_plain;f=lib%2Frand.c;h=0e787a62bad152568eee08824abf723716fec040;hb=9dc528b1638b625b5e167983a74de4e85c5859ea;hp=185b679e7c1365956cd80e40d433dc8fa41a951e;hpb=74a92cdd178ac5434d2bbbc1649fe66ff341c1d0;p=fio.git diff --git a/lib/rand.c b/lib/rand.c index 185b679e..0e787a62 100644 --- a/lib/rand.c +++ b/lib/rand.c @@ -34,16 +34,18 @@ */ #include -#include #include "rand.h" +#include "pattern.h" #include "../hash.h" -static inline int __seed(unsigned int x, unsigned int m) +int arch_random; + +static inline uint64_t __seed(uint64_t x, uint64_t m) { return (x < m) ? x + m : x; } -static void __init_rand(struct frand_state *state, unsigned int seed) +static void __init_rand32(struct taus88_state *state, unsigned int seed) { int cranks = 6; @@ -54,85 +56,101 @@ static void __init_rand(struct frand_state *state, unsigned int seed) state->s3 = __seed(LCG(state->s2, seed), 15); while (cranks--) - __rand(state); + __rand32(state); } -void init_rand(struct frand_state *state) +void __init_rand64(struct taus258_state *state, uint64_t seed) { - __init_rand(state, 1); + int cranks = 6; + +#define LCG64(x, seed) ((x) * 6906969069ULL ^ (seed)) + + state->s1 = __seed(LCG64((2^31) + (2^17) + (2^7), seed), 1); + state->s2 = __seed(LCG64(state->s1, seed), 7); + state->s3 = __seed(LCG64(state->s2, seed), 15); + state->s4 = __seed(LCG64(state->s3, seed), 33); + state->s5 = __seed(LCG64(state->s4, seed), 49); + + while (cranks--) + __rand64(state); } -void init_rand_seed(struct frand_state *state, unsigned int seed) +void init_rand(struct frand_state *state, bool use64) { - __init_rand(state, seed); + state->use64 = use64; + + if (!use64) + __init_rand32(&state->state32, 1); + else + __init_rand64(&state->state64, 1); } -void __fill_random_buf(void *buf, unsigned int len, unsigned long seed) +void init_rand_seed(struct frand_state *state, uint64_t seed, bool use64) { - void *ptr = buf; + state->use64 = use64; - while (len) { - int this_len; - - if (len >= sizeof(int64_t)) { - *((int64_t *) ptr) = seed; - this_len = sizeof(int64_t); - } else if (len >= sizeof(int32_t)) { - *((int32_t *) ptr) = seed; - this_len = sizeof(int32_t); - } else if (len >= sizeof(int16_t)) { - *((int16_t *) ptr) = seed; - this_len = sizeof(int16_t); - } else { - *((int8_t *) ptr) = seed; - this_len = sizeof(int8_t); - } - ptr += this_len; - len -= this_len; - seed *= GOLDEN_RATIO_PRIME; - seed >>= 3; - } + if (!use64) + __init_rand32(&state->state32, (unsigned int) seed); + else + __init_rand64(&state->state64, seed); } -unsigned long fill_random_buf(struct frand_state *fs, void *buf, - unsigned int len) +void __fill_random_buf_small(void *buf, unsigned int len, uint64_t seed) { - unsigned long r = __rand(fs); + uint64_t *b = buf; + uint64_t *e = b + len / sizeof(*b); + unsigned int rest = len % sizeof(*b); - if (sizeof(int) != sizeof(long *)) - r *= (unsigned long) __rand(fs); + for (; b != e; ++b) { + *b = seed; + seed = __hash_u64(seed); + } - __fill_random_buf(buf, len, r); - return r; + if (fio_unlikely(rest)) + __builtin_memcpy(e, &seed, rest); } -void fill_pattern(void *p, unsigned int len, char *pattern, - unsigned int pattern_bytes) +void __fill_random_buf(void *buf, unsigned int len, uint64_t seed) { - switch (pattern_bytes) { - case 0: - assert(0); - break; - case 1: - memset(p, pattern[0], len); - break; - default: { - unsigned int i = 0, size = 0; - unsigned char *b = p; - - while (i < len) { - size = pattern_bytes; - if (size > (len - i)) - size = len - i; - memcpy(b+i, pattern, size); - i += size; - } - break; + static uint64_t prime[] = {1, 2, 3, 5, 7, 11, 13, 17, + 19, 23, 29, 31, 37, 41, 43, 47}; + uint64_t *b, *e, s[CONFIG_SEED_BUCKETS]; + unsigned int rest; + int p; + + /* + * Calculate the max index which is multiples of the seed buckets. + */ + rest = (len / sizeof(*b) / CONFIG_SEED_BUCKETS) * CONFIG_SEED_BUCKETS; + + b = buf; + e = b + rest; + + rest = len - (rest * sizeof(*b)); + + for (p = 0; p < CONFIG_SEED_BUCKETS; p++) + s[p] = seed * prime[p]; + + for (; b != e; b += CONFIG_SEED_BUCKETS) { + for (p = 0; p < CONFIG_SEED_BUCKETS; ++p) { + b[p] = s[p]; + s[p] = __hash_u64(s[p]); } } + + __fill_random_buf_small(b, rest, s[0]); } -void __fill_random_buf_percentage(unsigned long seed, void *buf, +uint64_t fill_random_buf(struct frand_state *fs, void *buf, + unsigned int len) +{ + uint64_t r = __get_next_seed(fs); + + __fill_random_buf(buf, len, r); + return r; +} + +void __fill_random_buf_percentage(uint64_t seed, void *buf, unsigned int percentage, unsigned int segment, unsigned int len, char *pattern, unsigned int pbytes) @@ -141,7 +159,7 @@ void __fill_random_buf_percentage(unsigned long seed, void *buf, if (percentage == 100) { if (pbytes) - fill_pattern(buf, len, pattern, pbytes); + (void)cpy_pattern(pattern, pbytes, buf, len); else memset(buf, 0, len); return; @@ -154,7 +172,7 @@ void __fill_random_buf_percentage(unsigned long seed, void *buf, /* * Fill random chunk */ - this_len = (segment * (100 - percentage)) / 100; + this_len = ((unsigned long long)segment * (100 - percentage)) / 100; if (this_len > len) this_len = len; @@ -164,6 +182,7 @@ void __fill_random_buf_percentage(unsigned long seed, void *buf, if (!len) break; buf += this_len; + this_len = segment - this_len; if (this_len > len) this_len = len; @@ -171,7 +190,7 @@ void __fill_random_buf_percentage(unsigned long seed, void *buf, this_len = len; if (pbytes) - fill_pattern(buf, this_len, pattern, pbytes); + (void)cpy_pattern(pattern, pbytes, buf, this_len); else memset(buf, 0, this_len); @@ -180,15 +199,12 @@ void __fill_random_buf_percentage(unsigned long seed, void *buf, } } -unsigned long fill_random_buf_percentage(struct frand_state *fs, void *buf, - unsigned int percentage, - unsigned int segment, unsigned int len, - char *pattern, unsigned int pbytes) +uint64_t fill_random_buf_percentage(struct frand_state *fs, void *buf, + unsigned int percentage, + unsigned int segment, unsigned int len, + char *pattern, unsigned int pbytes) { - unsigned long r = __rand(fs); - - if (sizeof(int) != sizeof(long *)) - r *= (unsigned long) __rand(fs); + uint64_t r = __get_next_seed(fs); __fill_random_buf_percentage(r, buf, percentage, segment, len, pattern, pbytes);