/*

/*

/** The run status of this task */

volatile int status; // accessed directly by pool and workers

static final int DONE_MASK = 0xf0000000; // mask out non-completion bits

static final int NORMAL = 0xf0000000; // must be negative

static final int CANCELLED = 0xc0000000; // must be < NORMAL

static final int EXCEPTIONAL = 0x80000000; // must be < CANCELLED

static final int SIGNAL = 0x00010000; // must be >= 1 << 16

static final int SMASK = 0x0000ffff; // short bits for tags

/**

private int setCompletion(int completion) {

for (int s;;) {

if ((s = status) < 0)

return s;

if (U.compareAndSwapInt(this, STATUS, s, s | completion)) {

if ((s >>> 16) != 0)

synchronized (this) { notifyAll(); }

return completion;

}

}

}

/**

final int doExec() {

int s; boolean completed;

if ((s = status) >= 0) {

try {

completed = exec();

} catch (Throwable rex) {

return setExceptionalCompletion(rex);

}

if (completed)

s = setCompletion(NORMAL);

}

return s;

}

/**

final boolean trySetSignal() {

int s = status;

return s >= 0 && U.compareAndSwapInt(this, STATUS, s, s | SIGNAL);

}

/**

private int externalAwaitDone() {

int s;

ForkJoinPool cp = ForkJoinPool.common;

if ((s = status) >= 0) {

if (cp != null) {

if (this instanceof CountedCompleter)

s = cp.externalHelpComplete((CountedCompleter<?>)this, Integer.MAX_VALUE);

else if (cp.tryExternalUnpush(this))

s = doExec();

}

if (s >= 0 && (s = status) >= 0) {

boolean interrupted = false;

do {

if (U.compareAndSwapInt(this, STATUS, s, s | SIGNAL)) {

synchronized (this) {

if (status >= 0) {

try {

wait();

} catch (InterruptedException ie) {

interrupted = true;

}

}

else

notifyAll();

}

}

} while ((s = status) >= 0);

if (interrupted)

Thread.currentThread().interrupt();

}

}

return s;

}

/**

private int externalInterruptibleAwaitDone() throws InterruptedException {

int s;

ForkJoinPool cp = ForkJoinPool.common;

if (Thread.interrupted())

throw new InterruptedException();

if ((s = status) >= 0 && cp != null) {

if (this instanceof CountedCompleter)

cp.externalHelpComplete((CountedCompleter<?>)this, Integer.MAX_VALUE);

else if (cp.tryExternalUnpush(this))

doExec();

}

while ((s = status) >= 0) {

if (U.compareAndSwapInt(this, STATUS, s, s | SIGNAL)) {

synchronized (this) {

if (status >= 0)

wait();

else

notifyAll();

}

}

}

return s;

}

/**

private int doJoin() {

int s; Thread t; ForkJoinWorkerThread wt; ForkJoinPool.WorkQueue w;

return (s = status) < 0 ? s :

((t = Thread.currentThread()) instanceof ForkJoinWorkerThread) ?

(w = (wt = (ForkJoinWorkerThread)t).workQueue).

tryUnpush(this) && (s = doExec()) < 0 ? s :

wt.pool.awaitJoin(w, this) :

externalAwaitDone();

}

/**

private int doInvoke() {

int s; Thread t; ForkJoinWorkerThread wt;

return (s = doExec()) < 0 ? s :

((t = Thread.currentThread()) instanceof ForkJoinWorkerThread) ?

(wt = (ForkJoinWorkerThread)t).pool.awaitJoin(wt.workQueue, this) :

externalAwaitDone();

}

// Exception table support

/**

private static final ExceptionNode[] exceptionTable;

private static final ReentrantLock exceptionTableLock;

private static final ReferenceQueue<Object> exceptionTableRefQueue;

/**

private static final int EXCEPTION_MAP_CAPACITY = 32;

/**

static final class ExceptionNode extends WeakReference<ForkJoinTask<?>> {

final Throwable ex;

ExceptionNode next;

final long thrower; // use id not ref to avoid weak cycles

final int hashCode; // store task hashCode before weak ref disappears

ExceptionNode(ForkJoinTask<?> task, Throwable ex, ExceptionNode next) {

super(task, exceptionTableRefQueue);

this.ex = ex;

this.next = next;

this.thrower = Thread.currentThread().getId();

this.hashCode = System.identityHashCode(task);

}

}

/**

final int recordExceptionalCompletion(Throwable ex) {

int s;

if ((s = status) >= 0) {

int h = System.identityHashCode(this);

final ReentrantLock lock = exceptionTableLock;

lock.lock();

try {

expungeStaleExceptions();

ExceptionNode[] t = exceptionTable;

int i = h & (t.length - 1);

for (ExceptionNode e = t[i]; ; e = e.next) {

if (e == null) {

t[i] = new ExceptionNode(this, ex, t[i]);

break;

}

if (e.get() == this) // already present

break;

}

} finally {

lock.unlock();

}

s = setCompletion(EXCEPTIONAL);

}

return s;

}

/**

private int setExceptionalCompletion(Throwable ex) {

int s = recordExceptionalCompletion(ex);

if ((s & DONE_MASK) == EXCEPTIONAL)

internalPropagateException(ex);

return s;

}

/**

void internalPropagateException(Throwable ex) {

}

/**

static final void cancelIgnoringExceptions(ForkJoinTask<?> t) {

if (t != null && t.status >= 0) {

try {

t.cancel(false);

} catch (Throwable ignore) {

}

}

}

/**

private void clearExceptionalCompletion() {

int h = System.identityHashCode(this);

final ReentrantLock lock = exceptionTableLock;

lock.lock();

try {

ExceptionNode[] t = exceptionTable;

int i = h & (t.length - 1);

ExceptionNode e = t[i];

ExceptionNode pred = null;

while (e != null) {

ExceptionNode next = e.next;

if (e.get() == this) {

if (pred == null)

t[i] = next;

else

pred.next = next;

break;

}

pred = e;

e = next;

}

expungeStaleExceptions();

status = 0;

} finally {

lock.unlock();

}

}

/**

private Throwable getThrowableException() {

if ((status & DONE_MASK) != EXCEPTIONAL)

return null;

int h = System.identityHashCode(this);

ExceptionNode e;

final ReentrantLock lock = exceptionTableLock;

lock.lock();

try {

expungeStaleExceptions();

ExceptionNode[] t = exceptionTable;

e = t[h & (t.length - 1)];

while (e != null && e.get() != this)

e = e.next;

} finally {

lock.unlock();

}

Throwable ex;

if (e == null || (ex = e.ex) == null)

return null;

if (false && e.thrower != Thread.currentThread().getId()) {

Class<? extends Throwable> ec = ex.getClass();

try {

Constructor<?> noArgCtor = null;

Constructor<?>[] cs = ec.getConstructors();// public ctors only

for (int i = 0; i < cs.length; ++i) {

Constructor<?> c = cs[i];

Class<?>[] ps = c.getParameterTypes();

if (ps.length == 0)

noArgCtor = c;

else if (ps.length == 1 && ps[0] == Throwable.class)

return (Throwable)(c.newInstance(ex));

}

if (noArgCtor != null) {

Throwable wx = (Throwable)(noArgCtor.newInstance());

wx.initCause(ex);

return wx;

}

} catch (Exception ignore) {

}

}

return ex;

}

/**

private static void expungeStaleExceptions() {

for (Object x; (x = exceptionTableRefQueue.poll()) != null;) {

if (x instanceof ExceptionNode) {

int hashCode = ((ExceptionNode)x).hashCode;

ExceptionNode[] t = exceptionTable;

int i = hashCode & (t.length - 1);

ExceptionNode e = t[i];

ExceptionNode pred = null;

while (e != null) {

ExceptionNode next = e.next;

if (e == x) {

if (pred == null)

t[i] = next;

else

pred.next = next;

break;

}

pred = e;

e = next;

}

}

}

}

/**

static final void helpExpungeStaleExceptions() {

final ReentrantLock lock = exceptionTableLock;

if (lock.tryLock()) {

try {

expungeStaleExceptions();

} finally {

lock.unlock();

}

}

}

/**

static void rethrow(Throwable ex) {

if (ex != null)

ForkJoinTask.<RuntimeException>uncheckedThrow(ex);

}

/**

@SuppressWarnings("unchecked") static <T extends Throwable>

void uncheckedThrow(Throwable t) throws T {

throw (T)t; // rely on vacuous cast

}

/**

private void reportException(int s) {

if (s == CANCELLED)

throw new CancellationException();

if (s == EXCEPTIONAL)

rethrow(getThrowableException());

}

// public methods

/**

public final ForkJoinTask<V> fork() {

Thread t;

if ((t = Thread.currentThread()) instanceof ForkJoinWorkerThread)

((ForkJoinWorkerThread)t).workQueue.push(this);

else

ForkJoinPool.common.externalPush(this);

return this;

}

/**

public final V join() {

int s;

if ((s = doJoin() & DONE_MASK) != NORMAL)

reportException(s);

return getRawResult();

}

/**

public final V invoke() {

int s;

if ((s = doInvoke() & DONE_MASK) != NORMAL)

reportException(s);

return getRawResult();

}

/**

public static void invokeAll(ForkJoinTask<?> t1, ForkJoinTask<?> t2) {

int s1, s2;

t2.fork();

if ((s1 = t1.doInvoke() & DONE_MASK) != NORMAL)

t1.reportException(s1);

if ((s2 = t2.doJoin() & DONE_MASK) != NORMAL)

t2.reportException(s2);

}

/**

public static void invokeAll(ForkJoinTask<?>... tasks) {

Throwable ex = null;

int last = tasks.length - 1;

for (int i = last; i >= 0; --i) {

ForkJoinTask<?> t = tasks[i];

if (t == null) {

if (ex == null)

ex = new NullPointerException();

}

else if (i != 0)

t.fork();

else if (t.doInvoke() < NORMAL && ex == null)

ex = t.getException();

}

for (int i = 1; i <= last; ++i) {

ForkJoinTask<?> t = tasks[i];

if (t != null) {

if (ex != null)

t.cancel(false);

else if (t.doJoin() < NORMAL)

ex = t.getException();

}

}

if (ex != null)

rethrow(ex);

}

/**

public static <T extends ForkJoinTask<?>> Collection<T> invokeAll(Collection<T> tasks) {

if (!(tasks instanceof RandomAccess) || !(tasks instanceof List<?>)) {

invokeAll(tasks.toArray(new ForkJoinTask<?>[tasks.size()]));

return tasks;

}

@SuppressWarnings("unchecked")

List<? extends ForkJoinTask<?>> ts =

(List<? extends ForkJoinTask<?>>) tasks;

Throwable ex = null;

int last = ts.size() - 1;

for (int i = last; i >= 0; --i) {

ForkJoinTask<?> t = ts.get(i);

if (t == null) {

if (ex == null)

ex = new NullPointerException();

}

else if (i != 0)

t.fork();

else if (t.doInvoke() < NORMAL && ex == null)

ex = t.getException();

}

for (int i = 1; i <= last; ++i) {

ForkJoinTask<?> t = ts.get(i);

if (t != null) {

if (ex != null)

t.cancel(false);

else if (t.doJoin() < NORMAL)

ex = t.getException();

}

}

if (ex != null)

rethrow(ex);

return tasks;

}

/**

public boolean cancel(boolean mayInterruptIfRunning) {

return (setCompletion(CANCELLED) & DONE_MASK) == CANCELLED;

}

public final boolean isDone() {

return status < 0;

}

public final boolean isCancelled() {

return (status & DONE_MASK) == CANCELLED;

}

/**

public final boolean isCompletedAbnormally() {

return status < NORMAL;

}

/**

public final boolean isCompletedNormally() {

return (status & DONE_MASK) == NORMAL;

}

/**

public final Throwable getException() {

int s = status & DONE_MASK;

return ((s >= NORMAL) ? null :

(s == CANCELLED) ? new CancellationException() :

getThrowableException());

}

/**

public void completeExceptionally(Throwable ex) {

setExceptionalCompletion((ex instanceof RuntimeException) ||

(ex instanceof Error) ? ex :

new RuntimeException(ex));

}

/**

public void complete(V value) {

try {

setRawResult(value);

} catch (Throwable rex) {

setExceptionalCompletion(rex);

return;

}

setCompletion(NORMAL);

}

/**

public final void quietlyComplete() {

setCompletion(NORMAL);

}

/**

public final V get() throws InterruptedException, ExecutionException {

int s = (Thread.currentThread() instanceof ForkJoinWorkerThread) ?

doJoin() : externalInterruptibleAwaitDone();

Throwable ex;

if ((s &= DONE_MASK) == CANCELLED)

throw new CancellationException();

if (s == EXCEPTIONAL && (ex = getThrowableException()) != null)

throw new ExecutionException(ex);