/*

 * Copyright (c) 2005, 2011, 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.

 *

 */

#ifndef SHARE_VM_GC_IMPLEMENTATION_PARALLELSCAVENGE_PSPARALLELCOMPACT_HPP

#define SHARE_VM_GC_IMPLEMENTATION_PARALLELSCAVENGE_PSPARALLELCOMPACT_HPP

#include "gc_implementation/parallelScavenge/objectStartArray.hpp"

#include "gc_implementation/parallelScavenge/parMarkBitMap.hpp"

#include "gc_implementation/parallelScavenge/psCompactionManager.hpp"

#include "gc_implementation/shared/collectorCounters.hpp"

#include "gc_implementation/shared/markSweep.hpp"

#include "gc_implementation/shared/mutableSpace.hpp"

#include "memory/sharedHeap.hpp"

#include "oops/oop.hpp"

class ParallelScavengeHeap;

class PSAdaptiveSizePolicy;

class PSYoungGen;

class PSOldGen;

class PSPermGen;

class ParCompactionManager;

class ParallelTaskTerminator;

class PSParallelCompact;

class GCTaskManager;

class GCTaskQueue;

class PreGCValues;

class MoveAndUpdateClosure;

class RefProcTaskExecutor;

// 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

{

public:

  // Return true if this split info is valid (i.e., if a split has been

  // recorded).  The very first region cannot have a partial object and thus is

  // never split, so 0 is the 'invalid' value.

  bool is_valid() const { return _src_region_idx > 0; }

  // Return true if this split holds data for the specified source region.

  inline bool is_split(size_t source_region) const;

  // The index of the split region, the size of the partial object on that

  // region and the destination of the partial object.

  size_t    src_region_idx() const   { return _src_region_idx; }

  size_t    partial_obj_size() const { return _partial_obj_size; }

  HeapWord* destination() const      { return _destination; }

  // The destination count of the partial object referenced by this split

  // (either 1 or 2).  This must be added to the destination count of the

  // remainder of the source region.

  unsigned int destination_count() const { return _destination_count; }

  // If a word within the partial object will be written to the first word of a

  // destination region, this is the address of the destination region;

  // otherwise this is NULL.

  HeapWord* dest_region_addr() const     { return _dest_region_addr; }

  // If a word within the partial object will be written to the first word of a

  // destination region, this is the address of that word within the partial

  // object; otherwise this is NULL.

  HeapWord* first_src_addr() const       { return _first_src_addr; }

  // Record the data necessary to split the region src_region_idx.

  void record(size_t src_region_idx, size_t partial_obj_size,

              HeapWord* destination);

  void clear();

  DEBUG_ONLY(void verify_clear();)

private:

  size_t       _src_region_idx;

  size_t       _partial_obj_size;

  HeapWord*    _destination;

  unsigned int _destination_count;

  HeapWord*    _dest_region_addr;

  HeapWord*    _first_src_addr;

};

inline bool SplitInfo::is_split(size_t region_idx) const

{

  return _src_region_idx == region_idx && is_valid();

}

class SpaceInfo

{

 public:

  MutableSpace* space() const { return _space; }

  // Where the free space will start after the collection.  Valid only after the

  // summary phase completes.

  HeapWord* new_top() const { return _new_top; }

  // Allows new_top to be set.

  HeapWord** new_top_addr() { return &_new_top; }

  // Where the smallest allowable dense prefix ends (used only for perm gen).

  HeapWord* min_dense_prefix() const { return _min_dense_prefix; }

  // Where the dense prefix ends, or the compacted region begins.

  HeapWord* dense_prefix() const { return _dense_prefix; }

  // The start array for the (generation containing the) space, or NULL if there

  // is no start array.

  ObjectStartArray* start_array() const { return _start_array; }

  SplitInfo& split_info() { return _split_info; }

  void set_space(MutableSpace* s)           { _space = s; }

  void set_new_top(HeapWord* addr)          { _new_top = addr; }

  void set_min_dense_prefix(HeapWord* addr) { _min_dense_prefix = addr; }

  void set_dense_prefix(HeapWord* addr)     { _dense_prefix = addr; }

  void set_start_array(ObjectStartArray* s) { _start_array = s; }

  void publish_new_top() const              { _space->set_top(_new_top); }

 private:

  MutableSpace*     _space;

  HeapWord*         _new_top;

  HeapWord*         _min_dense_prefix;

  HeapWord*         _dense_prefix;

  ObjectStartArray* _start_array;

  SplitInfo         _split_info;

};

class ParallelCompactData

{

public:

  // Sizes are in HeapWords, unless indicated otherwise.

  static const size_t Log2RegionSize;

  static const size_t RegionSize;

  static const size_t RegionSizeBytes;

  // Mask for the bits in a size_t to get an offset within a region.

  static const size_t RegionSizeOffsetMask;

  // Mask for the bits in a pointer to get an offset within a region.

  static const size_t RegionAddrOffsetMask;

  // Mask for the bits in a pointer to get the address of the start of a region.

  static const size_t RegionAddrMask;

  class RegionData

  {

  public:

    // Destination address of the region.

    HeapWord* destination() const { return _destination; }

    // The first region containing data destined for this region.

    size_t source_region() const { return _source_region; }

    // The object (if any) starting in this region and ending in a different

    // region that could not be updated during the main (parallel) compaction

    // phase.  This is different from _partial_obj_addr, which is an object that

    // extends onto a source region.  However, the two uses do not overlap in

    // time, so the same field is used to save space.

    HeapWord* deferred_obj_addr() const { return _partial_obj_addr; }

    // The starting address of the partial object extending onto the region.

    HeapWord* partial_obj_addr() const { return _partial_obj_addr; }

    // Size of the partial object extending onto the region (words).

    size_t partial_obj_size() const { return _partial_obj_size; }

    // Size of live data that lies within this region due to objects that start

    // in this region (words).  This does not include the partial object

    // extending onto the region (if any), or the part of an object that extends

    // onto the next region (if any).

    size_t live_obj_size() const { return _dc_and_los & los_mask; }

    // Total live data that lies within the region (words).

    size_t data_size() const { return partial_obj_size() + live_obj_size(); }

    // The destination_count is the number of other regions to which data from

    // this region will be copied.  At the end of the summary phase, the valid

    // values of destination_count are

    //

    // 0 - data from the region will be compacted completely into itself, or the

    //     region is empty.  The region can be claimed and then filled.

    // 1 - data from the region will be compacted into 1 other region; some

    //     data from the region may also be compacted into the region itself.

    // 2 - data from the region will be copied to 2 other regions.

    //

    // During compaction as regions are emptied, the destination_count is

    // decremented (atomically) and when it reaches 0, it can be claimed and

    // then filled.

    //

    // A region is claimed for processing by atomically changing the

    // destination_count to the claimed value (dc_claimed).  After a region has

    // been filled, the destination_count should be set to the completed value

    // (dc_completed).

    inline uint destination_count() const;

    inline uint destination_count_raw() const;

    // The location of the java heap data that corresponds to this region.

    inline HeapWord* data_location() const;

    // The highest address referenced by objects in this region.

    inline HeapWord* highest_ref() const;

    // Whether this region is available to be claimed, has been claimed, or has

    // been completed.

    //

    // Minor subtlety:  claimed() returns true if the region is marked

    // completed(), which is desirable since a region must be claimed before it

    // can be completed.

    bool available() const { return _dc_and_los < dc_one; }

    bool claimed() const   { return _dc_and_los >= dc_claimed; }

    bool completed() const { return _dc_and_los >= dc_completed; }

    // These are not atomic.

    void set_destination(HeapWord* addr)       { _destination = addr; }

    void set_source_region(size_t region)      { _source_region = region; }

    void set_deferred_obj_addr(HeapWord* addr) { _partial_obj_addr = addr; }

    void set_partial_obj_addr(HeapWord* addr)  { _partial_obj_addr = addr; }

    void set_partial_obj_size(size_t words)    {

      _partial_obj_size = (region_sz_t) words;

    }

    inline void set_destination_count(uint count);

    inline void set_live_obj_size(size_t words);

    inline void set_data_location(HeapWord* addr);

    inline void set_completed();

    inline bool claim_unsafe();

    // These are atomic.

    inline void add_live_obj(size_t words);

    inline void set_highest_ref(HeapWord* addr);

    inline void decrement_destination_count();

    inline bool claim();

  private:

    // The type used to represent object sizes within a region.

    typedef uint region_sz_t;

    // 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.

    static const region_sz_t dc_shift;           // Shift amount.

    static const region_sz_t dc_mask;            // Mask for destination count.

    static const region_sz_t dc_one;             // 1, shifted appropriately.

    static const region_sz_t dc_claimed;         // Region has been claimed.

    static const region_sz_t dc_completed;       // Region has been completed.

    static const region_sz_t los_mask;           // Mask for live obj size.

    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

  };

public:

  ParallelCompactData();

  bool initialize(MemRegion covered_region);

  size_t region_count() const { return _region_count; }

  // Convert region indices to/from RegionData pointers.

  inline RegionData* region(size_t region_idx) const;

  inline size_t     region(const RegionData* const region_ptr) const;

  // Returns true if the given address is contained within the region

  bool region_contains(size_t region_index, HeapWord* addr);

  void add_obj(HeapWord* addr, size_t len);

  void add_obj(oop p, size_t len) { add_obj((HeapWord*)p, len); }

  // Fill in the regions covering [beg, end) so that no data moves; i.e., the

  // destination of region n is simply the start of region n.  The argument beg

  // must be region-aligned; end need not be.

  void summarize_dense_prefix(HeapWord* beg, HeapWord* end);

  HeapWord* summarize_split_space(size_t src_region, SplitInfo& split_info,

                                  HeapWord* destination, HeapWord* target_end,

                                  HeapWord** target_next);

  bool summarize(SplitInfo& split_info,

                 HeapWord* source_beg, HeapWord* source_end,

                 HeapWord** source_next,

                 HeapWord* target_beg, HeapWord* target_end,

                 HeapWord** target_next);

  void clear();

  void clear_range(size_t beg_region, size_t end_region);

  void clear_range(HeapWord* beg, HeapWord* end) {

    clear_range(addr_to_region_idx(beg), addr_to_region_idx(end));

  }

  // Return the number of words between addr and the start of the region

  // containing addr.

  inline size_t     region_offset(const HeapWord* addr) const;

  // Convert addresses to/from a region index or region pointer.

  inline size_t     addr_to_region_idx(const HeapWord* addr) const;

  inline RegionData* addr_to_region_ptr(const HeapWord* addr) const;

  inline HeapWord*  region_to_addr(size_t region) const;

  inline HeapWord*  region_to_addr(size_t region, size_t offset) const;

  inline HeapWord*  region_to_addr(const RegionData* region) const;

  inline HeapWord*  region_align_down(HeapWord* addr) const;

  inline HeapWord*  region_align_up(HeapWord* addr) const;

  inline bool       is_region_aligned(HeapWord* addr) const;

  // Return the address one past the end of the partial object.

  HeapWord* partial_obj_end(size_t region_idx) const;

  // Return the new location of the object p after the

  // the compaction.

  HeapWord* calc_new_pointer(HeapWord* addr);

  HeapWord* calc_new_pointer(oop p) {

    return calc_new_pointer((HeapWord*) p);

  }

  // Return the updated address for the given klass

  klassOop calc_new_klass(klassOop);

#ifdef  ASSERT

  void verify_clear(const PSVirtualSpace* vspace);

  void verify_clear();

#endif  // #ifdef ASSERT

private:

  bool initialize_region_data(size_t region_size);

  PSVirtualSpace* create_vspace(size_t count, size_t element_size);

private:

  HeapWord*       _region_start;

#ifdef  ASSERT

  HeapWord*       _region_end;

#endif  // #ifdef ASSERT

  PSVirtualSpace* _region_vspace;

  RegionData*     _region_data;

  size_t          _region_count;

};

inline uint

ParallelCompactData::RegionData::destination_count_raw() const

{

  return _dc_and_los & dc_mask;

}

inline uint

ParallelCompactData::RegionData::destination_count() const

{

  return destination_count_raw() >> dc_shift;

}

inline void

ParallelCompactData::RegionData::set_destination_count(uint count)

{

  assert(count <= (dc_completed >> dc_shift), "count too large");

  const region_sz_t live_sz = (region_sz_t) live_obj_size();

  _dc_and_los = (count << dc_shift) | live_sz;

}

inline void ParallelCompactData::RegionData::set_live_obj_size(size_t words)

{

  assert(words <= los_mask, "would overflow");

  _dc_and_los = destination_count_raw() | (region_sz_t)words;

}

inline void ParallelCompactData::RegionData::decrement_destination_count()

{

  assert(_dc_and_los < dc_claimed, "already claimed");

  assert(_dc_and_los >= dc_one, "count would go negative");

  Atomic::add((int)dc_mask, (volatile int*)&_dc_and_los);

}

inline HeapWord* ParallelCompactData::RegionData::data_location() const

{

  DEBUG_ONLY(return _data_location;)

  NOT_DEBUG(return NULL;)

}

inline HeapWord* ParallelCompactData::RegionData::highest_ref() const

{

  DEBUG_ONLY(return _highest_ref;)

  NOT_DEBUG(return NULL;)

}

inline void ParallelCompactData::RegionData::set_data_location(HeapWord* addr)

{

  DEBUG_ONLY(_data_location = addr;)

}

inline void ParallelCompactData::RegionData::set_completed()

{

  assert(claimed(), "must be claimed first");

  _dc_and_los = dc_completed | (region_sz_t) live_obj_size();

}

// MT-unsafe claiming of a region.  Should only be used during single threaded

// execution.

inline bool ParallelCompactData::RegionData::claim_unsafe()

{

  if (available()) {

    _dc_and_los |= dc_claimed;

    return true;

  }

  return false;

}

inline void ParallelCompactData::RegionData::add_live_obj(size_t words)

{

  assert(words <= (size_t)los_mask - live_obj_size(), "overflow");

  Atomic::add((int) words, (volatile int*) &_dc_and_los);

}

inline void ParallelCompactData::RegionData::set_highest_ref(HeapWord* addr)