jdk-sandbox: comparison hotspot/src/share/vm/gc/g1/g1CollectedHeap.cpp

equal deleted inserted replaced

-:3b732f17ea7d
+:0976c0c5c5d3
 #include "gc/shared/gcTimer.hpp"
 #include "gc/shared/gcTrace.hpp"
 #include "gc/shared/gcTraceTime.inline.hpp"
 #include "gc/shared/generationSpec.hpp"
 #include "gc/shared/isGCActiveMark.hpp"
+#include "gc/shared/preservedMarks.inline.hpp"
 #include "gc/shared/referenceProcessor.inline.hpp"
 #include "gc/shared/taskqueue.inline.hpp"
 #include "logging/log.hpp"
 #include "memory/allocation.hpp"
 #include "memory/iterator.hpp"
 _ref_processor_stw(NULL),
 _bot(NULL),
 _cg1r(NULL),
 _g1mm(NULL),
 _refine_cte_cl(NULL),
+_preserved_marks_set(true /* in_c_heap */),
 _secondary_free_list("Secondary Free List", new SecondaryFreeRegionListMtSafeChecker()),
 _old_set("Old Set", false /* humongous */, new OldRegionSetMtSafeChecker()),
 _humongous_set("Master Humongous Set", true /* humongous */, new HumongousRegionSetMtSafeChecker()),
 _humongous_reclaim_candidates(),
 _has_humongous_reclaim_candidates(false),
 vm_shutdown_during_initialization("Failed to allocate initial heap.");
 return JNI_ENOMEM;
 }
 // Perform any initialization actions delegated to the policy.
-g1_policy()->init();
+g1_policy()->init(this, &_collection_set);
 JavaThread::satb_mark_queue_set().initialize(SATB_Q_CBL_mon,
 SATB_Q_FL_lock,
 G1SATBProcessCompletedThreshold,
 Shared_SATB_Q_lock);
 // values in the heap have been properly initialized.
 _g1mm = new G1MonitoringSupport(this);
 G1StringDedup::initialize();
-_preserved_objs = NEW_C_HEAP_ARRAY(OopAndMarkOopStack, ParallelGCThreads, mtGC);
+_preserved_marks_set.init(ParallelGCThreads);
-for (uint i = 0; i < ParallelGCThreads; i++) {
-new (&_preserved_objs[i]) OopAndMarkOopStack();
-}
 return JNI_OK;
 }
 void G1CollectedHeap::stop() {
 size_t G1CollectedHeap::conservative_max_heap_alignment() {
 return HeapRegion::max_region_size();
 }
 void G1CollectedHeap::post_initialize() {
-CollectedHeap::post_initialize();
 ref_processing_init();
 }
 void G1CollectedHeap::ref_processing_init() {
 // Reference processing in G1 currently works as follows:
 }
 return true;
 }
-void G1CollectedHeap::restore_preserved_marks() {
-G1RestorePreservedMarksTask rpm_task(_preserved_objs);
-workers()->run_task(&rpm_task);
-}
 void G1CollectedHeap::remove_self_forwarding_pointers() {
 G1ParRemoveSelfForwardPtrsTask rsfp_task;
 workers()->run_task(&rsfp_task);
 }
 void G1CollectedHeap::restore_after_evac_failure() {
 double remove_self_forwards_start = os::elapsedTime();
 remove_self_forwarding_pointers();
-restore_preserved_marks();
+_preserved_marks_set.restore(workers());
 g1_policy()->phase_times()->record_evac_fail_remove_self_forwards((os::elapsedTime() - remove_self_forwards_start) * 1000.0);
 }
 void G1CollectedHeap::preserve_mark_during_evac_failure(uint worker_id, oop obj, markOop m) {
 if (!_evacuation_failed) {
 _evacuation_failed = true;
 }
 _evacuation_failed_info_array[worker_id].register_copy_failure(obj->size());
+_preserved_marks_set.get(worker_id)->push_if_necessary(obj, m);
-// We want to call the "for_promotion_failure" version only in the
-// case of a promotion failure.
-if (m->must_be_preserved_for_promotion_failure(obj)) {
-OopAndMarkOop elem(obj, m);
-_preserved_objs[worker_id].push(elem);
-}
 }
 bool G1ParEvacuateFollowersClosure::offer_termination() {
 G1ParScanThreadState* const pss = par_scan_state();
 start_term_time();
 G1HotCardCache* hot_card_cache = _cg1r->hot_card_cache();
 hot_card_cache->reset_hot_cache_claimed_index();
 hot_card_cache->set_use_cache(false);
 g1_rem_set()->prepare_for_oops_into_collection_set_do();
+_preserved_marks_set.assert_empty();
 }
 void G1CollectedHeap::evacuate_collection_set(EvacuationInfo& evacuation_info, G1ParScanThreadStateSet* per_thread_states) {
 // Should G1EvacuationFailureALot be in effect for this GC?
 NOT_PRODUCT(set_evacuation_failure_alot_for_current_gc();)
 // Reset the G1EvacuationFailureALot counters and flags
 // Note: the values are reset only when an actual
 // evacuation failure occurs.
 NOT_PRODUCT(reset_evacuation_should_fail();)
 }
+_preserved_marks_set.assert_empty();
 // Enqueue any remaining references remaining on the STW
 // reference processor's discovered lists. We need to do
 // this after the card table is cleaned (and verified) as
 // the act of enqueueing entries on to the pending list
 HeapRegion* G1CollectedHeap::new_mutator_alloc_region(size_t word_size,
 bool force) {
 assert_heap_locked_or_at_safepoint(true /* should_be_vm_thread */);
 assert(!force || g1_policy()->can_expand_young_list(),
 "if force is true we should be able to expand the young list");
-bool young_list_full = g1_policy()->is_young_list_full();
+bool should_allocate = g1_policy()->should_allocate_mutator_region();
-if (force || !young_list_full) {
+if (force || should_allocate) {
 HeapRegion* new_alloc_region = new_region(word_size,
 false /* is_old */,
 false /* do_expand */);
 if (new_alloc_region != NULL) {
 set_region_short_lived_locked(new_alloc_region);
-_hr_printer.alloc(new_alloc_region, young_list_full);
+_hr_printer.alloc(new_alloc_region, !should_allocate);
 _verifier->check_bitmaps("Mutator Region Allocation", new_alloc_region);
 return new_alloc_region;
 }
 }
 return NULL;

changeset 38144	0976c0c5c5d3
parent 38133	78b95467b9f1
parent 38106	da14ba2f0cd9
child 38154	4c30333c304e