8079792: GC directory structure cleanup

Reviewed-by: brutisso, stefank, david

hotspot/src/share/vm/gc/shared/generation.cpp

@@ -0,0 +1,360 @@
+/*
+ * Copyright (c) 1997, 2015, Oracle and/or its affiliates. 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.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ *
+ */
+
+#include "precompiled.hpp"
+#include "gc/serial/genMarkSweep.hpp"
+#include "gc/shared/blockOffsetTable.inline.hpp"
+#include "gc/shared/cardTableRS.hpp"
+#include "gc/shared/collectedHeap.inline.hpp"
+#include "gc/shared/gcLocker.inline.hpp"
+#include "gc/shared/gcTimer.hpp"
+#include "gc/shared/gcTrace.hpp"
+#include "gc/shared/genCollectedHeap.hpp"
+#include "gc/shared/genOopClosures.hpp"
+#include "gc/shared/genOopClosures.inline.hpp"
+#include "gc/shared/generation.hpp"
+#include "gc/shared/space.inline.hpp"
+#include "gc/shared/spaceDecorator.hpp"
+#include "memory/allocation.inline.hpp"
+#include "oops/oop.inline.hpp"
+#include "runtime/java.hpp"
+#include "utilities/copy.hpp"
+#include "utilities/events.hpp"
+
+Generation::Generation(ReservedSpace rs, size_t initial_size, int level) :
+  _level(level),
+  _ref_processor(NULL) {
+  if (!_virtual_space.initialize(rs, initial_size)) {
+    vm_exit_during_initialization("Could not reserve enough space for "
+                    "object heap");
+  }
+  // Mangle all of the the initial generation.
+  if (ZapUnusedHeapArea) {
+    MemRegion mangle_region((HeapWord*)_virtual_space.low(),
+      (HeapWord*)_virtual_space.high());
+    SpaceMangler::mangle_region(mangle_region);
+  }
+  _reserved = MemRegion((HeapWord*)_virtual_space.low_boundary(),
+          (HeapWord*)_virtual_space.high_boundary());
+}
+
+GenerationSpec* Generation::spec() {
+  GenCollectedHeap* gch = GenCollectedHeap::heap();
+  assert(level() == 0 || level() == 1, "Bad gen level");
+  return level() == 0 ? gch->gen_policy()->young_gen_spec() : gch->gen_policy()->old_gen_spec();
+}
+
+size_t Generation::max_capacity() const {
+  return reserved().byte_size();
+}
+
+void Generation::print_heap_change(size_t prev_used) const {
+  if (PrintGCDetails && Verbose) {
+    gclog_or_tty->print(" "  SIZE_FORMAT
+                        "->" SIZE_FORMAT
+                        "("  SIZE_FORMAT ")",
+                        prev_used, used(), capacity());
+  } else {
+    gclog_or_tty->print(" "  SIZE_FORMAT "K"
+                        "->" SIZE_FORMAT "K"
+                        "("  SIZE_FORMAT "K)",
+                        prev_used / K, used() / K, capacity() / K);
+  }
+}
+
+// By default we get a single threaded default reference processor;
+// generations needing multi-threaded refs processing or discovery override this method.
+void Generation::ref_processor_init() {
+  assert(_ref_processor == NULL, "a reference processor already exists");
+  assert(!_reserved.is_empty(), "empty generation?");
+  _ref_processor = new ReferenceProcessor(_reserved);    // a vanilla reference processor
+  if (_ref_processor == NULL) {
+    vm_exit_during_initialization("Could not allocate ReferenceProcessor object");
+  }
+}
+
+void Generation::print() const { print_on(tty); }
+
+void Generation::print_on(outputStream* st)  const {
+  st->print(" %-20s", name());
+  st->print(" total " SIZE_FORMAT "K, used " SIZE_FORMAT "K",
+             capacity()/K, used()/K);
+  st->print_cr(" [" INTPTR_FORMAT ", " INTPTR_FORMAT ", " INTPTR_FORMAT ")",
+              p2i(_virtual_space.low_boundary()),
+              p2i(_virtual_space.high()),
+              p2i(_virtual_space.high_boundary()));
+}
+
+void Generation::print_summary_info() { print_summary_info_on(tty); }
+
+void Generation::print_summary_info_on(outputStream* st) {
+  StatRecord* sr = stat_record();
+  double time = sr->accumulated_time.seconds();
+  st->print_cr("[Accumulated GC generation %d time %3.7f secs, "
+               "%d GC's, avg GC time %3.7f]",
+               level(), time, sr->invocations,
+               sr->invocations > 0 ? time / sr->invocations : 0.0);
+}
+
+// Utility iterator classes
+
+class GenerationIsInReservedClosure : public SpaceClosure {
+ public:
+  const void* _p;
+  Space* sp;
+  virtual void do_space(Space* s) {
+    if (sp == NULL) {
+      if (s->is_in_reserved(_p)) sp = s;
+    }
+  }
+  GenerationIsInReservedClosure(const void* p) : _p(p), sp(NULL) {}
+};
+
+class GenerationIsInClosure : public SpaceClosure {
+ public:
+  const void* _p;
+  Space* sp;
+  virtual void do_space(Space* s) {
+    if (sp == NULL) {
+      if (s->is_in(_p)) sp = s;
+    }
+  }
+  GenerationIsInClosure(const void* p) : _p(p), sp(NULL) {}
+};
+
+bool Generation::is_in(const void* p) const {
+  GenerationIsInClosure blk(p);
+  ((Generation*)this)->space_iterate(&blk);
+  return blk.sp != NULL;
+}
+
+Generation* Generation::next_gen() const {
+  GenCollectedHeap* gch = GenCollectedHeap::heap();
+  if (level() == 0) {
+    return gch->old_gen();
+  } else {
+    return NULL;
+  }
+}
+
+size_t Generation::max_contiguous_available() const {
+  // The largest number of contiguous free words in this or any higher generation.
+  size_t max = 0;
+  for (const Generation* gen = this; gen != NULL; gen = gen->next_gen()) {
+    size_t avail = gen->contiguous_available();
+    if (avail > max) {
+      max = avail;
+    }
+  }
+  return max;
+}
+
+bool Generation::promotion_attempt_is_safe(size_t max_promotion_in_bytes) const {
+  size_t available = max_contiguous_available();
+  bool   res = (available >= max_promotion_in_bytes);
+  if (PrintGC && Verbose) {
+    gclog_or_tty->print_cr(
+      "Generation: promo attempt is%s safe: available("SIZE_FORMAT") %s max_promo("SIZE_FORMAT")",
+      res? "":" not", available, res? ">=":"<",
+      max_promotion_in_bytes);
+  }
+  return res;
+}
+
+// Ignores "ref" and calls allocate().
+oop Generation::promote(oop obj, size_t obj_size) {
+  assert(obj_size == (size_t)obj->size(), "bad obj_size passed in");
+
+#ifndef PRODUCT
+  if (GenCollectedHeap::heap()->promotion_should_fail()) {
+    return NULL;
+  }
+#endif  // #ifndef PRODUCT
+
+  HeapWord* result = allocate(obj_size, false);
+  if (result != NULL) {
+    Copy::aligned_disjoint_words((HeapWord*)obj, result, obj_size);
+    return oop(result);
+  } else {
+    GenCollectedHeap* gch = GenCollectedHeap::heap();
+    return gch->handle_failed_promotion(this, obj, obj_size);
+  }
+}
+
+oop Generation::par_promote(int thread_num,
+                            oop obj, markOop m, size_t word_sz) {
+  // Could do a bad general impl here that gets a lock.  But no.
+  ShouldNotCallThis();
+  return NULL;
+}
+
+Space* Generation::space_containing(const void* p) const {
+  GenerationIsInReservedClosure blk(p);
+  // Cast away const
+  ((Generation*)this)->space_iterate(&blk);
+  return blk.sp;
+}
+
+// Some of these are mediocre general implementations.  Should be
+// overridden to get better performance.
+
+class GenerationBlockStartClosure : public SpaceClosure {
+ public:
+  const void* _p;
+  HeapWord* _start;
+  virtual void do_space(Space* s) {
+    if (_start == NULL && s->is_in_reserved(_p)) {
+      _start = s->block_start(_p);
+    }
+  }
+  GenerationBlockStartClosure(const void* p) { _p = p; _start = NULL; }
+};
+
+HeapWord* Generation::block_start(const void* p) const {
+  GenerationBlockStartClosure blk(p);
+  // Cast away const
+  ((Generation*)this)->space_iterate(&blk);
+  return blk._start;
+}
+
+class GenerationBlockSizeClosure : public SpaceClosure {
+ public:
+  const HeapWord* _p;
+  size_t size;
+  virtual void do_space(Space* s) {
+    if (size == 0 && s->is_in_reserved(_p)) {
+      size = s->block_size(_p);
+    }
+  }
+  GenerationBlockSizeClosure(const HeapWord* p) { _p = p; size = 0; }
+};
+
+size_t Generation::block_size(const HeapWord* p) const {
+  GenerationBlockSizeClosure blk(p);
+  // Cast away const
+  ((Generation*)this)->space_iterate(&blk);
+  assert(blk.size > 0, "seems reasonable");
+  return blk.size;
+}
+
+class GenerationBlockIsObjClosure : public SpaceClosure {
+ public:
+  const HeapWord* _p;
+  bool is_obj;
+  virtual void do_space(Space* s) {
+    if (!is_obj && s->is_in_reserved(_p)) {
+      is_obj |= s->block_is_obj(_p);
+    }
+  }
+  GenerationBlockIsObjClosure(const HeapWord* p) { _p = p; is_obj = false; }
+};
+
+bool Generation::block_is_obj(const HeapWord* p) const {
+  GenerationBlockIsObjClosure blk(p);
+  // Cast away const
+  ((Generation*)this)->space_iterate(&blk);
+  return blk.is_obj;
+}
+
+class GenerationOopIterateClosure : public SpaceClosure {
+ public:
+  ExtendedOopClosure* _cl;
+  virtual void do_space(Space* s) {
+    s->oop_iterate(_cl);
+  }
+  GenerationOopIterateClosure(ExtendedOopClosure* cl) :
+    _cl(cl) {}
+};
+
+void Generation::oop_iterate(ExtendedOopClosure* cl) {
+  GenerationOopIterateClosure blk(cl);
+  space_iterate(&blk);
+}
+
+void Generation::younger_refs_in_space_iterate(Space* sp,
+                                               OopsInGenClosure* cl) {
+  GenRemSet* rs = GenCollectedHeap::heap()->rem_set();
+  rs->younger_refs_in_space_iterate(sp, cl);
+}
+
+class GenerationObjIterateClosure : public SpaceClosure {
+ private:
+  ObjectClosure* _cl;
+ public:
+  virtual void do_space(Space* s) {
+    s->object_iterate(_cl);
+  }
+  GenerationObjIterateClosure(ObjectClosure* cl) : _cl(cl) {}
+};
+
+void Generation::object_iterate(ObjectClosure* cl) {
+  GenerationObjIterateClosure blk(cl);
+  space_iterate(&blk);
+}
+
+class GenerationSafeObjIterateClosure : public SpaceClosure {
+ private:
+  ObjectClosure* _cl;
+ public:
+  virtual void do_space(Space* s) {
+    s->safe_object_iterate(_cl);
+  }
+  GenerationSafeObjIterateClosure(ObjectClosure* cl) : _cl(cl) {}
+};
+
+void Generation::safe_object_iterate(ObjectClosure* cl) {
+  GenerationSafeObjIterateClosure blk(cl);
+  space_iterate(&blk);
+}
+
+void Generation::prepare_for_compaction(CompactPoint* cp) {
+  // Generic implementation, can be specialized
+  CompactibleSpace* space = first_compaction_space();
+  while (space != NULL) {
+    space->prepare_for_compaction(cp);
+    space = space->next_compaction_space();
+  }
+}
+
+class AdjustPointersClosure: public SpaceClosure {
+ public:
+  void do_space(Space* sp) {
+    sp->adjust_pointers();
+  }
+};
+
+void Generation::adjust_pointers() {
+  // Note that this is done over all spaces, not just the compactible
+  // ones.
+  AdjustPointersClosure blk;
+  space_iterate(&blk, true);
+}
+
+void Generation::compact() {
+  CompactibleSpace* sp = first_compaction_space();
+  while (sp != NULL) {
+    sp->compact();
+    sp = sp->next_compaction_space();
+  }
+}