src/share/vm/gc_implementation/g1/g1GCPhaseTimes.cpp

rev 7792 : 8149347: G1: guarantee fails with UseDynamicNumberOfGCThreads
Reviewed-by: poonam, kevinw

*** 152,205 ****
      assert(_data[worker_i] != WorkerDataArray<T>::uninitialized(), err_msg("No data to add to for worker %d", worker_i));
      _data[worker_i] += value;
      _has_new_data = true;
    }
  
!   double average(){
!     calculate_totals();
      return _average;
    }
  
!   T sum() {
!     calculate_totals();
      return _sum;
    }
  
!   T minimum() {
!     calculate_totals();
      return _min;
    }
  
!   T maximum() {
!     calculate_totals();
      return _max;
    }
  
    void reset() PRODUCT_RETURN;
!   void verify() PRODUCT_RETURN;
  
    void set_enabled(bool enabled) { _enabled = enabled; }
  
    int log_level() { return _log_level;  }
  
   private:
  
!   void calculate_totals(){
      if (!_has_new_data) {
        return;
      }
  
      _sum = (T)0;
      _min = _data[0];
      _max = _min;
!     for (uint i = 0; i < _length; ++i) {
        T val = _data[i];
        _sum += val;
        _min = MIN2(_min, val);
        _max = MAX2(_max, val);
      }
!     _average = (double)_sum / (double)_length;
      _has_new_data = false;
    }
  };
  
  
--- 152,206 ----
      assert(_data[worker_i] != WorkerDataArray<T>::uninitialized(), err_msg("No data to add to for worker %d", worker_i));
      _data[worker_i] += value;
      _has_new_data = true;
    }
  
!   double average(uint active_threads){
!     calculate_totals(active_threads);
      return _average;
    }
  
!   T sum(uint active_threads) {
!     calculate_totals(active_threads);
      return _sum;
    }
  
!   T minimum(uint active_threads) {
!     calculate_totals(active_threads);
      return _min;
    }
  
!   T maximum(uint active_threads) {
!     calculate_totals(active_threads);
      return _max;
    }
  
    void reset() PRODUCT_RETURN;
!   void verify(uint active_threads) PRODUCT_RETURN;
  
    void set_enabled(bool enabled) { _enabled = enabled; }
  
    int log_level() { return _log_level;  }
  
   private:
  
!   void calculate_totals(uint active_threads){
      if (!_has_new_data) {
        return;
      }
  
      _sum = (T)0;
      _min = _data[0];
      _max = _min;
!     assert(active_threads <= _length, "Wrong number of active threads");
!     for (uint i = 0; i < active_threads; ++i) {
        T val = _data[i];
        _sum += val;
        _min = MIN2(_min, val);
        _max = MAX2(_max, val);
      }
!     _average = (double)_sum / (double)active_threads;
      _has_new_data = false;
    }
  };
  
  
*** 224,244 ****
      _thread_work_items->reset();
    }
  }
  
  template <class T>
! void WorkerDataArray<T>::verify() {
    if (!_enabled) {
      return;
    }
  
!   for (uint i = 0; i < _length; i++) {
      assert(_data[i] != WorkerDataArray<T>::uninitialized(),
          err_msg("Invalid data for worker %u in '%s'", i, _title));
    }
    if (_thread_work_items != NULL) {
!     _thread_work_items->verify();
    }
  }
  
  #endif
  
--- 225,246 ----
      _thread_work_items->reset();
    }
  }
  
  template <class T>
! void WorkerDataArray<T>::verify(uint active_threads) {
    if (!_enabled) {
      return;
    }
  
!   assert(active_threads <= _length, "Wrong number of active threads");
!   for (uint i = 0; i < active_threads; i++) {
      assert(_data[i] != WorkerDataArray<T>::uninitialized(),
          err_msg("Invalid data for worker %u in '%s'", i, _title));
    }
    if (_thread_work_items != NULL) {
!     _thread_work_items->verify(active_threads);
    }
  }
  
  #endif
  
*** 319,329 ****
  
      record_time_secs(Other, i, worker_time - worker_known_time);
    }
  
    for (int i = 0; i < GCParPhasesSentinel; i++) {
!     _gc_par_phases[i]->verify();
    }
  }
  
  void G1GCPhaseTimes::print_stats(int level, const char* str, double value) {
    LineBuffer(level).append_and_print_cr("[%s: %.1lf ms]", str, value);
--- 321,331 ----
  
      record_time_secs(Other, i, worker_time - worker_known_time);
    }
  
    for (int i = 0; i < GCParPhasesSentinel; i++) {
!     _gc_par_phases[i]->verify(_active_gc_threads);
    }
  }
  
  void G1GCPhaseTimes::print_stats(int level, const char* str, double value) {
    LineBuffer(level).append_and_print_cr("[%s: %.1lf ms]", str, value);
*** 376,427 ****
    _gc_par_phases[phase]->set_thread_work_item(worker_i, count);
  }
  
  // return the average time for a phase in milliseconds
  double G1GCPhaseTimes::average_time_ms(GCParPhases phase) {
!   return _gc_par_phases[phase]->average() * 1000.0;
  }
  
  double G1GCPhaseTimes::get_time_ms(GCParPhases phase, uint worker_i) {
    return _gc_par_phases[phase]->get(worker_i) * 1000.0;
  }
  
  double G1GCPhaseTimes::sum_time_ms(GCParPhases phase) {
!   return _gc_par_phases[phase]->sum() * 1000.0;
  }
  
  double G1GCPhaseTimes::min_time_ms(GCParPhases phase) {
!   return _gc_par_phases[phase]->minimum() * 1000.0;
  }
  
  double G1GCPhaseTimes::max_time_ms(GCParPhases phase) {
!   return _gc_par_phases[phase]->maximum() * 1000.0;
  }
  
  size_t G1GCPhaseTimes::get_thread_work_item(GCParPhases phase, uint worker_i) {
    assert(_gc_par_phases[phase]->thread_work_items() != NULL, "No sub count");
    return _gc_par_phases[phase]->thread_work_items()->get(worker_i);
  }
  
  size_t G1GCPhaseTimes::sum_thread_work_items(GCParPhases phase) {
    assert(_gc_par_phases[phase]->thread_work_items() != NULL, "No sub count");
!   return _gc_par_phases[phase]->thread_work_items()->sum();
  }
  
  double G1GCPhaseTimes::average_thread_work_items(GCParPhases phase) {
    assert(_gc_par_phases[phase]->thread_work_items() != NULL, "No sub count");
!   return _gc_par_phases[phase]->thread_work_items()->average();
  }
  
  size_t G1GCPhaseTimes::min_thread_work_items(GCParPhases phase) {
    assert(_gc_par_phases[phase]->thread_work_items() != NULL, "No sub count");
!   return _gc_par_phases[phase]->thread_work_items()->minimum();
  }
  
  size_t G1GCPhaseTimes::max_thread_work_items(GCParPhases phase) {
    assert(_gc_par_phases[phase]->thread_work_items() != NULL, "No sub count");
!   return _gc_par_phases[phase]->thread_work_items()->maximum();
  }
  
  class G1GCParPhasePrinter : public StackObj {
    G1GCPhaseTimes* _phase_times;
   public:
--- 378,429 ----
    _gc_par_phases[phase]->set_thread_work_item(worker_i, count);
  }
  
  // return the average time for a phase in milliseconds
  double G1GCPhaseTimes::average_time_ms(GCParPhases phase) {
!   return _gc_par_phases[phase]->average(_active_gc_threads) * 1000.0;
  }
  
  double G1GCPhaseTimes::get_time_ms(GCParPhases phase, uint worker_i) {
    return _gc_par_phases[phase]->get(worker_i) * 1000.0;
  }
  
  double G1GCPhaseTimes::sum_time_ms(GCParPhases phase) {
!   return _gc_par_phases[phase]->sum(_active_gc_threads) * 1000.0;
  }
  
  double G1GCPhaseTimes::min_time_ms(GCParPhases phase) {
!   return _gc_par_phases[phase]->minimum(_active_gc_threads) * 1000.0;
  }
  
  double G1GCPhaseTimes::max_time_ms(GCParPhases phase) {
!   return _gc_par_phases[phase]->maximum(_active_gc_threads) * 1000.0;
  }
  
  size_t G1GCPhaseTimes::get_thread_work_item(GCParPhases phase, uint worker_i) {
    assert(_gc_par_phases[phase]->thread_work_items() != NULL, "No sub count");
    return _gc_par_phases[phase]->thread_work_items()->get(worker_i);
  }
  
  size_t G1GCPhaseTimes::sum_thread_work_items(GCParPhases phase) {
    assert(_gc_par_phases[phase]->thread_work_items() != NULL, "No sub count");
!   return _gc_par_phases[phase]->thread_work_items()->sum(_active_gc_threads);
  }
  
  double G1GCPhaseTimes::average_thread_work_items(GCParPhases phase) {
    assert(_gc_par_phases[phase]->thread_work_items() != NULL, "No sub count");
!   return _gc_par_phases[phase]->thread_work_items()->average(_active_gc_threads);
  }
  
  size_t G1GCPhaseTimes::min_thread_work_items(GCParPhases phase) {
    assert(_gc_par_phases[phase]->thread_work_items() != NULL, "No sub count");
!   return _gc_par_phases[phase]->thread_work_items()->minimum(_active_gc_threads);
  }
  
  size_t G1GCPhaseTimes::max_thread_work_items(GCParPhases phase) {
    assert(_gc_par_phases[phase]->thread_work_items() != NULL, "No sub count");
!   return _gc_par_phases[phase]->thread_work_items()->maximum(_active_gc_threads);
  }
  
  class G1GCParPhasePrinter : public StackObj {
    G1GCPhaseTimes* _phase_times;
   public:
*** 453,470 ****
        buf2.append_and_print_cr("[%s:  "SIZE_FORMAT"]", phase->_thread_work_items->_title, _phase_times->sum_thread_work_items(phase_id));
      }
    }
  
    void print_time_values(LineBuffer& buf, G1GCPhaseTimes::GCParPhases phase_id, WorkerDataArray<double>* phase) {
!     for (uint i = 0; i < phase->_length; ++i) {
        buf.append("  %.1lf", _phase_times->get_time_ms(phase_id, i));
      }
      buf.print_cr();
    }
  
    void print_count_values(LineBuffer& buf, G1GCPhaseTimes::GCParPhases phase_id, WorkerDataArray<size_t>* thread_work_items) {
!     for (uint i = 0; i < thread_work_items->_length; ++i) {
        buf.append("  " SIZE_FORMAT, _phase_times->get_thread_work_item(phase_id, i));
      }
      buf.print_cr();
    }
  
--- 455,474 ----
        buf2.append_and_print_cr("[%s:  "SIZE_FORMAT"]", phase->_thread_work_items->_title, _phase_times->sum_thread_work_items(phase_id));
      }
    }
  
    void print_time_values(LineBuffer& buf, G1GCPhaseTimes::GCParPhases phase_id, WorkerDataArray<double>* phase) {
!     uint active_length = _phase_times->_active_gc_threads;
!     for (uint i = 0; i < active_length; ++i) {
        buf.append("  %.1lf", _phase_times->get_time_ms(phase_id, i));
      }
      buf.print_cr();
    }
  
    void print_count_values(LineBuffer& buf, G1GCPhaseTimes::GCParPhases phase_id, WorkerDataArray<size_t>* thread_work_items) {
!     uint active_length = _phase_times->_active_gc_threads;
!     for (uint i = 0; i < active_length; ++i) {
        buf.append("  " SIZE_FORMAT, _phase_times->get_thread_work_item(phase_id, i));
      }
      buf.print_cr();
    }