1 /*

     2  * Copyright (c) 2015, 2017, 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 #ifndef SHARE_VM_GC_SHARED_WORKERDATAARRAY_INLINE_HPP

    26 #define SHARE_VM_GC_SHARED_WORKERDATAARRAY_INLINE_HPP

    27 

    28 #include "gc/shared/workerDataArray.hpp"

    29 #include "memory/allocation.inline.hpp"

    30 #include "utilities/ostream.hpp"

    31 

    32 template <typename T>

    33 WorkerDataArray<T>::WorkerDataArray(uint length, const char* title) :

    34  _title(title),

    35  _length(0) {

    36   assert(length > 0, "Must have some workers to store data for");

    37   _length = length;

    38   _data = NEW_C_HEAP_ARRAY(T, _length, mtGC);

    39   for (uint i = 0; i < MaxThreadWorkItems; i++) {

    40     _thread_work_items[i] = NULL;

    41   }

    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   return _data[worker_i];

    56 }

    57 

    58 template <typename T>

    59 WorkerDataArray<T>::~WorkerDataArray() {

    60   FREE_C_HEAP_ARRAY(T, _data);

    61 }

    62 

    63 template <typename T>

    64 void WorkerDataArray<T>::link_thread_work_items(WorkerDataArray<size_t>* thread_work_items, uint index) {

    65   assert(index < MaxThreadWorkItems, "Tried to access thread work item %u (max %u)", index, MaxThreadWorkItems);

    66   _thread_work_items[index] = thread_work_items;

    67 }

    68 

    69 template <typename T>

    70 void WorkerDataArray<T>::set_thread_work_item(uint worker_i, size_t value, uint index) {

    71   assert(index < MaxThreadWorkItems, "Tried to access thread work item %u (max %u)", index, MaxThreadWorkItems);

    72   assert(_thread_work_items[index] != NULL, "No sub count");

    73   _thread_work_items[index]->set(worker_i, value);

    74 }

    75 

    76 template <typename T>

    77 void WorkerDataArray<T>::add_thread_work_item(uint worker_i, size_t value, uint index) {

    78   assert(index < MaxThreadWorkItems, "Tried to access thread work item %u (max %u)", index, MaxThreadWorkItems);

    79   assert(_thread_work_items[index] != NULL, "No sub count");

    80   _thread_work_items[index]->add(worker_i, value);

    81 }

    82 

    83 template <typename T>

    84 void WorkerDataArray<T>::add(uint worker_i, T value) {

    85   assert(worker_i < _length, "Worker %d is greater than max: %d", worker_i, _length);

    86   assert(_data[worker_i] != uninitialized(), "No data to add to for worker %d", worker_i);

    87   _data[worker_i] += value;

    88 }

    89 

    90 template <typename T>

    91 double WorkerDataArray<T>::average() const {

    92   uint contributing_threads = 0;

    93   for (uint i = 0; i < _length; ++i) {

    94     if (get(i) != uninitialized()) {

    95       contributing_threads++;

    96     }

    97   }

    98   if (contributing_threads == 0) {

    99     return 0.0;

   100   }

   101   return sum() / (double) contributing_threads;

   102 }

   103 

   104 template <typename T>

   105 T WorkerDataArray<T>::sum() const {

   106   T s = 0;

   107   for (uint i = 0; i < _length; ++i) {

   108     if (get(i) != uninitialized()) {

   109       s += get(i);

   110     }

   111   }

   112   return s;

   113 }

   114 

   115 template <typename T>

   116 void WorkerDataArray<T>::set_all(T value) {

   117   for (uint i = 0; i < _length; i++) {

   118     _data[i] = value;

   119   }

   120 }

   121 

   122 template <class T>

   123 void WorkerDataArray<T>::print_summary_on(outputStream* out, bool print_sum) const {

   124   out->print("%-25s", title());

   125   uint start = 0;

   126   while (start < _length && get(start) == uninitialized()) {

   127     start++;

   128   }

   129   if (start < _length) {

   130     T min = get(start);

   131     T max = min;

   132     T sum = 0;

   133     uint contributing_threads = 0;

   134     for (uint i = start; i < _length; ++i) {

   135       T value = get(i);

   136       if (value != uninitialized()) {

   137         max = MAX2(max, value);

   138         min = MIN2(min, value);

   139         sum += value;

   140         contributing_threads++;

   141       }

   142     }

   143     T diff = max - min;

   144     assert(contributing_threads != 0, "Must be since we found a used value for the start index");

   145     double avg = sum / (double) contributing_threads;

   146     WDAPrinter::summary(out, min, avg, max, diff, sum, print_sum);

   147     out->print_cr(", Workers: %d", contributing_threads);

   148   } else {

   149     // No data for this phase.

   150     out->print_cr(" skipped");

   151   }

   152 }

   153 

   154 template <class T>

   155 void WorkerDataArray<T>::print_details_on(outputStream* out) const {

   156   WDAPrinter::details(this, out);

   157 }

   158 

   159 template <typename T>

   160 void WorkerDataArray<T>::reset() {

   161   set_all(uninitialized());

   162   for (uint i = 0; i < MaxThreadWorkItems; i++) {

   163     if (_thread_work_items[i] != NULL) {

   164       _thread_work_items[i]->reset();

   165     }

   166   }

   167 }

   168 

   169 #endif // SHARE_VM_GC_SHARED_WORKERDATAARRAY_INLINE_HPP