hotspot/src/share/vm/gc/g1/g1EvacStats.cpp
changeset 32379 aa14adafaf0f
child 32602 27d046027824
equal deleted inserted replaced
32378:8dd0e7359751 32379:aa14adafaf0f
       
     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 "precompiled.hpp"
       
    26 #include "gc/g1/g1EvacStats.hpp"
       
    27 #include "gc/shared/gcId.hpp"
       
    28 #include "trace/tracing.hpp"
       
    29 
       
    30 void G1EvacStats::adjust_desired_plab_sz() {
       
    31   if (PrintPLAB) {
       
    32     gclog_or_tty->print(" (allocated = " SIZE_FORMAT " wasted = " SIZE_FORMAT " "
       
    33                         "unused = " SIZE_FORMAT " used = " SIZE_FORMAT " "
       
    34                         "undo_waste = " SIZE_FORMAT " region_end_waste = " SIZE_FORMAT " "
       
    35                         "regions filled = %u direct_allocated = " SIZE_FORMAT " "
       
    36                         "failure_used = " SIZE_FORMAT " failure_waste = " SIZE_FORMAT ") ",
       
    37                         _allocated, _wasted, _unused, used(), _undo_wasted, _region_end_waste,
       
    38                         _regions_filled, _direct_allocated, _failure_used, _failure_waste);
       
    39   }
       
    40 
       
    41   if (ResizePLAB) {
       
    42 
       
    43     assert(is_object_aligned(max_size()) && min_size() <= max_size(),
       
    44            "PLAB clipping computation may be incorrect");
       
    45 
       
    46     if (_allocated == 0) {
       
    47       assert((_unused == 0),
       
    48              err_msg("Inconsistency in PLAB stats: "
       
    49                      "_allocated: "SIZE_FORMAT", "
       
    50                      "_wasted: "SIZE_FORMAT", "
       
    51                      "_region_end_waste: "SIZE_FORMAT", "
       
    52                      "_unused: "SIZE_FORMAT", "
       
    53                      "_used  : "SIZE_FORMAT,
       
    54                      _allocated, _wasted, _region_end_waste, _unused, used()));
       
    55       _allocated = 1;
       
    56     }
       
    57     // We account region end waste fully to PLAB allocation. This is not completely fair,
       
    58     // but is a conservative assumption because PLABs may be sized flexibly while we
       
    59     // cannot adjust direct allocations.
       
    60     // In some cases, wasted_frac may become > 1 but that just reflects the problem
       
    61     // with region_end_waste.
       
    62     double wasted_frac    = (double)(_unused + _wasted + _region_end_waste) / (double)_allocated;
       
    63     size_t target_refills = (size_t)((wasted_frac * TargetSurvivorRatio) / TargetPLABWastePct);
       
    64     if (target_refills == 0) {
       
    65       target_refills = 1;
       
    66     }
       
    67     size_t cur_plab_sz = used() / target_refills;
       
    68     // Take historical weighted average
       
    69     _filter.sample(cur_plab_sz);
       
    70     // Clip from above and below, and align to object boundary
       
    71     size_t plab_sz;
       
    72     plab_sz = MAX2(min_size(), (size_t)_filter.average());
       
    73     plab_sz = MIN2(max_size(), plab_sz);
       
    74     plab_sz = align_object_size(plab_sz);
       
    75     // Latch the result
       
    76     _desired_net_plab_sz = plab_sz;
       
    77     if (PrintPLAB) {
       
    78       gclog_or_tty->print_cr(" (plab_sz = " SIZE_FORMAT " desired_plab_sz = " SIZE_FORMAT ") ", cur_plab_sz, plab_sz);
       
    79     }
       
    80   }
       
    81   // Clear accumulators for next round.
       
    82   reset();
       
    83 }
       
    84