/*
 *  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.alloc;

import static org.mmtk.utility.Constants.*;

import org.mmtk.policy.Space;
import org.mmtk.utility.*;

import org.mmtk.vm.VM;

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

/**
 * This class implements "block" data structures of various sizes.<p>
 *
 * Blocks are a non-shared (thread-local) coarse-grained unit of
 * storage. Blocks are available in power-of-two sizes.<p>
 *
 * Virtual memory space is taken from a VM resource, and pages
 * consumed by blocks are accounted for by a memory resource.
 */
@Uninterruptible
public final class BlockAllocator {
  /****************************************************************************
   *
   * Class variables
   */

  /**
  *
  */

  // block freelist
  public static final int LOG_MIN_BLOCK = 12; // 4K bytes
  public static final int LOG_MAX_BLOCK = 15; // 32K bytes
  public static final byte MAX_BLOCK_SIZE_CLASS = LOG_MAX_BLOCK - LOG_MIN_BLOCK;
  public static final int BLOCK_SIZE_CLASSES = MAX_BLOCK_SIZE_CLASS + 1;

  // metadata
  private static final Offset NEXT_OFFSET = Offset.zero();
  private static final Offset BMD_OFFSET = NEXT_OFFSET.plus(BYTES_IN_ADDRESS);
  private static final Offset CSC_OFFSET = BMD_OFFSET.plus(1);
  private static final Offset IU_OFFSET = CSC_OFFSET.plus(1);
  private static final Offset FL_META_OFFSET = IU_OFFSET.plus(BYTES_IN_SHORT);
  private static final byte BLOCK_SC_MASK = 0xf;             // lower 4 bits
  private static final int BLOCK_PAGE_OFFSET_SHIFT = 4;      // higher 4 bits
  private static final int MAX_BLOCK_PAGE_OFFSET = (1 << 4) - 1; // 4 bits
  private static final int LOG_BYTES_IN_BLOCK_META = LOG_BYTES_IN_ADDRESS + 2;
  private static final int LOG_BYTE_COVERAGE = LOG_MIN_BLOCK - LOG_BYTES_IN_BLOCK_META;

  public static final int META_DATA_BYTES_PER_REGION = 1 << (EmbeddedMetaData.LOG_BYTES_IN_REGION - LOG_BYTE_COVERAGE);
  public static final Extent META_DATA_EXTENT = Extent.fromIntSignExtend(META_DATA_BYTES_PER_REGION);

  /****************************************************************************
   *
   * Allocation & freeing
   */

  /**
   * Allocate a block, returning the address of the first usable byte
   * in the block.
   *
   * @param space the space to request the memory from
   * @param blockSizeClass The size class for the block to be allocated.
   * @return The address of the first usable byte in the block, or
   * zero on failure.
   */
  public static Address alloc(Space space, int blockSizeClass) {
    if (VM.VERIFY_ASSERTIONS) VM.assertions._assert((blockSizeClass >= 0) && (blockSizeClass <= MAX_BLOCK_SIZE_CLASS));
    int pages = pagesForSizeClass(blockSizeClass);
    Address result = space.acquire(pages);
    if (!result.isZero()) {
      setBlkSizeMetaData(result, (byte) blockSizeClass);
    }
    return result;
  }

  /**
   * Free a block.  If the block is a sub-page block and the page is
   * not completely free, then the block is added to the free list.
   * Otherwise the block is returned to the virtual memory resource.
   *
   * @param space the space that contains the block
   * @param block The address of the block to be freed
   */
  public static void free(Space space, Address block) {
    space.release(block);
  }

  /**
   * Return the size in bytes of a block of a given size class
   *
   * @param blockSizeClass The size class in question
   * @return The size in bytes of a block of this size class
   */
  @Inline
  public static int blockSize(int blockSizeClass) {
    return 1 << (LOG_MIN_BLOCK + blockSizeClass);
  }

  /**
   * Return the number of pages required when allocating space for
   *         this size class.
   *
   * @param blockSizeClass The size class in question
   * @return The number of pages required when allocating a block (or
   * blocks) of this size class.
   */
  @Inline
  private static int pagesForSizeClass(int blockSizeClass) {
    return 1 << (LOG_MIN_BLOCK + blockSizeClass - LOG_BYTES_IN_PAGE);
  }

  /****************************************************************************
   *
   * Block meta-data manipulation
   */

  /**
   * Set the <i>block size class</i> meta data field for a given
   * address (all blocks on a given page are homogeneous with respect
   * to block size class).
   *
   * @param block The address of interest
   * @param sc The value to which this field is to be set
   */
  @Inline
  private static void setBlkSizeMetaData(Address block, byte sc) {
    if (VM.VERIFY_ASSERTIONS) {
      VM.assertions._assert(block.EQ(Conversions.pageAlign(block)));
      VM.assertions._assert(pagesForSizeClass(sc) - 1  <= MAX_BLOCK_PAGE_OFFSET);
    }
    Address address = block;
    for (int i = 0; i < pagesForSizeClass(sc); i++) {
      byte value = (byte) ((i << BLOCK_PAGE_OFFSET_SHIFT) | sc);
      getMetaAddress(address).store(value, BMD_OFFSET);
      if (VM.VERIFY_ASSERTIONS) {
        VM.assertions._assert(getBlkStart(address).EQ(block));
        VM.assertions._assert(getBlkSizeClass(address) == sc);
      }
      address = address.plus(1 << VM.LOG_BYTES_IN_PAGE);
    }
  }

  /**
   * Get the <i>block size class</i> meta data field for a given page
   * (all blocks on a given page are homogeneous with respect to block
   * size class).
   *
   * @param address The address of interest
   * @return The size class field for the block containing the given address
   */
  @Inline
  private static byte getBlkSizeClass(Address address) {
    address = Conversions.pageAlign(address);
    byte rtn = (byte) (getMetaAddress(address).loadByte(BMD_OFFSET) & BLOCK_SC_MASK);
    if (VM.VERIFY_ASSERTIONS) VM.assertions._assert(rtn >= 0 && rtn <= MAX_BLOCK_SIZE_CLASS);
    return rtn;
  }

  /**
   * Get the <i>address of the start of a block size class</i> a given page
   * within the block.
   *
   * @param address The address of interest
   * @return The address of the block containing the address
   */
  @Inline
  public static Address getBlkStart(Address address) {
    address = Conversions.pageAlign(address);
    byte offset = (byte) (getMetaAddress(address).loadByte(BMD_OFFSET) >>> BLOCK_PAGE_OFFSET_SHIFT);
    return address.minus(offset << LOG_BYTES_IN_PAGE);
  }

  /**
   * Set the <i>client size class</i> meta data field for a given
   * address (all blocks on a given page are homogeneous with respect
   * to block size class).
   *
   * @param block The address of interest
   * @param blocksc the block's size class
   * @param sc The value to which this field is to be set
   */
  @Inline
  public static void setAllClientSizeClass(Address block, int blocksc, byte sc) {
    if (VM.VERIFY_ASSERTIONS) VM.assertions._assert(block.EQ(Conversions.pageAlign(block)));
    Address address = block;
    for (int i = 0; i < pagesForSizeClass(blocksc); i++) {
      getMetaAddress(address).store(sc, CSC_OFFSET);
      address = address.plus(1 << VM.LOG_BYTES_IN_PAGE);
    }
  }

  /**
   * Get the <i>client size class</i> meta data field for a given page
   * (all blocks on a given page are homogeneous with respect to block
   * size class).
   *
   * @param address The address of interest
   * @return The size class field for the block containing the given address
   */
  @Inline
  public static byte getClientSizeClass(Address address) {
    address = Conversions.pageAlign(address);
    byte rtn = getMetaAddress(address).loadByte(CSC_OFFSET);
    return rtn;
  }

  /**
   * Set the free list meta data field for a given address (this is
   * per-block meta data that is stored along with the block metadata
   * but not used by the block allocator).
   *
   * @param address The address of interest
   * @param value The value to which this field is to be set
   */
  @Inline
  public static void setFreeListMeta(Address address, Address value) {
    getMetaAddress(address).plus(FL_META_OFFSET).store(value);
  }

  /**
   * Get the free list meta data field for a given address (this is
   * per-block meta data that is stored along with the block metadata
   * but not used by the block allocator).
   *
   * @param address The address of interest
   * @return The free list meta data field for the block containing
   * the given address
   */
  @Inline
  public static Address getFreeListMeta(Address address) {
    return getMetaAddress(address).plus(FL_META_OFFSET).loadAddress();
  }

  /**
   * Set the <i>prev</i> meta data field for a given address
   *
   * @param address The address of interest
   * @param prev The value to which this field is to be set
   */
  @Inline
  public static void setNext(Address address, Address prev) {
    getMetaAddress(address, NEXT_OFFSET).store(prev);
  }

  /**
   * Get the <i>prev</i> meta data field for a given address
   *
   * @param address The address of interest
   * @return The prev field for the block containing the given address
   */
  @Inline
  public static Address getNext(Address address) {
    return getMetaAddress(address, NEXT_OFFSET).loadAddress();
  }

  /**
   * Get the address of some metadata given the address for which the
   * metadata is required and the offset into the metadata that is of
   * interest.
   *
   * @param address The address for which the metadata is required
   * @return The address of the specified meta data
   */
  @Inline
  private static Address getMetaAddress(Address address) {
    return getMetaAddress(address, Offset.zero());
  }

  /**
   * Get the address of some metadata given the address for which the
   * metadata is required and the offset into the metadata that is of
   * interest.
   *
   * @param address The address for which the metadata is required
   * @param offset The offset (in bytes) into the metadata block (eg
   * for the prev pointer, or next pointer)
   * @return The address of the specified meta data
   */
  @Inline
  private static Address getMetaAddress(Address address, Offset offset) {
    return EmbeddedMetaData.getMetaDataBase(address).plus(
           EmbeddedMetaData.getMetaDataOffset(address, LOG_BYTE_COVERAGE, LOG_BYTES_IN_BLOCK_META)).plus(offset);
  }

  /****************************************************************************
   *
   * Block marking
   */

  /**
   * Marks the metadata for this block.
   *
   * @param ref the block's reference
   */
  @Inline
  public static void markBlockMeta(ObjectReference ref) {
    getMetaAddress(VM.objectModel.refToAddress(ref)).plus(FL_META_OFFSET).store(Word.one());
  }

  /**
   * Mark the metadata for this block.
   *
   * @param block The block address
   */
  @Inline
  public static void markBlockMeta(Address block) {
    getMetaAddress(block).plus(FL_META_OFFSET).store(Word.one());
  }

  /**
   * Return true if the metadata for this block was set.
   *
   * @param block The block address
   * @return value of the meta data.
   */
  @Inline
  public static boolean checkBlockMeta(Address block) {
    return getMetaAddress(block).plus(FL_META_OFFSET).loadWord().EQ(Word.one());
  }

  /**
   * Clear the metadata for this block
   *
   * @param block The block address
   */
  @Inline
  public static void clearBlockMeta(Address block) {
    getMetaAddress(block).plus(FL_META_OFFSET).store(Word.zero());
  }
}