Improve server tick loop

See Tuinity/Moonrise@0b842a9

Author: Spottedleaf

paper-server/patches/features/0032-fixup-paper-File-Patches.patch

@@ -0,0 +1,83 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Spottedleaf <Spottedleaf@users.noreply.github.com>
+Date: Sat, 4 Oct 2025 11:13:55 -0700
+Subject: [PATCH] fixup! Moonrise optimisation patches
+
+
+diff --git a/ca/spottedleaf/moonrise/patches/chunk_system/scheduling/ChunkHolderManager.java b/ca/spottedleaf/moonrise/patches/chunk_system/scheduling/ChunkHolderManager.java
+index 80f13315e8c7c0e3c82ab98f92387f56bb3b6481..e03faa94df6c77ab4f3f5d9ffe107220387a0dde 100644
+--- a/ca/spottedleaf/moonrise/patches/chunk_system/scheduling/ChunkHolderManager.java
++++ b/ca/spottedleaf/moonrise/patches/chunk_system/scheduling/ChunkHolderManager.java
+@@ -1472,6 +1472,11 @@ public final class ChunkHolderManager {
+ 
+         boolean ret = false;
+ 
++        if (pendingFullLoadUpdate.isEmpty()) {
++            // avoid allocating changedFullStatus
++            return ret;
++        }
++
+         final List<NewChunkHolder> changedFullStatus = new ArrayList<>();
+ 
+         NewChunkHolder holder;
+diff --git a/ca/spottedleaf/moonrise/patches/chunk_system/scheduling/ChunkTaskScheduler.java b/ca/spottedleaf/moonrise/patches/chunk_system/scheduling/ChunkTaskScheduler.java
+index 57f11ed1c8dfe7a10fddc53bcd2abc8cac29b2f4..c47e77ceb15948cbd4a2a370738843c02542f6c1 100644
+--- a/ca/spottedleaf/moonrise/patches/chunk_system/scheduling/ChunkTaskScheduler.java
++++ b/ca/spottedleaf/moonrise/patches/chunk_system/scheduling/ChunkTaskScheduler.java
+@@ -338,6 +338,17 @@ public final class ChunkTaskScheduler {
+         return this.mainThreadExecutor.executeTask();
+     }
+ 
++    // run only tasks queued before this function was invoked
++    public void executeAllRecentlyQueuedMainThreadTasks() {
++        // note: order of retrieval is important to avoid race conditions
++        final long executed = this.mainThreadExecutor.getTotalTasksExecuted();
++        final long scheduled = this.mainThreadExecutor.getTotalTasksScheduled();
++
++        final long left = scheduled - executed;
++        // may execute more tasks than expected due to recursion
++        for (long i = 0; i < left && this.mainThreadExecutor.executeTask(); ++i);
++    }
++
+     public void raisePriority(final int x, final int z, final Priority priority) {
+         this.chunkHolderManager.raisePriority(x, z, priority);
+     }
+diff --git a/net/minecraft/server/MinecraftServer.java b/net/minecraft/server/MinecraftServer.java
+index 201e80364daeb02b5aed8327eef5140053b00aa0..20efafc39eb219158c5dc126f527cc009fe15b15 100644
+--- a/net/minecraft/server/MinecraftServer.java
++++ b/net/minecraft/server/MinecraftServer.java
+@@ -1126,16 +1126,31 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+             // execute small amounts of other tasks just in case the number of tasks we are
+             // draining is large - chunk system and packet processing may be latency sensitive
+ 
+-            // TODO - Chunk System mid-tick
++            ((ca.spottedleaf.moonrise.patches.chunk_system.server.ChunkSystemMinecraftServer)this).moonrise$executeMidTickTasks(); // Paper - rewrite chunk system
+             this.packetProcessor.executeSinglePacket();
+         }
+         profiler.popPush("moonrise:run_all_packets");
+         while (this.packetProcessor.executeSinglePacket()) {
+             // execute possibly latency sensitive chunk system tasks (see above)
+-            // TODO - Chunk System mid-tick
++            ((ca.spottedleaf.moonrise.patches.chunk_system.server.ChunkSystemMinecraftServer)this).moonrise$executeMidTickTasks(); // Paper - rewrite chunk system
+         }
+         profiler.popPush("moonrise:run_all_chunk");
+-        // TODO - Chunk System tasks
++        // Paper start - rewrite chunk system
++        for (final ServerLevel world : this.getAllLevels()) {
++            profiler.push(world.toString() + " " + world.dimension().location()); // keep same formatting from regular tick, see tickChildren
++
++            // note: legacy tasks may expect a distance manager update
++            profiler.push("moonrise:distance_manager_update");
++            ((ca.spottedleaf.moonrise.patches.chunk_system.level.ChunkSystemServerLevel)world).moonrise$getChunkTaskScheduler().chunkHolderManager.processTicketUpdates();
++            profiler.popPush("moonrise:legacy_chunk_tasks");
++            world.getChunkSource().mainThreadProcessor.executeAllRecentInternalTasks();
++            profiler.popPush("moonrise:chunk_system_tasks");
++            ((ca.spottedleaf.moonrise.patches.chunk_system.level.ChunkSystemServerLevel)world).moonrise$getChunkTaskScheduler().executeAllRecentlyQueuedMainThreadTasks();
++            profiler.pop();
++
++            profiler.pop(); // world name
++        }
++        // Paper end - rewrite chunk system
+         profiler.pop(); // moonrise:run_all_chunk
+         profiler.pop(); // moonrise:run_all_tasks
+ 

paper-server/patches/features/0033-fixup-Moonrise-optimisation-patches.patch

@@ -0,0 +1,34 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Spottedleaf <Spottedleaf@users.noreply.github.com>
+Date: Sat, 4 Oct 2025 11:15:18 -0700
+Subject: [PATCH] fixup! paper File Patches
+
+
+diff --git a/net/minecraft/util/thread/BlockableEventLoop.java b/net/minecraft/util/thread/BlockableEventLoop.java
+index 9407433c431fb4e945a9db1ebd572b0764f47841..ef29b33db3a665621f35a7480892c65fd9045a5a 100644
+--- a/net/minecraft/util/thread/BlockableEventLoop.java
++++ b/net/minecraft/util/thread/BlockableEventLoop.java
+@@ -33,6 +33,23 @@ public abstract class BlockableEventLoop<R extends Runnable> implements Profiler
+         MetricsRegistry.INSTANCE.add(this);
+     }
+ 
++    // Paper start
++    public final void executeAllRecentInternalTasks() {
++        final int pending = this.pendingRunnables.size();
++
++        // note: due to possible recursive execution, we may execute more tasks than we want to
++
++        for (int i = 0; i < pending; ++i) {
++            final R run = this.pendingRunnables.poll();
++            if (run == null) {
++                // recursion
++                break;
++            }
++            this.doRunTask(run);
++        }
++    }
++    // Paper end
++
+     protected abstract boolean shouldRun(R runnable);
+ 
+     public boolean isSameThread() {

paper-server/patches/features/0034-fixup-paper-File-Patches.patch

@@ -0,0 +1,92 @@
+package ca.spottedleaf.moonrise.common.time;
+
+
+/**
+ * A Schedule is an object that can be used to maintain a periodic schedule for an event of interest.
+ */
+public final class Schedule {
+
+    private long lastPeriod;
+
+    /**
+     * Initialises a schedule with the provided period.
+     * @param firstPeriod The last time an event of interest occurred.
+     * @see #setLastPeriod(long)
+     */
+    public Schedule(final long firstPeriod) {
+        this.lastPeriod = firstPeriod;
+    }
+
+    /**
+     * Updates the last period to the specified value. This call sets the last "time" the event
+     * of interest took place at. Thus, the value returned by {@link #getDeadline(long)} is
+     * the provided time plus the period length provided to {@code getDeadline}.
+     * @param value The value to set the last period to.
+     */
+    public void setLastPeriod(final long value) {
+        this.lastPeriod = value;
+    }
+
+    /**
+     * Returns the last time the event of interest should have taken place.
+     */
+    public long getLastPeriod() {
+        return this.lastPeriod;
+    }
+
+    /**
+     * Returns the number of times the event of interest should have taken place between the last
+     * period and the provided time given the period between each event.
+     * @param periodLength The length of the period between events in ns.
+     * @param time The provided time.
+     */
+    public long getPeriodsAhead(final long periodLength, final long time) {
+        final long difference = time - this.lastPeriod;
+        final long ret = Math.abs(difference) / periodLength;
+        return difference >= 0 ? ret : -ret;
+    }
+
+    /**
+     * Returns the next starting deadline for the event of interest to take place,
+     * given the provided period length.
+     * @param periodLength The provided period length.
+     */
+    public long getDeadline(final long periodLength) {
+        return this.lastPeriod + periodLength;
+    }
+
+    /**
+     * Adjusts the last period so that the next starting deadline returned is the next period specified,
+     * given the provided period length.
+     * @param nextPeriod The specified next starting deadline.
+     * @param periodLength The specified period length.
+     */
+    public void setNextPeriod(final long nextPeriod, final long periodLength) {
+        this.lastPeriod = nextPeriod - periodLength;
+    }
+
+    /**
+     * Increases the last period by the specified number of periods and period length.
+     * The specified number of periods may be < 0, in which case the last period
+     * will decrease.
+     * @param periods The specified number of periods.
+     * @param periodLength The specified period length.
+     */
+    public void advanceBy(final long periods, final long periodLength) {
+        this.lastPeriod += periods * periodLength;
+    }
+
+    /**
+     * Sets the last period so that it is the specified number of periods ahead
+     * given the specified time and period length.
+     * @param periodsToBeAhead Specified number of periods to be ahead by.
+     * @param periodLength The specified period length.
+     * @param time The specified time.
+     */
+    public void setPeriodsAhead(final long periodsToBeAhead, final long periodLength, final long time) {
+        final long periodsAhead = this.getPeriodsAhead(periodLength, time);
+        final long periodsToAdd = periodsToBeAhead - periodsAhead;
+
+        this.lastPeriod -= periodsToAdd * periodLength;
+    }
+}