/*

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

  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_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)

{

#ifdef ASSERT

  HeapWord* tmp = _highest_ref;

  while (addr > tmp) {

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

  }

#endif  // #ifdef ASSERT

}

inline bool ParallelCompactData::RegionData::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::RegionData*

ParallelCompactData::region(size_t region_idx) const

{

  assert(region_idx <= region_count(), "bad arg");

  return _region_data + region_idx;

}

inline size_t

ParallelCompactData::region(const RegionData* const region_ptr) const

{

  assert(region_ptr >= _region_data, "bad arg");

  assert(region_ptr <= _region_data + region_count(), "bad arg");

  return pointer_delta(region_ptr, _region_data, sizeof(RegionData));

}

inline size_t

ParallelCompactData::region_offset(const HeapWord* addr) const

{

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

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

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

}

inline size_t

ParallelCompactData::addr_to_region_idx(const HeapWord* addr) const

{

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

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

  return pointer_delta(addr, _region_start) >> Log2RegionSize;

}

inline ParallelCompactData::RegionData*

ParallelCompactData::addr_to_region_ptr(const HeapWord* addr) const

{

  return region(addr_to_region_idx(addr));

}

inline HeapWord*

ParallelCompactData::region_to_addr(size_t region) const

{

  assert(region <= _region_count, "region out of range");

  return _region_start + (region << Log2RegionSize);

}

inline HeapWord*

ParallelCompactData::region_to_addr(const RegionData* region) const

{

  return region_to_addr(pointer_delta(region, _region_data,

                                      sizeof(RegionData)));

}

inline HeapWord*

ParallelCompactData::region_to_addr(size_t region, size_t offset) const

{

  assert(region <= _region_count, "region out of range");

  assert(offset < RegionSize, "offset too big");  // This may be too strict.

  return region_to_addr(region) + offset;

}

inline HeapWord*

ParallelCompactData::region_align_down(HeapWord* addr) const

{

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

  assert(addr < _region_end + RegionSize, "bad addr");

  return (HeapWord*)(size_t(addr) & RegionAddrMask);

}

inline HeapWord*

ParallelCompactData::region_align_up(HeapWord* addr) const

{

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

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

  return region_align_down(addr + RegionSizeOffsetMask);

}

inline bool

ParallelCompactData::is_region_aligned(HeapWord* addr) const

{

  return region_offset(addr) == 0;

}

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

 public:

  typedef ParMarkBitMap::idx_t idx_t;

  typedef ParMarkBitMap::IterationStatus IterationStatus;

 public:

  inline ParMarkBitMapClosure(ParMarkBitMap* mbm, ParCompactionManager* cm,

                              size_t words = max_uintx);

  inline ParCompactionManager* compaction_manager() const;

  inline ParMarkBitMap*        bitmap() const;

  inline size_t                words_remaining() const;

  inline bool                  is_full() const;

  inline HeapWord*             source() const;

  inline void                  set_source(HeapWord* addr);

  virtual IterationStatus do_addr(HeapWord* addr, size_t words) = 0;

 protected:

  inline void decrement_words_remaining(size_t words);

 private:

  ParMarkBitMap* const        _bitmap;

  ParCompactionManager* const _compaction_manager;

  DEBUG_ONLY(const size_t     _initial_words_remaining;) // Useful in debugger.

  size_t                      _words_remaining; // Words left to copy.

 protected:

  HeapWord*                   _source;          // Next addr that would be read.

};

inline

ParMarkBitMapClosure::ParMarkBitMapClosure(ParMarkBitMap* bitmap,

                                           ParCompactionManager* cm,