truffle: src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp comparison

comparison src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp @ 14518:d8041d695d19

Merged with jdk9/dev/hotspot changeset 3812c088b945

author	twisti
date	Tue, 11 Mar 2014 18:45:59 -0700
parents	02f27ecb4f3a 97300b6165f8
children	4ca6dc0799b6

comparison

equal deleted inserted replaced

-:f97c5ec83832
+:d8041d695d19
 /*
-* Copyright (c) 2001, 2013, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 2001, 2014, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 #include "gc_implementation/shared/gcTimer.hpp"
 #include "gc_implementation/shared/gcTrace.hpp"
 #include "gc_implementation/shared/gcTraceTime.hpp"
 #include "gc_implementation/shared/isGCActiveMark.hpp"
 #include "memory/gcLocker.inline.hpp"
-#include "memory/genOopClosures.inline.hpp"
 #include "memory/generationSpec.hpp"
+#include "memory/iterator.hpp"
 #include "memory/referenceProcessor.hpp"
 #include "oops/oop.inline.hpp"
 #include "oops/oop.pcgc.inline.hpp"
 #include "runtime/vmThread.hpp"
 #include "utilities/ticks.hpp"
 // This code is mostly copied from TenuredGeneration.
 void
 G1CollectedHeap::
 resize_if_necessary_after_full_collection(size_t word_size) {
-assert(MinHeapFreeRatio <= MaxHeapFreeRatio, "sanity check");
 // Include the current allocation, if any, and bytes that will be
 // pre-allocated to support collections, as "used".
 const size_t used_after_gc = used();
 const size_t capacity_after_gc = capacity();
 const size_t free_after_gc = capacity_after_gc - used_after_gc;
 &_is_alive_closure_stw,
 // is alive closure
 // (for efficiency/performance)
 false);
 // Setting next fields of discovered
-// lists requires a barrier.
+// lists does not require a barrier.
 }
 size_t G1CollectedHeap::capacity() const {
 return _g1_committed.byte_size();
 }
 size_t G1CollectedHeap::recalculate_used() const {
 SumUsedClosure blk;
 heap_region_iterate(&blk);
 return blk.result();
-}
-size_t G1CollectedHeap::unsafe_max_alloc() {
-if (free_regions() > 0) return HeapRegion::GrainBytes;
-// otherwise, is there space in the current allocation region?
-// We need to store the current allocation region in a local variable
-// here. The problem is that this method doesn't take any locks and
-// there may be other threads which overwrite the current allocation
-// region field. attempt_allocation(), for example, sets it to NULL
-// and this can happen *after* the NULL check here but before the call
-// to free(), resulting in a SIGSEGV. Note that this doesn't appear
-// to be a problem in the optimized build, since the two loads of the
-// current allocation region field are optimized away.
-HeapRegion* hr = _mutator_alloc_region.get();
-if (hr == NULL) {
-return 0;
-}
-return hr->free();
 }
 bool G1CollectedHeap::should_do_concurrent_full_gc(GCCause::Cause cause) {
 switch (cause) {
 case GCCause::_gc_locker:               return GCLockerInvokesConcurrent;
 bool G1CollectedHeap::supports_tlab_allocation() const {
 return true;
 }
 size_t G1CollectedHeap::tlab_capacity(Thread* ignored) const {
-return HeapRegion::GrainBytes;
+return (_g1_policy->young_list_target_length() - young_list()->survivor_length()) * HeapRegion::GrainBytes;
+}
+size_t G1CollectedHeap::tlab_used(Thread* ignored) const {
+return young_list()->eden_used_bytes();
+}
+// For G1 TLABs should not contain humongous objects, so the maximum TLAB size
+// must be smaller than the humongous object limit.
+size_t G1CollectedHeap::max_tlab_size() const {
+return align_size_down(_humongous_object_threshold_in_words - 1, MinObjAlignment);
 }
 size_t G1CollectedHeap::unsafe_max_tlab_alloc(Thread* ignored) const {
 // Return the remaining space in the cur alloc region, but not less than
 // the min TLAB size.
 // Also, this value can be at most the humongous object threshold,
 // since we can't allow tlabs to grow big enough to accommodate
 // humongous objects.
 HeapRegion* hr = _mutator_alloc_region.get();
-size_t max_tlab_size = _humongous_object_threshold_in_words * wordSize;
+size_t max_tlab = max_tlab_size() * wordSize;
 if (hr == NULL) {
-return max_tlab_size;
+return max_tlab;
 } else {
-return MIN2(MAX2(hr->free(), (size_t) MinTLABSize), max_tlab_size);
+return MIN2(MAX2(hr->free(), (size_t) MinTLABSize), max_tlab);
 }
 }
 size_t G1CollectedHeap::max_capacity() const {
 return _g1_reserved.byte_size();
 default:                            ShouldNotReachHere();
 }
 return NULL; // keep some compilers happy
 }
-// TODO: VerifyRootsClosure extends OopsInGenClosure so that we can
+class VerifyRootsClosure: public OopClosure {
-//       pass it as the perm_blk to SharedHeap::process_strong_roots.
-//       When process_strong_roots stop calling perm_blk->younger_refs_iterate
-//       we can change this closure to extend the simpler OopClosure.
-class VerifyRootsClosure: public OopsInGenClosure {
 private:
 G1CollectedHeap* _g1h;
 VerifyOption     _vo;
 bool             _failures;
 public:
 void do_oop(oop* p)       { do_oop_nv(p); }
 void do_oop(narrowOop* p) { do_oop_nv(p); }
 };
-class G1VerifyCodeRootOopClosure: public OopsInGenClosure {
+class G1VerifyCodeRootOopClosure: public OopClosure {
 G1CollectedHeap* _g1h;
 OopClosure* _root_cl;
 nmethod* _nm;
 VerifyOption _vo;
 bool _failures;
 assert(Thread::current()->is_VM_thread(),
 "Expected to be executed serially by the VM thread at this point");
 if (!silent) { gclog_or_tty->print("Roots "); }
 VerifyRootsClosure rootsCl(vo);
+VerifyKlassClosure klassCl(this, &rootsCl);
+// We apply the relevant closures to all the oops in the
+// system dictionary, class loader data graph and the string table.
+// Don't verify the code cache here, since it's verified below.
+const int so = SO_AllClasses | SO_Strings;
+// Need cleared claim bits for the strong roots processing
+ClassLoaderDataGraph::clear_claimed_marks();
+process_strong_roots(true,      // activate StrongRootsScope
+ScanningOption(so),  // roots scanning options
+&rootsCl,
+&klassCl
+);
+// Verify the nmethods in the code cache.
 G1VerifyCodeRootOopClosure codeRootsCl(this, &rootsCl, vo);
 G1VerifyCodeRootBlobClosure blobsCl(&codeRootsCl);
-VerifyKlassClosure klassCl(this, &rootsCl);
+CodeCache::blobs_do(&blobsCl);
-// We apply the relevant closures to all the oops in the
-// system dictionary, the string table and the code cache.
-const int so = SO_AllClasses | SO_Strings | SO_CodeCache;
-// Need cleared claim bits for the strong roots processing
-ClassLoaderDataGraph::clear_claimed_marks();
-process_strong_roots(true,      // activate StrongRootsScope
-false,     // we set "is scavenging" to false,
-// so we don't reset the dirty cards.
-ScanningOption(so),  // roots scanning options
-&rootsCl,
-&blobsCl,
-&klassCl
-);
 bool failures = rootsCl.failures() || codeRootsCl.failures();
 if (vo != VerifyOption_G1UseMarkWord) {
 // If we're verifying during a full GC then the region sets
 void G1CollectedHeap::gc_prologue(bool full /* Ignored */) {
 // always_do_update_barrier = false;
 assert(InlineCacheBuffer::is_empty(), "should have cleaned up ICBuffer");
 // Fill TLAB's and such
+accumulate_statistics_all_tlabs();
 ensure_parsability(true);
 if (G1SummarizeRSetStats && (G1SummarizeRSetStatsPeriod > 0) &&
 (total_collections() % G1SummarizeRSetStatsPeriod == 0)) {
 g1_rem_set()->print_periodic_summary_info("Before GC RS summary");
 // I'm ignoring the "fill_newgen()" call if "alloc_event_enabled"
 // is set.
 COMPILER2_PRESENT(assert(DerivedPointerTable::is_empty(),
 "derived pointer present"));
 // always_do_update_barrier = true;
+resize_all_tlabs();
 // We have just completed a GC. Update the soft reference
 // policy with the new heap occupancy
 Universe::update_heap_info_at_gc();
 }
 }
 G1ParGCAllocBuffer::G1ParGCAllocBuffer(size_t gclab_word_size) :
 ParGCAllocBuffer(gclab_word_size), _retired(false) { }
-G1ParScanThreadState::G1ParScanThreadState(G1CollectedHeap* g1h, uint queue_num)
+G1ParScanThreadState::G1ParScanThreadState(G1CollectedHeap* g1h, uint queue_num, ReferenceProcessor* rp)
 : _g1h(g1h),
 _refs(g1h->task_queue(queue_num)),
 _dcq(&g1h->dirty_card_queue_set()),
 _ct_bs(g1h->g1_barrier_set()),
 _g1_rem(g1h->g1_rem_set()),
 _hash_seed(17), _queue_num(queue_num),
 _term_attempts(0),
 _surviving_alloc_buffer(g1h->desired_plab_sz(GCAllocForSurvived)),
 _tenured_alloc_buffer(g1h->desired_plab_sz(GCAllocForTenured)),
-_age_table(false),
+_age_table(false), _scanner(g1h, this, rp),
 _strong_roots_time(0), _term_time(0),
 _alloc_buffer_waste(0), _undo_waste(0) {
 // we allocate G1YoungSurvRateNumRegions plus one entries, since
 // we "sacrifice" entry 0 to keep track of surviving bytes for
 // non-young regions (where the age is -1)
 } while (!refs()->is_empty());
 }
 G1ParClosureSuper::G1ParClosureSuper(G1CollectedHeap* g1,
 G1ParScanThreadState* par_scan_state) :
-_g1(g1), _g1_rem(_g1->g1_rem_set()), _cm(_g1->concurrent_mark()),
+_g1(g1), _par_scan_state(par_scan_state),
-_par_scan_state(par_scan_state),
+_worker_id(par_scan_state->queue_num()) { }
-_worker_id(par_scan_state->queue_num()),
-_during_initial_mark(_g1->g1_policy()->during_initial_mark_pause()),
+void G1ParCopyHelper::mark_object(oop obj) {
-_mark_in_progress(_g1->mark_in_progress()) { }
-template <bool do_gen_barrier, G1Barrier barrier, bool do_mark_object>
-void G1ParCopyClosure<do_gen_barrier, barrier, do_mark_object>::mark_object(oop obj) {
 #ifdef ASSERT
 HeapRegion* hr = _g1->heap_region_containing(obj);
 assert(hr != NULL, "sanity");
 assert(!hr->in_collection_set(), "should not mark objects in the CSet");
 #endif // ASSERT
 // We know that the object is not moving so it's safe to read its size.
 _cm->grayRoot(obj, (size_t) obj->size(), _worker_id);
 }
-template <bool do_gen_barrier, G1Barrier barrier, bool do_mark_object>
+void G1ParCopyHelper::mark_forwarded_object(oop from_obj, oop to_obj) {
-void G1ParCopyClosure<do_gen_barrier, barrier, do_mark_object>
-::mark_forwarded_object(oop from_obj, oop to_obj) {
 #ifdef ASSERT
 assert(from_obj->is_forwarded(), "from obj should be forwarded");
 assert(from_obj->forwardee() == to_obj, "to obj should be the forwardee");
 assert(from_obj != to_obj, "should not be self-forwarded");
 // well-formed. So we have to read its size from its from-space
 // image which we know should not be changing.
 _cm->grayRoot(to_obj, (size_t) from_obj->size(), _worker_id);
 }
-template <bool do_gen_barrier, G1Barrier barrier, bool do_mark_object>
+oop G1ParScanThreadState::copy_to_survivor_space(oop const old) {
-oop G1ParCopyClosure<do_gen_barrier, barrier, do_mark_object>
-::copy_to_survivor_space(oop old) {
 size_t word_sz = old->size();
-HeapRegion* from_region = _g1->heap_region_containing_raw(old);
+HeapRegion* from_region = _g1h->heap_region_containing_raw(old);
 // +1 to make the -1 indexes valid...
 int       young_index = from_region->young_index_in_cset()+1;
 assert( (from_region->is_young() && young_index >  0) ||
 (!from_region->is_young() && young_index == 0), "invariant" );
-G1CollectorPolicy* g1p = _g1->g1_policy();
+G1CollectorPolicy* g1p = _g1h->g1_policy();
 markOop m = old->mark();
 int age = m->has_displaced_mark_helper() ? m->displaced_mark_helper()->age()
 : m->age();
 GCAllocPurpose alloc_purpose = g1p->evacuation_destination(from_region, age,
 word_sz);
-HeapWord* obj_ptr = _par_scan_state->allocate(alloc_purpose, word_sz);
+HeapWord* obj_ptr = allocate(alloc_purpose, word_sz);
 #ifndef PRODUCT
 // Should this evacuation fail?
-if (_g1->evacuation_should_fail()) {
+if (_g1h->evacuation_should_fail()) {
 if (obj_ptr != NULL) {
-_par_scan_state->undo_allocation(alloc_purpose, obj_ptr, word_sz);
+undo_allocation(alloc_purpose, obj_ptr, word_sz);
 obj_ptr = NULL;
 }
 }
 #endif // !PRODUCT
 if (obj_ptr == NULL) {
 // This will either forward-to-self, or detect that someone else has
 // installed a forwarding pointer.
-return _g1->handle_evacuation_failure_par(_par_scan_state, old);
+return _g1h->handle_evacuation_failure_par(this, old);
 }
 oop obj = oop(obj_ptr);
 // We're going to allocate linearly, so might as well prefetch ahead.
 obj->incr_age();
 } else {
 m = m->incr_age();
 obj->set_mark(m);
 }
-_par_scan_state->age_table()->add(obj, word_sz);
+age_table()->add(obj, word_sz);
 } else {
 obj->set_mark(m);
 }
-size_t* surv_young_words = _par_scan_state->surviving_young_words();
+size_t* surv_young_words = surviving_young_words();
 surv_young_words[young_index] += word_sz;
 if (obj->is_objArray() && arrayOop(obj)->length() >= ParGCArrayScanChunk) {
 // We keep track of the next start index in the length field of
 // the to-space object. The actual length can be found in the
 // length field of the from-space object.
 arrayOop(obj)->set_length(0);
 oop* old_p = set_partial_array_mask(old);
-_par_scan_state->push_on_queue(old_p);
+push_on_queue(old_p);
 } else {
 // No point in using the slower heap_region_containing() method,
 // given that we know obj is in the heap.
-_scanner.set_region(_g1->heap_region_containing_raw(obj));
+_scanner.set_region(_g1h->heap_region_containing_raw(obj));
 obj->oop_iterate_backwards(&_scanner);
 }
 } else {
-_par_scan_state->undo_allocation(alloc_purpose, obj_ptr, word_sz);
+undo_allocation(alloc_purpose, obj_ptr, word_sz);
 obj = forward_ptr;
 }
 return obj;
 }
 if (_g1->heap_region_containing_raw(new_obj)->is_young()) {
 _scanned_klass->record_modified_oops();
 }
 }
-template <bool do_gen_barrier, G1Barrier barrier, bool do_mark_object>
+template <G1Barrier barrier, bool do_mark_object>
 template <class T>
-void G1ParCopyClosure<do_gen_barrier, barrier, do_mark_object>
+void G1ParCopyClosure<barrier, do_mark_object>::do_oop_work(T* p) {
-::do_oop_work(T* p) {
+T heap_oop = oopDesc::load_heap_oop(p);
-oop obj = oopDesc::load_decode_heap_oop(p);
-assert(barrier != G1BarrierRS || obj != NULL,
+if (oopDesc::is_null(heap_oop)) {
-"Precondition: G1BarrierRS implies obj is non-NULL");
+return;
+}
+oop obj = oopDesc::decode_heap_oop_not_null(heap_oop);
 assert(_worker_id == _par_scan_state->queue_num(), "sanity");
-// here the null check is implicit in the cset_fast_test() test
 if (_g1->in_cset_fast_test(obj)) {
 oop forwardee;
 if (obj->is_forwarded()) {
 forwardee = obj->forwardee();
 } else {
-forwardee = copy_to_survivor_space(obj);
+forwardee = _par_scan_state->copy_to_survivor_space(obj);
 }
 assert(forwardee != NULL, "forwardee should not be NULL");
 oopDesc::encode_store_heap_oop(p, forwardee);
 if (do_mark_object && forwardee != obj) {
 // If the object is self-forwarded we don't need to explicitly
 // mark it, the evacuation failure protocol will do so.
 mark_forwarded_object(obj, forwardee);
 }
-// When scanning the RS, we only care about objs in CS.
+if (barrier == G1BarrierKlass) {
-if (barrier == G1BarrierRS) {
-_par_scan_state->update_rs(_from, p, _worker_id);
-} else if (barrier == G1BarrierKlass) {
 do_klass_barrier(p, forwardee);
 }
 } else {
 // The object is not in collection set. If we're a root scanning
 // closure during an initial mark pause (i.e. do_mark_object will
 // be true) then attempt to mark the object.
-if (do_mark_object && _g1->is_in_g1_reserved(obj)) {
+if (do_mark_object) {
 mark_object(obj);
 }
 }
-if (barrier == G1BarrierEvac && obj != NULL) {
+if (barrier == G1BarrierEvac) {
 _par_scan_state->update_rs(_from, p, _worker_id);
 }
+}
-if (do_gen_barrier && obj != NULL) {
-par_do_barrier(p);
+template void G1ParCopyClosure<G1BarrierEvac, false>::do_oop_work(oop* p);
-}
+template void G1ParCopyClosure<G1BarrierEvac, false>::do_oop_work(narrowOop* p);
-}
-template void G1ParCopyClosure<false, G1BarrierEvac, false>::do_oop_work(oop* p);
-template void G1ParCopyClosure<false, G1BarrierEvac, false>::do_oop_work(narrowOop* p);
 template <class T> void G1ParScanPartialArrayClosure::do_oop_nv(T* p) {
 assert(has_partial_array_mask(p), "invariant");
 oop from_obj = clear_partial_array_mask(p);
 ResourceMark rm;
 HandleMark   hm;
 ReferenceProcessor*             rp = _g1h->ref_processor_stw();
-G1ParScanThreadState            pss(_g1h, worker_id);
+G1ParScanThreadState            pss(_g1h, worker_id, rp);
 G1ParScanHeapEvacClosure        scan_evac_cl(_g1h, &pss, rp);
 G1ParScanHeapEvacFailureClosure evac_failure_cl(_g1h, &pss, rp);
 G1ParScanPartialArrayClosure    partial_scan_cl(_g1h, &pss, rp);
 pss.set_evac_closure(&scan_evac_cl);
 double ext_roots_start = os::elapsedTime();
 double closure_app_time_sec = 0.0;
 BufferingOopClosure buf_scan_non_heap_roots(scan_non_heap_roots);
-assert(so & SO_CodeCache || scan_rs != NULL, "must scan code roots somehow");
-// Walk the code cache/strong code roots w/o buffering, because StarTask
-// cannot handle unaligned oop locations.
-CodeBlobToOopClosure eager_scan_code_roots(scan_non_heap_roots, true /* do_marking */);
 process_strong_roots(false, // no scoping; this is parallel code
-is_scavenging, so,
+so,
 &buf_scan_non_heap_roots,
-&eager_scan_code_roots,
 scan_klasses
 );
 // Now the CM ref_processor roots.
 if (!_process_strong_tasks->is_task_claimed(G1H_PS_refProcessor_oops_do)) {
 // the entire code cache, we need to mark the oops in the
 // strong code root lists for the regions that are not in
 // the collection set.
 // Note all threads participate in this set of root tasks.
 double mark_strong_code_roots_ms = 0.0;
-if (g1_policy()->during_initial_mark_pause() && !(so & SO_CodeCache)) {
+if (g1_policy()->during_initial_mark_pause() && !(so & SO_AllCodeCache)) {
 double mark_strong_roots_start = os::elapsedTime();
 mark_strong_code_roots(worker_i);
 mark_strong_code_roots_ms = (os::elapsedTime() - mark_strong_roots_start) * 1000.0;
 }
 g1_policy()->phase_times()->record_strong_code_root_mark_time(worker_i, mark_strong_code_roots_ms);
 // Now scan the complement of the collection set.
-if (scan_rs != NULL) {
+CodeBlobToOopClosure eager_scan_code_roots(scan_non_heap_roots, true /* do_marking */);
 g1_rem_set()->oops_into_collection_set_do(scan_rs, &eager_scan_code_roots, worker_i);
-}
 _process_strong_tasks->all_tasks_completed();
 }
-void
+class G1StringSymbolTableUnlinkTask : public AbstractGangTask {
-G1CollectedHeap::g1_process_weak_roots(OopClosure* root_closure) {
+private:
-CodeBlobToOopClosure roots_in_blobs(root_closure, /*do_marking=*/ false);
+BoolObjectClosure* _is_alive;
-SharedHeap::process_weak_roots(root_closure, &roots_in_blobs);
+int _initial_string_table_size;
+int _initial_symbol_table_size;
+bool  _process_strings;
+int _strings_processed;
+int _strings_removed;
+bool  _process_symbols;
+int _symbols_processed;
+int _symbols_removed;
+bool _do_in_parallel;
+public:
+G1StringSymbolTableUnlinkTask(BoolObjectClosure* is_alive, bool process_strings, bool process_symbols) :
+AbstractGangTask("Par String/Symbol table unlink"), _is_alive(is_alive),
+_do_in_parallel(G1CollectedHeap::use_parallel_gc_threads()),
+_process_strings(process_strings), _strings_processed(0), _strings_removed(0),
+_process_symbols(process_symbols), _symbols_processed(0), _symbols_removed(0) {
+_initial_string_table_size = StringTable::the_table()->table_size();
+_initial_symbol_table_size = SymbolTable::the_table()->table_size();
+if (process_strings) {
+StringTable::clear_parallel_claimed_index();
+}
+if (process_symbols) {
+SymbolTable::clear_parallel_claimed_index();
+}
+}
+~G1StringSymbolTableUnlinkTask() {
+guarantee(!_process_strings || !_do_in_parallel || StringTable::parallel_claimed_index() >= _initial_string_table_size,
+err_msg("claim value "INT32_FORMAT" after unlink less than initial string table size "INT32_FORMAT,
+StringTable::parallel_claimed_index(), _initial_string_table_size));
+guarantee(!_process_symbols || !_do_in_parallel || SymbolTable::parallel_claimed_index() >= _initial_symbol_table_size,
+err_msg("claim value "INT32_FORMAT" after unlink less than initial symbol table size "INT32_FORMAT,
+SymbolTable::parallel_claimed_index(), _initial_symbol_table_size));
+}
+void work(uint worker_id) {
+if (_do_in_parallel) {
+int strings_processed = 0;
+int strings_removed = 0;
+int symbols_processed = 0;
+int symbols_removed = 0;
+if (_process_strings) {
+StringTable::possibly_parallel_unlink(_is_alive, &strings_processed, &strings_removed);
+Atomic::add(strings_processed, &_strings_processed);
+Atomic::add(strings_removed, &_strings_removed);
+}
+if (_process_symbols) {
+SymbolTable::possibly_parallel_unlink(&symbols_processed, &symbols_removed);
+Atomic::add(symbols_processed, &_symbols_processed);
+Atomic::add(symbols_removed, &_symbols_removed);
+}
+} else {
+if (_process_strings) {
+StringTable::unlink(_is_alive, &_strings_processed, &_strings_removed);
+}
+if (_process_symbols) {
+SymbolTable::unlink(&_symbols_processed, &_symbols_removed);
+}
+}
+}
+size_t strings_processed() const { return (size_t)_strings_processed; }
+size_t strings_removed()   const { return (size_t)_strings_removed; }
+size_t symbols_processed() const { return (size_t)_symbols_processed; }
+size_t symbols_removed()   const { return (size_t)_symbols_removed; }
+};
+void G1CollectedHeap::unlink_string_and_symbol_table(BoolObjectClosure* is_alive,
+bool process_strings, bool process_symbols) {
+uint n_workers = (G1CollectedHeap::use_parallel_gc_threads() ?
+_g1h->workers()->active_workers() : 1);
+G1StringSymbolTableUnlinkTask g1_unlink_task(is_alive, process_strings, process_symbols);
+if (G1CollectedHeap::use_parallel_gc_threads()) {
+set_par_threads(n_workers);
+workers()->run_task(&g1_unlink_task);
+set_par_threads(0);
+} else {
+g1_unlink_task.work(0);
+}
+if (G1TraceStringSymbolTableScrubbing) {
+gclog_or_tty->print_cr("Cleaned string and symbol table, "
+"strings: "SIZE_FORMAT" processed, "SIZE_FORMAT" removed, "
+"symbols: "SIZE_FORMAT" processed, "SIZE_FORMAT" removed",
+g1_unlink_task.strings_processed(), g1_unlink_task.strings_removed(),
+g1_unlink_task.symbols_processed(), g1_unlink_task.symbols_removed());
+}
 }
 // Weak Reference Processing support
 // An always "is_alive" closure that is used to preserve referents.
 ResourceMark rm;
 HandleMark   hm;
 G1STWIsAliveClosure is_alive(_g1h);
-G1ParScanThreadState pss(_g1h, worker_id);
+G1ParScanThreadState            pss(_g1h, worker_id, NULL);
 G1ParScanHeapEvacClosure        scan_evac_cl(_g1h, &pss, NULL);
 G1ParScanHeapEvacFailureClosure evac_failure_cl(_g1h, &pss, NULL);
 G1ParScanPartialArrayClosure    partial_scan_cl(_g1h, &pss, NULL);
 void work(uint worker_id) {
 ResourceMark rm;
 HandleMark   hm;
-G1ParScanThreadState            pss(_g1h, worker_id);
+G1ParScanThreadState            pss(_g1h, worker_id, NULL);
 G1ParScanHeapEvacClosure        scan_evac_cl(_g1h, &pss, NULL);
 G1ParScanHeapEvacFailureClosure evac_failure_cl(_g1h, &pss, NULL);
 G1ParScanPartialArrayClosure    partial_scan_cl(_g1h, &pss, NULL);
 pss.set_evac_closure(&scan_evac_cl);
 // of JNI refs is serial and performed serially by the current thread
 // rather than by a worker. The following PSS will be used for processing
 // JNI refs.
 // Use only a single queue for this PSS.
-G1ParScanThreadState pss(this, 0);
+G1ParScanThreadState            pss(this, 0, NULL);
 // We do not embed a reference processor in the copying/scanning
 // closures while we're actually processing the discovered
 // reference objects.
 G1ParScanHeapEvacClosure        scan_evac_cl(this, &pss, NULL);

Mercurial > hg > truffle

comparison src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp @ 14518:d8041d695d19