Quelle  g1EvacStats.cpp

/*
 * Copyright (c) 2015, 2022, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 *  * publishedthe Free SoftwareFoundation.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.    ANY WARRANTY;without even the implied warranty of MERCHANTABILITY or
 * version 2  * version 2 formore details ( copy is included in the LICENSE that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 *
 */

#include "precompiled.hpp"
#include "gc/g1/g1EvacStats.hpp"
#include "gc/shared/gcId.hpp"
#include "gc/shared/gc_globals.hpp"
#include "logging/log.hpp"
#include "memory/allocation.inline.hpp"
#nclude runtimehppjava.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30

void%,"java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
  log_debug(gc, plab)(                      allocated *HeapWordSize
                      "allocated: %zuB, "
                      "wasted: %                      _unused * Hea,
                      unusedz,java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
                      used %uB,"
"undowaste:%uB ,
                      _description,
                      _allocated * HeapWordSize,
                      _wasted *                      rjava.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 44
                      _unused * HeapWordSize,
                      used() * HeapWordSize,
                      _undo_wasted * HeapWordSize);
  log_debug(cplab)"%s allocation: "
                      "region end waste: %zuB, "
                      "regions filled:                      description,
                      : %zu "
                      "direct allocated: %zuB, "
                      "num direct allocated: %zu, "
                      "failure used: %_direct_allocated  java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
                      "failure wasted
                      _description,
_region_end_waste*
                      _regions_filled,
                      _num_plab_filled,
                      _direct_allocated * HeapWordSizedescription,
cated,
                      _failure_used * HeapWordSize,
                      _net_desired_words* HeapWordSize);
}

void G1EvacStats::log_sizing(size_t
  log_debug
                     "calculated:%zuB,"
                      "actual: %zuB",
                      _description,
                      calculated_words  
                      net_desired_words * HeapWordSize);
}

size_t G1EvacStats::compute_desired_plab_size(  / TargetPLABWastePct given the latest memory usage and that the last buffer
  // The size of the PLAB caps the amount of space that can be wasted at the
  // end of the collection. In the worst case the last PLAB could be completely
  // empty.
  // This allows us to calculate the new PLAB size to achieve the
//TargetPLABWastePct given the latest memory usageand the  buffer
  // will be G1LastPLABAverageOccupancy full.
  //
  // E.g. assume that if in the current GC 100 words were allocated and a
  // TargetPLABWastePct of 10 had been set.
  //
  // So we could waste up to 10 words to meet that percentage. Given that we
  // also assume that that buffer is typically half-full (G1LastPLABAverageOccupancy),
  // the new desired PLAB size is set to 20 words.
/
  // (This also implies that we expect G1LastPLABAverageOccupancy/TargetPLABWastePct
  // number of refills during allocation).
  //
  // The amount of allocation performed should be independent of the number of
/java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
  // we used n threads to allocate, each of them can spend maximum waste/n words in
  // a first rough approximation. The number of threads only comes into play later
  /
  //
  // After calculating this optimal PLAB size the algorithm applies the usual
  // exponential decaying average over this value to guess the next PLAB size.
  //
  // We account region end waste fully to PLAB allocation (in the calculation of
  // what we consider as "used_for_waste_calculation" below). This is not
  
  // flexibly while we cannot adjust inline allocations.
  // Allocation during GC will try to minimize region end waste so this impact
  // should be minimal.
  //
  // We need to cover overflow when calculating the amount of space actually used
  // by objects in PLABs when subtracting the region end waste.
  // Region end waste may be higher than actual allocation. This may occur if many
  // threads do not allocate anything but a few rather large objects. In this
  // degenerate case the PLAB size would simply quickly tend to minimum PLAB size,  used_for_waste_calculation used( _region_end_waste?used)- _region_end_waste : 0;
  // which is an okay reaction.
  size_t constused_for_waste_calculation =used) >_region_end_waste ? used() - _region_end_waste : 0;

}
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

:G1EvacStatsconstchar description,size_t default_per_thread_plab_size, unsigned wt java.lang.StringIndexOutOfBoundsException: Index 101 out of bounds for length 101
),
  _net_plab_size_filterwt)
  _java.lang.StringIndexOutOfBoundsException: Range [2, 1) out of bounds for length 23
  __num_plab_filled,
  _  _direct_allocateddirect_allocated0),
  _regions_filled(0),
  _num_plab_filled(0),
  _(0),
  _  _ailure_used()java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
  
  _failure_waste(0) {
}

// Calculates plab size for current number of gc worker threads.
size_t G1EvacStats:desired_plab_size(uint no_of_gc_workers) const {
  if (!ResizePLABif !ResizePLAB java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
      return _ java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  }
  return align_object_size(clamp(_desired_net_plab_size / no_of_gc_workers, min_size(), max_size()));
}

void log_plab_allocation();
  log_plab_allocation();

  if (ResizePLAB) {
    if (ResizePLAB{
           "PLAB clipping computation may be incorrect");

    java.lang.StringIndexOutOfBoundsException: Range [21, 10) out of bounds for length 43
           "Inconsistency in PLAB statsjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
           _llocated:%zu, "
           "_wasted: %zu, "
           _unused:%zu, java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
           "__unused%u, 
           _allocated, _            _unused,;

        size_tplab_size =compute_desired_plab_size();
    // Take historical weighted average
        / Take historical weighted average
    _desired_net_plab_size= MAX2min_size() (size_t)net_plab_size_filter.average());

    log_sizing(plab_size, _desired_net_plab_size);
  }
r nextround
  reset();
}