truffle: src/share/vm/memory/defNewGeneration.cpp comparison

comparison src/share/vm/memory/defNewGeneration.cpp @ 269:850fdf70db2b

Merge

author	jmasa
date	Mon, 28 Jul 2008 15:30:23 -0700
parents	d1605aabd0a1 12eea04c8b06
children	1ee8caae33af

comparison

equal deleted inserted replaced

-:3df2fe7c4451
+:850fdf70db2b
 _from_counters = new CSpaceCounters("s0", 1, _max_survivor_size, _from_space,
 _gen_counters);
 _to_counters = new CSpaceCounters("s1", 2, _max_survivor_size, _to_space,
 _gen_counters);
-compute_space_boundaries(0);
+compute_space_boundaries(0, SpaceDecorator::Clear, SpaceDecorator::Mangle);
 update_counters();
 _next_gen = NULL;
 _tenuring_threshold = MaxTenuringThreshold;
 _pretenure_size_threshold_words = PretenureSizeThreshold >> LogHeapWordSize;
 }
-void DefNewGeneration::compute_space_boundaries(uintx minimum_eden_size) {
+void DefNewGeneration::compute_space_boundaries(uintx minimum_eden_size,
-uintx alignment = GenCollectedHeap::heap()->collector_policy()->min_alignment();
+bool clear_space,
+bool mangle_space) {
+uintx alignment =
+GenCollectedHeap::heap()->collector_policy()->min_alignment();
+// If the spaces are being cleared (only done at heap initialization
+// currently), the survivor spaces need not be empty.
+// Otherwise, no care is taken for used areas in the survivor spaces
+// so check.
+assert(clear_space || (to()->is_empty() && from()->is_empty()),
+"Initialization of the survivor spaces assumes these are empty");
 // Compute sizes
 uintx size = _virtual_space.committed_size();
 uintx survivor_size = compute_survivor_size(size, alignment);
 uintx eden_size = size - (2*survivor_size);
 MemRegion edenMR((HeapWord*)eden_start, (HeapWord*)from_start);
 MemRegion fromMR((HeapWord*)from_start, (HeapWord*)to_start);
 MemRegion toMR  ((HeapWord*)to_start, (HeapWord*)to_end);
-eden()->initialize(edenMR, (minimum_eden_size == 0));
+// A minimum eden size implies that there is a part of eden that
-// If minumum_eden_size != 0, we will not have cleared any
+// is being used and that affects the initialization of any
+// newly formed eden.
+bool live_in_eden = minimum_eden_size > 0;
+// If not clearing the spaces, do some checking to verify that
+// the space are already mangled.
+if (!clear_space) {
+// Must check mangling before the spaces are reshaped.  Otherwise,
+// the bottom or end of one space may have moved into another
+// a failure of the check may not correctly indicate which space
+// is not properly mangled.
+if (ZapUnusedHeapArea) {
+HeapWord* limit = (HeapWord*) _virtual_space.high();
+eden()->check_mangled_unused_area(limit);
+from()->check_mangled_unused_area(limit);
+to()->check_mangled_unused_area(limit);
+}
+}
+// Reset the spaces for their new regions.
+eden()->initialize(edenMR,
+clear_space && !live_in_eden,
+SpaceDecorator::Mangle);
+// If clear_space and live_in_eden, we will not have cleared any
 // portion of eden above its top. This can cause newly
 // expanded space not to be mangled if using ZapUnusedHeapArea.
 // We explicitly do such mangling here.
-if (ZapUnusedHeapArea && (minimum_eden_size != 0)) {
+if (ZapUnusedHeapArea && clear_space && live_in_eden && mangle_space) {
 eden()->mangle_unused_area();
 }
-from()->initialize(fromMR, true);
+from()->initialize(fromMR, clear_space, mangle_space);
-to()->initialize(toMR  , true);
+to()->initialize(toMR, clear_space, mangle_space);
+// Set next compaction spaces.
 eden()->set_next_compaction_space(from());
 // The to-space is normally empty before a compaction so need
 // not be considered.  The exception is during promotion
 // failure handling when to-space can contain live objects.
 from()->set_next_compaction_space(NULL);
 }
 }
 bool DefNewGeneration::expand(size_t bytes) {
 MutexLocker x(ExpandHeap_lock);
+HeapWord* prev_high = (HeapWord*) _virtual_space.high();
 bool success = _virtual_space.expand_by(bytes);
+if (success && ZapUnusedHeapArea) {
+// Mangle newly committed space immediately because it
+// can be done here more simply that after the new
+// spaces have been computed.
+HeapWord* new_high = (HeapWord*) _virtual_space.high();
+MemRegion mangle_region(prev_high, new_high);
+SpaceMangler::mangle_region(mangle_region);
+}
 // Do not attempt an expand-to-the reserve size.  The
 // request should properly observe the maximum size of
 // the generation so an expand-to-reserve should be
 // unnecessary.  Also a second call to expand-to-reserve
 // For example if the first expand fail for unknown reasons,
 // but the second succeeds and expands the heap to its maximum
 // value.
 if (GC_locker::is_active()) {
 if (PrintGC && Verbose) {
-gclog_or_tty->print_cr("Garbage collection disabled, expanded heap instead");
+gclog_or_tty->print_cr("Garbage collection disabled, "
+"expanded heap instead");
 }
 }
 return success;
 }
 assert(change % alignment == 0, "just checking");
 _virtual_space.shrink_by(change);
 changed = true;
 }
 if (changed) {
-compute_space_boundaries(eden()->used());
+// The spaces have already been mangled at this point but
-MemRegion cmr((HeapWord*)_virtual_space.low(), (HeapWord*)_virtual_space.high());
+// may not have been cleared (set top = bottom) and should be.
+// Mangling was done when the heap was being expanded.
+compute_space_boundaries(eden()->used(),
+SpaceDecorator::Clear,
+SpaceDecorator::DontMangle);
+MemRegion cmr((HeapWord*)_virtual_space.low(),
+(HeapWord*)_virtual_space.high());
 Universe::heap()->barrier_set()->resize_covered_region(cmr);
 if (Verbose && PrintGC) {
 size_t new_size_after  = _virtual_space.committed_size();
 size_t eden_size_after = eden()->capacity();
 size_t survivor_size_after = from()->capacity();
-gclog_or_tty->print("New generation size " SIZE_FORMAT "K->" SIZE_FORMAT "K [eden="
+gclog_or_tty->print("New generation size " SIZE_FORMAT "K->"
+SIZE_FORMAT "K [eden="
 SIZE_FORMAT "K,survivor=" SIZE_FORMAT "K]",
-new_size_before/K, new_size_after/K, eden_size_after/K, survivor_size_after/K);
+new_size_before/K, new_size_after/K,
+eden_size_after/K, survivor_size_after/K);
 if (WizardMode) {
 gclog_or_tty->print("[allowed " SIZE_FORMAT "K extra for %d threads]",
 thread_increase_size/K, threads_count);
 }
 gclog_or_tty->cr();
 // These can be shared for all code paths
 IsAliveClosure is_alive(this);
 ScanWeakRefClosure scan_weak_ref(this);
 age_table()->clear();
-to()->clear();
+to()->clear(SpaceDecorator::Mangle);
 gch->rem_set()->prepare_for_younger_refs_iterate(false);
 assert(gch->no_allocs_since_save_marks(0),
 "save marks have not been newly set.");
 FastKeepAliveClosure keep_alive(this, &scan_weak_ref);
 ref_processor()->process_discovered_references(
 soft_ref_policy, &is_alive, &keep_alive, &evacuate_followers, NULL);
 if (!promotion_failed()) {
 // Swap the survivor spaces.
-eden()->clear();
+eden()->clear(SpaceDecorator::Mangle);
-from()->clear();
+from()->clear(SpaceDecorator::Mangle);
+if (ZapUnusedHeapArea) {
+// This is now done here because of the piece-meal mangling which
+// can check for valid mangling at intermediate points in the
+// collection(s).  When a minor collection fails to collect
+// sufficient space resizing of the young generation can occur
+// an redistribute the spaces in the young generation.  Mangle
+// here so that unzapped regions don't get distributed to
+// other spaces.
+to()->mangle_unused_area();
+}
 swap_spaces();
 assert(to()->is_empty(), "to space should be empty now");
 // Set the desired survivor size to half the real survivor space
 sb->next = list;
 list = sb;
 }
 }
+void DefNewGeneration::reset_scratch() {
+// If contributing scratch in to_space, mangle all of
+// to_space if ZapUnusedHeapArea.  This is needed because
+// top is not maintained while using to-space as scratch.
+if (ZapUnusedHeapArea) {
+to()->mangle_unused_area_complete();
+}
+}
 bool DefNewGeneration::collection_attempt_is_safe() {
 if (!to()->is_empty()) {
 return false;
 }
 if (_next_gen == NULL) {
 if (full) { // we seem to be running out of space
 set_should_allocate_from_space();
 }
 }
+if (ZapUnusedHeapArea) {
+eden()->check_mangled_unused_area_complete();
+from()->check_mangled_unused_area_complete();
+to()->check_mangled_unused_area_complete();
+}
 // update the generation and space performance counters
 update_counters();
 gch->collector_policy()->counters()->update_counters();
 }
+void DefNewGeneration::record_spaces_top() {
+assert(ZapUnusedHeapArea, "Not mangling unused space");
+eden()->set_top_for_allocations();
+to()->set_top_for_allocations();
+from()->set_top_for_allocations();
+}
 void DefNewGeneration::update_counters() {
 if (UsePerfData) {
 _eden_counters->update_all();
 _from_counters->update_all();

Mercurial > hg > truffle

comparison src/share/vm/memory/defNewGeneration.cpp @ 269:850fdf70db2b