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

View: New views

1 Messages — Rating Filter: Alert me

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

by steveb-oss :: Rate this Message:

Reply to Author | View Threaded | Show Only this Message

Revision: 15772
http://jikesrvm.svn.sourceforge.net/jikesrvm/?rev=15772&view=rev
Author: steveb-oss
Date: 2009-08-28 21:08:26 +0000 (Fri, 28 Aug 2009)

Log Message:
-----------
Refactoring of barrier APIs in support of RVM-845. This is a fairly trivial but invastive refactoring which should make it easy for us to expland our barriers cleanly to deal with all of the primitive types. I've tested this pretty thoroughly on ia32, and done basic testing on PPC. I will watch regressions to see how it fares.

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/GenMutator.java
rvmroot/trunk/MMTk/src/org/mmtk/plan/poisoned/PoisonedMutator.java
rvmroot/trunk/MMTk/src/org/mmtk/plan/refcount/RCBaseMutator.java
rvmroot/trunk/MMTk/src/org/mmtk/plan/semispace/gctrace/GCTraceMutator.java
rvmroot/trunk/MMTk/src/org/mmtk/plan/stickyimmix/StickyImmixMutator.java
rvmroot/trunk/MMTk/src/org/mmtk/plan/stickyms/StickyMSMutator.java
rvmroot/trunk/MMTk/src/org/mmtk/utility/Constants.java
rvmroot/trunk/MMTk/src/org/mmtk/utility/heap/Map.java
rvmroot/trunk/MMTk/src/org/mmtk/vm/Barriers.java
rvmroot/trunk/libraryInterface/Common/src/java/lang/ref/Reference.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/baseline/ppc/Barriers.java
rvmroot/trunk/rvm/src/org/jikesrvm/compilers/baseline/ppc/BaselineCompilerImpl.java
rvmroot/trunk/rvm/src/org/jikesrvm/compilers/opt/hir2lir/ExpandRuntimeServices.java
rvmroot/trunk/rvm/src/org/jikesrvm/mm/mminterface/MemoryManager.java
rvmroot/trunk/rvm/src/org/jikesrvm/mm/mminterface/MemoryManagerConstants.java
rvmroot/trunk/rvm/src/org/jikesrvm/mm/mminterface/SynchronizationBarrier.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

Added Paths:
-----------
rvmroot/trunk/rvm/src/org/jikesrvm/mm/mminterface/Barriers.java

Removed Paths:
-------------
rvmroot/trunk/rvm/src/org/jikesrvm/mm/mminterface/Barrier.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-08-28 01:47:25 UTC (rev 15771)
+++ rvmroot/trunk/MMTk/ext/vm/harness/org/mmtk/harness/vm/Barriers.java 2009-08-28 21:08:26 UTC (rev 15772)
@@ -21,107 +21,102 @@
@Uninterruptible
public class Barriers extends org.mmtk.vm.Barriers {
/**
- * 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.
+ * Perform the actual write of the write barrier.
*
- * @param dst the destination array
- * @param index the index of the element to set
- * @param value the new value for the element
+ * @param ref The object that has the reference field
+ * @param target The value that the slot will be updated to
+ * @param slot The address to be written to
+ * @param unused Unused
+ * @param mode The context in which the write is occurring
*/
@Override
- public void setArrayNoBarrier(Object [] dst, int index, Object value) {
- dst[index] = value;
+ public void referenceWrite(ObjectReference ref, ObjectReference target,
+ Word slot, Word unused, int mode) {
+ slot.toAddress().store(target);
}

/**
- * Perform the actual write of the write barrier.
+ * 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 ref The object that has the reference field
- * @param slot The slot that holds the reference
+ * @param slot The address that contains the reference field
* @param target The value that the slot will be updated to
- * @param metaDataA Unused
- * @param metaDataB Unused
- * @param mode The context in which the write is occuring
+ * @param unusedA Opaque, VM-specific, meta-data identifying the slot
+ * @param unusedB Opaque, VM-specific, meta-data identifying the slot
*/
@Override
- public void performWriteInBarrier(ObjectReference ref, Address slot,
- ObjectReference target, Word metaDataA,
- Word metaDataB, int mode) {
+ public void referenceWrite(Address slot, ObjectReference target,
+ Word unusedA, Word unusedB) {
slot.store(target);
}

/**
- * Perform the actual write of the write barrier, writing the value as a raw Word.
+ * Atomically write a reference field of an object or array and return
+ * the old value of the reference field.
*
* @param ref The object that has the reference field
- * @param slot The slot that holds the reference
- * @param rawTarget The value that the slot will be updated to
- * @param metaDataA Unused
- * @param metaDataB Unused
- * @param mode The context in which the write is occuring
+ * @param target The value that the slot will be updated to
+ * @param slot The address to be written to
+ * @param unused Unused
+ * @param mode The context in which the write is occurring
+ * @return The value that was replaced by the write.
*/
@Override
- public void performRawWriteInBarrier(ObjectReference ref, Address slot,
- Word rawTarget, Word metaDataA,
- Word metaDataB, int mode) {
- slot.store(rawTarget);
+ public ObjectReference referenceAtomicWrite(ObjectReference ref, ObjectReference target,
+ Word slot, Word unused, int mode) {
+ ObjectReference old;
+ do {
+ old = slot.toAddress().prepareObjectReference();
+ } while (!slot.toAddress().attempt(old, target));
+ return old;
}

/**
- * Perform the actual read of the read barrier.
+ * Attempt an atomic compare and exchange in a write barrier sequence.
*
* @param ref The object that has the reference field
- * @param slot The slot that holds the reference
- * @param metaDataA Unused
- * @param metaDataB Unused
- * @param mode The context in which the write is occuring
- * @return the read value
+ * @param old The old reference to be swapped out
+ * @param target The value that the slot will be updated to
+ * @param slot The address to be written to
+ * @param unused Unused
+ * @param mode The context in which the write is occurring
+ * @return True if the compare and swap was successful
*/
@Override
- public ObjectReference performReadInBarrier(ObjectReference ref, Address slot,
- Word metaDataA, Word metaDataB, int mode) {
- return slot.loadObjectReference();
+ public boolean referenceTryCompareAndSwap(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, returning the value as a raw Word.
+ * Perform the actual read of the read barrier.
*
* @param ref The object that has the reference field
- * @param slot The slot that holds the reference
- * @param metaDataA Unused
- * @param metaDataB Unused
- * @param mode The context in which the write is occuring
+ * @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 Word performRawReadInBarrier(ObjectReference ref, Address slot,
- Word metaDataA, Word metaDataB, int mode) {
- return slot.loadWord();
+ public ObjectReference referenceRead(ObjectReference ref,
+ Word slot, Word unused, int mode) {
+ return slot.toAddress().loadObjectReference();
}

/**
- * Atomically write a reference field of an object or array and return
- * the old value of the reference field.
+ * Perform the actual write of the write barrier, writing the value as a raw Word.
*
* @param ref The object that has the reference field
- * @param slot The slot that holds the reference
* @param target The value that the slot will be updated to
- * @param metaDataA Unused
- * @param metaDataB Unused
- * @param mode The context in which the write is occuring
- * @return The value that was replaced by the write.
+ * @param slot The address to be written to
+ * @param unused Unused
+ * @param mode The context in which the write is occurring
*/
@Override
- public ObjectReference performWriteInBarrierAtomic(ObjectReference ref, Address slot,
- ObjectReference target, Word metaDataA,
- Word metaDataB, int mode) {
- ObjectReference old;
- do {
- old = slot.prepareObjectReference();
- } while (!slot.attempt(old, target));
- return old;
+ public void wordWrite(ObjectReference ref, Word target,
+ Word slot, Word unused, int mode) {
+ slot.toAddress().store(target);
}

/**
@@ -129,21 +124,19 @@
* the old value of the reference field.
*
* @param ref The object that has the reference field
- * @param slot The slot that holds the reference
- * @param rawTarget The raw value that the slot will be updated to
- * @param metaDataA Unused
- * @param metaDataB Unused
- * @param mode The context in which the write is occuring
+ * @param target The value that the slot will be updated to
+ * @param slot Unused
+ * @param unused Unused
+ * @param mode The context in which the write is occurring
* @return The raw value that was replaced by the write.
*/
@Override
- public Word performRawWriteInBarrierAtomic(ObjectReference ref, Address slot,
- Word rawTarget, Word metaDataA,
- Word metaDataB, int mode) {
+ public Word wordAtomicWrite(ObjectReference ref, Word target,
+ Word slot, Word unused, int mode) {
Word old;
do {
- old = slot.prepareWord();
- } while (!slot.attempt(old, rawTarget));
+ old = slot.toAddress().prepareWord();
+ } while (!slot.toAddress().attempt(old, target));
return old;
}

@@ -154,34 +147,45 @@
* @param slot The slot that holds the reference
* @param old The old reference to be swapped out
* @param target The value that the slot will be updated to
- * @param metaDataA Unused
- * @param metaDataB Unused
- * @param mode The context in which the write is occuring
+ * @param slot The address to be written to
+ * @param unused Unused
+ * @param mode The context in which the write is occurring
* @return True if the compare and swap was successful
*/
@Override
- public boolean tryCompareAndSwapWriteInBarrier(ObjectReference ref, Address slot,
- ObjectReference old, ObjectReference target,
- Word metaDataA, Word metaDataB, int mode) {
- return slot.attempt(old, target);
+ public boolean wordTryCompareAndSwap(ObjectReference ref, Word old, Word target,
+ Word slot, Word unused, int mode) {
+ return slot.toAddress().attempt(old, target);
}

/**
- * Attempt an atomic compare and exchange in a write barrier sequence.
+ * Perform the actual read of the read barrier, returning the value as a raw Word.
*
* @param ref The object that has the reference field
- * @param slot The slot that holds the reference
- * @param rawOld The old reference to be swapped out
- * @param rawTarget The value that the slot will be updated to
- * @param metaDataA Unused
- * @param metaDataB Unused
- * @param mode The context in which the write is occuring
- * @return True if the compare and swap was successful
+ * @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 boolean tryRawCompareAndSwapWriteInBarrier(ObjectReference ref, Address slot,
- Word rawOld, Word rawTarget,
- Word metaDataA, Word metaDataB, int mode) {
- return slot.attempt(rawOld, rawTarget);
+ public Word wordRead(ObjectReference ref,
+ Word slot, Word unused, int mode) {
+ return slot.toAddress().loadWord();
}
+
+ /**
+ * 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
+ */
+ @Override
+ public void referenceArrayStoreNoGCBarrier(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-08-28 01:47:25 UTC (rev 15771)
+++ rvmroot/trunk/MMTk/ext/vm/jikesrvm/org/jikesrvm/mm/mmtk/Barriers.java 2009-08-28 21:08:26 UTC (rev 15772)
@@ -25,131 +25,125 @@
* Perform the actual write of the write barrier.
*
* @param ref The object that has the reference field
- * @param slot The slot that holds the reference
* @param target The value that the slot will be updated to
- * @param metaDataA The offset from the ref
- * @param metaDataB The index of the FieldReference
- * @param mode The context in which the write is occuring
+ * @param offset The offset from the ref
+ * @param location The index of the FieldReference
+ * @param mode The context in which the write is occurring
*/
@Inline
- public final void performWriteInBarrier(ObjectReference ref, Address slot,
- ObjectReference target, Word metaDataA,
- Word metaDataB, int mode) {
- Object obj = ref.toObject();
- Offset offset = metaDataA.toOffset();
- int location = metaDataB.toInt();
- Magic.setObjectAtOffset(obj, offset, target.toObject(), location);
+ public final void referenceWrite(ObjectReference ref, ObjectReference target,
+ Word offset, Word location, int mode) {
+ Magic.setObjectAtOffset(ref.toObject(), offset.toOffset(), target.toObject(), location.toInt());
}

/**
- * Perform the actual write of the write barrier, writing the value as a raw word.
+ * 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);
+ }
+
+ /**
+ * Atomically write a reference field of an object or array and return
+ * the old value of the reference field.
*
* @param ref The object that has the reference field
- * @param slot The slot that holds the reference
- * @param rawTarget The value that the slot will be updated to
- * @param metaDataA The offset from the ref
- * @param metaDataB The index of the FieldReference
- * @param mode The context in which the write is occuring
+ * @param target The value that the slot will be updated to
+ * @param offset The offset from the ref
+ * @param unused Unused
+ * @param mode The context in which the write is occurring
+ * @return The value that was replaced by the write.
*/
@Inline
- public final void performRawWriteInBarrier(ObjectReference ref, Address slot,
- Word rawTarget, Word metaDataA,
- Word metaDataB, int mode) {
+ public final ObjectReference referenceAtomicWrite(ObjectReference ref, ObjectReference target,
+ Word offset, Word unused, int mode) {
Object obj = ref.toObject();
- Offset offset = metaDataA.toOffset();
- int location = metaDataB.toInt();
- Magic.setWordAtOffset(obj, offset, rawTarget, location);
+ Object newObject = target.toObject();
+ Object oldObject;
+ do {
+ oldObject = Magic.prepareObject(obj, offset.toOffset());
+ } while (!Magic.attemptObject(obj, offset.toOffset(), oldObject, newObject));
+ return ObjectReference.fromObject(oldObject);
}

/**
- * Perform the actual read of the read barrier.
+ * Attempt an atomic compare and exchange in a write barrier sequence.
*
* @param ref The object that has the reference field
- * @param slot The slot that holds the reference
- * @param metaDataA The offset from the ref
- * @param metaDataB The index of the FieldReference
- * @param mode The context in which the write is occuring
- * @return the read value
+ * @param old The old reference to be swapped out
+ * @param target The value that the slot will be updated to
+ * @param offset The offset from the ref
+ * @param unused Unused
+ * @param mode The context in which the write is occurring
+ * @return True if the compare and swap was successful
*/
@Inline
- public final ObjectReference performReadInBarrier(ObjectReference ref, Address slot,
- Word metaDataA, Word metaDataB, int mode) {
- Object obj = ref.toObject();
- Offset offset = metaDataA.toOffset();
- int location = metaDataB.toInt();
- return ObjectReference.fromObject(Magic.getObjectAtOffset(obj, offset, location));
+ public final boolean referenceTryCompareAndSwap(ObjectReference ref, ObjectReference old, ObjectReference target,
+ Word offset, Word unused, int mode) {
+ Object oldValue;
+ do {
+ oldValue = Magic.prepareObject(ref, offset.toOffset());
+ if (oldValue != old) return false;
+ } while (!Magic.attemptObject(ref, offset.toOffset(), oldValue, target));
+ return true;
}

/**
- * Perform the actual read of the read barrier, returning the value as a raw word.
+ * Perform the actual read of the read barrier.
*
* @param ref The object that has the reference field
- * @param slot The slot that holds the reference
- * @param metaDataA The offset from the ref
- * @param metaDataB The index of the FieldReference
- * @param mode The context in which the write is occuring
+ * @param offset The offset from the ref
+ * @param location The index of the FieldReference
+ * @param mode The context in which the write is occurring
* @return the read value
*/
@Inline
- public final Word performRawReadInBarrier(ObjectReference ref, Address slot,
- Word metaDataA, Word metaDataB, int mode) {
- Object obj = ref.toObject();
- Offset offset = metaDataA.toOffset();
- int location = metaDataB.toInt();
- return Magic.getWordAtOffset(obj, offset, location);
+ public final ObjectReference referenceRead(ObjectReference ref,
+ Word offset, Word location, int mode) {
+ return ObjectReference.fromObject(Magic.getObjectAtOffset(ref.toObject(), offset.toOffset(), location.toInt()));
}

/**
- * Atomically write a reference field of an object or array and return
- * the old value of the reference field.
+ * Perform the actual write of the write barrier, writing the value as a raw word.
*
* @param ref The object that has the reference field
- * @param slot The slot that holds the reference
* @param target The value that the slot will be updated to
- * @param metaDataA The offset from the ref
- * @param metaDataB Unused
- * @param mode The context in which the write is occuring
- * @return The value that was replaced by the write.
+ * @param offset The offset from the ref
+ * @param location The index of the FieldReference
+ * @param mode The context in which the write is occurring
*/
@Inline
- public final ObjectReference performWriteInBarrierAtomic(
- ObjectReference ref, Address slot,
- ObjectReference target, Word metaDataA,
- Word metaDataB, int mode) {
- Object obj = ref.toObject();
- Object newObject = target.toObject();
- Offset offset = metaDataA.toOffset();
- Object oldObject;
- do {
- oldObject = Magic.prepareObject(obj, offset);
- } while (!Magic.attemptObject(obj, offset, oldObject, newObject));
- return ObjectReference.fromObject(oldObject);
+ public final void wordWrite(ObjectReference ref, Word target,
+ Word offset, Word location, int mode) {
+ Magic.setWordAtOffset(ref.toObject(), offset.toOffset(), target, location.toInt());
}

-
/**
* Atomically write a raw reference field of an object or array and return
* the old value of the reference field.
*
* @param ref The object that has the reference field
- * @param slot The slot that holds the reference
- * @param rawTarget The value that the slot will be updated to
- * @param metaDataA The offset from the ref
- * @param metaDataB Unused
- * @param mode The context in which the write is occuring
+ * @param target The value that the slot will be updated to
+ * @param offset The offset from the ref
+ * @param unused Unused
+ * @param mode The context in which the write is occurring
* @return The value that was replaced by the write.
*/
@Inline
- public final Word performRawWriteInBarrierAtomic(
- ObjectReference ref, Address slot,
- Word rawTarget, Word metaDataA,
- Word metaDataB, int mode) {
- Object obj = ref.toObject();
- Offset offset = metaDataA.toOffset();
+ public final Word wordAtomicWrite(ObjectReference ref, Word target,
+ Word offset, Word unused, int mode) {
Word oldValue;
do {
- oldValue = Magic.prepareWord(obj, offset);
- } while (!Magic.attemptWord(obj, offset, oldValue, rawTarget));
+ oldValue = Magic.prepareWord(ref.toObject(), offset.toOffset());
+ } while (!Magic.attemptWord(ref.toObject(), offset.toOffset(), oldValue, target));
return oldValue;
}

@@ -157,50 +151,36 @@
* Attempt an atomic compare and exchange in a write barrier sequence.
*
* @param ref The object that has the reference field
- * @param slot The slot that holds the reference
* @param old The old reference to be swapped out
* @param target The value that the slot will be updated to
- * @param metaDataA The offset from the ref
- * @param metaDataB Unused
- * @param mode The context in which the write is occuring
+ * @param offset The offset from the ref
+ * @param unused Unused
+ * @param mode The context in which the write is occurring
* @return True if the compare and swap was successful
*/
@Inline
- public final boolean tryCompareAndSwapWriteInBarrier(ObjectReference ref, Address slot,
- ObjectReference old, ObjectReference target,
- Word metaDataA, Word metaDataB, int mode) {
- Object oldValue;
- Offset offset = metaDataA.toOffset();
+ public final boolean wordTryCompareAndSwap(ObjectReference ref, Word old, Word target,
+ Word offset, Word unused, int mode) {
do {
- oldValue = Magic.prepareObject(ref, offset);
- if (oldValue != old) return false;
- } while (!Magic.attemptObject(ref, offset, oldValue, target));
+ Word currentValue = Magic.prepareWord(ref, offset.toOffset());
+ if (currentValue != old) return false;
+ } while (!Magic.attemptObject(ref, offset.toOffset(), old, target));
return true;
}

-
/**
- * Attempt an atomic compare and exchange in a write barrier sequence.
+ * Perform the actual read of the read barrier, returning the value as a raw word.
*
* @param ref The object that has the reference field
- * @param slot The slot that holds the reference
- * @param rawOld The old reference to be swapped out
- * @param rawTarget The value that the slot will be updated to
- * @param metaDataA The offset from the ref
- * @param metaDataB Unused
- * @param mode The context in which the write is occuring
- * @return True if the compare and swap was successful
+ * @param offset The offset from the ref
+ * @param location The index of the FieldReference
+ * @param mode The context in which the write is occurring
+ * @return the read value
*/
@Inline
- public final boolean tryRawCompareAndSwapWriteInBarrier(ObjectReference ref, Address slot,
- Word rawOld, Word rawTarget, Word metaDataA,
- Word metaDataB, int mode) {
- Offset offset = metaDataA.toOffset();
- do {
- Word currentValue = Magic.prepareWord(ref, offset);
- if (currentValue != rawOld) return false;
- } while (!Magic.attemptObject(ref, offset, rawOld, rawTarget));
- return true;
+ public final Word wordRead(ObjectReference ref,
+ Word offset, Word location, int mode) {
+ return Magic.getWordAtOffset(ref.toObject(), offset.toOffset(), location.toInt());
}

/**
@@ -214,7 +194,7 @@
* @param value the new value for the element
*/
@UninterruptibleNoWarn
- public final void setArrayNoBarrier(Object [] dst, int index, Object value) {
+ 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));

Modified: rvmroot/trunk/MMTk/harness/src/org/mmtk/harness/Mutator.java
===================================================================
--- rvmroot/trunk/MMTk/harness/src/org/mmtk/harness/Mutator.java 2009-08-28 01:47:25 UTC (rev 15771)
+++ rvmroot/trunk/MMTk/harness/src/org/mmtk/harness/Mutator.java 2009-08-28 21:08:26 UTC (rev 15772)
@@ -303,7 +303,7 @@

Address referenceSlot = ObjectModel.getRefSlot(object, index);
if (ActivePlan.constraints.needsWriteBarrier()) {
- context.writeBarrier(object, referenceSlot, value, null, null, Plan.AASTORE_WRITE_BARRIER);
+ context.referenceWrite(object, referenceSlot, value, referenceSlot.toWord(), null, Plan.ARRAY_ELEMENT);
if (gcEveryWB) {
gc();
}
@@ -347,7 +347,7 @@
Address referenceSlot = ObjectModel.getRefSlot(object, index);
ObjectReference result;
if (ActivePlan.constraints.needsReadBarrier()) {
- result = context.readBarrier(object, referenceSlot, null, null, Plan.GETFIELD_READ_BARRIER);
+ result = context.referenceRead(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-08-28 01:47:25 UTC (rev 15771)
+++ rvmroot/trunk/MMTk/src/org/mmtk/plan/MutatorContext.java 2009-08-28 21:08:26 UTC (rev 15772)
@@ -280,7 +280,7 @@
* @param metaDataB A value that assists the host VM in creating a store
* @param mode The context in which the store occurred
*/
- public void writeBarrier(ObjectReference src, Address slot,
+ 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
@@ -289,6 +289,25 @@
}

/**
+ * A new reference is about to be created in a location that is not
+ * a regular heap object. Take appropriate write barrier actions.
+ *
+ * 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
+ */
+ public void referenceNonHeapWrite(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);
+ }
+
+ /**
* 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.
@@ -305,7 +324,7 @@
* @param mode The context in which the store occurred
* @return True if the swap was successful.
*/
- public boolean tryCompareAndSwapWriteBarrier(ObjectReference src, Address slot,
+ 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
@@ -332,7 +351,7 @@
* @return True if the update was performed by the barrier, false if
* left to the caller (always false in this case).
*/
- public boolean writeBarrier(ObjectReference src, Offset srcOffset,
+ public boolean referenceBulkCopy(ObjectReference src, Offset srcOffset,
ObjectReference dst, Offset dstOffset,
int bytes) {
// Either: write barriers are used and this is overridden, or
@@ -349,7 +368,7 @@
* @return The new referent.
*/
@Inline
- public ObjectReference referenceTypeReadBarrier(ObjectReference referent) {
+ 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);
@@ -369,7 +388,7 @@
* @return The reference that was read.
*/
@Inline
- public ObjectReference readBarrier(ObjectReference src, Address slot, Word metaDataA, Word metaDataB, int mode) {
+ public ObjectReference referenceRead(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);
@@ -377,6 +396,23 @@
}

/**
+ * 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.
+ *
+ * @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.
+ */
+ @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
+ if (VM.VERIFY_ASSERTIONS) VM.assertions._assert(false);
+ return ObjectReference.nullReference();
+ }
+ /**
* 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-08-28 01:47:25 UTC (rev 15771)
+++ rvmroot/trunk/MMTk/src/org/mmtk/plan/PlanConstraints.java 2009-08-28 21:08:26 UTC (rev 15772)
@@ -26,7 +26,7 @@
public boolean needsWriteBarrier() { return false; }

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

/** @return True of this Plan requires read barriers. */
public boolean needsReadBarrier() { return false; }

Modified: rvmroot/trunk/MMTk/src/org/mmtk/plan/generational/Gen.java
===================================================================
--- rvmroot/trunk/MMTk/src/org/mmtk/plan/generational/Gen.java 2009-08-28 01:47:25 UTC (rev 15771)
+++ rvmroot/trunk/MMTk/src/org/mmtk/plan/generational/Gen.java 2009-08-28 21:08:26 UTC (rev 15772)
@@ -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_STATIC_WRITE_BARRIER = true;
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/GenMutator.java
===================================================================
--- rvmroot/trunk/MMTk/src/org/mmtk/plan/generational/GenMutator.java 2009-08-28 01:47:25 UTC (rev 15771)
+++ rvmroot/trunk/MMTk/src/org/mmtk/plan/generational/GenMutator.java 2009-08-28 21:08:26 UTC (rev 15772)
@@ -143,8 +143,8 @@
@Inline
private void fastPath(ObjectReference src, Address slot, ObjectReference tgt, int mode) {
if (Gen.GATHER_WRITE_BARRIER_STATS) Gen.wbFast.inc();
- if ((mode == AASTORE_WRITE_BARRIER && USE_OBJECT_BARRIER_FOR_AASTORE) ||
- (mode == PUTFIELD_WRITE_BARRIER && USE_OBJECT_BARRIER_FOR_PUTFIELD)) {
+ if ((mode == ARRAY_ELEMENT && USE_OBJECT_BARRIER_FOR_AASTORE) ||
+ (mode == INSTANCE_FIELD && USE_OBJECT_BARRIER_FOR_PUTFIELD)) {
if (HeaderByte.isUnlogged(src)) {
if (Gen.GATHER_WRITE_BARRIER_STATS) Gen.wbSlow.inc();
HeaderByte.markAsLogged(src);
@@ -175,14 +175,54 @@
* @param mode The mode of the store (eg putfield, putstatic etc)
*/
@Inline
- public final void writeBarrier(ObjectReference src, Address slot,
+ public final void referenceWrite(ObjectReference src, Address slot,
ObjectReference tgt, Word metaDataA,
Word metaDataB, int mode) {
fastPath(src, slot, tgt, mode);
- VM.barriers.performWriteInBarrier(src, slot, tgt, metaDataA, metaDataB, mode);
+ VM.barriers.referenceWrite(src, tgt, metaDataA, metaDataB, mode);
}

+
/**
+ * Perform the root write barrier fast path, which may involve remembering
+ * a reference if necessary.
+ *
+ * @param slot The address into which the new reference will be
+ * stored.
+ * @param tgt The target of the new reference
+ * @param mode The mode of the store (eg putfield, putstatic etc)
+ */
+ @Inline
+ private void fastPath(Address slot, ObjectReference tgt) {
+ if (Gen.GATHER_WRITE_BARRIER_STATS) Gen.wbFast.inc();
+ if (Gen.inNursery(tgt)) {
+ if (Gen.GATHER_WRITE_BARRIER_STATS) Gen.wbSlow.inc();
+ remset.insert(slot);
+ }
+ }
+
+ /**
+ * A new reference is about to be created in a location that is not
+ * a regular heap object. Take appropriate write barrier actions.
+ *
+ * In this case, we remember the address of the source of the
+ * pointer if the new reference points into the nursery from
+ * non-nursery space.
+ *
+ * @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 final void referenceNonHeapWrite(Address slot, ObjectReference tgt,
+ Word metaDataA, Word metaDataB) {
+ fastPath(slot, tgt);
+ VM.barriers.referenceWrite(slot, tgt, metaDataA, metaDataB);
+ }
+
+ /**
* 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.
@@ -202,10 +242,9 @@
* @return True if the swap was successful.
*/
@Inline
- public boolean tryCompareAndSwapWriteBarrier(ObjectReference src, Address slot,
- ObjectReference old, ObjectReference tgt, Word metaDataA,
- Word metaDataB, int mode) {
- boolean result = VM.barriers.tryCompareAndSwapWriteInBarrier(src, slot, old, tgt, metaDataA, metaDataB, mode);
+ public boolean referenceTryCompareAndSwap(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);
if (result)
fastPath(src, slot, tgt, mode);
return result;
@@ -233,7 +272,7 @@
* left to the caller (always false in this case).
*/
@Inline
- public final boolean writeBarrier(ObjectReference src, Offset srcOffset,
+ public final boolean referenceBulkCopy(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/PoisonedMutator.java
===================================================================
--- rvmroot/trunk/MMTk/src/org/mmtk/plan/poisoned/PoisonedMutator.java 2009-08-28 01:47:25 UTC (rev 15771)
+++ rvmroot/trunk/MMTk/src/org/mmtk/plan/poisoned/PoisonedMutator.java 2009-08-28 21:08:26 UTC (rev 15772)
@@ -50,8 +50,8 @@
*/
@Inline
@Override
- public void writeBarrier(ObjectReference src, Address slot, ObjectReference tgt, Word metaDataA, Word metaDataB, int mode) {
- VM.barriers.performRawWriteInBarrier(src, slot, Poisoned.poison(tgt), metaDataA, metaDataB, mode);
+ public void referenceWrite(ObjectReference src, Address slot, ObjectReference tgt, Word metaDataA, Word metaDataB, int mode) {
+ VM.barriers.wordWrite(src, Poisoned.poison(tgt), metaDataA, metaDataB, mode);
}

/**
@@ -72,9 +72,9 @@
* @return True if the swap was successful.
*/
@Override
- public boolean tryCompareAndSwapWriteBarrier(ObjectReference src, Address slot, ObjectReference old, ObjectReference tgt,
+ public boolean referenceTryCompareAndSwap(ObjectReference src, Address slot, ObjectReference old, ObjectReference tgt,
Word metaDataA, Word metaDataB, int mode) {
- return VM.barriers.tryRawCompareAndSwapWriteInBarrier(src, slot, Poisoned.poison(old), Poisoned.poison(tgt), metaDataA, metaDataB, 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 writeBarrier(ObjectReference src, Offset srcOffset, ObjectReference dst, Offset dstOffset, int bytes) {
+ public boolean referenceBulkCopy(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 readBarrier(ObjectReference src, Address slot, Word metaDataA, Word metaDataB, int mode) {
- return Poisoned.depoison(VM.barriers.performRawReadInBarrier(src, slot, metaDataA, metaDataB, mode));
+ public ObjectReference referenceRead(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/RCBaseMutator.java
===================================================================
--- rvmroot/trunk/MMTk/src/org/mmtk/plan/refcount/RCBaseMutator.java 2009-08-28 01:47:25 UTC (rev 15771)
+++ rvmroot/trunk/MMTk/src/org/mmtk/plan/refcount/RCBaseMutator.java 2009-08-28 21:08:26 UTC (rev 15772)
@@ -238,13 +238,13 @@
* @param mode The context in which the store occurred
*/
@Inline
- public void writeBarrier(ObjectReference src, Address slot,
+ public void referenceWrite(ObjectReference src, Address slot,
ObjectReference tgt, Word metaDataA,
Word metaDataB, int mode) {
if (RCHeader.logRequired(src)) {
coalescingWriteBarrierSlow(src);
}
- VM.barriers.performWriteInBarrier(src,slot,tgt, metaDataA, metaDataB, mode);
+ VM.barriers.referenceWrite(src,tgt,metaDataA, metaDataB, mode);
}

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

/**
@@ -293,7 +293,7 @@
* left to the caller (always false in this case).
*/
@Inline
- public boolean writeBarrier(ObjectReference src, Offset srcOffset,
+ public boolean referenceBulkCopy(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/GCTraceMutator.java
===================================================================
--- rvmroot/trunk/MMTk/src/org/mmtk/plan/semispace/gctrace/GCTraceMutator.java 2009-08-28 01:47:25 UTC (rev 15771)
+++ rvmroot/trunk/MMTk/src/org/mmtk/plan/semispace/gctrace/GCTraceMutator.java 2009-08-28 21:08:26 UTC (rev 15772)
@@ -89,12 +89,12 @@
* @param mode The mode of the store (eg putfield, putstatic etc)
*/
@Inline
- public final void writeBarrier(ObjectReference src, Address slot,
+ public final void referenceWrite(ObjectReference src, Address slot,
ObjectReference tgt, Word metaDataA,
Word metaDataB, int mode) {
- TraceGenerator.processPointerUpdate(mode == PUTFIELD_WRITE_BARRIER,
+ TraceGenerator.processPointerUpdate(mode == INSTANCE_FIELD,
src, slot, tgt);
- VM.barriers.performWriteInBarrier(src, slot, tgt, metaDataA, metaDataB, mode);
+ VM.barriers.referenceWrite(src, tgt, metaDataA, metaDataB, mode);
}

/**
@@ -115,12 +115,12 @@
* @return True if the swap was successful.
*/
@Inline
- public boolean tryCompareAndSwapWriteBarrier(ObjectReference src, Address slot,
+ public boolean referenceTryCompareAndSwap(ObjectReference src, Address slot,
ObjectReference old, ObjectReference tgt, Word metaDataA,
Word metaDataB, int mode) {
- boolean result = VM.barriers.tryCompareAndSwapWriteInBarrier(src, slot, old, tgt, metaDataA, metaDataB, mode);
+ boolean result = VM.barriers.referenceTryCompareAndSwap(src, old, tgt, metaDataA, metaDataB, mode);
if (result) {
- TraceGenerator.processPointerUpdate(mode == PUTFIELD_WRITE_BARRIER, src, slot, tgt);
+ TraceGenerator.processPointerUpdate(mode == INSTANCE_FIELD, src, slot, tgt);
}
return result;
}
@@ -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 writeBarrier(ObjectReference src, Offset srcOffset,
+ public boolean referenceBulkCopy(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/StickyImmixMutator.java
===================================================================
--- rvmroot/trunk/MMTk/src/org/mmtk/plan/stickyimmix/StickyImmixMutator.java 2009-08-28 01:47:25 UTC (rev 15771)
+++ rvmroot/trunk/MMTk/src/org/mmtk/plan/stickyimmix/StickyImmixMutator.java 2009-08-28 21:08:26 UTC (rev 15772)
@@ -80,11 +80,11 @@
* @param mode The mode of the store (eg putfield, putstatic etc)
*/
@Inline
- public final void writeBarrier(ObjectReference src, Address slot,
+ public final void referenceWrite(ObjectReference src, Address slot,
ObjectReference tgt, Word metaDataA, Word metaDataB, int mode) {
if (HeaderByte.isUnlogged(src))
logSource(src);
- VM.barriers.performWriteInBarrier(src, slot, tgt, metaDataA, metaDataB, mode);
+ VM.barriers.referenceWrite(src, tgt, metaDataA, metaDataB, mode);
}

/**
@@ -109,7 +109,7 @@
* left to the caller (always false in this case).
*/
@Inline
- public final boolean writeBarrier(ObjectReference src, Offset srcOffset,
+ public final boolean referenceBulkCopy(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/StickyMSMutator.java
===================================================================
--- rvmroot/trunk/MMTk/src/org/mmtk/plan/stickyms/StickyMSMutator.java 2009-08-28 01:47:25 UTC (rev 15771)
+++ rvmroot/trunk/MMTk/src/org/mmtk/plan/stickyms/StickyMSMutator.java 2009-08-28 21:08:26 UTC (rev 15772)
@@ -81,11 +81,11 @@
* @param mode The mode of the store (eg putfield, putstatic etc)
*/
@Inline
- public final void writeBarrier(ObjectReference src, Address slot,
+ public final void referenceWrite(ObjectReference src, Address slot,
ObjectReference tgt, Word metaDataA, Word metaDataB, int mode) {
if (HeaderByte.isUnlogged(src))
logSource(src);
- VM.barriers.performWriteInBarrier(src, slot, tgt, metaDataA, metaDataB, mode);
+ VM.barriers.referenceWrite(src, tgt, metaDataA, metaDataB, mode);
}

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

Modified: rvmroot/trunk/MMTk/src/org/mmtk/utility/Constants.java
===================================================================
--- rvmroot/trunk/MMTk/src/org/mmtk/utility/Constants.java 2009-08-28 01:47:25 UTC (rev 15771)
+++ rvmroot/trunk/MMTk/src/org/mmtk/utility/Constants.java 2009-08-28 21:08:26 UTC (rev 15772)
@@ -32,12 +32,8 @@
*
* MMTk constants
*/
- int PUTFIELD_WRITE_BARRIER = 0;
- int GETFIELD_READ_BARRIER = 0;
- int PUTSTATIC_WRITE_BARRIER = 1;
- int GETSTATIC_READ_BARRIER = 1;
- int AASTORE_WRITE_BARRIER = 2;
- int AALOAD_READ_BARRIER = 2;
+ int INSTANCE_FIELD = 0;
+ int ARRAY_ELEMENT = 1;

/****************************************************************************

Modified: rvmroot/trunk/MMTk/src/org/mmtk/utility/heap/Map.java
===================================================================
--- rvmroot/trunk/MMTk/src/org/mmtk/utility/heap/Map.java 2009-08-28 01:47:25 UTC (rev 15771)
+++ rvmroot/trunk/MMTk/src/org/mmtk/utility/heap/Map.java 2009-08-28 21:08:26 UTC (rev 15772)
@@ -97,7 +97,7 @@
VM.assertions.fail("exiting");
}
descriptorMap[index] = descriptor;
- VM.barriers.setArrayNoBarrier(spaceMap, index, space);
+ VM.barriers.referenceArrayStoreNoGCBarrier(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.setArrayNoBarrier(spaceMap, chunk + offset, null);
+ VM.barriers.referenceArrayStoreNoGCBarrier(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-08-28 01:47:25 UTC (rev 15771)
+++ rvmroot/trunk/MMTk/src/org/mmtk/vm/Barriers.java 2009-08-28 21:08:26 UTC (rev 15772)
@@ -18,132 +18,133 @@
@Uninterruptible
public abstract class Barriers {
/**
- * 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.
+ * Perform the actual write of the write barrier.
*
- * @param dst the destination array
- * @param index the index of the element to set
- * @param value the new value for the element
+ * @param ref The object that has the reference field
+ * @param target The value that the slot will be updated to
+ * @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
*/
- public abstract void setArrayNoBarrier(Object [] dst, int index, Object value);
+ public abstract void referenceWrite(ObjectReference ref, ObjectReference target,
+ Word metaDataA, Word metaDataB, int mode);

/**
- * Perform the actual write of the write barrier.
+ * 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 ref The object that has the reference field
- * @param slot The slot that holds the reference
+ * @param slot The address that contains the reference field
* @param target The value that the slot will be updated to
- * @param metaDataA VM specific meta data
- * @param metaDataB VM specific meta data
- * @param mode The context in which the write is occuring
+ * @param metaDataA Opaque, VM-specific, meta-data identifying the slot
+ * @param metaDataB Opaque, VM-specific, meta-data identifying the slot
*/
- public abstract void performWriteInBarrier(ObjectReference ref, Address slot,
- ObjectReference target, Word metaDataA,
- Word metaDataB, int mode);
+ public abstract void referenceWrite(Address slot, ObjectReference target,
+ Word metaDataA, Word metaDataB);

/**
- * Perform the actual write of the write barrier, writing the value as a raw Word.
+ * Atomically write a reference field of an object or array and return
+ * the old value of the reference field.
*
* @param ref The object that has the reference field
- * @param slot The slot that holds the reference
- * @param rawTarget The value that the slot will be updated to
- * @param metaDataA VM specific meta data
- * @param metaDataB VM specific meta data
- * @param mode The context in which the write is occuring
+ * @param target The value that the slot will be updated to
+ * @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 value that was replaced by the write.
*/
- public abstract void performRawWriteInBarrier(ObjectReference ref, Address slot,
- Word rawTarget, Word metaDataA,
- Word metaDataB, int mode);
+ public abstract ObjectReference referenceAtomicWrite(ObjectReference ref, ObjectReference target,
+ Word metaDataA, Word metaDataB, int mode);

/**
- * Perform the actual read of the read barrier.
+ * Attempt an atomic compare and exchange in a write barrier sequence.
*
* @param ref The object that has the reference field
- * @param slot The slot that holds the reference
- * @param metaDataA VM specific meta data
- * @param metaDataB VM specific meta data
- * @param mode The context in which the write is occuring
- * @return the read value
+ * @param old The old reference to be swapped out
+ * @param target The value that the slot will be updated to
+ * @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 True if the compare and swap was successful
*/
- public abstract ObjectReference performReadInBarrier(ObjectReference ref, Address slot,
- Word metaDataA, Word metaDataB, int mode);
+ public abstract boolean referenceTryCompareAndSwap(ObjectReference ref, ObjectReference old, ObjectReference target,
+ Word metaDataA, Word metaDataB, int mode);

/**
- * Perform the actual read of the read barrier, returning the value as a raw Word.
+ * Perform the actual read of the read barrier.
*
* @param ref The object that has the reference field
- * @param slot The slot that holds the reference
- * @param metaDataA VM specific meta data
- * @param metaDataB VM specific meta data
- * @param mode The context in which the write is occuring
+ * @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 Word performRawReadInBarrier(ObjectReference ref, Address slot,
- Word metaDataA, Word metaDataB, int mode);
+ public abstract ObjectReference referenceRead(ObjectReference ref,
+ Word metaDataA, Word metaDataB, int mode);

+
/**
- * Atomically write a reference field of an object or array and return
- * the old value of the reference field.
+ * Perform the actual write of the write barrier, writing the value as a raw Word.
*
* @param ref The object that has the reference field
- * @param slot The slot that holds the reference
* @param target The value that the slot will be updated to
- * @param metaDataA VM specific meta data
- * @param metaDataB VM specific meta data
- * @param mode The context in which the write is occuring
- * @return The value that was replaced by the write.
+ * @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
*/
- public abstract ObjectReference performWriteInBarrierAtomic(ObjectReference ref, Address slot,
- ObjectReference 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
* the old value of the reference field.
*
* @param ref The object that has the reference field
- * @param slot The slot that holds the reference
- * @param rawTarget The raw value that the slot will be updated to
- * @param metaDataA VM specific meta data
- * @param metaDataB VM specific meta data
- * @param mode The context in which the write is occuring
+ * @param target The value that the slot will be updated to
+ * @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 raw value that was replaced by the write.
*/
- public abstract Word performRawWriteInBarrierAtomic(ObjectReference ref, Address slot,
- 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.
*
* @param ref The object that has the reference field
- * @param slot The slot that holds the reference
* @param old The old reference to be swapped out
* @param target The value that the slot will be updated to
- * @param metaDataA VM specific meta data
- * @param metaDataB VM specific meta data
- * @param mode The context in which the write is occuring
+ * @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 True if the compare and swap was successful
*/
- public abstract boolean tryCompareAndSwapWriteInBarrier(ObjectReference ref, Address slot,
- ObjectReference old, ObjectReference target,
- Word metaDataA, Word metaDataB, int mode);
+ public abstract boolean wordTryCompareAndSwap(ObjectReference ref, Word old, Word target,
+ Word metaDataA, Word metaDataB, int mode);

/**
- * Attempt an atomic compare and exchange in a write barrier sequence.
+ * Perform the actual read of the read barrier, returning the value as a raw Word.
*
* @param ref The object that has the reference field
- * @param slot The slot that holds the reference
- * @param rawOld The old reference to be swapped out
- * @param rawTarget The value that the slot will be updated to
- * @param metaDataA VM specific meta data
- * @param metaDataB VM specific meta data
- * @param mode The context in which the write is occuring
- * @return True if the compare and swap was successful
+ * @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 boolean tryRawCompareAndSwapWriteInBarrier(ObjectReference ref, Address slot,
- Word rawOld, Word rawTarget,
- 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
+ * 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
+ */
+ public abstract void referenceArrayStoreNoGCBarrier(Object [] dst, int index, Object value);
+
}

Modified: rvmroot/trunk/libraryInterface/Common/src/java/lang/ref/Reference.java
===================================================================
--- rvmroot/trunk/libraryInterface/Common/src/java/lang/ref/Reference.java 2009-08-28 01:47:25 UTC (rev 15771)
+++ rvmroot/trunk/libraryInterface/Common/src/java/lang/ref/Reference.java 2009-08-28 21:08:26 UTC (rev 15772)
@@ -12,8 +12,7 @@
*/
package java.lang.ref;

-import org.jikesrvm.mm.mminterface.MemoryManagerConstants;
-import org.jikesrvm.mm.mminterface.MemoryManager;
+import org.jikesrvm.mm.mminterface.Barriers;
import org.jikesrvm.runtime.Magic;
import org.vmmagic.pragma.Inline;
import org.vmmagic.pragma.Uninterruptible;
@@ -86,8 +85,8 @@
} else {
Object ref = Magic.addressAsObject(tmp);

- if (MemoryManagerConstants.NEEDS_REFTYPE_READ_BARRIER) {
- ref = MemoryManager.referenceTypeReadBarrier(ref);
+ if (Barriers.NEEDS_JAVA_LANG_REFERENCE_READ_BARRIER) {
+ ref = Barriers.javaLangReferenceReadBarrier(ref);
}
return ref;
}

Modified: rvmroot/trunk/rvm/src/org/jikesrvm/Services.java
===================================================================
--- rvmroot/trunk/rvm/src/org/jikesrvm/Services.java 2009-08-28 01:47:25 UTC (rev 15771)
+++ rvmroot/trunk/rvm/src/org/jikesrvm/Services.java 2009-08-28 21:08:26 UTC (rev 15772)
@@ -12,8 +12,7 @@
*/
package org.jikesrvm;

-import org.jikesrvm.mm.mminterface.MemoryManagerConstants;
-import org.jikesrvm.mm.mminterface.MemoryManager;
+import org.jikesrvm.mm.mminterface.Barriers;
import org.jikesrvm.runtime.Entrypoints;
import org.jikesrvm.runtime.Magic;
import org.jikesrvm.scheduler.Synchronization;
@@ -338,8 +337,8 @@
@Inline
public static void setArrayUninterruptible(Object[] dst, int index, Object value) {
if (VM.runningVM) {
- if (MemoryManagerConstants.NEEDS_WRITE_BARRIER) {
- MemoryManager.arrayStoreWriteBarrier(dst, index, value);
+ if (Barriers.NEEDS_REFERENCE_ASTORE_BARRIER) {
+ Barriers.referenceArrayWrite(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-08-28 01:47:25 UTC (rev 15771)
+++ rvmroot/trunk/rvm/src/org/jikesrvm/classloader/RVMArray.java 2009-08-28 21:08:26 UTC (rev 15772)
@@ -12,10 +12,11 @@
*/
package org.jikesrvm.classloader;

+import static org.jikesrvm.mm.mminterface.Barriers.*;
import org.jikesrvm.ArchitectureSpecific;
import org.jikesrvm.VM;
import org.jikesrvm.Constants;
-import org.jikesrvm.mm.mminterface.MemoryManagerConstants;
+import org.jikesrvm.mm.mminterface.Barriers;
import org.jikesrvm.mm.mminterface.MemoryManager;
import org.jikesrvm.objectmodel.ObjectModel;
import org.jikesrvm.objectmodel.TIB;
@@ -1024,9 +1025,9 @@
Offset dstOffset = Offset.fromIntZeroExtend(dstIdx << LOG_BYTES_IN_ADDRESS);
int bytes = len << LOG_BYTES_IN_ADDRESS;

- if (!MemoryManagerConstants.NEEDS_READ_BARRIER && ((src != dst) || loToHi)) {
- if (!MemoryManagerConstants.NEEDS_WRITE_BARRIER ||
- !MemoryManager.arrayCopyWriteBarrier(src, srcOffset, dst, dstOffset, bytes)) {
+ if (!NEEDS_REFERENCE_ALOAD_BARRIER && ((src != dst) || loToHi)) {
+ if (!NEEDS_REFERENCE_ASTORE_BARRIER ||
+ !Barriers.referenceBulkCopy(src, srcOffset, dst, dstOffset, bytes)) {
Memory.alignedWordCopy(Magic.objectAsAddress(dst).plus(dstOffset),
Magic.objectAsAddress(src).plus(srcOffset),
bytes);
@@ -1045,13 +1046,13 @@
// perform the copy
while (len-- != 0) {
Object value;
- if (MemoryManagerConstants.NEEDS_READ_BARRIER) {
- value = MemoryManager.arrayLoadReadBarrier(src, srcOffset.toInt() >> LOG_BYTES_IN_ADDRESS);
+ if (NEEDS_REFERENCE_GETFIELD_BARRIER) {
+ value = Barriers.referenceArrayRead(src, srcOffset.toInt() >> LOG_BYTES_IN_ADDRESS);
} else {
value = Magic.getObjectAtOffset(src, srcOffset);
}
- if (MemoryManagerConstants.NEEDS_WRITE_BARRIER) {
- MemoryManager.arrayStoreWriteBarrier(dst, dstOffset.toInt() >> LOG_BYTES_IN_ADDRESS, value);
+ if (NEEDS_REFERENCE_PUTFIELD_BARRIER) {
+ Barriers.referenceArrayWrite(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-08-28 01:47:25 UTC (rev 15771)
+++ rvmroot/trunk/rvm/src/org/jikesrvm/classloader/RVMField.java 2009-08-28 21:08:26 UTC (rev 15772)
@@ -15,12 +15,12 @@
import java.io.DataInputStream;
import java.io.IOException;
import org.jikesrvm.VM;
-import org.jikesrvm.mm.mminterface.MemoryManagerConstants;
-import org.jikesrvm.mm.mminterface.MemoryManager;
+import org.jikesrvm.mm.mminterface.Barriers;
import org.jikesrvm.runtime.Magic;
import org.jikesrvm.runtime.Statics;
import org.vmmagic.pragma.Uninterruptible;
import org.vmmagic.unboxed.Word;
+import static org.jikesrvm.mm.mminterface.Barriers.*;

/**
* A field of a java class.
@@ -295,14 +295,14 @@
*/
public Object getObjectValueUnchecked(Object obj) {
if (isStatic()) {
- if (MemoryManagerConstants.NEEDS_GETSTATIC_READ_BARRIER && !isUntraced()) {
- return MemoryManager.getstaticReadBarrier(getOffset(), getId());
+ if (NEEDS_REFERENCE_GETSTATIC_BARRIER && !isUntraced()) {
+ return Barriers.referenceNonHeapRead(getOffset(), getId());
} else {
return Statics.getSlotContentsAsObject(getOffset());
}
} else {
- if (MemoryManagerConstants.NEEDS_READ_BARRIER && !isUntraced()) {
- return MemoryManager.getfieldReadBarrier(obj, getOffset(), getId());
+ if (NEEDS_REFERENCE_GETFIELD_BARRIER && !isUntraced()) {
+ return Barriers.referenceFieldRead(obj, getOffset(), getId());
} else {
return Magic.getObjectAtOffset(obj, getOffset());
}
@@ -390,14 +390,14 @@
*/
public void setObjectValueUnchecked(Object obj, Object ref) {
if (isStatic()) {
- if (MemoryManagerConstants.NEEDS_PUTSTATIC_WRITE_BARRIER && !isUntraced()) {
- MemoryManager.putstaticWriteBarrier(ref, getOffset(), getId());
+ if (NEEDS_REFERENCE_PUTSTATIC_BARRIER && !isUntraced()) {
+ Barriers.referenceNonHeapWrite(ref, getOffset(), getId());
} else {
Statics.setSlotContents(getOffset(), ref);
}
} else {
- if (MemoryManagerConstants.NEEDS_WRITE_BARRIER && !isUntraced()) {
- MemoryManager.putfieldWriteBarrier(obj, ref, getOffset(), getId());
+ if (NEEDS_REFERENCE_PUTFIELD_BARRIER && !isUntraced()) {
+ Barriers.referenceFieldWrite(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-08-28 01:47:25 UTC (rev 15771)
+++ rvmroot/trunk/rvm/src/org/jikesrvm/compilers/baseline/ia32/Barriers.java 2009-08-28 21:08:26 UTC (rev 15772)
@@ -52,7 +52,7 @@
asm.emitPUSH_Imm(locationMetadata);
BaselineCompilerImpl.genParameterRegisterLoad(asm, 4);
genNullCheck(asm, T0);
- asm.emitCALL_Abs(Magic.getTocPointer().plus(Entrypoints.putfieldWriteBarrierMethod.getOffset()));
+ asm.emitCALL_Abs(Magic.getTocPointer().plus(Entrypoints.referenceFieldWriteBarrierMethod.getOffset()));
}

/**
@@ -69,7 +69,7 @@
asm.emitPUSH_Imm(locationMetadata);
BaselineCompilerImpl.genParameterRegisterLoad(asm, 4);
genNullCheck(asm, T0);
- asm.emitCALL_Abs(Magic.getTocPointer().plus(Entrypoints.putfieldWriteBarrierMethod.getOffset()));
+ asm.emitCALL_Abs(Magic.getTocPointer().plus(Entrypoints.referenceFieldWriteBarrierMethod.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.putstaticWriteBarrierMethod.getOffset()));
+ asm.emitCALL_Abs(Magic.getTocPointer().plus(Entrypoints.referenceNonHeapWriteBarrierMethod.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.putstaticWriteBarrierMethod.getOffset()));
+ asm.emitCALL_Abs(Magic.getTocPointer().plus(Entrypoints.referenceNonHeapWriteBarrierMethod.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.arrayLoadReadBarrierMethod.getOffset()));
+ asm.emitCALL_Abs(Magic.getTocPointer().plus(Entrypoints.referenceArrayReadBarrierMethod.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.getfieldReadBarrierMethod.getOffset()));
+ asm.emitCALL_Abs(Magic.getTocPointer().plus(Entrypoints.referenceFieldReadBarrierMethod.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.getfieldReadBarrierMethod.getOffset()));
+ asm.emitCALL_Abs(Magic.getTocPointer().plus(Entrypoints.referenceFieldReadBarrierMethod.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.getstaticReadBarrierMethod.getOffset()));
+ asm.emitCALL_Abs(Magic.getTocPointer().plus(Entrypoints.referenceNonHeapReadBarrierMethod.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.getstaticReadBarrierMethod.getOffset()));
+ asm.emitCALL_Abs(Magic.getTocPointer().plus(Entrypoints.referenceNonHeapReadBarrierMethod.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-08-28 01:47:25 UTC (rev 15771)
+++ rvmroot/trunk/rvm/src/org/jikesrvm/compilers/baseline/ia32/BaselineCompilerImpl.java 2009-08-28 21:08:26 UTC (rev 15772)
@@ -13,6 +13,7 @@
package org.jikesrvm.compilers.baseline.ia32;

import org.jikesrvm.SizeConstants;
+import static org.jikesrvm.mm.mminterface.Barriers.*;
import org.jikesrvm.VM;
import org.jikesrvm.adaptive.AosEntrypoints;
import org.jikesrvm.adaptive.recompilation.InvocationCounts;
@@ -40,7 +41,6 @@
import org.jikesrvm.ia32.ThreadLocalState;
import org.jikesrvm.jni.ia32.JNICompiler;
import org.jikesrvm.mm.mminterface.MemoryManager;
-import org.jikesrvm.mm.mminterface.MemoryManagerConstants;
import org.jikesrvm.objectmodel.JavaHeaderConstants;
import org.jikesrvm.objectmodel.ObjectModel;
import org.jikesrvm.runtime.ArchEntrypoints;
@@ -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 (MemoryManagerConstants.NEEDS_READ_BARRIER) {
+ if (NEEDS_REFERENCE_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 (MemoryManagerConstants.NEEDS_GETSTATIC_READ_BARRIER && !fieldRef.getFieldContentsType().isPrimitiveType()) {
+ if (NEEDS_REFERENCE_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 (MemoryManagerConstants.NEEDS_GETSTATIC_READ_BARRIER && !fieldRef.getFieldContentsType().isPrimitiveType() && !field.isUntraced()) {
+ if (NEEDS_REFERENCE_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 (MemoryManagerConstants.NEEDS_PUTSTATIC_WRITE_BARRIER && fieldRef.getFieldContentsType().isReferenceType()) {
+ if (NEEDS_REFERENCE_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 (MemoryManagerConstants.NEEDS_PUTSTATIC_WRITE_BARRIER && field.isReferenceType() && !field.isUntraced()) {
+ if (NEEDS_REFERENCE_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 (MemoryManagerConstants.NEEDS_READ_BARRIER) {
+ if (NEEDS_REFERENCE_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 (MemoryManagerConstants.NEEDS_READ_BARRIER && !field.isUntraced()) {
+ if (NEEDS_REFERENCE_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 (MemoryManagerConstants.NEEDS_WRITE_BARRIER) {
+ if (NEEDS_REFERENCE_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 (MemoryManagerConstants.NEEDS_WRITE_BARRIER && !field.isUntraced()) {
+ if (NEEDS_REFERENCE_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 (MemoryManagerConstants.NEEDS_READ_BARRIER) {
+ if (NEEDS_REFERENCE_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/baseline/ppc/Barriers.java
===================================================================
--- rvmroot/trunk/rvm/src/org/jikesrvm/compilers/baseline/ppc/Barriers.java 2009-08-28 01:47:25 UTC (rev 15771)
+++ rvmroot/trunk/rvm/src/org/jikesrvm/compilers/baseline/ppc/Barriers.java 2009-08-28 21:08:26 UTC (rev 15772)
@@ -34,7 +34,7 @@
// T2 already contains the offset of the field on entry
static void compilePutfieldBarrier(BaselineCompilerImpl comp, int locationMetadata) {
Assembler asm = comp.asm;
- asm.emitLAddrToc(S0, Entrypoints.putfieldWriteBarrierMethod.getOffset());
+ asm.emitLAddrToc(S0, Entrypoints.referenceFieldWriteBarrierMethod.getOffset());
asm.emitMTCTR(S0);
comp.peekAddr(T0, 1); // object base
asm.emitNullCheck(T0);
@@ -46,7 +46,7 @@
// on entry java stack contains ...|target_ref|ref_to_store|
static void compilePutfieldBarrierImm(BaselineCompilerImpl comp, Offset fieldOffset, int locationMetadata) {
Assembler asm = comp.asm;
- asm.emitLAddrToc(S0, Entrypoints.putfieldWriteBarrierMethod.getOffset());
+ asm.emitLAddrToc(S0, Entrypoints.referenceFieldWriteBarrierMethod.getOffset());
asm.emitMTCTR(S0);
comp.peekAddr(T0, 1); // object base
asm.emitNullCheck(T0);
@@ -60,7 +60,7 @@
// T1 already contains the offset of the field on entry
static void compilePutstaticBarrier(BaselineCompilerImpl comp, int locationMetadata) {
Assembler asm = comp.asm;
- asm.emitLAddrToc(S0, Entrypoints.putstaticWriteBarrierMethod.getOffset());
+ asm.emitLAddrToc(S0, Entrypoints.referenceNonHeapWriteBarrierMethod.getOffset());
asm.emitMTCTR(S0);
comp.peekAddr(T0, 0); // value to store
asm.emitLVAL(T2, locationMetadata);
@@ -70,7 +70,7 @@
// on entry java stack contains ...|ref_to_store|
static void compilePutstaticBarrierImm(BaselineCompilerImpl comp, Offset fieldOffset, int locationMetadata) {
Assembler asm = comp.asm;
- asm.emitLAddrToc(S0, Entrypoints.putstaticWriteBarrierMethod.getOffset());
+ asm.emitLAddrToc(S0, Entrypoints.referenceNonHeapWriteBarrierMethod.getOffset());
asm.emitMTCTR(S0);
asm.emitLVALAddr(T1, fieldOffset); // offset
comp.peekAddr(T0, 0); // value to store
@@ -81,7 +81,7 @@
// on entry T0, T1 already contain the appropriate values
static void compileArrayLoadBarrier(BaselineCompilerImpl comp) {
Assembler asm = comp.asm;
- asm.emitLAddrToc(S0, Entrypoints.arrayLoadReadBarrierMethod.getOffset());
+ asm.emitLAddrToc(S0, Entrypoints.referenceArrayReadBarrierMethod.getOffset());
asm.emitMTCTR(S0);
asm.emitBCCTRL(); // MemoryManager.arrayLoadReadBarrier(T0,T1)
}
@@ -90,7 +90,7 @@
// T1 already contains the offset of the field on entry
static void compileGetfieldBarrier(BaselineCompilerImpl comp, int locationMetadata) {
Assembler asm = comp.asm;
- asm.emitLAddrToc(S0, Entrypoints.getfieldReadBarrierMethod.getOffset());
+ asm.emitLAddrToc(S0, Entrypoints.referenceFieldReadBarrierMethod.getOffset());
asm.emitMTCTR(S0);
comp.peekAddr(T0, 0); // object base
asm.emitNullCheck(T0);
@@ -101,7 +101,7 @@
// on entry java stack contains ...|source_ref|
static void compileGetfieldBarrierImm(BaselineCompilerImpl comp, Offset fieldOffset, int locationMetadata) {
Assembler asm = comp.asm;
- asm.emitLAddrToc(S0, Entrypoints.getfieldReadBarrierMethod.getOffset());
+ asm.emitLAddrToc(S0, Entrypoints.referenceFieldReadBarrierMethod.getOffset());
asm.emitMTCTR(S0);
comp.peekAddr(T0, 0); // object base
asm.emitNullCheck(T0);
@@ -114,7 +114,7 @@
// T0 already contains the offset of the field on entry
static void compileGetstaticBarrier(BaselineCompilerImpl comp, int locationMetadata) {
Assembler asm = comp.asm;
- asm.emitLAddrToc(S0, Entrypoints.getstaticReadBarrierMethod.getOffset());
+ asm.emitLAddrToc(S0, Entrypoints.referenceNonHeapReadBarrierMethod.getOffset());
asm.emitMTCTR(S0);
asm.emitLVAL(T1, locationMetadata);
asm.emitBCCTRL(); // MemoryManager.getstaticReadBarrier(T0,T1)
@@ -123,7 +123,7 @@
// on entry java stack contains ...|
static void compileGetstaticBarrierImm(BaselineCompilerImpl comp, Offset fieldOffset, int locationMetadata) {
Assembler asm = comp.asm;
- asm.emitLAddrToc(S0, Entrypoints.getstaticReadBarrierMethod.getOffset());
+ asm.emitLAddrToc(S0, Entrypoints.referenceNonHeapReadBarrierMethod.getOffset());
asm.emitMTCTR(S0);
asm.emitLVALAddr(T0, fieldOffset); // offset
asm.emitLVAL(T1, locationMetadata);

Modified: rvmroot/trunk/rvm/src/org/jikesrvm/compilers/baseline/ppc/BaselineCompilerImpl.java
===================================================================
--- rvmroot/trunk/rvm/src/org/jikesrvm/compilers/baseline/ppc/BaselineCompilerImpl.java 2009-08-28 01:47:25 UTC (rev 15771)
+++ rvmroot/trunk/rvm/src/org/jikesrvm/compilers/baseline/ppc/BaselineCompilerImpl.java 2009-08-28 21:08:26 UTC (rev 15772)
@@ -39,7 +39,7 @@
import org.jikesrvm.compilers.common.assembler.ppc.AssemblerConstants;
import org.jikesrvm.jni.ppc.JNICompiler;
import org.jikesrvm.jni.ppc.JNIStackframeLayoutConstants;
-import org.jikesrvm.mm.mminterface.MemoryManagerConstants;
+import static org.jikesrvm.mm.mminterface.Barriers.*;
import org.jikesrvm.mm.mminterface.MemoryManager;
import org.jikesrvm.objectmodel.ObjectModel;
import org.jikesrvm.ppc.BaselineConstants;
@@ -965,7 +965,7 @@
@Override
protected final void emit_aaload() {
genBoundsCheck();
- if (MemoryManagerConstants.NEEDS_READ_BARRIER) {
+ if (NEEDS_REFERENCE_ALOAD_BARRIER) {
Barriers.compileArrayLoadBarrier(this);
pushAddr(T0);
} else {
@@ -2470,7 +2470,7 @@
protected final void emit_unresolved_getstatic(FieldReference fieldRef) {
emitDynamicLinkingSequence(T0, fieldRef, true);
TypeReference fieldType = fieldRef.getFieldContentsType();
- if (MemoryManagerConstants.NEEDS_GETSTATIC_READ_BARRIER && fieldType.isReferenceType()) {
+ if (NEEDS_REFERENCE_GETSTATIC_BARRIER && fieldType.isReferenceType()) {
Barriers.compileGetstaticBarrier(this, fieldType.getId());
pushAddr(T0);
return;
@@ -2500,7 +2500,7 @@
RVMField field = fieldRef.peekResolvedField();
Offset fieldOffset = field.getOffset();
TypeReference fieldType = fieldRef.getFieldContentsType();
- if (MemoryManagerConstants.NEEDS_GETSTATIC_READ_BARRIER && fieldType.isReferenceType() && !field.isUntraced()) {
+ if (NEEDS_REFERENCE_GETSTATIC_BARRIER && fieldType.isReferenceType() && !field.isUntraced()) {
Barriers.compileGetstaticBarrierImm(this, fieldOffset, fieldType.getId());
pushAddr(T0);
return;
@@ -2528,7 +2528,7 @@
*/
protected final void emit_unresolved_putstatic(FieldReference fieldRef) {
emitDynamicLinkingSequence(T1, fieldRef, true);
- if (MemoryManagerConstants.NEEDS_PUTSTATIC_WRITE_BARRIER && !fieldRef.getFieldContentsType().isPrimitiveType()) {
+ if (NEEDS_REFERENCE_PUTSTATIC_BARRIER && !fieldRef.getFieldContentsType().isPrimitiveType()) {
Barriers.compilePutstaticBarrier(this, fieldRef.getId()); // NOTE: offset is in T0 from emitDynamicLinkingSequence
discardSlots(1);
return;
@@ -2557,7 +2557,7 @@
protected final void emit_resolved_putstatic(FieldReference fieldRef) {
RVMField field = fieldRef.peekResolvedField();
Offset fieldOffset = field.getOffset();
- if (MemoryManagerConstants.NEEDS_PUTSTATIC_WRITE_BARRIER && !fieldRef.getFieldContentsType().isPrimitiveType() && !field.isUntraced()) {
+ if (NEEDS_REFERENCE_PUTSTATIC_BARRIER && !fieldRef.getFieldContentsType().isPrimitiveType() && !field.isUntraced()) {
Barriers.compilePutstaticBarrierImm(this, fieldOffset, fieldRef.getId());
discardSlots(1);
return;
@@ -2587,7 +2587,7 @@
TypeReference fieldType = fieldRef.getFieldContentsType();
// T1 = field offset from emitDynamicLinkingSequence()
emitDynamicLinkingSequence(T1, fieldRef, true);
- if (MemoryManagerConstants.NEEDS_READ_BARRIER && fieldType.isReferenceType()) {
+ if (NEEDS_REFERENCE_GETFIELD_BARRIER && fieldType.isReferenceType()) {
Barriers.compileGetfieldBarrier(this, fieldType.getId());
discardSlots(1);
pushAddr(T0);
@@ -2637,7 +2637,7 @@
RVMField field = fieldRef.peekResolvedField();
TypeReference fieldType = fieldRef.getFieldContentsType();
Offset fieldOffset = field.getOffset();
- if (MemoryManagerConstants.NEEDS_READ_BARRIER && fieldType.isReferenceType() && !field.isUntraced()) {
+ if (NEEDS_REFERENCE_GETFIELD_BARRIER && fieldType.isReferenceType() && !field.isUntraced()) {
Barriers.compileGetfieldBarrierImm(this, fieldOffset, fieldType.getId());
discardSlots(1);
pushAddr(T0);
@@ -2688,7 +2688,7 @@
emitDynamicLinkingSequence(T2, fieldRef, true);
if (fieldType.isReferenceType()) {
// 32/64bit reference store
- if (MemoryManagerConstants.NEEDS_WRITE_BARRIER) {
+ if (NEEDS_REFERENCE_PUTFIELD_BARRIER) {
// NOTE: offset is in T2 from emitDynamicLinkingSequence
Barriers.compilePutfieldBarrier(this, fieldRef.getId());
discardSlots(2);
@@ -2742,7 +2742,7 @@
TypeReference fieldType = fieldRef.getFieldContentsType();
if (fieldType.isReferenceType()) {
// 32/64bit reference store
- if (MemoryManagerConstants.NEEDS_WRITE_BARRIER && !field.isUntraced()) {
+ if (NEEDS_REFERENCE_PUTFIELD_BARRIER && !field.isUntraced()) {
Barriers.compilePutfieldBarrierImm(this, fieldOffset, fieldRef.getId());
discardSlots(2);
} else {
@@ -3743,7 +3743,7 @@
* @param reg The register to hold the counter array.
*/
private void loadCounterArray(int reg) {
- if (MemoryManagerConstants.NEEDS_READ_BARRIER) {
+ if (NEEDS_REFERENCE_ALOAD_BARRIER) {
asm.emitLAddrToc(T0, Entrypoints.edgeCountersField.getOffset());
asm.emitLVAL(T1, getEdgeCounterIndex());
Barriers.compileArrayLoadBarrier(this);

Modified: rvmroot/trunk/rvm/src/org/jikesrvm/compilers/opt/hir2lir/ExpandRuntimeServices.java
===================================================================
--- rvmroot/trunk/rvm/src/org/jikesrvm/compilers/opt/hir2lir/ExpandRuntimeServices.java 2009-08-28 01:47:25 UTC (rev 15771)
+++ rvmroot/trunk/rvm/src/org/jikesrvm/compilers/opt/hir2lir/ExpandRuntimeServices.java 2009-08-28 21:08:26 UTC (rev 15772)
@@ -31,6 +31,7 @@
import static org.jikesrvm.compilers.opt.ir.Operators.REF_ALOAD_opcode;
import static org.jikesrvm.compilers.opt.ir.Operators.REF_ASTORE_opcode;
import static org.jikesrvm.compilers.opt.ir.Operators.REF_MOVE;
+import static org.jikesrvm.mm.mminterface.Barriers.*;

import java.lang.reflect.Constructor;

@@ -70,7 +71,6 @@
import org.jikesrvm.compilers.opt.ir.operand.Operand;
import org.jikesrvm.compilers.opt.ir.operand.RegisterOperand;
import org.jikesrvm.compilers.opt.ir.operand.TypeOperand;
-import org.jikesrvm.mm.mminterface.MemoryManagerConstants;
import org.jikesrvm.mm.mminterface.MemoryManager;
import org.jikesrvm.objectmodel.ObjectModel;
import org.jikesrvm.runtime.Entrypoints;
@@ -372,8 +372,8 @@
break;

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

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

case PUTFIELD_opcode: {
- if (MemoryManagerConstants.NEEDS_WRITE_BARRIER) {
+ if (NEEDS_REFERENCE_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.putfieldWriteBarrierMethod;
+ RVMMethod target = Entrypoints.referenceFieldWriteBarrierMethod;
Instruction wb =
Call.create4(CALL,
null,
@@ -446,13 +446,13 @@
break;

case GETFIELD_opcode: {
- if (MemoryManagerConstants.NEEDS_READ_BARRIER) {
+ if (NEEDS_REFERENCE_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.getfieldReadBarrierMethod;
+ RVMMethod target = Entrypoints.referenceFieldReadBarrierMethod;
Instruction rb =
Call.create3(CALL,
GetField.getClearResult(inst),
@@ -474,11 +474,11 @@
break;

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

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

Deleted: rvmroot/trunk/rvm/src/org/jikesrvm/mm/mminterface/Barrier.java
===================================================================
--- rvmroot/trunk/rvm/src/org/jikesrvm/mm/mminterface/Barrier.java 2009-08-28 01:47:25 UTC (rev 15771)
+++ rvmroot/trunk/rvm/src/org/jikesrvm/mm/mminterface/Barrier.java 2009-08-28 21:08:26 UTC (rev 15772)
@@ -1,90 +0,0 @@
-/*
- * 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.jikesrvm.mm.mminterface;
-
-import org.jikesrvm.VM;
-import org.jikesrvm.scheduler.Monitor;
-import org.jikesrvm.scheduler.RVMThread;
-import org.vmmagic.pragma.Uninterruptible;
-import org.vmmagic.pragma.Interruptible;
-
-/**
- * This class implements barrier synchronization.
- * The mechanism handles proper resetting by usnig 3 underlying counters
- * and supports unconditional blocking until the number of participants
- * can be determined.
- */
-@Uninterruptible
-final class Barrier {
-
- public static final int VERBOSE = 0;
- private Monitor lock;
- private int target;
- private int[] counters=new int[2]; // are two counters enough?
- private int[] modes=new int[2];
- private int countIdx;
- public Barrier() {}
- @Interruptible
- public void boot(int target) {
- lock=new Monitor();
- this.target=target;
- countIdx=0;
- }
- public boolean arrive(int mode) {
- if (false) {
- VM.sysWriteln("thread ",RVMThread.getCurrentThreadSlot(),
- " entered ",RVMThread.getCurrentThread().barriersEntered++,
- " barriers");
- }
- lock.lockNoHandshake();
- int myCountIdx=countIdx;
- boolean result;
- if (VM.VerifyAssertions) {
- if (counters[myCountIdx]==0) {
- modes[myCountIdx]=mode;
- } else {
- int oldMode=modes[myCountIdx];
- if (oldMode!=mode) {
- VM.sysWriteln("Thread ",RVMThread.getCurrentThreadSlot()," encountered "+
- "incorrect mode entering barrier.");
- VM.sysWriteln("Thread ",RVMThread.getCurrentThreadSlot(),"'s mode: ",mode);
- VM.sysWriteln("Thread ",RVMThread.getCurrentThreadSlot()," saw others in mode: ",oldMode);
- VM._assert(modes[myCountIdx]==mode);
- VM._assert(oldMode==mode);
- }
- }
- }
- counters[myCountIdx]++;
- if (counters[myCountIdx]==target) {
- counters[myCountIdx]=0;
- countIdx^=1;
- lock.broadcast();
- if (false) {
- VM.sysWriteln("waking everyone");
- }
- result=true;
- } else {
- while (counters[myCountIdx]!=0) {
- lock.waitNoHandshake();
- }
- result=false;
- }
- lock.unlock();
- if (false) {
- VM.sysWriteln("thread ",RVMThread.getCurrentThreadSlot(),
- " exited ",RVMThread.getCurrentThread().barriersExited++,
- " barriers");
- }
- return result;
- }
-}

Added: rvmroot/trunk/rvm/src/org/jikesrvm/mm/mminterface/Barriers.java
===================================================================
--- rvmroot/trunk/rvm/src/org/jikesrvm/mm/mminterface/Barriers.java (rev 0)
+++ rvmroot/trunk/rvm/src/org/jikesrvm/mm/mminterface/Barriers.java 2009-08-28 21:08:26 UTC (rev 15772)
@@ -0,0 +1,255 @@
+/*
+ * 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.jikesrvm.mm.mminterface;
+
+import org.jikesrvm.runtime.Magic;
+import org.mmtk.vm.VM;
+import org.vmmagic.pragma.Entrypoint;
+import org.vmmagic.pragma.Inline;
+import org.vmmagic.pragma.Uninterruptible;
+import org.vmmagic.unboxed.ObjectReference;
+import org.vmmagic.unboxed.Offset;
+import org.vmmagic.unboxed.Word;
+
+@Uninterruptible
+public class Barriers implements org.mmtk.utility.Constants {
+ /** True if the selected plan requires a read barrier on java.lang.ref.Reference types */
+ private static final boolean NEEDS_JAVA_LANG_REFERENCE_GC_READ_BARRIER = Selected.Constraints.get().needsJavaLangReferenceReadBarrier();
+ /** True if the selected plan requires a read barrier on java.lang.ref.Reference types */
+ public static final boolean NEEDS_JAVA_LANG_REFERENCE_READ_BARRIER = NEEDS_JAVA_LANG_REFERENCE_GC_READ_BARRIER;
+
+ /**
+ * A java.lang.ref.Reference is being read.
+ *
+ * @param obj The non-null referent about to be released to the mutator.
+ * @return The object to release to the mutator.
+ */
+ public static Object javaLangReferenceReadBarrier(Object obj) {
+ if (NEEDS_JAVA_LANG_REFERENCE_GC_READ_BARRIER) {
+ ObjectReference result = Selected.Mutator.get().javaLangReferenceReadBarrier(ObjectReference.fromObject(obj));
+ return result.toObject();
+ } else if (VM.VERIFY_ASSERTIONS)
+ VM.assertions._assert(false);
+ return null;
+ }
+
+ /** 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().needsWriteBarrier();
+ /** True if the VM requires write barriers on reference putfield */
+ public static final boolean NEEDS_REFERENCE_PUTFIELD_BARRIER = NEEDS_REFERENCE_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;
+ /** 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().needsReadBarrier();
+ /** True if the VM requires read barriers on reference getfield */
+ public static final boolean NEEDS_REFERENCE_GETFIELD_BARRIER = NEEDS_REFERENCE_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;
+ /** True if the selected plan requires write barriers on reference putstatic */
+ private static final boolean NEEDS_REFERENCE_GC_PUTSTATIC_BARRIER = Selected.Constraints.get().needsStaticWriteBarrier();
+ /** 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().needsStaticReadBarrier();
+ /** 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).
+ *
+ * @param ref the object which is the subject of the putfield
+ * @param value the new value for the field
+ * @param offset the offset of the field to be modified
+ * @param locationMetadata an int that encodes the source location being modified
+ */
+ @Inline
+ @Entrypoint
+ public static void referenceFieldWrite(Object ref, Object value, Offset offset, int locationMetadata) {
+ if (NEEDS_REFERENCE_GC_WRITE_BARRIER) {
+ ObjectReference src = ObjectReference.fromObject(ref);
+ Selected.Mutator.get().referenceWrite(src,
+ src.toAddress().plus(offset),
+ ObjectReference.fromObject(value),
+ offset.toWord(),
+ Word.fromIntZeroExtend(locationMetadata),
+ INSTANCE_FIELD);
+ } else if (VM.VERIFY_ASSERTIONS)
+ VM.assertions._assert(false);
+ }
+
+ /**
+ * Barrier for writes of references 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
+ * resides. The index is the "natural" index into the array, for
+ * example a[index].
+ * @param value the value to be stored.
+ */
+ @Inline
+ @Entrypoint
+ public static void referenceArrayWrite(Object ref, int index, Object value) {
+ if (NEEDS_REFERENCE_GC_WRITE_BARRIER) {
+ ObjectReference array = ObjectReference.fromObject(ref);
+ Offset offset = Offset.fromIntZeroExtend(index << MemoryManagerConstants.LOG_BYTES_IN_ADDRESS);
+ Selected.Mutator.get().referenceWrite(array,
+ array.toAddress().plus(offset),
+ ObjectReference.fromObject(value),
+ offset.toWord(),
+ Word.zero(), // don't know metadata
+ ARRAY_ELEMENT);
+ } else if (VM.VERIFY_ASSERTIONS)
+ VM.assertions._assert(false);
+ }
+
+ /**
+ * Barrier for writes of references to non-heap locations (eg statics)
+ *
+ * @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
+ */
+ @Inline
+ @Entrypoint
+ public static void referenceNonHeapWrite(Object value, Offset offset, int locationMetadata) {
+ if (NEEDS_REFERENCE_GC_PUTSTATIC_BARRIER) {
+ ObjectReference src = ObjectReference.fromObject(Magic.getJTOC());
+ Selected.Mutator.get().referenceNonHeapWrite(src.toAddress().plus(offset),
+ ObjectReference.fromObject(value),
+ offset.toWord(),
+ Word.fromIntZeroExtend(locationMetadata));
+ } else if (VM.VERIFY_ASSERTIONS)
+ VM.assertions._assert(false);
+ }
+
+ /**
+ * Barrier for conditional compare and exchange of reference fields.
+ *
+ * @param ref the object which is the subject of the compare and exchanges
+ * @param offset the offset of the field to be modified
+ * @param old the old value to swap out
+ * @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) {

@@ Diff output truncated at 100000 characters. @@

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

------------------------------------------------------------------------------
Let Crystal Reports handle the reporting - Free Crystal Reports 2008 30-Day
trial. Simplify your report design, integration and deployment - and focus on
what you do best, core application coding. Discover what's new with
Crystal Reports now. http://p.sf.net/sfu/bobj-july
_______________________________________________
Jikesrvm-commits mailing list
Jikesrvm-commits@...
https://lists.sourceforge.net/lists/listinfo/jikesrvm-commits