Reduce impact of tick time calculations (#13188)

jpenilla · web-flow · commit af1823d47ca8 · 2025-10-14T22:15:07.000-07:00
diff --git a/paper-server/patches/sources/net/minecraft/server/MinecraftServer.java.patch b/paper-server/patches/sources/net/minecraft/server/MinecraftServer.java.patch
@@ -41,7 +41,7 @@
      private int playerIdleTimeout;
      private final long[] tickTimesNanos = new long[100];
      private long aggregatedTickTimesNanos = 0L;
-@@ -278,10 +_,91 @@
+@@ -278,10 +_,108 @@
      private final DiscontinuousFrame tickFrame;
      private final PacketProcessor packetProcessor;
  
@@ -70,7 +70,6 @@
 +    // Paper start - improve tick loop
 +    public final ca.spottedleaf.moonrise.common.time.TickData tickTimes1s  = new ca.spottedleaf.moonrise.common.time.TickData(java.util.concurrent.TimeUnit.SECONDS.toNanos(1L));
 +    public final ca.spottedleaf.moonrise.common.time.TickData tickTimes5s  = new ca.spottedleaf.moonrise.common.time.TickData(java.util.concurrent.TimeUnit.SECONDS.toNanos(5L));
-+    private volatile @Nullable ca.spottedleaf.moonrise.common.time.TickData.TickReportData tickReport5s;
 +    public final ca.spottedleaf.moonrise.common.time.TickData tickTimes10s = new ca.spottedleaf.moonrise.common.time.TickData(java.util.concurrent.TimeUnit.SECONDS.toNanos(10L));
 +    public final ca.spottedleaf.moonrise.common.time.TickData tickTimes15s = new ca.spottedleaf.moonrise.common.time.TickData(java.util.concurrent.TimeUnit.SECONDS.toNanos(15L));
 +    public final ca.spottedleaf.moonrise.common.time.TickData tickTimes1m  = new ca.spottedleaf.moonrise.common.time.TickData(java.util.concurrent.TimeUnit.MINUTES.toNanos(1L));
@@ -82,45 +81,63 @@
 +    private long lastTickStart;
 +    private long currentTickStart;
 +    private long scheduledTickStart;
-+    private volatile double[] tps = new double[]{0.0, 0.0, 0.0};
++    private final Object statsLock = new Object();
++    private @Nullable double[] tps;
++    private @Nullable ca.spottedleaf.moonrise.common.time.TickData.MSPTData msptData5s;
 +
 +    private void addTickTime(final ca.spottedleaf.moonrise.common.time.TickTime time) {
-+        org.spigotmc.AsyncCatcher.catchOp("addTickTime");
-+        this.tickTimes1s.addDataFrom(time);
-+        this.tickTimes5s.addDataFrom(time);
-+        this.tickReport5s = this.tickTimes5s.generateTickReport(null, System.nanoTime(), this.tickRateManager().nanosecondsPerTick());
-+        this.tickTimes10s.addDataFrom(time);
-+        this.tickTimes15s.addDataFrom(time);
-+        this.tickTimes1m.addDataFrom(time);
-+        this.tickTimes5m.addDataFrom(time);
-+        this.tickTimes15m.addDataFrom(time);
-+        this.tps = this.computeTPS();
++        synchronized (this.statsLock) {
++            this.tickTimes1s.addDataFrom(time);
++            this.tickTimes5s.addDataFrom(time);
++            this.tickTimes10s.addDataFrom(time);
++            this.tickTimes15s.addDataFrom(time);
++            this.tickTimes1m.addDataFrom(time);
++            this.tickTimes5m.addDataFrom(time);
++            this.tickTimes15m.addDataFrom(time);
++            this.clearTickTimeStatistics();
++        }
++    }
++
++    private void clearTickTimeStatistics() {
++        this.msptData5s = null;
++        this.tps = null;
 +    }
 +
-+    private static double getTPS(final ca.spottedleaf.moonrise.common.time.TickData tickData, final long timeNow, final long tickInterval) {
-+        final ca.spottedleaf.moonrise.common.time.TickData.TickReportData tickReportData = tickData.generateTickReport(null, timeNow, tickInterval);
-+        if (tickReportData == null) {
++    private static double getTPS(final ca.spottedleaf.moonrise.common.time.TickData tickData, final long tickInterval) {
++        final Double avg = tickData.getTPSAverage(null, tickInterval);
++        if (avg == null) {
 +            return 1.0E9 / (double)tickInterval;
 +        }
 +
-+        return tickReportData.tpsData().segmentAll().average();
++        return avg;
 +    }
 +
 +    public double[] getTPS() {
-+        return this.tps.clone();
++        synchronized (this.statsLock) {
++            double[] tps = this.tps;
++            if (tps == null) {
++                tps = this.computeTPS();
++                this.tps = tps;
++            }
++            return tps.clone();
++        }
 +    }
 +
-+    public @Nullable ca.spottedleaf.moonrise.common.time.TickData.TickReportData getTickReport5s() {
-+        return this.tickReport5s;
++    public @Nullable ca.spottedleaf.moonrise.common.time.TickData.MSPTData getMSPTData5s() {
++        synchronized (this.statsLock) {
++            if (this.msptData5s == null) {
++                this.msptData5s = this.tickTimes5s.getMSPTData(null, this.tickRateManager().nanosecondsPerTick());
++            }
++            return this.msptData5s;
++        }
 +    }
 +
 +    public double[] computeTPS() {
-+        final long now = System.nanoTime();
 +        final long interval = this.tickRateManager().nanosecondsPerTick();
 +        return new double[] {
-+            getTPS(this.tickTimes1m, now, interval),
-+            getTPS(this.tickTimes5m, now, interval),
-+            getTPS(this.tickTimes15m, now, interval)
++            getTPS(this.tickTimes1m, interval),
++            getTPS(this.tickTimes5m, interval),
++            getTPS(this.tickTimes15m, interval)
 +        };
 +    }
 +    // Paper end - improve tick loop
diff --git a/paper-server/src/main/java/ca/spottedleaf/moonrise/common/time/TickData.java b/paper-server/src/main/java/ca/spottedleaf/moonrise/common/time/TickData.java
@@ -103,6 +103,67 @@ private static record TickInformation(
         long tickTimeCPU
     ) {}
 
+    public Double getTPSAverage(final TickTime inProgress, final long tickInterval) {
+        return this.getTPSAverage(inProgress, tickInterval, false);
+    }
+
+    public Double getTPSAverage(final TickTime inProgress, final long tickInterval, final boolean createFakeTick) {
+        if (this.timeData.isEmpty() && inProgress == null) {
+            return null;
+        }
+
+        final List<TickTime> allData = new ArrayList<>(this.timeData);
+        if (inProgress != null) {
+            allData.add(inProgress);
+        }
+
+        final List<TickInformation> collapsedData = collapseData(allData, tickInterval, createFakeTick);
+        if (collapsedData.isEmpty()) {
+            return null;
+        }
+
+        long totalTimeBetweenTicks = 0L;
+        int collectedTicks = 0;
+        for (final TickInformation time : collapsedData) {
+            totalTimeBetweenTicks += time.differenceFromLastTick();
+            ++collectedTicks;
+        }
+        return (double)collectedTicks / ((double)totalTimeBetweenTicks / 1.0E9);
+    }
+
+    public record MSPTData(double avg, long[] rawData) {}
+
+    public MSPTData getMSPTData(final TickTime inProgress, final long tickInterval) {
+        return this.getMSPTData(inProgress, tickInterval, false);
+    }
+
+    public MSPTData getMSPTData(final TickTime inProgress, final long tickInterval, final boolean createFakeTick) {
+        if (this.timeData.isEmpty() && inProgress == null) {
+            return null;
+        }
+
+        final List<TickTime> allData = new ArrayList<>(this.timeData);
+        if (inProgress != null) {
+            allData.add(inProgress);
+        }
+
+        final List<TickInformation> collapsedData = collapseData(allData, tickInterval, createFakeTick);
+        if (collapsedData.isEmpty()) {
+            return null;
+        }
+
+        long totalTimeTicking = 0L;
+        int collectedTicks = 0;
+        final long[] timePerTickDataRaw = new long[collapsedData.size()];
+        for (int i = 0; i < collapsedData.size(); ++i) {
+            final TickInformation time = collapsedData.get(i);
+            totalTimeTicking += time.tickTime();
+            timePerTickDataRaw[i] = time.tickTime();
+            ++collectedTicks;
+        }
+        return new MSPTData((double)totalTimeTicking / (double)collectedTicks * 1.0E-6, timePerTickDataRaw);
+    }
+
     public TickReportData generateTickReport(final TickTime inProgress, final long endTime, final long tickInterval) {
         return this.generateTickReport(inProgress, endTime, tickInterval, false);
     }
@@ -118,6 +179,11 @@ public TickReportData generateTickReport(final TickTime inProgress, final long e
             allData.add(inProgress);
         }
 
+        final List<TickInformation> collapsedData = collapseData(allData, tickInterval, createFakeTick);
+        if (collapsedData.isEmpty()) {
+            return null;
+        }
+
         final long intervalStart = allData.get(0).tickStart();
         final long intervalEnd = allData.get(allData.size() - 1).tickEnd();
 
@@ -139,90 +205,6 @@ public TickReportData generateTickReport(final TickTime inProgress, final long e
             }
         }
 
-        // we only care about ticks, but because of inbetween tick task execution
-        // there will be data in allData that isn't ticks. But, that data cannot
-        // be ignored since it contributes to utilisation.
-        // So, we will "compact" the data by merging any inbetween tick times
-        // the next tick.
-        // If there is no "next tick", then we will create one.
-        final List<TickInformation> collapsedData = new ArrayList<>();
-        for (int i = 0, len = allData.size(); i < len; ++i) {
-            final List<TickTime> toCollapse = new ArrayList<>();
-            TickTime lastTick = null;
-            for (;i < len; ++i) {
-                final TickTime time = allData.get(i);
-                if (!time.isTickExecution()) {
-                    toCollapse.add(time);
-                    continue;
-                }
-                lastTick = time;
-                break;
-            }
-
-            if (toCollapse.isEmpty()) {
-                // nothing to collapse
-                final TickTime last = allData.get(i);
-                collapsedData.add(
-                    new TickInformation(
-                        last.differenceFromLastTick(tickInterval),
-                        last.tickLength(),
-                        last.supportCPUTime() ? last.tickCpuTime() : 0L
-                    )
-                );
-            } else {
-                long totalTickTime = 0L;
-                long totalCpuTime = 0L;
-                for (int k = 0, len2 = toCollapse.size(); k < len2; ++k) {
-                    final TickTime time = toCollapse.get(k);
-                    totalTickTime += time.tickLength();
-                    totalCpuTime += time.supportCPUTime() ? time.tickCpuTime() : 0L;
-                }
-                if (i < len) {
-                    // we know there is a tick to collapse into
-                    final TickTime last = allData.get(i);
-                    collapsedData.add(
-                        new TickInformation(
-                            last.differenceFromLastTick(tickInterval),
-                            last.tickLength() + totalTickTime,
-                            (last.supportCPUTime() ? last.tickCpuTime() : 0L) + totalCpuTime
-                        )
-                    );
-                } else if (createFakeTick) {
-                    // we do not have a tick to collapse into, so we must make one up
-                    // we will assume that the tick is "starting now" and ongoing
-
-                    // compute difference between imaginary tick and last tick
-                    final long differenceBetweenTicks;
-                    if (lastTick != null) {
-                        // we have a last tick, use it
-                        differenceBetweenTicks = lastTick.tickStart();
-                    } else {
-                        // we don't have a last tick, so we must make one up that makes sense
-                        // if the current interval exceeds the max tick time, then use it
-
-                        // Otherwise use the interval length.
-                        // This is how differenceFromLastTick() works on TickTime when there is no previous interval.
-                        differenceBetweenTicks = Math.max(
-                            tickInterval, totalTickTime
-                        );
-                    }
-
-                    collapsedData.add(
-                        new TickInformation(
-                            differenceBetweenTicks,
-                            totalTickTime,
-                            totalCpuTime
-                        )
-                    );
-                }
-            }
-        }
-
-
-        if (collapsedData.isEmpty()) {
-            return null;
-        }
-
         final int collectedTicks = collapsedData.size();
         final long[] tickStartToStartDifferences = new long[collectedTicks];
         final long[] timePerTickDataRaw = new long[collectedTicks];
@@ -303,6 +285,88 @@ public TickReportData generateTickReport(final TickTime inProgress, final long e
         );
     }
 
+    private static List<TickInformation> collapseData(final List<TickTime> allData, final long tickInterval, final boolean createFakeTick) {
+        // we only care about ticks, but because of inbetween tick task execution
+        // there will be data in allData that isn't ticks. But, that data cannot
+        // be ignored since it contributes to utilisation.
+        // So, we will "compact" the data by merging any inbetween tick times
+        // the next tick.
+        // If there is no "next tick", then we will create one.
+        final List<TickInformation> collapsedData = new ArrayList<>();
+        for (int i = 0, len = allData.size(); i < len; ++i) {
+            final List<TickTime> toCollapse = new ArrayList<>();
+            TickTime lastTick = null;
+            for (;i < len; ++i) {
+                final TickTime time = allData.get(i);
+                if (!time.isTickExecution()) {
+                    toCollapse.add(time);
+                    continue;
+                }
+                lastTick = time;
+                break;
+            }
+
+            if (toCollapse.isEmpty()) {
+                // nothing to collapse
+                final TickTime last = allData.get(i);
+                collapsedData.add(
+                    new TickInformation(
+                        last.differenceFromLastTick(tickInterval),
+                        last.tickLength(),
+                        last.supportCPUTime() ? last.tickCpuTime() : 0L
+                    )
+                );
+            } else {
+                long totalTickTime = 0L;
+                long totalCpuTime = 0L;
+                for (int k = 0, len2 = toCollapse.size(); k < len2; ++k) {
+                    final TickTime time = toCollapse.get(k);
+                    totalTickTime += time.tickLength();
+                    totalCpuTime += time.supportCPUTime() ? time.tickCpuTime() : 0L;
+                }
+                if (i < len) {
+                    // we know there is a tick to collapse into
+                    final TickTime last = allData.get(i);
+                    collapsedData.add(
+                        new TickInformation(
+                            last.differenceFromLastTick(tickInterval),
+                            last.tickLength() + totalTickTime,
+                            (last.supportCPUTime() ? last.tickCpuTime() : 0L) + totalCpuTime
+                        )
+                    );
+                } else if (createFakeTick) {
+                    // we do not have a tick to collapse into, so we must make one up
+                    // we will assume that the tick is "starting now" and ongoing
+
+                    // compute difference between imaginary tick and last tick
+                    final long differenceBetweenTicks;
+                    if (lastTick != null) {
+                        // we have a last tick, use it
+                        differenceBetweenTicks = lastTick.tickStart();
+                    } else {
+                        // we don't have a last tick, so we must make one up that makes sense
+                        // if the current interval exceeds the max tick time, then use it
+
+                        // Otherwise use the interval length.
+                        // This is how differenceFromLastTick() works on TickTime when there is no previous interval.
+                        differenceBetweenTicks = Math.max(
+                            tickInterval, totalTickTime
+                        );
+                    }
+
+                    collapsedData.add(
+                        new TickInformation(
+                            differenceBetweenTicks,
+                            totalTickTime,
+                            totalCpuTime
+                        )
+                    );
+                }
+            }
+        }
+        return collapsedData;
+    }
+
     public static final record TickReportData(
         int collectedTicks,
         long collectedTickIntervalStart,
diff --git a/paper-server/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/paper-server/src/main/java/org/bukkit/craftbukkit/CraftServer.java
@@ -2695,14 +2695,14 @@ public UnsafeValues getUnsafe() {
 
     @Override
     public long[] getTickTimes() {
-        final TickData.TickReportData reportData = this.getServer().getTickReport5s();
-        return reportData == null ? new long[0] : reportData.timePerTickData().rawData().clone();
+        final TickData.MSPTData reportData = this.getServer().getMSPTData5s();
+        return reportData == null ? new long[0] : reportData.rawData().clone();
     }
 
     @Override
     public double getAverageTickTime() {
-        final TickData.TickReportData reportData = this.getServer().getTickReport5s();
-        return reportData == null ? 0.0 : reportData.timePerTickData().segmentAll().average() * 1.0E-6D;
+        final TickData.MSPTData reportData = this.getServer().getMSPTData5s();
+        return reportData == null ? 0.0 : reportData.avg();
     }
 
     private final org.bukkit.Server.Spigot spigot = new org.bukkit.Server.Spigot() {
