correctly handle thread CPU time (when sti.threadCpuTime != -1) in applyDiffAtGetResultsMoment()

Author: thurka

visualvm/libs.profiler/lib.profiler/src/org/graalvm/visualvm/lib/jfluid/results/cpu/StackTraceSnapshotBuilder.java

@@ -696,33 +696,49 @@ protected long getDumpAbsTimeStamp() {
         @Override
         protected void applyDiffAtGetResultsMoment(ThreadInfo ti) {
             long time0 = getDumpAbsTimeStamp();
-            long diff = time0 - ti.topMethodEntryTime0;
+            long diff0 = time0 - ti.topMethodEntryTime0;
+            long diff1 = getThreadTime(ti, diff0) - ti.topMethodEntryTime1;
 
-            if (diff>0) {
-                applyDiffToTopNode(ti, diff);
-                ti.diffAtGetResultsMoment = diff;
+            if (diff0<0) diff0=0;
+            if (diff1<0) diff1=0;
+            if (diff0>0 || diff1>0) {
+                applyDiffToTopNode(ti, diff0, diff1);
+                ti.diffAtGetResultsMoment0 = diff0;
+                ti.diffAtGetResultsMoment1 = diff1;
             }
         }
 
         @Override
         protected void undoDiffAtGetResultsMoment(ThreadInfo ti) {
-            if (ti.diffAtGetResultsMoment>0) {
-                applyDiffToTopNode(ti, -ti.diffAtGetResultsMoment);
-                ti.diffAtGetResultsMoment = 0;
+            if (ti.diffAtGetResultsMoment0>0) {
+                applyDiffToTopNode(ti, -ti.diffAtGetResultsMoment0, -ti.diffAtGetResultsMoment1);
+                ti.diffAtGetResultsMoment0 = 0;
             }
         }
 
-        private void applyDiffToTopNode(ThreadInfo ti, long diff) {
+        private long getThreadTime(ThreadInfo ti, long diff0) {
+            if (isCollectingTwoTimeStamps()) {
+                SampledThreadInfo sti = lastStackTrace.get().get(Long.valueOf(ti.threadId));
+
+                if (sti!=null) {
+                    if (sti.threadCpuTime != -1) {
+                        return sti.threadCpuTime;
+                    }
+                    if (sti.getThreadState() == Thread.State.RUNNABLE) {
+                        return diff0;
+                    }
+                }
+            }
+            return 0;
+        }
+
+        private void applyDiffToTopNode(ThreadInfo ti, long diff0, long diff1) {
             TimedCPUCCTNode top = ti.peek();
 
             if (top instanceof MethodCPUCCTNode) {
-                top.addNetTime0(diff);
+                top.addNetTime0(diff0);
                 if (isCollectingTwoTimeStamps()) {
-                    SampledThreadInfo sti = lastStackTrace.get().get(Long.valueOf(ti.threadId));
-
-                    if (sti!=null && sti.getThreadState() == Thread.State.RUNNABLE) {
-                        top.addNetTime1(diff);
-                    }
+                    top.addNetTime1(diff1);
                 }
             }
         }

visualvm/libs.profiler/lib.profiler/src/org/graalvm/visualvm/lib/jfluid/results/cpu/ThreadInfo.java

@@ -52,8 +52,8 @@ public class ThreadInfo {
     // processing of data is resumed, we need to subtract this value back from that node.
     // This is effectively the self time for the last invocation of the top method on stack - if we would not keep
     // it separately, it would not be reported
-    long diffAtGetResultsMoment; // diff between last methodEntry and current moment timestamp -
-    //  we will have to compensate for the processing time
+    long diffAtGetResultsMoment0; // diff between last methodEntry and current moment timestamp - we will have to compensate for the processing time
+    long diffAtGetResultsMoment1; // as above, but for thread CPU time
 
     //~ Instance fields ------------------------------------------------------------------------------------------------------
     final private Object stackLock = new Object();