src/share/vm/memory/genCollectedHeap.cpp
Index Unified diffs Context diffs Sdiffs Patch New Old Previous File Next File hotspot Sdiff src/share/vm/memory

src/share/vm/memory/genCollectedHeap.cpp

Print this page
rev 7211 : [mq]: remove_ngen


 113   ReservedSpace heap_rs;
 114 
 115   size_t heap_alignment = collector_policy()->heap_alignment();
 116 
 117   heap_address = allocate(heap_alignment, &total_reserved,
 118                           &n_covered_regions, &heap_rs);
 119 
 120   if (!heap_rs.is_reserved()) {
 121     vm_shutdown_during_initialization(
 122       "Could not reserve enough space for object heap");
 123     return JNI_ENOMEM;
 124   }
 125 
 126   initialize_reserved_region((HeapWord*)heap_rs.base(), (HeapWord*)(heap_rs.base() + heap_rs.size()));
 127 
 128   _rem_set = collector_policy()->create_rem_set(reserved_region(), n_covered_regions);
 129   set_barrier_set(rem_set()->bs());
 130 
 131   _gch = this;
 132 
 133   for (i = 0; i < _n_gens; i++) {
 134     ReservedSpace this_rs = heap_rs.first_part(_gen_specs[i]->max_size(), false, false);
 135     _gens[i] = _gen_specs[i]->init(this_rs, i, rem_set());
 136     heap_rs = heap_rs.last_part(_gen_specs[i]->max_size());
 137   }


 138   clear_incremental_collection_failed();
 139 
 140 #if INCLUDE_ALL_GCS
 141   // If we are running CMS, create the collector responsible
 142   // for collecting the CMS generations.
 143   if (collector_policy()->is_concurrent_mark_sweep_policy()) {
 144     bool success = create_cms_collector();
 145     if (!success) return JNI_ENOMEM;
 146   }
 147 #endif // INCLUDE_ALL_GCS
 148 
 149   return JNI_OK;
 150 }
 151 
 152 
 153 char* GenCollectedHeap::allocate(size_t alignment,
 154                                  size_t* _total_reserved,
 155                                  int* _n_covered_regions,
 156                                  ReservedSpace* heap_rs){
 157   const char overflow_msg[] = "The size of the object heap + VM data exceeds "
 158     "the maximum representable size";
 159 
 160   // Now figure out the total size.
 161   size_t total_reserved = 0;
 162   int n_covered_regions = 0;
 163   const size_t pageSize = UseLargePages ?
 164       os::large_page_size() : os::vm_page_size();
 165 
 166   assert(alignment % pageSize == 0, "Must be");
 167 
 168   for (int i = 0; i < _n_gens; i++) {
 169     total_reserved += _gen_specs[i]->max_size();
 170     if (total_reserved < _gen_specs[i]->max_size()) {
 171       vm_exit_during_initialization(overflow_msg);
 172     }
 173     n_covered_regions += _gen_specs[i]->n_covered_regions();
 174   }
 175   assert(total_reserved % alignment == 0,
 176          err_msg("Gen size; total_reserved=" SIZE_FORMAT ", alignment="
 177                  SIZE_FORMAT, total_reserved, alignment));
 178 
 179   // Needed until the cardtable is fixed to have the right number
 180   // of covered regions.
 181   n_covered_regions += 2;
 182 
 183   *_total_reserved = total_reserved;
 184   *_n_covered_regions = n_covered_regions;
 185 
 186   *heap_rs = Universe::reserve_heap(total_reserved, alignment);
 187   return heap_rs->base();
 188 }
 189 
 190 
 191 void GenCollectedHeap::post_initialize() {
 192   SharedHeap::post_initialize();
 193   GenCollectorPolicy *policy = (GenCollectorPolicy *)collector_policy();
 194   guarantee(policy->is_generation_policy(), "Illegal policy type");
 195   DefNewGeneration* def_new_gen = (DefNewGeneration*) get_gen(0);
 196   assert(def_new_gen->kind() == Generation::DefNew ||
 197          def_new_gen->kind() == Generation::ParNew,
 198          "Wrong generation kind");
 199 
 200   Generation* old_gen = get_gen(1);
 201   assert(old_gen->kind() == Generation::ConcurrentMarkSweep ||
 202          old_gen->kind() == Generation::MarkSweepCompact,
 203     "Wrong generation kind");
 204 
 205   policy->initialize_size_policy(def_new_gen->eden()->capacity(),
 206                                  old_gen->capacity(),
 207                                  def_new_gen->from()->capacity());
 208   policy->initialize_gc_policy_counters();
 209 }
 210 
 211 void GenCollectedHeap::ref_processing_init() {
 212   SharedHeap::ref_processing_init();
 213   for (int i = 0; i < _n_gens; i++) {
 214     _gens[i]->ref_processor_init();
 215   }
 216 }
 217 
 218 size_t GenCollectedHeap::capacity() const {
 219   size_t res = 0;
 220   for (int i = 0; i < _n_gens; i++) {
 221     res += _gens[i]->capacity();
 222   }
 223   return res;
 224 }
 225 
 226 size_t GenCollectedHeap::used() const {
 227   size_t res = 0;
 228   for (int i = 0; i < _n_gens; i++) {
 229     res += _gens[i]->used();
 230   }
 231   return res;
 232 }
 233 
 234 // Save the "used_region" for generations level and lower.
 235 void GenCollectedHeap::save_used_regions(int level) {
 236   assert(level < _n_gens, "Illegal level parameter");
 237   for (int i = level; i >= 0; i--) {
 238     _gens[i]->save_used_region();
 239   }

 240 }
 241 
 242 size_t GenCollectedHeap::max_capacity() const {
 243   size_t res = 0;
 244   for (int i = 0; i < _n_gens; i++) {
 245     res += _gens[i]->max_capacity();
 246   }
 247   return res;
 248 }
 249 
 250 // Update the _full_collections_completed counter
 251 // at the end of a stop-world full GC.
 252 unsigned int GenCollectedHeap::update_full_collections_completed() {
 253   MonitorLockerEx ml(FullGCCount_lock, Mutex::_no_safepoint_check_flag);
 254   assert(_full_collections_completed <= _total_full_collections,
 255          "Can't complete more collections than were started");
 256   _full_collections_completed = _total_full_collections;
 257   ml.notify_all();
 258   return _full_collections_completed;
 259 }
 260 
 261 // Update the _full_collections_completed counter, as appropriate,
 262 // at the end of a concurrent GC cycle. Note the conditional update
 263 // below to allow this method to be called by a concurrent collector
 264 // without synchronizing in any manner with the VM thread (which
 265 // may already have initiated a STW full collection "concurrently").
 266 unsigned int GenCollectedHeap::update_full_collections_completed(unsigned int count) {
 267   MonitorLockerEx ml(FullGCCount_lock, Mutex::_no_safepoint_check_flag);


 291 // higher than we are prepared to pay for such rudimentary debugging
 292 // support.
 293 void GenCollectedHeap::check_for_non_bad_heap_word_value(HeapWord* addr,
 294                                                          size_t size) {
 295   if (CheckMemoryInitialization && ZapUnusedHeapArea) {
 296     // We are asked to check a size in HeapWords,
 297     // but the memory is mangled in juint words.
 298     juint* start = (juint*) (addr + skip_header_HeapWords());
 299     juint* end   = (juint*) (addr + size);
 300     for (juint* slot = start; slot < end; slot += 1) {
 301       assert(*slot == badHeapWordVal,
 302              "Found non badHeapWordValue in pre-allocation check");
 303     }
 304   }
 305 }
 306 #endif
 307 
 308 HeapWord* GenCollectedHeap::attempt_allocation(size_t size,
 309                                                bool is_tlab,
 310                                                bool first_only) {
 311   HeapWord* res;
 312   for (int i = 0; i < _n_gens; i++) {
 313     if (_gens[i]->should_allocate(size, is_tlab)) {
 314       res = _gens[i]->allocate(size, is_tlab);
 315       if (res != NULL) return res;
 316       else if (first_only) break;
 317     }
 318   }
 319   // Otherwise...
 320   return NULL;




 321 }
 322 
 323 HeapWord* GenCollectedHeap::mem_allocate(size_t size,
 324                                          bool* gc_overhead_limit_was_exceeded) {
 325   return collector_policy()->mem_allocate_work(size,
 326                                                false /* is_tlab */,
 327                                                gc_overhead_limit_was_exceeded);
 328 }
 329 
 330 bool GenCollectedHeap::must_clear_all_soft_refs() {
 331   return _gc_cause == GCCause::_last_ditch_collection;
 332 }
 333 
 334 bool GenCollectedHeap::should_do_concurrent_full_gc(GCCause::Cause cause) {
 335   return UseConcMarkSweepGC &&
 336          ((cause == GCCause::_gc_locker && GCLockerInvokesConcurrent) ||
 337           (cause == GCCause::_java_lang_system_gc && ExplicitGCInvokesConcurrent));
 338 }
 339 
 340 void GenCollectedHeap::do_collection(bool  full,
 341                                      bool   clear_all_soft_refs,
 342                                      size_t size,
 343                                      bool   is_tlab,
 344                                      int    max_level) {
 345   bool prepared_for_verification = false;
 346   ResourceMark rm;
 347   DEBUG_ONLY(Thread* my_thread = Thread::current();)
 348 
 349   assert(SafepointSynchronize::is_at_safepoint(), "should be at safepoint");
 350   assert(my_thread->is_VM_thread() ||
 351          my_thread->is_ConcurrentGC_thread(),
 352          "incorrect thread type capability");
 353   assert(Heap_lock->is_locked(),
 354          "the requesting thread should have the Heap_lock");
 355   guarantee(!is_gc_active(), "collection is not reentrant");
 356   assert(max_level < n_gens(), "sanity check");
 357 
 358   if (GC_locker::check_active_before_gc()) {
 359     return; // GC is disabled (e.g. JNI GetXXXCritical operation)
 360   }
 361 
 362   const bool do_clear_all_soft_refs = clear_all_soft_refs ||
 363                           collector_policy()->should_clear_all_soft_refs();
 364 
 365   ClearedAllSoftRefs casr(do_clear_all_soft_refs, collector_policy());
 366 
 367   const size_t metadata_prev_used = MetaspaceAux::used_bytes();
 368 
 369   print_heap_before_gc();
 370 
 371   {
 372     FlagSetting fl(_is_gc_active, true);
 373 
 374     bool complete = full && (max_level == (n_gens()-1));
 375     const char* gc_cause_prefix = complete ? "Full GC" : "GC";
 376     gclog_or_tty->date_stamp(PrintGC && PrintGCDateStamps);
 377     TraceCPUTime tcpu(PrintGCDetails, true, gclog_or_tty);
 378     // The PrintGCDetails logging starts before we have incremented the GC id. We will do that later
 379     // so we can assume here that the next GC id is what we want.
 380     GCTraceTime t(GCCauseString(gc_cause_prefix, gc_cause()), PrintGCDetails, false, NULL, GCId::peek());
 381 
 382     gc_prologue(complete);
 383     increment_total_collections(complete);
 384 
 385     size_t gch_prev_used = used();
 386 
 387     int starting_level = 0;
 388     if (full) {
 389       // Search for the oldest generation which will collect all younger
 390       // generations, and start collection loop there.
 391       for (int i = max_level; i >= 0; i--) {
 392         if (_gens[i]->full_collects_younger_generations()) {
 393           starting_level = i;
 394           break;
 395         }
 396       }
 397     }
 398 
 399     bool must_restore_marks_for_biased_locking = false;
 400 
 401     int max_level_collected = starting_level;
 402     for (int i = starting_level; i <= max_level; i++) {
 403       if (_gens[i]->should_collect(full, size, is_tlab)) {
 404         if (i == n_gens() - 1) {  // a major collection is to happen
 405           if (!complete) {
 406             // The full_collections increment was missed above.
 407             increment_total_full_collections();
 408           }
 409           pre_full_gc_dump(NULL);    // do any pre full gc dumps
 410         }
 411         // Timer for individual generations. Last argument is false: no CR
 412         // FIXME: We should try to start the timing earlier to cover more of the GC pause
 413         // The PrintGCDetails logging starts before we have incremented the GC id. We will do that later
 414         // so we can assume here that the next GC id is what we want.
 415         GCTraceTime t1(_gens[i]->short_name(), PrintGCDetails, false, NULL, GCId::peek());
 416         TraceCollectorStats tcs(_gens[i]->counters());
 417         TraceMemoryManagerStats tmms(_gens[i]->kind(),gc_cause());
 418 
 419         size_t prev_used = _gens[i]->used();
 420         _gens[i]->stat_record()->invocations++;
 421         _gens[i]->stat_record()->accumulated_time.start();
 422 
 423         // Must be done anew before each collection because
 424         // a previous collection will do mangling and will
 425         // change top of some spaces.
 426         record_gen_tops_before_GC();
 427 
 428         if (PrintGC && Verbose) {
 429           gclog_or_tty->print("level=%d invoke=%d size=" SIZE_FORMAT,
 430                      i,
 431                      _gens[i]->stat_record()->invocations,
 432                      size*HeapWordSize);
 433         }
 434 
 435         if (VerifyBeforeGC && i >= VerifyGCLevel &&
 436             total_collections() >= VerifyGCStartAt) {
 437           HandleMark hm;  // Discard invalid handles created during verification
 438           if (!prepared_for_verification) {
 439             prepare_for_verify();
 440             prepared_for_verification = true;
 441           }
 442           Universe::verify(" VerifyBeforeGC:");
 443         }
 444         COMPILER2_PRESENT(DerivedPointerTable::clear());
 445 
 446         if (!must_restore_marks_for_biased_locking &&
 447             _gens[i]->performs_in_place_marking()) {
 448           // We perform this mark word preservation work lazily
 449           // because it's only at this point that we know whether we
 450           // absolutely have to do it; we want to avoid doing it for
 451           // scavenge-only collections where it's unnecessary
 452           must_restore_marks_for_biased_locking = true;
 453           BiasedLocking::preserve_marks();
 454         }
 455 
 456         // Do collection work
 457         {
 458           // Note on ref discovery: For what appear to be historical reasons,
 459           // GCH enables and disabled (by enqueing) refs discovery.
 460           // In the future this should be moved into the generation's
 461           // collect method so that ref discovery and enqueueing concerns
 462           // are local to a generation. The collect method could return
 463           // an appropriate indication in the case that notification on
 464           // the ref lock was needed. This will make the treatment of
 465           // weak refs more uniform (and indeed remove such concerns
 466           // from GCH). XXX
 467 
 468           HandleMark hm;  // Discard invalid handles created during gc
 469           save_marks();   // save marks for all gens
 470           // We want to discover references, but not process them yet.
 471           // This mode is disabled in process_discovered_references if the
 472           // generation does some collection work, or in
 473           // enqueue_discovered_references if the generation returns
 474           // without doing any work.
 475           ReferenceProcessor* rp = _gens[i]->ref_processor();
 476           // If the discovery of ("weak") refs in this generation is
 477           // atomic wrt other collectors in this configuration, we
 478           // are guaranteed to have empty discovered ref lists.
 479           if (rp->discovery_is_atomic()) {
 480             rp->enable_discovery(true /*verify_disabled*/, true /*verify_no_refs*/);
 481             rp->setup_policy(do_clear_all_soft_refs);
 482           } else {
 483             // collect() below will enable discovery as appropriate
 484           }
 485           _gens[i]->collect(full, do_clear_all_soft_refs, size, is_tlab);
 486           if (!rp->enqueuing_is_done()) {
 487             rp->enqueue_discovered_references();
 488           } else {
 489             rp->set_enqueuing_is_done(false);
 490           }
 491           rp->verify_no_references_recorded();
 492         }
 493         max_level_collected = i;
 494 
 495         // Determine if allocation request was met.
 496         if (size > 0) {
 497           if (!is_tlab || _gens[i]->supports_tlab_allocation()) {
 498             if (size*HeapWordSize <= _gens[i]->unsafe_max_alloc_nogc()) {
 499               size = 0;
 500             }
 501           }
 502         }
 503 
 504         COMPILER2_PRESENT(DerivedPointerTable::update_pointers());
 505 
 506         _gens[i]->stat_record()->accumulated_time.stop();
 507 
 508         update_gc_stats(i, full);
 509 
 510         if (VerifyAfterGC && i >= VerifyGCLevel &&
 511             total_collections() >= VerifyGCStartAt) {
 512           HandleMark hm;  // Discard invalid handles created during verification
 513           Universe::verify(" VerifyAfterGC:");
 514         }
 515 
 516         if (PrintGCDetails) {
 517           gclog_or_tty->print(":");
 518           _gens[i]->print_heap_change(prev_used);
 519         }





















 520       }



























































 521     }
 522 
 523     // Update "complete" boolean wrt what actually transpired --
 524     // for instance, a promotion failure could have led to
 525     // a whole heap collection.
 526     complete = complete || (max_level_collected == n_gens() - 1);
 527 
 528     if (complete) { // We did a "major" collection
 529       // FIXME: See comment at pre_full_gc_dump call
 530       post_full_gc_dump(NULL);   // do any post full gc dumps
 531     }
 532 
 533     if (PrintGCDetails) {
 534       print_heap_change(gch_prev_used);
 535 
 536       // Print metaspace info for full GC with PrintGCDetails flag.
 537       if (complete) {
 538         MetaspaceAux::print_metaspace_change(metadata_prev_used);
 539       }
 540     }
 541 
 542     for (int j = max_level_collected; j >= 0; j -= 1) {
 543       // Adjust generation sizes.
 544       _gens[j]->compute_new_size();

 545     }

 546 
 547     if (complete) {
 548       // Delete metaspaces for unloaded class loaders and clean up loader_data graph
 549       ClassLoaderDataGraph::purge();
 550       MetaspaceAux::verify_metrics();
 551       // Resize the metaspace capacity after full collections
 552       MetaspaceGC::compute_new_size();
 553       update_full_collections_completed();
 554     }
 555 
 556     // Track memory usage and detect low memory after GC finishes
 557     MemoryService::track_memory_usage();
 558 
 559     gc_epilogue(complete);
 560 
 561     if (must_restore_marks_for_biased_locking) {
 562       BiasedLocking::restore_marks();
 563     }
 564   }
 565 


 582 void GenCollectedHeap::
 583 gen_process_roots(int level,
 584                   bool younger_gens_as_roots,
 585                   bool activate_scope,
 586                   SharedHeap::ScanningOption so,
 587                   OopsInGenClosure* not_older_gens,
 588                   OopsInGenClosure* weak_roots,
 589                   OopsInGenClosure* older_gens,
 590                   CLDClosure* cld_closure,
 591                   CLDClosure* weak_cld_closure,
 592                   CodeBlobClosure* code_closure) {
 593 
 594   // General roots.
 595   SharedHeap::process_roots(activate_scope, so,
 596                             not_older_gens, weak_roots,
 597                             cld_closure, weak_cld_closure,
 598                             code_closure);
 599 
 600   if (younger_gens_as_roots) {
 601     if (!_gen_process_roots_tasks->is_task_claimed(GCH_PS_younger_gens)) {
 602       for (int i = 0; i < level; i++) {
 603         not_older_gens->set_generation(_gens[i]);
 604         _gens[i]->oop_iterate(not_older_gens);
 605       }
 606       not_older_gens->reset_generation();
 607     }
 608   }
 609   // When collection is parallel, all threads get to cooperate to do
 610   // older-gen scanning.
 611   for (int i = level+1; i < _n_gens; i++) {
 612     older_gens->set_generation(_gens[i]);
 613     rem_set()->younger_refs_iterate(_gens[i], older_gens);
 614     older_gens->reset_generation();
 615   }
 616 
 617   _gen_process_roots_tasks->all_tasks_completed();
 618 }
 619 
 620 void GenCollectedHeap::
 621 gen_process_roots(int level,
 622                   bool younger_gens_as_roots,
 623                   bool activate_scope,
 624                   SharedHeap::ScanningOption so,
 625                   bool only_strong_roots,
 626                   OopsInGenClosure* not_older_gens,
 627                   OopsInGenClosure* older_gens,
 628                   CLDClosure* cld_closure) {
 629 
 630   const bool is_adjust_phase = !only_strong_roots && !younger_gens_as_roots;
 631 
 632   bool is_moving_collection = false;
 633   if (level == 0 || is_adjust_phase) {
 634     // young collections are always moving
 635     is_moving_collection = true;
 636   }
 637 
 638   MarkingCodeBlobClosure mark_code_closure(not_older_gens, is_moving_collection);
 639   CodeBlobClosure* code_closure = &mark_code_closure;
 640 
 641   gen_process_roots(level,
 642                     younger_gens_as_roots,
 643                     activate_scope, so,
 644                     not_older_gens, only_strong_roots ? NULL : not_older_gens,
 645                     older_gens,
 646                     cld_closure, only_strong_roots ? NULL : cld_closure,
 647                     code_closure);
 648 
 649 }
 650 
 651 void GenCollectedHeap::gen_process_weak_roots(OopClosure* root_closure) {
 652   SharedHeap::process_weak_roots(root_closure);
 653   // "Local" "weak" refs
 654   for (int i = 0; i < _n_gens; i++) {
 655     _gens[i]->ref_processor()->weak_oops_do(root_closure);
 656   }
 657 }
 658 
 659 #define GCH_SINCE_SAVE_MARKS_ITERATE_DEFN(OopClosureType, nv_suffix)    \
 660 void GenCollectedHeap::                                                 \
 661 oop_since_save_marks_iterate(int level,                                 \
 662                              OopClosureType* cur,                       \
 663                              OopClosureType* older) {                   \
 664   _gens[level]->oop_since_save_marks_iterate##nv_suffix(cur);           \
 665   for (int i = level+1; i < n_gens(); i++) {                            \
 666     _gens[i]->oop_since_save_marks_iterate##nv_suffix(older);           \


 667   }                                                                     \
 668 }
 669 
 670 ALL_SINCE_SAVE_MARKS_CLOSURES(GCH_SINCE_SAVE_MARKS_ITERATE_DEFN)
 671 
 672 #undef GCH_SINCE_SAVE_MARKS_ITERATE_DEFN
 673 
 674 bool GenCollectedHeap::no_allocs_since_save_marks(int level) {
 675   for (int i = level; i < _n_gens; i++) {
 676     if (!_gens[i]->no_allocs_since_save_marks()) return false;
 677   }

 678   return true;
 679 }
 680 
 681 bool GenCollectedHeap::supports_inline_contig_alloc() const {
 682   return _gens[0]->supports_inline_contig_alloc();
 683 }
 684 
 685 HeapWord** GenCollectedHeap::top_addr() const {
 686   return _gens[0]->top_addr();
 687 }
 688 
 689 HeapWord** GenCollectedHeap::end_addr() const {
 690   return _gens[0]->end_addr();
 691 }
 692 
 693 // public collection interfaces
 694 
 695 void GenCollectedHeap::collect(GCCause::Cause cause) {
 696   if (should_do_concurrent_full_gc(cause)) {
 697 #if INCLUDE_ALL_GCS
 698     // mostly concurrent full collection
 699     collect_mostly_concurrent(cause);
 700 #else  // INCLUDE_ALL_GCS
 701     ShouldNotReachHere();
 702 #endif // INCLUDE_ALL_GCS
 703   } else if (cause == GCCause::_wb_young_gc) {
 704     // minor collection for WhiteBox API
 705     collect(cause, 0);
 706   } else {
 707 #ifdef ASSERT
 708   if (cause == GCCause::_scavenge_alot) {
 709     // minor collection only
 710     collect(cause, 0);


 733 }
 734 
 735 // this is the private collection interface
 736 // The Heap_lock is expected to be held on entry.
 737 
 738 void GenCollectedHeap::collect_locked(GCCause::Cause cause, int max_level) {
 739   // Read the GC count while holding the Heap_lock
 740   unsigned int gc_count_before      = total_collections();
 741   unsigned int full_gc_count_before = total_full_collections();
 742   {
 743     MutexUnlocker mu(Heap_lock);  // give up heap lock, execute gets it back
 744     VM_GenCollectFull op(gc_count_before, full_gc_count_before,
 745                          cause, max_level);
 746     VMThread::execute(&op);
 747   }
 748 }
 749 
 750 #if INCLUDE_ALL_GCS
 751 bool GenCollectedHeap::create_cms_collector() {
 752 
 753   assert(_gens[1]->kind() == Generation::ConcurrentMarkSweep,
 754          "Unexpected generation kinds");
 755   // Skip two header words in the block content verification
 756   NOT_PRODUCT(_skip_header_HeapWords = CMSCollector::skip_header_HeapWords();)
 757   CMSCollector* collector = new CMSCollector(
 758     (ConcurrentMarkSweepGeneration*)_gens[1],
 759     _rem_set->as_CardTableRS(),
 760     (ConcurrentMarkSweepPolicy*) collector_policy());
 761 
 762   if (collector == NULL || !collector->completed_initialization()) {
 763     if (collector) {
 764       delete collector;  // Be nice in embedded situation
 765     }
 766     vm_shutdown_during_initialization("Could not create CMS collector");
 767     return false;
 768   }
 769   return true;  // success
 770 }
 771 
 772 void GenCollectedHeap::collect_mostly_concurrent(GCCause::Cause cause) {
 773   assert(!Heap_lock->owned_by_self(), "Should not own Heap_lock");
 774 
 775   MutexLocker ml(Heap_lock);
 776   // Read the GC counts while holding the Heap_lock
 777   unsigned int full_gc_count_before = total_full_collections();
 778   unsigned int gc_count_before      = total_collections();


 805                 local_max_level      /* max_level */);
 806   // Hack XXX FIX ME !!!
 807   // A scavenge may not have been attempted, or may have
 808   // been attempted and failed, because the old gen was too full
 809   if (local_max_level == 0 && gc_cause() == GCCause::_gc_locker &&
 810       incremental_collection_will_fail(false /* don't consult_young */)) {
 811     if (PrintGCDetails) {
 812       gclog_or_tty->print_cr("GC locker: Trying a full collection "
 813                              "because scavenge failed");
 814     }
 815     // This time allow the old gen to be collected as well
 816     do_collection(true                 /* full */,
 817                   clear_all_soft_refs  /* clear_all_soft_refs */,
 818                   0                    /* size */,
 819                   false                /* is_tlab */,
 820                   n_gens() - 1         /* max_level */);
 821   }
 822 }
 823 
 824 bool GenCollectedHeap::is_in_young(oop p) {
 825   bool result = ((HeapWord*)p) < _gens[_n_gens - 1]->reserved().start();
 826   assert(result == _gens[0]->is_in_reserved(p),
 827          err_msg("incorrect test - result=%d, p=" INTPTR_FORMAT, result, p2i((void*)p)));
 828   return result;
 829 }
 830 
 831 // Returns "TRUE" iff "p" points into the committed areas of the heap.
 832 bool GenCollectedHeap::is_in(const void* p) const {
 833   #ifndef ASSERT
 834   guarantee(VerifyBeforeGC      ||
 835             VerifyDuringGC      ||
 836             VerifyBeforeExit    ||
 837             VerifyDuringStartup ||
 838             PrintAssembly       ||
 839             tty->count() != 0   ||   // already printing
 840             VerifyAfterGC       ||
 841     VMError::fatal_error_in_progress(), "too expensive");
 842 
 843   #endif
 844   // This might be sped up with a cache of the last generation that
 845   // answered yes.
 846   for (int i = 0; i < _n_gens; i++) {
 847     if (_gens[i]->is_in(p)) return true;
 848   }
 849   // Otherwise...
 850   return false;
 851 }
 852 
 853 #ifdef ASSERT
 854 // Don't implement this by using is_in_young().  This method is used
 855 // in some cases to check that is_in_young() is correct.
 856 bool GenCollectedHeap::is_in_partial_collection(const void* p) {
 857   assert(is_in_reserved(p) || p == NULL,
 858     "Does not work if address is non-null and outside of the heap");
 859   return p < _gens[_n_gens - 2]->reserved().end() && p != NULL;
 860 }
 861 #endif
 862 
 863 void GenCollectedHeap::oop_iterate(ExtendedOopClosure* cl) {
 864   for (int i = 0; i < _n_gens; i++) {
 865     _gens[i]->oop_iterate(cl);
 866   }
 867 }
 868 
 869 void GenCollectedHeap::object_iterate(ObjectClosure* cl) {
 870   for (int i = 0; i < _n_gens; i++) {
 871     _gens[i]->object_iterate(cl);
 872   }
 873 }
 874 
 875 void GenCollectedHeap::safe_object_iterate(ObjectClosure* cl) {
 876   for (int i = 0; i < _n_gens; i++) {
 877     _gens[i]->safe_object_iterate(cl);
 878   }
 879 }
 880 
 881 Space* GenCollectedHeap::space_containing(const void* addr) const {
 882   for (int i = 0; i < _n_gens; i++) {
 883     Space* res = _gens[i]->space_containing(addr);
 884     if (res != NULL) return res;
 885   }
 886   // Otherwise...
 887   assert(false, "Could not find containing space");
 888   return NULL;
 889 }
 890 
 891 
 892 HeapWord* GenCollectedHeap::block_start(const void* addr) const {
 893   assert(is_in_reserved(addr), "block_start of address outside of heap");
 894   for (int i = 0; i < _n_gens; i++) {
 895     if (_gens[i]->is_in_reserved(addr)) {
 896       assert(_gens[i]->is_in(addr),
 897              "addr should be in allocated part of generation");
 898       return _gens[i]->block_start(addr);
 899     }
 900   }
 901   assert(false, "Some generation should contain the address");
 902   return NULL;


 903 }
 904 
 905 size_t GenCollectedHeap::block_size(const HeapWord* addr) const {
 906   assert(is_in_reserved(addr), "block_size of address outside of heap");
 907   for (int i = 0; i < _n_gens; i++) {
 908     if (_gens[i]->is_in_reserved(addr)) {
 909       assert(_gens[i]->is_in(addr),
 910              "addr should be in allocated part of generation");
 911       return _gens[i]->block_size(addr);
 912     }
 913   }
 914   assert(false, "Some generation should contain the address");
 915   return 0;

 916 }
 917 
 918 bool GenCollectedHeap::block_is_obj(const HeapWord* addr) const {
 919   assert(is_in_reserved(addr), "block_is_obj of address outside of heap");
 920   assert(block_start(addr) == addr, "addr must be a block start");
 921   for (int i = 0; i < _n_gens; i++) {
 922     if (_gens[i]->is_in_reserved(addr)) {
 923       return _gens[i]->block_is_obj(addr);
 924     }
 925   }
 926   assert(false, "Some generation should contain the address");
 927   return false;

 928 }
 929 
 930 bool GenCollectedHeap::supports_tlab_allocation() const {
 931   for (int i = 0; i < _n_gens; i += 1) {
 932     if (_gens[i]->supports_tlab_allocation()) {
 933       return true;
 934     }
 935   }
 936   return false;
 937 }
 938 
 939 size_t GenCollectedHeap::tlab_capacity(Thread* thr) const {
 940   size_t result = 0;
 941   for (int i = 0; i < _n_gens; i += 1) {
 942     if (_gens[i]->supports_tlab_allocation()) {
 943       result += _gens[i]->tlab_capacity();
 944     }
 945   }
 946   return result;
 947 }
 948 
 949 size_t GenCollectedHeap::tlab_used(Thread* thr) const {
 950   size_t result = 0;
 951   for (int i = 0; i < _n_gens; i += 1) {
 952     if (_gens[i]->supports_tlab_allocation()) {
 953       result += _gens[i]->tlab_used();
 954     }
 955   }
 956   return result;
 957 }
 958 
 959 size_t GenCollectedHeap::unsafe_max_tlab_alloc(Thread* thr) const {
 960   size_t result = 0;
 961   for (int i = 0; i < _n_gens; i += 1) {
 962     if (_gens[i]->supports_tlab_allocation()) {
 963       result += _gens[i]->unsafe_max_tlab_alloc();
 964     }
 965   }
 966   return result;
 967 }
 968 
 969 HeapWord* GenCollectedHeap::allocate_new_tlab(size_t size) {
 970   bool gc_overhead_limit_was_exceeded;
 971   return collector_policy()->mem_allocate_work(size /* size */,
 972                                                true /* is_tlab */,
 973                                                &gc_overhead_limit_was_exceeded);
 974 }
 975 
 976 // Requires "*prev_ptr" to be non-NULL.  Deletes and a block of minimal size
 977 // from the list headed by "*prev_ptr".
 978 static ScratchBlock *removeSmallestScratch(ScratchBlock **prev_ptr) {
 979   bool first = true;
 980   size_t min_size = 0;   // "first" makes this conceptually infinite.
 981   ScratchBlock **smallest_ptr, *smallest;
 982   ScratchBlock  *cur = *prev_ptr;
 983   while (cur) {
 984     assert(*prev_ptr == cur, "just checking");
 985     if (first || cur->num_words < min_size) {
 986       smallest_ptr = prev_ptr;


 995   *smallest_ptr = smallest->next;
 996   return smallest;
 997 }
 998 
 999 // Sort the scratch block list headed by res into decreasing size order,
1000 // and set "res" to the result.
1001 static void sort_scratch_list(ScratchBlock*& list) {
1002   ScratchBlock* sorted = NULL;
1003   ScratchBlock* unsorted = list;
1004   while (unsorted) {
1005     ScratchBlock *smallest = removeSmallestScratch(&unsorted);
1006     smallest->next  = sorted;
1007     sorted          = smallest;
1008   }
1009   list = sorted;
1010 }
1011 
1012 ScratchBlock* GenCollectedHeap::gather_scratch(Generation* requestor,
1013                                                size_t max_alloc_words) {
1014   ScratchBlock* res = NULL;
1015   for (int i = 0; i < _n_gens; i++) {
1016     _gens[i]->contribute_scratch(res, requestor, max_alloc_words);
1017   }
1018   sort_scratch_list(res);
1019   return res;
1020 }
1021 
1022 void GenCollectedHeap::release_scratch() {
1023   for (int i = 0; i < _n_gens; i++) {
1024     _gens[i]->reset_scratch();
1025   }
1026 }
1027 
1028 class GenPrepareForVerifyClosure: public GenCollectedHeap::GenClosure {
1029   void do_generation(Generation* gen) {
1030     gen->prepare_for_verify();
1031   }
1032 };
1033 
1034 void GenCollectedHeap::prepare_for_verify() {
1035   ensure_parsability(false);        // no need to retire TLABs
1036   GenPrepareForVerifyClosure blk;
1037   generation_iterate(&blk, false);
1038 }
1039 
1040 
1041 void GenCollectedHeap::generation_iterate(GenClosure* cl,
1042                                           bool old_to_young) {
1043   if (old_to_young) {
1044     for (int i = _n_gens-1; i >= 0; i--) {
1045       cl->do_generation(_gens[i]);
1046     }
1047   } else {
1048     for (int i = 0; i < _n_gens; i++) {
1049       cl->do_generation(_gens[i]);
1050     }
1051   }
1052 }
1053 
1054 void GenCollectedHeap::space_iterate(SpaceClosure* cl) {
1055   for (int i = 0; i < _n_gens; i++) {
1056     _gens[i]->space_iterate(cl, true);
1057   }
1058 }
1059 
1060 bool GenCollectedHeap::is_maximal_no_gc() const {
1061   for (int i = 0; i < _n_gens; i++) {
1062     if (!_gens[i]->is_maximal_no_gc()) {
1063       return false;
1064     }
1065   }
1066   return true;
1067 }
1068 
1069 void GenCollectedHeap::save_marks() {
1070   for (int i = 0; i < _n_gens; i++) {
1071     _gens[i]->save_marks();
1072   }
1073 }
1074 
1075 GenCollectedHeap* GenCollectedHeap::heap() {
1076   assert(_gch != NULL, "Uninitialized access to GenCollectedHeap::heap()");
1077   assert(_gch->kind() == CollectedHeap::GenCollectedHeap, "not a generational heap");
1078   return _gch;
1079 }
1080 
1081 
1082 void GenCollectedHeap::prepare_for_compaction() {
1083   guarantee(_n_gens = 2, "Wrong number of generations");
1084   Generation* old_gen = _gens[1];
1085   // Start by compacting into same gen.
1086   CompactPoint cp(old_gen);
1087   old_gen->prepare_for_compaction(&cp);
1088   Generation* young_gen = _gens[0];
1089   young_gen->prepare_for_compaction(&cp);
1090 }
1091 
1092 GCStats* GenCollectedHeap::gc_stats(int level) const {
1093   return _gens[level]->gc_stats();




1094 }
1095 
1096 void GenCollectedHeap::verify(bool silent, VerifyOption option /* ignored */) {
1097   for (int i = _n_gens-1; i >= 0; i--) {
1098     Generation* g = _gens[i];
1099     if (!silent) {
1100       gclog_or_tty->print("%s", g->name());
1101       gclog_or_tty->print(" ");
1102     }
1103     g->verify();




1104   }


1105   if (!silent) {
1106     gclog_or_tty->print("remset ");
1107   }
1108   rem_set()->verify();
1109 }
1110 
1111 void GenCollectedHeap::print_on(outputStream* st) const {
1112   for (int i = 0; i < _n_gens; i++) {
1113     _gens[i]->print_on(st);
1114   }
1115   MetaspaceAux::print_on(st);
1116 }
1117 
1118 void GenCollectedHeap::gc_threads_do(ThreadClosure* tc) const {
1119   if (workers() != NULL) {
1120     workers()->threads_do(tc);
1121   }
1122 #if INCLUDE_ALL_GCS
1123   if (UseConcMarkSweepGC) {
1124     ConcurrentMarkSweepThread::threads_do(tc);
1125   }
1126 #endif // INCLUDE_ALL_GCS
1127 }
1128 
1129 void GenCollectedHeap::print_gc_threads_on(outputStream* st) const {
1130 #if INCLUDE_ALL_GCS
1131   if (UseParNewGC) {
1132     workers()->print_worker_threads_on(st);
1133   }
1134   if (UseConcMarkSweepGC) {




 113   ReservedSpace heap_rs;
 114 
 115   size_t heap_alignment = collector_policy()->heap_alignment();
 116 
 117   heap_address = allocate(heap_alignment, &total_reserved,
 118                           &n_covered_regions, &heap_rs);
 119 
 120   if (!heap_rs.is_reserved()) {
 121     vm_shutdown_during_initialization(
 122       "Could not reserve enough space for object heap");
 123     return JNI_ENOMEM;
 124   }
 125 
 126   initialize_reserved_region((HeapWord*)heap_rs.base(), (HeapWord*)(heap_rs.base() + heap_rs.size()));
 127 
 128   _rem_set = collector_policy()->create_rem_set(reserved_region(), n_covered_regions);
 129   set_barrier_set(rem_set()->bs());
 130 
 131   _gch = this;
 132 
 133   ReservedSpace young_rs = heap_rs.first_part(_gen_specs[0]->max_size(), false, false);
 134   _young_gen = _gen_specs[0]->init(young_rs, 0, rem_set());
 135   heap_rs = heap_rs.last_part(_gen_specs[0]->max_size());
 136 
 137   ReservedSpace old_rs = heap_rs.first_part(_gen_specs[1]->max_size(), false, false);
 138   _old_gen = _gen_specs[1]->init(old_rs, 1, rem_set());
 139   heap_rs = heap_rs.last_part(_gen_specs[1]->max_size());
 140   clear_incremental_collection_failed();
 141 
 142 #if INCLUDE_ALL_GCS
 143   // If we are running CMS, create the collector responsible
 144   // for collecting the CMS generations.
 145   if (collector_policy()->is_concurrent_mark_sweep_policy()) {
 146     bool success = create_cms_collector();
 147     if (!success) return JNI_ENOMEM;
 148   }
 149 #endif // INCLUDE_ALL_GCS
 150 
 151   return JNI_OK;
 152 }
 153 

 154 char* GenCollectedHeap::allocate(size_t alignment,
 155                                  size_t* _total_reserved,
 156                                  int* _n_covered_regions,
 157                                  ReservedSpace* heap_rs){
 158   const char overflow_msg[] = "The size of the object heap + VM data exceeds "
 159     "the maximum representable size";
 160 
 161   // Now figure out the total size.
 162   size_t total_reserved = 0;
 163   int n_covered_regions = 0;
 164   const size_t pageSize = UseLargePages ?
 165       os::large_page_size() : os::vm_page_size();
 166 
 167   assert(alignment % pageSize == 0, "Must be");
 168 
 169   for (int i = 0; i < _n_gens; i++) {
 170     total_reserved += _gen_specs[i]->max_size();
 171     if (total_reserved < _gen_specs[i]->max_size()) {
 172       vm_exit_during_initialization(overflow_msg);
 173     }
 174     n_covered_regions += _gen_specs[i]->n_covered_regions();
 175   }
 176   assert(total_reserved % alignment == 0,
 177          err_msg("Gen size; total_reserved=" SIZE_FORMAT ", alignment="
 178                  SIZE_FORMAT, total_reserved, alignment));
 179 
 180   // Needed until the cardtable is fixed to have the right number
 181   // of covered regions.
 182   n_covered_regions += 2;
 183 
 184   *_total_reserved = total_reserved;
 185   *_n_covered_regions = n_covered_regions;
 186 
 187   *heap_rs = Universe::reserve_heap(total_reserved, alignment);
 188   return heap_rs->base();
 189 }
 190 

 191 void GenCollectedHeap::post_initialize() {
 192   SharedHeap::post_initialize();
 193   GenCollectorPolicy *policy = (GenCollectorPolicy *)collector_policy();
 194   guarantee(policy->is_generation_policy(), "Illegal policy type");
 195   DefNewGeneration* def_new_gen = (DefNewGeneration*) get_gen(0);
 196   assert(def_new_gen->kind() == Generation::DefNew ||
 197          def_new_gen->kind() == Generation::ParNew,
 198          "Wrong generation kind");
 199 
 200   Generation* old_gen = get_gen(1);
 201   assert(old_gen->kind() == Generation::ConcurrentMarkSweep ||
 202          old_gen->kind() == Generation::MarkSweepCompact,
 203     "Wrong generation kind");
 204 
 205   policy->initialize_size_policy(def_new_gen->eden()->capacity(),
 206                                  old_gen->capacity(),
 207                                  def_new_gen->from()->capacity());
 208   policy->initialize_gc_policy_counters();
 209 }
 210 
 211 void GenCollectedHeap::ref_processing_init() {
 212   SharedHeap::ref_processing_init();
 213   _young_gen->ref_processor_init();
 214   _old_gen->ref_processor_init();

 215 }
 216 
 217 size_t GenCollectedHeap::capacity() const {
 218   return _young_gen->capacity() + _old_gen->capacity();




 219 }
 220 
 221 size_t GenCollectedHeap::used() const {
 222   return _young_gen->used() + _old_gen->used();




 223 }
 224 
 225 // Save the "used_region" for generations level and lower.
 226 void GenCollectedHeap::save_used_regions(int level) {
 227   assert(level < _n_gens, "Illegal level parameter");
 228   if (level == 1) {
 229     _old_gen->save_used_region();
 230   }
 231   _young_gen->save_used_region();
 232 }
 233 
 234 size_t GenCollectedHeap::max_capacity() const {
 235   return _young_gen->max_capacity() + _old_gen->max_capacity();




 236 }
 237 
 238 // Update the _full_collections_completed counter
 239 // at the end of a stop-world full GC.
 240 unsigned int GenCollectedHeap::update_full_collections_completed() {
 241   MonitorLockerEx ml(FullGCCount_lock, Mutex::_no_safepoint_check_flag);
 242   assert(_full_collections_completed <= _total_full_collections,
 243          "Can't complete more collections than were started");
 244   _full_collections_completed = _total_full_collections;
 245   ml.notify_all();
 246   return _full_collections_completed;
 247 }
 248 
 249 // Update the _full_collections_completed counter, as appropriate,
 250 // at the end of a concurrent GC cycle. Note the conditional update
 251 // below to allow this method to be called by a concurrent collector
 252 // without synchronizing in any manner with the VM thread (which
 253 // may already have initiated a STW full collection "concurrently").
 254 unsigned int GenCollectedHeap::update_full_collections_completed(unsigned int count) {
 255   MonitorLockerEx ml(FullGCCount_lock, Mutex::_no_safepoint_check_flag);


 279 // higher than we are prepared to pay for such rudimentary debugging
 280 // support.
 281 void GenCollectedHeap::check_for_non_bad_heap_word_value(HeapWord* addr,
 282                                                          size_t size) {
 283   if (CheckMemoryInitialization && ZapUnusedHeapArea) {
 284     // We are asked to check a size in HeapWords,
 285     // but the memory is mangled in juint words.
 286     juint* start = (juint*) (addr + skip_header_HeapWords());
 287     juint* end   = (juint*) (addr + size);
 288     for (juint* slot = start; slot < end; slot += 1) {
 289       assert(*slot == badHeapWordVal,
 290              "Found non badHeapWordValue in pre-allocation check");
 291     }
 292   }
 293 }
 294 #endif
 295 
 296 HeapWord* GenCollectedHeap::attempt_allocation(size_t size,
 297                                                bool is_tlab,
 298                                                bool first_only) {
 299   HeapWord* res = NULL;
 300 
 301   if (_young_gen->should_allocate(size, is_tlab)) {
 302     res = _young_gen->allocate(size, is_tlab);
 303     if (res != NULL || first_only) {
 304       return res;
 305     }
 306   }
 307 
 308   if (_old_gen->should_allocate(size, is_tlab)) {
 309     res = _old_gen->allocate(size, is_tlab);
 310   }
 311 
 312   return res;
 313 }
 314 
 315 HeapWord* GenCollectedHeap::mem_allocate(size_t size,
 316                                          bool* gc_overhead_limit_was_exceeded) {
 317   return collector_policy()->mem_allocate_work(size,
 318                                                false /* is_tlab */,
 319                                                gc_overhead_limit_was_exceeded);
 320 }
 321 
 322 bool GenCollectedHeap::must_clear_all_soft_refs() {
 323   return _gc_cause == GCCause::_last_ditch_collection;
 324 }
 325 
 326 bool GenCollectedHeap::should_do_concurrent_full_gc(GCCause::Cause cause) {
 327   return UseConcMarkSweepGC &&
 328          ((cause == GCCause::_gc_locker && GCLockerInvokesConcurrent) ||
 329           (cause == GCCause::_java_lang_system_gc && ExplicitGCInvokesConcurrent));
 330 }
 331 
 332 void GenCollectedHeap::collect_generation(Generation* gen, bool full, size_t size,
 333                                           bool is_tlab, bool run_verification, bool clear_soft_refs) {





































































 334   // Timer for individual generations. Last argument is false: no CR
 335   // FIXME: We should try to start the timing earlier to cover more of the GC pause
 336   // The PrintGCDetails logging starts before we have incremented the GC id. We will do that later
 337   // so we can assume here that the next GC id is what we want.
 338   GCTraceTime t1(gen->short_name(), PrintGCDetails, false, NULL, GCId::peek());
 339   TraceCollectorStats tcs(gen->counters());
 340   TraceMemoryManagerStats tmms(gen->kind(),gc_cause());
 341 
 342   size_t prev_used = gen->used();
 343   gen->stat_record()->invocations++;
 344   gen->stat_record()->accumulated_time.start();
 345 
 346   // Must be done anew before each collection because
 347   // a previous collection will do mangling and will
 348   // change top of some spaces.
 349   record_gen_tops_before_GC();
 350 
 351   if (PrintGC && Verbose) {
 352     gclog_or_tty->print("level=%d invoke=%d size=" SIZE_FORMAT,
 353                         gen->level(),
 354                         gen->stat_record()->invocations,
 355                         size * HeapWordSize);
 356   }
 357 
 358   if (run_verification && VerifyBeforeGC) {

 359     HandleMark hm;  // Discard invalid handles created during verification




 360     Universe::verify(" VerifyBeforeGC:");
 361   }
 362   COMPILER2_PRESENT(DerivedPointerTable::clear());
 363 










 364   // Do collection work
 365   {
 366     // Note on ref discovery: For what appear to be historical reasons,
 367     // GCH enables and disabled (by enqueing) refs discovery.
 368     // In the future this should be moved into the generation's
 369     // collect method so that ref discovery and enqueueing concerns
 370     // are local to a generation. The collect method could return
 371     // an appropriate indication in the case that notification on
 372     // the ref lock was needed. This will make the treatment of
 373     // weak refs more uniform (and indeed remove such concerns
 374     // from GCH). XXX
 375 
 376     HandleMark hm;  // Discard invalid handles created during gc
 377     save_marks();   // save marks for all gens
 378     // We want to discover references, but not process them yet.
 379     // This mode is disabled in process_discovered_references if the
 380     // generation does some collection work, or in
 381     // enqueue_discovered_references if the generation returns
 382     // without doing any work.
 383     ReferenceProcessor* rp = gen->ref_processor();
 384     // If the discovery of ("weak") refs in this generation is
 385     // atomic wrt other collectors in this configuration, we
 386     // are guaranteed to have empty discovered ref lists.
 387     if (rp->discovery_is_atomic()) {
 388       rp->enable_discovery(true /*verify_disabled*/, true /*verify_no_refs*/);
 389       rp->setup_policy(clear_soft_refs);
 390     } else {
 391       // collect() below will enable discovery as appropriate
 392     }
 393     gen->collect(full, clear_soft_refs, size, is_tlab);
 394     if (!rp->enqueuing_is_done()) {
 395       rp->enqueue_discovered_references();
 396     } else {
 397       rp->set_enqueuing_is_done(false);
 398     }
 399     rp->verify_no_references_recorded();
 400   }

 401 
 402   // Determine if allocation request was met.
 403   if (size > 0) {
 404     if (!is_tlab || gen->supports_tlab_allocation()) {
 405       if (size * HeapWordSize <= gen->unsafe_max_alloc_nogc()) {
 406         size = 0;
 407       }
 408     }
 409   }
 410 
 411   COMPILER2_PRESENT(DerivedPointerTable::update_pointers());
 412 
 413   gen->stat_record()->accumulated_time.stop();
 414 
 415   update_gc_stats(gen->level(), full);
 416 
 417   if (run_verification && VerifyAfterGC) {

 418     HandleMark hm;  // Discard invalid handles created during verification
 419     Universe::verify(" VerifyAfterGC:");
 420   }
 421 
 422   if (PrintGCDetails) {
 423     gclog_or_tty->print(":");
 424     gen->print_heap_change(prev_used);
 425   }
 426 }
 427 
 428 void GenCollectedHeap::do_collection(bool   full,
 429                                      bool   clear_all_soft_refs,
 430                                      size_t size,
 431                                      bool   is_tlab,
 432                                      int    max_level) {
 433   ResourceMark rm;
 434   DEBUG_ONLY(Thread* my_thread = Thread::current();)
 435 
 436   assert(SafepointSynchronize::is_at_safepoint(), "should be at safepoint");
 437   assert(my_thread->is_VM_thread() ||
 438          my_thread->is_ConcurrentGC_thread(),
 439          "incorrect thread type capability");
 440   assert(Heap_lock->is_locked(),
 441          "the requesting thread should have the Heap_lock");
 442   guarantee(!is_gc_active(), "collection is not reentrant");
 443   assert(max_level < n_gens(), "sanity check");
 444 
 445   if (GC_locker::check_active_before_gc()) {
 446     return; // GC is disabled (e.g. JNI GetXXXCritical operation)
 447   }
 448 
 449   const bool do_clear_all_soft_refs = clear_all_soft_refs ||
 450                           collector_policy()->should_clear_all_soft_refs();
 451 
 452   ClearedAllSoftRefs casr(do_clear_all_soft_refs, collector_policy());
 453 
 454   const size_t metadata_prev_used = MetaspaceAux::used_bytes();
 455 
 456   print_heap_before_gc();
 457 
 458   {
 459     FlagSetting fl(_is_gc_active, true);
 460 
 461     bool complete = full && (max_level == (n_gens()-1));
 462     const char* gc_cause_prefix = complete ? "Full GC" : "GC";
 463     gclog_or_tty->date_stamp(PrintGC && PrintGCDateStamps);
 464     TraceCPUTime tcpu(PrintGCDetails, true, gclog_or_tty);
 465     // The PrintGCDetails logging starts before we have incremented the GC id. We will do that later
 466     // so we can assume here that the next GC id is what we want.
 467     GCTraceTime t(GCCauseString(gc_cause_prefix, gc_cause()), PrintGCDetails, false, NULL, GCId::peek());
 468 
 469     gc_prologue(complete);
 470     increment_total_collections(complete);
 471 
 472     size_t gch_prev_used = used();
 473     bool must_restore_marks_for_biased_locking = false;
 474     bool run_verification = total_collections() >= VerifyGCStartAt;
 475 
 476     if (_young_gen->performs_in_place_marking() ||
 477         _old_gen->performs_in_place_marking()) {
 478       // We want to avoid doing this for
 479       // scavenge-only collections where it's unnecessary.
 480       must_restore_marks_for_biased_locking = true;
 481       BiasedLocking::preserve_marks();
 482     }
 483 
 484     bool prepared_for_verification = false;
 485     int max_level_collected = 0;
 486     if (!(full && _old_gen->full_collects_younger_generations()) &&
 487         _young_gen->should_collect(full, size, is_tlab)) {
 488       if (run_verification && VerifyGCLevel <= 0 && VerifyBeforeGC) {
 489         prepare_for_verify();
 490         prepared_for_verification = true;
 491       }
 492       collect_generation(_young_gen, full, size, is_tlab, run_verification && VerifyGCLevel <= 0, do_clear_all_soft_refs);
 493     }
 494     if (max_level == 1 && _old_gen->should_collect(full, size, is_tlab)) {
 495       if (!complete) {
 496         // The full_collections increment was missed above.
 497         increment_total_full_collections();
 498       }
 499       pre_full_gc_dump(NULL);    // do any pre full gc dumps
 500       if (run_verification && VerifyGCLevel <= 1 && VerifyBeforeGC) {
 501         if (!prepared_for_verification) {
 502           prepare_for_verify();
 503         }
 504       }
 505       collect_generation(_old_gen, full, size, is_tlab, run_verification && VerifyGCLevel <= 1, do_clear_all_soft_refs);
 506       max_level_collected = 1;
 507     }
 508 
 509     // Update "complete" boolean wrt what actually transpired --
 510     // for instance, a promotion failure could have led to
 511     // a whole heap collection.
 512     complete = complete || (max_level_collected == n_gens() - 1);
 513 
 514     if (complete) { // We did a "major" collection
 515       // FIXME: See comment at pre_full_gc_dump call
 516       post_full_gc_dump(NULL);   // do any post full gc dumps
 517     }
 518 
 519     if (PrintGCDetails) {
 520       print_heap_change(gch_prev_used);
 521 
 522       // Print metaspace info for full GC with PrintGCDetails flag.
 523       if (complete) {
 524         MetaspaceAux::print_metaspace_change(metadata_prev_used);
 525       }
 526     }
 527 

 528     // Adjust generation sizes.
 529     if (max_level_collected == 1) {
 530       _old_gen->compute_new_size();
 531     }
 532     _young_gen->compute_new_size();
 533 
 534     if (complete) {
 535       // Delete metaspaces for unloaded class loaders and clean up loader_data graph
 536       ClassLoaderDataGraph::purge();
 537       MetaspaceAux::verify_metrics();
 538       // Resize the metaspace capacity after full collections
 539       MetaspaceGC::compute_new_size();
 540       update_full_collections_completed();
 541     }
 542 
 543     // Track memory usage and detect low memory after GC finishes
 544     MemoryService::track_memory_usage();
 545 
 546     gc_epilogue(complete);
 547 
 548     if (must_restore_marks_for_biased_locking) {
 549       BiasedLocking::restore_marks();
 550     }
 551   }
 552 


 569 void GenCollectedHeap::
 570 gen_process_roots(int level,
 571                   bool younger_gens_as_roots,
 572                   bool activate_scope,
 573                   SharedHeap::ScanningOption so,
 574                   OopsInGenClosure* not_older_gens,
 575                   OopsInGenClosure* weak_roots,
 576                   OopsInGenClosure* older_gens,
 577                   CLDClosure* cld_closure,
 578                   CLDClosure* weak_cld_closure,
 579                   CodeBlobClosure* code_closure) {
 580 
 581   // General roots.
 582   SharedHeap::process_roots(activate_scope, so,
 583                             not_older_gens, weak_roots,
 584                             cld_closure, weak_cld_closure,
 585                             code_closure);
 586 
 587   if (younger_gens_as_roots) {
 588     if (!_gen_process_roots_tasks->is_task_claimed(GCH_PS_younger_gens)) {
 589       if (level == 1) {
 590         not_older_gens->set_generation(_young_gen);
 591         _young_gen->oop_iterate(not_older_gens);
 592       }
 593       not_older_gens->reset_generation();
 594     }
 595   }
 596   // When collection is parallel, all threads get to cooperate to do
 597   // older-gen scanning.
 598   if (level == 0) {
 599     older_gens->set_generation(_old_gen);
 600     rem_set()->younger_refs_iterate(_old_gen, older_gens);
 601     older_gens->reset_generation();
 602   }
 603 
 604   _gen_process_roots_tasks->all_tasks_completed();
 605 }
 606 
 607 void GenCollectedHeap::
 608 gen_process_roots(int level,
 609                   bool younger_gens_as_roots,
 610                   bool activate_scope,
 611                   SharedHeap::ScanningOption so,
 612                   bool only_strong_roots,
 613                   OopsInGenClosure* not_older_gens,
 614                   OopsInGenClosure* older_gens,
 615                   CLDClosure* cld_closure) {
 616 
 617   const bool is_adjust_phase = !only_strong_roots && !younger_gens_as_roots;
 618 
 619   bool is_moving_collection = false;
 620   if (level == 0 || is_adjust_phase) {
 621     // young collections are always moving
 622     is_moving_collection = true;
 623   }
 624 
 625   MarkingCodeBlobClosure mark_code_closure(not_older_gens, is_moving_collection);
 626   CodeBlobClosure* code_closure = &mark_code_closure;
 627 
 628   gen_process_roots(level,
 629                     younger_gens_as_roots,
 630                     activate_scope, so,
 631                     not_older_gens, only_strong_roots ? NULL : not_older_gens,
 632                     older_gens,
 633                     cld_closure, only_strong_roots ? NULL : cld_closure,
 634                     code_closure);
 635 
 636 }
 637 
 638 void GenCollectedHeap::gen_process_weak_roots(OopClosure* root_closure) {
 639   SharedHeap::process_weak_roots(root_closure);
 640   // "Local" "weak" refs
 641   _young_gen->ref_processor()->weak_oops_do(root_closure);
 642   _old_gen->ref_processor()->weak_oops_do(root_closure);

 643 }
 644 
 645 #define GCH_SINCE_SAVE_MARKS_ITERATE_DEFN(OopClosureType, nv_suffix)    \
 646 void GenCollectedHeap::                                                 \
 647 oop_since_save_marks_iterate(int level,                                 \
 648                              OopClosureType* cur,                       \
 649                              OopClosureType* older) {                   \
 650   if (level == 0) {                                                     \
 651     _young_gen->oop_since_save_marks_iterate##nv_suffix(cur);           \
 652     _old_gen->oop_since_save_marks_iterate##nv_suffix(older);           \
 653   } else {                                                              \
 654     _old_gen->oop_since_save_marks_iterate##nv_suffix(cur);             \
 655   }                                                                     \
 656 }
 657 
 658 ALL_SINCE_SAVE_MARKS_CLOSURES(GCH_SINCE_SAVE_MARKS_ITERATE_DEFN)
 659 
 660 #undef GCH_SINCE_SAVE_MARKS_ITERATE_DEFN
 661 
 662 bool GenCollectedHeap::no_allocs_since_save_marks(int level) {
 663   if (level == 0) {
 664     if (!_young_gen->no_allocs_since_save_marks()) return false;
 665   }
 666   if (!_old_gen->no_allocs_since_save_marks()) return false;
 667   return true;
 668 }
 669 
 670 bool GenCollectedHeap::supports_inline_contig_alloc() const {
 671   return _young_gen->supports_inline_contig_alloc();
 672 }
 673 
 674 HeapWord** GenCollectedHeap::top_addr() const {
 675   return _young_gen->top_addr();
 676 }
 677 
 678 HeapWord** GenCollectedHeap::end_addr() const {
 679   return _young_gen->end_addr();
 680 }
 681 
 682 // public collection interfaces
 683 
 684 void GenCollectedHeap::collect(GCCause::Cause cause) {
 685   if (should_do_concurrent_full_gc(cause)) {
 686 #if INCLUDE_ALL_GCS
 687     // mostly concurrent full collection
 688     collect_mostly_concurrent(cause);
 689 #else  // INCLUDE_ALL_GCS
 690     ShouldNotReachHere();
 691 #endif // INCLUDE_ALL_GCS
 692   } else if (cause == GCCause::_wb_young_gc) {
 693     // minor collection for WhiteBox API
 694     collect(cause, 0);
 695   } else {
 696 #ifdef ASSERT
 697   if (cause == GCCause::_scavenge_alot) {
 698     // minor collection only
 699     collect(cause, 0);


 722 }
 723 
 724 // this is the private collection interface
 725 // The Heap_lock is expected to be held on entry.
 726 
 727 void GenCollectedHeap::collect_locked(GCCause::Cause cause, int max_level) {
 728   // Read the GC count while holding the Heap_lock
 729   unsigned int gc_count_before      = total_collections();
 730   unsigned int full_gc_count_before = total_full_collections();
 731   {
 732     MutexUnlocker mu(Heap_lock);  // give up heap lock, execute gets it back
 733     VM_GenCollectFull op(gc_count_before, full_gc_count_before,
 734                          cause, max_level);
 735     VMThread::execute(&op);
 736   }
 737 }
 738 
 739 #if INCLUDE_ALL_GCS
 740 bool GenCollectedHeap::create_cms_collector() {
 741 
 742   assert(_old_gen->kind() == Generation::ConcurrentMarkSweep,
 743          "Unexpected generation kinds");
 744   // Skip two header words in the block content verification
 745   NOT_PRODUCT(_skip_header_HeapWords = CMSCollector::skip_header_HeapWords();)
 746   CMSCollector* collector = new CMSCollector(
 747     (ConcurrentMarkSweepGeneration*)_old_gen,
 748     _rem_set->as_CardTableRS(),
 749     (ConcurrentMarkSweepPolicy*) collector_policy());
 750 
 751   if (collector == NULL || !collector->completed_initialization()) {
 752     if (collector) {
 753       delete collector;  // Be nice in embedded situation
 754     }
 755     vm_shutdown_during_initialization("Could not create CMS collector");
 756     return false;
 757   }
 758   return true;  // success
 759 }
 760 
 761 void GenCollectedHeap::collect_mostly_concurrent(GCCause::Cause cause) {
 762   assert(!Heap_lock->owned_by_self(), "Should not own Heap_lock");
 763 
 764   MutexLocker ml(Heap_lock);
 765   // Read the GC counts while holding the Heap_lock
 766   unsigned int full_gc_count_before = total_full_collections();
 767   unsigned int gc_count_before      = total_collections();


 794                 local_max_level      /* max_level */);
 795   // Hack XXX FIX ME !!!
 796   // A scavenge may not have been attempted, or may have
 797   // been attempted and failed, because the old gen was too full
 798   if (local_max_level == 0 && gc_cause() == GCCause::_gc_locker &&
 799       incremental_collection_will_fail(false /* don't consult_young */)) {
 800     if (PrintGCDetails) {
 801       gclog_or_tty->print_cr("GC locker: Trying a full collection "
 802                              "because scavenge failed");
 803     }
 804     // This time allow the old gen to be collected as well
 805     do_collection(true                 /* full */,
 806                   clear_all_soft_refs  /* clear_all_soft_refs */,
 807                   0                    /* size */,
 808                   false                /* is_tlab */,
 809                   n_gens() - 1         /* max_level */);
 810   }
 811 }
 812 
 813 bool GenCollectedHeap::is_in_young(oop p) {
 814   bool result = ((HeapWord*)p) < _old_gen->reserved().start();
 815   assert(result == _young_gen->is_in_reserved(p),
 816          err_msg("incorrect test - result=%d, p=" INTPTR_FORMAT, result, p2i((void*)p)));
 817   return result;
 818 }
 819 
 820 // Returns "TRUE" iff "p" points into the committed areas of the heap.
 821 bool GenCollectedHeap::is_in(const void* p) const {
 822   #ifndef ASSERT
 823   guarantee(VerifyBeforeGC      ||
 824             VerifyDuringGC      ||
 825             VerifyBeforeExit    ||
 826             VerifyDuringStartup ||
 827             PrintAssembly       ||
 828             tty->count() != 0   ||   // already printing
 829             VerifyAfterGC       ||
 830     VMError::fatal_error_in_progress(), "too expensive");
 831 
 832   #endif
 833   // This might be sped up with a cache of the last generation that
 834   // answered yes.
 835   if (_young_gen->is_in(p) || _old_gen->is_in(p)) {
 836     return true;
 837   }
 838   // Otherwise...
 839   return false;
 840 }
 841 
 842 #ifdef ASSERT
 843 // Don't implement this by using is_in_young().  This method is used
 844 // in some cases to check that is_in_young() is correct.
 845 bool GenCollectedHeap::is_in_partial_collection(const void* p) {
 846   assert(is_in_reserved(p) || p == NULL,
 847     "Does not work if address is non-null and outside of the heap");
 848   return p < _young_gen->reserved().end() && p != NULL;
 849 }
 850 #endif
 851 
 852 void GenCollectedHeap::oop_iterate(ExtendedOopClosure* cl) {
 853   _young_gen->oop_iterate(cl);
 854   _old_gen->oop_iterate(cl);

 855 }
 856 
 857 void GenCollectedHeap::object_iterate(ObjectClosure* cl) {
 858   _young_gen->object_iterate(cl);
 859   _old_gen->object_iterate(cl);

 860 }
 861 
 862 void GenCollectedHeap::safe_object_iterate(ObjectClosure* cl) {
 863   _young_gen->safe_object_iterate(cl);
 864   _old_gen->safe_object_iterate(cl);

 865 }
 866 
 867 Space* GenCollectedHeap::space_containing(const void* addr) const {
 868   Space* res = _young_gen->space_containing(addr);
 869   if (res != NULL) {
 870     return res;
 871   }
 872   res = _old_gen->space_containing(addr);
 873   assert(res != NULL, "Could not find containing space");
 874   return res;
 875 }
 876 

 877 HeapWord* GenCollectedHeap::block_start(const void* addr) const {
 878   assert(is_in_reserved(addr), "block_start of address outside of heap");
 879   if (_young_gen->is_in_reserved(addr)) {
 880     assert(_young_gen->is_in(addr), "addr should be in allocated part of generation");
 881     return _young_gen->block_start(addr);



 882   }
 883 
 884   assert(_old_gen->is_in_reserved(addr), "Some generation should contain the address");
 885   assert(_old_gen->is_in(addr), "addr should be in allocated part of generation");
 886   return _old_gen->block_start(addr);
 887 }
 888 
 889 size_t GenCollectedHeap::block_size(const HeapWord* addr) const {
 890   assert(is_in_reserved(addr), "block_size of address outside of heap");
 891   if (_young_gen->is_in_reserved(addr)) {
 892     assert(_young_gen->is_in(addr), "addr should be in allocated part of generation");
 893     return _young_gen->block_size(addr);


 894   }
 895 
 896   assert(_old_gen->is_in_reserved(addr), "Some generation should contain the address");
 897   assert(_old_gen->is_in(addr), "addr should be in allocated part of generation");
 898   return _old_gen->block_size(addr);
 899 }
 900 
 901 bool GenCollectedHeap::block_is_obj(const HeapWord* addr) const {
 902   assert(is_in_reserved(addr), "block_is_obj of address outside of heap");
 903   assert(block_start(addr) == addr, "addr must be a block start");
 904   if (_young_gen->is_in_reserved(addr)) {
 905     return _young_gen->block_is_obj(addr);


 906   }
 907 
 908   assert(_old_gen->is_in_reserved(addr), "Some generation should contain the address");
 909   return _old_gen->block_is_obj(addr);
 910 }
 911 
 912 bool GenCollectedHeap::supports_tlab_allocation() const {
 913   assert(!_old_gen->supports_tlab_allocation(), "Old gen supports TLAB allocation?!");
 914   return _young_gen->supports_tlab_allocation();




 915 }
 916 
 917 size_t GenCollectedHeap::tlab_capacity(Thread* thr) const {
 918   assert(!_old_gen->supports_tlab_allocation(), "Old gen supports TLAB allocation?!");
 919   if (_young_gen->supports_tlab_allocation()) {
 920     return _young_gen->tlab_capacity();


 921   }
 922   return 0;
 923 }
 924 
 925 size_t GenCollectedHeap::tlab_used(Thread* thr) const {
 926   assert(!_old_gen->supports_tlab_allocation(), "Old gen supports TLAB allocation?!");
 927   if (_young_gen->supports_tlab_allocation()) {
 928     return _young_gen->tlab_used();


 929   }
 930   return 0;
 931 }
 932 
 933 size_t GenCollectedHeap::unsafe_max_tlab_alloc(Thread* thr) const {
 934   assert(!_old_gen->supports_tlab_allocation(), "Old gen supports TLAB allocation?!");
 935   if (_young_gen->supports_tlab_allocation()) {
 936     return _young_gen->unsafe_max_tlab_alloc();


 937   }
 938   return 0;
 939 }
 940 
 941 HeapWord* GenCollectedHeap::allocate_new_tlab(size_t size) {
 942   bool gc_overhead_limit_was_exceeded;
 943   return collector_policy()->mem_allocate_work(size /* size */,
 944                                                true /* is_tlab */,
 945                                                &gc_overhead_limit_was_exceeded);
 946 }
 947 
 948 // Requires "*prev_ptr" to be non-NULL.  Deletes and a block of minimal size
 949 // from the list headed by "*prev_ptr".
 950 static ScratchBlock *removeSmallestScratch(ScratchBlock **prev_ptr) {
 951   bool first = true;
 952   size_t min_size = 0;   // "first" makes this conceptually infinite.
 953   ScratchBlock **smallest_ptr, *smallest;
 954   ScratchBlock  *cur = *prev_ptr;
 955   while (cur) {
 956     assert(*prev_ptr == cur, "just checking");
 957     if (first || cur->num_words < min_size) {
 958       smallest_ptr = prev_ptr;


 967   *smallest_ptr = smallest->next;
 968   return smallest;
 969 }
 970 
 971 // Sort the scratch block list headed by res into decreasing size order,
 972 // and set "res" to the result.
 973 static void sort_scratch_list(ScratchBlock*& list) {
 974   ScratchBlock* sorted = NULL;
 975   ScratchBlock* unsorted = list;
 976   while (unsorted) {
 977     ScratchBlock *smallest = removeSmallestScratch(&unsorted);
 978     smallest->next  = sorted;
 979     sorted          = smallest;
 980   }
 981   list = sorted;
 982 }
 983 
 984 ScratchBlock* GenCollectedHeap::gather_scratch(Generation* requestor,
 985                                                size_t max_alloc_words) {
 986   ScratchBlock* res = NULL;
 987   _young_gen->contribute_scratch(res, requestor, max_alloc_words);
 988   _old_gen->contribute_scratch(res, requestor, max_alloc_words);

 989   sort_scratch_list(res);
 990   return res;
 991 }
 992 
 993 void GenCollectedHeap::release_scratch() {
 994   _young_gen->reset_scratch();
 995   _old_gen->reset_scratch();

 996 }
 997 
 998 class GenPrepareForVerifyClosure: public GenCollectedHeap::GenClosure {
 999   void do_generation(Generation* gen) {
1000     gen->prepare_for_verify();
1001   }
1002 };
1003 
1004 void GenCollectedHeap::prepare_for_verify() {
1005   ensure_parsability(false);        // no need to retire TLABs
1006   GenPrepareForVerifyClosure blk;
1007   generation_iterate(&blk, false);
1008 }
1009 

1010 void GenCollectedHeap::generation_iterate(GenClosure* cl,
1011                                           bool old_to_young) {
1012   if (old_to_young) {
1013     cl->do_generation(_old_gen);
1014     cl->do_generation(_young_gen);

1015   } else {
1016     cl->do_generation(_young_gen);
1017     cl->do_generation(_old_gen);

1018   }
1019 }
1020 
1021 void GenCollectedHeap::space_iterate(SpaceClosure* cl) {
1022   _young_gen->space_iterate(cl, true);
1023   _old_gen->space_iterate(cl, true);

1024 }
1025 
1026 bool GenCollectedHeap::is_maximal_no_gc() const {
1027   return _young_gen->is_maximal_no_gc() && _old_gen->is_maximal_no_gc();





1028 }
1029 
1030 void GenCollectedHeap::save_marks() {
1031   _young_gen->save_marks();
1032   _old_gen->save_marks();

1033 }
1034 
1035 GenCollectedHeap* GenCollectedHeap::heap() {
1036   assert(_gch != NULL, "Uninitialized access to GenCollectedHeap::heap()");
1037   assert(_gch->kind() == CollectedHeap::GenCollectedHeap, "not a generational heap");
1038   return _gch;
1039 }
1040 
1041 
1042 void GenCollectedHeap::prepare_for_compaction() {
1043   guarantee(_n_gens = 2, "Wrong number of generations");
1044   Generation* old_gen = _old_gen;
1045   // Start by compacting into same gen.
1046   CompactPoint cp(old_gen);
1047   old_gen->prepare_for_compaction(&cp);
1048   Generation* young_gen = _young_gen;
1049   young_gen->prepare_for_compaction(&cp);
1050 }
1051 
1052 GCStats* GenCollectedHeap::gc_stats(int level) const {
1053   if (level == 0) {
1054     return _young_gen->gc_stats();
1055   } else {
1056     return _old_gen->gc_stats();
1057   }
1058 }
1059 
1060 void GenCollectedHeap::verify(bool silent, VerifyOption option /* ignored */) {


1061   if (!silent) {
1062     gclog_or_tty->print("%s", _old_gen->name());
1063     gclog_or_tty->print(" ");
1064   }
1065   _old_gen->verify();
1066 
1067   if (!silent) {
1068     gclog_or_tty->print("%s", _young_gen->name());
1069     gclog_or_tty->print(" ");
1070   }
1071   _young_gen->verify();
1072 
1073   if (!silent) {
1074     gclog_or_tty->print("remset ");
1075   }
1076   rem_set()->verify();
1077 }
1078 
1079 void GenCollectedHeap::print_on(outputStream* st) const {
1080   _young_gen->print_on(st);
1081   _old_gen->print_on(st);

1082   MetaspaceAux::print_on(st);
1083 }
1084 
1085 void GenCollectedHeap::gc_threads_do(ThreadClosure* tc) const {
1086   if (workers() != NULL) {
1087     workers()->threads_do(tc);
1088   }
1089 #if INCLUDE_ALL_GCS
1090   if (UseConcMarkSweepGC) {
1091     ConcurrentMarkSweepThread::threads_do(tc);
1092   }
1093 #endif // INCLUDE_ALL_GCS
1094 }
1095 
1096 void GenCollectedHeap::print_gc_threads_on(outputStream* st) const {
1097 #if INCLUDE_ALL_GCS
1098   if (UseParNewGC) {
1099     workers()->print_worker_threads_on(st);
1100   }
1101   if (UseConcMarkSweepGC) {


src/share/vm/memory/genCollectedHeap.cpp
Index Unified diffs Context diffs Sdiffs Patch New Old Previous File Next File