((cite: hotspot/src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.hpp))
    // The UseParallelOldGC collector is a stop-the-world garbage collector that
    // does parts of the collection using parallel threads.  The collection includes
    // the tenured generation and the young generation.  The permanent generation is
    // collected at the same time as the other two generations but the permanent
    // generation is collect by a single GC thread.  The permanent generation is
    // collected serially because of the requirement that during the processing of a
    // klass AAA, any objects reference by AAA must already have been processed.
    // This requirement is enforced by a left (lower address) to right (higher
    // address) sliding compaction.
    //
    // There are four phases of the collection.
    //
    //      - marking phase
    //      - summary phase
    //      - compacting phase
    //      - clean up phase
    //
    // Roughly speaking these phases correspond, respectively, to
    //      - mark all the live objects
    //      - calculate the destination of each object at the end of the collection
    //      - move the objects to their destination
    //      - update some references and reinitialize some variables
    //
    // These three phases are invoked in PSParallelCompact::invoke_no_policy().  The
    // marking phase is implemented in PSParallelCompact::marking_phase() and does a
    // complete marking of the heap.  The summary phase is implemented in
    // PSParallelCompact::summary_phase().  The move and update phase is implemented
    // in PSParallelCompact::compact().
    //
    // A space that is being collected is divided into regions and with each region
    // is associated an object of type ParallelCompactData.  Each region is of a
    // fixed size and typically will contain more than 1 object and may have parts
    // of objects at the front and back of the region.
    //
    // region            -----+---------------------+----------
    // objects covered   [ AAA  )[ BBB )[ CCC   )[ DDD     )
    //
    // The marking phase does a complete marking of all live objects in the heap.
    // The marking also compiles the size of the data for all live objects covered
    // by the region.  This size includes the part of any live object spanning onto
    // the region (part of AAA if it is live) from the front, all live objects
    // contained in the region (BBB and/or CCC if they are live), and the part of
    // any live objects covered by the region that extends off the region (part of
    // DDD if it is live).  The marking phase uses multiple GC threads and marking
    // is done in a bit array of type ParMarkBitMap.  The marking of the bit map is
    // done atomically as is the accumulation of the size of the live objects
    // covered by a region.
    //
    // The summary phase calculates the total live data to the left of each region
    // XXX.  Based on that total and the bottom of the space, it can calculate the
    // starting location of the live data in XXX.  The summary phase calculates for
    // each region XXX quantites such as
    //
    //      - the amount of live data at the beginning of a region from an object
    //        entering the region.
    //      - the location of the first live data on the region
    //      - a count of the number of regions receiving live data from XXX.
    //
    // See ParallelCompactData for precise details.  The summary phase also
    // calculates the dense prefix for the compaction.  The dense prefix is a
    // portion at the beginning of the space that is not moved.  The objects in the
    // dense prefix do need to have their object references updated.  See method
    // summarize_dense_prefix().
    //
    // The summary phase is done using 1 GC thread.
    //
    // The compaction phase moves objects to their new location and updates all
    // references in the object.
    //
    // A current exception is that objects that cross a region boundary are moved
    // but do not have their references updated.  References are not updated because
    // it cannot easily be determined if the klass pointer KKK for the object AAA
    // has been updated.  KKK likely resides in a region to the left of the region
    // containing AAA.  These AAA's have there references updated at the end in a
    // clean up phase.  See the method PSParallelCompact::update_deferred_objects().
    // An alternate strategy is being investigated for this deferral of updating.
    //
    // Compaction is done on a region basis.  A region that is ready to be filled is
    // put on a ready list and GC threads take region off the list and fill them.  A
    // region is ready to be filled if it empty of live objects.  Such a region may
    // have been initially empty (only contained dead objects) or may have had all
    // its live objects copied out already.  A region that compacts into itself is
    // also ready for filling.  The ready list is initially filled with empty
    // regions and regions compacting into themselves.  There is always at least 1
    // region that can be put on the ready list.  The regions are atomically added
    // and removed from the ready list.

    class PSParallelCompact : AllStatic {

    ((cite: hotspot/src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.hpp))
    class SpaceInfo
    {

    ((cite: hotspot/src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.hpp))
    class PSParallelCompact : AllStatic {
    ...
      typedef enum {
        perm_space_id, old_space_id, eden_space_id,
        from_space_id, to_space_id, last_space_id
      } SpaceId;
    ...
      static SpaceInfo            _space_info[last_space_id];

    ((cite: hotspot/src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.hpp))
      MutableSpace*     _space;
      HeapWord*         _new_top;
      HeapWord*         _min_dense_prefix;
      HeapWord*         _dense_prefix;
      ObjectStartArray* _start_array;
      SplitInfo         _split_info;

    ((cite: hotspot/src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.hpp))
    // The SplitInfo class holds the information needed to 'split' a source region
    // so that the live data can be copied to two destination *spaces*.  Normally,
    // all the live data in a region is copied to a single destination space (e.g.,
    // everything live in a region in eden is copied entirely into the old gen).
    // However, when the heap is nearly full, all the live data in eden may not fit
    // into the old gen.  Copying only some of the regions from eden to old gen
    // requires finding a region that does not contain a partial object (i.e., no
    // live object crosses the region boundary) somewhere near the last object that
    // does fit into the old gen.  Since it's not always possible to find such a
    // region, splitting is necessary for predictable behavior.
    //
    // A region is always split at the end of the partial object.  This avoids
    // additional tests when calculating the new location of a pointer, which is a
    // very hot code path.  The partial object and everything to its left will be
    // copied to another space (call it dest_space_1).  The live data to the right
    // of the partial object will be copied either within the space itself, or to a
    // different destination space (distinct from dest_space_1).
    //
    // Split points are identified during the summary phase, when region
    // destinations are computed:  data about the split, including the
    // partial_object_size, is recorded in a SplitInfo record and the
    // partial_object_size field in the summary data is set to zero.  The zeroing is
    // possible (and necessary) since the partial object will move to a different
    // destination space than anything to its right, thus the partial object should
    // not affect the locations of any objects to its right.
    //
    // The recorded data is used during the compaction phase, but only rarely:  when
    // the partial object on the split region will be copied across a destination
    // region boundary.  This test is made once each time a region is filled, and is
    // a simple address comparison, so the overhead is negligible (see
    // PSParallelCompact::first_src_addr()).
    //
    // Notes:
    //
    // Only regions with partial objects are split; a region without a partial
    // object does not need any extra bookkeeping.
    //
    // At most one region is split per space, so the amount of data required is
    // constant.
    //
    // A region is split only when the destination space would overflow.  Once that
    // happens, the destination space is abandoned and no other data (even from
    // other source spaces) is targeted to that destination space.  Abandoning the
    // destination space may leave a somewhat large unused area at the end, if a
    // large object caused the overflow.
    //
    // Future work:
    //
    // More bookkeeping would be required to continue to use the destination space.
    // The most general solution would allow data from regions in two different
    // source spaces to be "joined" in a single destination region.  At the very
    // least, additional code would be required in next_src_region() to detect the
    // join and skip to an out-of-order source region.  If the join region was also
    // the last destination region to which a split region was copied (the most
    // likely case), then additional work would be needed to get fill_region() to
    // stop iteration and switch to a new source region at the right point.  Basic
    // idea would be to use a fake value for the top of the source space.  It is
    // doable, if a bit tricky.
    //
    // A simpler (but less general) solution would fill the remainder of the
    // destination region with a dummy object and continue filling the next
    // destination region.

    class SplitInfo

    ((cite: hotspot/src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.hpp))
    class SpaceInfo
    {
    ...
      SplitInfo         _split_info;

    ((cite: hotspot/src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.hpp))
    class ParallelCompactData
    {

    ((cite: hotspot/src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.hpp))
    class PSParallelCompact : AllStatic {
    ...
      static ParallelCompactData  _summary_data;

    ((cite: hotspot/src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.hpp))
      static ParallelCompactData& summary_data() { return _summary_data; }

    ((cite: hotspot/src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.hpp))
      class RegionData
      {

    ((cite: hotspot/src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.hpp))
    class ParallelCompactData
    {
    ...
      PSVirtualSpace* _region_vspace;
      RegionData*     _region_data;
      size_t          _region_count;

    ((cite: hotspot/src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.hpp))
        // Constants for manipulating the _dc_and_los field, which holds both the
        // destination count and live obj size.  The live obj size lives at the
        // least significant end so no masking is necessary when adding.
    ...
        HeapWord*            _destination;
        size_t               _source_region;
        HeapWord*            _partial_obj_addr;
        region_sz_t          _partial_obj_size;
        region_sz_t volatile _dc_and_los;
    #ifdef ASSERT
        // These enable optimizations that are only partially implemented.  Use
        // debug builds to prevent the code fragments from breaking.
        HeapWord*            _data_location;
        HeapWord*            _highest_ref;
    #endif  // #ifdef ASSERT

    #ifdef ASSERT
       public:
        uint            _pushed;   // 0 until region is pushed onto a worker's stack
       private:
    #endif

    ((cite: hotspot/src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.hpp))
    // Abstract closure for use with ParMarkBitMap::iterate(), which will invoke the
    // do_addr() method.
    //
    // The closure is initialized with the number of heap words to process
    // (words_remaining()), and becomes 'full' when it reaches 0.  The do_addr()
    // methods in subclasses should update the total as words are processed.  Since
    // only one subclass actually uses this mechanism to terminate iteration, the
    // default initial value is > 0.  The implementation is here and not in the
    // single subclass that uses it to avoid making is_full() virtual, and thus
    // adding a virtual call per live object.

    class ParMarkBitMapClosure: public StackObj {

    ((cite: hotspot/src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.hpp))
      virtual IterationStatus do_addr(HeapWord* addr, size_t words) = 0;

    ((cite: hotspot/src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.hpp))
      class IsAliveClosure: public BoolObjectClosure {

    ((cite: hotspot/src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.hpp))
    class PSParallelCompact : AllStatic {
    ...
      static IsAliveClosure       _is_alive_closure;

    ((cite: hotspot/src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.hpp))
      class KeepAliveClosure: public OopClosure {

    ((cite: hotspot/src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.hpp))
      // Current unused
      class FollowRootClosure: public OopsInGenClosure {

    ((cite: hotspot/src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.hpp))
      class FollowStackClosure: public VoidClosure {

    ((cite: hotspot/src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.hpp))
      class AdjustPointerClosure: public OopsInGenClosure {

    ((cite: hotspot/src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.hpp))
    class PSParallelCompact : AllStatic {
    ...
      static AdjustPointerClosure _adjust_root_pointer_closure;
      static AdjustPointerClosure _adjust_pointer_closure;

    ((cite: hotspot/src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.hpp))
      static OopClosure* adjust_pointer_closure()      { return (OopClosure*)&_adjust_pointer_closure; }
      static OopClosure* adjust_root_pointer_closure() { return (OopClosure*)&_adjust_root_pointer_closure; }

    ((cite: hotspot/src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.hpp))
      // Closure for verifying update of pointers.  Does not
      // have any side effects.
      class VerifyUpdateClosure: public ParMarkBitMapClosure {

    ((cite: hotspot/src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.hpp))
      // Closure for updating objects altered for debug checking
      class ResetObjectsClosure: public ParMarkBitMapClosure {

    ((cite: hotspot/src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.hpp))
      class MarkAndPushClosure: public OopClosure {

    ((cite: hotspot/src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.hpp))
    class MoveAndUpdateClosure: public ParMarkBitMapClosure {

    ((cite: hotspot/src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.hpp))
      inline MoveAndUpdateClosure(ParMarkBitMap* bitmap, ParCompactionManager* cm,
                                  ObjectStartArray* start_array,
                                  HeapWord* destination, size_t words);

    ((cite: hotspot/src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.hpp))
    class UpdateOnlyClosure: public ParMarkBitMapClosure {

    ((cite: hotspot/src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.hpp))
    class FillClosure: public ParMarkBitMapClosure
    {

    ((cite: hotspot/src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.cpp))
    // Simple class for storing info about the heap at the start of GC, to be used
    // after GC for comparison/printing.
    class PreGCValues {

    ((cite: hotspot/src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.cpp))
      size_t _heap_used;
      size_t _young_gen_used;
      size_t _old_gen_used;
      size_t _perm_gen_used;

    ((cite: hotspot/src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.cpp))
      PreGCValues() { }
      PreGCValues(ParallelScavengeHeap* heap) { fill(heap); }

      void fill(ParallelScavengeHeap* heap) {
        _heap_used      = heap->used();
        _young_gen_used = heap->young_gen()->used_in_bytes();
        _old_gen_used   = heap->old_gen()->used_in_bytes();
        _perm_gen_used  = heap->perm_gen()->used_in_bytes();
      };

    ((cite: hotspot/src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.cpp))
    // This should be moved to the shared markSweep code!
    class PSAlwaysTrueClosure: public BoolObjectClosure {

    ((cite: hotspot/src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.cpp))
    static PSAlwaysTrueClosure always_true;

    ((cite: hotspot/src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.cpp))
    #ifdef VALIDATE_MARK_SWEEP
    ...
    class AdjusterTracker: public OopClosure {

    ((cite: hotspot/src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.cpp))
    void PSParallelCompact::track_interior_pointers(oop obj) {
      if (ValidateMarkSweep) {
        _adjusted_pointers->clear();
        _pointer_tracking = true;

        AdjusterTracker checker;
        obj->oop_iterate(&checker);
      }
    }