From 48c1fde6b090472a7e712fe48a85f3390abe753a Mon Sep 17 00:00:00 2001 From: MrHua269 Date: Tue, 20 Feb 2024 13:23:20 +0000 Subject: [PATCH] Add some optimizations and misc config --- ...-config-for-out-of-order-chat-checks.patch | 45 ++ ... 0015-Io_uring-channel-type-support.patch} | 0 ...-fixing-folia-spector-teleportation.patch} | 2 +- ...-entity-was-moving-to-another-regio.patch} | 2 +- ...sync-calling-during-moving-event-be.patch} | 0 ...019-Piston-fixes-from-molean-server.patch} | 0 ...u-linear-region-format-and-settings.patch} | 0 ...aiiju-Don-t-pathfind-outside-region.patch} | 0 ...ju-Vanilla-end-portal-teleportation.patch} | 0 ...> 0023-Kaiiju-Async-path-processing.patch} | 2 +- ...ch => 0024-Petal-Reduce-sensor-work.patch} | 2 +- ...fish-Optimize-entity-coordinate-key.patch} | 0 ...Cache-climbing-check-for-activation.patch} | 0 ...ish-Improve-fluid-direction-caching.patch} | 0 ...028-Pufferfish-Optimize-suffocation.patch} | 0 ...return-optimization-for-target-find.patch} | 0 ...erfish-Reduce-chunk-loading-lookups.patch} | 0 ...ve-container-checking-with-a-bitset.patch} | 0 ...per-6045-block-goal-shouldn-t-load-.patch} | 0 ...e-entity-fluid-lookups-if-no-fluids.patch} | 0 ...heck-for-spooky-season-once-an-hour.patch} | 0 ...patch => 0035-Pufferfish-Entity-TTL.patch} | 2 +- ...ish-Reduce-projectile-chunk-loading.patch} | 0 ...ferfish-Dynamic-Activation-of-Brain.patch} | 4 +- ...tle-goal-selector-during-inactive-ti.patch | 51 ++ ...Pufferfish-Reduce-entity-allocations.patch | 36 ++ ...le-Variable-entity-wake-up-duration.patch} | 0 ...hunks-to-activate-climbing-entities.patch} | 0 ...=> 0042-Gale-Optimize-sun-burn-tick.patch} | 4 +- ...k-frozen-ticks-before-landing-block.patch} | 0 ...r-lootable-refresh-for-non-player-i.patch} | 0 ...45-Gale-Use-platform-math-functions.patch} | 0 ...kip-entity-move-if-movement-is-zero.patch} | 0 ...ld-generation-chunk-and-block-acces.patch} | 0 ...0048-Gale-Optimize-noise-generation.patch} | 0 ...0049-Gale-Faster-chunk-serialization.patch | 434 ++++++++++++++++++ ...er-Remove-all-locks-on-region-files.patch} | 0 ...parkly-Paper-Optimize-canSee-checks.patch} | 0 ...2-Purpur-use-alternative-keep-alive.patch} | 0 ....patch => 0053-Leaves-Protocol-Core.patch} | 0 ...ch => 0054-Leaves-Bladeren-Protocol.patch} | 0 ...> 0055-Leaves-Fix-Bladeren-Protocol.patch} | 0 ...0056-Leaves-carpet-protocol-support.patch} | 0 ...-start-tick-and-finished-tick-event.patch} | 0 44 files changed, 575 insertions(+), 9 deletions(-) create mode 100644 patches/server/0014-Add-config-for-out-of-order-chat-checks.patch rename patches/server/{0014-Io_uring-channel-type-support.patch => 0015-Io_uring-channel-type-support.patch} (100%) rename patches/server/{0015-Try-fixing-folia-spector-teleportation.patch => 0016-Try-fixing-folia-spector-teleportation.patch} (95%) rename patches/server/{0016-Teleport-async-if-entity-was-moving-to-another-regio.patch => 0017-Teleport-async-if-entity-was-moving-to-another-regio.patch} (97%) rename patches/server/{0017-Prevent-teleportAsync-calling-during-moving-event-be.patch => 0018-Prevent-teleportAsync-calling-during-moving-event-be.patch} (100%) rename patches/server/{0018-Piston-fixes-from-molean-server.patch => 0019-Piston-fixes-from-molean-server.patch} (100%) rename patches/server/{0019-Kaiiju-linear-region-format-and-settings.patch => 0020-Kaiiju-linear-region-format-and-settings.patch} (100%) rename patches/server/{0020-Kaiiju-Don-t-pathfind-outside-region.patch => 0021-Kaiiju-Don-t-pathfind-outside-region.patch} (100%) rename patches/server/{0021-Kaiiju-Vanilla-end-portal-teleportation.patch => 0022-Kaiiju-Vanilla-end-portal-teleportation.patch} (100%) rename patches/server/{0022-Kaiiju-Async-path-processing.patch => 0023-Kaiiju-Async-path-processing.patch} (99%) rename patches/server/{0023-Petal-Reduce-sensor-work.patch => 0024-Petal-Reduce-sensor-work.patch} (96%) rename patches/server/{0024-Pufferfish-Optimize-entity-coordinate-key.patch => 0025-Pufferfish-Optimize-entity-coordinate-key.patch} (100%) rename patches/server/{0025-Pufferfish-Cache-climbing-check-for-activation.patch => 0026-Pufferfish-Cache-climbing-check-for-activation.patch} (100%) rename patches/server/{0026-Pufferfish-Improve-fluid-direction-caching.patch => 0027-Pufferfish-Improve-fluid-direction-caching.patch} (100%) rename patches/server/{0027-Pufferfish-Optimize-suffocation.patch => 0028-Pufferfish-Optimize-suffocation.patch} (100%) rename patches/server/{0028-Pufferfish-Early-return-optimization-for-target-find.patch => 0029-Pufferfish-Early-return-optimization-for-target-find.patch} (100%) rename patches/server/{0029-Pufferfish-Reduce-chunk-loading-lookups.patch => 0030-Pufferfish-Reduce-chunk-loading-lookups.patch} (100%) rename patches/server/{0030-Pufferfish-Improve-container-checking-with-a-bitset.patch => 0031-Pufferfish-Improve-container-checking-with-a-bitset.patch} (100%) rename patches/server/{0031-Pufferfish-Fix-Paper-6045-block-goal-shouldn-t-load-.patch => 0032-Pufferfish-Fix-Paper-6045-block-goal-shouldn-t-load-.patch} (100%) rename patches/server/{0032-Pufferfish-Reduce-entity-fluid-lookups-if-no-fluids.patch => 0033-Pufferfish-Reduce-entity-fluid-lookups-if-no-fluids.patch} (100%) rename patches/server/{0033-Pufferfish-Only-check-for-spooky-season-once-an-hour.patch => 0034-Pufferfish-Only-check-for-spooky-season-once-an-hour.patch} (100%) rename patches/server/{0034-Pufferfish-Entity-TTL.patch => 0035-Pufferfish-Entity-TTL.patch} (97%) rename patches/server/{0035-Pufferfish-Reduce-projectile-chunk-loading.patch => 0036-Pufferfish-Reduce-projectile-chunk-loading.patch} (100%) rename patches/server/{0036-Pufferfish-Dynamic-Activation-of-Brain.patch => 0037-Pufferfish-Dynamic-Activation-of-Brain.patch} (99%) create mode 100644 patches/server/0038-Pufferfish-Throttle-goal-selector-during-inactive-ti.patch create mode 100644 patches/server/0039-Pufferfish-Reduce-entity-allocations.patch rename patches/server/{0037-Gale-Variable-entity-wake-up-duration.patch => 0040-Gale-Variable-entity-wake-up-duration.patch} (100%) rename patches/server/{0038-Gale-Don-t-load-chunks-to-activate-climbing-entities.patch => 0041-Gale-Don-t-load-chunks-to-activate-climbing-entities.patch} (100%) rename patches/server/{0039-Gale-Optimize-sun-burn-tick.patch => 0042-Gale-Optimize-sun-burn-tick.patch} (96%) rename patches/server/{0040-Gale-Check-frozen-ticks-before-landing-block.patch => 0043-Gale-Check-frozen-ticks-before-landing-block.patch} (100%) rename patches/server/{0041-Gale-Don-t-trigger-lootable-refresh-for-non-player-i.patch => 0044-Gale-Don-t-trigger-lootable-refresh-for-non-player-i.patch} (100%) rename patches/server/{0042-Gale-Use-platform-math-functions.patch => 0045-Gale-Use-platform-math-functions.patch} (100%) rename patches/server/{0043-Gale-Skip-entity-move-if-movement-is-zero.patch => 0046-Gale-Skip-entity-move-if-movement-is-zero.patch} (100%) rename patches/server/{0044-Gale-Optimize-world-generation-chunk-and-block-acces.patch => 0047-Gale-Optimize-world-generation-chunk-and-block-acces.patch} (100%) rename patches/server/{0045-Gale-Optimize-noise-generation.patch => 0048-Gale-Optimize-noise-generation.patch} (100%) create mode 100644 patches/server/0049-Gale-Faster-chunk-serialization.patch rename patches/server/{0046-LinearPaper-Remove-all-locks-on-region-files.patch => 0050-LinearPaper-Remove-all-locks-on-region-files.patch} (100%) rename patches/server/{0047-Sparkly-Paper-Optimize-canSee-checks.patch => 0051-Sparkly-Paper-Optimize-canSee-checks.patch} (100%) rename patches/server/{0048-Purpur-use-alternative-keep-alive.patch => 0052-Purpur-use-alternative-keep-alive.patch} (100%) rename patches/server/{0049-Leaves-Protocol-Core.patch => 0053-Leaves-Protocol-Core.patch} (100%) rename patches/server/{0050-Leaves-Bladeren-Protocol.patch => 0054-Leaves-Bladeren-Protocol.patch} (100%) rename patches/server/{0051-Leaves-Fix-Bladeren-Protocol.patch => 0055-Leaves-Fix-Bladeren-Protocol.patch} (100%) rename patches/server/{0052-Leaves-carpet-protocol-support.patch => 0056-Leaves-carpet-protocol-support.patch} (100%) rename patches/server/{0053-Threaded-region-start-tick-and-finished-tick-event.patch => 0057-Threaded-region-start-tick-and-finished-tick-event.patch} (100%) diff --git a/patches/server/0014-Add-config-for-out-of-order-chat-checks.patch b/patches/server/0014-Add-config-for-out-of-order-chat-checks.patch new file mode 100644 index 0000000..9dfb4e7 --- /dev/null +++ b/patches/server/0014-Add-config-for-out-of-order-chat-checks.patch @@ -0,0 +1,45 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: MrHua269 +Date: Tue, 20 Feb 2024 13:10:07 +0000 +Subject: [PATCH] Add config for out-of-order chat checks + + +diff --git a/src/main/java/me/earthme/luminol/config/modules/misc/InorderChatConfig.java b/src/main/java/me/earthme/luminol/config/modules/misc/InorderChatConfig.java +new file mode 100644 +index 0000000000000000000000000000000000000000..83176a8a7e993b51a0663b0f76161884abbf4951 +--- /dev/null ++++ b/src/main/java/me/earthme/luminol/config/modules/misc/InorderChatConfig.java +@@ -0,0 +1,20 @@ ++package me.earthme.luminol.config.modules.misc; ++ ++import me.earthme.luminol.config.ConfigInfo; ++import me.earthme.luminol.config.EnumConfigCategory; ++import me.earthme.luminol.config.IConfigModule; ++ ++public class InorderChatConfig implements IConfigModule { ++ @ConfigInfo(baseName = "enabled") ++ public static boolean enabled = true; ++ ++ @Override ++ public EnumConfigCategory getCategory() { ++ return EnumConfigCategory.MISC; ++ } ++ ++ @Override ++ public String getBaseName() { ++ return "mojang_out_of_order_chat_check"; ++ } ++} +diff --git a/src/main/java/net/minecraft/network/chat/SignedMessageChain.java b/src/main/java/net/minecraft/network/chat/SignedMessageChain.java +index ba12919c3f9aec34a9e64993b143ae92be5eb172..ba983d557ae16b3fbb7d0ea6ff67666a809d2e99 100644 +--- a/src/main/java/net/minecraft/network/chat/SignedMessageChain.java ++++ b/src/main/java/net/minecraft/network/chat/SignedMessageChain.java +@@ -38,7 +38,7 @@ public class SignedMessageChain { + throw new SignedMessageChain.DecodeException(Component.translatable("chat.disabled.chain_broken"), false); // Paper - diff on change (if disconnects, need a new kick event cause) + } else if (playerPublicKey.data().hasExpired()) { + throw new SignedMessageChain.DecodeException(Component.translatable("chat.disabled.expiredProfileKey"), false, org.bukkit.event.player.PlayerKickEvent.Cause.EXPIRED_PROFILE_PUBLIC_KEY); // Paper - kick event causes +- } else if (body.timeStamp().isBefore(this.lastTimeStamp)) { ++ } else if (me.earthme.luminol.config.modules.misc.InorderChatConfig.enabled && body.timeStamp().isBefore(this.lastTimeStamp)) { // Luminol - Add config for out-of-order chat checks + throw new SignedMessageChain.DecodeException(Component.translatable("multiplayer.disconnect.out_of_order_chat"), true, org.bukkit.event.player.PlayerKickEvent.Cause.OUT_OF_ORDER_CHAT); // Paper - kick event causes + } else { + this.lastTimeStamp = body.timeStamp(); diff --git a/patches/server/0014-Io_uring-channel-type-support.patch b/patches/server/0015-Io_uring-channel-type-support.patch similarity index 100% rename from patches/server/0014-Io_uring-channel-type-support.patch rename to patches/server/0015-Io_uring-channel-type-support.patch diff --git a/patches/server/0015-Try-fixing-folia-spector-teleportation.patch b/patches/server/0016-Try-fixing-folia-spector-teleportation.patch similarity index 95% rename from patches/server/0015-Try-fixing-folia-spector-teleportation.patch rename to patches/server/0016-Try-fixing-folia-spector-teleportation.patch index 41f2595..808d78d 100644 --- a/patches/server/0015-Try-fixing-folia-spector-teleportation.patch +++ b/patches/server/0016-Try-fixing-folia-spector-teleportation.patch @@ -31,7 +31,7 @@ index 0000000000000000000000000000000000000000..8487799cdfb776eaca33b57f7c99ae3a + } +} diff --git a/src/main/java/net/minecraft/server/level/ServerPlayer.java b/src/main/java/net/minecraft/server/level/ServerPlayer.java -index 92a2e116f47d1434cc406709c3bcf85fedd2bb86..59f3ea98d0346d5b92053e13fa20048e3a946203 100644 +index 318cb1e98a3d73b7893f07c9f0db3adab801b67e..9cbf17436b4cf52aae374767aafe79ea4f60c3ce 100644 --- a/src/main/java/net/minecraft/server/level/ServerPlayer.java +++ b/src/main/java/net/minecraft/server/level/ServerPlayer.java @@ -17,6 +17,8 @@ import java.util.OptionalInt; diff --git a/patches/server/0016-Teleport-async-if-entity-was-moving-to-another-regio.patch b/patches/server/0017-Teleport-async-if-entity-was-moving-to-another-regio.patch similarity index 97% rename from patches/server/0016-Teleport-async-if-entity-was-moving-to-another-regio.patch rename to patches/server/0017-Teleport-async-if-entity-was-moving-to-another-regio.patch index 8233acc..8fcfa42 100644 --- a/patches/server/0016-Teleport-async-if-entity-was-moving-to-another-regio.patch +++ b/patches/server/0017-Teleport-async-if-entity-was-moving-to-another-regio.patch @@ -6,7 +6,7 @@ Subject: [PATCH] Teleport async if entity was moving to another region at once diff --git a/src/main/java/me/earthme/luminol/config/modules/fixes/FoliaEntityMovingFixConfig.java b/src/main/java/me/earthme/luminol/config/modules/fixes/FoliaEntityMovingFixConfig.java new file mode 100644 -index 0000000000000000000000000000000000000000..9ccd6a3a07abfce54dccf9b6e01d0050d03279b2 +index 0000000000000000000000000000000000000000..73d99a105a18231901e691922b0c283adae0cc79 --- /dev/null +++ b/src/main/java/me/earthme/luminol/config/modules/fixes/FoliaEntityMovingFixConfig.java @@ -0,0 +1,22 @@ diff --git a/patches/server/0017-Prevent-teleportAsync-calling-during-moving-event-be.patch b/patches/server/0018-Prevent-teleportAsync-calling-during-moving-event-be.patch similarity index 100% rename from patches/server/0017-Prevent-teleportAsync-calling-during-moving-event-be.patch rename to patches/server/0018-Prevent-teleportAsync-calling-during-moving-event-be.patch diff --git a/patches/server/0018-Piston-fixes-from-molean-server.patch b/patches/server/0019-Piston-fixes-from-molean-server.patch similarity index 100% rename from patches/server/0018-Piston-fixes-from-molean-server.patch rename to patches/server/0019-Piston-fixes-from-molean-server.patch diff --git a/patches/server/0019-Kaiiju-linear-region-format-and-settings.patch b/patches/server/0020-Kaiiju-linear-region-format-and-settings.patch similarity index 100% rename from patches/server/0019-Kaiiju-linear-region-format-and-settings.patch rename to patches/server/0020-Kaiiju-linear-region-format-and-settings.patch diff --git a/patches/server/0020-Kaiiju-Don-t-pathfind-outside-region.patch b/patches/server/0021-Kaiiju-Don-t-pathfind-outside-region.patch similarity index 100% rename from patches/server/0020-Kaiiju-Don-t-pathfind-outside-region.patch rename to patches/server/0021-Kaiiju-Don-t-pathfind-outside-region.patch diff --git a/patches/server/0021-Kaiiju-Vanilla-end-portal-teleportation.patch b/patches/server/0022-Kaiiju-Vanilla-end-portal-teleportation.patch similarity index 100% rename from patches/server/0021-Kaiiju-Vanilla-end-portal-teleportation.patch rename to patches/server/0022-Kaiiju-Vanilla-end-portal-teleportation.patch diff --git a/patches/server/0022-Kaiiju-Async-path-processing.patch b/patches/server/0023-Kaiiju-Async-path-processing.patch similarity index 99% rename from patches/server/0022-Kaiiju-Async-path-processing.patch rename to patches/server/0023-Kaiiju-Async-path-processing.patch index adac318..8116175 100644 --- a/patches/server/0022-Kaiiju-Async-path-processing.patch +++ b/patches/server/0023-Kaiiju-Async-path-processing.patch @@ -515,7 +515,7 @@ index 0000000000000000000000000000000000000000..a5472bb9d453bbeee92738c8d1a57ef4 + } +} diff --git a/src/main/java/net/minecraft/world/entity/Mob.java b/src/main/java/net/minecraft/world/entity/Mob.java -index a1a0ac986e2052d3669428a29987630bc226d80f..192584ac3b280cef2e76bc510c03ff6e0fd26ce2 100644 +index a3992e21e7d4112b9903e8d16a5e898d448eaea8..dc94c66404e9f2015119e249a560571355c92c96 100644 --- a/src/main/java/net/minecraft/world/entity/Mob.java +++ b/src/main/java/net/minecraft/world/entity/Mob.java @@ -296,6 +296,7 @@ public abstract class Mob extends LivingEntity implements Targeting { diff --git a/patches/server/0023-Petal-Reduce-sensor-work.patch b/patches/server/0024-Petal-Reduce-sensor-work.patch similarity index 96% rename from patches/server/0023-Petal-Reduce-sensor-work.patch rename to patches/server/0024-Petal-Reduce-sensor-work.patch index ade4dde..9c5ab91 100644 --- a/patches/server/0023-Petal-Reduce-sensor-work.patch +++ b/patches/server/0024-Petal-Reduce-sensor-work.patch @@ -33,7 +33,7 @@ index 0000000000000000000000000000000000000000..dd45cf1fde5ee4cf8347064f106c64b8 + } +} diff --git a/src/main/java/net/minecraft/world/entity/Mob.java b/src/main/java/net/minecraft/world/entity/Mob.java -index 192584ac3b280cef2e76bc510c03ff6e0fd26ce2..8e2da025ff13abd7f021099b66dc04d1ead64390 100644 +index dc94c66404e9f2015119e249a560571355c92c96..9636f69fab9f34f3b3f4590f151248cd5b2da089 100644 --- a/src/main/java/net/minecraft/world/entity/Mob.java +++ b/src/main/java/net/minecraft/world/entity/Mob.java @@ -926,10 +926,11 @@ public abstract class Mob extends LivingEntity implements Targeting { diff --git a/patches/server/0024-Pufferfish-Optimize-entity-coordinate-key.patch b/patches/server/0025-Pufferfish-Optimize-entity-coordinate-key.patch similarity index 100% rename from patches/server/0024-Pufferfish-Optimize-entity-coordinate-key.patch rename to patches/server/0025-Pufferfish-Optimize-entity-coordinate-key.patch diff --git a/patches/server/0025-Pufferfish-Cache-climbing-check-for-activation.patch b/patches/server/0026-Pufferfish-Cache-climbing-check-for-activation.patch similarity index 100% rename from patches/server/0025-Pufferfish-Cache-climbing-check-for-activation.patch rename to patches/server/0026-Pufferfish-Cache-climbing-check-for-activation.patch diff --git a/patches/server/0026-Pufferfish-Improve-fluid-direction-caching.patch b/patches/server/0027-Pufferfish-Improve-fluid-direction-caching.patch similarity index 100% rename from patches/server/0026-Pufferfish-Improve-fluid-direction-caching.patch rename to patches/server/0027-Pufferfish-Improve-fluid-direction-caching.patch diff --git a/patches/server/0027-Pufferfish-Optimize-suffocation.patch b/patches/server/0028-Pufferfish-Optimize-suffocation.patch similarity index 100% rename from patches/server/0027-Pufferfish-Optimize-suffocation.patch rename to patches/server/0028-Pufferfish-Optimize-suffocation.patch diff --git a/patches/server/0028-Pufferfish-Early-return-optimization-for-target-find.patch b/patches/server/0029-Pufferfish-Early-return-optimization-for-target-find.patch similarity index 100% rename from patches/server/0028-Pufferfish-Early-return-optimization-for-target-find.patch rename to patches/server/0029-Pufferfish-Early-return-optimization-for-target-find.patch diff --git a/patches/server/0029-Pufferfish-Reduce-chunk-loading-lookups.patch b/patches/server/0030-Pufferfish-Reduce-chunk-loading-lookups.patch similarity index 100% rename from patches/server/0029-Pufferfish-Reduce-chunk-loading-lookups.patch rename to patches/server/0030-Pufferfish-Reduce-chunk-loading-lookups.patch diff --git a/patches/server/0030-Pufferfish-Improve-container-checking-with-a-bitset.patch b/patches/server/0031-Pufferfish-Improve-container-checking-with-a-bitset.patch similarity index 100% rename from patches/server/0030-Pufferfish-Improve-container-checking-with-a-bitset.patch rename to patches/server/0031-Pufferfish-Improve-container-checking-with-a-bitset.patch diff --git a/patches/server/0031-Pufferfish-Fix-Paper-6045-block-goal-shouldn-t-load-.patch b/patches/server/0032-Pufferfish-Fix-Paper-6045-block-goal-shouldn-t-load-.patch similarity index 100% rename from patches/server/0031-Pufferfish-Fix-Paper-6045-block-goal-shouldn-t-load-.patch rename to patches/server/0032-Pufferfish-Fix-Paper-6045-block-goal-shouldn-t-load-.patch diff --git a/patches/server/0032-Pufferfish-Reduce-entity-fluid-lookups-if-no-fluids.patch b/patches/server/0033-Pufferfish-Reduce-entity-fluid-lookups-if-no-fluids.patch similarity index 100% rename from patches/server/0032-Pufferfish-Reduce-entity-fluid-lookups-if-no-fluids.patch rename to patches/server/0033-Pufferfish-Reduce-entity-fluid-lookups-if-no-fluids.patch diff --git a/patches/server/0033-Pufferfish-Only-check-for-spooky-season-once-an-hour.patch b/patches/server/0034-Pufferfish-Only-check-for-spooky-season-once-an-hour.patch similarity index 100% rename from patches/server/0033-Pufferfish-Only-check-for-spooky-season-once-an-hour.patch rename to patches/server/0034-Pufferfish-Only-check-for-spooky-season-once-an-hour.patch diff --git a/patches/server/0034-Pufferfish-Entity-TTL.patch b/patches/server/0035-Pufferfish-Entity-TTL.patch similarity index 97% rename from patches/server/0034-Pufferfish-Entity-TTL.patch rename to patches/server/0035-Pufferfish-Entity-TTL.patch index 3a40d0a..0757101 100644 --- a/patches/server/0034-Pufferfish-Entity-TTL.patch +++ b/patches/server/0035-Pufferfish-Entity-TTL.patch @@ -49,7 +49,7 @@ index 0000000000000000000000000000000000000000..15697d69659b6e1e776acf5094684b5f + } +} diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java -index e6b90e53b2b539543084ddbfda4ab819656a3179..03a6633edd34a34f7c5cfb1a58f4d132e6bd1c12 100644 +index 0b201fd79233ed0a5c2d298b283a15497dffd8e5..f120f977e3535847a1e3a009a25eb0137fce6ab0 100644 --- a/src/main/java/net/minecraft/world/entity/Entity.java +++ b/src/main/java/net/minecraft/world/entity/Entity.java @@ -798,6 +798,12 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource, S diff --git a/patches/server/0035-Pufferfish-Reduce-projectile-chunk-loading.patch b/patches/server/0036-Pufferfish-Reduce-projectile-chunk-loading.patch similarity index 100% rename from patches/server/0035-Pufferfish-Reduce-projectile-chunk-loading.patch rename to patches/server/0036-Pufferfish-Reduce-projectile-chunk-loading.patch diff --git a/patches/server/0036-Pufferfish-Dynamic-Activation-of-Brain.patch b/patches/server/0037-Pufferfish-Dynamic-Activation-of-Brain.patch similarity index 99% rename from patches/server/0036-Pufferfish-Dynamic-Activation-of-Brain.patch rename to patches/server/0037-Pufferfish-Dynamic-Activation-of-Brain.patch index 2310e79..6fc3248 100644 --- a/patches/server/0036-Pufferfish-Dynamic-Activation-of-Brain.patch +++ b/patches/server/0037-Pufferfish-Dynamic-Activation-of-Brain.patch @@ -83,7 +83,7 @@ index c0f8f72d1677d4ef6a15f487262953c5df3b03c0..33154e89457e3d7331c6d17785544d08 if (false && this.shouldDiscardEntity(entity)) { // CraftBukkit - We prevent spawning in general, so this butchering is not needed entity.discard(); diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java -index 03a6633edd34a34f7c5cfb1a58f4d132e6bd1c12..f61ac02037ce13bb80b0db0814145fd9ff39bc37 100644 +index f120f977e3535847a1e3a009a25eb0137fce6ab0..d62734c0365af706c136274faf3e135f6ea099ee 100644 --- a/src/main/java/net/minecraft/world/entity/Entity.java +++ b/src/main/java/net/minecraft/world/entity/Entity.java @@ -482,6 +482,11 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource, S @@ -111,7 +111,7 @@ index 8deae3e95a26f4b42b2c2134e22f9649bd7a5391..c09357c1ef84a29d972119cb496b0ae9 private String descriptionId; @Nullable diff --git a/src/main/java/net/minecraft/world/entity/Mob.java b/src/main/java/net/minecraft/world/entity/Mob.java -index 8e2da025ff13abd7f021099b66dc04d1ead64390..2f592612ddc39723b76ddc6de3b20681ece5829d 100644 +index 9636f69fab9f34f3b3f4590f151248cd5b2da089..50a144b0122c970856ef3faa3f899ee72e2a6300 100644 --- a/src/main/java/net/minecraft/world/entity/Mob.java +++ b/src/main/java/net/minecraft/world/entity/Mob.java @@ -233,10 +233,10 @@ public abstract class Mob extends LivingEntity implements Targeting { diff --git a/patches/server/0038-Pufferfish-Throttle-goal-selector-during-inactive-ti.patch b/patches/server/0038-Pufferfish-Throttle-goal-selector-during-inactive-ti.patch new file mode 100644 index 0000000..22713b3 --- /dev/null +++ b/patches/server/0038-Pufferfish-Throttle-goal-selector-during-inactive-ti.patch @@ -0,0 +1,51 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: MrHua269 +Date: Tue, 20 Feb 2024 13:03:42 +0000 +Subject: [PATCH] Pufferfish Throttle goal selector during inactive ticking + + +diff --git a/src/main/java/me/earthme/luminol/config/modules/optimizations/EntityGoalSelectorInactiveTickConfig.java b/src/main/java/me/earthme/luminol/config/modules/optimizations/EntityGoalSelectorInactiveTickConfig.java +new file mode 100644 +index 0000000000000000000000000000000000000000..acc032f727e605e79b688efb4873ff474fe7e132 +--- /dev/null ++++ b/src/main/java/me/earthme/luminol/config/modules/optimizations/EntityGoalSelectorInactiveTickConfig.java +@@ -0,0 +1,20 @@ ++package me.earthme.luminol.config.modules.optimizations; ++ ++import me.earthme.luminol.config.ConfigInfo; ++import me.earthme.luminol.config.EnumConfigCategory; ++import me.earthme.luminol.config.IConfigModule; ++ ++public class EntityGoalSelectorInactiveTickConfig implements IConfigModule { ++ @ConfigInfo(baseName = "enabled") ++ public static boolean enabled = false; ++ ++ @Override ++ public EnumConfigCategory getCategory() { ++ return EnumConfigCategory.OPTIMIZATIONS; ++ } ++ ++ @Override ++ public String getBaseName() { ++ return "skip_goal_selector_tick_in_inactive_tick"; ++ } ++} +diff --git a/src/main/java/net/minecraft/world/entity/Mob.java b/src/main/java/net/minecraft/world/entity/Mob.java +index 50a144b0122c970856ef3faa3f899ee72e2a6300..7378c9cb5eeddc7cefc409638179dfb8602ed0d0 100644 +--- a/src/main/java/net/minecraft/world/entity/Mob.java ++++ b/src/main/java/net/minecraft/world/entity/Mob.java +@@ -229,11 +229,13 @@ public abstract class Mob extends LivingEntity implements Targeting { + return this.lookControl; + } + ++ int _pufferfish_inactiveTickDisableCounter = 0; // Pufferfish - throttle inactive goal selector ticking + // Paper start + @Override + public void inactiveTick() { + super.inactiveTick(); +- if (this.goalSelector.inactiveTick(this.activatedPriority, true)) { // Pufferfish - pass activated priroity ++ boolean isThrottled = me.earthme.luminol.config.modules.optimizations.EntityGoalSelectorInactiveTickConfig.enabled && _pufferfish_inactiveTickDisableCounter++ % 20 != 0; // Pufferfish - throttle inactive goal selector ticking ++ if (this.goalSelector.inactiveTick(this.activatedPriority, true) && !isThrottled) { // Pufferfish - pass activated priroity // Pufferfish - throttle inactive goal selector ticking + this.goalSelector.tick(); + } + if (this.targetSelector.inactiveTick(this.activatedPriority, true)) { // Pufferfish - pass activated priority diff --git a/patches/server/0039-Pufferfish-Reduce-entity-allocations.patch b/patches/server/0039-Pufferfish-Reduce-entity-allocations.patch new file mode 100644 index 0000000..1794499 --- /dev/null +++ b/patches/server/0039-Pufferfish-Reduce-entity-allocations.patch @@ -0,0 +1,36 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: MrHua269 +Date: Tue, 20 Feb 2024 13:11:11 +0000 +Subject: [PATCH] Pufferfish Reduce entity allocations + + +diff --git a/src/main/java/net/minecraft/world/entity/ai/attributes/AttributeMap.java b/src/main/java/net/minecraft/world/entity/ai/attributes/AttributeMap.java +index 897d7632ecfea40890433474870dd7a5e534d8ab..683c9693754d1a87b7e8fccc757a0d0963351f60 100644 +--- a/src/main/java/net/minecraft/world/entity/ai/attributes/AttributeMap.java ++++ b/src/main/java/net/minecraft/world/entity/ai/attributes/AttributeMap.java +@@ -23,9 +23,11 @@ public class AttributeMap { + private final Map attributes = Maps.newHashMap(); + private final Set dirtyAttributes = Sets.newHashSet(); + private final AttributeSupplier supplier; ++ private final java.util.function.Function createInstance; // Pufferfish + + public AttributeMap(AttributeSupplier defaultAttributes) { + this.supplier = defaultAttributes; ++ this.createInstance = attribute -> this.supplier.createInstance(this::onAttributeModified, attribute); // Pufferfish + } + + private void onAttributeModified(AttributeInstance instance) { +@@ -45,11 +47,10 @@ public class AttributeMap { + }).collect(Collectors.toList()); + } + ++ + @Nullable + public AttributeInstance getInstance(Attribute attribute) { +- return this.attributes.computeIfAbsent(attribute, (attributex) -> { +- return this.supplier.createInstance(this::onAttributeModified, attributex); +- }); ++ return this.attributes.computeIfAbsent(attribute, this.createInstance); // Pufferfish - cache lambda, as for some reason java allocates it anyways + } + + @Nullable diff --git a/patches/server/0037-Gale-Variable-entity-wake-up-duration.patch b/patches/server/0040-Gale-Variable-entity-wake-up-duration.patch similarity index 100% rename from patches/server/0037-Gale-Variable-entity-wake-up-duration.patch rename to patches/server/0040-Gale-Variable-entity-wake-up-duration.patch diff --git a/patches/server/0038-Gale-Don-t-load-chunks-to-activate-climbing-entities.patch b/patches/server/0041-Gale-Don-t-load-chunks-to-activate-climbing-entities.patch similarity index 100% rename from patches/server/0038-Gale-Don-t-load-chunks-to-activate-climbing-entities.patch rename to patches/server/0041-Gale-Don-t-load-chunks-to-activate-climbing-entities.patch diff --git a/patches/server/0039-Gale-Optimize-sun-burn-tick.patch b/patches/server/0042-Gale-Optimize-sun-burn-tick.patch similarity index 96% rename from patches/server/0039-Gale-Optimize-sun-burn-tick.patch rename to patches/server/0042-Gale-Optimize-sun-burn-tick.patch index a68f9b9..49fdb99 100644 --- a/patches/server/0039-Gale-Optimize-sun-burn-tick.patch +++ b/patches/server/0042-Gale-Optimize-sun-burn-tick.patch @@ -37,10 +37,10 @@ index bc655e3db34630a419be883b0dcc1ba4d5bbeb90..bf530eb5e039f37b9bea37d2a61ee31f this.absMoveTo(x, y, z); this.setYRot(yaw % 360.0F); diff --git a/src/main/java/net/minecraft/world/entity/Mob.java b/src/main/java/net/minecraft/world/entity/Mob.java -index 50a144b0122c970856ef3faa3f899ee72e2a6300..128cba0cf37fc9b06111f80d63a2cf857e23edb1 100644 +index 7378c9cb5eeddc7cefc409638179dfb8602ed0d0..d83a6adc34c64652f1070651f5c96579a5c45e67 100644 --- a/src/main/java/net/minecraft/world/entity/Mob.java +++ b/src/main/java/net/minecraft/world/entity/Mob.java -@@ -1747,13 +1747,29 @@ public abstract class Mob extends LivingEntity implements Targeting { +@@ -1749,13 +1749,29 @@ public abstract class Mob extends LivingEntity implements Targeting { } diff --git a/patches/server/0040-Gale-Check-frozen-ticks-before-landing-block.patch b/patches/server/0043-Gale-Check-frozen-ticks-before-landing-block.patch similarity index 100% rename from patches/server/0040-Gale-Check-frozen-ticks-before-landing-block.patch rename to patches/server/0043-Gale-Check-frozen-ticks-before-landing-block.patch diff --git a/patches/server/0041-Gale-Don-t-trigger-lootable-refresh-for-non-player-i.patch b/patches/server/0044-Gale-Don-t-trigger-lootable-refresh-for-non-player-i.patch similarity index 100% rename from patches/server/0041-Gale-Don-t-trigger-lootable-refresh-for-non-player-i.patch rename to patches/server/0044-Gale-Don-t-trigger-lootable-refresh-for-non-player-i.patch diff --git a/patches/server/0042-Gale-Use-platform-math-functions.patch b/patches/server/0045-Gale-Use-platform-math-functions.patch similarity index 100% rename from patches/server/0042-Gale-Use-platform-math-functions.patch rename to patches/server/0045-Gale-Use-platform-math-functions.patch diff --git a/patches/server/0043-Gale-Skip-entity-move-if-movement-is-zero.patch b/patches/server/0046-Gale-Skip-entity-move-if-movement-is-zero.patch similarity index 100% rename from patches/server/0043-Gale-Skip-entity-move-if-movement-is-zero.patch rename to patches/server/0046-Gale-Skip-entity-move-if-movement-is-zero.patch diff --git a/patches/server/0044-Gale-Optimize-world-generation-chunk-and-block-acces.patch b/patches/server/0047-Gale-Optimize-world-generation-chunk-and-block-acces.patch similarity index 100% rename from patches/server/0044-Gale-Optimize-world-generation-chunk-and-block-acces.patch rename to patches/server/0047-Gale-Optimize-world-generation-chunk-and-block-acces.patch diff --git a/patches/server/0045-Gale-Optimize-noise-generation.patch b/patches/server/0048-Gale-Optimize-noise-generation.patch similarity index 100% rename from patches/server/0045-Gale-Optimize-noise-generation.patch rename to patches/server/0048-Gale-Optimize-noise-generation.patch diff --git a/patches/server/0049-Gale-Faster-chunk-serialization.patch b/patches/server/0049-Gale-Faster-chunk-serialization.patch new file mode 100644 index 0000000..1b7c188 --- /dev/null +++ b/patches/server/0049-Gale-Faster-chunk-serialization.patch @@ -0,0 +1,434 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: MrHua269 +Date: Tue, 20 Feb 2024 13:21:53 +0000 +Subject: [PATCH] Gale Faster chunk serialization + + +diff --git a/src/main/java/me/jellysquid/mods/lithium/common/world/chunk/LithiumHashPalette.java b/src/main/java/me/jellysquid/mods/lithium/common/world/chunk/LithiumHashPalette.java +new file mode 100644 +index 0000000000000000000000000000000000000000..349618b7f544bf9a30e0796d4d9a26407a2b8329 +--- /dev/null ++++ b/src/main/java/me/jellysquid/mods/lithium/common/world/chunk/LithiumHashPalette.java +@@ -0,0 +1,192 @@ ++// Gale - Lithium - faster chunk serialization ++ ++package me.jellysquid.mods.lithium.common.world.chunk; ++ ++import com.google.common.collect.ImmutableList; ++import it.unimi.dsi.fastutil.HashCommon; ++import it.unimi.dsi.fastutil.objects.Reference2IntMap; ++import it.unimi.dsi.fastutil.objects.Reference2IntOpenHashMap; ++import java.util.Arrays; ++import java.util.List; ++import java.util.function.Predicate; ++import net.minecraft.core.IdMap; ++import net.minecraft.network.FriendlyByteBuf; ++import net.minecraft.network.VarInt; ++import net.minecraft.world.level.chunk.Palette; ++import net.minecraft.world.level.chunk.PaletteResize; ++ ++import static it.unimi.dsi.fastutil.Hash.FAST_LOAD_FACTOR; ++ ++/** ++ * Generally provides better performance over the vanilla {@link net.minecraft.world.level.chunk.HashMapPalette} when calling ++ * {@link LithiumHashPalette#idFor(Object)} through using a faster backing map and reducing pointer chasing. ++ */ ++public class LithiumHashPalette implements Palette { ++ private static final int ABSENT_VALUE = -1; ++ ++ private final IdMap idList; ++ private final PaletteResize resizeHandler; ++ private final int indexBits; ++ ++ private final Reference2IntMap table; ++ private T[] entries; ++ private int size = 0; ++ ++ public LithiumHashPalette(IdMap idList, PaletteResize resizeHandler, int indexBits, T[] entries, Reference2IntMap table, int size) { ++ this.idList = idList; ++ this.resizeHandler = resizeHandler; ++ this.indexBits = indexBits; ++ this.entries = entries; ++ this.table = table; ++ this.size = size; ++ } ++ ++ public LithiumHashPalette(IdMap idList, int bits, PaletteResize resizeHandler, List list) { ++ this(idList, bits, resizeHandler); ++ ++ for (T t : list) { ++ this.addEntry(t); ++ } ++ } ++ ++ @SuppressWarnings("unchecked") ++ public LithiumHashPalette(IdMap idList, int bits, PaletteResize resizeHandler) { ++ this.idList = idList; ++ this.indexBits = bits; ++ this.resizeHandler = resizeHandler; ++ ++ int capacity = 1 << bits; ++ ++ this.entries = (T[]) new Object[capacity]; ++ this.table = new Reference2IntOpenHashMap<>(capacity, FAST_LOAD_FACTOR); ++ this.table.defaultReturnValue(ABSENT_VALUE); ++ } ++ ++ @Override ++ public int idFor(T obj) { ++ int id = this.table.getInt(obj); ++ ++ if (id == ABSENT_VALUE) { ++ id = this.computeEntry(obj); ++ } ++ ++ return id; ++ } ++ ++ @Override ++ public boolean maybeHas(Predicate predicate) { ++ for (int i = 0; i < this.size; ++i) { ++ if (predicate.test(this.entries[i])) { ++ return true; ++ } ++ } ++ ++ return false; ++ } ++ ++ private int computeEntry(T obj) { ++ int id = this.addEntry(obj); ++ ++ if (id >= 1 << this.indexBits) { ++ if (this.resizeHandler == null) { ++ throw new IllegalStateException("Cannot grow"); ++ } else { ++ id = this.resizeHandler.onResize(this.indexBits + 1, obj); ++ } ++ } ++ ++ return id; ++ } ++ ++ private int addEntry(T obj) { ++ int nextId = this.size; ++ ++ if (nextId >= this.entries.length) { ++ this.resize(this.size); ++ } ++ ++ this.table.put(obj, nextId); ++ this.entries[nextId] = obj; ++ ++ this.size++; ++ ++ return nextId; ++ } ++ ++ private void resize(int neededCapacity) { ++ this.entries = Arrays.copyOf(this.entries, HashCommon.nextPowerOfTwo(neededCapacity + 1)); ++ } ++ ++ @Override ++ public T valueFor(int id) { ++ T[] entries = this.entries; ++ ++ if (id >= 0 && id < entries.length) { ++ return entries[id]; ++ } ++ ++ return null; ++ } ++ ++ @Override ++ public void read(FriendlyByteBuf buf) { ++ this.clear(); ++ ++ int entryCount = buf.readVarInt(); ++ ++ for (int i = 0; i < entryCount; ++i) { ++ this.addEntry(this.idList.byId(buf.readVarInt())); ++ } ++ } ++ ++ @Override ++ public void write(FriendlyByteBuf buf) { ++ int size = this.size; ++ buf.writeVarInt(size); ++ ++ for (int i = 0; i < size; ++i) { ++ buf.writeVarInt(this.idList.getId(this.valueFor(i))); ++ } ++ } ++ ++ @Override ++ public int getSerializedSize() { ++ int size = VarInt.getByteSize(this.size); ++ ++ for (int i = 0; i < this.size; ++i) { ++ size += VarInt.getByteSize(this.idList.getId(this.valueFor(i))); ++ } ++ ++ return size; ++ } ++ ++ @Override ++ public int getSize() { ++ return this.size; ++ } ++ ++ @Override ++ public Palette copy() { ++ return new LithiumHashPalette<>(this.idList, this.resizeHandler, this.indexBits, this.entries.clone(), new Reference2IntOpenHashMap<>(this.table), this.size); ++ } ++ ++ private void clear() { ++ Arrays.fill(this.entries, null); ++ this.table.clear(); ++ this.size = 0; ++ } ++ ++ public List getElements() { ++ ImmutableList.Builder builder = new ImmutableList.Builder<>(); ++ for (T entry : this.entries) { ++ if (entry != null) { ++ builder.add(entry); ++ } ++ } ++ return builder.build(); ++ } ++ ++ public static Palette create(int bits, IdMap idList, PaletteResize listener, List list) { ++ return new LithiumHashPalette<>(idList, bits, listener, list); ++ } ++} +diff --git a/src/main/java/net/minecraft/util/BitStorage.java b/src/main/java/net/minecraft/util/BitStorage.java +index 8bafd5fd7499ba4a04bf706cfd1e156073716e21..f62aab492f231e688b448389b1910e6fc2f5d8e6 100644 +--- a/src/main/java/net/minecraft/util/BitStorage.java ++++ b/src/main/java/net/minecraft/util/BitStorage.java +@@ -31,4 +31,6 @@ public interface BitStorage { + + } + // Paper end ++ ++ void compact(net.minecraft.world.level.chunk.Palette srcPalette, net.minecraft.world.level.chunk.Palette dstPalette, short[] out); // Gale - Lithium - faster chunk serialization + } +diff --git a/src/main/java/net/minecraft/util/SimpleBitStorage.java b/src/main/java/net/minecraft/util/SimpleBitStorage.java +index 453c1d7e01970fd817d27f59c3b00ffc70e8ca0c..844539798213360831541f49d97f8401d80d030e 100644 +--- a/src/main/java/net/minecraft/util/SimpleBitStorage.java ++++ b/src/main/java/net/minecraft/util/SimpleBitStorage.java +@@ -201,4 +201,45 @@ public class SimpleBitStorage implements BitStorage { + super(message); + } + } ++ ++ // Gale start - Lithium - faster chunk serialization ++ @Override ++ public void compact(net.minecraft.world.level.chunk.Palette srcPalette, net.minecraft.world.level.chunk.Palette dstPalette, short[] out) { ++ if (this.size >= Short.MAX_VALUE) { ++ throw new IllegalStateException("Array too large"); ++ } ++ ++ if (this.size != out.length) { ++ throw new IllegalStateException("Array size mismatch"); ++ } ++ ++ short[] mappings = new short[(int) (this.mask + 1)]; ++ ++ int idx = 0; ++ ++ for (long word : this.data) { ++ long bits = word; ++ ++ for (int elementIdx = 0; elementIdx < this.valuesPerLong; ++elementIdx) { ++ int value = (int) (bits & this.mask); ++ int remappedId = mappings[value]; ++ ++ if (remappedId == 0) { ++ remappedId = dstPalette.idFor(srcPalette.valueFor(value)) + 1; ++ mappings[value] = (short) remappedId; ++ } ++ ++ out[idx] = (short) (remappedId - 1); ++ bits >>= this.bits; ++ ++ ++idx; ++ ++ if (idx >= this.size) { ++ return; ++ } ++ } ++ } ++ } ++ // Gale end - Lithium - faster chunk serialization ++ + } +diff --git a/src/main/java/net/minecraft/util/ZeroBitStorage.java b/src/main/java/net/minecraft/util/ZeroBitStorage.java +index f8de91393564b3691c17339ac9196cc0fc1cf748..ecfe47110697378d7f7369640cd06b77f6fa0a87 100644 +--- a/src/main/java/net/minecraft/util/ZeroBitStorage.java ++++ b/src/main/java/net/minecraft/util/ZeroBitStorage.java +@@ -72,4 +72,6 @@ public class ZeroBitStorage implements BitStorage { + public BitStorage copy() { + return this; + } ++ ++ @Override public void compact(net.minecraft.world.level.chunk.Palette srcPalette, net.minecraft.world.level.chunk.Palette dstPalette, short[] out) {} // Gale - Lithium - faster chunk serialization + } +diff --git a/src/main/java/net/minecraft/world/level/chunk/PaletteResize.java b/src/main/java/net/minecraft/world/level/chunk/PaletteResize.java +index acae3eb30e0689048937f479dc3070f0688abdad..4b79f0474a9013dd4fdb68c6363ca1942ba8b007 100644 +--- a/src/main/java/net/minecraft/world/level/chunk/PaletteResize.java ++++ b/src/main/java/net/minecraft/world/level/chunk/PaletteResize.java +@@ -1,5 +1,5 @@ + package net.minecraft.world.level.chunk; + +-interface PaletteResize { ++public interface PaletteResize { // Gale - Lithium - faster chunk serialization - package -> public + int onResize(int newBits, T object); + } +diff --git a/src/main/java/net/minecraft/world/level/chunk/PalettedContainer.java b/src/main/java/net/minecraft/world/level/chunk/PalettedContainer.java +index 983799520ce052d98c9231f4f7925492d4f7d5c9..6e7b3ea1819780aef6db3ff0b43998de8f1066bf 100644 +--- a/src/main/java/net/minecraft/world/level/chunk/PalettedContainer.java ++++ b/src/main/java/net/minecraft/world/level/chunk/PalettedContainer.java +@@ -25,6 +25,22 @@ import net.minecraft.util.ThreadingDetector; + import net.minecraft.util.ZeroBitStorage; + + public class PalettedContainer implements PaletteResize, PalettedContainerRO { ++ ++ // Gale start - Lithium - faster chunk serialization ++ private static final ThreadLocal CACHED_ARRAY_4096 = ThreadLocal.withInitial(() -> new short[4096]); ++ private static final ThreadLocal CACHED_ARRAY_64 = ThreadLocal.withInitial(() -> new short[64]); ++ private Optional asOptional(long[] data) { ++ return Optional.of(Arrays.stream(data)); ++ } ++ private short[] getOrCreate(int size) { ++ return switch (size) { ++ case 64 -> CACHED_ARRAY_64.get(); ++ case 4096 -> CACHED_ARRAY_4096.get(); ++ default -> new short[size]; ++ }; ++ } ++ // Gale end - Lithium - faster chunk serialization ++ + private static final int MIN_PALETTE_BITS = 0; + private final PaletteResize dummyPaletteResize = (newSize, added) -> { + return 0; +@@ -302,30 +318,54 @@ public class PalettedContainer implements PaletteResize, PalettedContainer + public synchronized PalettedContainerRO.PackedData pack(IdMap idList, PalettedContainer.Strategy paletteProvider) { // Paper - synchronize + this.acquire(); + +- PalettedContainerRO.PackedData var12; ++ // Gale start - Lithium - faster chunk serialization ++ Optional data = Optional.empty(); ++ List elements = null; + try { +- HashMapPalette hashMapPalette = new HashMapPalette<>(idList, this.data.storage.getBits(), this.dummyPaletteResize); +- int i = paletteProvider.size(); +- int[] is = new int[i]; +- this.data.storage.unpack(is); +- swapPalette(is, (id) -> { +- return hashMapPalette.idFor(this.data.palette.valueFor(id)); +- }); +- int j = paletteProvider.calculateBitsForSerialization(idList, hashMapPalette.getSize()); +- Optional optional; +- if (j != 0) { +- SimpleBitStorage simpleBitStorage = new SimpleBitStorage(j, i, is); +- optional = Optional.of(Arrays.stream(simpleBitStorage.getRaw())); +- } else { +- optional = Optional.empty(); ++ // The palette that will be serialized ++ me.jellysquid.mods.lithium.common.world.chunk.LithiumHashPalette hashPalette = null; ++ ++ final Palette palette = this.data.palette(); ++ final BitStorage storage = this.data.storage(); ++ if (storage instanceof ZeroBitStorage || palette.getSize() == 1) { ++ // If the palette only contains one entry, don't attempt to repack it. ++ elements = List.of(palette.valueFor(0)); ++ } else if (palette instanceof me.jellysquid.mods.lithium.common.world.chunk.LithiumHashPalette lithiumHashPalette) { ++ hashPalette = lithiumHashPalette; + } + +- var12 = new PalettedContainerRO.PackedData<>(hashMapPalette.getEntries(), optional); ++ if (elements == null) { ++ me.jellysquid.mods.lithium.common.world.chunk.LithiumHashPalette compactedPalette = new me.jellysquid.mods.lithium.common.world.chunk.LithiumHashPalette<>(idList, storage.getBits(), this.dummyPaletteResize); ++ short[] array = this.getOrCreate(paletteProvider.size()); ++ ++ storage.compact(this.data.palette(), compactedPalette, array); ++ ++ // If the palette didn't change during compaction, do a simple copy of the data array ++ if (hashPalette != null && hashPalette.getSize() == compactedPalette.getSize() && storage.getBits() == paletteProvider.calculateBitsForSerialization(idList, hashPalette.getSize())) { // paletteSize can de-sync from palette - see https://github.com/CaffeineMC/lithium-fabric/issues/279 ++ data = this.asOptional(storage.getRaw().clone()); ++ elements = hashPalette.getElements(); ++ } else { ++ int bits = paletteProvider.calculateBitsForSerialization(idList, compactedPalette.getSize()); ++ if (bits != 0) { ++ // Re-pack the integer array as the palette has changed size ++ SimpleBitStorage copy = new SimpleBitStorage(bits, array.length); ++ for (int i = 0; i < array.length; ++i) { ++ copy.set(i, array[i]); ++ } ++ ++ // We don't need to clone the data array as we are the sole owner of it ++ data = this.asOptional(copy.getRaw()); ++ } ++ ++ elements = compactedPalette.getElements(); ++ } ++ } + } finally { + this.release(); + } + +- return var12; ++ return new PalettedContainerRO.PackedData<>(elements, data); ++ // Gale end - Lithium - faster chunk serialization + } + + private static void swapPalette(int[] is, IntUnaryOperator applier) { +@@ -365,17 +405,37 @@ public class PalettedContainer implements PaletteResize, PalettedContainer + + @Override + public void count(PalettedContainer.CountConsumer counter) { +- if (this.data.palette.getSize() == 1) { +- counter.accept(this.data.palette.valueFor(0), this.data.storage.getSize()); +- } else { +- Int2IntOpenHashMap int2IntOpenHashMap = new Int2IntOpenHashMap(); +- this.data.storage.getAll((key) -> { +- int2IntOpenHashMap.addTo(key, 1); +- }); +- int2IntOpenHashMap.int2IntEntrySet().forEach((entry) -> { +- counter.accept(this.data.palette.valueFor(entry.getIntKey()), entry.getIntValue()); +- }); ++ // Gale start - Lithium - faster chunk serialization ++ int len = this.data.palette().getSize(); ++ ++ // Do not allocate huge arrays if we're using a large palette ++ if (len > 4096) { ++ // VanillaCopy ++ if (this.data.palette.getSize() == 1) { ++ counter.accept(this.data.palette.valueFor(0), this.data.storage.getSize()); ++ } else { ++ Int2IntOpenHashMap int2IntOpenHashMap = new Int2IntOpenHashMap(); ++ this.data.storage.getAll((key) -> { ++ int2IntOpenHashMap.addTo(key, 1); ++ }); ++ int2IntOpenHashMap.int2IntEntrySet().forEach((entry) -> { ++ counter.accept(this.data.palette.valueFor(entry.getIntKey()), entry.getIntValue()); ++ }); ++ } ++ } ++ ++ short[] counts = new short[len]; ++ ++ this.data.storage().getAll(i -> counts[i]++); ++ ++ for (int i = 0; i < counts.length; i++) { ++ T obj = this.data.palette().valueFor(i); ++ ++ if (obj != null) { ++ counter.accept(obj, counts[i]); ++ } + } ++ // Gale end - Lithium - faster chunk serialization + } + + static record Configuration(Palette.Factory factory, int bits) { diff --git a/patches/server/0046-LinearPaper-Remove-all-locks-on-region-files.patch b/patches/server/0050-LinearPaper-Remove-all-locks-on-region-files.patch similarity index 100% rename from patches/server/0046-LinearPaper-Remove-all-locks-on-region-files.patch rename to patches/server/0050-LinearPaper-Remove-all-locks-on-region-files.patch diff --git a/patches/server/0047-Sparkly-Paper-Optimize-canSee-checks.patch b/patches/server/0051-Sparkly-Paper-Optimize-canSee-checks.patch similarity index 100% rename from patches/server/0047-Sparkly-Paper-Optimize-canSee-checks.patch rename to patches/server/0051-Sparkly-Paper-Optimize-canSee-checks.patch diff --git a/patches/server/0048-Purpur-use-alternative-keep-alive.patch b/patches/server/0052-Purpur-use-alternative-keep-alive.patch similarity index 100% rename from patches/server/0048-Purpur-use-alternative-keep-alive.patch rename to patches/server/0052-Purpur-use-alternative-keep-alive.patch diff --git a/patches/server/0049-Leaves-Protocol-Core.patch b/patches/server/0053-Leaves-Protocol-Core.patch similarity index 100% rename from patches/server/0049-Leaves-Protocol-Core.patch rename to patches/server/0053-Leaves-Protocol-Core.patch diff --git a/patches/server/0050-Leaves-Bladeren-Protocol.patch b/patches/server/0054-Leaves-Bladeren-Protocol.patch similarity index 100% rename from patches/server/0050-Leaves-Bladeren-Protocol.patch rename to patches/server/0054-Leaves-Bladeren-Protocol.patch diff --git a/patches/server/0051-Leaves-Fix-Bladeren-Protocol.patch b/patches/server/0055-Leaves-Fix-Bladeren-Protocol.patch similarity index 100% rename from patches/server/0051-Leaves-Fix-Bladeren-Protocol.patch rename to patches/server/0055-Leaves-Fix-Bladeren-Protocol.patch diff --git a/patches/server/0052-Leaves-carpet-protocol-support.patch b/patches/server/0056-Leaves-carpet-protocol-support.patch similarity index 100% rename from patches/server/0052-Leaves-carpet-protocol-support.patch rename to patches/server/0056-Leaves-carpet-protocol-support.patch diff --git a/patches/server/0053-Threaded-region-start-tick-and-finished-tick-event.patch b/patches/server/0057-Threaded-region-start-tick-and-finished-tick-event.patch similarity index 100% rename from patches/server/0053-Threaded-region-start-tick-and-finished-tick-event.patch rename to patches/server/0057-Threaded-region-start-tick-and-finished-tick-event.patch