Changes in tests/concurrency/barrier/order.cfa [b5f1e850:b2fa3c2]

File:

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

tests/concurrency/barrier/order.cfa

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// order.cfa -- validates barrier return value from barrier block
+// order.cfa -- validates barriers the return value of
+//                                 barrier block
 //
 // Author           : Thierry Delisle
 // Created On       : Fri Apr 01 11:39:09 2022
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Sun Nov 10 11:22:56 2024
-// Update Count     : 20
+// Last Modified By :
+// Last Modified On :
+// Update Count     :
 //
+
+// Test validates barrier and block return value by checking
+// that no more than one thread gets the same return value
 
 #include <concurrency/barrier.hfa>
@@ -19 +23 @@
 #include <thread.hfa>
 
-enum { NUM_LAPS = 173, NUM_THREADS = 11 };
+const unsigned NUM_LAPS = 173;
+const unsigned NUM_THREADS = 11;
 
+// The barrier we are testing
 barrier bar = { NUM_THREADS };
 
-volatile unsigned generation = 0;                                               // count laps
-void last() {
-        generation += 1;                                                                        // last thread at barrier advances
-}
-volatile unsigned * generations;                                                // global array pointer
+// The return values of the previous generation.
+volatile unsigned * generation;
 
 thread Tester {};
 void main( Tester & this ) {
-        for ( l; NUM_LAPS ) {
-                yield( prng( this, 10 ) );                                              // yield for chaos
-                unsigned int order = block( bar, last );                // block at barrier
+        // Repeat a few times
+        for(l; NUM_LAPS) {
+                // Yield for chaos
+                yield( prng(this, 10) );
 
-                // 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
+                // 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;
+        }
 }
 
 int main() {
+        // Create the data ans zero it.
         volatile unsigned gen_data[NUM_THREADS];
-        for( t; NUM_THREADS ) gen_data[t] = 0;
-        generations = gen_data;                                                         // global points at local
+        for(t; NUM_THREADS)
+                gen_data[t] = 0;
 
-        processor p[4];                                                                         // parallelism
-        {                                                                                                       // run experiment
+        generation = gen_data;
+
+        // Run the experiment
+        processor p[4];
+        {
                 Tester testers[NUM_THREADS];
         }