1 files changed, 48 insertions, 55 deletions

diff --git a/src/share/vm/memory/defNewGeneration.inline.hpp b/src/share/vm/memory/defNewGeneration.inline.hpp
index dffc86b5a..23a969845 100644
--- a/src/share/vm/memory/defNewGeneration.inline.hpp
+++ b/src/share/vm/memory/defNewGeneration.inline.hpp
@@ -22,67 +22,60 @@
  *
  */
 
-CompactibleSpace* DefNewGeneration::first_compaction_space() const {
-  return eden();
-}
+// Methods of protected closure types
 
-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::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");
   }
-  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
 
-  // 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);
-  }
-  return result;
-}
+  _cl->do_oop_nv(p);
 
-HeapWord* DefNewGeneration::par_allocate(size_t word_size,
-                                         bool is_tlab) {
-  return eden()->par_allocate(word_size);
+  // 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);
+  }
 }
 
-void DefNewGeneration::gc_prologue(bool full) {
-  // Ensure that _end and _soft_end are the same in eden space.
-  eden()->set_soft_end(eden()->end());
-}
+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");
+  }
+#endif // ASSERT
 
-size_t DefNewGeneration::tlab_capacity() const {
-  return eden()->capacity();
-}
+  _cl->do_oop_nv(p);
 
-size_t DefNewGeneration::unsafe_max_tlab_alloc() const {
-  return unsafe_max_alloc_nogc();
+  // 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);
+  }
 }