/*
 *  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.utility.gcspy.drivers;

import org.mmtk.policy.Space;
import org.mmtk.utility.Log;
import org.mmtk.utility.gcspy.GCspy;
import org.mmtk.utility.gcspy.Subspace;
import org.mmtk.vm.gcspy.ServerSpace;
import org.mmtk.vm.gcspy.ServerInterpreter;
import org.mmtk.vm.gcspy.Stream;
import org.mmtk.vm.VM;

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

/**
 * Abstract GCspy driver for MMTk collectors.
 *
 * This class implements for the MMTk a base driver for a GCspy space.
 * All drivers for GCspy spaces should inherit from this class.
 */
@Uninterruptible
public abstract class AbstractDriver {

  /****************************************************************************
   *
   * Class variables
   */

  // Controls used for tile presentation
  /** The tile is used */
  protected static final byte CONTROL_USED            =  1;
  /** The tile is a background tile */
  protected static final byte CONTROL_BACKGROUND      =  2;
  /** The tile is unused */
  protected static final byte CONTROL_UNUSED          =  4;
  /** The tile is a separator */
  protected static final byte CONTROL_SEPARATOR       =  8;
  /** The tile is a link */
  protected static final byte CONTROL_LINK            = 16;


  private static final int MAX_STREAMS = 64;    // Max number of streams

  private static final boolean DEBUG = false;
  protected String myClass;                     // used in debugging messages


  /****************************************************************************
   *
   * Instance variables
   */

  /** The owning GCspy server */
  protected final ServerInterpreter server;
  /** The name of the GCspy space driver */
  protected final String name;
  /** The GCspy space abstraction */
  protected final ServerSpace serverSpace;
  /** The MMTK space */
  protected final Space mmtkSpace;
  /** The GCspy space's block size */
  protected int blockSize;
  /** The maximum number of tiles in this GCspy space */
  protected int maxTileNum;
  /** This space's streams  */
  protected Stream[] streams;
  /**  control values for tiles in this space */
  protected byte[] control;
  /** Has this space changed? */
  protected boolean changed = true;


  /**
   * Create a new driver for this collector.
   *
   * @param server The ServerInterpreter that owns this GCspy space.
   * @param name The name of this driver.
   * @param mmtkSpace The MMTk space represented by this driver.
   * @param blockSize The tile size.
   * @param mainSpace Is this the main space?
   */
  public AbstractDriver(ServerInterpreter server,
                        String name,
                        Space mmtkSpace,
                        int blockSize,
                        boolean mainSpace) {
    this.server = server;
    this.name = name;
    this.mmtkSpace = mmtkSpace;
    this.blockSize = blockSize;
    myClass = getClass().getName();
    maxTileNum = countTileNum(mmtkSpace.getExtent(), blockSize);
    control = (byte[])GCspy.util.createDataArray(new byte[0], maxTileNum);
    // to avoid allocation during GC we preallocate the streams array
    streams = new Stream[MAX_STREAMS];
    serverSpace = createServerSpace(server, name, maxTileNum, mainSpace);
  }

  /**
   * Create a subspace for this space.
   * Subspace provide useful facilities for contiguous spaces, even if
   * a space contains only one.
   * @param mmtkSpace The MMTk space
   */
  @Interruptible
  protected Subspace createSubspace(Space mmtkSpace) {
    Address start = mmtkSpace.getStart();
    return new Subspace(start, start, 0, blockSize, 0);
  }

  /**
   * Create a new GCspy ServerSpace and add it to the ServerInterpreter.
   * @param server the GCspy ServerInterpreter.
   * @param spaceName The name of this driver.
   * @param maxTileNum the maximum number of tiles in this space.
   * @param mainSpace Is this the main space?
   */
  @Interruptible
  protected ServerSpace createServerSpace(ServerInterpreter server,
                  String spaceName,
                  int maxTileNum,
                  boolean mainSpace) {
    // Set the block label
    String tmp = "Block Size: " + ((blockSize < 1024) ?
                     blockSize + " bytes\n":
                     (blockSize / 1024) + " Kbytes\n");

    // Create a single GCspy Space
    return VM.newGCspyServerSpace(server,           // the server
                                  spaceName,        // space name
                                  getDriverName(),  // driver (space) name
                                  "Block ",         // space title
                                  tmp,              // block info
                                  maxTileNum,       // number of tiles
                                  "UNUSED",         // the label for unused blocks
                                  mainSpace);       // main space
  }

  /**
   * Get the name of this driver type.
   * @return The name of this driver.
   */
  protected abstract String getDriverName();

  /**
   * Get the maximum number of tiles in this space.
   * @return the maximum number of tiles in the space.
   */
  public int getMaxTileNum() {
    return maxTileNum;
  }

  /**
   * The GCspy space managed by this driver.
   * @return the GCspy server space.
   */
  public ServerSpace getServerSpace() { return serverSpace; }

  /**
   * Add a stream to the driver. This also sets the stream's id
   * (unique for this space).
   * @param stream The stream
   * @exception IndexOutOfBoundsException if more than MAX_STREAMS are added
   */
  @Interruptible
  public void addStream(Stream stream) {
    int id = 0;
    while (id < MAX_STREAMS) {
      if (streams[id] == null) {
        streams[id] = stream;
        if (DEBUG) { Log.write("Adding stream with id="); Log.writeln(id); }
        Address stream_ = serverSpace.addStream(id);
        stream.setStream(id, stream_);
        return;
      }
      id++;
    }
    throw new IndexOutOfBoundsException("Too many streams added to driver "+name);
  }

  /**
   * Count number of tiles in an address range.
   * @param start The start of the range.
   * @param end The end of the range.
   * @param tileSize The size of each tile.
   * @return The number of tiles in this range.
   */
  protected int countTileNum(Address start, Address end, int tileSize) {
    if (end.LE(start)) return 0;
    int diff = end.diff(start).toInt();
    return countTileNum(diff, tileSize);
  }

  /**
   * Count number of tiles in an address range.
   * @param extent The extent of the range.
   * @param tileSize The size of each tile.
   * @return The number of tiles in this range.
   */
  protected int countTileNum(Extent extent, int tileSize) {
    int diff = extent.toInt();
    return countTileNum(diff, tileSize);
  }

  private int countTileNum(int diff, int tileSize) {
    int tiles = diff / tileSize;
    if ((diff % tileSize) != 0)
      ++tiles;
    return tiles;
  }

  /**
   * Indicate the limits of a space.
   *
   * @param start the Address of the start of the space.
   * @param end the Address of the end of the space.
   */
  public void setRange(Address start, Address end) {}

  /**
   * Indicate the limits of a space.
   *
   * @param start the Address of the start of the space.
   * @param extent the extent of the space.
   */
  public void setRange(Address start, Extent extent) {
    setRange(start, start.plus(extent));
  }

  /**
   * Setup the tile names in a subspace. Tile names are typically
   * address ranges but may be anything (e.g. a size class if the
   * space is a segregated free-list manager, or a class name if the
   * space represents the class instances loaded).
   *
   * @param subspace the Subspace
   * @param numTiles the number of tiles to name
   */
  protected void setTilenames(Subspace subspace, int numTiles) {
    Address start = subspace.getStart();
    int first = subspace.getFirstIndex();
    int bs = subspace.getBlockSize();

    for (int i = 0; i < numTiles; ++i) {
      if (subspace.indexInRange(i))
        serverSpace.setTilename(i, start.plus((i - first) * bs),
                                start.plus((i + 1 - first) * bs));
    }
  }

  /**
   * The "typical" maximum number of objects in each tile.
   * @param blockSize The size of a tile
   * @return The maximum number of objects in a tile
   */
  public int maxObjectsPerBlock(int blockSize) {
    // Maybe a misuse of ServerInterpreter but it's a convenient
    // VM-dependent class
    return blockSize / GCspy.server.computeHeaderSize();
  }

  /**
   * Is the server connected to a GCspy client?
   * @param event The current event
   */
  public boolean isConnected(int event) {
    return server.isConnected(event);
  }

  /**
   * Reset the statistics for a space.
   * In this base driver, we simply note that the data has changed.
   */
  protected void resetData() { changed = true; }

  /**
   * Scan an object found at a location.
   * Collectors typically call this method to update GCspy statistics.
   * The driver may or may not accumulate values found, depending on
   * the value of total.
   * @param obj the reference to the object found
   * @param total Whether to total the statistics
   */
  public void scan(ObjectReference obj, boolean total) {}

  /**
   * Scan an object found at a location.
   * Collectors typically call this method to update GCspy statistics
   * The driver will accumulate values found.
   * @param obj the reference to the object found
   */
  public void scan(ObjectReference obj) { scan(obj, true); }

  /**
   * Scan an object found at a location.
   * Collectors typically call this method to update GCspy statistics.
   * The driver may or may not accumulate values found, depending on
   * the value of total.
   * @param obj the reference to the object found
   * @param total Whether to total the statistics
   */
  public void scan(Address obj, boolean total) {}

  /**
   * Scan an object found at a location.
   * Collectors typically call this method to update GCspy statistics
   * The driver will accumulate values found.
   * @param obj the reference to the object found
   */
  public void scan(Address obj) {}

  /**
   * Handle a direct reference from the immortal space.<p>
   * This is an empty implementation. Subclasses may override this method
   * to increment their <code>refFromImmortal</code> Stream.
   *
   * @param addr The Address
   * @return true if the given Address is in this subspace. Always false here.
   */
  public boolean handleReferenceFromImmortalSpace(Address addr) {
    return false;
  }

  /**
   * Set space info.
   * This simply reports the size of the current space.
   * Drivers that want to send something more complex than
   *  "Current Size: size\n"
   * must override this method.
   *
   * @param size the size of the space
   */
  protected void setSpaceInfo(Offset size) {
    //    - sprintf(tmp, "Current Size: %s\n", gcspy_formatSize(size));
    Address tmp = GCspy.util.formatSize("Current Size: %s\n", 128, size.toInt());
    serverSpace.spaceInfo(tmp);
    GCspy.util.free(tmp);
  }


  /****************************************************************************
   *
   * Control values
   */

  /**
   * Is a tile used?
   * @param val the control value.
   * @return true if the tile is used
   */
  protected static boolean controlIsUsed(byte val) {
    return (val & CONTROL_USED) != 0;
  }

  /**
   * Is a tile a background pseudo-tile?
   * @param val the control value.
   * @return true if the tile is a background tile
   */
  protected static boolean controlIsBackground(byte val) {
    return (val & CONTROL_BACKGROUND) != 0;
  }

  /**
   * Is a tile unused?
   * @param val the control value.
   * @return true if the tile is unused
   */
  protected static boolean controlIsUnused(byte val) {
    return (val & CONTROL_UNUSED) != 0;
  }

  /**
   * Is this a separator?
   * @param val the control value.
   * @return true if this is a separator
   */
  protected static boolean controlIsSeparator(byte val) {
    return (val & CONTROL_SEPARATOR) != 0;
  }

  /**
   * Initialise the value of a control.
   * @param index The index of the tile.
   * @param value The new value of the control
   */
  protected void initControl(int index, byte value) {
    control[index] = value;
  }

  /**
   * Add a control to the tile
   * @param index The index of the tile.
   * @param value The control to add.
   */
  protected void addControl(int index, byte value) {
    control[index] |= value;
  }

  /** Set the control
   * @param value The value to set
   */
  protected void setControl(int index, byte value) {
    control[index] &= value;
  }

  /**
   * Get the controls for a tile.
   * @param index The index of the tile.
   * @return The value of the controls
   */
  public byte getControl(int index) {
    return control[index];
  }

  /**
   * Initialise control values in all tiles
   */
  protected void initControls() {
    for (int index = 0; index < control.length; ++index) {
      initControl(index, CONTROL_USED);
    }
  }

  /**
   * Set the control value in each tile in a region.
   * @param tag The control tag.
   * @param start The start index of the region.
   * @param len The number of tiles in the region.
   */
  protected void controlValues(byte tag, int start, int len) {
    if (DEBUG) {
      Log.write("AbstractDriver.controlValues for space ");
      Log.write(name);
      Log.write(", control length=", control.length);
      Log.write(" writing controls from ", start);
      Log.writeln(" to ", start + len);
    }
    changed = true;
    for (int i = start; i < (start+len); ++i) {
      // Cannot be both USED and UNUSED or BACKGROUND
      if (controlIsBackground(tag) || controlIsUnused(tag))
        setControl(i, (byte)~CONTROL_USED);
      else if (controlIsUsed(tag))
        setControl(i, (byte)~CONTROL_UNUSED);
      addControl(i, tag);
    }
  }

  /**
   * Transmit the streams for this space. A driver will typically
   * <ol>
   * <li> Determine whether a GCspy client is connected and interested in
   *      this event, e.g.
   *      <pre>server.isConnected(event)</pre>
   * <li> Setup the summaries for each stream, e.g.
   *      <pre>stream.setSummary(values...);</pre>
   * <li> Setup the control information for each tile. e.g.
   *      <pre>controlValues(CONTROL_USED, start, numBlocks);</pre>
   *      <pre>controlValues(CONTROL_UNUSED, end, remainingBlocks);</pre>
   * <li> Set up the space information, e.g.
   *      <pre>setSpace(info);</pre>
   * <li> Send the data for all streams, e.g.
   *      <pre>send(event, numTiles);</pre>
   *      Note that AbstractDriver.send takes care of sending the information
   *      for all streams (including control data).
   *
   * @param event The event
   */
  public abstract void transmit(int event);

  /**
   * Send all the streams for this space if it has changed.
   * Assume that the data has been gathered and that summary info
   * and control values have been set before this is called.
   *
   * @param event the event
   * @param numTiles the number of blocks in this space
   */
  protected void send(int event, int numTiles) {
    if (changed) {
      serverSpace.startCommunication();
      for (int i = 0; i < MAX_STREAMS; i++)
        if (streams[i] != null)
          streams[i].send(event, numTiles);
      serverSpace.sendControls(this, numTiles);
      serverSpace.endCommunication();
    }
  }
}