Seeded/Seedless random number

Just occurred to me a brilliant way to grab random values, I've tested a few times just now and it seems to be a usable option even for security, at least to me anyways:

Code:

---

#include <limits.h>
#include <malloc.h>
#include <time.h>

long mcc_rnd( long *seed, long min, long max ) {
        unsigned char *tmp = malloc(1);
        /* Initial ranom value */
        long val = time(NULL) + ((ptrdiff_t)tmp), _seed = 1;
        if ( !seed ) seed = &seed;
        if ( *seed == 0 ) *seed = 1;
        /* Counter possible divide by 0 situation */
        val %= *seed;
        val *= clock();
        free(tmp);
        *seed <<= 1;
        return (val > max) ? max : (val < min ? min : val);
}

int main() {
        int i;
        long seed = 1;
        for ( i = 0; i < 100; ++i ) {
                (void)printf( "%ld\n", mcc_rnd( &seed, LONG_MIN,LONG_MAX) );
        }
}

---

A real program will no doubt call malloc & co often providing a greater randomness than already provided, the time() and clock() calls help randomize in between those calls and the seed is for utilizing a change in magnitude while min & max are there to restrain the result
Go ahead and give it a try with and without a seed

Noticed a bug, fixed it, turned out to be a feature instead so fixed back and removed the un-needed variable and changed types

Code:

---

typedef ptrdiff_t mcc_rnd_t;
long mcc_rnd( mcc_rnd_t *seed, long min, long max ) {
        unsigned char *tmp = malloc(1);
        /* Initial random value */
        long val = time(NULL) + ((ptrdiff_t)tmp);
        if ( !seed ) seed = (mcc_rnd_t*)(&seed);
        if ( *seed == 0 ) *seed = 1;
        val %= *seed;
        val *= clock();
        free(tmp);
        *seed <<= 1;
        return (val > max) ? max : (val < min ? min : val);
}

---

ptrdiff_t is a signed integer type, and left shifts on signed integers result in undefined behaviour if the value is negative or if the result cannot be represented. Besides a ptrdiff_t doesn't make much sense here since no pointer subtraction is used. An unsigned int as in srand might be simpler.

time_t isn't guaranteed to be an integer, but we admittedly often use it as such in example/toy programs by providing srand with the result of time(). One idea I've seen (by forum member Prelude) is to hash the bytes of a time_t. You could easily do this while mixing in the (bytes of the) pointer from malloc, resulting in a portable solution.

I wonder if there's a point exposing the use of a seed in the interface though: you're trying to implement a RNG, not a PRNG, and although the use of a seed for a PRNG is often associated with making the random sequences differ on each run, that could be abstracted away, but isn't because there's value in allowing the seed to be specified: so that we can get the same pseudorandom sequence on each run, hence allowing for things like repeatable simulations, whereas with a RNG we would have to save the entire random sequence in order to replay it.

I'd definitely be concerned about using this as a secure RNG before you've run any proper tests and attacks on it: even seasoned security folks have been wrong about what they thought would be a sufficiently random source.

Quote:

---

Originally Posted by laserlight

ptrdiff_t is a signed integer type, and left shifts on signed integers result in undefined behaviour if the value is negative or if the result cannot be represented. Besides a ptrdiff_t doesn't make much sense here since no pointer subtraction is used. An unsigned int as in srand might be simpler.

time_t isn't guaranteed to be an integer, but we admittedly often use it as such in example/toy programs by providing srand with the result of time(). One idea I've seen (by forum member Prelude) is to hash the bytes of a time_t. You could easily do this while mixing in the (bytes of the) pointer from malloc, resulting in a portable solution.

I wonder if there's a point exposing the use of a seed in the interface though: you're trying to implement a RNG, not a PRNG, and although the use of a seed for a PRNG is often associated with making the random sequences differ on each run, that could be abstracted away, but isn't because there's value in allowing the seed to be specified: so that we can get the same pseudorandom sequence on each run, hence allowing for things like repeatable simulations, whereas with a RNG we would have to save the entire random sequence in order to replay it.

I'd definitely be concerned about using this as a secure RNG before you've run any proper tests and attacks on it: even seasoned security folks have been wrong about what they thought would be a sufficiently random source.

---

"undefined behaviour" "random" wonder what those two have in common? :) also the seed is an option, actually runs better without (when NULL is given), I've already tested this myself and advise you to test it also before you post again, (I did multiple runs just to see if the numbers where consistent or not)

Quote:

---

Originally Posted by awsdert

"undefined behaviour" "random" wonder what those two have in common?

---

One can result in a compile error, segmentation fault, or some other strange result; the other won't. That said, while bit shifting with unsigned integers such that it overflows is well defined, and conversions to unsigned integers is well defined too, multiplication even with unsigned integers technically results in undefined behaviour if the result is out of range... but for the most part people don't care since that one will practically result in the same thing as if it were a conversion for pretty much all implementations.

Another nice side effect of hashing is that it likely results in a better random mix of bits than simple addition.

Quote:

---

Originally Posted by awsdert

also the seed is an option, actually runs better without (when NULL is given)

---

Exactly: why provide it as an option then? You're making it harder to use well because people will be more likely to mistake this for a PRNG and provide their own seed when it is completely unnecessary for a RNG like this. Or worse still, they might expect repeatable pseudorandom sequences when this won't work since this is not a PRNG.

Quote:

---

Originally Posted by awsdert

I've already tested this myself and advise you to test it also before you post again (I did multiple runs just to see if the numbers where consistent or not)

---

I'm afraid that I don't have the necessary knowledge to run proper tests on this. Have you actually properly tested it? It looks like all you did was run it in a loop and eyeball the result, which unfortunately doesn't count as a proper test of randomness as humans tend to be pretty bad at guessing what's random and what's not from just looking. But because you're using things like addresses allocated and clock() it should be random; the question is whether your choices and the combination of these random sources does produce enough entropy for secure applications.

Quote:

---

Originally Posted by awsdert

"undefined behaviour" "random" wonder what those two have in common? :) also the seed is an option, actually runs better without (when NULL is given), I've already tested this myself and advise you to test it also before you post again, (I did multiple runs just to see if the numbers where consistent or not)

---

But, are they random enough to call random when the code is compiled under other OSes or even with other Compilers?

Tim S.

> Just occurred to me a brilliant way to grab random values,
You sound like a noob who just "discovered" bubble sorting and thinks it's the most awesome thing they've ever seen.

> I've tested a few times just now and it seems to be a usable option even for security, at least to me anyways:
I wouldn't use this for a student dice rolling program, never mind for any serious statistical or security application.
The algorithm (such as it is), is painfully slow as well as being singularly useless.

Diehard tests - Wikipedia

On my machine, malloc() returns the same pointer every time, and time() is a constant.
clock() is barely able to do any better than being an incrementing counter.

Code:

---

#include<stdio.h>
#include<time.h>
#include<stdlib.h>
#include<stddef.h>
#include<limits.h>

typedef ptrdiff_t mcc_rnd_t;
long mcc_rnd( mcc_rnd_t *seed, long min, long max ) {
    unsigned char *tmp = malloc(1);
    /* Initial random value */
    long val = time(NULL) + ((ptrdiff_t)tmp);
    if ( !seed ) seed = (mcc_rnd_t*)(&seed);
    if ( *seed == 0 ) *seed = 1;
    val %= *seed;
    val *= clock();
    free(tmp);
    *seed <<= 1;
    return (val > max) ? max : (val < min ? min : val);
}

void t1() {
    printf("100 Clocks()\n");
    long tests[100];
    for ( int i = 0; i < 100; ++i ) {
        tests[i] = clock();
    }
    for ( int i = 0; i < 100; ++i ) {
        (void)printf( "%ld\n", tests[i] );
    }
}

void t2() {
    printf("100 times()\n");
    long tests[100];
    for ( int i = 0; i < 100; ++i ) {
        tests[i] = time(NULL);
    }
    for ( int i = 0; i < 100; ++i ) {
        (void)printf( "%ld\n", tests[i] );
    }
}

void t3() {
    printf("100 pointers()\n");
    void *tests[100];
    for ( int i = 0; i < 100; ++i ) {
        tests[i] = malloc(1);
        free(tests[i]);
    }
    for ( int i = 0; i < 100; ++i ) {
        (void)printf( "%p\n", tests[i] );
    }
}

int main() {
    int i;
    long seed = 1;
    long tests[100];
    t1();
    t2();
    t3();
    for ( i = 0; i < 100; ++i ) {
        tests[i] = mcc_rnd( &seed, LONG_MIN,LONG_MAX);
    }
    for ( i = 0; i < 100; ++i ) {
        (void)printf( "%ld\n", tests[i] );
    }
    int dice[6] = { 0 };
    for ( int i = 0 ; i < 60000000 ; i++ ) {
      int d = mcc_rnd( &seed, LONG_MIN,LONG_MAX) % 6;
      dice[d]++;
    }
    for ( int i = 0 ; i < 6 ; i++ ) {
      printf("%d: %d\n", i, dice[i]);
    }
}

---

Your 'distribution' is awful. Your online casino operator is now suing you.

Code:

---

0: 25929392
1: 3481475
2: 9589231
3: 7932192
4: 9587561
5: 3480149

real        0m21.880s
user        0m7.460s
sys        0m14.416s

---

Compare with calling rand() millions of times.
Much better, and MUCH quicker!.

Code:

---

0: 9998142
1: 9999581
2: 10000326
3: 10003300
4: 9997641
5: 10001010

real        0m0.600s
user        0m0.596s
sys        0m0.000s

---

Quote:

---

Originally Posted by Salem

> Just occurred to me a brilliant way to grab random values,
You sound like a noob who just "discovered" bubble sorting and thinks it's the most awesome thing they've ever seen.

> I've tested a few times just now and it seems to be a usable option even for security, at least to me anyways:
I wouldn't use this for a student dice rolling program, never mind for any serious statistical or security application.
The algorithm (such as it is), is painfully slow as well as being singularly useless.

Diehard tests - Wikipedia

On my machine, malloc() returns the same pointer every time, and time() is a constant.
clock() is barely able to do any better than being an incrementing counter.

Code:

---

#include<stdio.h>
#include<time.h>
#include<stdlib.h>
#include<stddef.h>
#include<limits.h>

typedef ptrdiff_t mcc_rnd_t;
long mcc_rnd( mcc_rnd_t *seed, long min, long max ) {
    unsigned char *tmp = malloc(1);
    /* Initial random value */
    long val = time(NULL) + ((ptrdiff_t)tmp);
    if ( !seed ) seed = (mcc_rnd_t*)(&seed);
    if ( *seed == 0 ) *seed = 1;
    val %= *seed;
    val *= clock();
    free(tmp);
    *seed <<= 1;
    return (val > max) ? max : (val < min ? min : val);
}

void t1() {
    printf("100 Clocks()\n");
    long tests[100];
    for ( int i = 0; i < 100; ++i ) {
        tests[i] = clock();
    }
    for ( int i = 0; i < 100; ++i ) {
        (void)printf( "%ld\n", tests[i] );
    }
}

void t2() {
    printf("100 times()\n");
    long tests[100];
    for ( int i = 0; i < 100; ++i ) {
        tests[i] = time(NULL);
    }
    for ( int i = 0; i < 100; ++i ) {
        (void)printf( "%ld\n", tests[i] );
    }
}

void t3() {
    printf("100 pointers()\n");
    void *tests[100];
    for ( int i = 0; i < 100; ++i ) {
        tests[i] = malloc(1);
        free(tests[i]);
    }
    for ( int i = 0; i < 100; ++i ) {
        (void)printf( "%p\n", tests[i] );
    }
}

int main() {
    int i;
    long seed = 1;
    long tests[100];
    t1();
    t2();
    t3();
    for ( i = 0; i < 100; ++i ) {
        tests[i] = mcc_rnd( &seed, LONG_MIN,LONG_MAX);
    }
    for ( i = 0; i < 100; ++i ) {
        (void)printf( "%ld\n", tests[i] );
    }
    int dice[6] = { 0 };
    for ( int i = 0 ; i < 60000000 ; i++ ) {
      int d = mcc_rnd( &seed, LONG_MIN,LONG_MAX) % 6;
      dice[d]++;
    }
    for ( int i = 0 ; i < 6 ; i++ ) {
      printf("%d: %d\n", i, dice[i]);
    }
}

---

Your 'distribution' is awful. Your online casino operator is now suing you.

Code:

---

0: 25929392
1: 3481475
2: 9589231
3: 7932192
4: 9587561
5: 3480149

real        0m21.880s
user        0m7.460s
sys        0m14.416s

---

Compare with calling rand() millions of times.
Much better, and MUCH quicker!.

Code:

---

0: 9998142
1: 9999581
2: 10000326
3: 10003300
4: 9997641
5: 10001010

real        0m0.600s
user        0m0.596s
sys        0m0.000s

---

---

Maybe be slower but it does it's job, and you've been corrected on the randomness:

Code:

---

#include<stdio.h>
#include<time.h>
#include<stdlib.h>
#include<stddef.h>
#include<limits.h>
#define PER_LOOP 30
#define DIE_ROLL 600000
typedef ptrdiff_t mcc_rnd_t;
ulong mcc__rnd( mcc_rnd_t *seed ) {
        unsigned char *tmp = malloc(1);
        /* Initial random value */
        ulong val = (time(NULL) + ((ptrdiff_t)tmp));
        if ( seed ) {
                if ( *seed == 0 ) *seed = 1;
                val %= *seed;
                *seed <<= 1;
        }
        val *= clock();
        free(tmp);
        return val;
}
long mcc_rnd( mcc_rnd_t *seed, long min, long max ) {
        unsigned char *tmp = malloc(1);
        /* Initial random value */
        long val = time(NULL) + ((ptrdiff_t)tmp);
        if ( seed ) {
                if ( *seed == 0 ) *seed = 1;
                val %= *seed;
                *seed <<= 1;
        }
        val *= clock();
        free(tmp);
        return (val > max) ? max : (val < min ? min : val);
}

void t( char *name, long (*func)() ) {
        printf("%d %s()\n",PER_LOOP,name);
        long tests[PER_LOOP];
        for ( int i = 0; i < PER_LOOP; ++i ) {
                tests[i] = func();
        }
        for ( int i = 0; i < PER_LOOP; ++i ) {
                (void)printf( "%ld\n", tests[i] );
        }
}

long t_time() { return (long)time(NULL); }
long t_clock() { return (long)clock(); }
long t_malloc() {
        void *tmp = malloc(1);
        free(tmp);
        return (long)tmp;
}
long t_mcc_rnd() { return (long)mcc_rnd(NULL,LONG_MIN,LONG_MAX); }
long t_mcc__rnd() { return (long)mcc__rnd(NULL); }

void t1() {        t("time",t_time); }
void t2() { t("clock",t_clock); }
void t3() { t("malloc",t_malloc); }
void t4() { t("mcc_rnd",t_mcc_rnd); }
void t5() { t("mcc__rnd",t_mcc__rnd); }
 
int main() {
        long seed = 1;
        t1(); t2(); t3(); t4(); t5();
        printf("%d dice rolls mcc_rnd(seed)\n",DIE_ROLL);
        int dice[6] = { 0 };
        for ( int i = 0 ; i < DIE_ROLL; i++ ) {
                int d = mcc_rnd( &seed, 0, 5 );
                dice[d]++;
        }
        for ( int i = 0 ; i < 6 ; i++ ) {
                printf("%d: %d\n", i, dice[i]);
        }
        printf("%d dice rolls mcc__rnd(seed)\n",DIE_ROLL);
        for ( int i = 0 ; i < DIE_ROLL; i++ ) {
                int d = mcc__rnd( &seed ) % 6;
                dice[d]++;
        }
        for ( int i = 0 ; i < 6 ; i++ ) {
                printf("%d: %d\n", i, dice[i]);
        }
        printf("%d dice rolls mcc_rnd(NULL)\n",DIE_ROLL);
        for ( int i = 0 ; i < DIE_ROLL; i++ ) {
                int d = mcc_rnd( NULL, 0, 5 );
                dice[d]++;
        }
        for ( int i = 0 ; i < 6 ; i++ ) {
                printf("%d: %d\n", i, dice[i]);
        }
        printf("%d dice rolls mcc__rnd(NULL)\n",DIE_ROLL);
        for ( int i = 0 ; i < DIE_ROLL; i++ ) {
                int d = mcc__rnd( NULL ) % 6;
                dice[d]++;
        }
        for ( int i = 0 ; i < 6 ; i++ ) {
                printf("%d: %d\n", i, dice[i]);
        }
        return 0;
}

---

Code:

---

make --no-print-directory rnd
gcc -ggdb -Wall -lpthread -o ./mcc_rnd.elf mcc_rnd.c
./mcc_rnd.elf
30 time()
1578648723
1578648723
1578648723
1578648723
1578648723
1578648723
1578648723
1578648723
1578648723
1578648723
1578648723
1578648723
1578648723
1578648723
1578648723
1578648723
1578648723
1578648723
1578648723
1578648723
1578648723
1578648723
1578648723
1578648723
1578648723
1578648723
1578648723
1578648723
1578648723
1578648723
30 clock()
754
755
756
757
757
758
759
759
760
760
761
762
762
763
764
764
765
766
766
767
768
768
769
770
770
771
772
772
773
774
30 malloc()
94681744093872
94681744093872
94681744093872
94681744093872
94681744093872
94681744093872
94681744093872
94681744093872
94681744093872
94681744093872
94681744093872
94681744093872
94681744093872
94681744093872
94681744093872
94681744093872
94681744093872
94681744093872
94681744093872
94681744093872
94681744093872
94681744093872
94681744093872
94681744093872
94681744093872
94681744093872
94681744093872
94681744093872
94681744093872
94681744093872
30 mcc_rnd()
74705141643907455
74799824966650050
74894508289392645
74989191612135240
74989191612135240
75083874934877835
75178558257620430
75273241580363025
75273241580363025
75367924903105620
75462608225848215
75462608225848215
75557291548590810
75651974871333405
75746658194076000
75746658194076000
75841341516818595
75936024839561190
75936024839561190
76030708162303785
76125391485046380
76220074807788975
76220074807788975
76314758130531570
76409441453274165
76409441453274165
76504124776016760
76598808098759355
76693491421501950
76693491421501950
30 mcc__rnd()
77450958003442710
77545641326185305
77640324648927900
77735007971670495
77735007971670495
77829691294413090
77924374617155685
77924374617155685
78019057939898280
78113741262640875
78208424585383470
78208424585383470
78303107908126065
78397791230868660
78397791230868660
78492474553611255
78587157876353850
78681841199096445
78681841199096445
78776524521839040
78871207844581635
78871207844581635
78965891167324230
79060574490066825
79060574490066825
79155257812809420
79249941135552015
79344624458294610
79344624458294610
79439307781037205
600000 dice rolls mcc_rnd(seed)
0: 74556
1: 0
2: 0
3: 0
4: 0
5: 525444
600000 dice rolls mcc__rnd(seed)
0: 219695
1: 97168
2: 62456
3: 135375
4: 97256
5: 588050
600000 dice rolls mcc_rnd(NULL)
0: 499668
1: 97168
2: 62456
3: 135375
4: 97256
5: 908077
600000 dice rolls mcc__rnd(NULL)
0: 699594
1: 97168
2: 262438
3: 135375
4: 297348
5: 908077
Compilation finished successfully.

---

Quote:

---

Originally Posted by awsdert

A real program will no doubt call malloc & co often providing a greater randomness than already provided, the time() and clock() calls help randomize in between those calls

---

Btw salem did you read this bit?

Both mcc_rnd and mcc__rnd appear to be generating successive duplicates. That's weird: I would have thought that even if clock() didn't result in a different random number, at the very least seed doing the job of internal state would have done the trick.

That said, Salem's right about the low entropy of time() and malloc(), as you have observed, and with its continuously increasing value clock() only fares a little better.

Quote:

---

Originally Posted by awsdert

Btw salem did you read this bit?

---

Simulations requiring the use of a RNG or PRNG may not necessarily do intermediate memory allocations, e.g., it may be more efficient to allocate once then reuse the memory. A related issue is that the addresses allocated might not differ significantly, i.e. the entropy would be low.

Didn't like that I saw frequent doubles so I tried to find another way, I succeeded, gets its pointer from the stack instead now so malloc is no longer needed providing a speed up, although security applications should really sacrifice the time and put it in anyways to reduce chances of calculating to bare minimum.

Code:

---

#include<stdio.h>
#include<time.h>
#include<stdlib.h>
#include<stddef.h>
#include<limits.h>
#define PER_LOOP 15
#define DIE_ROLL 60000
typedef ptrdiff_t mcc_rnd_t;
ulong mcc__rnd( mcc_rnd_t *seed ) {
        /* Initial random value */
        ulong val = (ulong)(&seed) * (ulong)clock() * (ulong)clock();
        if ( seed ) {
                if ( *seed == 0 ) *seed = 1;
                val %= *seed;
                *seed <<= 1;
        }
        return val;
}
long mcc_rnd( mcc_rnd_t *seed, long min, long max ) {
        /* Initial random value */
        long val = (ulong)(&seed) * (ulong)clock();
        if ( seed ) {
                if ( *seed == 0 ) *seed = 1;
                val %= *seed;
                *seed <<= 1;
        }
        if ( val > max ) return (max != 0) ? val % max : 0;
        if ( val < min ) return (min != 0) ? val % min : 0;
        return val;
}

void t( char *name, long (*func)() ) {
        printf("%d %s()\n",PER_LOOP,name);
        long tests[PER_LOOP];
        for ( int i = 0; i < PER_LOOP; ++i ) {
                tests[i] = func();
        }
        for ( int i = 0; i < PER_LOOP; ++i ) {
                (void)printf( "%ld\n", tests[i] );
        }
}

long t_time() { return (long)time(NULL); }
long t_clock() { return (long)clock(); }
long t_malloc() {
        void *tmp = malloc(1);
        free(tmp);
        return (long)tmp;
}
long t_mcc_rnd() { return (long)mcc_rnd(NULL,LONG_MIN,LONG_MAX); }
long t_mcc__rnd() { return (long)mcc__rnd(NULL); }

void t1() {        t("time",t_time); }
void t2() { t("clock",t_clock); }
void t3() { t("malloc",t_malloc); }
void t4() { t("mcc_rnd",t_mcc_rnd); }
void t5() { t("mcc__rnd",t_mcc__rnd); }
 
int main() {
        long seed = 1;
        t1(); t2(); t3(); t4(); t5();
        printf("%d dice rolls mcc_rnd(seed)\n",DIE_ROLL);
        int dice[6] = { 0 };
        for ( int i = 0 ; i < DIE_ROLL; i++ ) {
                int d = mcc_rnd( &seed, 0, 5 );
                dice[d]++;
        }
        for ( int i = 0 ; i < 6 ; i++ ) {
                printf("%d: %d\n", i, dice[i]);
        }
        printf("%d dice rolls mcc__rnd(seed)\n",DIE_ROLL);
        for ( int i = 0 ; i < DIE_ROLL; i++ ) {
                int d = mcc__rnd( &seed ) % 6;
                dice[d]++;
        }
        for ( int i = 0 ; i < 6 ; i++ ) {
                printf("%d: %d\n", i, dice[i]);
        }
        printf("%d dice rolls mcc_rnd(NULL)\n",DIE_ROLL);
        for ( int i = 0 ; i < DIE_ROLL; i++ ) {
                int d = mcc_rnd( NULL, 0, 5 );
                dice[d]++;
        }
        for ( int i = 0 ; i < 6 ; i++ ) {
                printf("%d: %d\n", i, dice[i]);
        }
        printf("%d dice rolls mcc__rnd(NULL)\n",DIE_ROLL);
        for ( int i = 0 ; i < DIE_ROLL; i++ ) {
                int d = mcc__rnd( NULL ) % 6;
                dice[d]++;
        }
        for ( int i = 0 ; i < 6 ; i++ ) {
                printf("%d: %d\n", i, dice[i]);
        }
        return 0;
}

---

Had to use stack pointer to get huge values, using clock just once gave me quick repeats while using it twice gave the randomness so that's as fast as the functions can get
Edit: Forgot to add my output

Code:

---

make --no-print-directory rnd (in directory: /mnt/DATA/github/mc)
./mcc_rnd.elf
15 time()
1578651387
1578651387
1578651387
1578651387
1578651387
1578651387
1578651387
1578651387
1578651387
1578651387
1578651387
1578651387
1578651387
1578651387
1578651387
15 clock()
1418
1422
1423
1425
1427
1428
1429
1431
1432
1434
1435
1437
1438
1440
1441
15 malloc()
94865291133616
94865291133616
94865291133616
94865291133616
94865291133616
94865291133616
94865291133616
94865291133616
94865291133616
94865291133616
94865291133616
94865291133616
94865291133616
94865291133616
94865291133616
15 mcc_rnd()
205878483718330808
206159930722730440
206441377727130072
206582101229329888
206863548233729520
207004271735929336
207285718740328968
207426442242528784
207707889246928416
207989336251328048
208130059753527864
208411506757927496
208552230260127312
208833677264526944
208974400766726760
15 mcc__rnd()
1557322605451952320
2822145443223898528
4089501304035441424
5359390187886581008
6631812094777317280
7906767024707650240
9184254977677579888
-7982468120022445392
-6699914120973322368
-5414827098884602656
-4127207053756286256
-2837053985588373168
-1544367894380863392
-249148780133756928
1265036103536263232
60000 dice rolls mcc_rnd(seed)
0: 15543
1: 11088
2: 10635
3: 11717
4: 11017
5: 0
60000 dice rolls mcc__rnd(seed)
0: 39888
1: 11088
2: 28141
3: 11717
4: 29166
5: 0
60000 dice rolls mcc_rnd(NULL)
0: 64546
1: 19884
2: 36992
3: 20594
4: 37984
5: 0
60000 dice rolls mcc__rnd(NULL)
0: 84429
1: 19884
2: 57093
3: 20594
4: 58000
5: 0
Compilation finished successfully.

---

Run it through Robert G. Brown's General Tools Page

Quote:

---

Originally Posted by Hodor

Run it through Robert G. Brown's General Tools Page

---

Didn't even know about that, thanks, currently installing now

Quote:

---

Originally Posted by awsdert

Didn't even know about that, thanks, currently installing now

---

Still running but I think it is safe to say its passing at least the majority of tests, yet to see a fail after 10 or so different tests

Edit 1: On rgb_bitdist and still no fails
Edit 2: Whoops, wrong code got compiled, I noticed a fatal bug and yet dieharder was running fine??? It's using the tests we used a minute ago, perhaps I did something wrong (besides forget to change a bit of code after copy pasting)
the command I gave was

Code:

---

dieharder -a < ./mcc_rnd_die.elf

---

Edit 3: Running with compiled result of this now:

Code:

---

#ifdef BUILD_FOR_DIEHARDER
#define PER_LOOP 100
int main() {
        for ( int i = 0 ; i < PER_LOOP; i++ ) {
                printf( "%lu",mcc__rnd( NULL ) );
        }
}
#else

---

Okay so 1st one to not get a full passing grade is under diehard_sums, that was weak apparently, but everything else so far is a pass
Edit 5: One of the sts_serial's was weak but all was a pass, waiting on rgb_bitdist now
Edit 6: One rgb_lagged_sum got a weak but all else is a pass so far

Code:

---

make --no-print-directory dieharder_rnd
gcc -ggdb -Wall -lpthread -DBUILD_FOR_DIEHARDER -o ./mcc_rnd_die.elf mcc_rnd.c
dieharder -a < ./mcc_rnd_die.elf
#=============================================================================#
#            dieharder version 3.31.1 Copyright 2003 Robert G. Brown          #
#=============================================================================#
  rng_name    |rands/second|  Seed  |
        mt19937|  7.47e+07  |2183355501|
#=============================================================================#
        test_name  |ntup| tsamples |psamples|  p-value |Assessment
#=============================================================================#
  diehard_birthdays|  0|      100|    100|0.68912807|  PASSED
      diehard_operm5|  0|  1000000|    100|0.33185316|  PASSED
  diehard_rank_32x32|  0|    40000|    100|0.20523365|  PASSED
    diehard_rank_6x8|  0|    100000|    100|0.56657362|  PASSED
  diehard_bitstream|  0|  2097152|    100|0.48796673|  PASSED
        diehard_opso|  0|  2097152|    100|0.96932785|  PASSED
        diehard_oqso|  0|  2097152|    100|0.57613400|  PASSED
        diehard_dna|  0|  2097152|    100|0.36391026|  PASSED
diehard_count_1s_str|  0|    256000|    100|0.95420219|  PASSED
diehard_count_1s_byt|  0|    256000|    100|0.49438046|  PASSED
 diehard_parking_lot|  0|    12000|    100|0.69671967|  PASSED
    diehard_2dsphere|  2|      8000|    100|0.64493339|  PASSED
    diehard_3dsphere|  3|      4000|    100|0.70045590|  PASSED
    diehard_squeeze|  0|    100000|    100|0.18376720|  PASSED
        diehard_sums|  0|      100|    100|0.00066824|  WEAK
        diehard_runs|  0|    100000|    100|0.95812784|  PASSED
        diehard_runs|  0|    100000|    100|0.73436942|  PASSED
      diehard_craps|  0|    200000|    100|0.59867241|  PASSED
      diehard_craps|  0|    200000|    100|0.64270262|  PASSED
 marsaglia_tsang_gcd|  0|  10000000|    100|0.21112144|  PASSED
 marsaglia_tsang_gcd|  0|  10000000|    100|0.97679564|  PASSED
        sts_monobit|  1|    100000|    100|0.31412247|  PASSED
            sts_runs|  2|    100000|    100|0.38656440|  PASSED
          sts_serial|  1|    100000|    100|0.28265568|  PASSED
          sts_serial|  2|    100000|    100|0.84211097|  PASSED
          sts_serial|  3|    100000|    100|0.85743956|  PASSED
          sts_serial|  3|    100000|    100|0.62893546|  PASSED
          sts_serial|  4|    100000|    100|0.91881379|  PASSED
          sts_serial|  4|    100000|    100|0.99588482|  WEAK
          sts_serial|  5|    100000|    100|0.40422598|  PASSED
          sts_serial|  5|    100000|    100|0.65208682|  PASSED
          sts_serial|  6|    100000|    100|0.84282188|  PASSED
          sts_serial|  6|    100000|    100|0.48041382|  PASSED
          sts_serial|  7|    100000|    100|0.37634899|  PASSED
          sts_serial|  7|    100000|    100|0.94017686|  PASSED
          sts_serial|  8|    100000|    100|0.37766686|  PASSED
          sts_serial|  8|    100000|    100|0.80462312|  PASSED
          sts_serial|  9|    100000|    100|0.79408707|  PASSED
          sts_serial|  9|    100000|    100|0.78934859|  PASSED
          sts_serial|  10|    100000|    100|0.95975152|  PASSED
          sts_serial|  10|    100000|    100|0.95799169|  PASSED
          sts_serial|  11|    100000|    100|0.27117271|  PASSED
          sts_serial|  11|    100000|    100|0.07037894|  PASSED
          sts_serial|  12|    100000|    100|0.76411242|  PASSED
          sts_serial|  12|    100000|    100|0.45373889|  PASSED
          sts_serial|  13|    100000|    100|0.98482625|  PASSED
          sts_serial|  13|    100000|    100|0.32328241|  PASSED
          sts_serial|  14|    100000|    100|0.95671043|  PASSED
          sts_serial|  14|    100000|    100|0.58142558|  PASSED
          sts_serial|  15|    100000|    100|0.46890954|  PASSED
          sts_serial|  15|    100000|    100|0.95074230|  PASSED
          sts_serial|  16|    100000|    100|0.37380906|  PASSED
          sts_serial|  16|    100000|    100|0.65406332|  PASSED
        rgb_bitdist|  1|    100000|    100|0.84937886|  PASSED
        rgb_bitdist|  2|    100000|    100|0.28646607|  PASSED
        rgb_bitdist|  3|    100000|    100|0.51304968|  PASSED
        rgb_bitdist|  4|    100000|    100|0.45667059|  PASSED
        rgb_bitdist|  5|    100000|    100|0.28200974|  PASSED
        rgb_bitdist|  6|    100000|    100|0.91353734|  PASSED
        rgb_bitdist|  7|    100000|    100|0.72428162|  PASSED
        rgb_bitdist|  8|    100000|    100|0.93574763|  PASSED
        rgb_bitdist|  9|    100000|    100|0.69912244|  PASSED
        rgb_bitdist|  10|    100000|    100|0.86384268|  PASSED
        rgb_bitdist|  11|    100000|    100|0.98536743|  PASSED
        rgb_bitdist|  12|    100000|    100|0.49128106|  PASSED
rgb_minimum_distance|  2|    10000|    1000|0.70161637|  PASSED
rgb_minimum_distance|  3|    10000|    1000|0.35414237|  PASSED
rgb_minimum_distance|  4|    10000|    1000|0.47007518|  PASSED
rgb_minimum_distance|  5|    10000|    1000|0.47663074|  PASSED
    rgb_permutations|  2|    100000|    100|0.01458501|  PASSED
    rgb_permutations|  3|    100000|    100|0.12143930|  PASSED
    rgb_permutations|  4|    100000|    100|0.36905364|  PASSED
    rgb_permutations|  5|    100000|    100|0.55232070|  PASSED
      rgb_lagged_sum|  0|  1000000|    100|0.92829195|  PASSED
      rgb_lagged_sum|  1|  1000000|    100|0.86765846|  PASSED
      rgb_lagged_sum|  2|  1000000|    100|0.36400818|  PASSED
      rgb_lagged_sum|  3|  1000000|    100|0.99972018|  WEAK
      rgb_lagged_sum|  4|  1000000|    100|0.92030661|  PASSED
      rgb_lagged_sum|  5|  1000000|    100|0.31770161|  PASSED
      rgb_lagged_sum|  6|  1000000|    100|0.83334318|  PASSED
      rgb_lagged_sum|  7|  1000000|    100|0.79018869|  PASSED
      rgb_lagged_sum|  8|  1000000|    100|0.49984733|  PASSED
      rgb_lagged_sum|  9|  1000000|    100|0.29544993|  PASSED
      rgb_lagged_sum|  10|  1000000|    100|0.36598678|  PASSED
      rgb_lagged_sum|  11|  1000000|    100|0.53130325|  PASSED
      rgb_lagged_sum|  12|  1000000|    100|0.16963480|  PASSED
      rgb_lagged_sum|  13|  1000000|    100|0.36339478|  PASSED
      rgb_lagged_sum|  14|  1000000|    100|0.39880436|  PASSED
      rgb_lagged_sum|  15|  1000000|    100|0.50221412|  PASSED
      rgb_lagged_sum|  16|  1000000|    100|0.53840220|  PASSED
      rgb_lagged_sum|  17|  1000000|    100|0.98369666|  PASSED
      rgb_lagged_sum|  18|  1000000|    100|0.68814762|  PASSED
      rgb_lagged_sum|  19|  1000000|    100|0.95109665|  PASSED
      rgb_lagged_sum|  20|  1000000|    100|0.75218223|  PASSED
      rgb_lagged_sum|  21|  1000000|    100|0.19693003|  PASSED
      rgb_lagged_sum|  22|  1000000|    100|0.91385411|  PASSED
      rgb_lagged_sum|  23|  1000000|    100|0.88609169|  PASSED
      rgb_lagged_sum|  24|  1000000|    100|0.59183453|  PASSED
      rgb_lagged_sum|  25|  1000000|    100|0.67084305|  PASSED
      rgb_lagged_sum|  26|  1000000|    100|0.47168894|  PASSED
      rgb_lagged_sum|  27|  1000000|    100|0.91754824|  PASSED
      rgb_lagged_sum|  28|  1000000|    100|0.12052571|  PASSED
      rgb_lagged_sum|  29|  1000000|    100|0.83785940|  PASSED
      rgb_lagged_sum|  30|  1000000|    100|0.11108464|  PASSED
      rgb_lagged_sum|  31|  1000000|    100|0.56193332|  PASSED
      rgb_lagged_sum|  32|  1000000|    100|0.94368013|  PASSED
    rgb_kstest_test|  0|    10000|    1000|0.01123703|  PASSED
    dab_bytedistrib|  0|  51200000|      1|0.95472989|  PASSED
            dab_dct| 256|    50000|      1|0.73259145|  PASSED
Preparing to run test 207.  ntuple = 0
        dab_filltree|  32|  15000000|      1|0.71115491|  PASSED
        dab_filltree|  32|  15000000|      1|0.51285566|  PASSED
Preparing to run test 208.  ntuple = 0
      dab_filltree2|  0|  5000000|      1|0.58756546|  PASSED
      dab_filltree2|  1|  5000000|      1|0.14924778|  PASSED
Preparing to run test 209.  ntuple = 0
        dab_monobit2|  12|  65000000|      1|0.26885641|  PASSED
Compilation finished successfully.

---

Well I'd say a rough 97% pass rate is good enough for a compiler at least, possibly for security apps too, they just need to take care to make work arounds for the final 3 (such as use internet service whenever possible)

That may mean that you could use this for normal simulations, but secure applications is a different story though: the issue of entropy remains. It is akin to the issue of having state that can be determined without exhausting the pseudorandom sequence for a PRNG, which is why even PRNGs that pass statistical tests with flying colours do not necessarily qualify as cryptographically secure PRNGs, although they certainly could see other uses.

Quote:

---

Originally Posted by laserlight

That may mean that you could use this for normal simulations, but secure applications is a different story though: the issue of entropy remains. It is akin to the issue of having state that can be determined without exhausting the pseudorandom sequence for a PRNG, which is why even PRNGs that pass statistical tests with flying colours do not necessarily qualify as cryptographically secure PRNGs, although they certainly could see other uses.

---

It can still be used in security software but for the simple reason of security it shouldn't ne used on its own so for example one could include multple RNGs and add their results together making it much harder to predict the final number used, to be honest I don't think even the online ones should be used on their own, its better to mix everything and increase the security of the final result

Quote:

---

Originally Posted by awsdert

the command I gave was

Code:

---

dieharder -a < ./mcc_rnd_die.elf

---

---

Is that command doing what you think it does? That command redirects the executable file itself to the standard input of the "dieharder" program. It doesn't execute ./mcc_rnd_die.elf.

If you know better then please, I'm all eyes :)

christop is right though. My guess is that's supposed to be:

Code:

---

./mcc_rnd_die.elf | dieharder -a

---

But I haven't read the relevant documentation so I could be wrong.

Quote:

---

Originally Posted by laserlight

christop is right though. My guess is that's supposed to be:

Code:

---

./mcc_rnd_die.elf | dieharder -a

---

But I haven't read the relevant documentation so I could be wrong.

---

From dieharder(1) - Linux man page

Code:

---

cat /dev/urandom | ./dieharder -a -g 200

---

Tim S.

A simple test for the code at post #7... Take a look at:

Code:

---

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
 
// Scale 'n' to 24 bits (0xBBGGRR).
#define rand2rgb(n) \
  ( ( int ) ( ( (n) * 16777215.0 ) / RAND_MAX ) )
 
int main ( void )
{
  int x, y, r;
 
  srand( time(NULL) );
 
  fputs( "P6\n1024 1024\n255\n", stdout );
 
  for ( y = 0; y < 1024; y++ )
    for ( x = 0; x < 1024; x++ )
    {
      r = rand2rgb(rand());
      fwrite( &r, 3, 1, stdout );  // assume little endian.
    }
}

---

This will create a graphic file where each pixel is scaled to 24 bits and used as RGB value in a 1024x1024 surface. It will result in a "noisy" surface like this:
Attachment 15949
Now, take a look at your routine in #7, mildly modified (my comments):

Code:

---

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <limits.h>
 
// Scale n to 24 bit value (0xBBGGRR).
// OBS: Uses long double because 'long' is 64 bits long in x86-64 systems.
#define rand2rgb(n) \
  ( ( int ) ( ( (n) * 16777215.0L ) / LONG_MAX ) )
 
// using size_t instead of ptrdiff_t (same thing)
typedef size_t mcc_rnd_t;
 
static long mcc_rnd ( mcc_rnd_t *seed, long min, long max );
 
int main ( void )
{
  int x, y;
  int r;
  long seed = 1;
 
  fputs ( "P3 1024 1024 255\n", stdout );
 
  for ( y = 0; y < 1024; y++ )
    for ( x = 0; x < 1024; x++ )
    {
      r = rand2rgb ( mcc_rnd ( &seed, 0, LONG_MAX ) );
      fwrite ( &r, 3, 1, stdout );
    }
}
 
long mcc_rnd ( mcc_rnd_t *seed, long min, long max )
{
  // Most of the time tmp will point to the SAME memory block
  // for every process. Notice that, probably, tmp is aligned,
  // meaning the lower bits aren't 'random' at all...
  // and the upper bits isn't random as well...
  void *tmp = malloc ( 1 );
 
  long val = time ( NULL ) + ( size_t ) tmp;
 
  free ( tmp );
 
  // This isn't 'random' seed. Taking the argument address means
  // it will be copied to the stack and the stack pointer isn't
  // that 'random'... The value on stack isn't that unpredictable
  // as you think!
  if ( ! seed )
    seed = ( mcc_rnd_t * ) ( &seed );
 
  // Well... this isn't random, again, isn't it?
  if ( ! *seed )
    *seed = 1;
 
  val %= *seed;
  val *= clock();
 
  // The seed, again, isn't random!
  *seed <<= 1;
 
  // Saturation get even less random values!
  return ( val > max ) ? max : ( val < min ? min : val );
}

---

This will create a graphic like this:
Attachment 15950
See the patterns? Not random at all!

Quote:

---

Originally Posted by flp1969

A simple test for the code at post #7... Take a look at:

Code:

---

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
 
// Scale 'n' to 24 bits (0xBBGGRR).
#define rand2rgb(n) \
  ( ( int ) ( ( (n) * 16777215.0 ) / RAND_MAX ) )
 
int main ( void )
{
  int x, y, r;
 
  srand( time(NULL) );
 
  fputs( "P6\n1024 1024\n255\n", stdout );
 
  for ( y = 0; y < 1024; y++ )
    for ( x = 0; x < 1024; x++ )
    {
      r = rand2rgb(rand());
      fwrite( &r, 3, 1, stdout );  // assume little endian.
    }
}

---

This will create a graphic file where each pixel is scaled to 24 bits and used as RGB value in a 1024x1024 surface. It will result in a "noisy" surface like this:
Attachment 15949
Now, take a look at your routine in #7, mildly modified (my comments):

Code:

---

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <limits.h>
 
// Scale n to 24 bit value (0xBBGGRR).
// OBS: Uses long double because 'long' is 64 bits long in x86-64 systems.
#define rand2rgb(n) \
  ( ( int ) ( ( (n) * 16777215.0L ) / LONG_MAX ) )
 
// using size_t instead of ptrdiff_t (same thing)
typedef size_t mcc_rnd_t;
 
static long mcc_rnd ( mcc_rnd_t *seed, long min, long max );
 
int main ( void )
{
  int x, y;
  int r;
  long seed = 1;
 
  fputs ( "P3 1024 1024 255\n", stdout );
 
  for ( y = 0; y < 1024; y++ )
    for ( x = 0; x < 1024; x++ )
    {
      r = rand2rgb ( mcc_rnd ( &seed, 0, LONG_MAX ) );
      fwrite ( &r, 3, 1, stdout );
    }
}
 
long mcc_rnd ( mcc_rnd_t *seed, long min, long max )
{
  // Most of the time tmp will point to the SAME memory block
  // for every process. Notice that, probably, tmp is aligned,
  // meaning the lower bits aren't 'random' at all...
  // and the upper bits isn't random as well...
  void *tmp = malloc ( 1 );
 
  long val = time ( NULL ) + ( size_t ) tmp;
 
  free ( tmp );
 
  // This isn't 'random' seed. Taking the argument address means
  // it will be copied to the stack and the stack pointer isn't
  // that 'random'... The value on stack isn't that unpredictable
  // as you think!
  if ( ! seed )
    seed = ( mcc_rnd_t * ) ( &seed );
 
  // Well... this isn't random, again, isn't it?
  if ( ! *seed )
    *seed = 1;
 
  val %= *seed;
  val *= clock();
 
  // The seed, again, isn't random!
  *seed <<= 1;
 
  // Saturation get even less random values!
  return ( val > max ) ? max : ( val < min ? min : val );
}

---

This will create a graphic like this:
Attachment 15950
See the patterns? Not random at all!

---

Have you tried the updated code instead of old code?

Quote:

---

Originally Posted by stahta01

From dieharder(1) - Linux man page

Code:

---

cat /dev/urandom | ./dieharder -a -g 200

---

Tim S.

---

Been reading the docs and seems to be fine with stdin but to satisfy your curiosity I'll try it when I get home

Quote:

---

Originally Posted by awsdert

Have you tried the updated code instead of old code?

---

This one?

Code:

---

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <limits.h>

// Scale n to 24 bit value (0xBBGGRR).
// OBS: Uses long double because 'long' is 64 bits long in x86-64 systems.
#define rand2rgb(n) \
  ( ( int ) ( ( (n) * 16777215.0L ) / ULONG_MAX ) )

// using size_t instead of ptrdiff_t (same thing)
typedef size_t mcc_rnd_t;

static unsigned long mcc__rnd( mcc_rnd_t *seed );

int main( void )
{
  int x, y;
  int r;
  long seed = 1;

  fputs( "P6\n1024 1024\n255\n", stdout );

  for ( y = 0; y < 1024; y++ )
    for ( x = 0; x < 1024; x++ )
    {
      r = rand2rgb( mcc__rnd( &seed ) );
      fwrite( &r, 3, 1, stdout );
    }
}

unsigned long mcc__rnd( mcc_rnd_t *seed )
{
  /* Initial random value */
  unsigned long val = ( unsigned long )( &seed ) * ( unsigned long )clock() * ( unsigned long )clock();

  if ( seed )
  {
    if ( *seed == 0 )
      *seed = 1;

    val %= *seed;
    *seed <<= 1;
  }

  return val;
}

---

it is worse:

Attachment 15951

Quote:

---

Originally Posted by flp1969

This one?

Code:

---

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <limits.h>

// Scale n to 24 bit value (0xBBGGRR).
// OBS: Uses long double because 'long' is 64 bits long in x86-64 systems.
#define rand2rgb(n) \
  ( ( int ) ( ( (n) * 16777215.0L ) / ULONG_MAX ) )

// using size_t instead of ptrdiff_t (same thing)
typedef size_t mcc_rnd_t;

static unsigned long mcc__rnd( mcc_rnd_t *seed );

int main( void )
{
  int x, y;
  int r;
  long seed = 1;

  fputs( "P6\n1024 1024\n255\n", stdout );

  for ( y = 0; y < 1024; y++ )
    for ( x = 0; x < 1024; x++ )
    {
      r = rand2rgb( mcc__rnd( &seed ) );
      fwrite( &r, 3, 1, stdout );
    }
}

unsigned long mcc__rnd( mcc_rnd_t *seed )
{
  /* Initial random value */
  unsigned long val = ( unsigned long )( &seed ) * ( unsigned long )clock() * ( unsigned long )clock();

  if ( seed )
  {
    if ( *seed == 0 )
      *seed = 1;

    val %= *seed;
    *seed <<= 1;
  }

  return val;
}

---

it is worse:

Attachment 15951

---

Try without the seed set, ie NULL, also how did you get your terminal to do that? I've tried but it doesn't do that

Well currently re-running dieharderwith this so far:

Code:

---

make --no-print-directory dieharder_rnd
gcc -ggdb -Wall -lpthread -DBUILD_FOR_DIEHARDER -o ./mcc_rnd_die.elf mcc_rnd.c
./mcc_rnd_die.elf > diehard.txt
dieharder -a -f diehard.txt -t 100 -Y 1
#=============================================================================#
#            dieharder version 3.31.1 Copyright 2003 Robert G. Brown          #
#=============================================================================#
  rng_name    |          filename            |rands/second|
        mt19937|                    diehard.txt|  8.32e+07  |
#=============================================================================#
        test_name  |ntup| tsamples |psamples|  p-value |Assessment
#=============================================================================#
  diehard_birthdays|  0|      100|    100|0.85295815|  PASSED
      diehard_operm5|  0|  1000000|    100|0.95085512|  PASSED
  diehard_rank_32x32|  0|    40000|    100|0.84994506|  PASSED
    diehard_rank_6x8|  0|    100000|    100|0.88766341|  PASSED
  diehard_bitstream|  0|  2097152|    100|0.56787971|  PASSED
        diehard_opso|  0|  2097152|    100|0.30634647|  PASSED
        diehard_oqso|  0|  2097152|    100|0.97180228|  PASSED
        diehard_dna|  0|  2097152|    100|0.24078918|  PASSED
diehard_count_1s_str|  0|    256000|    100|0.30519436|  PASSED
diehard_count_1s_byt|  0|    256000|    100|0.51351868|  PASSED
 diehard_parking_lot|  0|    12000|    100|0.89432206|  PASSED
    diehard_2dsphere|  2|      8000|    100|0.99812802|  WEAK
    diehard_2dsphere|  2|      8000|    200|0.96469714|  PASSED
    diehard_3dsphere|  3|      4000|    100|0.96650039|  PASSED
    diehard_squeeze|  0|    100000|    100|0.77568347|  PASSED
        diehard_sums|  0|      100|    100|0.00051839|  WEAK
        diehard_sums|  0|      100|    200|0.00400734|  WEAK
        diehard_sums|  0|      100|    300|0.00090761|  WEAK
        diehard_sums|  0|      100|    400|0.00006661|  WEAK
        diehard_sums|  0|      100|    500|0.00002646|  WEAK
        diehard_sums|  0|      100|    600|0.00000203|  WEAK
        diehard_sums|  0|      100|    700|0.00000045|  FAILED
        diehard_runs|  0|    100000|    100|0.99080465|  PASSED
        diehard_runs|  0|    100000|    100|0.86282952|  PASSED
      diehard_craps|  0|    200000|    100|0.80909198|  PASSED
      diehard_craps|  0|    200000|    100|0.25693590|  PASSED
 marsaglia_tsang_gcd|  0|  10000000|    100|0.18319920|  PASSED
 marsaglia_tsang_gcd|  0|  10000000|    100|0.77544038|  PASSED
        sts_monobit|  1|    100000|    100|0.27733181|  PASSED
            sts_runs|  2|    100000|    100|0.81845021|  PASSED
          sts_serial|  1|    100000|    100|0.46403118|  PASSED
          sts_serial|  2|    100000|    100|0.11862501|  PASSED
          sts_serial|  3|    100000|    100|0.42804125|  PASSED
          sts_serial|  3|    100000|    100|0.96526517|  PASSED
          sts_serial|  4|    100000|    100|0.32388866|  PASSED
          sts_serial|  4|    100000|    100|0.14881751|  PASSED
          sts_serial|  5|    100000|    100|0.69732895|  PASSED
          sts_serial|  5|    100000|    100|0.74439824|  PASSED
          sts_serial|  6|    100000|    100|0.44819093|  PASSED
          sts_serial|  6|    100000|    100|0.27052991|  PASSED
          sts_serial|  7|    100000|    100|0.68303103|  PASSED
          sts_serial|  7|    100000|    100|0.98073079|  PASSED
          sts_serial|  8|    100000|    100|0.05490760|  PASSED
          sts_serial|  8|    100000|    100|0.46844079|  PASSED
          sts_serial|  9|    100000|    100|0.94170852|  PASSED
          sts_serial|  9|    100000|    100|0.37246207|  PASSED
          sts_serial|  10|    100000|    100|0.78708430|  PASSED
          sts_serial|  10|    100000|    100|0.43940563|  PASSED
          sts_serial|  11|    100000|    100|0.95682412|  PASSED
          sts_serial|  11|    100000|    100|0.91341183|  PASSED
          sts_serial|  12|    100000|    100|0.94059147|  PASSED
          sts_serial|  12|    100000|    100|0.91720462|  PASSED
          sts_serial|  13|    100000|    100|0.29977341|  PASSED
          sts_serial|  13|    100000|    100|0.80663660|  PASSED
          sts_serial|  14|    100000|    100|0.65174466|  PASSED
          sts_serial|  14|    100000|    100|0.10931696|  PASSED
          sts_serial|  15|    100000|    100|0.31703586|  PASSED
          sts_serial|  15|    100000|    100|0.03218640|  PASSED
          sts_serial|  16|    100000|    100|0.01650420|  PASSED
          sts_serial|  16|    100000|    100|0.21720490|  PASSED
        rgb_bitdist|  1|    100000|    100|0.96762642|  PASSED
        rgb_bitdist|  2|    100000|    100|0.52038768|  PASSED
        rgb_bitdist|  3|    100000|    100|0.75233658|  PASSED
        rgb_bitdist|  4|    100000|    100|0.37138772|  PASSED
        rgb_bitdist|  5|    100000|    100|0.88690941|  PASSED
        rgb_bitdist|  6|    100000|    100|0.64131006|  PASSED

---

I'm cancelling at this point and trying something in addition

I just noticed this part of your dieharder output (from 10 hours ago):

Code:

---

  rng_name    |rands/second|  Seed  |
        mt19937|  7.47e+07  |2183355501|

---

It looks like dieharder is using the "mt19937" RNG by default (the man page for dieharder confirms this). That is the "Mersenne Twister" using 19937 bits of state. This is a pretty good RNG, as you can see from dieharder's analysis.

Edit to add: you need to call dieharder with the "-g 200" option to make it read your "random" data on standard input.

Quote:

---

Originally Posted by awsdert

Been reading the docs and seems to be fine with stdin but to satisfy your curiosity I'll try it when I get home

---

stahta01's manual extract confirms my example, except that you might want to look at whether the other options are relevant. The pipe does use stdin: recall that it pipes the output of your program (to stdout) as input to the other program (as stdin). If you really did run those tests with input redirection instead of piping though, then it would seem that this utility ran statistical tests on an executable program rather than the output of said program... I'd have thought that the content of an executable wouldn't be statistically random enough, but oh well.

EDIT:

Quote:

---

Originally Posted by christop

It looks like dieharder is using the "mt19937" RNG by default (the man page for dieharder confirms this). That is the "Mersenne Twister" using 19937 bits of state. This is a pretty good RNG, as you can see from dieharder's analysis.

---

So the utility just discarded what was fed to it via standard input?

Well the change at least caused a pass on some previously failed tests

Code:

---

make --no-print-directory dieharder_rnd
gcc -ggdb -Wall -lpthread -DBUILD_FOR_DIEHARDER -o ./mcc_rnd_die.elf mcc_rnd.c
./mcc_rnd_die.elf > diehard.txt
dieharder -a -f diehard.txt -t 100 -Y 1
#=============================================================================#
#            dieharder version 3.31.1 Copyright 2003 Robert G. Brown          #
#=============================================================================#
  rng_name    |          filename            |rands/second|
        mt19937|                    diehard.txt|  7.96e+07  |
#=============================================================================#
        test_name  |ntup| tsamples |psamples|  p-value |Assessment
#=============================================================================#
  diehard_birthdays|  0|      100|    100|0.92161723|  PASSED
      diehard_operm5|  0|  1000000|    100|0.95034250|  PASSED
  diehard_rank_32x32|  0|    40000|    100|0.04762000|  PASSED
    diehard_rank_6x8|  0|    100000|    100|0.98629424|  PASSED
  diehard_bitstream|  0|  2097152|    100|0.68113481|  PASSED
        diehard_opso|  0|  2097152|    100|0.82427499|  PASSED
        diehard_oqso|  0|  2097152|    100|0.73382595|  PASSED
        diehard_dna|  0|  2097152|    100|0.80381661|  PASSED
diehard_count_1s_str|  0|    256000|    100|0.88826073|  PASSED
diehard_count_1s_byt|  0|    256000|    100|0.69131699|  PASSED
 diehard_parking_lot|  0|    12000|    100|0.42137346|  PASSED
    diehard_2dsphere|  2|      8000|    100|0.78353142|  PASSED
    diehard_3dsphere|  3|      4000|    100|0.83751604|  PASSED
    diehard_squeeze|  0|    100000|    100|0.97324599|  PASSED
        diehard_sums|  0|      100|    100|0.03890804|  PASSED
        diehard_runs|  0|    100000|    100|0.37897033|  PASSED
        diehard_runs|  0|    100000|    100|0.28134077|  PASSED
      diehard_craps|  0|    200000|    100|0.98255307|  PASSED
      diehard_craps|  0|    200000|    100|0.19981783|  PASSED
 marsaglia_tsang_gcd|  0|  10000000|    100|0.52946603|  PASSED
 marsaglia_tsang_gcd|  0|  10000000|    100|0.11235286|  PASSED
        sts_monobit|  1|    100000|    100|0.94853669|  PASSED
            sts_runs|  2|    100000|    100|0.98915854|  PASSED
          sts_serial|  1|    100000|    100|0.53037634|  PASSED
          sts_serial|  2|    100000|    100|0.99259101|  PASSED
          sts_serial|  3|    100000|    100|0.69499416|  PASSED
          sts_serial|  3|    100000|    100|0.25469722|  PASSED
          sts_serial|  4|    100000|    100|0.31794760|  PASSED
          sts_serial|  4|    100000|    100|0.65630293|  PASSED
          sts_serial|  5|    100000|    100|0.10030703|  PASSED
          sts_serial|  5|    100000|    100|0.33876643|  PASSED
          sts_serial|  6|    100000|    100|0.11512964|  PASSED
          sts_serial|  6|    100000|    100|0.92113071|  PASSED
          sts_serial|  7|    100000|    100|0.35443944|  PASSED
          sts_serial|  7|    100000|    100|0.73691352|  PASSED
          sts_serial|  8|    100000|    100|0.80353276|  PASSED
          sts_serial|  8|    100000|    100|0.86551832|  PASSED
          sts_serial|  9|    100000|    100|0.93505112|  PASSED
          sts_serial|  9|    100000|    100|0.98897060|  PASSED
          sts_serial|  10|    100000|    100|0.84157456|  PASSED
          sts_serial|  10|    100000|    100|0.89642801|  PASSED
          sts_serial|  11|    100000|    100|0.94733618|  PASSED
          sts_serial|  11|    100000|    100|0.88809914|  PASSED
          sts_serial|  12|    100000|    100|0.62251654|  PASSED
          sts_serial|  12|    100000|    100|0.74017302|  PASSED
          sts_serial|  13|    100000|    100|0.61114068|  PASSED
          sts_serial|  13|    100000|    100|0.70827034|  PASSED
          sts_serial|  14|    100000|    100|0.99409109|  PASSED
          sts_serial|  14|    100000|    100|0.86867344|  PASSED
          sts_serial|  15|    100000|    100|0.87824157|  PASSED
          sts_serial|  15|    100000|    100|0.60437611|  PASSED
          sts_serial|  16|    100000|    100|0.65594647|  PASSED
          sts_serial|  16|    100000|    100|0.91562830|  PASSED
        rgb_bitdist|  1|    100000|    100|0.30958867|  PASSED
        rgb_bitdist|  2|    100000|    100|0.63426304|  PASSED
        rgb_bitdist|  3|    100000|    100|0.14087628|  PASSED
        rgb_bitdist|  4|    100000|    100|0.07156920|  PASSED
        rgb_bitdist|  5|    100000|    100|0.13166009|  PASSED
        rgb_bitdist|  6|    100000|    100|0.10396914|  PASSED
        rgb_bitdist|  7|    100000|    100|0.85533507|  PASSED
        rgb_bitdist|  8|    100000|    100|0.76165246|  PASSED
        rgb_bitdist|  9|    100000|    100|0.90668495|  PASSED
        rgb_bitdist|  10|    100000|    100|0.81370263|  PASSED
        rgb_bitdist|  11|    100000|    100|0.56225235|  PASSED
        rgb_bitdist|  12|    100000|    100|0.62578504|  PASSED
rgb_minimum_distance|  2|    10000|    1000|0.14524290|  PASSED
rgb_minimum_distance|  3|    10000|    1000|0.71798653|  PASSED
rgb_minimum_distance|  4|    10000|    1000|0.62044967|  PASSED
rgb_minimum_distance|  5|    10000|    1000|0.92519925|  PASSED
    rgb_permutations|  2|    100000|    100|0.80781758|  PASSED
    rgb_permutations|  3|    100000|    100|0.22465441|  PASSED
    rgb_permutations|  4|    100000|    100|0.06486625|  PASSED
    rgb_permutations|  5|    100000|    100|0.88229895|  PASSED
      rgb_lagged_sum|  0|  1000000|    100|0.29016285|  PASSED
      rgb_lagged_sum|  1|  1000000|    100|0.44218168|  PASSED
      rgb_lagged_sum|  2|  1000000|    100|0.87158911|  PASSED
      rgb_lagged_sum|  3|  1000000|    100|0.40383383|  PASSED
      rgb_lagged_sum|  4|  1000000|    100|0.20346561|  PASSED
      rgb_lagged_sum|  5|  1000000|    100|0.06987294|  PASSED
      rgb_lagged_sum|  6|  1000000|    100|0.96547707|  PASSED
      rgb_lagged_sum|  7|  1000000|    100|0.65228771|  PASSED
      rgb_lagged_sum|  8|  1000000|    100|0.49786721|  PASSED
      rgb_lagged_sum|  9|  1000000|    100|0.03422759|  PASSED
      rgb_lagged_sum|  10|  1000000|    100|0.34623429|  PASSED
      rgb_lagged_sum|  11|  1000000|    100|0.34719122|  PASSED
      rgb_lagged_sum|  12|  1000000|    100|0.37062504|  PASSED
      rgb_lagged_sum|  13|  1000000|    100|0.74491138|  PASSED
      rgb_lagged_sum|  14|  1000000|    100|0.88931778|  PASSED
      rgb_lagged_sum|  15|  1000000|    100|0.13501736|  PASSED
      rgb_lagged_sum|  16|  1000000|    100|0.06369016|  PASSED
      rgb_lagged_sum|  17|  1000000|    100|0.88156651|  PASSED
      rgb_lagged_sum|  18|  1000000|    100|0.51469867|  PASSED
      rgb_lagged_sum|  19|  1000000|    100|0.16741199|  PASSED
      rgb_lagged_sum|  20|  1000000|    100|0.42849592|  PASSED
      rgb_lagged_sum|  21|  1000000|    100|0.40387072|  PASSED
      rgb_lagged_sum|  22|  1000000|    100|0.25274004|  PASSED
      rgb_lagged_sum|  23|  1000000|    100|0.28240284|  PASSED
      rgb_lagged_sum|  24|  1000000|    100|0.66642375|  PASSED
      rgb_lagged_sum|  25|  1000000|    100|0.83348324|  PASSED
      rgb_lagged_sum|  26|  1000000|    100|0.39567244|  PASSED
      rgb_lagged_sum|  27|  1000000|    100|0.98195499|  PASSED
      rgb_lagged_sum|  28|  1000000|    100|0.04585665|  PASSED
      rgb_lagged_sum|  29|  1000000|    100|0.98016458|  PASSED
      rgb_lagged_sum|  30|  1000000|    100|0.99756248|  WEAK
      rgb_lagged_sum|  30|  1000000|    200|0.97082170|  PASSED
      rgb_lagged_sum|  31|  1000000|    100|0.61949755|  PASSED
      rgb_lagged_sum|  32|  1000000|    100|0.72894547|  PASSED
    rgb_kstest_test|  0|    10000|    1000|0.09472064|  PASSED
    dab_bytedistrib|  0|  51200000|      1|0.27907397|  PASSED
            dab_dct| 256|    50000|      1|0.64134898|  PASSED
Preparing to run test 207.  ntuple = 0
        dab_filltree|  32|  15000000|      1|0.97399778|  PASSED
        dab_filltree|  32|  15000000|      1|0.95593012|  PASSED
Preparing to run test 208.  ntuple = 0
      dab_filltree2|  0|  5000000|      1|0.01867152|  PASSED
      dab_filltree2|  1|  5000000|      1|0.23876266|  PASSED
Preparing to run test 209.  ntuple = 0
        dab_monobit2|  12|  65000000|      1|0.35946069|  PASSED
Compilation finished successfully.

---

Still running, for reference the change I made is this:

Code:

---

return val;

---

to this:

Code:

---

return val >> (val % (sizeof(long) * CHAR_BIT));

---

in the ulong version

Quote:

---

Originally Posted by christop

I just noticed this part of your dieharder output (from 10 hours ago):

Code:

---

  rng_name    |rands/second|  Seed  |
        mt19937|  7.47e+07  |2183355501|

---

It looks like dieharder is using the "mt19937" RNG by default (the man page for dieharder confirms this). That is the "Mersenne Twister" using 19937 bits of state. This is a pretty good RNG, as you can see from dieharder's analysis.

Edit to add: you need to call dieharder with the "-g 200" option to make it read your "random" data on standard input.

---

Oh okay thx, might as well stick with file for now since it is currently running

Quote:

---

Originally Posted by laserlight

So the utility just discarded what was fed to it via standard input?

---

It appears so.

In any case, the manual gives a clear example of the simplest way to test a random-number generator:

Quote:

---

The simplest way to use dieharder with an external generator that produces raw binary (presumed random) bits is to pipe the raw binary output from this generator (presumed to be a binary stream of 32 bit unsigned integers) directly into dieharder, e.g.:

cat /dev/urandom | ./dieharder -a -g 200

---

(Just replace "cat /dev/urandom" with "./mcc_rnd_die.elf", and make sure the program produces binary output.)

Quote:

---

Originally Posted by christop

In any case, the manual gives a clear example of the simplest way to test a random-number generator:

---

... that produces binary output, or we could say a (pseudo-) random bit generator. Using text input instead may invalidate the results, so more changes to awsdert's program would be needed

EDIT:

Quote:

---

Originally Posted by awsdert

Oh okay thx, might as well stick with file for now since it is currently running

---

If we're interpreting the output correctly, then the test output still states that your RNG output isn't being used. Yet the input filenane is listed, so maybe your RNG output is being used, but somehow in combination with the default PRNG, so the test results still don't show how statistically random your RNG is by itself.

Here's the code I'm testing. I modified flp1969's code just slightly to produce binary output.

Code:

---

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <limits.h>

// using size_t instead of ptrdiff_t (same thing)
typedef size_t mcc_rnd_t;

static unsigned long mcc__rnd( mcc_rnd_t *seed );

int main( void )
{
  long seed = 1;

  for (;;)
    {
      unsigned long x = mcc__rnd( &seed );
      fwrite( &x, 4, 1, stdout );
    }
}

unsigned long mcc__rnd( mcc_rnd_t *seed )
{
  /* Initial random value */
  unsigned long val = ( unsigned long )( &seed ) * ( unsigned long )clock() * ( unsigned long )clock();

  if ( seed )
  {
    if ( *seed == 0 )
      *seed = 1;

    val %= *seed;
    *seed <<= 1;
  }

  return val;
}

---

And here's dieharder's output so far (called with ./178596 | dieharder -a -g 200):

Code:

---

#=============================================================================#
#            dieharder version 3.31.1 Copyright 2003 Robert G. Brown          #
#=============================================================================#
  rng_name    |rands/second|  Seed  |
stdin_input_raw|  1.47e+06  |2985300269|
#=============================================================================#
        test_name  |ntup| tsamples |psamples|  p-value |Assessment
#=============================================================================#
  diehard_birthdays|  0|      100|    100|0.00000000|  FAILED
      diehard_operm5|  0|  1000000|    100|0.00000000|  FAILED
  diehard_rank_32x32|  0|    40000|    100|0.00000000|  FAILED
    diehard_rank_6x8|  0|    100000|    100|0.00000000|  FAILED
  diehard_bitstream|  0|  2097152|    100|0.00000000|  FAILED

---

It's not looking very promising.

Quote:

---

Originally Posted by laserlight

... that produces binary output, or we could say a (pseudo-) random bit generator. Using text input instead may invalidate the results, so more changes to awsdert's program would be needed

EDIT:

If we're interpreting the output correctly, then the test output still states that your RNG output isn't being used. Yet the input filenane is listed, so maybe your RNG output is being used, but somehow in combination with the default PRNG, so the test results still don't show how statistically random your RNG is by itself.

---

Hmm then I'll do a bit of reading and come back to this after and try the binary output method

Quote:

---

Originally Posted by christop

It appears so.

In any case, the manual gives a clear example of the simplest way to test a random-number generator:



(Just replace "cat /dev/urandom" with "./mcc_rnd_die.elf", and make sure the program produces binary output.)

---

Okay tried that, got this:

Code:

---

make --no-print-directory dieharder_rnd
gcc -ggdb -Wall -lpthread -DBUILD_FOR_DIEHARDER -o ./mcc_rnd_die.elf mcc_rnd.c
./mcc_rnd_die.elf | dieharder -a -g 200
# stdin_input_raw(): Error: EOF
Compilation finished successfully.

---

on this code:

Code:

---

#ifdef BUILD_FOR_DIEHARDER
#define PER_LOOP 200
int main() {
        ulong val;
        for ( int i = 0 ; i < PER_LOOP; i++ ) {
                val = mcc___rnd( NULL );
                fwrite( &val, 4, 1, stdout );
        }
        return 0;
}
#elif

---

Can you tell me waht I'm doing wrong?

Make it an infinite loop. Dieharder will read as much data as it wants (which is A LOT, or so I've read).

Quote:

---

Originally Posted by christop

Make it an infinite loop. Dieharder will read as much data as it wants (which is A LOT, or so I've read).

---

Okay that seems to be working but its going abysmally slow

Edit: Gonna hop in bath then go to bed and try again 2mw since I'll have some time then

Quote:

---

Originally Posted by awsdert

Try without the seed set, ie NULL, also how did you get your terminal to do that? I've tried but it doesn't do that

---

Better, but worse then LCG (rand()) - you can see "continuous" small blocks at the same color in the final picture...

Code:

---

$ gcc -O2 -o random random.c
$ ./random > pic.ppm
$ eog pic.ppm

---

Here I converted the pic.ppm file to png with ImageMagick and reduced the resolution:

Code:

---

$ convert pic.ppm -resize 256x256 pic.png

---

This forum don't accept 1024x1024 pictures (file too long) or ppm format.

Why are you trying to create a PRNG from scratch? Usually it is difficult to do it right.
Here's a code I use in a project because I don't like LCG (due to the less random nature of lower bits):

Code:

---

#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdint.h>

#define _INIT __atrubute__((constructor))

// defined elsewhere...
extern void fatal_error( char *, ... );

/* The Random SEED will be created by SRANDOM */
// FIXME: Ok, this code isn't thread safe!
static uint64_t _seed[2];

/* xorshift128+

  We don't have to worry about the lower bits
  been less random than the upper, in theory.

  I only need 32 bits random values...
*/
static uint32_t random_xorshift128plus ( void )
{
  uint64_t s0 = _seed[1];
  uint64_t s1 = _seed[0];
  _seed[0] = s0;

  s1 ^= s1 << 23;
  _seed[1] = s1 ^ s0 ^ ( s1 >> 18 ) ^ ( s0 >> 5 );

  return ( _seed[1] + s0 );
}

// NOTE: Intel specific!
#if defined(__i386) || defined(__x86_64)
static uint32_t random_rdrand ( void )
{
  uint32_t r;

  // FIXME: Should try 10 times and call fatal_error() in case of failure,
  //    but this way is faster and I never knwe of RDRAND to fail.
  __asm__ __volatile__ (
    "1: rdrand %0\n"
    "  jnc 1b"
    : "=a" ( r )
  );

  return r;
}
#endif

static void empty_srandom ( void ) {}

static void get_random_seed ( void )
{
  // NOTE: Could use gettimeofday() and use it as seed,
  //      but, this way I'll make sure the seed is random.

  int _fd, r;
  void *p, *endp;

  if ( ( _fd = open ( "/dev/urandom", O_RDONLY ) ) == -1 )
    fatal_error ( "Cannot open /dev/urandom to get initial random seed." );

  /* NOTE: initializes this code "global" _seed var. */
  p = &_seed;
  endp = p + sizeof _seed;

  while ( p < endp )
  {
    if ( ( r = read ( _fd, p, endp - p ) ) == -1 )
      break;

    p += r;
  }

  close ( _fd );

  if ( r == -1 )
    fatal_error ( "Cannot read initial seed from /dev/urandom." );
}

/* The "constructor" below will overide this IF the platform is Intel/AMD and
  if RDRAND is supported. */
void ( *SRANDOM ) ( void ) = get_random_seed;
uint32_t ( *RANDOM ) ( void ) = random_xorshift128plus;

// Intel architecture dependend constructor.
#if defined(__i386) || defined(__x86_64)
#define RDRAND_BIT (1U << 30)

//--- Make sure to use RDRAND instruction if the processor has it.
static void _INIT check_rdrand ( void )
{
  int c;

  __asm__ __volatile__ ( "cpuid" : "=c" ( c ) : "a" ( 1 ) :
#ifdef __i386
                        "ebx", "edx"
#else /* x86_64 */
                        "rbx", "rdx"
#endif
                      );

  if ( c & RDRAND_BIT )
  {
    RANDOM = random_rdrand;
    SRANDOM = empty_srandom;  // RDRAND doesn't need a seed.
  }
}
#endif

---

Now, SRANDOM() and RANDOM() are used. SRANDOM() to initialize the seed and RANDOM() to get the random values.

Quote:

---

Originally Posted by flp1969

Why are you trying to create a PRNG from scratch? Usually it is difficult to do it right.
Here's a code I use in a project because I don't like LCG (due to the less random nature of lower bits):

Code:

---

#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdint.h>

#define _INIT __atrubute__((constructor))

// defined elsewhere...
extern void fatal_error( char *, ... );

/* The Random SEED will be created by SRANDOM */
// FIXME: Ok, this code isn't thread safe!
static uint64_t _seed[2];

/* xorshift128+

  We don't have to worry about the lower bits
  been less random than the upper, in theory.

  I only need 32 bits random values...
*/
static uint32_t random_xorshift128plus ( void )
{
  uint64_t s0 = _seed[1];
  uint64_t s1 = _seed[0];
  _seed[0] = s0;

  s1 ^= s1 << 23;
  _seed[1] = s1 ^ s0 ^ ( s1 >> 18 ) ^ ( s0 >> 5 );

  return ( _seed[1] + s0 );
}

// NOTE: Intel specific!
#if defined(__i386) || defined(__x86_64)
static uint32_t random_rdrand ( void )
{
  uint32_t r;

  // FIXME: Should try 10 times and call fatal_error() in case of failure,
  //    but this way is faster and I never knwe of RDRAND to fail.
  __asm__ __volatile__ (
    "1: rdrand %0\n"
    "  jnc 1b"
    : "=a" ( r )
  );

  return r;
}
#endif

static void empty_srandom ( void ) {}

static void get_random_seed ( void )
{
  // NOTE: Could use gettimeofday() and use it as seed,
  //      but, this way I'll make sure the seed is random.

  int _fd, r;
  void *p, *endp;

  if ( ( _fd = open ( "/dev/urandom", O_RDONLY ) ) == -1 )
    fatal_error ( "Cannot open /dev/urandom to get initial random seed." );

  /* NOTE: initializes this code "global" _seed var. */
  p = &_seed;
  endp = p + sizeof _seed;

  while ( p < endp )
  {
    if ( ( r = read ( _fd, p, endp - p ) ) == -1 )
      break;

    p += r;
  }

  close ( _fd );

  if ( r == -1 )
    fatal_error ( "Cannot read initial seed from /dev/urandom." );
}

/* The "constructor" below will overide this IF the platform is Intel/AMD and
  if RDRAND is supported. */
void ( *SRANDOM ) ( void ) = get_random_seed;
uint32_t ( *RANDOM ) ( void ) = random_xorshift128plus;

// Intel architecture dependend constructor.
#if defined(__i386) || defined(__x86_64)
#define RDRAND_BIT (1U << 30)

//--- Make sure to use RDRAND instruction if the processor has it.
static void _INIT check_rdrand ( void )
{
  int c;

  __asm__ __volatile__ ( "cpuid" : "=c" ( c ) : "a" ( 1 ) :
#ifdef __i386
                        "ebx", "edx"
#else /* x86_64 */
                        "rbx", "rdx"
#endif
                      );

  if ( c & RDRAND_BIT )
  {
    RANDOM = random_rdrand;
    SRANDOM = empty_srandom;  // RDRAND doesn't need a seed.
  }
}
#endif

---

Now, SRANDOM() and RANDOM() are used. SRANDOM() to initialize the seed and RANDOM() to get the random values.

---

I'm trying to do so because my hobby project mitsy (for the unaware it is my attempt at creating a compiler, end goal is to be portable) is under MIT License and I do not want any code that uses a different license there, I also want it to be thread safe to
avoid issues that I've read about in musl (which now that I think about it could have an implementation I could use, I'll look into that in a minute), also it is going to provide fallback functions for every standard function defined by the relative standards not just in user land but also kernel land, I've so far managed something for the limits file which was something I had been struggling with in a lot of previous hobby projects. Btw any of my code you see with mcc prepended to the front is code that I plan to utilize in mitsy

Er this is giving me errors, gonna copy past a bit from musl and make more back end compatible while I wait on a response:

Code:

---

/* Credit to flp1969 for this,
https://cboard.cprogramming.com/c-programming/178596-seeded-seedless-random-number.html
*/
ulong mcc_x86_rnd() {
#if defined(__i386) || defined(__x86_64)
        ulong val;
        __asm__ __volatile__ (
                "1: rdrand %0\n"
                "  jnc 1b"
                : "=a" ( val )
        );
        return val;
#endif
}

---

Well now I'm trying this:

Code:

---

unsigned musl_temper(unsigned x)
{
        x ^= x>>11;
        x ^= x<<7 & 0x9D2C5680;
        x ^= x<<15 & 0xEFC60000;
        x ^= x>>18;
        return x;
}

#define musl_rand_r(seed) \
        (musl_temper((seed) = (seed) * 1103515245 + 12345)/2)

#define musl_srand(seed,s) ((seed) = (s) - 1)
#define musl_rand(seed) \
        (((seed) = 6364136223846793005ULL*(seed) + 1) \
        >> (((sizeof(seed) / 2) * CHAR_BIT)+1))

/* Credit to flp1969 for this,
https://cboard.cprogramming.com/c-programming/178596-seeded-seedless-random-number.html
*/
uint_least64_t mcc_x86_rnd() {
        uint_least64_t val;
#if 1
        struct timeval was;
        gettimeofday(&was,NULL);
        val = was.tv_usec * (clock() * clock());
#elif defined(__i386) || defined(__x86_64)
        __asm__ __volatile__ (
                "1: rdrand %0\n"
                "  jnc 1b"
                : "=a" ( val )
        );
#endif
        return val;
}
ulong mcc___rnd( mcc_rnd_t *seed ) {
        /* Initial random value */
        ulong _seed = mcc_x86_rnd(), val;
        val = musl_rand_r(_seed);
        return musl_rand(val);
}

---

1st 2 have passed, still waiting on rest

Quote:

---

Originally Posted by flp1969

Better, but worse then LCG (rand()) - you can see "continuous" small blocks at the same color in the final picture...

Code:

---

$ gcc -O2 -o random random.c
$ ./random > pic.ppm
$ eog pic.ppm

---

Here I converted the pic.ppm file to png with ImageMagick and reduced the resolution:

Code:

---

$ convert pic.ppm -resize 256x256 pic.png

---

This forum don't accept 1024x1024 pictures (file too long) or ppm format.

---

Thanks, finally got round to trying it as I was tired of trying to pass the failed/weak results of some of the tests, was taking too long so I tried this which is faster but eog reports an incorrect byte initial byte:

Code:

---

gcc -ggdb -Wall -lpthread -DDRAW_NOISE -o ./mcc_rnd_noisy.elf mcc_rnd.c
./mcc_rnd_noisy.elf > pic.ppm
eog pic.ppm
Compilation finished successfully.

---

Did I do something wrong here?

Code:

---

#elif defined( DRAW_NOISE )
#define PER_LOOP 1024
#define rand2rgb(n) \
  ( ( int ) ( ( (n) * 16777215.0L ) / ULONG_MAX ) )
int main() {
        int x, y;
        uint val;
        for ( x = 0; x < PER_LOOP; ++x ) {
                for ( y = 0; y < PER_LOOP; ++y ) {
                        val = rand2rgb(mcc___rnd( NULL ));
                        fwrite( &val, 3, 1, stdout );
                }
        }
        return 0;
}
#else

---

Post #43: You need to verify if your processor supports RDRAND. That's why I did use that "constructor" attribute extension to GCC to check through CPUID.

PPM (binary) Graphics format:

P6
width height
max-value-per-component
<binary data> (RR GG BB RR GG BB ...)

The first 3 lines are strings

Example:

P6
1024 1024
255
FF FF FF 80 23 4D ... (binary)

You must have 1024*1024 bytes in binary to match the width and height.

You can change P6 to P3 and write RR GG BB in decimal string:

P3
1024 1024
255
255 255 255
128 34 77
... (strings)

See netpbm format

Quote:

---

Originally Posted by flp1969

PPM (binary) Graphics format:

P6
width height
max-value-per-component
<binary data> (RR GG BB RR GG BB ...)

The first 3 lines are strings

Example:

P6
1024 1024
255
FF FF FF 80 23 4D ... (binary)

You must have 1024*1024 bytes in binary to match the width and height.

You can change P6 to P3 and write RR GG BB in decimal string:

P3
1024 1024
255
255 255 255
128 34 77
... (strings)

See [utl=https://en.wikipedia.org/wiki/Netpbm_format]netpbm format[/url]

---

thank you that worked :)
Used this:

Code:

---

uint mcc___rnd( uint *seed ) {
        /* Initial random value */
        uint _seed;
        char tseed[10] = "946853721";
        struct timespec ts;
        clock_gettime(CLOCK_REALTIME,&ts);
        _seed = ((ulong)&_seed + ts.tv_nsec + (ts.tv_nsec << 1)) *
                tseed[ts.tv_nsec%10];
        if ( !seed ) seed = &_seed;
        return _seed + (tseed[*seed%10] * tseed[_seed%10] * _seed);
}

---

Gave me noisy result (with some slight tears) despite it failing the dieharder tests

Code:

---

#ifdef HARDY_RND
int main() {
        uint val;
        while ( 1 ) {
                val = mcc___rnd( NULL );
                fwrite( &val, 4, 1, stdout );
        }
        return 0;
}
#elif defined( NOISY_RND )
#define PER_LOOP 1024
long double rand2rgb( uint n ) {
        long double f = n;
        return (f * 16777215.0L);
}
int main() {
        int x, y;
        uint val;
        char *header = "P6\n1024 1024\n255\n";
        fwrite(header,strlen(header),1,stdout);
        for ( x = 0; x < PER_LOOP; ++x ) {
                for ( y = 0; y < PER_LOOP; ++y ) {
                        val = mcc___rnd( NULL );
                        fwrite( &val, 4, 1, stdout );
                }
        }
        return 0;
}
#else

---

Gotts leave for work now so don't have time to look through posts for how to downsize image for uploading

Quote:

---

Originally Posted by awsdert

I'm trying to do so because my hobby project mitsy (for the unaware it is my attempt at creating a compiler, end goal is to be portable) is under MIT License and I do not want any code that uses a different license there

---

The rand() function is ISO 9989 standard, not subject to any licensing (maybe ISO/IEC)... And, as far as I know, xorshift128+ isn't subject to licensing as well...

Quote:

---

Originally Posted by awsdert

, I also want it to be thread safe to avoid issues that I've read about in musl (which now that I think about it could have an implementation I could use, I'll look into that in a minute)

---

If you want to avoid licensing, using MUSL it's not going to help you... :) For thread safety, there is rand_r(), where you pass the seed to the function:

Code:

---

int rand_r( unsigned int *seedp);

---

Quote:

---

Originally Posted by awsdert

also it is going to provide fallback functions for every standard function defined by the relative standards not just in user land but also kernel land

---

Ahhhh... then you have a freestading (not hosted) project (kernel).... ok, it is a good idea to provide low level functions yourself. But, seems to me, yours are too much complex for a kernel... I would stick to LCG/xorshift128+ and/or RDRAND because they are fast and small.

[]s
Fred

Ahhh... BTW... if your processor uses Big Endian, I think it must be wise to do something like this. PPM format expects RR GG BB in that order:

Code:

---

...
int t;
val = t = rand2rgb( func() );

#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
t = __builtin_bswap32( t );
#endif

fwrite( &t, 3, 1, stdout );
...

---

Quote:

---

Originally Posted by flp1969

Ahhh... BTW... if your processor uses Big Endian, I think it must be wise to do something like this. PPM format expects RR GG BB in that order:

Code:

---

...
int t;
val = t = rand2rgb( func() );

#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
t = __builtin_bswap32( t );
#endif

fwrite( &t, 3, 1, stdout );
...

---

---

nah my cpu is little endian, I think it was an AMD FX Quad Core, old but still doing the job, thinking about investing in an AMD Zen bundle after replacing my washing machine which is surely on its way out

Quote:

---

Originally Posted by awsdert

nah my cpu is little endian, I think it was an AMD FX Quad Core, old but still doing the job, thinking about investing in an AMD Zen bundle after replacing my washing machine which is surely on its way out

---

One more reason to check if your processor supports RDRAND (AMD FX, maybe not!)... I recomend you do the same I did before: Declare 2 pointers to functions and initialize them after calling an "init" funcion (don't need to have the 'constructor' attribute)...

Quote:

---

Originally Posted by flp1969

One more reason to check if your processor supports RDRAND (AMD FX, maybe not!)... I recomend you do the same I did before: Declare 2 pointers to functions and initialize them after calling an "init" funcion (don't need to have the 'constructor' attribute)...

---

Yeah I removed that for now, better a slow but working version than a fast but hit and miss version, I'll try that when I can look at the macros and instructions properly on monday

Quote:

---

Originally Posted by awsdert

Yeah I removed that for now, better a slow but working version than a fast but hit and miss version, I'll try that when I can look at the macros and instructions properly on monday

---

Why "miss"? Example code to use RDRAND if available and to make sure will always return a random valid value:

Code:

---

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>

/* Test if RDRAND is available via CPUID[EAX=1]:ECX:30 */
int rdrand_avail( void )
{
#if defined(__i386) || defined(__x86_64)
  int avail;

  __asm__ __volatile__ (
    "cpuid" : "=c" ( avail ) : "a" (1) :
#ifdef __i386
    "ebx", "edx"
#else
    "rbx", "rdx"
#endif
  );

  return !!( avail & ( 1U << 30 ) );
#else
  return 0;
#endif 
}

/* Stolen from Intel intrinsics (immintrin.h). Updates *step with CF.
  *step = 1 means we have a random value, otherwise,
  we need to try again. */
static uint32_t rdrand_step( int *step )
{
  uint32_t r;

  __asm__ __volatile__ (
    "xorl %%ecx,%%ecx\n\t"
    "rdrand %0\n\t"
    "setc %%cl"
    : "=a" (r), "=c" (*step)
  );

  return r;
}

uint32_t rdrand( void )
{
  uint32_t r;
  int count, step;

  /* To avoid the possibility to get 0,
    Intel recomends to try to read 10 times.
    Accordingly to the documentation the odds to
    NOT get another 0 after this is "astronomical". */
  count = 10;
  while ( count-- )
  {
    r = rdrand_step( &step );
    if ( step )
      break;
  }

  // We tried 10 times and all failed (unlikely),
  // show an error and abort!
  if ( ! count )
  {
    fputs( "ERROR: cannot get random value from RDRAND instruction.\n", stderr );
    abort();
  }

  return r;
}

int main( void )
{
  if ( ! rdrand_avail() )
  {
    // Here we could inicialize pointers to funtions to
    // use PRNGs in case RDRAND isn't available. For example:
    //
    //  /* external identifiers: */
    //  void (*SRAND)( uint32_t );
    //  uint32_t (*RAND)( void );
    //
    //  static void do_norhing( uint32_t s ) { }
    //
    //  if ( rdrand_avail() ) { SRAND = do_nothing; RAND = rdrand; }
    //  else                  { SRAND = srand; RAND = rand; }
    //
    // Now we can use SRAND() and RAND() as srand() and rand(),
    // being sure the correct vesion will be called.

    fputs( "ERROR: RDRAND not available for this processor.\n", stderr );
    return EXIT_FAILURE;
  }

  printf( "%u\n", rdrand() );

  return EXIT_SUCCESS;
}

---

Quote:

---

Originally Posted by flp1969

Why "miss"? Example code to use RDRAND if available and to make sure will always return a random valid value:

Code:

---

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>

/* Test if RDRAND is available via CPUID[EAX=1]:ECX:30 */
int rdrand_avail( void )
{
#if defined(__i386) || defined(__x86_64)
  int avail;

  __asm__ __volatile__ (
    "cpuid" : "=c" ( avail ) : "a" (1) :
#ifdef __i386
    "ebx", "edx"
#else
    "rbx", "rdx"
#endif
  );

  return !!( avail & ( 1U << 30 ) );
#else
  return 0;
#endif 
}

/* Stolen from Intel intrinsics (immintrin.h). Updates *step with CF.
  *step = 1 means we have a random value, otherwise,
  we need to try again. */
static uint32_t rdrand_step( int *step )
{
  uint32_t r;

  __asm__ __volatile__ (
    "xorl %%ecx,%%ecx\n\t"
    "rdrand %0\n\t"
    "setc %%cl"
    : "=a" (r), "=c" (*step)
  );

  return r;
}

uint32_t rdrand( void )
{
  uint32_t r;
  int count, step;

  /* To avoid the possibility to get 0,
    Intel recomends to try to read 10 times.
    Accordingly to the documentation the odds to
    NOT get another 0 after this is "astronomical". */
  count = 10;
  while ( count-- )
  {
    r = rdrand_step( &step );
    if ( step )
      break;
  }

  // We tried 10 times and all failed (unlikely),
  // show an error and abort!
  if ( ! count )
  {
    fputs( "ERROR: cannot get random value from RDRAND instruction.\n", stderr );
    abort();
  }

  return r;
}

int main( void )
{
  if ( ! rdrand_avail() )
  {
    // Here we could inicialize pointers to funtions to
    // use PRNGs in case RDRAND isn't available. For example:
    //
    //  /* external identifiers: */
    //  void (*SRAND)( uint32_t );
    //  uint32_t (*RAND)( void );
    //
    //  static void do_norhing( uint32_t s ) { }
    //
    //  if ( rdrand_avail() ) { SRAND = do_nothing; RAND = rdrand; }
    //  else                  { SRAND = srand; RAND = rand; }
    //
    // Now we can use SRAND() and RAND() as srand() and rand(),
    // being sure the correct vesion will be called.

    fputs( "ERROR: RDRAND not available for this processor.\n", stderr );
    return EXIT_FAILURE;
  }

  printf( "%u\n", rdrand() );

  return EXIT_SUCCESS;
}

---

---

Miss as in if incorrectly detected causes the process to crash

Not sticking around tonight but here's the 256x256 version of what I get without a seed plus the original 1024x1024 pic
pic.ppm - Google Drive

Quote:

---

Originally Posted by awsdert

Not sticking around tonight but here's the 256x256 version of what I get without a seed plus the original 1024x1024 pic
pic.ppm - Google Drive

---

Compare this to the "noise" you get with the LCG (rand)... You'll notice yours has some "regular" spots (not as random as it should be)...

As I said... this is better than before, but rand() is better.

Quote:

---

Originally Posted by flp1969

Compare this to the "noise" you get with the LCG (rand)... You'll notice yours has some "regular" spots (not as random as it should be)...

As I said... this is better than before, but rand() is better.

---

Quote:

---

Originally Posted by awsdert

Gave me noisy result (with some slight tears) despite it failing the dieharder tests

---

Yeah I noticed :), incidentally before that I had accidentally tried with a hard-coded value that I just randomly hit some keys on my numpad for and I didn't notice any tears on that so I think for now that will do and later I'll work on making it faster since for time being this won't be operating in kernel land anyways

Quote:

---

Originally Posted by flp1969

The rand() function is ISO 9989 standard, not subject to any licensing (maybe ISO/IEC)... And, as far as I know, xorshift128+ isn't subject to licensing as well...

---

Noted, I will keep that in mind for future reference

Quote:

---

Originally Posted by flp1969

If you want to avoid licensing, using MUSL it's not going to help you... :)

---

Comparison of C/POSIX standard library implementations for Linux
Since musl is under MIT License also it is not an issue to include it's code so long as I reference the source

Quote:

---

Originally Posted by flp1969

For thread safety, there is rand_r(), where you pass the seed to the function:

Code:

---

int rand_r( unsigned int *seedp);

---

---

Thank you, used it to compare results when improving the function

Quote:

---

Originally Posted by flp1969

Ahhhh... then you have a freestanding (not hosted) project (kernel)

---

Almost, it simply plugs in what is missing before it passes on the main part of the project, so if for example the standard headers were to include the mitsy headers (which is what it's own implementation would do if mitsy fell back to it) then fallback functions are need for code assuming those functions exist to work properly, there are defines to tell it to not include the standard headers and just define the library by itself (which would then clash with actual headers if they were included along side)

Been meaning to reply to those before but phone was not suitable and forgot by the time I had a chance, on another note I managed to fix the code to be faster and more random after taking a leaf out of musl's book and using xor combined with a shift, at first I used musl_temper (what I renamed temper to when using in this closed environment test project) and sure enough that work and now I use a smaller faster variation of that, now it looks like this:

Code:

---

uint mcc___rnd( uint *seed ) {
        /* Initial random value */
        uint _seed;
        char tseed[10] = "9462537";
        struct timespec ts;
        clock_gettime(CLOCK_REALTIME,&ts);
        _seed = ((ulong)&ts * ts.tv_nsec);
        _seed ^= _seed >> _seed & 0xF;
        if ( !seed ) seed = &_seed;
        return _seed + (tseed[*seed&7u] * tseed[_seed&7u] * _seed);
}

---

noisy.ppm - Google Drive
Gotta go to work now so won't respond often or at all until after gospel later tonight

Good books about random number generators:

Luc Devroye - Non Uniform Random Variates

and, of course, volume 2 of the art of computer programming by Donald E. Knuth

Donald E. Knuth - The Art of Computer Programming (all)

Quote:

---

Originally Posted by flp1969

Good books about random number generators:

Luc Devroye - Non Uniform Random Variates

and, of course, volume 2 of the art of computer programming by Donald E. Knuth

Donald E. Knuth - The Art of Computer Programming (all)

---

Thanks, I tried reading through the 1st one but used so many math symbols that it would take too long for me to understand it, I do wish they had thought to include simple pseudo code as well, anyways I'll put that on back burner for now, in mean time I'll ask this instead, how many cpu instructions do you know of that supposed to return different values often, also do you know of how to read IRQ0 in assembly? I want to default to that when no other architecture is detected which would provide the speedup needed without sacrificing the seedless state, at the moment I am seriously considering a version of the function that takes no parameters to remove all the push/pop stuff that slows a seeded function down, I managed to get the speed down to an average of 200000 nanoseconds by utilizing the rdtsc call directly (although I forgot the macro to detect it so currently have an #if 1 there instead)

Well just finished running the version that was using NULL on the seed under dieharder (results attached), while not perfect it does seem to pass roughly 50% of the tests which is good enough for now, especially as it is a seedless run. As stated before security software should be able to use this just fine, although I wouldn't trust it if it uses just this.

Incidentally I found a way to not bother remembering macros:

Code:

---

#define MCC___DEF(NAME) (NAME)
#define MCC__DEF(NAME) MCC___DEF(NAME)
#define MCC_DEF(NAME) \
        (MCC__DEF(__##NAME##__) | MCC__DEF(__##NAME)\
        | MCC__DEF(_##NAME##_) | MCC__DEF(_##NAME)\
        | MCC__DEF(NAME))
#define MCC____RND(V) (V ^ (V * (V << (V & 0xF))))
uint mcc____rnd() {
#if MCC_DEF(X86) | MCC_DEF(X86_64) | MCC_DEF(x86) | MCC_DEF(x86_64)
        uint a, b;
        asm volatile("rdtsc":"=a"(a),"=b"(b));
        return MCC____RND(a);
#else
        struct timespec ts;
        clock_gettime(CLOCK_REALTIME,&ts);
        return MCC____RND(ts.tv_nsec);
#endif
}

---

Edit: Because some peops will be curios...

Code:

---

gcc -ggdb -Wall -lpthread -DQUICKY_RND -o ./mcc_rnd_quicky.elf mcc_rnd.c
./mcc_rnd_quicky.elf
mcc___rnd() took 0 seconds and 198353 nanoseconds
rand_r() took 0 seconds and 116349 nanoseconds
Compilation finished successfully.

---

Code:

---

#define PER_LOOP 10000
int main() {
        struct timespec init, stop;
        uint seed = time(NULL), i;
        clock_gettime(CLOCK_REALTIME,&init);
        for ( i = 0; i < PER_LOOP; ++i ) {
                (void)mcc____rnd();
        }
        clock_gettime(CLOCK_REALTIME,&stop);
        printf( "mcc___rnd() took %lld seconds and %lld nanoseconds\n",
                (long long)(stop.tv_sec - init.tv_sec),
                (long long)(stop.tv_nsec - init.tv_nsec) );
        clock_gettime(CLOCK_REALTIME,&init);
        for ( i = 0; i < PER_LOOP; ++i ) {
                (void)rand_r(&seed);
        }
        clock_gettime(CLOCK_REALTIME,&stop);
        printf( "rand_r() took %lld seconds and %lld nanoseconds\n",
                (long long)(stop.tv_sec - init.tv_sec),
                (long long)(stop.tv_nsec - init.tv_nsec) );
        return 0;
}

---

Edit 2: I tried removing the loop out of curiosity, was surprised to get consistent results looking like this:

Code:

---

gcc -ggdb -Wall -lpthread -DQUICKY_RND -o ./mcc_rnd_quicky.elf mcc_rnd.c
mcc_rnd.c: In function ‘main’:
mcc_rnd.c:101:26: warning: unused variable ‘i’ [-Wunused-variable]
  101 |  uint seed = time(NULL), i;
      |                          ^
./mcc_rnd_quicky.elf
mcc___rnd() took 0 seconds and 182 nanoseconds
rand_r() took 0 seconds and 550 nanoseconds
Compilation finished successfully.

---

Why not use Mersenne Twister? Its behaviour is known, and mathematically proven, and it's easy to implement. The paper and reference implementation can be found here: Mersenne Twister: A random number generator (since 1997/10)

An advantage (shared with other PRNGs) is that you can give it a fixed seed so you know the sequence will be the same for the given seed; useful for debugging.

Quote:

---

Originally Posted by Hodor

Why not use Mersenne Twister? Its behaviour is known, and mathematically proven, and it's easy to implement. The paper and reference implementation can be found here: Mersenne Twister: A random number generator (since 1997/10)

An advantage (shared with other PRNGs) is that you can give it a fixed seed so you know the sequence will be the same for the given seed; useful for debugging.

---

Isn't the point of a random number generator supposed to be ooh I dunno not fixed?

Quote:

---

Originally Posted by awsdert

Isn't the point of a random number generator supposed to be ooh I dunno not fixed?

---

No, that's not necessarily the point: while "true randomness" typically cannot have sequences reproduced on demand other than by saving the sequences to replay them, there's statistical randomness and randomness that is unpredictable, and these don't require that the sequence cannot be repeated on demand given only a seed. If you're running a simulation, or as Hodor said, debugging, being able to repeat the pseudorandom sequence on demand is useful.

Quote:

---

Originally Posted by laserlight

No, that's not necessarily the point: while "true randomness" typically cannot have sequences reproduced on demand other than by saving the sequences to replay them, there's statistical randomness and randomness that is unpredictable, and these don't require that the sequence cannot be repeated on demand given only a seed. If you're running a simulation, or as Hodor said, debugging, being able to repeat the pseudorandom sequence on demand is useful.

---

Well as you'll note I used a macro on this last version so I can always maintain only slightly different functions and the developer using them can simply use a macro to decide if they want the seeded version, something like this:

Code:

---

#ifdef _DEBUG
#define MCC_RND( VAL ) mcc_rnd_r( &VAL )
#else
#define MCC_RND( VAL ) VAL = mcc_rnd()
#endif

---

Quote:

---

Originally Posted by awsdert

Thanks, I tried reading through the 1st one but used so many math symbols that it would take too long for me to understand it, I do wish they had thought to include simple pseudo code as well,

---

What suprises me is that you are dealing with mathematical problems (floating point, random numbers), but refuse to learn the proper mathematics...

Quote:

---

Originally Posted by flp1969

What suprises me is that you are dealing with mathematical problems (floating point, random numbers), but refuse to learn the proper mathematics...

---

Nah its not that, I can read scripts easily enough since they're in nice simple lines but math symbols go all over the place and there are some I'm not even familiar with, I only got a B in my GCSEs and wasn't really interested in studying it in the last 14 odd years, but on that note do you have a good reference to look through for studying each symbol? (preferably list format with the name of each symbol next to them and a basic description, I can google from there once I know the name and find the description insufficient for learning about it)

Quote:

---

Originally Posted by awsdert

Nah its not that, I can read scripts easily enough since they're in nice simple lines but math symbols go all over the place and there are some I'm not even familiar with, I only got a B in my GCSEs and wasn't really interested in studying it in the last 14 odd years, but on that note do you have a good reference to look through for studying each symbol? (preferably list format with the name of each symbol next to them and a basic description, I can google from there once I know the name and find the description insufficient for learning about it)

---

Knuth gives pseudocode or code in the MIX or MMIX language (which both have assemblers... MIX or MMIX depends on what revision of his books you look at) or both. So volume 2 and the stuff about random numbers has lots of mathematics but lots of pseudocode as well (all the volumes do). The Mersenne twister algorithm, linked to above, even uses a LCG random number generator to set its initial state from a given seed and references Knuth. There's not really even much, if any, mathematics to understand (unless you want to). If I see code that uses some kind of weird unpublished random (or pseudo-random) number generator all sorts of alarm bells go off and I'd steer clear of it. I can understand the mathematics for most PRNGs but even if I can't (there are some that are just beyond my ability) I'd rather see code using algorithms written in peer-reviewed journals; especially if I need something that approaches anything useful for secure cryptography because I either don't have the ability to prove these things myself or I don't have the time.

Mersenne twister is fast but not as fast as your code or a LCG PRNG. Pretty close though and it has better randomness than rand() (side note: does the C standard specify what algorithm rand() must use?)

Edit: there was a PRNG algorithm published in Doctor Dobb's Journal in about 1995 based on the Fibonacci sequence that was good for CPUs at the time that didn't have FPUs. Its period was terrible but it was easy to implement in ASM and good enough for games. I can't find a reference to it but I don't think it was a "classical" LCG, although it might have been (can't say for sure because I cannot find the article)

Quote:

---

Originally Posted by Hodor

does the C standard specify what algorithm rand() must use?

---

No, except that it does require a PRNG and imposes some minimum requirements on the PRNG like a minimum RAND_MAX.

Quote:

---

Originally Posted by laserlight

No, except that it does require a PRNG and imposes some minimum requirements on the PRNG like a minimum RAND_MAX.

---

Thanks. That's what I thought but wasn't sure

I, erm, think I fixed the time based generator to be shall we say WAY more secure than before, I was experimenting hoping to get a few more passed and on my current attempt (dieharder is still running, at lagged sum tests right now) a LOT more were passing than I expected with the simple change I made (also change a few names because I found this method only works for counter based values, got a different one for seeds).
My current experimental code

Code:

---

#define MCC_RND(TICK) (((TICK) ^ ((TICK) * ((TICK) << ((TICK) & 0xF)))) + ((TICK) % 123))
#define MCC_RNG_SEED(SEED) (((SEED) * ((SEED) % 4321)) + ((SEED) % 12345))
#define MCC_RNG_(SEED) ((MCC_RNG_SEED(SEED) ^ (SEED)))
#define MCC_RNG(SEED) MCC_RND(MCC_RNG_(SEED))

#if 0//MCC_DEF(X86) | MCC_DEF(X86_64) | MCC_DEF(x86) | MCC_DEF(x86_64)
#define mcc_get_ticks(TS) \
        do { asm volatile("rdtsc":\
                "=" #TS ".tv_sec" (TS.tv_sec),\
                "=" #TS ".tv_nsec" (TS.tv_nsec));\
        } while (0)
#else
#define mcc_get_ticks(TS) clock_gettime(CLOCK_REALTIME,&TS);
#endif

#define mcc_random(V,TS) \
        do { mcc_init_seed(TS); \
        V = MCC_RND(TS.tv_nsec ^ V); } while (0)

uint mcc_rng() {
        struct timespec ts;
        mcc_get_ticks(ts);
        return MCC_RNG(ts.tv_nsec + (ulong)&ts);
}
uint mcc_rng_r( uint *seed ) {
        return (*seed = MCC_RNG(*seed));
}
long mcc_random_between( uint *seed, long min, long max ) {
        /* Initial random value */
        long val = (*seed = MCC_RNG( *seed ));
        if ( val < min ) return (min != 0) ? val % min : -(val & 1);
        if ( val > max ) return (max != 0) ? val % max : (val & 1);
        return val;
}

---

Edit: Gonna go out for breakfast, dieharder should be done by the time I come back and I can then upload the results

Why not keep this simple. You are not, obviously, interested in a cryptographically secure RNG, so LCG, Mersene Twister, Xorshift128 or any other PRNG is suitable. A thread safe LCG is easy enough to be implemented. For example:

Code:

---

unsigned int myrand( unsigned int *state )
{
  unsigned int r;

  /* LCG: Stolen from glibc (changed to unsigned int). */
  r = ( *state * 1103515245 ) + 12345;
  *state = r;

  return r;
}

---

This "state" is your initial seed and the values 1103515245 and 12345 are good enough for an LCG...

If you want to use RDRAND for Intel/AMD processors, you can do something like this:

Code:

---

/* rand.c */
#include <cpuid.h>

/* Interface pointers to proper functions. */
void (*SRAND)( unsigned int *, unsigned int );
unsigned int (*RAND)( unsigned int * );

/* Because RDRAND don't need a seed! */
static void empty( unsigned int *state, unsigned int seed ) {}

/* mysrand() & myrand() are thread safe. You need only to provide
  A pointer to the initial seed */
static void mysrand( unsigned int *state, unsigned int seed )
{
  *state = seed;
}

static unsigned int myrand( unsigned int *state )
{
  unsigned int r;

  /* LCG: Stolen from glibc (changed to unsigned int). */
  r = ( *state * 1103515245 ) + 12345;
  *state = r;

  return r;
}

#if defined(__i386) || defined(__x86_64)
static unsigned int rdrand( unsigned int *state )
/* state pointer is ignored! */
{
  unsigned int r;

  /* Need to save EBX/RBX because of SysV calling convention. */
  __asm__ __volatile__(
    "1:\n\t"
    "  rdrand %0\n\t"
    "  jnc 1b" : "=c" (r) ::
  #ifdef __i386
    "ebx"
  #else
    "rbx"
  #endif
  );

  // NOTE: There is an intrinsic called _rdrand32_step(), but it created worse code
  // than this one...

  return r;
}
#endif

/* The default behavior is to use LCG, unless we are dealing with
  Intel/AMD processors which have RDRAND instruction. */
void (*SRAND)( unsigned int *, unsigned int ) = mysrand;
unsigned int (*RAND)( unsigned int * ) = myrand;

#if defined(__i386) || defined(__x86_64)
/* You can change this to a simple RAND_init() function which must be called before any
  use of SRAND() or RAND(). I prefer to use the GCC extension. */
static void __attribute__((constructor)) RAND_ctor( void )
{
  int a, b, c, d;

  __cpuid( 1, a, b, c, d ); // Yep, this is an intrinsic @ cpuid.h.
                            // You can do this in asm, if you wish...

  if ( c & bit_RDRND )      // bit_RDRND also defined in cpuid.h
  {
    SRAND = empty;
    RAND = rdrand;
  } 
}
#endif

---

A small test code:

Code:

---

/* test.c */
#include <stdio.h>
#include <time.h>
#include <limits.h>

#define scale2rgb(n) \
  ( unsigned int ) ( ( (n) * 16777215.0 ) / UINT_MAX )

extern void (*SRAND)( unsigned int *, unsigned int );
extern unsigned int (*RAND)( unsigned int * );

int main ( void )
{
  int i;
  unsigned int rnd_state, r;

  SRAND( &rnd_state, time(NULL) );

  puts("P6\n1024 1024\n255");
  for ( i = 0; i < 1024*1024; i++ )
  {
    r = scale2rgb(RAND(&rnd_state));
    fwrite( &r, 3, 1, stdout );
  }
}

---

Compiling and linking:

Code:

---

$ cc -O2 -c rand.c test.c
$ cc -O2 -s -o test test.o rand.o
$ ./test > pic.ppm

---

Well here's the results, just 2 failures out of the lot, I can live with that for now, I'll switch back to my other project for a while and fix an allocation issue I just thought of in it (related to the custom allocator and it's realloc part)