From 4726b51fbb038b1bd34f54eacd7d50caf8b7bb7d Mon Sep 17 00:00:00 2001 From: violetc <58360096+s-yh-china@users.noreply.github.com> Date: Wed, 17 Aug 2022 11:25:21 +0800 Subject: [PATCH] Add More More More More Performance Improvements by Pufferfish --- .../0034-Reduce-entity-allocations.patch | 71 ++++++++++++++++ ...035-Remove-lambda-from-ticking-guard.patch | 53 ++++++++++++ ...ve-iterators-from-inventory-contains.patch | 72 ++++++++++++++++ ...-streams-from-getting-nearby-players.patch | 85 +++++++++++++++++++ ...reams-and-iterators-from-range-check.patch | 80 +++++++++++++++++ 5 files changed, 361 insertions(+) create mode 100644 patches/server/0034-Reduce-entity-allocations.patch create mode 100644 patches/server/0035-Remove-lambda-from-ticking-guard.patch create mode 100644 patches/server/0036-Remove-iterators-from-inventory-contains.patch create mode 100644 patches/server/0037-Remove-streams-from-getting-nearby-players.patch create mode 100644 patches/server/0038-Remove-streams-and-iterators-from-range-check.patch diff --git a/patches/server/0034-Reduce-entity-allocations.patch b/patches/server/0034-Reduce-entity-allocations.patch new file mode 100644 index 00000000..20f6b261 --- /dev/null +++ b/patches/server/0034-Reduce-entity-allocations.patch @@ -0,0 +1,71 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: violetc <58360096+s-yh-china@users.noreply.github.com> +Date: Wed, 17 Aug 2022 10:48:18 +0800 +Subject: [PATCH] Reduce entity allocations + +This patch is Powered by Pufferfish(https://github.com/pufferfish-gg/Pufferfish) + +diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java +index 1f1bed78e8d003cfd85bc5cf38014c3ddb3078d1..66cecf64fac0b72590e1a4ea7147ea2ac78dd30a 100644 +--- a/src/main/java/net/minecraft/world/entity/Entity.java ++++ b/src/main/java/net/minecraft/world/entity/Entity.java +@@ -414,6 +414,8 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource { + return this.originWorld; + } + // Paper end ++ // public final BlockPos.MutableBlockPos cachedBlockPos = new BlockPos.MutableBlockPos(); // Leaves - used where needed ? ++ + public float getBukkitYaw() { + return this.yRot; + } +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 c770ee21b7b699522941f6a1584d532001c04082..a0672f21797ff90e8bb6b16d3aaa671b317d6912 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 +@@ -22,9 +22,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; // Leaves - reduce entity allocations + + public AttributeMap(AttributeSupplier defaultAttributes) { + this.supplier = defaultAttributes; ++ this.createInstance = attribute -> this.supplier.createInstance(this::onAttributeModified, attribute); + } + + private void onAttributeModified(AttributeInstance instance) { +@@ -46,9 +48,15 @@ public class AttributeMap { + + @Nullable + public AttributeInstance getInstance(Attribute attribute) { +- return this.attributes.computeIfAbsent(attribute, (attributex) -> { +- return this.supplier.createInstance(this::onAttributeModified, attributex); +- }); ++ // Leaves start - cache lambda, as for some reason java allocates it anyways ++ if (top.leavesmc.leaves.LeavesConfig.reduceEntityAllocations) { ++ return this.attributes.computeIfAbsent(attribute, this.createInstance); ++ } else { ++ return this.attributes.computeIfAbsent(attribute, (attributex) -> { ++ return this.supplier.createInstance(this::onAttributeModified, attributex); ++ }); ++ } ++ // Leaves end - cache lambda, as for some reason java allocates it anyways + } + + public boolean hasAttribute(Attribute attribute) { +diff --git a/src/main/java/top/leavesmc/leaves/LeavesConfig.java b/src/main/java/top/leavesmc/leaves/LeavesConfig.java +index 1e7b428f4e8fef77bdc8eae43216fe113484fdcc..afdb9c047d9f06c6dee5cec24393d5dd5bc9546b 100644 +--- a/src/main/java/top/leavesmc/leaves/LeavesConfig.java ++++ b/src/main/java/top/leavesmc/leaves/LeavesConfig.java +@@ -298,6 +298,11 @@ public final class LeavesConfig { + skipCloneLootParameters = getBoolean("settings.performance.skip-clone-loot-parameters", skipCloneLootParameters); + } + ++ public static boolean reduceEntityAllocations = true; ++ private static void reduceEntityAllocations() { ++ reduceEntityAllocations = getBoolean("settings.performance.reduce-entity-allocations", reduceEntityAllocations); ++ } ++ + public static final class WorldConfig { + + public final String worldName; diff --git a/patches/server/0035-Remove-lambda-from-ticking-guard.patch b/patches/server/0035-Remove-lambda-from-ticking-guard.patch new file mode 100644 index 00000000..ee0d2662 --- /dev/null +++ b/patches/server/0035-Remove-lambda-from-ticking-guard.patch @@ -0,0 +1,53 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: violetc <58360096+s-yh-china@users.noreply.github.com> +Date: Wed, 17 Aug 2022 10:56:49 +0800 +Subject: [PATCH] Remove lambda from ticking guard + +This patch is Powered by Pufferfish(https://github.com/pufferfish-gg/Pufferfish) + +diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java +index bb360a8a54fa4efe1cc6b672df09d4c0d6816d16..82fdf9ae2af5e36b2a8b74ec92d604d11326d4eb 100644 +--- a/src/main/java/net/minecraft/server/level/ServerLevel.java ++++ b/src/main/java/net/minecraft/server/level/ServerLevel.java +@@ -690,7 +690,24 @@ public class ServerLevel extends Level implements WorldGenLevel { + } + + gameprofilerfiller.push("tick"); +- this.guardEntityTick(this::tickNonPassenger, entity); ++ // Leaves start - copied from this.guardEntityTick ++ if (top.leavesmc.leaves.LeavesConfig.removeTickGuardLambda) { ++ try { ++ this.tickNonPassenger(entity); // Leaves - changed ++ MinecraftServer.getServer().executeMidTickTasks(); // Tuinity - execute chunk tasks mid tick ++ } catch (Throwable throwable) { ++ if (throwable instanceof ThreadDeath) throw throwable; // Paper ++ // Paper start - Prevent tile entity and entity crashes ++ final String msg = String.format("Entity threw exception at %s:%s,%s,%s", entity.level.getWorld().getName(), entity.getX(), entity.getY(), entity.getZ()); ++ MinecraftServer.LOGGER.error(msg, throwable); ++ getCraftServer().getPluginManager().callEvent(new com.destroystokyo.paper.event.server.ServerExceptionEvent(new com.destroystokyo.paper.exception.ServerInternalException(msg, throwable))); ++ entity.discard(); ++ // Paper end ++ } ++ } else { ++ this.guardEntityTick(this::tickNonPassenger, entity); ++ } ++ // Leaves end - copied from this.guardEntityTick + gameprofilerfiller.pop(); + } + } +diff --git a/src/main/java/top/leavesmc/leaves/LeavesConfig.java b/src/main/java/top/leavesmc/leaves/LeavesConfig.java +index afdb9c047d9f06c6dee5cec24393d5dd5bc9546b..5c35fe757b7dfffb7570a36e49f13fa2e4680a3a 100644 +--- a/src/main/java/top/leavesmc/leaves/LeavesConfig.java ++++ b/src/main/java/top/leavesmc/leaves/LeavesConfig.java +@@ -303,6 +303,11 @@ public final class LeavesConfig { + reduceEntityAllocations = getBoolean("settings.performance.reduce-entity-allocations", reduceEntityAllocations); + } + ++ public static boolean removeTickGuardLambda = true; ++ private static void removeTickGuardLambda() { ++ removeTickGuardLambda = getBoolean("settings.performance.remove.tick-guard-lambda", removeTickGuardLambda); ++ } ++ + public static final class WorldConfig { + + public final String worldName; diff --git a/patches/server/0036-Remove-iterators-from-inventory-contains.patch b/patches/server/0036-Remove-iterators-from-inventory-contains.patch new file mode 100644 index 00000000..44cc642a --- /dev/null +++ b/patches/server/0036-Remove-iterators-from-inventory-contains.patch @@ -0,0 +1,72 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: violetc <58360096+s-yh-china@users.noreply.github.com> +Date: Wed, 17 Aug 2022 11:04:12 +0800 +Subject: [PATCH] Remove iterators from inventory contains + +This patch is Powered by Pufferfish(https://github.com/pufferfish-gg/Pufferfish) + +diff --git a/src/main/java/net/minecraft/world/entity/player/Inventory.java b/src/main/java/net/minecraft/world/entity/player/Inventory.java +index a1a625a8dacf4d2bbf75ddd90dce1b1be663c919..038c5fae763c5d387a23aaacc3264ab340588ab4 100644 +--- a/src/main/java/net/minecraft/world/entity/player/Inventory.java ++++ b/src/main/java/net/minecraft/world/entity/player/Inventory.java +@@ -681,21 +681,35 @@ public class Inventory implements Container, Nameable { + } + + public boolean contains(ItemStack stack) { +- Iterator iterator = this.compartments.iterator(); ++ // Leaves start - don't allocate iterators ++ if (top.leavesmc.leaves.LeavesConfig.removeInventoryContainsIterators) { ++ for (int i = 0; i < this.compartments.size(); i++) { ++ List list = this.compartments.get(i); ++ for (int j = 0; j < list.size(); j++) { ++ ItemStack itemstack1 = list.get(j); ++ ++ if (!itemstack1.isEmpty() && itemstack1.sameItem(stack)) { ++ return true; ++ } ++ } ++ } ++ } else { ++ Iterator iterator = this.compartments.iterator(); + +- while (iterator.hasNext()) { +- List list = (List) iterator.next(); +- Iterator iterator1 = list.iterator(); ++ while (iterator.hasNext()) { ++ List list = (List) iterator.next(); ++ Iterator iterator1 = list.iterator(); + +- while (iterator1.hasNext()) { +- ItemStack itemstack1 = (ItemStack) iterator1.next(); ++ while (iterator1.hasNext()) { ++ ItemStack itemstack1 = (ItemStack) iterator1.next(); + +- if (!itemstack1.isEmpty() && itemstack1.sameItem(stack)) { +- return true; ++ if (!itemstack1.isEmpty() && itemstack1.sameItem(stack)) { ++ return true; ++ } + } + } + } +- ++ // Leaves end - don't allocate iterators + return false; + } + +diff --git a/src/main/java/top/leavesmc/leaves/LeavesConfig.java b/src/main/java/top/leavesmc/leaves/LeavesConfig.java +index 5c35fe757b7dfffb7570a36e49f13fa2e4680a3a..8b4095c0e8797482bca3800ad9dfc4f894e63f85 100644 +--- a/src/main/java/top/leavesmc/leaves/LeavesConfig.java ++++ b/src/main/java/top/leavesmc/leaves/LeavesConfig.java +@@ -308,6 +308,11 @@ public final class LeavesConfig { + removeTickGuardLambda = getBoolean("settings.performance.remove.tick-guard-lambda", removeTickGuardLambda); + } + ++ public static boolean removeInventoryContainsIterators = true; ++ private static void removeInventoryContainsIterators() { ++ removeInventoryContainsIterators = getBoolean("settings.performance.remove.inventory-contains-iterators", removeInventoryContainsIterators); ++ } ++ + public static final class WorldConfig { + + public final String worldName; diff --git a/patches/server/0037-Remove-streams-from-getting-nearby-players.patch b/patches/server/0037-Remove-streams-from-getting-nearby-players.patch new file mode 100644 index 00000000..1af14dbe --- /dev/null +++ b/patches/server/0037-Remove-streams-from-getting-nearby-players.patch @@ -0,0 +1,85 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: violetc <58360096+s-yh-china@users.noreply.github.com> +Date: Wed, 17 Aug 2022 11:13:30 +0800 +Subject: [PATCH] Remove streams from getting nearby players + +This patch is Powered by Pufferfish(https://github.com/pufferfish-gg/Pufferfish) + +diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java +index 66cecf64fac0b72590e1a4ea7147ea2ac78dd30a..2a55e56b80e2835ca8b3975f3b34e0087d385717 100644 +--- a/src/main/java/net/minecraft/world/entity/Entity.java ++++ b/src/main/java/net/minecraft/world/entity/Entity.java +@@ -439,25 +439,50 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource { + this.isLegacyTrackingEntity = isLegacyTrackingEntity; + } + ++ // Leaves start - better metond ++ private org.spigotmc.TrackingRange.TrackingRangeType getFurthestEntity(Entity entity, net.minecraft.server.level.ChunkMap chunkMap, org.spigotmc.TrackingRange.TrackingRangeType type, int range) { ++ List passengers = entity.getPassengers(); ++ for (int i = 0, size = passengers.size(); i < size; i++) { ++ Entity passenger = passengers.get(i); ++ org.spigotmc.TrackingRange.TrackingRangeType passengerType = passenger.trackingRangeType; ++ int passengerRange = chunkMap.getEntityTrackerRange(passengerType.ordinal()); ++ if (passengerRange > range) { ++ type = passengerType; ++ range = passengerRange; ++ } ++ ++ type = this.getFurthestEntity(passenger, chunkMap, type, range); ++ } ++ ++ return type; ++ } ++ // Leaves end - better metond ++ + public final com.destroystokyo.paper.util.misc.PooledLinkedHashSets.PooledObjectLinkedOpenHashSet getPlayersInTrackRange() { + // determine highest range of passengers + if (this.passengers.isEmpty()) { + return ((ServerLevel)this.level).getChunkSource().chunkMap.playerEntityTrackerTrackMaps[this.trackingRangeType.ordinal()] + .getObjectsInRange(MCUtil.getCoordinateKey(this)); + } +- Iterable passengers = this.getIndirectPassengers(); ++ // Leaves start - use getFurthestEntity to skip getIndirectPassengers + net.minecraft.server.level.ChunkMap chunkMap = ((ServerLevel)this.level).getChunkSource().chunkMap; + org.spigotmc.TrackingRange.TrackingRangeType type = this.trackingRangeType; + int range = chunkMap.getEntityTrackerRange(type.ordinal()); + +- for (Entity passenger : passengers) { +- org.spigotmc.TrackingRange.TrackingRangeType passengerType = passenger.trackingRangeType; +- int passengerRange = chunkMap.getEntityTrackerRange(passengerType.ordinal()); +- if (passengerRange > range) { +- type = passengerType; +- range = passengerRange; ++ if (top.leavesmc.leaves.LeavesConfig.removeGetNearPlayerStreams) { ++ type = this.getFurthestEntity(this, chunkMap, type, range); ++ } else { ++ Iterable passengers = this.getIndirectPassengers(); ++ for (Entity passenger : passengers) { ++ org.spigotmc.TrackingRange.TrackingRangeType passengerType = passenger.trackingRangeType; ++ int passengerRange = chunkMap.getEntityTrackerRange(passengerType.ordinal()); ++ if (passengerRange > range) { ++ type = passengerType; ++ range = passengerRange; ++ } + } + } ++ // Leaves end - use getFurthestEntity to skip getIndirectPassengers + + return chunkMap.playerEntityTrackerTrackMaps[type.ordinal()].getObjectsInRange(MCUtil.getCoordinateKey(this)); + } +diff --git a/src/main/java/top/leavesmc/leaves/LeavesConfig.java b/src/main/java/top/leavesmc/leaves/LeavesConfig.java +index 8b4095c0e8797482bca3800ad9dfc4f894e63f85..d797792d4c26ba70c08e0b96f0a611c379b07105 100644 +--- a/src/main/java/top/leavesmc/leaves/LeavesConfig.java ++++ b/src/main/java/top/leavesmc/leaves/LeavesConfig.java +@@ -313,6 +313,11 @@ public final class LeavesConfig { + removeInventoryContainsIterators = getBoolean("settings.performance.remove.inventory-contains-iterators", removeInventoryContainsIterators); + } + ++ public static boolean removeGetNearPlayerStreams = true; ++ private static void removeGetNearPlayerStreams() { ++ removeGetNearPlayerStreams = getBoolean("settings.performance.remove.get-nearby-players-streams", removeGetNearPlayerStreams); ++ } ++ + public static final class WorldConfig { + + public final String worldName; diff --git a/patches/server/0038-Remove-streams-and-iterators-from-range-check.patch b/patches/server/0038-Remove-streams-and-iterators-from-range-check.patch new file mode 100644 index 00000000..c18f83ce --- /dev/null +++ b/patches/server/0038-Remove-streams-and-iterators-from-range-check.patch @@ -0,0 +1,80 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: violetc <58360096+s-yh-china@users.noreply.github.com> +Date: Wed, 17 Aug 2022 11:19:33 +0800 +Subject: [PATCH] Remove streams and iterators from range check + +This patch is Powered by Pufferfish(https://github.com/pufferfish-gg/Pufferfish) + +diff --git a/src/main/java/net/minecraft/server/level/ChunkMap.java b/src/main/java/net/minecraft/server/level/ChunkMap.java +index 6c95663869b9d7a545393df0416332a509306bb5..b5ac10207ef5d500b36547322459f19e4d32f5fc 100644 +--- a/src/main/java/net/minecraft/server/level/ChunkMap.java ++++ b/src/main/java/net/minecraft/server/level/ChunkMap.java +@@ -2430,19 +2430,45 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider + return ChunkMap.this.level.getServer().getScaledTrackingDistance(initialDistance); + } + ++ // Leaves start ++ private static int getHighestRange(Entity parent, int highest) { ++ List passengers = parent.getPassengers(); ++ ++ for (int i = 0, size = passengers.size(); i < size; i++) { ++ Entity entity = passengers.get(i); ++ int range = entity.getType().clientTrackingRange() * 16; ++ range = org.spigotmc.TrackingRange.getEntityTrackingRange(entity, range); // Paper ++ ++ if (range > highest) { // Paper - we need the lowest range thanks to the fact that our tracker doesn't account for passenger logic // Tuinity - not anymore! ++ highest = range; ++ } ++ ++ highest = getHighestRange(entity, highest); ++ } ++ ++ return highest; ++ } ++ // Leaves end ++ + private int getEffectiveRange() { + int i = this.range; +- Iterator iterator = this.entity.getIndirectPassengers().iterator(); ++ // Leaves start - remove iterators and streams ++ if (top.leavesmc.leaves.LeavesConfig.removeRangeCheckStreams) { ++ i = getHighestRange(this.entity, i); ++ } else { ++ Iterator iterator = this.entity.getIndirectPassengers().iterator(); + +- while (iterator.hasNext()) { +- Entity entity = (Entity) iterator.next(); +- int j = entity.getType().clientTrackingRange() * 16; +- j = org.spigotmc.TrackingRange.getEntityTrackingRange(entity, j); // Paper ++ while (iterator.hasNext()) { ++ Entity entity = (Entity) iterator.next(); ++ int j = entity.getType().clientTrackingRange() * 16; ++ j = org.spigotmc.TrackingRange.getEntityTrackingRange(entity, j); // Paper + +- if (j > i) { +- i = j; ++ if (j > i) { ++ i = j; ++ } + } + } ++ // Leaves end - remove iterators and streams + + return this.scaledRange(i); + } +diff --git a/src/main/java/top/leavesmc/leaves/LeavesConfig.java b/src/main/java/top/leavesmc/leaves/LeavesConfig.java +index d797792d4c26ba70c08e0b96f0a611c379b07105..1c36dd6bdaa0bc11b0a7e082fdcd2061c19a333b 100644 +--- a/src/main/java/top/leavesmc/leaves/LeavesConfig.java ++++ b/src/main/java/top/leavesmc/leaves/LeavesConfig.java +@@ -318,6 +318,11 @@ public final class LeavesConfig { + removeGetNearPlayerStreams = getBoolean("settings.performance.remove.get-nearby-players-streams", removeGetNearPlayerStreams); + } + ++ public static boolean removeRangeCheckStreams = true; ++ private static void removeRangeCheckStreams() { ++ removeRangeCheckStreams = getBoolean("settings.performance.remove.range-check-streams-and-iterators", removeRangeCheckStreams); ++ } ++ + public static final class WorldConfig { + + public final String worldName;