[GR-62935] Introduce a common timing interface

PullRequest: graal/20319

Author: ivan-ristovic

substratevm/src/com.oracle.svm.core.genscavenge/src/com/oracle/svm/core/genscavenge/AdaptiveCollectionPolicy.java

@@ -32,6 +32,7 @@
 import com.oracle.svm.core.heap.GCCause;
 import com.oracle.svm.core.util.BasedOnJDKFile;
 import com.oracle.svm.core.util.TimeUtils;
+import com.oracle.svm.core.util.Timer;
 import com.oracle.svm.core.util.UnsignedUtils;
 
 import jdk.graal.compiler.word.Word;
@@ -393,39 +394,39 @@ private static UnsignedWord spaceIncrement(UnsignedWord curSize, UnsignedWord pe
     }
 
     private double secondsSinceMajorGc() { // time_since_major_gc
-        return TimeUtils.nanosToSecondsDouble(System.nanoTime() - majorTimer.getOpenedTime());
+        return TimeUtils.nanosToSecondsDouble(System.nanoTime() - majorTimer.startedNanos());
     }
 
     @Override
     public void onCollectionBegin(boolean completeCollection, long requestingNanoTime) { // {major,minor}_collection_begin
         Timer timer = completeCollection ? majorTimer : minorTimer;
-        timer.closeAt(requestingNanoTime);
+        timer.stopAt(requestingNanoTime);
         if (completeCollection) {
-            latestMajorMutatorIntervalNanos = timer.getMeasuredNanos();
+            latestMajorMutatorIntervalNanos = timer.totalNanos();
         } else {
-            latestMinorMutatorIntervalNanos = timer.getMeasuredNanos();
+            latestMinorMutatorIntervalNanos = timer.totalNanos();
         }
 
         timer.reset();
-        timer.open(); // measure collection pause
+        timer.start(); // measure collection pause
 
         super.onCollectionBegin(completeCollection, requestingNanoTime);
     }
 
     @Override
     public void onCollectionEnd(boolean completeCollection, GCCause cause) { // {major,minor}_collection_end
         Timer timer = completeCollection ? majorTimer : minorTimer;
-        timer.close();
+        timer.stop();
 
         if (completeCollection) {
             updateCollectionEndAverages(avgMajorGcCost, avgMajorPause, majorCostEstimator, avgMajorIntervalSeconds,
-                            cause, latestMajorMutatorIntervalNanos, timer.getMeasuredNanos(), promoSize);
+                            cause, latestMajorMutatorIntervalNanos, timer.totalNanos(), promoSize);
             majorCount++;
             minorCountSinceMajorCollection = 0;
 
         } else {
             updateCollectionEndAverages(avgMinorGcCost, avgMinorPause, minorCostEstimator, null,
-                            cause, latestMinorMutatorIntervalNanos, timer.getMeasuredNanos(), edenSize);
+                            cause, latestMinorMutatorIntervalNanos, timer.totalNanos(), edenSize);
             minorCount++;
             minorCountSinceMajorCollection++;
 
@@ -435,7 +436,7 @@ public void onCollectionEnd(boolean completeCollection, GCCause cause) { // {maj
         }
 
         timer.reset();
-        timer.open();
+        timer.start();
 
         GCAccounting accounting = GCImpl.getAccounting();
         UnsignedWord oldLive = accounting.getOldGenerationAfterChunkBytes();

substratevm/src/com.oracle.svm.core.genscavenge/src/com/oracle/svm/core/genscavenge/CompactingOldGeneration.java

@@ -53,6 +53,7 @@
 import com.oracle.svm.core.log.Log;
 import com.oracle.svm.core.thread.VMThreads;
 import com.oracle.svm.core.threadlocal.VMThreadLocalSupport;
+import com.oracle.svm.core.util.Timer;
 
 import jdk.graal.compiler.word.Word;
 
@@ -251,25 +252,25 @@ void sweepAndCompact(Timers timers, ChunkReleaser chunkReleaser) {
          */
         ReferenceObjectProcessing.updateForwardedRefs();
 
-        Timer oldPlanningTimer = timers.oldPlanning.open();
+        Timer oldPlanningTimer = timers.oldPlanning.start();
         try {
             planCompaction();
         } finally {
-            oldPlanningTimer.close();
+            oldPlanningTimer.stop();
         }
 
-        Timer oldFixupTimer = timers.oldFixup.open();
+        Timer oldFixupTimer = timers.oldFixup.start();
         try {
             fixupReferencesBeforeCompaction(chunkReleaser, timers);
         } finally {
-            oldFixupTimer.close();
+            oldFixupTimer.stop();
         }
 
-        Timer oldCompactionTimer = timers.oldCompaction.open();
+        Timer oldCompactionTimer = timers.oldCompaction.start();
         try {
             compact(timers);
         } finally {
-            oldCompactionTimer.close();
+            oldCompactionTimer.stop();
         }
     }
 
@@ -280,18 +281,18 @@ private void planCompaction() {
 
     @Uninterruptible(reason = "Avoid unnecessary safepoint checks in GC for performance.")
     private void fixupReferencesBeforeCompaction(ChunkReleaser chunkReleaser, Timers timers) {
-        Timer oldFixupAlignedChunksTimer = timers.oldFixupAlignedChunks.open();
+        Timer oldFixupAlignedChunksTimer = timers.oldFixupAlignedChunks.start();
         try {
             AlignedHeapChunk.AlignedHeader aChunk = space.getFirstAlignedHeapChunk();
             while (aChunk.isNonNull()) {
                 ObjectMoveInfo.walkObjects(aChunk, fixupVisitor);
                 aChunk = HeapChunk.getNext(aChunk);
             }
         } finally {
-            oldFixupAlignedChunksTimer.close();
+            oldFixupAlignedChunksTimer.stop();
         }
 
-        Timer oldFixupImageHeapTimer = timers.oldFixupImageHeap.open();
+        Timer oldFixupImageHeapTimer = timers.oldFixupImageHeap.start();
         try {
             for (ImageHeapInfo info : HeapImpl.getImageHeapInfos()) {
                 fixupImageHeapRoots(info);
@@ -303,43 +304,43 @@ private void fixupReferencesBeforeCompaction(ChunkReleaser chunkReleaser, Timers
                 }
             }
         } finally {
-            oldFixupImageHeapTimer.close();
+            oldFixupImageHeapTimer.stop();
         }
 
-        Timer oldFixupThreadLocalsTimer = timers.oldFixupThreadLocals.open();
+        Timer oldFixupThreadLocalsTimer = timers.oldFixupThreadLocals.start();
         try {
             for (IsolateThread isolateThread = VMThreads.firstThread(); isolateThread.isNonNull(); isolateThread = VMThreads.nextThread(isolateThread)) {
                 VMThreadLocalSupport.singleton().walk(isolateThread, refFixupVisitor);
             }
         } finally {
-            oldFixupThreadLocalsTimer.close();
+            oldFixupThreadLocalsTimer.stop();
         }
 
-        Timer oldFixupStackTimer = timers.oldFixupStack.open();
+        Timer oldFixupStackTimer = timers.oldFixupStack.start();
         try {
             fixupStackReferences();
         } finally {
-            oldFixupStackTimer.close();
+            oldFixupStackTimer.stop();
         }
 
         /*
          * Check each unaligned object and fix its references if the object is marked. Add the chunk
          * to the releaser's list in case the object is not marked and therefore won't survive.
          */
-        Timer oldFixupUnalignedChunksTimer = timers.oldFixupUnalignedChunks.open();
+        Timer oldFixupUnalignedChunksTimer = timers.oldFixupUnalignedChunks.start();
         try {
             fixupUnalignedChunkReferences(chunkReleaser);
         } finally {
-            oldFixupUnalignedChunksTimer.close();
+            oldFixupUnalignedChunksTimer.stop();
         }
 
-        Timer oldFixupRuntimeCodeCacheTimer = timers.oldFixupRuntimeCodeCache.open();
+        Timer oldFixupRuntimeCodeCacheTimer = timers.oldFixupRuntimeCodeCache.start();
         try {
             if (RuntimeCompilation.isEnabled()) {
                 RuntimeCodeInfoMemory.singleton().walkRuntimeMethodsDuringGC(runtimeCodeCacheFixupWalker);
             }
         } finally {
-            oldFixupRuntimeCodeCacheTimer.close();
+            oldFixupRuntimeCodeCacheTimer.stop();
         }
     }
 
@@ -394,7 +395,7 @@ private void compact(Timers timers) {
             chunk = HeapChunk.getNext(chunk);
         }
 
-        Timer oldCompactionRememberedSetsTimer = timers.oldCompactionRememberedSets.open();
+        Timer oldCompactionRememberedSetsTimer = timers.oldCompactionRememberedSets.start();
         try {
             chunk = space.getFirstAlignedHeapChunk();
             while (chunk.isNonNull()) {
@@ -413,7 +414,7 @@ private void compact(Timers timers) {
                 chunk = HeapChunk.getNext(chunk);
             }
         } finally {
-            oldCompactionRememberedSetsTimer.close();
+            oldCompactionRememberedSetsTimer.stop();
         }
     }