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

comparison src/share/vm/utilities/taskqueue.hpp @ 1665:a93a9eda13f7

6962947: shared TaskQueue statistics Reviewed-by: tonyp, ysr

author	jcoomes
date	Fri, 16 Jul 2010 21:33:21 -0700
parents	b2a00dd3117c
children	5f429ee79634

comparison

equal deleted inserted replaced

-:1a1ce2076047
+:a93a9eda13f7
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 *
 */
+// Simple TaskQueue stats that are collected by default in debug builds.
+#if !defined(TASKQUEUE_STATS) && defined(ASSERT)
+#define TASKQUEUE_STATS 1
+#elif !defined(TASKQUEUE_STATS)
+#define TASKQUEUE_STATS 0
+#endif
+#if TASKQUEUE_STATS
+#define TASKQUEUE_STATS_ONLY(code) code
+#else
+#define TASKQUEUE_STATS_ONLY(code)
+#endif // TASKQUEUE_STATS
+#if TASKQUEUE_STATS
+class TaskQueueStats {
+public:
+enum StatId {
+push,             // number of taskqueue pushes
+pop,              // number of taskqueue pops
+pop_slow,         // subset of taskqueue pops that were done slow-path
+steal_attempt,    // number of taskqueue steal attempts
+steal,            // number of taskqueue steals
+overflow,         // number of overflow pushes
+overflow_max_len, // max length of overflow stack
+last_stat_id
+};
+public:
+inline TaskQueueStats()       { reset(); }
+inline void record_push()     { ++_stats[push]; }
+inline void record_pop()      { ++_stats[pop]; }
+inline void record_pop_slow() { record_pop(); ++_stats[pop_slow]; }
+inline void record_steal(bool success);
+inline void record_overflow(size_t new_length);
+inline size_t get(StatId id) const { return _stats[id]; }
+inline const size_t* get() const   { return _stats; }
+inline void reset();
+static void print_header(unsigned int line, outputStream* const stream = tty,
+unsigned int width = 10);
+void print(outputStream* const stream = tty, unsigned int width = 10) const;
+private:
+size_t                    _stats[last_stat_id];
+static const char * const _names[last_stat_id];
+};
+void TaskQueueStats::record_steal(bool success) {
+++_stats[steal_attempt];
+if (success) ++_stats[steal];
+}
+void TaskQueueStats::record_overflow(size_t new_len) {
+++_stats[overflow];
+if (new_len > _stats[overflow_max_len]) _stats[overflow_max_len] = new_len;
+}
+void TaskQueueStats::reset() {
+memset(_stats, 0, sizeof(_stats));
+}
+#endif // TASKQUEUE_STATS
 template <unsigned int N>
 class TaskQueueSuper: public CHeapObj {
 protected:
 // Internal type for indexing the queue; also used for the tag.
 typedef NOT_LP64(uint16_t) LP64_ONLY(uint32_t) idx_t;
 // than the actual queue size, for somewhat complicated reasons.
 uint max_elems() const { return N - 2; }
 // Total size of queue.
 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> {
 protected:
 using TaskQueueSuper<N>::dirty_size;
 public:
 using TaskQueueSuper<N>::max_elems;
 using TaskQueueSuper<N>::size;
+TASKQUEUE_STATS_ONLY(using TaskQueueSuper<N>::stats;)
 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);
 // 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);
 OrderAccess::release_store(&_bottom, increment_index(localBot));
+TASKQUEUE_STATS_ONLY(stats.record_push());
 return true;
 }
 return false;
 }
 template<class E, unsigned int N>
-bool GenericTaskQueue<E, N>::
+bool GenericTaskQueue<E, N>::pop_local_slow(uint localBot, Age oldAge) {
-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",
 // install new_age, thus claiming the element.
 Age tempAge = _age.cmpxchg(newAge, oldAge);
 if (tempAge == oldAge) {
 // We win.
 assert(dirty_size(localBot, _age.top()) != N - 1, "sanity");
+TASKQUEUE_STATS_ONLY(stats.record_pop_slow());
 return true;
 }
 }
 // We lose; a completing pop_global gets the element.  But the queue is empty
 // and top is greater than bottom.  Fix this representation of the empty queue
 {
 public:
 typedef GrowableArray<E>       overflow_t;
 typedef GenericTaskQueue<E, N> taskqueue_t;
+TASKQUEUE_STATS_ONLY(using taskqueue_t::stats;)
 OverflowTaskQueue();
 ~OverflowTaskQueue();
 void initialize();
 inline overflow_t* overflow_stack() const { return _overflow_stack; }
 template <class E, unsigned int N>
 bool OverflowTaskQueue<E, N>::push(E t)
 {
 if (!taskqueue_t::push(t)) {
 overflow_stack()->push(t);
+TASKQUEUE_STATS_ONLY(stats.record_overflow(overflow_stack()->length()));
 }
 return true;
 }
 template <class E, unsigned int N>
 return _queues[i];
 }
 template<class T> bool
 GenericTaskQueueSet<T>::steal(uint queue_num, int* seed, E& t) {
-for (uint i = 0; i < 2 * _n; i++)
+for (uint i = 0; i < 2 * _n; i++) {
-if (steal_best_of_2(queue_num, seed, t))
+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
 GenericTaskQueueSet<T>::steal_best_of_all(uint queue_num, int* seed, E& t) {
 assert(dirty_n_elems < N, "n_elems out of range.");
 if (dirty_n_elems < max_elems()) {
 // g++ complains if the volatile result of the assignment is unused.
 const_cast<E&>(_elems[localBot] = t);
 OrderAccess::release_store(&_bottom, increment_index(localBot));
+TASKQUEUE_STATS_ONLY(stats.record_push());
 return true;
 } else {
 return push_slow(t, dirty_n_elems);
 }
 }
 // "_bottom" and "age" we've read, then there can be no interference with
 // a "pop_global" operation, and we're done.
 idx_t tp = _age.top();    // XXX
 if (size(localBot, tp) > 0) {
 assert(dirty_size(localBot, tp) != N - 1, "sanity");
+TASKQUEUE_STATS_ONLY(stats.record_pop());
 return true;
 } else {
 // Otherwise, the queue contained exactly one element; we take the slow
 // path.
 return pop_local_slow(localBot, _age.get());

Mercurial > hg > truffle

comparison src/share/vm/utilities/taskqueue.hpp @ 1665:a93a9eda13f7