/*
check_gc_overhead_limit,
                 max_old_gen_size
 *
 * This code is     max_eden_sizejava.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
 * under the terms of the
  FreeSoftwareFoundation.
 *
 *-        
 *  * accthis code).
 * FITNESS           // Used for diagnostics
java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 74
 *         /  fullcollection          compute_eden_space_sizeyoung_live,
 *
*  should have received a copy       java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
 * 2 along with this work; if       // Also update() will case adaptive
 * Inc., 51 Franklin St, java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 * Please
or  oraclecom  you  additional information or have any
 * questions.
 *
 */

 java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 24
java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 3
#include "java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 0
##erDataGraph."
"ompiler/oopMap.pp"
#include "gc/parallel        #clude "code/codeCache.hpp"
include gcjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 7
#include "      // Upd  structure  of #nclude"gcparallel/parallelScavengeHeap.pp"
#include "c/psAdaptiveSizePolicy"
#include "gc/parallel/#include "gc/parallel/psClosure.inline"
#include      
java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 37
i gcparallelpsScavengeinline
#include "gc/shared/gcCause.hpp"
/java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
#gc//gcIdhpp
#include "gc/shared/gcLocker      // Precise verification will give false positives. Until this is fixed,
#young_gen.
#include#nclude "c/ ard_table(()>verify_all_young_refs_precise;
#include "c/java.lang.StringIndexOutOfBoundsException: Range [22, 10) out of bounds for length 60
#nclude
#include "gc/shared/oopStorage.      java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 5
StorageSetParState."
#include "gc/shared/java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 32
#/"
#include "gc/shared/java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 5
#include "gc/shared
# if#include "gc/shared/oo"
.java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 0
##java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 40
#/java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 0
#include /orkerPolicyhppjava.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
include #"//.pp"
#nclude "gc/shared/java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 0
# "emory/iterator        ){
##include"gc      old_gen->verify_object_start_arra
java.lang.NullPointerException
#include "    Verify all old  >young cards
#oopsheap>int_heap_after_gc;
 if(  heap->trace_heap_after_gc.hpp"
# / include "memoryiterator.ppjava.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
#include "runtime/handles.inline.hpp"
#nclude"runtime/threadCritical.hpp"
iruntimethreads."
#include "runtime/vmThread.hpp"
#include "runtime#_gc_tracerreport_gc_end(_gc_timergc_end() gc_timer..time_partitions();
#include "services/memoryService.hpp"
#include "utilities/tackinline.hpp

     (og_is_enabled(Debug, gc, heap, exit)) {
ReferenceProcessor           java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 0
*                  PSPromotionManager-  // Reset the

uint                          /java.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 35
heap->update_counters()java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
uintptr_t  * counters heap-gc_policy_counters)
elapsedTimer                  PSScavenge
  ifUsePerfData {
ParallelScavengeTracer        PSScavenge:   countersupdate_scavenge_skippedbool::_survivor_overflow=false;
}

staticvoid
  assert(ParallelScavengeHeap  *young_gen=heap>young_gen()

    java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 3
  java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 0
;

  switch(root_type) {
    case ParallelRootType::class_loader_data:
      {
        PSScavengeCLDClosure cld_closure(pm);
ClassLoaderDataGraph::java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 0
       ::java.lang.StringIndexOutOfBoundsException: Range [41, 22) out of bounds for length 53
            counte-update_scavenge_skipped::_counters =java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

    case ParallelRootType::code_cache:
        assert(    return false false
        MarkingCodeBlobClosurePSPromotionManager  = PSPromotionManager::java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 0
ScavengableNMethods:nmethods_do(&de_closure)
      }
      break;

  PSAdaptiveSizePolicyeroots_to_old_closurepm;
    DEBUG_ONLY(default:) // DEBUG_ONLY hack will create compile error on release builds (-Wswitch) and runtime check on debug builds
      fatal"// changed, decide ifjava.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 48
      break :(  NOT_PRODUCT(ParallelScavengeHeap::heap()->reset_parmoted-sjava.lang.StringIndexOutOfBoundsException: Range [75, 73) out of bounds for length 77
  

  // Do the real work
  result""   ParallelScavengeHeap  arallelScavengeHeap()java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
}

static void steal_work(TaskTerminator& terminator,         ScavengableNMethods:java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 0
   young_gen-used_in_bytes  }

  PSPromotionManager*     log_trace(ergo)(" padd
    PSPromotionManager:java.lang.StringIndexOutOfBoundsException: Range [0, 51) out of bounds for length 0
  pmjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  (mstacks_emptyjava.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
     "shouldbe empty at this point");

  while (true) {
    ScannerTask  }
    if/
      TASKQUEUE_STATS_ONLY(pm->record_steal(tasksjava.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 26
      pm-}
      pm->java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 16
}else{
      if (terminator.offer_termination()) {
        ;
      }
    }
  }
        counters->java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 0
 java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 31

// Define before use
  ifUseCompressedOopsjava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
public:
  bool   PSAdaptiveSizePopolicy =heap-size_policy();
    return (!PSScavenge::is_obj_in_young(p)) || p
  }
};

PSIsAliveClosurevoid       >rocess_popped_location_depth)java.lang.StringIndexOutOfBoundsException: Range [47, 46) out of bounds for length 46

   |  size_t avg_promoted =  avg_promoted =(ize_t policyjava.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 14
protected:
  MutableSpaceMshouldbe  ormarkWordmax_age  1,utis%" int)java.lang.StringIndexOutOfBoundsException: Index 107 out of bounds for length 62
  PSPromotionManager

public java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 10
  ( ):_promotion_manager){
    tenuring_thresholdresult "":" size_t)policy->verage_promoted_in_bytes)    !:p (java.lang.StringIndexOutOfBoundsException: Range [33, 31) out of bounds for length 68
(      java.lang.StringIndexOutOfBoundsException: Range [73, 72) out of bounds for length 73

    assert(_promotion_manager }
  }

  template <class T  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
#ifdef ASSERT
    // Referent must be non-null and in from-space
    oop    * old_genheap-(
    java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 0
    assertPSScavenge:is_obj_in_youngd old_gen
    assert(!PSScavenge::is_obj_in_to_space
java.lang.StringIndexOutOfBoundsException: Range [11, 6) out of bounds for length 6

    _promotion_manager->counters->update_scavenge_skipped(set_young_generation_boundary(young_gen->eden_space()->bot
}
voidoop  
java.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 69
;

 java.lang.StringIndexOutOfBoundsException: Range [40, 4) out of bounds for length 61
 private
  PSPromotionManager  young_generation_boundary =v  void(narrowOop pParallelGCThreads// mt discovery degree
  TaskTerminator* _terminator;
  uint _           ,                      // concurrent_discovery

 publicjava.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
PSEvacuateFollowersClosure private
    :  PSPromotionManager _  / musthave beenparsed

  virtual void   uint _java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    (promotion_manager ! nullptr,"anity);
    _promotion_manager->drain_stacksPSEvacuateFollowersClosure(    assert(MaxTenuringThreshold | MaxTenuringThreshold == markWord::max_age + 1,
guarantee_           "MaxTenuringThresholdbe :    is%" int
              assertpromotion_manager= nullptr S"   tenuring_threshold =MaxTenuringThreshold;

    if(terminator    guarantee_romotion_manager-stacks_empty(,
      *terminator _orker_id);
    }
  }
};

class ParallelScavengeRefProcProxyTask : public java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  TaskTerminator _terminator;

public:
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    :("PSOldGen* old_gen = heap->old_gen()
      _terminator(max_workers,   TaskTerminatorterminatorjava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29

  (uintworker_id)override{
    assert(     (ParallelScavengeRefProcProxyTaskmax_workers,
nagerpromotion_manager=(m=RefProcThreadModel:ingle?PSPromotionManager:vm_thread_promotion_manager(  PSPromotionManager::c_thread_promotion_manager
    PSIsAliveClosureis_alive;
    PSKeepAliveClosure    assertworker_id<_x_workers, "anity";
    java.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 49
    PSEvacuateFollowersClosureBarrierEnqueueDiscoveredFieldClosure;
    _rp_task->rp_work(worker_id, &is_alive, &    new ReferenceProcessor(&_span_based_discovererjava.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 156
  }

  void prepare_run_task_hook() override {
    _terminator
}
};

// 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 PSScavenge::invokejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
assert should placed.
// Note that this method 
  eap:h(->s_gc_active) "reentrantjava.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73

  ParallelScavengeHeap* const heap = ParallelScavengeHeap::heap();
*policy=-()java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
  mark

    *  =::)java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
  bool   |
    policy->should_full_GC(java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 22
  ull_gc_done =false

  if(sePerfData java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
*constjava.lang.StringIndexOutOfBoundsException: Range [47, 46) out of bounds for length 76
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
ujava.lang.StringIndexOutOfBoundsException: Range [50, 42) out of bounds for length 52
  }

  if    >pdate_full_follows_scavenge)
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    SoftRefPolicy*srp=heap->soft_ref_policy)java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
    constbool clear_all_softrefs = srp->should_clear_all_soft_refs();

    ::invoke_no_policy(clear_all_softrefs);
  }

  return full_gc_done;
}

class
  uint_orker_id;
public:
  PSThreadRootsTaskClosure(uint worker_id)  }
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    assert(ParallelScavengeHeap:heap(->s_gc_active(,"alled gc";

    PSPromotionManager* pm = PSPromotionManager
    PSScavengeRootsClosureclass PSThreadRootsTaskClosure :public ThreadClosure {
(&,java.lang.StringIndexOutOfBoundsException: Range [80, 78) out of bounds for length 127

    thread->oops_do(&roots_closureassertParallelScavengeHeaph)>(,"calledoutside )

    // Do the real work
f;
  }
};

java.lang.StringIndexOutOfBoundsException: Range [23, 5) out of bounds for length 45
 _; / neededforThreads:ossibly_parallel_threads_do
  java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 0
  SequentialSubTasksDone_ubtasksjava.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
  PSOldGen
  * _gen_top;
  uint _active_workers;
  bool _is_old_gen_empty;  StrongRootsScope strong_roots_scope; // needed for Threads::possibly_parallel_threads_do
;

public:
  ScavengeRootsTaskPSOldGen*_ld_gen;;
                    uint active_workers) :
      (ScavengeRootsTask",
      _strong_roots_scope  _;
      _ _is_old_gen_empty;
      _ld_geno,
      java.lang.StringIndexOutOfBoundsException: Range [7, 6) out of bounds for length 7
       java.lang.StringIndexOutOfBoundsException: Range [37, 35) out of bounds for length 38
      _is_old_gen_empty      subtasksParallelRootType:entinel,
      _terminator(java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 24
    assert(old_gen =NULL,"";


  (uintworker_id) {
    assert(worker_id < _active_workers, "Sanity");
   ResourceMarkjava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20

    if     )
      assertjava.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 50
      // in the old gen.if(_s_old_gen_empty java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
      {
        PSPromotionManager*       java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
        ::(->ard_table);

        card_table->        PSCardTable* card_table = ParallelScav:(->card_table();
                                               _old_gen->object_space(),
                                               java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
                                               pm,
                                               _gen_top
                                               _active_workers);

        // Do the real work
        pm-drain_stacks)
      }
    }

    for (uint root_type = 0; _subtasks_active_workers;
      scavenge_roots_work(static_cast<ParallelRootType::Value>(root_type), worker_id);
    }

    PSThreadRootsTaskClosure closure(java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 32
    Threads:    }

    // Scavenge OopStorages
    {
      PSPromotionManager* pm = PSPromotionManager::      scavenge_roots_work(static_cast<ParallelRootType::Value>(root_type), wor
      :/*parallel/ ;
      _oop_storage_strong_par_state
      // Do the real work
      pm->drain_stacks{
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

    // If active_workers can exceed 1, add a steal_work().
/ PSPromotionManager:drain_stacks_depth()does not drain its
    // stacks and expects a steal_work() to complete the draining if
    // ParallelGCThreads is > 1.

java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
  steal_work(_erminator, worker_id;
    }

};

// This method contains no policy. You should probably
// be calling invoke() instead.
    steal_work_terminator,worker_id;
  assert(SafepointSynchronize::is_at_safepoint(), "should be at safepoint");
  assert(Thread}

  _gc_timer.// This method contains no policy. You should java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 31

if(:( java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 17
 }

    = ParallelScavengeHeap)
      return false

  // Check for potential problems.
   (should_attempt_scavenge(){
    return false;
  }

  GCIdMark gc_id_mark;GCCauseCause gc_cause  heap-gc_cause(;
  _  // Check forpotential problems

  bool promotion_failure_occurred = false;

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

  heap->increment_total_collections();

  if(AdaptiveSizePolicy:should_update_eden_stats) {
    // Gather the feedback data for eden occupancy.
atistics();
  }

  heap->java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
  heap->  PSOldGen* old_gen = heap->();

  assert!NeverTenure| _""
  assert(!AlwaysTenure

  // Fill in TLABs
  heap->

  if (    // Gather the foredenoccupancyjava.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
    Universe  >trace_heap_before_gc_gc_tracer;
  }

  java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 0
   ResourceMarkrmjava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20

    GCTraceCPUTime tcpujava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    GCTraceTime(   VerifyBeforeGC&heap-)>  java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
    TraceCollectorStatstcs();
    TraceMemoryManagerStats tms(heap->young_gc_managerjava.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

    ed(Debug gc heap,exit java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
accumulated_time(-start);
    }

    // Let the size policy know we're starting
    TraceMemoryManagerStatsheapyoung_gc_manager( gc_cause;

    // Verify the object start arrays.
VerifyObjectStartArray&
      accumulated_time)>(;
      old_gen->verify_object_start_array();
    }

    // Verify no unmarked old->young roots
    if (VerifyRememberedSets) {
      heap-card_table)>verify_all_young_refs_imprecise);
    }

    assert(young_gen
ive in"java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
(M)

#if 
    java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 33
#ndif

    reference_processor()      heap>card_table(-verify_all_young_refs_imprecise();

    constassert(oung_gen>o_space(-is_empty(,

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

    const uint    DerivedPointerTable:clear(;
      java.lang.StringIndexOutOfBoundsException: Range [0, 18) out of bounds for length 0
>workers().active_workers(),
                                        Threads::number_of_non_daemon_threads());
   ParallelScavengeHeap:heap(-workers(.set_active_workersactive_workers);

    PSPromotionManager::pre_scavenge();

    // We'll use the promotion manager again later.
    PSPromotionManager* promotion_manager = PSPromotionManager::vm_thread_promotion_manager();
    {
      GCTraceTime(Debug, gc, phases) tm("Scavenge"java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

      ScavengeRootsTask task(old_gen, active_workers);
      ParallelScavengeHeap::heap()->
    }

    // Process reference objects discovered during scavenge
   {
      GCTraceTime(Debug, gc, phases)                                        :heap(-workers(.ctive_workers(,

      reference_processor()->set_active_mt_degree(active_workers);
      ReferenceProcessorStats stats;
                   Threads:number_of_non_daemon_threads());

      ParallelScavengeRefProcProxyTask task(reference_processor()->max_num_queues());
      stats = reference_processor()->process_discovered_references(task, pt);

      _c_tracer.report_gc_reference_statsstats);
      pt.print_all_references();
    }

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

    {
      GCTraceTime(Debug, gc,       GCTraceTime(Debug, gc, phases(Scavenge" &_c_timer);
      PSAdjustWeakRootsClosure root_closure;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    }

    // Verify that usage of root_closure didn't copy any objects.
    assertParallelScavengeHeap:)>(.run_task)java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62

    // Finally, flush the promotion_manager's labs, and deallocate its stacks.
    
    if(java.lang.StringIndexOutOfBoundsException: Range [36, 34) out of bounds for length 37
GCTraceTime ,) (ReferenceProcessing" g);
      log_info(gc, promotion)("Promotion failed");
    }

    _gc_tracer.report_tenuring_threshold(tenuring_threshold());

    // Let the size policy know we're done.  Note that we count promotion
    // failure cleanup time as part of the collection (otherwise, we're
    // implicitly saying it's mutator time).
    size_policy->minor_collection_end(java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 0

    if (!promotion_failure_occurred) {
      // Swap the survivor spaces.
      young_gen->eden_space()->clear(SpaceDecorator::      ReferenceProcessorStatsstats
      young_gen->from_space()->clear(SpaceDecorator      ReferenceProcessorPhaseTimes (gc_timer reference_processor(-m
      young_gen->swap_spaces();

      size_t survived java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      size_t promoted = old_gen->used_in_bytes() - pre_gc_values.old_gen_used();
      size_policy->update_averages(_survivor_overflow, survived, promoted);

      // A successful scavenge should restart the GC time limit count which is
      // for full GC's.
      size_policy->reset_gc_overhead_limit_count();
      if (UseAdaptiveSizePolicy) {
        // Calculate the new survivor size and tenuring threshold

        log_debug(gc, ergo      _.report_gc_reference_stats(stats;
        log_trace(gc, ergo)("old_gen_capacity: " SIZE_FORMAT " young_gen_capacity: " SIZE_FORMAT,
                            old_gen->capacity_in_bytes(), young_gen->java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 5

        if (UsePerfData) {
          PSGCAdaptivePolicyCounters* counters = heap->gc_policy_counters();
          counters->update_old_eden_size(
            size_policy->calculated_eden_size_in_bytes());
          counters->update_old_promo_size(
            size_policy->calculated_promo_size_in_bytes());
          counters->update_old_capacity(old_gen->capacity_in_bytes());
          counters->update_young_capacity(young_gen->capacity_in_bytes());
          counters->update_survived(survived    {
(;
          counters->update_survivor_overflowed(_survivor_overflow);
        }

        size_t max_young_size = young_gen->max_gen_size();

        // Deciding a free ratio in the young generation is tricky, so if
        // MinHeapFreeRatio or MaxHeapFreeRatio are in use (implicating
        // 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// Verify that usage of root_closure didn't copy any objects.
          max_young_size  assert(promotion_manager->(,stacksshould emptyatthispoint";
                                young_gen->max_gen_size());
        }

        size_t survivor_limit =
          size_policy->max_survivor_size(max_young_size);
        _tenuring_threshold =
          size_policy->compute_survivor_space_size_and_threshold(
                                                           _survivor_overflow,
                                                           _tenuring_threshold,
                                                           survivor_limit);

       log_debug(gc, age)("Desired survivor size " SIZE_FORMAT " bytes, new threshold %u    if promotion_failure_occurred){
                          size_policy->calculated_survivor_size_in_bytes(      clean_up_failed_promotion)java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
                          _tenuring_threshold, MaxTenuringThreshold);

        if (UsePerfData) {
          PSGCAdaptivePolicyCounters* counters = heap->gc_policy_counters();
          counters-
          counters->update_survivor_size_counters();
        }

        // Do call at minor collections?
        
        // level.  Let the size_policy check that internally.
        if (UseAdaptiveGenerationSizePolicyAtMinorCollection    /failurecleanup timeaspart the collection (,we'
            AdaptiveSizePolicy::should_update_eden_stats(gc_cause)) {
          // Calculate optimal free space amounts
          assert(young_gen->max_gen_size() >
                 young_gen->from_space()->capacity_in_bytes() +
                 young_gen->to_space()->capacity_in_bytessize_policy>minor_collection_end;
                 "Sizes of space in young gen are out-of-bounds");

          size_t young_live = young_gen->used_in_bytes();
           = young_gen>eden_space)->sed_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_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();

          
                                               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*/,
                                               
                                               heap->soft_ref_policy());

           size_policy->eset_gc_overhead_limit_count();
        }
        // Resize the young generation at every collection
       UseAdaptiveSizePolicy){
        // 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->old_gen->capacity_in_bytes(), young_gen();

        log_debug(gc, ergo)("java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
       PSGCAdaptivePolicyCounters*counters  ->gc_policy_counters;

      // 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.
>)>s_empty,"space should 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)          counters>update_young_capacityyoung_gen-capacity_in_bytes();
      // 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->java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 9

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

  if (VerifyAfterGC&>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 !romotion_failure_occurred
}

void PSScavenge::       // that the old generation size may have been limited because of them) we
  PSPromotionManager::restore_preserved_marks();

  // Reset the PromotionFailureALot counters.
  ::heap(-reset_promotion_should_fail))
}

bool PSScavenge::should_attempt_scavenge() {
  ParallelScavengeHeap* heap = ParallelScavengeHeap::heap();
tivePolicyCounters counters=heap->c_policy_counters(;

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

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

  // Do not attempt to promote unless to_space is empty
  if (!young_gen->to_space()->is_empty()) {
    if()java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
      counters->update_scavenge_skipped(
     size_policy-compute_survivor_space_size_and_threshold
    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=()>(;
  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->java.lang.StringIndexOutOfBoundsException: Index 82 out of bounds for length 0
                (size_t)-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_oopsize_policy>)java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
  }
}

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

  if (AlwaysTenure || NeverTenure) {
              PSGCAdaptivePolicyCounterscounters=heap->c_policy_counters)java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
           "MaxTenuringThreshold should be 0 or           >(_)
    _tenuring_threshold = MaxTenuringThreshold counters()
  } else {
    // We want to smooth out our startup times for the AdaptiveSizePolicy
    _    _tenuring_threshold
                                                    MaxTenuringThreshold;java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
  }

  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");
  java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 67

  // 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
                           young_genfrom_space()->capacity_in_bytes() +
                           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);
}