((cite: hotspot/src/share/vm/memory/space.hpp))
    // A space is an abstraction for the "storage units" backing
    // up the generation abstraction. It includes specific
    // implementations for keeping track of free and used space,
    // for iterating over objects and free blocks, etc.

    ((cite: hotspot/src/share/vm/memory/space.hpp))
    // Here's the Space hierarchy:
    //
    // - Space               -- an asbtract base class describing a heap area
    //   - CompactibleSpace  -- a space supporting compaction
    //     - CompactibleFreeListSpace -- (used for CMS generation)
    //     - ContiguousSpace -- a compactible space in which all free space
    //                          is contiguous
    //       - EdenSpace     -- contiguous space used as nursery
    //         - ConcEdenSpace -- contiguous space with a 'soft end safe' allocation
    //       - OffsetTableContigSpace -- contiguous space with a block offset array
    //                          that allows "fast" block_start calls
    //         - TenuredSpace -- (used for TenuredGeneration)
    //         - ContigPermSpace -- an offset table contiguous space for perm gen

    ((cite: hotspot/src/share/vm/memory/space.hpp))
    // A Space describes a heap area. Class Space is an abstract
    // base class.
    //
    // Space supports allocation, size computation and GC support is provided.
    //
    // Invariant: bottom() and end() are on page_size boundaries and
    // bottom() <= top() <= end()
    // top() is inclusive and end() is exclusive.

    class Space: public CHeapObj {

    ((cite: hotspot/src/share/vm/memory/space.hpp))
      HeapWord* _bottom;
      HeapWord* _end;

    ((cite: hotspot/src/share/vm/memory/space.hpp))
    // A space that supports compaction operations.  This is usually, but not
    // necessarily, a space that is normally contiguous.  But, for example, a
    // free-list-based space whose normal collection is a mark-sweep without
    // compaction could still support compaction in full GC's.

    class CompactibleSpace: public Space {

    ((cite: hotspot/src/share/vm/memory/space.hpp))
      // MarkSweep support phase2

      // Start the process of compaction of the current space: compute
      // post-compaction addresses, and insert forwarding pointers.  The fields
      // "cp->gen" and "cp->compaction_space" are the generation and space into
      // which we are currently compacting.  This call updates "cp" as necessary,
      // and leaves the "compaction_top" of the final value of
      // "cp->compaction_space" up-to-date.  Offset tables may be updated in
      // this phase as if the final copy had occurred; if so, "cp->threshold"
      // indicates when the next such action should be taken.
      virtual void prepare_for_compaction(CompactPoint* cp);
      // MarkSweep support phase3
      virtual void adjust_pointers();
      // MarkSweep support phase4
      virtual void compact();

    ((cite: hotspot/src/share/vm/memory/space.hpp))
    // A space in which the free area is contiguous.  It therefore supports
    // faster allocation, and compaction.
    class ContiguousSpace: public CompactibleSpace {

    ((cite: hotspot/src/share/vm/memory/defNewGeneration.cpp))
    DefNewGeneration::DefNewGeneration(ReservedSpace rs,
                                       size_t initial_size,
                                       int level,
                                       const char* policy)
    ...
    {
    ...
      _from_space = new ContiguousSpace();
      _to_space   = new ContiguousSpace();

    ((cite: hotspot/src/share/vm/memory/space.hpp))
      HeapWord* _top;

    ((cite: hotspot/src/share/vm/memory/space.hpp))
    // Class EdenSpace describes eden-space in new generation.
    ...
    class EdenSpace : public ContiguousSpace {

    ((cite: hotspot/src/share/vm/memory/defNewGeneration.cpp))
    DefNewGeneration::DefNewGeneration(ReservedSpace rs,
                                       size_t initial_size,
                                       int level,
                                       const char* policy)
    ...
    {
    ...
      if (GenCollectedHeap::heap()->collector_policy()->has_soft_ended_eden()) {
        _eden_space = new ConcEdenSpace(this);
      } else {
        _eden_space = new EdenSpace(this);
      }

    ((cite: hotspot/src/share/vm/memory/space.hpp))
    // Class ConcEdenSpace extends EdenSpace for the sake of safe
    // allocation while soft-end is being modified concurrently

    class ConcEdenSpace : public EdenSpace {

    ((cite: hotspot/src/share/vm/memory/defNewGeneration.cpp))
    DefNewGeneration::DefNewGeneration(ReservedSpace rs,
                                       size_t initial_size,
                                       int level,
                                       const char* policy)
    ...
    {
    ...
      if (GenCollectedHeap::heap()->collector_policy()->has_soft_ended_eden()) {
        _eden_space = new ConcEdenSpace(this);
      } else {
        _eden_space = new EdenSpace(this);
      }

    ((cite: hotspot/src/share/vm/runtime/arguments.cpp))
        // -Xincgc: i-CMS
        } else if (match_option(option, "-Xincgc", &tail)) {
          FLAG_SET_CMDLINE(bool, UseConcMarkSweepGC, true);
          FLAG_SET_CMDLINE(bool, CMSIncrementalMode, true);

    ((cite: hotspot/src/share/vm/memory/space.hpp))
    // A ContigSpace that Supports an efficient "block_start" operation via
    // a BlockOffsetArray (whose BlockOffsetSharedArray may be shared with
    // other spaces.)  This is the abstract base class for old generation
    // (tenured, perm) spaces.

    class OffsetTableContigSpace: public ContiguousSpace {

    ((cite: hotspot/src/share/vm/memory/compactingPermGenGen.cpp))
    CompactingPermGenGen::CompactingPermGenGen(ReservedSpace rs,
                                               ReservedSpace shared_rs,
                                               size_t initial_byte_size,
                                               int level, GenRemSet* remset,
                                               ContiguousSpace* space,
                                               PermanentGenerationSpec* spec_) :
    ...
      // Allocate shared spaces
      if (spec()->enable_shared_spaces()) {
    ...
        _ro_space = new OffsetTableContigSpace(_ro_bts,
                      MemRegion(readonly_bottom, readonly_end));
    ...
        _rw_space = new OffsetTableContigSpace(_rw_bts,
                      MemRegion(readwrite_bottom, readwrite_end));

    ((cite: hotspot/src/share/vm/memory/space.hpp))
    // Class TenuredSpace is used by TenuredGeneration

    class TenuredSpace: public OffsetTableContigSpace {

    ((cite: hotspot/src/share/vm/memory/tenuredGeneration.cpp))
    TenuredGeneration::TenuredGeneration(ReservedSpace rs,
                                         size_t initial_byte_size, int level,
                                         GenRemSet* remset) :
    ...
    {
    ...
      _the_space  = new TenuredSpace(_bts, MemRegion(bottom, end));

    ((cite: hotspot/src/share/vm/memory/space.hpp))
    // Class ContigPermSpace is used by CompactingPermGen

    class ContigPermSpace: public OffsetTableContigSpace {

    ((cite: hotspot/src/share/vm/memory/compactingPermGenGen.cpp))
    CompactingPermGenGen::CompactingPermGenGen(ReservedSpace rs,
                                               ReservedSpace shared_rs,
                                               size_t initial_byte_size,
                                               int level, GenRemSet* remset,
                                               ContiguousSpace* space,
                                               PermanentGenerationSpec* spec_) :
    ...
      // Allocate the unshared (default) space.
      _the_space = new ContigPermSpace(_bts,
                   MemRegion(unshared_bottom, heap_word_size(initial_byte_size)));

    ((cite: hotspot/src/share/vm/memory/space.hpp))
    // An oop closure that is circumscribed by a filtering memory region.
    class SpaceMemRegionOopsIterClosure: public OopClosure {

    ((cite: hotspot/src/share/vm/memory/space.hpp))
      SpaceMemRegionOopsIterClosure(OopClosure* cl, MemRegion mr):

    ((cite: hotspot/src/share/vm/memory/space.cpp))
    void SpaceMemRegionOopsIterClosure::do_oop(oop* p)       { SpaceMemRegionOopsIterClosure::do_oop_work(p); }
    void SpaceMemRegionOopsIterClosure::do_oop(narrowOop* p) { SpaceMemRegionOopsIterClosure::do_oop_work(p); }

    ((cite: hotspot/src/share/vm/memory/space.hpp))
    // A MemRegionClosure (ResourceObj) whose "do_MemRegion" function applies an
    // OopClosure to (the addresses of) all the ref-containing fields that could
    // be modified by virtue of the given MemRegion being dirty. (Note that
    // because of the imprecise nature of the write barrier, this may iterate
    // over oops beyond the region.)
    // This base type for dirty card to oop closures handles memory regions
    // in non-contiguous spaces with no boundaries, and should be sub-classed
    // to support other space types. See ContiguousDCTOC for a sub-class
    // that works with ContiguousSpaces.

    class DirtyCardToOopClosure: public MemRegionClosureRO {

    ((cite: hotspot/src/share/vm/memory/space.hpp))
    // A structure to represent a point at which objects are being copied
    // during compaction.
    class CompactPoint : public StackObj {

    ((cite: hotspot/src/share/vm/memory/space.hpp))
    public:
      Generation* gen;
      CompactibleSpace* space;
      HeapWord* threshold;

    ((cite: hotspot/src/share/vm/memory/space.hpp))
    // A dirty card to oop closure that does filtering.
    // It knows how to filter out objects that are outside of the _boundary.
    class Filtering_DCTOC : public DirtyCardToOopClosure {

    ((cite: hotspot/src/share/vm/memory/space.hpp))
      virtual void walk_mem_region_with_cl(MemRegion mr,
                                           HeapWord* bottom, HeapWord* top,
                                           OopClosure* cl) = 0;
      virtual void walk_mem_region_with_cl(MemRegion mr,
                                           HeapWord* bottom, HeapWord* top,
                                           FilteringClosure* cl) = 0;

    ((cite: hotspot/src/share/vm/memory/space.hpp))
    // A dirty card to oop closure for contiguous spaces
    // (ContiguousSpace and sub-classes).
    // It is a FilteringClosure, as defined above, and it knows:
    //
    // 1. That the actual top of any area in a memory region
    //    contained by the space is bounded by the end of the contiguous
    //    region of the space.
    // 2. That the space is really made up of objects and not just
    //    blocks.

    class ContiguousSpaceDCTOC : public Filtering_DCTOC {

    ((cite: hotspot/src/share/vm/memory/space.cpp))
    class VerifyOldOopClosure : public OopClosure {

    ((cite: hotspot/src/share/vm/memory/space.cpp))
    void OffsetTableContigSpace::verify(bool allow_dirty) const {
    ...
      VerifyOldOopClosure blk;      // Does this do anything?
      blk._allow_dirty = allow_dirty;
    ...
          blk._the_obj = oop(p);
          oop(p)->oop_iterate(&blk);