mirror of
https://github.com/PaperMC/Paper.git
synced 2024-12-13 18:31:20 +01:00
295 lines
16 KiB
Diff
295 lines
16 KiB
Diff
|
From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
|
||
|
From: Aikar <aikar@aikar.co>
|
||
|
Date: Wed, 8 Apr 2020 03:06:30 -0400
|
||
|
Subject: [PATCH] Optimize PlayerChunkMap memory use for visibleChunks
|
||
|
|
||
|
No longer clones visible chunks which is causing massive memory
|
||
|
allocation issues, likely the source of Humongous Objects on large servers.
|
||
|
|
||
|
Instead we just synchronize, clear and rebuild, reusing the same object buffers
|
||
|
as before with only 2 small objects created (FastIterator/MapEntry)
|
||
|
|
||
|
This should result in siginificant memory use reduction and improved GC behavior.
|
||
|
|
||
|
diff --git a/src/main/java/com/destroystokyo/paper/util/map/Long2ObjectLinkedOpenHashMapFastCopy.java b/src/main/java/com/destroystokyo/paper/util/map/Long2ObjectLinkedOpenHashMapFastCopy.java
|
||
|
new file mode 100644
|
||
|
index 0000000000000000000000000000000000000000..f6ff4d8132a95895680f5bc81f8f873e78f0bbdb
|
||
|
--- /dev/null
|
||
|
+++ b/src/main/java/com/destroystokyo/paper/util/map/Long2ObjectLinkedOpenHashMapFastCopy.java
|
||
|
@@ -0,0 +1,39 @@
|
||
|
+package com.destroystokyo.paper.util.map;
|
||
|
+
|
||
|
+import it.unimi.dsi.fastutil.longs.Long2ObjectLinkedOpenHashMap;
|
||
|
+
|
||
|
+public class Long2ObjectLinkedOpenHashMapFastCopy<V> extends Long2ObjectLinkedOpenHashMap<V> {
|
||
|
+
|
||
|
+ public void copyFrom(Long2ObjectLinkedOpenHashMapFastCopy<V> map) {
|
||
|
+ if (key.length != map.key.length) {
|
||
|
+ key = null;
|
||
|
+ key = new long[map.key.length];
|
||
|
+ }
|
||
|
+ if (value.length != map.value.length) {
|
||
|
+ value = null;
|
||
|
+ //noinspection unchecked
|
||
|
+ value = (V[]) new Object[map.value.length];
|
||
|
+ }
|
||
|
+ if (link.length != map.link.length) {
|
||
|
+ link = null;
|
||
|
+ link = new long[map.link.length];
|
||
|
+ }
|
||
|
+ System.arraycopy(map.key, 0, this.key, 0, map.key.length);
|
||
|
+ System.arraycopy(map.value, 0, this.value, 0, map.value.length);
|
||
|
+ System.arraycopy(map.link, 0, this.link, 0, map.link.length);
|
||
|
+ this.size = map.size;
|
||
|
+ this.mask = map.mask;
|
||
|
+ this.first = map.first;
|
||
|
+ this.last = map.last;
|
||
|
+ this.n = map.n;
|
||
|
+ this.maxFill = map.maxFill;
|
||
|
+ this.containsNullKey = map.containsNullKey;
|
||
|
+ }
|
||
|
+
|
||
|
+ @Override
|
||
|
+ public Long2ObjectLinkedOpenHashMapFastCopy<V> clone() {
|
||
|
+ Long2ObjectLinkedOpenHashMapFastCopy<V> clone = (Long2ObjectLinkedOpenHashMapFastCopy<V>) super.clone();
|
||
|
+ clone.copyFrom(this);
|
||
|
+ return clone;
|
||
|
+ }
|
||
|
+}
|
||
|
diff --git a/src/main/java/net/minecraft/server/MCUtil.java b/src/main/java/net/minecraft/server/MCUtil.java
|
||
|
index 5a410550cfb48505c9de9979465ed1528c8fbf05..9edbde8299bcd127e1727d34ed441f638e716b2a 100644
|
||
|
--- a/src/main/java/net/minecraft/server/MCUtil.java
|
||
|
+++ b/src/main/java/net/minecraft/server/MCUtil.java
|
||
|
@@ -616,7 +616,7 @@ public final class MCUtil {
|
||
|
|
||
|
WorldServer world = ((org.bukkit.craftbukkit.CraftWorld)bukkitWorld).getHandle();
|
||
|
PlayerChunkMap chunkMap = world.getChunkProvider().playerChunkMap;
|
||
|
- Long2ObjectLinkedOpenHashMap<PlayerChunk> visibleChunks = chunkMap.visibleChunks;
|
||
|
+ Long2ObjectLinkedOpenHashMap<PlayerChunk> visibleChunks = chunkMap.getVisibleChunks();
|
||
|
ChunkMapDistance chunkMapDistance = chunkMap.chunkDistanceManager;
|
||
|
List<PlayerChunk> allChunks = new ArrayList<>(visibleChunks.values());
|
||
|
List<EntityPlayer> players = world.players;
|
||
|
diff --git a/src/main/java/net/minecraft/server/level/ChunkProviderServer.java b/src/main/java/net/minecraft/server/level/ChunkProviderServer.java
|
||
|
index 214098d7ad95839e90b0ec9ea997930c27b4bea4..13ac946487bb05b5c47ee8ee10cb6ed1c992c0e2 100644
|
||
|
--- a/src/main/java/net/minecraft/server/level/ChunkProviderServer.java
|
||
|
+++ b/src/main/java/net/minecraft/server/level/ChunkProviderServer.java
|
||
|
@@ -781,7 +781,7 @@ public class ChunkProviderServer extends IChunkProvider {
|
||
|
};
|
||
|
// Paper end
|
||
|
this.world.timings.chunkTicks.startTiming(); // Paper
|
||
|
- this.playerChunkMap.f().forEach((playerchunk) -> { // Paper - no... just no...
|
||
|
+ this.playerChunkMap.forEachVisibleChunk((playerchunk) -> { // Paper - safe iterator incase chunk loads, also no wrapping
|
||
|
Optional<Chunk> optional = ((Either) playerchunk.a().getNow(PlayerChunk.UNLOADED_CHUNK)).left();
|
||
|
|
||
|
if (optional.isPresent()) {
|
||
|
diff --git a/src/main/java/net/minecraft/server/level/PlayerChunkMap.java b/src/main/java/net/minecraft/server/level/PlayerChunkMap.java
|
||
|
index c7619bba9115e8695b5aea2b4d059bea577e748e..5ccc70f36616e1bd8cdb8b23315f7422ec5acc61 100644
|
||
|
--- a/src/main/java/net/minecraft/server/level/PlayerChunkMap.java
|
||
|
+++ b/src/main/java/net/minecraft/server/level/PlayerChunkMap.java
|
||
|
@@ -106,8 +106,33 @@ public class PlayerChunkMap extends IChunkLoader implements PlayerChunk.d {
|
||
|
|
||
|
private static final Logger LOGGER = LogManager.getLogger();
|
||
|
public static final int GOLDEN_TICKET = 33 + ChunkStatus.b();
|
||
|
- public final Long2ObjectLinkedOpenHashMap<PlayerChunk> updatingChunks = new Long2ObjectLinkedOpenHashMap();
|
||
|
- public volatile Long2ObjectLinkedOpenHashMap<PlayerChunk> visibleChunks;
|
||
|
+ // Paper start - faster copying
|
||
|
+ public final Long2ObjectLinkedOpenHashMap<PlayerChunk> updatingChunks = new com.destroystokyo.paper.util.map.Long2ObjectLinkedOpenHashMapFastCopy<>(); // Paper - faster copying
|
||
|
+ public final Long2ObjectLinkedOpenHashMap<PlayerChunk> visibleChunks = new ProtectedVisibleChunksMap(); // Paper - faster copying
|
||
|
+
|
||
|
+ private class ProtectedVisibleChunksMap extends com.destroystokyo.paper.util.map.Long2ObjectLinkedOpenHashMapFastCopy<PlayerChunk> {
|
||
|
+ @Override
|
||
|
+ public PlayerChunk put(long k, PlayerChunk playerChunk) {
|
||
|
+ throw new UnsupportedOperationException("Updating visible Chunks");
|
||
|
+ }
|
||
|
+
|
||
|
+ @Override
|
||
|
+ public PlayerChunk remove(long k) {
|
||
|
+ throw new UnsupportedOperationException("Removing visible Chunks");
|
||
|
+ }
|
||
|
+
|
||
|
+ @Override
|
||
|
+ public PlayerChunk get(long k) {
|
||
|
+ return PlayerChunkMap.this.getVisibleChunk(k);
|
||
|
+ }
|
||
|
+
|
||
|
+ public PlayerChunk safeGet(long k) {
|
||
|
+ return super.get(k);
|
||
|
+ }
|
||
|
+ }
|
||
|
+ // Paper end
|
||
|
+ public final com.destroystokyo.paper.util.map.Long2ObjectLinkedOpenHashMapFastCopy<PlayerChunk> pendingVisibleChunks = new com.destroystokyo.paper.util.map.Long2ObjectLinkedOpenHashMapFastCopy<PlayerChunk>(); // Paper - this is used if the visible chunks is updated while iterating only
|
||
|
+ public transient com.destroystokyo.paper.util.map.Long2ObjectLinkedOpenHashMapFastCopy<PlayerChunk> visibleChunksClone; // Paper - used for async access of visible chunks, clone and cache only when needed
|
||
|
private final Long2ObjectLinkedOpenHashMap<PlayerChunk> pendingUnload;
|
||
|
public final LongSet loadedChunks; // Paper - private -> public
|
||
|
public final WorldServer world;
|
||
|
@@ -180,7 +205,7 @@ public class PlayerChunkMap extends IChunkLoader implements PlayerChunk.d {
|
||
|
|
||
|
public PlayerChunkMap(WorldServer worldserver, Convertable.ConversionSession convertable_conversionsession, DataFixer datafixer, DefinedStructureManager definedstructuremanager, Executor executor, IAsyncTaskHandler<Runnable> iasynctaskhandler, ILightAccess ilightaccess, ChunkGenerator chunkgenerator, WorldLoadListener worldloadlistener, Supplier<WorldPersistentData> supplier, int i, boolean flag) {
|
||
|
super(new File(convertable_conversionsession.a(worldserver.getDimensionKey()), "region"), datafixer, flag);
|
||
|
- this.visibleChunks = this.updatingChunks.clone();
|
||
|
+ //this.visibleChunks = this.updatingChunks.clone(); // Paper - no more cloning
|
||
|
this.pendingUnload = new Long2ObjectLinkedOpenHashMap();
|
||
|
this.loadedChunks = new LongOpenHashSet();
|
||
|
this.unloadQueue = new LongOpenHashSet();
|
||
|
@@ -272,9 +297,52 @@ public class PlayerChunkMap extends IChunkLoader implements PlayerChunk.d {
|
||
|
return (PlayerChunk) this.updatingChunks.get(i);
|
||
|
}
|
||
|
|
||
|
+ // Paper start - remove cloning of visible chunks unless accessed as a collection async
|
||
|
+ private static final boolean DEBUG_ASYNC_VISIBLE_CHUNKS = Boolean.getBoolean("paper.debug-async-visible-chunks");
|
||
|
+ private boolean isIterating = false;
|
||
|
+ private boolean hasPendingVisibleUpdate = false;
|
||
|
+ public void forEachVisibleChunk(java.util.function.Consumer<PlayerChunk> consumer) {
|
||
|
+ org.spigotmc.AsyncCatcher.catchOp("forEachVisibleChunk");
|
||
|
+ boolean prev = isIterating;
|
||
|
+ isIterating = true;
|
||
|
+ try {
|
||
|
+ for (PlayerChunk value : this.visibleChunks.values()) {
|
||
|
+ consumer.accept(value);
|
||
|
+ }
|
||
|
+ } finally {
|
||
|
+ this.isIterating = prev;
|
||
|
+ if (!this.isIterating && this.hasPendingVisibleUpdate) {
|
||
|
+ ((ProtectedVisibleChunksMap)this.visibleChunks).copyFrom(this.pendingVisibleChunks);
|
||
|
+ this.pendingVisibleChunks.clear();
|
||
|
+ this.hasPendingVisibleUpdate = false;
|
||
|
+ }
|
||
|
+ }
|
||
|
+ }
|
||
|
+ public Long2ObjectLinkedOpenHashMap<PlayerChunk> getVisibleChunks() {
|
||
|
+ if (Thread.currentThread() == this.world.serverThread) {
|
||
|
+ return this.visibleChunks;
|
||
|
+ } else {
|
||
|
+ synchronized (this.visibleChunks) {
|
||
|
+ if (DEBUG_ASYNC_VISIBLE_CHUNKS) new Throwable("Async getVisibleChunks").printStackTrace();
|
||
|
+ if (this.visibleChunksClone == null) {
|
||
|
+ this.visibleChunksClone = this.hasPendingVisibleUpdate ? this.pendingVisibleChunks.clone() : ((ProtectedVisibleChunksMap)this.visibleChunks).clone();
|
||
|
+ }
|
||
|
+ return this.visibleChunksClone;
|
||
|
+ }
|
||
|
+ }
|
||
|
+ }
|
||
|
+ // Paper end
|
||
|
+
|
||
|
@Nullable
|
||
|
public PlayerChunk getVisibleChunk(long i) { // Paper - protected -> public
|
||
|
- return (PlayerChunk) this.visibleChunks.get(i);
|
||
|
+ // Paper start - mt safe get
|
||
|
+ if (Thread.currentThread() != this.world.serverThread) {
|
||
|
+ synchronized (this.visibleChunks) {
|
||
|
+ return (PlayerChunk) (this.hasPendingVisibleUpdate ? this.pendingVisibleChunks.get(i) : ((ProtectedVisibleChunksMap)this.visibleChunks).safeGet(i));
|
||
|
+ }
|
||
|
+ }
|
||
|
+ return (PlayerChunk) (this.hasPendingVisibleUpdate ? this.pendingVisibleChunks.get(i) : ((ProtectedVisibleChunksMap)this.visibleChunks).safeGet(i));
|
||
|
+ // Paper end
|
||
|
}
|
||
|
|
||
|
protected IntSupplier c(long i) {
|
||
|
@@ -462,8 +530,9 @@ public class PlayerChunkMap extends IChunkLoader implements PlayerChunk.d {
|
||
|
// Paper end
|
||
|
|
||
|
protected void save(boolean flag) {
|
||
|
+ Long2ObjectLinkedOpenHashMap<PlayerChunk> visibleChunks = this.getVisibleChunks(); // Paper remove clone of visible Chunks unless saving off main thread (watchdog kill)
|
||
|
if (flag) {
|
||
|
- List<PlayerChunk> list = (List) this.visibleChunks.values().stream().filter(PlayerChunk::hasBeenLoaded).peek(PlayerChunk::m).collect(Collectors.toList());
|
||
|
+ List<PlayerChunk> list = (List) visibleChunks.values().stream().filter(PlayerChunk::hasBeenLoaded).peek(PlayerChunk::m).collect(Collectors.toList()); // Paper - remove cloning of visible chunks
|
||
|
MutableBoolean mutableboolean = new MutableBoolean();
|
||
|
|
||
|
do {
|
||
|
@@ -491,7 +560,7 @@ public class PlayerChunkMap extends IChunkLoader implements PlayerChunk.d {
|
||
|
// this.i(); // Paper - nuke IOWorker
|
||
|
PlayerChunkMap.LOGGER.info("ThreadedAnvilChunkStorage ({}): All chunks are saved", this.w.getName());
|
||
|
} else {
|
||
|
- this.visibleChunks.values().stream().filter(PlayerChunk::hasBeenLoaded).forEach((playerchunk) -> {
|
||
|
+ visibleChunks.values().stream().filter(PlayerChunk::hasBeenLoaded).forEach((playerchunk) -> {
|
||
|
IChunkAccess ichunkaccess = (IChunkAccess) playerchunk.getChunkSave().getNow(null); // CraftBukkit - decompile error
|
||
|
|
||
|
if (ichunkaccess instanceof ProtoChunkExtension || ichunkaccess instanceof Chunk) {
|
||
|
@@ -662,7 +731,20 @@ public class PlayerChunkMap extends IChunkLoader implements PlayerChunk.d {
|
||
|
if (!this.updatingChunksModified) {
|
||
|
return false;
|
||
|
} else {
|
||
|
- this.visibleChunks = this.updatingChunks.clone();
|
||
|
+ // Paper start - stop cloning visibleChunks
|
||
|
+ synchronized (this.visibleChunks) {
|
||
|
+ if (isIterating) {
|
||
|
+ hasPendingVisibleUpdate = true;
|
||
|
+ this.pendingVisibleChunks.copyFrom((com.destroystokyo.paper.util.map.Long2ObjectLinkedOpenHashMapFastCopy<PlayerChunk>)this.updatingChunks);
|
||
|
+ } else {
|
||
|
+ hasPendingVisibleUpdate = false;
|
||
|
+ this.pendingVisibleChunks.clear();
|
||
|
+ ((ProtectedVisibleChunksMap)this.visibleChunks).copyFrom((com.destroystokyo.paper.util.map.Long2ObjectLinkedOpenHashMapFastCopy<PlayerChunk>)this.updatingChunks);
|
||
|
+ this.visibleChunksClone = null;
|
||
|
+ }
|
||
|
+ }
|
||
|
+ // Paper end
|
||
|
+
|
||
|
this.updatingChunksModified = false;
|
||
|
return true;
|
||
|
}
|
||
|
@@ -1141,12 +1223,12 @@ public class PlayerChunkMap extends IChunkLoader implements PlayerChunk.d {
|
||
|
}
|
||
|
|
||
|
protected Iterable<PlayerChunk> f() {
|
||
|
- return Iterables.unmodifiableIterable(this.visibleChunks.values());
|
||
|
+ return Iterables.unmodifiableIterable(this.getVisibleChunks().values()); // Paper
|
||
|
}
|
||
|
|
||
|
void a(Writer writer) throws IOException {
|
||
|
CSVWriter csvwriter = CSVWriter.a().a("x").a("z").a("level").a("in_memory").a("status").a("full_status").a("accessible_ready").a("ticking_ready").a("entity_ticking_ready").a("ticket").a("spawning").a("entity_count").a("block_entity_count").a(writer);
|
||
|
- ObjectBidirectionalIterator objectbidirectionaliterator = this.visibleChunks.long2ObjectEntrySet().iterator();
|
||
|
+ ObjectBidirectionalIterator objectbidirectionaliterator = this.getVisibleChunks().long2ObjectEntrySet().iterator(); // Paper
|
||
|
|
||
|
while (objectbidirectionaliterator.hasNext()) {
|
||
|
Entry<PlayerChunk> entry = (Entry) objectbidirectionaliterator.next();
|
||
|
diff --git a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
|
||
|
index fcad64fcfc22af227be19741b634b773aca7a98d..c5a4c8c4c9d90a8a081a593488f86ab487adaecb 100644
|
||
|
--- a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
|
||
|
+++ b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
|
||
|
@@ -294,6 +294,7 @@ public class CraftWorld implements World {
|
||
|
return ret;
|
||
|
}
|
||
|
public int getTileEntityCount() {
|
||
|
+ return net.minecraft.server.MCUtil.ensureMain(() -> {
|
||
|
// We don't use the full world tile entity list, so we must iterate chunks
|
||
|
Long2ObjectLinkedOpenHashMap<PlayerChunk> chunks = world.getChunkProvider().playerChunkMap.visibleChunks;
|
||
|
int size = 0;
|
||
|
@@ -305,11 +306,13 @@ public class CraftWorld implements World {
|
||
|
size += chunk.tileEntities.size();
|
||
|
}
|
||
|
return size;
|
||
|
+ });
|
||
|
}
|
||
|
public int getTickableTileEntityCount() {
|
||
|
return world.tileEntityListTick.size();
|
||
|
}
|
||
|
public int getChunkCount() {
|
||
|
+ return net.minecraft.server.MCUtil.ensureMain(() -> {
|
||
|
int ret = 0;
|
||
|
|
||
|
for (PlayerChunk chunkHolder : world.getChunkProvider().playerChunkMap.visibleChunks.values()) {
|
||
|
@@ -318,7 +321,7 @@ public class CraftWorld implements World {
|
||
|
}
|
||
|
}
|
||
|
|
||
|
- return ret;
|
||
|
+ return ret; });
|
||
|
}
|
||
|
public int getPlayerCount() {
|
||
|
return world.players.size();
|
||
|
@@ -443,6 +446,14 @@ public class CraftWorld implements World {
|
||
|
|
||
|
@Override
|
||
|
public Chunk[] getLoadedChunks() {
|
||
|
+ // Paper start
|
||
|
+ if (Thread.currentThread() != world.getMinecraftWorld().serverThread) {
|
||
|
+ synchronized (world.getChunkProvider().playerChunkMap.visibleChunks) {
|
||
|
+ Long2ObjectLinkedOpenHashMap<PlayerChunk> chunks = world.getChunkProvider().playerChunkMap.visibleChunks;
|
||
|
+ return chunks.values().stream().map(PlayerChunk::getFullChunk).filter(Objects::nonNull).map(net.minecraft.world.level.chunk.Chunk::getBukkitChunk).toArray(Chunk[]::new);
|
||
|
+ }
|
||
|
+ }
|
||
|
+ // Paper end
|
||
|
Long2ObjectLinkedOpenHashMap<PlayerChunk> chunks = world.getChunkProvider().playerChunkMap.visibleChunks;
|
||
|
return chunks.values().stream().map(PlayerChunk::getFullChunk).filter(Objects::nonNull).map(net.minecraft.world.level.chunk.Chunk::getBukkitChunk).toArray(Chunk[]::new);
|
||
|
}
|