/*

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

  static const size_t BlockSize;

  static const size_t BlockOffsetMask;

  static const size_t BlockMask;

  {

  public:

    HeapWord* destination() const { return _destination; }

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

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

    HeapWord* deferred_obj_addr() const { return _partial_obj_addr; }

    HeapWord* partial_obj_addr() const { return _partial_obj_addr; }

    size_t partial_obj_size() const { return _partial_obj_size; }

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

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

    // values of destination_count are

    //

    //

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

    // then filled.

    //

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

    inline HeapWord* data_location() const;

    inline HeapWord* highest_ref() const;

    // been completed.

    //

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

    }

    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:

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

#ifdef ASSERT

    // These enable optimizations that are only partially implemented.  Use

    // debug builds to prevent the code fragments from breaking.

#endif  // #ifdef ASSERT

#ifdef ASSERT

   public:

   private:

#endif

  };

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

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

  //

  // 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 block_count() const { return _block_count; }

  inline BlockData* block(size_t n) const;

  void add_obj(HeapWord* addr, size_t len);

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

  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(HeapWord* beg, HeapWord* end) {

  }

  // containing addr.

  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.

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

  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

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

  PSVirtualSpace* create_vspace(size_t count, size_t element_size);

private:

  HeapWord*       _region_start;

#ifdef  ASSERT

  HeapWord*       _region_end;

#endif  // #ifdef ASSERT

  PSVirtualSpace* _block_vspace;

  BlockData*      _block_data;

  size_t          _block_count;

};

inline uint

{

  return _dc_and_los & dc_mask;

}

inline uint

{

  return destination_count_raw() >> dc_shift;

}

inline void

{

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

  _dc_and_los = (count << dc_shift) | live_sz;

}

{

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

}

{

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

}

{

  DEBUG_ONLY(return _data_location;)

  NOT_DEBUG(return NULL;)

}

{

  DEBUG_ONLY(return _highest_ref;)

  NOT_DEBUG(return NULL;)

}

{

  DEBUG_ONLY(_data_location = addr;)

}

{

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

}

// execution.

{

  if (available()) {

    _dc_and_los |= dc_claimed;

    return true;

  }

  return false;

}

{

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

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

}

{

#ifdef ASSERT

  HeapWord* tmp = _highest_ref;

  while (addr > tmp) {

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

  }

#endif  // #ifdef ASSERT

}

{

  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 size_t

{

}

inline ParallelCompactData::BlockData*

ParallelCompactData::block(size_t n) const {

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

  return _block_data + n;

}

inline size_t