From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 From: Aikar Date: Wed, 6 May 2020 23:30:30 -0400 Subject: [PATCH] Optimize NibbleArray to use pooled buffers Massively reduces memory allocation of 2048 byte buffers by using an object pool for these. Uses lots of advanced new capabilities of the Paper codebase :) diff --git a/src/main/java/net/minecraft/server/ChunkRegionLoader.java b/src/main/java/net/minecraft/server/ChunkRegionLoader.java index e625842e524f18e469f7695b27d52d4d04892266..d752e793f13a9caf5d255293f7ce9d562fd50064 100644 --- a/src/main/java/net/minecraft/server/ChunkRegionLoader.java +++ b/src/main/java/net/minecraft/server/ChunkRegionLoader.java @@ -387,11 +387,11 @@ public class ChunkRegionLoader { } if (nibblearray != null && !nibblearray.c()) { - nbttagcompound2.setByteArray("BlockLight", nibblearray.asBytes()); + nbttagcompound2.setByteArray("BlockLight", nibblearray.asBytesPoolSafe().clone()); // Paper } if (nibblearray1 != null && !nibblearray1.c()) { - nbttagcompound2.setByteArray("SkyLight", nibblearray1.asBytes()); + nbttagcompound2.setByteArray("SkyLight", nibblearray1.asBytesPoolSafe().clone()); // Paper } nbttaglist.add(nbttagcompound2); diff --git a/src/main/java/net/minecraft/server/LightEngineStorage.java b/src/main/java/net/minecraft/server/LightEngineStorage.java index 88277d23c36696fdd5363e41a130c9a443fac2c0..fa8039d38d5b3110fd85abf850248ba7948374c3 100644 --- a/src/main/java/net/minecraft/server/LightEngineStorage.java +++ b/src/main/java/net/minecraft/server/LightEngineStorage.java @@ -148,7 +148,7 @@ public abstract class LightEngineStorage> e protected NibbleArray j(long i) { NibbleArray nibblearray = (NibbleArray) this.i.get(i); - return nibblearray != null ? nibblearray : new NibbleArray(); + return nibblearray != null ? nibblearray : new NibbleArray().markPoolSafe(); // Paper } protected void a(LightEngineLayer lightenginelayer, long i) { @@ -319,7 +319,7 @@ public abstract class LightEngineStorage> e if (nibblearray != null) { this.i.put(i, nibblearray); } else { - this.i.remove(i); + NibbleArray remove = this.i.remove(i); if (remove != null && remove.cleaner != null) remove.cleaner.run(); // Paper - clean up when removed } } diff --git a/src/main/java/net/minecraft/server/LightEngineStorageArray.java b/src/main/java/net/minecraft/server/LightEngineStorageArray.java index fe35e297d9283d2826e8985806ee268ac2020bfb..cbeb6387e1e05961d2b747bbb05d3f577f82399c 100644 --- a/src/main/java/net/minecraft/server/LightEngineStorageArray.java +++ b/src/main/java/net/minecraft/server/LightEngineStorageArray.java @@ -27,7 +27,9 @@ public abstract class LightEngineStorageArray BYTE_2048 = new PooledObjects<>(() -> new byte[2048], maxPoolSize); + public static void releaseBytes(byte[] bytes) { + if (bytes != null && bytes != EMPTY_NIBBLE && bytes.length == 2048) { + System.arraycopy(EMPTY_NIBBLE, 0, bytes, 0, 2048); + BYTE_2048.release(bytes); + } + } + + public NibbleArray markPoolSafe(byte[] bytes) { + if (bytes != EMPTY_NIBBLE) this.a = bytes; + return markPoolSafe(); + } + public NibbleArray markPoolSafe() { + poolSafe = true; + return this; + } + public byte[] getIfSet() { + return this.a != null ? this.a : EMPTY_NIBBLE; + } + public byte[] getCloneIfSet() { + if (a == null) { + return EMPTY_NIBBLE; + } + byte[] ret = BYTE_2048.acquire(); + System.arraycopy(getIfSet(), 0, ret, 0, 2048); + return ret; + } + + public NibbleArray cloneAndSet(byte[] bytes) { + if (bytes != null && bytes != EMPTY_NIBBLE) { + this.a = BYTE_2048.acquire(); + System.arraycopy(bytes, 0, this.a, 0, 2048); + } + return this; + } + boolean poolSafe = false; + public java.lang.Runnable cleaner; + private void registerCleaner() { + if (!poolSafe) { + cleaner = MCUtil.registerCleaner(this, this.a, NibbleArray::releaseBytes); + } else { + cleaner = MCUtil.once(() -> NibbleArray.releaseBytes(this.a)); + } + } + // Paper end + @Nullable protected byte[] a; + public NibbleArray() {} public NibbleArray(byte[] abyte) { + // Paper start + this(abyte, false); + } + public NibbleArray(byte[] abyte, boolean isSafe) { this.a = abyte; + if (!isSafe) this.a = getCloneIfSet(); // Paper - clone for safety + registerCleaner(); + // Paper end if (abyte.length != 2048) { throw (IllegalArgumentException) SystemUtils.c(new IllegalArgumentException("ChunkNibbleArrays should be 2048 bytes not: " + abyte.length)); } @@ -44,7 +103,8 @@ public class NibbleArray { public void a(int i, int j) { // PAIL: private -> public if (this.a == null) { - this.a = new byte[2048]; + this.a = BYTE_2048.acquire(); // Paper + registerCleaner();// Paper } int k = this.d(i); @@ -66,14 +126,36 @@ public class NibbleArray { public byte[] asBytes() { if (this.a == null) { this.a = new byte[2048]; + } else { // Paper start + // Accessor may need this object past garbage collection so need to clone it and return pooled value + // If we know its safe for pre GC access, use asBytesPoolSafe(). If you just need read, use getIfSet() + Runnable cleaner = this.cleaner; + if (cleaner != null) { + this.a = this.a.clone(); + cleaner.run(); // release the previously pooled value + this.cleaner = null; + } + } + // Paper end + + return this.a; + } + + @Nonnull + public byte[] asBytesPoolSafe() { + if (this.a == null) { + this.a = BYTE_2048.acquire(); // Paper + registerCleaner(); // Paper } + //noinspection ConstantConditions return this.a; } + // Paper end public NibbleArray copy() { return this.b(); } // Paper - OBFHELPER public NibbleArray b() { - return this.a == null ? new NibbleArray() : new NibbleArray((byte[]) this.a.clone()); + return this.a == null ? new NibbleArray() : new NibbleArray(this.a); // Paper - clone in ctor } public String toString() { diff --git a/src/main/java/net/minecraft/server/NibbleArrayFlat.java b/src/main/java/net/minecraft/server/NibbleArrayFlat.java index 67c960292db9d99ac85b5d0dda50ae48ef942c1b..5e3efa1fa6c089df35971ce5c83da384f7dbd402 100644 --- a/src/main/java/net/minecraft/server/NibbleArrayFlat.java +++ b/src/main/java/net/minecraft/server/NibbleArrayFlat.java @@ -8,7 +8,7 @@ public class NibbleArrayFlat extends NibbleArray { public NibbleArrayFlat(NibbleArray nibblearray, int i) { super(128); - System.arraycopy(nibblearray.asBytes(), i * 128, this.a, 0, 128); + System.arraycopy(nibblearray.getIfSet(), i * 128, this.a, 0, 128); // Paper } @Override @@ -18,7 +18,7 @@ public class NibbleArrayFlat extends NibbleArray { @Override public byte[] asBytes() { - byte[] abyte = new byte[2048]; + byte[] abyte = BYTE_2048.acquire(); // Paper for (int i = 0; i < 16; ++i) { System.arraycopy(this.a, 0, abyte, i * 128, 128); diff --git a/src/main/java/net/minecraft/server/PacketPlayOutLightUpdate.java b/src/main/java/net/minecraft/server/PacketPlayOutLightUpdate.java index cd1ad45469aa163b9bc41774ae80adfa617fd97b..1946aae7424593100279834baa89c19f2522437f 100644 --- a/src/main/java/net/minecraft/server/PacketPlayOutLightUpdate.java +++ b/src/main/java/net/minecraft/server/PacketPlayOutLightUpdate.java @@ -16,13 +16,42 @@ public class PacketPlayOutLightUpdate implements Packet { private List g; private List h; + // Paper start + java.lang.Runnable cleaner1; + java.lang.Runnable cleaner2; + java.util.concurrent.atomic.AtomicInteger remainingSends = new java.util.concurrent.atomic.AtomicInteger(0); + + @Override + public void onPacketDispatch(EntityPlayer player) { + remainingSends.incrementAndGet(); + } + + @Override + public void onPacketDispatchFinish(EntityPlayer player, io.netty.channel.ChannelFuture future) { + if (remainingSends.decrementAndGet() <= 0) { + // incase of any race conditions, schedule this delayed + MCUtil.scheduleTask(1, () -> { + if (remainingSends.get() == 0) { + cleaner1.run(); + cleaner2.run(); + } + }); + } + } + + @Override + public boolean hasFinishListener() { + return true; + } + + // Paper end public PacketPlayOutLightUpdate() {} public PacketPlayOutLightUpdate(ChunkCoordIntPair chunkcoordintpair, LightEngine lightengine) { this.a = chunkcoordintpair.x; this.b = chunkcoordintpair.z; - this.g = Lists.newArrayList(); - this.h = Lists.newArrayList(); + this.g = Lists.newArrayList();cleaner1 = MCUtil.registerListCleaner(this, this.g, NibbleArray::releaseBytes); // Paper + this.h = Lists.newArrayList();cleaner2 = MCUtil.registerListCleaner(this, this.h, NibbleArray::releaseBytes); // Paper for (int i = 0; i < 18; ++i) { NibbleArray nibblearray = lightengine.a(EnumSkyBlock.SKY).a(SectionPosition.a(chunkcoordintpair, -1 + i)); @@ -33,7 +62,7 @@ public class PacketPlayOutLightUpdate implements Packet { this.e |= 1 << i; } else { this.c |= 1 << i; - this.g.add(nibblearray.asBytes().clone()); + this.g.add(nibblearray.getCloneIfSet()); // Paper } } @@ -42,7 +71,7 @@ public class PacketPlayOutLightUpdate implements Packet { this.f |= 1 << i; } else { this.d |= 1 << i; - this.h.add(nibblearray1.asBytes().clone()); + this.h.add(nibblearray1.getCloneIfSet()); // Paper } } } @@ -54,8 +83,8 @@ public class PacketPlayOutLightUpdate implements Packet { this.b = chunkcoordintpair.z; this.c = i; this.d = j; - this.g = Lists.newArrayList(); - this.h = Lists.newArrayList(); + this.g = Lists.newArrayList();cleaner1 = MCUtil.registerListCleaner(this, this.g, NibbleArray::releaseBytes); // Paper + this.h = Lists.newArrayList();cleaner2 = MCUtil.registerListCleaner(this, this.h, NibbleArray::releaseBytes); // Paper for (int k = 0; k < 18; ++k) { NibbleArray nibblearray; @@ -63,7 +92,7 @@ public class PacketPlayOutLightUpdate implements Packet { if ((this.c & 1 << k) != 0) { nibblearray = lightengine.a(EnumSkyBlock.SKY).a(SectionPosition.a(chunkcoordintpair, -1 + k)); if (nibblearray != null && !nibblearray.c()) { - this.g.add(nibblearray.asBytes().clone()); + this.g.add(nibblearray.getCloneIfSet()); // Paper } else { this.c &= ~(1 << k); if (nibblearray != null) { @@ -75,7 +104,7 @@ public class PacketPlayOutLightUpdate implements Packet { if ((this.d & 1 << k) != 0) { nibblearray = lightengine.a(EnumSkyBlock.BLOCK).a(SectionPosition.a(chunkcoordintpair, -1 + k)); if (nibblearray != null && !nibblearray.c()) { - this.h.add(nibblearray.asBytes().clone()); + this.h.add(nibblearray.getCloneIfSet()); // Paper } else { this.d &= ~(1 << k); if (nibblearray != null) { diff --git a/src/main/java/org/bukkit/craftbukkit/CraftChunk.java b/src/main/java/org/bukkit/craftbukkit/CraftChunk.java index 39ef95cbbb1d1d049354ae1e8991309e918d0462..ec3f560556c3056bdfc11cc6a7eb76420f13abad 100644 --- a/src/main/java/org/bukkit/craftbukkit/CraftChunk.java +++ b/src/main/java/org/bukkit/craftbukkit/CraftChunk.java @@ -271,14 +271,14 @@ public class CraftChunk implements Chunk { sectionSkyLights[i] = emptyLight; } else { sectionSkyLights[i] = new byte[2048]; - System.arraycopy(skyLightArray.asBytes(), 0, sectionSkyLights[i], 0, 2048); + System.arraycopy(skyLightArray.getIfSet(), 0, sectionSkyLights[i], 0, 2048); // Paper } NibbleArray emitLightArray = lightengine.a(EnumSkyBlock.BLOCK).a(SectionPosition.a(x, i, z)); if (emitLightArray == null) { sectionEmitLights[i] = emptyLight; } else { sectionEmitLights[i] = new byte[2048]; - System.arraycopy(emitLightArray.asBytes(), 0, sectionEmitLights[i], 0, 2048); + System.arraycopy(emitLightArray.getIfSet(), 0, sectionEmitLights[i], 0, 2048); // Paper } } }