src/share/vm/gc/g1/workerDataArray.inline.hpp

@@ -48,11 +48,10 @@
 }
 
 template <typename T>
 T WorkerDataArray<T>::get(uint worker_i) const {
   assert(worker_i < _length, "Worker %d is greater than max: %d", worker_i, _length);
-  assert(_data[worker_i] != uninitialized(), "No data added for worker %d", worker_i);
   return _data[worker_i];
 }
 
 template <typename T>
 WorkerDataArray<T>::~WorkerDataArray() {

@@ -76,84 +75,86 @@
   assert(_data[worker_i] != uninitialized(), "No data to add to for worker %d", worker_i);
   _data[worker_i] += value;
 }
 
 template <typename T>
-double WorkerDataArray<T>::average(uint active_threads) const {
-  return sum(active_threads) / (double) active_threads;
+double WorkerDataArray<T>::average() const {
+  uint active_threads = 0;
+  for (uint i = 0; i < _length; ++i) {
+    if (get(i) != uninitialized()) {
+      active_threads++;
+    }
+  }
+  if (active_threads == 0) {
+    return 0.0;
+  }
+  return sum() / (double) active_threads;
 }
 
 template <typename T>
-T WorkerDataArray<T>::sum(uint active_threads) const {
-  T s = get(0);
-  for (uint i = 1; i < active_threads; ++i) {
+T WorkerDataArray<T>::sum() const {
+  T s = 0;
+  for (uint i = 0; i < _length; ++i) {
+    if (get(i) != uninitialized()) {
     s += get(i);
   }
+  }
   return s;
 }
 
 template <typename T>
-void WorkerDataArray<T>::clear() {
-  set_all(0);
-}
-
-template <typename T>
 void WorkerDataArray<T>::set_all(T value) {
   for (uint i = 0; i < _length; i++) {
     _data[i] = value;
   }
 }
 
 template <class T>
-void WorkerDataArray<T>::print_summary_on(outputStream* out, uint active_threads, bool print_sum) const {
-  T max = get(0);
-  T min = max;
+void WorkerDataArray<T>::print_summary_on(outputStream* out, bool print_sum) const {
+  uint start = 0;
+  while (get(start) == uninitialized()) {
+    assert(start < _length, "Printing unused WorkerDataArray.");
+    start++;
+  }
+  T min = get(start);
+  T max = min;
   T sum = 0;
-  for (uint i = 1; i < active_threads; ++i) {
+  uint active_threads = 0;
+  for (uint i = start; i < _length; ++i) {
     T value = get(i);
+    if (value != uninitialized()) {
     max = MAX2(max, value);
     min = MIN2(min, value);
     sum += value;
+      active_threads++;
+    }
   }
   T diff = max - min;
+  assert(active_threads != 0, "Must be since we found a used value for the start index");
   double avg = sum / (double) active_threads;
   WDAPrinter::summary(out, title(), min, avg, max, diff, sum, print_sum);
 }
 
 template <class T>
-void WorkerDataArray<T>::print_details_on(outputStream* out, uint active_threads) const {
-  WDAPrinter::details(this, out, active_threads);
+void WorkerDataArray<T>::print_details_on(outputStream* out) const {
+  WDAPrinter::details(this, out);
 }
 
-#ifndef PRODUCT
 template <typename T>
 void WorkerDataArray<T>::reset() {
   set_all(uninitialized());
   if (_thread_work_items != NULL) {
     _thread_work_items->reset();
   }
 }
 
-template <typename T>
-void WorkerDataArray<T>::verify(uint active_threads) const {
-  assert(active_threads <= _length, "Wrong number of active threads");
-  for (uint i = 0; i < active_threads; i++) {
-    assert(_data[i] != uninitialized(),
-           "Invalid data for worker %u in '%s'", i, _title);
-  }
-  if (_thread_work_items != NULL) {
-    _thread_work_items->verify(active_threads);
-  }
-}
-
 template <>
 inline size_t WorkerDataArray<size_t>::uninitialized() const {
   return (size_t)-1;
 }
 
 template <>
 inline double WorkerDataArray<double>::uninitialized() const {
   return -1.0;
 }
-#endif
 
 #endif // SHARE_VM_GC_G1_WORKERDATAARRAY_INLINE_HPP