From 836319d934268dec938c3cb0110e6530947fc88f Mon Sep 17 00:00:00 2001 From: Mechoriet Date: Sat, 7 Oct 2023 21:09:01 +0200 Subject: [PATCH 1/8] work --- .../server/0003-Setup-Gradle-project.patch | 5 +- patches/server/0099-add-fastutil.patch | 18 ++ ...-PlayerList-Object2ObjectOpenHashMap.patch | 19 ++ .../0101-fastutil-add-ObjectMapList.patch | 210 ++++++++++++++++++ ...l-use-ObjectMapList-in-EntityTracker.patch | 19 ++ ...-ObjectMapList-in-Chunk-EntitySlices.patch | 19 ++ .../server/0104-fastutil-PlayerChunkMap.patch | 37 +++ patches/server/0105-fastutil-World.patch | 21 ++ .../server/0106-fastutil-NBTTagCompound.patch | 19 ++ .../server/0107-fastutil-HashTreeSet.patch | 19 ++ 10 files changed, 384 insertions(+), 2 deletions(-) create mode 100644 patches/server/0099-add-fastutil.patch create mode 100644 patches/server/0100-fastutil-PlayerList-Object2ObjectOpenHashMap.patch create mode 100644 patches/server/0101-fastutil-add-ObjectMapList.patch create mode 100644 patches/server/0102-fastutil-use-ObjectMapList-in-EntityTracker.patch create mode 100644 patches/server/0103-fastutil-use-ObjectMapList-in-Chunk-EntitySlices.patch create mode 100644 patches/server/0104-fastutil-PlayerChunkMap.patch create mode 100644 patches/server/0105-fastutil-World.patch create mode 100644 patches/server/0106-fastutil-NBTTagCompound.patch create mode 100644 patches/server/0107-fastutil-HashTreeSet.patch diff --git a/patches/server/0003-Setup-Gradle-project.patch b/patches/server/0003-Setup-Gradle-project.patch index 33fe2cd4..1467078e 100644 --- a/patches/server/0003-Setup-Gradle-project.patch +++ b/patches/server/0003-Setup-Gradle-project.patch @@ -6,10 +6,10 @@ Subject: [PATCH] Setup Gradle project diff --git a/build.gradle.kts b/build.gradle.kts new file mode 100644 -index 0000000000000000000000000000000000000000..3938905ca58c3d1cd1db4fa9632637b7a43ff8c5 +index 0000000000000000000000000000000000000000..8fa745439919255e4b6598b1f9a162c8e18e5f87 --- /dev/null +++ b/build.gradle.kts -@@ -0,0 +1,114 @@ +@@ -0,0 +1,115 @@ +plugins { + id("pandaspigot.conventions") + id("com.github.johnrengelman.shadow") version "7.1.2" @@ -121,6 +121,7 @@ index 0000000000000000000000000000000000000000..3938905ca58c3d1cd1db4fa9632637b7 + registerRunTask("runDev") { + description = "Spin up a non-shaded non-relocated test server" + classpath = java.sourceSets.main.get().runtimeClasspath ++ jvmArgs = listOf("-Xms1G", "-Xmx1G", "-XX:+UseG1GC", "-XX:+ParallelRefProcEnabled", "-XX:MaxGCPauseMillis=200", "-XX:+UnlockExperimentalVMOptions", "-XX:+DisableExplicitGC", "-XX:+AlwaysPreTouch", "-XX:G1NewSizePercent=30", "-XX:G1MaxNewSizePercent=40", "-XX:G1HeapRegionSize=8M", "-XX:G1ReservePercent=20", "-XX:G1HeapWastePercent=5", "-XX:G1MixedGCCountTarget=4", "-XX:InitiatingHeapOccupancyPercent=15", "-XX:G1MixedGCLiveThresholdPercent=90", "-XX:G1RSetUpdatingPauseTimePercent=5", "-XX:SurvivorRatio=32", "-XX:+PerfDisableSharedMem", "-XX:MaxTenuringThreshold=1", "-Dusing.aikars.flags=https://mcflags.emc.gs", "-Daikars.new.flags=true") + mainClass.set("org.bukkit.craftbukkit.Main") + } +} diff --git a/patches/server/0099-add-fastutil.patch b/patches/server/0099-add-fastutil.patch new file mode 100644 index 00000000..5dddf522 --- /dev/null +++ b/patches/server/0099-add-fastutil.patch @@ -0,0 +1,18 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Mechoriet +Date: Sat, 7 Oct 2023 17:27:39 +0200 +Subject: [PATCH] add fastutil + + +diff --git a/build.gradle.kts b/build.gradle.kts +index 32e86e461d803da6493ac42c173317c2c67ca18b..12283bd6386dc459aebb28484cb1221fabb3db88 100644 +--- a/build.gradle.kts ++++ b/build.gradle.kts +@@ -20,6 +20,7 @@ dependencies { + + // Minecraft libraries: + implementation("io.netty:netty-all:4.1.91.Final") // PandaSpigot - Update Netty to 4.1.x ++ implementation("it.unimi.dsi:fastutil:8.5.12") // PandaSpigot - add fastutil + implementation("com.mojang:authlib:1.5.21") + // PandaSpigot start - Update log4j + implementation("org.apache.logging.log4j:log4j-api:2.17.1") diff --git a/patches/server/0100-fastutil-PlayerList-Object2ObjectOpenHashMap.patch b/patches/server/0100-fastutil-PlayerList-Object2ObjectOpenHashMap.patch new file mode 100644 index 00000000..a128c7b6 --- /dev/null +++ b/patches/server/0100-fastutil-PlayerList-Object2ObjectOpenHashMap.patch @@ -0,0 +1,19 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Mechoriet +Date: Sat, 7 Oct 2023 17:28:45 +0200 +Subject: [PATCH] fastutil - PlayerList - Object2ObjectOpenHashMap + + +diff --git a/src/main/java/net/minecraft/server/PlayerList.java b/src/main/java/net/minecraft/server/PlayerList.java +index ada9cf25b091c2df24301bb5e82d1f76fbd929e5..905a141d1bc731875fd739dc7ce0171db4cf9779 100644 +--- a/src/main/java/net/minecraft/server/PlayerList.java ++++ b/src/main/java/net/minecraft/server/PlayerList.java +@@ -49,7 +49,7 @@ public abstract class PlayerList { + private static final SimpleDateFormat g = new SimpleDateFormat("yyyy-MM-dd \'at\' HH:mm:ss z"); + private final MinecraftServer server; + public final List players = new java.util.concurrent.CopyOnWriteArrayList(); // CraftBukkit - ArrayList -> CopyOnWriteArrayList: Iterator safety +- private final Map j = Maps.newHashMap(); ++ private final Map j = new it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap<>(); + private final GameProfileBanList k; + private final IpBanList l; + private final OpList operators; diff --git a/patches/server/0101-fastutil-add-ObjectMapList.patch b/patches/server/0101-fastutil-add-ObjectMapList.patch new file mode 100644 index 00000000..3d6cc436 --- /dev/null +++ b/patches/server/0101-fastutil-add-ObjectMapList.patch @@ -0,0 +1,210 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Mechoriet +Date: Sat, 7 Oct 2023 17:33:06 +0200 +Subject: [PATCH] fastutil - add ObjectMapList + + +diff --git a/src/main/java/io/papermc/paper/util/maplist/ObjectMapList.java b/src/main/java/io/papermc/paper/util/maplist/ObjectMapList.java +new file mode 100644 +index 0000000000000000000000000000000000000000..a9eee73e34cc6ad6f872e8f000775c900a7509c1 +--- /dev/null ++++ b/src/main/java/io/papermc/paper/util/maplist/ObjectMapList.java +@@ -0,0 +1,198 @@ ++package io.papermc.paper.util.maplist; ++ ++import it.unimi.dsi.fastutil.ints.Int2IntOpenHashMap; ++import it.unimi.dsi.fastutil.objects.AbstractReferenceList; ++import it.unimi.dsi.fastutil.objects.ObjectListIterator; ++import it.unimi.dsi.fastutil.objects.ObjectSpliterator; ++import org.jetbrains.annotations.NotNull; ++ ++import java.util.Arrays; ++import java.util.NoSuchElementException; ++import java.util.Set; ++ ++/** ++ * list with O(1) remove & contains ++ * @author Spottedleaf ++ */ ++public final class ObjectMapList extends AbstractReferenceList implements Set { ++ ++ private final Int2IntOpenHashMap objectToIndex; ++ ++ private static final Object[] EMPTY_LIST = new Object[0]; ++ private T[] elements = (T[]) EMPTY_LIST; ++ private int count; ++ ++ public ObjectMapList() { ++ this(2, 0.8f); ++ } ++ ++ public ObjectMapList(int expectedSize, float loadFactor) { ++ this.objectToIndex = new Int2IntOpenHashMap(expectedSize, loadFactor); ++ this.objectToIndex.defaultReturnValue(Integer.MIN_VALUE); ++ } ++ ++ @Override ++ public int size() { ++ return this.count; ++ } ++ ++ @Override ++ public int indexOf(Object object) { ++ return this.objectToIndex.get(object.hashCode()); ++ } ++ ++ @Override ++ public int lastIndexOf(Object object) { ++ return super.indexOf(object); ++ } ++ ++ @Override ++ public boolean remove(final Object object) { ++ final int index = this.objectToIndex.remove(object.hashCode()); ++ if (index == Integer.MIN_VALUE) { ++ return false; ++ } ++ ++ // move the obj at the end to this index ++ final int endIndex = --this.count; ++ final T end = this.elements[endIndex]; ++ if (index != endIndex) { ++ // not empty after this call ++ this.objectToIndex.put(end.hashCode(), index); // update index ++ } ++ this.elements[index] = end; ++ this.elements[endIndex] = null; ++ return true; ++ } ++ ++ @Override ++ public boolean add(final T object) { ++ final int count = this.count; ++ final int currIndex = this.objectToIndex.putIfAbsent(object.hashCode(), count); ++ ++ if (currIndex != Integer.MIN_VALUE) { ++ return false; // already in this list ++ } ++ ++ T[] list = this.elements; ++ if (list.length == count) { ++ // resize required ++ list = this.elements = Arrays.copyOf(list, (int)Math.max(4L, (long) count << 1)); // overflow results in negative ++ } ++ ++ list[count] = object; ++ this.count = count + 1; ++ return true; ++ } ++ ++ @Override ++ public void add(final int index, final T object) { ++ final int currIndex = this.objectToIndex.putIfAbsent(object.hashCode(), index); ++ ++ if (currIndex != Integer.MIN_VALUE) { ++ return; // already in this list ++ } ++ ++ int count = this.count; ++ T[] list = this.elements; ++ if (list.length == count) { ++ // resize required ++ list = this.elements = Arrays.copyOf(list, (int) Math.max(4L, (long) count << 1)); // overflow results in negative ++ } ++ ++ System.arraycopy(list, index, list, index + 1, count - index); ++ list[index] = object; ++ this.count = count + 1; ++ } ++ ++ @Override ++ public T get(int index) { ++ return this.elements[index]; ++ } ++ ++ @Override ++ public boolean isEmpty() { ++ return this.count == 0; ++ } ++ ++ @Override ++ public void clear() { ++ this.objectToIndex.clear(); ++ Arrays.fill(this.elements, 0, this.count, null); ++ this.count = 0; ++ } ++ ++ @Override ++ public Object @NotNull [] toArray() { ++ return Arrays.copyOf(this.elements, this.count); ++ } ++ ++ @Override ++ public ObjectSpliterator spliterator() { ++ return super.spliterator(); ++ } ++ ++ @Override ++ public @NotNull ObjectListIterator iterator() { ++ return new Iterator(0); ++ } ++ ++ private class Iterator implements ObjectListIterator { ++ ++ T lastRet; ++ int current; ++ ++ Iterator(int index) { ++ current = index; ++ } ++ ++ @Override ++ public int nextIndex() { ++ return this.current + 1; ++ } ++ ++ @Override ++ public int previousIndex() { ++ return this.current - 1; ++ } ++ ++ @Override ++ public boolean hasNext() { ++ return this.current < ObjectMapList.this.count; ++ } ++ ++ @Override ++ public boolean hasPrevious() { ++ return this.current > 0; ++ } ++ ++ @Override ++ public T next() { ++ if (this.current >= ObjectMapList.this.count) { ++ throw new NoSuchElementException(); ++ } ++ return this.lastRet = ObjectMapList.this.elements[this.current++]; ++ } ++ ++ @Override ++ public T previous() { ++ if (this.current < 0) { ++ throw new NoSuchElementException(); ++ } ++ return this.lastRet = ObjectMapList.this.elements[--this.current]; ++ } ++ ++ @Override ++ public void remove() { ++ final T lastRet = this.lastRet; ++ ++ if (lastRet == null) { ++ throw new IllegalStateException(); ++ } ++ this.lastRet = null; ++ ++ ObjectMapList.this.remove(lastRet); ++ --this.current; ++ } ++ } ++} diff --git a/patches/server/0102-fastutil-use-ObjectMapList-in-EntityTracker.patch b/patches/server/0102-fastutil-use-ObjectMapList-in-EntityTracker.patch new file mode 100644 index 00000000..52ab8c83 --- /dev/null +++ b/patches/server/0102-fastutil-use-ObjectMapList-in-EntityTracker.patch @@ -0,0 +1,19 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Mechoriet +Date: Sat, 7 Oct 2023 17:33:39 +0200 +Subject: [PATCH] fastutil - use ObjectMapList in EntityTracker + + +diff --git a/src/main/java/net/minecraft/server/EntityTracker.java b/src/main/java/net/minecraft/server/EntityTracker.java +index cb72b36725927272fddfdad929b268a7b06140ac..d3afb43259dc34a63c561266efbf7e5050d9d213 100644 +--- a/src/main/java/net/minecraft/server/EntityTracker.java ++++ b/src/main/java/net/minecraft/server/EntityTracker.java +@@ -13,7 +13,7 @@ public class EntityTracker { + + private static final Logger a = LogManager.getLogger(); + private final WorldServer world; +- private Set c = Sets.newHashSet(); ++ private Set c = new io.papermc.paper.util.maplist.ObjectMapList<>(); // PandaSpigot - FastUtil - ObjectMapList + public IntHashMap trackedEntities = new IntHashMap(); + private int e; + diff --git a/patches/server/0103-fastutil-use-ObjectMapList-in-Chunk-EntitySlices.patch b/patches/server/0103-fastutil-use-ObjectMapList-in-Chunk-EntitySlices.patch new file mode 100644 index 00000000..796f6eac --- /dev/null +++ b/patches/server/0103-fastutil-use-ObjectMapList-in-Chunk-EntitySlices.patch @@ -0,0 +1,19 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Mechoriet +Date: Sat, 7 Oct 2023 17:34:37 +0200 +Subject: [PATCH] fastutil - use ObjectMapList in Chunk EntitySlices + + +diff --git a/src/main/java/net/minecraft/server/Chunk.java b/src/main/java/net/minecraft/server/Chunk.java +index 3cb8d99311e2fa9a4a1173f6ef9e8dee957b20fa..25669f6ebd1075573385c77d7644910cb00ad970 100644 +--- a/src/main/java/net/minecraft/server/Chunk.java ++++ b/src/main/java/net/minecraft/server/Chunk.java +@@ -146,7 +146,7 @@ public class Chunk { + this.heightMap = new int[256]; + + for (int k = 0; k < this.entitySlices.length; ++k) { +- this.entitySlices[k] = new org.bukkit.craftbukkit.util.UnsafeList(); // Spigot ++ this.entitySlices[k] = new io.papermc.paper.util.maplist.ObjectMapList<>(); // PandaSpigot - Fastutil ObjectMapList + } + + Arrays.fill(this.f, -999); diff --git a/patches/server/0104-fastutil-PlayerChunkMap.patch b/patches/server/0104-fastutil-PlayerChunkMap.patch new file mode 100644 index 00000000..b60737dc --- /dev/null +++ b/patches/server/0104-fastutil-PlayerChunkMap.patch @@ -0,0 +1,37 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Mechoriet +Date: Sat, 7 Oct 2023 17:51:33 +0200 +Subject: [PATCH] fastutil - PlayerChunkMap + + +diff --git a/src/main/java/net/minecraft/server/PlayerChunkMap.java b/src/main/java/net/minecraft/server/PlayerChunkMap.java +index 696edfe83aa6c75deaaa59cc10818dbf261cc5a9..22d0c03b3e9ff37d182f0a7194c946d03abc4b91 100644 +--- a/src/main/java/net/minecraft/server/PlayerChunkMap.java ++++ b/src/main/java/net/minecraft/server/PlayerChunkMap.java +@@ -19,7 +19,7 @@ public class PlayerChunkMap { + + private static final Logger a = LogManager.getLogger(); + private final WorldServer world; +- private final List managedPlayers = Lists.newArrayList(); ++ private final List managedPlayers = new it.unimi.dsi.fastutil.objects.ObjectArrayList<>(); // PandaSpigot - fastutil - ObjectArrayList + private final LongHashMap d = new LongHashMap(); + private final Queue e = new java.util.concurrent.ConcurrentLinkedQueue(); // CraftBukkit ArrayList -> ConcurrentLinkedQueue + private final Queue f = new java.util.concurrent.ConcurrentLinkedQueue(); // CraftBukkit ArrayList -> ConcurrentLinkedQueue +@@ -351,7 +351,7 @@ public class PlayerChunkMap { + + class PlayerChunk { + +- private final List b = Lists.newArrayList(); ++ private final List b = new it.unimi.dsi.fastutil.objects.ObjectArrayList<>(); // PandaSpigot - fastutil - ObjectArrayList + private final ChunkCoordIntPair location; + private short[] dirtyBlocks = new short[64]; + private int dirtyCount; +@@ -359,7 +359,7 @@ public class PlayerChunkMap { + private long g; + + // CraftBukkit start - add fields +- private final HashMap players = new HashMap(); ++ private final java.util.Map players = new it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap<>(); // Pandaspigot - fastutil - Object2ObjectOpenHashMAp + private boolean loaded = false; + private Runnable loadedRunnable = new Runnable() { + public void run() { diff --git a/patches/server/0105-fastutil-World.patch b/patches/server/0105-fastutil-World.patch new file mode 100644 index 00000000..a3acd18c --- /dev/null +++ b/patches/server/0105-fastutil-World.patch @@ -0,0 +1,21 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Mechoriet +Date: Sat, 7 Oct 2023 20:52:52 +0200 +Subject: [PATCH] fastutil - World + + +diff --git a/src/main/java/net/minecraft/server/World.java b/src/main/java/net/minecraft/server/World.java +index 38ebe35f6fa434103b52e86262c7f4cc32d486e3..5736c939c850e9c4dea9c4070079ed1fd4db9809 100644 +--- a/src/main/java/net/minecraft/server/World.java ++++ b/src/main/java/net/minecraft/server/World.java +@@ -66,8 +66,8 @@ public abstract class World implements IBlockAccess { + public final List tileEntityList = Lists.newArrayList(); + private final List b = Lists.newArrayList(); + private final Set c = Sets.newHashSet(); // Paper +- public final List players = Lists.newArrayList(); +- public final List k = Lists.newArrayList(); ++ public final List players = new it.unimi.dsi.fastutil.objects.ObjectArrayList<>(); // PandaSpigot - fastutil - ObjectArrayList ++ public final List k = new it.unimi.dsi.fastutil.objects.ObjectArrayList<>(); // PandaSpigot - fastutil - ObjectArrayList + protected final IntHashMap entitiesById = new IntHashMap(); + private long d = 16777215L; + private int I; diff --git a/patches/server/0106-fastutil-NBTTagCompound.patch b/patches/server/0106-fastutil-NBTTagCompound.patch new file mode 100644 index 00000000..87a50c21 --- /dev/null +++ b/patches/server/0106-fastutil-NBTTagCompound.patch @@ -0,0 +1,19 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Mechoriet +Date: Sat, 7 Oct 2023 20:54:14 +0200 +Subject: [PATCH] fastutil - NBTTagCompound + + +diff --git a/src/main/java/net/minecraft/server/NBTTagCompound.java b/src/main/java/net/minecraft/server/NBTTagCompound.java +index 22d7c2ab36f11f93c0b9d08b786c784562ef7077..89c9298fde1711a1a5923b81715f45f1341fa693 100644 +--- a/src/main/java/net/minecraft/server/NBTTagCompound.java ++++ b/src/main/java/net/minecraft/server/NBTTagCompound.java +@@ -12,7 +12,7 @@ import java.util.concurrent.Callable; + + public class NBTTagCompound extends NBTBase { + +- private Map map = Maps.newHashMap(); ++ private Map map = new it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap<>(8, 0.8f); // PandaSpigot - reduce memory footprint of NBTTagCompound + + public NBTTagCompound() {} + diff --git a/patches/server/0107-fastutil-HashTreeSet.patch b/patches/server/0107-fastutil-HashTreeSet.patch new file mode 100644 index 00000000..aa67ef68 --- /dev/null +++ b/patches/server/0107-fastutil-HashTreeSet.patch @@ -0,0 +1,19 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Mechoriet +Date: Sat, 7 Oct 2023 20:55:42 +0200 +Subject: [PATCH] fastutil - HashTreeSet + + +diff --git a/src/main/java/org/bukkit/craftbukkit/util/HashTreeSet.java b/src/main/java/org/bukkit/craftbukkit/util/HashTreeSet.java +index 80a5c29f3b9f0e6ccb2acb01a6be3726d6b368b3..70430f5dd8139384eaec1246af159f6d254c7de3 100644 +--- a/src/main/java/org/bukkit/craftbukkit/util/HashTreeSet.java ++++ b/src/main/java/org/bukkit/craftbukkit/util/HashTreeSet.java +@@ -8,7 +8,7 @@ import java.util.TreeSet; + + public class HashTreeSet implements Set { + +- private HashSet hash = new HashSet(); ++ private Set hash = new it.unimi.dsi.fastutil.objects.ObjectOpenHashSet<>(); // PandaSpigot - Replace java.util.HashSet with ObjectOpenHashSet + private TreeSet tree = new TreeSet(); + + public HashTreeSet() { From f5c19acf6335744fbfa5251a170a02ce19535fa1 Mon Sep 17 00:00:00 2001 From: Mechoriet Date: Sat, 7 Oct 2023 21:12:19 +0200 Subject: [PATCH 2/8] rebase --- .../server/{0099-add-fastutil.patch => 0100-add-fastutil.patch} | 0 ...ch => 0101-fastutil-PlayerList-Object2ObjectOpenHashMap.patch} | 0 ...-ObjectMapList.patch => 0102-fastutil-add-ObjectMapList.patch} | 0 ...tch => 0103-fastutil-use-ObjectMapList-in-EntityTracker.patch} | 0 ...> 0104-fastutil-use-ObjectMapList-in-Chunk-EntitySlices.patch} | 0 ...il-PlayerChunkMap.patch => 0105-fastutil-PlayerChunkMap.patch} | 0 .../{0105-fastutil-World.patch => 0106-fastutil-World.patch} | 0 ...il-NBTTagCompound.patch => 0107-fastutil-NBTTagCompound.patch} | 0 ...fastutil-HashTreeSet.patch => 0108-fastutil-HashTreeSet.patch} | 0 9 files changed, 0 insertions(+), 0 deletions(-) rename patches/server/{0099-add-fastutil.patch => 0100-add-fastutil.patch} (100%) rename patches/server/{0100-fastutil-PlayerList-Object2ObjectOpenHashMap.patch => 0101-fastutil-PlayerList-Object2ObjectOpenHashMap.patch} (100%) rename patches/server/{0101-fastutil-add-ObjectMapList.patch => 0102-fastutil-add-ObjectMapList.patch} (100%) rename patches/server/{0102-fastutil-use-ObjectMapList-in-EntityTracker.patch => 0103-fastutil-use-ObjectMapList-in-EntityTracker.patch} (100%) rename patches/server/{0103-fastutil-use-ObjectMapList-in-Chunk-EntitySlices.patch => 0104-fastutil-use-ObjectMapList-in-Chunk-EntitySlices.patch} (100%) rename patches/server/{0104-fastutil-PlayerChunkMap.patch => 0105-fastutil-PlayerChunkMap.patch} (100%) rename patches/server/{0105-fastutil-World.patch => 0106-fastutil-World.patch} (100%) rename patches/server/{0106-fastutil-NBTTagCompound.patch => 0107-fastutil-NBTTagCompound.patch} (100%) rename patches/server/{0107-fastutil-HashTreeSet.patch => 0108-fastutil-HashTreeSet.patch} (100%) diff --git a/patches/server/0099-add-fastutil.patch b/patches/server/0100-add-fastutil.patch similarity index 100% rename from patches/server/0099-add-fastutil.patch rename to patches/server/0100-add-fastutil.patch diff --git a/patches/server/0100-fastutil-PlayerList-Object2ObjectOpenHashMap.patch b/patches/server/0101-fastutil-PlayerList-Object2ObjectOpenHashMap.patch similarity index 100% rename from patches/server/0100-fastutil-PlayerList-Object2ObjectOpenHashMap.patch rename to patches/server/0101-fastutil-PlayerList-Object2ObjectOpenHashMap.patch diff --git a/patches/server/0101-fastutil-add-ObjectMapList.patch b/patches/server/0102-fastutil-add-ObjectMapList.patch similarity index 100% rename from patches/server/0101-fastutil-add-ObjectMapList.patch rename to patches/server/0102-fastutil-add-ObjectMapList.patch diff --git a/patches/server/0102-fastutil-use-ObjectMapList-in-EntityTracker.patch b/patches/server/0103-fastutil-use-ObjectMapList-in-EntityTracker.patch similarity index 100% rename from patches/server/0102-fastutil-use-ObjectMapList-in-EntityTracker.patch rename to patches/server/0103-fastutil-use-ObjectMapList-in-EntityTracker.patch diff --git a/patches/server/0103-fastutil-use-ObjectMapList-in-Chunk-EntitySlices.patch b/patches/server/0104-fastutil-use-ObjectMapList-in-Chunk-EntitySlices.patch similarity index 100% rename from patches/server/0103-fastutil-use-ObjectMapList-in-Chunk-EntitySlices.patch rename to patches/server/0104-fastutil-use-ObjectMapList-in-Chunk-EntitySlices.patch diff --git a/patches/server/0104-fastutil-PlayerChunkMap.patch b/patches/server/0105-fastutil-PlayerChunkMap.patch similarity index 100% rename from patches/server/0104-fastutil-PlayerChunkMap.patch rename to patches/server/0105-fastutil-PlayerChunkMap.patch diff --git a/patches/server/0105-fastutil-World.patch b/patches/server/0106-fastutil-World.patch similarity index 100% rename from patches/server/0105-fastutil-World.patch rename to patches/server/0106-fastutil-World.patch diff --git a/patches/server/0106-fastutil-NBTTagCompound.patch b/patches/server/0107-fastutil-NBTTagCompound.patch similarity index 100% rename from patches/server/0106-fastutil-NBTTagCompound.patch rename to patches/server/0107-fastutil-NBTTagCompound.patch diff --git a/patches/server/0107-fastutil-HashTreeSet.patch b/patches/server/0108-fastutil-HashTreeSet.patch similarity index 100% rename from patches/server/0107-fastutil-HashTreeSet.patch rename to patches/server/0108-fastutil-HashTreeSet.patch From 38d73e9d33a6d5b347f49ba2f4e7338902faed41 Mon Sep 17 00:00:00 2001 From: Mechoriet Date: Sat, 7 Oct 2023 21:36:02 +0200 Subject: [PATCH 3/8] work work --- .../0109-fixup-fastutil-NBTTagCompound.patch | 54 +++++++++++++++++++ .../server/0110-fastutil-DataWatcher.patch | 53 ++++++++++++++++++ .../0111-fastutil-HandshakeListener.patch | 19 +++++++ .../0112-fastutil-ChunkProviderServer.patch | 19 +++++++ 4 files changed, 145 insertions(+) create mode 100644 patches/server/0109-fixup-fastutil-NBTTagCompound.patch create mode 100644 patches/server/0110-fastutil-DataWatcher.patch create mode 100644 patches/server/0111-fastutil-HandshakeListener.patch create mode 100644 patches/server/0112-fastutil-ChunkProviderServer.patch diff --git a/patches/server/0109-fixup-fastutil-NBTTagCompound.patch b/patches/server/0109-fixup-fastutil-NBTTagCompound.patch new file mode 100644 index 00000000..a7dbfc2e --- /dev/null +++ b/patches/server/0109-fixup-fastutil-NBTTagCompound.patch @@ -0,0 +1,54 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Mechoriet +Date: Sat, 7 Oct 2023 21:24:34 +0200 +Subject: [PATCH] fixup! fastutil - NBTTagCompound + + +diff --git a/src/main/java/net/minecraft/server/NBTTagCompound.java b/src/main/java/net/minecraft/server/NBTTagCompound.java +index 89c9298fde1711a1a5923b81715f45f1341fa693..01cc42ebc8429ac0fb66366542781739fbe77ee7 100644 +--- a/src/main/java/net/minecraft/server/NBTTagCompound.java ++++ b/src/main/java/net/minecraft/server/NBTTagCompound.java +@@ -12,10 +12,14 @@ import java.util.concurrent.Callable; + + public class NBTTagCompound extends NBTBase { + +- private Map map = new it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap<>(8, 0.8f); // PandaSpigot - reduce memory footprint of NBTTagCompound +- +- public NBTTagCompound() {} ++ private Map map; + ++ public NBTTagCompound() { ++ map = new it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap<>(8, 0.8f); // PandaSpigot - reduce memory footprint of NBTTagCompound ++ } ++ public NBTTagCompound(it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap map) { ++ this.map = map; ++ } + void write(DataOutput dataoutput) throws IOException { + Iterator iterator = this.map.keySet().iterator(); + +@@ -282,16 +286,17 @@ public class NBTTagCompound extends NBTBase { + } + + public NBTBase clone() { +- NBTTagCompound nbttagcompound = new NBTTagCompound(); +- Iterator iterator = this.map.keySet().iterator(); +- ++ it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap ret = new it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap<>( ++ this.map.size(), 0.8f); ++ Iterator> iterator = (this.map instanceof it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap) ++ ? ((it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap) this.map).object2ObjectEntrySet() ++ .fastIterator() ++ : this.map.entrySet().iterator(); + while (iterator.hasNext()) { +- String s = (String) iterator.next(); +- +- nbttagcompound.set(s, ((NBTBase) this.map.get(s)).clone()); ++ Map.Entry entry = iterator.next(); ++ ret.put(entry.getKey(), entry.getValue().clone()); + } +- +- return nbttagcompound; ++ return new NBTTagCompound(ret); + } + + public boolean equals(Object object) { diff --git a/patches/server/0110-fastutil-DataWatcher.patch b/patches/server/0110-fastutil-DataWatcher.patch new file mode 100644 index 00000000..6883bd54 --- /dev/null +++ b/patches/server/0110-fastutil-DataWatcher.patch @@ -0,0 +1,53 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Mechoriet +Date: Sat, 7 Oct 2023 21:29:31 +0200 +Subject: [PATCH] fastutil - DataWatcher + + +diff --git a/src/main/java/net/minecraft/server/DataWatcher.java b/src/main/java/net/minecraft/server/DataWatcher.java +index 518e8f379d690b1f1b4d2374c875dd3dae22360e..42909eddbb1984966d910cab2c3e3889472f4749 100644 +--- a/src/main/java/net/minecraft/server/DataWatcher.java ++++ b/src/main/java/net/minecraft/server/DataWatcher.java +@@ -16,11 +16,11 @@ public class DataWatcher { + private final Entity a; + private boolean b = true; + // Spigot Start +- private static final gnu.trove.map.TObjectIntMap classToId = new gnu.trove.map.hash.TObjectIntHashMap( 10, 0.5f, -1 ); +- private final gnu.trove.map.TIntObjectMap dataValues = new gnu.trove.map.hash.TIntObjectHashMap( 10, 0.5f, -1 ); ++ private static final it.unimi.dsi.fastutil.objects.Object2IntMap> classToId = new it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap<>(10, 0.5f); ++ private final it.unimi.dsi.fastutil.ints.Int2ObjectMap dataValues = new it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap<>( 10, 0.5f); + // These exist as an attempt at backwards compatability for (broken) NMS plugins +- private static final Map, Integer> c = gnu.trove.TDecorators.wrap( classToId ); +- private final Map d = gnu.trove.TDecorators.wrap( dataValues ); ++ private static final Map, Integer> c = classToId; ++ private final Map d = dataValues; + // Spigot End + private boolean e; + // private ReadWriteLock f = new ReentrantReadWriteLock(); // PandaSpigot - Remove DataWatcher Locking +@@ -151,7 +151,7 @@ public class DataWatcher { + + if (this.e) { + // this.f.readLock().lock(); // PandaSpigot +- Iterator iterator = this.dataValues.valueCollection().iterator(); // Spigot ++ Iterator iterator = this.dataValues.values().iterator(); // Spigot + + while (iterator.hasNext()) { + DataWatcher.WatchableObject datawatcher_watchableobject = (DataWatcher.WatchableObject) iterator.next(); +@@ -186,7 +186,7 @@ public class DataWatcher { + + public void a(PacketDataSerializer packetdataserializer) throws IOException { + // this.f.readLock().lock(); // PandaSpigot +- Iterator iterator = this.dataValues.valueCollection().iterator(); // Spigot ++ Iterator iterator = this.dataValues.values().iterator(); // Spigot + + while (iterator.hasNext()) { + DataWatcher.WatchableObject datawatcher_watchableobject = (DataWatcher.WatchableObject) iterator.next(); +@@ -203,7 +203,7 @@ public class DataWatcher { + + // this.f.readLock().lock(); // PandaSpigot + +- arraylist.addAll(this.dataValues.valueCollection()); // Spigot ++ arraylist.addAll(this.dataValues.values()); // Spigot + // Spigot start - copy ItemStacks to prevent ConcurrentModificationExceptions + for ( int i = 0; i < arraylist.size(); i++ ) + { diff --git a/patches/server/0111-fastutil-HandshakeListener.patch b/patches/server/0111-fastutil-HandshakeListener.patch new file mode 100644 index 00000000..21c8c7be --- /dev/null +++ b/patches/server/0111-fastutil-HandshakeListener.patch @@ -0,0 +1,19 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Mechoriet +Date: Sat, 7 Oct 2023 21:30:42 +0200 +Subject: [PATCH] fastutil - HandshakeListener + + +diff --git a/src/main/java/net/minecraft/server/HandshakeListener.java b/src/main/java/net/minecraft/server/HandshakeListener.java +index 10a8c440f08535d90d8d1204a23c859ba296aa39..ef1a07a6d9667f7fd94f0f6596c4963ad5f0dd54 100644 +--- a/src/main/java/net/minecraft/server/HandshakeListener.java ++++ b/src/main/java/net/minecraft/server/HandshakeListener.java +@@ -9,7 +9,7 @@ public class HandshakeListener implements PacketHandshakingInListener { + + private static final com.google.gson.Gson gson = new com.google.gson.Gson(); // Spigot + // CraftBukkit start - add fields +- private static final HashMap throttleTracker = new HashMap(); ++ private static final java.util.Map throttleTracker = new it.unimi.dsi.fastutil.objects.Object2LongOpenHashMap<>(); + private static int throttleCounter = 0; + // CraftBukkit end + diff --git a/patches/server/0112-fastutil-ChunkProviderServer.patch b/patches/server/0112-fastutil-ChunkProviderServer.patch new file mode 100644 index 00000000..b87d35f5 --- /dev/null +++ b/patches/server/0112-fastutil-ChunkProviderServer.patch @@ -0,0 +1,19 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Mechoriet +Date: Sat, 7 Oct 2023 21:32:40 +0200 +Subject: [PATCH] fastutil - ChunkProviderServer + + +diff --git a/src/main/java/net/minecraft/server/ChunkProviderServer.java b/src/main/java/net/minecraft/server/ChunkProviderServer.java +index 7085cb503db3e1e585417ce4300c6be075c7d2fe..079e8e29cc34e41eb932d6d90f8b775164a45251 100644 +--- a/src/main/java/net/minecraft/server/ChunkProviderServer.java ++++ b/src/main/java/net/minecraft/server/ChunkProviderServer.java +@@ -34,7 +34,7 @@ public class ChunkProviderServer implements IChunkProvider { + public IChunkProvider chunkProvider; + private IChunkLoader chunkLoader; + public boolean forceChunkLoad = false; // CraftBukkit - true -> false +- public LongObjectHashMap chunks = new LongObjectHashMap(); ++ public it.unimi.dsi.fastutil.longs.Long2ObjectMap chunks = new it.unimi.dsi.fastutil.longs.Long2ObjectOpenHashMap<>(4096, 0.5f); + public WorldServer world; + + public ChunkProviderServer(WorldServer worldserver, IChunkLoader ichunkloader, IChunkProvider ichunkprovider) { From 3acd639f6f054d248621d1ecbdb0eec796571e08 Mon Sep 17 00:00:00 2001 From: Mechoriet Date: Sat, 7 Oct 2023 21:50:12 +0200 Subject: [PATCH 4/8] work work work --- .../server/0103-fastutil-EntityTracker.patch | 32 +++++++++++ ...l-use-ObjectMapList-in-EntityTracker.patch | 19 ------- patches/server/0106-fastutil-World.patch | 11 +++- .../server/0107-fastutil-NBTTagCompound.patch | 43 +++++++++++++-- ....patch => 0109-fastutil-DataWatcher.patch} | 0 .../0109-fixup-fastutil-NBTTagCompound.patch | 54 ------------------- ... => 0110-fastutil-HandshakeListener.patch} | 0 ...> 0111-fastutil-ChunkProviderServer.patch} | 0 .../0112-fastutil-SpawnerCreature.patch | 45 ++++++++++++++++ .../0113-fastutil-CraftingManager.patch | 19 +++++++ 10 files changed, 145 insertions(+), 78 deletions(-) create mode 100644 patches/server/0103-fastutil-EntityTracker.patch delete mode 100644 patches/server/0103-fastutil-use-ObjectMapList-in-EntityTracker.patch rename patches/server/{0110-fastutil-DataWatcher.patch => 0109-fastutil-DataWatcher.patch} (100%) delete mode 100644 patches/server/0109-fixup-fastutil-NBTTagCompound.patch rename patches/server/{0111-fastutil-HandshakeListener.patch => 0110-fastutil-HandshakeListener.patch} (100%) rename patches/server/{0112-fastutil-ChunkProviderServer.patch => 0111-fastutil-ChunkProviderServer.patch} (100%) create mode 100644 patches/server/0112-fastutil-SpawnerCreature.patch create mode 100644 patches/server/0113-fastutil-CraftingManager.patch diff --git a/patches/server/0103-fastutil-EntityTracker.patch b/patches/server/0103-fastutil-EntityTracker.patch new file mode 100644 index 00000000..638919f9 --- /dev/null +++ b/patches/server/0103-fastutil-EntityTracker.patch @@ -0,0 +1,32 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Mechoriet +Date: Sat, 7 Oct 2023 17:33:39 +0200 +Subject: [PATCH] fastutil - EntityTracker + + +diff --git a/src/main/java/net/minecraft/server/EntityTracker.java b/src/main/java/net/minecraft/server/EntityTracker.java +index cb72b36725927272fddfdad929b268a7b06140ac..d3afb43259dc34a63c561266efbf7e5050d9d213 100644 +--- a/src/main/java/net/minecraft/server/EntityTracker.java ++++ b/src/main/java/net/minecraft/server/EntityTracker.java +@@ -13,7 +13,7 @@ public class EntityTracker { + + private static final Logger a = LogManager.getLogger(); + private final WorldServer world; +- private Set c = Sets.newHashSet(); ++ private Set c = new io.papermc.paper.util.maplist.ObjectMapList<>(); // PandaSpigot - FastUtil - ObjectMapList + public IntHashMap trackedEntities = new IntHashMap(); + private int e; + +diff --git a/src/main/java/net/minecraft/server/EntityTrackerEntry.java b/src/main/java/net/minecraft/server/EntityTrackerEntry.java +index 0b90b6f30ea09fb117281d5ddd2fc752d2c139b5..91e72f4fe98a4d83c5f886e86c945c602eb1454a 100644 +--- a/src/main/java/net/minecraft/server/EntityTrackerEntry.java ++++ b/src/main/java/net/minecraft/server/EntityTrackerEntry.java +@@ -42,7 +42,7 @@ public class EntityTrackerEntry { + // PaperSpigot start + // Replace trackedPlayers Set with a Map. The value is true until the player receives + // their first update (which is forced to have absolute coordinates), false afterward. +- public java.util.Map trackedPlayerMap = new java.util.HashMap(); ++ public java.util.Map trackedPlayerMap = new it.unimi.dsi.fastutil.objects.Reference2BooleanOpenHashMap<>(); + public Set trackedPlayers = trackedPlayerMap.keySet(); + // PaperSpigot end + diff --git a/patches/server/0103-fastutil-use-ObjectMapList-in-EntityTracker.patch b/patches/server/0103-fastutil-use-ObjectMapList-in-EntityTracker.patch deleted file mode 100644 index 52ab8c83..00000000 --- a/patches/server/0103-fastutil-use-ObjectMapList-in-EntityTracker.patch +++ /dev/null @@ -1,19 +0,0 @@ -From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 -From: Mechoriet -Date: Sat, 7 Oct 2023 17:33:39 +0200 -Subject: [PATCH] fastutil - use ObjectMapList in EntityTracker - - -diff --git a/src/main/java/net/minecraft/server/EntityTracker.java b/src/main/java/net/minecraft/server/EntityTracker.java -index cb72b36725927272fddfdad929b268a7b06140ac..d3afb43259dc34a63c561266efbf7e5050d9d213 100644 ---- a/src/main/java/net/minecraft/server/EntityTracker.java -+++ b/src/main/java/net/minecraft/server/EntityTracker.java -@@ -13,7 +13,7 @@ public class EntityTracker { - - private static final Logger a = LogManager.getLogger(); - private final WorldServer world; -- private Set c = Sets.newHashSet(); -+ private Set c = new io.papermc.paper.util.maplist.ObjectMapList<>(); // PandaSpigot - FastUtil - ObjectMapList - public IntHashMap trackedEntities = new IntHashMap(); - private int e; - diff --git a/patches/server/0106-fastutil-World.patch b/patches/server/0106-fastutil-World.patch index a3acd18c..f75c73d7 100644 --- a/patches/server/0106-fastutil-World.patch +++ b/patches/server/0106-fastutil-World.patch @@ -5,9 +5,18 @@ Subject: [PATCH] fastutil - World diff --git a/src/main/java/net/minecraft/server/World.java b/src/main/java/net/minecraft/server/World.java -index 38ebe35f6fa434103b52e86262c7f4cc32d486e3..5736c939c850e9c4dea9c4070079ed1fd4db9809 100644 +index 38ebe35f6fa434103b52e86262c7f4cc32d486e3..560b15ee0d932f30161915be21425c97d4ba656d 100644 --- a/src/main/java/net/minecraft/server/World.java +++ b/src/main/java/net/minecraft/server/World.java +@@ -36,7 +36,7 @@ public abstract class World implements IBlockAccess { + private int a = 63; + protected boolean e; + // Spigot start - guard entity list from removals +- public final List entityList = new java.util.ArrayList() ++ public final List entityList = new it.unimi.dsi.fastutil.objects.ObjectArrayList() + { + @Override + public Entity remove(int index) @@ -66,8 +66,8 @@ public abstract class World implements IBlockAccess { public final List tileEntityList = Lists.newArrayList(); private final List b = Lists.newArrayList(); diff --git a/patches/server/0107-fastutil-NBTTagCompound.patch b/patches/server/0107-fastutil-NBTTagCompound.patch index 87a50c21..e8e07c49 100644 --- a/patches/server/0107-fastutil-NBTTagCompound.patch +++ b/patches/server/0107-fastutil-NBTTagCompound.patch @@ -5,15 +5,50 @@ Subject: [PATCH] fastutil - NBTTagCompound diff --git a/src/main/java/net/minecraft/server/NBTTagCompound.java b/src/main/java/net/minecraft/server/NBTTagCompound.java -index 22d7c2ab36f11f93c0b9d08b786c784562ef7077..89c9298fde1711a1a5923b81715f45f1341fa693 100644 +index 22d7c2ab36f11f93c0b9d08b786c784562ef7077..01cc42ebc8429ac0fb66366542781739fbe77ee7 100644 --- a/src/main/java/net/minecraft/server/NBTTagCompound.java +++ b/src/main/java/net/minecraft/server/NBTTagCompound.java -@@ -12,7 +12,7 @@ import java.util.concurrent.Callable; +@@ -12,10 +12,14 @@ import java.util.concurrent.Callable; public class NBTTagCompound extends NBTBase { - private Map map = Maps.newHashMap(); -+ private Map map = new it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap<>(8, 0.8f); // PandaSpigot - reduce memory footprint of NBTTagCompound +- +- public NBTTagCompound() {} ++ private Map map; - public NBTTagCompound() {} ++ public NBTTagCompound() { ++ map = new it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap<>(8, 0.8f); // PandaSpigot - reduce memory footprint of NBTTagCompound ++ } ++ public NBTTagCompound(it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap map) { ++ this.map = map; ++ } + void write(DataOutput dataoutput) throws IOException { + Iterator iterator = this.map.keySet().iterator(); +@@ -282,16 +286,17 @@ public class NBTTagCompound extends NBTBase { + } + + public NBTBase clone() { +- NBTTagCompound nbttagcompound = new NBTTagCompound(); +- Iterator iterator = this.map.keySet().iterator(); +- ++ it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap ret = new it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap<>( ++ this.map.size(), 0.8f); ++ Iterator> iterator = (this.map instanceof it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap) ++ ? ((it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap) this.map).object2ObjectEntrySet() ++ .fastIterator() ++ : this.map.entrySet().iterator(); + while (iterator.hasNext()) { +- String s = (String) iterator.next(); +- +- nbttagcompound.set(s, ((NBTBase) this.map.get(s)).clone()); ++ Map.Entry entry = iterator.next(); ++ ret.put(entry.getKey(), entry.getValue().clone()); + } +- +- return nbttagcompound; ++ return new NBTTagCompound(ret); + } + + public boolean equals(Object object) { diff --git a/patches/server/0110-fastutil-DataWatcher.patch b/patches/server/0109-fastutil-DataWatcher.patch similarity index 100% rename from patches/server/0110-fastutil-DataWatcher.patch rename to patches/server/0109-fastutil-DataWatcher.patch diff --git a/patches/server/0109-fixup-fastutil-NBTTagCompound.patch b/patches/server/0109-fixup-fastutil-NBTTagCompound.patch deleted file mode 100644 index a7dbfc2e..00000000 --- a/patches/server/0109-fixup-fastutil-NBTTagCompound.patch +++ /dev/null @@ -1,54 +0,0 @@ -From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 -From: Mechoriet -Date: Sat, 7 Oct 2023 21:24:34 +0200 -Subject: [PATCH] fixup! fastutil - NBTTagCompound - - -diff --git a/src/main/java/net/minecraft/server/NBTTagCompound.java b/src/main/java/net/minecraft/server/NBTTagCompound.java -index 89c9298fde1711a1a5923b81715f45f1341fa693..01cc42ebc8429ac0fb66366542781739fbe77ee7 100644 ---- a/src/main/java/net/minecraft/server/NBTTagCompound.java -+++ b/src/main/java/net/minecraft/server/NBTTagCompound.java -@@ -12,10 +12,14 @@ import java.util.concurrent.Callable; - - public class NBTTagCompound extends NBTBase { - -- private Map map = new it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap<>(8, 0.8f); // PandaSpigot - reduce memory footprint of NBTTagCompound -- -- public NBTTagCompound() {} -+ private Map map; - -+ public NBTTagCompound() { -+ map = new it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap<>(8, 0.8f); // PandaSpigot - reduce memory footprint of NBTTagCompound -+ } -+ public NBTTagCompound(it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap map) { -+ this.map = map; -+ } - void write(DataOutput dataoutput) throws IOException { - Iterator iterator = this.map.keySet().iterator(); - -@@ -282,16 +286,17 @@ public class NBTTagCompound extends NBTBase { - } - - public NBTBase clone() { -- NBTTagCompound nbttagcompound = new NBTTagCompound(); -- Iterator iterator = this.map.keySet().iterator(); -- -+ it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap ret = new it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap<>( -+ this.map.size(), 0.8f); -+ Iterator> iterator = (this.map instanceof it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap) -+ ? ((it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap) this.map).object2ObjectEntrySet() -+ .fastIterator() -+ : this.map.entrySet().iterator(); - while (iterator.hasNext()) { -- String s = (String) iterator.next(); -- -- nbttagcompound.set(s, ((NBTBase) this.map.get(s)).clone()); -+ Map.Entry entry = iterator.next(); -+ ret.put(entry.getKey(), entry.getValue().clone()); - } -- -- return nbttagcompound; -+ return new NBTTagCompound(ret); - } - - public boolean equals(Object object) { diff --git a/patches/server/0111-fastutil-HandshakeListener.patch b/patches/server/0110-fastutil-HandshakeListener.patch similarity index 100% rename from patches/server/0111-fastutil-HandshakeListener.patch rename to patches/server/0110-fastutil-HandshakeListener.patch diff --git a/patches/server/0112-fastutil-ChunkProviderServer.patch b/patches/server/0111-fastutil-ChunkProviderServer.patch similarity index 100% rename from patches/server/0112-fastutil-ChunkProviderServer.patch rename to patches/server/0111-fastutil-ChunkProviderServer.patch diff --git a/patches/server/0112-fastutil-SpawnerCreature.patch b/patches/server/0112-fastutil-SpawnerCreature.patch new file mode 100644 index 00000000..561ba10f --- /dev/null +++ b/patches/server/0112-fastutil-SpawnerCreature.patch @@ -0,0 +1,45 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Mechoriet +Date: Sat, 7 Oct 2023 21:43:55 +0200 +Subject: [PATCH] fastutil - SpawnerCreature + + +diff --git a/src/main/java/net/minecraft/server/SpawnerCreature.java b/src/main/java/net/minecraft/server/SpawnerCreature.java +index 550bd42b656ce2e7a0d1542215845d2bf7c475d7..4c497835c9f3be3410d53a53beb289fcb36ca2d9 100644 +--- a/src/main/java/net/minecraft/server/SpawnerCreature.java ++++ b/src/main/java/net/minecraft/server/SpawnerCreature.java +@@ -23,28 +23,13 @@ public final class SpawnerCreature { + // Spigot start - get entity count only from chunks being processed in b + private int getEntityCount(WorldServer server, Class oClass) + { +- // PandaSpigot start - use entire world, not just active chunks. Spigot broke vanilla expectations. +- if (true) { +- int sum = 0; +- for (Chunk c : server.chunkProviderServer.chunks.values()) { +- sum += c.entityCount.get(oClass); +- } +- return sum; +- } +- // PandaSpigot end +- int i = 0; +- Iterator it = this.b.iterator(); +- while ( it.hasNext() ) +- { +- Long coord = it.next(); +- int x = LongHash.msw( coord ); +- int z = LongHash.lsw( coord ); +- if ( !server.chunkProviderServer.unloadQueue.contains( coord ) && server.isChunkLoaded( x, z, true ) ) +- { +- i += server.getChunkAt( x, z ).entityCount.get( oClass ); +- } ++ int sum = 0; ++ for (it.unimi.dsi.fastutil.objects.ObjectIterator objectIterator = (server.chunkProviderServer).chunks.values() ++ .iterator(); objectIterator.hasNext();) { ++ Chunk c = objectIterator.next(); ++ sum += c.entityCount.get(oClass); + } +- return i; ++ return sum; + } + // Spigot end + diff --git a/patches/server/0113-fastutil-CraftingManager.patch b/patches/server/0113-fastutil-CraftingManager.patch new file mode 100644 index 00000000..e70a3313 --- /dev/null +++ b/patches/server/0113-fastutil-CraftingManager.patch @@ -0,0 +1,19 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Mechoriet +Date: Sat, 7 Oct 2023 21:46:27 +0200 +Subject: [PATCH] fastutil - CraftingManager + + +diff --git a/src/main/java/net/minecraft/server/CraftingManager.java b/src/main/java/net/minecraft/server/CraftingManager.java +index 544ff0a6c2ec62911c97fb02aec24d0215188dc3..2d099863b1d77cf5e1dbc6c37a48f517685d1925 100644 +--- a/src/main/java/net/minecraft/server/CraftingManager.java ++++ b/src/main/java/net/minecraft/server/CraftingManager.java +@@ -14,7 +14,7 @@ import org.bukkit.craftbukkit.event.CraftEventFactory; // CraftBukkit + public class CraftingManager { + + private static final CraftingManager a = new CraftingManager(); +- public List recipes = Lists.newArrayList(); ++ public List recipes = new it.unimi.dsi.fastutil.objects.ObjectArrayList<>(); + // CraftBukkit start + public IRecipe lastRecipe; + public org.bukkit.inventory.InventoryView lastCraftView; From 9189c66d3cdc6733c5850ea240c7301c1d205a3a Mon Sep 17 00:00:00 2001 From: Mechoriet Date: Sat, 7 Oct 2023 22:48:48 +0200 Subject: [PATCH 5/8] work work work work --- ...ist-faster-uuid-and-name-lookup-tabl.patch | 147 ++++++++++++++++++ ...layer-more-optimized-entties-checkin.patch | 77 +++++++++ 2 files changed, 224 insertions(+) create mode 100644 patches/server/0114-fastutil-PlayerList-faster-uuid-and-name-lookup-tabl.patch create mode 100644 patches/server/0115-fastutil-EntityPlayer-more-optimized-entties-checkin.patch diff --git a/patches/server/0114-fastutil-PlayerList-faster-uuid-and-name-lookup-tabl.patch b/patches/server/0114-fastutil-PlayerList-faster-uuid-and-name-lookup-tabl.patch new file mode 100644 index 00000000..1cc1dd8c --- /dev/null +++ b/patches/server/0114-fastutil-PlayerList-faster-uuid-and-name-lookup-tabl.patch @@ -0,0 +1,147 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Mechoriet +Date: Sat, 7 Oct 2023 22:32:49 +0200 +Subject: [PATCH] fastutil - PlayerList faster uuid and name lookup tables + + +diff --git a/src/main/java/net/minecraft/server/PlayerList.java b/src/main/java/net/minecraft/server/PlayerList.java +index 905a141d1bc731875fd739dc7ce0171db4cf9779..3c677b8bde482400e6cdb3818ce0a9cd036aece8 100644 +--- a/src/main/java/net/minecraft/server/PlayerList.java ++++ b/src/main/java/net/minecraft/server/PlayerList.java +@@ -49,7 +49,89 @@ public abstract class PlayerList { + private static final SimpleDateFormat g = new SimpleDateFormat("yyyy-MM-dd \'at\' HH:mm:ss z"); + private final MinecraftServer server; + public final List players = new java.util.concurrent.CopyOnWriteArrayList(); // CraftBukkit - ArrayList -> CopyOnWriteArrayList: Iterator safety +- private final Map j = new it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap<>(); ++ public final Map playerMap = new it.unimi.dsi.fastutil.objects.Object2ObjectArrayMap() { ++ ++ private final java.util.concurrent.locks.ReentrantReadWriteLock lock = new java.util.concurrent.locks.ReentrantReadWriteLock(); ++ ++ @Override ++ public EntityPlayer put(String key, EntityPlayer value) { ++ lock.writeLock().lock(); ++ try { ++ return super.put(key.toLowerCase(), value); ++ } finally { ++ lock.writeLock().unlock(); ++ } ++ } ++ ++ @Override ++ public EntityPlayer get(Object key) { ++ lock.readLock().lock(); ++ try { ++ // put the .playerConnection check done in other places here ++ EntityPlayer player = super.get(key instanceof String ? ((String) key).toLowerCase() : key); ++ return (player != null && player.playerConnection != null) ? player : null; ++ } finally { ++ lock.readLock().unlock(); ++ } ++ } ++ ++ @Override ++ public boolean containsKey(Object key) { ++ return get(key) != null; ++ } ++ ++ @Override ++ public EntityPlayer remove(Object key) { ++ lock.writeLock().lock(); ++ try { ++ return super.remove(key instanceof String ? ((String) key).toLowerCase() : key); ++ } finally { ++ lock.writeLock().unlock(); ++ } ++ } ++ }; ++ public final Map uuidMap = new it.unimi.dsi.fastutil.objects.Object2ObjectArrayMap() { ++ ++ private final java.util.concurrent.locks.ReentrantReadWriteLock lock = new java.util.concurrent.locks.ReentrantReadWriteLock(); ++ ++ @Override ++ public EntityPlayer get(Object key) { ++ lock.readLock().lock(); ++ try { ++ // put the .playerConnection check done in other places here ++ EntityPlayer player = super.get(key instanceof String ? ((String) key).toLowerCase() : key); ++ return (player != null && player.playerConnection != null) ? player : null; ++ } finally { ++ lock.readLock().unlock(); ++ } ++ } ++ ++ @Override ++ public EntityPlayer put(UUID key, EntityPlayer value) { ++ lock.writeLock().lock(); ++ try { ++ return super.put(key, value); ++ } finally { ++ lock.writeLock().unlock(); ++ } ++ } ++ ++ @Override ++ public boolean containsKey(Object key) { ++ // WindSpigot - synchronize uuid map ++ return get(key) != null; ++ } ++ ++ @Override ++ public EntityPlayer remove(Object key) { ++ lock.writeLock().lock(); ++ try { ++ return super.remove(key); ++ } finally { ++ lock.writeLock().unlock(); ++ } ++ } ++ }; + private final GameProfileBanList k; + private final IpBanList l; + private final OpList operators; +@@ -304,7 +386,8 @@ public abstract class PlayerList { + public void onPlayerJoin(EntityPlayer entityplayer, String joinMessage) { // CraftBukkit added param + this.players.add(entityplayer); + this.playersByName.put(entityplayer.getName(), entityplayer); // Spigot +- this.j.put(entityplayer.getUniqueID(), entityplayer); ++ this.playerMap.put(entityplayer.getName(), entityplayer); ++ this.uuidMap.put(entityplayer.getUniqueID(), entityplayer); + // this.sendAll(new PacketPlayOutPlayerInfo(PacketPlayOutPlayerInfo.EnumPlayerInfoAction.ADD_PLAYER, new EntityPlayer[] { entityplayer})); // CraftBukkit - replaced with loop below + WorldServer worldserver = this.server.getWorldServer(entityplayer.dimension); + +@@ -381,12 +464,14 @@ public abstract class PlayerList { + worldserver.kill(entityplayer); + worldserver.getPlayerChunkMap().removePlayer(entityplayer); + this.players.remove(entityplayer); ++ this.uuidMap.remove(entityplayer.getUniqueID()); ++ this.playerMap.remove(entityplayer.getName()); + this.playersByName.remove(entityplayer.getName()); // Spigot + UUID uuid = entityplayer.getUniqueID(); +- EntityPlayer entityplayer1 = (EntityPlayer) this.j.get(uuid); ++ EntityPlayer entityplayer1 = this.uuidMap.get(uuid); + + if (entityplayer1 == entityplayer) { +- this.j.remove(uuid); ++ this.playerMap.remove(entityplayer.getName()); + this.o.remove(uuid); + } + +@@ -629,7 +714,8 @@ public abstract class PlayerList { + worldserver.addEntity(entityplayer1); + this.players.add(entityplayer1); + this.playersByName.put(entityplayer1.getName(), entityplayer1); // Spigot +- this.j.put(entityplayer1.getUniqueID(), entityplayer1); ++ this.playerMap.put(entityplayer1.getName(), entityplayer1); ++ this.uuidMap.put(entityplayer1.getUniqueID(), entityplayer1); + } + // Added from changeDimension + updateClient(entityplayer); // Update health, etc... +@@ -1269,7 +1355,7 @@ public abstract class PlayerList { + } + + public EntityPlayer a(UUID uuid) { +- return (EntityPlayer) this.j.get(uuid); ++ return this.uuidMap.get(uuid); + } + + public boolean f(GameProfile gameprofile) { diff --git a/patches/server/0115-fastutil-EntityPlayer-more-optimized-entties-checkin.patch b/patches/server/0115-fastutil-EntityPlayer-more-optimized-entties-checkin.patch new file mode 100644 index 00000000..7ac684ce --- /dev/null +++ b/patches/server/0115-fastutil-EntityPlayer-more-optimized-entties-checkin.patch @@ -0,0 +1,77 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Mechoriet +Date: Sat, 7 Oct 2023 22:43:20 +0200 +Subject: [PATCH] fastutil - EntityPlayer more optimized entties checking + + +diff --git a/src/main/java/net/minecraft/server/EntityPlayer.java b/src/main/java/net/minecraft/server/EntityPlayer.java +index b4f301a3eb660b9bf080c4f6b4e3bbaa3678a8d6..54ead77dbf1ef17121a2068947e5b1018f2fa3b0 100644 +--- a/src/main/java/net/minecraft/server/EntityPlayer.java ++++ b/src/main/java/net/minecraft/server/EntityPlayer.java +@@ -232,9 +232,9 @@ public class EntityPlayer extends EntityHuman implements ICrafting { + } + + if (!this.chunkCoordIntPairQueue.isEmpty()) { +- ArrayList arraylist = Lists.newArrayList(); +- Iterator iterator1 = this.chunkCoordIntPairQueue.iterator(); +- ArrayList arraylist1 = Lists.newArrayList(); ++ ArrayList arraylist = Lists.newArrayList(); ++ Iterator iterator1 = this.chunkCoordIntPairQueue.iterator(); ++ ArrayList arraylist1 = Lists.newArrayList(); + + Chunk chunk; + +@@ -262,20 +262,18 @@ public class EntityPlayer extends EntityHuman implements ICrafting { + } else { + this.playerConnection.sendPacket(new PacketPlayOutMapChunkBulk(arraylist)); + } +- +- Iterator iterator2 = arraylist1.iterator(); +- +- while (iterator2.hasNext()) { +- TileEntity tileentity = (TileEntity) iterator2.next(); +- ++ for (TileEntity tileentity : arraylist1) { + this.a(tileentity); + } ++ it.unimi.dsi.fastutil.longs.LongOpenHashSet chunkPosSet = new it.unimi.dsi.fastutil.longs.LongOpenHashSet(arraylist.size()); ++ for (Chunk newChunk : arraylist) { ++ chunkPosSet.add(this.chunkToLong(newChunk.locX, newChunk.locZ)); ++ } + +- iterator2 = arraylist.iterator(); +- +- while (iterator2.hasNext()) { +- chunk = (Chunk) iterator2.next(); +- this.u().getTracker().a(this, chunk); ++ for (EntityTrackerEntry entitytrackerentry : this.u().getTracker().c) { ++ if (entitytrackerentry.tracker != this && chunkPosSet.contains(this.chunkToLong(entitytrackerentry.tracker.ae, entitytrackerentry.tracker.ag))) { ++ entitytrackerentry.updatePlayer(this); ++ } + } + } + } +@@ -295,7 +293,9 @@ public class EntityPlayer extends EntityHuman implements ICrafting { + } + + } +- ++ private long chunkToLong(int chunkX, int chunkZ) { ++ return (chunkX << 32L) + chunkZ - -2147483648L; ++ } + public void l() { + try { + super.t_(); +diff --git a/src/main/java/net/minecraft/server/EntityTracker.java b/src/main/java/net/minecraft/server/EntityTracker.java +index d3afb43259dc34a63c561266efbf7e5050d9d213..7a6bd624cfe4a1e58155e0498f6d6c6387465db1 100644 +--- a/src/main/java/net/minecraft/server/EntityTracker.java ++++ b/src/main/java/net/minecraft/server/EntityTracker.java +@@ -13,7 +13,7 @@ public class EntityTracker { + + private static final Logger a = LogManager.getLogger(); + private final WorldServer world; +- private Set c = new io.papermc.paper.util.maplist.ObjectMapList<>(); // PandaSpigot - FastUtil - ObjectMapList ++ public Set c = new io.papermc.paper.util.maplist.ObjectMapList<>(); // PandaSpigot - FastUtil - ObjectMapList + public IntHashMap trackedEntities = new IntHashMap(); + private int e; + From 41ea2e93ef6dd7e5e60cd8010c000f8ae375916d Mon Sep 17 00:00:00 2001 From: Mechoriet Date: Sun, 8 Oct 2023 23:46:24 +0200 Subject: [PATCH 6/8] work work work work work --- ...-PlayerList-Object2ObjectOpenHashMap.patch | 19 ------------------- ... => 0101-fastutil-add-ObjectMapList.patch} | 0 ...atch => 0102-fastutil-EntityTracker.patch} | 0 ...ObjectMapList-in-Chunk-EntitySlices.patch} | 0 ...tch => 0104-fastutil-PlayerChunkMap.patch} | 0 ...-World.patch => 0105-fastutil-World.patch} | 0 ...tch => 0106-fastutil-NBTTagCompound.patch} | 0 ....patch => 0107-fastutil-HashTreeSet.patch} | 0 ....patch => 0108-fastutil-DataWatcher.patch} | 0 ... => 0109-fastutil-HandshakeListener.patch} | 0 ...> 0110-fastutil-ChunkProviderServer.patch} | 0 ...ch => 0111-fastutil-SpawnerCreature.patch} | 0 ...ch => 0112-fastutil-CraftingManager.patch} | 0 ...st-faster-uuid-and-name-lookup-tabl.patch} | 4 ++-- ...ayer-more-optimized-entties-checkin.patch} | 0 ...0115-fixup-Add-packet-limiter-config.patch | 19 +++++++++++++++++++ 16 files changed, 21 insertions(+), 21 deletions(-) delete mode 100644 patches/server/0101-fastutil-PlayerList-Object2ObjectOpenHashMap.patch rename patches/server/{0102-fastutil-add-ObjectMapList.patch => 0101-fastutil-add-ObjectMapList.patch} (100%) rename patches/server/{0103-fastutil-EntityTracker.patch => 0102-fastutil-EntityTracker.patch} (100%) rename patches/server/{0104-fastutil-use-ObjectMapList-in-Chunk-EntitySlices.patch => 0103-fastutil-use-ObjectMapList-in-Chunk-EntitySlices.patch} (100%) rename patches/server/{0105-fastutil-PlayerChunkMap.patch => 0104-fastutil-PlayerChunkMap.patch} (100%) rename patches/server/{0106-fastutil-World.patch => 0105-fastutil-World.patch} (100%) rename patches/server/{0107-fastutil-NBTTagCompound.patch => 0106-fastutil-NBTTagCompound.patch} (100%) rename patches/server/{0108-fastutil-HashTreeSet.patch => 0107-fastutil-HashTreeSet.patch} (100%) rename patches/server/{0109-fastutil-DataWatcher.patch => 0108-fastutil-DataWatcher.patch} (100%) rename patches/server/{0110-fastutil-HandshakeListener.patch => 0109-fastutil-HandshakeListener.patch} (100%) rename patches/server/{0111-fastutil-ChunkProviderServer.patch => 0110-fastutil-ChunkProviderServer.patch} (100%) rename patches/server/{0112-fastutil-SpawnerCreature.patch => 0111-fastutil-SpawnerCreature.patch} (100%) rename patches/server/{0113-fastutil-CraftingManager.patch => 0112-fastutil-CraftingManager.patch} (100%) rename patches/server/{0114-fastutil-PlayerList-faster-uuid-and-name-lookup-tabl.patch => 0113-fastutil-PlayerList-faster-uuid-and-name-lookup-tabl.patch} (97%) rename patches/server/{0115-fastutil-EntityPlayer-more-optimized-entties-checkin.patch => 0114-fastutil-EntityPlayer-more-optimized-entties-checkin.patch} (100%) create mode 100644 patches/server/0115-fixup-Add-packet-limiter-config.patch diff --git a/patches/server/0101-fastutil-PlayerList-Object2ObjectOpenHashMap.patch b/patches/server/0101-fastutil-PlayerList-Object2ObjectOpenHashMap.patch deleted file mode 100644 index a128c7b6..00000000 --- a/patches/server/0101-fastutil-PlayerList-Object2ObjectOpenHashMap.patch +++ /dev/null @@ -1,19 +0,0 @@ -From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 -From: Mechoriet -Date: Sat, 7 Oct 2023 17:28:45 +0200 -Subject: [PATCH] fastutil - PlayerList - Object2ObjectOpenHashMap - - -diff --git a/src/main/java/net/minecraft/server/PlayerList.java b/src/main/java/net/minecraft/server/PlayerList.java -index ada9cf25b091c2df24301bb5e82d1f76fbd929e5..905a141d1bc731875fd739dc7ce0171db4cf9779 100644 ---- a/src/main/java/net/minecraft/server/PlayerList.java -+++ b/src/main/java/net/minecraft/server/PlayerList.java -@@ -49,7 +49,7 @@ public abstract class PlayerList { - private static final SimpleDateFormat g = new SimpleDateFormat("yyyy-MM-dd \'at\' HH:mm:ss z"); - private final MinecraftServer server; - public final List players = new java.util.concurrent.CopyOnWriteArrayList(); // CraftBukkit - ArrayList -> CopyOnWriteArrayList: Iterator safety -- private final Map j = Maps.newHashMap(); -+ private final Map j = new it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap<>(); - private final GameProfileBanList k; - private final IpBanList l; - private final OpList operators; diff --git a/patches/server/0102-fastutil-add-ObjectMapList.patch b/patches/server/0101-fastutil-add-ObjectMapList.patch similarity index 100% rename from patches/server/0102-fastutil-add-ObjectMapList.patch rename to patches/server/0101-fastutil-add-ObjectMapList.patch diff --git a/patches/server/0103-fastutil-EntityTracker.patch b/patches/server/0102-fastutil-EntityTracker.patch similarity index 100% rename from patches/server/0103-fastutil-EntityTracker.patch rename to patches/server/0102-fastutil-EntityTracker.patch diff --git a/patches/server/0104-fastutil-use-ObjectMapList-in-Chunk-EntitySlices.patch b/patches/server/0103-fastutil-use-ObjectMapList-in-Chunk-EntitySlices.patch similarity index 100% rename from patches/server/0104-fastutil-use-ObjectMapList-in-Chunk-EntitySlices.patch rename to patches/server/0103-fastutil-use-ObjectMapList-in-Chunk-EntitySlices.patch diff --git a/patches/server/0105-fastutil-PlayerChunkMap.patch b/patches/server/0104-fastutil-PlayerChunkMap.patch similarity index 100% rename from patches/server/0105-fastutil-PlayerChunkMap.patch rename to patches/server/0104-fastutil-PlayerChunkMap.patch diff --git a/patches/server/0106-fastutil-World.patch b/patches/server/0105-fastutil-World.patch similarity index 100% rename from patches/server/0106-fastutil-World.patch rename to patches/server/0105-fastutil-World.patch diff --git a/patches/server/0107-fastutil-NBTTagCompound.patch b/patches/server/0106-fastutil-NBTTagCompound.patch similarity index 100% rename from patches/server/0107-fastutil-NBTTagCompound.patch rename to patches/server/0106-fastutil-NBTTagCompound.patch diff --git a/patches/server/0108-fastutil-HashTreeSet.patch b/patches/server/0107-fastutil-HashTreeSet.patch similarity index 100% rename from patches/server/0108-fastutil-HashTreeSet.patch rename to patches/server/0107-fastutil-HashTreeSet.patch diff --git a/patches/server/0109-fastutil-DataWatcher.patch b/patches/server/0108-fastutil-DataWatcher.patch similarity index 100% rename from patches/server/0109-fastutil-DataWatcher.patch rename to patches/server/0108-fastutil-DataWatcher.patch diff --git a/patches/server/0110-fastutil-HandshakeListener.patch b/patches/server/0109-fastutil-HandshakeListener.patch similarity index 100% rename from patches/server/0110-fastutil-HandshakeListener.patch rename to patches/server/0109-fastutil-HandshakeListener.patch diff --git a/patches/server/0111-fastutil-ChunkProviderServer.patch b/patches/server/0110-fastutil-ChunkProviderServer.patch similarity index 100% rename from patches/server/0111-fastutil-ChunkProviderServer.patch rename to patches/server/0110-fastutil-ChunkProviderServer.patch diff --git a/patches/server/0112-fastutil-SpawnerCreature.patch b/patches/server/0111-fastutil-SpawnerCreature.patch similarity index 100% rename from patches/server/0112-fastutil-SpawnerCreature.patch rename to patches/server/0111-fastutil-SpawnerCreature.patch diff --git a/patches/server/0113-fastutil-CraftingManager.patch b/patches/server/0112-fastutil-CraftingManager.patch similarity index 100% rename from patches/server/0113-fastutil-CraftingManager.patch rename to patches/server/0112-fastutil-CraftingManager.patch diff --git a/patches/server/0114-fastutil-PlayerList-faster-uuid-and-name-lookup-tabl.patch b/patches/server/0113-fastutil-PlayerList-faster-uuid-and-name-lookup-tabl.patch similarity index 97% rename from patches/server/0114-fastutil-PlayerList-faster-uuid-and-name-lookup-tabl.patch rename to patches/server/0113-fastutil-PlayerList-faster-uuid-and-name-lookup-tabl.patch index 1cc1dd8c..1265185d 100644 --- a/patches/server/0114-fastutil-PlayerList-faster-uuid-and-name-lookup-tabl.patch +++ b/patches/server/0113-fastutil-PlayerList-faster-uuid-and-name-lookup-tabl.patch @@ -5,14 +5,14 @@ Subject: [PATCH] fastutil - PlayerList faster uuid and name lookup tables diff --git a/src/main/java/net/minecraft/server/PlayerList.java b/src/main/java/net/minecraft/server/PlayerList.java -index 905a141d1bc731875fd739dc7ce0171db4cf9779..3c677b8bde482400e6cdb3818ce0a9cd036aece8 100644 +index ada9cf25b091c2df24301bb5e82d1f76fbd929e5..3c677b8bde482400e6cdb3818ce0a9cd036aece8 100644 --- a/src/main/java/net/minecraft/server/PlayerList.java +++ b/src/main/java/net/minecraft/server/PlayerList.java @@ -49,7 +49,89 @@ public abstract class PlayerList { private static final SimpleDateFormat g = new SimpleDateFormat("yyyy-MM-dd \'at\' HH:mm:ss z"); private final MinecraftServer server; public final List players = new java.util.concurrent.CopyOnWriteArrayList(); // CraftBukkit - ArrayList -> CopyOnWriteArrayList: Iterator safety -- private final Map j = new it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap<>(); +- private final Map j = Maps.newHashMap(); + public final Map playerMap = new it.unimi.dsi.fastutil.objects.Object2ObjectArrayMap() { + + private final java.util.concurrent.locks.ReentrantReadWriteLock lock = new java.util.concurrent.locks.ReentrantReadWriteLock(); diff --git a/patches/server/0115-fastutil-EntityPlayer-more-optimized-entties-checkin.patch b/patches/server/0114-fastutil-EntityPlayer-more-optimized-entties-checkin.patch similarity index 100% rename from patches/server/0115-fastutil-EntityPlayer-more-optimized-entties-checkin.patch rename to patches/server/0114-fastutil-EntityPlayer-more-optimized-entties-checkin.patch diff --git a/patches/server/0115-fixup-Add-packet-limiter-config.patch b/patches/server/0115-fixup-Add-packet-limiter-config.patch new file mode 100644 index 00000000..ce4cd616 --- /dev/null +++ b/patches/server/0115-fixup-Add-packet-limiter-config.patch @@ -0,0 +1,19 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Mechoriet +Date: Sat, 7 Oct 2023 23:26:59 +0200 +Subject: [PATCH] fixup! Add packet limiter config + + +diff --git a/src/main/java/net/minecraft/server/NetworkManager.java b/src/main/java/net/minecraft/server/NetworkManager.java +index 5c631068db79615bf51ed357bc9bda2b0ebb0c3b..87ecc1b9a46bfcc146b7b42f142cac46c02faa9c 100644 +--- a/src/main/java/net/minecraft/server/NetworkManager.java ++++ b/src/main/java/net/minecraft/server/NetworkManager.java +@@ -126,7 +126,7 @@ public class NetworkManager extends SimpleChannelInboundHandler { + this.close(reason[0]); + this.k(); + this.stopReadingPackets = true; +- }, null); ++ }, (GenericFutureListener>) null); + } + // PandaSpigot end - packet limiter + public NetworkManager(EnumProtocolDirection enumprotocoldirection) { From ee5cc6fa083485dd2e3e4e3e576645d9c2d9043c Mon Sep 17 00:00:00 2001 From: Mechoriet Date: Mon, 9 Oct 2023 00:21:51 +0200 Subject: [PATCH 7/8] work work work work work work --- patches/server/0003-Setup-Gradle-project.patch | 9 +++++---- patches/server/0102-fastutil-EntityTracker.patch | 4 ++-- ...use-ObjectMapList-in-Chunk-EntitySlices.patch | 4 ++-- .../server/0104-fastutil-PlayerChunkMap.patch | 8 ++++---- patches/server/0105-fastutil-World.patch | 8 ++++---- patches/server/0107-fastutil-HashTreeSet.patch | 4 ++-- patches/server/0108-fastutil-DataWatcher.patch | 16 ++++++++-------- .../server/0109-fastutil-HandshakeListener.patch | 4 ++-- .../0110-fastutil-ChunkProviderServer.patch | 4 ++-- .../server/0112-fastutil-CraftingManager.patch | 4 ++-- ...tyPlayer-more-optimized-entties-checkin.patch | 4 ++-- ...15-tempfixup-Add-packet-limiter-config.patch} | 2 +- 12 files changed, 36 insertions(+), 35 deletions(-) rename patches/server/{0115-fixup-Add-packet-limiter-config.patch => 0115-tempfixup-Add-packet-limiter-config.patch} (94%) diff --git a/patches/server/0003-Setup-Gradle-project.patch b/patches/server/0003-Setup-Gradle-project.patch index 1467078e..68bb5db6 100644 --- a/patches/server/0003-Setup-Gradle-project.patch +++ b/patches/server/0003-Setup-Gradle-project.patch @@ -6,10 +6,10 @@ Subject: [PATCH] Setup Gradle project diff --git a/build.gradle.kts b/build.gradle.kts new file mode 100644 -index 0000000000000000000000000000000000000000..8fa745439919255e4b6598b1f9a162c8e18e5f87 +index 0000000000000000000000000000000000000000..7a4dbe3923dc2a001f57e35fe6a6e94083769c65 --- /dev/null +++ b/build.gradle.kts -@@ -0,0 +1,115 @@ +@@ -0,0 +1,116 @@ +plugins { + id("pandaspigot.conventions") + id("com.github.johnrengelman.shadow") version "7.1.2" @@ -112,16 +112,17 @@ index 0000000000000000000000000000000000000000..8fa745439919255e4b6598b1f9a162c8 + ) + } + } -+ ++ var jvmargs = listOf("-Xms1G", "-Xmx1G", "-XX:+UseG1GC", "-XX:+ParallelRefProcEnabled", "-XX:MaxGCPauseMillis=200", "-XX:+UnlockExperimentalVMOptions", "-XX:+DisableExplicitGC", "-XX:+AlwaysPreTouch", "-XX:G1NewSizePercent=30", "-XX:G1MaxNewSizePercent=40", "-XX:G1HeapRegionSize=8M", "-XX:G1ReservePercent=20", "-XX:G1HeapWastePercent=5", "-XX:G1MixedGCCountTarget=4", "-XX:InitiatingHeapOccupancyPercent=15", "-XX:G1MixedGCLiveThresholdPercent=90", "-XX:G1RSetUpdatingPauseTimePercent=5", "-XX:SurvivorRatio=32", "-XX:+PerfDisableSharedMem", "-XX:MaxTenuringThreshold=1", "-Dusing.aikars.flags=https://mcflags.emc.gs", "-Daikars.new.flags=true") + registerRunTask("runShadow") { + description = "Spin up a test server from the shadowJar archiveFile" ++ jvmArgs = jvmargs + classpath(shadowJar.flatMap { it.archiveFile }) + } + + registerRunTask("runDev") { + description = "Spin up a non-shaded non-relocated test server" + classpath = java.sourceSets.main.get().runtimeClasspath -+ jvmArgs = listOf("-Xms1G", "-Xmx1G", "-XX:+UseG1GC", "-XX:+ParallelRefProcEnabled", "-XX:MaxGCPauseMillis=200", "-XX:+UnlockExperimentalVMOptions", "-XX:+DisableExplicitGC", "-XX:+AlwaysPreTouch", "-XX:G1NewSizePercent=30", "-XX:G1MaxNewSizePercent=40", "-XX:G1HeapRegionSize=8M", "-XX:G1ReservePercent=20", "-XX:G1HeapWastePercent=5", "-XX:G1MixedGCCountTarget=4", "-XX:InitiatingHeapOccupancyPercent=15", "-XX:G1MixedGCLiveThresholdPercent=90", "-XX:G1RSetUpdatingPauseTimePercent=5", "-XX:SurvivorRatio=32", "-XX:+PerfDisableSharedMem", "-XX:MaxTenuringThreshold=1", "-Dusing.aikars.flags=https://mcflags.emc.gs", "-Daikars.new.flags=true") ++ jvmArgs = jvmargs + mainClass.set("org.bukkit.craftbukkit.Main") + } +} diff --git a/patches/server/0102-fastutil-EntityTracker.patch b/patches/server/0102-fastutil-EntityTracker.patch index 638919f9..b00495e0 100644 --- a/patches/server/0102-fastutil-EntityTracker.patch +++ b/patches/server/0102-fastutil-EntityTracker.patch @@ -18,7 +18,7 @@ index cb72b36725927272fddfdad929b268a7b06140ac..d3afb43259dc34a63c561266efbf7e50 private int e; diff --git a/src/main/java/net/minecraft/server/EntityTrackerEntry.java b/src/main/java/net/minecraft/server/EntityTrackerEntry.java -index 0b90b6f30ea09fb117281d5ddd2fc752d2c139b5..91e72f4fe98a4d83c5f886e86c945c602eb1454a 100644 +index 0b90b6f30ea09fb117281d5ddd2fc752d2c139b5..108043d6460374d64a6c1fcfb9e1aab5a4024733 100644 --- a/src/main/java/net/minecraft/server/EntityTrackerEntry.java +++ b/src/main/java/net/minecraft/server/EntityTrackerEntry.java @@ -42,7 +42,7 @@ public class EntityTrackerEntry { @@ -26,7 +26,7 @@ index 0b90b6f30ea09fb117281d5ddd2fc752d2c139b5..91e72f4fe98a4d83c5f886e86c945c60 // Replace trackedPlayers Set with a Map. The value is true until the player receives // their first update (which is forced to have absolute coordinates), false afterward. - public java.util.Map trackedPlayerMap = new java.util.HashMap(); -+ public java.util.Map trackedPlayerMap = new it.unimi.dsi.fastutil.objects.Reference2BooleanOpenHashMap<>(); ++ public java.util.Map trackedPlayerMap = new it.unimi.dsi.fastutil.objects.Reference2BooleanOpenHashMap<>(); // PandaSpigot - HashMap -> Reference2BooleanOpenHashMap public Set trackedPlayers = trackedPlayerMap.keySet(); // PaperSpigot end diff --git a/patches/server/0103-fastutil-use-ObjectMapList-in-Chunk-EntitySlices.patch b/patches/server/0103-fastutil-use-ObjectMapList-in-Chunk-EntitySlices.patch index 796f6eac..fb9c430b 100644 --- a/patches/server/0103-fastutil-use-ObjectMapList-in-Chunk-EntitySlices.patch +++ b/patches/server/0103-fastutil-use-ObjectMapList-in-Chunk-EntitySlices.patch @@ -5,7 +5,7 @@ Subject: [PATCH] fastutil - use ObjectMapList in Chunk EntitySlices diff --git a/src/main/java/net/minecraft/server/Chunk.java b/src/main/java/net/minecraft/server/Chunk.java -index 3cb8d99311e2fa9a4a1173f6ef9e8dee957b20fa..25669f6ebd1075573385c77d7644910cb00ad970 100644 +index 3cb8d99311e2fa9a4a1173f6ef9e8dee957b20fa..4107f2ab945cc1f1ae428493341f5c65f1b56daa 100644 --- a/src/main/java/net/minecraft/server/Chunk.java +++ b/src/main/java/net/minecraft/server/Chunk.java @@ -146,7 +146,7 @@ public class Chunk { @@ -13,7 +13,7 @@ index 3cb8d99311e2fa9a4a1173f6ef9e8dee957b20fa..25669f6ebd1075573385c77d7644910c for (int k = 0; k < this.entitySlices.length; ++k) { - this.entitySlices[k] = new org.bukkit.craftbukkit.util.UnsafeList(); // Spigot -+ this.entitySlices[k] = new io.papermc.paper.util.maplist.ObjectMapList<>(); // PandaSpigot - Fastutil ObjectMapList ++ this.entitySlices[k] = new io.papermc.paper.util.maplist.ObjectMapList<>(); // PandaSpigot - UnsafeList -> ObjectMapList } Arrays.fill(this.f, -999); diff --git a/patches/server/0104-fastutil-PlayerChunkMap.patch b/patches/server/0104-fastutil-PlayerChunkMap.patch index b60737dc..2c9d47ef 100644 --- a/patches/server/0104-fastutil-PlayerChunkMap.patch +++ b/patches/server/0104-fastutil-PlayerChunkMap.patch @@ -5,7 +5,7 @@ Subject: [PATCH] fastutil - PlayerChunkMap diff --git a/src/main/java/net/minecraft/server/PlayerChunkMap.java b/src/main/java/net/minecraft/server/PlayerChunkMap.java -index 696edfe83aa6c75deaaa59cc10818dbf261cc5a9..22d0c03b3e9ff37d182f0a7194c946d03abc4b91 100644 +index 696edfe83aa6c75deaaa59cc10818dbf261cc5a9..600c75e86db444b1f31e245a729d22365d5b222b 100644 --- a/src/main/java/net/minecraft/server/PlayerChunkMap.java +++ b/src/main/java/net/minecraft/server/PlayerChunkMap.java @@ -19,7 +19,7 @@ public class PlayerChunkMap { @@ -13,7 +13,7 @@ index 696edfe83aa6c75deaaa59cc10818dbf261cc5a9..22d0c03b3e9ff37d182f0a7194c946d0 private static final Logger a = LogManager.getLogger(); private final WorldServer world; - private final List managedPlayers = Lists.newArrayList(); -+ private final List managedPlayers = new it.unimi.dsi.fastutil.objects.ObjectArrayList<>(); // PandaSpigot - fastutil - ObjectArrayList ++ private final List managedPlayers = new it.unimi.dsi.fastutil.objects.ObjectArrayList<>(); // PandaSpigot - ArrayList -> ObjectArrayList private final LongHashMap d = new LongHashMap(); private final Queue e = new java.util.concurrent.ConcurrentLinkedQueue(); // CraftBukkit ArrayList -> ConcurrentLinkedQueue private final Queue f = new java.util.concurrent.ConcurrentLinkedQueue(); // CraftBukkit ArrayList -> ConcurrentLinkedQueue @@ -22,7 +22,7 @@ index 696edfe83aa6c75deaaa59cc10818dbf261cc5a9..22d0c03b3e9ff37d182f0a7194c946d0 class PlayerChunk { - private final List b = Lists.newArrayList(); -+ private final List b = new it.unimi.dsi.fastutil.objects.ObjectArrayList<>(); // PandaSpigot - fastutil - ObjectArrayList ++ private final List b = new it.unimi.dsi.fastutil.objects.ObjectArrayList<>(); // PandaSpigot - ArrayList -> ObjectArrayList private final ChunkCoordIntPair location; private short[] dirtyBlocks = new short[64]; private int dirtyCount; @@ -31,7 +31,7 @@ index 696edfe83aa6c75deaaa59cc10818dbf261cc5a9..22d0c03b3e9ff37d182f0a7194c946d0 // CraftBukkit start - add fields - private final HashMap players = new HashMap(); -+ private final java.util.Map players = new it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap<>(); // Pandaspigot - fastutil - Object2ObjectOpenHashMAp ++ private final java.util.Map players = new it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap<>(); // Pandaspigot - HashMap -> Object2ObjectOpenHashMAp private boolean loaded = false; private Runnable loadedRunnable = new Runnable() { public void run() { diff --git a/patches/server/0105-fastutil-World.patch b/patches/server/0105-fastutil-World.patch index f75c73d7..ebd9d4df 100644 --- a/patches/server/0105-fastutil-World.patch +++ b/patches/server/0105-fastutil-World.patch @@ -5,7 +5,7 @@ Subject: [PATCH] fastutil - World diff --git a/src/main/java/net/minecraft/server/World.java b/src/main/java/net/minecraft/server/World.java -index 38ebe35f6fa434103b52e86262c7f4cc32d486e3..560b15ee0d932f30161915be21425c97d4ba656d 100644 +index 38ebe35f6fa434103b52e86262c7f4cc32d486e3..599b496acfd7ba727a4948ff18ada7614bb74e08 100644 --- a/src/main/java/net/minecraft/server/World.java +++ b/src/main/java/net/minecraft/server/World.java @@ -36,7 +36,7 @@ public abstract class World implements IBlockAccess { @@ -13,7 +13,7 @@ index 38ebe35f6fa434103b52e86262c7f4cc32d486e3..560b15ee0d932f30161915be21425c97 protected boolean e; // Spigot start - guard entity list from removals - public final List entityList = new java.util.ArrayList() -+ public final List entityList = new it.unimi.dsi.fastutil.objects.ObjectArrayList() ++ public final List entityList = new it.unimi.dsi.fastutil.objects.ObjectArrayList() // PandaSpigot ArrayList -> ObjectArrayList { @Override public Entity remove(int index) @@ -23,8 +23,8 @@ index 38ebe35f6fa434103b52e86262c7f4cc32d486e3..560b15ee0d932f30161915be21425c97 private final Set c = Sets.newHashSet(); // Paper - public final List players = Lists.newArrayList(); - public final List k = Lists.newArrayList(); -+ public final List players = new it.unimi.dsi.fastutil.objects.ObjectArrayList<>(); // PandaSpigot - fastutil - ObjectArrayList -+ public final List k = new it.unimi.dsi.fastutil.objects.ObjectArrayList<>(); // PandaSpigot - fastutil - ObjectArrayList ++ public final List players = new it.unimi.dsi.fastutil.objects.ObjectArrayList<>(); // PandaSpigot - ArrayList -> ObjectArrayList ++ public final List k = new it.unimi.dsi.fastutil.objects.ObjectArrayList<>(); // PandaSpigot - ArrayList -> ObjectArrayList protected final IntHashMap entitiesById = new IntHashMap(); private long d = 16777215L; private int I; diff --git a/patches/server/0107-fastutil-HashTreeSet.patch b/patches/server/0107-fastutil-HashTreeSet.patch index aa67ef68..34657c0e 100644 --- a/patches/server/0107-fastutil-HashTreeSet.patch +++ b/patches/server/0107-fastutil-HashTreeSet.patch @@ -5,7 +5,7 @@ Subject: [PATCH] fastutil - HashTreeSet diff --git a/src/main/java/org/bukkit/craftbukkit/util/HashTreeSet.java b/src/main/java/org/bukkit/craftbukkit/util/HashTreeSet.java -index 80a5c29f3b9f0e6ccb2acb01a6be3726d6b368b3..70430f5dd8139384eaec1246af159f6d254c7de3 100644 +index 80a5c29f3b9f0e6ccb2acb01a6be3726d6b368b3..2a1ab9d3a3675acaaacb6c257cbe0beed415efce 100644 --- a/src/main/java/org/bukkit/craftbukkit/util/HashTreeSet.java +++ b/src/main/java/org/bukkit/craftbukkit/util/HashTreeSet.java @@ -8,7 +8,7 @@ import java.util.TreeSet; @@ -13,7 +13,7 @@ index 80a5c29f3b9f0e6ccb2acb01a6be3726d6b368b3..70430f5dd8139384eaec1246af159f6d public class HashTreeSet implements Set { - private HashSet hash = new HashSet(); -+ private Set hash = new it.unimi.dsi.fastutil.objects.ObjectOpenHashSet<>(); // PandaSpigot - Replace java.util.HashSet with ObjectOpenHashSet ++ private Set hash = new it.unimi.dsi.fastutil.objects.ObjectOpenHashSet<>(); // PandaSpigot - HashSet -> ObjectOpenHashSet private TreeSet tree = new TreeSet(); public HashTreeSet() { diff --git a/patches/server/0108-fastutil-DataWatcher.patch b/patches/server/0108-fastutil-DataWatcher.patch index 6883bd54..76110601 100644 --- a/patches/server/0108-fastutil-DataWatcher.patch +++ b/patches/server/0108-fastutil-DataWatcher.patch @@ -5,7 +5,7 @@ Subject: [PATCH] fastutil - DataWatcher diff --git a/src/main/java/net/minecraft/server/DataWatcher.java b/src/main/java/net/minecraft/server/DataWatcher.java -index 518e8f379d690b1f1b4d2374c875dd3dae22360e..42909eddbb1984966d910cab2c3e3889472f4749 100644 +index 518e8f379d690b1f1b4d2374c875dd3dae22360e..ca88b6ab6d3fac8ae30659555559d12fdee272b9 100644 --- a/src/main/java/net/minecraft/server/DataWatcher.java +++ b/src/main/java/net/minecraft/server/DataWatcher.java @@ -16,11 +16,11 @@ public class DataWatcher { @@ -14,13 +14,13 @@ index 518e8f379d690b1f1b4d2374c875dd3dae22360e..42909eddbb1984966d910cab2c3e3889 // Spigot Start - private static final gnu.trove.map.TObjectIntMap classToId = new gnu.trove.map.hash.TObjectIntHashMap( 10, 0.5f, -1 ); - private final gnu.trove.map.TIntObjectMap dataValues = new gnu.trove.map.hash.TIntObjectHashMap( 10, 0.5f, -1 ); -+ private static final it.unimi.dsi.fastutil.objects.Object2IntMap> classToId = new it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap<>(10, 0.5f); -+ private final it.unimi.dsi.fastutil.ints.Int2ObjectMap dataValues = new it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap<>( 10, 0.5f); ++ private static final it.unimi.dsi.fastutil.objects.Object2IntMap> classToId = new it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap<>(10, 0.5f); // Pandaspigot TObjectIntHashMap -> Object2IntOpenHashMap ++ private final it.unimi.dsi.fastutil.ints.Int2ObjectMap dataValues = new it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap<>( 10, 0.5f);// Pandaspigot TIntObjectHashMap -> Int2ObjectOpenHashMap // These exist as an attempt at backwards compatability for (broken) NMS plugins - private static final Map, Integer> c = gnu.trove.TDecorators.wrap( classToId ); - private final Map d = gnu.trove.TDecorators.wrap( dataValues ); -+ private static final Map, Integer> c = classToId; -+ private final Map d = dataValues; ++ private static final Map, Integer> c = classToId; // Pandaspigot ++ private final Map d = dataValues; // Pandaspigot // Spigot End private boolean e; // private ReadWriteLock f = new ReentrantReadWriteLock(); // PandaSpigot - Remove DataWatcher Locking @@ -29,7 +29,7 @@ index 518e8f379d690b1f1b4d2374c875dd3dae22360e..42909eddbb1984966d910cab2c3e3889 if (this.e) { // this.f.readLock().lock(); // PandaSpigot - Iterator iterator = this.dataValues.valueCollection().iterator(); // Spigot -+ Iterator iterator = this.dataValues.values().iterator(); // Spigot ++ Iterator iterator = this.dataValues.values().iterator(); // Spigot // Pandaspigot while (iterator.hasNext()) { DataWatcher.WatchableObject datawatcher_watchableobject = (DataWatcher.WatchableObject) iterator.next(); @@ -38,7 +38,7 @@ index 518e8f379d690b1f1b4d2374c875dd3dae22360e..42909eddbb1984966d910cab2c3e3889 public void a(PacketDataSerializer packetdataserializer) throws IOException { // this.f.readLock().lock(); // PandaSpigot - Iterator iterator = this.dataValues.valueCollection().iterator(); // Spigot -+ Iterator iterator = this.dataValues.values().iterator(); // Spigot ++ Iterator iterator = this.dataValues.values().iterator(); // Spigot // Pandaspigot while (iterator.hasNext()) { DataWatcher.WatchableObject datawatcher_watchableobject = (DataWatcher.WatchableObject) iterator.next(); @@ -47,7 +47,7 @@ index 518e8f379d690b1f1b4d2374c875dd3dae22360e..42909eddbb1984966d910cab2c3e3889 // this.f.readLock().lock(); // PandaSpigot - arraylist.addAll(this.dataValues.valueCollection()); // Spigot -+ arraylist.addAll(this.dataValues.values()); // Spigot ++ arraylist.addAll(this.dataValues.values()); // Spigot // Pandaspigot // Spigot start - copy ItemStacks to prevent ConcurrentModificationExceptions for ( int i = 0; i < arraylist.size(); i++ ) { diff --git a/patches/server/0109-fastutil-HandshakeListener.patch b/patches/server/0109-fastutil-HandshakeListener.patch index 21c8c7be..98df576f 100644 --- a/patches/server/0109-fastutil-HandshakeListener.patch +++ b/patches/server/0109-fastutil-HandshakeListener.patch @@ -5,7 +5,7 @@ Subject: [PATCH] fastutil - HandshakeListener diff --git a/src/main/java/net/minecraft/server/HandshakeListener.java b/src/main/java/net/minecraft/server/HandshakeListener.java -index 10a8c440f08535d90d8d1204a23c859ba296aa39..ef1a07a6d9667f7fd94f0f6596c4963ad5f0dd54 100644 +index 10a8c440f08535d90d8d1204a23c859ba296aa39..9fedebc490273994352f9f024d1e789a06215a78 100644 --- a/src/main/java/net/minecraft/server/HandshakeListener.java +++ b/src/main/java/net/minecraft/server/HandshakeListener.java @@ -9,7 +9,7 @@ public class HandshakeListener implements PacketHandshakingInListener { @@ -13,7 +13,7 @@ index 10a8c440f08535d90d8d1204a23c859ba296aa39..ef1a07a6d9667f7fd94f0f6596c4963a private static final com.google.gson.Gson gson = new com.google.gson.Gson(); // Spigot // CraftBukkit start - add fields - private static final HashMap throttleTracker = new HashMap(); -+ private static final java.util.Map throttleTracker = new it.unimi.dsi.fastutil.objects.Object2LongOpenHashMap<>(); ++ private static final java.util.Map throttleTracker = new it.unimi.dsi.fastutil.objects.Object2LongOpenHashMap<>(); // PandaSpigot HashMap -> Object2LongOpenHashMap private static int throttleCounter = 0; // CraftBukkit end diff --git a/patches/server/0110-fastutil-ChunkProviderServer.patch b/patches/server/0110-fastutil-ChunkProviderServer.patch index b87d35f5..c0f00c78 100644 --- a/patches/server/0110-fastutil-ChunkProviderServer.patch +++ b/patches/server/0110-fastutil-ChunkProviderServer.patch @@ -5,7 +5,7 @@ Subject: [PATCH] fastutil - ChunkProviderServer diff --git a/src/main/java/net/minecraft/server/ChunkProviderServer.java b/src/main/java/net/minecraft/server/ChunkProviderServer.java -index 7085cb503db3e1e585417ce4300c6be075c7d2fe..079e8e29cc34e41eb932d6d90f8b775164a45251 100644 +index 7085cb503db3e1e585417ce4300c6be075c7d2fe..15dff439f1e2caf6881612a5c629d65a6c2b5734 100644 --- a/src/main/java/net/minecraft/server/ChunkProviderServer.java +++ b/src/main/java/net/minecraft/server/ChunkProviderServer.java @@ -34,7 +34,7 @@ public class ChunkProviderServer implements IChunkProvider { @@ -13,7 +13,7 @@ index 7085cb503db3e1e585417ce4300c6be075c7d2fe..079e8e29cc34e41eb932d6d90f8b7751 private IChunkLoader chunkLoader; public boolean forceChunkLoad = false; // CraftBukkit - true -> false - public LongObjectHashMap chunks = new LongObjectHashMap(); -+ public it.unimi.dsi.fastutil.longs.Long2ObjectMap chunks = new it.unimi.dsi.fastutil.longs.Long2ObjectOpenHashMap<>(4096, 0.5f); ++ public it.unimi.dsi.fastutil.longs.Long2ObjectMap chunks = new it.unimi.dsi.fastutil.longs.Long2ObjectOpenHashMap<>(4096, 0.5f); // PandaSpigot LongObjectHashMap -> Long2ObjectOpenHashMap public WorldServer world; public ChunkProviderServer(WorldServer worldserver, IChunkLoader ichunkloader, IChunkProvider ichunkprovider) { diff --git a/patches/server/0112-fastutil-CraftingManager.patch b/patches/server/0112-fastutil-CraftingManager.patch index e70a3313..ba17939b 100644 --- a/patches/server/0112-fastutil-CraftingManager.patch +++ b/patches/server/0112-fastutil-CraftingManager.patch @@ -5,7 +5,7 @@ Subject: [PATCH] fastutil - CraftingManager diff --git a/src/main/java/net/minecraft/server/CraftingManager.java b/src/main/java/net/minecraft/server/CraftingManager.java -index 544ff0a6c2ec62911c97fb02aec24d0215188dc3..2d099863b1d77cf5e1dbc6c37a48f517685d1925 100644 +index 544ff0a6c2ec62911c97fb02aec24d0215188dc3..f0ef79d01ab2019686b9fb56f6672ebab7c6b56e 100644 --- a/src/main/java/net/minecraft/server/CraftingManager.java +++ b/src/main/java/net/minecraft/server/CraftingManager.java @@ -14,7 +14,7 @@ import org.bukkit.craftbukkit.event.CraftEventFactory; // CraftBukkit @@ -13,7 +13,7 @@ index 544ff0a6c2ec62911c97fb02aec24d0215188dc3..2d099863b1d77cf5e1dbc6c37a48f517 private static final CraftingManager a = new CraftingManager(); - public List recipes = Lists.newArrayList(); -+ public List recipes = new it.unimi.dsi.fastutil.objects.ObjectArrayList<>(); ++ public List recipes = new it.unimi.dsi.fastutil.objects.ObjectArrayList<>(); // PandaSpigot - ArrayList -> ObjectArrayList // CraftBukkit start public IRecipe lastRecipe; public org.bukkit.inventory.InventoryView lastCraftView; diff --git a/patches/server/0114-fastutil-EntityPlayer-more-optimized-entties-checkin.patch b/patches/server/0114-fastutil-EntityPlayer-more-optimized-entties-checkin.patch index 7ac684ce..d80fb0b4 100644 --- a/patches/server/0114-fastutil-EntityPlayer-more-optimized-entties-checkin.patch +++ b/patches/server/0114-fastutil-EntityPlayer-more-optimized-entties-checkin.patch @@ -63,7 +63,7 @@ index b4f301a3eb660b9bf080c4f6b4e3bbaa3678a8d6..54ead77dbf1ef17121a2068947e5b101 try { super.t_(); diff --git a/src/main/java/net/minecraft/server/EntityTracker.java b/src/main/java/net/minecraft/server/EntityTracker.java -index d3afb43259dc34a63c561266efbf7e5050d9d213..7a6bd624cfe4a1e58155e0498f6d6c6387465db1 100644 +index d3afb43259dc34a63c561266efbf7e5050d9d213..e34f7e4cba2d9e4213e44da99dfdebd907dc8ffb 100644 --- a/src/main/java/net/minecraft/server/EntityTracker.java +++ b/src/main/java/net/minecraft/server/EntityTracker.java @@ -13,7 +13,7 @@ public class EntityTracker { @@ -71,7 +71,7 @@ index d3afb43259dc34a63c561266efbf7e5050d9d213..7a6bd624cfe4a1e58155e0498f6d6c63 private static final Logger a = LogManager.getLogger(); private final WorldServer world; - private Set c = new io.papermc.paper.util.maplist.ObjectMapList<>(); // PandaSpigot - FastUtil - ObjectMapList -+ public Set c = new io.papermc.paper.util.maplist.ObjectMapList<>(); // PandaSpigot - FastUtil - ObjectMapList ++ public Set c = new io.papermc.paper.util.maplist.ObjectMapList<>(); // PandaSpigot - private -> public public IntHashMap trackedEntities = new IntHashMap(); private int e; diff --git a/patches/server/0115-fixup-Add-packet-limiter-config.patch b/patches/server/0115-tempfixup-Add-packet-limiter-config.patch similarity index 94% rename from patches/server/0115-fixup-Add-packet-limiter-config.patch rename to patches/server/0115-tempfixup-Add-packet-limiter-config.patch index ce4cd616..94d2a6a7 100644 --- a/patches/server/0115-fixup-Add-packet-limiter-config.patch +++ b/patches/server/0115-tempfixup-Add-packet-limiter-config.patch @@ -1,7 +1,7 @@ From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 From: Mechoriet Date: Sat, 7 Oct 2023 23:26:59 +0200 -Subject: [PATCH] fixup! Add packet limiter config +Subject: [PATCH] tempfixup! Add packet limiter config diff --git a/src/main/java/net/minecraft/server/NetworkManager.java b/src/main/java/net/minecraft/server/NetworkManager.java From 27c057a6be38f2eb4249383bf8efb490846ffbb2 Mon Sep 17 00:00:00 2001 From: Mechoriet Date: Sat, 14 Oct 2023 22:47:52 +0200 Subject: [PATCH 8/8] work work work work work work work --- patches/server/0116-temp.patch | 127 +++++++++++++++++++++++++++++++++ 1 file changed, 127 insertions(+) create mode 100644 patches/server/0116-temp.patch diff --git a/patches/server/0116-temp.patch b/patches/server/0116-temp.patch new file mode 100644 index 00000000..9671ec19 --- /dev/null +++ b/patches/server/0116-temp.patch @@ -0,0 +1,127 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Mechoriet +Date: Sat, 14 Oct 2023 22:47:19 +0200 +Subject: [PATCH] temp + + +diff --git a/src/main/java/net/minecraft/server/Entity.java b/src/main/java/net/minecraft/server/Entity.java +index 37aae0ccb40e1827f268a88b1a74d288e3f5760d..f7087e3d0dae1c9f3653b4d5039de8403304db98 100644 +--- a/src/main/java/net/minecraft/server/Entity.java ++++ b/src/main/java/net/minecraft/server/Entity.java +@@ -437,11 +437,9 @@ public abstract class Entity implements ICommandListener { + * PaperSpigot - Load surrounding chunks the entity is moving through + */ + public void loadChunks() { +- for (int cx = (int) locX >> 4; cx <= (int) (locX + motX) >> 4; ++cx) { +- for (int cz = (int) locZ >> 4; cz <= (int) (locZ + motZ) >> 4; ++cz) { +- ((ChunkProviderServer) world.chunkProvider).getChunkAt(cx, cz); +- } +- } ++ int chunkX = org.bukkit.util.NumberConversions.floor(locX) >> 4; ++ int chunkZ = org.bukkit.util.NumberConversions.floor(locZ) >> 4; ++ ((ChunkProviderServer) world.chunkProvider).getChunkAt(chunkX, chunkZ); + } + + +diff --git a/src/main/java/net/minecraft/server/World.java b/src/main/java/net/minecraft/server/World.java +index 599b496acfd7ba727a4948ff18ada7614bb74e08..aab8252468afee9ebe3684f37291749699d4de86 100644 +--- a/src/main/java/net/minecraft/server/World.java ++++ b/src/main/java/net/minecraft/server/World.java +@@ -129,7 +129,8 @@ public abstract class World implements IBlockAccess { + + // Spigot start + private boolean guardEntityList; +- protected final gnu.trove.map.hash.TLongShortHashMap chunkTickList; ++// protected final gnu.trove.map.hash.TLongShortHashMap chunkTickList; ++ protected final it.unimi.dsi.fastutil.longs.Long2ShortOpenHashMap chunkTickList; + protected float growthOdds = 100; + protected float modifiedOdds = 100; + private final byte chunkTickRadius; +@@ -196,8 +197,7 @@ public abstract class World implements IBlockAccess { + // CraftBukkit end + // Spigot start + this.chunkTickRadius = (byte) ( ( this.getServer().getViewDistance() < 7 ) ? this.getServer().getViewDistance() : 7 ); +- this.chunkTickList = new gnu.trove.map.hash.TLongShortHashMap( spigotConfig.chunksPerTick * 5, 0.7f, Long.MIN_VALUE, Short.MIN_VALUE ); +- this.chunkTickList.setAutoCompactionFactor( 0 ); ++ this.chunkTickList = new it.unimi.dsi.fastutil.longs.Long2ShortOpenHashMap(spigotConfig.chunksPerTick * 5,0.7f); + // Spigot end + + this.L = this.random.nextInt(12000); +@@ -1273,7 +1273,7 @@ public abstract class World implements IBlockAccess { + } + + public List getCubes(Entity entity, AxisAlignedBB axisalignedbb) { +- ArrayList arraylist = Lists.newArrayList(); ++ List arraylist = new it.unimi.dsi.fastutil.objects.ObjectArrayList<>(); // PandaSpigot - ArrayList -> ObjectArrayList + int i = MathHelper.floor(axisalignedbb.a); + int j = MathHelper.floor(axisalignedbb.d + 1.0D); + int k = MathHelper.floor(axisalignedbb.b); +@@ -1283,8 +1283,6 @@ public abstract class World implements IBlockAccess { + WorldBorder worldborder = this.getWorldBorder(); + boolean flag = entity.aT(); + boolean flag1 = this.a(worldborder, entity); +- IBlockData iblockdata = Blocks.STONE.getBlockData(); +- BlockPosition.MutableBlockPosition blockposition_mutableblockposition = new BlockPosition.MutableBlockPosition(); + + // Spigot start + int ystart = ( ( k - 1 ) < 0 ) ? 0 : ( k - 1 ); +@@ -2363,7 +2361,7 @@ public abstract class World implements IBlockAccess { + int dx = ( random.nextBoolean() ? 1 : -1 ) * random.nextInt( randRange ); + int dz = ( random.nextBoolean() ? 1 : -1 ) * random.nextInt( randRange ); + long hash = chunkToKey( dx + j, dz + k ); +- if ( !chunkTickList.contains( hash ) && this.chunkProvider.isChunkLoaded(dx + j, dz + k ) ) ++ if ( !chunkTickList.containsKey( hash ) && this.chunkProvider.isChunkLoaded(dx + j, dz + k ) ) + { + chunkTickList.put( hash, (short) -1 ); // no players + } +diff --git a/src/main/java/net/minecraft/server/WorldServer.java b/src/main/java/net/minecraft/server/WorldServer.java +index d68deb81f9f7dfb82591d5876daaac9a3a258dc6..20ea81dea87bf75e1426cd60618f2d4c19c2a5cf 100644 +--- a/src/main/java/net/minecraft/server/WorldServer.java ++++ b/src/main/java/net/minecraft/server/WorldServer.java +@@ -13,6 +13,10 @@ import java.util.Random; + import java.util.Set; + import java.util.TreeSet; + import java.util.UUID; ++ ++import it.unimi.dsi.fastutil.longs.Long2ShortMap; ++import it.unimi.dsi.fastutil.objects.ObjectIterator; ++import it.unimi.dsi.fastutil.shorts.ShortIterator; + import org.apache.logging.log4j.LogManager; + import org.apache.logging.log4j.Logger; + +@@ -377,11 +381,10 @@ public class WorldServer extends World implements IAsyncTaskHandler { + super.h(); + if (this.worldData.getType() == WorldType.DEBUG_ALL_BLOCK_STATES) { + // Spigot start +- gnu.trove.iterator.TLongShortIterator iterator = this.chunkTickList.iterator(); ++ ObjectIterator iterator = this.chunkTickList.long2ShortEntrySet().fastIterator(); + + while (iterator.hasNext()) { +- iterator.advance(); +- long chunkCoord = iterator.key(); ++ long chunkCoord = iterator.next().getLongKey(); + + this.getChunkAt(World.keyToX( chunkCoord ), World.keyToZ( chunkCoord )).b(false); + // Spigot end +@@ -397,16 +400,16 @@ public class WorldServer extends World implements IAsyncTaskHandler { + // int k = chunkcoordintpair1.x * 16; + // int l = chunkcoordintpair1.z * 16; + // Spigot start +- for (gnu.trove.iterator.TLongShortIterator iter = chunkTickList.iterator(); iter.hasNext(); ) +- { +- iter.advance(); +- long chunkCoord = iter.key(); ++ ObjectIterator iterator = this.chunkTickList.long2ShortEntrySet().iterator(); ++ while (iterator.hasNext()) { ++ Long2ShortMap.Entry entry = iterator.next(); ++ long chunkCoord = entry.getLongKey(); + int chunkX = World.keyToX( chunkCoord ); + int chunkZ = World.keyToZ( chunkCoord ); + // If unloaded, or in procedd of being unloaded, drop it + if ( ( !this.chunkProvider.isChunkLoaded( chunkX, chunkZ ) ) || ( this.chunkProviderServer.unloadQueue.contains( chunkX, chunkZ ) ) ) + { +- iter.remove(); ++ iterator.remove(); + continue; + } + // Spigot end