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

comparison src/share/vm/memory/space.cpp @ 20804:7848fc12602b

Merge with jdk8u40-b25

author	Gilles Duboscq <gilles.m.duboscq@oracle.com>
date	Tue, 07 Apr 2015 14:58:49 +0200
parents	52b4284cb496 ee019285a52c
children

comparison

equal deleted inserted replaced

-:84105dcdb05b
+:7848fc12602b
 #include "classfile/systemDictionary.hpp"
 #include "classfile/vmSymbols.hpp"
 #include "gc_implementation/shared/liveRange.hpp"
 #include "gc_implementation/shared/markSweep.hpp"
 #include "gc_implementation/shared/spaceDecorator.hpp"
+#include "gc_interface/collectedHeap.inline.hpp"
 #include "memory/blockOffsetTable.inline.hpp"
 #include "memory/defNewGeneration.hpp"
 #include "memory/genCollectedHeap.hpp"
 #include "memory/space.hpp"
 #include "memory/space.inline.hpp"
 #include "memory/universe.inline.hpp"
 #include "oops/oop.inline.hpp"
 #include "oops/oop.inline2.hpp"
 #include "runtime/java.hpp"
+#include "runtime/prefetch.inline.hpp"
+#include "runtime/orderAccess.inline.hpp"
 #include "runtime/safepoint.hpp"
 #include "utilities/copy.hpp"
 #include "utilities/globalDefinitions.hpp"
 #include "utilities/macros.hpp"
-void SpaceMemRegionOopsIterClosure::do_oop(oop* p)       { SpaceMemRegionOopsIterClosure::do_oop_work(p); }
-void SpaceMemRegionOopsIterClosure::do_oop(narrowOop* p) { SpaceMemRegionOopsIterClosure::do_oop_work(p); }
 PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
 HeapWord* DirtyCardToOopClosure::get_actual_top(HeapWord* top,
 HeapWord* top_obj) {
 set_top(bottom());
 set_saved_mark();
 CompactibleSpace::clear(mangle_space);
 }
-bool ContiguousSpace::is_in(const void* p) const {
-return _bottom <= p && p < _top;
-}
 bool ContiguousSpace::is_free_block(const HeapWord* p) const {
 return p >= _top;
 }
 void OffsetTableContigSpace::clear(bool mangle_space) {
 void Space::oop_iterate(ExtendedOopClosure* blk) {
 ObjectToOopClosure blk2(blk);
 object_iterate(&blk2);
 }
-HeapWord* Space::object_iterate_careful(ObjectClosureCareful* cl) {
-guarantee(false, "NYI");
-return bottom();
-}
-HeapWord* Space::object_iterate_careful_m(MemRegion mr,
-ObjectClosureCareful* cl) {
-guarantee(false, "NYI");
-return bottom();
-}
-void Space::object_iterate_mem(MemRegion mr, UpwardsObjectClosure* cl) {
-assert(!mr.is_empty(), "Should be non-empty");
-// We use MemRegion(bottom(), end()) rather than used_region() below
-// because the two are not necessarily equal for some kinds of
-// spaces, in particular, certain kinds of free list spaces.
-// We could use the more complicated but more precise:
-// MemRegion(used_region().start(), round_to(used_region().end(), CardSize))
-// but the slight imprecision seems acceptable in the assertion check.
-assert(MemRegion(bottom(), end()).contains(mr),
-"Should be within used space");
-HeapWord* prev = cl->previous();   // max address from last time
-if (prev >= mr.end()) { // nothing to do
-return;
-}
-// This assert will not work when we go from cms space to perm
-// space, and use same closure. Easy fix deferred for later. XXX YSR
-// assert(prev == NULL || contains(prev), "Should be within space");
-bool last_was_obj_array = false;
-HeapWord *blk_start_addr, *region_start_addr;
-if (prev > mr.start()) {
-region_start_addr = prev;
-blk_start_addr    = prev;
-// The previous invocation may have pushed "prev" beyond the
-// last allocated block yet there may be still be blocks
-// in this region due to a particular coalescing policy.
-// Relax the assertion so that the case where the unallocated
-// block is maintained and "prev" is beyond the unallocated
-// block does not cause the assertion to fire.
-assert((BlockOffsetArrayUseUnallocatedBlock &&
-(!is_in(prev))) ||
-(blk_start_addr == block_start(region_start_addr)), "invariant");
-} else {
-region_start_addr = mr.start();
-blk_start_addr    = block_start(region_start_addr);
-}
-HeapWord* region_end_addr = mr.end();
-MemRegion derived_mr(region_start_addr, region_end_addr);
-while (blk_start_addr < region_end_addr) {
-const size_t size = block_size(blk_start_addr);
-if (block_is_obj(blk_start_addr)) {
-last_was_obj_array = cl->do_object_bm(oop(blk_start_addr), derived_mr);
-} else {
-last_was_obj_array = false;
-}
-blk_start_addr += size;
-}
-if (!last_was_obj_array) {
-assert((bottom() <= blk_start_addr) && (blk_start_addr <= end()),
-"Should be within (closed) used space");
-assert(blk_start_addr > prev, "Invariant");
-cl->set_previous(blk_start_addr); // min address for next time
-}
-}
 bool Space::obj_is_alive(const HeapWord* p) const {
 assert (block_is_obj(p), "The address should point to an object");
 return true;
-}
-void ContiguousSpace::object_iterate_mem(MemRegion mr, UpwardsObjectClosure* cl) {
-assert(!mr.is_empty(), "Should be non-empty");
-assert(used_region().contains(mr), "Should be within used space");
-HeapWord* prev = cl->previous();   // max address from last time
-if (prev >= mr.end()) { // nothing to do
-return;
-}
-// See comment above (in more general method above) in case you
-// happen to use this method.
-assert(prev == NULL || is_in_reserved(prev), "Should be within space");
-bool last_was_obj_array = false;
-HeapWord *obj_start_addr, *region_start_addr;
-if (prev > mr.start()) {
-region_start_addr = prev;
-obj_start_addr    = prev;
-assert(obj_start_addr == block_start(region_start_addr), "invariant");
-} else {
-region_start_addr = mr.start();
-obj_start_addr    = block_start(region_start_addr);
-}
-HeapWord* region_end_addr = mr.end();
-MemRegion derived_mr(region_start_addr, region_end_addr);
-while (obj_start_addr < region_end_addr) {
-oop obj = oop(obj_start_addr);
-const size_t size = obj->size();
-last_was_obj_array = cl->do_object_bm(obj, derived_mr);
-obj_start_addr += size;
-}
-if (!last_was_obj_array) {
-assert((bottom() <= obj_start_addr)  && (obj_start_addr <= end()),
-"Should be within (closed) used space");
-assert(obj_start_addr > prev, "Invariant");
-cl->set_previous(obj_start_addr); // min address for next time
-}
 }
 #if INCLUDE_ALL_GCS
 #define ContigSpace_PAR_OOP_ITERATE_DEFN(OopClosureType, nv_suffix)         \
 \
 HeapWord* t = top();
 // Could call objects iterate, but this is easier.
 while (obj_addr < t) {
 obj_addr += oop(obj_addr)->oop_iterate(blk);
 }
-}
-void ContiguousSpace::oop_iterate(MemRegion mr, ExtendedOopClosure* blk) {
-if (is_empty()) {
-return;
-}
-MemRegion cur = MemRegion(bottom(), top());
-mr = mr.intersection(cur);
-if (mr.is_empty()) {
-return;
-}
-if (mr.equals(cur)) {
-oop_iterate(blk);
-return;
-}
-assert(mr.end() <= top(), "just took an intersection above");
-HeapWord* obj_addr = block_start(mr.start());
-HeapWord* t = mr.end();
-// Handle first object specially.
-oop obj = oop(obj_addr);
-SpaceMemRegionOopsIterClosure smr_blk(blk, mr);
-obj_addr += obj->oop_iterate(&smr_blk);
-while (obj_addr < t) {
-oop obj = oop(obj_addr);
-assert(obj->is_oop(), "expected an oop");
-obj_addr += obj->size();
-// If "obj_addr" is not greater than top, then the
-// entire object "obj" is within the region.
-if (obj_addr <= t) {
-obj->oop_iterate(blk);
-} else {
-// "obj" extends beyond end of region
-obj->oop_iterate(&smr_blk);
-break;
-}
-};
 }
 void ContiguousSpace::object_iterate(ObjectClosure* blk) {
 if (is_empty()) return;
 WaterMark bm = bottom_mark();
 }
 // This version requires locking.
 inline HeapWord* ContiguousSpace::allocate_impl(size_t size,
 HeapWord* const end_value) {
-// In G1 there are places where a GC worker can allocates into a
-// region using this serial allocation code without being prone to a
-// race with other GC workers (we ensure that no other GC worker can
-// access the same region at the same time). So the assert below is
-// too strong in the case of G1.
 assert(Heap_lock->owned_by_self() ||
-(SafepointSynchronize::is_at_safepoint() &&
+(SafepointSynchronize::is_at_safepoint() && Thread::current()->is_VM_thread()),
-(Thread::current()->is_VM_thread() || UseG1GC)),
 "not locked");
 HeapWord* obj = top();
 if (pointer_delta(end_value, obj) >= size) {
 HeapWord* new_top = obj + size;
 set_top(new_top);
 }
 } else {
 return NULL;
 }
 } while (true);
+}
+HeapWord* ContiguousSpace::allocate_aligned(size_t size) {
+assert(Heap_lock->owned_by_self() || (SafepointSynchronize::is_at_safepoint() && Thread::current()->is_VM_thread()), "not locked");
+HeapWord* end_value = end();
+HeapWord* obj = CollectedHeap::align_allocation_or_fail(top(), end_value, SurvivorAlignmentInBytes);
+if (obj == NULL) {
+return NULL;
+}
+if (pointer_delta(end_value, obj) >= size) {
+HeapWord* new_top = obj + size;
+set_top(new_top);
+assert(is_ptr_aligned(obj, SurvivorAlignmentInBytes) && is_aligned(new_top),
+"checking alignment");
+return obj;
+} else {
+set_top(obj);
+return NULL;
+}
 }
 // Requires locking.
 HeapWord* ContiguousSpace::allocate(size_t size) {
 return allocate_impl(size, end());

Mercurial > hg > graal-jvmci-8

comparison src/share/vm/memory/space.cpp @ 20804:7848fc12602b