Changeset b5f1e850

Timestamp:

Nov 11, 2024, 10:33:51 PM (10 days ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

master

Children:

0cb3479

Parents:

a3af522

Message:

update barrier test programs after changes

File:

• tests/concurrency/barrier/order.cfa (modified) (2 diffs)

tests/concurrency/barrier/order.cfa

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// order.cfa -- validates barriers the return value of
-//                                 barrier block
+// order.cfa -- validates barrier return value from barrier block
 //
 // Author           : Thierry Delisle
 // Created On       : Fri Apr 01 11:39:09 2022
-// Last Modified By :
-// Last Modified On :
-// Update Count     :
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Sun Nov 10 11:22:56 2024
+// Update Count     : 20
 //
-
-// Test validates barrier and block return value by checking
-// that no more than one thread gets the same return value
 
 #include <concurrency/barrier.hfa>
@@ -23 +19 @@
 #include <thread.hfa>
 
-const unsigned NUM_LAPS = 173;
-const unsigned NUM_THREADS = 11;
+enum { NUM_LAPS = 173, NUM_THREADS = 11 };
 
-// The barrier we are testing
 barrier bar = { NUM_THREADS };
 
-// The return values of the previous generation.
-volatile unsigned * generation;
+volatile unsigned generation = 0;                                               // count laps
+void last() {
+        generation += 1;                                                                        // last thread at barrier advances
+}
+volatile unsigned * generations;                                                // global array pointer
 
 thread Tester {};
 void main( Tester & this ) {
-        // Repeat a few times
-        for(l; NUM_LAPS) {
-                // Yield for chaos
-                yield( prng(this, 10) );
+        for ( l; NUM_LAPS ) {
+                yield( prng( this, 10 ) );                                              // yield for chaos
+                unsigned int order = block( bar, last );                // block at barrier
 
-                // Block and what order we arrived
-                unsigned ret = block(bar);
-
-                // Check what was the last generation of that last thread in this position
-                unsigned g = generation[ret];
-
-                // Is it what we expect?
-                if(g != l) {
-                        // Complain that they are different
-                        sout | "Gen" | l | ": Expeced generation at" | ret | "to be" | l | "was" | g;
-                }
-
-                // Mark the expected next generation
-                generation[ret] = l+1;
-        }
+                // For G == T, no thread should be able to advance generation until current generation finishes.
+                if ( generation - 1 != l || generations[order] != l ) { // generation advanced in block
+                        mutex( sout ) sout | "mismatched generation, expected" | l | "got" | generation;
+                } // if
+                generations[order] = l + 1;                                             // every thread advances their current order generation
+        } // for
 }
 
 int main() {
-        // Create the data ans zero it.
         volatile unsigned gen_data[NUM_THREADS];
-        for(t; NUM_THREADS)
-                gen_data[t] = 0;
+        for( t; NUM_THREADS ) gen_data[t] = 0;
+        generations = gen_data;                                                         // global points at local
 
-        generation = gen_data;
-
-        // Run the experiment
-        processor p[4];
-        {
+        processor p[4];                                                                         // parallelism
+        {                                                                                                       // run experiment
                 Tester testers[NUM_THREADS];
         }