truffle: src/share/vm/utilities/taskqueue.hpp comparison

comparison src/share/vm/utilities/taskqueue.hpp @ 6197:d2a62e0f25eb

6995781: Native Memory Tracking (Phase 1) 7151532: DCmd for hotspot native memory tracking Summary: Implementation of native memory tracking phase 1, which tracks VM native memory usage, and related DCmd Reviewed-by: acorn, coleenp, fparain

author	zgu
date	Thu, 28 Jun 2012 17:03:16 -0400
parents	f08d439fab8c
children	b9a9ed0f8eeb

comparison

equal deleted inserted replaced

-:74533f63b116
+:d2a62e0f25eb
 void TaskQueueStats::reset() {
 memset(_stats, 0, sizeof(_stats));
 }
 #endif // TASKQUEUE_STATS
-template <unsigned int N>
+template <unsigned int N, MEMFLAGS F>
-class TaskQueueSuper: public CHeapObj {
+class TaskQueueSuper: public CHeapObj<F> {
 protected:
 // Internal type for indexing the queue; also used for the tag.
 typedef NOT_LP64(uint16_t) LP64_ONLY(uint32_t) idx_t;
 // The first free element after the last one pushed (mod N).
 static const uint total_size() { return N; }
 TASKQUEUE_STATS_ONLY(TaskQueueStats stats;)
 };
-template<class E, unsigned int N = TASKQUEUE_SIZE>
-class GenericTaskQueue: public TaskQueueSuper<N> {
+template <class E, MEMFLAGS F, unsigned int N = TASKQUEUE_SIZE>
+class GenericTaskQueue: public TaskQueueSuper<N, F> {
 protected:
-typedef typename TaskQueueSuper<N>::Age Age;
+typedef typename TaskQueueSuper<N, F>::Age Age;
-typedef typename TaskQueueSuper<N>::idx_t idx_t;
+typedef typename TaskQueueSuper<N, F>::idx_t idx_t;
-using TaskQueueSuper<N>::_bottom;
+using TaskQueueSuper<N, F>::_bottom;
-using TaskQueueSuper<N>::_age;
+using TaskQueueSuper<N, F>::_age;
-using TaskQueueSuper<N>::increment_index;
+using TaskQueueSuper<N, F>::increment_index;
-using TaskQueueSuper<N>::decrement_index;
+using TaskQueueSuper<N, F>::decrement_index;
-using TaskQueueSuper<N>::dirty_size;
+using TaskQueueSuper<N, F>::dirty_size;
 public:
-using TaskQueueSuper<N>::max_elems;
+using TaskQueueSuper<N, F>::max_elems;
-using TaskQueueSuper<N>::size;
+using TaskQueueSuper<N, F>::size;
-TASKQUEUE_STATS_ONLY(using TaskQueueSuper<N>::stats;)
+#if  TASKQUEUE_STATS
+using TaskQueueSuper<N, F>::stats;
+#endif
 private:
 // Slow paths for push, pop_local.  (pop_global has no fast path.)
 bool push_slow(E t, uint dirty_n_elems);
 bool pop_local_slow(uint localBot, Age oldAge);
 private:
 // Element array.
 volatile E* _elems;
 };
-template<class E, unsigned int N>
+template<class E, MEMFLAGS F, unsigned int N>
-GenericTaskQueue<E, N>::GenericTaskQueue() {
+GenericTaskQueue<E, F, N>::GenericTaskQueue() {
 assert(sizeof(Age) == sizeof(size_t), "Depends on this.");
 }
-template<class E, unsigned int N>
+template<class E, MEMFLAGS F, unsigned int N>
-void GenericTaskQueue<E, N>::initialize() {
+void GenericTaskQueue<E, F, N>::initialize() {
-_elems = NEW_C_HEAP_ARRAY(E, N);
+_elems = NEW_C_HEAP_ARRAY(E, N, F);
 }
-template<class E, unsigned int N>
+template<class E, MEMFLAGS F, unsigned int N>
-void GenericTaskQueue<E, N>::oops_do(OopClosure* f) {
+void GenericTaskQueue<E, F, N>::oops_do(OopClosure* f) {
 // tty->print_cr("START OopTaskQueue::oops_do");
 uint iters = size();
 uint index = _bottom;
 for (uint i = 0; i < iters; ++i) {
 index = decrement_index(index);
 f->do_oop(p);
 }
 // tty->print_cr("END OopTaskQueue::oops_do");
 }
-template<class E, unsigned int N>
+template<class E, MEMFLAGS F, unsigned int N>
-bool GenericTaskQueue<E, N>::push_slow(E t, uint dirty_n_elems) {
+bool GenericTaskQueue<E, F, N>::push_slow(E t, uint dirty_n_elems) {
 if (dirty_n_elems == N - 1) {
 // Actually means 0, so do the push.
 uint localBot = _bottom;
 // g++ complains if the volatile result of the assignment is unused.
 const_cast<E&>(_elems[localBot] = t);
 // get the last task in the queue.  It will compete with pop_global()
 // that will be used by other threads.  The tag age is incremented
 // whenever the queue goes empty which it will do here if this thread
 // gets the last task or in pop_global() if the queue wraps (top == 0
 // and pop_global() succeeds, see pop_global()).
-template<class E, unsigned int N>
+template<class E, MEMFLAGS F, unsigned int N>
-bool GenericTaskQueue<E, N>::pop_local_slow(uint localBot, Age oldAge) {
+bool GenericTaskQueue<E, F, N>::pop_local_slow(uint localBot, Age oldAge) {
 // This queue was observed to contain exactly one element; either this
 // thread will claim it, or a competing "pop_global".  In either case,
 // the queue will be logically empty afterwards.  Create a new Age value
 // that represents the empty queue for the given value of "_bottom".  (We
 // must also increment "tag" because of the case where "bottom == 1",
 _age.set(newAge);
 assert(dirty_size(localBot, _age.top()) != N - 1, "sanity");
 return false;
 }
-template<class E, unsigned int N>
+template<class E, MEMFLAGS F, unsigned int N>
-bool GenericTaskQueue<E, N>::pop_global(E& t) {
+bool GenericTaskQueue<E, F, N>::pop_global(E& t) {
 Age oldAge = _age.get();
 uint localBot = _bottom;
 uint n_elems = size(localBot, oldAge.top());
 if (n_elems == 0) {
 return false;
 // have decremented it.
 assert(dirty_size(localBot, newAge.top()) != N - 1, "sanity");
 return resAge == oldAge;
 }
-template<class E, unsigned int N>
+template<class E, MEMFLAGS F, unsigned int N>
-GenericTaskQueue<E, N>::~GenericTaskQueue() {
+GenericTaskQueue<E, F, N>::~GenericTaskQueue() {
-FREE_C_HEAP_ARRAY(E, _elems);
+FREE_C_HEAP_ARRAY(E, _elems, F);
 }
 // OverflowTaskQueue is a TaskQueue that also includes an overflow stack for
 // elements that do not fit in the TaskQueue.
 //
 // is_empty() - return true if both the TaskQueue and overflow stack are empty
 //
 // Note that size() is not hidden--it returns the number of elements in the
 // TaskQueue, and does not include the size of the overflow stack.  This
 // simplifies replacement of GenericTaskQueues with OverflowTaskQueues.
-template<class E, unsigned int N = TASKQUEUE_SIZE>
+template<class E, MEMFLAGS F, unsigned int N = TASKQUEUE_SIZE>
-class OverflowTaskQueue: public GenericTaskQueue<E, N>
+class OverflowTaskQueue: public GenericTaskQueue<E, F, N>
 {
 public:
-typedef Stack<E>               overflow_t;
+typedef Stack<E, F>               overflow_t;
-typedef GenericTaskQueue<E, N> taskqueue_t;
+typedef GenericTaskQueue<E, F, N> taskqueue_t;
 TASKQUEUE_STATS_ONLY(using taskqueue_t::stats;)
 // Push task t onto the queue or onto the overflow stack.  Return true.
 inline bool push(E t);
 private:
 overflow_t _overflow_stack;
 };
-template <class E, unsigned int N>
+template <class E, MEMFLAGS F, unsigned int N>
-bool OverflowTaskQueue<E, N>::push(E t)
+bool OverflowTaskQueue<E, F, N>::push(E t)
 {
 if (!taskqueue_t::push(t)) {
 overflow_stack()->push(t);
 TASKQUEUE_STATS_ONLY(stats.record_overflow(overflow_stack()->size()));
 }
 return true;
 }
-template <class E, unsigned int N>
+template <class E, MEMFLAGS F, unsigned int N>
-bool OverflowTaskQueue<E, N>::pop_overflow(E& t)
+bool OverflowTaskQueue<E, F, N>::pop_overflow(E& t)
 {
 if (overflow_empty()) return false;
 t = overflow_stack()->pop();
 return true;
 }
-class TaskQueueSetSuper: public CHeapObj {
+class TaskQueueSetSuper {
 protected:
 static int randomParkAndMiller(int* seed0);
 public:
 // Returns "true" if some TaskQueue in the set contains a task.
 virtual bool peek() = 0;
 };
-template<class T>
+template <MEMFLAGS F> class TaskQueueSetSuperImpl: public CHeapObj<F>, public TaskQueueSetSuper {
-class GenericTaskQueueSet: public TaskQueueSetSuper {
+};
+template<class T, MEMFLAGS F>
+class GenericTaskQueueSet: public TaskQueueSetSuperImpl<F> {
 private:
 uint _n;
 T** _queues;
 public:
 typedef typename T::element_type E;
 GenericTaskQueueSet(int n) : _n(n) {
 typedef T* GenericTaskQueuePtr;
-_queues = NEW_C_HEAP_ARRAY(GenericTaskQueuePtr, n);
+_queues = NEW_C_HEAP_ARRAY(GenericTaskQueuePtr, n, F);
 for (int i = 0; i < n; i++) {
 _queues[i] = NULL;
 }
 }
 bool steal(uint queue_num, int* seed, E& t);
 bool peek();
 };
-template<class T> void
+template<class T, MEMFLAGS F> void
-GenericTaskQueueSet<T>::register_queue(uint i, T* q) {
+GenericTaskQueueSet<T, F>::register_queue(uint i, T* q) {
 assert(i < _n, "index out of range.");
 _queues[i] = q;
 }
-template<class T> T*
+template<class T, MEMFLAGS F> T*
-GenericTaskQueueSet<T>::queue(uint i) {
+GenericTaskQueueSet<T, F>::queue(uint i) {
 return _queues[i];
 }
-template<class T> bool
+template<class T, MEMFLAGS F> bool
-GenericTaskQueueSet<T>::steal(uint queue_num, int* seed, E& t) {
+GenericTaskQueueSet<T, F>::steal(uint queue_num, int* seed, E& t) {
 for (uint i = 0; i < 2 * _n; i++) {
 if (steal_best_of_2(queue_num, seed, t)) {
 TASKQUEUE_STATS_ONLY(queue(queue_num)->stats.record_steal(true));
 return true;
 }
 }
 TASKQUEUE_STATS_ONLY(queue(queue_num)->stats.record_steal(false));
 return false;
 }
-template<class T> bool
+template<class T, MEMFLAGS F> bool
-GenericTaskQueueSet<T>::steal_best_of_all(uint queue_num, int* seed, E& t) {
+GenericTaskQueueSet<T, F>::steal_best_of_all(uint queue_num, int* seed, E& t) {
 if (_n > 2) {
 int best_k;
 uint best_sz = 0;
 for (uint k = 0; k < _n; k++) {
 if (k == queue_num) continue;
 assert(_n == 1, "can't be zero.");
 return false;
 }
 }
-template<class T> bool
+template<class T, MEMFLAGS F> bool
-GenericTaskQueueSet<T>::steal_1_random(uint queue_num, int* seed, E& t) {
+GenericTaskQueueSet<T, F>::steal_1_random(uint queue_num, int* seed, E& t) {
 if (_n > 2) {
 uint k = queue_num;
-while (k == queue_num) k = randomParkAndMiller(seed) % _n;
+while (k == queue_num) k = TaskQueueSetSuper::randomParkAndMiller(seed) % _n;
 return _queues[2]->pop_global(t);
 } else if (_n == 2) {
 // Just try the other one.
 int k = (queue_num + 1) % 2;
 return _queues[k]->pop_global(t);
 assert(_n == 1, "can't be zero.");
 return false;
 }
 }
-template<class T> bool
+template<class T, MEMFLAGS F> bool
-GenericTaskQueueSet<T>::steal_best_of_2(uint queue_num, int* seed, E& t) {
+GenericTaskQueueSet<T, F>::steal_best_of_2(uint queue_num, int* seed, E& t) {
 if (_n > 2) {
 uint k1 = queue_num;
-while (k1 == queue_num) k1 = randomParkAndMiller(seed) % _n;
+while (k1 == queue_num) k1 = TaskQueueSetSuper::randomParkAndMiller(seed) % _n;
 uint k2 = queue_num;
-while (k2 == queue_num || k2 == k1) k2 = randomParkAndMiller(seed) % _n;
+while (k2 == queue_num || k2 == k1) k2 = TaskQueueSetSuper::randomParkAndMiller(seed) % _n;
 // Sample both and try the larger.
 uint sz1 = _queues[k1]->size();
 uint sz2 = _queues[k2]->size();
 if (sz2 > sz1) return _queues[k2]->pop_global(t);
 else return _queues[k1]->pop_global(t);
 assert(_n == 1, "can't be zero.");
 return false;
 }
 }
-template<class T>
+template<class T, MEMFLAGS F>
-bool GenericTaskQueueSet<T>::peek() {
+bool GenericTaskQueueSet<T, F>::peek() {
 // Try all the queues.
 for (uint j = 0; j < _n; j++) {
 if (_queues[j]->peek())
 return true;
 }
 return false;
 }
 // When to terminate from the termination protocol.
-class TerminatorTerminator: public CHeapObj {
+class TerminatorTerminator: public CHeapObj<mtInternal> {
 public:
 virtual bool should_exit_termination() = 0;
 };
 // A class to aid in the termination of a set of parallel tasks using
 static uint total_peeks() { return _total_peeks; }
 static void print_termination_counts();
 #endif
 };
-template<class E, unsigned int N> inline bool
+template<class E, MEMFLAGS F, unsigned int N> inline bool
-GenericTaskQueue<E, N>::push(E t) {
+GenericTaskQueue<E, F, N>::push(E t) {
 uint localBot = _bottom;
 assert((localBot >= 0) && (localBot < N), "_bottom out of range.");
 idx_t top = _age.top();
 uint dirty_n_elems = dirty_size(localBot, top);
 assert(dirty_n_elems < N, "n_elems out of range.");
 } else {
 return push_slow(t, dirty_n_elems);
 }
 }
-template<class E, unsigned int N> inline bool
+template<class E, MEMFLAGS F, unsigned int N> inline bool
-GenericTaskQueue<E, N>::pop_local(E& t) {
+GenericTaskQueue<E, F, N>::pop_local(E& t) {
 uint localBot = _bottom;
 // This value cannot be N-1.  That can only occur as a result of
 // the assignment to bottom in this method.  If it does, this method
 // resets the size to 0 before the next call (which is sequential,
 // since this is pop_local.)
 // path.
 return pop_local_slow(localBot, _age.get());
 }
 }
-typedef GenericTaskQueue<oop>             OopTaskQueue;
+typedef GenericTaskQueue<oop, mtGC>             OopTaskQueue;
-typedef GenericTaskQueueSet<OopTaskQueue> OopTaskQueueSet;
+typedef GenericTaskQueueSet<OopTaskQueue, mtGC> OopTaskQueueSet;
 #ifdef _MSC_VER
 #pragma warning(push)
 // warning C4522: multiple assignment operators specified
 #pragma warning(disable:4522)
 #ifdef _MSC_VER
 #pragma warning(pop)
 #endif
-typedef OverflowTaskQueue<StarTask>           OopStarTaskQueue;
+typedef OverflowTaskQueue<StarTask, mtClass>           OopStarTaskQueue;
-typedef GenericTaskQueueSet<OopStarTaskQueue> OopStarTaskQueueSet;
+typedef GenericTaskQueueSet<OopStarTaskQueue, mtClass> OopStarTaskQueueSet;
-typedef OverflowTaskQueue<size_t>             RegionTaskQueue;
+typedef OverflowTaskQueue<size_t, mtInternal>             RegionTaskQueue;
-typedef GenericTaskQueueSet<RegionTaskQueue>  RegionTaskQueueSet;
+typedef GenericTaskQueueSet<RegionTaskQueue, mtClass>     RegionTaskQueueSet;
 #endif // SHARE_VM_UTILITIES_TASKQUEUE_HPP

Mercurial > hg > truffle

comparison src/share/vm/utilities/taskqueue.hpp @ 6197:d2a62e0f25eb