/*
* 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.vm;
import org.mmtk.policy.ImmortalSpace;
import org.vmmagic.unboxed.*;
import org.vmmagic.pragma.*;
@Uninterruptible public abstract class Memory {
/**
* Allows for the VM to reserve space between HEAP_START()
* and AVAILABLE_START() for its own purposes. MMTk should
* expect to encounter objects in this range, but may not
* allocate in this range.
*
* MMTk expects the virtual address space between AVAILABLE_START()
* and AVAILABLE_END() to be contiguous and unmapped.
* Allows for the VM to reserve space between HEAP_END()
* and AVAILABLE_END() for its own purposes. MMTk should
* expect to encounter objects in this range, but may not
* allocate in this range.
*
* MMTk expects the virtual address space between AVAILABLE_START()
* and AVAILABLE_END() to be contiguous and unmapped.
*
* @return The high bound of the memory that MMTk can allocate.
*/
/**
* Return the space associated with/reserved for the VM. In the
* case of Jikes RVM this is the boot image space.<p>
*
* @return The space managed by the virtual machine.
*/
@Interruptible
public abstract ImmortalSpace getVMSpace();
/** Global preparation for a collection. */
public abstract void globalPrepareVMSpace();
/** Per-collector preparation for a collection. */
public abstract void collectorPrepareVMSpace();
/** Per-collector post-collection work. */
public abstract void collectorReleaseVMSpace();
/** Global post-collection work. */
public abstract void globalReleaseVMSpace();
/**
* Sets the range of addresses associated with a heap.
*
* @param id the heap identifier
* @param start the address of the start of the heap
* @param end the address of the end of the heap
*/
public abstract void setHeapRange(int id, Address start, Address end);
/**
* Demand zero mmaps an area of virtual memory.
*
* @param start the address of the start of the area to be mapped
* @param size the size, in bytes, of the area to be mapped
* @return 0 if successful, otherwise the system errno
*/
public abstract int dzmmap(Address start, int size);
/**
* Protects access to an area of virtual memory.
*
* @param start the address of the start of the area to be mapped
* @param size the size, in bytes, of the area to be mapped
* @return <code>true</code> if successful, otherwise
* <code>false</code>
*/
public abstract boolean mprotect(Address start, int size);
/**
* Allows access to an area of virtual memory.
*
* @param start the address of the start of the area to be mapped
* @param size the size, in bytes, of the area to be mapped
* @return <code>true</code> if successful, otherwise
* <code>false</code>
*/
public abstract boolean munprotect(Address start, int size);
/**
* Zero a region of memory.
* @param start Start of address range (inclusive)
* @param len Length in bytes of range to zero
* Returned: nothing
*/
public abstract void zero(Address start, Extent len);
/**
* Zero a range of pages of memory.
* @param start Start of address range (must be a page address)
* @param len Length in bytes of range (must be multiple of page size)
*/
public abstract void zeroPages(Address start, int len);
/**
* Logs the contents of an address and the surrounding memory to the
* error output.
*
* @param start the address of the memory to be dumped
* @param beforeBytes the number of bytes before the address to be
* included
* @param afterBytes the number of bytes after the address to be
* included
*/
public abstract void dumpMemory(Address start, int beforeBytes,
int afterBytes);
/**
* Wait for preceeding cache flush/invalidate instructions to complete
* on all processors. Ensures that all memory writes before this
* point are visible to all processors.
*/
@Inline
public abstract void sync();
/**
* Wait for all preceeding instructions to complete and discard any
* prefetched instructions on this processor. Also prevents the
* compiler from performing code motion across this point.
*/
@Inline
public abstract void isync();
/*
* NOTE: The following methods must be implemented by subclasses of this
* class, but are internal to the VM<->MM interface glue, so are never
* called by MMTk users.
*/
/** @return The lowest address in the virtual address space known to MMTk */
protected abstract Address getHeapStartConstant();
/** @return The highest address in the virtual address space known to MMTk */
protected abstract Address getHeapEndConstant();
/** @return The lowest address in the contiguous address space available to MMTk */
protected abstract Address getAvailableStartConstant();
/** @return The highest address in the contiguous address space available to MMTk */
protected abstract Address getAvailableEndConstant();
/** @return The log base two of the size of an address */
protected abstract byte getLogBytesInAddressConstant();
/** @return The log base two of the size of a word */
protected abstract byte getLogBytesInWordConstant();
/** @return The log base two of the size of an OS page */
protected abstract byte getLogBytesInPageConstant();
/** @return The log base two of the minimum allocation alignment */
protected abstract byte getLogMinAlignmentConstant();
/** @return The log base two of (MAX_ALIGNMENT/MIN_ALIGNMENT) */
protected abstract byte getMaxAlignmentShiftConstant();
/** @return The maximum number of bytes of padding to prepend to an object */
protected abstract int getMaxBytesPaddingConstant();
/** @return The value to store in alignment holes */
protected abstract int getAlignmentValueConstant();
/*
* NOTE: These methods should not be called by anything other than the
* reflective mechanisms in org.mmtk.vm.VM, and are not implemented by
* subclasses. This hack exists only to allow us to declare the respective
* methods as protected.
*/
static Address heapStartTrapdoor(Memory m) {
return m.getHeapStartConstant();
}
static Address heapEndTrapdoor(Memory m) {
return m.getHeapEndConstant();
}
static Address availableStartTrapdoor(Memory m) {
return m.getAvailableStartConstant();
}
static Address availableEndTrapdoor(Memory m) {
return m.getAvailableEndConstant();
}
static byte logBytesInAddressTrapdoor(Memory m) {
return m.getLogBytesInAddressConstant();
}
static byte logBytesInWordTrapdoor(Memory m) {
return m.getLogBytesInWordConstant();
}
static byte logBytesInPageTrapdoor(Memory m) {
return m.getLogBytesInPageConstant();
}
static byte logMinAlignmentTrapdoor(Memory m) {
return m.getLogMinAlignmentConstant();
}
static byte maxAlignmentShiftTrapdoor(Memory m) {
return m.getMaxAlignmentShiftConstant();
}
static int maxBytesPaddingTrapdoor(Memory m) {
return m.getMaxBytesPaddingConstant();
}
static int alignmentValueTrapdoor(Memory m) {
return m.getAlignmentValueConstant();
}
}