Changeset 6c7b1e7


Ignore:
Timestamp:
Oct 31, 2017, 1:41:33 PM (4 years ago)
Author:
Peter A. Buhr <pabuhr@…>
Branches:
aaron-thesis, arm-eh, cleanup-dtors, deferred_resn, demangler, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, resolv-new, with_gc
Children:
0dc954b
Parents:
c59bde6
Message:

change random name

Location:
src/tests
Files:
14 edited

Legend:

Unmodified
Added
Removed
  • src/tests/boundedBuffer.c

    rc59bde6 r6c7b1e7  
    88// Created On       : Mon Oct 30 12:45:13 2017
    99// Last Modified By : Peter A. Buhr
    10 // Last Modified On : Mon Oct 30 18:00:10 2017
    11 // Update Count     : 7
     10// Last Modified On : Mon Oct 30 23:02:46 2017
     11// Update Count     : 9
    1212//
    1313
    1414#include <stdlib>
    15 #include <fstream>
     15#include <fstream>                                                                              // random
    1616#include <kernel>
    1717#include <thread>
    18 #include <unistd.h>                                     // getpid
     18#include <unistd.h>                                                                             // getpid
    1919
    2020monitor Buffer {
     
    5252void main( Producer & prod ) {
    5353        for ( int i = 1; i <= prod.N; i += 1 ) {
    54                 yield( rand48( 5 ) );
     54                yield( random( 5 ) );
    5555                insert( prod.buffer, 1 );
    5656        } // for
     
    6969        cons.sum = 0;
    7070        for ( ;; ) {
    71                 yield( rand48( 5 ) );
     71                yield( random( 5 ) );
    7272                int item = remove( cons.buffer );
    7373                if ( item == -1 ) break;                                // sentinel ?
     
    9090        processor p;
    9191
    92         //rand48seed( getpid() );
    93         rand48seed( 1003 );
     92        //random_seed( getpid() );
     93        random_seed( 1003 );
    9494
    9595        for ( i = 0; i < Cons; i += 1 ) {                       // create consumers
  • src/tests/datingService.c

    rc59bde6 r6c7b1e7  
    99// Created On       : Mon Oct 30 12:56:20 2017
    1010// Last Modified By : Peter A. Buhr
    11 // Last Modified On : Mon Oct 30 17:58:41 2017
    12 // Update Count     : 14
     11// Last Modified On : Mon Oct 30 23:02:11 2017
     12// Update Count     : 15
    1313//
    1414
    15 #include <stdlib>                                                                               // rand48
     15#include <stdlib>                                                                               // random
    1616#include <fstream>
    1717#include <kernel>
     
    6161
    6262void main( Girl & g ) {
    63         yield( rand48( 100 ) );                                                         // don't all start at the same time
     63        yield( random( 100 ) );                                                         // don't all start at the same time
    6464        unsigned int partner = girl( g.TheExchange, g.id, g.ccode );
    6565        //sout | "Girl:" | g.id | "is dating Boy at" | partner | "with ccode" | g.ccode | endl;
     
    7979
    8080void main( Boy & b ) {
    81         yield( rand48( 100 ) );                                                         // don't all start at the same time
     81        yield( random( 100 ) );                                                         // don't all start at the same time
    8282        unsigned int partner = boy( b.TheExchange, b.id, b.ccode );
    8383        //sout | " Boy:" | b.id | "is dating Girl" | partner | "with ccode" | b.ccode | endl;
     
    9696        Boy  *boys[NoOfPairs];
    9797
    98         rand48seed( getpid() );
     98        random_seed( getpid() );
    9999
    100100        for ( unsigned int i = 0; i < NoOfPairs; i += 1 ) {
  • src/tests/prodcons.c

    rc59bde6 r6c7b1e7  
    1010// Created On       : Mon Sep 18 12:23:39 2017
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon Oct 30 18:01:19 2017
    13 // Update Count     : 41
     12// Last Modified On : Mon Oct 30 23:06:05 2017
     13// Update Count     : 42
    1414//
    1515
    1616#include <fstream>
    1717#include <coroutine>
    18 #include <stdlib>                                                                               // rand48
     18#include <stdlib>                                                                               // random
    1919#include <unistd.h>                                                                             // getpid
    2020
     
    3030        // 1st resume starts here
    3131        for ( int i = 0; i < prod.N; i += 1 ) {
    32                 int p1 = rand48( 100 );
    33                 int p2 = rand48( 100 );
     32                int p1 = random( 100 );
     33                int p2 = random( 100 );
    3434                sout | p1 | " " | p2 | endl;
    3535                int status = delivery( *prod.c, p1, p2 );
     
    9090        Prod prod;
    9191        Cons cons = { prod };
    92         rand48seed( /* getpid() */ 103 );                                       // fixed seed for testing
     92        random_seed( /* getpid() */ 103 );                                      // fixed seed for testing
    9393        start( prod, 5, cons );
    9494        sout | "main stops" | endl;
  • src/tests/random.c

    rc59bde6 r6c7b1e7  
    1010// Created On       : Tue Jul  5 21:29:30 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Jul  6 18:00:29 2016
    13 // Update Count     : 3
     12// Last Modified On : Mon Oct 30 23:06:49 2017
     13// Update Count     : 6
    1414//
    1515
     
    1919
    2020int main() {
    21         //rand48seed( getpid() );                                                               // set random seed
    22         rand48seed( 1003 );                                                                     // fixed seed for repeatable tests
     21        //srandom( getpid() );                                                          // set random seed
     22        random_seed( 1003 );                                                            // fixed seed for repeatable tests
    2323
    2424        // test polymorphic calls to random and stream
    25         char c = rand48();
     25        char c = random();
    2626        sout | c | endl;
    27         int i = rand48();
     27        int i = random();
    2828    sout | i | endl;
    29         unsigned int ui = rand48();
     29        unsigned int ui = random();
    3030    sout | ui | endl;
    31         long int li = rand48();
     31        long int li = random();
    3232    sout | li | endl;
    33         unsigned long int uli = rand48();
     33        unsigned long int uli = random();
    3434    sout | uli | endl;
    35     float f = rand48();
     35    float f = random();
    3636    sout | f | endl;
    37     double d = rand48();
     37    double d = random();
    3838    sout | d | endl;
    39     float _Complex fc = rand48();
     39    float _Complex fc = random();
    4040    sout | fc | endl;
    41     double _Complex dc = rand48();
     41    double _Complex dc = random();
    4242    sout | dc | endl;
    43     long double _Complex ldc = rand48();
     43    long double _Complex ldc = random();
    4444    sout | ldc | endl;
    4545} // main
  • src/tests/rational.c

    rc59bde6 r6c7b1e7  
    1010// Created On       : Mon Mar 28 08:43:12 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Aug 23 21:40:11 2017
    13 // Update Count     : 66
     12// Last Modified On : Tue Oct 10 23:25:04 2017
     13// Update Count     : 67
    1414//
    1515
  • src/tests/sched-ext-barge.c

    rc59bde6 r6c7b1e7  
    4242void main( barger_t & this ) {
    4343        yield();
    44         while( barge( global ) ) { yield(((unsigned)rand48()) % 10); }
     44        while( barge( global ) ) { yield(random( 10 )); }
    4545}
    4646
    4747bool do_call( global_t & mutex this ) {
    48         yield(((unsigned)rand48()) % 10);
     48        yield(random( 10 ));
    4949        if( this.state != WAITFOR && !this.done && this.started ) {
    5050                serr | "Barging before caller detected" | endl;
     
    5757thread caller_t {};
    5858void main( caller_t & this ) {
    59         while( do_call(global) ) { yield(((unsigned)rand48()) % 10); }
     59        while( do_call(global) ) { yield(random( 10 )); }
    6060}
    6161
     
    6363        this.started = true;
    6464        for( int i = 0; i < N; i++) {
    65                 yield(((unsigned)rand48()) % 10);
     65                yield(random( 10 ));
    6666                this.state = WAITFOR;
    6767                waitfor(do_call, this) {
  • src/tests/sched-ext-dtor.c

    rc59bde6 r6c7b1e7  
    4545
    4646void main( dummy_t & this ) {
    47         yield(((unsigned)rand48()) % 10);
     47        yield(random( 10 ));
    4848        set_state( this, MAIN );
    4949        waitfor( ^?{}, this ) {
     
    5858        for( int i = 0; i < N; i++ ){
    5959                dummy_t dummy[4];
    60                 yield( ((unsigned)rand48()) % 100 );
     60                yield( random( 100 ) );
    6161        }
    6262        sout | "Stopping" | endl;
  • src/tests/sched-ext-recurse.c

    rc59bde6 r6c7b1e7  
    1515static const unsigned long N = 5_000ul;
    1616
    17 static inline void rand_yield() { yield(((unsigned)rand48()) % 10); }
     17static inline void rand_yield() { yield(random( 10 )); }
    1818
    1919enum state_t { FIRST, SECOND, THIRD, LAST, STOP };
     
    2323        for (i = 0; i < 4; i++)
    2424        {
    25                 int j = ((unsigned)rand48()) % 4;
     25            int j = random( 4 );
    2626                enum state_t t = array[j];
    2727                array[j] = array[i];
     
    131131
    132132int main() {
    133         rand48seed( time(NULL) );
     133        random_seed( time(NULL) );
    134134        sout | "Starting" | endl;
    135135        {
  • src/tests/sched-ext-when.c

    rc59bde6 r6c7b1e7  
    1515static const unsigned long N = 4_998ul;
    1616
    17 static inline void rand_yield() { yield(((unsigned)rand48()) % 10); }
     17static inline void rand_yield() { yield(random( 10 )); }
    1818
    1919monitor global_t {
     
    7777
    7878int main() {
    79         rand48seed( time(NULL) );
     79        random_seed( time(NULL) );
    8080        sout | "Starting" | endl;
    8181        {
  • src/tests/sched-ext.c

    rc59bde6 r6c7b1e7  
    2626volatile bool done;
    2727
    28 unsigned rand10() {
    29         return (unsigned)rand48() % 10;
    30 }
    31 
    3228//----------------------------------------------------------------------------------------------------
    3329// Acceptor
     
    3632void do_wait( global_t * mutex a ) {
    3733        sout | "Waiting to accept" | endl;
    38         yield( rand10() );
     34        yield( random( 10 ) );
    3935
    4036        sout | "Accepting" | endl;
     
    4844
    4945        sout | "Accepted" | endl;
    50         yield( rand10() );
     46        yield( random( 10 ) );
    5147}
    5248
     
    6864void main( Acceptee* this ) {
    6965        while( !done ) {
    70                 yield( rand10() );
     66                yield( random( 10 ) );
    7167                do_notify( &globalA );
    72                 yield( rand10() );
     68                yield( random( 10 ) );
    7369        }
    7470}
     
    7874int main(int argc, char* argv[]) {
    7975        done = false;
    80         rand48seed( time( NULL ) );
     76        random_seed( time( NULL ) );
    8177        printf("%p\n", &globalA);
    8278        sout | "Starting" | endl;
  • src/tests/sched-int-barge.c

    rc59bde6 r6c7b1e7  
    6464
    6565        if( action == 0 ) {
    66                 c.do_signal = max( ((unsigned)rand48()) % 10, 1);
    67                 c.do_wait1 = ((unsigned)rand48()) % (c.do_signal);
    68                 c.do_wait2 = ((unsigned)rand48()) % (c.do_signal);
     66                c.do_signal = max( random( 10 ), 1);
     67                c.do_wait1 = random( c.do_signal );
     68                c.do_wait2 = random( c.do_signal );
    6969
    7070                if(c.do_wait1 == c.do_wait2) sout | "Same" | endl;
     
    109109
    110110int main(int argc, char* argv[]) {
    111         rand48seed(0);
     111        random_seed(0);
    112112        processor p;
    113113        {
  • src/tests/sched-int-block.c

    rc59bde6 r6c7b1e7  
    4949        wait( &cond, (uintptr_t)this_thread );
    5050
    51         yield( ((unsigned)rand48()) % 10 );
     51        yield( random( 10 ) );
    5252
    5353        if(a.last_thread != a.last_signaller || b.last_thread != b.last_signaller ) {
     
    5858        a.last_thread = b.last_thread = this_thread;
    5959
    60         yield( ((unsigned)rand48()) % 10 );
     60        yield( random( 10 ) );
    6161}
    6262
     
    7070//------------------------------------------------------------------------------
    7171void signal_op( global_data_t & mutex a, global_data_t & mutex b ) {
    72         yield( ((unsigned)rand48()) % 10 );
     72        yield( random( 10 ) );
    7373
    7474        [a.last_thread, b.last_thread, a.last_signaller, b.last_signaller] = this_thread;
     
    8383                }
    8484
    85                 yield( ((unsigned)rand48()) % 10 );
     85                yield( random( 10 ) );
    8686
    8787                if(a.last_thread != next || b.last_thread != next) {
     
    118118
    119119int main(int argc, char* argv[]) {
    120         rand48seed( time( NULL ) );
     120        random_seed( time( NULL ) );
    121121        done = false;
    122122        processor p;
  • src/tests/sched-int-disjoint.c

    rc59bde6 r6c7b1e7  
    8888        signal( &cond, a, data );
    8989
    90         yield( (unsigned)rand48() % 10 );
     90        yield( random( 10 ) );
    9191
    9292        //This is technically a mutual exclusion violation but the mutex monitor protects us
     
    109109// Main loop
    110110int main(int argc, char* argv[]) {
    111         rand48seed( time( NULL ) );
     111        random_seed( time( NULL ) );
    112112        all_done = false;
    113113        processor p;
  • src/tests/sched-int-wait.c

    rc59bde6 r6c7b1e7  
    6262
    6363        while( waiter_left != 0 ) {
    64                 unsigned action = (unsigned)rand48() % 4;
     64            unsigned action = random( 4 );
    6565                switch( action ) {
    6666                        case 0:
     
    127127// Main
    128128int main(int argc, char* argv[]) {
    129         rand48seed( time( NULL ) );
     129        random_seed( time( NULL ) );
    130130        waiter_left = 4;
    131131        processor p[2];
Note: See TracChangeset for help on using the changeset viewer.