Changes in libcfa/src/concurrency/barrier.hfa [95707a3:b2f3880]

File:

• libcfa/src/concurrency/barrier.hfa (modified) (2 diffs)

libcfa/src/concurrency/barrier.hfa

@@ -1 @@
-//                               -*- Mode: C -*- 
-// 
+//
 // Cforall Version 1.0.0 Copyright (C) 2022 University of Waterloo
-// 
+//
 // The contents of this file are covered under the licence agreement in the
 // file "LICENCE" distributed with Cforall.
 //
-// barrier.hfa -- simple barrier implemented using a monitor
-// 
-// Author           : Peter A. Buhr
-// Created On       : Sun Nov 10 08:07:35 2024
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Nov 13 12:37:04 2024
-// Update Count     : 9
-// 
+// barrier.hfa -- simple barrier implemented from monitors
+//
+// Author           : Thierry Delisle
+// Created On       : Thu Mar 31 16:51:35 2022
+// Last Modified By :
+// Last Modified On :
+// Update Count     :
+//
 
 #pragma once
@@ -19 +18 @@
 #include <monitor.hfa>
 
-// Plan 9 inheritance does not work with monitors. Two monitor locks are created.
+// Simple barrier based on a monitor
+monitor barrier {
+        // Number of threads blocking needed to unblock the barrier
+        // Unsigned should be enough, I don't expect use cases with 2^32 thread barriers.
+        unsigned width;
 
-monitor barrier {
-        unsigned int group, arrivals;                                           // group size, arrival counter
-        condition c;                                                                            // wait for group to form
+        // Current count (counting backwards)
+        unsigned count;
+
+        // Barrier uses internal scheduling
+        condition c;
 };
 
-static inline void ?{}( barrier & b, unsigned int group ) {
-        b.group = b.arrivals = group;                                           // arrivals count backward
+// Constructor
+void ?{}( barrier & this, unsigned width ) {
+        this.width = width;
+        this.count = width; // Count backwards so initialize at width
 }
 
-// Returns a value indicating the reverse order the threads arrived, i.e. last thread returns 0 (and does not block)
-// last is an optional hook that is called by the Gth thread before unblocking the other threads.
-static inline unsigned int block( barrier & mutex b, fptr_t last = (fptr_t)0 ) with( b ) {
-        arrivals -= 1;                                                                          // prefix decrement so last is 0 not 1
-        unsigned arrived = b.arrivals;                                          // note arrival order
-        if ( arrivals != 0 ) {                                                          // wait for group to form
-                wait( b.c );
-        } else {                                                                                        // group formed
-                if ( last ) last();                                                             // safe to call
-                signal_all( c );                                                                // unblock group
-                arrivals = group;                                                               // reset
-        } // if
-        return arrived;                                                                         // return arrival order
+// block until the number of threads needed have blocked
+// returns an value indicating the reverse order the threads arrived in
+// i.e. last thread will return 0 (and not block)
+//      second last thread returns 1
+//      etc.
+// last is an optional hook that will be called by the last thread
+// before unblocking the others
+static inline unsigned block(barrier & mutex this, fptr_t last = (fptr_t)0 ) {
+        this.count -= 1; // prefix decrement so we the last is 0 and not 1
+        unsigned arrival = this.count; // Note arrival order
+        if(arrival == 0) {
+                if(last) last();
+                // If arrived last unblock everyone and reset
+                signal_all(this.c);
+                this.count = this.width;
+        } else {
+                // Otherwise block
+                wait(this.c);
+        }
+        return arrival; // return arrival order
 }