1 /*

     2  * Copyright (c) 2015, 2016, 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 "precompiled.hpp"

    26 #include "gc/g1/g1CollectedHeap.inline.hpp"

    27 #include "gc/g1/g1IHOPControl.hpp"

    28 #include "gc/g1/g1Predictions.hpp"

    29 #include "gc/shared/gcTrace.hpp"

    30 #include "logging/log.hpp"

    31 

    32 G1IHOPControl::G1IHOPControl(double initial_ihop_percent) :

    33   _initial_ihop_percent(initial_ihop_percent),

    34   _target_occupancy(0),

    35   _last_allocated_bytes(0),

    36   _last_allocation_time_s(0.0)

    37 {

    38   assert(_initial_ihop_percent >= 0.0 && _initial_ihop_percent <= 100.0, "Initial IHOP value must be between 0 and 100 but is %.3f", initial_ihop_percent);

    39 }

    40 

    41 void G1IHOPControl::update_target_occupancy(size_t new_target_occupancy) {

    42   log_debug(gc, ihop)("Target occupancy update: old: " SIZE_FORMAT "B, new: " SIZE_FORMAT "B",

    43                       _target_occupancy, new_target_occupancy);

    44   _target_occupancy = new_target_occupancy;

    45 }

    46 

    47 void G1IHOPControl::update_allocation_info(double allocation_time_s, size_t allocated_bytes, size_t additional_buffer_size) {

    48   assert(allocation_time_s >= 0.0, "Allocation time must be positive but is %.3f", allocation_time_s);

    49 

    50   _last_allocation_time_s = allocation_time_s;

    51   _last_allocated_bytes = allocated_bytes;

    52 }

    53 

    54 void G1IHOPControl::print() {

    55   assert(_target_occupancy > 0, "Target occupancy still not updated yet.");

    56   size_t cur_conc_mark_start_threshold = get_conc_mark_start_threshold();

    57   log_debug(gc, ihop)("Basic information (value update), threshold: " SIZE_FORMAT "B (%1.2f), target occupancy: " SIZE_FORMAT "B, current occupancy: " SIZE_FORMAT "B, "

    58                       "recent allocation size: " SIZE_FORMAT "B, recent allocation duration: %1.2fms, recent old gen allocation rate: %1.2fB/s, recent marking phase length: %1.2fms",

    59                       cur_conc_mark_start_threshold,

    60                       cur_conc_mark_start_threshold * 100.0 / _target_occupancy,

    61                       _target_occupancy,

    62                       G1CollectedHeap::heap()->used(),

    63                       _last_allocated_bytes,

    64                       _last_allocation_time_s * 1000.0,

    65                       _last_allocation_time_s > 0.0 ? _last_allocated_bytes / _last_allocation_time_s : 0.0,

    66                       last_marking_length_s() * 1000.0);

    67 }

    68 

    69 void G1IHOPControl::send_trace_event(G1NewTracer* tracer) {

    70   assert(_target_occupancy > 0, "Target occupancy still not updated yet.");

    71   tracer->report_basic_ihop_statistics(get_conc_mark_start_threshold(),

    72                                        _target_occupancy,

    73                                        G1CollectedHeap::heap()->used(),

    74                                        _last_allocated_bytes,

    75                                        _last_allocation_time_s,

    76                                        last_marking_length_s());

    77 }

    78 

    79 G1StaticIHOPControl::G1StaticIHOPControl(double ihop_percent) :

    80   G1IHOPControl(ihop_percent),

    81   _last_marking_length_s(0.0) {

    82 }

    83 

    84 G1AdaptiveIHOPControl::G1AdaptiveIHOPControl(double ihop_percent,

    85                                              G1Predictions const* predictor,

    86                                              size_t heap_reserve_percent,

    87                                              size_t heap_waste_percent) :

    88   G1IHOPControl(ihop_percent),

    89   _predictor(predictor),

    90   _marking_times_s(10, 0.95),

    91   _allocation_rate_s(10, 0.95),

    92   _last_unrestrained_young_size(0),

    93   _heap_reserve_percent(heap_reserve_percent),

    94   _heap_waste_percent(heap_waste_percent)

    95 {

    96 }

    97 

    98 size_t G1AdaptiveIHOPControl::actual_target_threshold() const {

    99   guarantee(_target_occupancy > 0, "Target occupancy still not updated yet.");

   100   // The actual target threshold takes the heap reserve and the expected waste in

   101   // free space  into account.

   102   // _heap_reserve is that part of the total heap capacity that is reserved for

   103   // eventual promotion failure.

   104   // _heap_waste is the amount of space will never be reclaimed in any

   105   // heap, so can not be used for allocation during marking and must always be

   106   // considered.

   107 

   108   double safe_total_heap_percentage = MIN2((double)(_heap_reserve_percent + _heap_waste_percent), 100.0);

   109 

   110   return (size_t)MIN2(

   111     G1CollectedHeap::heap()->max_capacity() * (100.0 - safe_total_heap_percentage) / 100.0,

   112     _target_occupancy * (100.0 - _heap_waste_percent) / 100.0

   113     );

   114 }

   115 

   116 bool G1AdaptiveIHOPControl::have_enough_data_for_prediction() const {

   117   return ((size_t)_marking_times_s.num() >= G1AdaptiveIHOPNumInitialSamples) &&

   118          ((size_t)_allocation_rate_s.num() >= G1AdaptiveIHOPNumInitialSamples);

   119 }

   120 

   121 size_t G1AdaptiveIHOPControl::get_conc_mark_start_threshold() {

   122   if (have_enough_data_for_prediction()) {

   123     double pred_marking_time = _predictor->get_new_prediction(&_marking_times_s);

   124     double pred_promotion_rate = _predictor->get_new_prediction(&_allocation_rate_s);

   125     size_t pred_promotion_size = (size_t)(pred_marking_time * pred_promotion_rate);

   126 

   127     size_t predicted_needed_bytes_during_marking =

   128       pred_promotion_size +

   129       // In reality we would need the maximum size of the young gen during

   130       // marking. This is a conservative estimate.

   131       _last_unrestrained_young_size;

   132 

   133     size_t internal_threshold = actual_target_threshold();

   134     size_t predicted_initiating_threshold = predicted_needed_bytes_during_marking < internal_threshold ?

   135                                             internal_threshold - predicted_needed_bytes_during_marking :

   136                                             0;

   137     return predicted_initiating_threshold;

   138   } else {

   139     // Use the initial value.

   140     return (size_t)(_initial_ihop_percent * _target_occupancy / 100.0);

   141   }

   142 }

   143 

   144 void G1AdaptiveIHOPControl::update_allocation_info(double allocation_time_s,

   145                                                    size_t allocated_bytes,

   146                                                    size_t additional_buffer_size) {

   147   G1IHOPControl::update_allocation_info(allocation_time_s, allocated_bytes, additional_buffer_size);

   148 

   149   double allocation_rate = (double) allocated_bytes / allocation_time_s;

   150   _allocation_rate_s.add(allocation_rate);

   151 

   152   _last_unrestrained_young_size = additional_buffer_size;

   153 }

   154 

   155 void G1AdaptiveIHOPControl::update_marking_length(double marking_length_s) {

   156    assert(marking_length_s >= 0.0, "Marking length must be larger than zero but is %.3f", marking_length_s);

   157   _marking_times_s.add(marking_length_s);

   158 }

   159 

   160 void G1AdaptiveIHOPControl::print() {

   161   G1IHOPControl::print();

   162   size_t actual_target = actual_target_threshold();

   163   log_debug(gc, ihop)("Adaptive IHOP information (value update), threshold: " SIZE_FORMAT "B (%1.2f), internal target occupancy: " SIZE_FORMAT "B, "

   164                       "occupancy: " SIZE_FORMAT "B, additional buffer size: " SIZE_FORMAT "B, predicted old gen allocation rate: %1.2fB/s, "

   165                       "predicted marking phase length: %1.2fms, prediction active: %s",

   166                       get_conc_mark_start_threshold(),

   167                       percent_of(get_conc_mark_start_threshold(), actual_target),

   168                       actual_target,

   169                       G1CollectedHeap::heap()->used(),

   170                       _last_unrestrained_young_size,

   171                       _predictor->get_new_prediction(&_allocation_rate_s),

   172                       _predictor->get_new_prediction(&_marking_times_s) * 1000.0,

   173                       have_enough_data_for_prediction() ? "true" : "false");

   174 }

   175 

   176 void G1AdaptiveIHOPControl::send_trace_event(G1NewTracer* tracer) {

   177   G1IHOPControl::send_trace_event(tracer);

   178   tracer->report_adaptive_ihop_statistics(get_conc_mark_start_threshold(),

   179                                           actual_target_threshold(),

   180                                           G1CollectedHeap::heap()->used(),

   181                                           _last_unrestrained_young_size,

   182                                           _predictor->get_new_prediction(&_allocation_rate_s),

   183                                           _predictor->get_new_prediction(&_marking_times_s),

   184                                           have_enough_data_for_prediction());

   185 }