SF.net SVN: jikesrvm:[15782] rvmroot/trunk

View: New views

1 Messages — Rating Filter: Alert me

SF.net SVN: jikesrvm:[15782] rvmroot/trunk

by steveb-oss :: Rate this Message:

Reply to Author | View Threaded | Show Only this Message

Revision: 15782
http://jikesrvm.svn.sourceforge.net/jikesrvm/?rev=15782&view=rev
Author: steveb-oss
Date: 2009-09-18 03:57:39 +0000 (Fri, 18 Sep 2009)

Log Message:
-----------
Yet another minor refactoring toward RVM-845

Modified Paths:
--------------
rvmroot/trunk/MMTk/ext/vm/harness/org/mmtk/harness/vm/Barriers.java
rvmroot/trunk/MMTk/ext/vm/jikesrvm/org/jikesrvm/mm/mmtk/Barriers.java
rvmroot/trunk/MMTk/harness/src/org/mmtk/harness/Mutator.java
rvmroot/trunk/MMTk/src/org/mmtk/plan/MutatorContext.java
rvmroot/trunk/MMTk/src/org/mmtk/plan/PlanConstraints.java
rvmroot/trunk/MMTk/src/org/mmtk/plan/generational/Gen.java
rvmroot/trunk/MMTk/src/org/mmtk/plan/generational/GenCollector.java
rvmroot/trunk/MMTk/src/org/mmtk/plan/generational/GenConstraints.java
rvmroot/trunk/MMTk/src/org/mmtk/plan/generational/GenMutator.java
rvmroot/trunk/MMTk/src/org/mmtk/plan/poisoned/PoisonedConstraints.java
rvmroot/trunk/MMTk/src/org/mmtk/plan/poisoned/PoisonedMutator.java
rvmroot/trunk/MMTk/src/org/mmtk/plan/refcount/RCBaseConstraints.java
rvmroot/trunk/MMTk/src/org/mmtk/plan/refcount/RCBaseMutator.java
rvmroot/trunk/MMTk/src/org/mmtk/plan/semispace/gctrace/GCTraceConstraints.java
rvmroot/trunk/MMTk/src/org/mmtk/plan/semispace/gctrace/GCTraceMutator.java
rvmroot/trunk/MMTk/src/org/mmtk/plan/stickyimmix/StickyImmixConstraints.java
rvmroot/trunk/MMTk/src/org/mmtk/plan/stickyimmix/StickyImmixMutator.java
rvmroot/trunk/MMTk/src/org/mmtk/plan/stickyms/StickyMSConstraints.java
rvmroot/trunk/MMTk/src/org/mmtk/plan/stickyms/StickyMSMutator.java
rvmroot/trunk/MMTk/src/org/mmtk/utility/heap/Map.java
rvmroot/trunk/MMTk/src/org/mmtk/vm/Barriers.java
rvmroot/trunk/rvm/src/org/jikesrvm/Services.java
rvmroot/trunk/rvm/src/org/jikesrvm/classloader/RVMArray.java
rvmroot/trunk/rvm/src/org/jikesrvm/classloader/RVMField.java
rvmroot/trunk/rvm/src/org/jikesrvm/compilers/baseline/ia32/Barriers.java
rvmroot/trunk/rvm/src/org/jikesrvm/compilers/baseline/ia32/BaselineCompilerImpl.java
rvmroot/trunk/rvm/src/org/jikesrvm/compilers/opt/hir2lir/ExpandRuntimeServices.java
rvmroot/trunk/rvm/src/org/jikesrvm/mm/mminterface/Barriers.java
rvmroot/trunk/rvm/src/org/jikesrvm/mm/mminterface/MemoryManager.java
rvmroot/trunk/rvm/src/org/jikesrvm/osr/ObjectHolder.java
rvmroot/trunk/rvm/src/org/jikesrvm/runtime/Entrypoints.java
rvmroot/trunk/rvm/src/org/jikesrvm/runtime/Statics.java
rvmroot/trunk/rvm/src/org/jikesrvm/scheduler/Synchronization.java

Modified: rvmroot/trunk/MMTk/ext/vm/harness/org/mmtk/harness/vm/Barriers.java
===================================================================
--- rvmroot/trunk/MMTk/ext/vm/harness/org/mmtk/harness/vm/Barriers.java 2009-09-18 02:15:19 UTC (rev 15781)
+++ rvmroot/trunk/MMTk/ext/vm/harness/org/mmtk/harness/vm/Barriers.java 2009-09-18 03:57:39 UTC (rev 15782)
@@ -30,12 +30,25 @@
* @param mode The context in which the write is occurring
*/
@Override
- public void referenceWrite(ObjectReference ref, ObjectReference target,
- Word slot, Word unused, int mode) {
+ public void objectReferenceWrite(ObjectReference ref, ObjectReference target, Word slot, Word unused, int mode) {
slot.toAddress().store(target);
}

/**
+ * Perform the actual read of the read barrier.
+ *
+ * @param ref The object that has the reference field
+ * @param slot The address to be read from
+ * @param unused Unused
+ * @param mode The context in which the write is occurring
+ * @return the read value
+ */
+ @Override
+ public ObjectReference objectReferenceRead(ObjectReference ref,Word slot, Word unused, int mode) {
+ return slot.toAddress().loadObjectReference();
+ }
+
+ /**
* Perform the actual write of the non-heap write barrier. This is
* used when the store is not to an object, but to a non-heap location
* such as statics or the stack.
@@ -46,8 +59,7 @@
* @param unusedB Opaque, VM-specific, meta-data identifying the slot
*/
@Override
- public void referenceWrite(Address slot, ObjectReference target,
- Word unusedA, Word unusedB) {
+ public void objectReferenceWrite(Address slot, ObjectReference target, Word unusedA, Word unusedB) {
slot.store(target);
}

@@ -63,8 +75,7 @@
* @return The value that was replaced by the write.
*/
@Override
- public ObjectReference referenceAtomicWrite(ObjectReference ref, ObjectReference target,
- Word slot, Word unused, int mode) {
+ public ObjectReference objectReferenceAtomicWrite(ObjectReference ref, ObjectReference target, Word slot, Word unused, int mode) {
ObjectReference old;
do {
old = slot.toAddress().prepareObjectReference();
@@ -84,25 +95,10 @@
* @return True if the compare and swap was successful
*/
@Override
- public boolean referenceTryCompareAndSwap(ObjectReference ref, ObjectReference old, ObjectReference target,
- Word slot, Word unused, int mode) {
+ public boolean objectReferenceTryCompareAndSwap(ObjectReference ref, ObjectReference old, ObjectReference target, Word slot, Word unused, int mode) {
return slot.toAddress().attempt(old, target);
}

- /**
- * Perform the actual read of the read barrier.
- *
- * @param ref The object that has the reference field
- * @param slot The address to be read from
- * @param unused Unused
- * @param mode The context in which the write is occurring
- * @return the read value
- */
- @Override
- public ObjectReference referenceRead(ObjectReference ref,
- Word slot, Word unused, int mode) {
- return slot.toAddress().loadObjectReference();
- }

/**
* Perform the actual write of the write barrier, writing the value as a raw Word.
@@ -114,8 +110,7 @@
* @param mode The context in which the write is occurring
*/
@Override
- public void wordWrite(ObjectReference ref, Word target,
- Word slot, Word unused, int mode) {
+ public void wordWrite(ObjectReference ref, Word target, Word slot, Word unused, int mode) {
slot.toAddress().store(target);
}

@@ -168,8 +163,7 @@
* @return the read value
*/
@Override
- public Word wordRead(ObjectReference ref,
- Word slot, Word unused, int mode) {
+ public Word wordRead(ObjectReference ref, Word slot, Word unused, int mode) {
return slot.toAddress().loadWord();
}

@@ -184,8 +178,7 @@
* @param value the new value for the element
*/
@Override
- public void referenceArrayStoreNoGCBarrier(Object [] dst, int index, Object value) {
+ public void objectArrayStoreNoGCBarrier(Object [] dst, int index, Object value) {
dst[index] = value;
}
-
}

Modified: rvmroot/trunk/MMTk/ext/vm/jikesrvm/org/jikesrvm/mm/mmtk/Barriers.java
===================================================================
--- rvmroot/trunk/MMTk/ext/vm/jikesrvm/org/jikesrvm/mm/mmtk/Barriers.java 2009-09-18 02:15:19 UTC (rev 15781)
+++ rvmroot/trunk/MMTk/ext/vm/jikesrvm/org/jikesrvm/mm/mmtk/Barriers.java 2009-09-18 03:57:39 UTC (rev 15782)
@@ -31,25 +31,11 @@
* @param mode The context in which the write is occurring
*/
@Inline
- public final void referenceWrite(ObjectReference objref, ObjectReference target, Word offset, Word location, int mode) {
+ public final void objectReferenceWrite(ObjectReference objref, ObjectReference target, Word offset, Word location, int mode) {
Magic.setObjectAtOffset(objref.toObject(), offset.toOffset(), target.toObject(), location.toInt());
}

/**
- * Perform the actual write of the non-heap write barrier. This is
- * used when the store is not to an object, but to a non-heap location
- * such as statics or the stack.
- * @param target The value that the slot will be updated to
- * @param unusedA The offset from the ref
- * @param unusedB Unused
- * @param ref The object that has the reference field
- */
- @Inline
- public final void referenceWrite(Address slot, ObjectReference target, Word unusedA, Word unusedB) {
- slot.store(target);
- }
-
- /**
* Perform the actual read of the read barrier.
*
* @param objref The object that has the reference field
@@ -59,29 +45,22 @@
* @return the read value
*/
@Inline
- public final ObjectReference referenceRead(ObjectReference objref, Word offset, Word location, int mode) {
+ public final ObjectReference objectReferenceRead(ObjectReference objref, Word offset, Word location, int mode) {
return ObjectReference.fromObject(Magic.getObjectAtOffset(objref.toObject(), offset.toOffset(), location.toInt()));
}

/**
- * Sets an element of an object array without invoking any write
- * barrier. This method is called by the Map class to ensure
- * potentially-allocation-triggering write barriers do not occur in
- * allocation slow path code.
- *
- * @param dst the destination array
- * @param index the index of the element to set
- * @param value the new value for the element
+ * Perform the actual write of the non-heap write barrier. This is
+ * used when the store is not to an object, but to a non-heap location
+ * such as statics or the stack.
+ * @param target The value that the slot will be updated to
+ * @param unusedA The offset from the ref
+ * @param unusedB Unused
+ * @param ref The object that has the reference field
*/
- @UninterruptibleNoWarn
- public final void referenceArrayStoreNoGCBarrier(Object[] dst, int index, Object value) {
- if (org.jikesrvm.VM.runningVM) {
- Address base = ObjectReference.fromObject(dst).toAddress();
- Address slot = base.plus(Offset.fromIntZeroExtend(index << LOG_BYTES_IN_ADDRESS));
- VM.activePlan.global().storeObjectReference(slot, ObjectReference.fromObject(value));
- } else {
- dst[index] = value;
- }
+ @Inline
+ public final void objectReferenceWrite(Address slot, ObjectReference target, Word unusedA, Word unusedB) {
+ slot.store(target);
}

/**
@@ -96,7 +75,7 @@
* @return The value that was replaced by the write.
*/
@Inline
- public final ObjectReference referenceAtomicWrite(ObjectReference objref, ObjectReference target, Word offset, Word unused, int mode) {
+ public final ObjectReference objectReferenceAtomicWrite(ObjectReference objref, ObjectReference target, Word offset, Word unused, int mode) {
Object obj = objref.toObject();
Object newObject = target.toObject();
Object oldObject;
@@ -118,7 +97,7 @@
* @return True if the compare and swap was successful
*/
@Inline
- public final boolean referenceTryCompareAndSwap(ObjectReference objref, ObjectReference old, ObjectReference target, Word offset, Word unused, int mode) {
+ public final boolean objectReferenceTryCompareAndSwap(ObjectReference objref, ObjectReference old, ObjectReference target, Word offset, Word unused, int mode) {
Object oldValue;
do {
oldValue = Magic.prepareObject(objref, offset.toOffset());
@@ -199,4 +178,24 @@
return Magic.getWordAtOffset(ref.toObject(), offset.toOffset(), location.toInt());
}

+ /**
+ * Sets an element of an object array without invoking any write
+ * barrier. This method is called by the Map class to ensure
+ * potentially-allocation-triggering write barriers do not occur in
+ * allocation slow path code.
+ *
+ * @param dst the destination array
+ * @param index the index of the element to set
+ * @param value the new value for the element
+ */
+ @UninterruptibleNoWarn
+ public final void objectArrayStoreNoGCBarrier(Object[] dst, int index, Object value) {
+ if (org.jikesrvm.VM.runningVM) {
+ Address base = ObjectReference.fromObject(dst).toAddress();
+ Address slot = base.plus(Offset.fromIntZeroExtend(index << LOG_BYTES_IN_ADDRESS));
+ VM.activePlan.global().storeObjectReference(slot, ObjectReference.fromObject(value));
+ } else {
+ dst[index] = value;
+ }
+ }
}

Modified: rvmroot/trunk/MMTk/harness/src/org/mmtk/harness/Mutator.java
===================================================================
--- rvmroot/trunk/MMTk/harness/src/org/mmtk/harness/Mutator.java 2009-09-18 02:15:19 UTC (rev 15781)
+++ rvmroot/trunk/MMTk/harness/src/org/mmtk/harness/Mutator.java 2009-09-18 03:57:39 UTC (rev 15782)
@@ -302,8 +302,8 @@
check(index < limit, "Index "+index+" out of bounds "+limit);

Address referenceSlot = ObjectModel.getRefSlot(object, index);
- if (ActivePlan.constraints.needsReferenceWriteBarrier()) {
- context.referenceWrite(object, referenceSlot, value, referenceSlot.toWord(), null, Plan.ARRAY_ELEMENT);
+ if (ActivePlan.constraints.needsObjectReferenceWriteBarrier()) {
+ context.objectReferenceWrite(object, referenceSlot, value, referenceSlot.toWord(), null, Plan.ARRAY_ELEMENT);
if (gcEveryWB) {
gc();
}
@@ -346,8 +346,8 @@

Address referenceSlot = ObjectModel.getRefSlot(object, index);
ObjectReference result;
- if (ActivePlan.constraints.needsReferenceReadBarrier()) {
- result = context.referenceRead(object, referenceSlot, null, null, Plan.INSTANCE_FIELD);
+ if (ActivePlan.constraints.needsObjectReferenceReadBarrier()) {
+ result = context.objectReferenceRead(object, referenceSlot, null, null, Plan.INSTANCE_FIELD);
} else {
result = referenceSlot.loadObjectReference();
}

Modified: rvmroot/trunk/MMTk/src/org/mmtk/plan/MutatorContext.java
===================================================================
--- rvmroot/trunk/MMTk/src/org/mmtk/plan/MutatorContext.java 2009-09-18 02:15:19 UTC (rev 15781)
+++ rvmroot/trunk/MMTk/src/org/mmtk/plan/MutatorContext.java 2009-09-18 03:57:39 UTC (rev 15782)
@@ -267,70 +267,57 @@
*/

/**
- * A new reference is about to be created. Take appropriate write
- * barrier actions.
+ * Read a reference type. In a concurrent collector this may
+ * involve adding the referent to the marking queue.
*
- * By default do nothing, override if appropriate.
- *
- * @param src The object into which the new reference will be stored
- * @param slot The address into which the new reference will be
- * stored.
- * @param tgt The target of the new reference
- * @param metaDataA A value that assists the host VM in creating a store
- * @param metaDataB A value that assists the host VM in creating a store
- * @param mode The context in which the store occurred
+ * @param referent The referent being read.
+ * @return The new referent.
*/
- public void referenceWrite(ObjectReference src, Address slot,
- ObjectReference tgt, Word metaDataA,
- Word metaDataB, int mode) {
- // Either: write barriers are used and this is overridden, or
- // write barriers are not used and this is never called
+ @Inline
+ public ObjectReference javaLangReferenceReadBarrier(ObjectReference referent) {
+ // Either: read barriers are used and this is overridden, or
+ // read barriers are not used and this is never called
if (VM.VERIFY_ASSERTIONS) VM.assertions._assert(false);
+ return ObjectReference.nullReference();
}

/**
- * A new reference is about to be created in a location that is not
- * a regular heap object. Take appropriate write barrier actions.
+ * Write an object reference. Take appropriate write barrier actions.
*
* By default do nothing, override if appropriate.
*
+ * @param src The object into which the new reference will be stored
* @param slot The address into which the new reference will be
* stored.
* @param tgt The target of the new reference
* @param metaDataA A value that assists the host VM in creating a store
* @param metaDataB A value that assists the host VM in creating a store
+ * @param mode The context in which the store occurred
*/
- public void referenceNonHeapWrite(Address slot, ObjectReference tgt,
- Word metaDataA, Word metaDataB) {
+ public void objectReferenceWrite(ObjectReference src, Address slot, ObjectReference tgt, Word metaDataA, Word metaDataB, int mode) {
// Either: write barriers are used and this is overridden, or
// write barriers are not used and this is never called
if (VM.VERIFY_ASSERTIONS) VM.assertions._assert(false);
}

/**
- * Attempt to atomically exchange the value in the given slot
- * with the passed replacement value. If a new reference is
- * created, we must then take appropriate write barrier actions.
+ * Read an object reference. Take appropriate read barrier action, and
+ * return the value that was read. This is a substituting
+ * barrier. The call to this barrier takes the place of a load.
*
- * By default do nothing, override if appropriate.
- *
- * @param src The object into which the new reference will be stored
- * @param slot The address into which the new reference will be
- * stored.
- * @param old The old reference to be swapped out
- * @param tgt The target of the new reference
- * @param metaDataA A value that assists the host VM in creating a store
- * @param metaDataB A value that assists the host VM in creating a store
- * @param mode The context in which the store occurred
- * @return True if the swap was successful.
+ * @param src The object reference holding the field being read.
+ * @param slot The address of the slot being read.
+ * @param metaDataA A value that assists the host VM in creating a load
+ * @param metaDataB A value that assists the host VM in creating a load
+ * @param mode The context in which the load occurred
+ * @return The reference that was read.
*/
- public boolean referenceTryCompareAndSwap(ObjectReference src, Address slot,
- ObjectReference old, ObjectReference tgt, Word metaDataA,
- Word metaDataB, int mode) {
- // Either: write barriers are used and this is overridden, or
- // write barriers are not used and this is never called
+ @Inline
+ public ObjectReference objectReferenceRead(ObjectReference src, Address slot, Word metaDataA, Word metaDataB, int mode) {
+ // Either: read barriers are used and this is overridden, or
+ // read barriers are not used and this is never called
if (VM.VERIFY_ASSERTIONS) VM.assertions._assert(false);
- return false;
+ return ObjectReference.nullReference();
}

/**
@@ -351,44 +338,44 @@
* @return True if the update was performed by the barrier, false if
* left to the caller (always false in this case).
*/
- public boolean referenceBulkCopy(ObjectReference src, Offset srcOffset,
- ObjectReference dst, Offset dstOffset,
- int bytes) {
+ public boolean objectReferenceBulkCopy(ObjectReference src, Offset srcOffset, ObjectReference dst, Offset dstOffset, int bytes) {
// Either: write barriers are used and this is overridden, or
// write barriers are not used and this is never called
if (VM.VERIFY_ASSERTIONS) VM.assertions._assert(false);
return false;
}

+
/**
- * Read a reference type. In a concurrent collector this may
- * involve adding the referent to the marking queue.
+ * A new reference is about to be created in a location that is not
+ * a regular heap object. Take appropriate write barrier actions.
*
- * @param referent The referent being read.
- * @return The new referent.
+ * By default do nothing, override if appropriate.
+ *
+ * @param slot The address into which the new reference will be
+ * stored.
+ * @param tgt The target of the new reference
+ * @param metaDataA A value that assists the host VM in creating a store
+ * @param metaDataB A value that assists the host VM in creating a store
*/
- @Inline
- public ObjectReference javaLangReferenceReadBarrier(ObjectReference referent) {
- // Either: read barriers are used and this is overridden, or
- // read barriers are not used and this is never called
+ public void objectReferenceNonHeapWrite(Address slot, ObjectReference tgt, Word metaDataA, Word metaDataB) {
+ // Either: write barriers are used and this is overridden, or
+ // write barriers are not used and this is never called
if (VM.VERIFY_ASSERTIONS) VM.assertions._assert(false);
- return ObjectReference.nullReference();
}

/**
- * Read a reference. Take appropriate read barrier action, and
+ * Read an object reference. Take appropriate read barrier action, and
* return the value that was read. This is a substituting
* barrier. The call to this barrier takes the place of a load.
*
- * @param src The object reference holding the field being read.
* @param slot The address of the slot being read.
* @param metaDataA A value that assists the host VM in creating a load
* @param metaDataB A value that assists the host VM in creating a load
- * @param mode The context in which the load occurred
* @return The reference that was read.
*/
@Inline
- public ObjectReference referenceRead(ObjectReference src, Address slot, Word metaDataA, Word metaDataB, int mode) {
+ public ObjectReference objectReferenceNonHeapRead(Address slot, Word metaDataA, Word metaDataB) {
// Either: read barriers are used and this is overridden, or
// read barriers are not used and this is never called
if (VM.VERIFY_ASSERTIONS) VM.assertions._assert(false);
@@ -396,22 +383,33 @@
}

/**
- * Read a reference. Take appropriate read barrier action, and
- * return the value that was read. This is a substituting
- * barrier. The call to this barrier takes the place of a load.
+ * Attempt to atomically exchange the value in the given slot
+ * with the passed replacement value. If a new reference is
+ * created, we must then take appropriate write barrier actions.
*
- * @param slot The address of the slot being read.
- * @param metaDataA A value that assists the host VM in creating a load
- * @param metaDataB A value that assists the host VM in creating a load
- * @return The reference that was read.
+ * By default do nothing, override if appropriate.
+ *
+ * @param src The object into which the new reference will be stored
+ * @param slot The address into which the new reference will be
+ * stored.
+ * @param old The old reference to be swapped out
+ * @param tgt The target of the new reference
+ * @param metaDataA A value that assists the host VM in creating a store
+ * @param metaDataB A value that assists the host VM in creating a store
+ * @param mode The context in which the store occurred
+ * @return True if the swap was successful.
*/
- @Inline
- public ObjectReference referenceNonHeapRead(Address slot, Word metaDataA, Word metaDataB) {
- // Either: read barriers are used and this is overridden, or
- // read barriers are not used and this is never called
+ public boolean objectReferenceTryCompareAndSwap(ObjectReference src, Address slot, ObjectReference old, ObjectReference tgt, Word metaDataA, Word metaDataB, int mode) {
+ // Either: write barriers are used and this is overridden, or
+ // write barriers are not used and this is never called
if (VM.VERIFY_ASSERTIONS) VM.assertions._assert(false);
- return ObjectReference.nullReference();
+ return false;
}
+
+
+
+
+
/**
* Flush mutator context, in response to a requestMutatorFlush.
* Also called by the default implementation of deinitMutator.

Modified: rvmroot/trunk/MMTk/src/org/mmtk/plan/PlanConstraints.java
===================================================================
--- rvmroot/trunk/MMTk/src/org/mmtk/plan/PlanConstraints.java 2009-09-18 02:15:19 UTC (rev 15781)
+++ rvmroot/trunk/MMTk/src/org/mmtk/plan/PlanConstraints.java 2009-09-18 03:57:39 UTC (rev 15782)
@@ -25,17 +25,17 @@
/** @return True of this Plan requires read barriers on java.lang.reference types. */
public boolean needsJavaLangReferenceReadBarrier() { return false; }

- /** @return True if this Plan requires write barriers on reference types. */
- public boolean needsReferenceWriteBarrier() { return false; }
+ /** @return True if this Plan requires write barriers on object references. */
+ public boolean needsObjectReferenceWriteBarrier() { return false; }

- /** @return True of this Plan requires read barriers on reference types. */
- public boolean needsReferenceReadBarrier() { return false; }
+ /** @return True of this Plan requires read barriers on object references. */
+ public boolean needsObjectReferenceReadBarrier() { return false; }

- /** @return True if this Plan requires static write barriers on reference types. */
- public boolean needsReferenceStaticWriteBarrier() { return false;}
+ /** @return True if this Plan requires non-heap write barriers on object references. */
+ public boolean needsObjectReferenceNonHeapWriteBarrier() { return false;}

- /** @return True if this Plan requires static read barriers on reference types. */
- public boolean needsReferenceStaticReadBarrier() { return false; }
+ /** @return True if this Plan requires non-heap read barriers on object references. */
+ public boolean needsObjectReferenceNonHeapReadBarrier() { return false; }

/** @return True if this Plan requires linear scanning. */
public boolean needsLinearScan() { return org.mmtk.utility.Constants.SUPPORT_CARD_SCANNING;}

Modified: rvmroot/trunk/MMTk/src/org/mmtk/plan/generational/Gen.java
===================================================================
--- rvmroot/trunk/MMTk/src/org/mmtk/plan/generational/Gen.java 2009-09-18 02:15:19 UTC (rev 15781)
+++ rvmroot/trunk/MMTk/src/org/mmtk/plan/generational/Gen.java 2009-09-18 03:57:39 UTC (rev 15782)
@@ -56,7 +56,7 @@
protected static final float MATURE_FRACTION = 0.5f; // est yield
private static final float WORST_CASE_COPY_EXPANSION = 1.5f; // worst case for addition of one word overhead due to address based hashing
public static final boolean IGNORE_REMSETS = false;
- public static final boolean USE_STATIC_WRITE_BARRIER = false;
+ public static final boolean USE_NON_HEAP_OBJECT_REFERENCE_WRITE_BARRIER = false;
public static final boolean USE_OBJECT_BARRIER_FOR_AASTORE = false; // choose between slot and object barriers
public static final boolean USE_OBJECT_BARRIER_FOR_PUTFIELD = false; // choose between slot and object barriers
public static final boolean USE_OBJECT_BARRIER = USE_OBJECT_BARRIER_FOR_AASTORE || USE_OBJECT_BARRIER_FOR_PUTFIELD;

Modified: rvmroot/trunk/MMTk/src/org/mmtk/plan/generational/GenCollector.java
===================================================================
--- rvmroot/trunk/MMTk/src/org/mmtk/plan/generational/GenCollector.java 2009-09-18 02:15:19 UTC (rev 15781)
+++ rvmroot/trunk/MMTk/src/org/mmtk/plan/generational/GenCollector.java 2009-09-18 03:57:39 UTC (rev 15782)
@@ -95,7 +95,7 @@

if (phaseId == StopTheWorld.ROOTS) {
VM.scanning.computeGlobalRoots(getCurrentTrace());
- if (!Gen.USE_STATIC_WRITE_BARRIER || global().traceFullHeap()) {
+ if (!Gen.USE_NON_HEAP_OBJECT_REFERENCE_WRITE_BARRIER || global().traceFullHeap()) {
VM.scanning.computeStaticRoots(getCurrentTrace());
}
if (Plan.SCAN_BOOT_IMAGE && global().traceFullHeap()) {

Modified: rvmroot/trunk/MMTk/src/org/mmtk/plan/generational/GenConstraints.java
===================================================================
--- rvmroot/trunk/MMTk/src/org/mmtk/plan/generational/GenConstraints.java 2009-09-18 02:15:19 UTC (rev 15781)
+++ rvmroot/trunk/MMTk/src/org/mmtk/plan/generational/GenConstraints.java 2009-09-18 03:57:39 UTC (rev 15782)
@@ -46,11 +46,11 @@

/** @return True if this plan requires a write barrier */
@Override
- public boolean needsReferenceWriteBarrier() { return true; }
+ public boolean needsObjectReferenceWriteBarrier() { return true; }

/** @return True if this plan requires a static barrier */
@Override
- public boolean needsReferenceStaticWriteBarrier() { return Gen.USE_STATIC_WRITE_BARRIER; }
+ public boolean needsObjectReferenceNonHeapWriteBarrier() { return Gen.USE_NON_HEAP_OBJECT_REFERENCE_WRITE_BARRIER; }

/** @return The specialized scan methods required */
@Override

Modified: rvmroot/trunk/MMTk/src/org/mmtk/plan/generational/GenMutator.java
===================================================================
--- rvmroot/trunk/MMTk/src/org/mmtk/plan/generational/GenMutator.java 2009-09-18 02:15:19 UTC (rev 15781)
+++ rvmroot/trunk/MMTk/src/org/mmtk/plan/generational/GenMutator.java 2009-09-18 03:57:39 UTC (rev 15782)
@@ -175,11 +175,11 @@
* @param mode The mode of the store (eg putfield, putstatic etc)
*/
@Inline
- public final void referenceWrite(ObjectReference src, Address slot,
+ public final void objectReferenceWrite(ObjectReference src, Address slot,
ObjectReference tgt, Word metaDataA,
Word metaDataB, int mode) {
fastPath(src, slot, tgt, mode);
- VM.barriers.referenceWrite(src, tgt, metaDataA, metaDataB, mode);
+ VM.barriers.objectReferenceWrite(src, tgt, metaDataA, metaDataB, mode);
}

@@ -216,10 +216,10 @@
* @param metaDataB A value that assists the host VM in creating a store
*/
@Inline
- public final void referenceNonHeapWrite(Address slot, ObjectReference tgt,
+ public final void objectReferenceNonHeapWrite(Address slot, ObjectReference tgt,
Word metaDataA, Word metaDataB) {
fastPath(slot, tgt);
- VM.barriers.referenceWrite(slot, tgt, metaDataA, metaDataB);
+ VM.barriers.objectReferenceWrite(slot, tgt, metaDataA, metaDataB);
}

/**
@@ -242,9 +242,9 @@
* @return True if the swap was successful.
*/
@Inline
- public boolean referenceTryCompareAndSwap(ObjectReference src, Address slot, ObjectReference old, ObjectReference tgt,
+ public boolean objectReferenceTryCompareAndSwap(ObjectReference src, Address slot, ObjectReference old, ObjectReference tgt,
Word metaDataA, Word metaDataB, int mode) {
- boolean result = VM.barriers.referenceTryCompareAndSwap(src, old, tgt, metaDataA, metaDataB, mode);
+ boolean result = VM.barriers.objectReferenceTryCompareAndSwap(src, old, tgt, metaDataA, metaDataB, mode);
if (result)
fastPath(src, slot, tgt, mode);
return result;
@@ -272,7 +272,7 @@
* left to the caller (always false in this case).
*/
@Inline
- public final boolean referenceBulkCopy(ObjectReference src, Offset srcOffset,
+ public final boolean objectReferenceBulkCopy(ObjectReference src, Offset srcOffset,
ObjectReference dst, Offset dstOffset,
int bytes) {
// We can ignore when src is in old space, right?

Modified: rvmroot/trunk/MMTk/src/org/mmtk/plan/poisoned/PoisonedConstraints.java
===================================================================
--- rvmroot/trunk/MMTk/src/org/mmtk/plan/poisoned/PoisonedConstraints.java 2009-09-18 02:15:19 UTC (rev 15781)
+++ rvmroot/trunk/MMTk/src/org/mmtk/plan/poisoned/PoisonedConstraints.java 2009-09-18 03:57:39 UTC (rev 15782)
@@ -24,11 +24,11 @@
@Uninterruptible
public class PoisonedConstraints extends MSConstraints {
@Override
- public boolean needsReferenceWriteBarrier() { return true; }
+ public boolean needsObjectReferenceWriteBarrier() { return true; }
@Override
- public boolean needsReferenceReadBarrier() { return true; }
+ public boolean needsObjectReferenceReadBarrier() { return true; }
@Override
- public boolean needsReferenceStaticWriteBarrier() { return false; }
+ public boolean needsObjectReferenceNonHeapWriteBarrier() { return false; }
@Override
- public boolean needsReferenceStaticReadBarrier() { return false; }
+ public boolean needsObjectReferenceNonHeapReadBarrier() { return false; }
}

Modified: rvmroot/trunk/MMTk/src/org/mmtk/plan/poisoned/PoisonedMutator.java
===================================================================
--- rvmroot/trunk/MMTk/src/org/mmtk/plan/poisoned/PoisonedMutator.java 2009-09-18 02:15:19 UTC (rev 15781)
+++ rvmroot/trunk/MMTk/src/org/mmtk/plan/poisoned/PoisonedMutator.java 2009-09-18 03:57:39 UTC (rev 15782)
@@ -50,7 +50,7 @@
*/
@Inline
@Override
- public void referenceWrite(ObjectReference src, Address slot, ObjectReference tgt, Word metaDataA, Word metaDataB, int mode) {
+ public void objectReferenceWrite(ObjectReference src, Address slot, ObjectReference tgt, Word metaDataA, Word metaDataB, int mode) {
VM.barriers.wordWrite(src, Poisoned.poison(tgt), metaDataA, metaDataB, mode);
}

@@ -72,7 +72,7 @@
* @return True if the swap was successful.
*/
@Override
- public boolean referenceTryCompareAndSwap(ObjectReference src, Address slot, ObjectReference old, ObjectReference tgt,
+ public boolean objectReferenceTryCompareAndSwap(ObjectReference src, Address slot, ObjectReference old, ObjectReference tgt,
Word metaDataA, Word metaDataB, int mode) {
return VM.barriers.wordTryCompareAndSwap(src, Poisoned.poison(old), Poisoned.poison(tgt), metaDataA, metaDataB, mode);
}
@@ -96,7 +96,7 @@
* left to the caller (always false in this case).
*/
@Override
- public boolean referenceBulkCopy(ObjectReference src, Offset srcOffset, ObjectReference dst, Offset dstOffset, int bytes) {
+ public boolean objectReferenceBulkCopy(ObjectReference src, Offset srcOffset, ObjectReference dst, Offset dstOffset, int bytes) {
// TODO: Currently, read barriers implies that this is never used, perhaps
// we might want to use it sometime anyway?
if (VM.VERIFY_ASSERTIONS) VM.assertions._assert(false);
@@ -117,7 +117,7 @@
*/
@Inline
@Override
- public ObjectReference referenceRead(ObjectReference src, Address slot, Word metaDataA, Word metaDataB, int mode) {
+ public ObjectReference objectReferenceRead(ObjectReference src, Address slot, Word metaDataA, Word metaDataB, int mode) {
return Poisoned.depoison(VM.barriers.wordRead(src, metaDataA, metaDataB, mode));
}
}

Modified: rvmroot/trunk/MMTk/src/org/mmtk/plan/refcount/RCBaseConstraints.java
===================================================================
--- rvmroot/trunk/MMTk/src/org/mmtk/plan/refcount/RCBaseConstraints.java 2009-09-18 02:15:19 UTC (rev 15781)
+++ rvmroot/trunk/MMTk/src/org/mmtk/plan/refcount/RCBaseConstraints.java 2009-09-18 03:57:39 UTC (rev 15782)
@@ -30,7 +30,7 @@
@Override
public int gcHeaderWords() { return RCHeader.GC_HEADER_WORDS_REQUIRED; }
@Override
- public boolean needsReferenceWriteBarrier() { return true; }
+ public boolean needsObjectReferenceWriteBarrier() { return true; }
@Override
public int maxNonLOSDefaultAllocBytes() { return MAX_FREELIST_OBJECT_BYTES; }
}

Modified: rvmroot/trunk/MMTk/src/org/mmtk/plan/refcount/RCBaseMutator.java
===================================================================
--- rvmroot/trunk/MMTk/src/org/mmtk/plan/refcount/RCBaseMutator.java 2009-09-18 02:15:19 UTC (rev 15781)
+++ rvmroot/trunk/MMTk/src/org/mmtk/plan/refcount/RCBaseMutator.java 2009-09-18 03:57:39 UTC (rev 15782)
@@ -238,13 +238,13 @@
* @param mode The context in which the store occurred
*/
@Inline
- public void referenceWrite(ObjectReference src, Address slot,
+ public void objectReferenceWrite(ObjectReference src, Address slot,
ObjectReference tgt, Word metaDataA,
Word metaDataB, int mode) {
if (RCHeader.logRequired(src)) {
coalescingWriteBarrierSlow(src);
}
- VM.barriers.referenceWrite(src,tgt,metaDataA, metaDataB, mode);
+ VM.barriers.objectReferenceWrite(src,tgt,metaDataA, metaDataB, mode);
}

/**
@@ -265,13 +265,13 @@
* @return True if the swap was successful.
*/
@Inline
- public boolean referenceTryCompareAndSwap(ObjectReference src, Address slot,
+ public boolean objectReferenceTryCompareAndSwap(ObjectReference src, Address slot,
ObjectReference old, ObjectReference tgt, Word metaDataA,
Word metaDataB, int mode) {
if (RCHeader.logRequired(src)) {
coalescingWriteBarrierSlow(src);
}
- return VM.barriers.referenceTryCompareAndSwap(src,old,tgt,metaDataA,metaDataB,mode);
+ return VM.barriers.objectReferenceTryCompareAndSwap(src,old,tgt,metaDataA,metaDataB,mode);
}

/**
@@ -293,7 +293,7 @@
* left to the caller (always false in this case).
*/
@Inline
- public boolean referenceBulkCopy(ObjectReference src, Offset srcOffset,
+ public boolean objectReferenceBulkCopy(ObjectReference src, Offset srcOffset,
ObjectReference dst, Offset dstOffset, int bytes) {
if (RCHeader.logRequired(dst)) {
coalescingWriteBarrierSlow(dst);

Modified: rvmroot/trunk/MMTk/src/org/mmtk/plan/semispace/gctrace/GCTraceConstraints.java
===================================================================
--- rvmroot/trunk/MMTk/src/org/mmtk/plan/semispace/gctrace/GCTraceConstraints.java 2009-09-18 02:15:19 UTC (rev 15781)
+++ rvmroot/trunk/MMTk/src/org/mmtk/plan/semispace/gctrace/GCTraceConstraints.java 2009-09-18 03:57:39 UTC (rev 15782)
@@ -22,7 +22,7 @@
@Uninterruptible
public class GCTraceConstraints extends SSConstraints {
@Override
- public boolean needsReferenceWriteBarrier() { return true; }
+ public boolean needsObjectReferenceWriteBarrier() { return true; }
@Override
public boolean generateGCTrace() { return true; }
}

Modified: rvmroot/trunk/MMTk/src/org/mmtk/plan/semispace/gctrace/GCTraceMutator.java
===================================================================
--- rvmroot/trunk/MMTk/src/org/mmtk/plan/semispace/gctrace/GCTraceMutator.java 2009-09-18 02:15:19 UTC (rev 15781)
+++ rvmroot/trunk/MMTk/src/org/mmtk/plan/semispace/gctrace/GCTraceMutator.java 2009-09-18 03:57:39 UTC (rev 15782)
@@ -89,12 +89,12 @@
* @param mode The mode of the store (eg putfield, putstatic etc)
*/
@Inline
- public final void referenceWrite(ObjectReference src, Address slot,
+ public final void objectReferenceWrite(ObjectReference src, Address slot,
ObjectReference tgt, Word metaDataA,
Word metaDataB, int mode) {
TraceGenerator.processPointerUpdate(mode == INSTANCE_FIELD,
src, slot, tgt);
- VM.barriers.referenceWrite(src, tgt, metaDataA, metaDataB, mode);
+ VM.barriers.objectReferenceWrite(src, tgt, metaDataA, metaDataB, mode);
}

/**
@@ -115,10 +115,10 @@
* @return True if the swap was successful.
*/
@Inline
- public boolean referenceTryCompareAndSwap(ObjectReference src, Address slot,
+ public boolean objectReferenceTryCompareAndSwap(ObjectReference src, Address slot,
ObjectReference old, ObjectReference tgt, Word metaDataA,
Word metaDataB, int mode) {
- boolean result = VM.barriers.referenceTryCompareAndSwap(src, old, tgt, metaDataA, metaDataB, mode);
+ boolean result = VM.barriers.objectReferenceTryCompareAndSwap(src, old, tgt, metaDataA, metaDataB, mode);
if (result) {
TraceGenerator.processPointerUpdate(mode == INSTANCE_FIELD, src, slot, tgt);
}
@@ -143,7 +143,7 @@
* @return True if the update was performed by the barrier, false if
* left to the caller (always false in this case).
*/
- public boolean referenceBulkCopy(ObjectReference src, Offset srcOffset,
+ public boolean objectReferenceBulkCopy(ObjectReference src, Offset srcOffset,
ObjectReference dst, Offset dstOffset, int bytes) {
/* These names seem backwards, but are defined to be compatable with the
* previous writeBarrier method. */

Modified: rvmroot/trunk/MMTk/src/org/mmtk/plan/stickyimmix/StickyImmixConstraints.java
===================================================================
--- rvmroot/trunk/MMTk/src/org/mmtk/plan/stickyimmix/StickyImmixConstraints.java 2009-09-18 02:15:19 UTC (rev 15781)
+++ rvmroot/trunk/MMTk/src/org/mmtk/plan/stickyimmix/StickyImmixConstraints.java 2009-09-18 03:57:39 UTC (rev 15782)
@@ -32,7 +32,7 @@

/** @return True if this plan requires a write barrier */
@Override
- public boolean needsReferenceWriteBarrier() { return true; }
+ public boolean needsObjectReferenceWriteBarrier() { return true; }

/** @return True if this Plan requires a header bit for object logging */
@Override

Modified: rvmroot/trunk/MMTk/src/org/mmtk/plan/stickyimmix/StickyImmixMutator.java
===================================================================
--- rvmroot/trunk/MMTk/src/org/mmtk/plan/stickyimmix/StickyImmixMutator.java 2009-09-18 02:15:19 UTC (rev 15781)
+++ rvmroot/trunk/MMTk/src/org/mmtk/plan/stickyimmix/StickyImmixMutator.java 2009-09-18 03:57:39 UTC (rev 15782)
@@ -80,11 +80,11 @@
* @param mode The mode of the store (eg putfield, putstatic etc)
*/
@Inline
- public final void referenceWrite(ObjectReference src, Address slot,
+ public final void objectReferenceWrite(ObjectReference src, Address slot,
ObjectReference tgt, Word metaDataA, Word metaDataB, int mode) {
if (HeaderByte.isUnlogged(src))
logSource(src);
- VM.barriers.referenceWrite(src, tgt, metaDataA, metaDataB, mode);
+ VM.barriers.objectReferenceWrite(src, tgt, metaDataA, metaDataB, mode);
}

/**
@@ -109,7 +109,7 @@
* left to the caller (always false in this case).
*/
@Inline
- public final boolean referenceBulkCopy(ObjectReference src, Offset srcOffset,
+ public final boolean objectReferenceBulkCopy(ObjectReference src, Offset srcOffset,
ObjectReference dst, Offset dstOffset, int bytes) {
if (HeaderByte.isUnlogged(src))
logSource(src);

Modified: rvmroot/trunk/MMTk/src/org/mmtk/plan/stickyms/StickyMSConstraints.java
===================================================================
--- rvmroot/trunk/MMTk/src/org/mmtk/plan/stickyms/StickyMSConstraints.java 2009-09-18 02:15:19 UTC (rev 15781)
+++ rvmroot/trunk/MMTk/src/org/mmtk/plan/stickyms/StickyMSConstraints.java 2009-09-18 03:57:39 UTC (rev 15782)
@@ -32,7 +32,7 @@

/** @return True if this plan requires a write barrier */
@Override
- public boolean needsReferenceWriteBarrier() { return true; }
+ public boolean needsObjectReferenceWriteBarrier() { return true; }

/** @return True if this Plan requires a header bit for object logging */
@Override

Modified: rvmroot/trunk/MMTk/src/org/mmtk/plan/stickyms/StickyMSMutator.java
===================================================================
--- rvmroot/trunk/MMTk/src/org/mmtk/plan/stickyms/StickyMSMutator.java 2009-09-18 02:15:19 UTC (rev 15781)
+++ rvmroot/trunk/MMTk/src/org/mmtk/plan/stickyms/StickyMSMutator.java 2009-09-18 03:57:39 UTC (rev 15782)
@@ -81,11 +81,11 @@
* @param mode The mode of the store (eg putfield, putstatic etc)
*/
@Inline
- public final void referenceWrite(ObjectReference src, Address slot,
+ public final void objectReferenceWrite(ObjectReference src, Address slot,
ObjectReference tgt, Word metaDataA, Word metaDataB, int mode) {
if (HeaderByte.isUnlogged(src))
logSource(src);
- VM.barriers.referenceWrite(src, tgt, metaDataA, metaDataB, mode);
+ VM.barriers.objectReferenceWrite(src, tgt, metaDataA, metaDataB, mode);
}

/**
@@ -110,7 +110,7 @@
* left to the caller (always false in this case).
*/
@Inline
- public final boolean referenceBulkCopy(ObjectReference src, Offset srcOffset,
+ public final boolean objectReferenceBulkCopy(ObjectReference src, Offset srcOffset,
ObjectReference dst, Offset dstOffset, int bytes) {
if (HeaderByte.isUnlogged(src))
logSource(src);

Modified: rvmroot/trunk/MMTk/src/org/mmtk/utility/heap/Map.java
===================================================================
--- rvmroot/trunk/MMTk/src/org/mmtk/utility/heap/Map.java 2009-09-18 02:15:19 UTC (rev 15781)
+++ rvmroot/trunk/MMTk/src/org/mmtk/utility/heap/Map.java 2009-09-18 03:57:39 UTC (rev 15782)
@@ -97,7 +97,7 @@
VM.assertions.fail("exiting");
}
descriptorMap[index] = descriptor;
- VM.barriers.referenceArrayStoreNoGCBarrier(spaceMap, index, space);
+ VM.barriers.objectArrayStoreNoGCBarrier(spaceMap, index, space);
e = e.plus(Space.BYTES_IN_CHUNK);
}
}
@@ -208,7 +208,7 @@
totalAvailableDiscontiguousChunks += chunks;
for (int offset = 0; offset < chunks; offset++) {
descriptorMap[chunk + offset] = 0;
- VM.barriers.referenceArrayStoreNoGCBarrier(spaceMap, chunk + offset, null);
+ VM.barriers.objectArrayStoreNoGCBarrier(spaceMap, chunk + offset, null);
linkageMap[chunk + offset] = 0;
}
return chunks;

Modified: rvmroot/trunk/MMTk/src/org/mmtk/vm/Barriers.java
===================================================================
--- rvmroot/trunk/MMTk/src/org/mmtk/vm/Barriers.java 2009-09-18 02:15:19 UTC (rev 15781)
+++ rvmroot/trunk/MMTk/src/org/mmtk/vm/Barriers.java 2009-09-18 03:57:39 UTC (rev 15782)
@@ -18,7 +18,7 @@
@Uninterruptible
public abstract class Barriers {
/**
- * Perform the actual write of the write barrier.
+ * Perform the actual write of an object reference write barrier.
*
* @param ref The object that has the reference field
* @param target The value that the slot will be updated to
@@ -26,10 +26,20 @@
* @param metaDataB Opaque, VM-specific, meta-data identifying the slot
* @param mode The context in which the write is occurring
*/
- public abstract void referenceWrite(ObjectReference ref, ObjectReference target,
- Word metaDataA, Word metaDataB, int mode);
+ public abstract void objectReferenceWrite(ObjectReference ref, ObjectReference target, Word metaDataA, Word metaDataB, int mode);

/**
+ * Perform the actual read of the read barrier.
+ *
+ * @param ref The object that has the reference field
+ * @param metaDataA Opaque, VM-specific, meta-data identifying the slot
+ * @param metaDataB Opaque, VM-specific, meta-data identifying the slot
+ * @param mode The context in which the write is occurring
+ * @return the read value
+ */
+ public abstract ObjectReference objectReferenceRead(ObjectReference ref, Word metaDataA, Word metaDataB, int mode);
+
+ /**
* Perform the actual write of the non-heap write barrier. This is
* used when the store is not to an object, but to a non-heap location
* such as statics or the stack.
@@ -39,8 +49,7 @@
* @param metaDataA Opaque, VM-specific, meta-data identifying the slot
* @param metaDataB Opaque, VM-specific, meta-data identifying the slot
*/
- public abstract void referenceWrite(Address slot, ObjectReference target,
- Word metaDataA, Word metaDataB);
+ public abstract void objectReferenceWrite(Address slot, ObjectReference target, Word metaDataA, Word metaDataB);

/**
* Atomically write a reference field of an object or array and return
@@ -53,8 +62,7 @@
* @param mode The context in which the write is occurring
* @return The value that was replaced by the write.
*/
- public abstract ObjectReference referenceAtomicWrite(ObjectReference ref, ObjectReference target,
- Word metaDataA, Word metaDataB, int mode);
+ public abstract ObjectReference objectReferenceAtomicWrite(ObjectReference ref, ObjectReference target, Word metaDataA, Word metaDataB, int mode);

/**
* Attempt an atomic compare and exchange in a write barrier sequence.
@@ -67,23 +75,9 @@
* @param mode The context in which the write is occurring
* @return True if the compare and swap was successful
*/
- public abstract boolean referenceTryCompareAndSwap(ObjectReference ref, ObjectReference old, ObjectReference target,
- Word metaDataA, Word metaDataB, int mode);
+ public abstract boolean objectReferenceTryCompareAndSwap(ObjectReference ref, ObjectReference old, ObjectReference target, Word metaDataA, Word metaDataB, int mode);

/**
- * Perform the actual read of the read barrier.
- *
- * @param ref The object that has the reference field
- * @param metaDataA Opaque, VM-specific, meta-data identifying the slot
- * @param metaDataB Opaque, VM-specific, meta-data identifying the slot
- * @param mode The context in which the write is occurring
- * @return the read value
- */
- public abstract ObjectReference referenceRead(ObjectReference ref,
- Word metaDataA, Word metaDataB, int mode);
-
-
- /**
* Perform the actual write of the write barrier, writing the value as a raw Word.
*
* @param ref The object that has the reference field
@@ -92,8 +86,7 @@
* @param metaDataB Opaque, VM-specific, meta-data identifying the slot
* @param mode The context in which the write is occurring
*/
- public abstract void wordWrite(ObjectReference ref, Word target,
- Word metaDataA, Word metaDataB, int mode);
+ public abstract void wordWrite(ObjectReference ref, Word target, Word metaDataA, Word metaDataB, int mode);

/**
* Atomically write a reference field of an object or array and return
@@ -106,8 +99,7 @@
* @param mode The context in which the write is occurring
* @return The raw value that was replaced by the write.
*/
- public abstract Word wordAtomicWrite(ObjectReference ref, Word rawTarget,
- Word metaDataA, Word metaDataB, int mode);
+ public abstract Word wordAtomicWrite(ObjectReference ref, Word rawTarget, Word metaDataA, Word metaDataB, int mode);

/**
* Attempt an atomic compare and exchange in a write barrier sequence.
@@ -120,8 +112,7 @@
* @param mode The context in which the write is occurring
* @return True if the compare and swap was successful
*/
- public abstract boolean wordTryCompareAndSwap(ObjectReference ref, Word old, Word target,
- Word metaDataA, Word metaDataB, int mode);
+ public abstract boolean wordTryCompareAndSwap(ObjectReference ref, Word old, Word target, Word metaDataA, Word metaDataB, int mode);

/**
* Perform the actual read of the read barrier, returning the value as a raw Word.
@@ -132,8 +123,7 @@
* @param mode The context in which the write is occurring
* @return the read value
*/
- public abstract Word wordRead(ObjectReference ref,
- Word metaDataA, Word metaDataB, int mode);
+ public abstract Word wordRead(ObjectReference ref, Word metaDataA, Word metaDataB, int mode);

/**
* Sets an element of an object array without invoking any write
@@ -145,6 +135,5 @@
* @param index the index of the element to set
* @param value the new value for the element
*/
- public abstract void referenceArrayStoreNoGCBarrier(Object [] dst, int index, Object value);
-
+ public abstract void objectArrayStoreNoGCBarrier(Object [] dst, int index, Object value);
}

Modified: rvmroot/trunk/rvm/src/org/jikesrvm/Services.java
===================================================================
--- rvmroot/trunk/rvm/src/org/jikesrvm/Services.java 2009-09-18 02:15:19 UTC (rev 15781)
+++ rvmroot/trunk/rvm/src/org/jikesrvm/Services.java 2009-09-18 03:57:39 UTC (rev 15782)
@@ -337,8 +337,8 @@
@Inline
public static void setArrayUninterruptible(Object[] dst, int index, Object value) {
if (VM.runningVM) {
- if (Barriers.NEEDS_REFERENCE_ASTORE_BARRIER) {
- Barriers.referenceArrayWrite(dst, index, value);
+ if (Barriers.NEEDS_OBJECT_ASTORE_BARRIER) {
+ Barriers.objectArrayWrite(dst, index, value);
} else {
Magic.setObjectAtOffset(dst, Offset.fromIntZeroExtend(index << LOG_BYTES_IN_ADDRESS), value);
}

Modified: rvmroot/trunk/rvm/src/org/jikesrvm/classloader/RVMArray.java
===================================================================
--- rvmroot/trunk/rvm/src/org/jikesrvm/classloader/RVMArray.java 2009-09-18 02:15:19 UTC (rev 15781)
+++ rvmroot/trunk/rvm/src/org/jikesrvm/classloader/RVMArray.java 2009-09-18 03:57:39 UTC (rev 15782)
@@ -1025,9 +1025,9 @@
Offset dstOffset = Offset.fromIntZeroExtend(dstIdx << LOG_BYTES_IN_ADDRESS);
int bytes = len << LOG_BYTES_IN_ADDRESS;

- if (!NEEDS_REFERENCE_ALOAD_BARRIER && ((src != dst) || loToHi)) {
- if (!NEEDS_REFERENCE_ASTORE_BARRIER ||
- !Barriers.referenceBulkCopy(src, srcOffset, dst, dstOffset, bytes)) {
+ if (!NEEDS_OBJECT_ALOAD_BARRIER && ((src != dst) || loToHi)) {
+ if (!NEEDS_OBJECT_ASTORE_BARRIER ||
+ !Barriers.objectBulkCopy(src, srcOffset, dst, dstOffset, bytes)) {
Memory.alignedWordCopy(Magic.objectAsAddress(dst).plus(dstOffset),
Magic.objectAsAddress(src).plus(srcOffset),
bytes);
@@ -1046,13 +1046,13 @@
// perform the copy
while (len-- != 0) {
Object value;
- if (NEEDS_REFERENCE_GETFIELD_BARRIER) {
- value = Barriers.referenceArrayRead(src, srcOffset.toInt() >> LOG_BYTES_IN_ADDRESS);
+ if (NEEDS_OBJECT_GETFIELD_BARRIER) {
+ value = Barriers.objectArrayRead(src, srcOffset.toInt() >> LOG_BYTES_IN_ADDRESS);
} else {
value = Magic.getObjectAtOffset(src, srcOffset);
}
- if (NEEDS_REFERENCE_PUTFIELD_BARRIER) {
- Barriers.referenceArrayWrite(dst, dstOffset.toInt() >> LOG_BYTES_IN_ADDRESS, value);
+ if (NEEDS_OBJECT_PUTFIELD_BARRIER) {
+ Barriers.objectArrayWrite(dst, dstOffset.toInt() >> LOG_BYTES_IN_ADDRESS, value);
} else {
Magic.setObjectAtOffset(dst, dstOffset, value);
}

Modified: rvmroot/trunk/rvm/src/org/jikesrvm/classloader/RVMField.java
===================================================================
--- rvmroot/trunk/rvm/src/org/jikesrvm/classloader/RVMField.java 2009-09-18 02:15:19 UTC (rev 15781)
+++ rvmroot/trunk/rvm/src/org/jikesrvm/classloader/RVMField.java 2009-09-18 03:57:39 UTC (rev 15782)
@@ -295,14 +295,14 @@
*/
public Object getObjectValueUnchecked(Object obj) {
if (isStatic()) {
- if (NEEDS_REFERENCE_GETSTATIC_BARRIER && !isUntraced()) {
- return Barriers.referenceNonHeapRead(getOffset(), getId());
+ if (NEEDS_OBJECT_GETSTATIC_BARRIER && !isUntraced()) {
+ return Barriers.objectStaticRead(getOffset(), getId());
} else {
return Statics.getSlotContentsAsObject(getOffset());
}
} else {
- if (NEEDS_REFERENCE_GETFIELD_BARRIER && !isUntraced()) {
- return Barriers.referenceFieldRead(obj, getOffset(), getId());
+ if (NEEDS_OBJECT_GETFIELD_BARRIER && !isUntraced()) {
+ return Barriers.objectFieldRead(obj, getOffset(), getId());
} else {
return Magic.getObjectAtOffset(obj, getOffset());
}
@@ -390,14 +390,14 @@
*/
public void setObjectValueUnchecked(Object obj, Object ref) {
if (isStatic()) {
- if (NEEDS_REFERENCE_PUTSTATIC_BARRIER && !isUntraced()) {
- Barriers.referenceNonHeapWrite(ref, getOffset(), getId());
+ if (NEEDS_OBJECT_PUTSTATIC_BARRIER && !isUntraced()) {
+ Barriers.objectStaticWrite(ref, getOffset(), getId());
} else {
Statics.setSlotContents(getOffset(), ref);
}
} else {
- if (NEEDS_REFERENCE_PUTFIELD_BARRIER && !isUntraced()) {
- Barriers.referenceFieldWrite(obj, ref, getOffset(), getId());
+ if (NEEDS_OBJECT_PUTFIELD_BARRIER && !isUntraced()) {
+ Barriers.objectFieldWrite(obj, ref, getOffset(), getId());
} else {
Magic.setObjectAtOffset(obj, getOffset(), ref);
}

Modified: rvmroot/trunk/rvm/src/org/jikesrvm/compilers/baseline/ia32/Barriers.java
===================================================================
--- rvmroot/trunk/rvm/src/org/jikesrvm/compilers/baseline/ia32/Barriers.java 2009-09-18 02:15:19 UTC (rev 15781)
+++ rvmroot/trunk/rvm/src/org/jikesrvm/compilers/baseline/ia32/Barriers.java 2009-09-18 03:57:39 UTC (rev 15782)
@@ -52,7 +52,7 @@
asm.emitPUSH_Imm(locationMetadata);
BaselineCompilerImpl.genParameterRegisterLoad(asm, 4);
genNullCheck(asm, T0);
- asm.emitCALL_Abs(Magic.getTocPointer().plus(Entrypoints.referenceFieldWriteBarrierMethod.getOffset()));
+ asm.emitCALL_Abs(Magic.getTocPointer().plus(Entrypoints.objectFieldWriteBarrierMethod.getOffset()));
}

/**
@@ -69,7 +69,7 @@
asm.emitPUSH_Imm(locationMetadata);
BaselineCompilerImpl.genParameterRegisterLoad(asm, 4);
genNullCheck(asm, T0);
- asm.emitCALL_Abs(Magic.getTocPointer().plus(Entrypoints.referenceFieldWriteBarrierMethod.getOffset()));
+ asm.emitCALL_Abs(Magic.getTocPointer().plus(Entrypoints.objectFieldWriteBarrierMethod.getOffset()));
}

static void compilePutstaticBarrier(Assembler asm, GPR reg, int locationMetadata) {
@@ -78,7 +78,7 @@
asm.emitPUSH_Reg(reg); // offset
asm.emitPUSH_Imm(locationMetadata);
BaselineCompilerImpl.genParameterRegisterLoad(asm, 3);
- asm.emitCALL_Abs(Magic.getTocPointer().plus(Entrypoints.referenceNonHeapWriteBarrierMethod.getOffset()));
+ asm.emitCALL_Abs(Magic.getTocPointer().plus(Entrypoints.objectNonHeapWriteBarrierMethod.getOffset()));
}

static void compilePutstaticBarrierImm(Assembler asm, Offset fieldOffset, int locationMetadata) {
@@ -86,14 +86,14 @@
asm.emitPUSH_Imm(fieldOffset.toInt());
asm.emitPUSH_Imm(locationMetadata);
BaselineCompilerImpl.genParameterRegisterLoad(asm, 3);
- asm.emitCALL_Abs(Magic.getTocPointer().plus(Entrypoints.referenceNonHeapWriteBarrierMethod.getOffset()));
+ asm.emitCALL_Abs(Magic.getTocPointer().plus(Entrypoints.objectNonHeapWriteBarrierMethod.getOffset()));
}

static void compileArrayLoadBarrier(Assembler asm, boolean pushResult) {
// on entry java stack contains ...|target_array_ref|array_index|
// SP -> index, SP+4 -> target_ref
BaselineCompilerImpl.genParameterRegisterLoad(asm, 2);
- asm.emitCALL_Abs(Magic.getTocPointer().plus(Entrypoints.referenceArrayReadBarrierMethod.getOffset()));
+ asm.emitCALL_Abs(Magic.getTocPointer().plus(Entrypoints.objectArrayReadBarrierMethod.getOffset()));
if (pushResult) asm.emitPUSH_Reg(T0);
}

@@ -104,7 +104,7 @@
asm.emitPUSH_Imm(locationMetadata);
BaselineCompilerImpl.genParameterRegisterLoad(asm, 3);
genNullCheck(asm, T0);
- asm.emitCALL_Abs(Magic.getTocPointer().plus(Entrypoints.referenceFieldReadBarrierMethod.getOffset()));
+ asm.emitCALL_Abs(Magic.getTocPointer().plus(Entrypoints.objectFieldReadBarrierMethod.getOffset()));
asm.emitPUSH_Reg(T0);
}

@@ -113,7 +113,7 @@
asm.emitPUSH_Imm(locationMetadata);
BaselineCompilerImpl.genParameterRegisterLoad(asm, 3);
genNullCheck(asm, T0);
- asm.emitCALL_Abs(Magic.getTocPointer().plus(Entrypoints.referenceFieldReadBarrierMethod.getOffset()));
+ asm.emitCALL_Abs(Magic.getTocPointer().plus(Entrypoints.objectFieldReadBarrierMethod.getOffset()));
asm.emitPUSH_Reg(T0);
}

@@ -121,7 +121,7 @@
asm.emitPUSH_Reg(reg);
asm.emitPUSH_Imm(locationMetadata);
BaselineCompilerImpl.genParameterRegisterLoad(asm, 2);
- asm.emitCALL_Abs(Magic.getTocPointer().plus(Entrypoints.referenceNonHeapReadBarrierMethod.getOffset()));
+ asm.emitCALL_Abs(Magic.getTocPointer().plus(Entrypoints.objectNonHeapReadBarrierMethod.getOffset()));
asm.emitPUSH_Reg(T0);
}

@@ -129,7 +129,7 @@
asm.emitPUSH_Imm(fieldOffset.toInt());
asm.emitPUSH_Imm(locationMetadata);
BaselineCompilerImpl.genParameterRegisterLoad(asm, 2);
- asm.emitCALL_Abs(Magic.getTocPointer().plus(Entrypoints.referenceNonHeapReadBarrierMethod.getOffset()));
+ asm.emitCALL_Abs(Magic.getTocPointer().plus(Entrypoints.objectNonHeapReadBarrierMethod.getOffset()));
asm.emitPUSH_Reg(T0);
}

Modified: rvmroot/trunk/rvm/src/org/jikesrvm/compilers/baseline/ia32/BaselineCompilerImpl.java
===================================================================
--- rvmroot/trunk/rvm/src/org/jikesrvm/compilers/baseline/ia32/BaselineCompilerImpl.java 2009-09-18 02:15:19 UTC (rev 15781)
+++ rvmroot/trunk/rvm/src/org/jikesrvm/compilers/baseline/ia32/BaselineCompilerImpl.java 2009-09-18 03:57:39 UTC (rev 15782)
@@ -576,7 +576,7 @@
asm.emitPOP_Reg(T0); // T0 is array index
asm.emitPOP_Reg(T1); // T1 is array ref
genBoundsCheck(asm, T0, T1); // T0 is index, T1 is address of array
- if (NEEDS_REFERENCE_ALOAD_BARRIER) {
+ if (NEEDS_OBJECT_ALOAD_BARRIER) {
// rewind 2 args on stack
asm.emitPUSH_Reg(T1); // T1 is array ref
asm.emitPUSH_Reg(T0); // T0 is array index
@@ -2582,7 +2582,7 @@
@Override
protected final void emit_unresolved_getstatic(FieldReference fieldRef) {
emitDynamicLinkingSequence(asm, T0, fieldRef, true);
- if (NEEDS_REFERENCE_GETSTATIC_BARRIER && !fieldRef.getFieldContentsType().isPrimitiveType()) {
+ if (NEEDS_OBJECT_GETSTATIC_BARRIER && !fieldRef.getFieldContentsType().isPrimitiveType()) {
Barriers.compileGetstaticBarrier(asm, T0, fieldRef.getId());
return;
}
@@ -2616,7 +2616,7 @@
protected final void emit_resolved_getstatic(FieldReference fieldRef) {
RVMField field = fieldRef.peekResolvedField();
Offset fieldOffset = field.getOffset();
- if (NEEDS_REFERENCE_GETSTATIC_BARRIER && !fieldRef.getFieldContentsType().isPrimitiveType() && !field.isUntraced()) {
+ if (NEEDS_OBJECT_GETSTATIC_BARRIER && !fieldRef.getFieldContentsType().isPrimitiveType() && !field.isUntraced()) {
Barriers.compileGetstaticBarrierImm(asm, fieldOffset, fieldRef.getId());
return;
}
@@ -2648,7 +2648,7 @@
@Override
protected final void emit_unresolved_putstatic(FieldReference fieldRef) {
emitDynamicLinkingSequence(asm, T0, fieldRef, true);
- if (NEEDS_REFERENCE_PUTSTATIC_BARRIER && fieldRef.getFieldContentsType().isReferenceType()) {
+ if (NEEDS_OBJECT_PUTSTATIC_BARRIER && fieldRef.getFieldContentsType().isReferenceType()) {
Barriers.compilePutstaticBarrier(asm, T0, fieldRef.getId());
} else {
if (fieldRef.getSize() <= BYTES_IN_INT) { // field is one word
@@ -2681,7 +2681,7 @@
protected final void emit_resolved_putstatic(FieldReference fieldRef) {
RVMField field = fieldRef.peekResolvedField();
Offset fieldOffset = field.getOffset();
- if (NEEDS_REFERENCE_PUTSTATIC_BARRIER && field.isReferenceType() && !field.isUntraced()) {
+ if (NEEDS_OBJECT_PUTSTATIC_BARRIER && field.isReferenceType() && !field.isUntraced()) {
Barriers.compilePutstaticBarrierImm(asm, fieldOffset, fieldRef.getId());
} else {
if (field.getSize() <= BYTES_IN_INT) { // field is one word
@@ -2716,7 +2716,7 @@
emitDynamicLinkingSequence(asm, T0, fieldRef, true);
if (fieldType.isReferenceType()) {
// 32/64bit reference load
- if (NEEDS_REFERENCE_GETFIELD_BARRIER) {
+ if (NEEDS_OBJECT_GETFIELD_BARRIER) {
Barriers.compileGetfieldBarrier(asm, T0, fieldRef.getId());
} else {
asm.emitPOP_Reg(S0); // S0 is object reference
@@ -2785,7 +2785,7 @@
Offset fieldOffset = field.getOffset();
if (field.isReferenceType()) {
// 32/64bit reference load
- if (NEEDS_REFERENCE_GETFIELD_BARRIER && !field.isUntraced()) {
+ if (NEEDS_OBJECT_GETFIELD_BARRIER && !field.isUntraced()) {
Barriers.compileGetfieldBarrierImm(asm, fieldOffset, fieldRef.getId());
} else {
asm.emitPOP_Reg(T0); // T0 is object reference
@@ -2855,7 +2855,7 @@
emitDynamicLinkingSequence(asm, T0, fieldRef, true);
if (fieldType.isReferenceType()) {
// 32/64bit reference store
- if (NEEDS_REFERENCE_PUTFIELD_BARRIER) {
+ if (NEEDS_OBJECT_PUTFIELD_BARRIER) {
Barriers.compilePutfieldBarrier(asm, T0, fieldRef.getId());
} else {
asm.emitPOP_Reg(T1); // T1 is the value to be stored
@@ -2926,7 +2926,7 @@
Offset fieldOffset = field.getOffset();
if (field.isReferenceType()) {
// 32/64bit reference store
- if (NEEDS_REFERENCE_PUTFIELD_BARRIER && !field.isUntraced()) {
+ if (NEEDS_OBJECT_PUTFIELD_BARRIER && !field.isUntraced()) {
Barriers.compilePutfieldBarrierImm(asm, fieldOffset, fieldRef.getId());
} else {
asm.emitPOP_Reg(T0); // T0 is the value to be stored
@@ -3791,7 +3791,7 @@

if (!VM.runningTool && ((BaselineCompiledMethod) compiledMethod).hasCounterArray()) {
// use (nonvolatile) EBX to hold base of this method's counter array
- if (NEEDS_REFERENCE_ALOAD_BARRIER) {
+ if (NEEDS_OBJECT_ALOAD_BARRIER) {
asm.emitPUSH_Abs(Magic.getTocPointer().plus(Entrypoints.edgeCountersField.getOffset()));
asm.emitPUSH_Imm(getEdgeCounterIndex());
Barriers.compileArrayLoadBarrier(asm, false);

Modified: rvmroot/trunk/rvm/src/org/jikesrvm/compilers/opt/hir2lir/ExpandRuntimeServices.java
===================================================================
--- rvmroot/trunk/rvm/src/org/jikesrvm/compilers/opt/hir2lir/ExpandRuntimeServices.java 2009-09-18 02:15:19 UTC (rev 15781)
+++ rvmroot/trunk/rvm/src/org/jikesrvm/compilers/opt/hir2lir/ExpandRuntimeServices.java 2009-09-18 03:57:39 UTC (rev 15782)
@@ -372,8 +372,8 @@
break;

case REF_ASTORE_opcode: {
- if (NEEDS_REFERENCE_ASTORE_BARRIER) {
- RVMMethod target = Entrypoints.referenceArrayWriteBarrierMethod;
+ if (NEEDS_OBJECT_ASTORE_BARRIER) {
+ RVMMethod target = Entrypoints.objectArrayWriteBarrierMethod;
Instruction wb =
Call.create3(CALL,
null,
@@ -395,8 +395,8 @@
break;

case REF_ALOAD_opcode: {
- if (NEEDS_REFERENCE_ALOAD_BARRIER) {
- RVMMethod target = Entrypoints.referenceArrayReadBarrierMethod;
+ if (NEEDS_OBJECT_ALOAD_BARRIER) {
+ RVMMethod target = Entrypoints.objectArrayReadBarrierMethod;
Instruction rb =
Call.create2(CALL,
ALoad.getClearResult(inst),
@@ -415,13 +415,13 @@
break;

case PUTFIELD_opcode: {
- if (NEEDS_REFERENCE_PUTFIELD_BARRIER) {
+ if (NEEDS_OBJECT_PUTFIELD_BARRIER) {
LocationOperand loc = PutField.getLocation(inst);
FieldReference fieldRef = loc.getFieldRef();
if (!fieldRef.getFieldContentsType().isPrimitiveType()) {
RVMField field = fieldRef.peekResolvedField();
if (field == null || !field.isUntraced()) {
- RVMMethod target = Entrypoints.referenceFieldWriteBarrierMethod;
+ RVMMethod target = Entrypoints.objectFieldWriteBarrierMethod;
Instruction wb =
Call.create4(CALL,
null,
@@ -446,13 +446,13 @@
break;

case GETFIELD_opcode: {
- if (NEEDS_REFERENCE_GETFIELD_BARRIER) {
+ if (NEEDS_OBJECT_GETFIELD_BARRIER) {
LocationOperand loc = GetField.getLocation(inst);
FieldReference fieldRef = loc.getFieldRef();
if (GetField.getResult(inst).getType().isReferenceType()) {
RVMField field = fieldRef.peekResolvedField();
if (field == null || !field.isUntraced()) {
- RVMMethod target = Entrypoints.referenceFieldReadBarrierMethod;
+ RVMMethod target = Entrypoints.objectFieldReadBarrierMethod;
Instruction rb =
Call.create3(CALL,
GetField.getClearResult(inst),
@@ -474,11 +474,11 @@
break;

case PUTSTATIC_opcode: {
- if (NEEDS_REFERENCE_PUTSTATIC_BARRIER) {
+ if (NEEDS_OBJECT_PUTSTATIC_BARRIER) {
LocationOperand loc = PutStatic.getLocation(inst);
FieldReference field = loc.getFieldRef();
if (!field.getFieldContentsType().isPrimitiveType()) {
- RVMMethod target = Entrypoints.referenceNonHeapWriteBarrierMethod;
+ RVMMethod target = Entrypoints.objectNonHeapWriteBarrierMethod;
Instruction wb =
Call.create3(CALL,
null,
@@ -500,11 +500,11 @@
break;

case GETSTATIC_opcode: {
- if (NEEDS_REFERENCE_GETSTATIC_BARRIER) {
+ if (NEEDS_OBJECT_GETSTATIC_BARRIER) {
LocationOperand loc = GetStatic.getLocation(inst);
FieldReference field = loc.getFieldRef();
if (!field.getFieldContentsType().isPrimitiveType()) {
- RVMMethod target = Entrypoints.referenceNonHeapReadBarrierMethod;
+ RVMMethod target = Entrypoints.objectNonHeapReadBarrierMethod;
Instruction rb =
Call.create2(CALL,
GetStatic.getClearResult(inst),

Modified: rvmroot/trunk/rvm/src/org/jikesrvm/mm/mminterface/Barriers.java
===================================================================
--- rvmroot/trunk/rvm/src/org/jikesrvm/mm/mminterface/Barriers.java 2009-09-18 02:15:19 UTC (rev 15781)
+++ rvmroot/trunk/rvm/src/org/jikesrvm/mm/mminterface/Barriers.java 2009-09-18 03:57:39 UTC (rev 15782)
@@ -44,30 +44,20 @@
}

/** True if the garbage collector requires write barriers on reference putfield, arraystore or modifycheck */
- private static final boolean NEEDS_REFERENCE_GC_WRITE_BARRIER = Selected.Constraints.get().needsReferenceWriteBarrier();
+ private static final boolean NEEDS_OBJECT_GC_WRITE_BARRIER = Selected.Constraints.get().needsObjectReferenceWriteBarrier();
/** True if the VM requires write barriers on reference putfield */
- public static final boolean NEEDS_REFERENCE_PUTFIELD_BARRIER = NEEDS_REFERENCE_GC_WRITE_BARRIER;
+ public static final boolean NEEDS_OBJECT_PUTFIELD_BARRIER = NEEDS_OBJECT_GC_WRITE_BARRIER;
/** True if the VM requires write barriers on reference arraystore */
- public static final boolean NEEDS_REFERENCE_ASTORE_BARRIER = NEEDS_REFERENCE_GC_WRITE_BARRIER;
+ public static final boolean NEEDS_OBJECT_ASTORE_BARRIER = NEEDS_OBJECT_GC_WRITE_BARRIER;
/** True if the garbage collector requires read barriers on reference getfield or arrayload */
- private static final boolean NEEDS_REFERENCE_GC_READ_BARRIER = Selected.Constraints.get().needsReferenceReadBarrier();
+ private static final boolean NEEDS_OBJECT_GC_READ_BARRIER = Selected.Constraints.get().needsObjectReferenceReadBarrier();
/** True if the VM requires read barriers on reference getfield */
- public static final boolean NEEDS_REFERENCE_GETFIELD_BARRIER = NEEDS_REFERENCE_GC_READ_BARRIER;
+ public static final boolean NEEDS_OBJECT_GETFIELD_BARRIER = NEEDS_OBJECT_GC_READ_BARRIER;
/** True if the VM requires read barriers on reference arrayload */
- public static final boolean NEEDS_REFERENCE_ALOAD_BARRIER = NEEDS_REFERENCE_GC_READ_BARRIER;
+ public static final boolean NEEDS_OBJECT_ALOAD_BARRIER = NEEDS_OBJECT_GC_READ_BARRIER;

- /** True if the selected plan requires write barriers on reference putstatic */
- private static final boolean NEEDS_REFERENCE_GC_PUTSTATIC_BARRIER = Selected.Constraints.get().needsReferenceStaticWriteBarrier();
- /** True if the selected plan requires write barriers on reference putstatic */
- public static final boolean NEEDS_REFERENCE_PUTSTATIC_BARRIER = NEEDS_REFERENCE_GC_PUTSTATIC_BARRIER;
- /** True if the selected plan requires read barriers on reference getstatic */
- private static final boolean NEEDS_REFERENCE_GC_GETSTATIC_BARRIER = Selected.Constraints.get().needsReferenceStaticReadBarrier();
- /** True if the selected plan requires read barriers on reference getstatic */
- public static final boolean NEEDS_REFERENCE_GETSTATIC_BARRIER = NEEDS_REFERENCE_GC_GETSTATIC_BARRIER;
-
-
/**
- * Barrier for writes of references into fields of instances (ie putfield).
+ * Barrier for writes of objects into fields of instances (ie putfield).
*
* @param ref the object which is the subject of the putfield
* @param value the new value for the field
@@ -76,10 +66,10 @@
*/
@Inline
@Entrypoint
- public static void referenceFieldWrite(Object ref, Object value, Offset offset, int locationMetadata) {
- if (NEEDS_REFERENCE_GC_WRITE_BARRIER) {
+ public static void objectFieldWrite(Object ref, Object value, Offset offset, int locationMetadata) {
+ if (NEEDS_OBJECT_GC_WRITE_BARRIER) {
ObjectReference src = ObjectReference.fromObject(ref);
- Selected.Mutator.get().referenceWrite(src,
+ Selected.Mutator.get().objectReferenceWrite(src,
src.toAddress().plus(offset),
ObjectReference.fromObject(value),
offset.toWord(),
@@ -90,7 +80,7 @@
}

/**
- * Barrier for writes of references into arrays (ie astore).
+ * Barrier for writes of objects into arrays (ie astore).
*
* @param ref the array which is the subject of the astore
* @param index the index into the array where the new reference
@@ -100,11 +90,11 @@
*/
@Inline
@Entrypoint
- public static void referenceArrayWrite(Object ref, int index, Object value) {
- if (NEEDS_REFERENCE_GC_WRITE_BARRIER) {
+ public static void objectArrayWrite(Object ref, int index, Object value) {
+ if (NEEDS_OBJECT_GC_WRITE_BARRIER) {
ObjectReference array = ObjectReference.fromObject(ref);
Offset offset = Offset.fromIntZeroExtend(index << MemoryManagerConstants.LOG_BYTES_IN_ADDRESS);
- Selected.Mutator.get().referenceWrite(array,
+ Selected.Mutator.get().objectReferenceWrite(array,
array.toAddress().plus(offset),
ObjectReference.fromObject(value),
offset.toWord(),
@@ -115,7 +105,7 @@
}

/**
- * Barrier for loads of references from fields of instances (ie getfield).
+ * Barrier for loads of objects from fields of instances (ie getfield).
*
* @param ref the object which is the subject of the getfield
* @param offset the offset of the field to be read
@@ -124,10 +114,10 @@
*/
@Inline
@Entrypoint
- public static Object referenceFieldRead(Object ref, Offset offset, int locationMetadata) {
- if (NEEDS_REFERENCE_GC_READ_BARRIER) {
+ public static Object objectFieldRead(Object ref, Offset offset, int locationMetadata) {
+ if (NEEDS_OBJECT_GC_READ_BARRIER) {
ObjectReference src = ObjectReference.fromObject(ref);
- return Selected.Mutator.get().referenceRead(src,
+ return Selected.Mutator.get().objectReferenceRead(src,
src.toAddress().plus(offset),
offset.toWord(),
Word.fromIntZeroExtend(locationMetadata),
@@ -138,7 +128,7 @@
}

/**
- * Barrier for loads of references from fields of arrays (ie aload).
+ * Barrier for loads of objects from fields of arrays (ie aload).
*
* @param ref the array containing the reference.
* @param index the index into the array were the reference resides.
@@ -146,11 +136,11 @@
*/
@Inline
@Entrypoint
- public static Object referenceArrayRead(Object ref, int index) {
- if (NEEDS_REFERENCE_GC_READ_BARRIER) {
+ public static Object objectArrayRead(Object ref, int index) {
+ if (NEEDS_OBJECT_GC_READ_BARRIER) {
ObjectReference array = ObjectReference.fromObject(ref);
Offset offset = Offset.fromIntZeroExtend(index << MemoryManagerConstants.LOG_BYTES_IN_ADDRESS);
- return Selected.Mutator.get().referenceRead(array,
+ return Selected.Mutator.get().objectReferenceRead(array,
array.toAddress().plus(offset),
offset.toWord(),
Word.zero(), // don't know metadata
@@ -161,7 +151,7 @@
}

/**
- * Barrier for a copy (i.e. in an array copy).
+ * Barrier for a bulk copy of objects (i.e. in an array copy).
*
* @param src The source object
* @param srcOffset The offset of the first source address, in
@@ -176,9 +166,9 @@
* left to the caller (always false in this case).
*/
@Inline
- public static boolean referenceBulkCopy(Object src, Offset srcOffset, Object tgt, Offset tgtOffset, int bytes) {
- if (NEEDS_REFERENCE_GC_WRITE_BARRIER || NEEDS_REFERENCE_GC_READ_BARRIER) {
- return Selected.Mutator.get().referenceBulkCopy(ObjectReference.fromObject(src),
+ public static boolean objectBulkCopy(Object src, Offset srcOffset, Object tgt, Offset tgtOffset, int bytes) {
+ if (NEEDS_OBJECT_GC_WRITE_BARRIER || NEEDS_OBJECT_GC_READ_BARRIER) {
+ return Selected.Mutator.get().objectReferenceBulkCopy(ObjectReference.fromObject(src),
srcOffset,
ObjectReference.fromObject(tgt),
tgtOffset,
@@ -188,48 +178,58 @@
return false;
}

+
+ /** True if the selected plan requires write barriers on reference putstatic */
+ private static final boolean NEEDS_OBJECT_GC_PUTSTATIC_BARRIER = Selected.Constraints.get().needsObjectReferenceNonHeapWriteBarrier();
+ /** True if the selected plan requires write barriers on reference putstatic */
+ public static final boolean NEEDS_OBJECT_PUTSTATIC_BARRIER = NEEDS_OBJECT_GC_PUTSTATIC_BARRIER;
+ /** True if the selected plan requires read barriers on reference getstatic */
+ private static final boolean NEEDS_OBJECT_GC_GETSTATIC_BARRIER = Selected.Constraints.get().needsObjectReferenceNonHeapReadBarrier();
+ /** True if the selected plan requires read barriers on reference getstatic */
+ public static final boolean NEEDS_OBJECT_GETSTATIC_BARRIER = NEEDS_OBJECT_GC_GETSTATIC_BARRIER;
+
/**
- * Barrier for loads of references from non-heap locations (ie getstatic)
+ * Barrier for writes of objects from statics (eg putstatic)
*
+ * @param value the new value to be stored
* @param offset the offset of the field to be modified
- * @param locationMetadata an int that encodes the source location being read
- * @return the value read from the field
+ * @param locationMetadata an int that encodes the source location being modified
*/
@Inline
@Entrypoint
- public static Object referenceNonHeapRead(Offset offset, int locationMetadata) {
- if (NEEDS_REFERENCE_GC_GETSTATIC_BARRIER) {
+ public static void objectStaticWrite(Object value, Offset offset, int locationMetadata) {
+ if (NEEDS_OBJECT_GC_PUTSTATIC_BARRIER) {
ObjectReference src = ObjectReference.fromObject(Magic.getJTOC());
- return Selected.Mutator.get().referenceNonHeapRead(
- src.toAddress().plus(offset),
+ Selected.Mutator.get().objectReferenceNonHeapWrite(src.toAddress().plus(offset),
+ ObjectReference.fromObject(value),
offset.toWord(),
- Word.fromIntZeroExtend(locationMetadata)).toObject();
+ Word.fromIntZeroExtend(locationMetadata));
} else if (VM.VERIFY_ASSERTIONS)
VM.assertions._assert(false);
- return null;
}

-
/**
- * Barrier for writes of references to non-heap locations (eg statics)
+ * Barrier for loads of objects from statics (ie getstatic)
*
- * @param value the new value to be stored
* @param offset the offset of the field to be modified
- * @param locationMetadata an int that encodes the source location being modified
+ * @param locationMetadata an int that encodes the source location being read
+ * @return the value read from the field
*/
@Inline
@Entrypoint
- public static void referenceNonHeapWrite(Object value, Offset offset, int locationMetadata) {
- if (NEEDS_REFERENCE_GC_PUTSTATIC_BARRIER) {
+ public static Object objectStaticRead(Offset offset, int locationMetadata) {
+ if (NEEDS_OBJECT_GC_GETSTATIC_BARRIER) {
ObjectReference src = ObjectReference.fromObject(Magic.getJTOC());
- Selected.Mutator.get().referenceNonHeapWrite(src.toAddress().plus(offset),
- ObjectReference.fromObject(value),
+ return Selected.Mutator.get().objectReferenceNonHeapRead(
+ src.toAddress().plus(offset),
offset.toWord(),
- Word.fromIntZeroExtend(locationMetadata));
+ Word.fromIntZeroExtend(locationMetadata)).toObject();
} else if (VM.VERIFY_ASSERTIONS)
VM.assertions._assert(false);
+ return null;
}

+
/**
* Barrier for conditional compare and exchange of reference fields.
*
@@ -239,10 +239,10 @@
* @param value the new value for the field
*/
@Inline
- public static boolean referenceTryCompareAndSwap(Object ref, Offset offset, Object old, Object value) {
- if (NEEDS_REFERENCE_GC_WRITE_BARRIER || NEEDS_REFERENCE_GC_READ_BARRIER) {
+ public static boolean objectTryCompareAndSwap(Object ref, Offset offset, Object old, Object value) {
+ if (NEEDS_OBJECT_GC_WRITE_BARRIER || NEEDS_OBJECT_GC_READ_BARRIER) {
ObjectReference src = ObjectReference.fromObject(ref);
- return Selected.Mutator.get().referenceTryCompareAndSwap(src,
+ return Selected.Mutator.get().objectReferenceTryCompareAndSwap(src,
src.toAddress().plus(offset),
ObjectReference.fromObject(old),
ObjectReference.fromObject(value),

Modified: rvmroot/trunk/rvm/src/org/jikesrvm/mm/mminterface/MemoryManager.java
===================================================================
--- rvmroot/trunk/rvm/src/org/jikesrvm/mm/mminterface/MemoryManager.java 2009-09-18 02:15:19 UTC (rev 15781)
+++ rvmroot/trunk/rvm/src/org/jikesrvm/mm/mminterface/MemoryManager.java 2009-09-18 03:57:39 UTC (rev 15782)
@@ -106,7 +106,7 @@
*/
@Interruptible
public static void init() {
- if (VM.VerifyAssertions) VM._assert(!Selected.Constraints.get().needsReferenceStaticReadBarrier());
+ if (VM.VerifyAssertions) VM._assert(!Selected.Constraints.get().needsObjectReferenceNonHeapReadBarrier());
CollectorThread.init();
org.jikesrvm.mm.mmtk.Collection.init();
}

Modified: rvmroot/trunk/rvm/src/org/jikesrvm/osr/ObjectHolder.java
===================================================================
--- rvmroot/trunk/rvm/src/org/jikesrvm/osr/ObjectHolder.java 2009-09-18 02:15:19 UTC (rev 15781)
+++ rvmroot/trunk/rvm/src/org/jikesrvm/osr/ObjectHolder.java 2009-09-18 03:57:39 UTC (rev 15782)
@@ -93,8 +93,8 @@
VM.sysWriteln("ObjectHolder cleanRefs");
}
/* refs[h] = null; */
- if (Barriers.NEEDS_REFERENCE_ASTORE_BARRIER) {
- Barriers.referenceArrayWrite(refs, h, null);
+ if (Barriers.NEEDS_OBJECT_ASTORE_BARRIER) {
+ Barriers.objectArrayWrite(refs, h, null);
} else {
Magic.setObjectAtOffset(refs, Offset.fromIntSignExtend(h << LOG_BYTES_IN_ADDRESS), null);
}

Modified: rvmroot/trunk/rvm/src/org/jikesrvm/runtime/Entrypoints.java
===================================================================
--- rvmroot/trunk/rvm/src/org/jikesrvm/runtime/Entrypoints.java 2009-09-18 02:15:19 UTC (rev 15781)
+++ rvmroot/trunk/rvm/src/org/jikesrvm/runtime/Entrypoints.java 2009-09-18 03:57:39 UTC (rev 15782)
@@ -263,20 +263,21 @@
public static final RVMField synchronizedCounterField =
getField(org.jikesrvm.mm.mmtk.SynchronizedCounter.class, "count", int.class);

- public static final NormalMethod referenceArrayWriteBarrierMethod =
- getMethod(org.jikesrvm.mm.mminterface.Barriers.class, "referenceArrayWrite", "(Ljava/lang/Object;ILjava/lang/Object;)V");
- public static final NormalMethod referenceFieldWriteBarrierMethod =
- getMethod(org.jikesrvm.mm.mminterface.Barriers.class, "referenceFieldWrite", "(Ljava/lang/Object;Ljava/lang/Object;Lorg/vmmagic/unboxed/Offset;I)V");
- public static final NormalMethod referenceNonHeapWriteBarrierMethod =
- getMethod(org.jikesrvm.mm.mminterface.Barriers.class, "referenceNonHeapWrite", "(Ljava/lang/Object;Lorg/vmmagic/unboxed/Offset;I)V");
+ public static final NormalMethod objectArrayWriteBarrierMethod =
+ getMethod(org.jikesrvm.mm.mminterface.Barriers.class, "objectArrayWrite", "(Ljava/lang/Object;ILjava/lang/Object;)V");
+ public static final NormalMethod objectFieldWriteBarrierMethod =
+ getMethod(org.jikesrvm.mm.mminterface.Barriers.class, "objectFieldWrite", "(Ljava/lang/Object;Ljava/lang/Object;Lorg/vmmagic/unboxed/Offset;I)V");

- public static final NormalMethod referenceArrayReadBarrierMethod =
- getMethod(org.jikesrvm.mm.mminterface.Barriers.class, "referenceArrayRead", "(Ljava/lang/Object;I)Ljava/lang/Object;");
- public static final NormalMethod referenceFieldReadBarrierMethod =
- getMethod(org.jikesrvm.mm.mminterface.Barriers.class, "referenceFieldRead", "(Ljava/lang/Object;Lorg/vmmagic/unboxed/Offset;I)Ljava/lang/Object;");
- public static final NormalMethod referenceNonHeapReadBarrierMethod =
- getMethod(org.jikesrvm.mm.mminterface.Barriers.class, "referenceNonHeapRead", "(Lorg/vmmagic/unboxed/Offset;I)Ljava/lang/Object;");
+ public static final NormalMethod objectArrayReadBarrierMethod =
+ getMethod(org.jikesrvm.mm.mminterface.Barriers.class, "objectArrayRead", "(Ljava/lang/Object;I)Ljava/lang/Object;");
+ public static final NormalMethod objectFieldReadBarrierMethod =
+ getMethod(org.jikesrvm.mm.mminterface.Barriers.class, "objectFieldRead", "(Ljava/lang/Object;Lorg/vmmagic/unboxed/Offset;I)Ljava/lang/Object;");

+ public static final NormalMethod objectNonHeapWriteBarrierMethod =
+ getMethod(org.jikesrvm.mm.mminterface.Barriers.class, "objectStaticWrite", "(Ljava/lang/Object;Lorg/vmmagic/unboxed/Offset;I)V");
+ public static final NormalMethod objectNonHeapReadBarrierMethod =
+ getMethod(org.jikesrvm.mm.mminterface.Barriers.class, "objectStaticRead", "(Lorg/vmmagic/unboxed/Offset;I)Ljava/lang/Object;");
+
public static final NormalMethod modifyCheckMethod =
getMethod(org.jikesrvm.mm.mminterface.MemoryManager.class, "modifyCheck", "(Ljava/lang/Object;)V");

Modified: rvmroot/trunk/rvm/src/org/jikesrvm/runtime/Statics.java
===================================================================
--- rvmroot/trunk/rvm/src/org/jikesrvm/runtime/Statics.java 2009-09-18 02:15:19 UTC (rev 15781)
+++ rvmroot/trunk/rvm/src/org/jikesrvm/runtime/Statics.java 2009-09-18 03:57:39 UTC (rev 15782)
@@ -617,8 +617,8 @@
// happen as the fault would only ever occur when not running the
// VM. We suppress the warning as we know the error can't happen.

- if (VM.runningVM && Barriers.NEEDS_REFERENCE_PUTSTATIC_BARRIER) {
- Barriers.referenceNonHeapWrite(object, offset, 0);
+ if (VM.runningVM && Barriers.NEEDS_OBJECT_PUTSTATIC_BARRIER) {
+ Barriers.objectStaticWrite(object, offset, 0);
} else {
setSlotContents(offset, Magic.objectAsAddress(object).toWord());
}

Modified: rvmroot/trunk/rvm/src/org/jikesrvm/scheduler/Synchronization.java
===================================================================
--- rvmroot/trunk/rvm/src/org/jikesrvm/scheduler/Synchronization.java 2009-09-18 02:15:19 UTC (rev 15781)
+++ rvmroot/trunk/rvm/src/org/jikesrvm/scheduler/Synchronization.java 2009-09-18 03:57:39 UTC (rev 15782)
@@ -93,8 +93,8 @@
*/
@Inline
public static boolean tryCompareAndSwap(Object base, Offset offset, Object testValue, Object newValue) {
- if (Barriers.NEEDS_REFERENCE_PUTFIELD_BARRIER) {
- return Barriers.referenceTryCompareAndSwap(base, offset, testValue, newValue);
+ if (Barriers.NEEDS_OBJECT_PUTFIELD_BARRIER) {
+ return Barriers.objectTryCompareAndSwap(base, offset, testValue, newValue);
} else {
Object oldValue;
do {

This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

------------------------------------------------------------------------------
Come build with us! The BlackBerry® Developer Conference in SF, CA
is the only developer event you need to attend this year. Jumpstart your
developing skills, take BlackBerry mobile applications to market and stay
ahead of the curve. Join us from November 9-12, 2009. Register now!
http://p.sf.net/sfu/devconf
_______________________________________________
Jikesrvm-commits mailing list
Jikesrvm-commits@...
https://lists.sourceforge.net/lists/listinfo/jikesrvm-commits