[Wisp] Port WispCounterMXBean and PerfCounterMonitor to JDK17.

src/java.base/share/classes/com/alibaba/wisp/engine/ScheduledWispEngine.java

@@ -587,6 +587,7 @@ protected void closeEngineSelector() {
     @Override
     public void shutdown() {
         hasBeenShutdown = true;
+        deRegisterPerfCounter();
         if (WispEngine.current().current == threadTask) {
             doShutdown();
         } else {

src/java.base/share/classes/com/alibaba/wisp/engine/Wisp2Engine.java

@@ -252,6 +252,7 @@ public void shutdown() {
             return;
         }
         hasBeenShutdown = true;
+        deRegisterPerfCounter();
         group.scheduler.executeWithCarrierThread(new StealAwareRunnable() {
             @Override
             public void run() {

src/java.base/share/classes/com/alibaba/wisp/engine/Wisp2Scheduler.java

@@ -111,6 +111,7 @@ public void run() {
                 engine.group = group;
                 engine.carrier = this;
                 group.carrierEngines.add(engine);
+                engine.registerPerfCounter();
                 runCarrier(engine);
             } finally {
                 WispEngine.carrierThreads.remove(thread);
@@ -461,6 +462,8 @@ public void run() {
                 last = cs[i];
             }
             carriers = cs;
+            Wisp2Engine engine = (Wisp2Engine) JLA.getWispEngine(thread);
+            engine.deRegisterPerfCounter();
         }
     }
 

src/java.base/share/classes/com/alibaba/wisp/engine/WispCounter.java

@@ -1,14 +1,14 @@
 package com.alibaba.wisp.engine;
 
-final class WispCounter {
+final public class WispCounter {
 
     private long switchCount = 0;
 
     private long waitTimeTotal = 0;
 
     private long runningTimeTotal = 0;
 
-    private long completeTaskCount = 0;
+    private long completedTaskCount = 0;
 
     private long createTaskCount = 0;
 
@@ -26,18 +26,26 @@ final class WispCounter {
 
     private long totalEnqueueTime = 0;
 
+    private long maxEnqueueTime = 0;
+
     private long enqueueCount = 0;
 
     private long totalExecutionTime = 0;
 
+    private long maxExecutionTime = 0;
+
     private long executionCount = 0;
 
     private long totalWaitSocketIOTime = 0;
 
+    private long maxWaitSocketIOTime = 0;
+
     private long waitSocketIOCount = 0;
 
     private long totalBlockingTime = 0;
 
+    private long maxBlockingTime = 0;
+
     private long unparkFromJvmCount = 0;
 
     WispEngine engine;
@@ -46,55 +54,56 @@ private WispCounter(WispEngine engine) {
         this.engine = engine;
     }
 
-    boolean getRunningState() {
-        return engine.isRunning();
+    public boolean getRunningState() {
+        WispEngine e = engine;
+        return e != null ? e.isRunning() : false;
     }
 
     void incrementSwitchCount() {
         switchCount++;
     }
 
-    long getSwitchCount() {
+    public long getSwitchCount() {
         return switchCount;
     }
 
     void incrementCompleteTaskCount() {
-        completeTaskCount++;
+        completedTaskCount++;
     }
 
     void incrementRunningTimeTotal(long value) {
         runningTimeTotal += value;
     }
 
-    long getRunningTimeTotal() {
+    public long getRunningTimeTotal() {
         return runningTimeTotal;
     }
 
     void incrementWaitTime(long value) {
         waitTimeTotal += value;
     }
 
-    long getWaitTimeTotal() {
+    public long getWaitTimeTotal() {
         return waitTimeTotal;
     }
 
-    long getCompleteTaskCount() {
-        return completeTaskCount;
+    public long getCompletedTaskCount() {
+        return completedTaskCount;
     }
 
     void incrementCreateTaskCount() {
         createTaskCount++;
     }
 
-    long getCreateTaskCount() {
+    public long getCreateTaskCount() {
         return createTaskCount;
     }
 
     void incrementParkCount() {
         parkCount++;
     }
 
-    long getParkCount() {
+    public long getParkCount() {
         return parkCount;
     }
 
@@ -103,120 +112,165 @@ void incrementUnparkInterruptSelectorCount() {
         unparkInterruptSelectorCount++;
     }
 
-    long getUnparkInterruptSelectorCount() {
+    public long getUnparkInterruptSelectorCount() {
         return unparkInterruptSelectorCount;
     }
 
     void incrementSelectableIOCount() {
         selectableIOCount++;
     }
 
-    long getSelectableIOCount() {
+    public long getSelectableIOCount() {
         return selectableIOCount;
     }
 
     void incrementTimeOutCount() {
         timeOutCount++;
     }
 
-    long getTimeOutCount() {
+    public long getTimeOutCount() {
         return timeOutCount;
     }
 
     void incrementEventLoopCount() {
         eventLoopCount++;
     }
 
-    long getEventLoopCount() {
+    public long getEventLoopCount() {
         return eventLoopCount;
     }
 
     void incrementTotalEnqueueTime(long value) {
         totalEnqueueTime += value;
         enqueueCount++;
+        if (value > maxEnqueueTime) {
+            maxEnqueueTime = value;
+        }
     }
 
-    long getTotalEnqueueTime() {
+    public long getTotalEnqueueTime() {
         return totalEnqueueTime;
     }
 
-    long getEnqueueCount() {
+    public long getEnqueueCount() {
         return enqueueCount;
     }
 
     void incrementTotalExecutionTime(long value) {
         totalExecutionTime += value;
         executionCount++;
+        if (value > maxExecutionTime) {
+            maxExecutionTime = value;
+        }
     }
 
-    long getTotalExecutionTime() {
+    public long getTotalExecutionTime() {
         return totalExecutionTime;
     }
 
-    long getExecutionCount() {
+    public long getExecutionCount() {
         return executionCount;
     }
 
     void incrementTotalWaitSocketIOTime(long value) {
         totalWaitSocketIOTime += value;
         waitSocketIOCount++;
+        if (value > maxWaitSocketIOTime) {
+            maxWaitSocketIOTime = value;
+        }
     }
 
-    long getTotalWaitSocketIOTime() {
+    public long getTotalWaitSocketIOTime() {
         return totalWaitSocketIOTime;
     }
 
-    long getWaitSocketIOCount() {
+    public long getWaitSocketIOCount() {
         return waitSocketIOCount;
     }
 
     void incrementTotalBlockingTime(long value) {
         totalBlockingTime += value;
         unparkCount++;
+        if (value > maxBlockingTime) {
+            maxBlockingTime = value;
+        }
     }
 
-    long getTotalBlockingTime() {
+    public long getTotalBlockingTime() {
         return totalBlockingTime;
     }
 
-    long getUnparkCount() {
+    public long getUnparkCount() {
         return unparkCount;
     }
 
-    public long getQueueLength() {
-        return engine.getTaskQueueLength();
+    public long getTaskQueueLength() {
+        WispEngine e = engine;
+        return e != null ? e.getTaskQueueLength() : 0;
     }
 
-    long getNumberOfRunningTasks() {
-        return engine.getRunningTaskCount();
+    public long getRunningTaskCount() {
+        WispEngine e = engine;
+        return e != null ? e.getRunningTaskCount() : 0;
     }
 
     void incrementUnparkFromJvmCount() {
         unparkFromJvmCount++;
     }
 
-    long getUnparkFromJvmCount() {
+    public long getUnparkFromJvmCount() {
         return unparkFromJvmCount;
     }
 
+    public long getMaxEnqueueTime() {
+        return maxEnqueueTime;
+    }
+
+    public long getMaxExecutionTime() {
+        return maxExecutionTime;
+    }
+
+    public long getMaxWaitSocketIOTime() {
+        return maxWaitSocketIOTime;
+    }
+
+    public long getMaxBlockingTime() {
+        return maxBlockingTime;
+    }
+
     WispCounter() {}
 
     void assign(WispCounter counter) {
-        createTaskCount =  counter.createTaskCount;
-        completeTaskCount = counter.completeTaskCount;
+        createTaskCount = counter.createTaskCount;
+        completedTaskCount = counter.completedTaskCount;
         totalEnqueueTime = counter.totalEnqueueTime;
         enqueueCount = counter.enqueueCount;
+        maxEnqueueTime = counter.maxEnqueueTime;
         totalExecutionTime = counter.totalExecutionTime;
         executionCount = counter.executionCount;
+        maxExecutionTime = counter.maxExecutionTime;
         totalBlockingTime = counter.totalBlockingTime;
         unparkCount = counter.unparkCount;
+        maxBlockingTime = counter.maxBlockingTime;
         totalWaitSocketIOTime = counter.totalWaitSocketIOTime;
         waitSocketIOCount = counter.waitSocketIOCount;
+        maxWaitSocketIOTime = counter.maxWaitSocketIOTime;
         switchCount = counter.switchCount;
         unparkFromJvmCount = counter.unparkFromJvmCount;
     }
 
-    public static WispCounter create(WispEngine engine) {
+    void resetMaxValue() {
+        maxEnqueueTime = 0;
+        maxExecutionTime = 0;
+        maxWaitSocketIOTime = 0;
+        maxBlockingTime = 0;
+    }
+
+    void cleanup() {
+        engine = null;
+    }
+
+    static WispCounter create(WispEngine engine) {
         return new WispCounter(engine);
     }
 }