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

*** 48,58 ****
  }
  
  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() {
--- 48,57 ----
*** 76,159 ****
    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;
  }
  
  template <typename T>
! T WorkerDataArray<T>::sum(uint active_threads) const {
!   T s = get(0);
!   for (uint i = 1; i < active_threads; ++i) {
      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;
    T sum = 0;
!   for (uint i = 1; i < active_threads; ++i) {
      T value = get(i);
      max = MAX2(max, value);
      min = MIN2(min, value);
      sum += value;
    }
    T diff = max - min;
    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);
  }
  
- #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
--- 75,156 ----
    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() 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() 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>::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, bool print_sum) const {
!   out->print("%-25s", title());
!   uint start = 0;
!   while (start < _length && get(start) == uninitialized()) {
!     start++;
!   }
!   if (start < _length) {
!     T min = get(start);
!     T max = min;
      T sum = 0;
!     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, min, avg, max, diff, sum, print_sum);
!     out->print_cr(", Workers: %d", active_threads);
!   } else {
!     // No data for this phase.
!     out->print_cr(" skipped");
!   }
  }
  
  template <class T>
! void WorkerDataArray<T>::print_details_on(outputStream* out) const {
!   WDAPrinter::details(this, out);
  }
  
  template <typename T>
  void WorkerDataArray<T>::reset() {
    set_all(uninitialized());
    if (_thread_work_items != NULL) {
      _thread_work_items->reset();
    }
  }
  
  #endif // SHARE_VM_GC_G1_WORKERDATAARRAY_INLINE_HPP