Registration. Unlike the case for other barriers, the + * number of parties registered to synchronize on a phaser + * may vary over time. Tasks may be registered at any time (using + * methods {@link #register}, {@link #bulkRegister}, or forms of + * constructors establishing initial numbers of parties), and + * optionally deregistered upon any arrival (using {@link + * #arriveAndDeregister}). As is the case with most basic + * synchronization constructs, registration and deregistration affect + * only internal counts; they do not establish any further internal + * bookkeeping, so tasks cannot query whether they are registered. + * (However, you can introduce such bookkeeping by subclassing this + * class.) * - *
Synchronization. Like a {@code CyclicBarrier}, a {@code + * Phaser} may be repeatedly awaited. Method {@link + * #arriveAndAwaitAdvance} has effect analogous to {@link + * java.util.concurrent.CyclicBarrier#await CyclicBarrier.await}. Each + * generation of a phaser has an associated phase number. The phase + * number starts at zero, and advances when all parties arrive at the + * phaser, wrapping around to zero after reaching {@code + * Integer.MAX_VALUE}. The use of phase numbers enables independent + * control of actions upon arrival at a phaser and upon awaiting + * others, via two kinds of methods that may be invoked by any + * registered party: * *
Termination. A phaser may enter a termination + * state in which all synchronization methods immediately return + * without updating phaser state or waiting for advance, and + * indicating (via a negative phase value) that execution is complete. + * Termination is triggered when an invocation of {@code onAdvance} + * returns {@code true}. The default implementation returns {@code + * true} if a deregistration has caused the number of registered + * parties to become zero. As illustrated below, when phasers control + * actions with a fixed number of iterations, it is often convenient + * to override this method to cause termination when the current phase + * number reaches a threshold. Method {@link #forceTermination} is + * also available to abruptly release waiting threads and allow them + * to terminate. * - *
Tiering. Phasers may be tiered (i.e., + * constructed in tree structures) to reduce contention. Phasers with + * large numbers of parties that would otherwise experience heavy + * synchronization contention costs may instead be set up so that + * groups of sub-phasers share a common parent. This may greatly + * increase throughput even though it incurs greater per-operation + * overhead. * - *
Monitoring. While synchronization methods may be invoked + * only by registered parties, the current state of a phaser may be + * monitored by any caller. At any given moment there are {@link + * #getRegisteredParties} parties in total, of which {@link + * #getArrivedParties} have arrived at the current phase ({@link + * #getPhase}). When the remaining ({@link #getUnarrivedParties}) + * parties arrive, the phase advances. The values returned by these + * methods may reflect transient states and so are not in general + * useful for synchronization control. Method {@link #toString} + * returns snapshots of these state queries in a form convenient for + * informal monitoring. + * + *
Sample usages: + * + *
A {@code Phaser} may be used instead of a {@code CountDownLatch} + * to control a one-shot action serving a variable number of parties. + * The typical idiom is for the method setting this up to first + * register, then start the actions, then deregister, as in: + * + *
{@code
+ * void runTasks(List tasks) {
+ * final Phaser phaser = new Phaser(1); // "1" to register self
+ * // create and start threads
+ * for (Runnable task : tasks) {
+ * phaser.register();
+ * new Thread() {
+ * public void run() {
+ * phaser.arriveAndAwaitAdvance(); // await all creation
+ * task.run();
+ * }
+ * }.start();
+ * }
+ *
+ * // allow threads to start and deregister self
+ * phaser.arriveAndDeregister();
+ * }}
+ *
+ * One way to cause a set of threads to repeatedly perform actions + * for a given number of iterations is to override {@code onAdvance}: + * + *
{@code
+ * void startTasks(List tasks, final int iterations) {
+ * final Phaser phaser = new Phaser() {
+ * protected boolean onAdvance(int phase, int registeredParties) {
+ * return phase >= iterations || registeredParties == 0;
+ * }
+ * };
+ * phaser.register();
+ * for (final Runnable task : tasks) {
+ * phaser.register();
+ * new Thread() {
+ * public void run() {
+ * do {
+ * task.run();
+ * phaser.arriveAndAwaitAdvance();
+ * } while (!phaser.isTerminated());
+ * }
+ * }.start();
+ * }
+ * phaser.arriveAndDeregister(); // deregister self, don't wait
+ * }}
*
- * Sample usage: + * If the main task must later await termination, it + * may re-register and then execute a similar loop: + *
{@code
+ * // ...
+ * phaser.register();
+ * while (!phaser.isTerminated())
+ * phaser.arriveAndAwaitAdvance();}
*
- * [todo: non-FJ example] + *
Related constructions may be used to await particular phase numbers + * in contexts where you are sure that the phase will never wrap around + * {@code Integer.MAX_VALUE}. For example: * - *
A Phaser may be used to support a style of programming in - * which a task waits for others to complete, without otherwise - * needing to keep track of which tasks it is waiting for. This is - * similar to the "sync" construct in Cilk and "clocks" in X10. - * Special constructions based on such barriers are available using - * the LinkedAsyncAction and CyclicAction classes, - * but they can be useful in other contexts as well. For a simple - * (but not very useful) example, here is a variant of Fibonacci: - * - *
- * class BarrierFibonacci extends RecursiveAction {
- * int argument, result;
- * final Phaser parentBarrier;
- * BarrierFibonacci(int n, Phaser parentBarrier) {
- * this.argument = n;
- * this.parentBarrier = parentBarrier;
- * parentBarrier.register();
+ * {@code
+ * void awaitPhase(Phaser phaser, int phase) {
+ * int p = phaser.register(); // assumes caller not already registered
+ * while (p < phase) {
+ * if (phaser.isTerminated())
+ * // ... deal with unexpected termination
+ * else
+ * p = phaser.arriveAndAwaitAdvance();
* }
- * protected void compute() {
- * int n = argument;
- * if (n <= 1)
- * result = n;
- * else {
- * Phaser childBarrier = new Phaser(1);
- * BarrierFibonacci f1 = new BarrierFibonacci(n - 1, childBarrier);
- * BarrierFibonacci f2 = new BarrierFibonacci(n - 2, childBarrier);
- * f1.fork();
- * f2.fork();
- * childBarrier.arriveAndAwait();
- * result = f1.result + f2.result;
+ * phaser.arriveAndDeregister();
+ * }}
+ *
+ *
+ * To create a set of {@code n} tasks using a tree of phasers, you
+ * could use code of the following form, assuming a Task class with a
+ * constructor accepting a {@code Phaser} that it registers with upon
+ * construction. After invocation of {@code build(new Task[n], 0, n,
+ * new Phaser())}, these tasks could then be started, for example by
+ * submitting to a pool:
+ *
+ *
{@code
+ * void build(Task[] tasks, int lo, int hi, Phaser ph) {
+ * if (hi - lo > TASKS_PER_PHASER) {
+ * for (int i = lo; i < hi; i += TASKS_PER_PHASER) {
+ * int j = Math.min(i + TASKS_PER_PHASER, hi);
+ * build(tasks, i, j, new Phaser(ph));
* }
- * parentBarrier.arriveAndDeregister();
+ * } else {
+ * for (int i = lo; i < hi; ++i)
+ * tasks[i] = new Task(ph);
+ * // assumes new Task(ph) performs ph.register()
* }
- * }
- *
+ * }}
+ *
+ * The best value of {@code TASKS_PER_PHASER} depends mainly on
+ * expected synchronization rates. A value as low as four may
+ * be appropriate for extremely small per-phase task bodies (thus
+ * high rates), or up to hundreds for extremely large ones.
*
* Implementation notes: This implementation restricts the
- * maximum number of parties to 65535. Attempts to register
- * additional parties result in IllegalStateExceptions.
+ * maximum number of parties to 65535. Attempts to register additional
+ * parties result in {@code IllegalStateException}. However, you can and
+ * should create tiered phasers to accommodate arbitrarily large sets
+ * of participants.
+ *
+ * @since 1.7
+ * @author Doug Lea
*/
public class Phaser {
/*
* This class implements an extension of X10 "clocks". Thanks to
- * Vijay Saraswat for the idea of applying it to ForkJoinTasks,
- * and to Vivek Sarkar for enhancements to extend functionality.
+ * Vijay Saraswat for the idea, and to Vivek Sarkar for
+ * enhancements to extend functionality.
*/
/**
- * Barrier state representation. Conceptually, a barrier contains
- * four values:
- *
- * * parties -- the number of parties to wait (16 bits)
- * * unarrived -- the number of parties yet to hit barrier (16 bits)
- * * phase -- the generation of the barrier (31 bits)
- * * terminated -- set if barrier is terminated (1 bit)
+ * Primary state representation, holding four fields:
*
- * However, to efficiently maintain atomicity, these values are
- * packed into a single AtomicLong. Termination uses the sign bit
- * of 32 bit representation of phase, so phase is set to -1 on
- * termination.
- */
- private final AtomicLong state;
-
- /**
- * Head of Treiber stack for waiting nonFJ threads.
- */
- private final AtomicReference It is a usage error for an unregistered party to invoke this
+ * method. However, this error may result in an {@code
+ * IllegalStateException} only upon some subsequent operation on
+ * this phaser, if ever.
*
- * @return the current barrier phase number upon entry to
- * this method, or a negative value if terminated;
- * @throws IllegalStateException if the number of registered or
- * unarrived parties would become negative.
+ * @return the arrival phase number, or a negative value if terminated
+ * @throws IllegalStateException if not terminated and the number
+ * of unarrived parties would become negative
*/
- public int arriveAndDeregister() { // Same as arrive, plus decrement parties
- final AtomicLong state = this.state;
- for (;;) {
- long s = state.get();
- int phase = phaseOf(s);
- int parties = partiesOf(s) - 1;
- int unarrived = unarrivedOf(s) - 1;
- if (parties < 0 || unarrived < 0)
- throw badBounds(parties, unarrived);
- if (unarrived == 0 && phase >= 0) {
- trip(phase, parties);
- return phase;
- }
- if (state.compareAndSet(s, stateFor(phase, parties, unarrived)))
- return phase;
- }
+ public int arrive() {
+ return doArrive(false);
+ }
+
+ /**
+ * Arrives at this phaser and deregisters from it without waiting
+ * for others to arrive. Deregistration reduces the number of
+ * parties required to advance in future phases. If this phaser
+ * has a parent, and deregistration causes this phaser to have
+ * zero parties, this phaser is also deregistered from its parent.
+ *
+ * It is a usage error for an unregistered party to invoke this
+ * method. However, this error may result in an {@code
+ * IllegalStateException} only upon some subsequent operation on
+ * this phaser, if ever.
+ *
+ * @return the arrival phase number, or a negative value if terminated
+ * @throws IllegalStateException if not terminated and the number
+ * of registered or unarrived parties would become negative
+ */
+ public int arriveAndDeregister() {
+ return doArrive(true);
}
/**
- * Arrives at the barrier and awaits others. Unlike other arrival
- * methods, this method returns the arrival index of the
- * caller. The caller tripping the barrier returns zero, the
- * previous caller 1, and so on.
- * @return the arrival index
- * @throws IllegalStateException if the number of unarrived
- * parties would become negative.
+ * Arrives at this phaser and awaits others. Equivalent in effect
+ * to {@code awaitAdvance(arrive())}. If you need to await with
+ * interruption or timeout, you can arrange this with an analogous
+ * construction using one of the other forms of the {@code
+ * awaitAdvance} method. If instead you need to deregister upon
+ * arrival, use {@code awaitAdvance(arriveAndDeregister())}.
+ *
+ * It is a usage error for an unregistered party to invoke this
+ * method. However, this error may result in an {@code
+ * IllegalStateException} only upon some subsequent operation on
+ * this phaser, if ever.
+ *
+ * @return the arrival phase number, or a negative number if terminated
+ * @throws IllegalStateException if not terminated and the number
+ * of unarrived parties would become negative
*/
public int arriveAndAwaitAdvance() {
- final AtomicLong state = this.state;
- for (;;) {
- long s = state.get();
- int phase = phaseOf(s);
- int parties = partiesOf(s);
- int unarrived = unarrivedOf(s) - 1;
- if (unarrived < 0)
- throw badBounds(parties, unarrived);
- if (unarrived == 0 && phase >= 0) {
- trip(phase, parties);
- return 0;
- }
- if (state.compareAndSet(s, stateFor(phase, parties, unarrived))) {
- awaitAdvance(phase);
- return unarrived;
- }
- }
+ return awaitAdvance(doArrive(false));
}
/**
- * Awaits the phase of the barrier to advance from the given
- * value, or returns immediately if this barrier is terminated
- * @param phase the phase on entry to this method
- * @return the phase on exit from this method
+ * Awaits the phase of this phaser to advance from the given phase
+ * value, returning immediately if the current phase is not equal
+ * to the given phase value or this phaser is terminated.
+ *
+ * @param phase an arrival phase number, or negative value if
+ * terminated; this argument is normally the value returned by a
+ * previous call to {@code arrive} or {@code arriveAndDeregister}.
+ * @return the next arrival phase number, or a negative value
+ * if terminated or argument is negative
*/
public int awaitAdvance(int phase) {
+ Phaser rt;
+ int p = (int)(state >>> PHASE_SHIFT);
if (phase < 0)
return phase;
- Thread current = Thread.currentThread();
- if (current instanceof ForkJoinWorkerThread)
- return helpingWait(phase);
- if (untimedWait(current, phase, false))
- current.interrupt();
- return phaseOf(state.get());
+ if (p == phase) {
+ if ((p = (int)((rt = root).state >>> PHASE_SHIFT)) == phase)
+ return rt.internalAwaitAdvance(phase, null);
+ reconcileState();
+ }
+ return p;
}
/**
- * Awaits the phase of the barrier to advance from the given
- * value, or returns immediately if this barrier is terminated, or
- * throws InterruptedException if interrupted while waiting.
- * @param phase the phase on entry to this method
- * @return the phase on exit from this method
+ * Awaits the phase of this phaser to advance from the given phase
+ * value, throwing {@code InterruptedException} if interrupted
+ * while waiting, or returning immediately if the current phase is
+ * not equal to the given phase value or this phaser is
+ * terminated.
+ *
+ * @param phase an arrival phase number, or negative value if
+ * terminated; this argument is normally the value returned by a
+ * previous call to {@code arrive} or {@code arriveAndDeregister}.
+ * @return the next arrival phase number, or a negative value
+ * if terminated or argument is negative
* @throws InterruptedException if thread interrupted while waiting
*/
- public int awaitAdvanceInterruptibly(int phase) throws InterruptedException {
+ public int awaitAdvanceInterruptibly(int phase)
+ throws InterruptedException {
+ Phaser rt;
+ int p = (int)(state >>> PHASE_SHIFT);
if (phase < 0)
return phase;
- Thread current = Thread.currentThread();
- if (current instanceof ForkJoinWorkerThread)
- return helpingWait(phase);
- else if (Thread.interrupted() || untimedWait(current, phase, true))
- throw new InterruptedException();
- else
- return phaseOf(state.get());
+ if (p == phase) {
+ if ((p = (int)((rt = root).state >>> PHASE_SHIFT)) == phase) {
+ QNode node = new QNode(this, phase, true, false, 0L);
+ p = rt.internalAwaitAdvance(phase, node);
+ if (node.wasInterrupted)
+ throw new InterruptedException();
+ }
+ else
+ reconcileState();
+ }
+ return p;
}
/**
- * Awaits the phase of the barrier to advance from the given value
- * or the given timeout elapses, or returns immediately if this
- * barrier is terminated
- * @param phase the phase on entry to this method
- * @return the phase on exit from this method
+ * Awaits the phase of this phaser to advance from the given phase
+ * value or the given timeout to elapse, throwing {@code
+ * InterruptedException} if interrupted while waiting, or
+ * returning immediately if the current phase is not equal to the
+ * given phase value or this phaser is terminated.
+ *
+ * @param phase an arrival phase number, or negative value if
+ * terminated; this argument is normally the value returned by a
+ * previous call to {@code arrive} or {@code arriveAndDeregister}.
+ * @param timeout how long to wait before giving up, in units of
+ * {@code unit}
+ * @param unit a {@code TimeUnit} determining how to interpret the
+ * {@code timeout} parameter
+ * @return the next arrival phase number, or a negative value
+ * if terminated or argument is negative
* @throws InterruptedException if thread interrupted while waiting
* @throws TimeoutException if timed out while waiting
*/
- public int awaitAdvanceInterruptibly(int phase, long timeout, TimeUnit unit)
+ public int awaitAdvanceInterruptibly(int phase,
+ long timeout, TimeUnit unit)
throws InterruptedException, TimeoutException {
+ long nanos = unit.toNanos(timeout);
+ Phaser rt;
+ int p = (int)(state >>> PHASE_SHIFT);
if (phase < 0)
return phase;
- long nanos = unit.toNanos(timeout);
- Thread current = Thread.currentThread();
- if (current instanceof ForkJoinWorkerThread)
- return timedHelpingWait(phase, nanos);
- timedWait(current, phase, nanos);
- return phaseOf(state.get());
+ if (p == phase) {
+ if ((p = (int)((rt = root).state >>> PHASE_SHIFT)) == phase) {
+ QNode node = new QNode(this, phase, true, true, nanos);
+ p = rt.internalAwaitAdvance(phase, node);
+ if (node.wasInterrupted)
+ throw new InterruptedException();
+ else if (p == phase)
+ throw new TimeoutException();
+ }
+ else
+ reconcileState();
+ }
+ return p;
}
/**
- * Forces this barrier to enter termination state. Counts of
- * arrived and registered parties are unaffected. This method may
- * be useful for coordinating recovery after one or more tasks
- * encounter unexpected exceptions.
+ * Forces this phaser to enter termination state. Counts of
+ * registered parties are unaffected. If this phaser is a member
+ * of a tiered set of phasers, then all of the phasers in the set
+ * are terminated. If this phaser is already terminated, this
+ * method has no effect. This method may be useful for
+ * coordinating recovery after one or more tasks encounter
+ * unexpected exceptions.
*/
public void forceTermination() {
- final AtomicLong state = this.state;
- for (;;) {
- long s = state.get();
- int phase = phaseOf(s);
- int parties = partiesOf(s);
- int unarrived = unarrivedOf(s);
- if (phase < 0 ||
- state.compareAndSet(s, stateFor(-1, parties, unarrived))) {
- if (head.get() != null)
- releaseWaiters(-1);
+ // Only need to change root state
+ final Phaser root = this.root;
+ long s;
+ while ((s = root.state) >= 0) {
+ long next = (s & ~(long)(MAX_PARTIES)) | TERMINATION_BIT;
+ if (UNSAFE.compareAndSwapLong(root, stateOffset, s, next)) {
+ releaseWaiters(0); // signal all threads
+ releaseWaiters(1);
return;
}
}
}
/**
- * Resets the barrier with the given numbers of registered unarrived
- * parties and phase number 0. This method allows repeated reuse
- * of this barrier, but only if it is somehow known not to be in
- * use for other purposes.
- * @param parties the number of parties required to trip barrier.
- * @throws IllegalArgumentException if parties less than zero
- * or greater than the maximum number of parties supported.
- */
- public void reset(int parties) {
- if (parties < 0 || parties > ushortMask)
- throw new IllegalArgumentException("Illegal number of parties");
- state.set(stateFor(0, parties, parties));
- if (head.get() != null)
- releaseWaiters(0);
- }
-
- /**
* Returns the current phase number. The maximum phase number is
- * Integer.MAX_VALUE, after which it restarts at
- * zero. Upon termination, the phase number is negative.
+ * {@code Integer.MAX_VALUE}, after which it restarts at
+ * zero. Upon termination, the phase number is negative,
+ * in which case the prevailing phase prior to termination
+ * may be obtained via {@code getPhase() + Integer.MIN_VALUE}.
+ *
* @return the phase number, or a negative value if terminated
*/
- public int getPhase() {
- return phaseOf(state.get());
+ public final int getPhase() {
+ return (int)(root.state >>> PHASE_SHIFT);
}
/**
- * Returns the number of parties registered at this barrier.
+ * Returns the number of parties registered at this phaser.
+ *
* @return the number of parties
*/
public int getRegisteredParties() {
- return partiesOf(state.get());
+ return partiesOf(state);
}
/**
- * Returns the number of parties that have arrived at the current
- * phase of this barrier.
+ * Returns the number of registered parties that have arrived at
+ * the current phase of this phaser.
+ *
* @return the number of arrived parties
*/
public int getArrivedParties() {
- return arrivedOf(state.get());
+ return arrivedOf(reconcileState());
}
/**
* Returns the number of registered parties that have not yet
- * arrived at the current phase of this barrier.
+ * arrived at the current phase of this phaser.
+ *
* @return the number of unarrived parties
*/
public int getUnarrivedParties() {
- return unarrivedOf(state.get());
+ return unarrivedOf(reconcileState());
+ }
+
+ /**
+ * Returns the parent of this phaser, or {@code null} if none.
+ *
+ * @return the parent of this phaser, or {@code null} if none
+ */
+ public Phaser getParent() {
+ return parent;
+ }
+
+ /**
+ * Returns the root ancestor of this phaser, which is the same as
+ * this phaser if it has no parent.
+ *
+ * @return the root ancestor of this phaser
+ */
+ public Phaser getRoot() {
+ return root;
}
/**
- * Returns true if this barrier has been terminated
- * @return true if this barrier has been terminated
+ * Returns {@code true} if this phaser has been terminated.
+ *
+ * @return {@code true} if this phaser has been terminated
*/
public boolean isTerminated() {
- return phaseOf(state.get()) < 0;
+ return root.state < 0L;
}
/**
- * Overridable method to perform an action upon phase advance, and
- * to control termination. This method is invoked whenever the
- * barrier is tripped (and thus all other waiting parties are
- * dormant). If it returns true, then, rather than advance the
- * phase number, this barrier will be set to a final termination
- * state, and subsequent calls to isTerminated will
- * return true.
- *
- * The default version returns true when the number of
- * registered parties is zero. Normally, overrides that arrange
- * termination for other reasons should also preserve this
- * property.
- *
- * @param phase the phase number on entering the barrier
- * @param registeredParties the current number of registered
- * parties.
- * @return true if this barrier should terminate
+ * Overridable method to perform an action upon impending phase
+ * advance, and to control termination. This method is invoked
+ * upon arrival of the party advancing this phaser (when all other
+ * waiting parties are dormant). If this method returns {@code
+ * true}, this phaser will be set to a final termination state
+ * upon advance, and subsequent calls to {@link #isTerminated}
+ * will return true. Any (unchecked) Exception or Error thrown by
+ * an invocation of this method is propagated to the party
+ * attempting to advance this phaser, in which case no advance
+ * occurs.
+ *
+ * The arguments to this method provide the state of the phaser
+ * prevailing for the current transition. The effects of invoking
+ * arrival, registration, and waiting methods on this phaser from
+ * within {@code onAdvance} are unspecified and should not be
+ * relied on.
+ *
+ * If this phaser is a member of a tiered set of phasers, then
+ * {@code onAdvance} is invoked only for its root phaser on each
+ * advance.
+ *
+ * To support the most common use cases, the default
+ * implementation of this method returns {@code true} when the
+ * number of registered parties has become zero as the result of a
+ * party invoking {@code arriveAndDeregister}. You can disable
+ * this behavior, thus enabling continuation upon future
+ * registrations, by overriding this method to always return
+ * {@code false}:
+ *
+ * {@code
+ * Phaser phaser = new Phaser() {
+ * protected boolean onAdvance(int phase, int parties) { return false; }
+ * }}
+ *
+ * @param phase the current phase number on entry to this method,
+ * before this phaser is advanced
+ * @param registeredParties the current number of registered parties
+ * @return {@code true} if this phaser should terminate
*/
protected boolean onAdvance(int phase, int registeredParties) {
- return registeredParties <= 0;
+ return registeredParties == 0;
}
/**
- * Returns a string identifying this barrier, as well as its
+ * Returns a string identifying this phaser, as well as its
* state. The state, in brackets, includes the String {@code
- * "phase ="} followed by the phase number, {@code "parties ="}
+ * "phase = "} followed by the phase number, {@code "parties = "}
* followed by the number of registered parties, and {@code
- * "arrived ="} followed by the number of arrived parties
+ * "arrived = "} followed by the number of arrived parties.
*
- * @return a string identifying this barrier, as well as its state
+ * @return a string identifying this phaser, as well as its state
*/
public String toString() {
- long s = state.get();
- return super.toString() + "[phase = " + phaseOf(s) + " parties = " + partiesOf(s) + " arrived = " + arrivedOf(s) + "]";
+ return stateToString(reconcileState());
}
- // methods for tripping and waiting
-
/**
- * Advance the current phase (or terminate)
+ * Implementation of toString and string-based error messages
*/
- private void trip(int phase, int parties) {
- int next = onAdvance(phase, parties)? -1 : ((phase + 1) & phaseMask);
- state.set(stateFor(next, parties, parties));
- if (head.get() != null)
- releaseWaiters(next);
+ private String stateToString(long s) {
+ return super.toString() +
+ "[phase = " + phaseOf(s) +
+ " parties = " + partiesOf(s) +
+ " arrived = " + arrivedOf(s) + "]";
}
- private int helpingWait(int phase) {
- final AtomicLong state = this.state;
- int p;
- while ((p = phaseOf(state.get())) == phase) {
- ForkJoinTask t = ForkJoinWorkerThread.pollTask();
- if (t != null) {
- if ((p = phaseOf(state.get())) == phase)
- t.exec();
- else { // push task and exit if barrier advanced
- t.fork();
- break;
- }
+ // Waiting mechanics
+
+ /**
+ * Removes and signals threads from queue for phase.
+ */
+ private void releaseWaiters(int phase) {
+ QNode q; // first element of queue
+ int p; // its phase
+ Thread t; // its thread
+ // assert phase != phaseOf(root.state);
+ AtomicReference