63     times[i] = uninitialized_time;
  64   }
  65 }
  66 
  67 static void reset_items(size_t* items, size_t nitems) {
  68   for (size_t i = 0; i < nitems; ++i) {
  69     items[i] = 0;
  70   }
  71 }
  72 
  73 void WeakProcessorPhaseTimes::reset_phase_data() {
  74   reset_times(_phase_times_sec, ARRAY_SIZE(_phase_times_sec));
  75   reset_items(_phase_dead_items, ARRAY_SIZE(_phase_dead_items));
  76   reset_items(_phase_total_items, ARRAY_SIZE(_phase_total_items));
  77 }
  78 
  79 WeakProcessorPhaseTimes::WeakProcessorPhaseTimes(uint max_threads) :
  80   _max_threads(max_threads),
  81   _active_workers(0),
  82   _total_time_sec(uninitialized_time),
  83   _worker_data(),
  84   _worker_dead_items(),
  85   _worker_total_items()
  86 {
  87   assert(_max_threads > 0, "max_threads must not be zero");
  88 
  89   reset_phase_data();
  90 
  91   WorkerDataArray<double>** wpt = _worker_data;
  92   OopStorageSet::Iterator it = OopStorageSet::weak_iterator();
  93   for ( ; !it.is_end(); ++it) {
  94     assert(size_t(wpt - _worker_data) < ARRAY_SIZE(_worker_data), "invariant");
  95     const char* description = it->name();
  96     *wpt = new WorkerDataArray<double>(_max_threads, description);
  97     (*wpt)->link_thread_work_items(new WorkerDataArray<size_t>(_max_threads, "Dead"), DeadItems);
  98     (*wpt)->link_thread_work_items(new WorkerDataArray<size_t>(_max_threads, "Total"), TotalItems);
  99     wpt++;
 100   }
 101   assert(size_t(wpt - _worker_data) == ARRAY_SIZE(_worker_data), "invariant");
 102 }
 103 
 104 WeakProcessorPhaseTimes::~WeakProcessorPhaseTimes() {
 105   for (size_t i = 0; i < ARRAY_SIZE(_worker_data); ++i) {
 106     delete _worker_data[i];
 107     delete _worker_dead_items[i];
 108     delete _worker_total_items[i];
 109   }
 110 }
 111 
 112 uint WeakProcessorPhaseTimes::max_threads() const { return _max_threads; }
 113 
 114 uint WeakProcessorPhaseTimes::active_workers() const {
 115   assert(_active_workers != 0, "active workers not set");
 116   return _active_workers;
 117 }
 118 
 119 void WeakProcessorPhaseTimes::set_active_workers(uint n) {
 120   assert(_active_workers == 0, "active workers already set");
 121   assert(n > 0, "active workers must be non-zero");
 122   assert(n <= _max_threads, "active workers must not exceed max threads");
 123   _active_workers = n;
 124 }
 125 
 126 void WeakProcessorPhaseTimes::reset() {
 127   _active_workers = 0;
 128   _total_time_sec = uninitialized_time;

  63     times[i] = uninitialized_time;
  64   }
  65 }
  66 
  67 static void reset_items(size_t* items, size_t nitems) {
  68   for (size_t i = 0; i < nitems; ++i) {
  69     items[i] = 0;
  70   }
  71 }
  72 
  73 void WeakProcessorPhaseTimes::reset_phase_data() {
  74   reset_times(_phase_times_sec, ARRAY_SIZE(_phase_times_sec));
  75   reset_items(_phase_dead_items, ARRAY_SIZE(_phase_dead_items));
  76   reset_items(_phase_total_items, ARRAY_SIZE(_phase_total_items));
  77 }
  78 
  79 WeakProcessorPhaseTimes::WeakProcessorPhaseTimes(uint max_threads) :
  80   _max_threads(max_threads),
  81   _active_workers(0),
  82   _total_time_sec(uninitialized_time),
  83   _worker_data()


  84 {
  85   assert(_max_threads > 0, "max_threads must not be zero");
  86 
  87   reset_phase_data();
  88 
  89   WorkerDataArray<double>** wpt = _worker_data;
  90   OopStorageSet::Iterator it = OopStorageSet::weak_iterator();
  91   for ( ; !it.is_end(); ++it) {
  92     assert(size_t(wpt - _worker_data) < ARRAY_SIZE(_worker_data), "invariant");
  93     const char* description = it->name();
  94     *wpt = new WorkerDataArray<double>(description, _max_threads);
  95     (*wpt)->create_thread_work_items("Dead", DeadItems);
  96     (*wpt)->create_thread_work_items("Total", TotalItems);
  97     wpt++;
  98   }
  99   assert(size_t(wpt - _worker_data) == ARRAY_SIZE(_worker_data), "invariant");
 100 }
 101 
 102 WeakProcessorPhaseTimes::~WeakProcessorPhaseTimes() {
 103   for (size_t i = 0; i < ARRAY_SIZE(_worker_data); ++i) {
 104     delete _worker_data[i];


 105   }
 106 }
 107 
 108 uint WeakProcessorPhaseTimes::max_threads() const { return _max_threads; }
 109 
 110 uint WeakProcessorPhaseTimes::active_workers() const {
 111   assert(_active_workers != 0, "active workers not set");
 112   return _active_workers;
 113 }
 114 
 115 void WeakProcessorPhaseTimes::set_active_workers(uint n) {
 116   assert(_active_workers == 0, "active workers already set");
 117   assert(n > 0, "active workers must be non-zero");
 118   assert(n <= _max_threads, "active workers must not exceed max threads");
 119   _active_workers = n;
 120 }
 121 
 122 void WeakProcessorPhaseTimes::reset() {
 123   _active_workers = 0;
 124   _total_time_sec = uninitialized_time;