/*
* 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.policy;
import org.mmtk.plan.TransitiveClosure;
import org.mmtk.utility.heap.*;
import org.mmtk.utility.options.Options;
import org.mmtk.utility.Constants;
import org.mmtk.utility.ForwardingWord;
import org.mmtk.utility.Log;
import org.mmtk.vm.VM;
import org.vmmagic.unboxed.*;
import org.vmmagic.pragma.*;
/**
* This class implements tracing functionality for a simple copying
* space. Since no state needs to be held globally or locally, all
* methods are static.
*/
@Uninterruptible public final class CopySpace extends Space
implements Constants {
/****************************************************************************
*
* Class variables
*/
public static final int LOCAL_GC_BITS_REQUIRED = 2;
public static final int GLOBAL_GC_BITS_REQUIRED = 0;
public static final int GC_HEADER_WORDS_REQUIRED = 0;
private static final int META_DATA_PAGES_PER_REGION = CARD_META_PAGES_PER_REGION;
/****************************************************************************
*
* Instance variables
*/
private boolean fromSpace = true;
public boolean isFromSpace() {
return fromSpace;
}
/** fromSpace CopySpace can always move, toSpace will not move during current GC */
@Override
public boolean isMovable() {
return fromSpace;
}
/****************************************************************************
*
* Initialization
*/
/**
* The caller specifies the region of virtual memory to be used for
* this space. If this region conflicts with an existing space,
* then the constructor will fail.
*
* @param name The name of this space (used when printing error messages etc)
* @param pageBudget The number of pages this space may consume
* before consulting the plan
* @param fromSpace The does this instance start life as from-space
* (or to-space)?
* @param vmRequest An object describing the virtual memory requested.
*/
public CopySpace(String name, int pageBudget, boolean fromSpace, VMRequest vmRequest) {
super(name, true, false, vmRequest);
this.fromSpace = fromSpace;
if (vmRequest.isDiscontiguous()) {
pr = new MonotonePageResource(pageBudget, this, META_DATA_PAGES_PER_REGION);
} else {
pr = new MonotonePageResource(pageBudget, this, start, extent, META_DATA_PAGES_PER_REGION);
}
}
/****************************************************************************
*
* Prepare and release
*/
/**
* Prepare this space instance for a collection. Set the
* "fromSpace" field according to whether this space is the
* source or target of the collection.
*
* @param fromSpace Set the fromSpace field to this value
*/
public void prepare(boolean fromSpace) { this.fromSpace = fromSpace; }
/**
* Release this copy space after a collection. This means releasing
* all pages associated with this (now empty) space.
*/
public void release() {
((MonotonePageResource) pr).reset();
headDiscontiguousRegion = Address.zero();
fromSpace = false;
}
/**
* Release an allocated page or pages. In this case we do nothing
* because we only release pages enmasse.
*
* @param start The address of the start of the page or pages
*/
@Inline
public void release(Address start) {
if (VM.VERIFY_ASSERTIONS)
VM.assertions._assert(false); // this policy only releases pages enmasse
}
/****************************************************************************
*
* Tracing and forwarding
*/
/**
* Trace an object under a copying collection policy.
*
* We use a tri-state algorithm to deal with races to forward
* the object. The tracer must wait if the object is concurrently
* being forwarded by another thread.
*
* If the object is already forwarded, the copy is returned.
* Otherwise, the object is forwarded and the copy is returned.
*
* @param trace The trace being conducted.
* @param object The object to be forwarded.
* @return The forwarded object.
*/
@Inline
public ObjectReference traceObject(TransitiveClosure trace, ObjectReference object) {
VM.assertions.fail("CopySpace.traceLocal called without allocator");
return ObjectReference.nullReference();
}
/**
* Trace an object under a copying collection policy.
*
* We use a tri-state algorithm to deal with races to forward
* the object. The tracer must wait if the object is concurrently
* being forwarded by another thread.
*
* If the object is already forwarded, the copy is returned.
* Otherwise, the object is forwarded and the copy is returned.
*
* @param trace The trace being conducted.
* @param object The object to be forwarded.
* @param allocator The allocator to use when copying.
* @return The forwarded object.
*/
@Inline
public ObjectReference traceObject(TransitiveClosure trace, ObjectReference object, int allocator) {
/* If the object in question is already in to-space, then do nothing */
if (!fromSpace) return object;
/* Try to forward the object */
Word forwardingWord = ForwardingWord.attemptToForward(object);
if (ForwardingWord.stateIsForwardedOrBeingForwarded(forwardingWord)) {
/* Somebody else got to it first. */
/* We must wait (spin) if the object is not yet fully forwarded */
while (ForwardingWord.stateIsBeingForwarded(forwardingWord))
forwardingWord = VM.objectModel.readAvailableBitsWord(object);
/* Now extract the object reference from the forwarding word and return it */
return ForwardingWord.extractForwardingPointer(forwardingWord);
} else {
/* We are the designated copier, so forward it and enqueue it */
ObjectReference newObject = VM.objectModel.copy(object, allocator);
ForwardingWord.setForwardingPointer(object, newObject);
trace.processNode(newObject); // Scan it later
if (VM.VERIFY_ASSERTIONS && Options.verbose.getValue() >= 9) {
Log.write("C["); Log.write(object); Log.write("/");
Log.write(getName()); Log.write("] -> ");
Log.write(newObject); Log.write("/");
Log.write(Space.getSpaceForObject(newObject).getName());
Log.writeln("]");
}
return newObject;
}
}
/**
* Return true if this object is live in this GC
*
* @param object The object in question
* @return True if this object is live in this GC (has it been forwarded?)
*/
public boolean isLive(ObjectReference object) {
return ForwardingWord.isForwarded(object);
}
/**
* Has the object in this space been reached during the current collection.
* This is used for GC Tracing.
*
* @param object The object reference.
* @return True if the object is reachable.
*/
public boolean isReachable(ObjectReference object) {
return !fromSpace || ForwardingWord.isForwarded(object);
}
/****************************************************************************
*
* Header manipulation
*/
/**
* Perform any required post-allocation initialization
*
* <i>Nothing to be done in this case</i>
*
* @param object the object ref to the storage to be initialized
*/
@Inline
public void postAlloc(ObjectReference object) {}
}