/*
* $Id$
*
* Copyright (C) 2003-2014 JNode.org
*
* This library is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as published
* by the Free Software Foundation; either version 2.1 of the License, or
* (at your option) any later version.
*
* This library 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 Lesser General Public
* License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this library; If not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
package org.jnode.vm.memmgr.def;
import org.jnode.annotation.Inline;
import org.jnode.annotation.MagicPermission;
import org.jnode.vm.classmgr.ObjectLayout;
import org.jnode.vm.facade.ObjectVisitor;
import org.jnode.vm.memmgr.HeapHelper;
import org.jnode.vm.scheduler.SpinLock;
import org.vmmagic.pragma.Uninterruptible;
import org.vmmagic.pragma.UninterruptiblePragma;
import org.vmmagic.unboxed.Address;
import org.vmmagic.unboxed.ObjectReference;
import org.vmmagic.unboxed.Offset;
import org.vmmagic.unboxed.Word;
/**
* An abstract heap class.
* <p/>
* All changes to the structure of the heap must be made exclusive by {@link #lock()}
* and {@link #unlock()}.
*
* @author epr
*/
@MagicPermission
abstract class VmAbstractHeap extends SpinLock implements Uninterruptible {
/**
* Start address of this heap (inclusive)
*/
protected Address start;
/**
* End address of this heap (exclusive)
*/
protected Address end;
/**
* Size of this heap in bytes
*/
private int size;
/**
* Size of an object header in bytes
*/
protected int headerSize;
/**
* Offset of the flags field in an object header
*/
protected Offset flagsOffset;
/**
* Offset of the type information block field in an object header
*/
protected Offset tibOffset;
/**
* Start address of allocation bitmap
*/
protected Address allocationBitmapPtr;
/**
* Default marker for free object space (marker in VMT field)
*/
protected Object FREE = null;
protected HeapHelper helper;
public VmAbstractHeap(HeapHelper helper) {
this.helper = helper;
}
/**
* Initialization method for the private fields in this class.
* This method must be called, after start and end have been set.
*
* @param slotSize
*/
protected final void initializeAbstract(int slotSize) {
this.headerSize = ObjectLayout.HEADER_SLOTS * slotSize;
this.flagsOffset = Offset.fromIntSignExtend(ObjectLayout.FLAGS_SLOT * slotSize);
this.tibOffset = Offset.fromIntSignExtend(ObjectLayout.TIB_SLOT * slotSize);
this.size = end.toWord().sub(start.toWord()).toInt();
}
/**
* Gets the size in bytes of this heap.
*
* @return int
*/
@Inline
public final int getSize() {
return size;
}
/**
* Is the given address the address of an allocated object on this heap?
*
* @param addr
* @return boolean
*/
@Inline
protected final boolean isObject(Address addr) {
if (addr.LT(start) || addr.GE(end)) {
// The object if not within this heap
return false;
}
final int offset = addr.toWord().sub(start.toWord()).toInt();
int bit = offset / ObjectLayout.OBJECT_ALIGN;
final Offset idx = Offset.fromIntZeroExtend(bit / 8);
final int mask = 1 << (bit & 7);
final Address bitmapPtr = this.allocationBitmapPtr;
final int value = bitmapPtr.loadByte(idx);
return ((value & mask) == mask);
}
/**
* Is the given address an address within this heap.
* If so, this does not always mean that the address is a valid object!
*
* @param addr
* @return boolean
*/
@Inline
protected final boolean inHeap(Address addr) {
return (addr.GE(start) && addr.LT(end));
}
/**
* Change a bit in the allocation bitmap.
*
* @param object
* @param on
*/
@Inline
protected final void setAllocationBit(Object object, boolean on) {
final Address addr = ObjectReference.fromObject(object).toAddress();
if (addr.LT(start) || addr.GE(end)) {
return;
}
final int offset = addr.toWord().sub(start.toWord()).toInt();
final int bit = offset / ObjectLayout.OBJECT_ALIGN;
final Offset idx = Offset.fromIntZeroExtend(bit / 8);
final int mask = 1 << (bit & 7);
final Address bitmapPtr = this.allocationBitmapPtr;
int value = bitmapPtr.loadByte(idx);
if (on) {
value |= mask;
} else {
value &= ~mask;
}
bitmapPtr.store((byte) value, idx);
}
/**
* Initialize this heap
*
* @param start Start address of this heap
* @param end End address of this heap (first address after this heap)
* @param slotSize
*/
protected abstract void initialize(Address start, Address end, int slotSize);
/**
* Let a selected set of objects in this heap accept the given <code>visitor</code>.
* The selection is made based on the objectflags. The objectflags are masked
* by flagsMask and the result is compared with flagsValue, if they are equal
* the object is visited.
*
* @param visitor
* @param locking If true, use lock/unlock while proceeding to the next object.
* @param flagsMask
* @param flagsValue
* @throws UninterruptiblePragma
*/
protected abstract void walk(ObjectVisitor visitor, boolean locking, Word flagsMask, Word flagsValue)
throws UninterruptiblePragma;
}