0N/A

0N/Aclass TaskQueueSuper: public CHeapObj {

0N/Aprotected:

907N/A // Internal type for indexing the queue; also used for the tag.

907N/A typedef NOT_LP64(uint16_t) LP64_ONLY(uint32_t) idx_t;

907N/A

907N/A // The first free element after the last one pushed (mod N).

541N/A volatile uint _bottom;

0N/A

907N/A enum {

907N/A N = 1 << NOT_LP64(14) LP64_ONLY(17), // Queue size: 16K or 128K

907N/A MOD_N_MASK = N - 1 // To compute x mod N efficiently.

0N/A };

907N/A

907N/A class Age {

907N/A public:

907N/A Age(size_t data = 0) { _data = data; }

907N/A Age(const Age& age) { _data = age._data; }

907N/A Age(idx_t top, idx_t tag) { _fields._top = top; _fields._tag = tag; }

0N/A

907N/A Age get() const volatile { return _data; }

907N/A void set(Age age) volatile { _data = age._data; }

907N/A

907N/A idx_t top() const volatile { return _fields._top; }

907N/A idx_t tag() const volatile { return _fields._tag; }

0N/A

907N/A // Increment top; if it wraps, increment tag also.

907N/A void increment() {

907N/A _fields._top = increment_index(_fields._top);

907N/A if (_fields._top == 0) ++_fields._tag;

907N/A }

0N/A

907N/A Age cmpxchg(const Age new_age, const Age old_age) volatile {

907N/A return (size_t) Atomic::cmpxchg_ptr((intptr_t)new_age._data,

907N/A (volatile intptr_t *)&_data,

907N/A (intptr_t)old_age._data);

907N/A }

907N/A

907N/A bool operator ==(const Age& other) const { return _data == other._data; }

0N/A

907N/A private:

907N/A struct fields {

907N/A idx_t _top;

907N/A idx_t _tag;

907N/A };

907N/A union {

907N/A size_t _data;

907N/A fields _fields;

907N/A };

0N/A };

907N/A

907N/A volatile Age _age;

907N/A

907N/A // These both operate mod N.

907N/A static uint increment_index(uint ind) {

907N/A return (ind + 1) & MOD_N_MASK;

0N/A }

907N/A static uint decrement_index(uint ind) {

907N/A return (ind - 1) & MOD_N_MASK;

0N/A }

0N/A

907N/A // Returns a number in the range [0..N). If the result is "N-1", it should be

907N/A // interpreted as 0.

541N/A uint dirty_size(uint bot, uint top) {

907N/A return (bot - top) & MOD_N_MASK;

0N/A }

0N/A

0N/A // Returns the size corresponding to the given "bot" and "top".

541N/A uint size(uint bot, uint top) {

541N/A uint sz = dirty_size(bot, top);

907N/A // Has the queue "wrapped", so that bottom is less than top? There's a

907N/A // complicated special case here. A pair of threads could perform pop_local

907N/A // and pop_global operations concurrently, starting from a state in which

907N/A // _bottom == _top+1. The pop_local could succeed in decrementing _bottom,

907N/A // and the pop_global in incrementing _top (in which case the pop_global

907N/A // will be awarded the contested queue element.) The resulting state must

907N/A // be interpreted as an empty queue. (We only need to worry about one such

907N/A // event: only the queue owner performs pop_local's, and several concurrent

907N/A // threads attempting to perform the pop_global will all perform the same

907N/A // CAS, and only one can succeed.) Any stealing thread that reads after

907N/A // either the increment or decrement will see an empty queue, and will not

907N/A // join the competitors. The "sz == -1 || sz == N-1" state will not be

907N/A // modified by concurrent queues, so the owner thread can reset the state to

907N/A // _bottom == top so subsequent pushes will be performed normally.

907N/A return (sz == N - 1) ? 0 : sz;

0N/A }

0N/A

0N/Apublic:

0N/A TaskQueueSuper() : _bottom(0), _age() {}

0N/A

0N/A // Return "true" if the TaskQueue contains any tasks.

0N/A bool peek();

0N/A

0N/A // Return an estimate of the number of elements in the queue.

0N/A // The "careful" version admits the possibility of pop_local/pop_global

0N/A // races.

541N/A uint size() {

907N/A return size(_bottom, _age.top());

0N/A }

0N/A

541N/A uint dirty_size() {

907N/A return dirty_size(_bottom, _age.top());

0N/A }

0N/A

342N/A void set_empty() {

342N/A _bottom = 0;

907N/A _age.set(0);

342N/A }

342N/A

0N/A // Maximum number of elements allowed in the queue. This is two less

0N/A // than the actual queue size, for somewhat complicated reasons.

907N/A uint max_elems() { return N - 2; }

0N/A};

0N/A

0N/Atemplate<class E> class GenericTaskQueue: public TaskQueueSuper {

0N/Aprivate:

0N/A // Slow paths for push, pop_local. (pop_global has no fast path.)

541N/A bool push_slow(E t, uint dirty_n_elems);

541N/A bool pop_local_slow(uint localBot, Age oldAge);

0N/A

0N/Apublic:

0N/A // Initializes the queue to empty.

0N/A GenericTaskQueue();

0N/A

0N/A void initialize();

0N/A

0N/A // Push the task "t" on the queue. Returns "false" iff the queue is

0N/A // full.

0N/A inline bool push(E t);

0N/A

0N/A // If succeeds in claiming a task (from the 'local' end, that is, the

0N/A // most recently pushed task), returns "true" and sets "t" to that task.

0N/A // Otherwise, the queue is empty and returns false.

0N/A inline bool pop_local(E& t);

0N/A

0N/A // If succeeds in claiming a task (from the 'global' end, that is, the

0N/A // least recently pushed task), returns "true" and sets "t" to that task.

0N/A // Otherwise, the queue is empty and returns false.

0N/A bool pop_global(E& t);

0N/A

0N/A // Delete any resource associated with the queue.

0N/A ~GenericTaskQueue();

0N/A

342N/A // apply the closure to all elements in the task queue

342N/A void oops_do(OopClosure* f);

342N/A

0N/Aprivate:

0N/A // Element array.

0N/A volatile E* _elems;

0N/A};

0N/A

0N/Atemplate<class E>

0N/AGenericTaskQueue<E>::GenericTaskQueue():TaskQueueSuper() {

907N/A assert(sizeof(Age) == sizeof(size_t), "Depends on this.");

0N/A}

0N/A

0N/Atemplate<class E>

0N/Avoid GenericTaskQueue<E>::initialize() {

907N/A _elems = NEW_C_HEAP_ARRAY(E, N);

0N/A guarantee(_elems != NULL, "Allocation failed.");

0N/A}

0N/A

0N/Atemplate<class E>

342N/Avoid GenericTaskQueue<E>::oops_do(OopClosure* f) {

342N/A // tty->print_cr("START OopTaskQueue::oops_do");

541N/A uint iters = size();

541N/A uint index = _bottom;

541N/A for (uint i = 0; i < iters; ++i) {

342N/A index = decrement_index(index);

342N/A // tty->print_cr(" doing entry %d," INTPTR_T " -> " INTPTR_T,

342N/A // index, &_elems[index], _elems[index]);

342N/A E* t = (E*)&_elems[index]; // cast away volatility

342N/A oop* p = (oop*)t;

342N/A assert((*t)->is_oop_or_null(), "Not an oop or null");

342N/A f->do_oop(p);

342N/A }

342N/A // tty->print_cr("END OopTaskQueue::oops_do");

342N/A}

342N/A

342N/A

342N/Atemplate<class E>

541N/Abool GenericTaskQueue<E>::push_slow(E t, uint dirty_n_elems) {

907N/A if (dirty_n_elems == N - 1) {

0N/A // Actually means 0, so do the push.

541N/A uint localBot = _bottom;

0N/A _elems[localBot] = t;

1024N/A OrderAccess::release_store(&_bottom, increment_index(localBot));

0N/A return true;

907N/A }

907N/A return false;

0N/A}

0N/A

0N/Atemplate<class E>

0N/Abool GenericTaskQueue<E>::

541N/Apop_local_slow(uint localBot, Age oldAge) {

0N/A // This queue was observed to contain exactly one element; either this

0N/A // thread will claim it, or a competing "pop_global". In either case,

0N/A // the queue will be logically empty afterwards. Create a new Age value

0N/A // that represents the empty queue for the given value of "_bottom". (We

0N/A // must also increment "tag" because of the case where "bottom == 1",

0N/A // "top == 0". A pop_global could read the queue element in that case,

0N/A // then have the owner thread do a pop followed by another push. Without

0N/A // the incrementing of "tag", the pop_global's CAS could succeed,

0N/A // allowing it to believe it has claimed the stale element.)

907N/A Age newAge((idx_t)localBot, oldAge.tag() + 1);

0N/A // Perhaps a competing pop_global has already incremented "top", in which

0N/A // case it wins the element.

0N/A if (localBot == oldAge.top()) {

0N/A // No competing pop_global has yet incremented "top"; we'll try to

0N/A // install new_age, thus claiming the element.

907N/A Age tempAge = _age.cmpxchg(newAge, oldAge);

0N/A if (tempAge == oldAge) {

0N/A // We win.

907N/A assert(dirty_size(localBot, _age.top()) != N - 1, "sanity");

0N/A return true;

0N/A }

0N/A }

907N/A // We lose; a completing pop_global gets the element. But the queue is empty

907N/A // and top is greater than bottom. Fix this representation of the empty queue

907N/A // to become the canonical one.

907N/A _age.set(newAge);

907N/A assert(dirty_size(localBot, _age.top()) != N - 1, "sanity");

0N/A return false;

0N/A}

0N/A

0N/Atemplate<class E>

0N/Abool GenericTaskQueue<E>::pop_global(E& t) {

907N/A Age oldAge = _age.get();

541N/A uint localBot = _bottom;

541N/A uint n_elems = size(localBot, oldAge.top());

0N/A if (n_elems == 0) {

0N/A return false;

0N/A }

907N/A

0N/A t = _elems[oldAge.top()];

907N/A Age newAge(oldAge);

907N/A newAge.increment();

907N/A Age resAge = _age.cmpxchg(newAge, oldAge);

907N/A

0N/A // Note that using "_bottom" here might fail, since a pop_local might

0N/A // have decremented it.

907N/A assert(dirty_size(localBot, newAge.top()) != N - 1, "sanity");

907N/A return resAge == oldAge;

0N/A}

0N/A

0N/Atemplate<class E>

0N/AGenericTaskQueue<E>::~GenericTaskQueue() {

0N/A FREE_C_HEAP_ARRAY(E, _elems);

0N/A}

0N/A

0N/Aclass TaskQueueSetSuper: public CHeapObj {

0N/Aprotected:

0N/A static int randomParkAndMiller(int* seed0);

0N/Apublic:

0N/A // Returns "true" if some TaskQueue in the set contains a task.

0N/A virtual bool peek() = 0;

0N/A};

0N/A

0N/Atemplate<class E> class GenericTaskQueueSet: public TaskQueueSetSuper {

0N/Aprivate:

541N/A uint _n;

0N/A GenericTaskQueue<E>** _queues;

0N/A

0N/Apublic:

0N/A GenericTaskQueueSet(int n) : _n(n) {

0N/A typedef GenericTaskQueue<E>* GenericTaskQueuePtr;

0N/A _queues = NEW_C_HEAP_ARRAY(GenericTaskQueuePtr, n);

0N/A guarantee(_queues != NULL, "Allocation failure.");

0N/A for (int i = 0; i < n; i++) {

0N/A _queues[i] = NULL;

0N/A }

0N/A }

0N/A

541N/A bool steal_1_random(uint queue_num, int* seed, E& t);

541N/A bool steal_best_of_2(uint queue_num, int* seed, E& t);

541N/A bool steal_best_of_all(uint queue_num, int* seed, E& t);

0N/A

541N/A void register_queue(uint i, GenericTaskQueue<E>* q);

0N/A

541N/A GenericTaskQueue<E>* queue(uint n);

0N/A

0N/A // The thread with queue number "queue_num" (and whose random number seed

0N/A // is at "seed") is trying to steal a task from some other queue. (It

0N/A // may try several queues, according to some configuration parameter.)

0N/A // If some steal succeeds, returns "true" and sets "t" the stolen task,

0N/A // otherwise returns false.

541N/A bool steal(uint queue_num, int* seed, E& t);

0N/A

0N/A bool peek();

0N/A};

0N/A

0N/Atemplate<class E>

541N/Avoid GenericTaskQueueSet<E>::register_queue(uint i, GenericTaskQueue<E>* q) {

541N/A assert(i < _n, "index out of range.");

0N/A _queues[i] = q;

0N/A}

0N/A

0N/Atemplate<class E>

541N/AGenericTaskQueue<E>* GenericTaskQueueSet<E>::queue(uint i) {

0N/A return _queues[i];

0N/A}

0N/A

0N/Atemplate<class E>

541N/Abool GenericTaskQueueSet<E>::steal(uint queue_num, int* seed, E& t) {

541N/A for (uint i = 0; i < 2 * _n; i++)

0N/A if (steal_best_of_2(queue_num, seed, t))

0N/A return true;

0N/A return false;

0N/A}

0N/A

0N/Atemplate<class E>

541N/Abool GenericTaskQueueSet<E>::steal_best_of_all(uint queue_num, int* seed, E& t) {

0N/A if (_n > 2) {

0N/A int best_k;

541N/A uint best_sz = 0;

541N/A for (uint k = 0; k < _n; k++) {

0N/A if (k == queue_num) continue;

541N/A uint sz = _queues[k]->size();

0N/A if (sz > best_sz) {

0N/A best_sz = sz;

0N/A best_k = k;

0N/A }

0N/A }

0N/A return best_sz > 0 && _queues[best_k]->pop_global(t);

0N/A } else if (_n == 2) {

0N/A // Just try the other one.

0N/A int k = (queue_num + 1) % 2;

0N/A return _queues[k]->pop_global(t);

0N/A } else {

0N/A assert(_n == 1, "can't be zero.");

0N/A return false;

0N/A }

0N/A}

0N/A

0N/Atemplate<class E>

541N/Abool GenericTaskQueueSet<E>::steal_1_random(uint queue_num, int* seed, E& t) {

0N/A if (_n > 2) {

541N/A uint k = queue_num;

0N/A while (k == queue_num) k = randomParkAndMiller(seed) % _n;

0N/A return _queues[2]->pop_global(t);

0N/A } else if (_n == 2) {

0N/A // Just try the other one.

0N/A int k = (queue_num + 1) % 2;

0N/A return _queues[k]->pop_global(t);

0N/A } else {

0N/A assert(_n == 1, "can't be zero.");

0N/A return false;

0N/A }

0N/A}

0N/A

0N/Atemplate<class E>

541N/Abool GenericTaskQueueSet<E>::steal_best_of_2(uint queue_num, int* seed, E& t) {

0N/A if (_n > 2) {

541N/A uint k1 = queue_num;

0N/A while (k1 == queue_num) k1 = randomParkAndMiller(seed) % _n;

541N/A uint k2 = queue_num;

0N/A while (k2 == queue_num || k2 == k1) k2 = randomParkAndMiller(seed) % _n;

0N/A // Sample both and try the larger.

541N/A uint sz1 = _queues[k1]->size();

541N/A uint sz2 = _queues[k2]->size();

0N/A if (sz2 > sz1) return _queues[k2]->pop_global(t);

0N/A else return _queues[k1]->pop_global(t);

0N/A } else if (_n == 2) {

0N/A // Just try the other one.

541N/A uint k = (queue_num + 1) % 2;

0N/A return _queues[k]->pop_global(t);

0N/A } else {

0N/A assert(_n == 1, "can't be zero.");

0N/A return false;

0N/A }

0N/A}

0N/A

0N/Atemplate<class E>

0N/Abool GenericTaskQueueSet<E>::peek() {

0N/A // Try all the queues.

541N/A for (uint j = 0; j < _n; j++) {

0N/A if (_queues[j]->peek())

0N/A return true;

0N/A }

0N/A return false;

0N/A}

0N/A

342N/Aclass TerminatorTerminator: public CHeapObj {

342N/Apublic:

342N/A virtual bool should_exit_termination() = 0;

342N/A};

342N/A

0N/A

546N/A#undef TRACESPINNING

546N/A

0N/Aclass ParallelTaskTerminator: public StackObj {

0N/Aprivate:

0N/A int _n_threads;

0N/A TaskQueueSetSuper* _queue_set;

541N/A int _offered_termination;

0N/A

546N/A#ifdef TRACESPINNING

546N/A static uint _total_yields;

546N/A static uint _total_spins;

546N/A static uint _total_peeks;

546N/A#endif

546N/A

0N/A bool peek_in_queue_set();

0N/Aprotected:

0N/A virtual void yield();

0N/A void sleep(uint millis);

0N/A

0N/Apublic:

0N/A

0N/A // "n_threads" is the number of threads to be terminated. "queue_set" is a

0N/A // queue sets of work queues of other threads.

0N/A ParallelTaskTerminator(int n_threads, TaskQueueSetSuper* queue_set);

0N/A

0N/A // The current thread has no work, and is ready to terminate if everyone

0N/A // else is. If returns "true", all threads are terminated. If returns

0N/A // "false", available work has been observed in one of the task queues,

0N/A // so the global task is not complete.

342N/A bool offer_termination() {

342N/A return offer_termination(NULL);

342N/A }

342N/A

907N/A // As above, but it also terminates if the should_exit_termination()

342N/A // method of the terminator parameter returns true. If terminator is

342N/A // NULL, then it is ignored.

342N/A bool offer_termination(TerminatorTerminator* terminator);

0N/A

0N/A // Reset the terminator, so that it may be reused again.

0N/A // The caller is responsible for ensuring that this is done

0N/A // in an MT-safe manner, once the previous round of use of

0N/A // the terminator is finished.

0N/A void reset_for_reuse();

0N/A

546N/A#ifdef TRACESPINNING

546N/A static uint total_yields() { return _total_yields; }

546N/A static uint total_spins() { return _total_spins; }

546N/A static uint total_peeks() { return _total_peeks; }

546N/A static void print_termination_counts();

546N/A#endif

0N/A};

0N/A

0N/A#define SIMPLE_STACK 0

0N/A

0N/Atemplate<class E> inline bool GenericTaskQueue<E>::push(E t) {

0N/A#if SIMPLE_STACK

541N/A uint localBot = _bottom;

0N/A if (_bottom < max_elems()) {

0N/A _elems[localBot] = t;

0N/A _bottom = localBot + 1;

0N/A return true;

0N/A } else {

0N/A return false;

0N/A }

0N/A#else

541N/A uint localBot = _bottom;

907N/A assert((localBot >= 0) && (localBot < N), "_bottom out of range.");

907N/A idx_t top = _age.top();

541N/A uint dirty_n_elems = dirty_size(localBot, top);

907N/A assert((dirty_n_elems >= 0) && (dirty_n_elems < N), "n_elems out of range.");

0N/A if (dirty_n_elems < max_elems()) {

0N/A _elems[localBot] = t;

1024N/A OrderAccess::release_store(&_bottom, increment_index(localBot));

0N/A return true;

0N/A } else {

0N/A return push_slow(t, dirty_n_elems);

0N/A }

0N/A#endif

0N/A}

0N/A

0N/Atemplate<class E> inline bool GenericTaskQueue<E>::pop_local(E& t) {

0N/A#if SIMPLE_STACK

541N/A uint localBot = _bottom;

0N/A assert(localBot > 0, "precondition.");

0N/A localBot--;

0N/A t = _elems[localBot];

0N/A _bottom = localBot;

0N/A return true;

0N/A#else

541N/A uint localBot = _bottom;

907N/A // This value cannot be N-1. That can only occur as a result of

0N/A // the assignment to bottom in this method. If it does, this method

0N/A // resets the size( to 0 before the next call (which is sequential,

0N/A // since this is pop_local.)

907N/A uint dirty_n_elems = dirty_size(localBot, _age.top());

907N/A assert(dirty_n_elems != N - 1, "Shouldn't be possible...");

0N/A if (dirty_n_elems == 0) return false;

0N/A localBot = decrement_index(localBot);

0N/A _bottom = localBot;

0N/A // This is necessary to prevent any read below from being reordered

0N/A // before the store just above.

0N/A OrderAccess::fence();

0N/A t = _elems[localBot];

0N/A // This is a second read of "age"; the "size()" above is the first.

0N/A // If there's still at least one element in the queue, based on the

0N/A // "_bottom" and "age" we've read, then there can be no interference with

0N/A // a "pop_global" operation, and we're done.

907N/A idx_t tp = _age.top(); // XXX

0N/A if (size(localBot, tp) > 0) {

907N/A assert(dirty_size(localBot, tp) != N - 1, "sanity");

0N/A return true;

0N/A } else {

0N/A // Otherwise, the queue contained exactly one element; we take the slow

0N/A // path.

907N/A return pop_local_slow(localBot, _age.get());

0N/A }

0N/A#endif

0N/A}

0N/A

0N/Atypedef oop Task;

0N/Atypedef GenericTaskQueue<Task> OopTaskQueue;

0N/Atypedef GenericTaskQueueSet<Task> OopTaskQueueSet;

0N/A

113N/A

113N/A#define COMPRESSED_OOP_MASK 1

113N/A

113N/Aclass StarTask {

113N/A void* _holder; // either union oop* or narrowOop*

113N/A public:

845N/A StarTask(narrowOop* p) {

845N/A assert(((uintptr_t)p & COMPRESSED_OOP_MASK) == 0, "Information loss!");

845N/A _holder = (void *)((uintptr_t)p | COMPRESSED_OOP_MASK);

845N/A }

845N/A StarTask(oop* p) {

845N/A assert(((uintptr_t)p & COMPRESSED_OOP_MASK) == 0, "Information loss!");

845N/A _holder = (void*)p;

845N/A }

113N/A StarTask() { _holder = NULL; }

113N/A operator oop*() { return (oop*)_holder; }

113N/A operator narrowOop*() {

113N/A return (narrowOop*)((uintptr_t)_holder & ~COMPRESSED_OOP_MASK);

113N/A }

113N/A

113N/A // Operators to preserve const/volatile in assignments required by gcc

113N/A void operator=(const volatile StarTask& t) volatile { _holder = t._holder; }

113N/A

113N/A bool is_narrow() const {

113N/A return (((uintptr_t)_holder & COMPRESSED_OOP_MASK) != 0);

113N/A }

113N/A};

113N/A

0N/Atypedef GenericTaskQueue<StarTask> OopStarTaskQueue;

0N/Atypedef GenericTaskQueueSet<StarTask> OopStarTaskQueueSet;

0N/A

375N/Atypedef size_t RegionTask; // index for region

375N/Atypedef GenericTaskQueue<RegionTask> RegionTaskQueue;

375N/Atypedef GenericTaskQueueSet<RegionTask> RegionTaskQueueSet;

0N/A

375N/Aclass RegionTaskQueueWithOverflow: public CHeapObj {

0N/A protected:

375N/A RegionTaskQueue _region_queue;

375N/A GrowableArray<RegionTask>* _overflow_stack;

0N/A

0N/A public:

375N/A RegionTaskQueueWithOverflow() : _overflow_stack(NULL) {}

0N/A // Initialize both stealable queue and overflow

0N/A void initialize();

0N/A // Save first to stealable queue and then to overflow

375N/A void save(RegionTask t);

0N/A // Retrieve first from overflow and then from stealable queue

375N/A bool retrieve(RegionTask& region_index);

0N/A // Retrieve from stealable queue

375N/A bool retrieve_from_stealable_queue(RegionTask& region_index);

0N/A // Retrieve from overflow

375N/A bool retrieve_from_overflow(RegionTask& region_index);

0N/A bool is_empty();

0N/A bool stealable_is_empty();

0N/A bool overflow_is_empty();

541N/A uint stealable_size() { return _region_queue.size(); }

375N/A RegionTaskQueue* task_queue() { return &_region_queue; }

0N/A};

0N/A

375N/A#define USE_RegionTaskQueueWithOverflow