/*

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

 *

 */

#include "incls/_precompiled.incl"

#include "incls/_psParallelCompact.cpp.incl"

#include <math.h>

// All sizes are in HeapWords.

// 32-bit:  128 words covers 4 bitmap words

// 64-bit:  128 words covers 2 bitmap words

const size_t ParallelCompactData::Log2BlockSize   = 7; // 128 words

const size_t ParallelCompactData::BlockSize       = (size_t)1 << Log2BlockSize;

const size_t ParallelCompactData::BlockOffsetMask = BlockSize - 1;

const size_t ParallelCompactData::BlockMask       = ~BlockOffsetMask;

#ifdef ASSERT

short   ParallelCompactData::BlockData::_cur_phase = 0;

#endif

SpaceInfo PSParallelCompact::_space_info[PSParallelCompact::last_space_id];

bool      PSParallelCompact::_print_phases = false;

ReferenceProcessor* PSParallelCompact::_ref_processor = NULL;

klassOop            PSParallelCompact::_updated_int_array_klass_obj = NULL;

double PSParallelCompact::_dwl_mean;

double PSParallelCompact::_dwl_std_dev;

double PSParallelCompact::_dwl_first_term;

double PSParallelCompact::_dwl_adjustment;

#ifdef  ASSERT

bool   PSParallelCompact::_dwl_initialized = false;

#endif  // #ifdef ASSERT

#ifdef VALIDATE_MARK_SWEEP

GrowableArray<void*>*   PSParallelCompact::_root_refs_stack = NULL;

GrowableArray<oop> *    PSParallelCompact::_live_oops = NULL;

GrowableArray<oop> *    PSParallelCompact::_live_oops_moved_to = NULL;

GrowableArray<size_t>*  PSParallelCompact::_live_oops_size = NULL;

size_t                  PSParallelCompact::_live_oops_index = 0;

size_t                  PSParallelCompact::_live_oops_index_at_perm = 0;

GrowableArray<void*>*   PSParallelCompact::_other_refs_stack = NULL;

GrowableArray<void*>*   PSParallelCompact::_adjusted_pointers = NULL;

bool                    PSParallelCompact::_pointer_tracking = false;

bool                    PSParallelCompact::_root_tracking = true;

GrowableArray<HeapWord*>* PSParallelCompact::_cur_gc_live_oops = NULL;

GrowableArray<HeapWord*>* PSParallelCompact::_cur_gc_live_oops_moved_to = NULL;

GrowableArray<size_t>   * PSParallelCompact::_cur_gc_live_oops_size = NULL;

GrowableArray<HeapWord*>* PSParallelCompact::_last_gc_live_oops = NULL;

GrowableArray<HeapWord*>* PSParallelCompact::_last_gc_live_oops_moved_to = NULL;

GrowableArray<size_t>   * PSParallelCompact::_last_gc_live_oops_size = NULL;

#endif

#ifndef PRODUCT

const char* PSParallelCompact::space_names[] = {

  "perm", "old ", "eden", "from", "to  "

};

{

  tty->print_cr("space  bottom     top        end        new_top");

  tty->print_cr("------ ---------- ---------- ---------- ----------");

  for (unsigned int id = 0; id < last_space_id; ++id) {

    const MutableSpace* space = _space_info[id].space();

    tty->print_cr("%u %s "

                  SIZE_FORMAT_W(10) " " SIZE_FORMAT_W(10) " "

                  SIZE_FORMAT_W(10) " " SIZE_FORMAT_W(10) " ",

                  id, space_names[id],

  }

}

void

{

  ParallelCompactData& sd = PSParallelCompact::summary_data();

                i, c->data_location(), dci, c->destination(),

                c->partial_obj_size(), c->live_obj_size(),

}

void

print_generic_summary_data(ParallelCompactData& summary_data,

                           HeapWord* const beg_addr,

                           HeapWord* const end_addr)

{

  size_t total_words = 0;

  HeapWord* pdest = 0;

  while (i <= last) {

    if (c->data_size() != 0 || c->destination() != pdest) {

      total_words += c->data_size();

      pdest = c->destination();

    }

    ++i;

  }

  tty->print_cr("summary_data_bytes=" SIZE_FORMAT, total_words * HeapWordSize);

}

void

print_generic_summary_data(ParallelCompactData& summary_data,

                           SpaceInfo* space_info)

{

  for (unsigned int id = 0; id < PSParallelCompact::last_space_id; ++id) {

    const MutableSpace* space = space_info[id].space();

    print_generic_summary_data(summary_data, space->bottom(),

                               MAX2(space->top(), space_info[id].new_top()));

  }

}

void

{

  tty->print(SIZE_FORMAT_W(5) " " PTR_FORMAT " "

             SIZE_FORMAT_W(5) " " SIZE_FORMAT_W(5) " "

             SIZE_FORMAT_W(5) " " SIZE_FORMAT_W(5) " %d",

             i, c->destination(),

             c->partial_obj_size(), c->live_obj_size(),

  if (newline) tty->cr();

}

void

print_initial_summary_data(ParallelCompactData& summary_data,

                           const MutableSpace* space) {

  if (space->top() == space->bottom()) {

    return;

  }

  HeapWord* end_addr = c->destination() + c->data_size();

  const size_t live_in_space = pointer_delta(end_addr, space->bottom());

    ++i;

  }

  double max_reclaimed_ratio = 0.0;

  size_t max_dead_to_right = 0;

  size_t max_live_to_right = 0;

  // uninteresting), and computing the ratio will result in division by 0.

    const size_t dead_to_right = used_to_right - live_to_right;

    const double reclaimed_ratio = double(dead_to_right) / live_to_right;

    if (reclaimed_ratio > max_reclaimed_ratio) {

            max_reclaimed_ratio = reclaimed_ratio;

            max_dead_to_right = dead_to_right;

            max_live_to_right = live_to_right;

    }

    tty->print_cr(" %12.10f " SIZE_FORMAT_W(10) " " SIZE_FORMAT_W(10),

                  reclaimed_ratio, dead_to_right, live_to_right);

    live_to_right -= c->data_size();

    ++i;

  }

  }

  tty->print_cr("max:  " SIZE_FORMAT_W(4) " d2r=" SIZE_FORMAT_W(10) " "

                "l2r=" SIZE_FORMAT_W(10) " max_ratio=%14.12f",

                max_live_to_right, max_reclaimed_ratio);

}

void

print_initial_summary_data(ParallelCompactData& summary_data,

                           SpaceInfo* space_info) {

  unsigned int id = PSParallelCompact::perm_space_id;

  const MutableSpace* space;

  do {

    space = space_info[id].space();

    print_initial_summary_data(summary_data, space);

  } while (++id < PSParallelCompact::eden_space_id);

  do {

    space = space_info[id].space();

    print_generic_summary_data(summary_data, space->bottom(), space->top());

  } while (++id < PSParallelCompact::last_space_id);

}

#endif  // #ifndef PRODUCT

#ifdef  ASSERT

size_t add_obj_count;

size_t add_obj_size;

size_t mark_bitmap_count;

size_t mark_bitmap_size;

#endif  // #ifdef ASSERT

ParallelCompactData::ParallelCompactData()

{

  _region_start = 0;

  _block_vspace = 0;

  _block_data = 0;

  _block_count = 0;

}

bool ParallelCompactData::initialize(MemRegion covered_region)

{

  _region_start = covered_region.start();

  const size_t region_size = covered_region.word_size();

  DEBUG_ONLY(_region_end = _region_start + region_size;)

         "region start not aligned");

  // Initialize the block data if it will be used for updating pointers, or if

  // this is a debug build.

    result = result && initialize_block_data(region_size);

  }

  return result;

}

PSVirtualSpace*

ParallelCompactData::create_vspace(size_t count, size_t element_size)

{

  const size_t raw_bytes = count * element_size;

  const size_t page_sz = os::page_size_for_region(raw_bytes, raw_bytes, 10);

  const size_t granularity = os::vm_allocation_granularity();

  const size_t bytes = align_size_up(raw_bytes, MAX2(page_sz, granularity));

  const size_t rs_align = page_sz == (size_t) os::vm_page_size() ? 0 :

    MAX2(page_sz, granularity);

  ReservedSpace rs(bytes, rs_align, rs_align > 0);

  os::trace_page_sizes("par compact", raw_bytes, raw_bytes, page_sz, rs.base(),

                       rs.size());

  PSVirtualSpace* vspace = new PSVirtualSpace(rs, page_sz);

  if (vspace != 0) {

    if (vspace->expand_by(bytes)) {

      return vspace;

    }

    delete vspace;

    // Release memory reserved in the space.

    rs.release();

  }

  return 0;

}

{

    return true;

  }

  return false;

}

bool ParallelCompactData::initialize_block_data(size_t region_size)

{

  const size_t count = (region_size + BlockOffsetMask) >> Log2BlockSize;

  _block_vspace = create_vspace(count, sizeof(BlockData));

  if (_block_vspace != 0) {

    _block_data = (BlockData*)_block_vspace->reserved_low_addr();

    _block_count = count;

    return true;

  }

  return false;

}

void ParallelCompactData::clear()

{

  if (_block_data) {

    memset(_block_data, 0, _block_vspace->committed_size());

  }

}

  if (_block_data) {

    memset(_block_data + beg_block, 0, block_cnt * sizeof(BlockData));

  }

}

{

  if (cur_cp < end_cp) {

    do {

      result += cur_cp->partial_obj_size();

  }

  return result;

}

void ParallelCompactData::add_obj(HeapWord* addr, size_t len)

{

  const size_t obj_ofs = pointer_delta(addr, _region_start);

  DEBUG_ONLY(Atomic::inc_ptr(&add_obj_count);)

  DEBUG_ONLY(Atomic::add_ptr(len, &add_obj_size);)

    return;

  }

  klassOop klass = ((oop)addr)->klass();

  }

}

void

ParallelCompactData::summarize_dense_prefix(HeapWord* beg, HeapWord* end)

{

  HeapWord* addr = beg;

  }

}

bool ParallelCompactData::summarize(HeapWord* target_beg, HeapWord* target_end,

                                    HeapWord* source_beg, HeapWord* source_end,

                                    HeapWord** target_next,

                                    HeapWord** source_next) {

  // This is too strict.

  if (TraceParallelOldGCSummaryPhase) {

    tty->print_cr("tb=" PTR_FORMAT " te=" PTR_FORMAT " "

                  "sb=" PTR_FORMAT " se=" PTR_FORMAT " "

                  "tn=" PTR_FORMAT " sn=" PTR_FORMAT,

                  target_beg, target_end,

                  source_beg, source_end,

                  target_next != 0 ? *target_next : (HeapWord*) 0,

                  source_next != 0 ? *source_next : (HeapWord*) 0);

  }

  HeapWord *dest_addr = target_beg;

#if     1

    assert(pointer_delta(target_end, dest_addr) >= words,

           "source region does not fit into target region");

#else

    if (dest_addr + words >= target_end) {

      // Let the caller know where to continue.

      *target_next = dest_addr;

      return false;

    }

#endif  // #if 1