/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

/*

 * This file is available under and governed by the GNU General Public

 * License version 2 only, as published by the Free Software Foundation.

 * However, the following notice accompanied the original version of this

 * file:

 *

 * Written by Doug Lea with assistance from members of JCP JSR-166

 * Expert Group and released to the public domain, as explained at

 * http://creativecommons.org/licenses/publicdomain

 */

package java.util.concurrent;

import java.util.concurrent.atomic.AtomicReference;

import java.util.concurrent.locks.LockSupport;

/**

 * A reusable synchronization barrier, similar in functionality to

 * {@link java.util.concurrent.CyclicBarrier CyclicBarrier} and

 * {@link java.util.concurrent.CountDownLatch CountDownLatch}

 * but supporting more flexible usage.

 *

 * <p> <b>Registration.</b> Unlike the case for other barriers, the

 * number of parties <em>registered</em> 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.)

 *

 * <p> <b>Synchronization.</b> 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 {@code Phaser} has an associated phase number. The

 * phase number starts at zero, and advances when all parties arrive

 * at the barrier, wrapping around to zero after reaching {@code

 * Integer.MAX_VALUE}. The use of phase numbers enables independent

 * control of actions upon arrival at a barrier and upon awaiting

 * others, via two kinds of methods that may be invoked by any

 * registered party:

 *

 * <ul>

 *

 *   <li> <b>Arrival.</b> Methods {@link #arrive} and

 *       {@link #arriveAndDeregister} record arrival at a

 *       barrier. These methods do not block, but return an associated

 *       <em>arrival phase number</em>; that is, the phase number of

 *       the barrier to which the arrival applied. When the final

 *       party for a given phase arrives, an optional barrier action

 *       is performed and the phase advances.  Barrier actions,

 *       performed by the party triggering a phase advance, are

 *       arranged by overriding method {@link #onAdvance(int, int)},

 *       which also controls termination. Overriding this method is

 *       similar to, but more flexible than, providing a barrier

 *       action to a {@code CyclicBarrier}.

 *

 *   <li> <b>Waiting.</b> Method {@link #awaitAdvance} requires an

 *       argument indicating an arrival phase number, and returns when

 *       the barrier advances to (or is already at) a different phase.

 *       Unlike similar constructions using {@code CyclicBarrier},

 *       method {@code awaitAdvance} continues to wait even if the

 *       waiting thread is interrupted. Interruptible and timeout

 *       versions are also available, but exceptions encountered while

 *       tasks wait interruptibly or with timeout do not change the

 *       state of the barrier. If necessary, you can perform any

 *       associated recovery within handlers of those exceptions,

 *       often after invoking {@code forceTermination}.  Phasers may

 *       also be used by tasks executing in a {@link ForkJoinPool},

 *       which will ensure sufficient parallelism to execute tasks

 *       when others are blocked waiting for a phase to advance.

 *

 * </ul>

 *

 * <p> <b>Termination.</b> A {@code Phaser} may enter a

 * <em>termination</em> 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}.  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.

 *

 * <p> <b>Tiering.</b> Phasers may be <em>tiered</em> (i.e., arranged

 * 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.

 *

 * <p><b>Monitoring.</b> 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.

 *

 * <p><b>Sample usages:</b>

 *

 * <p>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:

 *

 *  <pre> {@code

 * void runTasks(List<Runnable> 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();

 * }}</pre>

 *

 * <p>One way to cause a set of threads to repeatedly perform actions

 * for a given number of iterations is to override {@code onAdvance}:

 *

 *  <pre> {@code

 * void startTasks(List<Runnable> 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

 * }}</pre>

 *

 * If the main task must later await termination, it

 * may re-register and then execute a similar loop:

 *  <pre> {@code

 *   // ...

 *   phaser.register();

 *   while (!phaser.isTerminated())

 *     phaser.arriveAndAwaitAdvance();}</pre>

 *

 * <p>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:

 *

 *  <pre> {@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();

 *   }

 *   phaser.arriveAndDeregister();

 * }}</pre>

 *

 *

 * <p>To create a set of tasks using a tree of phasers,

 * you could use code of the following form, assuming a

 * Task class with a constructor accepting a phaser that

 * it registers for upon construction:

 *

 *  <pre> {@code

 * void build(Task[] actions, 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(actions, i, j, new Phaser(ph));

 *     }

 *   } else {

 *     for (int i = lo; i < hi; ++i)

 *       actions[i] = new Task(ph);

 *       // assumes new Task(ph) performs ph.register()

 *   }

 * }

 * // .. initially called, for n tasks via

 * build(new Task[n], 0, n, new Phaser());}</pre>

 *

 * The best value of {@code TASKS_PER_PHASER} depends mainly on

 * expected barrier synchronization rates. A value as low as four may

 * be appropriate for extremely small per-barrier task bodies (thus

 * high rates), or up to hundreds for extremely large ones.

 *

 * </pre>

 *

 * <p><b>Implementation notes</b>: This implementation restricts the

 * 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, 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)

     *

     * However, to efficiently maintain atomicity, these values are

     * packed into a single (atomic) long. Termination uses the sign

     * bit of 32 bit representation of phase, so phase is set to -1 on

     * termination. Good performance relies on keeping state decoding

     * and encoding simple, and keeping race windows short.

     *

     * Note: there are some cheats in arrive() that rely on unarrived

     * count being lowest 16 bits.

     */

    private volatile long state;

    private static final int ushortMask = 0xffff;

    private static final int phaseMask  = 0x7fffffff;

    private static int unarrivedOf(long s) {

        return (int) (s & ushortMask);

    }

    private static int partiesOf(long s) {

        return ((int) s) >>> 16;

    }

    private static int phaseOf(long s) {

        return (int) (s >>> 32);

    }

    private static int arrivedOf(long s) {

        return partiesOf(s) - unarrivedOf(s);

    }

    private static long stateFor(int phase, int parties, int unarrived) {

        return ((((long) phase) << 32) | (((long) parties) << 16) |

                (long) unarrived);

    }

    private static long trippedStateFor(int phase, int parties) {

        long lp = (long) parties;

        return (((long) phase) << 32) | (lp << 16) | lp;

    }

    /**

     * Returns message string for bad bounds exceptions.

     */

    private static String badBounds(int parties, int unarrived) {

        return ("Attempt to set " + unarrived +

                " unarrived of " + parties + " parties");

    }

    /**

     * The parent of this phaser, or null if none

     */

    private final Phaser parent;

    /**

     * The root of phaser tree. Equals this if not in a tree.  Used to

     * support faster state push-down.

     */

    private final Phaser root;

    // Wait queues

    /**

     * Heads of Treiber stacks for waiting threads. To eliminate

     * contention while releasing some threads while adding others, we

     * use two of them, alternating across even and odd phases.

     */

    private final AtomicReference<QNode> evenQ = new AtomicReference<QNode>();

    private final AtomicReference<QNode> oddQ  = new AtomicReference<QNode>();

    private AtomicReference<QNode> queueFor(int phase) {

        return ((phase & 1) == 0) ? evenQ : oddQ;

    }

    /**

     * Returns current state, first resolving lagged propagation from

     * root if necessary.

     */

    private long getReconciledState() {

        return (parent == null) ? state : reconcileState();

    }

    /**

     * Recursively resolves state.

     */

    private long reconcileState() {

        Phaser p = parent;

        long s = state;

        if (p != null) {

            while (unarrivedOf(s) == 0 && phaseOf(s) != phaseOf(root.state)) {

                long parentState = p.getReconciledState();

                int parentPhase = phaseOf(parentState);

                int phase = phaseOf(s = state);

                if (phase != parentPhase) {

                    long next = trippedStateFor(parentPhase, partiesOf(s));

                    if (casState(s, next)) {

                        releaseWaiters(phase);

                        s = next;

                    }

                }

            }

        }

        return s;

    }

    /**

     * Creates a new phaser without any initially registered parties,

     * initial phase number 0, and no parent. Any thread using this

     * phaser will need to first register for it.

     */

    public Phaser() {

        this(null);

    }

    /**

     * Creates a new phaser with the given numbers of registered

     * unarrived parties, initial phase number 0, and no parent.

     *

     * @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 Phaser(int parties) {

        this(null, parties);

    }

    /**

     * Creates a new phaser with the given parent, without any

     * initially registered parties. If parent is non-null this phaser

     * is registered with the parent and its initial phase number is

     * the same as that of parent phaser.

     *

     * @param parent the parent phaser

     */

    public Phaser(Phaser parent) {

        int phase = 0;

        this.parent = parent;

        if (parent != null) {

            this.root = parent.root;

            phase = parent.register();

        }

        else

            this.root = this;

        this.state = trippedStateFor(phase, 0);

    }

    /**

     * Creates a new phaser with the given parent and numbers of

     * registered unarrived parties. If parent is non-null, this phaser

     * is registered with the parent and its initial phase number is

     * the same as that of parent phaser.

     *

     * @param parent the parent phaser

     * @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 Phaser(Phaser parent, int parties) {

        if (parties < 0 || parties > ushortMask)

            throw new IllegalArgumentException("Illegal number of parties");

        int phase = 0;

        this.parent = parent;

        if (parent != null) {

            this.root = parent.root;

            phase = parent.register();

        }

        else

            this.root = this;

        this.state = trippedStateFor(phase, parties);

    }

    /**

     * Adds a new unarrived party to this phaser.

     *

     * @return the arrival phase number to which this registration applied

     * @throws IllegalStateException if attempting to register more

     * than the maximum supported number of parties

     */

    public int register() {

        return doRegister(1);

    }

    /**

     * Adds the given number of new unarrived parties to this phaser.

     *

     * @param parties the number of parties required to trip barrier

     * @return the arrival phase number to which this registration applied

     * @throws IllegalStateException if attempting to register more

     * than the maximum supported number of parties

     */

    public int bulkRegister(int parties) {

        if (parties < 0)

            throw new IllegalArgumentException();

        if (parties == 0)

            return getPhase();

        return doRegister(parties);

    }

    /**

     * Shared code for register, bulkRegister

     */

    private int doRegister(int registrations) {

        int phase;

        for (;;) {

            long s = getReconciledState();

            phase = phaseOf(s);

            int unarrived = unarrivedOf(s) + registrations;

            int parties = partiesOf(s) + registrations;

            if (phase < 0)

                break;

            if (parties > ushortMask || unarrived > ushortMask)

                throw new IllegalStateException(badBounds(parties, unarrived));

            if (phase == phaseOf(root.state) &&

                casState(s, stateFor(phase, parties, unarrived)))

                break;

        }

        return phase;

    }

    /**

     * Arrives at the barrier, but does not wait for others.  (You can

     * in turn wait for others via {@link #awaitAdvance}).  It is an

     * unenforced usage error for an unregistered party to invoke this

     * method.

     *

     * @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 arrive() {

        int phase;

        for (;;) {

            long s = state;

            phase = phaseOf(s);

            if (phase < 0)

                break;

            int parties = partiesOf(s);

            int unarrived = unarrivedOf(s) - 1;

            if (unarrived > 0) {        // Not the last arrival

                if (casState(s, s - 1)) // s-1 adds one arrival

                    break;

            }

            else if (unarrived == 0) {  // the last arrival

                Phaser par = parent;

                if (par == null) {      // directly trip

                    if (casState

                        (s,

                         trippedStateFor(onAdvance(phase, parties) ? -1 :

                                         ((phase + 1) & phaseMask), parties))) {

                        releaseWaiters(phase);

                        break;

                    }

                }

                else {                  // cascade to parent

                    if (casState(s, s - 1)) { // zeroes unarrived

                        par.arrive();

                        reconcileState();

                        break;

                    }

                }

            }

            else if (phase != phaseOf(root.state)) // or if unreconciled

                reconcileState();

            else

                throw new IllegalStateException(badBounds(parties, unarrived));

        }