test/loops/CyclicAction.java

/*
 * 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/publicdomain/zero/1.0/
 */

import java.util.*;
import java.util.concurrent.*;

/**
 * A computation that is broken into a series of task executions, each
 * separated by a Phaser arrival.  Concrete subclasses must
 * define method {@code compute}, that performs the action occurring
 * at each step of the barrier.  Upon invocation of this task, the
 * {@code compute} method is repeatedly invoked until the barrier
 * {@code isTerminated} or until its execution throws an exception.
 *
 * <p><b>Sample Usage.</b> Here is a sketch of a set of CyclicActions
 * that each perform 500 iterations of an imagined image smoothing
 * operation. Note that the aggregate ImageSmoother task itself is not
 * a CyclicTask.
 *
 * <pre>
 * class ImageSmoother extends RecursiveAction {
 *   protected void compute() {
 *     Phaser b = new Phaser() {
 *       protected boolean onAdvance(int cycle, int registeredParties) {
 *          return registeredParties &lt;= 0 || cycle &gt;= 500;
 *       }
 *     }
 *     int n = pool.getParallelismLevel();
 *     CyclicAction[] actions = new CyclicAction[n];
 *     for (int i = 0; i &lt; n; ++i) {
 *       action[i] = new CyclicAction(b) {
 *         protected void compute() {
 *           smoothImagePart(i);
 *         }
 *       }
 *     }
 *     invokeAll(actions);
 *   }
 * }
 * </pre>
 */
public abstract class CyclicAction extends ForkJoinTask<Void> {
    final Phaser barrier;
    boolean deregistered;
    int lastArrived;

    /**
     * Constructs a new CyclicAction using the supplied barrier,
     * registering for this barrier upon construction.
     * @param barrier the barrier
     */
    public CyclicAction(Phaser barrier) {
        this.barrier = barrier;
        lastArrived = barrier.register() - 1;
    }

    /**
     * The computation performed by this task on each cycle of the
     * barrier.  While you must define this method, you should not in
     * general call it directly.
     */
    protected abstract void step();

    /**
     * Returns the barrier
     */
    public final Phaser getBarrier() {
        return barrier;
    }

    /**
     * Returns the current cycle of the barrier
     */
    public final int getCycle() {
        return barrier.getPhase();
    }

    public final Void getRawResult() { return null; }
    protected final void setRawResult(Void mustBeNull) { }

    private void deregister() {
        if (!deregistered) {
            deregistered = true;
            barrier.arriveAndDeregister();
        }
    }

    protected final boolean exec() {
        Phaser b = barrier;
        if (!isDone()) {
            b.awaitAdvance(lastArrived);
            if (b.getPhase() >= 0) {
                try {
                    step();
                } catch (Throwable rex) {
                    deregister();
                    completeExceptionally(rex);
                    return false;
                }
                if ((lastArrived = b.arrive()) >= 0) {
                    this.fork();
                    return false;
                }
            }
        }
        deregister();
        return true;
    }

}
Revision:	1.7
Committed:	Wed Dec 31 17:00:58 2014 UTC (9 years, 4 months ago) by jsr166
Branch:	MAIN
CVS Tags:	HEAD
Changes since 1.6:	+1 -1 lines
Log Message:	lexicographic import order
#	User	Rev	Content
1	dl	1.1	/*
2			* Written by Doug Lea with assistance from members of JCP JSR-166
3			* Expert Group and released to the public domain, as explained at
4	jsr166	1.4	* http://creativecommons.org/publicdomain/zero/1.0/
5	dl	1.1	*/
6
7	jsr166	1.7	import java.util.*;
8	dl	1.1	import java.util.concurrent.*;
9
10			/**
11			* A computation that is broken into a series of task executions, each
12			* separated by a Phaser arrival. Concrete subclasses must
13	jsr166	1.6	* define method {@code compute}, that performs the action occurring
14	dl	1.1	* at each step of the barrier. Upon invocation of this task, the
15	jsr166	1.6	* {@code compute} method is repeatedly invoked until the barrier
16			* {@code isTerminated} or until its execution throws an exception.
17	dl	1.1	*
18	jsr166	1.5	* <p><b>Sample Usage.</b> Here is a sketch of a set of CyclicActions
19	dl	1.1	* that each perform 500 iterations of an imagined image smoothing
20			* operation. Note that the aggregate ImageSmoother task itself is not
21			* a CyclicTask.
22			*
23			* <pre>
24			* class ImageSmoother extends RecursiveAction {
25			* protected void compute() {
26			* Phaser b = new Phaser() {
27			* protected boolean onAdvance(int cycle, int registeredParties) {
28			* return registeredParties <= 0 \|\| cycle >= 500;
29			* }
30			* }
31			* int n = pool.getParallelismLevel();
32			* CyclicAction[] actions = new CyclicAction[n];
33			* for (int i = 0; i < n; ++i) {
34			* action[i] = new CyclicAction(b) {
35			* protected void compute() {
36			* smoothImagePart(i);
37			* }
38			* }
39			* }
40			* invokeAll(actions);
41			* }
42			* }
43			* </pre>
44			*/
45			public abstract class CyclicAction extends ForkJoinTask<Void> {
46			final Phaser barrier;
47			boolean deregistered;
48			int lastArrived;
49
50			/**
51			* Constructs a new CyclicAction using the supplied barrier,
52			* registering for this barrier upon construction.
53			* @param barrier the barrier
54			*/
55			public CyclicAction(Phaser barrier) {
56			this.barrier = barrier;
57			lastArrived = barrier.register() - 1;
58			}
59
60			/**
61			* The computation performed by this task on each cycle of the
62			* barrier. While you must define this method, you should not in
63			* general call it directly.
64			*/
65			protected abstract void step();
66
67			/**
68			* Returns the barrier
69			*/
70			public final Phaser getBarrier() {
71			return barrier;
72			}
73
74			/**
75			* Returns the current cycle of the barrier
76			*/
77			public final int getCycle() {
78			return barrier.getPhase();
79			}
80
81			public final Void getRawResult() { return null; }
82			protected final void setRawResult(Void mustBeNull) { }
83
84			private void deregister() {
85			if (!deregistered) {
86			deregistered = true;
87			barrier.arriveAndDeregister();
88			}
89			}
90
91			protected final boolean exec() {
92			Phaser b = barrier;
93			if (!isDone()) {
94			b.awaitAdvance(lastArrived);
95			if (b.getPhase() >= 0) {
96			try {
97			step();
98			} catch (Throwable rex) {
99			deregister();
100			completeExceptionally(rex);
101			return false;
102			}
103			if ((lastArrived = b.arrive()) >= 0) {
104			this.fork();
105			return false;
106			}
107			}
108			}
109			deregister();
110			return true;
111			}
112
113			}