Mercurial > hg > graal-compiler
diff src/share/vm/memory/defNewGeneration.inline.hpp @ 113:ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
Summary: Compressed oops in instances, arrays, and headers. Code contributors are coleenp, phh, never, swamyv
Reviewed-by: jmasa, kamg, acorn, tbell, kvn, rasbold
author | coleenp |
---|---|
date | Sun, 13 Apr 2008 17:43:42 -0400 |
parents | a61af66fc99e |
children | d1605aabd0a1 |
line wrap: on
line diff
--- a/src/share/vm/memory/defNewGeneration.inline.hpp Fri Apr 11 09:56:35 2008 -0400 +++ b/src/share/vm/memory/defNewGeneration.inline.hpp Sun Apr 13 17:43:42 2008 -0400 @@ -22,67 +22,60 @@ * */ -CompactibleSpace* DefNewGeneration::first_compaction_space() const { - return eden(); +// Methods of protected closure types + +template <class T> +inline void DefNewGeneration::KeepAliveClosure::do_oop_work(T* p) { +#ifdef ASSERT + { + // We never expect to see a null reference being processed + // as a weak reference. + assert (!oopDesc::is_null(*p), "expected non-null ref"); + oop obj = oopDesc::load_decode_heap_oop_not_null(p); + assert (obj->is_oop(), "expected an oop while scanning weak refs"); + } +#endif // ASSERT + + _cl->do_oop_nv(p); + + // Card marking is trickier for weak refs. + // This oop is a 'next' field which was filled in while we + // were discovering weak references. While we might not need + // to take a special action to keep this reference alive, we + // will need to dirty a card as the field was modified. + // + // Alternatively, we could create a method which iterates through + // each generation, allowing them in turn to examine the modified + // field. + // + // We could check that p is also in an older generation, but + // dirty cards in the youngest gen are never scanned, so the + // extra check probably isn't worthwhile. + if (Universe::heap()->is_in_reserved(p)) { + oop obj = oopDesc::load_decode_heap_oop_not_null(p); + _rs->inline_write_ref_field_gc(p, obj); + } } -HeapWord* DefNewGeneration::allocate(size_t word_size, - bool is_tlab) { - // This is the slow-path allocation for the DefNewGeneration. - // Most allocations are fast-path in compiled code. - // We try to allocate from the eden. If that works, we are happy. - // Note that since DefNewGeneration supports lock-free allocation, we - // have to use it here, as well. - HeapWord* result = eden()->par_allocate(word_size); - if (result != NULL) { - return result; +template <class T> +inline void DefNewGeneration::FastKeepAliveClosure::do_oop_work(T* p) { +#ifdef ASSERT + { + // We never expect to see a null reference being processed + // as a weak reference. + assert (!oopDesc::is_null(*p), "expected non-null ref"); + oop obj = oopDesc::load_decode_heap_oop_not_null(p); + assert (obj->is_oop(), "expected an oop while scanning weak refs"); } - do { - HeapWord* old_limit = eden()->soft_end(); - if (old_limit < eden()->end()) { - // Tell the next generation we reached a limit. - HeapWord* new_limit = - next_gen()->allocation_limit_reached(eden(), eden()->top(), word_size); - if (new_limit != NULL) { - Atomic::cmpxchg_ptr(new_limit, eden()->soft_end_addr(), old_limit); - } else { - assert(eden()->soft_end() == eden()->end(), - "invalid state after allocation_limit_reached returned null"); - } - } else { - // The allocation failed and the soft limit is equal to the hard limit, - // there are no reasons to do an attempt to allocate - assert(old_limit == eden()->end(), "sanity check"); - break; - } - // Try to allocate until succeeded or the soft limit can't be adjusted - result = eden()->par_allocate(word_size); - } while (result == NULL); +#endif // ASSERT + + _cl->do_oop_nv(p); - // If the eden is full and the last collection bailed out, we are running - // out of heap space, and we try to allocate the from-space, too. - // allocate_from_space can't be inlined because that would introduce a - // circular dependency at compile time. - if (result == NULL) { - result = allocate_from_space(word_size); + // Optimized for Defnew generation if it's the youngest generation: + // we set a younger_gen card if we have an older->youngest + // generation pointer. + oop obj = oopDesc::load_decode_heap_oop_not_null(p); + if (((HeapWord*)obj < _boundary) && Universe::heap()->is_in_reserved(p)) { + _rs->inline_write_ref_field_gc(p, obj); } - return result; -} - -HeapWord* DefNewGeneration::par_allocate(size_t word_size, - bool is_tlab) { - return eden()->par_allocate(word_size); } - -void DefNewGeneration::gc_prologue(bool full) { - // Ensure that _end and _soft_end are the same in eden space. - eden()->set_soft_end(eden()->end()); -} - -size_t DefNewGeneration::tlab_capacity() const { - return eden()->capacity(); -} - -size_t DefNewGeneration::unsafe_max_tlab_alloc() const { - return unsafe_max_alloc_nogc(); -}