/*
 *  This file is part of the Jikes RVM project (http://jikesrvm.org).
 *
 *  This file is licensed to You under the Eclipse Public License (EPL);
 *  You may not use this file except in compliance with the License. You
 *  may obtain a copy of the License at
 *
 *      http://www.opensource.org/licenses/eclipse-1.0.php
 *
 *  See the COPYRIGHT.txt file distributed with this work for information
 *  regarding copyright ownership.
 */
package org.mmtk.plan.semispace.gcspy;

import org.mmtk.plan.Phase;
import org.mmtk.plan.semispace.SS;
import org.mmtk.plan.semispace.SSCollector;
import org.mmtk.policy.CopySpace;
import org.mmtk.utility.Log;
import org.mmtk.utility.gcspy.GCspy;
import org.mmtk.utility.gcspy.drivers.LinearSpaceDriver;
import org.mmtk.vm.VM;

import org.vmmagic.unboxed.*;
import org.vmmagic.pragma.*;

/**
 * This class implements <i>per-collector thread</i> behavior and state for the
 * <i>SSGCspy</i> plan.<p>
 *
 * See {@link SSGCspy} for an overview of the GC-spy mechanisms.<p>
 *
 * @see SSCollector
 * @see SSGCspy
 * @see SSGCspyMutator
 * @see org.mmtk.plan.StopTheWorldCollector
 * @see org.mmtk.plan.CollectorContext
 * @see org.mmtk.plan.SimplePhase
 */
@Uninterruptible public class SSGCspyCollector extends SSCollector {

  /****************************************************************************
   *
   * Initialization
   */

  /*****************************************************************************
   * Instance fields
   */

  private static final boolean DEBUG = false;

  /**
   * Constructor
   */
  public SSGCspyCollector() {
    super(new SSGCspyTraceLocal(global().ssTrace));
  }


  /****************************************************************************
   *
   * Data gathering
   */

  /**
   * Perform a (local) collection phase.
   * Before a collection, we need to discover
   * <ul>
   * <li>the tospace objects copied by the collector in the last GC cycle
   * <li>the semispace objects allocated since by the mutator.
   * <li>all immortal objects allocated by the mutator
   * <li>all large objects allocated by the mutator
   * </ul>
   * After the semispace has been copied, we need to discover
   * <ul>
   * <li>the tospace objects copied by the collector
   * <li>all immortal objects allocated by the mutator
   * <li>all large objects allocated by the mutator
   * </ul>
   */
  @Inline
  public final void collectionPhase(short phaseId, boolean primary) {
    if (DEBUG) { Log.write("--Phase Collector."); Log.writeln(Phase.getName(phaseId)); }

    //TODO do we need to worry any longer about primary??
    if (phaseId == SS.PREPARE) {
      //if (primary)
        gcspyGatherData(SSGCspy.BEFORE_COLLECTION);
      super.collectionPhase(phaseId, primary);
      return;
    }

    if (phaseId == SS.FORWARD_FINALIZABLE) {
      super.collectionPhase(phaseId, primary);
      //if (primary)
        gcspyGatherData(SSGCspy.SEMISPACE_COPIED);
      return;
    }

    if (phaseId == SS.RELEASE) {
      //if (primary)
        //gcspyGatherData(SSGCspy.SEMISPACE_COPIED);
      super.collectionPhase(phaseId, primary);
      //if (primary)
        gcspyGatherData(SSGCspy.AFTER_COLLECTION);
      return;
    }

    super.collectionPhase(phaseId, primary);
  }

  /**
   * Gather data for GCspy for the semispaces only.
   * <p>
   * This method sweeps the semispace under consideration to gather data.
   * Alternatively and more efficiently, 'used space' can obviously be
   * discovered in constant time simply by comparing the start and the end
   * addresses of the semispace. However, per-object information can only be
   * gathered by sweeping through the space and we do this here for tutorial
   * purposes.
   *
   * @param event
   *          The event, either BEFORE_COLLECTION, SEMISPACE_COPIED or
   *          AFTER_COLLECTION
   */
  private void gcspyGatherData(int event) {
    if(DEBUG) {
      Log.writeln("SSGCspyCollector.gcspyGatherData, event=", event);
      Log.writeln("SSGCspyCollector.gcspyGatherData, port=", GCspy.getGCspyPort());
    }

    // If port = 0 there can be no GCspy client connected
    if (GCspy.getGCspyPort() == 0)
      return;

    // If the server is connected to a client that is interested in this
    // event, then we gather data. But first we start a timer to
    // compensate for the time spent gathering data here.
    if (GCspy.server.isConnected(event)) {

      if (DEBUG) {
        if (SSGCspy.hi)
          Log.write("\nCollector Examining Lowspace (event ", event);
        else
          Log.write("\nCollector Examining Highspace (event ", event);
        Log.write(")");
        SSGCspy.reportSpaces(); Log.writeln();
      }

      if (event == SSGCspy.BEFORE_COLLECTION) {
        if (DEBUG) debugSpaces(SSGCspy.fromSpace());

        // Just send the old values again
        if (DEBUG) {
          Log.write("SSGCspyCollector.gcspyGatherData transmit driver, ");
          Log.writeln(SSGCspy.fromSpace().getName());
        }

        fromSpaceDriver().transmit(event);
        // Mutator.gcspyGatherData follows so leave safepoint to there.
      } else if (event == SSGCspy.SEMISPACE_COPIED) {
        if (DEBUG) debugSpaces(SSGCspy.toSpace());

        // We need to reset, scan and send values for tospace
        // We'll leave resetting fromspace to AFTER_COLLECTION
        if (DEBUG) {
          Log.write("SSGCspyCollector.gcspyGatherData reset, gather and transmit driver ");
          Log.writeln(SSGCspy.toSpace().getName());
        }

        GCspy.server.startCompensationTimer();
        toSpaceDriver().resetData();
        ss.gcspyGatherData(toSpaceDriver(), SSGCspy.toSpace());
        GCspy.server.stopCompensationTimer();
        toSpaceDriver().transmit(event);

        // We'll leave the safepoint to RELEASE
      } else if (event == SSGCspy.AFTER_COLLECTION) {
        if (DEBUG) {
          Log.write("SSGCspyCollector.gcspyGatherData transmit toSpaceDriver, ");
          Log.writeln(SSGCspy.toSpace().getName());
          Log.write("SSGCspyCollector.gcspyGatherData reset fromSpaceDriver, ");
          Log.writeln(SSGCspy.fromSpace().getName());
        }

        toSpaceDriver().transmit(event);

        // Here we reset fromspace data
        fromSpaceDriver().resetData();
        Address start = SSGCspy.fromSpace().getStart();
        fromSpaceDriver().setRange(start, start);
        fromSpaceDriver().transmit(event);
      }

    }
    // else Log.write("not transmitting...");
  }

  /**
   * Print some debugging info
   * @param scannedSpace
   */
  private void debugSpaces(CopySpace scannedSpace) {
    Log.write("SSGCspyCollector.gcspyGatherData: gather data for active semispace ");
    Log.write(scannedSpace.getStart()); Log.write("-",ss.getCursor()); Log.flush();
    Log.write(". The space is: "); Log.writeln(ss.getSpace().getName());
    Log.write("scannedSpace is "); Log.writeln(scannedSpace.getName());
    Log.write("The range is "); Log.write(ss.getSpace().getStart());
    Log.write(" to "); Log.writeln(ss.getCursor());
    SSGCspy.reportSpaces();
  }

  /**
   * Reset all root streams.<p>
   */
  void resetRootStreams() {
    SSGCspy.ss0Driver.resetRootsStream();
    SSGCspy.ss1Driver.resetRootsStream();
    SSGCspy.immortalDriver.resetRootsStream();
    SSGCspy.losNurseryDriver.resetRootsStream();
    SSGCspy.losDriver.resetRootsStream();
    SSGCspy.plosNurseryDriver.resetRootsStream();
    SSGCspy.plosDriver.resetRootsStream();
    ss.getCursor();
  }

  /**
   * Pass a root to all drivers.<p>
   * @param addr The Address of the object to be checked
   */
  protected void checkAllDriversForRootAddress(Address addr) {
    if(addr.isZero())
      return;

    SSGCspy.ss0Driver.handleRoot(addr);
    SSGCspy.ss1Driver.handleRoot(addr);
    SSGCspy.immortalDriver.handleRoot(addr);
    SSGCspy.losNurseryDriver.handleRoot(addr);
    SSGCspy.losDriver.handleRoot(addr);
    SSGCspy.plosNurseryDriver.handleRoot(addr);
    SSGCspy.plosDriver.handleRoot(addr);
  }

  /****************************************************************************
   *
   * Miscellaneous
   */

  /** @return The active global plan as an <code>SSGCspy</code> instance. */
  @Inline
  private static SSGCspy global() {
    return (SSGCspy) VM.activePlan.global();
  }

  /** @return the driver for toSpace */
  private LinearSpaceDriver toSpaceDriver() {
    return SSGCspy.hi ? SSGCspy.ss1Driver : SSGCspy.ss0Driver;
  }

  /** @return the driver for fromSpace */
  private LinearSpaceDriver fromSpaceDriver() {
    return SSGCspy.hi ? SSGCspy.ss0Driver : SSGCspy.ss1Driver;
  }
}