/*

 * Copyright 2005-2008 Sun Microsystems, Inc.  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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

 * CA 95054 USA or visit www.sun.com if you need additional information or

 * have any questions.

 *

 */

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;

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; }

  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; }

 private:

  MutableSpace*     _space;

  HeapWord*         _new_top;

  HeapWord*         _min_dense_prefix;

  HeapWord*         _dense_prefix;

  ObjectStartArray* _start_array;

};

class ParallelCompactData

{

public:

  // Sizes are in HeapWords, unless indicated otherwise.

  static const size_t Log2ChunkSize;

  static const size_t ChunkSize;

  static const size_t ChunkSizeBytes;

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

  static const size_t ChunkSizeOffsetMask;

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

  static const size_t ChunkAddrOffsetMask;

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

  static const size_t ChunkAddrMask;

  static const size_t Log2BlockSize;

  static const size_t BlockSize;

  static const size_t BlockOffsetMask;

  static const size_t BlockMask;

  static const size_t BlocksPerChunk;

  class ChunkData

  {

  public:

    // Destination address of the chunk.

    HeapWord* destination() const { return _destination; }

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

    size_t source_chunk() const { return _source_chunk; }

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

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

    HeapWord* partial_obj_addr() const { return _partial_obj_addr; }

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

    size_t partial_obj_size() const { return _partial_obj_size; }

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

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

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

    // onto the next chunk (if any).

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

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

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

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

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

    // values of destination_count are

    //

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

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

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

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

    // 2 - data from the chunk will be copied to 2 other chunks.

    //

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

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

    // then filled.

    //

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

    // destination_count to the claimed value (dc_claimed).  After a chunk 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 chunk.

    inline HeapWord* data_location() const;

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

    inline HeapWord* highest_ref() const;

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

    // been completed.

    //

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

    // completed(), which is desirable since a chunk 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_chunk(size_t chunk)        { _source_chunk = chunk; }

    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 = (chunk_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 chunk.

    typedef uint chunk_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 chunk_sz_t dc_shift;           // Shift amount.

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

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

    static const chunk_sz_t dc_claimed;         // Chunk has been claimed.

    static const chunk_sz_t dc_completed;       // Chunk has been completed.

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

    HeapWord*           _destination;

    size_t              _source_chunk;

    HeapWord*           _partial_obj_addr;

    chunk_sz_t          _partial_obj_size;

    chunk_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 chunk is pushed onto a worker's stack

   private:

#endif

  };

  // 'Blocks' allow shorter sections of the bitmap to be searched.  Each Block

  // holds an offset, which is the amount of live data in the Chunk to the left

  // of the first live object in the Block.  This amount of live data will

  // include any object extending into the block. The first block in

  // a chunk does not include any partial object extending into the

  // the chunk.

  //

  // The offset also encodes the

  // 'parity' of the first 1 bit in the Block:  a positive offset means the

  // first 1 bit marks the start of an object, a negative offset means the first

  // 1 bit marks the end of an object.

  class BlockData

  {

   public:

    typedef short int blk_ofs_t;

    blk_ofs_t offset() const { return _offset >= 0 ? _offset : -_offset; }

    blk_ofs_t raw_offset() const { return _offset; }

    void set_first_is_start_bit(bool v) { _first_is_start_bit = v; }

#if 0

    // The need for this method was anticipated but it is

    // never actually used.  Do not include it for now.  If

    // it is needed, consider the problem of what is passed

    // as "v".  To avoid warning errors the method set_start_bit_offset()

    // was changed to take a size_t as the parameter and to do the

    // check for the possible overflow.  Doing the cast in these

    // methods better limits the potential problems because of

    // the size of the field to this class.

    void set_raw_offset(blk_ofs_t v) { _offset = v; }

#endif

    void set_start_bit_offset(size_t val) {

      assert(val >= 0, "sanity");

      _offset = (blk_ofs_t) val;

      assert(val == (size_t) _offset, "Value is too large");

      _first_is_start_bit = true;

    }

    void set_end_bit_offset(size_t val) {

      assert(val >= 0, "sanity");

      _offset = (blk_ofs_t) val;

      assert(val == (size_t) _offset, "Value is too large");

      _offset = - _offset;

      _first_is_start_bit = false;

    }

    bool first_is_start_bit() {

      assert(_set_phase > 0, "Not initialized");

      return _first_is_start_bit;

    }

    bool first_is_end_bit() {

      assert(_set_phase > 0, "Not initialized");

      return !_first_is_start_bit;

    }

   private:

    blk_ofs_t _offset;

    // This is temporary until the mark_bitmap is separated into

    // a start bit array and an end bit array.

    bool      _first_is_start_bit;

#ifdef ASSERT

    short     _set_phase;

    static short _cur_phase;

   public:

    static void set_cur_phase(short v) { _cur_phase = v; }

#endif

  };

public:

  ParallelCompactData();

  bool initialize(MemRegion covered_region);

  size_t chunk_count() const { return _chunk_count; }

  // Convert chunk indices to/from ChunkData pointers.

  inline ChunkData* chunk(size_t chunk_idx) const;

  inline size_t     chunk(const ChunkData* const chunk_ptr) const;

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

  bool chunk_contains(size_t chunk_index, HeapWord* addr);

  size_t block_count() const { return _block_count; }

  inline BlockData* block(size_t n) const;

  // Returns true if the given block is in the given chunk.

  static bool chunk_contains_block(size_t chunk_index, size_t block_index);

  void add_obj(HeapWord* addr, size_t len);

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

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

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

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

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

  bool summarize(HeapWord* target_beg, HeapWord* target_end,

                 HeapWord* source_beg, HeapWord* source_end,

                 HeapWord** target_next, HeapWord** source_next = 0);

  void clear();

  void clear_range(size_t beg_chunk, size_t end_chunk);

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

    clear_range(addr_to_chunk_idx(beg), addr_to_chunk_idx(end));

  }

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

  // containing addr.

  inline size_t     chunk_offset(const HeapWord* addr) const;

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

  inline size_t     addr_to_chunk_idx(const HeapWord* addr) const;

  inline ChunkData* addr_to_chunk_ptr(const HeapWord* addr) const;

  inline HeapWord*  chunk_to_addr(size_t chunk) const;

  inline HeapWord*  chunk_to_addr(size_t chunk, size_t offset) const;

  inline HeapWord*  chunk_to_addr(const ChunkData* chunk) const;

  inline HeapWord*  chunk_align_down(HeapWord* addr) const;

  inline HeapWord*  chunk_align_up(HeapWord* addr) const;

  inline bool       is_chunk_aligned(HeapWord* addr) const;

  // Analogous to chunk_offset() for blocks.

  size_t     block_offset(const HeapWord* addr) const;

  size_t     addr_to_block_idx(const HeapWord* addr) const;

  size_t     addr_to_block_idx(const oop obj) const {

    return addr_to_block_idx((HeapWord*) obj);

  }

  inline BlockData* addr_to_block_ptr(const HeapWord* addr) const;

  inline HeapWord*  block_to_addr(size_t block) const;

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

  HeapWord* partial_obj_end(size_t chunk_idx) const;

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

  // the compaction.

  HeapWord* calc_new_pointer(HeapWord* addr);

  // Same as calc_new_pointer() using blocks.

  HeapWord* block_calc_new_pointer(HeapWord* addr);

  // Same as calc_new_pointer() using chunks.

  HeapWord* chunk_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);

  // Given a block returns true if the partial object for the

  // corresponding chunk ends in the block.  Returns false, otherwise

  // If there is no partial object, returns false.

  bool partial_obj_ends_in_block(size_t block_index);

  // Returns the block index for the block

  static size_t block_idx(BlockData* block);

#ifdef  ASSERT

  void verify_clear(const PSVirtualSpace* vspace);

  void verify_clear();

#endif  // #ifdef ASSERT

private:

  bool initialize_block_data(size_t region_size);

  bool initialize_chunk_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* _chunk_vspace;

  ChunkData*      _chunk_data;

  size_t          _chunk_count;

  PSVirtualSpace* _block_vspace;

  BlockData*      _block_data;

  size_t          _block_count;

};

inline uint

ParallelCompactData::ChunkData::destination_count_raw() const

{

  return _dc_and_los & dc_mask;

}

inline uint

ParallelCompactData::ChunkData::destination_count() const

{

  return destination_count_raw() >> dc_shift;

}

inline void

ParallelCompactData::ChunkData::set_destination_count(uint count)

{

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

  const chunk_sz_t live_sz = (chunk_sz_t) live_obj_size();

  _dc_and_los = (count << dc_shift) | live_sz;

}

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

{

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

  _dc_and_los = destination_count_raw() | (chunk_sz_t)words;

}

inline void ParallelCompactData::ChunkData::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::ChunkData::data_location() const

{

  DEBUG_ONLY(return _data_location;)

  NOT_DEBUG(return NULL;)

}

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

{

  DEBUG_ONLY(return _highest_ref;)

  NOT_DEBUG(return NULL;)

}

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

{

  DEBUG_ONLY(_data_location = addr;)

}

inline void ParallelCompactData::ChunkData::set_completed()

{

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

  _dc_and_los = dc_completed | (chunk_sz_t) live_obj_size();

}

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

// execution.

inline bool ParallelCompactData::ChunkData::claim_unsafe()

{

  if (available()) {

    _dc_and_los |= dc_claimed;

    return true;

  }

  return false;

}

inline void ParallelCompactData::ChunkData::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::ChunkData::set_highest_ref(HeapWord* addr)

{

#ifdef ASSERT

  HeapWord* tmp = _highest_ref;

  while (addr > tmp) {

    tmp = (HeapWord*)Atomic::cmpxchg_ptr(addr, &_highest_ref, tmp);

  }

#endif  // #ifdef ASSERT

}

inline bool ParallelCompactData::ChunkData::claim()

{

  const int los = (int) live_obj_size();

  const int old = Atomic::cmpxchg(dc_claimed | los,

                                  (volatile int*) &_dc_and_los, los);

  return old == los;

}

inline ParallelCompactData::ChunkData*

ParallelCompactData::chunk(size_t chunk_idx) const

{

  assert(chunk_idx <= chunk_count(), "bad arg");

  return _chunk_data + chunk_idx;

}

inline size_t

ParallelCompactData::chunk(const ChunkData* const chunk_ptr) const

{

  assert(chunk_ptr >= _chunk_data, "bad arg");

  assert(chunk_ptr <= _chunk_data + chunk_count(), "bad arg");

  return pointer_delta(chunk_ptr, _chunk_data, sizeof(ChunkData));

}

inline ParallelCompactData::BlockData*

ParallelCompactData::block(size_t n) const {

  assert(n < block_count(), "bad arg");

  return _block_data + n;

}

inline size_t

ParallelCompactData::chunk_offset(const HeapWord* addr) const

{

  assert(addr >= _region_start, "bad addr");

  assert(addr <= _region_end, "bad addr");

  return (size_t(addr) & ChunkAddrOffsetMask) >> LogHeapWordSize;

}

inline size_t

ParallelCompactData::addr_to_chunk_idx(const HeapWord* addr) const

{

  assert(addr >= _region_start, "bad addr");

  assert(addr <= _region_end, "bad addr");

  return pointer_delta(addr, _region_start) >> Log2ChunkSize;

}

inline ParallelCompactData::ChunkData*