Quelle  psScavenge.cpp   Sprache: C

/*
 
 *gc )"Desired survivor   SIZE_FORMATiinarejava.lang.StringIndexOutOfBoundsException: Range [66, 63) out of bounds for length 66
 *
 software can  and/modify
 * under the terms of the GNU Generalcur_eden,
*                                             
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 java.lang.StringIndexOutOfBoundsException: Range [47, 1) out of bounds for length 56
 * ANY                         heap>);
 *java.lang.StringIndexOutOfBoundsException: Range [8, 1) out of bounds for length 9
luded inthe LICENSEfile 
ompanied java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 26
 *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 * You should have received a size_policy-   * version 2 for mo(  in file 
 * 2                                               
 * Inc., 51 >ecay_supplemental_growth* not full gc*/);
 *
 *Please*wwwjava.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 73
 * or visit www.oracle.com if youendif
 * questions.
 *
 */

#includejava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 0
."
#include "classfile/#include c."
njava.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 29
#include #"c/java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 7
nclude/ppjava.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
gparallel/.java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 47
.hppjava.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
#include gc//psCompactionManager#nclude gc/parallel/.hpp"
#include "gc/parallel/psParallelCompact.inline#nclude"gc//..hpp"
#include "gc/#include "gc/sharedgcHeapSummary.hpp"
#shared.java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 29
#include "gc/parallel/psScavenge.inline.hpp"
ared/gcCausehpp"
ig      heap>java.lang.StringIndexOutOfBoundsException: Range [27, 25) out of bounds for length 61
"heap->card_tableheap->gc_policy_counters()
#include "gc/shared/gcLockerijava.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 0
#include "gc/if (log_is_enabled.inlinehpp"
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Range [6, 4) out of bounds for length 33
#include "gc/shared/isGCActiveMark.hpp    java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
pStorage..hpp
#include "gc/shared/#include "gc/shared/spaceDecoratorjava.lang.StringIndexOutOfBoundsException: Range [0, 41) out of bounds for length 0
#    :(;
#ndif
 >includeweakProcessor
#include "gc/    // Re-verify object start arrays"c/."
nclude"c//.java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
#include "gc/   ( &&heap-java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
 "gc/shared/taskTerminator.hppy(;
i "java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 5
#include "java.lang.StringIndexOutOfBoundsException: Range [0, 12) out of bounds for length 3
#include "gc/sharedinclude "/heap>)
java.lang.StringIndexOutOfBoundsException: Range [32, 8) out of bounds for length 36
#/iterator."
#include " java.lang.StringIndexOutOfBoundsException: Range [36, 12) out of bounds for length 36
##"java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 30
java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 76
#include "oops/java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 5
#include "oops/java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 0
#include "oops/oop.inline*      accumulated_time()->stop()
PSCardTable                  ::restore_preserved_marks
    -> 
#include "runtime/threads.hpp"
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
#include"runtime/mOperations.hpp"
#include java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
#include "utilities/stack.inline.hpp"

SpanSubjectToDiscoveryClosure PSScavenge::_span_based_discoverer;
PSGCAdaptivePolicyCounters java.lang.StringIndexOutOfBoundsException: Range [40, 38) out of bounds for length 68
PSCardTable*                  java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Range [40, 4) out of bounds for length 69
uint                          PSScavenge::_CollectorCounters*            PSScavenge::_counters 
HeapWord*                     java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                 PSScavenge  PSPromoteRootsClosure  roots_to_old_closure(pm) {
elapsedTimer:java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 7
STWGCTimer        java.lang.StringIndexOutOfBoundsException: Range [30, 28) out of bounds for length 51
    ::java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
java.lang.StringIndexOutOfBoundsException: Range [42, 17) out of bounds for length 59

static java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
assertjava.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 17

  *pm= java.lang.StringIndexOutOfBoundsException: Range [46, 45) out of bounds for length 86
 roots_closure:(cjava.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
epmjava.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50

    Ae:(){
          (Bad/  :(;
      {
  size_t =( -java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 0
       ClassLoaderDataGraph:cld_do&cld_closure  size_t  a_moted ->(;
      java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
      breaklog_traceergo(  

    case ParallelRootType::code_cache?Do:     :;
      {
     java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 1
        :java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 0
      }
      breakjava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12

    case ParallelRootType::    :java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 0
:)  ( m(,
      fatal("Bad if "acks  java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 52
      break;
  

    // Do the real work
      java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

static void      {
       U ;

  java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 1
    // Adaptive size policy support.
      
  (m>tacks_empty
            "stacks should be java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 3

  while    _java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 7
    java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 3
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
      java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 2
pm>task;
      pm->drain_stacks_depth(parse
    } else {
      if (terminator.java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 0

      }
    }
  
  guarantee(size_t promotion_estimate"MaxTenuringThr 0  :+1,isjava.lang.StringIndexOutOfBoundsException: Index 101 out of bounds for length 62
}

// Define before use
class PSIsAliveClosure:    java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
:
  bool do_object_bPSKeepAliveClosurePSPromotionManager*pm  (pm java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
return(java.lang.StringIndexOutOfBoundsException: Range [26, 23) out of bounds for length 66
  }
};

                old_gen>();

class PSKeepAliveClosure: publicif(oung_gen-u    _to_space = heap->young_gen      MaxTenuringThreshold
protected:
  MutableSpacejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 0

public:
  PSKeepAliveClosure( 
    ParallelScavengeHeap
_  PSOldGen -(

    assert
   (:  // Set boundary between young_gen an

java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 6
#    if          java.lang.StringIndexOutOfBoundsException: Range [0, 19) out of bounds for length 0
    // Referent must be non-null and in from-space
    oop  
virtual do_oopjava.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 75
    ::(bjreturnresult;
    assert(!PSScavenge
e

    _promotion_manager-> ReferenceProcessor(&_span_based_discoverer
  class :void PSScavenge::set_young_generation_boHeapWord ){
  virtual void do_oop private:
virtual do_oop )                           ,          java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
};

class PSEvacuateFollowersClosure public&java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
 :
  * p/rgumentsmusthavebeen 
  TaskTerminator
  _java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 publicassert_ !,S"
  java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 96
    : _promotion_manager(pm), _terminator(terminator),     (_romotion_managershouldjava.lang.StringIndexOutOfBoundsException: Range [43, 42) out of bounds for length 111

  virtual void do_void() {
    (_ != ,"anity)_=;
    _promotion_manager->drain_stacks(true
    _-(,
              "stacks should be      steal_work(*, w)java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43

    if(terminator ! nullptr {
      steal_work(*_                                                   
    }
  }
}java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

class  RefProcProxyTask  java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
 _;

public:
  ParallelScavengeRefProcProxyTask(uint java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
:RefProcProxyTask"", ),
_    PSPromotionMa   _=:java.lang.StringIndexOutOfBoundsException: Range [79, 78) out of bounds for length 193

  void work(uint worker_id is_alive
    m, s);
    PSPromotionManager* BarrierEnqueueDiscoveredFieldClosure enqueue;
    PSIsAliveClosure // Initialize ref handling
    PSKeepAliveClosure _span_based_discoverer.set_span->eserved()java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
     enqueue;
    PSEvacuateFollowersClosure complete_gc(                           ParallelGCThreads, 
    _java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  }

  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
    _terminator.reset_for_reuse(_queue_count);                          &is_alive_closure;// header provides liveness info
  }
};// we've exceeded policy time limits, or any other special behavior.

// This method contains all heap specific policy for invoking scavenge.
// PSScavenge::invoke_no_policy() will do nothing but attempt to
// scavenge. It will not clean up after failed promotions, bail out if
// we've exceeded policy time limits, or any other special behavior.
// All such policy should be placed here.
//
// Note that this method should only be called from the vm_thread while
// at a safepoint!
bool assert(!ParallelScavengeH::eap)>s_gc_active(,"ot ");
  assert(SafepointSynchronize::is_at_safepoint(), "should be at safepoint"java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  assert(Thread::current()  PSAdaptiveSizePolicy policy =heap->size_policy;
  assert(!ParallelScavengeHeap::heap()IsGCActiveMark ;

ParallelScavengeHeap constheap=ParallelScavengeHeapheap(;
  PSAdaptiveSizePolicy* policy = heap->size_policyconst bool need_full_gc=!scavenge_done|
  IsGCActiveMark mark;

  const  =;
  const   U){
    policy->should_full_GC(heap->old_gen()->    PSGCAdaptivePolicyCounters  counters = heap->gc_policy_counters();
  bool full_gc_done = false;

  if (UsePerfData) {
    PSGCAdaptivePolicyCounters*     counters->pdate_full_follows_scavenge(ffs_val);
    const int ffs_val = need_full_gc ? full_follows_scavenge : not_skipped;
    counters-u(ffs_val;
  }

  if (need_full_gc) {
        SoftRefPolicy   -(;
    SoftRefPolicy* srp = heap->     bool ;
    const bool full_gc_done = PSParallelCompactjava.lang.StringIndexOutOfBoundsException: Range [55, 54) out of bounds for length 75

       _java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 18
}

  return full_gc_done;    assert:heap)>) c outside)java.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
}

  java.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 55
  uint _worker_id;
public:
  PSThreadRootsTaskClosure(uint     MarkingCodeBlobClosure roots_in_blobsroots_closure CodeBlobToOopClosure::FixRelocations, true /* keepalive nmethods */);
  java.lang.StringIndexOutOfBoundsException: Range [0, 9) out of bounds for length 0
    assert(::eap(-is_gc_active) called outsidegc";

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    PSScavengeRootsClosure     pm->drain_stacks(alse)java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
    class ScavengeRootsTask : public WorkerTask {

    thread->oops_do(& StrongRootsScope strong_roots_scope//  for :p

    // Do the real work
    pm _ubtasks;
  }
};

HeapWord _java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
   _ // needed for Threads::possibly_parallel_threads_do
    TaskTerminator _terminator
  public:
   ojava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
  HeapWord*       WorkerTask")
uint _active_workers
  bool;
      _ld_gen(ld_gen),

public:
  ScavengeRootsTask(PSOldGen* old_gen,
                    uint active_workers) :
     WorkerTask("ScavengeRootsTask"),
      _strong_roots_scope(active_workers),
_(:s)java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
      _old_gen(old_gen),
      _gen_top(old_gen    _! ,Sanity)
      
      _  virtual void work java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 37
      _terminator(    rm;
    assert(_old_gen != NULL, "Sanity");
  }

  virtual void work(uint worker_id) {
    (worker_id < _active_workers, "Sanity");
    ResourceMark rm;

     !_) {
      // There are only old-to-young pointers if there are objects
      // in the old gen.
      {
        PSPromotionManager* pm = PSCardTable* card_table = ParallelScavengeHeap:eap)c(;
engeHeap::eap)>java.lang.StringIndexOutOfBoundsException: Range [75, 74) out of bounds for length 77

        card_table->scavenge_contents_parallel(_old_gen->start_array_gen_top,
                                               _old_gen->object_space(),
                                               ,
                                               pm,
                                               worker_id-(false)
                                               )java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64

        // Do the real work
        pm->drain_stacks(false);
      }
    }

    for (uint java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 5
ker_id);
    }

    PSThreadRootsTaskClosure closure(worker_id);
reads:possibly_parallel_threads_do(true /*parallel */, &closure); *, &closure);

    // Scavenge OopStorages// Do the real work
    {
}
      PSScavengeRootsClosure closure(pm);
      _
      // Do the real work
      pm-    /:()does  fully its
    }

    // If active_workers can exceed 1, add a steal_work().
        if (_active_workers > 1) {
    steal_work_, );
    // ParallelGCThreads is > 1.

    if (_active_workers > 1) {
  (_,)java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
    }
  }
;

// This method contains no policy. You should probably
// be calling invoke() instead.
bool PSScavenge::invoke_no_policy() {
  assert   (GCLocker:check_active_before_gc(){
  assert(Thread::current() == (Thread*)VMThread::vm_thread(), "should be    return false;

  _gc_timer.register_gc_start(); }

  ParallelScavengeHeap* heap=::heap(;
    return;
  }

  ParallelScavengeHeap* heap =   if () java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
 :: =heap-)

  .
  if (!should_attempt_scavenge()) {
    returnjava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
  }

  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  _   :(gc_cause){

  bool promotion_failure_occurred =     young_gen->eden_space()->accumulate_st

  PSYoungGen* young_gen = heap->young_gen();
old_gen(;
  PSAdaptiveSizePolicy( | tenuring_threshold == markWord::max_age + 1, "Sanity";

  heap->java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 0

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 feedbackdata   .
    young_gen->eden_space()->accumulate_statistics();
  }

  heap->print_heap_before_gc();
  heap->(&)java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42

  assert(!NeverTenure || _tenuring_threshold ==    ;
  assert(!AlwaysTenurejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  // Fill in TLABs
  heap->ensure_parsability(true);  // retire TLABs

  if(VerifyBeforeGC & heap-total_collections( = VerifyGCStartAt) {
    Universe::verify("Before GC" tcs(counters()
  }

  {
    if (log_is_enabl, ,heap )){

    GCTraceCPUTime tcpu(&_gc_tracer)      (>(;
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    TraceCollectorStats tcs(counters());
     tms(->), )java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68

    if ( &
()-start)java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
        }

    // Let the size policy know we're starting
    size_policy->minor_collection_begin-(-(java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60

    // Verify the object start arrays. objects in to_space);
    if (VerifyObjectStartArray &&
        VerifyBeforeGC) {
      old_gen->    young_gen->to_space()->clearSpaceDecorator::angle;
    }

    // Verify no unmarked old->young rootsDerivedPointerTable::clear();
    if (VerifyRememberedSets) #
      -card_table)-verify_all_young_refs_imprecise;
    }

    (->o_space(>(,
           "Attempt 
    young_genf;

#if COMPILER2_OR_JVMCI
    ::(;
#endif

    reference_processor()->start_discovery(false                                         ParallelScavengeHeap::heap()->workers().active_workers(),

    const  :heap)>)(java.lang.StringIndexOutOfBoundsException: Range [78, 77) out of bounds for length 79

    // Reset our survivor overflow.
    set_survivor_overflow(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
      WorkerPolicy:{
 ParallelScavengeHeap:)>).)
                           :java.lang.StringIndexOutOfBoundsException: Range [78, 77) out of bounds for length 81
    java.lang.StringIndexOutOfBoundsException: Range [6, 1) out of bounds for length 77

     _(

assert(java.lang.StringIndexOutOfBoundsException: Range [30, 28) out of bounds for length 85
    
    {
) tm",&gjava.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64

      ScavengeRootsTask task(old_gen, active_workers);
      :heap(-workers((&task;
    }

        if (promotion_failure_occurred) { (romotion_failure_occurred) {
    {
      GCTraceTime(Debug,gc phases)tm" , &_c_timer

      reference_processor()->set_active_mt_degree(active_workers);
       stats;
      pt(_,(>max_num_queues());

      ParallelScavengeRefProcProxyTask task(reference_processor()->max_num_queues());
      stats = reference_processor()->java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 23

      _c_tracer()java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
      pt.print_all_references();
    }

    assert(promotion_manager->stacks_empty(),"stacks should be empty at this point"

   
      GCTraceTime(Debug, gc,           counters->update_promotedpromoted);
      PSAdjustWeakRootsClosure java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 0
      WeakProcessor:        java.lang.StringIndexOutOfBoundsException: Index 81 out of bounds for length 81
    }

    // Verify that usage of root_closure didn't copy any objects.
   >tacks_empty("tacks be    )java.lang.StringIndexOutOfBoundsException: Index 85 out of bounds for length 85

    // Finally, flush the promotion_manager's labs, and deallocate its stacks.
    promotion_failure_occurred = PSPromotionManager::post_scavenge(_gc_tracer);
    ( java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
(;
      log_info(gc, promotion)("Promotion failed");
    }

    _          java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 52

    // Let the size policy know we're done.  Note that we count promotion        // Don't check if the size_policy is ready at this
//failure   as of (therwise 'e
    // implicitly saying it's mutator time).
    -(gc_cause)java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48

    if (!promotion_failure_occurred
      // Swap the survivor spaces.size_t eden_live-(u(;
      young_gen-> max_eden_size java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
      young_gen->java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
      

      size_t survived = young_gen->from_space()->used_in_bytes();
      size_t promoted = old_gen->used_in_bytes() - pre_gc_values.old_gen_used();
      size_policy->update_averages(                                              ,

      // A successful scavenge should restart the GC time limit count which is
      // for full GC's.
     >java.lang.StringIndexOutOfBoundsException: Range [51, 48) out of bounds for length 51
if( java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
                // relative location of the "to" and "from" spaces.

        log_debug(        // that don't
        log_trace(gc, ergo)("old_gen_capacity: "
                            ->capacity_in_bytes);

        if (UsePerfData) {
     =heap->()java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
          counters->update_old_eden_size(
            size_policy->calculated_eden_size_in_bytes());
          counters->update_old_promo_size(
            size_policy      assert(young_gen->eden_space(->() "eden   be empty java.lang.StringIndexOutOfBoundsException: Index 84 out of bounds for length 84
          java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
          -(-);
          counters->update_survived(survived);
          counters-    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
          counters->update_survivor_overflowed(_java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 33
        }

        size_t max_young_size = young_gen->max_gen_size();

        // Deciding a free ratio in the young generation is tricky, so if (VerifyAfterGC & heap-) = ) java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
        // MinHeapFreeRatio or MaxHeapFreeRatio are in use (implicating!romotion_failure_occurred;
       // that the old generation size may have been limited because of them) we
        // should then limit our young generation size using NewRatio to have it
        // follow the old generation size.
        if (NOT_PRODUCT(ParallelScavengeHeap)>(;java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
          * counters =-g)java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
young_gen-m())java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
        }

        size_t survivor_limit =
          size_policy-    if UsePerfData){

          -(
                                                           _java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 3
                                                           
                                                            size_t avg_promoted  (size_t policy-padded_average_promoted_in_bytes(

       log_debug(gc, age)("Desired survivor size " SIZE_FORMAT "                 size_t)policy-java.lang.StringIndexOutOfBoundsException: Range [68, 65) out of bounds for length 68
                          -calculated_survivor_size_in_bytes(,
                          _java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 3

        if (UsePerfData) {
          *   heapg(;
          counters->pdate_tenuring_thresholdtenuring_threshold;
         counters->update_survivor_size_counters)
        }

        // Do call at minor collections?
        // Don't check if the size_policy is ready at this
        // level.  Let the size_policy check that internally.
        if (java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 3
            AdaptiveSizePolicy    =-);
          // Calculate optimal free space amounts
          assert(set_young_generation_boundary(young_gen->eden_space()->bottom());
                 ->java.lang.StringIndexOutOfBoundsException: Range [40, 38) out of bounds for length 63
                 young_gen->to_space()->capacity_in_bytes(),
                 "Sizes of space in young gen

          size_t young_live = young_gen->used_in_bytes();
          size_t eden_live = young_gen->eden_space()->used_in_bytes();
          size_t cur_eden = young_gen->eden_space()->capacity_in_bytes();
          size_t max_old_gen_size = old_gen->max_gen_size();
          size_t max_eden_size = max_young_size -
            young_gen->from_space()->capacity_in_bytes() -
            young_gen->to_space()->capacity_in_bytes();

          // Used for diagnostics
          size_policy->clear_generation_free_space_flags();

          size_policy->compute_eden_space_size(young_live,
                                               eden_live,
                                               cur_eden,
                                               max_eden_size,
                                               false /* not full gc*/);

          size_policy->check_gc_overhead_limit(eden_live,
                                               max_old_gen_size,
                                               max_eden_size,
                                               false /* not full gc*/,
                                               gc_cause,
                                               heap->soft_ref_policy());

          size_policy->decay_supplemental_growth(false /* not full gc*/);
        }
        // Resize the young generation at every collection
        // even if new sizes have not been calculated.  This is
        // to allow resizes that may have been inhibited by the
        // relative location of the "to" and "from" spaces.

        // Resizing the old gen at young collections can cause increases
        // that don't feed back to the generation sizing policy until
        // a full collection.  Don't resize the old gen here.

        heap->resize_young_gen(size_policy->calculated_eden_size_in_bytes(),
                        size_policy->calculated_survivor_size_in_bytes());

        log_debug(gc, ergo)("AdaptiveSizeStop: collection: %d ", heap->total_collections());
      }

      // Update the structure of the eden. With NUMA-eden CPU hotplugging or offlining can
      // cause the change of the heap layout. Make sure eden is reshaped if that's the case.
      // Also update() will case adaptive NUMA chunk resizing.
      assert(young_gen->eden_space()->is_empty(), "eden space should be empty now");
      young_gen->eden_space()->update();

      heap->gc_policy_counters()->update_counters();

      heap->resize_all_tlabs();

      assert(young_gen->to_space()->is_empty(), "to space should be empty now");
    }

#if COMPILER2_OR_JVMCI
    DerivedPointerTable::update_pointers();
#endif

    // Re-verify object start arrays
    if (VerifyObjectStartArray &&
        VerifyAfterGC) {
      old_gen->verify_object_start_array();
    }

    // Verify all old -> young cards are now precise
    if (VerifyRememberedSets) {
      // Precise verification will give false positives. Until this is fixed,
      // use imprecise verification.
      // heap->card_table()->verify_all_young_refs_precise();
      heap->card_table()->verify_all_young_refs_imprecise();
    }

    if (log_is_enabled(Debug, gc, heap, exit)) {
      accumulated_time()->stop();
    }

    heap->print_heap_change(pre_gc_values);

    // Track memory usage and detect low memory
    MemoryService::track_memory_usage();
    heap->update_counters();
  }

  if (VerifyAfterGC && heap->total_collections() >= VerifyGCStartAt) {
    Universe::verify("After GC");
  }

  heap->print_heap_after_gc();
  heap->trace_heap_after_gc(&_gc_tracer);

  AdaptiveSizePolicyOutput::print(size_policy, heap->total_collections());

  _gc_timer.register_gc_end();

  _gc_tracer.report_gc_end(_gc_timer.gc_end(), _gc_timer.time_partitions());

  return !promotion_failure_occurred;
}

void PSScavenge::clean_up_failed_promotion() {
  PSPromotionManager::restore_preserved_marks();

  // Reset the PromotionFailureALot counters.
  NOT_PRODUCT(ParallelScavengeHeap::heap()->reset_promotion_should_fail();)
}

bool PSScavenge::should_attempt_scavenge() {
  ParallelScavengeHeap* heap = ParallelScavengeHeap::heap();
  PSGCAdaptivePolicyCounters* counters = heap->gc_policy_counters();

  if (UsePerfData) {
    counters->update_scavenge_skipped(not_skipped);
  }

  PSYoungGen* young_gen = heap->young_gen();
  PSOldGen* old_gen = heap->old_gen();

  // Do not attempt to promote unless to_space is empty
  if (!young_gen->to_space()->is_empty()) {
    if (UsePerfData) {
      counters->update_scavenge_skipped(to_space_not_empty);
    }
    return false;
  }

  // Test to see if the scavenge will likely fail.
  PSAdaptiveSizePolicy* policy = heap->size_policy();

  // A similar test is done in the policy's should_full_GC().  If this is
  // changed, decide if that test should also be changed.
  size_t avg_promoted = (size_t) policy->padded_average_promoted_in_bytes();
  size_t promotion_estimate = MIN2(avg_promoted, young_gen->used_in_bytes());
  bool result = promotion_estimate < old_gen->free_in_bytes();

  log_trace(ergo)("%s scavenge: average_promoted " SIZE_FORMAT " padded_average_promoted " SIZE_FORMAT " free in old gen " SIZE_FORMAT,
                result ? "Do" : "Skip", (size_t) policy->average_promoted_in_bytes(),
                (size_t) policy->padded_average_promoted_in_bytes(),
                old_gen->free_in_bytes());
  if (young_gen->used_in_bytes() < (size_t) policy->padded_average_promoted_in_bytes()) {
    log_trace(ergo)(" padded_promoted_average is greater than maximum promotion = " SIZE_FORMAT, young_gen->used_in_bytes());
  }

  if (!result) {
    if (UsePerfData) {
      counters->update_scavenge_skipped(promoted_too_large);
    }
  }
  return result;
}

// Adaptive size policy support.
void PSScavenge::set_young_generation_boundary(HeapWord* v) {
  _young_generation_boundary = v;
  if (UseCompressedOops) {
    _young_generation_boundary_compressed = (uintptr_t)CompressedOops::encode(cast_to_oop(v));
  }
}

void PSScavenge::initialize() {
  // Arguments must have been parsed

  if (AlwaysTenure || NeverTenure) {
    assert(MaxTenuringThreshold == 0 || MaxTenuringThreshold == markWord::max_age + 1,
           "MaxTenuringThreshold should be 0 or markWord::max_age + 1, but is %d", (int) MaxTenuringThreshold);
    _tenuring_threshold = MaxTenuringThreshold;
  } else {
    // We want to smooth out our startup times for the AdaptiveSizePolicy
    _tenuring_threshold = (UseAdaptiveSizePolicy) ? InitialTenuringThreshold :
                                                    MaxTenuringThreshold;
  }

  ParallelScavengeHeap* heap = ParallelScavengeHeap::heap();
  PSYoungGen* young_gen = heap->young_gen();
  PSOldGen* old_gen = heap->old_gen();

  // Set boundary between young_gen and old_gen
  assert(old_gen->reserved().end() <= young_gen->eden_space()->bottom(),
         "old above young");
  set_young_generation_boundary(young_gen->eden_space()->bottom());

  // Initialize ref handling object for scavenging.
  _span_based_discoverer.set_span(young_gen->reserved());
  _ref_processor =
    new ReferenceProcessor(&_span_based_discoverer,
                           ParallelGCThreads,          // mt processing degree
                           ParallelGCThreads,          // mt discovery degree
                           false,                      // concurrent_discovery
                           &_is_alive_closure);        // header provides liveness info

  // Cache the cardtable
  _card_table = heap->card_table();

  _counters = new CollectorCounters("Parallel young collection pauses", 0);
}