Changeset 31ef267 for tests/concurrent/barrier

Timestamp:

Apr 1, 2022, 12:40:35 PM (3 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, ast-experimental, enum, master, pthread-emulation, qualifiedEnum

Children:

1417f6b

Parents:

93b8cf4

Message:

Added comments.

Location:

tests/concurrent/barrier

Files:

• generation.cfa (modified) (2 diffs)
• order.cfa (modified) (3 diffs)

tests/concurrent/barrier/generation.cfa

@@ -15 +15 @@
 //
 
+// Test validates barrier by having each thread print ABCD...
+// If the barrier is correct it should print all As, all Bs, etc.
 
-int NUM_THREADS = 9;
-int NUM_LAPS = 53;
+unsigned NUM_THREADS = 9;
+unsigned NUM_LAPS = 53;
 
 #include <concurrency/barrier.hfa>
@@ -24 +26 @@
 #include <thread.hfa>
 
+// The barrier we are testing
 barrier bar = { NUM_THREADS };
+
 
 thread Tester {};
 void main( Tester & this ) {
+        // Repeat the experiment a few times
         for(NUM_LAPS)
+                // For each letters
                 for(c; 'A' ~= 'Z') {
+                        // Yield for chaos
                         yield(prng(this, 10));
+
+                        // Print the generation, no newline because
                         mutex(sout) sout | c | nonl;
+
+                        // Yield again for more chaos
                         yield(prng(this, 10));
+
+                        // Block on the barrier
                         block(bar);
                 }

tests/concurrent/barrier/order.cfa

@@ -15 +15 @@
 //
 
+// Test validates barrier and block return value by checking
+// that no more than one thread gets the same return value
+
 #include <concurrency/barrier.hfa>
 #include <fstream.hfa>
@@ -20 +23 @@
 #include <thread.hfa>
 
-const int NUM_LAPS = 173;
-const int NUM_THREADS = 11;
+const unsigned NUM_LAPS = 173;
+const unsigned NUM_THREADS = 11;
 
+// The barrier we are testing
 barrier bar = { NUM_THREADS };
-volatile int * generation;
+
+// The return values of the previous generation.
+volatile unsigned * generation;
 
 thread Tester {};
 void main( Tester & ) {
+        // Repeat a few times
         for(l; NUM_LAPS) {
-                int ret = block(bar);
-                int g = generation[ret];
+                // 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;
                 }
-                generation[ret] = g+1;
+
+                // Mark the expected next generation
+                generation[ret] = l+1;
         }
 }
 
 int main() {
-        volatile int gen_data[NUM_THREADS];
+        // Create the data ans zero it.
+        volatile unsigned gen_data[NUM_THREADS];
         for(t; NUM_THREADS)
                 gen_data[t] = 0;
@@ -45 +61 @@
         generation = gen_data;
 
+        // Run the experiment
         processor p[4];
         {