From: <jik...@li...> - 2013-03-24 13:22:13
|
details: http://hg.code.sourceforge.net/p/jikesrvm/code/rev/fe3ee05044fd changeset: 10612:fe3ee05044fd user: Erik Brangs <eri...@gm...> date: Sun Mar 24 13:15:59 2013 +0100 description: Clean up org.jikesrvm.classloader.FieldVector by removing unused methods, removing useless comments and improving the rest of the comments. details: http://hg.code.sourceforge.net/p/jikesrvm/code/rev/f7c14a4fd3e7 changeset: 10613:f7c14a4fd3e7 user: Erik Brangs <eri...@gm...> date: Sun Mar 24 13:16:27 2013 +0100 description: Clean up org.jikesrvm.classloader.MethodVector by removing useless comments and improving the rest of the comments. details: http://hg.code.sourceforge.net/p/jikesrvm/code/rev/e9cf2ddbe6d4 changeset: 10614:e9cf2ddbe6d4 user: Erik Brangs <eri...@gm...> date: Sun Mar 24 13:17:39 2013 +0100 description: Add a unit test for org.jikesrvm.classloader.MethodVector. diffstat: rvm/src/org/jikesrvm/classloader/FieldVector.java | 41 +- rvm/src/org/jikesrvm/classloader/MethodVector.java | 29 +- rvm/test-src/org/jikesrvm/classloader/MethodVectorTest.java | 221 ++++++++++++ 3 files changed, 246 insertions(+), 45 deletions(-) diffs (truncated from 363 to 300 lines): diff --git a/rvm/src/org/jikesrvm/classloader/FieldVector.java b/rvm/src/org/jikesrvm/classloader/FieldVector.java --- a/rvm/src/org/jikesrvm/classloader/FieldVector.java +++ b/rvm/src/org/jikesrvm/classloader/FieldVector.java @@ -15,7 +15,8 @@ import java.util.WeakHashMap; /** - * Lightweight implementation of a vector of Fields. + * Lightweight implementation of a vector of Fields. This class is intended + * to be used by a single thread and is therefore not thread-safe. */ final class FieldVector { //-----------// @@ -26,8 +27,6 @@ array = new RVMField[10]; } - // Add item. - // void addElement(RVMField item) { if (cnt == array.length) { adjustLength(cnt << 1); // double size of array @@ -35,35 +34,13 @@ array[cnt++] = item; } - // Add item if it is not already in the Vector. - // - public void addUniqueElement(RVMField item) { - for (int i = 0; i < cnt; i++) { - if (array[i] == item) return; - } - addElement(item); - } - - // Get item. - // - RVMField elementAt(int index) { - return array[index]; - } - - // Set item. - // - void setElementAt(RVMField item, int index) { - array[index] = item; - } - - // Get number of items added so far. - // - public int size() { - return cnt; - } - - // Get array, trimmed to size. - // + /** + * @return an array of fields, trimmed to size. The returned array + * is canonical: Adding the same set of fields in the same order + * to different newly-created vectors {@code v1} and {@code v2} + * will lead to the same array being returned for both {@code v1} + * and {@code v2} when this method is called. + */ public RVMField[] finish() { synchronized(RVMField.class) { RVMField[] result = popularFVs.get(this); diff --git a/rvm/src/org/jikesrvm/classloader/MethodVector.java b/rvm/src/org/jikesrvm/classloader/MethodVector.java --- a/rvm/src/org/jikesrvm/classloader/MethodVector.java +++ b/rvm/src/org/jikesrvm/classloader/MethodVector.java @@ -15,7 +15,8 @@ import java.util.WeakHashMap; /** - * Lightweight implementation of a vector of Fields. + * Lightweight implementation of a vector of Fields. This class is intended + * to be used by a single thread and is therefore not thread-safe. */ final class MethodVector { //-----------// @@ -26,8 +27,6 @@ array = new RVMMethod[10]; } - // Add item. - // void addElement(RVMMethod item) { if (cnt == array.length) { adjustLength(cnt << 1); // double size of array @@ -35,8 +34,12 @@ array[cnt++] = item; } - // Add item if it is not already in the Vector. - // + /** + * Adds an item if it is not already in the vector. The test + * for the item uses object identity. + * + * @param item method to be added + */ public void addUniqueElement(RVMMethod item) { for (int i = 0; i < cnt; i++) { if (array[i] == item) return; @@ -44,26 +47,26 @@ addElement(item); } - // Get item. - // RVMMethod elementAt(int index) { return array[index]; } - // Set item. - // void setElementAt(RVMMethod item, int index) { array[index] = item; } - // Get number of items added so far. - // public int size() { return cnt; } - // Get array, trimmed to size. - // + /** + * + * @return an array of methods, trimmed to size. The returned array + * is canonical: Adding the same set of methods in the same order + * to different newly-created vectors {@code v1} and {@code v2} + * will lead to the same array being returned for both {@code v1} + * and {@code v2} when this method is called. + */ public RVMMethod[] finish() { synchronized(MethodVector.class) { RVMMethod[] result = popularMVs.get(this); diff --git a/rvm/test-src/org/jikesrvm/classloader/MethodVectorTest.java b/rvm/test-src/org/jikesrvm/classloader/MethodVectorTest.java new file mode 100644 --- /dev/null +++ b/rvm/test-src/org/jikesrvm/classloader/MethodVectorTest.java @@ -0,0 +1,221 @@ +/* + * 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.classloader; + +import static org.hamcrest.CoreMatchers.is; +import static org.junit.Assert.assertNull; +import static org.junit.Assert.assertSame; +import static org.junit.Assert.assertThat; +import static org.junit.Assert.assertTrue; + +import java.util.Arrays; +import java.util.List; + +import org.jikesrvm.VM; +import org.jikesrvm.compilers.common.CompiledMethod; +import org.jikesrvm.junit.runners.RequiresJikesRVM; +import org.jikesrvm.junit.runners.VMRequirements; +import org.junit.Before; +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.experimental.categories.Category; +import org.junit.runner.RunWith; + +@RunWith(VMRequirements.class) +@Category(RequiresJikesRVM.class) +public class MethodVectorTest { + + private static class MockMethod extends RVMMethod { + + private static final Atom memberDescriptor = Atom.findOrCreateAsciiAtom("()V"); + + public MockMethod(TypeReference tRef, Atom memberName) { + super(null, MemberReference.findOrCreate(tRef, memberName, memberDescriptor), (short) 0, null, null, null, null, null); + } + + @Override + protected CompiledMethod genCode() { + return null; + } + + } + + private static TypeReference tRef; + private MethodVector mv; + + @BeforeClass + public static void createTypeReference() { + if (VM.runningVM) { + tRef = TypeReference.findOrCreate("LFoo;"); + } + } + + @Before + public void setUp() { + mv = new MethodVector(); + } + + @Test + public void oneMethodIsSavedCorrectly() { + RVMMethod oneMethod = createMockMethod("foo"); + + mv.addElement(oneMethod); + + RVMMethod[] methods = mv.finish(); + assertThat(methods.length, is(1)); + assertSame(methods[0], oneMethod); + } + + RVMMethod createMockMethod(String methodName) { + Atom memberName = Atom.findOrCreateAsciiAtom(methodName); + RVMMethod oneMethod = new MockMethod(tRef, memberName); + return oneMethod; + } + + @Test + public void finalArrayIsTrimmedToSize() { + RVMMethod fooMethod = createMockMethod("foo"); + RVMMethod barMethod = createMockMethod("bar"); + RVMMethod bazMethod = createMockMethod("baz"); + + mv.addElement(fooMethod); + mv.addElement(barMethod); + mv.addElement(bazMethod); + + RVMMethod[] methods = mv.finish(); + assertThat(methods.length, is(3)); + List<RVMMethod> methodList = Arrays.asList(methods); + assertTrue(methodList.contains(fooMethod)); + assertTrue(methodList.contains(barMethod)); + assertTrue(methodList.contains(bazMethod)); + } + + @Test + public void addUniqueElementOnlyAddsElementsIfRequired() { + RVMMethod testMethod = createMockMethod("test"); + + mv.addUniqueElement(testMethod); + mv.addUniqueElement(testMethod); + + RVMMethod[] methods = mv.finish(); + assertThat(methods.length, is(1)); + assertSame(methods[0], testMethod); + } + + @Test + public void sizeWorksCorrectly() { + assertThat(mv.size(), is(0)); + + RVMMethod testMethod = createMockMethod("sizeTest"); + mv.addElement(testMethod); + assertThat(mv.size(), is(1)); + + mv.addElement(testMethod); + assertThat(mv.size(), is(2)); + } + + @Test + public void elementAtWorksForValidIndexes() { + RVMMethod fooMethod = createMockMethod("foo"); + mv.addElement(fooMethod); + RVMMethod barMethod = createMockMethod("bar"); + mv.addElement(barMethod); + RVMMethod bazMethod = createMockMethod("baz"); + mv.addElement(bazMethod); + assertSame(fooMethod, mv.elementAt(0)); + assertSame(barMethod, mv.elementAt(1)); + assertSame(bazMethod, mv.elementAt(2)); + } + + @Test(expected = ArrayIndexOutOfBoundsException.class) + public void elementAtDoesNotCheckForTooSmallIndexes() { + mv.elementAt(-1); + } + + @Test(expected = ArrayIndexOutOfBoundsException.class) + public void elementAtDoesNotCheckForTooBigIndexes() { + mv.elementAt(1000); + } + + @Test + public void elementAtReturnsUnintializedValuesForInvalidIndexes() { + RVMMethod method = mv.elementAt(5); + assertNull(method); + } + + @Test + public void setElementWorksCorrectly() throws Exception { + RVMMethod fooMethod = createMockMethod("foo"); |
From: <jik...@li...> - 2013-04-12 06:34:37
|
details: http://hg.code.sourceforge.net/p/jikesrvm/code/rev/80b2bf51f219 changeset: 10618:80b2bf51f219 user: rgarner date: Wed Mar 20 11:36:27 2013 +1100 description: RVM-1022, Allow emergency collection to succeed before throwing an OutOfMemory Exception. Not a complete fix, because the existing logic ensures that we will always perform one redundant GC before exiting. details: http://hg.code.sourceforge.net/p/jikesrvm/code/rev/c057dcd82509 changeset: 10619:c057dcd82509 user: Robin Garner <rob...@sc...> date: Fri Apr 12 16:10:54 2013 +1000 description: RVM-1025, Nursery is created for non-generational garbage collectors. Move the DEFAULT_PRETENURE_THRESHOLD constant out of the Gen package where it doesn't cause invalid class loading. details: http://hg.code.sourceforge.net/p/jikesrvm/code/rev/59bf6c9ed4af changeset: 10620:59bf6c9ed4af user: Robin Garner <rob...@sc...> date: Fri Apr 12 16:29:15 2013 +1000 description: RVM-1022, tidy up comments and initial value of 'emergency'. diffstat: MMTk/src/org/mmtk/plan/generational/Gen.java | 4 --- MMTk/src/org/mmtk/utility/alloc/Allocator.java | 13 +++++++-- MMTk/src/org/mmtk/utility/options/PretenureThresholdFraction.java | 7 +++- 3 files changed, 15 insertions(+), 9 deletions(-) diffs (69 lines): diff --git a/MMTk/src/org/mmtk/plan/generational/Gen.java b/MMTk/src/org/mmtk/plan/generational/Gen.java --- a/MMTk/src/org/mmtk/plan/generational/Gen.java +++ b/MMTk/src/org/mmtk/plan/generational/Gen.java @@ -52,10 +52,6 @@ * Constants */ - /** - * - */ - public static final float DEFAULT_PRETENURE_THRESHOLD_FRACTION = 0.5f; // if object is bigger than this fraction of nursery, pretenure to LOS protected static final float SURVIVAL_ESTIMATE = 0.8f; // est yield 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 diff --git a/MMTk/src/org/mmtk/utility/alloc/Allocator.java b/MMTk/src/org/mmtk/utility/alloc/Allocator.java --- a/MMTk/src/org/mmtk/utility/alloc/Allocator.java +++ b/MMTk/src/org/mmtk/utility/alloc/Allocator.java @@ -253,6 +253,9 @@ public final Address allocSlowInline(int bytes, int alignment, int offset) { Allocator current = this; Space space = current.getSpace(); + + // Information about the previous collection. + boolean emergencyCollection = Plan.isEmergencyCollection(); while (true) { // Try to allocate using the slow path Address result = current.allocSlowOnce(bytes, alignment, offset); @@ -263,9 +266,6 @@ return result; } - // Information about the previous collection. - boolean emergencyCollection = Plan.isEmergencyCollection(); - if (!result.isZero()) { // Report allocation success to assist OutOfMemory handling. if (!allocationSuccess) { @@ -297,6 +297,13 @@ * VMs that dynamically multiplex Java threads onto multiple mutator * contexts, */ current = VM.activePlan.mutator().getAllocatorFromSpace(space); + + /* + * Record whether last collection was an Emergency collection. + * If so, we make one more attempt to allocate before we signal + * an OOM. + */ + emergencyCollection = Plan.isEmergencyCollection(); } } } diff --git a/MMTk/src/org/mmtk/utility/options/PretenureThresholdFraction.java b/MMTk/src/org/mmtk/utility/options/PretenureThresholdFraction.java --- a/MMTk/src/org/mmtk/utility/options/PretenureThresholdFraction.java +++ b/MMTk/src/org/mmtk/utility/options/PretenureThresholdFraction.java @@ -12,9 +12,12 @@ */ package org.mmtk.utility.options; -import static org.mmtk.plan.generational.Gen.DEFAULT_PRETENURE_THRESHOLD_FRACTION; +public class PretenureThresholdFraction extends org.vmutil.options.FloatOption { + /** + * + */ + private static final float DEFAULT_PRETENURE_THRESHOLD_FRACTION = 0.5f; // if object is bigger than this fraction of nursery, pretenure to LOS -public class PretenureThresholdFraction extends org.vmutil.options.FloatOption { /** * Create the option. */ |
From: <jik...@li...> - 2013-06-14 19:58:45
|
details: http://hg.code.sourceforge.net/p/jikesrvm/code/rev/0ef0bc5c4361 changeset: 10640:0ef0bc5c4361 user: Erik Brangs <eri...@gm...> date: Fri Jun 14 20:43:06 2013 +0200 description: Change comments that still refer to the outdated "nicely/dangerously" naming convention to use "withHandshake/noHandshake". details: http://hg.code.sourceforge.net/p/jikesrvm/code/rev/8e6a95261268 changeset: 10641:8e6a95261268 user: Erik Brangs <eri...@gm...> date: Fri Jun 14 21:08:29 2013 +0200 description: Update inline comments for code patching on PPC. details: http://hg.code.sourceforge.net/p/jikesrvm/code/rev/bc39a2ef36bb changeset: 10642:bc39a2ef36bb user: Erik Brangs <eri...@gm...> date: Fri Jun 14 21:39:48 2013 +0200 description: Remove some references to the old green thread model that were still present in comments. diffstat: MMTk/ext/vm/jikesrvm/org/jikesrvm/mm/mmtk/Lock.java | 2 +- rvm/src/org/jikesrvm/compilers/opt/runtimesupport/OptCompiledMethod.java | 21 ++- rvm/src/org/jikesrvm/jni/ppc/JNICompiler.java | 4 +- rvm/src/org/jikesrvm/scheduler/NoYieldpointsMonitor.java | 4 +- rvm/src/org/jikesrvm/scheduler/RVMThread.java | 5 +- rvm/src/org/jikesrvm/scheduler/SpinLock.java | 48 +++++----- 6 files changed, 43 insertions(+), 41 deletions(-) diffs (246 lines): diff --git a/MMTk/ext/vm/jikesrvm/org/jikesrvm/mm/mmtk/Lock.java b/MMTk/ext/vm/jikesrvm/org/jikesrvm/mm/mmtk/Lock.java --- a/MMTk/ext/vm/jikesrvm/org/jikesrvm/mm/mmtk/Lock.java +++ b/MMTk/ext/vm/jikesrvm/org/jikesrvm/mm/mmtk/Lock.java @@ -123,7 +123,7 @@ state=LOCKED_QUEUED; me.monitor().lockNoHandshake(); while (queue.isQueued(me)) { - // use await instead of waitNicely because this is NOT a GC point! + // use waitNoHandshake instead of waitWithHandshake because this is NOT a GC point! me.monitor().waitNoHandshake(); } me.monitor().unlock(); diff --git a/rvm/src/org/jikesrvm/compilers/opt/runtimesupport/OptCompiledMethod.java b/rvm/src/org/jikesrvm/compilers/opt/runtimesupport/OptCompiledMethod.java --- a/rvm/src/org/jikesrvm/compilers/opt/runtimesupport/OptCompiledMethod.java +++ b/rvm/src/org/jikesrvm/compilers/opt/runtimesupport/OptCompiledMethod.java @@ -508,28 +508,31 @@ } if (VM.BuildForPowerPC) { - /* we need synchronization on PPC to handle the weak memory model - * and its icache/dcache synchronization requriements. - * before the class loading finish, other processor should get - * synchronized. - */ + // we need synchronization on PPC to handle the weak memory model + // and its icache/dcache synchronization requirements. + // Before the class loading finishes, other processors must get + // synchronized. boolean DEBUG_CODE_PATCH = false; - // let other processors see changes; although really physical processors - // need synchronization, we set each virtual processor to execute - // isync at thread switch point. + // let other processors see changes. Magic.sync(); // All other processors now will see the patched code in their data cache. // We now need to force everyone's instruction caches to be in synch with their // data caches. Some of the work of this call is redundant (since we already have // forced the data caches to be in synch), but we need the icbi instructions + // to invalidate the instruction caches. Memory.sync(Magic.objectAsAddress(instructions), instructions.length() << ArchitectureSpecific.RegisterConstants.LG_INSTRUCTION_WIDTH); + // Force all other threads to execute isync at the next thread switch point + // so that the icbi instructions take effect. Another effect is that + // prefetched instructions are discarded. + // Note: it would be sufficient to execute isync once for each + // physical processor. RVMThread.softHandshake(codePatchSyncRequestVisitor); if (DEBUG_CODE_PATCH) { - VM.sysWrite("all processors get synchronized!\n"); + VM.sysWrite("all processors got synchronized!\n"); } } diff --git a/rvm/src/org/jikesrvm/jni/ppc/JNICompiler.java b/rvm/src/org/jikesrvm/jni/ppc/JNICompiler.java --- a/rvm/src/org/jikesrvm/jni/ppc/JNICompiler.java +++ b/rvm/src/org/jikesrvm/jni/ppc/JNICompiler.java @@ -273,11 +273,11 @@ } // - // try to return virtual processor to vpStatus IN_JAVA + // try to return thread status to IN_JAVA // int label1 = asm.getMachineCodeIndex(); - //TODO: we can do this directly from FP becasue we know framesize at compiletime + //TODO: we can do this directly from FP because we know framesize at compiletime // (the same way we stored the JNI Env above) asm.emitLAddr(S0, 0, FP); // get mini-frame asm.emitLAddr(S0, 0, S0); // get Java caller FP diff --git a/rvm/src/org/jikesrvm/scheduler/NoYieldpointsMonitor.java b/rvm/src/org/jikesrvm/scheduler/NoYieldpointsMonitor.java --- a/rvm/src/org/jikesrvm/scheduler/NoYieldpointsMonitor.java +++ b/rvm/src/org/jikesrvm/scheduler/NoYieldpointsMonitor.java @@ -24,7 +24,7 @@ * the lock is held. Extremely useful for any locks that may be acquired, * released, or waited upon in the process of performing a GC. * <p> - * Note that calling any of the Nicely methods on an instance of this + * Note that calling any of the withHandshake methods on an instance of this * class is extremely dangerous. These methods may cause you to block on * GC, which seemingly goes against the very intent of this being a "no * interrupts" condition variable and lock. However, it makes a subtle @@ -32,7 +32,7 @@ * instance of NoInterruptsCondLock that your thread will wait on when * blocking on GC</i>. This idiom is used quite a bit. * <p> - * To ensure that the Nicely methods are used correctly - that is, that + * To ensure that the withHandshake methods are used correctly - that is, that * they are only used by the thread that owns the lock - there are assertions * in place to ensure that the caller is the owner. */ diff --git a/rvm/src/org/jikesrvm/scheduler/RVMThread.java b/rvm/src/org/jikesrvm/scheduler/RVMThread.java --- a/rvm/src/org/jikesrvm/scheduler/RVMThread.java +++ b/rvm/src/org/jikesrvm/scheduler/RVMThread.java @@ -2618,8 +2618,7 @@ } /** - * Start execution of 'this' by putting it on the appropriate queue of an - * unspecified virtual processor. + * Start execution of 'this' by creating and starting a native thread. */ @Interruptible public void start() { @@ -4585,7 +4584,7 @@ /** * @return the thread's context registers (saved registers when thread is - * suspended by green-thread scheduler). + * suspended by scheduler). */ public Registers getContextRegisters() { return contextRegisters; diff --git a/rvm/src/org/jikesrvm/scheduler/SpinLock.java b/rvm/src/org/jikesrvm/scheduler/SpinLock.java --- a/rvm/src/org/jikesrvm/scheduler/SpinLock.java +++ b/rvm/src/org/jikesrvm/scheduler/SpinLock.java @@ -42,9 +42,9 @@ * <p> Acquiring or releasing a lock involves atomically reading and * setting the lock's <code>latestContender</code> field. If this * field is null, the lock is unowned. Otherwise, the field points to - * the virtual processor that owns the lock, or, if MCS locking is - * being used, to the last vp on a circular queue of virtual - * processors spinning until they get the lock, or, if MCS locking is + * the thread that owns the lock, or, if MCS locking is + * being used, to the last thread on a circular queue of threads + * spinning until they get the lock, or, if MCS locking is * being used and the circular spin queue is being updated, to * <code>IN_FLUX</code>. * @@ -59,19 +59,19 @@ * tryLocks, etc.) should lock() be called. Here, any remaining * contention is handled by spinning on a local flag. * - * <p> To add itself to the circular waiting queue, a processor must + * <p> To add itself to the circular waiting queue, a thread must * succeed in setting the latestContender field to IN_FLUX. A backoff * strategy is used to reduce contention for this field. This - * strategy has both a pseudo-random (to prevent two or more virtual - * processors from backing off in lock step) and an exponential + * strategy has both a pseudo-random (to prevent two or more threads + * from backing off in lock step) and an exponential * component (to deal with really high contention). * * <p> Releasing a lock entails either atomically setting the - * latestContender field to null (if this processor is the - * latestContender), or releasing the first virtual processor on the + * latestContender field to null (if this thread is the + * latestContender), or releasing the first thread on the * circular spin queue. In the latter case, the latestContender field * must be set to IN_FLUX. To give unlock() priority over lock(), the - * backoff strategy is not used for unlocking: if a vp fails to set + * backoff strategy is not used for unlocking: if a thread fails to set * set the field to IN_FLUX, it tries again immediately. * * <p> Usage: system locks should only be used when synchronized @@ -92,11 +92,11 @@ private static final boolean MCS_Locking = false; /** - * The state of the processor lock. + * The state of the thread lock. * <ul> * <li> <code>null</code>, if the lock is not owned; - * <li> the processor that owns the lock, if no processors are waiting; - * <li> the last in a circular chain of processors waiting to own the lock; or + * <li> the thread that owns the lock, if no threads are waiting; + * <li> the last in a circular chain of threads waiting to own the lock; or * <li> <code>IN_FLUX</code>, if the circular chain is being edited. * </ul> * Only the first two states are possible unless MCS locking is implemented. @@ -110,7 +110,7 @@ lock(); } /** - * Acquire a processor lock. + * Acquire a lock. */ public void lock() { if (!VM.runningVM) return; @@ -146,14 +146,14 @@ p.contenderLink = i; } Magic.sync(); // so other contender will see updated contender chain - Magic.setObjectAtOffset(this, latestContenderOffset, i); // other processors can get at the lock + Magic.setObjectAtOffset(this, latestContenderOffset, i); // other threads can get at the lock do { // spin, waiting for the lock Magic.isync(); // to make new value visible as soon as possible } while (i.awaitingSpinLock == this); } /** - * Conditionally acquire a processor lock. + * Conditionally acquire a lock. * @return whether acquisition succeeded */ public boolean tryLock() { @@ -172,11 +172,11 @@ } /** - * Release a processor lock. + * Release a lock. */ public void unlock() { if (!VM.runningVM) return; - Magic.sync(); // commit changes while lock was held so they are visiable to the next processor that acquires the lock + Magic.sync(); // commit changes while lock was held so they are visible to the next processor that acquires the lock Offset latestContenderOffset = Entrypoints.latestContenderField.getOffset(); RVMThread i = RVMThread.getCurrentThread(); if (!MCS_Locking) { @@ -192,7 +192,7 @@ break; } } else - if (Magic.objectAsAddress(p).NE(IN_FLUX)) { // there are waiters, but the contention chain is not being chainged + if (Magic.objectAsAddress(p).NE(IN_FLUX)) { // there are waiters, but the contention chain is not being changed if (Magic.attemptAddress(this, latestContenderOffset, Magic.objectAsAddress(p), IN_FLUX)) { break; } @@ -200,17 +200,17 @@ handleMicrocontention(-1); // wait a little before trying again } } while (true); - if (p != i) { // p is the last processor on the chain of processors contending for the lock - RVMThread q = p.contenderLink; // q is first processor on the chain - if (p == q) { // only one processor waiting for the lock + if (p != i) { // p is the last thread on the chain of threads contending for the lock + RVMThread q = p.contenderLink; // q is first thread on the chain + if (p == q) { // only one thread waiting for the lock q.awaitingSpinLock = null; // q now owns the lock - Magic.sync(); // make sure the chain of waiting processors gets updated before another processor accesses the chain + Magic.sync(); // make sure the chain of waiting threads gets updated before another thread accesses the chain // other contenders can get at the lock: Magic.setObjectAtOffset(this, latestContenderOffset, q); // latestContender = q; - } else { // more than one processor waiting for the lock + } else { // more than one thread waiting for the lock p.contenderLink = q.contenderLink; // remove q from the chain q.awaitingSpinLock = null; // q now owns the lock - Magic.sync(); // make sure the chain of waiting processors gets updated before another processor accesses the chain + Magic.sync(); // make sure the chain of waiting threads gets updated before another thread accesses the chain Magic.setObjectAtOffset(this, latestContenderOffset, p); // other contenders can get at the lock } } |
From: <jik...@li...> - 2013-07-10 19:43:46
|
details: http://hg.code.sourceforge.net/p/jikesrvm/code/rev/3410e762619d changeset: 10648:3410e762619d user: Erik Brangs <eri...@gm...> date: Wed Jul 10 20:24:07 2013 +0200 description: Make the trampolineRegisters field in RVMThread final. details: http://hg.code.sourceforge.net/p/jikesrvm/code/rev/7357a9c67674 changeset: 10649:7357a9c67674 user: Erik Brangs <eri...@gm...> date: Wed Jul 10 20:28:02 2013 +0200 description: Cleanup RVMThread.SoftHandshakeVisitor. This commit makes SoftHandshakeVisitor abstract because clients are supposed to define their own visitor. The method includeThread is made abstract because the previous default implementation was incorrect. details: http://hg.code.sourceforge.net/p/jikesrvm/code/rev/725a64cea361 changeset: 10650:725a64cea361 user: Erik Brangs <eri...@gm...> date: Wed Jul 10 20:33:06 2013 +0200 description: Create a separate class for the visitor that is used to request code patching. diffstat: rvm/src/org/jikesrvm/compilers/opt/runtimesupport/CodePatchSyncRequestVisitor.java | 39 ++++++++++ rvm/src/org/jikesrvm/compilers/opt/runtimesupport/OptCompiledMethod.java | 17 +---- rvm/src/org/jikesrvm/scheduler/RVMThread.java | 26 +++--- 3 files changed, 54 insertions(+), 28 deletions(-) diffs (126 lines): diff --git a/rvm/src/org/jikesrvm/compilers/opt/runtimesupport/CodePatchSyncRequestVisitor.java b/rvm/src/org/jikesrvm/compilers/opt/runtimesupport/CodePatchSyncRequestVisitor.java new file mode 100644 --- /dev/null +++ b/rvm/src/org/jikesrvm/compilers/opt/runtimesupport/CodePatchSyncRequestVisitor.java @@ -0,0 +1,39 @@ +/* + * 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.compilers.opt.runtimesupport; + +import org.jikesrvm.scheduler.RVMThread; +import org.vmmagic.pragma.Uninterruptible; + +/** + * A visitor that is used to request synchronization of processor caches + * after code patching has taken place.<p> + */ +@Uninterruptible +class CodePatchSyncRequestVisitor extends RVMThread.SoftHandshakeVisitor { + + @Override + public boolean checkAndSignal(RVMThread t) { + t.codePatchSyncRequested = true; + return true; // handshake with everyone but ourselves. + } + + @Override + public boolean includeThread(RVMThread t) { + // CollectorThreads will never be executing code that is subject to code patching. + // (We don't allow speculative optimization of Uninterruptible code). Therefore + // it is safe to exempt collectors from the need to respond to the handshake. + return !t.isCollectorThread(); + } + +} diff --git a/rvm/src/org/jikesrvm/compilers/opt/runtimesupport/OptCompiledMethod.java b/rvm/src/org/jikesrvm/compilers/opt/runtimesupport/OptCompiledMethod.java --- a/rvm/src/org/jikesrvm/compilers/opt/runtimesupport/OptCompiledMethod.java +++ b/rvm/src/org/jikesrvm/compilers/opt/runtimesupport/OptCompiledMethod.java @@ -540,20 +540,5 @@ } private static RVMThread.SoftHandshakeVisitor codePatchSyncRequestVisitor = - new RVMThread.SoftHandshakeVisitor() { - @Override - @Uninterruptible - public boolean checkAndSignal(RVMThread t) { - t.codePatchSyncRequested = true; - return true; // handshake with everyone but ourselves. - } - @Override - @Uninterruptible - public boolean includeThread(RVMThread t) { - // CollectorThreads will never be executing code that is subject to code patching. - // (We don't allow speculative optimization of Uninterruptible code). Therefore - // it is safe to exempt collectors from the need to respond to the handshake. - return !t.isCollectorThread(); - } - }; + new CodePatchSyncRequestVisitor(); } diff --git a/rvm/src/org/jikesrvm/scheduler/RVMThread.java b/rvm/src/org/jikesrvm/scheduler/RVMThread.java --- a/rvm/src/org/jikesrvm/scheduler/RVMThread.java +++ b/rvm/src/org/jikesrvm/scheduler/RVMThread.java @@ -292,7 +292,7 @@ } /** Registers used by return barrier trampoline */ - private Registers trampolineRegisters = new Registers(); + private final Registers trampolineRegisters = new Registers(); /** Return address of stack frame hijacked by return barrier */ private Address hijackedReturnAddress; @@ -3421,16 +3421,20 @@ } @Uninterruptible - public static class SoftHandshakeVisitor { + public abstract static class SoftHandshakeVisitor { /** - * Set whatever flags need to be set to signal that the given thread should - * perform some action when it acknowledges the soft handshake. If not - * interested in this thread, return false; otherwise return true. Returning - * true will cause a soft handshake request to be put through. + * Sets whatever flags need to be set to signal that the given thread should + * perform some action when it acknowledges the soft handshake. * <p> - * This method is called with the thread's monitor() held, but while the + * This method is only called for threads for which {@link #includeThread(RVMThread)} + * is {@code true}. + * <p> + * This method is called with the thread's monitor held, but while the * thread may still be running. This method is not called on mutators that * have indicated that they are about to terminate. + * + * @return {@code false} if not interested in this thread, {@code true} otherwise. + * Returning {@code true} will cause a soft handshake request to be put through. */ public boolean checkAndSignal(RVMThread t) { return true; @@ -3445,14 +3449,12 @@ } /** - * Check whether to include the specified thread in the soft handshake. + * Checks whether to include the specified thread in the soft handshake.<p> * * @param t The thread to check for inclusion - * @return True if the thread should be included. + * @return {@code true} if the thread should be included. */ - public boolean includeThread(RVMThread t) { - return true; - } + public abstract boolean includeThread(RVMThread t); } @NoCheckStore |
From: <jik...@li...> - 2013-08-20 17:36:47
|
details: http://hg.code.sourceforge.net/p/jikesrvm/code/rev/4b18a05ad45d changeset: 10662:4b18a05ad45d user: Erik Brangs <eri...@gm...> date: Mon Aug 19 21:15:15 2013 +0200 description: Fix FindBugs warnings in CodePatchSyncRequestVisitorTest. details: http://hg.code.sourceforge.net/p/jikesrvm/code/rev/f97b5ba61fdc changeset: 10663:f97b5ba61fdc user: Erik Brangs <eri...@gm...> date: Mon Aug 19 21:20:47 2013 +0200 description: Add some simple black-box tests for System.arraycopy(..). details: http://hg.code.sourceforge.net/p/jikesrvm/code/rev/50c500c6d5b8 changeset: 10664:50c500c6d5b8 user: Erik Brangs <eri...@gm...> date: Mon Aug 19 21:27:23 2013 +0200 description: Add some rudimentary tests for a subset of the methods in org.jikesrvm.runtime.Memory. The test case contains some simple tests for memcopy(..) and the aligned*Copy(..) methods. diffstat: rvm/src/org/jikesrvm/runtime/Memory.java | 9 + rvm/test-src/org/jikesrvm/compilers/opt/runtimesupport/CodePatchSyncRequestVisitorTest.java | 10 +- rvm/test-src/org/jikesrvm/runtime/MemoryTest.java | 311 ++++ testing/tests/basic/build.xml | 1 + testing/tests/basic/src/test/org/jikesrvm/basic/java/lang/TestSystem.expected | 186 ++ testing/tests/basic/src/test/org/jikesrvm/basic/java/lang/TestSystem.java | 638 ++++++++++ 6 files changed, 1148 insertions(+), 7 deletions(-) diffs (truncated from 1212 to 300 lines): diff --git a/rvm/src/org/jikesrvm/runtime/Memory.java b/rvm/src/org/jikesrvm/runtime/Memory.java --- a/rvm/src/org/jikesrvm/runtime/Memory.java +++ b/rvm/src/org/jikesrvm/runtime/Memory.java @@ -618,4 +618,13 @@ public static int alignDown(int address, int alignment) { return (address & ~(alignment - 1)); } + + /** + * For use in test cases only. + * @return native threshold (number in bytes before copying uses C code) + */ + static int getNativeThreshold() { + return NATIVE_THRESHOLD; + } + } diff --git a/rvm/test-src/org/jikesrvm/compilers/opt/runtimesupport/CodePatchSyncRequestVisitorTest.java b/rvm/test-src/org/jikesrvm/compilers/opt/runtimesupport/CodePatchSyncRequestVisitorTest.java --- a/rvm/test-src/org/jikesrvm/compilers/opt/runtimesupport/CodePatchSyncRequestVisitorTest.java +++ b/rvm/test-src/org/jikesrvm/compilers/opt/runtimesupport/CodePatchSyncRequestVisitorTest.java @@ -89,10 +89,6 @@ synchronized (this) { try { wait(1000); - } catch (IllegalMonitorStateException e) { - throw e; - } catch (IllegalArgumentException e) { - throw e; } catch (InterruptedException e) { return; } @@ -119,8 +115,6 @@ synchronized (this) { idleImpl(); } - } catch (IllegalMonitorStateException e) { - throw e; } catch (InterruptedException e) { return; } @@ -135,7 +129,9 @@ @Override protected void idleImpl() throws InterruptedException, IllegalMonitorStateException { - wait(); + while (true) { + wait(); + } } } diff --git a/rvm/test-src/org/jikesrvm/runtime/MemoryTest.java b/rvm/test-src/org/jikesrvm/runtime/MemoryTest.java new file mode 100644 --- /dev/null +++ b/rvm/test-src/org/jikesrvm/runtime/MemoryTest.java @@ -0,0 +1,311 @@ +/* + * 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.runtime; + +import static org.jikesrvm.SizeConstants.BYTES_IN_BYTE; +import static org.jikesrvm.SizeConstants.BYTES_IN_INT; +import static org.jikesrvm.SizeConstants.BYTES_IN_LONG; +import static org.jikesrvm.SizeConstants.BYTES_IN_SHORT; +import static org.junit.Assert.fail; + +import org.jikesrvm.VM; +import org.jikesrvm.junit.runners.RequiresJikesRVM; +import org.jikesrvm.junit.runners.VMRequirements; +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.experimental.categories.Category; +import org.junit.runner.RunWith; +import org.vmmagic.unboxed.Address; + +@RunWith(VMRequirements.class) +@Category(RequiresJikesRVM.class) +public class MemoryTest { + + private static int nativeThreshold; + private static int arrayLength; + + @BeforeClass + public static void setup() { + if (!VM.runningVM) return; + nativeThreshold = Memory.getNativeThreshold(); + arrayLength = nativeThreshold * 2; + } + + @Test + public void testOverlappingCopyOfByteArrayFromGreaterToLesserPosition() { + byte[] largeByteArray = initializeByteArray(); + + int copyLength = (arrayLength * 7) / 9; + int copyStart = arrayLength - copyLength; + int copyDest = (arrayLength) / 9; + + byte srcPosValue = largeByteArray[copyStart]; + + doAligned8CopyForBytes(largeByteArray, copyStart, copyLength, copyDest); + + verifyThatCopyingToByteArrayWasCorrect(largeByteArray, + copyLength, copyDest, srcPosValue); + } + + private void verifyThatCopyingToByteArrayWasCorrect(byte[] largeByteArray, + int copyLength, int copyDest, byte srcPosValue) { + for (int i = copyDest; i < copyLength; i++) { + if (largeByteArray[i] != srcPosValue) { + fail("Expected " + srcPosValue + " but was " + largeByteArray[i] + " at pos " + i + + ". This means that parts of the byte array were overwritten"); + break; + } + srcPosValue++; + } + } + + private void doAligned8CopyForBytes(byte[] largeByteArray, int copyStart, + int copyLength, int copyDest) { + VM.disableGC(); + Address arrayStart = Magic.objectAsAddress(largeByteArray); + Address copyStartAddress = arrayStart.plus(copyStart * BYTES_IN_BYTE); + Address copyDestAddress = arrayStart.plus(copyDest * BYTES_IN_BYTE); + int copyBytes = copyLength * BYTES_IN_BYTE; + Memory.aligned8Copy(copyDestAddress, copyStartAddress, copyBytes); + VM.enableGC(); + } + + private byte[] initializeByteArray() { + byte[] largeByteArray = new byte[arrayLength]; + + byte startValue = Byte.MIN_VALUE; + byte value = startValue; + for (int i = 0; i < largeByteArray.length; i++) { + largeByteArray[i] = value; + value++; + } + return largeByteArray; + } + + @Test + public void testOverlappingCopyOfShortArrayFromGreaterToLesserPosition() { + short[] largeShortArray = initializeShortArray(); + + int copyLength = (arrayLength * 7) / 9; + int copyStart = arrayLength - copyLength; + int copyDest = (arrayLength) / 9; + + short srcPosValue = largeShortArray[copyStart]; + + doAligned16BitCopyForShorts(largeShortArray, copyStart, copyLength, + copyDest); + + srcPosValue = verifyThatCopyingToShortArrayWasCorrect( + largeShortArray, copyLength, copyDest, srcPosValue); + } + + private short verifyThatCopyingToShortArrayWasCorrect( + short[] largeShortArray, int copyLength, int copyDest, short srcPosValue) { + for (int i = copyDest; i < copyLength; i++) { + if (largeShortArray[i] != srcPosValue) { + fail("Expected + " + srcPosValue + " but was " + largeShortArray[i] + " at pos " + i + + ". This means that parts of the short array were overwritten"); + break; + } + srcPosValue++; + } + return srcPosValue; + } + + private void doAligned16BitCopyForShorts(short[] largeShortArray, + int copyStart, int copyLength, int copyDest) { + VM.disableGC(); + Address arrayStart = Magic.objectAsAddress(largeShortArray); + Address copyStartAddress = arrayStart.plus(copyStart * BYTES_IN_SHORT); + Address copyDestAddress = arrayStart.plus(copyDest * BYTES_IN_SHORT); + int copyBytes = copyLength * BYTES_IN_SHORT; + Memory.aligned16Copy(copyDestAddress, copyStartAddress, copyBytes); + VM.enableGC(); + } + + private short[] initializeShortArray() { + short[] largeShortArray = new short[arrayLength]; + + short startValue = Short.MIN_VALUE; + short value = startValue; + for (int i = 0; i < largeShortArray.length; i++) { + largeShortArray[i] = value; + value++; + } + return largeShortArray; + } + + @Test + public void testOverlappingCopyOfIntArrayFromGreaterToLesserPosition() { + int[] largeIntArray = initializeIntArray(); + + int copyLength = (arrayLength * 7) / 9; + int copyStart = arrayLength - copyLength; + int copyDest = (arrayLength) / 9; + + int srcPosValue = largeIntArray[copyStart]; + + doAligned32CopyForInts(largeIntArray, copyStart, copyLength, copyDest); + + srcPosValue = verifyThatCopyingToIntArrayWasCorrect(largeIntArray, + copyLength, copyDest, srcPosValue); + } + + private int verifyThatCopyingToIntArrayWasCorrect(int[] largeIntArray, + int copyLength, int copyDest, int srcPosValue) { + for (int i = copyDest; i < copyLength; i++) { + if (largeIntArray[i] != srcPosValue) { + fail("Expected + " + srcPosValue + " but was " + largeIntArray[i] + " at pos " + i + + ". This means that parts of the int array were overwritten"); + break; + } + srcPosValue++; + } + return srcPosValue; + } + + private void doAligned32CopyForInts(int[] largeIntArray, int copyStart, + int copyLength, int copyDest) { + VM.disableGC(); + Address arrayStart = Magic.objectAsAddress(largeIntArray); + Address copyStartAddress = arrayStart.plus(copyStart * BYTES_IN_INT); + Address copyDestAddress = arrayStart.plus(copyDest * BYTES_IN_INT); + int copyBytes = copyLength * BYTES_IN_INT; + Memory.aligned32Copy(copyDestAddress, copyStartAddress, copyBytes); + VM.enableGC(); + } + + private int[] initializeIntArray() { + int[] largeIntArray = new int[arrayLength]; + + int startValue = Integer.MIN_VALUE; + int value = startValue; + for (int i = 0; i < largeIntArray.length; i++) { + largeIntArray[i] = value; + value++; + } + return largeIntArray; + } + + @Test + public void testOverlappingCopyOfLongArrayFromGreaterToLesserPosition() { + long[] largeLongArray = initializeLongArray(); + + int copyLength = (arrayLength * 7) / 9; + int copyStart = arrayLength - copyLength; + int copyDest = (arrayLength) / 9; + + long srcPosValue = largeLongArray[copyStart]; + + doAligned64CopyForLongs(largeLongArray, copyStart, copyLength, copyDest); + + srcPosValue = verifiyThatCopyingToLongArrayWasCorrect(largeLongArray, + copyLength, copyDest, srcPosValue); + } + + private long verifiyThatCopyingToLongArrayWasCorrect( + long[] largeLongArray, int copyLength, int copyDest, long srcPosValue) { + for (int i = copyDest; i < copyLength; i++) { + if (largeLongArray[i] != srcPosValue) { + fail("Expected + " + srcPosValue + " but was " + largeLongArray[i] + " at pos " + i + + ". This means that parts of the long array were overwritten"); + break; + } + srcPosValue++; + } + return srcPosValue; + } + + private void doAligned64CopyForLongs(long[] largeLongArray, int copyStart, + int copyLength, int copyDest) { + VM.disableGC(); + Address arrayStart = Magic.objectAsAddress(largeLongArray); + Address copyStartAddress = arrayStart.plus(copyStart * BYTES_IN_LONG); + Address copyDestAddress = arrayStart.plus(copyDest * BYTES_IN_LONG); + int copyBytes = copyLength * BYTES_IN_LONG; + Memory.aligned64Copy(copyDestAddress, copyStartAddress, copyBytes); + VM.enableGC(); + } + + private long[] initializeLongArray() { + long[] largeLongArray = new long[arrayLength]; + + long startValue = Long.MIN_VALUE; + long value = startValue; |
From: <jik...@li...> - 2013-08-26 01:44:38
|
details: http://hg.code.sourceforge.net/p/jikesrvm/code/rev/3ce77cb8757a changeset: 10667:3ce77cb8757a user: Robin Garner <rob...@sc...> date: Mon Jun 10 11:53:23 2013 +1000 description: Update to the more recent Perl libraries - removes warnings from the test logs details: http://hg.code.sourceforge.net/p/jikesrvm/code/rev/6fbce363a466 changeset: 10668:6fbce363a466 user: Robin Garner <rob...@sc...> date: Mon Jun 10 12:09:51 2013 +1000 description: Failing test for RVM-1031 details: http://hg.code.sourceforge.net/p/jikesrvm/code/rev/2cb88ba8d65e changeset: 10669:2cb88ba8d65e user: Robin Garner <rob...@sc...> date: Mon Aug 26 11:32:40 2013 +1000 description: RVM-1031, remove requirement that 'superspaces' report objects as live during nursery collections diffstat: MMTk/src/org/mmtk/plan/generational/GenNurseryTraceLocal.java | 2 +- bin/timedrun | 5 +- testing/tests/gctest/build.xml | 1 + testing/tests/gctest/src/FinalizeTest.java | 143 ++++++++++ 4 files changed, 148 insertions(+), 3 deletions(-) diffs (186 lines): diff --git a/MMTk/src/org/mmtk/plan/generational/GenNurseryTraceLocal.java b/MMTk/src/org/mmtk/plan/generational/GenNurseryTraceLocal.java --- a/MMTk/src/org/mmtk/plan/generational/GenNurseryTraceLocal.java +++ b/MMTk/src/org/mmtk/plan/generational/GenNurseryTraceLocal.java @@ -64,7 +64,7 @@ if (Gen.inNursery(object)) { return Gen.nurserySpace.isLive(object); } - if (VM.VERIFY_ASSERTIONS) VM.assertions._assert(super.isLive(object)); + /* During a nursery trace, all objects not in the nursery are considered alive */ return true; } diff --git a/bin/timedrun b/bin/timedrun --- a/bin/timedrun +++ b/bin/timedrun @@ -11,8 +11,9 @@ # See the COPYRIGHT.txt file distributed with this work for information # regarding copyright ownership. # -require "getopts.pl"; -&Getopts('t:e:o:'); +use Getopt::Std; + +getopts('t:e:o:'); $alarm_exit_code = 1; diff --git a/testing/tests/gctest/build.xml b/testing/tests/gctest/build.xml --- a/testing/tests/gctest/build.xml +++ b/testing/tests/gctest/build.xml @@ -72,6 +72,7 @@ <target name="test" depends="compile"> <startResults/> + <gcTest class="FinalizeTest"/> <gcTest class="InlineAllocation"/> <gcTest class="ReferenceTest"/> <gcTest class="ReferenceStress"/> diff --git a/testing/tests/gctest/src/FinalizeTest.java b/testing/tests/gctest/src/FinalizeTest.java new file mode 100644 --- /dev/null +++ b/testing/tests/gctest/src/FinalizeTest.java @@ -0,0 +1,143 @@ +/* + * 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. + */ +import org.vmmagic.pragma.NonMoving; + +/** + * Test finalizers in various spaces. + */ +public class FinalizeTest { + + /** This class will be allocated into the non-moving space */ + @NonMoving + static class FinalizeNM { + @Override + public void finalize() throws Throwable { + } + } + + /** This class will be allocated into the default space, eg nursery */ + static class Finalize { + @Override + public void finalize() throws Throwable { + } + } + + /** This class will be allocated into the large object space */ + static class FinalizeLarge { + // 16 x 8 bytes = 128 bytes per row + // 64 rows = 8192 bytes + // + 8 byte header = 8200 bytes, which should occupy 3 pages in the LOS. + long a01, b01, c01, d01, e01, f01, g01, h01, i01, j01, k01, l01, m01, n01, o01, p01; + long a02, b02, c02, d02, e02, f02, g02, h02, i02, j02, k02, l02, m02, n02, o02, p02; + long a03, b03, c03, d03, e03, f03, g03, h03, i03, j03, k03, l03, m03, n03, o03, p03; + long a04, b04, c04, d04, e04, f04, g04, h04, i04, j04, k04, l04, m04, n04, o04, p04; + long a05, b05, c05, d05, e05, f05, g05, h05, i05, j05, k05, l05, m05, n05, o05, p05; + long a06, b06, c06, d06, e06, f06, g06, h06, i06, j06, k06, l06, m06, n06, o06, p06; + long a07, b07, c07, d07, e07, f07, g07, h07, i07, j07, k07, l07, m07, n07, o07, p07; + long a08, b08, c08, d08, e08, f08, g08, h08, i08, j08, k08, l08, m08, n08, o08, p08; + long a09, b09, c09, d09, e09, f09, g09, h09, i09, j09, k09, l09, m09, n09, o09, p09; + long a10, b10, c10, d10, e10, f10, g10, h10, i10, j10, k10, l10, m10, n10, o10, p10; + long a11, b11, c11, d11, e11, f11, g11, h11, i11, j11, k11, l11, m11, n11, o11, p11; + long a12, b12, c12, d12, e12, f12, g12, h12, i12, j12, k12, l12, m12, n12, o12, p12; + long a13, b13, c13, d13, e13, f13, g13, h13, i13, j13, k13, l13, m13, n13, o13, p13; + long a14, b14, c14, d14, e14, f14, g14, h14, i14, j14, k14, l14, m14, n14, o14, p14; + long a15, b15, c15, d15, e15, f15, g15, h15, i15, j15, k15, l15, m15, n15, o15, p15; + long a16, b16, c16, d16, e16, f16, g16, h16, i16, j16, k16, l16, m16, n16, o16, p16; + long a17, b17, c17, d17, e17, f17, g17, h17, i17, j17, k17, l17, m17, n17, o17, p17; + long a18, b18, c18, d18, e18, f18, g18, h18, i18, j18, k18, l18, m18, n18, o18, p18; + long a19, b19, c19, d19, e19, f19, g19, h19, i19, j19, k19, l19, m19, n19, o19, p19; + long a20, b20, c20, d20, e20, f20, g20, h20, i20, j20, k20, l20, m20, n20, o20, p20; + long a21, b21, c21, d21, e21, f21, g21, h21, i21, j21, k21, l21, m21, n21, o21, p21; + long a22, b22, c22, d22, e22, f22, g22, h22, i22, j22, k22, l22, m22, n22, o22, p22; + long a23, b23, c23, d23, e23, f23, g23, h23, i23, j23, k23, l23, m23, n23, o23, p23; + long a24, b24, c24, d24, e24, f24, g24, h24, i24, j24, k24, l24, m24, n24, o24, p24; + long a25, b25, c25, d25, e25, f25, g25, h25, i25, j25, k25, l25, m25, n25, o25, p25; + long a26, b26, c26, d26, e26, f26, g26, h26, i26, j26, k26, l26, m26, n26, o26, p26; + long a27, b27, c27, d27, e27, f27, g27, h27, i27, j27, k27, l27, m27, n27, o27, p27; + long a28, b28, c28, d28, e28, f28, g28, h28, i28, j28, k28, l28, m28, n28, o28, p28; + long a29, b29, c29, d29, e29, f29, g29, h29, i29, j29, k29, l29, m29, n29, o29, p29; + long a30, b30, c30, d30, e30, f30, g30, h30, i30, j30, k30, l30, m30, n30, o30, p30; + long a31, b31, c31, d31, e31, f31, g31, h31, i31, j31, k31, l31, m31, n31, o31, p31; + long a32, b32, c32, d32, e32, f32, g32, h32, i32, j32, k32, l32, m32, n32, o32, p32; + long a33, b33, c33, d33, e33, f33, g33, h33, i33, j33, k33, l33, m33, n33, o33, p33; + long a34, b34, c34, d34, e34, f34, g34, h34, i34, j34, k34, l34, m34, n34, o34, p34; + long a35, b35, c35, d35, e35, f35, g35, h35, i35, j35, k35, l35, m35, n35, o35, p35; + long a36, b36, c36, d36, e36, f36, g36, h36, i36, j36, k36, l36, m36, n36, o36, p36; + long a37, b37, c37, d37, e37, f37, g37, h37, i37, j37, k37, l37, m37, n37, o37, p37; + long a38, b38, c38, d38, e38, f38, g38, h38, i38, j38, k38, l38, m38, n38, o38, p38; + long a39, b39, c39, d39, e39, f39, g39, h39, i39, j39, k39, l39, m39, n39, o39, p39; + long a40, b40, c40, d40, e40, f40, g40, h40, i40, j40, k40, l40, m40, n40, o40, p40; + long a41, b41, c41, d41, e41, f41, g41, h41, i41, j41, k41, l41, m41, n41, o41, p41; + long a42, b42, c42, d42, e42, f42, g42, h42, i42, j42, k42, l42, m42, n42, o42, p42; + long a43, b43, c43, d43, e43, f43, g43, h43, i43, j43, k43, l43, m43, n43, o43, p43; + long a44, b44, c44, d44, e44, f44, g44, h44, i44, j44, k44, l44, m44, n44, o44, p44; + long a45, b45, c45, d45, e45, f45, g45, h45, i45, j45, k45, l45, m45, n45, o45, p45; + long a46, b46, c46, d46, e46, f46, g46, h46, i46, j46, k46, l46, m46, n46, o46, p46; + long a47, b47, c47, d47, e47, f47, g47, h47, i47, j47, k47, l47, m47, n47, o47, p47; + long a48, b48, c48, d48, e48, f48, g48, h48, i48, j48, k48, l48, m48, n48, o48, p48; + long a49, b49, c49, d49, e49, f49, g49, h49, i49, j49, k49, l49, m49, n49, o49, p49; + long a50, b50, c50, d50, e50, f50, g50, h50, i50, j50, k50, l50, m50, n50, o50, p50; + long a51, b51, c51, d51, e51, f51, g51, h51, i51, j51, k51, l51, m51, n51, o51, p51; + long a52, b52, c52, d52, e52, f52, g52, h52, i52, j52, k52, l52, m52, n52, o52, p52; + long a53, b53, c53, d53, e53, f53, g53, h53, i53, j53, k53, l53, m53, n53, o53, p53; + long a54, b54, c54, d54, e54, f54, g54, h54, i54, j54, k54, l54, m54, n54, o54, p54; + long a55, b55, c55, d55, e55, f55, g55, h55, i55, j55, k55, l55, m55, n55, o55, p55; + long a56, b56, c56, d56, e56, f56, g56, h56, i56, j56, k56, l56, m56, n56, o56, p56; + long a57, b57, c57, d57, e57, f57, g57, h57, i57, j57, k57, l57, m57, n57, o57, p57; + long a58, b58, c58, d58, e58, f58, g58, h58, i58, j58, k58, l58, m58, n58, o58, p58; + long a59, b59, c59, d59, e59, f59, g59, h59, i59, j59, k59, l59, m59, n59, o59, p59; + long a60, b60, c60, d60, e60, f60, g60, h60, i60, j60, k60, l60, m60, n60, o60, p60; + long a61, b61, c61, d61, e61, f61, g61, h61, i61, j61, k61, l61, m61, n61, o61, p61; + long a62, b62, c62, d62, e62, f62, g62, h62, i62, j62, k62, l62, m62, n62, o62, p62; + long a63, b63, c63, d63, e63, f63, g63, h63, i63, j63, k63, l63, m63, n63, o63, p63; + long a64, b64, c64, d64, e64, f64, g64, h64, i64, j64, k64, l64, m64, n64, o64, p64; + + @Override + public void finalize() throws Throwable { + } + } + + public static void main(String[] args) { + // These objects will live (in their various spaces) until the end of the test + // and be processed as potentially finalizable at the end of each GC + Object liveM = new Finalize(); + Object liveNM = new FinalizeNM(); + Object liveLarge = new FinalizeLarge(); + + // These objects will be finalized in various spaces + Object toDieMature = new Finalize(); + new FinalizeNM(); + new Finalize(); + new FinalizeLarge(); + int sum = toDieMature.hashCode(); + + // This should be enough allocation to force toDieMatureMature into + // the mature space, and to process all finalizers in a nursery collection + for (int i=0; i < 1E5; i++) { + @SuppressWarnings("unused") + Object o = new byte[512]; + } + System.gc(); + toDieMature = null; + for (int i=0; i < 1E5; i++) { + @SuppressWarnings("unused") + Object o = new byte[512]; + } + + sum += liveNM.hashCode()+liveM.hashCode()+liveLarge.hashCode(); + System.out.println(sum); + System.out.println("SUCCESS"); + } + + +} |
From: <jik...@li...> - 2013-10-02 16:18:38
|
details: http://hg.code.sourceforge.net/p/jikesrvm/code/rev/33e19aade629 changeset: 10687:33e19aade629 user: Erik Brangs <eri...@gm...> date: Wed Oct 02 16:51:09 2013 +0200 description: Add a separate property for the Checkstyle jar to the build system to get rid of hardcoding. The commit also changes the directory where constants.properties for Checkstyle is located. This should ensure a smooth upgrade as the constants.properties will be rewritten and pick up the new checkstyle.jar property immediately. details: http://hg.code.sourceforge.net/p/jikesrvm/code/rev/c434dc650671 changeset: 10688:c434dc650671 user: Erik Brangs <eri...@gm...> date: Wed Oct 02 17:05:28 2013 +0200 description: Remove static modifier from interfaces. The static modifier does not have any effect until Java 8 (which we do not support at the moment). Checkstyle's redundant modifier check will warn about this starting with Checkstyle 5.4. details: http://hg.code.sourceforge.net/p/jikesrvm/code/rev/cf7c9e3627f3 changeset: 10689:cf7c9e3627f3 user: Erik Brangs <eri...@gm...> date: Wed Oct 02 17:05:45 2013 +0200 description: Update to Checkstyle 5.6. The DoubleCheckedLocking check was removed in Checkstyle 5.6. diffstat: MMTk/src/org/mmtk/policy/Space.java | 2 +- build.xml | 2 +- build/checkstyle/rvm-checks.xml | 1 - build/components/checkstyle.xml | 10 ++++++---- testing/tests/basic/src/test/org/jikesrvm/basic/core/bytecode/TestInvoke.java | 2 +- testing/tests/basic/src/test/org/jikesrvm/basic/core/bytecode/TestMiranda.java | 2 +- testing/tests/basic/src/test/org/jikesrvm/basic/core/bytecode/TestResolveOnCheckcast.java | 2 +- testing/tests/basic/src/test/org/jikesrvm/basic/core/bytecode/TestResolveOnInstanceof.java | 2 +- testing/tests/basic/src/test/org/jikesrvm/basic/core/bytecode/TestResolveOnInvokeInterface.java | 2 +- testing/tests/jni/src/TestJNIGetFieldID.java | 2 +- 10 files changed, 14 insertions(+), 13 deletions(-) diffs (150 lines): diff --git a/MMTk/src/org/mmtk/policy/Space.java b/MMTk/src/org/mmtk/policy/Space.java --- a/MMTk/src/org/mmtk/policy/Space.java +++ b/MMTk/src/org/mmtk/policy/Space.java @@ -586,7 +586,7 @@ /** * Interface to use to implement the Visitor Pattern for Spaces. */ - public static interface SpaceVisitor { + public interface SpaceVisitor { void visit(Space s); } diff --git a/build.xml b/build.xml --- a/build.xml +++ b/build.xml @@ -2200,7 +2200,7 @@ </target> <target name="checkstyle" depends="prepare-source,prepare-config-source,choose-classlib,ensure-checkstyle"> - <taskdef resource="checkstyletask.properties" classpath="${checkstyle.dir}/checkstyle-5.3-all.jar"/> + <taskdef resource="checkstyletask.properties" classpath="${checkstyle.jar}"/> <mkdir dir="${build.dir}/checkstyle"/> <checkstyle config="build/checkstyle/rvm-checks.xml" failureProperty="checkstyle.failed" failOnViolation="false"> diff --git a/build/checkstyle/rvm-checks.xml b/build/checkstyle/rvm-checks.xml --- a/build/checkstyle/rvm-checks.xml +++ b/build/checkstyle/rvm-checks.xml @@ -124,7 +124,6 @@ <!-- Checks for common coding problems --> <!-- See http://checkstyle.sf.net/config_coding.html --> <!--<module name="AvoidInlineConditionals"/>--> - <module name="DoubleCheckedLocking"/> <!--<module name="EmptyStatement"/>--> <!--<module name="EqualsHashCode"/>--> <!--<module name="HiddenField"/>--> diff --git a/build/components/checkstyle.xml b/build/components/checkstyle.xml --- a/build/components/checkstyle.xml +++ b/build/components/checkstyle.xml @@ -15,17 +15,18 @@ <import file="base.xml"/> <property file="${components.file}"/> - <property name="checkstyle.version" value="5.3"/> + <property name="checkstyle.version" value="5.6"/> <property name="checkstyle.description" value="Checkstyle"/> <property name="checkstyle.package.dir" value="${components.dir}/checkstyle/${checkstyle.version}"/> <property name="checkstyle.dir" location="${checkstyle.package.dir}/checkstyle-${checkstyle.version}"/> + <property name="checkstyle.jar" location="${checkstyle.dir}/checkstyle-${checkstyle.version}-all.jar"/> <target name="init-checkstyle-properties" depends="prepare-ant-tasks"> <condition property="checkstyle.from-web" value="true"> <or> <not> - <available file="${checkstyle.dir}/constants.properties"/> + <available file="${checkstyle.package.dir}/constants.properties"/> </not> <isset property="checkstyle.force-download"/> </or> @@ -39,15 +40,16 @@ src="http://sourceforge.net/projects/checkstyle/files/checkstyle/${checkstyle.version}/${checkstyle.web-archive}/download?use_mirror=autoselect" dest="${checkstyle.package.dir}/${checkstyle.web-archive}"/> <untar src="${checkstyle.package.dir}/${checkstyle.web-archive}" compression="gzip" dest="${checkstyle.package.dir}"/> - <writeComponentConstants dir="${checkstyle.dir}"/> + <writeComponentConstants dir="${checkstyle.package.dir}"/> </target> <target name="build" depends="fetch"> + <setComponentsConfig key="checkstyle.jar" value="${checkstyle.jar}"/> <setComponentsConfig key="checkstyle.dir" value="${checkstyle.dir}"/> </target> <target name="ensure" depends="prepare-ant-tasks"> - <ensureUptodate name="checkstyle" dir="${checkstyle.dir}"/> + <ensureUptodate name="checkstyle" dir="${checkstyle.package.dir}"/> </target> </project> diff --git a/testing/tests/basic/src/test/org/jikesrvm/basic/core/bytecode/TestInvoke.java b/testing/tests/basic/src/test/org/jikesrvm/basic/core/bytecode/TestInvoke.java --- a/testing/tests/basic/src/test/org/jikesrvm/basic/core/bytecode/TestInvoke.java +++ b/testing/tests/basic/src/test/org/jikesrvm/basic/core/bytecode/TestInvoke.java @@ -18,7 +18,7 @@ */ class TestInvoke { - static interface MyInterface { + interface MyInterface { void performMagic(); } diff --git a/testing/tests/basic/src/test/org/jikesrvm/basic/core/bytecode/TestMiranda.java b/testing/tests/basic/src/test/org/jikesrvm/basic/core/bytecode/TestMiranda.java --- a/testing/tests/basic/src/test/org/jikesrvm/basic/core/bytecode/TestMiranda.java +++ b/testing/tests/basic/src/test/org/jikesrvm/basic/core/bytecode/TestMiranda.java @@ -22,7 +22,7 @@ /** * A simple interface with a method in it */ - static interface Interface { + interface Interface { /** A method that can be implemented */ int someMethod(int i, int j); } diff --git a/testing/tests/basic/src/test/org/jikesrvm/basic/core/bytecode/TestResolveOnCheckcast.java b/testing/tests/basic/src/test/org/jikesrvm/basic/core/bytecode/TestResolveOnCheckcast.java --- a/testing/tests/basic/src/test/org/jikesrvm/basic/core/bytecode/TestResolveOnCheckcast.java +++ b/testing/tests/basic/src/test/org/jikesrvm/basic/core/bytecode/TestResolveOnCheckcast.java @@ -20,7 +20,7 @@ */ public class TestResolveOnCheckcast { - static interface A { + interface A { String genString(); } diff --git a/testing/tests/basic/src/test/org/jikesrvm/basic/core/bytecode/TestResolveOnInstanceof.java b/testing/tests/basic/src/test/org/jikesrvm/basic/core/bytecode/TestResolveOnInstanceof.java --- a/testing/tests/basic/src/test/org/jikesrvm/basic/core/bytecode/TestResolveOnInstanceof.java +++ b/testing/tests/basic/src/test/org/jikesrvm/basic/core/bytecode/TestResolveOnInstanceof.java @@ -20,7 +20,7 @@ */ public class TestResolveOnInstanceof { - static interface A { + interface A { String genString(); } diff --git a/testing/tests/basic/src/test/org/jikesrvm/basic/core/bytecode/TestResolveOnInvokeInterface.java b/testing/tests/basic/src/test/org/jikesrvm/basic/core/bytecode/TestResolveOnInvokeInterface.java --- a/testing/tests/basic/src/test/org/jikesrvm/basic/core/bytecode/TestResolveOnInvokeInterface.java +++ b/testing/tests/basic/src/test/org/jikesrvm/basic/core/bytecode/TestResolveOnInvokeInterface.java @@ -20,7 +20,7 @@ */ public class TestResolveOnInvokeInterface { - static interface A { + interface A { String genString(); } diff --git a/testing/tests/jni/src/TestJNIGetFieldID.java b/testing/tests/jni/src/TestJNIGetFieldID.java --- a/testing/tests/jni/src/TestJNIGetFieldID.java +++ b/testing/tests/jni/src/TestJNIGetFieldID.java @@ -23,7 +23,7 @@ public int a = 0; } - static interface I { + interface I { int f = 1; } |
From: <jik...@li...> - 2013-10-20 12:04:10
|
details: http://hg.code.sourceforge.net/p/jikesrvm/code/rev/83d23567483d changeset: 10706:83d23567483d user: Erik Brangs <eri...@gm...> date: Sun Oct 20 11:58:32 2013 +0200 description: RVM-1059 : Improve readability of the loadClass(String) method in the OptTestHarness. details: http://hg.code.sourceforge.net/p/jikesrvm/code/rev/4a870ff570d9 changeset: 10707:4a870ff570d9 user: Erik Brangs <eri...@gm...> date: Sun Oct 20 12:47:00 2013 +0200 description: RVM-1059 : Replace uses of VM.sysWrite* with System.out.print*. A unit test for the OptTestHarness requires examination of the output which in turn requires a way to capture or redirect the output. details: http://hg.code.sourceforge.net/p/jikesrvm/code/rev/caa6b97df036 changeset: 10708:caa6b97df036 user: Erik Brangs <eri...@gm...> date: Sun Oct 20 12:47:47 2013 +0200 description: RVM-1059 : Add a simple unit test for org.jikesrvm.tools.oth.OptTestHarness. diffstat: rvm/src/org/jikesrvm/tools/oth/OptTestHarness.java | 52 +++- rvm/test-src/org/jikesrvm/tests/util/StringBuilderOutputStream.java | 37 +++ rvm/test-src/org/jikesrvm/tools/oth/OptTestHarnessTest.java | 119 ++++++++++ 3 files changed, 193 insertions(+), 15 deletions(-) diffs (299 lines): diff --git a/rvm/src/org/jikesrvm/tools/oth/OptTestHarness.java b/rvm/src/org/jikesrvm/tools/oth/OptTestHarness.java --- a/rvm/src/org/jikesrvm/tools/oth/OptTestHarness.java +++ b/rvm/src/org/jikesrvm/tools/oth/OptTestHarness.java @@ -36,6 +36,7 @@ import org.jikesrvm.runtime.Magic; import org.jikesrvm.runtime.Reflection; import org.jikesrvm.runtime.Time; +import org.vmmagic.unboxed.Address; /** * A test harness for the optimizing compiler. @@ -170,6 +171,12 @@ } static RVMClass loadClass(String s) throws ClassNotFoundException { + String className = convertToClassName(s); + Class<?> clazz = Class.forName(className, true, cl); + return (RVMClass) java.lang.JikesRVMSupport.getTypeForClass(clazz); + } + + private static String convertToClassName(String s) { if (s.startsWith("./")) s = s.substring(2, s.length()); if (s.endsWith(".java")) s = s.substring(0, s.length() - 5); if (s.endsWith(".class")) s = s.substring(0, s.length() - 6); @@ -180,8 +187,7 @@ } s = s.replace('.', '/'); - - return (RVMClass) java.lang.JikesRVMSupport.getTypeForClass(Class.forName(s, true, cl)); + return s; } static void printFormatString() { @@ -307,8 +313,10 @@ } if (cm != null) { method.replaceCompiledMethod(cm); - if (PRINT_CODE_ADDRESS) - VM.sysWriteln("Method: " + method + " compiled code: ", Magic.objectAsAddress(cm.getEntryCodeArray())); + if (PRINT_CODE_ADDRESS) { + Address addr = Magic.objectAsAddress(cm.getEntryCodeArray()); + System.out.println("Method: " + method + " compiled code: " + addrToString(addr)); + } } TypeReference[] argDesc = method.getDescriptor().parseForParameterTypes(klass.getClassLoader()); Object[] reflectMethodArgs = new Object[argDesc.length]; @@ -348,20 +356,22 @@ private static void compileMethodsInVector() { // Compile all baseline methods first int size = baselineMethodVector.size(); - VM.sysWrite("Compiling " + size + " methods baseline\n"); + System.out.println("Compiling " + size + " methods baseline"); // Compile all methods in baseline vector for (int i = 0; i < size; i++) { NormalMethod method = (NormalMethod) baselineMethodVector.elementAt(i); CompiledMethod cm = null; cm = BaselineCompiler.compile(method); method.replaceCompiledMethod(cm); - if (PRINT_CODE_ADDRESS) - VM.sysWriteln("Method: " + method + " compiled code: ", Magic.objectAsAddress(cm.getEntryCodeArray())); + if (PRINT_CODE_ADDRESS) { + Address addr = Magic.objectAsAddress(cm.getEntryCodeArray()); + System.out.println("Method: " + method + " compiled code: " + addrToString(addr)); + } } // Now compile all methods in opt vector size = optMethodVector.size(); - VM.sysWrite("Compiling " + size + " methods opt\n"); + System.out.println("Compiling " + size + " methods opt"); for (int i = 0; i < size; i++) { NormalMethod method = (NormalMethod) optMethodVector.elementAt(i); OptOptions opts = optOptionsVector.elementAt(i); @@ -371,8 +381,10 @@ new CompilationPlan(method, OptimizationPlanner.createOptimizationPlan(opts), null, opts); cm = OptimizingCompiler.compile(cp); method.replaceCompiledMethod(cm); - if (PRINT_CODE_ADDRESS) - VM.sysWriteln("Method: " + method + " compiled code: ", Magic.objectAsAddress(cm.getEntryCodeArray())); + if (PRINT_CODE_ADDRESS) { + Address addr = Magic.objectAsAddress(cm.getEntryCodeArray()); + System.out.println("Method: " + method + " compiled code: " + addrToString(addr)); + } } catch (OptimizingCompilerException e) { if (e.isFatal && VM.ErrorsFatal) { e.printStackTrace(); @@ -401,13 +413,13 @@ reflectoid = reflectoidVector.elementAt(i); reflectMethodArgs = reflectMethodArgsVector.elementAt(i); RVMMethod method = reflectMethodVector.elementAt(i); - VM.sysWrite("**** START OF EXECUTION of " + method + " ****.\n"); + System.out.println("**** START OF EXECUTION of " + method + " ****."); Object result = null; if (perf != null) perf.reset(); result = reflectoid.invoke(null, reflectMethodArgs); if (perf != null) perf.stop(); - VM.sysWrite("**** END OF EXECUTION of " + method + " ****.\n"); - VM.sysWrite("**** RESULT: " + result + "\n"); + System.out.println("**** END OF EXECUTION of " + method + " ****."); + System.out.println("**** RESULT: " + result); } EXECUTE_WITH_REFLECTION = false; } @@ -419,9 +431,9 @@ System.err.println(mainClass + " doesn't have a \"public static void main(String[])\" method to execute\n"); return; } - VM.sysWrite("**** START OF EXECUTION of " + mainMethod + " ****.\n"); + System.out.println("**** START OF EXECUTION of " + mainMethod + " ****."); Reflection.invoke(mainMethod, null, null, new Object[]{mainArgs}, true); - VM.sysWrite("**** END OF EXECUTION of " + mainMethod + " ****.\n"); + System.out.println("**** END OF EXECUTION of " + mainMethod + " ****."); } } @@ -446,6 +458,16 @@ } } + private static String addrToString(Address addr) { + if (VM.BuildFor32Addr) { + return Integer.toHexString(addr.toInt()); + } else if (VM.BuildFor64Addr) { + return Long.toHexString(addr.toLong()); + } + return null; + } + + private static class Performance implements Callbacks.ExitMonitor { private long start = 0; private long end = 0; diff --git a/rvm/test-src/org/jikesrvm/tests/util/StringBuilderOutputStream.java b/rvm/test-src/org/jikesrvm/tests/util/StringBuilderOutputStream.java new file mode 100644 --- /dev/null +++ b/rvm/test-src/org/jikesrvm/tests/util/StringBuilderOutputStream.java @@ -0,0 +1,37 @@ +/* + * 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.tests.util; + +import java.io.IOException; +import java.io.OutputStream; + +/** + * Provides access to the received output in the form of a {@link StringBuilder}. + */ +public class StringBuilderOutputStream extends OutputStream{ + + private final StringBuilder output = new StringBuilder(); + + @Override + public void write(int byteAsInt) throws IOException { + byte b = (byte) (byteAsInt & 0x000000FF); + byte[] bytes = new byte[1]; + bytes[0] = b; + output.append(new String(bytes)); + } + + public StringBuilder getOutput() { + return output; + } + +} diff --git a/rvm/test-src/org/jikesrvm/tools/oth/OptTestHarnessTest.java b/rvm/test-src/org/jikesrvm/tools/oth/OptTestHarnessTest.java new file mode 100644 --- /dev/null +++ b/rvm/test-src/org/jikesrvm/tools/oth/OptTestHarnessTest.java @@ -0,0 +1,119 @@ +/* + * 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.tools.oth; + +import static org.junit.Assert.*; +import static org.junit.Assume.assumeThat; +import static org.hamcrest.CoreMatchers.*; + +import java.io.PrintStream; +import java.lang.reflect.InvocationTargetException; + +import org.jikesrvm.VM; +import org.jikesrvm.junit.runners.RequiresJikesRVM; +import org.jikesrvm.junit.runners.VMRequirements; +import org.jikesrvm.tests.util.StringBuilderOutputStream; +import org.junit.After; +import org.junit.Before; +import org.junit.Test; +import org.junit.experimental.categories.Category; +import org.junit.runner.RunWith; + +@RunWith(VMRequirements.class) +@Category(RequiresJikesRVM.class) +public class OptTestHarnessTest { + + //TODO use interface for output in OTH to eliminate necessity for + // redirection of streams + + private static final String lineEnd = System.getProperty("line.separator"); + + private static final PrintStream standardSysOut = System.out; + private static final PrintStream standardSysErr = System.err; + + private static final String baselineMethodCompileString = "Compiling X methods baseline" + lineEnd; + private static final String optMethodCompileString = "Compiling X methods opt" + lineEnd; + + private StringBuilderOutputStream out; + private StringBuilderOutputStream err; + + @Before + public void redirectStandardStreams() { + out = new StringBuilderOutputStream(); + PrintStream newSysOut = new PrintStream(out); + System.setOut(newSysOut); + + err = new StringBuilderOutputStream(); + PrintStream newSysErr = new PrintStream(err); + System.setErr(newSysErr); + } + + @After + public void cleanup() { + resetStandardStreams(); + } + + private void resetStandardStreams() { + System.setOut(standardSysOut); + System.setErr(standardSysErr); + } + + @Test + public void doesNotCrashWhenNoOptCompilerIsAvailabe() throws InvocationTargetException, IllegalAccessException{ + assumeThat(VM.BuildForOptCompiler, is(false)); + String[] emptyArgs = {}; + OptTestHarness.main(emptyArgs); + } + + @Test + public void emptyArgsLeadToNoCompiles() throws InvocationTargetException, IllegalAccessException { + String[] emptyArgs = new String[0]; + OptTestHarness.main(emptyArgs); + + assertThatNumberOfBaselineCompiledMethodsIs(0); + assertThatNumberOfOptCompiledMethodsIs(0); + assertThatNoUnexpectedOutputRemains(); + assertThatNoErrorsHaveOccurred(); + } + + private void assertNumberOfCompiledMethodsIsCorrect(String s, int i) { + String output = out.getOutput().toString(); + int outputLength = output.length(); + + String expected = s.replace('X', Integer.toString(i).charAt(0)); + int expectedLength = expected.length(); + + int substringEnd = (expectedLength > outputLength) ? outputLength : expectedLength; + String outputStart = output.substring(0, substringEnd); + + assertEquals(expected, outputStart); + out.getOutput().replace(0, expectedLength, ""); + } + + private void assertThatNumberOfBaselineCompiledMethodsIs(int i) { + assertNumberOfCompiledMethodsIsCorrect(baselineMethodCompileString, i); + } + + private void assertThatNumberOfOptCompiledMethodsIs(int i) { + assertNumberOfCompiledMethodsIsCorrect(optMethodCompileString, i); + } + + private void assertThatNoUnexpectedOutputRemains() { + assertTrue(out.getOutput().toString().trim().isEmpty()); + } + + private void assertThatNoErrorsHaveOccurred() { + assertTrue(err.getOutput().toString().isEmpty()); + } + +} |
From: <jik...@li...> - 2014-01-20 17:30:24
|
details: http://hg.code.sourceforge.net/p/jikesrvm/code/rev/3228f1f76c06 changeset: 10719:3228f1f76c06 user: Erik Brangs <eri...@gm...> date: Mon Jan 20 17:25:07 2014 +0100 description: Fix a Javadoc warning. details: http://hg.code.sourceforge.net/p/jikesrvm/code/rev/517e85397f3c changeset: 10720:517e85397f3c user: Erik Brangs <eri...@gm...> date: Mon Jan 20 17:41:30 2014 +0100 description: RVM-1023 : Add initial package-level comments for the bc2ir packages. details: http://hg.code.sourceforge.net/p/jikesrvm/code/rev/babc38fbdb73 changeset: 10721:babc38fbdb73 user: Erik Brangs <eri...@gm...> date: Mon Jan 20 18:29:40 2014 +0100 description: Rephrase JavaDoc comment of BBSet to get a more useful first sentence for display in the package overview. diffstat: MMTk/src/org/mmtk/utility/heap/VMRequest.java | 1 - rvm/src/org/jikesrvm/compilers/opt/bc2ir/BBSet.java | 6 +- rvm/src/org/jikesrvm/compilers/opt/bc2ir/ia32/package-info.java | 22 ++++ rvm/src/org/jikesrvm/compilers/opt/bc2ir/package-info.java | 48 ++++++++++ rvm/src/org/jikesrvm/compilers/opt/bc2ir/ppc/package-info.java | 22 ++++ 5 files changed, 95 insertions(+), 4 deletions(-) diffs (134 lines): diff --git a/MMTk/src/org/mmtk/utility/heap/VMRequest.java b/MMTk/src/org/mmtk/utility/heap/VMRequest.java --- a/MMTk/src/org/mmtk/utility/heap/VMRequest.java +++ b/MMTk/src/org/mmtk/utility/heap/VMRequest.java @@ -95,7 +95,6 @@ * A request for a number of megabytes of memory at the highest available addresses * * @param mb The number of megabytes - * @param top True to request high memory * @return The request object */ public static VMRequest highFixedSize(int mb) { diff --git a/rvm/src/org/jikesrvm/compilers/opt/bc2ir/BBSet.java b/rvm/src/org/jikesrvm/compilers/opt/bc2ir/BBSet.java --- a/rvm/src/org/jikesrvm/compilers/opt/bc2ir/BBSet.java +++ b/rvm/src/org/jikesrvm/compilers/opt/bc2ir/BBSet.java @@ -32,9 +32,9 @@ import org.jikesrvm.compilers.opt.ir.operand.TypeOperand; /** - * A somewhat complex subtask of IR generation is to discover and maintain - * the set of basic blocks that are being generated. - * This class encapsulates that functionality. + * Encapsulates the discovery and maintenance of the set of basic blocks that + * are being generated during construction of the IR. + * <p> * The backing data store is a red/black tree, but there are a number of * very specialized operations that are performed during search/insertion * so we roll our own instead of using one from the standard library. diff --git a/rvm/src/org/jikesrvm/compilers/opt/bc2ir/ia32/package-info.java b/rvm/src/org/jikesrvm/compilers/opt/bc2ir/ia32/package-info.java new file mode 100644 --- /dev/null +++ b/rvm/src/org/jikesrvm/compilers/opt/bc2ir/ia32/package-info.java @@ -0,0 +1,22 @@ +/* + * 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. + */ + +/** + * Provides classes that implement the generation of IA32-specific magics + * for the optimizing compiler. + * <p> + * Code for magic methods that are not machine-specific is generated in + * {@link org.jikesrvm.compilers.opt.bc2ir.GenerateMagic}. + */ +package org.jikesrvm.compilers.opt.bc2ir.ia32; + diff --git a/rvm/src/org/jikesrvm/compilers/opt/bc2ir/package-info.java b/rvm/src/org/jikesrvm/compilers/opt/bc2ir/package-info.java new file mode 100644 --- /dev/null +++ b/rvm/src/org/jikesrvm/compilers/opt/bc2ir/package-info.java @@ -0,0 +1,48 @@ +/* + * 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. + */ + +/** + * Provides classes that implement the transformation from bytecode to the + * high-level intermediate representation (HIR). + * <p> + * {@link org.jikesrvm.compilers.opt.bc2ir.ConvertBCtoHIR} is the very first + * compiler phase in the optimizing compiler. Its job is to call + * {@link org.jikesrvm.compilers.opt.bc2ir.BC2IR} which generates the initial HIR. + * BC2IR collaborates with {@link org.jikesrvm.compilers.opt.bc2ir.BBSet} + * (for basic block management), {@link org.jikesrvm.compilers.opt.bc2ir.GenerationContext} + * (for information about the generation process and the method + * that is to be compiled) and {@link org.jikesrvm.compilers.opt.bc2ir.GenerateMagic} + * (for non-machine specific magics) and one implementation of + * {@link org.jikesrvm.ArchitectureSpecificOpt.GenerateMachineSpecificMagic}. + * BC2IR is also responsible for generating code to deal with on-stack-replacement. + * <p> + * Note that all inlining of application level methods in the optimizing compiler + * happens in BC2IR. Inlining of runtime services (e.g. creation of new objects, + * implementation of monitorexit and monitorenter, write barriers, ...) + * happens during the transition from high-level IR to low-level IR. + * <p> + * Important classes from other packages that relate to the job of BC2IR are the + * classes that form the IR and the classes that are related to inlining. + * <p> + * For debugging aids, see {@link org.jikesrvm.compilers.opt.bc2ir.IRGenOptions} + * and the source code of BC2IR. + * <p> + * Please consult the User Guide and the "Recommended Reading" section on the + * website for more information about the optimizing compiler and the intermediate + * representations. + * + * @see org.jikesrvm.compilers.opt.ir.IR + * @see org.jikesrvm.compilers.opt.inlining + */ +package org.jikesrvm.compilers.opt.bc2ir; + diff --git a/rvm/src/org/jikesrvm/compilers/opt/bc2ir/ppc/package-info.java b/rvm/src/org/jikesrvm/compilers/opt/bc2ir/ppc/package-info.java new file mode 100644 --- /dev/null +++ b/rvm/src/org/jikesrvm/compilers/opt/bc2ir/ppc/package-info.java @@ -0,0 +1,22 @@ +/* + * 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. + */ + +/** + * Provides classes that implement the generation of PPC-specific magics + * for the optimizing compiler. + * <p> + * Code for magic methods that are not machine-specific is generated in + * {@link org.jikesrvm.compilers.opt.bc2ir.GenerateMagic}. + */ +package org.jikesrvm.compilers.opt.bc2ir.ppc; + |
From: <jik...@li...> - 2014-03-02 15:31:59
|
details: http://hg.code.sourceforge.net/p/jikesrvm/code/rev/c12894a2bf55 changeset: 10733:c12894a2bf55 user: Erik Brangs <eri...@gm...> date: Sun Mar 02 13:04:35 2014 +0100 description: Fix JavaDoc error in VMChannel from the GNUClasspath library interface. details: http://hg.code.sourceforge.net/p/jikesrvm/code/rev/478bdb0430b1 changeset: 10734:478bdb0430b1 user: Erik Brangs <eri...@gm...> date: Sun Mar 02 15:08:26 2014 +0100 description: Fix remaining JavaDoc errors in templates for generated files. details: http://hg.code.sourceforge.net/p/jikesrvm/code/rev/420687033758 changeset: 10735:420687033758 user: Erik Brangs <eri...@gm...> date: Sun Mar 02 16:01:27 2014 +0100 description: Fix remaining JavaDoc errors. diffstat: MMTk/ext/vm/jikesrvm/org/jikesrvm/mm/mmtk/ScanThread.java | 2 +- MMTk/src/org/mmtk/plan/CollectorContext.java | 2 +- MMTk/src/org/mmtk/plan/MutatorContext.java | 28 +++--- MMTk/src/org/mmtk/plan/TraceLocal.java | 6 +- MMTk/src/org/mmtk/plan/generational/copying/GenCopy.java | 6 +- MMTk/src/org/mmtk/plan/generational/immix/GenImmix.java | 4 +- MMTk/src/org/mmtk/plan/generational/marksweep/GenMS.java | 4 +- MMTk/src/org/mmtk/plan/semispace/SS.java | 2 +- MMTk/src/org/mmtk/plan/semispace/gcspy/SSGCspy.java | 2 +- MMTk/src/org/mmtk/plan/semispace/gctrace/GCTrace.java | 4 +- MMTk/src/org/mmtk/plan/semispace/gctrace/GCTraceTraceLocal.java | 4 +- MMTk/src/org/mmtk/plan/stickyimmix/StickyImmixConstraints.java | 2 +- MMTk/src/org/mmtk/plan/stickyms/StickyMSConstraints.java | 2 +- MMTk/src/org/mmtk/utility/BaseGenericFreeList.java | 8 +- MMTk/src/org/mmtk/utility/Constants.java | 4 +- MMTk/src/org/mmtk/utility/GenericFreeList.java | 8 +- MMTk/src/org/mmtk/utility/Log.java | 2 +- MMTk/src/org/mmtk/utility/alloc/Allocator.java | 2 +- MMTk/src/org/mmtk/utility/alloc/BumpPointer.java | 2 +- MMTk/src/org/mmtk/utility/deque/SortSharedDeque.java | 6 +- MMTk/src/org/mmtk/utility/deque/SortTODAddressStack.java | 2 +- MMTk/src/org/mmtk/utility/deque/SortTODObjectReferenceStack.java | 2 +- MMTk/src/org/mmtk/utility/gcspy/StreamConstants.java | 6 +- MMTk/src/org/mmtk/utility/gcspy/drivers/AbstractDriver.java | 1 + MMTk/src/org/mmtk/utility/statistics/Xml.java | 6 +- common/vmmagic/src/org/vmmagic/pragma/LogicallyUninterruptible.java | 2 +- common/vmmagic/src/org/vmmagic/pragma/Pure.java | 4 +- common/vmmagic/src/org/vmmagic/pragma/Unpreemptible.java | 6 +- libraryInterface/GNUClasspath/LGPL/src/gnu/java/nio/VMChannel.java | 2 +- rvm/src-generated/opt-burs/BURS_TreeNode.template | 8 +- rvm/src-generated/opt-ir/Operator.template | 18 ++- rvm/src-generated/vm-configuration/Configuration.template | 2 +- rvm/src/org/jikesrvm/VM.java | 4 +- rvm/src/org/jikesrvm/adaptive/controller/AINewHotEdgeEvent.java | 2 +- rvm/src/org/jikesrvm/adaptive/controller/ControllerPlan.java | 4 +- rvm/src/org/jikesrvm/adaptive/controller/ControllerThread.java | 2 +- rvm/src/org/jikesrvm/adaptive/controller/MultiLevelAdaptiveModel.java | 2 +- rvm/src/org/jikesrvm/adaptive/controller/RecompilationStrategy.java | 2 +- rvm/src/org/jikesrvm/adaptive/measurements/instrumentation/ManagedCounterData.java | 4 +- rvm/src/org/jikesrvm/adaptive/measurements/listeners/EdgeListener.java | 2 +- rvm/src/org/jikesrvm/adaptive/recompilation/InvocationCounts.java | 4 +- rvm/src/org/jikesrvm/adaptive/recompilation/instrumentation/InstrumentationSamplingFramework.java | 2 +- rvm/src/org/jikesrvm/adaptive/util/CompilerAdviceAttribute.java | 10 +- rvm/src/org/jikesrvm/adaptive/util/CompilerAdviceInfoReader.java | 12 +- rvm/src/org/jikesrvm/adaptive/util/DynamicCallFileInfoReader.java | 2 +- rvm/src/org/jikesrvm/classloader/Atom.java | 6 +- rvm/src/org/jikesrvm/classloader/BootstrapClassLoader.java | 2 +- rvm/src/org/jikesrvm/classloader/ClassFileReader.java | 2 +- rvm/src/org/jikesrvm/classloader/DynamicTypeCheck.java | 8 +- rvm/src/org/jikesrvm/classloader/InterfaceMethodSignature.java | 2 +- rvm/src/org/jikesrvm/classloader/NormalMethod.java | 8 +- rvm/src/org/jikesrvm/classloader/RVMArray.java | 2 +- rvm/src/org/jikesrvm/classloader/RVMClass.java | 20 ++-- rvm/src/org/jikesrvm/classloader/RVMClassLoader.java | 8 +- rvm/src/org/jikesrvm/classloader/RVMField.java | 4 +- rvm/src/org/jikesrvm/classloader/RVMMethod.java | 10 +- rvm/src/org/jikesrvm/classloader/RVMType.java | 8 +- rvm/src/org/jikesrvm/classloader/TypeDescriptorParsing.java | 6 +- rvm/src/org/jikesrvm/compilers/baseline/TemplateCompilerFramework.java | 6 +- rvm/src/org/jikesrvm/compilers/common/CompiledMethod.java | 4 +- rvm/src/org/jikesrvm/compilers/common/CompiledMethods.java | 2 +- rvm/src/org/jikesrvm/compilers/common/RuntimeCompiler.java | 6 +- rvm/src/org/jikesrvm/compilers/common/assembler/AbstractAssembler.java | 2 +- rvm/src/org/jikesrvm/compilers/opt/FieldDatabase.java | 2 +- rvm/src/org/jikesrvm/compilers/opt/Simplifier.java | 8 +- rvm/src/org/jikesrvm/compilers/opt/bc2ir/BC2IR.java | 2 +- rvm/src/org/jikesrvm/compilers/opt/bc2ir/GenerationContext.java | 12 +- rvm/src/org/jikesrvm/compilers/opt/bc2ir/IRGenOptions.java | 2 +- rvm/src/org/jikesrvm/compilers/opt/bc2ir/ppc/GenerateMachineSpecificMagic.java | 2 +- rvm/src/org/jikesrvm/compilers/opt/controlflow/AnnotatedLSTNode.java | 18 ++-- rvm/src/org/jikesrvm/compilers/opt/controlflow/BranchOptimizations.java | 6 +- rvm/src/org/jikesrvm/compilers/opt/controlflow/DominanceFrontier.java | 6 +- rvm/src/org/jikesrvm/compilers/opt/controlflow/DominatorTreeNode.java | 2 +- rvm/src/org/jikesrvm/compilers/opt/controlflow/EstimateBlockFrequencies.java | 3 +- rvm/src/org/jikesrvm/compilers/opt/controlflow/LTDominators.java | 2 +- rvm/src/org/jikesrvm/compilers/opt/controlflow/MIRBranchOptimizations.java | 2 +- rvm/src/org/jikesrvm/compilers/opt/escape/EscapeTransformations.java | 4 +- rvm/src/org/jikesrvm/compilers/opt/escape/ObjectReplacer.java | 3 +- rvm/src/org/jikesrvm/compilers/opt/ir/BasicBlock.java | 5 +- rvm/src/org/jikesrvm/compilers/opt/ir/ControlFlowGraph.java | 2 +- rvm/src/org/jikesrvm/compilers/opt/ir/ExceptionHandlerBasicBlock.java | 8 +- rvm/src/org/jikesrvm/compilers/opt/ir/GCIRMapElement.java | 2 +- rvm/src/org/jikesrvm/compilers/opt/ir/IR.java | 8 +- rvm/src/org/jikesrvm/compilers/opt/ir/IRTools.java | 16 +- rvm/src/org/jikesrvm/compilers/opt/ir/Instruction.java | 6 +- rvm/src/org/jikesrvm/compilers/opt/ir/Register.java | 2 +- rvm/src/org/jikesrvm/compilers/opt/ir/ia32/MachineSpecificIRIA.java | 2 +- rvm/src/org/jikesrvm/compilers/opt/ir/operand/ConditionOperand.java | 18 ++-- rvm/src/org/jikesrvm/compilers/opt/ir/operand/MethodOperand.java | 2 +- rvm/src/org/jikesrvm/compilers/opt/lir2mir/MinimalBURS.java | 2 +- rvm/src/org/jikesrvm/compilers/opt/lir2mir/NormalBURS.java | 2 +- rvm/src/org/jikesrvm/compilers/opt/lir2mir/SplitBasicBlock.java | 4 +- rvm/src/org/jikesrvm/compilers/opt/lir2mir/ia32/BURS_Helpers.java | 10 +- rvm/src/org/jikesrvm/compilers/opt/lir2mir/ppc/ComplexLIR2MIRExpansion.java | 4 +- rvm/src/org/jikesrvm/compilers/opt/liveness/LiveAnalysis.java | 12 +- rvm/src/org/jikesrvm/compilers/opt/regalloc/CoalesceGraph.java | 2 +- rvm/src/org/jikesrvm/compilers/opt/regalloc/RegisterAllocatorState.java | 2 +- rvm/src/org/jikesrvm/compilers/opt/regalloc/ia32/ExpandFPRStackConvention.java | 2 +- rvm/src/org/jikesrvm/compilers/opt/regalloc/ppc/PhysicalRegisterConstants.java | 2 +- rvm/src/org/jikesrvm/compilers/opt/runtimesupport/OptMachineCodeMap.java | 6 +- rvm/src/org/jikesrvm/compilers/opt/runtimesupport/OptSaveVolatile.java | 2 +- rvm/src/org/jikesrvm/compilers/opt/ssa/EnterSSA.java | 6 +- rvm/src/org/jikesrvm/compilers/opt/ssa/GlobalCSE.java | 2 +- rvm/src/org/jikesrvm/compilers/opt/ssa/IndexPropagation.java | 9 +- rvm/src/org/jikesrvm/compilers/opt/ssa/IndexPropagationSystem.java | 6 +- rvm/src/org/jikesrvm/compilers/opt/ssa/LiveRangeSplitting.java | 2 +- rvm/src/org/jikesrvm/compilers/opt/ssa/LoadElimination.java | 4 +- rvm/src/org/jikesrvm/compilers/opt/ssa/LoopVersioning.java | 24 ++-- rvm/src/org/jikesrvm/compilers/opt/ssa/SSA.java | 2 +- rvm/src/org/jikesrvm/ia32/InterfaceMethodConflictResolver.java | 2 +- rvm/src/org/jikesrvm/ia32/MachineSpecificIA.java | 2 +- rvm/src/org/jikesrvm/ia32/Registers.java | 4 +- rvm/src/org/jikesrvm/ia32/StackframeLayoutConstants.java | 42 +++++---- rvm/src/org/jikesrvm/jni/JNIFunctions.java | 2 +- rvm/src/org/jikesrvm/jni/ia32/JNICompiler.java | 14 +- rvm/src/org/jikesrvm/jni/ia32/JNIHelpers.java | 24 ++-- rvm/src/org/jikesrvm/mm/mminterface/DebugUtil.java | 6 +- rvm/src/org/jikesrvm/mm/mminterface/GCMapIteratorGroup.java | 2 +- rvm/src/org/jikesrvm/objectmodel/ObjectModel.java | 10 +- rvm/src/org/jikesrvm/objectmodel/TIBLayoutConstants.java | 18 ++-- rvm/src/org/jikesrvm/osr/VariableMap.java | 8 +- rvm/src/org/jikesrvm/osr/ia32/PostThreadSwitch.java | 2 +- rvm/src/org/jikesrvm/runtime/BootRecord.java | 6 +- rvm/src/org/jikesrvm/runtime/Entrypoints.java | 2 +- rvm/src/org/jikesrvm/runtime/FileSystem.java | 10 +- rvm/src/org/jikesrvm/runtime/Memory.java | 20 ++-- rvm/src/org/jikesrvm/runtime/RuntimeEntrypoints.java | 14 +- rvm/src/org/jikesrvm/runtime/StackTrace.java | 2 +- rvm/src/org/jikesrvm/runtime/Statics.java | 14 +- rvm/src/org/jikesrvm/runtime/SysCall.java | 2 +- rvm/src/org/jikesrvm/scheduler/Lock.java | 6 +- rvm/src/org/jikesrvm/scheduler/RVMThread.java | 12 +- rvm/src/org/jikesrvm/scheduler/Synchronization.java | 10 +- rvm/src/org/jikesrvm/tools/oth/OptTestHarness.java | 14 +- rvm/src/org/jikesrvm/tuningfork/TraceEngine.java | 2 +- 135 files changed, 416 insertions(+), 401 deletions(-) diffs (truncated from 3387 to 300 lines): diff --git a/MMTk/ext/vm/jikesrvm/org/jikesrvm/mm/mmtk/ScanThread.java b/MMTk/ext/vm/jikesrvm/org/jikesrvm/mm/mmtk/ScanThread.java --- a/MMTk/ext/vm/jikesrvm/org/jikesrvm/mm/mmtk/ScanThread.java +++ b/MMTk/ext/vm/jikesrvm/org/jikesrvm/mm/mmtk/ScanThread.java @@ -611,7 +611,7 @@ * RVM did allow the GC system to move thread stacks, and called a * special fixup routine, thread.fixupMovedStack to adjust all of * the special interior pointers (SP, FP). If we implement split C - * & Java stacks then we could allow the Java stacks to be moved, + * & Java stacks then we could allow the Java stacks to be moved, * but we can't move the native stack. */ private void assertImmovableInCurrentCollection() { diff --git a/MMTk/src/org/mmtk/plan/CollectorContext.java b/MMTk/src/org/mmtk/plan/CollectorContext.java --- a/MMTk/src/org/mmtk/plan/CollectorContext.java +++ b/MMTk/src/org/mmtk/plan/CollectorContext.java @@ -22,7 +22,7 @@ import org.vmmagic.unboxed.*; /** - * This class (and its sub-classes) implement <i>per-collector thread</i> + * <p> This class (and its sub-classes) implement <i>per-collector thread</i> * behavior. We assume <i>N</i> collector threads and <i>M</i> * mutator threads, where <i>N</i> is often equal to the number of * available processors, P (for P-way parallelism at GC-time), and diff --git a/MMTk/src/org/mmtk/plan/MutatorContext.java b/MMTk/src/org/mmtk/plan/MutatorContext.java --- a/MMTk/src/org/mmtk/plan/MutatorContext.java +++ b/MMTk/src/org/mmtk/plan/MutatorContext.java @@ -302,7 +302,7 @@ /** * Read a boolean. Take appropriate read barrier action, and - * return the value that was read.<p> This is a <b>substituting<b> + * return the value that was read.<p> This is a <b>substituting</b> * barrier. The call to this barrier takes the place of a load.<p> * * @param src The object reference holding the field being read. @@ -362,7 +362,7 @@ /** * Read a byte. Take appropriate read barrier action, and - * return the value that was read.<p> This is a <b>substituting<b> + * return the value that was read.<p> This is a <b>substituting</b> * barrier. The call to this barrier takes the place of a load.<p> * * @param src The object reference holding the field being read. @@ -422,7 +422,7 @@ /** * Read a char. Take appropriate read barrier action, and - * return the value that was read.<p> This is a <b>substituting<b> + * return the value that was read.<p> This is a <b>substituting</b> * barrier. The call to this barrier takes the place of a load.<p> * * @param src The object reference holding the field being read. @@ -482,7 +482,7 @@ /** * Read a short. Take appropriate read barrier action, and - * return the value that was read.<p> This is a <b>substituting<b> + * return the value that was read.<p> This is a <b>substituting</b> * barrier. The call to this barrier takes the place of a load.<p> * * @param src The object reference holding the field being read. @@ -543,7 +543,7 @@ /** * Read a int. Take appropriate read barrier action, and - * return the value that was read.<p> This is a <b>substituting<b> + * return the value that was read.<p> This is a <b>substituting</b> * barrier. The call to this barrier takes the place of a load.<p> * * @param src The object reference holding the field being read. @@ -626,7 +626,7 @@ /** * Read a long. Take appropriate read barrier action, and - * return the value that was read.<p> This is a <b>substituting<b> + * return the value that was read.<p> This is a <b>substituting</b> * barrier. The call to this barrier takes the place of a load.<p> * * @param src The object reference holding the field being read. @@ -709,7 +709,7 @@ /** * Read a float. Take appropriate read barrier action, and - * return the value that was read.<p> This is a <b>substituting<b> + * return the value that was read.<p> This is a <b>substituting</b> * barrier. The call to this barrier takes the place of a load.<p> * * @param src The object reference holding the field being read. @@ -769,7 +769,7 @@ /** * Read a double. Take appropriate read barrier action, and - * return the value that was read.<p> This is a <b>substituting<b> + * return the value that was read.<p> This is a <b>substituting</b> * barrier. The call to this barrier takes the place of a load.<p> * * @param src The object reference holding the field being read. @@ -829,7 +829,7 @@ /** * Read a Word. Take appropriate read barrier action, and - * return the value that was read.<p> This is a <b>substituting<b> + * return the value that was read.<p> This is a <b>substituting</b> * barrier. The call to this barrier takes the place of a load.<p> * * @param src The object reference holding the field being read. @@ -912,7 +912,7 @@ /** * Read an Address. Take appropriate read barrier action, and - * return the value that was read.<p> This is a <b>substituting<b> + * return the value that was read.<p> This is a <b>substituting</b> * barrier. The call to this barrier takes the place of a load.<p> * * @param src The object reference holding the field being read. @@ -995,7 +995,7 @@ /** * Read an Extent. Take appropriate read barrier action, and - * return the value that was read.<p> This is a <b>substituting<b> + * return the value that was read.<p> This is a <b>substituting</b> * barrier. The call to this barrier takes the place of a load.<p> * * @param src The object reference holding the field being read. @@ -1055,7 +1055,7 @@ /** * Read an Offset. Take appropriate read barrier action, and - * return the value that was read.<p> This is a <b>substituting<b> + * return the value that was read.<p> This is a <b>substituting</b> * barrier. The call to this barrier takes the place of a load.<p> * * @param src The object reference holding the field being read. @@ -1115,7 +1115,7 @@ /** * Read an object reference. Take appropriate read barrier action, and - * return the value that was read.<p> This is a <b>substituting<b> + * return the value that was read.<p> This is a <b>substituting</b> * barrier. The call to this barrier takes the place of a load.<p> * * @param src The object reference holding the field being read. @@ -1175,7 +1175,7 @@ /** * Read an object reference. Take appropriate read barrier action, and - * return the value that was read.<p> This is a <b>substituting<b> + * return the value that was read.<p> This is a <b>substituting</b> * barrier. The call to this barrier takes the place of a load.<p> * * @param slot The address of the slot being read. diff --git a/MMTk/src/org/mmtk/plan/TraceLocal.java b/MMTk/src/org/mmtk/plan/TraceLocal.java --- a/MMTk/src/org/mmtk/plan/TraceLocal.java +++ b/MMTk/src/org/mmtk/plan/TraceLocal.java @@ -408,11 +408,13 @@ * * <i>For many collectors these semantics reflect those of * <code>traceObject</code>, which is implemented here. Other - * collectors must override this method.</i> + * collectors must override this method.</i><p> + * + * TODO is the JavaDoc for this method still up to date? * * @param object The object which may have been forwarded. * @return The forwarded value for <code>object</code>. <i>In this - * case return <code>object</code>, copying collectors must override + * case return <code>object</code></i>, copying collectors must override * this method. */ public ObjectReference retainForFinalize(ObjectReference object) { diff --git a/MMTk/src/org/mmtk/plan/generational/copying/GenCopy.java b/MMTk/src/org/mmtk/plan/generational/copying/GenCopy.java --- a/MMTk/src/org/mmtk/plan/generational/copying/GenCopy.java +++ b/MMTk/src/org/mmtk/plan/generational/copying/GenCopy.java @@ -32,13 +32,13 @@ * collector). Thus both fixed and flexible nursery sizes are * supported. Full heap collections occur when the nursery size has * dropped to a statically defined threshold, - * <code>NURSERY_THRESHOLD</code><p> + * <code>NURSERY_THRESHOLD</code>.<p> * - * See the Jones & Lins GC book, chapter 7 for a detailed discussion + * See the Jones & Lins GC book, chapter 7 for a detailed discussion * of generational collection and section 7.3 for an overview of the * flexible nursery behavior ("The Standard ML of New Jersey * collector"), or go to Appel's paper "Simple generational garbage - * collection and fast allocation." SP&E 19(2):171--183, 1989.<p> + * collection and fast allocation." SP&E 19(2):171--183, 1989.<p> * * All plans make a clear distinction between <i>global</i> and * <i>thread-local</i> activities. Global activities must be diff --git a/MMTk/src/org/mmtk/plan/generational/immix/GenImmix.java b/MMTk/src/org/mmtk/plan/generational/immix/GenImmix.java --- a/MMTk/src/org/mmtk/plan/generational/immix/GenImmix.java +++ b/MMTk/src/org/mmtk/plan/generational/immix/GenImmix.java @@ -39,11 +39,11 @@ * See the PLDI'08 paper by Blackburn and McKinley for a description * of the algorithm: http://doi.acm.org/10.1145/1375581.1375586<p> * - * See the Jones & Lins GC book, chapter 7 for a detailed discussion + * See the Jones & Lins GC book, chapter 7 for a detailed discussion * of generational collection and section 7.3 for an overview of the * flexible nursery behavior ("The Standard ML of New Jersey * collector"), or go to Appel's paper "Simple generational garbage - * collection and fast allocation." SP&E 19(2):171--183, 1989.<p> + * collection and fast allocation." SP&E 19(2):171--183, 1989.<p> * * * For general comments about the global/local distinction among classes refer diff --git a/MMTk/src/org/mmtk/plan/generational/marksweep/GenMS.java b/MMTk/src/org/mmtk/plan/generational/marksweep/GenMS.java --- a/MMTk/src/org/mmtk/plan/generational/marksweep/GenMS.java +++ b/MMTk/src/org/mmtk/plan/generational/marksweep/GenMS.java @@ -35,11 +35,11 @@ * nursery size has dropped to a statically defined threshold, * <code>NURSERY_THRESHOLD</code><p> * - * See the Jones & Lins GC book, chapter 7 for a detailed discussion + * See the Jones & Lins GC book, chapter 7 for a detailed discussion * of generational collection and section 7.3 for an overview of the * flexible nursery behavior ("The Standard ML of New Jersey * collector"), or go to Appel's paper "Simple generational garbage - * collection and fast allocation." SP&E 19(2):171--183, 1989.<p> + * collection and fast allocation." SP&E 19(2):171--183, 1989.<p> * * * For general comments about the global/local distinction among classes refer diff --git a/MMTk/src/org/mmtk/plan/semispace/SS.java b/MMTk/src/org/mmtk/plan/semispace/SS.java --- a/MMTk/src/org/mmtk/plan/semispace/SS.java +++ b/MMTk/src/org/mmtk/plan/semispace/SS.java @@ -22,7 +22,7 @@ /** * This class implements a simple semi-space collector. See the Jones - * & Lins GC book, section 2.2 for an overview of the basic + * & Lins GC book, section 2.2 for an overview of the basic * algorithm. This implementation also includes a large object space * (LOS), and an uncollected "immortal" space.<p> * diff --git a/MMTk/src/org/mmtk/plan/semispace/gcspy/SSGCspy.java b/MMTk/src/org/mmtk/plan/semispace/gcspy/SSGCspy.java --- a/MMTk/src/org/mmtk/plan/semispace/gcspy/SSGCspy.java +++ b/MMTk/src/org/mmtk/plan/semispace/gcspy/SSGCspy.java @@ -32,7 +32,7 @@ * This class extends a simple semi-space collector to instrument it for * GCspy. <p> * - * See the Jones & Lins GC book, section 2.2 for an overview of the basic + * See the Jones & Lins GC book, section 2.2 for an overview of the basic * algorithm. This implementation also includes a large object space * (LOS), and an uncollected "immortal" space.<p> * diff --git a/MMTk/src/org/mmtk/plan/semispace/gctrace/GCTrace.java b/MMTk/src/org/mmtk/plan/semispace/gctrace/GCTrace.java --- a/MMTk/src/org/mmtk/plan/semispace/gctrace/GCTrace.java +++ b/MMTk/src/org/mmtk/plan/semispace/gctrace/GCTrace.java @@ -54,7 +54,7 @@ * (Object 6864 was allocated into immortal space, requiring 24 bytes, * with fp 346640 on thread 5; this allocation DOES NOT have perfect * knowledge) - * 48954->[345]LObject;:blah()V:23 Ljava/lang/Foo; + * 48954->[345]LObject;:blah()V:23 Ljava/lang/Foo; * (Citation for: a) where the was allocated, fp of 48954, * at the method with ID 345 -- or void Object.blah() -- and bytecode * with offset 23; b) the object allocated is of type java.lang.Foo) @@ -62,7 +62,7 @@ * (Object 342789 became unreachable after 361460 was allocated) * </pre> * This class implements a simple semi-space collector. See the Jones - * & Lins GC book, section 2.2 for an overview of the basic + * & Lins GC book, section 2.2 for an overview of the basic * algorithm. This implementation also includes a large object space * (LOS), and an uncollected "immortal" space.<p> * diff --git a/MMTk/src/org/mmtk/plan/semispace/gctrace/GCTraceTraceLocal.java b/MMTk/src/org/mmtk/plan/semispace/gctrace/GCTraceTraceLocal.java --- a/MMTk/src/org/mmtk/plan/semispace/gctrace/GCTraceTraceLocal.java +++ b/MMTk/src/org/mmtk/plan/semispace/gctrace/GCTraceTraceLocal.java @@ -49,7 +49,7 @@ * (Object 6864 was allocated into immortal space, requiring 24 bytes, * with fp 346640 on thread 5; this allocation DOES NOT have perfect * knowledge) - * 48954->[345]LObject;:blah()V:23 Ljava/lang/Foo; + * 48954->[345]LObject;:blah()V:23 Ljava/lang/Foo; * (Citation for: a) where the was allocated, fp of 48954, * at the method with ID 345 -- or void Object.blah() -- and bytecode * with offset 23; b) the object allocated is of type java.lang.Foo) @@ -57,7 +57,7 @@ * (Object 342789 became unreachable after 361460 was allocated) * </pre> * This class implements a simple semi-space collector. See the Jones - * & Lins GC book, section 2.2 for an overview of the basic + * & Lins GC book, section 2.2 for an overview of the basic * algorithm. This implementation also includes a large object space * (LOS), and an uncollected "immortal" space.<p> * diff --git a/MMTk/src/org/mmtk/plan/stickyimmix/StickyImmixConstraints.java b/MMTk/src/org/mmtk/plan/stickyimmix/StickyImmixConstraints.java --- a/MMTk/src/org/mmtk/plan/stickyimmix/StickyImmixConstraints.java +++ b/MMTk/src/org/mmtk/plan/stickyimmix/StickyImmixConstraints.java @@ -26,7 +26,7 @@ */ @Uninterruptible public class StickyImmixConstraints extends ImmixConstraints { - /** @return The number of specialized scans. We need nursery & full heap. */ |
From: <jik...@li...> - 2014-04-16 12:43:55
|
details: http://hg.code.sourceforge.net/p/jikesrvm/code/rev/16053ec52d30 changeset: 10744:16053ec52d30 user: Erik Brangs <eri...@gm...> date: Wed Apr 16 11:28:16 2014 +0200 description: Reorder compiler options for jburg compilation so that all flags to enable warnings are grouped together. details: http://hg.code.sourceforge.net/p/jikesrvm/code/rev/a2b5ac7a7b6a changeset: 10745:a2b5ac7a7b6a user: Erik Brangs <eri...@gm...> date: Wed Apr 16 11:33:43 2014 +0200 description: Update compiler options for jburg to newer gcc versions. It is now recommended to use "-Wextra" instead of "-W" to increase clarity. The option "-Wtrigraphs" is now implied by "-Wall". The option "-Wmissing-noreturn" is replaced by "-Wsuggest-attribute=noreturn". details: http://hg.code.sourceforge.net/p/jikesrvm/code/rev/874fd4a6b2d7 changeset: 10746:874fd4a6b2d7 user: Erik Brangs <eri...@gm...> date: Wed Apr 16 11:36:55 2014 +0200 description: Remove "-fkeep-static-consts" from the compiler options used for jburg. This option is enabled by default in gcc when optimization isn't turned on (which is the case for jburg) and therefore unnecessary. Moreover, it is unsupported on clang on Mac OS 10.9.2 which will cause jburg compilation to fail. diffstat: build.xml | 2 +- 1 files changed, 1 insertions(+), 1 deletions(-) diffs (12 lines): diff --git a/build.xml b/build.xml --- a/build.xml +++ b/build.xml @@ -736,7 +736,7 @@ </exec> <exec executable="${c.exe}" failonerror="true"> <arg - line="-W -Wall -Wbad-function-cast -Wcast-align -Wpointer-arith -Wcast-qual -Wshadow -Wmissing-prototypes -Wmissing-declarations -fkeep-static-consts -fkeep-inline-functions -Wwrite-strings -Wno-aggregate-return -Wmissing-noreturn -Wnested-externs -Wtrigraphs -Wconversion -Wsign-compare -Wno-unused -Wno-strict-prototypes -Wno-undef"/> + line="-Wextra -Wall -Wbad-function-cast -Wcast-align -Wpointer-arith -Wcast-qual -Wshadow -Wmissing-prototypes -Wmissing-declarations -Wwrite-strings -Wno-aggregate-return -Wsuggest-attribute=noreturn -Wnested-externs -Wconversion -Wsign-compare -fkeep-inline-functions -Wno-unused -Wno-strict-prototypes -Wno-undef"/> <arg value="-I"/> <arg value="${basedir}/rvm/src-generated/opt-burs/jburg"/> <arg value="-o"/> |
From: <jik...@li...> - 2014-07-10 13:07:02
|
details: http://hg.code.sourceforge.net/p/jikesrvm/code/rev/a519238dd146 changeset: 10765:a519238dd146 user: Erik Brangs <eri...@gm...> date: Wed Jul 09 19:10:39 2014 +0200 description: Add missing @Entrypoint annotations. details: http://hg.code.sourceforge.net/p/jikesrvm/code/rev/7be8ed5d75ad changeset: 10766:7be8ed5d75ad user: Erik Brangs <eri...@gm...> date: Wed Jul 09 20:16:40 2014 +0200 description: Modify warnings for forbidden bytecodes (e.g. new in uninterruptible methods) so that the whole message is on a single line. This ensures that the data about the affected method is visible immediately when the build fails. Consequently, it is no longer necessary to look at the output log of the bootimage writer to determine where the problem lies. details: http://hg.code.sourceforge.net/p/jikesrvm/code/rev/5b83d78b731c changeset: 10767:5b83d78b731c user: Erik Brangs <eri...@gm...> date: Wed Jul 09 20:25:38 2014 +0200 description: Fail the build if an @Entrypoint annotation is missing and assertions are enabled. The presence of an @Entrypoint annotation is an important hint to ensure correctness. For example, one should do careful research before making fields final if they are annotated with @Entrypoint because writes to the field from code generated by the JIT compilers will not be visible in IDEs. diffstat: libraryInterface/Common/src/java/lang/VMCommonLibrarySupport.java | 1 + rvm/src/org/jikesrvm/compilers/baseline/TemplateCompilerFramework.java | 12 ++++---- rvm/src/org/jikesrvm/ia32/MultianewarrayHelper.java | 2 + rvm/src/org/jikesrvm/ia32/OutOfLineMachineCode.java | 9 +++--- rvm/src/org/jikesrvm/ia32/Registers.java | 6 ++++ rvm/src/org/jikesrvm/ppc/MultianewarrayHelper.java | 2 + rvm/src/org/jikesrvm/ppc/OutOfLineMachineCode.java | 13 +++++---- rvm/src/org/jikesrvm/ppc/Registers.java | 6 ++++ rvm/src/org/jikesrvm/runtime/EntrypointHelper.java | 11 ++++++++ rvm/src/org/jikesrvm/scheduler/RVMThread.java | 5 +++ 10 files changed, 51 insertions(+), 16 deletions(-) diffs (truncated from 302 to 300 lines): diff --git a/libraryInterface/Common/src/java/lang/VMCommonLibrarySupport.java b/libraryInterface/Common/src/java/lang/VMCommonLibrarySupport.java --- a/libraryInterface/Common/src/java/lang/VMCommonLibrarySupport.java +++ b/libraryInterface/Common/src/java/lang/VMCommonLibrarySupport.java @@ -102,6 +102,7 @@ * @param dstPos position within destination array * @param len amount of elements to copy */ + @Entrypoint static void arraycopy(Object src, int srcPos, Object dst, int dstPos, int len) { if (src == null || dst == null) { RuntimeEntrypoints.raiseNullPointerException(); diff --git a/rvm/src/org/jikesrvm/compilers/baseline/TemplateCompilerFramework.java b/rvm/src/org/jikesrvm/compilers/baseline/TemplateCompilerFramework.java --- a/rvm/src/org/jikesrvm/compilers/baseline/TemplateCompilerFramework.java +++ b/rvm/src/org/jikesrvm/compilers/baseline/TemplateCompilerFramework.java @@ -2074,8 +2074,8 @@ if (method.hasUnpreemptibleNoWarnAnnotation()) return; } // NB generate as a single string to avoid threads splitting output - VM.sysWriteln("WARNING: UNINTERRUPTIBLE VIOLATION\n "+ method + " at line " + method.getLineNumberForBCIndex(bci) + - "\n Uninterruptible methods may not contain the following forbidden bytecode\n " + msg); + VM.sysWriteln("WARNING: UNINTERRUPTIBLE VIOLATION. " + method + " at line " + method.getLineNumberForBCIndex(bci) + + ". Uninterruptible methods may not contain the following forbidden bytecode: " + msg); } /** @@ -2093,13 +2093,13 @@ } if (isUninterruptible && !target.isUninterruptible()) { // NB generate as a single string to avoid threads splitting output - VM.sysWrite("WARNING: UNINTERRUPTIBLE VIOLATION\n "+ method + " at line " + method.getLineNumberForBCIndex(bci) + - "\n Uninterruptible method calls non-uninterruptible method " + target + "\n"); + VM.sysWrite("WARNING: UNINTERRUPTIBLE VIOLATION. " + method + " at line " + method.getLineNumberForBCIndex(bci) + + ". Uninterruptible method calls non-uninterruptible method " + target + "\n"); } if (isUnpreemptible && target.isInterruptible()) { // NB generate as a single string to avoid threads splitting output - VM.sysWrite("WARNING: UNPREEMPTIBLE VIOLATION\n "+ method + " at line " + method.getLineNumberForBCIndex(bci) + - "\n Unpreemptible method calls interruptible method " + target + "\n"); + VM.sysWrite("WARNING: UNPREEMPTIBLE VIOLATION. " + method + " at line " + method.getLineNumberForBCIndex(bci) + + ". Unpreemptible method calls interruptible method " + target + "\n"); } } diff --git a/rvm/src/org/jikesrvm/ia32/MultianewarrayHelper.java b/rvm/src/org/jikesrvm/ia32/MultianewarrayHelper.java --- a/rvm/src/org/jikesrvm/ia32/MultianewarrayHelper.java +++ b/rvm/src/org/jikesrvm/ia32/MultianewarrayHelper.java @@ -17,6 +17,7 @@ import org.jikesrvm.classloader.TypeReference; import org.jikesrvm.runtime.Magic; import org.jikesrvm.runtime.RuntimeEntrypoints; +import org.vmmagic.pragma.Entrypoint; import org.vmmagic.unboxed.Address; import static org.jikesrvm.SizeConstants.BYTES_IN_WORD; @@ -42,6 +43,7 @@ * * See also: bytecode 0xc5 ("multianewarray") in BaselineCompilerImpl */ + @Entrypoint static Object newArrayArray(int methodId, int numDimensions, int typeId, int argOffset) throws NoClassDefFoundError, NegativeArraySizeException, OutOfMemoryError { if (numDimensions == 2) { diff --git a/rvm/src/org/jikesrvm/ia32/OutOfLineMachineCode.java b/rvm/src/org/jikesrvm/ia32/OutOfLineMachineCode.java --- a/rvm/src/org/jikesrvm/ia32/OutOfLineMachineCode.java +++ b/rvm/src/org/jikesrvm/ia32/OutOfLineMachineCode.java @@ -25,6 +25,7 @@ import org.jikesrvm.runtime.Entrypoints; import org.jikesrvm.runtime.Magic; import org.jikesrvm.scheduler.RVMThread; +import org.vmmagic.pragma.Entrypoint; import org.vmmagic.unboxed.Offset; import static org.jikesrvm.runtime.RuntimeEntrypoints.TRAP_UNKNOWN; @@ -92,16 +93,16 @@ private static ArchitectureSpecific.CodeArray pcThunkEDIInstructions; @SuppressWarnings({"unused", "UnusedDeclaration", "FieldCanBeLocal"}) - // Accessed via EntryPoints + @Entrypoint private static ArchitectureSpecific.CodeArray reflectiveMethodInvokerInstructions; @SuppressWarnings({"unused", "UnusedDeclaration", "FieldCanBeLocal"}) - // Accessed via EntryPoints + @Entrypoint private static ArchitectureSpecific.CodeArray saveThreadStateInstructions; @SuppressWarnings({"unused", "UnusedDeclaration", "FieldCanBeLocal"}) - // Accessed via EntryPoints + @Entrypoint private static ArchitectureSpecific.CodeArray threadSwitchInstructions; @SuppressWarnings({"unused", "UnusedDeclaration", "FieldCanBeLocal"}) - // Accessed via EntryPoints + @Entrypoint private static ArchitectureSpecific.CodeArray restoreHardwareExceptionStateInstructions; private static final Offset PARAMS_FP_OFFSET = Offset.fromIntSignExtend(WORDSIZE * 2); diff --git a/rvm/src/org/jikesrvm/ia32/Registers.java b/rvm/src/org/jikesrvm/ia32/Registers.java --- a/rvm/src/org/jikesrvm/ia32/Registers.java +++ b/rvm/src/org/jikesrvm/ia32/Registers.java @@ -17,6 +17,7 @@ import org.jikesrvm.scheduler.RVMThread; import org.jikesrvm.VM; import org.jikesrvm.mm.mminterface.MemoryManager; +import org.vmmagic.pragma.Entrypoint; import org.vmmagic.pragma.NonMoving; import org.vmmagic.pragma.Uninterruptible; import org.vmmagic.pragma.Untraced; @@ -36,15 +37,19 @@ /** General purpose registers */ @Untraced + @Entrypoint public final WordArray gprs; /** Floating point registers */ @Untraced + @Entrypoint public final double[] fprs; public final WordArray gprsShadow; public final double[] fprsShadow; /** Instruction address register */ + @Entrypoint public Address ip; /** Frame pointer */ + @Entrypoint public Address fp; /** @@ -52,6 +57,7 @@ * exception handler and RuntimeEntrypoints.athrow and reset by each * implementation of ExceptionDeliverer.deliverException */ + @Entrypoint public boolean inuse; public Registers() { diff --git a/rvm/src/org/jikesrvm/ppc/MultianewarrayHelper.java b/rvm/src/org/jikesrvm/ppc/MultianewarrayHelper.java --- a/rvm/src/org/jikesrvm/ppc/MultianewarrayHelper.java +++ b/rvm/src/org/jikesrvm/ppc/MultianewarrayHelper.java @@ -18,6 +18,7 @@ import org.jikesrvm.classloader.TypeReference; import org.jikesrvm.runtime.Magic; import org.jikesrvm.runtime.RuntimeEntrypoints; +import org.vmmagic.pragma.Entrypoint; import org.vmmagic.unboxed.Address; /** @@ -40,6 +41,7 @@ * be allocated for each dimension. * See also: bytecode 0xc5 ("multianewarray") in Compiler */ + @Entrypoint static Object newArrayArray(int methodId, int numDimensions, int typeId, int argOffset) throws NoClassDefFoundError, NegativeArraySizeException, OutOfMemoryError { if (numDimensions == 2) { diff --git a/rvm/src/org/jikesrvm/ppc/OutOfLineMachineCode.java b/rvm/src/org/jikesrvm/ppc/OutOfLineMachineCode.java --- a/rvm/src/org/jikesrvm/ppc/OutOfLineMachineCode.java +++ b/rvm/src/org/jikesrvm/ppc/OutOfLineMachineCode.java @@ -20,6 +20,7 @@ import org.jikesrvm.objectmodel.ObjectModel; import org.jikesrvm.runtime.ArchEntrypoints; import org.jikesrvm.runtime.Entrypoints; +import org.vmmagic.pragma.Entrypoint; import org.vmmagic.unboxed.Offset; /** @@ -47,21 +48,21 @@ } @SuppressWarnings("unused") - // Accessed via EntryPoints + @Entrypoint private static ArchitectureSpecific.CodeArray reflectiveMethodInvokerInstructions; @SuppressWarnings("unused") - // Accessed via EntryPoints + @Entrypoint private static ArchitectureSpecific.CodeArray saveThreadStateInstructions; @SuppressWarnings("unused") - // Accessed via EntryPoints + @Entrypoint private static ArchitectureSpecific.CodeArray threadSwitchInstructions; @SuppressWarnings("unused") - // Accessed via EntryPoints + @Entrypoint private static ArchitectureSpecific.CodeArray restoreHardwareExceptionStateInstructions; @SuppressWarnings("unused") - // Accessed via EntryPoints + @Entrypoint private static ArchitectureSpecific.CodeArray saveVolatilesInstructions; - // Accessed via EntryPoints + @Entrypoint private static ArchitectureSpecific.CodeArray restoreVolatilesInstructions; /** Machine code for reflective method invocation. diff --git a/rvm/src/org/jikesrvm/ppc/Registers.java b/rvm/src/org/jikesrvm/ppc/Registers.java --- a/rvm/src/org/jikesrvm/ppc/Registers.java +++ b/rvm/src/org/jikesrvm/ppc/Registers.java @@ -17,6 +17,7 @@ import org.jikesrvm.runtime.Magic; import org.jikesrvm.scheduler.RVMThread; import org.jikesrvm.VM; +import org.vmmagic.pragma.Entrypoint; import org.vmmagic.pragma.Uninterruptible; import org.vmmagic.pragma.Untraced; import org.vmmagic.unboxed.Address; @@ -35,12 +36,15 @@ /** word size general purpose registers (either 32 or 64 bit) */ @Untraced + @Entrypoint public final WordArray gprs; @Untraced + @Entrypoint public final double[] fprs; // 64-bit floating point registers public final WordArray gprsShadow; public final double[] fprsShadow; /** instruction address register **/ + @Entrypoint public Address ip; // The following are used by exception delivery. @@ -49,8 +53,10 @@ // They are not used for context switching. // /** link register */ + @Entrypoint public Address lr; /** do exception registers currently contain live values? */ + @Entrypoint public boolean inuse; private static final Address invalidIP = Address.max(); diff --git a/rvm/src/org/jikesrvm/runtime/EntrypointHelper.java b/rvm/src/org/jikesrvm/runtime/EntrypointHelper.java --- a/rvm/src/org/jikesrvm/runtime/EntrypointHelper.java +++ b/rvm/src/org/jikesrvm/runtime/EntrypointHelper.java @@ -22,6 +22,7 @@ import org.jikesrvm.classloader.MethodReference; import org.jikesrvm.classloader.NormalMethod; import org.jikesrvm.classloader.TypeReference; +import org.vmmagic.pragma.Entrypoint; /** * Helper class for retrieving entrypoints. Entrypoints are fields and @@ -52,9 +53,11 @@ RVMMember member; if ((member = cls.findDeclaredField(memName, memDescriptor)) != null) { + verifyPresenceOfEntrypointAnnotation(member); return member; } if ((member = cls.findDeclaredMethod(memName, memDescriptor)) != null) { + verifyPresenceOfEntrypointAnnotation(member); return member; } } catch (Exception e) { @@ -75,6 +78,14 @@ return null; } + private static void verifyPresenceOfEntrypointAnnotation(RVMMember member) { + if (VM.VerifyAssertions && !(member.isAnnotationPresent(Entrypoint.class))) { + String msg = "WARNING: MISSING @Entrypoint ANNOTATION: " + member + + " is missing an @Entrypoint annotation!"; + VM.sysWriteln(msg); + } + } + public static NormalMethod getMethod(String klass, String member, String descriptor, final boolean runtimeServiceMethod) { NormalMethod m = (NormalMethod) getMember(klass, member, descriptor); m.setRuntimeServiceMethod(runtimeServiceMethod); diff --git a/rvm/src/org/jikesrvm/scheduler/RVMThread.java b/rvm/src/org/jikesrvm/scheduler/RVMThread.java --- a/rvm/src/org/jikesrvm/scheduler/RVMThread.java +++ b/rvm/src/org/jikesrvm/scheduler/RVMThread.java @@ -295,9 +295,11 @@ } /** Registers used by return barrier trampoline */ + @Entrypoint private Registers trampolineRegisters = new Registers(); /** Return address of stack frame hijacked by return barrier */ + @Entrypoint private Address hijackedReturnAddress; /** Callee frame pointer for stack frame hijacked by return barrier */ @@ -501,16 +503,19 @@ /** * FP for current frame, saved in the prologue of every method */ + @Entrypoint Address framePointer; /** * "hidden parameter" for interface invocation thru the IMT */ + @Entrypoint int hiddenSignatureId; /** * "hidden parameter" from ArrayIndexOutOfBounds trap to C trap handler */ + @Entrypoint int arrayIndexTrapParam; |
From: <jik...@li...> - 2014-07-12 14:18:56
|
details: http://hg.code.sourceforge.net/p/jikesrvm/code/rev/26e107736866 changeset: 10768:26e107736866 user: Erik Brangs <eri...@gm...> date: Sat Jul 12 15:13:55 2014 +0200 description: RVM-1080 : Use the methods provided by unboxed types to do comparisons and null checks (changes extracted from work on Sapphire by Laurence Hellyer, Carl Ritson and Tomoharu Ugawa). These changes were extracted from the following GitHub commits: - https://github.com/perlfu/sapphire/commit/9650a830a0d8640f37684cf1e097d32ea199283e - https://github.com/perlfu/sapphire/commit/84bc297fdb0b38d68543dbed3fdef59302d24540 - https://github.com/perlfu/sapphire/commit/d122212e179d4b888e643a53d127f9ef207ef6fd details: http://hg.code.sourceforge.net/p/jikesrvm/code/rev/7dbf6a0a7c3b changeset: 10769:7dbf6a0a7c3b user: Erik Brangs <eri...@gm...> date: Sat Jul 12 15:21:24 2014 +0200 description: RVM-1080 : Replace remaining invalid operations on unboxed types with the correct operations. It's likely that these changes were not necessary for Sapphire: the changes to Barriers and Synchronization do not affect IA32 and the change in ScanThread is in an assertion. details: http://hg.code.sourceforge.net/p/jikesrvm/code/rev/defb5b95ab05 changeset: 10770:defb5b95ab05 user: Erik Brangs <eri...@gm...> date: Sat Jul 12 15:26:45 2014 +0200 description: RVM-1080 : Detect invalid operations on unboxed types in the optimizing compiler. It would be preferable to detect invalid operations on unboxed types in a compiler-independent way, e.g. in a bytecode verifier. We currently don't have a suitable component for this. Therefore, I've decided to detect the invalid operations in BC2IR which already contains code for the detection of illegal upcasts of unboxed types. diffstat: MMTk/ext/vm/jikesrvm/org/jikesrvm/mm/mmtk/Barriers.java | 4 +- MMTk/ext/vm/jikesrvm/org/jikesrvm/mm/mmtk/ScanThread.java | 2 +- MMTk/ext/vm/jikesrvm/org/jikesrvm/mm/mmtk/Scanning.java | 2 +- MMTk/src/org/mmtk/policy/Space.java | 2 +- MMTk/src/org/mmtk/utility/gcspy/drivers/TreadmillDriver.java | 2 +- rvm/src/org/jikesrvm/adaptive/measurements/listeners/EdgeListener.java | 4 +- rvm/src/org/jikesrvm/compilers/opt/bc2ir/BC2IR.java | 30 ++++++++++ rvm/src/org/jikesrvm/runtime/DynamicLibrary.java | 4 +- rvm/src/org/jikesrvm/runtime/Memory.java | 8 +- rvm/src/org/jikesrvm/scheduler/Synchronization.java | 4 +- 10 files changed, 46 insertions(+), 16 deletions(-) diffs (204 lines): diff --git a/MMTk/ext/vm/jikesrvm/org/jikesrvm/mm/mmtk/Barriers.java b/MMTk/ext/vm/jikesrvm/org/jikesrvm/mm/mmtk/Barriers.java --- a/MMTk/ext/vm/jikesrvm/org/jikesrvm/mm/mmtk/Barriers.java +++ b/MMTk/ext/vm/jikesrvm/org/jikesrvm/mm/mmtk/Barriers.java @@ -463,7 +463,7 @@ } else { do { Word currentValue = Magic.prepareWord(ref, offset.toOffset()); - if (currentValue != old) return false; + if (currentValue.NE(old)) return false; } while (!Magic.attemptWord(ref, offset.toOffset(), old, target)); return true; } @@ -536,7 +536,7 @@ Address oldValue; do { oldValue = Magic.prepareAddress(objref, offset.toOffset()); - if (oldValue != expected) return false; + if (oldValue.NE(expected)) return false; } while (!Magic.attemptAddress(objref, offset.toOffset(), oldValue, newValue)); return true; } diff --git a/MMTk/ext/vm/jikesrvm/org/jikesrvm/mm/mmtk/ScanThread.java b/MMTk/ext/vm/jikesrvm/org/jikesrvm/mm/mmtk/ScanThread.java --- a/MMTk/ext/vm/jikesrvm/org/jikesrvm/mm/mmtk/ScanThread.java +++ b/MMTk/ext/vm/jikesrvm/org/jikesrvm/mm/mmtk/ScanThread.java @@ -330,7 +330,7 @@ compiledMethod.setActiveOnStack(); ObjectReference code = ObjectReference.fromObject(compiledMethod.getEntryCodeArray()); Address ipLoc = exReg.getIPLocation(); - if (VM.VerifyAssertions) VM._assert(ip == ipLoc.loadAddress()); + if (VM.VerifyAssertions) VM._assert(ip.EQ(ipLoc.loadAddress())); processCodeLocation(code, ipLoc); } } diff --git a/MMTk/ext/vm/jikesrvm/org/jikesrvm/mm/mmtk/Scanning.java b/MMTk/ext/vm/jikesrvm/org/jikesrvm/mm/mmtk/Scanning.java --- a/MMTk/ext/vm/jikesrvm/org/jikesrvm/mm/mmtk/Scanning.java +++ b/MMTk/ext/vm/jikesrvm/org/jikesrvm/mm/mmtk/Scanning.java @@ -135,7 +135,7 @@ } Address linkageTriplets = Magic.objectAsAddress(JNIEnvironment.LinkageTriplets); - if (linkageTriplets != null) { + if (!linkageTriplets.isZero()) { for(int i=start; i < end; i++) { trace.processRootEdge(linkageTriplets.plus(i << LOG_BYTES_IN_ADDRESS), true); } diff --git a/MMTk/src/org/mmtk/policy/Space.java b/MMTk/src/org/mmtk/policy/Space.java --- a/MMTk/src/org/mmtk/policy/Space.java +++ b/MMTk/src/org/mmtk/policy/Space.java @@ -573,7 +573,7 @@ for(Address a = space.headDiscontiguousRegion; !a.isZero(); a = Map.getNextContiguousRegion(a)) { Log.write(a); Log.write("->"); Log.write(a.plus(Map.getContiguousRegionSize(a).minus(1))); - if (Map.getNextContiguousRegion(a) != Address.zero()) + if (!Map.getNextContiguousRegion(a).isZero()) Log.write(", "); } Log.writeln("]"); diff --git a/MMTk/src/org/mmtk/utility/gcspy/drivers/TreadmillDriver.java b/MMTk/src/org/mmtk/utility/gcspy/drivers/TreadmillDriver.java --- a/MMTk/src/org/mmtk/utility/gcspy/drivers/TreadmillDriver.java +++ b/MMTk/src/org/mmtk/utility/gcspy/drivers/TreadmillDriver.java @@ -245,7 +245,7 @@ Address start = subspace.getStart(); int required = countTileNum(start, maxAddr, blockSize); int current = subspace.getBlockNum(); - if (required > current || maxAddr != subspace.getEnd()) { + if (required > current || maxAddr.NE(subspace.getEnd())) { subspace.reset(start, maxAddr, 0, required); allTileNum = required; serverSpace.resize(allTileNum); diff --git a/rvm/src/org/jikesrvm/adaptive/measurements/listeners/EdgeListener.java b/rvm/src/org/jikesrvm/adaptive/measurements/listeners/EdgeListener.java --- a/rvm/src/org/jikesrvm/adaptive/measurements/listeners/EdgeListener.java +++ b/rvm/src/org/jikesrvm/adaptive/measurements/listeners/EdgeListener.java @@ -134,7 +134,7 @@ int callerCMID = 0; Address returnAddress = Address.zero(); - if (sfp.loadAddress() == STACKFRAME_SENTINEL_FP) { + if (sfp.loadAddress().EQ(STACKFRAME_SENTINEL_FP)) { if (DEBUG) VM.sysWrite(" Walking off end of stack!\n"); return; } @@ -151,7 +151,7 @@ returnAddress = Magic.getReturnAddress(sfp); // return address in caller sfp = Magic.getCallerFramePointer(sfp); // caller's frame pointer - if (sfp.loadAddress() == STACKFRAME_SENTINEL_FP) { + if (sfp.loadAddress().EQ(STACKFRAME_SENTINEL_FP)) { if (DEBUG) VM.sysWrite(" Walking off end of stack\n"); return; } diff --git a/rvm/src/org/jikesrvm/compilers/opt/bc2ir/BC2IR.java b/rvm/src/org/jikesrvm/compilers/opt/bc2ir/BC2IR.java --- a/rvm/src/org/jikesrvm/compilers/opt/bc2ir/BC2IR.java +++ b/rvm/src/org/jikesrvm/compilers/opt/bc2ir/BC2IR.java @@ -4297,6 +4297,15 @@ RegisterOperand ref = (RegisterOperand) op0; BranchOperand branch = null; RegisterOperand guard = null; + + // Check for incorrect null checks on unboxed types + if (ref.getType().isUnboxedType()) { + throw new OptimizingCompilerException("Detected incorrect null check of unboxed type in " + + gc.getMethod() + " at bytecode index " + instrIndex + " from class " + + gc.getMethod().getDeclaringClass() + + " . Use the methods provided on the unboxed types to do null checks!"); + } + if (cond.isEQUAL()) { branch = generateTarget(offset); if (ref.getRegister().isLocal()) { @@ -4375,6 +4384,27 @@ return null; } } + + // Check for incorrect comparison operators on unboxed types + if (op0.isRegister()) { + RegisterOperand op0Reg = op0.asRegister(); + if (op0Reg.getType().isUnboxedType()) { + throw new OptimizingCompilerException("Detected incorrect comparison of unboxed types in " + + gc.getMethod() + " at bytecode index " + instrIndex + " from class " + + gc.getMethod().getDeclaringClass() + + " . Use the methods provided on the unboxed types to do comparisons!"); + } + } + if (op1.isRegister()) { + RegisterOperand op1Reg = op1.asRegister(); + if (op1Reg.getType().isUnboxedType()) { + throw new OptimizingCompilerException("Detected incorrect comparison of unboxed types in " + + gc.getMethod() + " at bytecode index " + instrIndex + " from class " + + gc.getMethod().getDeclaringClass() + + " . Use the methods provided on the unboxed types to do comparisons!"); + } + } + fallThrough = true; RegisterOperand guard = gc.getTemps().makeTempValidation(); return IfCmp.create(REF_IFCMP, diff --git a/rvm/src/org/jikesrvm/runtime/DynamicLibrary.java b/rvm/src/org/jikesrvm/runtime/DynamicLibrary.java --- a/rvm/src/org/jikesrvm/runtime/DynamicLibrary.java +++ b/rvm/src/org/jikesrvm/runtime/DynamicLibrary.java @@ -113,7 +113,7 @@ Iterator<DynamicLibrary> libs = dynamicLibraries.valueIterator(); while(libs.hasNext()) { DynamicLibrary lib = libs.next(); - if (lib.jniOnLoad == candidate) { + if (lib.jniOnLoad.EQ(candidate)) { return Address.zero(); } } @@ -129,7 +129,7 @@ Iterator<DynamicLibrary> libs = dynamicLibraries.valueIterator(); while(libs.hasNext()) { DynamicLibrary lib = libs.next(); - if (lib.jniOnUnload == candidate) { + if (lib.jniOnUnload.EQ(candidate)) { return Address.zero(); } } diff --git a/rvm/src/org/jikesrvm/runtime/Memory.java b/rvm/src/org/jikesrvm/runtime/Memory.java --- a/rvm/src/org/jikesrvm/runtime/Memory.java +++ b/rvm/src/org/jikesrvm/runtime/Memory.java @@ -113,8 +113,8 @@ memcopy(dstPtr, srcPtr, copyBytes); } else { if (copyBytes >= BYTES_IN_COPY && - (srcPtr.toWord().and(Word.fromIntZeroExtend(BYTES_IN_COPY - 1)) == - (dstPtr.toWord().and(Word.fromIntZeroExtend(BYTES_IN_COPY - 1))))) { + (srcPtr.toWord().and(Word.fromIntZeroExtend(BYTES_IN_COPY - 1)).EQ( + (dstPtr.toWord().and(Word.fromIntZeroExtend(BYTES_IN_COPY - 1)))))) { // relative alignment is the same Address endPtr = srcPtr.plus(copyBytes); Address wordEndPtr = endPtr.toWord().and(Word.fromIntZeroExtend(BYTES_IN_COPY-1).not()).toAddress(); @@ -223,8 +223,8 @@ memcopy(dstPtr, srcPtr, copyBytes); } else { if (copyBytes >= BYTES_IN_COPY && - (srcPtr.toWord().and(Word.fromIntZeroExtend(BYTES_IN_COPY - 1)) == - (dstPtr.toWord().and(Word.fromIntZeroExtend(BYTES_IN_COPY - 1))))) { + (srcPtr.toWord().and(Word.fromIntZeroExtend(BYTES_IN_COPY - 1)).EQ( + (dstPtr.toWord().and(Word.fromIntZeroExtend(BYTES_IN_COPY - 1)))))) { // relative alignment is the same Address endPtr = srcPtr.plus(copyBytes); Address wordEndPtr = endPtr.toWord().and(Word.fromIntZeroExtend(BYTES_IN_COPY-1).not()).toAddress(); diff --git a/rvm/src/org/jikesrvm/scheduler/Synchronization.java b/rvm/src/org/jikesrvm/scheduler/Synchronization.java --- a/rvm/src/org/jikesrvm/scheduler/Synchronization.java +++ b/rvm/src/org/jikesrvm/scheduler/Synchronization.java @@ -100,7 +100,7 @@ Word oldValue; do { oldValue = Magic.prepareWord(base, offset); - if (oldValue != testValue) return false; + if (oldValue.NE(testValue)) return false; } while (!Magic.attemptWord(base, offset, oldValue, newValue)); return true; } @@ -126,7 +126,7 @@ Address oldValue; do { oldValue = Magic.prepareAddress(base, offset); - if (oldValue != testValue) + if (oldValue.NE(testValue)) return false; } while (!Magic.attemptAddress(base, offset, oldValue, newValue)); return true; |
From: <jik...@li...> - 2014-07-14 16:42:17
|
details: http://hg.code.sourceforge.net/p/jikesrvm/code/rev/b601c8f96e5e changeset: 10778:b601c8f96e5e user: Erik Brangs <eri...@gm...> date: Mon Jul 14 15:23:23 2014 +0200 description: RVM-1079 : Convert BBConstants to a class. details: http://hg.code.sourceforge.net/p/jikesrvm/code/rev/0b95bfdd7179 changeset: 10779:0b95bfdd7179 user: Erik Brangs <eri...@gm...> date: Mon Jul 14 15:44:48 2014 +0200 description: RVM-1079 : Convert the IA32 AssemblerConstants to a class. details: http://hg.code.sourceforge.net/p/jikesrvm/code/rev/a9eca289c599 changeset: 10780:a9eca289c599 user: Erik Brangs <eri...@gm...> date: Mon Jul 14 16:46:48 2014 +0200 description: RVM-1079 : Convert the PPC AssemblerConstants to a class. diffstat: rvm/src-generated/ia32-assembler/Assembler.in | 4 +- rvm/src/org/jikesrvm/compilers/baseline/BBConstants.java | 56 +- rvm/src/org/jikesrvm/compilers/baseline/BuildBB.java | 2 +- rvm/src/org/jikesrvm/compilers/baseline/BuildReferenceMaps.java | 7 +- rvm/src/org/jikesrvm/compilers/baseline/ia32/BaselineCompilerImpl.java | 257 +++++---- rvm/src/org/jikesrvm/compilers/baseline/ia32/BaselineMagic.java | 101 ++- rvm/src/org/jikesrvm/compilers/baseline/ppc/BaselineCompilerImpl.java | 24 +- rvm/src/org/jikesrvm/compilers/common/assembler/ia32/AssemblerConstants.java | 48 +- rvm/src/org/jikesrvm/compilers/common/assembler/ppc/Assembler.java | 9 +- rvm/src/org/jikesrvm/compilers/common/assembler/ppc/AssemblerConstants.java | 18 +- rvm/src/org/jikesrvm/compilers/opt/ir/operand/ia32/IA32ConditionOperand.java | 21 +- rvm/src/org/jikesrvm/compilers/opt/mir2mc/ia32/AssemblerBase.java | 17 +- rvm/src/org/jikesrvm/ia32/InterfaceMethodConflictResolver.java | 7 +- rvm/src/org/jikesrvm/ia32/OutOfLineMachineCode.java | 32 +- rvm/src/org/jikesrvm/jni/ia32/JNICompiler.java | 10 +- rvm/src/org/jikesrvm/jni/ppc/JNICompiler.java | 15 +- rvm/src/org/jikesrvm/ppc/InterfaceMethodConflictResolver.java | 6 +- rvm/src/org/jikesrvm/ppc/OutOfLineMachineCode.java | 5 +- 18 files changed, 362 insertions(+), 277 deletions(-) diffs (truncated from 2042 to 300 lines): diff --git a/rvm/src-generated/ia32-assembler/Assembler.in b/rvm/src-generated/ia32-assembler/Assembler.in --- a/rvm/src-generated/ia32-assembler/Assembler.in +++ b/rvm/src-generated/ia32-assembler/Assembler.in @@ -12,6 +12,8 @@ */ package org.jikesrvm.compilers.common.assembler.ia32; +import static org.jikesrvm.compilers.common.assembler.ia32.AssemblerConstants.*; + import org.jikesrvm.*; import org.jikesrvm.runtime.Magic; import org.jikesrvm.compilers.baseline.ia32.BaselineCompilerImpl; @@ -179,7 +181,7 @@ * @see ForwardReference * */ -public abstract class Assembler extends AbstractAssembler implements RegisterConstants, AssemblerConstants { +public abstract class Assembler extends AbstractAssembler implements RegisterConstants { /** * The lister object is used to print generated machine code. diff --git a/rvm/src/org/jikesrvm/compilers/baseline/BBConstants.java b/rvm/src/org/jikesrvm/compilers/baseline/BBConstants.java --- a/rvm/src/org/jikesrvm/compilers/baseline/BBConstants.java +++ b/rvm/src/org/jikesrvm/compilers/baseline/BBConstants.java @@ -17,38 +17,42 @@ * sizes that describe the state of a basic block and its stack * contents on entry. */ -public interface BBConstants { +public final class BBConstants { // first two bits determine the number of Java words making up the // entity - byte LENGTH_MASK = 0x03; + public static final byte LENGTH_MASK = 0x03; - byte VOID_TYPE = 0x00; - byte INT_TYPE = 0x01; - byte ADDRESS_TYPE = 0x02; - byte LONG_TYPE = 0x04; - byte FLOAT_TYPE = 0x08; - byte DOUBLE_TYPE = 0x10; - byte LONGHALF_TYPE = 0x20; + public static final byte VOID_TYPE = 0x00; + public static final byte INT_TYPE = 0x01; + public static final byte ADDRESS_TYPE = 0x02; + public static final byte LONG_TYPE = 0x04; + public static final byte FLOAT_TYPE = 0x08; + public static final byte DOUBLE_TYPE = 0x10; + public static final byte LONGHALF_TYPE = 0x20; - short DUMMYBLOCK = -1; - short STARTBLOCK = 1; - short EXITBLOCK = 2; - short EXCEPTIONHANDLER = -2; + public static final short DUMMYBLOCK = -1; + public static final short STARTBLOCK = 1; + public static final short EXITBLOCK = 2; + public static final short EXCEPTIONHANDLER = -2; - byte TARGET_ = 0x10; - byte CONDITIONAL_ = 0x20; - byte FALLTHRU_ = 0x40; - byte TRYSTART_ = (byte) 0x80; + public static final byte TARGET_ = 0x10; + public static final byte CONDITIONAL_ = 0x20; + public static final byte FALLTHRU_ = 0x40; + public static final byte TRYSTART_ = (byte) 0x80; - byte NOTBLOCK = 0x0; - byte INJSR_ = 0x1; - byte JSRENTRY = 0x2; - byte TRYHANDLERSTART = 0x4; - byte HASHANDLER_ = 0x8; - byte METHODENTRY = TARGET_; - byte CONDITIONALTARGET = TARGET_ | CONDITIONAL_; - byte UNCONDITIONALTARGET = TARGET_; - byte FALLTHRUTARGET = TARGET_ | CONDITIONAL_ | FALLTHRU_; + public static final byte NOTBLOCK = 0x0; + public static final byte INJSR_ = 0x1; + public static final byte JSRENTRY = 0x2; + public static final byte TRYHANDLERSTART = 0x4; + public static final byte HASHANDLER_ = 0x8; + public static final byte METHODENTRY = TARGET_; + public static final byte CONDITIONALTARGET = TARGET_ | CONDITIONAL_; + public static final byte UNCONDITIONALTARGET = TARGET_; + public static final byte FALLTHRUTARGET = TARGET_ | CONDITIONAL_ | FALLTHRU_; + + private BBConstants() { + // prevent instantiation + } } diff --git a/rvm/src/org/jikesrvm/compilers/baseline/BuildBB.java b/rvm/src/org/jikesrvm/compilers/baseline/BuildBB.java --- a/rvm/src/org/jikesrvm/compilers/baseline/BuildBB.java +++ b/rvm/src/org/jikesrvm/compilers/baseline/BuildBB.java @@ -24,7 +24,7 @@ * basic blocks. Used for building the reference maps for a * method. */ -final class BuildBB implements BBConstants { +final class BuildBB { // ---------------- Static Class Fields -------------------- diff --git a/rvm/src/org/jikesrvm/compilers/baseline/BuildReferenceMaps.java b/rvm/src/org/jikesrvm/compilers/baseline/BuildReferenceMaps.java --- a/rvm/src/org/jikesrvm/compilers/baseline/BuildReferenceMaps.java +++ b/rvm/src/org/jikesrvm/compilers/baseline/BuildReferenceMaps.java @@ -15,6 +15,11 @@ import static org.jikesrvm.classloader.BytecodeConstants.*; import static org.jikesrvm.classloader.ClassLoaderConstants.CP_CLASS; import static org.jikesrvm.classloader.ClassLoaderConstants.CP_STRING; +import static org.jikesrvm.compilers.baseline.BBConstants.ADDRESS_TYPE; +import static org.jikesrvm.compilers.baseline.BBConstants.DOUBLE_TYPE; +import static org.jikesrvm.compilers.baseline.BBConstants.FLOAT_TYPE; +import static org.jikesrvm.compilers.baseline.BBConstants.INT_TYPE; +import static org.jikesrvm.compilers.baseline.BBConstants.LONG_TYPE; import org.jikesrvm.ArchitectureSpecific.BaselineCompilerImpl; import org.jikesrvm.VM; @@ -35,7 +40,7 @@ * java operand stack or a C-like stack?; when processing java bytecodes it * seemed best to use "stack" for java operand stack.) */ -final class BuildReferenceMaps implements BBConstants { +final class BuildReferenceMaps { /** * The entry in the reference map contains a value that is not a reference. diff --git a/rvm/src/org/jikesrvm/compilers/baseline/ia32/BaselineCompilerImpl.java b/rvm/src/org/jikesrvm/compilers/baseline/ia32/BaselineCompilerImpl.java --- a/rvm/src/org/jikesrvm/compilers/baseline/ia32/BaselineCompilerImpl.java +++ b/rvm/src/org/jikesrvm/compilers/baseline/ia32/BaselineCompilerImpl.java @@ -14,6 +14,7 @@ import static org.jikesrvm.classloader.ClassLoaderConstants.CP_CLASS; import static org.jikesrvm.classloader.ClassLoaderConstants.CP_STRING; +import static org.jikesrvm.compilers.common.assembler.ia32.AssemblerConstants.*; import static org.jikesrvm.mm.mminterface.Barriers.*; import org.jikesrvm.SizeConstants; @@ -469,7 +470,7 @@ asm.emitPOP_Reg(S0); // S0 is array ref genBoundsCheck(asm, T0, S0); // T0 is index, S0 is address of array // push [S0+T0<<2] - asm.emitPUSH_RegIdx(S0, T0, Assembler.WORD, NO_SLOT); + asm.emitPUSH_RegIdx(S0, T0, WORD, NO_SLOT); } @Override @@ -500,9 +501,9 @@ genBoundsCheck(asm, T0, S0); // T0 is index, S0 is address of array // T1 = (int)[S0+T0<<1] if (VM.BuildFor32Addr) { - asm.emitMOVZX_Reg_RegIdx_Word(T1, S0, T0, Assembler.SHORT, NO_SLOT); + asm.emitMOVZX_Reg_RegIdx_Word(T1, S0, T0, SHORT, NO_SLOT); } else { - asm.emitMOVZXQ_Reg_RegIdx_Word(T1, S0, T0, Assembler.SHORT, NO_SLOT); + asm.emitMOVZXQ_Reg_RegIdx_Word(T1, S0, T0, SHORT, NO_SLOT); } asm.emitPUSH_Reg(T1); // push short onto stack } @@ -514,9 +515,9 @@ genBoundsCheck(asm, T0, S0); // T0 is index, S0 is address of array // T1 = (int)[S0+T0<<1] if (VM.BuildFor32Addr) { - asm.emitMOVSX_Reg_RegIdx_Word(T1, S0, T0, Assembler.SHORT, NO_SLOT); + asm.emitMOVSX_Reg_RegIdx_Word(T1, S0, T0, SHORT, NO_SLOT); } else { - asm.emitMOVSXQ_Reg_RegIdx_Word(T1, S0, T0, Assembler.SHORT, NO_SLOT); + asm.emitMOVSXQ_Reg_RegIdx_Word(T1, S0, T0, SHORT, NO_SLOT); } asm.emitPUSH_Reg(T1); // push short onto stack } @@ -528,9 +529,9 @@ genBoundsCheck(asm, T0, S0); // T0 is index, S0 is address of array // T1 = (int)[S0+T0<<1] if (VM.BuildFor32Addr) { - asm.emitMOVSX_Reg_RegIdx_Byte(T1, S0, T0, Assembler.BYTE, NO_SLOT); + asm.emitMOVSX_Reg_RegIdx_Byte(T1, S0, T0, BYTE, NO_SLOT); } else { - asm.emitMOVSXQ_Reg_RegIdx_Byte(T1, S0, T0, Assembler.BYTE, NO_SLOT); + asm.emitMOVSXQ_Reg_RegIdx_Byte(T1, S0, T0, BYTE, NO_SLOT); } asm.emitPUSH_Reg(T1); // push byte onto stack } @@ -545,15 +546,15 @@ genBoundsCheck(asm, T0, T1); // T0 is index, T1 is address of array if (VM.BuildFor32Addr) { if (SSE2_BASE) { - asm.emitMOVQ_Reg_RegIdx(XMM0, T1, T0, Assembler.LONG, NO_SLOT); + asm.emitMOVQ_Reg_RegIdx(XMM0, T1, T0, LONG, NO_SLOT); asm.emitMOVQ_RegInd_Reg(SP, XMM0); } else { - asm.emitPUSH_RegIdx(T1, T0, Assembler.LONG, ONE_SLOT); // load high part of desired long array element - asm.emitPUSH_RegIdx(T1, T0, Assembler.LONG, NO_SLOT); // load low part of desired long array element + asm.emitPUSH_RegIdx(T1, T0, LONG, ONE_SLOT); // load high part of desired long array element + asm.emitPUSH_RegIdx(T1, T0, LONG, NO_SLOT); // load low part of desired long array element } } else { adjustStack(-WORDSIZE, true); - asm.emitPUSH_RegIdx(T1, T0, Assembler.LONG, NO_SLOT); // load desired long array element + asm.emitPUSH_RegIdx(T1, T0, LONG, NO_SLOT); // load desired long array element } } @@ -588,7 +589,7 @@ asm.emitPOP_Reg(S0); // S0 is array ref genBoundsCheck(asm, T0, S0); // T0 is index, S0 is address of array // store halfword element into array i.e. [S0 +T0] <- T1 (halfword) - asm.emitMOV_RegIdx_Reg_Word(S0, T0, Assembler.SHORT, NO_SLOT, T1); + asm.emitMOV_RegIdx_Reg_Word(S0, T0, SHORT, NO_SLOT, T1); } /** @@ -600,7 +601,7 @@ asm.emitPOP_Reg(T0); // T0 is array index asm.emitPOP_Reg(S0); // S0 is array ref genBoundsCheck(asm, T0, S0); // T0 is index, S0 is address of array - asm.emitMOV_RegIdx_Reg(S0, T0, Assembler.WORD, NO_SLOT, T1); // [S0 + T0<<2] <- T1 + asm.emitMOV_RegIdx_Reg(S0, T0, WORD, NO_SLOT, T1); // [S0 + T0<<2] <- T1 } /** @@ -628,17 +629,17 @@ genBoundsCheck(asm, T0, S0); // T0 is index, S0 is address of array if (VM.BuildFor32Addr) { if (SSE2_BASE) { - asm.emitMOVQ_RegIdx_Reg(S0, T0, Assembler.LONG, NO_SLOT, XMM0); // [S0+T0<<<3] <- XMM0 + asm.emitMOVQ_RegIdx_Reg(S0, T0, LONG, NO_SLOT, XMM0); // [S0+T0<<<3] <- XMM0 } else { // [S0 + T0<<3 + 0] <- T1 store low part into array - asm.emitMOV_RegIdx_Reg(S0, T0, Assembler.LONG, NO_SLOT, T1); + asm.emitMOV_RegIdx_Reg(S0, T0, LONG, NO_SLOT, T1); asm.emitMOV_Reg_RegDisp(T1, SP, ONE_SLOT); // high part of long value // [S0 + T0<<3 + 4] <- T1 store high part into array adjustStack(WORDSIZE * 4, false); // remove index and ref from the stack - asm.emitMOV_RegIdx_Reg(S0, T0, Assembler.LONG, ONE_SLOT, T1); + asm.emitMOV_RegIdx_Reg(S0, T0, LONG, ONE_SLOT, T1); } } else { - asm.emitMOV_RegIdx_Reg_Quad(S0, T0, Assembler.LONG, NO_SLOT, T1); // [S0+T0<<<3] <- T1 + asm.emitMOV_RegIdx_Reg_Quad(S0, T0, LONG, NO_SLOT, T1); // [S0+T0<<<3] <- T1 } } @@ -710,7 +711,7 @@ asm.emitPOP_Reg(T0); // T0 is array index asm.emitPOP_Reg(S0); // S0 is array ref genBoundsCheck(asm, T0, S0); // T0 is index, S0 is address of array - asm.emitMOV_RegIdx_Reg_Byte(S0, T0, Assembler.BYTE, NO_SLOT, T1); // [S0 + T0<<2] <- T1 + asm.emitMOV_RegIdx_Reg_Byte(S0, T0, BYTE, NO_SLOT, T1); // [S0 + T0<<2] <- T1 } } @@ -983,7 +984,7 @@ // EDX = multiplier low asm.emitMOV_Reg_RegInd(EDX, SP); // Jump if we need a 64bit multiply - ForwardReference fr1 = asm.forwardJcc(Assembler.NE); + ForwardReference fr1 = asm.forwardJcc(NE); // EDX:EAX = 32bit multiply of multiplier and multiplicand low asm.emitMUL_Reg_Reg(EAX, EDX); // Jump over 64bit multiply @@ -1022,7 +1023,7 @@ asm.emitMOV_Reg_RegInd(T0, SP); asm.emitOR_Reg_RegDisp(T0, SP, ONE_SLOT); asm.emitBranchLikelyNextInstruction(); - ForwardReference fr1 = asm.forwardJcc(Assembler.NE); + ForwardReference fr1 = asm.forwardJcc(NE); asm.emitINT_Imm(RuntimeEntrypoints.TRAP_DIVIDE_BY_ZERO + RVM_TRAP_BASE); // trap if divisor is 0 fr1.resolve(asm); // (2) save RVM nonvolatiles @@ -1067,7 +1068,7 @@ asm.emitMOV_Reg_RegInd(T0, SP); asm.emitOR_Reg_RegDisp(T0, SP, ONE_SLOT); asm.emitBranchLikelyNextInstruction(); - ForwardReference fr1 = asm.forwardJcc(Assembler.NE); + ForwardReference fr1 = asm.forwardJcc(NE); asm.emitINT_Imm(RuntimeEntrypoints.TRAP_DIVIDE_BY_ZERO + RVM_TRAP_BASE); // trap if divisor is 0 fr1.resolve(asm); // (2) save RVM nonvolatiles @@ -1135,7 +1136,7 @@ asm.emitPOP_Reg(T0); // pop low half asm.emitPOP_Reg(T1); // pop high half asm.emitTEST_Reg_Imm(ECX, 32); - ForwardReference fr1 = asm.forwardJcc(Assembler.NE); + ForwardReference fr1 = asm.forwardJcc(NE); asm.emitSHLD_Reg_Reg_Reg(T1, T0, ECX); // shift high half asm.emitSHL_Reg_Reg(T0, ECX); // shift low half ForwardReference fr2 = asm.forwardJMP(); @@ -1162,7 +1163,7 @@ asm.emitPOP_Reg(T0); // pop low half asm.emitPOP_Reg(T1); // pop high half asm.emitTEST_Reg_Imm(ECX, 32); - ForwardReference fr1 = asm.forwardJcc(Assembler.NE); + ForwardReference fr1 = asm.forwardJcc(NE); asm.emitSHRD_Reg_Reg_Reg(T0, T1, ECX); // shift high half asm.emitSAR_Reg_Reg(T1, ECX); // shift low half ForwardReference fr2 = asm.forwardJMP(); @@ -1196,7 +1197,7 @@ |
From: <jik...@li...> - 2014-07-16 17:36:24
|
details: http://hg.code.sourceforge.net/p/jikesrvm/code/rev/7fff6fc82fc8 changeset: 10787:7fff6fc82fc8 user: Erik Brangs <eri...@gm...> date: Wed Jul 16 17:03:31 2014 +0200 description: RVM-174 : Remove TrapConstants from ArchitectureSpecific. TrapConstants is currently part of ArchitectureSpecific but not used via ArchitectureSpecific on either IA32 or PPC. We want to phase out ArchitectureSpecific so it's best to remove TrapConstants from ArchitectureSpecific before a dependency on it is introduced. details: http://hg.code.sourceforge.net/p/jikesrvm/code/rev/a3db46c9ca04 changeset: 10788:a3db46c9ca04 user: Erik Brangs <eri...@gm...> date: Wed Jul 16 17:09:00 2014 +0200 description: RVM-1079 : Convert IA32 TrapConstants to a class. details: http://hg.code.sourceforge.net/p/jikesrvm/code/rev/8110264a06a1 changeset: 10789:8110264a06a1 user: Erik Brangs <eri...@gm...> date: Wed Jul 16 18:20:31 2014 +0200 description: RVM-1079 : Convert PPC TrapConstants to a class. diffstat: rvm/src-generated/vm-configuration/ArchitectureSpecific.template | 1 - rvm/src/org/jikesrvm/compilers/baseline/ia32/BaselineCompilerImpl.java | 1 + rvm/src/org/jikesrvm/ia32/ArchConstants.java | 2 +- rvm/src/org/jikesrvm/ia32/OutOfLineMachineCode.java | 1 + rvm/src/org/jikesrvm/ia32/TrapConstants.java | 8 +- rvm/src/org/jikesrvm/ppc/ArchConstants.java | 2 +- rvm/src/org/jikesrvm/ppc/TrapConstants.java | 60 +++++---- rvm/src/org/jikesrvm/tools/header_gen/GenArch_ppc.java | 55 ++++---- 8 files changed, 71 insertions(+), 59 deletions(-) diffs (237 lines): diff --git a/rvm/src-generated/vm-configuration/ArchitectureSpecific.template b/rvm/src-generated/vm-configuration/ArchitectureSpecific.template --- a/rvm/src-generated/vm-configuration/ArchitectureSpecific.template +++ b/rvm/src-generated/vm-configuration/ArchitectureSpecific.template @@ -66,7 +66,6 @@ @NonMoving public static final class Registers extends org.jikesrvm.@_ARCH_@.Registers {} public interface StackframeLayoutConstants extends org.jikesrvm.@_ARCH_@.StackframeLayoutConstants {} - public interface TrapConstants extends org.jikesrvm.@_ARCH_@.TrapConstants {} public static final class JNICompiler extends org.jikesrvm.jni.@_ARCH_@.JNICompiler {} public static final class JNIGCMapIterator extends org.jikesrvm.jni.@_ARCH_@.JNIGCMapIterator { public JNIGCMapIterator(WordArray registerLocations) { diff --git a/rvm/src/org/jikesrvm/compilers/baseline/ia32/BaselineCompilerImpl.java b/rvm/src/org/jikesrvm/compilers/baseline/ia32/BaselineCompilerImpl.java --- a/rvm/src/org/jikesrvm/compilers/baseline/ia32/BaselineCompilerImpl.java +++ b/rvm/src/org/jikesrvm/compilers/baseline/ia32/BaselineCompilerImpl.java @@ -15,6 +15,7 @@ import static org.jikesrvm.classloader.ClassLoaderConstants.CP_CLASS; import static org.jikesrvm.classloader.ClassLoaderConstants.CP_STRING; import static org.jikesrvm.compilers.common.assembler.ia32.AssemblerConstants.*; +import static org.jikesrvm.ia32.TrapConstants.RVM_TRAP_BASE; import static org.jikesrvm.mm.mminterface.Barriers.*; import static org.jikesrvm.objectmodel.TIBLayoutConstants.NEEDS_DYNAMIC_LINK; import static org.jikesrvm.objectmodel.TIBLayoutConstants.TIB_DOES_IMPLEMENT_INDEX; diff --git a/rvm/src/org/jikesrvm/ia32/ArchConstants.java b/rvm/src/org/jikesrvm/ia32/ArchConstants.java --- a/rvm/src/org/jikesrvm/ia32/ArchConstants.java +++ b/rvm/src/org/jikesrvm/ia32/ArchConstants.java @@ -17,7 +17,7 @@ /** * Architecture specific constants. */ -public interface ArchConstants extends StackframeLayoutConstants, RegisterConstants, TrapConstants { +public interface ArchConstants extends StackframeLayoutConstants, RegisterConstants { boolean SSE2_BASE = Configuration.BuildForSSE2; boolean SSE2_FULL = Configuration.BuildForSSE2Full; } diff --git a/rvm/src/org/jikesrvm/ia32/OutOfLineMachineCode.java b/rvm/src/org/jikesrvm/ia32/OutOfLineMachineCode.java --- a/rvm/src/org/jikesrvm/ia32/OutOfLineMachineCode.java +++ b/rvm/src/org/jikesrvm/ia32/OutOfLineMachineCode.java @@ -14,6 +14,7 @@ import static org.jikesrvm.compilers.common.assembler.ia32.AssemblerConstants.EQ; import static org.jikesrvm.compilers.common.assembler.ia32.AssemblerConstants.NE; +import static org.jikesrvm.ia32.TrapConstants.RVM_TRAP_BASE; import static org.jikesrvm.runtime.RuntimeEntrypoints.TRAP_UNKNOWN; import org.jikesrvm.ArchitectureSpecific; diff --git a/rvm/src/org/jikesrvm/ia32/TrapConstants.java b/rvm/src/org/jikesrvm/ia32/TrapConstants.java --- a/rvm/src/org/jikesrvm/ia32/TrapConstants.java +++ b/rvm/src/org/jikesrvm/ia32/TrapConstants.java @@ -15,12 +15,16 @@ /** * Trap constants for IA32 platform. */ -public interface TrapConstants { +public final class TrapConstants { /** * This base is added to the numeric trap codes in RuntimeEntrypoints.java * to yield the intel trap number that is given to INT instructions */ - byte RVM_TRAP_BASE = (byte) 0x40; + public static final byte RVM_TRAP_BASE = (byte) 0x40; + + private TrapConstants() { + // prevent instantiation + } } diff --git a/rvm/src/org/jikesrvm/ppc/ArchConstants.java b/rvm/src/org/jikesrvm/ppc/ArchConstants.java --- a/rvm/src/org/jikesrvm/ppc/ArchConstants.java +++ b/rvm/src/org/jikesrvm/ppc/ArchConstants.java @@ -15,5 +15,5 @@ /** * Architecture specific constants. */ -public interface ArchConstants extends StackframeLayoutConstants, RegisterConstants, TrapConstants { +public interface ArchConstants extends StackframeLayoutConstants, RegisterConstants { } diff --git a/rvm/src/org/jikesrvm/ppc/TrapConstants.java b/rvm/src/org/jikesrvm/ppc/TrapConstants.java --- a/rvm/src/org/jikesrvm/ppc/TrapConstants.java +++ b/rvm/src/org/jikesrvm/ppc/TrapConstants.java @@ -15,7 +15,7 @@ /** * Trap Conventions */ -public interface TrapConstants { +public final class TrapConstants { //--------------------------------------------------------------------------------------------// // Trap Conventions. // //--------------------------------------------------------------------------------------------// @@ -24,32 +24,38 @@ // values in order for traps to be correctly recognized by the trap handler // in libvm.C // - int DIVIDE_BY_ZERO_MASK = 0xFBE0FFFF; // opcode, condition mask, & immediate - int DIVIDE_BY_ZERO_TRAP = 0x08800000; // teqi, divisor, 0 - int ARRAY_INDEX_MASK = 0xFFE007FE; // extended opcode and condition mask - int ARRAY_INDEX_TRAP = 0x7CC00008; // tlle arraySize, arrayIndex - int ARRAY_INDEX_REG_MASK = 0x0000f800; - int ARRAY_INDEX_REG_SHIFT = 11; - int CONSTANT_ARRAY_INDEX_MASK = 0xFFE00000; // opcode and condition mask - int CONSTANT_ARRAY_INDEX_TRAP = 0x0CC00000; // tllei arraySize, arrayIndexConstant - int CONSTANT_ARRAY_INDEX_INFO = 0x0000ffff; - int STACK_OVERFLOW_MASK = 0xFFE0077E; // opcode and condition mask - int STACK_OVERFLOW_TRAP = 0x7E000008; // tlt stackPointer, stackLimit - int STACK_OVERFLOW_HAVE_FRAME_TRAP = 0x7D000008; // tgt stackLimit, stackPointer - int WRITE_BUFFER_OVERFLOW_MASK = 0xFFE0077E; // opcode and condition mask - int WRITE_BUFFER_OVERFLOW_TRAP = 0x7E800008; // tle modifiedOldObjectMax, modifiedOldObjectAddr + public static final int DIVIDE_BY_ZERO_MASK = 0xFBE0FFFF; // opcode, condition mask, & immediate + public static final int DIVIDE_BY_ZERO_TRAP = 0x08800000; // teqi, divisor, 0 + public static final int ARRAY_INDEX_MASK = 0xFFE007FE; // extended opcode and condition mask + public static final int ARRAY_INDEX_TRAP = 0x7CC00008; // tlle arraySize, arrayIndex + public static final int ARRAY_INDEX_REG_MASK = 0x0000f800; + public static final int ARRAY_INDEX_REG_SHIFT = 11; + public static final int CONSTANT_ARRAY_INDEX_MASK = 0xFFE00000; // opcode and condition mask + public static final int CONSTANT_ARRAY_INDEX_TRAP = 0x0CC00000; // tllei arraySize, arrayIndexConstant + public static final int CONSTANT_ARRAY_INDEX_INFO = 0x0000ffff; + public static final int STACK_OVERFLOW_MASK = 0xFFE0077E; // opcode and condition mask + public static final int STACK_OVERFLOW_TRAP = 0x7E000008; // tlt stackPointer, stackLimit + public static final int STACK_OVERFLOW_HAVE_FRAME_TRAP = 0x7D000008; // tgt stackLimit, stackPointer + public static final int WRITE_BUFFER_OVERFLOW_MASK = 0xFFE0077E; // opcode and condition mask + public static final int WRITE_BUFFER_OVERFLOW_TRAP = 0x7E800008; // tle modifiedOldObjectMax, modifiedOldObjectAddr - /* JNI stack size checking */ int JNI_STACK_TRAP_MASK = 0x0BECFFFF; // tALWAYSi, 12, 0x0001 - int JNI_STACK_TRAP = 0x0BEC0001; + /* JNI stack size checking */ + public static final int JNI_STACK_TRAP_MASK = 0x0BECFFFF; // tALWAYSi, 12, 0x0001 + public static final int JNI_STACK_TRAP = 0x0BEC0001; - /* USED BY THE OPT COMPILER */ int CHECKCAST_MASK = 0x0BECFFFF; // tALWAYSi, 12, 0x0000 - int CHECKCAST_TRAP = 0x0BEC0000; - int MUST_IMPLEMENT_MASK = 0x0BECFFFF; // tALWAYSi, 12, 0x0002 - int MUST_IMPLEMENT_TRAP = 0x0BEC0002; - int STORE_CHECK_MASK = 0x0BECFFFF; // tALWAYSi, 12, 0x0003 - int STORE_CHECK_TRAP = 0x0BEC0003; - int REGENERATE_MASK = 0xFFE0077E; - int REGENERATE_TRAP = 0x7C600008; // tlne - int NULLCHECK_MASK = 0xFBE0FFFF; - int NULLCHECK_TRAP = 0x08400001; // tllt 1 + /* USED BY THE OPT COMPILER */ + public static final int CHECKCAST_MASK = 0x0BECFFFF; // tALWAYSi, 12, 0x0000 + public static final int CHECKCAST_TRAP = 0x0BEC0000; + public static final int MUST_IMPLEMENT_MASK = 0x0BECFFFF; // tALWAYSi, 12, 0x0002 + public static final int MUST_IMPLEMENT_TRAP = 0x0BEC0002; + public static final int STORE_CHECK_MASK = 0x0BECFFFF; // tALWAYSi, 12, 0x0003 + public static final int STORE_CHECK_TRAP = 0x0BEC0003; + public static final int REGENERATE_MASK = 0xFFE0077E; + public static final int REGENERATE_TRAP = 0x7C600008; // tlne + public static final int NULLCHECK_MASK = 0xFBE0FFFF; + public static final int NULLCHECK_TRAP = 0x08400001; // tllt 1 + + private TrapConstants() { + // prevent instantiation + } } diff --git a/rvm/src/org/jikesrvm/tools/header_gen/GenArch_ppc.java b/rvm/src/org/jikesrvm/tools/header_gen/GenArch_ppc.java --- a/rvm/src/org/jikesrvm/tools/header_gen/GenArch_ppc.java +++ b/rvm/src/org/jikesrvm/tools/header_gen/GenArch_ppc.java @@ -12,11 +12,12 @@ */ package org.jikesrvm.tools.header_gen; +import static org.jikesrvm.ppc.TrapConstants.*; + import org.jikesrvm.VM; import org.jikesrvm.ppc.BaselineConstants; import org.jikesrvm.ppc.RegisterConstants; import org.jikesrvm.ppc.StackframeLayoutConstants; -import org.jikesrvm.ppc.TrapConstants; import org.jikesrvm.runtime.ArchEntrypoints; import org.vmmagic.unboxed.Offset; @@ -36,39 +37,39 @@ p("static const int Constants_FRAME_POINTER = " + RegisterConstants.FRAME_POINTER + ";\n"); p("static const int Constants_THREAD_REGISTER = " + RegisterConstants.THREAD_REGISTER + ";\n"); p("static const int Constants_FIRST_VOLATILE_GPR = " + RegisterConstants.FIRST_VOLATILE_GPR + ";\n"); - p("static const int Constants_DIVIDE_BY_ZERO_MASK = " + TrapConstants.DIVIDE_BY_ZERO_MASK + ";\n"); - p("static const int Constants_DIVIDE_BY_ZERO_TRAP = " + TrapConstants.DIVIDE_BY_ZERO_TRAP + ";\n"); - p("static const int Constants_MUST_IMPLEMENT_MASK = " + TrapConstants.MUST_IMPLEMENT_MASK + ";\n"); - p("static const int Constants_MUST_IMPLEMENT_TRAP = " + TrapConstants.MUST_IMPLEMENT_TRAP + ";\n"); - p("static const int Constants_STORE_CHECK_MASK = " + TrapConstants.STORE_CHECK_MASK + ";\n"); - p("static const int Constants_STORE_CHECK_TRAP = " + TrapConstants.STORE_CHECK_TRAP + ";\n"); - p("static const int Constants_ARRAY_INDEX_MASK = " + TrapConstants.ARRAY_INDEX_MASK + ";\n"); - p("static const int Constants_ARRAY_INDEX_TRAP = " + TrapConstants.ARRAY_INDEX_TRAP + ";\n"); - p("static const int Constants_ARRAY_INDEX_REG_MASK = " + TrapConstants.ARRAY_INDEX_REG_MASK + ";\n"); - p("static const int Constants_ARRAY_INDEX_REG_SHIFT = " + TrapConstants.ARRAY_INDEX_REG_SHIFT + ";\n"); + p("static const int Constants_DIVIDE_BY_ZERO_MASK = " + DIVIDE_BY_ZERO_MASK + ";\n"); + p("static const int Constants_DIVIDE_BY_ZERO_TRAP = " + DIVIDE_BY_ZERO_TRAP + ";\n"); + p("static const int Constants_MUST_IMPLEMENT_MASK = " + MUST_IMPLEMENT_MASK + ";\n"); + p("static const int Constants_MUST_IMPLEMENT_TRAP = " + MUST_IMPLEMENT_TRAP + ";\n"); + p("static const int Constants_STORE_CHECK_MASK = " + STORE_CHECK_MASK + ";\n"); + p("static const int Constants_STORE_CHECK_TRAP = " + STORE_CHECK_TRAP + ";\n"); + p("static const int Constants_ARRAY_INDEX_MASK = " + ARRAY_INDEX_MASK + ";\n"); + p("static const int Constants_ARRAY_INDEX_TRAP = " + ARRAY_INDEX_TRAP + ";\n"); + p("static const int Constants_ARRAY_INDEX_REG_MASK = " + ARRAY_INDEX_REG_MASK + ";\n"); + p("static const int Constants_ARRAY_INDEX_REG_SHIFT = " + ARRAY_INDEX_REG_MASK + ";\n"); p("static const int Constants_CONSTANT_ARRAY_INDEX_MASK = " + - TrapConstants.CONSTANT_ARRAY_INDEX_MASK + ";\n"); + CONSTANT_ARRAY_INDEX_MASK + ";\n"); p("static const int Constants_CONSTANT_ARRAY_INDEX_TRAP = " + - TrapConstants.CONSTANT_ARRAY_INDEX_TRAP + ";\n"); + CONSTANT_ARRAY_INDEX_TRAP + ";\n"); p("static const int Constants_CONSTANT_ARRAY_INDEX_INFO = " + - TrapConstants.CONSTANT_ARRAY_INDEX_INFO + ";\n"); + CONSTANT_ARRAY_INDEX_INFO + ";\n"); p("static const int Constants_WRITE_BUFFER_OVERFLOW_MASK = " + - TrapConstants.WRITE_BUFFER_OVERFLOW_MASK + ";\n"); + WRITE_BUFFER_OVERFLOW_MASK + ";\n"); p("static const int Constants_WRITE_BUFFER_OVERFLOW_TRAP = " + - TrapConstants.WRITE_BUFFER_OVERFLOW_TRAP + ";\n"); - p("static const int Constants_STACK_OVERFLOW_MASK = " + TrapConstants.STACK_OVERFLOW_MASK + ";\n"); + WRITE_BUFFER_OVERFLOW_TRAP + ";\n"); + p("static const int Constants_STACK_OVERFLOW_MASK = " + STACK_OVERFLOW_MASK + ";\n"); p("static const int Constants_STACK_OVERFLOW_HAVE_FRAME_TRAP = " + - TrapConstants.STACK_OVERFLOW_HAVE_FRAME_TRAP + ";\n"); - p("static const int Constants_STACK_OVERFLOW_TRAP = " + TrapConstants.STACK_OVERFLOW_TRAP + ";\n"); - p("static const int Constants_CHECKCAST_MASK = " + TrapConstants.CHECKCAST_MASK + ";\n"); - p("static const int Constants_CHECKCAST_TRAP = " + TrapConstants.CHECKCAST_TRAP + ";\n"); - p("static const int Constants_REGENERATE_MASK = " + TrapConstants.REGENERATE_MASK + ";\n"); - p("static const int Constants_REGENERATE_TRAP = " + TrapConstants.REGENERATE_TRAP + ";\n"); - p("static const int Constants_NULLCHECK_MASK = " + TrapConstants.NULLCHECK_MASK + ";\n"); - p("static const int Constants_NULLCHECK_TRAP = " + TrapConstants.NULLCHECK_TRAP + ";\n"); + STACK_OVERFLOW_HAVE_FRAME_TRAP + ";\n"); + p("static const int Constants_STACK_OVERFLOW_TRAP = " + STACK_OVERFLOW_TRAP + ";\n"); + p("static const int Constants_CHECKCAST_MASK = " + CHECKCAST_MASK + ";\n"); + p("static const int Constants_CHECKCAST_TRAP = " + CHECKCAST_TRAP + ";\n"); + p("static const int Constants_REGENERATE_MASK = " + REGENERATE_MASK + ";\n"); + p("static const int Constants_REGENERATE_TRAP = " + REGENERATE_TRAP + ";\n"); + p("static const int Constants_NULLCHECK_MASK = " + NULLCHECK_MASK + ";\n"); + p("static const int Constants_NULLCHECK_TRAP = " + NULLCHECK_TRAP + ";\n"); p("static const int Constants_JNI_STACK_TRAP_MASK = " + - TrapConstants.JNI_STACK_TRAP_MASK + ";\n"); - p("static const int Constants_JNI_STACK_TRAP = " + TrapConstants.JNI_STACK_TRAP + ";\n"); + JNI_STACK_TRAP_MASK + ";\n"); + p("static const int Constants_JNI_STACK_TRAP = " + JNI_STACK_TRAP + ";\n"); p("static const int Constants_STACKFRAME_RETURN_ADDRESS_OFFSET = " + StackframeLayoutConstants.STACKFRAME_RETURN_ADDRESS_OFFSET + ";\n"); p("static const int Constants_STACKFRAME_ALIGNMENT = " + |
From: <jik...@li...> - 2014-08-04 09:18:04
|
details: http://hg.code.sourceforge.net/p/jikesrvm/code/rev/5ec4f283ff3e changeset: 10837:5ec4f283ff3e user: Erik Brangs <eri...@gm...> date: Mon Aug 04 10:30:45 2014 +0200 description: Fix JavaDoc warnings in org.jikesrvm.compilers.opt.depgraph. details: http://hg.code.sourceforge.net/p/jikesrvm/code/rev/f14cf6ff215d changeset: 10838:f14cf6ff215d user: Erik Brangs <eri...@gm...> date: Mon Aug 04 10:36:35 2014 +0200 description: RVM-1023 : Add a package comment for org.jikesrvm.compilers.opt.depgraph. details: http://hg.code.sourceforge.net/p/jikesrvm/code/rev/7aa1043a0abb changeset: 10839:7aa1043a0abb user: Erik Brangs <eri...@gm...> date: Mon Aug 04 10:38:29 2014 +0200 description: Change createDepGraphNode(Instruction) to not use a local variable. diffstat: rvm/src/org/jikesrvm/compilers/opt/depgraph/DepGraph.java | 21 ++++++--- rvm/src/org/jikesrvm/compilers/opt/depgraph/DepGraphStats.java | 6 +- rvm/src/org/jikesrvm/compilers/opt/depgraph/package-info.java | 22 ++++++++++ rvm/src/org/jikesrvm/compilers/opt/lir2mir/NormalBURS_DepGraph.java | 3 +- 4 files changed, 41 insertions(+), 11 deletions(-) diffs (121 lines): diff --git a/rvm/src/org/jikesrvm/compilers/opt/depgraph/DepGraph.java b/rvm/src/org/jikesrvm/compilers/opt/depgraph/DepGraph.java --- a/rvm/src/org/jikesrvm/compilers/opt/depgraph/DepGraph.java +++ b/rvm/src/org/jikesrvm/compilers/opt/depgraph/DepGraph.java @@ -108,9 +108,6 @@ } } - /** - * Create the dependency graph nodes for instructions start to end - */ private void createNodes(Instruction start, Instruction end) { for (Instruction p = start; ; p = p.nextInstructionInCodeOrder()) { DepGraphNode pnode = createDepGraphNode(p); @@ -122,13 +119,15 @@ } protected DepGraphNode createDepGraphNode(Instruction p) { - DepGraphNode pnode = new DepGraphNode(p); - return pnode; + return new DepGraphNode(p); } /** - * Compute flow and output dependences by doing a forward + * Computes flow and output dependences by doing a forward * traversal of the instructions from start to end. + * + * @param start start instruction + * @param end end instruction */ private void computeForwardDependences(Instruction start, Instruction end) { boolean readsKill = ir.options.READS_KILL; @@ -210,8 +209,11 @@ } /** - * Compute anti dependences by doing a backwards + * Computse anti dependences by doing a backwards * traversal of the instructions from start to end. + * + * @param start start instruction + * @param end end instruction */ private void computeBackwardDependences(Instruction start, Instruction end) { clearRegisters(start, end); @@ -275,6 +277,9 @@ * Compute control and barrier (acquire/release) dependences * in two passes (one forward, one reverse over the instructions * from start to end. + * + * @param start start instruction + * @param end end instruction */ private void computeControlAndBarrierDependences(Instruction start, Instruction end) { // (1) In a forward pass, we add the following dependences: @@ -508,6 +513,8 @@ /** * Get the location of a given load or store instruction. * @param s the instruction to get the location from. + * + * @return a location or {@code null} */ private LocationOperand getLocation(Instruction s) { // This extra conforms check wouldn't be necessary if the DepGraph diff --git a/rvm/src/org/jikesrvm/compilers/opt/depgraph/DepGraphStats.java b/rvm/src/org/jikesrvm/compilers/opt/depgraph/DepGraphStats.java --- a/rvm/src/org/jikesrvm/compilers/opt/depgraph/DepGraphStats.java +++ b/rvm/src/org/jikesrvm/compilers/opt/depgraph/DepGraphStats.java @@ -116,9 +116,11 @@ } /** - * Return an estimate of the number of cycles for a given instruction. - * Currently, this estimate is comically simple. + * Returns an estimate of the number of cycles for a given instruction. + * Currently, this estimate is comically simple (see below). + * * @param instr the instruction + * @return {@code 0} or {@code 1} */ int estimateExecutionTime(Instruction instr) { if (instr.operator() == NULL_CHECK) { diff --git a/rvm/src/org/jikesrvm/compilers/opt/depgraph/package-info.java b/rvm/src/org/jikesrvm/compilers/opt/depgraph/package-info.java new file mode 100644 --- /dev/null +++ b/rvm/src/org/jikesrvm/compilers/opt/depgraph/package-info.java @@ -0,0 +1,22 @@ +/* + * 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. + */ + +/** + * Provides classes that implement a dependence graph. + * <p> + * Dependence graphs are used during BURS and for instruction scheduling. + * + * @see org.jikesrvm.compilers.opt.instrsched + * @see org.jikesrvm.compilers.opt.lir2mir + */ +package org.jikesrvm.compilers.opt.depgraph; diff --git a/rvm/src/org/jikesrvm/compilers/opt/lir2mir/NormalBURS_DepGraph.java b/rvm/src/org/jikesrvm/compilers/opt/lir2mir/NormalBURS_DepGraph.java --- a/rvm/src/org/jikesrvm/compilers/opt/lir2mir/NormalBURS_DepGraph.java +++ b/rvm/src/org/jikesrvm/compilers/opt/lir2mir/NormalBURS_DepGraph.java @@ -31,8 +31,7 @@ @Override public DepGraphNode createDepGraphNode(Instruction inst) { - DepGraphNode node = new NormalBURS_DepGraphNode(inst); - return node; + return new NormalBURS_DepGraphNode(inst); } } |
From: <jik...@li...> - 2014-08-17 11:39:21
|
details: http://hg.code.sourceforge.net/p/jikesrvm/code/rev/b9a0c9c4dac7 changeset: 10849:b9a0c9c4dac7 user: Erik Brangs <eri...@gm...> date: Sun Aug 17 13:12:41 2014 +0200 description: Make implementation of toString() in LiveSetElement easier to understand. details: http://hg.code.sourceforge.net/p/jikesrvm/code/rev/19e4f3e081e4 changeset: 10850:19e4f3e081e4 user: Erik Brangs <eri...@gm...> date: Sun Aug 17 13:20:40 2014 +0200 description: Minor cleanups in org.jikesrvm.compilers.opt.liveness.LiveAnalysis . details: http://hg.code.sourceforge.net/p/jikesrvm/code/rev/8a9f3da63adf changeset: 10851:8a9f3da63adf user: Erik Brangs <eri...@gm...> date: Sun Aug 17 13:22:09 2014 +0200 description: Remove the unused class IRSummary. diffstat: rvm/src/org/jikesrvm/compilers/opt/ir/IRSummary.java | 40 ---------- rvm/src/org/jikesrvm/compilers/opt/liveness/LiveAnalysis.java | 33 ++----- rvm/src/org/jikesrvm/compilers/opt/liveness/LiveSetElement.java | 5 +- 3 files changed, 11 insertions(+), 67 deletions(-) diffs (129 lines): diff --git a/rvm/src/org/jikesrvm/compilers/opt/ir/IRSummary.java b/rvm/src/org/jikesrvm/compilers/opt/ir/IRSummary.java deleted file mode 100644 --- a/rvm/src/org/jikesrvm/compilers/opt/ir/IRSummary.java +++ /dev/null @@ -1,40 +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.compilers.opt.ir; - -import static org.jikesrvm.compilers.opt.ir.Operators.BOUNDS_CHECK; - -import java.util.Enumeration; - -/** - * General utilities to summarize an IR - */ -public final class IRSummary { - - /** - * @param ir IR to check - * @return {@code true} if this IR has a bounds check expression - */ - public static boolean hasBoundsCheck(IR ir) { - for (Enumeration<Instruction> e = ir.forwardInstrEnumerator(); e.hasMoreElements();) { - Instruction s = e.nextElement(); - if (s.operator == BOUNDS_CHECK) { - return true; - } - } - return false; - } -} - - - diff --git a/rvm/src/org/jikesrvm/compilers/opt/liveness/LiveAnalysis.java b/rvm/src/org/jikesrvm/compilers/opt/liveness/LiveAnalysis.java --- a/rvm/src/org/jikesrvm/compilers/opt/liveness/LiveAnalysis.java +++ b/rvm/src/org/jikesrvm/compilers/opt/liveness/LiveAnalysis.java @@ -347,19 +347,12 @@ * @param r2 new register */ public void merge(Register r1, Register r2) { - ArrayList<LiveIntervalElement> toRemove = new ArrayList<LiveIntervalElement>(5); - - for (Iterator<LiveIntervalElement> i = iterateLiveIntervals(r2); i.hasNext();) { + Iterator<LiveIntervalElement> i = iterateLiveIntervals(r2); + while (i.hasNext()) { LiveIntervalElement interval = i.next(); interval.setRegister(r1); addToRegisterMap(r1, interval); - // defer removing the interval to avoid concurrent modification of - // the iterator's backing set. - toRemove.add(interval); - } - // perform deferred removals - for (LiveIntervalElement interval : toRemove) { - removeFromRegisterMap(r2, interval); + i.remove(); } } @@ -374,10 +367,10 @@ @SuppressWarnings("unchecked") private void computeRegisterMap(IR ir) { registerMap = new ArrayList[ir.regpool.getNumberOfSymbolicRegisters()]; - for (Enumeration e = ir.getBasicBlocks(); e.hasMoreElements();) { - BasicBlock bb = (BasicBlock) e.nextElement(); - for (Enumeration i = bb.enumerateLiveIntervals(); i.hasMoreElements();) { - LiveIntervalElement lie = (LiveIntervalElement) i.nextElement(); + for (Enumeration<BasicBlock> e = ir.getBasicBlocks(); e.hasMoreElements();) { + BasicBlock bb = e.nextElement(); + for (Enumeration<LiveIntervalElement> i = bb.enumerateLiveIntervals(); i.hasMoreElements();) { + LiveIntervalElement lie = i.nextElement(); lie.setBasicBlock(bb); if (lie.getRegister().isSymbolic()) { addToRegisterMap(lie.getRegister(), lie); @@ -387,21 +380,15 @@ } private void addToRegisterMap(Register r, LiveIntervalElement i) { - ArrayList<LiveIntervalElement> set = registerMap[r.getNumber()]; + int regNumber = r.getNumber(); + ArrayList<LiveIntervalElement> set = registerMap[regNumber]; if (set == null) { set = new ArrayList<LiveIntervalElement>(3); - registerMap[r.getNumber()] = set; + registerMap[regNumber] = set; } set.add(i); } - private void removeFromRegisterMap(Register r, LiveIntervalElement i) { - ArrayList<LiveIntervalElement> set = registerMap[r.getNumber()]; - if (set != null) { - set.remove(i); - } - } - /** * Compute summary (local) live variable analysis for a basic block, which * is basically Gen and Kill information.<p> diff --git a/rvm/src/org/jikesrvm/compilers/opt/liveness/LiveSetElement.java b/rvm/src/org/jikesrvm/compilers/opt/liveness/LiveSetElement.java --- a/rvm/src/org/jikesrvm/compilers/opt/liveness/LiveSetElement.java +++ b/rvm/src/org/jikesrvm/compilers/opt/liveness/LiveSetElement.java @@ -93,13 +93,10 @@ } /** - * Returns a string version of this element * @return a string version of this element */ @Override public String toString() { - StringBuilder buf = new StringBuilder(""); - buf.append(regOp); - return buf.toString(); + return regOp.toString(); } } |
From: <jik...@li...> - 2014-09-08 14:01:00
|
details: http://hg.code.sourceforge.net/p/jikesrvm/code/rev/11d9c8a8fb86 changeset: 10877:11d9c8a8fb86 user: Erik Brangs <eri...@gm...> date: Mon Sep 08 14:34:52 2014 +0200 description: RVM-1086 : Replace uses of new/delete in sys.C with malloc/free (original patch by Carl Ritson). details: http://hg.code.sourceforge.net/p/jikesrvm/code/rev/844d6aae00ae changeset: 10878:844d6aae00ae user: Erik Brangs <eri...@gm...> date: Mon Sep 08 15:37:40 2014 +0200 description: RVM-1086 : Replace uses of malloc/free and related functions with appropriate wrappers (original patch by Carl Ritson). details: http://hg.code.sourceforge.net/p/jikesrvm/code/rev/06ab941977b0 changeset: 10879:06ab941977b0 user: Erik Brangs <eri...@gm...> date: Mon Sep 08 15:41:05 2014 +0200 description: RVM-1086 : Fix memory leak that occurs during thread creation (original patch by Carl Ritson). diffstat: tools/bootImageRunner/sys.C | 70 ++++++++++++++++++++++++++++++++++---------- 1 files changed, 54 insertions(+), 16 deletions(-) diffs (165 lines): diff --git a/tools/bootImageRunner/sys.C b/tools/bootImageRunner/sys.C --- a/tools/bootImageRunner/sys.C +++ b/tools/bootImageRunner/sys.C @@ -163,6 +163,10 @@ * buffers, but I hope that it will be one day. */ static int loadResultBuf(char * buf, int limit, const char *result); +static void* checkMalloc(int); +static void* checkCalloc(int, int); +static void checkFree(void*); + extern TLS_KEY_TYPE VmThreadKey; TLS_KEY_TYPE TerminateJmpBufKey; @@ -498,11 +502,11 @@ errx(1, "error in pfm_initialize: %s", pfm_strerror(ret)); } - perf_event_fds = (int*)calloc(numEvents, sizeof(int)); + perf_event_fds = (int*)checkCalloc(numEvents, sizeof(int)); if (!perf_event_fds) { errx(1, "error allocating perf_event_fds"); } - perf_event_attrs = (struct perf_event_attr *)calloc(numEvents, sizeof(struct perf_event_attr)); + perf_event_attrs = (struct perf_event_attr *)checkCalloc(numEvents, sizeof(struct perf_event_attr)); if (!perf_event_attrs) { errx(1, "error allocating perf_event_attrs"); } @@ -978,7 +982,7 @@ // create arguments // - sysThreadArguments = new Address[3]; + sysThreadArguments = (Address*) checkMalloc(sizeof(Address) * 3); sysThreadArguments[0] = tr; sysThreadArguments[1] = ip; sysThreadArguments[2] = fp; @@ -1086,7 +1090,7 @@ char *stackBuf; memset (&stack, 0, sizeof stack); - stack.ss_sp = stackBuf = new char[SIGSTKSZ]; + stack.ss_sp = stackBuf = (char*) checkMalloc(sizeof(char) * SIGSTKSZ); stack.ss_flags = 0; stack.ss_size = SIGSTKSZ; if (sigaltstack (&stack, 0)) { @@ -1096,18 +1100,30 @@ Address tr = ((Address *)args)[0]; - jmp_buf *jb = (jmp_buf*)malloc(sizeof(jmp_buf)); + jmp_buf *jb = (jmp_buf*)checkMalloc(sizeof(jmp_buf)); if (setjmp(*jb)) { // this is where we come to terminate the thread #ifdef RVM_FOR_HARMONY hythread_detach(NULL); #endif - free(jb); + checkFree(jb); *(int*)(tr + RVMThread_execStatus_offset) = RVMThread_TERMINATED; + // disable the signal stack (first retreiving the current one) + sigaltstack(0, &stack); stack.ss_flags = SS_DISABLE; sigaltstack(&stack, 0); - delete[] stackBuf; + + // check if the signal stack is the one in stackBuf + if (stack.ss_sp != stackBuf) { + // no; release it as well + checkFree(stack.ss_sp); + } + + // release signal stack allocated here + checkFree(stackBuf); + // release arguments + checkFree(args); } else { setThreadLocal(TerminateJmpBufKey, (void*)jb); @@ -1198,7 +1214,7 @@ stack_t stack; memset (&stack, 0, sizeof stack); - stack.ss_sp = new char[SIGSTKSZ]; + stack.ss_sp = (char*) checkMalloc(sizeof(char) * SIGSTKSZ); stack.ss_size = SIGSTKSZ; if (sigaltstack (&stack, 0)) { @@ -1373,7 +1389,7 @@ hythread_monitor_t monitor; hythread_monitor_init_with_name(&monitor, 0, NULL); #else - vmmonitor_t *monitor = new vmmonitor_t; + vmmonitor_t *monitor = (vmmonitor_t*) checkMalloc(sizeof(vmmonitor_t)); pthread_mutex_init(&monitor->mutex, NULL); pthread_cond_init(&monitor->cond, NULL); #endif @@ -1389,7 +1405,7 @@ vmmonitor_t *monitor = (vmmonitor_t*)_monitor; pthread_mutex_destroy(&monitor->mutex); pthread_cond_destroy(&monitor->cond); - delete monitor; + checkFree(monitor); #endif } @@ -1688,10 +1704,8 @@ int inRVMAddressSpace(Address a); -// Allocate memory. -// -extern "C" void * -sysMalloc(int length) +static void* +checkMalloc(int length) { void *result=malloc(length); if (inRVMAddressSpace((Address)result)) { @@ -1700,10 +1714,34 @@ return result; } +static void* +checkCalloc(int numElements, int sizeOfOneElement) +{ + void *result=calloc(numElements,sizeOfOneElement); + if (inRVMAddressSpace((Address)result)) { + fprintf(stderr,"calloc returned something that is in RVM address space: %p\n",result); + } + return result; +} + +static void +checkFree(void* mem) +{ + free(mem); +} + +// Allocate memory. +// +extern "C" void * +sysMalloc(int length) +{ + return checkMalloc(length); +} + extern "C" void * sysCalloc(int length) { - return calloc(1, length); + return checkCalloc(1, length); } // Release memory. @@ -1711,7 +1749,7 @@ extern "C" void sysFree(void *location) { - free(location); + checkFree(location); } // Zero a range of memory with non-temporal instructions on x86 |
From: <jik...@li...> - 2014-09-18 10:09:52
|
details: http://hg.code.sourceforge.net/p/jikesrvm/code/rev/6f79c07e8291 changeset: 10921:6f79c07e8291 user: Erik Brangs <eri...@gm...> date: Thu Sep 18 11:07:43 2014 +0200 description: Remove useless null check revealed by FindBugs. details: http://hg.code.sourceforge.net/p/jikesrvm/code/rev/0adf93ab7aa3 changeset: 10922:0adf93ab7aa3 user: Erik Brangs <eri...@gm...> date: Thu Sep 18 11:19:01 2014 +0200 description: Do not pass an empty String when creating new StringBuilder instances (issues revealed by FindBugs). details: http://hg.code.sourceforge.net/p/jikesrvm/code/rev/46664766dd95 changeset: 10923:46664766dd95 user: Erik Brangs <eri...@gm...> date: Thu Sep 18 11:21:14 2014 +0200 description: Use characters instead of Strings during String manipulation where it is possible (issues revealed by FindBugs). diffstat: libraryInterface/Common/src/java/lang/Class.java | 2 +- rvm/src/org/jikesrvm/CommandLineArgs.java | 2 +- rvm/src/org/jikesrvm/adaptive/controller/RecompilationStrategy.java | 2 +- rvm/src/org/jikesrvm/classloader/RVMClass.java | 2 +- rvm/src/org/jikesrvm/compilers/opt/controlflow/LTDominators.java | 4 ++-- rvm/src/org/jikesrvm/compilers/opt/ir/GCIRMap.java | 2 +- rvm/src/org/jikesrvm/compilers/opt/ir/GCIRMapElement.java | 2 +- rvm/src/org/jikesrvm/compilers/opt/ir/RegSpillListElement.java | 2 +- rvm/src/org/jikesrvm/compilers/opt/ir/operand/InlinedOsrTypeInfoOperand.java | 6 +++--- rvm/src/org/jikesrvm/compilers/opt/liveness/LiveAnalysis.java | 2 +- rvm/src/org/jikesrvm/compilers/opt/liveness/LiveSet.java | 2 +- rvm/src/org/jikesrvm/compilers/opt/ssa/SSA.java | 2 +- rvm/src/org/jikesrvm/compilers/opt/util/Tree.java | 4 ++-- rvm/src/org/jikesrvm/osr/MethodVariables.java | 2 +- rvm/src/org/jikesrvm/osr/VariableMap.java | 2 +- rvm/src/org/jikesrvm/tools/header_gen/GenerateInterfaceDeclarations.java | 2 +- rvm/src/org/jikesrvm/tools/oth/OptTestHarness.java | 2 +- rvm/src/org/jikesrvm/util/BitVector.java | 2 +- 18 files changed, 22 insertions(+), 22 deletions(-) diffs (244 lines): diff --git a/libraryInterface/Common/src/java/lang/Class.java b/libraryInterface/Common/src/java/lang/Class.java --- a/libraryInterface/Common/src/java/lang/Class.java +++ b/libraryInterface/Common/src/java/lang/Class.java @@ -330,7 +330,7 @@ return getComponentType().getSimpleName() + "[]"; } else { String fullName = getName(); - return fullName.substring(fullName.lastIndexOf(".") + 1); + return fullName.substring(fullName.lastIndexOf('.') + 1); } } diff --git a/rvm/src/org/jikesrvm/CommandLineArgs.java b/rvm/src/org/jikesrvm/CommandLineArgs.java --- a/rvm/src/org/jikesrvm/CommandLineArgs.java +++ b/rvm/src/org/jikesrvm/CommandLineArgs.java @@ -739,7 +739,7 @@ break; case JAVAAGENT_ARG: /* Extract jar file from the -javaagent:<jar>[=options] form */ - int equalsPos = arg.indexOf("="); + int equalsPos = arg.indexOf('='); String jarPath; if (equalsPos != -1) { jarPath = arg.substring(0, equalsPos); diff --git a/rvm/src/org/jikesrvm/adaptive/controller/RecompilationStrategy.java b/rvm/src/org/jikesrvm/adaptive/controller/RecompilationStrategy.java --- a/rvm/src/org/jikesrvm/adaptive/controller/RecompilationStrategy.java +++ b/rvm/src/org/jikesrvm/adaptive/controller/RecompilationStrategy.java @@ -295,7 +295,7 @@ } if (!optCompilerOption1.startsWith("opt:")) { // must specify optimization level! - int endPoint = optCompilerOption1.indexOf(":"); + int endPoint = optCompilerOption1.indexOf(':'); if (endPoint == -1) { VM.sysWrite("vm: Unrecognized optimization level in optimizing compiler command line argument: \"" + optCompilerOption1 + diff --git a/rvm/src/org/jikesrvm/classloader/RVMClass.java b/rvm/src/org/jikesrvm/classloader/RVMClass.java --- a/rvm/src/org/jikesrvm/classloader/RVMClass.java +++ b/rvm/src/org/jikesrvm/classloader/RVMClass.java @@ -214,7 +214,7 @@ */ public String getPackageName() { String className = toString(); - int lastDot = className.lastIndexOf("."); + int lastDot = className.lastIndexOf('.'); return (lastDot >= 0) ? className.substring(0, lastDot) : ""; } diff --git a/rvm/src/org/jikesrvm/compilers/opt/controlflow/LTDominators.java b/rvm/src/org/jikesrvm/compilers/opt/controlflow/LTDominators.java --- a/rvm/src/org/jikesrvm/compilers/opt/controlflow/LTDominators.java +++ b/rvm/src/org/jikesrvm/compilers/opt/controlflow/LTDominators.java @@ -200,7 +200,7 @@ } Enumeration<BasicBlock> e = getNextNodes(block); while (e.hasMoreElements()) { - System.out.print(" "); + System.out.print(' '); System.out.print(e.nextElement()); } System.out.println(); @@ -564,7 +564,7 @@ System.out.println("Dominators of " + block + ":" + LTDominatorInfo.getInfo(block).dominators(block, ir)); } } - System.out.println("\n"); + System.out.println('\n'); } /** diff --git a/rvm/src/org/jikesrvm/compilers/opt/ir/GCIRMap.java b/rvm/src/org/jikesrvm/compilers/opt/ir/GCIRMap.java --- a/rvm/src/org/jikesrvm/compilers/opt/ir/GCIRMap.java +++ b/rvm/src/org/jikesrvm/compilers/opt/ir/GCIRMap.java @@ -194,7 +194,7 @@ */ @Override public String toString() { - StringBuilder buf = new StringBuilder(""); + StringBuilder buf = new StringBuilder(); if (list.isEmpty()) { buf.append("empty"); } else { diff --git a/rvm/src/org/jikesrvm/compilers/opt/ir/GCIRMapElement.java b/rvm/src/org/jikesrvm/compilers/opt/ir/GCIRMapElement.java --- a/rvm/src/org/jikesrvm/compilers/opt/ir/GCIRMapElement.java +++ b/rvm/src/org/jikesrvm/compilers/opt/ir/GCIRMapElement.java @@ -119,7 +119,7 @@ */ @Override public String toString() { - StringBuilder buf = new StringBuilder(""); + StringBuilder buf = new StringBuilder(); buf.append(" Instruction: ").append(inst.bcIndex).append(", ").append(inst); for (RegSpillListElement elem : regSpillList) { buf.append(elem).append(" "); diff --git a/rvm/src/org/jikesrvm/compilers/opt/ir/RegSpillListElement.java b/rvm/src/org/jikesrvm/compilers/opt/ir/RegSpillListElement.java --- a/rvm/src/org/jikesrvm/compilers/opt/ir/RegSpillListElement.java +++ b/rvm/src/org/jikesrvm/compilers/opt/ir/RegSpillListElement.java @@ -105,7 +105,7 @@ */ @Override public String toString() { - StringBuilder buf = new StringBuilder(""); + StringBuilder buf = new StringBuilder(); buf.append("(").append(symbolicReg).append(", "); if (isSpill()) { buf.append("Sp: ").append(getSpill()); diff --git a/rvm/src/org/jikesrvm/compilers/opt/ir/operand/InlinedOsrTypeInfoOperand.java b/rvm/src/org/jikesrvm/compilers/opt/ir/operand/InlinedOsrTypeInfoOperand.java --- a/rvm/src/org/jikesrvm/compilers/opt/ir/operand/InlinedOsrTypeInfoOperand.java +++ b/rvm/src/org/jikesrvm/compilers/opt/ir/operand/InlinedOsrTypeInfoOperand.java @@ -85,13 +85,13 @@ StringBuffer buf = new StringBuffer("("); for (int i = 0, n = methodids.length; i < n; i++) { - buf.append(bcindexes[i]).append("@").append(MemberReference.getMemberRef(methodids[i]).getName()).append(" : "); + buf.append(bcindexes[i]).append('@').append(MemberReference.getMemberRef(methodids[i]).getName()).append(" : "); for (int j = 0, m = localTypeCodes[i].length; j < m; j++) { buf.append((char) localTypeCodes[i][j]); } - buf.append(","); + buf.append(','); for (int j = 0, m = stackTypeCodes[i].length; j < m; j++) { buf.append((char) stackTypeCodes[i][j]); } @@ -100,7 +100,7 @@ buf.append(" | "); } } - buf.append(")"); + buf.append(')'); return new String(buf); } } diff --git a/rvm/src/org/jikesrvm/compilers/opt/liveness/LiveAnalysis.java b/rvm/src/org/jikesrvm/compilers/opt/liveness/LiveAnalysis.java --- a/rvm/src/org/jikesrvm/compilers/opt/liveness/LiveAnalysis.java +++ b/rvm/src/org/jikesrvm/compilers/opt/liveness/LiveAnalysis.java @@ -1168,7 +1168,7 @@ */ @Override public String toString() { - StringBuilder buf = new StringBuilder(""); + StringBuilder buf = new StringBuilder(); buf.append(" Gen: ").append(gen).append("\n"); buf.append(" BB Kill: ").append(BBKillSet).append("\n"); buf.append(" first PEI Kill: ").append(firstPEIKillSet).append("\n"); diff --git a/rvm/src/org/jikesrvm/compilers/opt/liveness/LiveSet.java b/rvm/src/org/jikesrvm/compilers/opt/liveness/LiveSet.java --- a/rvm/src/org/jikesrvm/compilers/opt/liveness/LiveSet.java +++ b/rvm/src/org/jikesrvm/compilers/opt/liveness/LiveSet.java @@ -302,7 +302,7 @@ */ @Override public String toString() { - StringBuilder buf = new StringBuilder(""); + StringBuilder buf = new StringBuilder(); if (first == null) { buf.append("empty"); } else { diff --git a/rvm/src/org/jikesrvm/compilers/opt/ssa/SSA.java b/rvm/src/org/jikesrvm/compilers/opt/ssa/SSA.java --- a/rvm/src/org/jikesrvm/compilers/opt/ssa/SSA.java +++ b/rvm/src/org/jikesrvm/compilers/opt/ssa/SSA.java @@ -163,7 +163,7 @@ } System.out.print(" )"); } - System.out.print("\n"); + System.out.print('\n'); } } System.out.println("********* END OF IR DUMP in SSA FOR " + ir.method); diff --git a/rvm/src/org/jikesrvm/compilers/opt/util/Tree.java b/rvm/src/org/jikesrvm/compilers/opt/util/Tree.java --- a/rvm/src/org/jikesrvm/compilers/opt/util/Tree.java +++ b/rvm/src/org/jikesrvm/compilers/opt/util/Tree.java @@ -130,9 +130,9 @@ private StringBuffer DFS(StringBuffer sb, TreeNode node, int depth) { // indent appropriate spaces and print node for (int i = 0; i < 2 * depth; i++) { - sb.append(" "); + sb.append(' '); } - sb.append(node).append("\n"); + sb.append(node).append('\n'); Enumeration<TreeNode> childEnum = node.getChildren(); while (childEnum.hasMoreElements()) { diff --git a/rvm/src/org/jikesrvm/osr/MethodVariables.java b/rvm/src/org/jikesrvm/osr/MethodVariables.java --- a/rvm/src/org/jikesrvm/osr/MethodVariables.java +++ b/rvm/src/org/jikesrvm/osr/MethodVariables.java @@ -41,7 +41,7 @@ @Override public String toString() { - StringBuilder buf = new StringBuilder(""); + StringBuilder buf = new StringBuilder(); buf.append(" pc@").append(bcIndex).append(MemberReference.getMemberRef(methId).getName()); buf.append("\n"); diff --git a/rvm/src/org/jikesrvm/osr/VariableMap.java b/rvm/src/org/jikesrvm/osr/VariableMap.java --- a/rvm/src/org/jikesrvm/osr/VariableMap.java +++ b/rvm/src/org/jikesrvm/osr/VariableMap.java @@ -68,7 +68,7 @@ */ @Override public String toString() { - StringBuilder buf = new StringBuilder(""); + StringBuilder buf = new StringBuilder(); if (list.isEmpty()) { buf.append("empty"); diff --git a/rvm/src/org/jikesrvm/tools/header_gen/GenerateInterfaceDeclarations.java b/rvm/src/org/jikesrvm/tools/header_gen/GenerateInterfaceDeclarations.java --- a/rvm/src/org/jikesrvm/tools/header_gen/GenerateInterfaceDeclarations.java +++ b/rvm/src/org/jikesrvm/tools/header_gen/GenerateInterfaceDeclarations.java @@ -187,7 +187,7 @@ System.err.println(msg); System.err.print("The build system will delete the output file"); if (outFileName != null) { - System.err.print(" "); + System.err.print(' '); System.err.print(outFileName); } System.err.println(); diff --git a/rvm/src/org/jikesrvm/tools/oth/OptTestHarness.java b/rvm/src/org/jikesrvm/tools/oth/OptTestHarness.java --- a/rvm/src/org/jikesrvm/tools/oth/OptTestHarness.java +++ b/rvm/src/org/jikesrvm/tools/oth/OptTestHarness.java @@ -237,7 +237,7 @@ // use for cases when the command line is too long for AIX i++; BufferedReader in = new BufferedReader(new FileReader(args[i])); - StringBuilder s = new StringBuilder(""); + StringBuilder s = new StringBuilder(); while (in.ready()) { String line = in.readLine().trim(); if (!line.startsWith("#")) { diff --git a/rvm/src/org/jikesrvm/util/BitVector.java b/rvm/src/org/jikesrvm/util/BitVector.java --- a/rvm/src/org/jikesrvm/util/BitVector.java +++ b/rvm/src/org/jikesrvm/util/BitVector.java @@ -225,7 +225,7 @@ */ @Override public boolean equals(Object obj) { - if ((obj != null) && (obj instanceof BitVector)) { + if (obj instanceof BitVector) { if (this == obj) { // should help alias analysis return true; } |
From: <jik...@li...> - 2014-09-22 19:22:43
|
details: http://hg.code.sourceforge.net/p/jikesrvm/code/rev/db9c3a1a5144 changeset: 10934:db9c3a1a5144 user: Erik Brangs <eri...@gm...> date: Mon Sep 22 19:13:35 2014 +0200 description: RVM-1083 : Remove usage of Instruction.scratchObject from LeaveSSA. details: http://hg.code.sourceforge.net/p/jikesrvm/code/rev/cfc22f1cb9e1 changeset: 10935:cfc22f1cb9e1 user: Erik Brangs <eri...@gm...> date: Mon Sep 22 20:17:17 2014 +0200 description: RVM-1083 : Remove usage of scratch fields of Register from LeaveSSA. details: http://hg.code.sourceforge.net/p/jikesrvm/code/rev/5fee87933f1d changeset: 10936:5fee87933f1d user: Erik Brangs <eri...@gm...> date: Mon Sep 22 20:21:24 2014 +0200 description: RVM-1083 : Remove usage of scratch fields of Register from EnterSSA. diffstat: rvm/src/org/jikesrvm/compilers/opt/ssa/EnterSSA.java | 7 ++- rvm/src/org/jikesrvm/compilers/opt/ssa/LeaveSSA.java | 43 ++++++++++++------- 2 files changed, 31 insertions(+), 19 deletions(-) diffs (138 lines): diff --git a/rvm/src/org/jikesrvm/compilers/opt/ssa/EnterSSA.java b/rvm/src/org/jikesrvm/compilers/opt/ssa/EnterSSA.java --- a/rvm/src/org/jikesrvm/compilers/opt/ssa/EnterSSA.java +++ b/rvm/src/org/jikesrvm/compilers/opt/ssa/EnterSSA.java @@ -760,6 +760,9 @@ */ private void search(BasicBlock X, Stack<RegisterOperand>[] S) { if (DEBUG) System.out.println("SEARCH " + X); + + HashMap<Register, Register> pushedRegs = new HashMap<Register, Register>(); + for (Enumeration<Instruction> ie = X.forwardInstrEnumerator(); ie.hasMoreElements();) { Instruction A = ie.nextElement(); if (A.operator() != PHI) { @@ -792,7 +795,7 @@ if (DEBUG) System.out.println("PUSH " + r2 + " FOR " + r1 + " BECAUSE " + A); S[r1.getNumber()].push(new RegisterOperand(r2, rop.getType())); rop.setRegister(r2); - r2.setScratchObject(r1); + pushedRegs.put(r2, r1); } } } // end of first loop @@ -848,7 +851,7 @@ Register newReg = newOp.asRegister().getRegister(); if (newReg.isSSA()) continue; if (newReg.isPhysical()) continue; - Register r1 = (Register) newReg.getScratchObject(); + Register r1 = pushedRegs.get(newReg); S[r1.getNumber()].pop(); if (DEBUG) System.out.println("POP " + r1); } diff --git a/rvm/src/org/jikesrvm/compilers/opt/ssa/LeaveSSA.java b/rvm/src/org/jikesrvm/compilers/opt/ssa/LeaveSSA.java --- a/rvm/src/org/jikesrvm/compilers/opt/ssa/LeaveSSA.java +++ b/rvm/src/org/jikesrvm/compilers/opt/ssa/LeaveSSA.java @@ -616,6 +616,10 @@ Instruction guardPhis = null; + private HashMap<Instruction, Instruction> inst2guardPhi; + private HashMap<Register, Integer> guardRegUnion; + private HashMap<Register, Register> associatedRegisters; + /** * Initialization for removal of guard phis. * @@ -627,6 +631,8 @@ // visit all instructions, looking for guard phis + inst2guardPhi = new HashMap<Instruction, Instruction>(); + while (e.hasMoreElements()) { Instruction inst = e.nextElement(); if (!Phi.conforms(inst)) continue; @@ -636,8 +642,7 @@ if (!r.isValidation()) continue; // force all operands of Phis into registers. - - inst.setScratchObject(guardPhis); + inst2guardPhi.put(inst, guardPhis); guardPhis = inst; int values = Phi.getNumberOfValues(inst); @@ -659,11 +664,13 @@ } } + guardRegUnion = new HashMap<Register, Integer>(); + associatedRegisters = new HashMap<Register, Register>(); // visit all guard registers, init union/find for (Register r = ir.regpool.getFirstSymbolicRegister(); r != null; r = r.getNext()) { if (!r.isValidation()) continue; - r.setScratch(1); - r.setScratchObject(r); + guardRegUnion.put(r, Integer.valueOf(1)); + associatedRegisters.put(r, r); } } @@ -687,7 +694,7 @@ } } } - inst = (Instruction) inst.getScratchObject(); + inst = inst2guardPhi.get(inst); } } @@ -715,7 +722,7 @@ Instruction inst = guardPhis; while (inst != null) { inst.remove(); - inst = (Instruction) inst.getScratchObject(); + inst = inst2guardPhi.get(inst); } } @@ -723,26 +730,28 @@ Register a = guardFind(from); Register b = guardFind(to); if (a == b) return a; - if (a.getScratch() == b.getScratch()) { - a.setScratch(a.getScratch() + 1); - b.setScratchObject(a); + int aUnion = guardRegUnion.get(a); + int bUnion = guardRegUnion.get(b); + if (aUnion == bUnion) { + guardRegUnion.put(a, Integer.valueOf(aUnion+1)); + associatedRegisters.put(b, a); return a; } - if (a.getScratch() > b.getScratch()) { - b.setScratchObject(a); + if (aUnion > bUnion) { + associatedRegisters.put(b, a); return a; } - a.setScratchObject(b); + associatedRegisters.put(a, b); return b; } private Register guardFind(Register r) { Register start = r; - if (VM.VerifyAssertions) VM._assert(r.getScratchObject() != null); - while (r.getScratchObject() != r) r = (Register) r.getScratchObject(); - while (start.getScratchObject() != r) { - start.setScratchObject(r); - start = (Register) start.getScratchObject(); + if (VM.VerifyAssertions) VM._assert(associatedRegisters.get(r) != null); + while (associatedRegisters.get(r) != r) r = associatedRegisters.get(r); + while (associatedRegisters.get(start) != r) { + associatedRegisters.put(start, r); + start = associatedRegisters.get(start); } return r; } |
From: <jik...@li...> - 2014-09-28 07:03:00
|
details: http://hg.code.sourceforge.net/p/jikesrvm/code/rev/1840b8173c6d changeset: 10941:1840b8173c6d user: Erik Brangs <eri...@gm...> date: Sat Sep 27 13:51:12 2014 +0200 description: RVM-1083 : Extract back-patching of forward branches in AssemblerOpt (PPC) to a separate method. details: http://hg.code.sourceforge.net/p/jikesrvm/code/rev/a9effb544b48 changeset: 10942:a9effb544b48 user: Erik Brangs <eri...@gm...> date: Sat Sep 27 20:47:10 2014 +0200 description: RVM-1083 : Change AssemblerOpt (PPC) to save information for back-patching of branch targets in a separate data structure instead of using Instruction's scratchObject field. Note that I don't have any numbers for the frequency and distribution of branch targets and sources. It's likely that the performance of the lookup could be improved. details: http://hg.code.sourceforge.net/p/jikesrvm/code/rev/79df00744a66 changeset: 10943:79df00744a66 user: Erik Brangs <eri...@gm...> date: Sat Sep 27 20:48:22 2014 +0200 description: RVM-1083 : Remove the scratchObject field from org.jikesrvm.compilers.opt.ir.Instruction. diffstat: rvm/src/org/jikesrvm/compilers/opt/ir/IR.java | 11 - rvm/src/org/jikesrvm/compilers/opt/ir/Instruction.java | 7 - rvm/src/org/jikesrvm/compilers/opt/mir2mc/ia32/FinalMIRExpansion.java | 1 - rvm/src/org/jikesrvm/compilers/opt/mir2mc/ppc/AssemblerOpt.java | 198 ++++++--- rvm/src/org/jikesrvm/compilers/opt/mir2mc/ppc/FinalMIRExpansion.java | 2 +- rvm/src/org/jikesrvm/compilers/opt/ssa/LICM.java | 1 - 6 files changed, 124 insertions(+), 96 deletions(-) diffs (truncated from 327 to 300 lines): diff --git a/rvm/src/org/jikesrvm/compilers/opt/ir/IR.java b/rvm/src/org/jikesrvm/compilers/opt/ir/IR.java --- a/rvm/src/org/jikesrvm/compilers/opt/ir/IR.java +++ b/rvm/src/org/jikesrvm/compilers/opt/ir/IR.java @@ -605,17 +605,6 @@ } /** - * Clear (set to {@code null}) the scratch object on - * all instructions currently in this IR. - */ - public void clearInstructionScratchObject() { - for (Instruction instr = firstInstructionInCodeOrder(); instr != null; instr = - instr.nextInstructionInCodeOrder()) { - instr.setScratchObject(null); - } - } - - /** * Returns the number of symbolic registers for this IR. * * @return number of symbolic registers that were allocated diff --git a/rvm/src/org/jikesrvm/compilers/opt/ir/Instruction.java b/rvm/src/org/jikesrvm/compilers/opt/ir/Instruction.java --- a/rvm/src/org/jikesrvm/compilers/opt/ir/Instruction.java +++ b/rvm/src/org/jikesrvm/compilers/opt/ir/Instruction.java @@ -2026,11 +2026,4 @@ this.scratch = scratch; } - public Object getScratchObject() { - return scratchObject; - } - - public void setScratchObject(Object scratchObject) { - this.scratchObject = scratchObject; - } } diff --git a/rvm/src/org/jikesrvm/compilers/opt/mir2mc/ia32/FinalMIRExpansion.java b/rvm/src/org/jikesrvm/compilers/opt/mir2mc/ia32/FinalMIRExpansion.java --- a/rvm/src/org/jikesrvm/compilers/opt/mir2mc/ia32/FinalMIRExpansion.java +++ b/rvm/src/org/jikesrvm/compilers/opt/mir2mc/ia32/FinalMIRExpansion.java @@ -125,7 +125,6 @@ for (Instruction next, p = ir.firstInstructionInCodeOrder(); p != null; p = next) { next = p.nextInstructionInCodeOrder(); p.setmcOffset(-1); - p.setScratchObject(null); switch (p.getOpcode()) { case IA32_TEST_opcode: diff --git a/rvm/src/org/jikesrvm/compilers/opt/mir2mc/ppc/AssemblerOpt.java b/rvm/src/org/jikesrvm/compilers/opt/mir2mc/ppc/AssemblerOpt.java --- a/rvm/src/org/jikesrvm/compilers/opt/mir2mc/ppc/AssemblerOpt.java +++ b/rvm/src/org/jikesrvm/compilers/opt/mir2mc/ppc/AssemblerOpt.java @@ -14,6 +14,12 @@ import static org.jikesrvm.compilers.opt.ir.Operators.*; +import java.util.ArrayDeque; +import java.util.Deque; +import java.util.HashMap; +import java.util.Map; +import java.util.Iterator; + import org.jikesrvm.ArchitectureSpecific; import org.jikesrvm.ArchitectureSpecificOpt; import org.jikesrvm.ArchitectureSpecific.CodeArray; @@ -50,6 +56,7 @@ import org.jikesrvm.compilers.opt.ir.ppc.PhysicalRegisterSet; import org.jikesrvm.ppc.ArchConstants; import org.jikesrvm.ppc.Disassembler; +import org.jikesrvm.util.EmptyIterator; /** * Assemble PowerPC MIR into binary code. @@ -85,6 +92,8 @@ private int unresolvedBranches = 0; + private BranchInformationForBackPatching branchBackPatching; + /** * Generate machine code into ir.MIRInfo.machinecode. * @@ -101,75 +110,15 @@ int mi = 0; CodeArray machinecodes = ir.MIRInfo.machinecode; PhysicalRegisterSet phys = ir.regpool.getPhysicalRegisterSet(); + int labelCountEstimate = ir.cfg.numberOfNodes(); + branchBackPatching = new BranchInformationForBackPatching(labelCountEstimate); boolean unsafeCondDispl = machinecodes.length() > MAX_COND_DISPL; //boolean unsafeDispl = machinecodes.length() > MAX_DISPL; for (Instruction p = ir.firstInstructionInCodeOrder(); p != null; p = p.nextInstructionInCodeOrder()) { int inst = p.operator().instTemplate; switch (p.getOpcode()) { case LABEL_opcode: - // Back-patch any forward branches to it. - // The Label instructions scratchObject holds the head of a - // linked list of the (forward) branch instructions with this - // label as their target. - for (BranchSrcElement bSrc = (BranchSrcElement) p.getScratchObject(); bSrc != null; bSrc = bSrc.next) { - Instruction branchStmt = bSrc.source; - int bo = branchStmt.getmcOffset() - (1 << LG_INSTRUCTION_WIDTH); - int bi = bo >> LG_INSTRUCTION_WIDTH; - int targetOffset = (mi - bi) << LG_INSTRUCTION_WIDTH; - boolean setLink = false; - - if (targetOffset > MAX_DISPL << LG_INSTRUCTION_WIDTH) { - throw new OptimizingCompilerException("CodeGen", "Branch positive offset too large: ", targetOffset); - } - - switch (branchStmt.getOpcode()) { - case PPC_B_opcode: - case PPC_BL_opcode: - machinecodes.set(bi, machinecodes.get(bi) | targetOffset & LI_MASK); - break; - case PPC_DATA_LABEL_opcode: - machinecodes.set(bi, targetOffset); - break; - // Since resolveBranch and patch already check the range - // of target offset, and will fail if it is out of range - case IG_PATCH_POINT_opcode: - // do nothing - break; - case PPC_BCL_opcode: - setLink = true; - // fall through! - default: // conditional branches - if (targetOffset <= MAX_COND_DISPL << 2) {// one word is enough - machinecodes.set(bi, machinecodes.get(bi) | targetOffset & BD_MASK); - if (DEBUG) { - VM.sysWrite("**** Forward Short Cond. Branch ****\n"); - VM.sysWrite(disasm(machinecodes.get(bi), 0) + "\n"); - } - } else { // one word is not enough - // we're moving the "real" branch ahead 1 instruction - // if it's a GC point (eg BCL for yieldpoint) then we must - // make sure the GCMap is generated at the correct mc offset. - branchStmt.setmcOffset(branchStmt.getmcOffset() + (1 << LG_INSTRUCTION_WIDTH)); - // flip the condition and skip the next branch instruction - machinecodes.set(bi, flipCondition(machinecodes.get(bi))); - machinecodes.set(bi, machinecodes.get(bi) | (2 << LG_INSTRUCTION_WIDTH)); - machinecodes.set(bi, machinecodes.get(bi) & 0xfffffffe); // turn off link bit. - // make a long branch - machinecodes.set(bi + 1, Btemplate | ((targetOffset - 4) & LI_MASK)); - if (setLink) { - machinecodes.set(bi + 1, machinecodes.get(bi + 1) | 1); // turn on link bit. - } - if (DEBUG) { - VM.sysWrite("**** Forward Long Cond. Branch ****\n"); - VM.sysWrite(disasm(machinecodes.get(bi), 0) + "\n"); - VM.sysWrite(disasm(machinecodes.get(bi + 1), 0) + "\n"); - } - } - break; - } - unresolvedBranches--; - } - p.setmcOffset(mi << LG_INSTRUCTION_WIDTH); + backpatchForwardBranches(p, machinecodes, mi); break; case BBEND_opcode: @@ -1231,17 +1180,76 @@ } /** - * Used to build a link list of unresolved forward branches - * on the target label instr. + * Back-patches any forward branches to the given instruction. + * <p> + * Note: The updated index into the machine code array would normally need + * to be returned but this method currently does not modify the index. + * + * @param branchTarget the LABEL instruction to process + * @param machinecodes machine code array + * @param machineCodeIndex current index into the machine code array */ - private static final class BranchSrcElement { - Instruction source; - BranchSrcElement next; + private void backpatchForwardBranches(Instruction branchTarget, CodeArray machinecodes, int machineCodeIndex) { + Iterator<Instruction> branchSources = branchBackPatching.getBranchSources(branchTarget); + while (branchSources.hasNext()) { + Instruction branchStmt = branchSources.next(); + int bo = branchStmt.getmcOffset() - (1 << LG_INSTRUCTION_WIDTH); + int bi = bo >> LG_INSTRUCTION_WIDTH; + int targetOffset = (machineCodeIndex - bi) << LG_INSTRUCTION_WIDTH; + boolean setLink = false; - BranchSrcElement(Instruction src, BranchSrcElement Next) { - source = src; - next = Next; + if (targetOffset > MAX_DISPL << LG_INSTRUCTION_WIDTH) { + throw new OptimizingCompilerException("CodeGen", "Branch positive offset too large: ", targetOffset); + } + + switch (branchStmt.getOpcode()) { + case PPC_B_opcode: + case PPC_BL_opcode: + machinecodes.set(bi, machinecodes.get(bi) | targetOffset & LI_MASK); + break; + case PPC_DATA_LABEL_opcode: + machinecodes.set(bi, targetOffset); + break; + // Since resolveBranch and patch already check the range + // of target offset, and will fail if it is out of range + case IG_PATCH_POINT_opcode: + // do nothing + break; + case PPC_BCL_opcode: + setLink = true; + // fall through! + default: // conditional branches + if (targetOffset <= MAX_COND_DISPL << 2) {// one word is enough + machinecodes.set(bi, machinecodes.get(bi) | targetOffset & BD_MASK); + if (DEBUG) { + VM.sysWrite("**** Forward Short Cond. Branch ****\n"); + VM.sysWrite(disasm(machinecodes.get(bi), 0) + "\n"); + } + } else { // one word is not enough + // we're moving the "real" branch ahead 1 instruction + // if it's a GC point (eg BCL for yieldpoint) then we must + // make sure the GCMap is generated at the correct mc offset. + branchStmt.setmcOffset(branchStmt.getmcOffset() + (1 << LG_INSTRUCTION_WIDTH)); + // flip the condition and skip the next branch instruction + machinecodes.set(bi, flipCondition(machinecodes.get(bi))); + machinecodes.set(bi, machinecodes.get(bi) | (2 << LG_INSTRUCTION_WIDTH)); + machinecodes.set(bi, machinecodes.get(bi) & 0xfffffffe); // turn off link bit. + // make a long branch + machinecodes.set(bi + 1, Btemplate | ((targetOffset - 4) & LI_MASK)); + if (setLink) { + machinecodes.set(bi + 1, machinecodes.get(bi + 1) | 1); // turn on link bit. + } + if (DEBUG) { + VM.sysWrite("**** Forward Long Cond. Branch ****\n"); + VM.sysWrite(disasm(machinecodes.get(bi), 0) + "\n"); + VM.sysWrite(disasm(machinecodes.get(bi + 1), 0) + "\n"); + } + } + break; + } + unresolvedBranches--; } + branchTarget.setmcOffset(machineCodeIndex << LG_INSTRUCTION_WIDTH); } /** @@ -1254,10 +1262,9 @@ if (tgt.getmcOffset() < 0) { unresolvedBranches++; // forward branch target, which has not been fixed yet. - // Unresolved forward branch stmts will form a linked list - // via the scratchObject of the label instruction. - // These branch stmts will be back-patched as part of assembly of LABEL - tgt.setScratchObject(new BranchSrcElement(src, (BranchSrcElement) tgt.getScratchObject())); + // Unresolved forward branch stmts will be saved now and + // will be back-patched later as part of the assembly of LABEL + branchBackPatching.addBranchSourceForLabel(src, tgt); return 0; } else { // backward branch target, which has been fixed. @@ -1328,4 +1335,45 @@ // make a B IMM instruction code.set(patchOffset, (18 << 26) | (rel32 & LI_MASK)); } + + /** + * Contains information about of unresolved forward branches + * for the respective target label instructions. + */ + private static final class BranchInformationForBackPatching { + /** + * An estimate for the number of sources that a branch target may have. + * <p> + * TODO This could likely be improved by information from measurements. + * The current value was chosen merely because the default capacity + * of 16 is likely too large. + */ + private static final int BRANCH_SOURCE_COUNT_ESTIMATE = 4; + + private Map<Instruction, Deque<Instruction>> labelToBranchSources; + + BranchInformationForBackPatching(int labelCountEstimate) { + int noRehashCapacity = (labelCountEstimate / 2) * 3; + labelToBranchSources = + new HashMap<Instruction, Deque<Instruction>>(noRehashCapacity); + } + + void addBranchSourceForLabel(Instruction branchSource, Instruction label) { + Deque<Instruction> queue = labelToBranchSources.get(label); + if (queue == null) { + queue = new ArrayDeque(BRANCH_SOURCE_COUNT_ESTIMATE); + labelToBranchSources.put(label, queue); + } + queue.addFirst(branchSource); + } + + Iterator<Instruction> getBranchSources(Instruction label) { + Deque<Instruction> sources = labelToBranchSources.get(label); + if (sources == null) { + return EmptyIterator.<Instruction>getInstance(); + } + return sources.iterator(); |