Changeset 58fe85a for tests/concurrent


Ignore:
Timestamp:
Jan 7, 2021, 3:27:00 PM (5 years ago)
Author:
Thierry Delisle <tdelisle@…>
Branches:
ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, master, new-ast-unique-expr, pthread-emulation, qualifiedEnum
Children:
2b4daf2, 64aeca0
Parents:
3c64c668 (diff), eef8dfb (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge branch 'master' into park_unpark

Location:
tests/concurrent
Files:
19 added
12 edited
1 moved

Legend:

Unmodified
Added
Removed

  • tests/concurrent/.expect/monitor.txt

    r3c64c668 r58fe85a  
    1 4000000
     13000000

  • tests/concurrent/coroutineYield.cfa

    r3c64c668 r58fe85a  
    3333                        sout | "Coroutine 2";
    3434                #endif
    35                 suspend();
     35                suspend;
    3636        }
    3737}

  • tests/concurrent/examples/.expect/datingService.txt

    r3c64c668 r58fe85a  
     1done

  • tests/concurrent/examples/boundedBufferEXT.cfa

    r3c64c668 r58fe85a  
    11//
    22// Cforall Version 1.0.0 Copyright (C) 2018 University of Waterloo
    3 // 
     3//
    44// The contents of this file are covered under the licence agreement in the
    55// file "LICENCE" distributed with Cforall.
    … …  
    8787}
    8888
     89enum { Prods = 4, Cons = 5 };
     90Producer * prods[Prods];
     91Consumer * cons[Cons];
     92
    8993int main() {
    9094        Buffer(int) buffer;
    91         enum { Prods = 4, Cons = 5 };
    92         Producer * prods[Prods];
    93         Consumer * cons[Cons];
    9495        int sums[Cons];
    9596        int i;

  • tests/concurrent/examples/datingService.cfa

    r3c64c668 r58fe85a  
    1010// Created On       : Mon Oct 30 12:56:20 2017
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Jun 21 11:32:34 2019
    13 // Update Count     : 38
     12// Last Modified On : Sun Sep 27 15:42:25 2020
     13// Update Count     : 40
    1414//
    1515
    … …  
    3535                signal_block( Boys[ccode] );                                    // restart boy to set phone number
    3636        } // if
    37         //sout | "Girl:" | PhoneNo | "is dating Boy at" | BoyPhoneNo | "with ccode" | ccode;
     37        // sout | "Girl:" | PhoneNo | "is dating Boy at" | BoyPhoneNo | "with ccode" | ccode;
    3838        return BoyPhoneNo;
    3939} // DatingService girl
    … …  
    4747                signal_block( Girls[ccode] );                                   // restart girl to set phone number
    4848        } // if
    49         //sout | " Boy:" | PhoneNo | "is dating Girl" | GirlPhoneNo | "with ccode" | ccode;
     49        // sout | " Boy:" | PhoneNo | "is dating Girl" | GirlPhoneNo | "with ccode" | ccode;
    5050        return GirlPhoneNo;
    5151} // DatingService boy
    … …  
    108108                if ( girlck[ boyck[i] ] != boyck[ girlck[i] ] ) abort();
    109109        } // for
     110
     111        printf( "done\n" );                                                                     // non-empty .expect file
    110112} // main
    111113

  • tests/concurrent/monitor.cfa

    r3c64c668 r58fe85a  
    2929
    3030void main( MyThread & this ) {
    31         for(int i = 0; i < 1_000_000; i++) {
     31        for(int i = 0; i < 750_000; i++) {
    3232                increment( global );
    3333        }

  • tests/concurrent/park/.expect/force_preempt.txt

    r3c64c668 r58fe85a  
    1 0 Calling unpark 0
    2 1 Calling unpark 0
    3 2 Calling unpark 0
    4 3 Calling unpark 0
    5 4 Calling unpark 0
    6 0 Parking 0
    7 0 Unparked 0
    8 0 Calling unpark 1
    9 1 Parking 0
    10 1 Unparked 0
    11 1 Calling unpark 1
    12 2 Parking 0
    13 2 Unparked 0
    14 2 Calling unpark 1
    15 3 Parking 0
    16 3 Unparked 0
    17 3 Calling unpark 1
    18 4 Parking 0
    19 4 Unparked 0
    20 4 Calling unpark 1
    21 0 Parking 1
    22 0 Unparked 1
    23 0 Calling unpark 2
    24 1 Parking 1
    25 1 Unparked 1
    26 1 Calling unpark 2
    27 2 Parking 1
    28 2 Unparked 1
    29 2 Calling unpark 2
    30 3 Parking 1
    31 3 Unparked 1
    32 3 Calling unpark 2
    33 4 Parking 1
    34 4 Unparked 1
    35 4 Calling unpark 2
    36 0 Parking 2
    37 0 Unparked 2
    38 0 Calling unpark 3
    39 1 Parking 2
    40 1 Unparked 2
    41 1 Calling unpark 3
    42 2 Parking 2
    43 2 Unparked 2
    44 2 Calling unpark 3
    45 3 Parking 2
    46 3 Unparked 2
    47 3 Calling unpark 3
    48 4 Parking 2
    49 4 Unparked 2
    50 4 Calling unpark 3
    51 0 Parking 3
    52 0 Unparked 3
    53 0 Calling unpark 4
    54 1 Parking 3
    55 1 Unparked 3
    56 1 Calling unpark 4
    57 2 Parking 3
    58 2 Unparked 3
    59 2 Calling unpark 4
    60 3 Parking 3
    61 3 Unparked 3
    62 3 Calling unpark 4
    63 4 Parking 3
    64 4 Unparked 3
    65 4 Calling unpark 4
    66 0 Parking 4
    67 0 Unparked 4
    68 1 Parking 4
    69 1 Unparked 4
    70 2 Parking 4
    71 2 Unparked 4
    72 3 Parking 4
    73 3 Unparked 4
    74 4 Parking 4
    75 4 Unparked 4
     1done

  • tests/concurrent/park/contention.cfa

    r3c64c668 r58fe85a  
    2424                } else {
    2525                        Thread * thrd = __atomic_exchange_n(&blocked[idx], &this, __ATOMIC_SEQ_CST);
    26                         unpark( *thrd);
     26                        unpark( *thrd );
    2727                        park();
    2828                }

  • tests/concurrent/park/force_preempt.cfa

    r3c64c668 r58fe85a  
    1616}
    1717
    18 thread Waiter;
    1918thread Waiter {};
    20 
    2119
    2220volatile int count = 0;
    … …  
    2523        // Get a unique id
    2624        int id = __atomic_fetch_add(&count, 1, __ATOMIC_SEQ_CST);
     25        int id_hash = id | (id << 8) | (id << 16) | (id << 24);
     26        int mask = 0xCAFEBABA;
    2727
    2828        for(int i = 0; i < 5; i++) {
     29                assert(mask == 0xCAFEBABA);
     30
    2931                // Unpark this thread, don't force a yield
    30                 sout | id | "Calling unpark" | i;
    31                 unpark(this);
     32                unpark( this );
     33                assert(mask == 0xCAFEBABA);
     34
     35                // Hash the mask to make sure no one else messes with them
     36                mask ^= id_hash;
     37                assert(mask == (id_hash ^ 0xCAFEBABA));
    3238
    3339                // Force a preemption before the call to park
    … …  
    3642
    3743                // Park this thread,
    38                 sout | id | "Parking" | i;
     44                assert(mask == (id_hash ^ 0xCAFEBABA));
    3945                park();
    40                 sout | id | "Unparked" | i;
     46                assert(mask == (id_hash ^ 0xCAFEBABA));
     47
     48                // Reset the hash and recheck it
     49                mask ^= id_hash;
     50                assert(mask == 0xCAFEBABA);
    4151        }
    4252}
    … …  
    4757                Waiter waiters[5];
    4858        }
     59        printf( "done\n" );                             // non-empty .expect file
    4960}

  • tests/concurrent/signal/block.cfa

    r3c64c668 r58fe85a  
    8282        if( !is_empty( cond ) ) {
    8383
    84                 $thread * next = front( cond );
     84                $thread * next = ( $thread * ) front( cond );
    8585
    8686                if( ! signal_block( cond ) ) {

  • tests/concurrent/signal/disjoint.cfa

    r3c64c668 r58fe85a  
    2121#endif
    2222
     23// This tests checks what happens when someone barges in the midle of the release
     24// of a bulk of monitors.
     25
    2326enum state_t { WAIT, SIGNAL, BARGE };
    2427
    2528monitor global_t {};
    26 global_t mut;
    2729
    2830monitor global_data_t;
    … …  
    3335        int counter;
    3436        state_t state;
    35 } data;
     37};
     38
     39// Use a global struct because the order needs to match with Signaller thread
     40struct {
     41        global_t mut;
     42        global_data_t data;
     43} globals;
    3644
    3745condition cond;
    … …  
    4048
    4149void ?{}( global_data_t & this ) {
    42         this.counter == 0;
     50        this.counter = 0;
    4351        this.state = BARGE;
    4452}
    … …  
    5361
    5462thread Barger {};
     63void ?{}( Barger & this ) {
     64        ((thread&)this){ "Barger Thread" };
     65}
    5566
    5667void main( Barger & this ) {
    5768        while( !all_done ) {
    58                 barge( data );
     69                barge( globals.data );
    5970                yield();
    6071        }
    … …  
    7889
    7990thread Waiter {};
     91void ?{}( Waiter & this ) {
     92        ((thread&)this){ "Waiter Thread" };
     93}
    8094
    8195void main( Waiter & this ) {
    82         while( wait( mut, data ) ) { KICK_WATCHDOG; yield(); }
     96        while( wait( globals.mut, globals.data ) ) { KICK_WATCHDOG; yield(); }
    8397}
    8498
    … …  
    92106
    93107void logic( global_t & mutex a ) {
    94         signal( cond, a, data );
     108        signal( cond, a, globals.data );
    95109
    96110        yield( random( 10 ) );
    97111
    98112        //This is technically a mutual exclusion violation but the mutex monitor protects us
    99         bool running = TEST(data.counter < N) && data.counter > 0;
    100         if( data.state != SIGNAL && running ) {
    101                 sout | "ERROR Eager signal" | data.state;
     113        bool running = TEST(globals.data.counter < N) && globals.data.counter > 0;
     114        if( globals.data.state != SIGNAL && running ) {
     115                sout | "ERROR Eager signal" | globals.data.state;
    102116        }
    103117}
    104118
    105119thread Signaller {};
     120void ?{}( Signaller & this ) {
     121        ((thread&)this){ "Signaller Thread" };
     122}
    106123
    107124void main( Signaller & this ) {
    108125        while( !all_done ) {
    109                 logic( mut );
     126                logic( globals.mut );
    110127                yield();
    111128        }

  • tests/concurrent/suspend_then.cfa

    r3c64c668 r58fe85a  
    11#include <fstream.hfa>
    22#include <kernel.hfa>
    3 #include <monitor.hfa>
    43#include <thread.hfa>
    54#include <time.hfa>
    … …  
    109#include "long_tests.hfa"
    1110
    12 #ifndef PREEMPTION_RATE
    13 #define PREEMPTION_RATE 10`ms
    14 #endif
    15 
    1611Duration default_preemption() {
    17         return PREEMPTION_RATE;
     12        return 0;
    1813}
    1914
    … …  
    2621#if !defined(TEST_FOREVER)
    2722        static inline void print(const char * const text ) {
    28                 write( STDERR_FILENO, text, strlen(text) );
     23                write( STDOUT_FILENO, text, strlen(text) );
    2924        }
    3025#else
    … …  
    3227#endif
    3328
    34 coroutine Coroutine {};
     29generator Coroutine { int i; };
    3530
    3631volatile bool done = false;
    … …  
    4944
    5045void main(Coroutine& this) {
    51         suspend();
    52         for(int i = 0; TEST(i < N); i++) {
     46        this.i = 0;
     47        suspend;
     48        for(;TEST(this.i < N); this.i++) {
    5349
    54                 print("C - Suspending");
    55                 void publish() {
    56                         print("C - Publishing");
     50                print("C - Suspending\n");
     51                suspend{
     52                        print("C - Publishing\n");
    5753                        assert(!the_cor);
    5854                        store( this );
    5955                }
    60                 suspend_then(publish);
    6156                assert(!the_cor);
    62                 print("Coroutine 2");
     57                print("C - Back\n");
    6358                KICK_WATCHDOG;
    6459                yield();
    6560        }
    6661        done = true;
    67         suspend();
     62        suspend;
    6863}
    6964
    … …  
    7772                if(!mine) continue;
    7873
    79                 print("T - took");
     74                print("T - took\n");
    8075                resume(*mine);
    81                 print("T - back");
    8276        }
    8377}

  • tests/concurrent/waitfor/when.cfa

    r3c64c668 r58fe85a  
    5757
    5858void arbiter( global_t & mutex this ) {
     59        // There is a race at start where callers can get in before the arbiter.
     60        // It doesn't really matter here so just restart the loop correctly and move on
     61        this.last_call = 6;
     62
    5963        for( int i = 0; i < N; i++ ) {
    6064                   when( this.last_call == 6 ) waitfor( call1 : this ) { if( this.last_call != 1) { serr | "Expected last_call to be 1 got" | this.last_call; } }
Note: See TracChangeset for help on using the changeset viewer.