Changeset 2a301ff for tests/concurrency

Timestamp:

Aug 31, 2023, 11:31:15 PM (3 years ago)

Author:

JiadaL <j82liang@…>

Branches:

master, stuck-waitfor-destruct

Children:

950c58e

Parents:

92355883 (diff), 686912c (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:

Resolve conflict

Location:

tests/concurrency

Files:

• actors/inherit.cfa (modified) (1 diff)
• channels/daisy_chain.cfa (modified) (2 diffs)
• mutexstmt/.expect/tuple.txt (added)
• mutexstmt/tuple.cfa (added)
• unified_locking/thread_test.cfa (modified) (1 diff)
• waituntil/.expect/repeat_close.txt (added)
• waituntil/all_types.cfa (modified) (1 diff)
• waituntil/channel_close.cfa (modified) (3 diffs)
• waituntil/channel_zero_size.cfa (modified) (1 diff)
• waituntil/channels.cfa (modified) (1 diff)
• waituntil/one_chan.cfa (modified) (1 diff)
• waituntil/repeat_close.cfa (added)
• waituntil/timeout.cfa (modified) (1 diff)

tests/concurrency/actors/inherit.cfa

@@ -13 +13 @@
 struct D_msg { int a; inline message; };
 void ?{}( D_msg & this ) { set_allocation( this, Delete ); }
-void ^?{}( D_msg & this ) { mutex(sout) sout | 'A'; }
+void ^?{}( D_msg & ) { mutex(sout) sout | 'A'; }
 
 struct D_msg2 { inline D_msg; };

tests/concurrency/channels/daisy_chain.cfa

@@ -19 +19 @@
 void main(Task & this) {
     size_t runs = 0;
+    int token = 0;
     try{
         for ( ;; ) {
-            remove( *chain );
-            insert( *chain, 0 );
+            token << *chain;
+            *chain << token;
             runs++;
         }
@@ -59 +60 @@
     Channel chainChan{ 1 };
 
-    insert( chainChan, 0 );
+    chainChan << ((int)0);
 
     chain = &chainChan;    

tests/concurrency/unified_locking/thread_test.cfa

@@ -3 +3 @@
 #include <stdlib.hfa>
 #include <thread.hfa>
-#include <containers/array.hfa>
+#include <collections/array.hfa>
 
 static unsigned int taskCount = 4;

tests/concurrency/waituntil/all_types.cfa

@@ -96 +96 @@
             Churner c;
             for( long long int j = 0; j < numtimes; j++ ) {
-                when( j % 2 == 0 ) waituntil( j >> A ) { total += j; }
+                when( j % 2 == 0 ) waituntil( A << j ) { total += j; }
                 or when( j % 4 < 2 ) waituntil( B ) { produce_b_val( total ); }
-                and when( j % 8 < 4 ) waituntil( j >> C ) { total += j; }
+                and when( j % 8 < 4 ) waituntil( C << j ) { total += j; }
                 and waituntil( timeout( 1`ns ) ) {}
                 if ( j == numtimes / 2 )

tests/concurrency/waituntil/channel_close.cfa

@@ -13 +13 @@
     try {
         for( long long int i = 0;;i++ ) {
-            waituntil( (i >> A) ) { inserts++; }
-            and waituntil( (i >> B) ) { inserts++; }
+            waituntil( A << i ) { inserts++; }
+            and waituntil( B << i ) { inserts++; }
         }
     } catch ( channel_closed * e ) {} 
@@ -31 +31 @@
             }
             waituntil( (in << A) ) { assert( A_removes == in ); A_removes++; removes++; }
-            or waituntil( (in2 << B) ) { assert( B_removes == in2 ); B_removes++; removes++; }
+            or waituntil( (in << B) ) { assert( B_removes == in ); B_removes++; removes++; }
         }
     } catchResume ( channel_closed * e ) {} // continue to remove until would block
@@ -74 +74 @@
     ^B{};
 
+    useAnd = true;
+
     inserts = 0;
     removes = 0;

tests/concurrency/waituntil/channel_zero_size.cfa

@@ -37 +37 @@
         for( long long int j = 0; j < numtimes; j++ ) {
             // printf("loop\n");
-            waituntil( j >> A ) { total += j; }
-            or waituntil( j >> B ) { total += j; }
-            or waituntil( j >> C ) { total += j; }
+            waituntil( A << j ) { total += j; }
+            or waituntil( B << j ) { total += j; }
+            or waituntil( C << j ) { total += j; }
         }
         printf("sending sentinels\n");

tests/concurrency/waituntil/channels.cfa

@@ -69 +69 @@
             Churner c;
             for( long long int j = 0; j < numtimes; j++ ) {
-                when( j % 2 == 0 ) waituntil( j >> A ) { total += j; }
-                or when( j % 4 < 2 ) waituntil( j >> B ) { total += j; }
-                and when( j % 8 < 4 ) waituntil( j >> C ) { total += j; }
+                when( j % 2 == 0 ) waituntil( A << j ) { total += j; }
+                or when( j % 4 < 2 ) waituntil( B << j ) { total += j; }
+                and when( j % 8 < 4 ) waituntil( C << j ) { total += j; }
             }
             done = true;

tests/concurrency/waituntil/one_chan.cfa

@@ -31 +31 @@
         Server1 s[numServers];
         for( long long int j = 0; j < numtimes; j++ ) {
-            waituntil( j >> C ) { total += j; }
+            waituntil( C << j ) { total += j; }
         }
         printf("waiting for empty channels\n");

tests/concurrency/waituntil/timeout.cfa

@@ -15 +15 @@
 
     assert( count == 1000 );
+    sleep( 1`ms );
     printf("done\n");
 }