1 /*
   2  * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 



  25 #include "gc/g1/workerDataArray.hpp"
  26 #include "memory/allocation.inline.hpp"

  27 
  28 template <typename T>
  29 WorkerDataArray<T>::WorkerDataArray(uint length,
  30                                     const char* title,
  31                                     bool print_sum,
  32                                     uint indent_level) :
  33  _title(title),
  34  _length(0),
  35  _print_sum(print_sum),
  36  _indent_level(indent_level),
  37  _thread_work_items(NULL),
  38  _enabled(true) {
  39   assert(length > 0, "Must have some workers to store data for");
  40   _length = length;
  41   _data = NEW_C_HEAP_ARRAY(T, _length, mtGC);
  42   reset();
  43 }
  44 
  45 template <typename T>
  46 void WorkerDataArray<T>::set(uint worker_i, T value) {
  47   assert(worker_i < _length, "Worker %d is greater than max: %d", worker_i, _length);
  48   assert(_data[worker_i] == uninitialized(), "Overwriting data for worker %d in %s", worker_i, _title);
  49   _data[worker_i] = value;
  50 }
  51 
  52 template <typename T>
  53 T WorkerDataArray<T>::get(uint worker_i) const {
  54   assert(worker_i < _length, "Worker %d is greater than max: %d", worker_i, _length);
  55   assert(_data[worker_i] != uninitialized(), "No data added for worker %d", worker_i);
  56   return _data[worker_i];
  57 }
  58 
  59 template <typename T>
  60 WorkerDataArray<T>::~WorkerDataArray() {
  61   FREE_C_HEAP_ARRAY(T, _data);
  62 }
  63 
  64 template <typename T>
  65 void WorkerDataArray<T>::link_thread_work_items(WorkerDataArray<size_t>* thread_work_items) {
  66   _thread_work_items = thread_work_items;
  67 }
  68 
  69 template <typename T>
  70 void WorkerDataArray<T>::set_thread_work_item(uint worker_i, size_t value) {
  71   assert(_thread_work_items != NULL, "No sub count");
  72   _thread_work_items->set(worker_i, value);
  73 }
  74 
  75 template <typename T>
  76 void WorkerDataArray<T>::add(uint worker_i, T value) {
  77   assert(worker_i < _length, "Worker %d is greater than max: %d", worker_i, _length);
  78   assert(_data[worker_i] != uninitialized(), "No data to add to for worker %d", worker_i);
  79   _data[worker_i] += value;
  80 }
  81 
  82 template <typename T>
  83 double WorkerDataArray<T>::average(uint active_threads) const {
  84   return sum(active_threads) / (double) active_threads;
  85 }
  86 
  87 template <typename T>
  88 T WorkerDataArray<T>::sum(uint active_threads) const {
  89   T s = get(0);
  90   for (uint i = 1; i < active_threads; ++i) {
  91     s += get(i);
  92   }
  93   return s;
  94 }
  95 
  96 template <typename T>
  97 T WorkerDataArray<T>::minimum(uint active_threads) const {
  98   T min = get(0);
  99   for (uint i = 1; i < active_threads; ++i) {
 100     min = MIN2(min, get(i));
 101   }
 102   return min;
 103 }
 104 
 105 template <typename T>
 106 T WorkerDataArray<T>::maximum(uint active_threads) const {
 107   T max = get(0);
 108   for (uint i = 1; i < active_threads; ++i) {
 109     max = MAX2(max, get(i));
 110   }
 111   return max;
 112 }
 113 
 114 template <typename T>
 115 T WorkerDataArray<T>::diff(uint active_threads) const {
 116   return maximum(active_threads) - minimum(active_threads);
 117 }
 118 
 119 template <typename T>
 120 void WorkerDataArray<T>::clear() {
 121   set_all(0);
 122 }
 123 
 124 template <typename T>
 125 void WorkerDataArray<T>::set_all(T value) {
 126   for (uint i = 0; i < _length; i++) {
 127     _data[i] = value;
 128   }
 129 }
 130 





















 131 #ifndef PRODUCT
 132 template <typename T>
 133 void WorkerDataArray<T>::reset() {
 134   set_all(uninitialized());
 135   if (_thread_work_items != NULL) {
 136     _thread_work_items->reset();
 137   }
 138 }
 139 
 140 template <typename T>
 141 void WorkerDataArray<T>::verify(uint active_threads) const {
 142   if (!_enabled) {
 143     return;
 144   }
 145 
 146   assert(active_threads <= _length, "Wrong number of active threads");
 147   for (uint i = 0; i < active_threads; i++) {
 148     assert(_data[i] != uninitialized(),
 149            "Invalid data for worker %u in '%s'", i, _title);
 150   }
 151   if (_thread_work_items != NULL) {
 152     _thread_work_items->verify(active_threads);
 153   }
 154 }
 155 
 156 template <>
 157 inline size_t WorkerDataArray<size_t>::uninitialized() const {
 158   return (size_t)-1;
 159 }
 160 
 161 template <>
 162 inline double WorkerDataArray<double>::uninitialized() const {
 163   return -1.0;
 164 }
 165 #endif


--- EOF ---