From 4e230b394f525bded6ff3c9e4f8f3ef261ddc404 Mon Sep 17 00:00:00 2001 From: BillyGalbreath Date: Fri, 22 Jul 2022 22:48:25 -0500 Subject: [PATCH] Remove Timings and Mojang's Profiler (#1057) --- ...d-removal-warning-to-timings-command.patch | 24 - ...ofiler.patch => 0046-Spark-Profiler.patch} | 0 ...ch => 0047-Add-local-difficulty-api.patch} | 0 ...-API.patch => 0048-Chat-Preview-API.patch} | 0 patches/api/0049-Remove-Timings.patch | 151 ++ patches/server/0290-Remove-Timings.patch | 1060 +++++++++ .../server/0291-Remove-Mojang-Profiler.patch | 1886 +++++++++++++++++ 7 files changed, 3097 insertions(+), 24 deletions(-) delete mode 100644 patches/api/0046-Add-removal-warning-to-timings-command.patch rename patches/api/{0047-Spark-Profiler.patch => 0046-Spark-Profiler.patch} (100%) rename patches/api/{0048-Add-local-difficulty-api.patch => 0047-Add-local-difficulty-api.patch} (100%) rename patches/api/{0049-Chat-Preview-API.patch => 0048-Chat-Preview-API.patch} (100%) create mode 100644 patches/api/0049-Remove-Timings.patch create mode 100644 patches/server/0290-Remove-Timings.patch create mode 100644 patches/server/0291-Remove-Mojang-Profiler.patch diff --git a/patches/api/0046-Add-removal-warning-to-timings-command.patch b/patches/api/0046-Add-removal-warning-to-timings-command.patch deleted file mode 100644 index 03b16ed0d..000000000 --- a/patches/api/0046-Add-removal-warning-to-timings-command.patch +++ /dev/null @@ -1,24 +0,0 @@ -From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 -From: BillyGalbreath -Date: Sun, 26 Jun 2022 01:10:05 -0500 -Subject: [PATCH] Add removal warning to timings command - - -diff --git a/src/main/java/co/aikar/timings/TimingsCommand.java b/src/main/java/co/aikar/timings/TimingsCommand.java -index 3132dc98d26c54c5e46162e53aaed195d7335c8d..a2357b323bcfd23c8c45a81ef749d88dd64cb8d5 100644 ---- a/src/main/java/co/aikar/timings/TimingsCommand.java -+++ b/src/main/java/co/aikar/timings/TimingsCommand.java -@@ -53,6 +53,13 @@ public class TimingsCommand extends BukkitCommand { - if (!testPermission(sender)) { - return true; - } -+ if (currentAlias.equalsIgnoreCase("timings")) { -+ net.kyori.adventure.text.minimessage.MiniMessage mm = net.kyori.adventure.text.minimessage.MiniMessage.miniMessage(); -+ sender.sendMessage(mm.deserialize("Purpur is removing timings soon. Try using /spark instead")); -+ sender.sendMessage(mm.deserialize("For more information, view its documentation at")); -+ sender.sendMessage(mm.deserialize("https://spark.lucko.me/docs/Command-Usage")); -+ return true; -+ } - if (args.length < 1) { - sender.sendMessage(text("Usage: " + this.usageMessage, NamedTextColor.RED)); - return true; diff --git a/patches/api/0047-Spark-Profiler.patch b/patches/api/0046-Spark-Profiler.patch similarity index 100% rename from patches/api/0047-Spark-Profiler.patch rename to patches/api/0046-Spark-Profiler.patch diff --git a/patches/api/0048-Add-local-difficulty-api.patch b/patches/api/0047-Add-local-difficulty-api.patch similarity index 100% rename from patches/api/0048-Add-local-difficulty-api.patch rename to patches/api/0047-Add-local-difficulty-api.patch diff --git a/patches/api/0049-Chat-Preview-API.patch b/patches/api/0048-Chat-Preview-API.patch similarity index 100% rename from patches/api/0049-Chat-Preview-API.patch rename to patches/api/0048-Chat-Preview-API.patch diff --git a/patches/api/0049-Remove-Timings.patch b/patches/api/0049-Remove-Timings.patch new file mode 100644 index 000000000..bbaaef1d8 --- /dev/null +++ b/patches/api/0049-Remove-Timings.patch @@ -0,0 +1,151 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: BillyGalbreath +Date: Fri, 1 Jul 2022 04:03:26 -0500 +Subject: [PATCH] Remove Timings + + +diff --git a/src/main/java/co/aikar/timings/TimedEventExecutor.java b/src/main/java/co/aikar/timings/TimedEventExecutor.java +index 4e6e1b8e8aeb07e34536941d2cbfc25e5cfa6c27..5f8aab2cb734fcea7e2b4d4b2803170a7beddb87 100644 +--- a/src/main/java/co/aikar/timings/TimedEventExecutor.java ++++ b/src/main/java/co/aikar/timings/TimedEventExecutor.java +@@ -76,8 +76,8 @@ public class TimedEventExecutor implements EventExecutor { + executor.execute(listener, event); + return; + } +- try (Timing ignored = timings.startTiming()){ ++ //try (Timing ignored = timings.startTiming()){ // Purpur + executor.execute(listener, event); +- } ++ //} // Purpur + } + } +diff --git a/src/main/java/co/aikar/timings/Timing.java b/src/main/java/co/aikar/timings/Timing.java +index a21e5ead5024fd0058c5e3302d8201dd249d32bc..505908e987a032a801ae03d7fb020dfb662bf81b 100644 +--- a/src/main/java/co/aikar/timings/Timing.java ++++ b/src/main/java/co/aikar/timings/Timing.java +@@ -36,6 +36,7 @@ public interface Timing extends AutoCloseable { + * @return Timing + */ + @NotNull ++ @io.papermc.paper.annotation.DoNotUse // Purpur + Timing startTiming(); + + /** +@@ -43,6 +44,7 @@ public interface Timing extends AutoCloseable { + * + * Will automatically be called when this Timing is used with try-with-resources + */ ++ @io.papermc.paper.annotation.DoNotUse // Purpur + void stopTiming(); + + /** +@@ -53,6 +55,7 @@ public interface Timing extends AutoCloseable { + * @return Timing + */ + @NotNull ++ @io.papermc.paper.annotation.DoNotUse // Purpur + Timing startTimingIfSync(); + + /** +@@ -62,12 +65,14 @@ public interface Timing extends AutoCloseable { + * + * But only if we are on the primary thread. + */ ++ @io.papermc.paper.annotation.DoNotUse // Purpur + void stopTimingIfSync(); + + /** + * @deprecated Doesn't do anything - Removed + */ + @Deprecated ++ @io.papermc.paper.annotation.DoNotUse // Purpur + void abort(); + + /** +@@ -79,5 +84,6 @@ public interface Timing extends AutoCloseable { + TimingHandler getTimingHandler(); + + @Override ++ @io.papermc.paper.annotation.DoNotUse // Purpur + void close(); + } +diff --git a/src/main/java/co/aikar/timings/Timings.java b/src/main/java/co/aikar/timings/Timings.java +index dd72a34eaa4bedd9ea0b92eaa79091b00eb4dd09..759e9cbcedb50894821dcb6dcc602af4f0c3453e 100644 +--- a/src/main/java/co/aikar/timings/Timings.java ++++ b/src/main/java/co/aikar/timings/Timings.java +@@ -114,7 +114,7 @@ public final class Timings { + @NotNull + public static Timing ofStart(@NotNull Plugin plugin, @NotNull String name, @Nullable Timing groupHandler) { + Timing timing = of(plugin, name, groupHandler); +- timing.startTiming(); ++ //timing.startTiming(); // Purpur + return timing; + } + +diff --git a/src/main/java/co/aikar/timings/TimingsCommand.java b/src/main/java/co/aikar/timings/TimingsCommand.java +index 3132dc98d26c54c5e46162e53aaed195d7335c8d..f744ef6bb38f9fada25720862b83ce37007ce769 100644 +--- a/src/main/java/co/aikar/timings/TimingsCommand.java ++++ b/src/main/java/co/aikar/timings/TimingsCommand.java +@@ -44,7 +44,7 @@ public class TimingsCommand extends BukkitCommand { + public TimingsCommand(@NotNull String name) { + super(name); + this.description = "Manages Spigot Timings data to see performance of the server."; +- this.usageMessage = "/timings "; ++ this.usageMessage = "/timings";// "; // Purpur + this.setPermission("bukkit.command.timings"); + } + +@@ -53,6 +53,13 @@ public class TimingsCommand extends BukkitCommand { + if (!testPermission(sender)) { + return true; + } ++ if (true) { ++ net.kyori.adventure.text.minimessage.MiniMessage mm = net.kyori.adventure.text.minimessage.MiniMessage.miniMessage(); ++ sender.sendMessage(mm.deserialize("Purpur has removed timings to save your performance. Please use /spark instead")); ++ sender.sendMessage(mm.deserialize("For more information, view its documentation at")); ++ sender.sendMessage(mm.deserialize("https://spark.lucko.me/docs/Command-Usage")); ++ return true; ++ } + if (args.length < 1) { + sender.sendMessage(text("Usage: " + this.usageMessage, NamedTextColor.RED)); + return true; +@@ -111,7 +118,7 @@ public class TimingsCommand extends BukkitCommand { + Preconditions.checkNotNull(args, "Arguments cannot be null"); + Preconditions.checkNotNull(alias, "Alias cannot be null"); + +- if (args.length == 1) { ++ if (false && args.length == 1) { // Purpur + return StringUtil.copyPartialMatches(args[0], TIMINGS_SUBCOMMANDS, + new ArrayList(TIMINGS_SUBCOMMANDS.size())); + } +diff --git a/src/main/java/org/bukkit/command/SimpleCommandMap.java b/src/main/java/org/bukkit/command/SimpleCommandMap.java +index 0bc24d0effe9b2e44c41a1c00060b0ebf7395c4a..aad6edb02f690b875db28e8db9bcd4e36b90d766 100644 +--- a/src/main/java/org/bukkit/command/SimpleCommandMap.java ++++ b/src/main/java/org/bukkit/command/SimpleCommandMap.java +@@ -163,10 +163,10 @@ public class SimpleCommandMap implements CommandMap { + // Paper end + + try { +- try (co.aikar.timings.Timing ignored = target.timings.startTiming()) { // Paper - use try with resources ++ //try (co.aikar.timings.Timing ignored = target.timings.startTiming()) { // Paper - use try with resources // Purpur + // Note: we don't return the result of target.execute as thats success / failure, we return handled (true) or not handled (false) + target.execute(sender, sentCommandLabel, parsedArgs); // Purpur +- } // target.timings.stopTiming(); // Spigot // Paper ++ //} // target.timings.stopTiming(); // Spigot // Paper // Purpur + } catch (CommandException ex) { + server.getPluginManager().callEvent(new com.destroystokyo.paper.event.server.ServerExceptionEvent(new com.destroystokyo.paper.exception.ServerCommandException(ex, target, sender, args))); // Paper + //target.timings.stopTiming(); // Spigot // Paper +diff --git a/src/main/java/org/spigotmc/CustomTimingsHandler.java b/src/main/java/org/spigotmc/CustomTimingsHandler.java +index 123647bb10fc89508437d7a0bd3fd31d58ee7c82..ce209668dd7f11b284bd7f5688191a0b3ae86a09 100644 +--- a/src/main/java/org/spigotmc/CustomTimingsHandler.java ++++ b/src/main/java/org/spigotmc/CustomTimingsHandler.java +@@ -61,7 +61,7 @@ public final class CustomTimingsHandler { + handler = timing; + } + +- public void startTiming() { handler.startTiming(); } +- public void stopTiming() { handler.stopTiming(); } ++ public void startTiming() { /*handler.startTiming();*/ } // Purpur ++ public void stopTiming() { /*handler.stopTiming();*/ } // Purpur + + } diff --git a/patches/server/0290-Remove-Timings.patch b/patches/server/0290-Remove-Timings.patch new file mode 100644 index 000000000..733904ef1 --- /dev/null +++ b/patches/server/0290-Remove-Timings.patch @@ -0,0 +1,1060 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: BillyGalbreath +Date: Fri, 1 Jul 2022 04:03:37 -0500 +Subject: [PATCH] Remove Timings + + +diff --git a/src/main/java/com/destroystokyo/paper/io/chunk/ChunkLoadTask.java b/src/main/java/com/destroystokyo/paper/io/chunk/ChunkLoadTask.java +index e9070b6158e7e8c2dd33a9dcb20898a2f0d86e48..c8c019aea915ebb089f2ebe45bbcd1b5317c629f 100644 +--- a/src/main/java/com/destroystokyo/paper/io/chunk/ChunkLoadTask.java ++++ b/src/main/java/com/destroystokyo/paper/io/chunk/ChunkLoadTask.java +@@ -89,7 +89,7 @@ public final class ChunkLoadTask extends ChunkTask { + + final ChunkMap chunkManager = this.world.getChunkSource().chunkMap; + +- try (Timing ignored = this.world.timings.chunkLoadLevelTimer.startTimingIfSync()) { ++ //try (Timing ignored = this.world.timings.chunkLoadLevelTimer.startTimingIfSync()) { // Purpur + final ChunkSerializer.InProgressChunkHolder chunkHolder; + + // apply fixes +@@ -123,7 +123,7 @@ public final class ChunkLoadTask extends ChunkTask { + } + + this.complete(chunkHolder); +- } ++ //} // Purpur + } + + private void complete(final ChunkSerializer.InProgressChunkHolder holder) { +diff --git a/src/main/java/com/destroystokyo/paper/io/chunk/ChunkSaveTask.java b/src/main/java/com/destroystokyo/paper/io/chunk/ChunkSaveTask.java +index 0d245ad7d19b11e946e0b5b43bf2181292297210..49f3a4e66ea38e80f8096071003500513b750584 100644 +--- a/src/main/java/com/destroystokyo/paper/io/chunk/ChunkSaveTask.java ++++ b/src/main/java/com/destroystokyo/paper/io/chunk/ChunkSaveTask.java +@@ -34,7 +34,7 @@ public final class ChunkSaveTask extends ChunkTask { + // can be executed asynchronously or synchronously + final CompoundTag compound; + +- try (Timing ignored = this.world.timings.chunkUnloadDataSave.startTimingIfSync()) { ++ try /*(Timing ignored = this.world.timings.chunkUnloadDataSave.startTimingIfSync())*/ { // Purpur + compound = ChunkSerializer.saveChunk(this.world, this.chunk, this.asyncSaveData); + } catch (final Throwable ex) { + // has a plugin modified something it should not have and made us CME? +@@ -43,7 +43,7 @@ public final class ChunkSaveTask extends ChunkTask { + // Note: We add to the server thread queue here since this is what the server will drain tasks from + // when waiting for chunks + ChunkTaskManager.queueChunkWaitTask(() -> { +- try (Timing ignored = this.world.timings.chunkUnloadDataSave.startTiming()) { ++ //try (Timing ignored = this.world.timings.chunkUnloadDataSave.startTiming()) { // Purpur + CompoundTag data = PaperFileIOThread.FAILURE_VALUE; + + try { +@@ -54,7 +54,7 @@ public final class ChunkSaveTask extends ChunkTask { + } + + ChunkSaveTask.this.complete(data); +- } ++ // } // Purpur + }); + + return; // the main thread will now complete the data +diff --git a/src/main/java/net/minecraft/network/protocol/PacketUtils.java b/src/main/java/net/minecraft/network/protocol/PacketUtils.java +index 1429f938c36d5a3a33e71837f440b2303d60cfe7..ace18f023fde2d6561f6f0c3717e4820e454797c 100644 +--- a/src/main/java/net/minecraft/network/protocol/PacketUtils.java ++++ b/src/main/java/net/minecraft/network/protocol/PacketUtils.java +@@ -47,8 +47,9 @@ public class PacketUtils { + if (MinecraftServer.getServer().hasStopped() || (listener instanceof ServerGamePacketListenerImpl && ((ServerGamePacketListenerImpl) listener).processedDisconnect)) return; // CraftBukkit, MC-142590 + if (listener.getConnection().isConnected()) { + co.aikar.timings.Timing timing = co.aikar.timings.MinecraftTimings.getPacketTiming(packet); // Paper - timings +- try (co.aikar.timings.Timing ignored = timing.startTiming()) { // Paper - timings ++ //try (co.aikar.timings.Timing ignored = timing.startTiming()) { // Paper - timings // Purpur + packet.handle(listener); ++ /* // Purpur + } catch (Exception exception) { + net.minecraft.network.Connection networkmanager = listener.getConnection(); + String playerIP = io.papermc.paper.configuration.GlobalConfiguration.get().logging.logPlayerIpAddresses ? String.valueOf(networkmanager.getRemoteAddress()) : ""; // Paper +@@ -62,7 +63,7 @@ public class PacketUtils { + networkmanager.disconnect(error); + }); + networkmanager.setReadOnly(); +- } ++ } */ // Purpur + } else { + PacketUtils.LOGGER.debug("Ignoring packet due to disconnection: {}", packet); + } +diff --git a/src/main/java/net/minecraft/server/MinecraftServer.java b/src/main/java/net/minecraft/server/MinecraftServer.java +index 6e8055d70695841d21654b4f72643b4d0ea42867..83e04e0a0d5067668729118b05d289ac075ba37a 100644 +--- a/src/main/java/net/minecraft/server/MinecraftServer.java ++++ b/src/main/java/net/minecraft/server/MinecraftServer.java +@@ -1426,15 +1426,15 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop { + return !this.canOversleep(); + }); +- isOversleep = false;MinecraftTimings.serverOversleep.stopTiming(); ++ //isOversleep = false;MinecraftTimings.serverOversleep.stopTiming(); // Purpur + // Paper end + new com.destroystokyo.paper.event.server.ServerTickStartEvent(this.tickCount+1).callEvent(); // Paper + +@@ -1486,9 +1486,9 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop> scheduleChunkLoad(ChunkPos pos) { + // Paper start - Async chunk io + final java.util.function.BiFunction> syncLoadComplete = (chunkHolder, ioThrowable) -> { +- try (Timing ignored = this.level.timings.chunkLoad.startTimingIfSync()) { // Paper ++ try /*(Timing ignored = this.level.timings.chunkLoad.startTimingIfSync())*/ { // Paper // Purpur + this.level.getProfiler().incrementCounter("chunkLoad"); + if (ioThrowable != null) { + return this.handleChunkLoadFailure(ioThrowable, pos); +@@ -1363,7 +1363,7 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider + ChunkStatus chunkstatus = ChunkHolder.getStatus(chunkHolder.getTicketLevel()); + + return !chunkstatus.isOrAfter(ChunkStatus.FULL) ? ChunkHolder.UNLOADED_CHUNK : either.mapLeft((ichunkaccess) -> { +- try (Timing ignored = level.timings.chunkPostLoad.startTimingIfSync()) { // Paper ++ //try (Timing ignored = level.timings.chunkPostLoad.startTimingIfSync()) { // Paper // Purpur + ChunkPos chunkcoordintpair = chunkHolder.getPos(); + ProtoChunk protochunk = (ProtoChunk) ichunkaccess; + LevelChunk chunk; +@@ -1388,7 +1388,7 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider + } + + return chunk; +- } // Paper ++ //} // Paper // Purpur + }); + }, (runnable) -> { + ProcessorHandle mailbox = this.mainThreadMailbox; +@@ -1514,9 +1514,9 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider + private void asyncSave(ChunkAccess chunk) { + ChunkPos chunkPos = chunk.getPos(); + CompoundTag poiData; +- try (Timing ignored = this.level.timings.chunkUnloadPOISerialization.startTiming()) { ++ //try (Timing ignored = this.level.timings.chunkUnloadPOISerialization.startTiming()) { // Purpur + poiData = this.poiManager.getData(chunk.getPos()); +- } ++ //} // Purpur + + com.destroystokyo.paper.io.PaperFileIOThread.Holder.INSTANCE.scheduleSave(this.level, chunkPos.x, chunkPos.z, + poiData, null, com.destroystokyo.paper.io.PrioritizedTaskQueue.NORMAL_PRIORITY); +@@ -1536,9 +1536,9 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider + } + + ChunkSerializer.AsyncSaveData asyncSaveData; +- try (Timing ignored = this.level.timings.chunkUnloadPrepareSave.startTiming()) { ++ //try (Timing ignored = this.level.timings.chunkUnloadPrepareSave.startTiming()) { // Purpur + asyncSaveData = ChunkSerializer.getAsyncSaveData(this.level, chunk); +- } ++ //} // Purpur + + this.level.asyncChunkTaskManager.scheduleChunkSave(chunkPos.x, chunkPos.z, com.destroystokyo.paper.io.PrioritizedTaskQueue.NORMAL_PRIORITY, + asyncSaveData, chunk); +@@ -1549,7 +1549,7 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider + // Paper end + + public boolean save(ChunkAccess chunk) { +- try (co.aikar.timings.Timing ignored = this.level.timings.chunkSave.startTiming()) { // Paper ++ //try (co.aikar.timings.Timing ignored = this.level.timings.chunkSave.startTiming()) { // Paper // Purpur + this.poiManager.flush(chunk.getPos()); + if (!chunk.isUnsaved()) { + return false; +@@ -1573,9 +1573,9 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider + + this.level.getProfiler().incrementCounter("chunkSave"); + CompoundTag nbttagcompound; +- try (co.aikar.timings.Timing ignored1 = this.level.timings.chunkSaveDataSerialization.startTiming()) { // Paper ++ //try (co.aikar.timings.Timing ignored1 = this.level.timings.chunkSaveDataSerialization.startTiming()) { // Paper // Purpur + nbttagcompound = ChunkSerializer.write(this.level, chunk); +- } // Paper ++ //} // Paper // Purpur + + // Paper start - async chunk io + com.destroystokyo.paper.io.PaperFileIOThread.Holder.INSTANCE.scheduleSave(this.level, chunkcoordintpair.x, chunkcoordintpair.z, +@@ -1589,7 +1589,7 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider + return false; + } + } +- } // Paper ++ //} // Paper // Purpur + } + + private boolean isExistingChunkFull(ChunkPos pos) { +@@ -2112,24 +2112,24 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider + } + // Pufferfish end + +- this.level.timings.tracker1.startTiming(); ++ //this.level.timings.tracker1.startTiming(); // Purpur + try { + for (TrackedEntity tracker : this.entityMap.values()) { + // update tracker entry + tracker.updatePlayers(tracker.entity.getPlayersInTrackRange()); + } + } finally { +- this.level.timings.tracker1.stopTiming(); ++ //this.level.timings.tracker1.stopTiming(); // Purpur + } + + +- this.level.timings.tracker2.startTiming(); ++ //this.level.timings.tracker2.startTiming(); // Purpur + try { + for (TrackedEntity tracker : this.entityMap.values()) { + tracker.serverEntity.sendChanges(); + } + } finally { +- this.level.timings.tracker2.stopTiming(); ++ //this.level.timings.tracker2.stopTiming(); // Purpur + } + } + // Paper end - optimised tracker +@@ -2144,7 +2144,7 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider + List list = Lists.newArrayList(); + List list1 = this.level.players(); + ObjectIterator objectiterator = this.entityMap.values().iterator(); +- level.timings.tracker1.startTiming(); // Paper ++ //level.timings.tracker1.startTiming(); // Paper // Purpur + + ChunkMap.TrackedEntity playerchunkmap_entitytracker; + +@@ -2169,17 +2169,17 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider + playerchunkmap_entitytracker.serverEntity.sendChanges(); + } + } +- level.timings.tracker1.stopTiming(); // Paper ++ //level.timings.tracker1.stopTiming(); // Paper // Purpur + + if (!list.isEmpty()) { + objectiterator = this.entityMap.values().iterator(); + +- level.timings.tracker2.startTiming(); // Paper ++ //level.timings.tracker2.startTiming(); // Paper // Purpur + while (objectiterator.hasNext()) { + playerchunkmap_entitytracker = (ChunkMap.TrackedEntity) objectiterator.next(); + playerchunkmap_entitytracker.updatePlayers(list); + } +- level.timings.tracker2.stopTiming(); // Paper ++ //level.timings.tracker2.stopTiming(); // Paper // Purpur + } + + } +diff --git a/src/main/java/net/minecraft/server/level/ServerChunkCache.java b/src/main/java/net/minecraft/server/level/ServerChunkCache.java +index 378cc1f9e19eb9b18037ab8af92f65897e15a405..de4b8001ff0ddb1603fcca2b6829bb55289d651e 100644 +--- a/src/main/java/net/minecraft/server/level/ServerChunkCache.java ++++ b/src/main/java/net/minecraft/server/level/ServerChunkCache.java +@@ -660,10 +660,10 @@ public class ServerChunkCache extends ChunkSource { + com.destroystokyo.paper.io.chunk.ChunkTaskManager.pushChunkWait(this.level, x1, z1); + // Paper end + com.destroystokyo.paper.io.SyncLoadFinder.logSyncLoad(this.level, x1, z1); // Paper - sync load info +- this.level.timings.syncChunkLoad.startTiming(); // Paper ++ //this.level.timings.syncChunkLoad.startTiming(); // Paper // Purpur + chunkproviderserver_b.managedBlock(completablefuture::isDone); + com.destroystokyo.paper.io.chunk.ChunkTaskManager.popChunkWait(); // Paper - async chunk debug +- this.level.timings.syncChunkLoad.stopTiming(); // Paper ++ //this.level.timings.syncChunkLoad.stopTiming(); // Paper // Purpur + this.distanceManager.clearPriorityTickets(pair); // Paper - Chunk priority + this.distanceManager.clearUrgent(pair); // Paper - Chunk priority + } // Paper +@@ -827,7 +827,7 @@ public class ServerChunkCache extends ChunkSource { + public boolean runDistanceManagerUpdates() { + if (distanceManager.delayDistanceManagerTick) return false; // Paper - Chunk priority + if (this.chunkMap.unloadingPlayerChunk) { LOGGER.error("Cannot tick distance manager while unloading playerchunks", new Throwable()); throw new IllegalStateException("Cannot tick distance manager while unloading playerchunks"); } // Paper +- co.aikar.timings.MinecraftTimings.distanceManagerTick.startTiming(); try { // Paper - add timings for distance manager ++ //co.aikar.timings.MinecraftTimings.distanceManagerTick.startTiming(); try { // Paper - add timings for distance manager // Purpur + boolean flag = this.distanceManager.runAllUpdates(this.chunkMap); + boolean flag1 = this.chunkMap.promoteChunkMap(); + +@@ -837,7 +837,7 @@ public class ServerChunkCache extends ChunkSource { + this.clearCache(); + return true; + } +- } finally { co.aikar.timings.MinecraftTimings.distanceManagerTick.stopTiming(); } // Paper - add timings for distance manager ++ //} finally { co.aikar.timings.MinecraftTimings.distanceManagerTick.stopTiming(); } // Paper - add timings for distance manager // Purpur + } + + // Paper start +@@ -855,17 +855,17 @@ public class ServerChunkCache extends ChunkSource { + + public void save(boolean flush) { + this.runDistanceManagerUpdates(); +- try (co.aikar.timings.Timing timed = level.timings.chunkSaveData.startTiming()) { // Paper - Timings ++ //try (co.aikar.timings.Timing timed = level.timings.chunkSaveData.startTiming()) { // Paper - Timings // Purpur + this.chunkMap.saveAllChunks(flush); +- } // Paper - Timings ++ //} // Paper - Timings // Purpur + } + + // Paper start - duplicate save, but call incremental + public void saveIncrementally() { + this.runDistanceManagerUpdates(); +- try (co.aikar.timings.Timing timed = level.timings.chunkSaveData.startTiming()) { // Paper - Timings ++ //try (co.aikar.timings.Timing timed = level.timings.chunkSaveData.startTiming()) { // Paper - Timings // Purpur + this.chunkMap.saveIncrementally(); +- } // Paper - Timings ++ //} // Paper - Timings // Purpur + } + // Paper end + +@@ -900,22 +900,22 @@ public class ServerChunkCache extends ChunkSource { + @Override + public void tick(BooleanSupplier shouldKeepTicking, boolean tickChunks) { + this.level.getProfiler().push("purge"); +- this.level.timings.doChunkMap.startTiming(); // Spigot ++ //this.level.timings.doChunkMap.startTiming(); // Spigot // Purpur + this.distanceManager.purgeStaleTickets(); + this.runDistanceManagerUpdates(); +- this.level.timings.doChunkMap.stopTiming(); // Spigot ++ //this.level.timings.doChunkMap.stopTiming(); // Spigot // Purpur + this.level.getProfiler().popPush("chunks"); + if (tickChunks) { +- this.level.timings.chunks.startTiming(); // Paper - timings ++ //this.level.timings.chunks.startTiming(); // Paper - timings // Purpur + this.chunkMap.playerChunkManager.tick(); // Paper - this is mostly is to account for view distance changes + this.tickChunks(); +- this.level.timings.chunks.stopTiming(); // Paper - timings ++ //this.level.timings.chunks.stopTiming(); // Paper - timings // Purpur + } + +- this.level.timings.doChunkUnload.startTiming(); // Spigot ++ //this.level.timings.doChunkUnload.startTiming(); // Spigot // Purpur + this.level.getProfiler().popPush("unload"); + this.chunkMap.tick(shouldKeepTicking); +- this.level.timings.doChunkUnload.stopTiming(); // Spigot ++ //this.level.timings.doChunkUnload.stopTiming(); // Spigot // Purpur + this.level.getProfiler().pop(); + this.clearCache(); + } +@@ -970,7 +970,7 @@ public class ServerChunkCache extends ChunkSource { + boolean flag1 = level.ticksPerSpawnCategory.getLong(org.bukkit.entity.SpawnCategory.ANIMAL) != 0L && worlddata.getGameTime() % level.ticksPerSpawnCategory.getLong(org.bukkit.entity.SpawnCategory.ANIMAL) == 0L; // CraftBukkit + + gameprofilerfiller.push("naturalSpawnCount"); +- this.level.timings.countNaturalMobs.startTiming(); // Paper - timings ++ //this.level.timings.countNaturalMobs.startTiming(); // Paper - timings // Purpur + int l = this.distanceManager.getNaturalSpawnChunkCount(); + // Paper start - per player mob spawning + NaturalSpawner.SpawnState spawnercreature_d; // moved down +@@ -991,12 +991,12 @@ public class ServerChunkCache extends ChunkSource { + // Pufferfish end + } + // Paper end +- this.level.timings.countNaturalMobs.stopTiming(); // Paper - timings ++ //this.level.timings.countNaturalMobs.stopTiming(); // Paper - timings // Purpur + + //this.lastSpawnState = spawnercreature_d; // Pufferfish - this is managed asynchronously + gameprofilerfiller.popPush("filteringLoadedChunks"); + // Paper - moved down +- this.level.timings.chunkTicks.startTiming(); // Paper ++ //this.level.timings.chunkTicks.startTiming(); // Paper // Purpur + + // Paper - moved down + +@@ -1050,17 +1050,17 @@ public class ServerChunkCache extends ChunkSource { + } + } + // Paper end - optimise chunk tick iteration +- this.level.timings.chunkTicks.stopTiming(); // Paper ++ //this.level.timings.chunkTicks.stopTiming(); // Paper // Purpur + gameprofilerfiller.popPush("customSpawners"); + if (flag2) { +- try (co.aikar.timings.Timing ignored = this.level.timings.miscMobSpawning.startTiming()) { // Paper - timings ++ //try (co.aikar.timings.Timing ignored = this.level.timings.miscMobSpawning.startTiming()) { // Paper - timings // Purpur + this.level.tickCustomSpawners(this.spawnEnemies, this.spawnFriendlies); +- } // Paper - timings ++ //} // Paper - timings // Purpur + } + gameprofilerfiller.pop(); + // Paper start - use set of chunks requiring updates, rather than iterating every single one loaded + gameprofilerfiller.popPush("broadcast"); +- this.level.timings.broadcastChunkUpdates.startTiming(); // Paper - timing ++ //this.level.timings.broadcastChunkUpdates.startTiming(); // Paper - timing // Purpur + if (!this.chunkMap.needsChangeBroadcasting.isEmpty()) { + ReferenceOpenHashSet copy = this.chunkMap.needsChangeBroadcasting.clone(); + this.chunkMap.needsChangeBroadcasting.clear(); +@@ -1072,7 +1072,7 @@ public class ServerChunkCache extends ChunkSource { + } + } + } +- this.level.timings.broadcastChunkUpdates.stopTiming(); // Paper - timing ++ //this.level.timings.broadcastChunkUpdates.stopTiming(); // Paper - timing // Purpur + gameprofilerfiller.pop(); + // Paper end - use set of chunks requiring updates, rather than iterating every single one loaded + // Paper start - controlled flush for entity tracker packets +diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java +index 0d82ca8ba9f2b11213cfe1ab01dc6ef3f2f510c9..ca733d97929c123df1234143660631eb07d62e79 100644 +--- a/src/main/java/net/minecraft/server/level/ServerLevel.java ++++ b/src/main/java/net/minecraft/server/level/ServerLevel.java +@@ -648,7 +648,7 @@ public class ServerLevel extends Level implements WorldGenLevel { + this.updateSkyBrightness(); + this.tickTime(); + gameprofilerfiller.popPush("tickPending"); +- timings.scheduledBlocks.startTiming(); // Paper ++ //timings.scheduledBlocks.startTiming(); // Paper // Purpur + if (!this.isDebug()) { + j = this.getGameTime(); + gameprofilerfiller.push("blockTicks"); +@@ -657,20 +657,20 @@ public class ServerLevel extends Level implements WorldGenLevel { + this.fluidTicks.tick(j, 65536, this::tickFluid); + gameprofilerfiller.pop(); + } +- timings.scheduledBlocks.stopTiming(); // Paper ++ //timings.scheduledBlocks.stopTiming(); // Paper // Purpur + + gameprofilerfiller.popPush("raid"); +- this.timings.raids.startTiming(); // Paper - timings ++ //this.timings.raids.startTiming(); // Paper - timings // Purpur + this.raids.tick(); +- this.timings.raids.stopTiming(); // Paper - timings ++ //this.timings.raids.stopTiming(); // Paper - timings // Purpur + gameprofilerfiller.popPush("chunkSource"); +- this.timings.chunkProviderTick.startTiming(); // Paper - timings ++ //this.timings.chunkProviderTick.startTiming(); // Paper - timings // Purpur + this.getChunkSource().tick(shouldKeepTicking, true); +- this.timings.chunkProviderTick.stopTiming(); // Paper - timings ++ //this.timings.chunkProviderTick.stopTiming(); // Paper - timings // Purpur + gameprofilerfiller.popPush("blockEvents"); +- timings.doSounds.startTiming(); // Spigot ++ //timings.doSounds.startTiming(); // Spigot // Purpur + this.runBlockEvents(); +- timings.doSounds.stopTiming(); // Spigot ++ //timings.doSounds.stopTiming(); // Spigot // Purpur + this.handlingTick = false; + gameprofilerfiller.pop(); + boolean flag = true || !this.players.isEmpty() || !this.getForcedChunks().isEmpty(); // CraftBukkit - this prevents entity cleanup, other issues on servers with no players +@@ -681,7 +681,7 @@ public class ServerLevel extends Level implements WorldGenLevel { + + if (flag || this.emptyTime++ < 300) { + gameprofilerfiller.push("entities"); +- timings.tickEntities.startTiming(); // Spigot ++ //timings.tickEntities.startTiming(); // Spigot // Purpur + if (this.dragonFight != null) { + gameprofilerfiller.push("dragonFight"); + this.dragonFight.tick(); +@@ -689,7 +689,7 @@ public class ServerLevel extends Level implements WorldGenLevel { + } + + org.spigotmc.ActivationRange.activateEntities(this); // Spigot +- timings.entityTick.startTiming(); // Spigot ++ //timings.entityTick.startTiming(); // Spigot // Purpur + this.entityTickList.forEach((entity) -> { + if (!entity.isRemoved()) { + if (false && this.shouldDiscardEntity(entity)) { // CraftBukkit - We prevent spawning in general, so this butchering is not needed +@@ -729,8 +729,8 @@ public class ServerLevel extends Level implements WorldGenLevel { + } + } + }); +- timings.entityTick.stopTiming(); // Spigot +- timings.tickEntities.stopTiming(); // Spigot ++ //timings.entityTick.stopTiming(); // Spigot // Purpur ++ //timings.tickEntities.stopTiming(); // Spigot // Purpur + gameprofilerfiller.pop(); + this.tickBlockEntities(); + } +@@ -892,7 +892,7 @@ public class ServerLevel extends Level implements WorldGenLevel { + + // Paper start - optimise random block ticking + gameprofilerfiller.popPush("randomTick"); +- timings.chunkTicksBlocks.startTiming(); // Paper ++ //timings.chunkTicksBlocks.startTiming(); // Paper // Purpur + if (randomTickSpeed > 0) { + LevelChunkSection[] sections = chunk.getSections(); + int minSection = io.papermc.paper.util.WorldUtil.getMinSection(this); +@@ -926,7 +926,7 @@ public class ServerLevel extends Level implements WorldGenLevel { + } + } + // Paper end - optimise random block ticking +- timings.chunkTicksBlocks.stopTiming(); // Paper ++ //timings.chunkTicksBlocks.stopTiming(); // Paper // Purpur + gameprofilerfiller.pop(); + } + +@@ -1220,8 +1220,8 @@ public class ServerLevel extends Level implements WorldGenLevel { + // Spigot end + // Paper start- timings + final boolean isActive = org.spigotmc.ActivationRange.checkIfActive(entity); +- timer = isActive ? entity.getType().tickTimer.startTiming() : entity.getType().inactiveTickTimer.startTiming(); // Paper +- try { ++ //timer = isActive ? entity.getType().tickTimer.startTiming() : entity.getType().inactiveTickTimer.startTiming(); // Paper // Purpur ++ //try { // Purpur + // Paper end - timings + entity.setOldPosAndRot(); + ProfilerFiller gameprofilerfiller = this.getProfiler(); +@@ -1237,7 +1237,7 @@ public class ServerLevel extends Level implements WorldGenLevel { + entity.postTick(); // CraftBukkit + } else { entity.inactiveTick(); } // Paper - EAR 2 + this.getProfiler().pop(); +- } finally { timer.stopTiming(); } // Paper - timings ++ //} finally { timer.stopTiming(); } // Paper - timings // Purpur + Iterator iterator = entity.getPassengers().iterator(); + + while (iterator.hasNext()) { +@@ -1260,8 +1260,8 @@ public class ServerLevel extends Level implements WorldGenLevel { + if (passenger instanceof Player || this.entityTickList.contains(passenger)) { + // Paper - EAR 2 + final boolean isActive = org.spigotmc.ActivationRange.checkIfActive(passenger); +- co.aikar.timings.Timing timer = isActive ? passenger.getType().passengerTickTimer.startTiming() : passenger.getType().passengerInactiveTickTimer.startTiming(); // Paper +- try { ++ //co.aikar.timings.Timing timer = isActive ? passenger.getType().passengerTickTimer.startTiming() : passenger.getType().passengerInactiveTickTimer.startTiming(); // Paper // Purpur ++ //try { // Purpur + // Paper end + passenger.setOldPosAndRot(); + ++passenger.tickCount; +@@ -1291,7 +1291,7 @@ public class ServerLevel extends Level implements WorldGenLevel { + this.tickPassenger(passenger, entity2); + } + +- } finally { timer.stopTiming(); }// Paper - EAR2 timings ++ //} finally { timer.stopTiming(); }// Paper - EAR2 timings // Purpur + } + } else { + passenger.stopRiding(); +@@ -1311,14 +1311,14 @@ public class ServerLevel extends Level implements WorldGenLevel { + org.bukkit.Bukkit.getPluginManager().callEvent(new org.bukkit.event.world.WorldSaveEvent(getWorld())); + } + +- try (co.aikar.timings.Timing ignored = this.timings.worldSave.startTiming()) { ++ //try (co.aikar.timings.Timing ignored = this.timings.worldSave.startTiming()) { // Purpur + if (doFull) { + this.saveLevelData(); + } + +- this.timings.worldSaveChunks.startTiming(); // Paper ++ //this.timings.worldSaveChunks.startTiming(); // Paper // Purpur + if (!this.noSave()) chunkproviderserver.saveIncrementally(); +- this.timings.worldSaveChunks.stopTiming(); // Paper ++ //this.timings.worldSaveChunks.stopTiming(); // Paper // Purpur + + // Copied from save() + // CraftBukkit start - moved from MinecraftServer.saveChunks +@@ -1330,7 +1330,7 @@ public class ServerLevel extends Level implements WorldGenLevel { + this.convertable.saveDataTag(this.server.registryHolder, this.serverLevelData, this.server.getPlayerList().getSingleplayerData()); + } + // CraftBukkit end +- } ++ //} // Purpur + } + // Paper end + +@@ -1339,7 +1339,7 @@ public class ServerLevel extends Level implements WorldGenLevel { + + if (!savingDisabled) { + org.bukkit.Bukkit.getPluginManager().callEvent(new org.bukkit.event.world.WorldSaveEvent(getWorld())); // CraftBukkit +- try (co.aikar.timings.Timing ignored = timings.worldSave.startTiming()) { // Paper ++ //try (co.aikar.timings.Timing ignored = timings.worldSave.startTiming()) { // Paper // Purpur // Purpur + if (progressListener != null) { + progressListener.progressStartNoAbort(Component.translatable("menu.savingLevel")); + } +@@ -1349,10 +1349,10 @@ public class ServerLevel extends Level implements WorldGenLevel { + progressListener.progressStage(Component.translatable("menu.savingChunks")); + } + +- timings.worldSaveChunks.startTiming(); // Paper ++ //timings.worldSaveChunks.startTiming(); // Paper // Purpur + chunkproviderserver.save(flush); +- timings.worldSaveChunks.stopTiming(); // Paper +- }// Paper ++ //timings.worldSaveChunks.stopTiming(); // Paper // Purpur ++ //}// Paper // Purpur + if (flush) { + this.entityManager.saveAll(); + } else { +diff --git a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java +index 38cd5aec3c54984c3c3429aa0bfb525ba170f116..6fd2886a77868a19f8077e6f0c61532be8db089a 100644 +--- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java ++++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java +@@ -2447,7 +2447,7 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Ser + } + + private void handleCommand(String s) { +- co.aikar.timings.MinecraftTimings.playerCommandTimer.startTiming(); // Paper ++ //co.aikar.timings.MinecraftTimings.playerCommandTimer.startTiming(); // Paper // Purpur + if ( org.spigotmc.SpigotConfig.logCommands ) // Spigot + this.LOGGER.info(this.player.getScoreboardName() + " issued server command: " + s); + +@@ -2457,7 +2457,7 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Ser + this.cserver.getPluginManager().callEvent(event); + + if (event.isCancelled()) { +- co.aikar.timings.MinecraftTimings.playerCommandTimer.stopTiming(); // Paper ++ //co.aikar.timings.MinecraftTimings.playerCommandTimer.stopTiming(); // Paper // Purpur + return; + } + +@@ -2470,7 +2470,7 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Ser + java.util.logging.Logger.getLogger(ServerGamePacketListenerImpl.class.getName()).log(java.util.logging.Level.SEVERE, null, ex); + return; + } finally { +- co.aikar.timings.MinecraftTimings.playerCommandTimer.stopTiming(); // Paper ++ //co.aikar.timings.MinecraftTimings.playerCommandTimer.stopTiming(); // Paper // Purpur + } + } + // CraftBukkit end +diff --git a/src/main/java/net/minecraft/server/players/PlayerList.java b/src/main/java/net/minecraft/server/players/PlayerList.java +index be338bfaaada839ca9fcc556e4f0608fca3216ec..048df4f7263515faefd78e60a8223136665cdf44 100644 +--- a/src/main/java/net/minecraft/server/players/PlayerList.java ++++ b/src/main/java/net/minecraft/server/players/PlayerList.java +@@ -1280,7 +1280,7 @@ public abstract class PlayerList { + + public void saveAll(int interval) { + net.minecraft.server.MCUtil.ensureMain("Save Players" , () -> { // Paper - Ensure main +- MinecraftTimings.savePlayers.startTiming(); // Paper ++ //MinecraftTimings.savePlayers.startTiming(); // Paper // Purpur + int numSaved = 0; + long now = MinecraftServer.currentTick; + for (int i = 0; i < this.players.size(); ++i) { +@@ -1291,7 +1291,7 @@ public abstract class PlayerList { + } + // Paper end + } +- MinecraftTimings.savePlayers.stopTiming(); // Paper ++ //MinecraftTimings.savePlayers.stopTiming(); // Paper // Purpur + return null; }); // Paper - ensure main + } + +diff --git a/src/main/java/net/minecraft/world/entity/ai/behavior/Behavior.java b/src/main/java/net/minecraft/world/entity/ai/behavior/Behavior.java +index eb5a332f0705dd2e5568749a22f2f318d68010d1..8e3b06e1512ea4ee7b0de8294cfd624f47e260ee 100644 +--- a/src/main/java/net/minecraft/world/entity/ai/behavior/Behavior.java ++++ b/src/main/java/net/minecraft/world/entity/ai/behavior/Behavior.java +@@ -56,9 +56,9 @@ public abstract class Behavior { + this.status = Behavior.Status.RUNNING; + int i = this.minDuration + world.getRandom().nextInt(this.maxDuration + 1 - this.minDuration); + this.endTimestamp = time + (long)i; +- this.timing.startTiming(); // Paper - behavior timings ++ //this.timing.startTiming(); // Paper - behavior timings // Purpur + this.start(world, entity, time); +- this.timing.stopTiming(); // Paper - behavior timings ++ //this.timing.stopTiming(); // Paper - behavior timings // Purpur + return true; + } else { + return false; +@@ -69,13 +69,13 @@ public abstract class Behavior { + } + + public final void tickOrStop(ServerLevel world, E entity, long time) { +- this.timing.startTiming(); // Paper - behavior timings ++ //this.timing.startTiming(); // Paper - behavior timings // Purpur + if (!this.timedOut(time) && this.canStillUse(world, entity, time)) { + this.tick(world, entity, time); + } else { + this.doStop(world, entity, time); + } +- this.timing.stopTiming(); // Paper - behavior timings ++ //this.timing.stopTiming(); // Paper - behavior timings // Purpur + + } + +diff --git a/src/main/java/net/minecraft/world/entity/ai/sensing/Sensor.java b/src/main/java/net/minecraft/world/entity/ai/sensing/Sensor.java +index fcdb9bde8e1605e30dde3e580491522d4b62cdc0..7094701d213c73ba47ace806962244c10fdf4dda 100644 +--- a/src/main/java/net/minecraft/world/entity/ai/sensing/Sensor.java ++++ b/src/main/java/net/minecraft/world/entity/ai/sensing/Sensor.java +@@ -46,10 +46,10 @@ public abstract class Sensor { + if (--this.timeToTick <= 0L) { + // Paper start - configurable sensor tick rate and timings + this.timeToTick = java.util.Objects.requireNonNullElse(world.paperConfig().tickRates.sensor.get(entity.getType(), this.configKey), this.scanRate); +- this.timing.startTiming(); ++ //this.timing.startTiming(); // Purpur + // Paper end + this.doTick(world, entity); +- this.timing.stopTiming(); // Paper - sensor timings ++ //this.timing.stopTiming(); // Paper - sensor timings // Purpur + } + + } +diff --git a/src/main/java/net/minecraft/world/entity/ai/village/poi/PoiManager.java b/src/main/java/net/minecraft/world/entity/ai/village/poi/PoiManager.java +index 210b0cdd4831421c8f43c3d823ac8e962b56bbbc..de99946f5215ff2c78d6df5b8b7d5b6abaece907 100644 +--- a/src/main/java/net/minecraft/world/entity/ai/village/poi/PoiManager.java ++++ b/src/main/java/net/minecraft/world/entity/ai/village/poi/PoiManager.java +@@ -351,9 +351,9 @@ public class PoiManager extends SectionStorage { + ChunkPos chunkcoordintpair = SectionPos.of(this.dirty.firstLong()).chunk(); + + net.minecraft.nbt.CompoundTag data; +- try (co.aikar.timings.Timing ignored1 = this.world.timings.poiSaveDataSerialization.startTiming()) { ++ //try (co.aikar.timings.Timing ignored1 = this.world.timings.poiSaveDataSerialization.startTiming()) { // Purpur + data = this.getData(chunkcoordintpair); +- } ++ //} // Purpur + com.destroystokyo.paper.io.PaperFileIOThread.Holder.INSTANCE.scheduleSave(this.world, + chunkcoordintpair.x, chunkcoordintpair.z, data, null, com.destroystokyo.paper.io.PrioritizedTaskQueue.NORMAL_PRIORITY); + } +diff --git a/src/main/java/net/minecraft/world/level/Level.java b/src/main/java/net/minecraft/world/level/Level.java +index 0dab4ef279f7e9af64290395b4af205b0d54f271..d270d0f47d26085ce7912b61a66b922a95871a73 100644 +--- a/src/main/java/net/minecraft/world/level/Level.java ++++ b/src/main/java/net/minecraft/world/level/Level.java +@@ -994,15 +994,15 @@ public abstract class Level implements LevelAccessor, AutoCloseable { + ProfilerFiller gameprofilerfiller = this.getProfiler(); + + gameprofilerfiller.push("blockEntities"); +- timings.tileEntityPending.startTiming(); // Spigot ++ //timings.tileEntityPending.startTiming(); // Spigot // Purpur + this.tickingBlockEntities = true; + if (!this.pendingBlockEntityTickers.isEmpty()) { + this.blockEntityTickers.addAll(this.pendingBlockEntityTickers); + this.pendingBlockEntityTickers.clear(); + } +- timings.tileEntityPending.stopTiming(); // Spigot ++ //timings.tileEntityPending.stopTiming(); // Spigot // Purpur + +- timings.tileEntityTick.startTiming(); // Spigot ++ //timings.tileEntityTick.startTiming(); // Spigot // Purpur + // Spigot start + // Iterator iterator = this.blockEntityTickers.iterator(); + int tilesThisCycle = 0; +@@ -1035,7 +1035,7 @@ public abstract class Level implements LevelAccessor, AutoCloseable { + } + this.blockEntityTickers.removeAll(toRemove); + +- timings.tileEntityTick.stopTiming(); // Spigot ++ //timings.tileEntityTick.stopTiming(); // Spigot // Purpur + this.tickingBlockEntities = false; + co.aikar.timings.TimingHistory.tileEntityTicks += this.blockEntityTickers.size(); // Paper + gameprofilerfiller.pop(); +diff --git a/src/main/java/net/minecraft/world/level/NaturalSpawner.java b/src/main/java/net/minecraft/world/level/NaturalSpawner.java +index 1f4acc1a2605f1e9051126fc811a5479351fc61a..5c6fde4baf27e7d8f027c138d843da39a4a2ed36 100644 +--- a/src/main/java/net/minecraft/world/level/NaturalSpawner.java ++++ b/src/main/java/net/minecraft/world/level/NaturalSpawner.java +@@ -132,7 +132,7 @@ public final class NaturalSpawner { + + public static void spawnForChunk(ServerLevel world, LevelChunk chunk, NaturalSpawner.SpawnState info, boolean spawnAnimals, boolean spawnMonsters, boolean rareSpawn) { + world.getProfiler().push("spawner"); +- world.timings.mobSpawn.startTiming(); // Spigot ++ //world.timings.mobSpawn.startTiming(); // Spigot // Purpur + MobCategory[] aenumcreaturetype = NaturalSpawner.SPAWNING_CATEGORIES; + int i = aenumcreaturetype.length; + +@@ -187,7 +187,7 @@ public final class NaturalSpawner { + } + } + +- world.timings.mobSpawn.stopTiming(); // Spigot ++ //world.timings.mobSpawn.stopTiming(); // Spigot // Purpur + world.getProfiler().pop(); + } + +diff --git a/src/main/java/net/minecraft/world/level/chunk/LevelChunk.java b/src/main/java/net/minecraft/world/level/chunk/LevelChunk.java +index 6fbf26eb7da8df2f0a4158ff9f12022518ada8e3..ab024c5315c0a7cb2f80d5d7b251f6a3531879b3 100644 +--- a/src/main/java/net/minecraft/world/level/chunk/LevelChunk.java ++++ b/src/main/java/net/minecraft/world/level/chunk/LevelChunk.java +@@ -875,7 +875,7 @@ public class LevelChunk extends ChunkAccess { + server.getPluginManager().callEvent(new org.bukkit.event.world.ChunkLoadEvent(this.bukkitChunk, this.needsDecoration)); + + if (this.needsDecoration) { +- try (co.aikar.timings.Timing ignored = this.level.timings.chunkLoadPopulate.startTiming()) { // Paper ++ //try (co.aikar.timings.Timing ignored = this.level.timings.chunkLoadPopulate.startTiming()) { // Paper // Purpur + this.needsDecoration = false; + java.util.Random random = new java.util.Random(); + random.setSeed(this.level.getSeed()); +@@ -895,7 +895,7 @@ public class LevelChunk extends ChunkAccess { + } + } + server.getPluginManager().callEvent(new org.bukkit.event.world.ChunkPopulateEvent(this.bukkitChunk)); +- } // Paper ++ //} // Paper // Purpur + } + } + } +@@ -1239,7 +1239,7 @@ public class LevelChunk extends ChunkAccess { + ProfilerFiller gameprofilerfiller = LevelChunk.this.level.getProfiler(); + + gameprofilerfiller.push(this::getType); +- this.blockEntity.tickTimer.startTiming(); // Spigot ++ //this.blockEntity.tickTimer.startTiming(); // Spigot // Purpur + BlockState iblockdata = LevelChunk.this.getBlockState(blockposition); + + if (this.blockEntity.getType().isValid(iblockdata)) { +@@ -1261,7 +1261,7 @@ public class LevelChunk extends ChunkAccess { + // Paper end + // Spigot start + } finally { +- this.blockEntity.tickTimer.stopTiming(); ++ //this.blockEntity.tickTimer.stopTiming(); // Purpur + // Spigot end + } + } +diff --git a/src/main/java/org/bukkit/craftbukkit/scheduler/CraftScheduler.java b/src/main/java/org/bukkit/craftbukkit/scheduler/CraftScheduler.java +index d1526ed7197b883e1d1f07baf285bf5eef4d20d5..5402098dce0d64d3dceea51f248d7d366850a74f 100644 +--- a/src/main/java/org/bukkit/craftbukkit/scheduler/CraftScheduler.java ++++ b/src/main/java/org/bukkit/craftbukkit/scheduler/CraftScheduler.java +@@ -516,10 +516,10 @@ public class CraftScheduler implements BukkitScheduler { + this.runners.remove(task.getTaskId()); + } + } +- MinecraftTimings.bukkitSchedulerFinishTimer.startTiming(); // Paper ++ //MinecraftTimings.bukkitSchedulerFinishTimer.startTiming(); // Paper // Purpur + this.pending.addAll(temp); + temp.clear(); +- MinecraftTimings.bukkitSchedulerFinishTimer.stopTiming(); // Paper ++ //MinecraftTimings.bukkitSchedulerFinishTimer.stopTiming(); // Paper // Purpur + //this.debugHead = this.debugHead.getNextHead(currentTick); // Paper + } + +@@ -563,7 +563,7 @@ public class CraftScheduler implements BukkitScheduler { + } + + void parsePending() { // Paper +- if (!this.isAsyncScheduler) MinecraftTimings.bukkitSchedulerPendingTimer.startTiming(); // Paper ++ //if (!this.isAsyncScheduler) MinecraftTimings.bukkitSchedulerPendingTimer.startTiming(); // Paper // Purpur + CraftTask head = this.head; + CraftTask task = head.getNext(); + CraftTask lastTask = head; +@@ -582,7 +582,7 @@ public class CraftScheduler implements BukkitScheduler { + task.setNext(null); + } + this.head = lastTask; +- if (!this.isAsyncScheduler) MinecraftTimings.bukkitSchedulerPendingTimer.stopTiming(); // Paper ++ //if (!this.isAsyncScheduler) MinecraftTimings.bukkitSchedulerPendingTimer.stopTiming(); // Paper // Purpur + } + + private boolean isReady(final int currentTick) { +diff --git a/src/main/java/org/bukkit/craftbukkit/scheduler/CraftTask.java b/src/main/java/org/bukkit/craftbukkit/scheduler/CraftTask.java +index 3f45bab0e9f7b3697e6d9d1092a1e6e579f7066f..4f1cf281c4bf68c37982d390da8779dea78dab18 100644 +--- a/src/main/java/org/bukkit/craftbukkit/scheduler/CraftTask.java ++++ b/src/main/java/org/bukkit/craftbukkit/scheduler/CraftTask.java +@@ -96,13 +96,13 @@ public class CraftTask implements BukkitTask, Runnable { // Spigot + + @Override + public void run() { +- try (Timing ignored = timings.startTiming()) { // Paper ++ //try (Timing ignored = timings.startTiming()) { // Paper // Purpur + if (this.rTask != null) { + this.rTask.run(); + } else { + this.cTask.accept(this); + } +- } // Paper ++ //} // Paper // Purpur + } + + long getCreatedAt() { +diff --git a/src/main/java/org/bukkit/craftbukkit/scoreboard/CraftScoreboardManager.java b/src/main/java/org/bukkit/craftbukkit/scoreboard/CraftScoreboardManager.java +index c74ac9cf5db4d8adfe781cf066258011da469717..73c48bbb3c6ff9de15acb7adaa15f904785ccfef 100644 +--- a/src/main/java/org/bukkit/craftbukkit/scoreboard/CraftScoreboardManager.java ++++ b/src/main/java/org/bukkit/craftbukkit/scoreboard/CraftScoreboardManager.java +@@ -115,7 +115,7 @@ public final class CraftScoreboardManager implements ScoreboardManager { + public void getScoreboardScores(ObjectiveCriteria criteria, String name, Consumer consumer) { + // Paper start - add timings for scoreboard search + // plugins leaking scoreboards will make this very expensive, let server owners debug it easily +- co.aikar.timings.MinecraftTimings.scoreboardScoreSearch.startTimingIfSync(); ++ //co.aikar.timings.MinecraftTimings.scoreboardScoreSearch.startTimingIfSync(); // Purpur + try { + // Paper end - add timings for scoreboard search + for (CraftScoreboard scoreboard : this.scoreboards) { +@@ -123,7 +123,7 @@ public final class CraftScoreboardManager implements ScoreboardManager { + board.forAllObjectives(criteria, name, (score) -> consumer.accept(score)); + } + } finally { // Paper start - add timings for scoreboard search +- co.aikar.timings.MinecraftTimings.scoreboardScoreSearch.stopTimingIfSync(); ++ //co.aikar.timings.MinecraftTimings.scoreboardScoreSearch.stopTimingIfSync(); // Purpur + } + // Paper end - add timings for scoreboard search + } +diff --git a/src/main/java/org/spigotmc/ActivationRange.java b/src/main/java/org/spigotmc/ActivationRange.java +index 08d678f781a86e709a8b6066a12fd76830d142cc..796e0ff6dda3ed7e237597d050e1277ea7939086 100644 +--- a/src/main/java/org/spigotmc/ActivationRange.java ++++ b/src/main/java/org/spigotmc/ActivationRange.java +@@ -170,7 +170,7 @@ public class ActivationRange + */ + public static void activateEntities(Level world) + { +- MinecraftTimings.entityActivationCheckTimer.startTiming(); ++ //MinecraftTimings.entityActivationCheckTimer.startTiming(); // Purpur + final int miscActivationRange = world.spigotConfig.miscActivationRange; + final int raiderActivationRange = world.spigotConfig.raiderActivationRange; + final int animalActivationRange = world.spigotConfig.animalActivationRange; +@@ -239,7 +239,7 @@ public class ActivationRange + } + // Paper end + } +- MinecraftTimings.entityActivationCheckTimer.stopTiming(); ++ //MinecraftTimings.entityActivationCheckTimer.stopTiming(); // Purpur + } + + /** diff --git a/patches/server/0291-Remove-Mojang-Profiler.patch b/patches/server/0291-Remove-Mojang-Profiler.patch new file mode 100644 index 000000000..5d9b1c554 --- /dev/null +++ b/patches/server/0291-Remove-Mojang-Profiler.patch @@ -0,0 +1,1886 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: BillyGalbreath +Date: Sat, 16 Jul 2022 21:37:10 -0500 +Subject: [PATCH] Remove Mojang Profiler + + +diff --git a/src/main/java/net/minecraft/commands/Commands.java b/src/main/java/net/minecraft/commands/Commands.java +index d0ca327337206a64609c1b6ee652cf99bc49e088..7c7190890c46d783b67fef3bdbed9bb8dd60c8d0 100644 +--- a/src/main/java/net/minecraft/commands/Commands.java ++++ b/src/main/java/net/minecraft/commands/Commands.java +@@ -135,7 +135,7 @@ public class Commands { + CloneCommands.register(this.dispatcher, commandRegistryAccess); + DataCommands.register(this.dispatcher); + DataPackCommand.register(this.dispatcher); +- DebugCommand.register(this.dispatcher); ++ //DebugCommand.register(this.dispatcher); // Purpur + DefaultGameModeCommands.register(this.dispatcher); + DifficultyCommand.register(this.dispatcher); + EffectCommands.register(this.dispatcher); +@@ -288,9 +288,9 @@ public class Commands { + public int performCommand(CommandSourceStack commandlistenerwrapper, String s, String label) { // CraftBukkit + StringReader stringreader = new StringReader(s); + +- commandlistenerwrapper.getServer().getProfiler().push(() -> { ++ /*commandlistenerwrapper.getServer().getProfiler().push(() -> { // Purpur + return "/" + s; +- }); ++ });*/ // Purpur + + byte b0; + +@@ -353,7 +353,7 @@ public class Commands { + b0 = 0; + } + } finally { +- commandlistenerwrapper.getServer().getProfiler().pop(); ++ //commandlistenerwrapper.getServer().getProfiler().pop(); // Purpur + } + + return b0; +diff --git a/src/main/java/net/minecraft/server/MinecraftServer.java b/src/main/java/net/minecraft/server/MinecraftServer.java +index 83e04e0a0d5067668729118b05d289ac075ba37a..d48a3203e67617e2f3f75756bf9effe31f439457 100644 +--- a/src/main/java/net/minecraft/server/MinecraftServer.java ++++ b/src/main/java/net/minecraft/server/MinecraftServer.java +@@ -326,13 +326,13 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop registryreadops, Thread thread, LevelStorageSource.LevelStorageAccess convertable_conversionsession, PackRepository resourcepackrepository, WorldStem worldstem, Proxy proxy, DataFixer datafixer, Services services, ChunkProgressListenerFactory worldloadlistenerfactory) { + super("Server"); + SERVER = this; // Paper - better singleton +- this.metricsRecorder = InactiveMetricsRecorder.INSTANCE; +- this.profiler = this.metricsRecorder.getProfiler(); +- this.onMetricsRecordingStopped = (methodprofilerresults) -> { ++ //this.metricsRecorder = InactiveMetricsRecorder.INSTANCE; // Purpur ++ //this.profiler = this.metricsRecorder.getProfiler(); // Purpur ++ /*this.onMetricsRecordingStopped = (methodprofilerresults) -> { // Purpur + this.stopRecordingMetrics(); +- }; +- this.onMetricsRecordingFinished = (path) -> { +- }; ++ };*/ // Purpur ++ //this.onMetricsRecordingFinished = (path) -> { // Purpur ++ //}; // Purpur + this.status = new ServerStatus(); + this.random = RandomSource.create(); + this.port = -1; +@@ -924,9 +924,9 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop 0 && this.tickCount % autosavePeriod == 0; + try { + this.isSaving = true; +@@ -1482,7 +1482,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop 0; // Purpur + net.minecraft.world.level.block.entity.HopperBlockEntity.skipHopperEvents = worldserver.paperConfig().hopper.disableMoveEvent || org.bukkit.event.inventory.InventoryMoveItemEvent.getHandlerList().getRegisteredListeners().length == 0; // Paper + +- this.profiler.push(() -> { ++ /*this.profiler.push(() -> { // Purpur + return worldserver + " " + worldserver.dimension().location(); +- }); ++ });*/ // Purpur + /* Drop global time updates + if (this.tickCount % 20 == 0) { +- this.profiler.push("timeSync"); ++ //this.profiler.push("timeSync"); // Purpur + this.playerList.broadcastAll(new PacketPlayOutUpdateTime(worldserver.getGameTime(), worldserver.getDayTime(), worldserver.getGameRules().getBoolean(GameRules.RULE_DAYLIGHT)), worldserver.dimension()); +- this.profiler.pop(); ++ //this.profiler.pop(); // Purpur + } + // CraftBukkit end */ + +- this.profiler.push("tick"); ++ //this.profiler.push("tick"); // Purpur + + try { + //worldserver.timings.doTick.startTiming(); // Spigot // Purpur +@@ -1599,17 +1599,17 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop { + this.executeBlocking(() -> { + this.saveDebugReport(path.resolve("server")); +@@ -2507,40 +2507,40 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop resultConsumer, Consumer dumpConsumer) { +- this.onMetricsRecordingStopped = (methodprofilerresults) -> { ++ /*this.onMetricsRecordingStopped = (methodprofilerresults) -> { // Purpur + this.stopRecordingMetrics(); + resultConsumer.accept(methodprofilerresults); + }; + this.onMetricsRecordingFinished = dumpConsumer; +- this.willStartRecordingMetrics = true; ++ this.willStartRecordingMetrics = true;*/ // Purpur + } + + public void stopRecordingMetrics() { +- this.metricsRecorder = InactiveMetricsRecorder.INSTANCE; ++ //this.metricsRecorder = InactiveMetricsRecorder.INSTANCE; // Purpur + } + + public void finishRecordingMetrics() { +- this.metricsRecorder.end(); ++ //this.metricsRecorder.end(); // Purpur + } + + public void cancelRecordingMetrics() { +- this.metricsRecorder.cancel(); +- this.profiler = this.metricsRecorder.getProfiler(); ++ //this.metricsRecorder.cancel(); // Purpur ++ //this.profiler = this.metricsRecorder.getProfiler(); // Purpur + } + + public Path getWorldPath(LevelResource worldSavePath) { +@@ -2585,15 +2585,15 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop functions, ResourceLocation label) { +- ProfilerFiller gameprofilerfiller = this.server.getProfiler(); ++ //ProfilerFiller gameprofilerfiller = this.server.getProfiler(); // Purpur + + Objects.requireNonNull(label); +- gameprofilerfiller.push(label::toString); ++ //gameprofilerfiller.push(label::toString); // Purpur + Iterator iterator = functions.iterator(); + + while (iterator.hasNext()) { +@@ -69,7 +69,7 @@ public class ServerFunctionManager { + this.execute(customfunction, this.getGameLoopSender()); + } + +- this.server.getProfiler().pop(); ++ //this.server.getProfiler().pop(); // Purpur + } + + public int execute(CommandFunction function, CommandSourceStack source) { +@@ -177,10 +177,10 @@ public class ServerFunctionManager { + + try { + ServerFunctionManager.QueuedCommand customfunctiondata_b = (ServerFunctionManager.QueuedCommand) this.commandQueue.removeFirst(); +- ProfilerFiller gameprofilerfiller = ServerFunctionManager.this.server.getProfiler(); ++ //ProfilerFiller gameprofilerfiller = ServerFunctionManager.this.server.getProfiler(); // Purpur + + Objects.requireNonNull(customfunctiondata_b); +- gameprofilerfiller.push(customfunctiondata_b::toString); ++ //gameprofilerfiller.push(customfunctiondata_b::toString); // Purpur + this.depth = customfunctiondata_b.depth; + customfunctiondata_b.execute(ServerFunctionManager.this, this.commandQueue, i, this.tracer); + if (!this.nestedCalls.isEmpty()) { +@@ -192,7 +192,7 @@ public class ServerFunctionManager { + this.nestedCalls.clear(); + } + } finally { +- ServerFunctionManager.this.server.getProfiler().pop(); ++ //ServerFunctionManager.this.server.getProfiler().pop(); // Purpur + } + + ++j; +diff --git a/src/main/java/net/minecraft/server/level/ChunkMap.java b/src/main/java/net/minecraft/server/level/ChunkMap.java +index 4e0529f5ca6efe0188631689eaa0fecc8c7660d6..150f9b354d24f6a351a704a718044768b5521589 100644 +--- a/src/main/java/net/minecraft/server/level/ChunkMap.java ++++ b/src/main/java/net/minecraft/server/level/ChunkMap.java +@@ -1003,20 +1003,20 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider + } + + protected void tick(BooleanSupplier shouldKeepTicking) { +- ProfilerFiller gameprofilerfiller = this.level.getProfiler(); ++ //ProfilerFiller gameprofilerfiller = this.level.getProfiler(); // Purpur + + //try (Timing ignored = this.level.timings.poiUnload.startTiming()) { // Paper // Purpur +- gameprofilerfiller.push("poi"); ++ //gameprofilerfiller.push("poi"); // Purpur + this.poiManager.tick(shouldKeepTicking); + //} // Paper // Purpur +- gameprofilerfiller.popPush("chunk_unload"); ++ //gameprofilerfiller.popPush("chunk_unload"); // Purpur + if (!this.level.noSave()) { + //try (Timing ignored = this.level.timings.chunkUnload.startTiming()) { // Paper // Purpur + this.processUnloads(shouldKeepTicking); + //} // Paper // Purpur + } + +- gameprofilerfiller.pop(); ++ //gameprofilerfiller.pop(); // Purpur + } + + public boolean hasWork() { +@@ -1173,7 +1173,7 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider + // Paper start - Async chunk io + final java.util.function.BiFunction> syncLoadComplete = (chunkHolder, ioThrowable) -> { + try /*(Timing ignored = this.level.timings.chunkLoad.startTimingIfSync())*/ { // Paper // Purpur +- this.level.getProfiler().incrementCounter("chunkLoad"); ++ //this.level.getProfiler().incrementCounter("chunkLoad"); // Purpur + if (ioThrowable != null) { + return this.handleChunkLoadFailure(ioThrowable, pos); + } +@@ -1269,9 +1269,9 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider + return this.getDependencyStatus(requiredStatus, i); + }); + +- this.level.getProfiler().incrementCounter(() -> { ++ /*this.level.getProfiler().incrementCounter(() -> { // Purpur + return "chunkGenerate " + requiredStatus.getName(); +- }); ++ });*/ // Purpur + Executor executor = (runnable) -> { + // Paper start - optimize chunk status progression without jumping through thread pool + if (holder.canAdvanceStatus()) { +@@ -1571,7 +1571,7 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider + } + } + +- this.level.getProfiler().incrementCounter("chunkSave"); ++ //this.level.getProfiler().incrementCounter("chunkSave"); // Purpur + CompoundTag nbttagcompound; + //try (co.aikar.timings.Timing ignored1 = this.level.timings.chunkSaveDataSerialization.startTiming()) { // Paper // Purpur + nbttagcompound = ChunkSerializer.write(this.level, chunk); +diff --git a/src/main/java/net/minecraft/server/level/ServerChunkCache.java b/src/main/java/net/minecraft/server/level/ServerChunkCache.java +index de4b8001ff0ddb1603fcca2b6829bb55289d651e..1c49aec79581c6bbeaeb87e42f98ed22fa13faee 100644 +--- a/src/main/java/net/minecraft/server/level/ServerChunkCache.java ++++ b/src/main/java/net/minecraft/server/level/ServerChunkCache.java +@@ -631,9 +631,9 @@ public class ServerChunkCache extends ChunkSource { + return ifLoaded; + } + // Paper end +- ProfilerFiller gameprofilerfiller = this.level.getProfiler(); ++ //ProfilerFiller gameprofilerfiller = this.level.getProfiler(); // Purpur + +- gameprofilerfiller.incrementCounter("getChunk"); ++ //gameprofilerfiller.incrementCounter("getChunk"); // Purpur + long k = ChunkPos.asLong(x, z); + + ChunkAccess ichunkaccess; +@@ -647,7 +647,7 @@ public class ServerChunkCache extends ChunkSource { + } + } + +- gameprofilerfiller.incrementCounter("getChunkCacheMiss"); ++ //gameprofilerfiller.incrementCounter("getChunkCacheMiss"); // Purpur + CompletableFuture> completablefuture = this.getChunkFutureMainThread(x, z, leastStatus, create, true); // Paper + ServerChunkCache.MainThreadExecutor chunkproviderserver_b = this.mainThreadProcessor; + +@@ -746,13 +746,13 @@ public class ServerChunkCache extends ChunkSource { + this.distanceManager.addTicket(TicketType.REQUIRED_LOAD, chunkcoordintpair, l, identifier); // Paper - prevent plugin unloads from removing our ticket + if (isUrgent) this.distanceManager.markUrgent(chunkcoordintpair); // Paper - Chunk priority + if (this.chunkAbsent(playerchunk, l)) { +- ProfilerFiller gameprofilerfiller = this.level.getProfiler(); ++ //ProfilerFiller gameprofilerfiller = this.level.getProfiler(); // Purpur + +- gameprofilerfiller.push("chunkLoad"); ++ //gameprofilerfiller.push("chunkLoad"); // Purpur + distanceManager.delayDistanceManagerTick = false; // Paper - Chunk priority - ensure this is never false + this.runDistanceManagerUpdates(); + playerchunk = this.getVisibleChunkIfPresent(k); +- gameprofilerfiller.pop(); ++ //gameprofilerfiller.pop(); // Purpur + if (this.chunkAbsent(playerchunk, l)) { + this.distanceManager.removeTicket(TicketType.REQUIRED_LOAD, chunkcoordintpair, l, identifier); // Paper + throw (IllegalStateException) Util.pauseInIde(new IllegalStateException("No chunk holder after ticket has been added")); +@@ -887,24 +887,24 @@ public class ServerChunkCache extends ChunkSource { + // CraftBukkit start - modelled on below + public void purgeUnload() { + if (true) return; // Paper - tickets will be removed later, this behavior isn't really well accounted for by the chunk system +- this.level.getProfiler().push("purge"); ++ //this.level.getProfiler().push("purge"); // Purpur + this.distanceManager.purgeStaleTickets(); + this.runDistanceManagerUpdates(); +- this.level.getProfiler().popPush("unload"); ++ //this.level.getProfiler().popPush("unload"); // Purpur + this.chunkMap.tick(() -> true); +- this.level.getProfiler().pop(); ++ //this.level.getProfiler().pop(); // Purpur + this.clearCache(); + } + // CraftBukkit end + + @Override + public void tick(BooleanSupplier shouldKeepTicking, boolean tickChunks) { +- this.level.getProfiler().push("purge"); ++ //this.level.getProfiler().push("purge"); // Purpur + //this.level.timings.doChunkMap.startTiming(); // Spigot // Purpur + this.distanceManager.purgeStaleTickets(); + this.runDistanceManagerUpdates(); + //this.level.timings.doChunkMap.stopTiming(); // Spigot // Purpur +- this.level.getProfiler().popPush("chunks"); ++ //this.level.getProfiler().popPush("chunks"); // Purpur + if (tickChunks) { + //this.level.timings.chunks.startTiming(); // Paper - timings // Purpur + this.chunkMap.playerChunkManager.tick(); // Paper - this is mostly is to account for view distance changes +@@ -913,10 +913,10 @@ public class ServerChunkCache extends ChunkSource { + } + + //this.level.timings.doChunkUnload.startTiming(); // Spigot // Purpur +- this.level.getProfiler().popPush("unload"); ++ //this.level.getProfiler().popPush("unload"); // Purpur + this.chunkMap.tick(shouldKeepTicking); + //this.level.timings.doChunkUnload.stopTiming(); // Spigot // Purpur +- this.level.getProfiler().pop(); ++ //this.level.getProfiler().pop(); // Purpur + this.clearCache(); + } + +@@ -962,14 +962,14 @@ public class ServerChunkCache extends ChunkSource { + } + // Paper end - optimize isOutisdeRange + LevelData worlddata = this.level.getLevelData(); +- ProfilerFiller gameprofilerfiller = this.level.getProfiler(); ++ //ProfilerFiller gameprofilerfiller = this.level.getProfiler(); // Purpur + +- gameprofilerfiller.push("pollingChunks"); ++ //gameprofilerfiller.push("pollingChunks"); // Purpur + this.level.resetIceAndSnowTick(); // Pufferfish - reset ice & snow tick random + int k = this.level.getGameRules().getInt(GameRules.RULE_RANDOMTICKING); + boolean flag1 = level.ticksPerSpawnCategory.getLong(org.bukkit.entity.SpawnCategory.ANIMAL) != 0L && worlddata.getGameTime() % level.ticksPerSpawnCategory.getLong(org.bukkit.entity.SpawnCategory.ANIMAL) == 0L; // CraftBukkit + +- gameprofilerfiller.push("naturalSpawnCount"); ++ //gameprofilerfiller.push("naturalSpawnCount"); // Purpur + //this.level.timings.countNaturalMobs.startTiming(); // Paper - timings // Purpur + int l = this.distanceManager.getNaturalSpawnChunkCount(); + // Paper start - per player mob spawning +@@ -994,13 +994,13 @@ public class ServerChunkCache extends ChunkSource { + //this.level.timings.countNaturalMobs.stopTiming(); // Paper - timings // Purpur + + //this.lastSpawnState = spawnercreature_d; // Pufferfish - this is managed asynchronously +- gameprofilerfiller.popPush("filteringLoadedChunks"); ++ //gameprofilerfiller.popPush("filteringLoadedChunks"); // Purpur + // Paper - moved down + //this.level.timings.chunkTicks.startTiming(); // Paper // Purpur + + // Paper - moved down + +- gameprofilerfiller.popPush("spawnAndTick"); ++ //gameprofilerfiller.popPush("spawnAndTick"); // Purpur + boolean flag2 = this.level.getGameRules().getBoolean(GameRules.RULE_DOMOBSPAWNING) && !this.level.players().isEmpty(); // CraftBukkit + + // Paper - only shuffle if per-player mob spawning is disabled +@@ -1051,15 +1051,15 @@ public class ServerChunkCache extends ChunkSource { + } + // Paper end - optimise chunk tick iteration + //this.level.timings.chunkTicks.stopTiming(); // Paper // Purpur +- gameprofilerfiller.popPush("customSpawners"); ++ //gameprofilerfiller.popPush("customSpawners"); // Purpur + if (flag2) { + //try (co.aikar.timings.Timing ignored = this.level.timings.miscMobSpawning.startTiming()) { // Paper - timings // Purpur + this.level.tickCustomSpawners(this.spawnEnemies, this.spawnFriendlies); + //} // Paper - timings // Purpur + } +- gameprofilerfiller.pop(); ++ //gameprofilerfiller.pop(); // Purpur + // Paper start - use set of chunks requiring updates, rather than iterating every single one loaded +- gameprofilerfiller.popPush("broadcast"); ++ //gameprofilerfiller.popPush("broadcast"); // Purpur + //this.level.timings.broadcastChunkUpdates.startTiming(); // Paper - timing // Purpur + if (!this.chunkMap.needsChangeBroadcasting.isEmpty()) { + ReferenceOpenHashSet copy = this.chunkMap.needsChangeBroadcasting.clone(); +@@ -1073,7 +1073,7 @@ public class ServerChunkCache extends ChunkSource { + } + } + //this.level.timings.broadcastChunkUpdates.stopTiming(); // Paper - timing // Purpur +- gameprofilerfiller.pop(); ++ //gameprofilerfiller.pop(); // Purpur + // Paper end - use set of chunks requiring updates, rather than iterating every single one loaded + // Paper start - controlled flush for entity tracker packets + List disabledFlushes = new java.util.ArrayList<>(this.level.players.size()); +@@ -1279,7 +1279,7 @@ public class ServerChunkCache extends ChunkSource { + + @Override + protected void doRunTask(Runnable task) { +- ServerChunkCache.this.level.getProfiler().incrementCounter("runTask"); ++ //ServerChunkCache.this.level.getProfiler().incrementCounter("runTask"); // Purpur + super.doRunTask(task); + } + +diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java +index ca733d97929c123df1234143660631eb07d62e79..655b9e8ffb941a0777f3895bf39c38fe488dbfa4 100644 +--- a/src/main/java/net/minecraft/server/level/ServerLevel.java ++++ b/src/main/java/net/minecraft/server/level/ServerLevel.java +@@ -615,12 +615,12 @@ public class ServerLevel extends Level implements WorldGenLevel { + } + } + // Paper end - optimise checkDespawn +- ProfilerFiller gameprofilerfiller = this.getProfiler(); ++ //ProfilerFiller gameprofilerfiller = this.getProfiler(); // Purpur + + this.handlingTick = true; +- gameprofilerfiller.push("world border"); ++ //gameprofilerfiller.push("world border"); // Purpur + this.getWorldBorder().tick(); +- gameprofilerfiller.popPush("weather"); ++ //gameprofilerfiller.popPush("weather"); // Purpur + this.advanceWeatherCycle(); + int i = this.getGameRules().getInt(GameRules.RULE_PLAYERS_SLEEPING_PERCENTAGE); + long j; +@@ -647,32 +647,32 @@ public class ServerLevel extends Level implements WorldGenLevel { + + this.updateSkyBrightness(); + this.tickTime(); +- gameprofilerfiller.popPush("tickPending"); ++ //gameprofilerfiller.popPush("tickPending"); // Purpur + //timings.scheduledBlocks.startTiming(); // Paper // Purpur + if (!this.isDebug()) { + j = this.getGameTime(); +- gameprofilerfiller.push("blockTicks"); ++ //gameprofilerfiller.push("blockTicks"); // Purpur + this.blockTicks.tick(j, 65536, this::tickBlock); +- gameprofilerfiller.popPush("fluidTicks"); ++ //gameprofilerfiller.popPush("fluidTicks"); // Purpur + this.fluidTicks.tick(j, 65536, this::tickFluid); +- gameprofilerfiller.pop(); ++ //gameprofilerfiller.pop(); // Purpur + } + //timings.scheduledBlocks.stopTiming(); // Paper // Purpur + +- gameprofilerfiller.popPush("raid"); ++ //gameprofilerfiller.popPush("raid"); // Purpur + //this.timings.raids.startTiming(); // Paper - timings // Purpur + this.raids.tick(); + //this.timings.raids.stopTiming(); // Paper - timings // Purpur +- gameprofilerfiller.popPush("chunkSource"); ++ //gameprofilerfiller.popPush("chunkSource"); // Purpur + //this.timings.chunkProviderTick.startTiming(); // Paper - timings // Purpur + this.getChunkSource().tick(shouldKeepTicking, true); + //this.timings.chunkProviderTick.stopTiming(); // Paper - timings // Purpur +- gameprofilerfiller.popPush("blockEvents"); ++ //gameprofilerfiller.popPush("blockEvents"); // Purpur + //timings.doSounds.startTiming(); // Spigot // Purpur + this.runBlockEvents(); + //timings.doSounds.stopTiming(); // Spigot // Purpur + this.handlingTick = false; +- gameprofilerfiller.pop(); ++ //gameprofilerfiller.pop(); // Purpur + boolean flag = true || !this.players.isEmpty() || !this.getForcedChunks().isEmpty(); // CraftBukkit - this prevents entity cleanup, other issues on servers with no players + + if (flag) { +@@ -680,12 +680,12 @@ public class ServerLevel extends Level implements WorldGenLevel { + } + + if (flag || this.emptyTime++ < 300) { +- gameprofilerfiller.push("entities"); ++ //gameprofilerfiller.push("entities"); // Purpur + //timings.tickEntities.startTiming(); // Spigot // Purpur + if (this.dragonFight != null) { +- gameprofilerfiller.push("dragonFight"); ++ //gameprofilerfiller.push("dragonFight"); // Purpur + this.dragonFight.tick(); +- gameprofilerfiller.pop(); ++ //gameprofilerfiller.pop(); // Purpur + } + + org.spigotmc.ActivationRange.activateEntities(this); // Spigot +@@ -695,9 +695,9 @@ public class ServerLevel extends Level implements WorldGenLevel { + if (false && this.shouldDiscardEntity(entity)) { // CraftBukkit - We prevent spawning in general, so this butchering is not needed + entity.discard(); + } else { +- gameprofilerfiller.push("checkDespawn"); ++ //gameprofilerfiller.push("checkDespawn"); // Purpur + entity.checkDespawn(); +- gameprofilerfiller.pop(); ++ //gameprofilerfiller.pop(); // Purpur + if (true || this.chunkSource.chunkMap.getDistanceManager().inEntityTickingRange(entity.chunkPosition().toLong())) { // Paper - now always true if in the ticking list + Entity entity1 = entity.getVehicle(); + +@@ -709,7 +709,7 @@ public class ServerLevel extends Level implements WorldGenLevel { + entity.stopRiding(); + } + +- gameprofilerfiller.push("tick"); ++ //gameprofilerfiller.push("tick"); // Purpur + // Pufferfish start - copied from this.guardEntityTick + try { + this.tickNonPassenger(entity); // Pufferfish - changed +@@ -724,22 +724,22 @@ public class ServerLevel extends Level implements WorldGenLevel { + // Paper end + } + // Pufferfish end +- gameprofilerfiller.pop(); ++ //gameprofilerfiller.pop(); // Purpur + } + } + } + }); + //timings.entityTick.stopTiming(); // Spigot // Purpur + //timings.tickEntities.stopTiming(); // Spigot // Purpur +- gameprofilerfiller.pop(); ++ //gameprofilerfiller.pop(); // Purpur + this.tickBlockEntities(); + } + +- gameprofilerfiller.push("entityManagement"); ++ //gameprofilerfiller.push("entityManagement"); // Purpur + this.entityManager.tick(); +- gameprofilerfiller.popPush("gameEvents"); ++ //gameprofilerfiller.popPush("gameEvents"); // Purpur + this.sendGameEvents(); +- gameprofilerfiller.pop(); ++ //gameprofilerfiller.pop(); // Purpur + } + + @Override +@@ -821,9 +821,9 @@ public class ServerLevel extends Level implements WorldGenLevel { + boolean flag = this.isRaining(); + int j = chunkcoordintpair.getMinBlockX(); + int k = chunkcoordintpair.getMinBlockZ(); +- ProfilerFiller gameprofilerfiller = this.getProfiler(); ++ //ProfilerFiller gameprofilerfiller = this.getProfiler(); // Purpur + +- gameprofilerfiller.push("thunder"); ++ //gameprofilerfiller.push("thunder"); // Purpur + final BlockPos.MutableBlockPos blockposition = this.chunkTickMutablePosition; // Paper - use mutable to reduce allocation rate, final to force compile fail on change + + if (!this.paperConfig().environment.disableThunder && flag && this.isThundering() && this.spigotConfig.thunderChance > 0 && /*this.random.nextInt(this.spigotConfig.thunderChance) == 0 &&*/ chunk.shouldDoLightning(this.random)) { // Spigot // Paper - disable thunder // Pufferfish - replace random with shouldDoLightning +@@ -855,7 +855,7 @@ public class ServerLevel extends Level implements WorldGenLevel { + } + } + +- gameprofilerfiller.popPush("iceandsnow"); ++ //gameprofilerfiller.popPush("iceandsnow"); // Purpur + if (!this.paperConfig().environment.disableIceAndSnow && (this.currentIceAndSnowTick++ & 15) == 0) { // Paper - Disable ice and snow // Paper - optimise random ticking // Pufferfish - optimize further random ticking + // Paper start - optimise chunk ticking + this.getRandomBlockPosition(j, 0, k, 15, blockposition); +@@ -891,7 +891,7 @@ public class ServerLevel extends Level implements WorldGenLevel { + } + + // Paper start - optimise random block ticking +- gameprofilerfiller.popPush("randomTick"); ++ //gameprofilerfiller.popPush("randomTick"); // Purpur + //timings.chunkTicksBlocks.startTiming(); // Paper // Purpur + if (randomTickSpeed > 0) { + LevelChunkSection[] sections = chunk.getSections(); +@@ -927,7 +927,7 @@ public class ServerLevel extends Level implements WorldGenLevel { + } + // Paper end - optimise random block ticking + //timings.chunkTicksBlocks.stopTiming(); // Paper // Purpur +- gameprofilerfiller.pop(); ++ //gameprofilerfiller.pop(); // Purpur + } + + public Optional findLightningRod(BlockPos pos) { +@@ -1224,19 +1224,19 @@ public class ServerLevel extends Level implements WorldGenLevel { + //try { // Purpur + // Paper end - timings + entity.setOldPosAndRot(); +- ProfilerFiller gameprofilerfiller = this.getProfiler(); ++ //ProfilerFiller gameprofilerfiller = this.getProfiler(); // Purpur + + ++entity.tickCount; +- this.getProfiler().push(() -> { ++ /*this.getProfiler().push(() -> { // Purpur + return Registry.ENTITY_TYPE.getKey(entity.getType()).toString(); +- }); +- gameprofilerfiller.incrementCounter("tickNonPassenger"); ++ });*/ // Purpur ++ //gameprofilerfiller.incrementCounter("tickNonPassenger"); // Purpur + if (isActive) { // Paper - EAR 2 + TimingHistory.activatedEntityTicks++; + entity.tick(); + entity.postTick(); // CraftBukkit + } else { entity.inactiveTick(); } // Paper - EAR 2 +- this.getProfiler().pop(); ++ //this.getProfiler().pop(); // Purpur + //} finally { timer.stopTiming(); } // Paper - timings // Purpur + Iterator iterator = entity.getPassengers().iterator(); + +@@ -1265,12 +1265,12 @@ public class ServerLevel extends Level implements WorldGenLevel { + // Paper end + passenger.setOldPosAndRot(); + ++passenger.tickCount; +- ProfilerFiller gameprofilerfiller = this.getProfiler(); ++ //ProfilerFiller gameprofilerfiller = this.getProfiler(); // Purpur + +- gameprofilerfiller.push(() -> { ++ /*gameprofilerfiller.push(() -> { // Purpur + return Registry.ENTITY_TYPE.getKey(passenger.getType()).toString(); +- }); +- gameprofilerfiller.incrementCounter("tickPassenger"); ++ });*/ // Purpur ++ //gameprofilerfiller.incrementCounter("tickPassenger"); // Purpur + // Paper start - EAR 2 + if (isActive) { + passenger.rideTick(); +@@ -1282,7 +1282,7 @@ public class ServerLevel extends Level implements WorldGenLevel { + vehicle.positionRider(passenger); + } + // Paper end - EAR 2 +- gameprofilerfiller.pop(); ++ //gameprofilerfiller.pop(); // Purpur + Iterator iterator = passenger.getPassengers().iterator(); + + while (iterator.hasNext()) { +diff --git a/src/main/java/net/minecraft/server/level/ServerPlayer.java b/src/main/java/net/minecraft/server/level/ServerPlayer.java +index 60873c874abbeff8f30b3536f5c4cc03e663530a..a8a3de5b23e4e5ce5d7d5bb84d85c3a7d62431ac 100644 +--- a/src/main/java/net/minecraft/server/level/ServerPlayer.java ++++ b/src/main/java/net/minecraft/server/level/ServerPlayer.java +@@ -1154,7 +1154,7 @@ public class ServerPlayer extends Player { + PortalInfo shapedetectorshape = this.findDimensionEntryPoint(worldserver); + + if (shapedetectorshape != null) { +- worldserver1.getProfiler().push("moving"); ++ //worldserver1.getProfiler().push("moving"); // Purpur + worldserver = shapedetectorshape.world; // CraftBukkit + if (worldserver == null) { } else // CraftBukkit - empty to fall through to null to event + if (resourcekey == LevelStem.OVERWORLD && worldserver.getTypeKey() == LevelStem.NETHER) { // CraftBukkit +@@ -1177,8 +1177,8 @@ public class ServerPlayer extends Player { + worldserver = ((CraftWorld) exit.getWorld()).getHandle(); + // CraftBukkit end + +- worldserver1.getProfiler().pop(); +- worldserver1.getProfiler().push("placing"); ++ //worldserver1.getProfiler().pop(); // Purpur ++ //worldserver1.getProfiler().push("placing"); // Purpur + if (true) { // CraftBukkit + this.isChangingDimension = true; // CraftBukkit - Set teleport invulnerability only if player changing worlds + +@@ -1196,7 +1196,7 @@ public class ServerPlayer extends Player { + worldserver.addDuringPortalTeleport(this); + this.connection.teleport(exit); // CraftBukkit - use internal teleport without event + this.connection.resetPosition(); // CraftBukkit - sync position after changing it (from PortalTravelAgent#findAndteleport) +- worldserver1.getProfiler().pop(); ++ //worldserver1.getProfiler().pop(); // Purpur + this.triggerDimensionChangeTriggers(worldserver1); + this.connection.send(new ClientboundPlayerAbilitiesPacket(this.getAbilities())); + playerlist.sendLevelInfo(this, worldserver); +diff --git a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java +index 6fd2886a77868a19f8077e6f0c61532be8db089a..2b3640dc691bf04e8e463a219551c98703647216 100644 +--- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java ++++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java +@@ -391,7 +391,7 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Ser + this.aboveGroundVehicleTickCount = 0; + }} // Paper - end if (valid) + +- this.server.getProfiler().push("keepAlive"); ++ //this.server.getProfiler().push("keepAlive"); // Purpur + // Paper Start - give clients a longer time to respond to pings as per pre 1.12.2 timings + // This should effectively place the keepalive handling back to "as it was" before 1.12.2 + long currentTime = Util.getMillis(); +@@ -427,7 +427,7 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Ser + } + // Paper end + +- this.server.getProfiler().pop(); ++ //this.server.getProfiler().pop(); // Purpur + // CraftBukkit start + for (int spam; (spam = this.chatSpamTickCount.get()) > 0 && !this.chatSpamTickCount.compareAndSet(spam, spam - 1); ) ; + if (tabSpamLimiter.get() > 0) tabSpamLimiter.getAndDecrement(); // Paper - split to seperate variable +diff --git a/src/main/java/net/minecraft/server/packs/resources/ResourceManagerReloadListener.java b/src/main/java/net/minecraft/server/packs/resources/ResourceManagerReloadListener.java +index 9ddbfcf80d9a381dace78a62880f85a4d767e0eb..7383c7d3820dce06108eaafd236a7c6c06a10a42 100644 +--- a/src/main/java/net/minecraft/server/packs/resources/ResourceManagerReloadListener.java ++++ b/src/main/java/net/minecraft/server/packs/resources/ResourceManagerReloadListener.java +@@ -9,11 +9,11 @@ public interface ResourceManagerReloadListener extends PreparableReloadListener + @Override + default CompletableFuture reload(PreparableReloadListener.PreparationBarrier synchronizer, ResourceManager manager, ProfilerFiller prepareProfiler, ProfilerFiller applyProfiler, Executor prepareExecutor, Executor applyExecutor) { + return synchronizer.wait(Unit.INSTANCE).thenRunAsync(() -> { +- applyProfiler.startTick(); +- applyProfiler.push("listener"); ++ //applyProfiler.startTick(); // Purpur ++ //applyProfiler.push("listener"); // Purpur + this.onResourceManagerReload(manager); +- applyProfiler.pop(); +- applyProfiler.endTick(); ++ //applyProfiler.pop(); // Purpur ++ //applyProfiler.endTick(); // Purpur + }, applyExecutor); + } + +diff --git a/src/main/java/net/minecraft/util/profiling/ActiveProfiler.java b/src/main/java/net/minecraft/util/profiling/ActiveProfiler.java +index 6d96da16f25e2359e053c45270310886e168f828..de024b88e7328c25748f59288fb7ff575fce1fdc 100644 +--- a/src/main/java/net/minecraft/util/profiling/ActiveProfiler.java ++++ b/src/main/java/net/minecraft/util/profiling/ActiveProfiler.java +@@ -55,7 +55,7 @@ public class ActiveProfiler implements ProfileCollector { + this.started = true; + this.path = ""; + this.paths.clear(); +- this.push("root"); ++ //this.push("root"); // Purpur + } + } + +@@ -64,7 +64,7 @@ public class ActiveProfiler implements ProfileCollector { + if (!this.started) { + LOGGER.error("Profiler tick already ended - missing startTick()?"); + } else { +- this.pop(); ++ //this.pop(); // Purpur + this.started = false; + if (!this.path.isEmpty()) { + LOGGER.error("Profiler tick ended before path was fully popped (remainder: '{}'). Mismatched push/pop?", LogUtils.defer(() -> { +@@ -93,7 +93,7 @@ public class ActiveProfiler implements ProfileCollector { + + @Override + public void push(Supplier locationGetter) { +- this.push(locationGetter.get()); ++ //this.push(locationGetter.get()); // Purpur + } + + @Override +@@ -132,14 +132,14 @@ public class ActiveProfiler implements ProfileCollector { + + @Override + public void popPush(String location) { +- this.pop(); +- this.push(location); ++ //this.pop(); // Purpur ++ //this.push(location); // Purpur + } + + @Override + public void popPush(Supplier locationGetter) { +- this.pop(); +- this.push(locationGetter); ++ //this.pop(); // Purpur ++ //this.push(locationGetter); // Purpur + } + + private ActiveProfiler.PathEntry getCurrentEntry() { +diff --git a/src/main/java/net/minecraft/util/profiling/ProfilerFiller.java b/src/main/java/net/minecraft/util/profiling/ProfilerFiller.java +index 5725c6593480fada65facc29664a00a8cc073512..ccb1f998ae3122d1856d77149ff7e7dffeedc71a 100644 +--- a/src/main/java/net/minecraft/util/profiling/ProfilerFiller.java ++++ b/src/main/java/net/minecraft/util/profiling/ProfilerFiller.java +@@ -6,32 +6,44 @@ import net.minecraft.util.profiling.metrics.MetricCategory; + public interface ProfilerFiller { + String ROOT = "root"; + ++ @io.papermc.paper.annotation.DoNotUse // Purpur + void startTick(); + ++ @io.papermc.paper.annotation.DoNotUse // Purpur + void endTick(); + ++ @io.papermc.paper.annotation.DoNotUse // Purpur + void push(String location); + ++ @io.papermc.paper.annotation.DoNotUse // Purpur + void push(Supplier locationGetter); + ++ @io.papermc.paper.annotation.DoNotUse // Purpur + void pop(); + ++ @io.papermc.paper.annotation.DoNotUse // Purpur + void popPush(String location); + ++ @io.papermc.paper.annotation.DoNotUse // Purpur + void popPush(Supplier locationGetter); + ++ @io.papermc.paper.annotation.DoNotUse // Purpur + void markForCharting(MetricCategory type); + ++ @io.papermc.paper.annotation.DoNotUse // Purpur + default void incrementCounter(String marker) { +- this.incrementCounter(marker, 1); ++ //this.incrementCounter(marker, 1); // Purpur + } + ++ @io.papermc.paper.annotation.DoNotUse // Purpur + void incrementCounter(String marker, int i); + ++ @io.papermc.paper.annotation.DoNotUse // Purpur + default void incrementCounter(Supplier markerGetter) { +- this.incrementCounter(markerGetter, 1); ++ //this.incrementCounter(markerGetter, 1); // Purpur + } + ++ @io.papermc.paper.annotation.DoNotUse // Purpur + void incrementCounter(Supplier markerGetter, int i); + + static ProfilerFiller tee(final ProfilerFiller a, final ProfilerFiller b) { +@@ -41,62 +53,62 @@ public interface ProfilerFiller { + return b == InactiveProfiler.INSTANCE ? a : new ProfilerFiller() { + @Override + public void startTick() { +- a.startTick(); +- b.startTick(); ++ //a.startTick(); // Purpur ++ //b.startTick(); // Purpur + } + + @Override + public void endTick() { +- a.endTick(); +- b.endTick(); ++ //a.endTick(); // Purpur ++ //b.endTick(); // Purpur + } + + @Override + public void push(String location) { +- a.push(location); +- b.push(location); ++ //a.push(location); // Purpur ++ //b.push(location); // Purpur + } + + @Override + public void push(Supplier locationGetter) { +- a.push(locationGetter); +- b.push(locationGetter); ++ //a.push(locationGetter); // Purpur ++ //b.push(locationGetter); // Purpur + } + + @Override + public void markForCharting(MetricCategory type) { +- a.markForCharting(type); +- b.markForCharting(type); ++ //a.markForCharting(type); // Purpur ++ //b.markForCharting(type); // Purpur + } + + @Override + public void pop() { +- a.pop(); +- b.pop(); ++ //a.pop(); // Purpur ++ //b.pop(); // Purpur + } + + @Override + public void popPush(String location) { +- a.popPush(location); +- b.popPush(location); ++ //a.popPush(location); // Purpur ++ //b.popPush(location); // Purpur + } + + @Override + public void popPush(Supplier locationGetter) { +- a.popPush(locationGetter); +- b.popPush(locationGetter); ++ //a.popPush(locationGetter); // Purpur ++ //b.popPush(locationGetter); // Purpur + } + + @Override + public void incrementCounter(String marker, int i) { +- a.incrementCounter(marker, i); +- b.incrementCounter(marker, i); ++ //a.incrementCounter(marker, i); // Purpur ++ //b.incrementCounter(marker, i); // Purpur + } + + @Override + public void incrementCounter(Supplier markerGetter, int i) { +- a.incrementCounter(markerGetter, i); +- b.incrementCounter(markerGetter, i); ++ //a.incrementCounter(markerGetter, i); // Purpur ++ //b.incrementCounter(markerGetter, i); // Purpur + } + }; + } +diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java +index ba4ff82c773b5c2ab46af13a467a7b36ba2bf63c..4e456c3c99d5203f48e921c38c38f9c6779581ad 100644 +--- a/src/main/java/net/minecraft/world/entity/Entity.java ++++ b/src/main/java/net/minecraft/world/entity/Entity.java +@@ -821,7 +821,7 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource { + return; + } + // Pufferfish end - entity TTL +- this.level.getProfiler().push("entityBaseTick"); ++ //this.level.getProfiler().push("entityBaseTick"); // Purpur + if (firstTick && this instanceof net.minecraft.world.entity.NeutralMob neutralMob) neutralMob.tickInitialPersistentAnger(level); // Paper - Update last hurt when ticking + this.feetBlockState = null; + if (this.isPassenger() && this.getVehicle().isRemoved()) { +@@ -882,7 +882,7 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource { + } + + this.firstTick = false; +- this.level.getProfiler().pop(); ++ //this.level.getProfiler().pop(); // Purpur + } + + public void setSharedFlagOnFire(boolean onFire) { +@@ -1056,7 +1056,7 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource { + } + } + +- this.level.getProfiler().push("move"); ++ //this.level.getProfiler().push("move"); // Purpur + if (this.stuckSpeedMultiplier.lengthSqr() > 1.0E-7D) { + movement = movement.multiply(this.stuckSpeedMultiplier); + this.stuckSpeedMultiplier = Vec3.ZERO; +@@ -1065,7 +1065,7 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource { + // Paper start - ignore movement changes while inactive. + if (isTemporarilyActive && !(this instanceof ItemEntity || this instanceof net.minecraft.world.entity.vehicle.AbstractMinecart) && movement == getDeltaMovement() && movementType == MoverType.SELF) { + setDeltaMovement(Vec3.ZERO); +- this.level.getProfiler().pop(); ++ //this.level.getProfiler().pop(); // Purpur + return; + } + // Paper end +@@ -1086,8 +1086,8 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource { + this.setPos(this.getX() + vec3d1.x, this.getY() + vec3d1.y, this.getZ() + vec3d1.z); + } + +- this.level.getProfiler().pop(); +- this.level.getProfiler().push("rest"); ++ //this.level.getProfiler().pop(); // Purpur ++ //this.level.getProfiler().push("rest"); // Purpur + boolean flag = !Mth.equal(movement.x, vec3d1.x); + boolean flag1 = !Mth.equal(movement.z, vec3d1.z); + +@@ -1106,7 +1106,7 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource { + + this.checkFallDamage(vec3d1.y, this.onGround, iblockdata, blockposition); + if (this.isRemoved()) { +- this.level.getProfiler().pop(); ++ //this.level.getProfiler().pop(); // Purpur + } else { + if (this.horizontalCollision) { + Vec3 vec3d2 = this.getDeltaMovement(); +@@ -1247,7 +1247,7 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource { + this.setRemainingFireTicks(-this.getFireImmuneTicks()); + } + +- this.level.getProfiler().pop(); ++ //this.level.getProfiler().pop(); // Purpur + } + } + // Paper start - detailed watchdog information +@@ -2906,7 +2906,7 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource { + ServerLevel worldserver1 = minecraftserver.getLevel(resourcekey); + + if (true && !this.isPassenger() && this.portalTime++ >= i) { // CraftBukkit +- this.level.getProfiler().push("portal"); ++ //this.level.getProfiler().push("portal"); // Purpur + this.portalTime = i; + // Paper start + io.papermc.paper.event.entity.EntityPortalReadyEvent event = new io.papermc.paper.event.entity.EntityPortalReadyEvent(this.getBukkitEntity(), worldserver1 == null ? null : worldserver1.getWorld(), org.bukkit.PortalType.NETHER); +@@ -2924,7 +2924,7 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource { + } + } // Paper + // CraftBukkit end +- this.level.getProfiler().pop(); ++ //this.level.getProfiler().pop(); // Purpur + } + + this.isInsidePortal = false; +@@ -3378,14 +3378,14 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource { + } + // Paper end + if (this.level instanceof ServerLevel && !this.isRemoved()) { +- this.level.getProfiler().push("changeDimension"); ++ //this.level.getProfiler().push("changeDimension"); // Purpur + // CraftBukkit start + // this.decouple(); + if (worldserver == null) { + return null; + } + // CraftBukkit end +- this.level.getProfiler().push("reposition"); ++ //this.level.getProfiler().push("reposition"); // Purpur + PortalInfo shapedetectorshape = (location == null) ? this.findDimensionEntryPoint(worldserver) : new PortalInfo(new Vec3(location.x(), location.y(), location.z()), Vec3.ZERO, this.yRot, this.xRot, worldserver, null); // CraftBukkit + + if (shapedetectorshape == null) { +@@ -3419,7 +3419,7 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource { + this.unRide(); + // CraftBukkit end + +- this.level.getProfiler().popPush("reloading"); ++ //this.level.getProfiler().popPush("reloading"); // Purpur + // Paper start - Change lead drop timing to prevent dupe + if (this instanceof Mob) { + ((Mob) this).dropLeash(true, true); // Paper drop lead +@@ -3442,10 +3442,10 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource { + } + + this.removeAfterChangingDimensions(); +- this.level.getProfiler().pop(); ++ //this.level.getProfiler().pop(); // Purpur + ((ServerLevel) this.level).resetEmptyTime(); + worldserver.resetEmptyTime(); +- this.level.getProfiler().pop(); ++ //this.level.getProfiler().pop(); // Purpur + return entity; + } + } else { +diff --git a/src/main/java/net/minecraft/world/entity/LivingEntity.java b/src/main/java/net/minecraft/world/entity/LivingEntity.java +index 411593b1b105d62440d76b7bd1b8c74b701e3e75..8872a9e62619f86288bc4a4e02eb49744c315cf9 100644 +--- a/src/main/java/net/minecraft/world/entity/LivingEntity.java ++++ b/src/main/java/net/minecraft/world/entity/LivingEntity.java +@@ -397,7 +397,7 @@ public abstract class LivingEntity extends Entity { + } + + super.baseTick(); +- this.level.getProfiler().push("livingEntityBaseTick"); ++ //this.level.getProfiler().push("livingEntityBaseTick"); // Purpur + if (this.fireImmune() || this.level.isClientSide) { + this.clearFire(); + } +@@ -501,7 +501,7 @@ public abstract class LivingEntity extends Entity { + this.yHeadRotO = this.yHeadRot; + this.yRotO = this.getYRot(); + this.xRotO = this.getXRot(); +- this.level.getProfiler().pop(); ++ //this.level.getProfiler().pop(); // Purpur + } + + public boolean canSpawnSoulSpeedParticle() { +@@ -3062,10 +3062,10 @@ public abstract class LivingEntity extends Entity { + } + + this.run += (f3 - this.run) * 0.3F; +- this.level.getProfiler().push("headTurn"); ++ //this.level.getProfiler().push("headTurn"); // Purpur + f2 = this.tickHeadTurn(f1, f2); +- this.level.getProfiler().pop(); +- this.level.getProfiler().push("rangeChecks"); ++ //this.level.getProfiler().pop(); // Purpur ++ //this.level.getProfiler().push("rangeChecks"); // Purpur + + while (this.getYRot() - this.yRotO < -180.0F) { + this.yRotO -= 360.0F; +@@ -3099,7 +3099,7 @@ public abstract class LivingEntity extends Entity { + this.yHeadRotO += 360.0F; + } + +- this.level.getProfiler().pop(); ++ //this.level.getProfiler().pop(); // Purpur + this.animStep += f2; + if (this.isFallFlying()) { + ++this.fallFlyTicks; +@@ -3381,19 +3381,19 @@ public abstract class LivingEntity extends Entity { + } + + this.setDeltaMovement(d4, d5, d6); +- this.level.getProfiler().push("ai"); ++ //this.level.getProfiler().push("ai"); // Purpur + if (this.isImmobile()) { + this.jumping = false; + this.xxa = 0.0F; + this.zza = 0.0F; + } else if (this.isEffectiveAi()) { +- this.level.getProfiler().push("newAi"); ++ //this.level.getProfiler().push("newAi"); // Purpur + this.serverAiStep(); +- this.level.getProfiler().pop(); ++ //this.level.getProfiler().pop(); // Purpur + } + +- this.level.getProfiler().pop(); +- this.level.getProfiler().push("jump"); ++ //this.level.getProfiler().pop(); // Purpur ++ //this.level.getProfiler().push("jump"); // Purpur + if (this.jumping && this.isAffectedByFluids()) { + double d7; + +@@ -3420,8 +3420,8 @@ public abstract class LivingEntity extends Entity { + this.noJumpDelay = 0; + } + +- this.level.getProfiler().pop(); +- this.level.getProfiler().push("travel"); ++ //this.level.getProfiler().pop(); // Purpur ++ //this.level.getProfiler().push("travel"); // Purpur + this.xxa *= 0.98F; + this.zza *= 0.98F; + this.updateFallFlying(); +@@ -3430,8 +3430,8 @@ public abstract class LivingEntity extends Entity { + // SpigotTimings.timerEntityAIMove.startTiming(); // Spigot // Paper + this.travel(new Vec3((double) this.xxa, (double) this.yya, (double) this.zza)); + // SpigotTimings.timerEntityAIMove.stopTiming(); // Spigot // Paper +- this.level.getProfiler().pop(); +- this.level.getProfiler().push("freezing"); ++ //this.level.getProfiler().pop(); // Purpur ++ //this.level.getProfiler().push("freezing"); // Purpur + boolean flag1 = this.getType().is(EntityTypeTags.FREEZE_HURTS_EXTRA_TYPES); + int i; + +@@ -3451,15 +3451,15 @@ public abstract class LivingEntity extends Entity { + this.hurt(DamageSource.FREEZE, (float) i); + } + +- this.level.getProfiler().pop(); +- this.level.getProfiler().push("push"); ++ //this.level.getProfiler().pop(); // Purpur ++ //this.level.getProfiler().push("push"); // Purpur + if (this.autoSpinAttackTicks > 0) { + --this.autoSpinAttackTicks; + this.checkAutoSpinAttack(axisalignedbb, this.getBoundingBox()); + } + + this.pushEntities(); +- this.level.getProfiler().pop(); ++ //this.level.getProfiler().pop(); // Purpur + // Paper start + // Purpur start + if (this.xo != this.getX() || this.yo != this.getY() || this.zo != this.getZ() || this.yRotO != this.getYRot() || this.xRotO != this.getXRot()) { +diff --git a/src/main/java/net/minecraft/world/entity/Mob.java b/src/main/java/net/minecraft/world/entity/Mob.java +index 34db1bd524bb97fbbe0f86b088a2ac343e730f5e..b75243eca01cae108093368e426ea2d6b6ef1057 100644 +--- a/src/main/java/net/minecraft/world/entity/Mob.java ++++ b/src/main/java/net/minecraft/world/entity/Mob.java +@@ -332,14 +332,14 @@ public abstract class Mob extends LivingEntity { + @Override + public void baseTick() { + super.baseTick(); +- this.level.getProfiler().push("mobBaseTick"); ++ //this.level.getProfiler().push("mobBaseTick"); // Purpur + if (this.isAlive() && this.random.nextInt(1000) < this.ambientSoundTime++) { + this.resetAmbientSoundTime(); + this.playAmbientSound(); + } + + incrementTicksSinceLastInteraction(); // Purpur +- this.level.getProfiler().pop(); ++ //this.level.getProfiler().pop(); // Purpur + } + + // Purpur start +@@ -663,7 +663,7 @@ public abstract class Mob extends LivingEntity { + @Override + public void aiStep() { + super.aiStep(); +- this.level.getProfiler().push("looting"); ++ //this.level.getProfiler().push("looting"); // Purpur + if (!this.level.isClientSide && this.canPickUpLoot() && this.isAlive() && !this.dead && (this.level.purpurConfig.entitiesPickUpLootBypassMobGriefing || this.level.getGameRules().getBoolean(GameRules.RULE_MOBGRIEFING))) { + Vec3i baseblockposition = this.getPickupReach(); + List list = this.level.getEntitiesOfClass(ItemEntity.class, this.getBoundingBox().inflate((double) baseblockposition.getX(), (double) baseblockposition.getY(), (double) baseblockposition.getZ())); +@@ -683,7 +683,7 @@ public abstract class Mob extends LivingEntity { + } + } + +- this.level.getProfiler().pop(); ++ //this.level.getProfiler().pop(); // Purpur + } + + protected Vec3i getPickupReach() { +@@ -878,46 +878,46 @@ public abstract class Mob extends LivingEntity { + return; + } + // Paper end +- this.level.getProfiler().push("sensing"); ++ //this.level.getProfiler().push("sensing"); // Purpur + this.sensing.tick(); +- this.level.getProfiler().pop(); ++ //this.level.getProfiler().pop(); // Purpur + int i = this.level.getServer().getTickCount() + this.getId(); + + if (i % 2 != 0 && this.tickCount > 1) { +- this.level.getProfiler().push("targetSelector"); ++ //this.level.getProfiler().push("targetSelector"); // Purpur + if (this.targetSelector.inactiveTick(this.activatedPriority, false)) // Pufferfish - use this to alternate ticking + this.targetSelector.tickRunningGoals(false); +- this.level.getProfiler().pop(); +- this.level.getProfiler().push("goalSelector"); ++ //this.level.getProfiler().pop(); // Purpur ++ //this.level.getProfiler().push("goalSelector"); // Purpur + if (this.goalSelector.inactiveTick(this.activatedPriority, false)) // Pufferfish - use this to alternate ticking + this.goalSelector.tickRunningGoals(false); +- this.level.getProfiler().pop(); ++ //this.level.getProfiler().pop(); // Purpur + } else { +- this.level.getProfiler().push("targetSelector"); ++ //this.level.getProfiler().push("targetSelector"); // Purpur + if (this.targetSelector.inactiveTick(this.activatedPriority, false)) // Pufferfish - use this to alternate ticking + this.targetSelector.tick(); +- this.level.getProfiler().pop(); +- this.level.getProfiler().push("goalSelector"); ++ //this.level.getProfiler().pop(); // Purpur ++ //this.level.getProfiler().push("goalSelector"); // Purpur + if (this.goalSelector.inactiveTick(this.activatedPriority, false)) // Pufferfish - use this to alternate ticking + this.goalSelector.tick(); +- this.level.getProfiler().pop(); ++ //this.level.getProfiler().pop(); // Purpur + } + +- this.level.getProfiler().push("navigation"); ++ //this.level.getProfiler().push("navigation"); // Purpur + this.navigation.tick(); +- this.level.getProfiler().pop(); +- this.level.getProfiler().push("mob tick"); ++ //this.level.getProfiler().pop(); // Purpur ++ //this.level.getProfiler().push("mob tick"); // Purpur + this.customServerAiStep(); +- this.level.getProfiler().pop(); +- this.level.getProfiler().push("controls"); +- this.level.getProfiler().push("move"); ++ //this.level.getProfiler().pop(); // Purpur ++ //this.level.getProfiler().push("controls"); // Purpur ++ //this.level.getProfiler().push("move"); // Purpur + this.moveControl.tick(); +- this.level.getProfiler().popPush("look"); ++ //this.level.getProfiler().popPush("look"); // Purpur + this.lookControl.tick(); +- this.level.getProfiler().popPush("jump"); ++ //this.level.getProfiler().popPush("jump"); // Purpur + this.jumpControl.tick(); +- this.level.getProfiler().pop(); +- this.level.getProfiler().pop(); ++ //this.level.getProfiler().pop(); // Purpur ++ //this.level.getProfiler().pop(); // Purpur + this.sendDebugPackets(); + } + +diff --git a/src/main/java/net/minecraft/world/entity/ai/goal/GoalSelector.java b/src/main/java/net/minecraft/world/entity/ai/goal/GoalSelector.java +index 0cc0d719e95e108263683b7a40f4ce3a8ca9465b..872ec431ae6beb0ef603d833f38aedb9d87e5466 100644 +--- a/src/main/java/net/minecraft/world/entity/ai/goal/GoalSelector.java ++++ b/src/main/java/net/minecraft/world/entity/ai/goal/GoalSelector.java +@@ -102,8 +102,8 @@ public class GoalSelector { + } + + public void tick() { +- ProfilerFiller profilerFiller = this.profiler.get(); +- profilerFiller.push("goalCleanup"); ++ //ProfilerFiller profilerFiller = this.profiler.get(); // Purpur ++ //profilerFiller.push("goalCleanup"); // Purpur + + for(WrappedGoal wrappedGoal : this.availableGoals) { + if (wrappedGoal.isRunning() && (goalContainsAnyFlags(wrappedGoal, this.goalTypes) || !wrappedGoal.canContinueToUse())) { +@@ -120,8 +120,8 @@ public class GoalSelector { + } + } + +- profilerFiller.pop(); +- profilerFiller.push("goalUpdate"); ++ //profilerFiller.pop(); // Purpur ++ //profilerFiller.push("goalUpdate"); // Purpur + + for(WrappedGoal wrappedGoal2 : this.availableGoals) { + // Paper start +@@ -141,13 +141,13 @@ public class GoalSelector { + } + } + +- profilerFiller.pop(); ++ //profilerFiller.pop(); // Purpur + this.tickRunningGoals(true); + } + + public void tickRunningGoals(boolean tickAll) { +- ProfilerFiller profilerFiller = this.profiler.get(); +- profilerFiller.push("goalTick"); ++ //ProfilerFiller profilerFiller = this.profiler.get(); // Purpur ++ //profilerFiller.push("goalTick"); // Purpur + + for(WrappedGoal wrappedGoal : this.availableGoals) { + if (wrappedGoal.isRunning() && (tickAll || wrappedGoal.requiresUpdateEveryTick())) { +@@ -155,7 +155,7 @@ public class GoalSelector { + } + } + +- profilerFiller.pop(); ++ //profilerFiller.pop(); // Purpur + } + + public Set getAvailableGoals() { +diff --git a/src/main/java/net/minecraft/world/entity/ai/navigation/PathNavigation.java b/src/main/java/net/minecraft/world/entity/ai/navigation/PathNavigation.java +index aa3fbdaffd69d65d9522f82fab45d0475cae024f..f8b0ed25718c766fe6a152e350a38ee0f3a4d230 100644 +--- a/src/main/java/net/minecraft/world/entity/ai/navigation/PathNavigation.java ++++ b/src/main/java/net/minecraft/world/entity/ai/navigation/PathNavigation.java +@@ -174,12 +174,12 @@ public abstract class PathNavigation { + } + } + // Paper end +- this.level.getProfiler().push("pathfind"); ++ //this.level.getProfiler().push("pathfind"); // Purpur + BlockPos blockPos = useHeadPos ? this.mob.blockPosition().above() : this.mob.blockPosition(); + int i = (int)(followRange + (float)range); + PathNavigationRegion pathNavigationRegion = new PathNavigationRegion(this.level, blockPos.offset(-i, -i, -i), blockPos.offset(i, i, i)); + Path path = this.pathFinder.findPath(pathNavigationRegion, this.mob, positions, followRange, distance, this.maxVisitedNodesMultiplier); +- this.level.getProfiler().pop(); ++ //this.level.getProfiler().pop(); // Purpur + + // Pufferfish start + if (!gg.pufferfish.pufferfish.PufferfishConfig.enableAsyncPathfinding) { +diff --git a/src/main/java/net/minecraft/world/entity/ai/sensing/Sensing.java b/src/main/java/net/minecraft/world/entity/ai/sensing/Sensing.java +index 288c6627906d07c0d223eacd84ae4eb31a349998..9babe636176da3c40598eb5bdac0919a1704eaa0 100644 +--- a/src/main/java/net/minecraft/world/entity/ai/sensing/Sensing.java ++++ b/src/main/java/net/minecraft/world/entity/ai/sensing/Sensing.java +@@ -26,9 +26,9 @@ public class Sensing { + } else if (this.unseen.contains(i)) { + return false; + } else { +- this.mob.level.getProfiler().push("hasLineOfSight"); ++ //this.mob.level.getProfiler().push("hasLineOfSight"); // Purpur + boolean bl = this.mob.hasLineOfSight(entity); +- this.mob.level.getProfiler().pop(); ++ //this.mob.level.getProfiler().pop(); // Purpur + if (bl) { + this.seen.add(i); + } else { +diff --git a/src/main/java/net/minecraft/world/entity/animal/allay/Allay.java b/src/main/java/net/minecraft/world/entity/animal/allay/Allay.java +index 1fbdf53691670414564171521583b00d719040e4..67d5742b85f0636f23a23564bf3658cd143ac7d5 100644 +--- a/src/main/java/net/minecraft/world/entity/animal/allay/Allay.java ++++ b/src/main/java/net/minecraft/world/entity/animal/allay/Allay.java +@@ -216,12 +216,12 @@ public class Allay extends PathfinderMob implements InventoryCarrier, VibrationL + + @Override + protected void customServerAiStep() { +- this.level.getProfiler().push("allayBrain"); ++ //this.level.getProfiler().push("allayBrain"); // Purpur + this.getBrain().tick((ServerLevel)this.level, this); +- this.level.getProfiler().pop(); +- this.level.getProfiler().push("allayActivityUpdate"); ++ //this.level.getProfiler().pop(); // Purpur ++ //this.level.getProfiler().push("allayActivityUpdate"); // Purpur + AllayAi.updateActivity(this); +- this.level.getProfiler().pop(); ++ //this.level.getProfiler().pop(); // Purpur + super.customServerAiStep(); + } + +diff --git a/src/main/java/net/minecraft/world/entity/animal/axolotl/Axolotl.java b/src/main/java/net/minecraft/world/entity/animal/axolotl/Axolotl.java +index 32870e6727d09fbf1c4913ffdf321a278b5b6f64..50f19125fa3dda79a850cfce0ab7c72045d6220b 100644 +--- a/src/main/java/net/minecraft/world/entity/animal/axolotl/Axolotl.java ++++ b/src/main/java/net/minecraft/world/entity/animal/axolotl/Axolotl.java +@@ -328,13 +328,13 @@ public class Axolotl extends Animal implements LerpingModel, Bucketable { + private int behaviorTick = 0; // Pufferfish + @Override + protected void customServerAiStep() { +- this.level.getProfiler().push("axolotlBrain"); ++ //this.level.getProfiler().push("axolotlBrain"); // Purpur + if (this.behaviorTick++ % this.activatedPriority == 0) // Pufferfish + this.getBrain().tick((ServerLevel) this.level, this); +- this.level.getProfiler().pop(); +- this.level.getProfiler().push("axolotlActivityUpdate"); ++ //this.level.getProfiler().pop(); // Purpur ++ //this.level.getProfiler().push("axolotlActivityUpdate"); // Purpur + AxolotlAi.updateActivity(this); +- this.level.getProfiler().pop(); ++ //this.level.getProfiler().pop(); // Purpur + if (!this.isNoAi()) { + Optional optional = this.getBrain().getMemory(MemoryModuleType.PLAY_DEAD_TICKS); + +diff --git a/src/main/java/net/minecraft/world/entity/animal/frog/Frog.java b/src/main/java/net/minecraft/world/entity/animal/frog/Frog.java +index 04262d31dc0767500f2b22cfe5768a8e24de7af9..82d98615fea97ebc0a333748d47b83beeff923d6 100644 +--- a/src/main/java/net/minecraft/world/entity/animal/frog/Frog.java ++++ b/src/main/java/net/minecraft/world/entity/animal/frog/Frog.java +@@ -229,12 +229,12 @@ public class Frog extends Animal { + + @Override + protected void customServerAiStep() { +- this.level.getProfiler().push("frogBrain"); ++ //this.level.getProfiler().push("frogBrain"); // Purpur + this.getBrain().tick((ServerLevel)this.level, this); +- this.level.getProfiler().pop(); +- this.level.getProfiler().push("frogActivityUpdate"); ++ //this.level.getProfiler().pop(); // Purpur ++ //this.level.getProfiler().push("frogActivityUpdate"); // Purpur + FrogAi.updateActivity(this); +- this.level.getProfiler().pop(); ++ //this.level.getProfiler().pop(); // Purpur + super.customServerAiStep(); + } + +diff --git a/src/main/java/net/minecraft/world/entity/animal/frog/Tadpole.java b/src/main/java/net/minecraft/world/entity/animal/frog/Tadpole.java +index 4dca3788a8fa335dc5969bd61cd0658f21e3bff3..88025a051a9e8c21aaf171431a0850c267ca4ca4 100644 +--- a/src/main/java/net/minecraft/world/entity/animal/frog/Tadpole.java ++++ b/src/main/java/net/minecraft/world/entity/animal/frog/Tadpole.java +@@ -115,12 +115,12 @@ public class Tadpole extends AbstractFish { + + @Override + protected void customServerAiStep() { +- this.level.getProfiler().push("tadpoleBrain"); ++ //this.level.getProfiler().push("tadpoleBrain"); // Purpur + this.getBrain().tick((ServerLevel) this.level, this); +- this.level.getProfiler().pop(); +- this.level.getProfiler().push("tadpoleActivityUpdate"); ++ //this.level.getProfiler().pop(); // Purpur ++ //this.level.getProfiler().push("tadpoleActivityUpdate"); // Purpur + TadpoleAi.updateActivity(this); +- this.level.getProfiler().pop(); ++ //this.level.getProfiler().pop(); // Purpur + super.customServerAiStep(); + } + +diff --git a/src/main/java/net/minecraft/world/entity/animal/goat/Goat.java b/src/main/java/net/minecraft/world/entity/animal/goat/Goat.java +index 4688e567dff250437335cbde34db4483f535b79a..3b85ec87ec708d670710734a1c1b04b2313cbbea 100644 +--- a/src/main/java/net/minecraft/world/entity/animal/goat/Goat.java ++++ b/src/main/java/net/minecraft/world/entity/animal/goat/Goat.java +@@ -203,13 +203,13 @@ public class Goat extends Animal { + private int behaviorTick = 0; // Pufferfish + @Override + protected void customServerAiStep() { +- this.level.getProfiler().push("goatBrain"); ++ //this.level.getProfiler().push("goatBrain"); // Purpur + if ((getRider() == null || !this.isControllable()) && this.behaviorTick++ % this.activatedPriority == 0) // Pufferfish // Purpur - only use brain if no rider + this.getBrain().tick((ServerLevel) this.level, this); +- this.level.getProfiler().pop(); +- this.level.getProfiler().push("goatActivityUpdate"); ++ //this.level.getProfiler().pop(); // Purpur ++ //this.level.getProfiler().push("goatActivityUpdate"); // Purpur + GoatAi.updateActivity(this); +- this.level.getProfiler().pop(); ++ //this.level.getProfiler().pop(); // Purpur + super.customServerAiStep(); + } + +diff --git a/src/main/java/net/minecraft/world/entity/monster/Zoglin.java b/src/main/java/net/minecraft/world/entity/monster/Zoglin.java +index 66b824ac3c24c46014d615b355a8a04e59f45e1b..cc6e65d8fd760e46f20a7bcc6aff1cc08d7ca6a9 100644 +--- a/src/main/java/net/minecraft/world/entity/monster/Zoglin.java ++++ b/src/main/java/net/minecraft/world/entity/monster/Zoglin.java +@@ -231,10 +231,10 @@ public class Zoglin extends Monster implements Enemy, HoglinBase { + + @Override + protected void customServerAiStep() { +- this.level.getProfiler().push("zoglinBrain"); ++ //this.level.getProfiler().push("zoglinBrain"); // Purpur + if (getRider() == null || !this.isControllable()) // Purpur - only use brain if no rider + this.getBrain().tick((ServerLevel)this.level, this); +- this.level.getProfiler().pop(); ++ //this.level.getProfiler().pop(); // Purpur + this.updateActivity(); + } + +diff --git a/src/main/java/net/minecraft/world/entity/monster/hoglin/Hoglin.java b/src/main/java/net/minecraft/world/entity/monster/hoglin/Hoglin.java +index 9d65b412e30f528d378de9072b48632c56c3e5bb..9ff882352b3fb69d8a8ecaf1908709761b3e9658 100644 +--- a/src/main/java/net/minecraft/world/entity/monster/hoglin/Hoglin.java ++++ b/src/main/java/net/minecraft/world/entity/monster/hoglin/Hoglin.java +@@ -166,10 +166,10 @@ public class Hoglin extends Animal implements Enemy, HoglinBase { + private int behaviorTick; // Pufferfish + @Override + protected void customServerAiStep() { +- this.level.getProfiler().push("hoglinBrain"); ++ //this.level.getProfiler().push("hoglinBrain"); // Purpur + if ((getRider() == null || !this.isControllable()) && this.behaviorTick++ % this.activatedPriority == 0) // Pufferfish // Purpur - only use brain if no rider + this.getBrain().tick((ServerLevel)this.level, this); +- this.level.getProfiler().pop(); ++ //this.level.getProfiler().pop(); // Purpur + HoglinAi.updateActivity(this); + if (this.isConverting()) { + ++this.timeInOverworld; +diff --git a/src/main/java/net/minecraft/world/entity/monster/piglin/Piglin.java b/src/main/java/net/minecraft/world/entity/monster/piglin/Piglin.java +index 68cb1fb0b1d5b4d4b656f71a35a5ba69e37511e2..01f0cfb119f51fa3dcb50ee543d500f85455d405 100644 +--- a/src/main/java/net/minecraft/world/entity/monster/piglin/Piglin.java ++++ b/src/main/java/net/minecraft/world/entity/monster/piglin/Piglin.java +@@ -324,10 +324,10 @@ public class Piglin extends AbstractPiglin implements CrossbowAttackMob, Invento + private int behaviorTick; // Pufferfish + @Override + protected void customServerAiStep() { +- this.level.getProfiler().push("piglinBrain"); ++ //this.level.getProfiler().push("piglinBrain"); // Purpur + if ((getRider() == null || !this.isControllable()) && this.behaviorTick++ % this.activatedPriority == 0) // Pufferfish // Purpur - only use brain if no rider + this.getBrain().tick((ServerLevel) this.level, this); +- this.level.getProfiler().pop(); ++ //this.level.getProfiler().pop(); // Purpur + PiglinAi.updateActivity(this); + super.customServerAiStep(); + } +diff --git a/src/main/java/net/minecraft/world/entity/monster/piglin/PiglinBrute.java b/src/main/java/net/minecraft/world/entity/monster/piglin/PiglinBrute.java +index 760015f7a98e70b735707c77472c084d8bd052bb..bc6572b1025d74a7590d7e1cc49132f95af0560a 100644 +--- a/src/main/java/net/minecraft/world/entity/monster/piglin/PiglinBrute.java ++++ b/src/main/java/net/minecraft/world/entity/monster/piglin/PiglinBrute.java +@@ -117,10 +117,10 @@ public class PiglinBrute extends AbstractPiglin { + + @Override + protected void customServerAiStep() { +- this.level.getProfiler().push("piglinBruteBrain"); ++ //this.level.getProfiler().push("piglinBruteBrain"); // Purpur + if (getRider() == null || this.isControllable()) // Purpur - only use brain if no rider + this.getBrain().tick((ServerLevel)this.level, this); +- this.level.getProfiler().pop(); ++ //this.level.getProfiler().pop(); // Purpur + PiglinBruteAi.updateActivity(this); + PiglinBruteAi.maybePlayActivitySound(this); + super.customServerAiStep(); +diff --git a/src/main/java/net/minecraft/world/entity/monster/warden/Warden.java b/src/main/java/net/minecraft/world/entity/monster/warden/Warden.java +index 54959365ffc81d305d07562fc5677cbb9fb97d2b..f8d773d3a2c20ab27c0a250b2f5fc7be05ca9b1b 100644 +--- a/src/main/java/net/minecraft/world/entity/monster/warden/Warden.java ++++ b/src/main/java/net/minecraft/world/entity/monster/warden/Warden.java +@@ -298,9 +298,9 @@ public class Warden extends Monster implements VibrationListener.VibrationListen + protected void customServerAiStep() { + ServerLevel worldserver = (ServerLevel) this.level; + +- worldserver.getProfiler().push("wardenBrain"); ++ //worldserver.getProfiler().push("wardenBrain"); // Purpur + this.getBrain().tick(worldserver, this); +- this.level.getProfiler().pop(); ++ //this.level.getProfiler().pop(); // Purpur + super.customServerAiStep(); + if ((this.tickCount + this.getId()) % 120 == 0) { + Warden.applyDarknessAround(worldserver, this.position(), this, 20); +diff --git a/src/main/java/net/minecraft/world/entity/npc/Villager.java b/src/main/java/net/minecraft/world/entity/npc/Villager.java +index 20668d53625ec88ba3eb2a655ad3f6bc4fb0fd0e..b1a4b83fc248ae2f0a8852e60f9cd4486535390a 100644 +--- a/src/main/java/net/minecraft/world/entity/npc/Villager.java ++++ b/src/main/java/net/minecraft/world/entity/npc/Villager.java +@@ -337,7 +337,7 @@ public class Villager extends AbstractVillager implements ReputationEventHandler + @Override + protected void customServerAiStep() { mobTick(false); } + protected void mobTick(boolean inactive) { +- this.level.getProfiler().push("villagerBrain"); ++ //this.level.getProfiler().push("villagerBrain"); // Purpur + // Purpur start + if (this.level.purpurConfig.villagerLobotomizeEnabled) { + // treat as inactive if lobotomized +@@ -363,7 +363,7 @@ public class Villager extends AbstractVillager implements ReputationEventHandler + restock(); + } + // Purpur end +- this.level.getProfiler().pop(); ++ //this.level.getProfiler().pop(); // Purpur + if (this.assignProfessionWhenSpawned) { + this.assignProfessionWhenSpawned = false; + } +diff --git a/src/main/java/net/minecraft/world/level/Explosion.java b/src/main/java/net/minecraft/world/level/Explosion.java +index 01477e7240f9e33d08d416a7d40ee10f3e5d4abf..c9def2202d7c2a523858ec124df2beaf994d9888 100644 +--- a/src/main/java/net/minecraft/world/level/Explosion.java ++++ b/src/main/java/net/minecraft/world/level/Explosion.java +@@ -363,7 +363,7 @@ public class Explosion { + if (!iblockdata.isAir() && iblockdata.isDestroyable()) { // Paper + BlockPos blockposition1 = blockposition.immutable(); + +- this.level.getProfiler().push("explosion_blocks"); ++ //this.level.getProfiler().push("explosion_blocks"); // Purpur + if (block.dropFromExplosion(this)) { + Level world = this.level; + +@@ -385,7 +385,7 @@ public class Explosion { + + this.level.setBlock(blockposition, Blocks.AIR.defaultBlockState(), 3); + block.wasExploded(this.level, blockposition, this); +- this.level.getProfiler().pop(); ++ //this.level.getProfiler().pop(); // Purpur + } + } + +diff --git a/src/main/java/net/minecraft/world/level/Level.java b/src/main/java/net/minecraft/world/level/Level.java +index d270d0f47d26085ce7912b61a66b922a95871a73..ee54cbdaecbdd285fe3f74f902f01f964b569521 100644 +--- a/src/main/java/net/minecraft/world/level/Level.java ++++ b/src/main/java/net/minecraft/world/level/Level.java +@@ -713,9 +713,9 @@ public abstract class Level implements LevelAccessor, AutoCloseable { + BlockState iblockdata2 = this.getBlockState(pos); + + if ((flags & 128) == 0 && iblockdata2 != iblockdata1 && (iblockdata2.getLightBlock(this, pos) != iblockdata1.getLightBlock(this, pos) || iblockdata2.getLightEmission() != iblockdata1.getLightEmission() || iblockdata2.useShapeForLightOcclusion() || iblockdata1.useShapeForLightOcclusion())) { +- this.getProfiler().push("queueCheckLight"); ++ //this.getProfiler().push("queueCheckLight"); // Purpur + this.getChunkSource().getLightEngine().checkBlock(pos); +- this.getProfiler().pop(); ++ //this.getProfiler().pop(); // Purpur + } + + /* +@@ -991,9 +991,9 @@ public abstract class Level implements LevelAccessor, AutoCloseable { + } + + protected void tickBlockEntities() { +- ProfilerFiller gameprofilerfiller = this.getProfiler(); ++ //ProfilerFiller gameprofilerfiller = this.getProfiler(); // Purpur + +- gameprofilerfiller.push("blockEntities"); ++ //gameprofilerfiller.push("blockEntities"); // Purpur + //timings.tileEntityPending.startTiming(); // Spigot // Purpur + this.tickingBlockEntities = true; + if (!this.pendingBlockEntityTickers.isEmpty()) { +@@ -1038,7 +1038,7 @@ public abstract class Level implements LevelAccessor, AutoCloseable { + //timings.tileEntityTick.stopTiming(); // Spigot // Purpur + this.tickingBlockEntities = false; + co.aikar.timings.TimingHistory.tileEntityTicks += this.blockEntityTickers.size(); // Paper +- gameprofilerfiller.pop(); ++ //gameprofilerfiller.pop(); // Purpur + spigotConfig.currentPrimedTnt = 0; // Spigot + } + +@@ -1199,7 +1199,7 @@ public abstract class Level implements LevelAccessor, AutoCloseable { + + @Override + public List getEntities(@Nullable Entity except, AABB box, Predicate predicate) { +- this.getProfiler().incrementCounter("getEntities"); ++ //this.getProfiler().incrementCounter("getEntities"); // Purpur + List list = Lists.newArrayList(); + this.entitySliceManager.getEntities(except, box, list, predicate); // Paper - optimise this call + return list; +@@ -1207,7 +1207,7 @@ public abstract class Level implements LevelAccessor, AutoCloseable { + + @Override + public List getEntities(EntityTypeTest filter, AABB box, Predicate predicate) { +- this.getProfiler().incrementCounter("getEntities"); ++ //this.getProfiler().incrementCounter("getEntities"); // Purpur + List list = Lists.newArrayList(); + + // Paper start - optimise this call +@@ -1538,7 +1538,7 @@ public abstract class Level implements LevelAccessor, AutoCloseable { + } + + public ProfilerFiller getProfiler() { +- if (gg.pufferfish.pufferfish.PufferfishConfig.disableMethodProfiler) return net.minecraft.util.profiling.InactiveProfiler.INSTANCE; // Pufferfish ++ if (true || gg.pufferfish.pufferfish.PufferfishConfig.disableMethodProfiler) return net.minecraft.util.profiling.InactiveProfiler.INSTANCE; // Pufferfish // Purpur + return (ProfilerFiller) this.profiler.get(); + } + +diff --git a/src/main/java/net/minecraft/world/level/NaturalSpawner.java b/src/main/java/net/minecraft/world/level/NaturalSpawner.java +index 5c6fde4baf27e7d8f027c138d843da39a4a2ed36..4a8998a98987985e259b0a2a29ee7c94c1f3a4b1 100644 +--- a/src/main/java/net/minecraft/world/level/NaturalSpawner.java ++++ b/src/main/java/net/minecraft/world/level/NaturalSpawner.java +@@ -131,7 +131,7 @@ public final class NaturalSpawner { + } + + public static void spawnForChunk(ServerLevel world, LevelChunk chunk, NaturalSpawner.SpawnState info, boolean spawnAnimals, boolean spawnMonsters, boolean rareSpawn) { +- world.getProfiler().push("spawner"); ++ //world.getProfiler().push("spawner"); // Purpur + //world.timings.mobSpawn.startTiming(); // Spigot // Purpur + MobCategory[] aenumcreaturetype = NaturalSpawner.SPAWNING_CATEGORIES; + int i = aenumcreaturetype.length; +@@ -188,7 +188,7 @@ public final class NaturalSpawner { + } + + //world.timings.mobSpawn.stopTiming(); // Spigot // Purpur +- world.getProfiler().pop(); ++ //world.getProfiler().pop(); // Purpur + } + + // Paper start +diff --git a/src/main/java/net/minecraft/world/level/chunk/LevelChunk.java b/src/main/java/net/minecraft/world/level/chunk/LevelChunk.java +index ab024c5315c0a7cb2f80d5d7b251f6a3531879b3..12293740461b6cd965297543a1ae3bead83bd3a6 100644 +--- a/src/main/java/net/minecraft/world/level/chunk/LevelChunk.java ++++ b/src/main/java/net/minecraft/world/level/chunk/LevelChunk.java +@@ -1236,9 +1236,9 @@ public class LevelChunk extends ChunkAccess { + + if (LevelChunk.this.isTicking(blockposition)) { + try { +- ProfilerFiller gameprofilerfiller = LevelChunk.this.level.getProfiler(); ++ //ProfilerFiller gameprofilerfiller = LevelChunk.this.level.getProfiler(); // Purpur + +- gameprofilerfiller.push(this::getType); ++ //gameprofilerfiller.push(this::getType); // Purpur + //this.blockEntity.tickTimer.startTiming(); // Spigot // Purpur + BlockState iblockdata = LevelChunk.this.getBlockState(blockposition); + +@@ -1250,7 +1250,7 @@ public class LevelChunk extends ChunkAccess { + LevelChunk.LOGGER.warn("Block entity {} @ {} state {} invalid for ticking:", new Object[]{LogUtils.defer(this::getType), LogUtils.defer(this::getPos), iblockdata}); + } + +- gameprofilerfiller.pop(); ++ //gameprofilerfiller.pop(); // Purpur + } catch (Throwable throwable) { + if (throwable instanceof ThreadDeath) throw throwable; // Paper + // Paper start - Prevent tile entity and entity crashes +diff --git a/src/main/java/net/minecraft/world/level/pathfinder/PathFinder.java b/src/main/java/net/minecraft/world/level/pathfinder/PathFinder.java +index e6593d081b9349d68d45b645455d28f6f00d7c00..aca4100964a1f225bd93390f521073e2bc15c04f 100644 +--- a/src/main/java/net/minecraft/world/level/pathfinder/PathFinder.java ++++ b/src/main/java/net/minecraft/world/level/pathfinder/PathFinder.java +@@ -78,8 +78,8 @@ public class PathFinder { + // Paper start - optimize collection + private Path findPath(ProfilerFiller profiler, Node startNode, List> positions, float followRange, int distance, float rangeMultiplier) { + // readd the profiler code for sync +- profiler.push("find_path"); +- profiler.markForCharting(MetricCategory.PATH_FINDING); ++ //profiler.push("find_path"); // Purpur ++ //profiler.markForCharting(MetricCategory.PATH_FINDING); // Purpur + + try { + return this.processPath(this.nodeEvaluator, startNode, positions, followRange, distance, rangeMultiplier); +diff --git a/src/main/java/net/minecraft/world/ticks/LevelTicks.java b/src/main/java/net/minecraft/world/ticks/LevelTicks.java +index 7f1ac2cb29eb84833c0895442d611dfa0504527e..5dea8414964e0d2d1fb15a6baa27227e9722bfc7 100644 +--- a/src/main/java/net/minecraft/world/ticks/LevelTicks.java ++++ b/src/main/java/net/minecraft/world/ticks/LevelTicks.java +@@ -86,20 +86,20 @@ public class LevelTicks implements LevelTickAccess { + } + + public void tick(long time, int maxTicks, BiConsumer ticker) { +- ProfilerFiller profilerFiller = this.profiler.get(); +- profilerFiller.push("collect"); +- this.collectTicks(time, maxTicks, profilerFiller); +- profilerFiller.popPush("run"); +- profilerFiller.incrementCounter("ticksToRun", this.toRunThisTick.size()); ++ //ProfilerFiller profilerFiller = this.profiler.get(); // Purpur ++ //profilerFiller.push("collect"); // Purpur ++ this.collectTicks(time, maxTicks, null); // Purpur ++ //profilerFiller.popPush("run"); // Purpur ++ //profilerFiller.incrementCounter("ticksToRun", this.toRunThisTick.size()); // Purpur + this.runCollectedTicks(ticker); +- profilerFiller.popPush("cleanup"); ++ //profilerFiller.popPush("cleanup"); // Purpur + this.cleanupAfterTick(); +- profilerFiller.pop(); ++ //profilerFiller.pop(); // Purpur + } + + private void collectTicks(long time, int maxTicks, ProfilerFiller profiler) { + this.sortContainersToTick(time); +- profiler.incrementCounter("containersToTick", this.containersToTick.size()); ++ //profiler.incrementCounter("containersToTick", this.containersToTick.size()); // Purpur + this.drainContainers(time, maxTicks); + this.rescheduleLeftoverContainers(); + }