/*

// Static utilities

/**

private static void checkPermission() {

SecurityManager security = System.getSecurityManager();

if (security != null)

security.checkPermission(modifyThreadPermission);

}

// Nested classes

/**

public static interface ForkJoinWorkerThreadFactory {

/**

public ForkJoinWorkerThread newThread(ForkJoinPool pool);

}

/**

static final class DefaultForkJoinWorkerThreadFactory

implements ForkJoinWorkerThreadFactory {

public final ForkJoinWorkerThread newThread(ForkJoinPool pool) {

return new ForkJoinWorkerThread(pool);

}

}

/**

static final class EmptyTask extends ForkJoinTask<Void> {

private static final long serialVersionUID = -7721805057305804111L;

EmptyTask() { status = ForkJoinTask.NORMAL; } // force done

public final Void getRawResult() { return null; }

public final void setRawResult(Void x) {}

public final boolean exec() { return true; }

}

// Constants shared across ForkJoinPool and WorkQueue

// Bounds

static final int SMASK = 0xffff; // short bits == max index

static final int MAX_CAP = 0x7fff; // max #workers - 1

static final int EVENMASK = 0xfffe; // even short bits

static final int SQMASK = 0x007e; // max 64 (even) slots

// Masks and units for WorkQueue.scanState and ctl sp subfield

static final int SCANNING = 1; // false when running tasks

static final int INACTIVE = 1 << 31; // must be negative

static final int SS_SEQ = 1 << 16; // version count

// Mode bits for ForkJoinPool.config and WorkQueue.config

static final int MODE_MASK = 0xffff << 16; // top half of int

static final int LIFO_QUEUE = 0;

static final int FIFO_QUEUE = 1 << 16;

static final int SHARED_QUEUE = 1 << 31; // must be negative

/**

@sun.misc.Contended

static final class WorkQueue {

/**

static final int INITIAL_QUEUE_CAPACITY = 1 << 13;

/**

static final int MAXIMUM_QUEUE_CAPACITY = 1 << 26; // 64M

// Instance fields

volatile int scanState; // versioned, <0: inactive; odd:scanning

int stackPred; // pool stack (ctl) predecessor

int nsteals; // number of steals

int hint; // randomization and stealer index hint

int config; // pool index and mode

volatile int qlock; // 1: locked, < 0: terminate; else 0

volatile int base; // index of next slot for poll

int top; // index of next slot for push

ForkJoinTask<?>[] array; // the elements (initially unallocated)

final ForkJoinPool pool; // the containing pool (may be null)

final ForkJoinWorkerThread owner; // owning thread or null if shared

volatile Thread parker; // == owner during call to park; else null

volatile ForkJoinTask<?> currentJoin; // task being joined in awaitJoin

volatile ForkJoinTask<?> currentSteal; // mainly used by helpStealer

WorkQueue(ForkJoinPool pool, ForkJoinWorkerThread owner) {

this.pool = pool;

this.owner = owner;

// Place indices in the center of array (that is not yet allocated)

base = top = INITIAL_QUEUE_CAPACITY >>> 1;

}

/**

final int getPoolIndex() {

return (config & 0xffff) >>> 1; // ignore odd/even tag bit

}

/**

final int queueSize() {

int n = base - top; // non-owner callers must read base first

return (n >= 0) ? 0 : -n; // ignore transient negative

}

/**

final boolean isEmpty() {

ForkJoinTask<?>[] a; int n, m, s;

return ((n = base - (s = top)) >= 0 ||

(n == -1 && // possibly one task

((a = array) == null || (m = a.length - 1) < 0 ||

U.getObject

(a, (long)((m & (s - 1)) << ASHIFT) + ABASE) == null)));

}

/**

final void push(ForkJoinTask<?> task) {

ForkJoinTask<?>[] a; ForkJoinPool p;

int b = base, s = top, n;

if ((a = array) != null) { // ignore if queue removed

int m = a.length - 1; // fenced write for task visibility

U.putOrderedObject(a, ((m & s) << ASHIFT) + ABASE, task);

U.putOrderedInt(this, QTOP, s + 1);

if ((n = s - b) <= 1) {

if ((p = pool) != null)

p.signalWork(p.workQueues, this);

}

else if (n >= m)

growArray();

}

}

/**

final ForkJoinTask<?>[] growArray() {

ForkJoinTask<?>[] oldA = array;

int size = oldA != null ? oldA.length << 1 : INITIAL_QUEUE_CAPACITY;

if (size > MAXIMUM_QUEUE_CAPACITY)

throw new RejectedExecutionException("Queue capacity exceeded");

int oldMask, t, b;

ForkJoinTask<?>[] a = array = new ForkJoinTask<?>[size];

if (oldA != null && (oldMask = oldA.length - 1) >= 0 &&

(t = top) - (b = base) > 0) {

int mask = size - 1;

do { // emulate poll from old array, push to new array

ForkJoinTask<?> x;

int oldj = ((b & oldMask) << ASHIFT) + ABASE;

int j = ((b & mask) << ASHIFT) + ABASE;

x = (ForkJoinTask<?>)U.getObjectVolatile(oldA, oldj);

if (x != null &&

U.compareAndSwapObject(oldA, oldj, x, null))

U.putObjectVolatile(a, j, x);

} while (++b != t);

}

return a;

}

/**

final ForkJoinTask<?> pop() {

ForkJoinTask<?>[] a; ForkJoinTask<?> t; int m;

if ((a = array) != null && (m = a.length - 1) >= 0) {

for (int s; (s = top - 1) - base >= 0;) {

long j = ((m & s) << ASHIFT) + ABASE;

if ((t = (ForkJoinTask<?>)U.getObject(a, j)) == null)

break;

if (U.compareAndSwapObject(a, j, t, null)) {

U.putOrderedInt(this, QTOP, s);

return t;

}

}

}

return null;

}

/**

final ForkJoinTask<?> pollAt(int b) {

ForkJoinTask<?> t; ForkJoinTask<?>[] a;

if ((a = array) != null) {

int j = (((a.length - 1) & b) << ASHIFT) + ABASE;

if ((t = (ForkJoinTask<?>)U.getObjectVolatile(a, j)) != null &&

base == b && U.compareAndSwapObject(a, j, t, null)) {

base = b + 1;

return t;

}

}

return null;

}

/**

final ForkJoinTask<?> poll() {

ForkJoinTask<?>[] a; int b; ForkJoinTask<?> t;

while ((b = base) - top < 0 && (a = array) != null) {

int j = (((a.length - 1) & b) << ASHIFT) + ABASE;

t = (ForkJoinTask<?>)U.getObjectVolatile(a, j);

if (base == b) {

if (t != null) {

if (U.compareAndSwapObject(a, j, t, null)) {

base = b + 1;

return t;

}

}

else if (b + 1 == top) // now empty

break;

}

}

return null;

}

/**

final ForkJoinTask<?> nextLocalTask() {

return (config & FIFO_QUEUE) == 0 ? pop() : poll();

}

/**

final ForkJoinTask<?> peek() {

ForkJoinTask<?>[] a = array; int m;

if (a == null || (m = a.length - 1) < 0)

return null;

int i = (config & FIFO_QUEUE) == 0 ? top - 1 : base;

int j = ((i & m) << ASHIFT) + ABASE;

return (ForkJoinTask<?>)U.getObjectVolatile(a, j);

}

/**

final boolean tryUnpush(ForkJoinTask<?> t) {

ForkJoinTask<?>[] a; int s;

if ((a = array) != null && (s = top) != base &&

U.compareAndSwapObject

(a, (((a.length - 1) & --s) << ASHIFT) + ABASE, t, null)) {

U.putOrderedInt(this, QTOP, s);

return true;

}

return false;

}

/**

final void cancelAll() {