graal-jvmci-8: src/share/vm/memory/space.cpp comparison

comparison src/share/vm/memory/space.cpp @ 356:1ee8caae33af

Merge

author	tonyp
date	Thu, 21 Aug 2008 23:36:31 -0400
parents	60fb9c4db4e6 850fdf70db2b
children	122d10c82f3f

comparison

equal deleted inserted replaced

-:0edda524b58c
+:1ee8caae33af
 /*
-* Copyright 1997-2006 Sun Microsystems, Inc.  All Rights Reserved.
+* Copyright 1997-2008 Sun Microsystems, Inc.  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.
 CardTableModRefBS::PrecisionStyle precision,
 HeapWord* boundary) {
 return new ContiguousSpaceDCTOC(this, cl, precision, boundary);
 }
-void Space::set_bounds(MemRegion mr) {
+void Space::initialize(MemRegion mr,
+bool clear_space,
+bool mangle_space) {
 HeapWord* bottom = mr.start();
 HeapWord* end    = mr.end();
 assert(Universe::on_page_boundary(bottom) && Universe::on_page_boundary(end),
 "invalid space boundaries");
 set_bottom(bottom);
 set_end(end);
-}
+if (clear_space) clear(mangle_space);
+}
-void Space::initialize(MemRegion mr, bool clear_space) {
-set_bounds(mr);
+void Space::clear(bool mangle_space) {
-if (clear_space) clear();
+if (ZapUnusedHeapArea && mangle_space) {
-}
+mangle_unused_area();
+}
-void Space::clear() {
+}
-if (ZapUnusedHeapArea) mangle_unused_area();
-}
+ContiguousSpace::ContiguousSpace(): CompactibleSpace(), _top(NULL),
+_concurrent_iteration_safe_limit(NULL) {
-void CompactibleSpace::initialize(MemRegion mr, bool clear_space) {
+_mangler = new GenSpaceMangler(this);
-Space::initialize(mr, false); // We'll do the clearing if there's
+}
-// clearing to be done.
-_compaction_top = bottom();
+ContiguousSpace::~ContiguousSpace() {
-_next_compaction_space = NULL;
+delete _mangler;
-if (clear_space) clear();
+}
-}
+void ContiguousSpace::initialize(MemRegion mr,
-void CompactibleSpace::clear() {
+bool clear_space,
-_compaction_top = bottom();
+bool mangle_space)
-Space::clear();
+{
-}
+CompactibleSpace::initialize(mr, clear_space, mangle_space);
+set_concurrent_iteration_safe_limit(top());
-void ContiguousSpace::initialize(MemRegion mr, bool clear_space) {
+}
-CompactibleSpace::initialize(mr, false); // We'll do the clearing if there's
-// clearing to be done.
+void ContiguousSpace::clear(bool mangle_space) {
 set_top(bottom());
 set_saved_mark();
-if (clear_space) clear();
+CompactibleSpace::clear(mangle_space);
-set_concurrent_iteration_safe_limit(top());
-}
-void ContiguousSpace::clear() {
-set_top(bottom());
-set_saved_mark();
-CompactibleSpace::clear();
 }
 bool Space::is_in(const void* p) const {
 HeapWord* b = block_start_const(p);
 return b != NULL && block_is_obj(b);
 bool ContiguousSpace::is_free_block(const HeapWord* p) const {
 return p >= _top;
 }
-void OffsetTableContigSpace::initialize(MemRegion mr, bool clear_space) {
+void OffsetTableContigSpace::clear(bool mangle_space) {
-// false ==> we'll do the clearing if there's clearing to be done.
+ContiguousSpace::clear(mangle_space);
-ContiguousSpace::initialize(mr, false);
-_offsets.zero_bottom_entry();
-_offsets.initialize_threshold();
-if (clear_space) clear();
-}
-void OffsetTableContigSpace::clear() {
-ContiguousSpace::clear();
-_offsets.zero_bottom_entry();
 _offsets.initialize_threshold();
 }
 void OffsetTableContigSpace::set_bottom(HeapWord* new_bottom) {
 Space::set_bottom(new_bottom);
 // until after the underlying offest table has been enlarged.
 _offsets.resize(pointer_delta(new_end, bottom()));
 Space::set_end(new_end);
 }
+#ifndef PRODUCT
+void ContiguousSpace::set_top_for_allocations(HeapWord* v) {
+mangler()->set_top_for_allocations(v);
+}
+void ContiguousSpace::set_top_for_allocations() {
+mangler()->set_top_for_allocations(top());
+}
+void ContiguousSpace::check_mangled_unused_area(HeapWord* limit) {
+mangler()->check_mangled_unused_area(limit);
+}
+void ContiguousSpace::check_mangled_unused_area_complete() {
+mangler()->check_mangled_unused_area_complete();
+}
+// Mangled only the unused space that has not previously
+// been mangled and that has not been allocated since being
+// mangled.
 void ContiguousSpace::mangle_unused_area() {
-// to-space is used for storing marks during mark-sweep
+mangler()->mangle_unused_area();
-mangle_region(MemRegion(top(), end()));
+}
-}
+void ContiguousSpace::mangle_unused_area_complete() {
+mangler()->mangle_unused_area_complete();
+}
 void ContiguousSpace::mangle_region(MemRegion mr) {
-debug_only(Copy::fill_to_words(mr.start(), mr.word_size(), badHeapWord));
+// Although this method uses SpaceMangler::mangle_region() which
+// is not specific to a space, the when the ContiguousSpace version
+// is called, it is always with regard to a space and this
+// bounds checking is appropriate.
+MemRegion space_mr(bottom(), end());
+assert(space_mr.contains(mr), "Mangling outside space");
+SpaceMangler::mangle_region(mr);
+}
+#endif  // NOT_PRODUCT
+void CompactibleSpace::initialize(MemRegion mr,
+bool clear_space,
+bool mangle_space) {
+Space::initialize(mr, clear_space, mangle_space);
+set_compaction_top(bottom());
+_next_compaction_space = NULL;
+}
+void CompactibleSpace::clear(bool mangle_space) {
+Space::clear(mangle_space);
+_compaction_top = bottom();
 }
 HeapWord* CompactibleSpace::forward(oop q, size_t size,
 CompactPoint* cp, HeapWord* compact_top) {
 // q is alive
 obj->set_klass_gap(0);
 obj->set_klass(SystemDictionary::object_klass());
 }
 }
-void EdenSpace::clear() {
+void EdenSpace::clear(bool mangle_space) {
-ContiguousSpace::clear();
+ContiguousSpace::clear(mangle_space);
 set_soft_end(end());
 }
 // Requires locking.
 HeapWord* EdenSpace::allocate(size_t size) {
 MemRegion mr) :
 _offsets(sharedOffsetArray, mr),
 _par_alloc_lock(Mutex::leaf, "OffsetTableContigSpace par alloc lock", true)
 {
 _offsets.set_contig_space(this);
-initialize(mr, true);
+initialize(mr, SpaceDecorator::Clear, SpaceDecorator::Mangle);
 }
 class VerifyOldOopClosure : public OopClosure {
 public:

Mercurial > hg > graal-jvmci-8

comparison src/share/vm/memory/space.cpp @ 356:1ee8caae33af