/*

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

 *

 */

#include "precompiled.hpp"

#include "classfile/systemDictionary.hpp"

#include "gc_implementation/parallelScavenge/objectStartArray.hpp"

#include "gc_implementation/parallelScavenge/parallelScavengeHeap.hpp"

#include "gc_implementation/parallelScavenge/psMarkSweep.hpp"

#include "gc_implementation/parallelScavenge/psMarkSweepDecorator.hpp"

#include "gc_implementation/shared/liveRange.hpp"

#include "gc_implementation/shared/markSweep.inline.hpp"

#include "gc_implementation/shared/spaceDecorator.hpp"

#include "oops/oop.inline.hpp"

PSMarkSweepDecorator* PSMarkSweepDecorator::_destination_decorator = NULL;

void PSMarkSweepDecorator::set_destination_decorator_tenured() {

  ParallelScavengeHeap* heap = (ParallelScavengeHeap*)Universe::heap();

  assert(heap->kind() == CollectedHeap::ParallelScavengeHeap, "Sanity");

  _destination_decorator = heap->old_gen()->object_mark_sweep();

}

void PSMarkSweepDecorator::advance_destination_decorator() {

  ParallelScavengeHeap* heap = (ParallelScavengeHeap*)Universe::heap();

  assert(heap->kind() == CollectedHeap::ParallelScavengeHeap, "Sanity");

  assert(_destination_decorator != NULL, "Sanity");

  PSMarkSweepDecorator* first = heap->old_gen()->object_mark_sweep();

  PSMarkSweepDecorator* second = heap->young_gen()->eden_mark_sweep();

  PSMarkSweepDecorator* third = heap->young_gen()->from_mark_sweep();

  PSMarkSweepDecorator* fourth = heap->young_gen()->to_mark_sweep();

  if ( _destination_decorator == first ) {

    _destination_decorator = second;

  } else if ( _destination_decorator == second ) {

    _destination_decorator = third;

  } else if ( _destination_decorator == third ) {

    _destination_decorator = fourth;

  } else {

    fatal("PSMarkSweep attempting to advance past last compaction area");

  }

}

PSMarkSweepDecorator* PSMarkSweepDecorator::destination_decorator() {

  assert(_destination_decorator != NULL, "Sanity");

  return _destination_decorator;

}

// FIX ME FIX ME FIX ME FIX ME!!!!!!!!!

// The object forwarding code is duplicated. Factor this out!!!!!

//

// This method "precompacts" objects inside its space to dest. It places forwarding

// pointers into markOops for use by adjust_pointers. If "dest" should overflow, we

// finish by compacting into our own space.

void PSMarkSweepDecorator::precompact() {

  // Reset our own compact top.

  set_compaction_top(space()->bottom());

  /* We allow some amount of garbage towards the bottom of the space, so

   * we don't start compacting before there is a significant gain to be made.

   * Occasionally, we want to ensure a full compaction, which is determined

   * by the MarkSweepAlwaysCompactCount parameter. This is a significant

   * performance improvement!

   */

  bool skip_dead = (MarkSweepAlwaysCompactCount < 1)

    || ((PSMarkSweep::total_invocations() % MarkSweepAlwaysCompactCount) != 0);

  size_t allowed_deadspace = 0;

  if (skip_dead) {

    const size_t ratio = allowed_dead_ratio();

    allowed_deadspace = space()->capacity_in_words() * ratio / 100;

  }

  // Fetch the current destination decorator

  PSMarkSweepDecorator* dest = destination_decorator();

  ObjectStartArray* start_array = dest->start_array();

  HeapWord* compact_top = dest->compaction_top();

  HeapWord* compact_end = dest->space()->end();

  HeapWord* q = space()->bottom();

  HeapWord* t = space()->top();

  HeapWord*  end_of_live= q;    /* One byte beyond the last byte of the last

                                   live object. */

  HeapWord*  first_dead = space()->end(); /* The first dead object. */

  LiveRange* liveRange  = NULL; /* The current live range, recorded in the

                                   first header of preceding free area. */

  _first_dead = first_dead;

  const intx interval = PrefetchScanIntervalInBytes;

  while (q < t) {

    assert(oop(q)->mark()->is_marked() || oop(q)->mark()->is_unlocked() ||

           oop(q)->mark()->has_bias_pattern(),

           "these are the only valid states during a mark sweep");

    if (oop(q)->is_gc_marked()) {

      /* prefetch beyond q */

      Prefetch::write(q, interval);

      size_t size = oop(q)->size();

      size_t compaction_max_size = pointer_delta(compact_end, compact_top);

      // This should only happen if a space in the young gen overflows the

      // old gen. If that should happen, we null out the start_array, because

      // the young spaces are not covered by one.

      while(size > compaction_max_size) {

        // First record the last compact_top

        dest->set_compaction_top(compact_top);

        // Advance to the next compaction decorator

        advance_destination_decorator();

        dest = destination_decorator();

        // Update compaction info

        start_array = dest->start_array();

        compact_top = dest->compaction_top();

        compact_end = dest->space()->end();

        assert(compact_top == dest->space()->bottom(), "Advanced to space already in use");

        assert(compact_end > compact_top, "Must always be space remaining");

        compaction_max_size =

          pointer_delta(compact_end, compact_top);

      }

      // store the forwarding pointer into the mark word

      if (q != compact_top) {

        oop(q)->forward_to(oop(compact_top));

        assert(oop(q)->is_gc_marked(), "encoding the pointer should preserve the mark");

      } else {

        // if the object isn't moving we can just set the mark to the default

        // mark and handle it specially later on.

        oop(q)->init_mark();

        assert(oop(q)->forwardee() == NULL, "should be forwarded to NULL");

      }

      // Update object start array

      if (start_array) {

        start_array->allocate_block(compact_top);

      }

      VALIDATE_MARK_SWEEP_ONLY(MarkSweep::register_live_oop(oop(q), size));

      compact_top += size;

      assert(compact_top <= dest->space()->end(),

        "Exceeding space in destination");

      q += size;

      end_of_live = q;

    } else {

      /* run over all the contiguous dead objects */

      HeapWord* end = q;

      do {

        /* prefetch beyond end */

        Prefetch::write(end, interval);

        end += oop(end)->size();

      } while (end < t && (!oop(end)->is_gc_marked()));

      /* see if we might want to pretend this object is alive so that

       * we don't have to compact quite as often.

       */

      if (allowed_deadspace > 0 && q == compact_top) {

        size_t sz = pointer_delta(end, q);

        if (insert_deadspace(allowed_deadspace, q, sz)) {

          size_t compaction_max_size = pointer_delta(compact_end, compact_top);

          // This should only happen if a space in the young gen overflows the

          // old gen. If that should happen, we null out the start_array, because

          // the young spaces are not covered by one.

          while (sz > compaction_max_size) {

            // First record the last compact_top

            dest->set_compaction_top(compact_top);

            // Advance to the next compaction decorator

            advance_destination_decorator();

            dest = destination_decorator();

            // Update compaction info

            start_array = dest->start_array();

            compact_top = dest->compaction_top();

            compact_end = dest->space()->end();

            assert(compact_top == dest->space()->bottom(), "Advanced to space already in use");

            assert(compact_end > compact_top, "Must always be space remaining");

            compaction_max_size =

              pointer_delta(compact_end, compact_top);

          }

          // store the forwarding pointer into the mark word

          if (q != compact_top) {

            oop(q)->forward_to(oop(compact_top));

            assert(oop(q)->is_gc_marked(), "encoding the pointer should preserve the mark");

          } else {

            // if the object isn't moving we can just set the mark to the default

            // mark and handle it specially later on.

            oop(q)->init_mark();

            assert(oop(q)->forwardee() == NULL, "should be forwarded to NULL");

          }

          // Update object start array

          if (start_array) {

            start_array->allocate_block(compact_top);

          }

          VALIDATE_MARK_SWEEP_ONLY(MarkSweep::register_live_oop(oop(q), sz));

          compact_top += sz;

          assert(compact_top <= dest->space()->end(),

            "Exceeding space in destination");

          q = end;

          end_of_live = end;

          continue;

        }

      }

      /* for the previous LiveRange, record the end of the live objects. */

      if (liveRange) {

        liveRange->set_end(q);

      }

      /* record the current LiveRange object.

       * liveRange->start() is overlaid on the mark word.

       */

      liveRange = (LiveRange*)q;

      liveRange->set_start(end);

      liveRange->set_end(end);

      /* see if this is the first dead region. */

      if (q < first_dead) {

        first_dead = q;

      }

      /* move on to the next object */

      q = end;

    }

  }

  assert(q == t, "just checking");

  if (liveRange != NULL) {

    liveRange->set_end(q);

  }

  _end_of_live = end_of_live;

  if (end_of_live < first_dead) {

    first_dead = end_of_live;

  }

  _first_dead = first_dead;

  // Update compaction top

  dest->set_compaction_top(compact_top);

}

bool PSMarkSweepDecorator::insert_deadspace(size_t& allowed_deadspace_words,

                                            HeapWord* q, size_t deadlength) {

  if (allowed_deadspace_words >= deadlength) {

    allowed_deadspace_words -= deadlength;

    CollectedHeap::fill_with_object(q, deadlength);

    oop(q)->set_mark(oop(q)->mark()->set_marked());

    assert((int) deadlength == oop(q)->size(), "bad filler object size");

    // Recall that we required "q == compaction_top".

    return true;

  } else {

    allowed_deadspace_words = 0;

    return false;

  }

}

void PSMarkSweepDecorator::adjust_pointers() {

  // adjust all the interior pointers to point at the new locations of objects

  // Used by MarkSweep::mark_sweep_phase3()

  HeapWord* q = space()->bottom();

  HeapWord* t = _end_of_live;  // Established by "prepare_for_compaction".

  assert(_first_dead <= _end_of_live, "Stands to reason, no?");

  if (q < t && _first_dead > q &&

      !oop(q)->is_gc_marked()) {

    // we have a chunk of the space which hasn't moved and we've

    // reinitialized the mark word during the previous pass, so we can't

    // use is_gc_marked for the traversal.

    HeapWord* end = _first_dead;

    while (q < end) {

      VALIDATE_MARK_SWEEP_ONLY(MarkSweep::track_interior_pointers(oop(q)));

      // point all the oops to the new location

      size_t size = oop(q)->adjust_pointers();

      VALIDATE_MARK_SWEEP_ONLY(MarkSweep::check_interior_pointers());

      VALIDATE_MARK_SWEEP_ONLY(MarkSweep::validate_live_oop(oop(q), size));

      q += size;

    }

    if (_first_dead == t) {

      q = t;

    } else {

      // $$$ This is funky.  Using this to read the previously written

      // LiveRange.  See also use below.

      q = (HeapWord*)oop(_first_dead)->mark()->decode_pointer();

    }

  }

  const intx interval = PrefetchScanIntervalInBytes;

  debug_only(HeapWord* prev_q = NULL);

  while (q < t) {

    // prefetch beyond q

    Prefetch::write(q, interval);

    if (oop(q)->is_gc_marked()) {

      // q is alive

      VALIDATE_MARK_SWEEP_ONLY(MarkSweep::track_interior_pointers(oop(q)));

      // point all the oops to the new location

      size_t size = oop(q)->adjust_pointers();

      VALIDATE_MARK_SWEEP_ONLY(MarkSweep::check_interior_pointers());

      VALIDATE_MARK_SWEEP_ONLY(MarkSweep::validate_live_oop(oop(q), size));

      debug_only(prev_q = q);

      q += size;

    } else {

      // q is not a live object, so its mark should point at the next

      // live object

      debug_only(prev_q = q);

      q = (HeapWord*) oop(q)->mark()->decode_pointer();

      assert(q > prev_q, "we should be moving forward through memory");

    }

  }

  assert(q == t, "just checking");

}

void PSMarkSweepDecorator::compact(bool mangle_free_space ) {

  // Copy all live objects to their new location

  // Used by MarkSweep::mark_sweep_phase4()

  HeapWord*       q = space()->bottom();

  HeapWord* const t = _end_of_live;

  debug_only(HeapWord* prev_q = NULL);

  if (q < t && _first_dead > q &&

      !oop(q)->is_gc_marked()) {

#ifdef ASSERT

    // we have a chunk of the space which hasn't moved and we've reinitialized the

    // mark word during the previous pass, so we can't use is_gc_marked for the

    // traversal.

    HeapWord* const end = _first_dead;

    while (q < end) {

      size_t size = oop(q)->size();

      assert(!oop(q)->is_gc_marked(), "should be unmarked (special dense prefix handling)");

      VALIDATE_MARK_SWEEP_ONLY(MarkSweep::live_oop_moved_to(q, size, q));

      debug_only(prev_q = q);

      q += size;

    }

#endif

    if (_first_dead == t) {

      q = t;

    } else {

      // $$$ Funky

      q = (HeapWord*) oop(_first_dead)->mark()->decode_pointer();

    }

  }

  const intx scan_interval = PrefetchScanIntervalInBytes;

  const intx copy_interval = PrefetchCopyIntervalInBytes;

  while (q < t) {

    if (!oop(q)->is_gc_marked()) {

      // mark is pointer to next marked oop

      debug_only(prev_q = q);

      q = (HeapWord*) oop(q)->mark()->decode_pointer();

      assert(q > prev_q, "we should be moving forward through memory");

    } else {

      // prefetch beyond q

      Prefetch::read(q, scan_interval);

      // size and destination

      size_t size = oop(q)->size();

      HeapWord* compaction_top = (HeapWord*)oop(q)->forwardee();

      // prefetch beyond compaction_top

      Prefetch::write(compaction_top, copy_interval);

      // copy object and reinit its mark

      VALIDATE_MARK_SWEEP_ONLY(MarkSweep::live_oop_moved_to(q, size, compaction_top));

      assert(q != compaction_top, "everything in this pass should be moving");

      Copy::aligned_conjoint_words(q, compaction_top, size);

      oop(compaction_top)->init_mark();

      assert(oop(compaction_top)->klass() != NULL, "should have a class");

      debug_only(prev_q = q);

      q += size;

    }

  }

  assert(compaction_top() >= space()->bottom() && compaction_top() <= space()->end(),

         "should point inside space");

  space()->set_top(compaction_top());

  if (mangle_free_space) {

    space()->mangle_unused_area();

  }

}