progress
This commit is contained in:
parent
d001eefd7e
commit
3c02c90f3e
23 changed files with 157 additions and 219 deletions
|
@ -0,0 +1,101 @@
|
|||
From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
|
||||
From: MeFisto94 <MeFisto94@users.noreply.github.com>
|
||||
Date: Tue, 12 May 2020 23:02:43 +0200
|
||||
Subject: [PATCH] Workaround for Client Lag Spikes (MC-162253)
|
||||
|
||||
When crossing certain chunk boundaries, the client needlessly
|
||||
calculates light maps for chunk neighbours. In some specific map
|
||||
configurations, these calculations cause a 500ms+ freeze on the Client.
|
||||
|
||||
This patch basically serves as a workaround by sending light maps
|
||||
to the client, so that it doesn't attempt to calculate them.
|
||||
This mitigates the frametime impact to a minimum (but it's still there).
|
||||
|
||||
1.17 update note: Line sending the light update packet needs updating, rest seems to be mostly fine
|
||||
|
||||
diff --git a/src/main/java/net/minecraft/server/level/ChunkMap.java b/src/main/java/net/minecraft/server/level/ChunkMap.java
|
||||
index d8f99f7f5ca0e1dbbb9b760af3a4b4f9c52ef6c7..f700ac973ebc3037a5a44eac3c9d505b98adce41 100644
|
||||
--- a/src/main/java/net/minecraft/server/level/ChunkMap.java
|
||||
+++ b/src/main/java/net/minecraft/server/level/ChunkMap.java
|
||||
@@ -1906,9 +1906,68 @@ Sections go from 0..16. Now whenever a section is not empty, it can potentially
|
||||
|
||||
public void playerLoadedChunk(ServerPlayer player, Packet<?>[] packets, LevelChunk chunk) { // Paper - private -> public
|
||||
if (packets[0] == null) {
|
||||
+ // Paper start - add 8 for light fix workaround
|
||||
+ if (packets.length != 10) { // in case Plugins call sendChunk, resize
|
||||
+ packets = new Packet[10];
|
||||
+ }
|
||||
+ // Paper end
|
||||
packets[0] = new ClientboundLevelChunkPacket(chunk);
|
||||
packets[1] = new ClientboundLightUpdatePacket(chunk.getPos(), this.lightEngine, (BitSet) null, (BitSet) null, true);
|
||||
+
|
||||
+ // Paper start - Fix MC-162253
|
||||
+ final int lightMask = getLightMask(chunk);
|
||||
+ int i = 1;
|
||||
+ for (int x = -1; x <= 1; x++) {
|
||||
+ for (int z = -1; z <= 1; z++) {
|
||||
+ if (x == 0 && z == 0) {
|
||||
+ continue;
|
||||
+ }
|
||||
+
|
||||
+ ++i;
|
||||
+
|
||||
+ if (!chunk.isNeighbourLoaded(x, z)) {
|
||||
+ continue;
|
||||
+ }
|
||||
+
|
||||
+ final LevelChunk neighbor = chunk.getRelativeNeighbourIfLoaded(x, z);
|
||||
+ final int updateLightMask = lightMask & ~getCeilingLightMask(neighbor);
|
||||
+
|
||||
+ if (updateLightMask == 0) {
|
||||
+ continue;
|
||||
+ }
|
||||
+
|
||||
+ packets[i] = new ClientboundLightUpdatePacket(new ChunkPos(chunk.getPos().x + x, chunk.getPos().z + z), lightEngine, null, null, updateLightMask, 0, true); // TODO: This line needs updating
|
||||
+ }
|
||||
+ }
|
||||
+ }
|
||||
+
|
||||
+ final int viewDistance = playerViewDistanceBroadcastMap.getLastViewDistance(player);
|
||||
+ final long lastPosition = playerViewDistanceBroadcastMap.getLastCoordinate(player);
|
||||
+
|
||||
+ int j = 1;
|
||||
+ for (int x = -1; x <= 1; x++) {
|
||||
+ for (int z = -1; z <= 1; z++) {
|
||||
+ if (x == 0 && z == 0) {
|
||||
+ continue;
|
||||
+ }
|
||||
+
|
||||
+ ++j;
|
||||
+
|
||||
+ Packet<?> packet = packets[j];
|
||||
+ if (packet == null) {
|
||||
+ continue;
|
||||
+ }
|
||||
+
|
||||
+ final int distX = Math.abs(MCUtil.getCoordinateX(lastPosition) - (chunk.getPos().x + x));
|
||||
+ final int distZ = Math.abs(MCUtil.getCoordinateZ(lastPosition) - (chunk.getPos().z + z));
|
||||
+
|
||||
+ if (Math.max(distX, distZ) > viewDistance) {
|
||||
+ continue;
|
||||
+ }
|
||||
+ player.connection.send(packet);
|
||||
+ }
|
||||
}
|
||||
+ // Paper end - Fix MC-162253
|
||||
|
||||
player.trackChunk(chunk.getPos(), packets[0], packets[1]);
|
||||
DebugPackets.sendPoiPacketsForChunk(this.level, chunk.getPos());
|
||||
diff --git a/src/main/java/net/minecraft/world/level/chunk/LevelChunk.java b/src/main/java/net/minecraft/world/level/chunk/LevelChunk.java
|
||||
index a63dc77db41dab79f03ef7384da55c1cdeca5d98..7cced5d06f296fcdc1209a43e7b3d1d9b47c0b26 100644
|
||||
--- a/src/main/java/net/minecraft/world/level/chunk/LevelChunk.java
|
||||
+++ b/src/main/java/net/minecraft/world/level/chunk/LevelChunk.java
|
||||
@@ -262,7 +262,7 @@ public class LevelChunk implements ChunkAccess {
|
||||
|
||||
// broadcast
|
||||
Object[] backingSet = inRange.getBackingSet();
|
||||
- Packet[] chunkPackets = new Packet[2];
|
||||
+ Packet[] chunkPackets = new Packet[10];
|
||||
for (int index = 0, len = backingSet.length; index < len; ++index) {
|
||||
Object temp = backingSet[index];
|
||||
if (!(temp instanceof net.minecraft.server.level.ServerPlayer)) {
|
|
@ -0,0 +1,322 @@
|
|||
From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
|
||||
From: Spottedleaf <spottedleaf@spottedleaf.dev>
|
||||
Date: Mon, 27 Apr 2020 04:05:38 -0700
|
||||
Subject: [PATCH] Stop copy-on-write operations for updating light data
|
||||
|
||||
Causes huge memory allocations + gc issues
|
||||
|
||||
1.17 update note: Needs updating, temp skipped
|
||||
|
||||
diff --git a/src/main/java/net/minecraft/world/level/lighting/BlockLightSectionStorage.java b/src/main/java/net/minecraft/world/level/lighting/BlockLightSectionStorage.java
|
||||
index 9f33fa8f84d10f8f4089030074ad6c0d81269ce8..a1ad4d73ddaf6afe97a1f1ff7e0622b52fac8761 100644
|
||||
--- a/src/main/java/net/minecraft/world/level/lighting/BlockLightSectionStorage.java
|
||||
+++ b/src/main/java/net/minecraft/world/level/lighting/BlockLightSectionStorage.java
|
||||
@@ -10,7 +10,7 @@ import net.minecraft.world.level.chunk.LightChunkGetter;
|
||||
public class BlockLightSectionStorage extends LayerLightSectionStorage<BlockLightSectionStorage.BlockDataLayerStorageMap> {
|
||||
|
||||
protected BlockLightSectionStorage(LightChunkGetter chunkProvider) {
|
||||
- super(LightLayer.BLOCK, chunkProvider, new BlockLightSectionStorage.BlockDataLayerStorageMap(new Long2ObjectOpenHashMap()));
|
||||
+ super(LightLayer.BLOCK, chunkProvider, new BlockLightSectionStorage.BlockDataLayerStorageMap(new com.destroystokyo.paper.util.map.QueuedChangesMapLong2Object<>(), false)); // Paper - avoid copying light data
|
||||
}
|
||||
|
||||
@Override
|
||||
@@ -23,13 +23,13 @@ public class BlockLightSectionStorage extends LayerLightSectionStorage<BlockLigh
|
||||
|
||||
public static final class BlockDataLayerStorageMap extends DataLayerStorageMap<BlockLightSectionStorage.BlockDataLayerStorageMap> {
|
||||
|
||||
- public BlockDataLayerStorageMap(Long2ObjectOpenHashMap<DataLayer> arrays) {
|
||||
- super(arrays);
|
||||
+ public BlockDataLayerStorageMap(com.destroystokyo.paper.util.map.QueuedChangesMapLong2Object<DataLayer> long2objectopenhashmap, boolean isVisible) { // Paper - avoid copying light data
|
||||
+ super(long2objectopenhashmap, isVisible); // Paper - avoid copying light data
|
||||
}
|
||||
|
||||
@Override
|
||||
public BlockLightSectionStorage.BlockDataLayerStorageMap copy() {
|
||||
- return new BlockLightSectionStorage.BlockDataLayerStorageMap(this.map.clone());
|
||||
+ return new BlockDataLayerStorageMap(this.data, true); // Paper - avoid copying light data
|
||||
}
|
||||
}
|
||||
}
|
||||
diff --git a/src/main/java/net/minecraft/world/level/lighting/DataLayerStorageMap.java b/src/main/java/net/minecraft/world/level/lighting/DataLayerStorageMap.java
|
||||
index 01ae1c811862f56317a90e3811fe2ef4b593695f..4c9041f1c1cb4b3ec114fbd0c5d4db50a6f2526d 100644
|
||||
--- a/src/main/java/net/minecraft/world/level/lighting/DataLayerStorageMap.java
|
||||
+++ b/src/main/java/net/minecraft/world/level/lighting/DataLayerStorageMap.java
|
||||
@@ -9,10 +9,23 @@ public abstract class DataLayerStorageMap<M extends DataLayerStorageMap<M>> {
|
||||
private final long[] lastSectionKeys = new long[2];
|
||||
private final DataLayer[] lastSections = new DataLayer[2];
|
||||
private boolean cacheEnabled;
|
||||
- protected final Long2ObjectOpenHashMap<DataLayer> map;
|
||||
-
|
||||
- protected DataLayerStorageMap(Long2ObjectOpenHashMap<DataLayer> arrays) {
|
||||
- this.map = arrays;
|
||||
+ protected final com.destroystokyo.paper.util.map.QueuedChangesMapLong2Object<DataLayer> data; // Paper - avoid copying light data
|
||||
+ protected final boolean isVisible; // Paper - avoid copying light data
|
||||
+ java.util.function.Function<Long, DataLayer> lookup; // Paper - faster branchless lookup
|
||||
+
|
||||
+ // Paper start - avoid copying light data
|
||||
+ protected DataLayerStorageMap(com.destroystokyo.paper.util.map.QueuedChangesMapLong2Object<DataLayer> data, boolean isVisible) {
|
||||
+ if (isVisible) {
|
||||
+ data.performUpdatesLockMap();
|
||||
+ }
|
||||
+ this.data = data;
|
||||
+ this.isVisible = isVisible;
|
||||
+ if (isVisible) {
|
||||
+ lookup = data::getVisibleAsync;
|
||||
+ } else {
|
||||
+ lookup = data::getUpdating;
|
||||
+ }
|
||||
+ // Paper end - avoid copying light data
|
||||
this.clearCache();
|
||||
this.cacheEnabled = true;
|
||||
}
|
||||
@@ -20,16 +33,17 @@ public abstract class DataLayerStorageMap<M extends DataLayerStorageMap<M>> {
|
||||
public abstract M copy();
|
||||
|
||||
public void copyDataLayer(long pos) {
|
||||
- this.map.put(pos, ((DataLayer) this.map.get(pos)).copy());
|
||||
+ if (this.isVisible) { throw new IllegalStateException("writing to visible data"); } // Paper - avoid copying light data
|
||||
+ this.data.queueUpdate(pos, ((DataLayer) this.data.getUpdating(pos)).copy()); // Paper - avoid copying light data
|
||||
this.clearCache();
|
||||
}
|
||||
|
||||
public boolean hasLayer(long chunkPos) {
|
||||
- return this.map.containsKey(chunkPos);
|
||||
+ return lookup.apply(chunkPos) != null; // Paper - avoid copying light data
|
||||
}
|
||||
|
||||
@Nullable
|
||||
- public DataLayer getLayer(long chunkPos) {
|
||||
+ public final DataLayer getLayer(long chunkPos) { // Paper - final
|
||||
if (this.cacheEnabled) {
|
||||
for (int j = 0; j < 2; ++j) {
|
||||
if (chunkPos == this.lastSectionKeys[j]) {
|
||||
@@ -38,7 +52,7 @@ public abstract class DataLayerStorageMap<M extends DataLayerStorageMap<M>> {
|
||||
}
|
||||
}
|
||||
|
||||
- DataLayer nibblearray = (DataLayer) this.map.get(chunkPos);
|
||||
+ DataLayer nibblearray = lookup.apply(chunkPos); // Paper - avoid copying light data
|
||||
|
||||
if (nibblearray == null) {
|
||||
return null;
|
||||
@@ -59,11 +73,13 @@ public abstract class DataLayerStorageMap<M extends DataLayerStorageMap<M>> {
|
||||
|
||||
@Nullable
|
||||
public DataLayer removeLayer(long chunkPos) {
|
||||
- return (DataLayer) this.map.remove(chunkPos);
|
||||
+ if (this.isVisible) { throw new IllegalStateException("writing to visible data"); } // Paper - avoid copying light data
|
||||
+ return (DataLayer) this.data.queueRemove(chunkPos); // Paper - avoid copying light data
|
||||
}
|
||||
|
||||
public void setLayer(long pos, DataLayer data) {
|
||||
- this.map.put(pos, data);
|
||||
+ if (this.isVisible) { throw new IllegalStateException("writing to visible data"); } // Paper - avoid copying light data
|
||||
+ this.data.queueUpdate(pos, data); // Paper - avoid copying light data
|
||||
}
|
||||
|
||||
public void clearCache() {
|
||||
@@ -71,7 +87,6 @@ public abstract class DataLayerStorageMap<M extends DataLayerStorageMap<M>> {
|
||||
this.lastSectionKeys[i] = Long.MAX_VALUE;
|
||||
this.lastSections[i] = null;
|
||||
}
|
||||
-
|
||||
}
|
||||
|
||||
public void disableCache() {
|
||||
diff --git a/src/main/java/net/minecraft/world/level/lighting/LayerLightSectionStorage.java b/src/main/java/net/minecraft/world/level/lighting/LayerLightSectionStorage.java
|
||||
index 45be10a0d7c26e4b6e5738ba994ce343265210f5..177dae992d13674bb285a60b8427df9ea843dc99 100644
|
||||
--- a/src/main/java/net/minecraft/world/level/lighting/LayerLightSectionStorage.java
|
||||
+++ b/src/main/java/net/minecraft/world/level/lighting/LayerLightSectionStorage.java
|
||||
@@ -26,8 +26,8 @@ public abstract class LayerLightSectionStorage<M extends DataLayerStorageMap<M>>
|
||||
protected final LongSet dataSectionSet = new LongOpenHashSet();
|
||||
protected final LongSet toMarkNoData = new LongOpenHashSet();
|
||||
protected final LongSet toMarkData = new LongOpenHashSet();
|
||||
- protected volatile M visibleSectionData;
|
||||
- protected final M updatingSectionData;
|
||||
+ protected volatile M e_visible; protected final Object visibleUpdateLock = new Object(); // Paper - diff on change, should be "visible" - force compile fail on usage change
|
||||
+ protected final M updatingSectionData; // Paper - diff on change, should be "updating"
|
||||
protected final LongSet changedSections = new LongOpenHashSet();
|
||||
protected final LongSet sectionsAffectedByLightUpdates = new LongOpenHashSet();
|
||||
protected final Long2ObjectMap<DataLayer> queuedSections = Long2ObjectMaps.synchronize(new Long2ObjectOpenHashMap());
|
||||
@@ -41,8 +41,8 @@ public abstract class LayerLightSectionStorage<M extends DataLayerStorageMap<M>>
|
||||
this.layer = lightType;
|
||||
this.chunkSource = chunkProvider;
|
||||
this.updatingSectionData = lightData;
|
||||
- this.visibleSectionData = lightData.copy();
|
||||
- this.visibleSectionData.disableCache();
|
||||
+ this.e_visible = lightData.copy(); // Paper - avoid copying light data
|
||||
+ this.e_visible.disableCache(); // Paper - avoid copying light data
|
||||
}
|
||||
|
||||
protected boolean storingLightForSection(long sectionPos) {
|
||||
@@ -51,7 +51,15 @@ public abstract class LayerLightSectionStorage<M extends DataLayerStorageMap<M>>
|
||||
|
||||
@Nullable
|
||||
protected DataLayer getDataLayer(long sectionPos, boolean cached) {
|
||||
- return this.getDataLayer(cached ? this.updatingSectionData : this.visibleSectionData, sectionPos);
|
||||
+ // Paper start - avoid copying light data
|
||||
+ if (cached) {
|
||||
+ return this.getDataLayer(this.updatingSectionData, sectionPos);
|
||||
+ } else {
|
||||
+ synchronized (this.visibleUpdateLock) {
|
||||
+ return this.getDataLayer(this.e_visible, sectionPos);
|
||||
+ }
|
||||
+ }
|
||||
+ // Paper end - avoid copying light data
|
||||
}
|
||||
|
||||
@Nullable
|
||||
@@ -364,10 +372,12 @@ public abstract class LayerLightSectionStorage<M extends DataLayerStorageMap<M>>
|
||||
|
||||
protected void swapSectionMap() {
|
||||
if (!this.changedSections.isEmpty()) {
|
||||
+ synchronized (this.visibleUpdateLock) { // Paper - avoid copying light data
|
||||
M m0 = this.updatingSectionData.copy();
|
||||
|
||||
m0.disableCache();
|
||||
- this.visibleSectionData = m0;
|
||||
+ this.e_visible = m0; // Paper - avoid copying light data
|
||||
+ } // Paper - avoid copying light data
|
||||
this.changedSections.clear();
|
||||
}
|
||||
|
||||
diff --git a/src/main/java/net/minecraft/world/level/lighting/SkyLightSectionStorage.java b/src/main/java/net/minecraft/world/level/lighting/SkyLightSectionStorage.java
|
||||
index c304637ae8f80c65b58e8ba8a27609b532bb1184..410fcfa8c01b7e3d3e3829ebdb92a11badff16ea 100644
|
||||
--- a/src/main/java/net/minecraft/world/level/lighting/SkyLightSectionStorage.java
|
||||
+++ b/src/main/java/net/minecraft/world/level/lighting/SkyLightSectionStorage.java
|
||||
@@ -23,15 +23,16 @@ public class SkyLightSectionStorage extends LayerLightSectionStorage<SkyLightSec
|
||||
private volatile boolean hasSourceInconsistencies;
|
||||
|
||||
protected SkyLightSectionStorage(LightChunkGetter chunkProvider) {
|
||||
- super(LightLayer.SKY, chunkProvider, new SkyLightSectionStorage.SkyDataLayerStorageMap(new Long2ObjectOpenHashMap(), new Long2IntOpenHashMap(), Integer.MAX_VALUE));
|
||||
+ super(LightLayer.SKY, chunkProvider, new SkyLightSectionStorage.SkyDataLayerStorageMap(new com.destroystokyo.paper.util.map.QueuedChangesMapLong2Object<>(), new com.destroystokyo.paper.util.map.QueuedChangesMapLong2Int(), Integer.MAX_VALUE, false)); // Paper - avoid copying light data
|
||||
}
|
||||
|
||||
@Override
|
||||
protected int getLightValue(long blockPos) {
|
||||
long j = SectionPos.blockToSection(blockPos);
|
||||
int k = SectionPos.y(j);
|
||||
- SkyLightSectionStorage.SkyDataLayerStorageMap lightenginestoragesky_a = (SkyLightSectionStorage.SkyDataLayerStorageMap) this.visibleSectionData;
|
||||
- int l = lightenginestoragesky_a.topSections.get(SectionPos.getZeroNode(j));
|
||||
+ synchronized (this.visibleUpdateLock) { // Paper - avoid copying light data
|
||||
+ SkyLightSectionStorage.SkyDataLayerStorageMap lightenginestoragesky_a = (SkyLightSectionStorage.SkyDataLayerStorageMap) this.e_visible; // Paper - avoid copying light data - must be after lock acquire
|
||||
+ int l = lightenginestoragesky_a.otherData.getVisibleAsync(SectionPos.getZeroNode(j)); // Paper - avoid copying light data
|
||||
|
||||
if (l != lightenginestoragesky_a.currentLowestY && k < l) {
|
||||
DataLayer nibblearray = this.getDataLayer(lightenginestoragesky_a, j); // Paper - decompile fix
|
||||
@@ -52,6 +53,7 @@ public class SkyLightSectionStorage extends LayerLightSectionStorage<SkyLightSec
|
||||
} else {
|
||||
return 15;
|
||||
}
|
||||
+ } // Paper - avoid copying light data
|
||||
}
|
||||
|
||||
@Override
|
||||
@@ -60,14 +62,14 @@ public class SkyLightSectionStorage extends LayerLightSectionStorage<SkyLightSec
|
||||
|
||||
if (((SkyLightSectionStorage.SkyDataLayerStorageMap) this.updatingSectionData).currentLowestY > j) {
|
||||
((SkyLightSectionStorage.SkyDataLayerStorageMap) this.updatingSectionData).currentLowestY = j;
|
||||
- ((SkyLightSectionStorage.SkyDataLayerStorageMap) this.updatingSectionData).topSections.defaultReturnValue(((SkyLightSectionStorage.SkyDataLayerStorageMap) this.updatingSectionData).currentLowestY);
|
||||
+ ((SkyLightSectionStorage.SkyDataLayerStorageMap) this.updatingSectionData).otherData.queueDefaultReturnValue(((SkyLightSectionStorage.SkyDataLayerStorageMap) this.updatingSectionData).currentLowestY); // Paper - avoid copying light data
|
||||
}
|
||||
|
||||
long k = SectionPos.getZeroNode(sectionPos);
|
||||
- int l = ((SkyLightSectionStorage.SkyDataLayerStorageMap) this.updatingSectionData).topSections.get(k);
|
||||
+ int l = ((SkyLightSectionStorage.SkyDataLayerStorageMap) this.updatingSectionData).otherData.getUpdating(k); // Paper - avoid copying light data
|
||||
|
||||
if (l < j + 1) {
|
||||
- ((SkyLightSectionStorage.SkyDataLayerStorageMap) this.updatingSectionData).topSections.put(k, j + 1);
|
||||
+ ((SkyLightSectionStorage.SkyDataLayerStorageMap) this.updatingSectionData).otherData.queueUpdate(k, j + 1); // Paper - avoid copying light data
|
||||
if (this.columnsWithSkySources.contains(k)) {
|
||||
this.queueAddSource(sectionPos);
|
||||
if (l > ((SkyLightSectionStorage.SkyDataLayerStorageMap) this.updatingSectionData).currentLowestY) {
|
||||
@@ -107,7 +109,7 @@ public class SkyLightSectionStorage extends LayerLightSectionStorage<SkyLightSec
|
||||
|
||||
int k = SectionPos.y(sectionPos);
|
||||
|
||||
- if (((SkyLightSectionStorage.SkyDataLayerStorageMap) this.updatingSectionData).topSections.get(j) == k + 1) {
|
||||
+ if (((SkyLightSectionStorage.SkyDataLayerStorageMap) this.updatingSectionData).otherData.getUpdating(j) == k + 1) { // Paper - avoid copying light data
|
||||
long l;
|
||||
|
||||
for (l = sectionPos; !this.storingLightForSection(l) && this.hasSectionsBelow(k); l = SectionPos.offset(l, Direction.DOWN)) {
|
||||
@@ -115,12 +117,12 @@ public class SkyLightSectionStorage extends LayerLightSectionStorage<SkyLightSec
|
||||
}
|
||||
|
||||
if (this.storingLightForSection(l)) {
|
||||
- ((SkyLightSectionStorage.SkyDataLayerStorageMap) this.updatingSectionData).topSections.put(j, k + 1);
|
||||
+ ((SkyLightSectionStorage.SkyDataLayerStorageMap) this.updatingSectionData).otherData.queueUpdate(j, k + 1); // Paper - avoid copying light data
|
||||
if (flag) {
|
||||
this.queueAddSource(l);
|
||||
}
|
||||
} else {
|
||||
- ((SkyLightSectionStorage.SkyDataLayerStorageMap) this.updatingSectionData).topSections.remove(j);
|
||||
+ ((SkyLightSectionStorage.SkyDataLayerStorageMap) this.updatingSectionData).otherData.queueRemove(j); // Paper - avoid copying light data
|
||||
}
|
||||
}
|
||||
|
||||
@@ -134,7 +136,7 @@ public class SkyLightSectionStorage extends LayerLightSectionStorage<SkyLightSec
|
||||
protected void enableLightSources(long columnPos, boolean enabled) {
|
||||
this.runAllUpdates();
|
||||
if (enabled && this.columnsWithSkySources.add(columnPos)) {
|
||||
- int j = ((SkyLightSectionStorage.SkyDataLayerStorageMap) this.updatingSectionData).topSections.get(columnPos);
|
||||
+ int j = ((SkyLightSectionStorage.SkyDataLayerStorageMap) this.updatingSectionData).otherData.getUpdating(columnPos); // Paper - avoid copying light data
|
||||
|
||||
if (j != ((SkyLightSectionStorage.SkyDataLayerStorageMap) this.updatingSectionData).currentLowestY) {
|
||||
long k = SectionPos.asLong(SectionPos.x(columnPos), j - 1, SectionPos.z(columnPos));
|
||||
@@ -161,7 +163,7 @@ public class SkyLightSectionStorage extends LayerLightSectionStorage<SkyLightSec
|
||||
return nibblearray;
|
||||
} else {
|
||||
long j = SectionPos.offset(sectionPos, Direction.UP);
|
||||
- int k = ((SkyLightSectionStorage.SkyDataLayerStorageMap) this.updatingSectionData).topSections.get(SectionPos.getZeroNode(sectionPos));
|
||||
+ int k = ((SkyLightSectionStorage.SkyDataLayerStorageMap) this.updatingSectionData).otherData.getUpdating(SectionPos.getZeroNode(sectionPos)); // Paper - avoid copying light data
|
||||
|
||||
if (k != ((SkyLightSectionStorage.SkyDataLayerStorageMap) this.updatingSectionData).currentLowestY && SectionPos.y(j) < k) {
|
||||
DataLayer nibblearray1;
|
||||
@@ -304,7 +306,7 @@ public class SkyLightSectionStorage extends LayerLightSectionStorage<SkyLightSec
|
||||
if (!this.columnsWithSkySources.contains(l)) {
|
||||
return false;
|
||||
} else {
|
||||
- int i1 = ((SkyLightSectionStorage.SkyDataLayerStorageMap) this.updatingSectionData).topSections.get(l);
|
||||
+ int i1 = ((SkyLightSectionStorage.SkyDataLayerStorageMap) this.updatingSectionData).otherData.getUpdating(l); // Paper - avoid copying light data
|
||||
|
||||
return SectionPos.sectionToBlockCoord(i1) == j + 16;
|
||||
}
|
||||
@@ -313,7 +315,7 @@ public class SkyLightSectionStorage extends LayerLightSectionStorage<SkyLightSec
|
||||
|
||||
protected boolean isAboveData(long sectionPos) {
|
||||
long j = SectionPos.getZeroNode(sectionPos);
|
||||
- int k = ((SkyLightSectionStorage.SkyDataLayerStorageMap) this.updatingSectionData).topSections.get(j);
|
||||
+ int k = ((SkyLightSectionStorage.SkyDataLayerStorageMap) this.updatingSectionData).otherData.getUpdating(j); // Paper - avoid copying light data
|
||||
|
||||
return k == ((SkyLightSectionStorage.SkyDataLayerStorageMap) this.updatingSectionData).currentLowestY || SectionPos.y(sectionPos) >= k;
|
||||
}
|
||||
@@ -327,18 +329,21 @@ public class SkyLightSectionStorage extends LayerLightSectionStorage<SkyLightSec
|
||||
public static final class SkyDataLayerStorageMap extends DataLayerStorageMap<SkyLightSectionStorage.SkyDataLayerStorageMap> {
|
||||
|
||||
private int currentLowestY;
|
||||
- private final Long2IntOpenHashMap topSections;
|
||||
-
|
||||
- public SkyDataLayerStorageMap(Long2ObjectOpenHashMap<DataLayer> arrays, Long2IntOpenHashMap columnToTopSection, int minSectionY) {
|
||||
- super(arrays);
|
||||
- this.topSections = columnToTopSection;
|
||||
- columnToTopSection.defaultReturnValue(minSectionY);
|
||||
- this.currentLowestY = minSectionY;
|
||||
+ private final com.destroystokyo.paper.util.map.QueuedChangesMapLong2Int otherData; // Paper - avoid copying light data
|
||||
+
|
||||
+ // Paper start - avoid copying light data
|
||||
+ public SkyDataLayerStorageMap(com.destroystokyo.paper.util.map.QueuedChangesMapLong2Object<DataLayer> data, com.destroystokyo.paper.util.map.QueuedChangesMapLong2Int otherData, int i, boolean isVisible) {
|
||||
+ super(data, isVisible);
|
||||
+ this.otherData = otherData;
|
||||
+ otherData.queueDefaultReturnValue(i);
|
||||
+ // Paper end - avoid copying light data
|
||||
+ this.currentLowestY = i;
|
||||
}
|
||||
|
||||
@Override
|
||||
public SkyLightSectionStorage.SkyDataLayerStorageMap copy() {
|
||||
- return new SkyLightSectionStorage.SkyDataLayerStorageMap(this.map.clone(), this.topSections.clone(), this.currentLowestY);
|
||||
+ this.otherData.performUpdatesLockMap(); // Paper - avoid copying light data
|
||||
+ return new SkyLightSectionStorage.SkyDataLayerStorageMap(this.data, this.otherData, this.currentLowestY, true); // Paper - avoid copying light data
|
||||
}
|
||||
}
|
||||
}
|
|
@ -0,0 +1,396 @@
|
|||
From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
|
||||
From: Aikar <aikar@aikar.co>
|
||||
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 :)
|
||||
|
||||
1.17 update note: ClientboundLightUpdatePacket has has made changes which necessitate updating this patch
|
||||
|
||||
diff --git a/src/main/java/net/minecraft/network/protocol/game/ClientboundLightUpdatePacket.java b/src/main/java/net/minecraft/network/protocol/game/ClientboundLightUpdatePacket.java
|
||||
index bc1b4cc2e0a4181bde5ac05ce0a20a651cb0c4c3..902f14e2e5ac5aa11b545a68ac69e9b0282df7f4 100644
|
||||
--- a/src/main/java/net/minecraft/network/protocol/game/ClientboundLightUpdatePacket.java
|
||||
+++ b/src/main/java/net/minecraft/network/protocol/game/ClientboundLightUpdatePacket.java
|
||||
@@ -1,12 +1,16 @@
|
||||
package net.minecraft.network.protocol.game;
|
||||
|
||||
import com.google.common.collect.Lists;
|
||||
+import io.netty.channel.ChannelFuture; // Paper
|
||||
+
|
||||
import java.io.IOException;
|
||||
import java.util.Iterator;
|
||||
import java.util.List;
|
||||
import net.minecraft.core.SectionPos;
|
||||
import net.minecraft.network.FriendlyByteBuf;
|
||||
import net.minecraft.network.protocol.Packet;
|
||||
+import net.minecraft.server.MCUtil;
|
||||
+import net.minecraft.server.level.ServerPlayer;
|
||||
import net.minecraft.world.level.ChunkPos;
|
||||
import net.minecraft.world.level.LightLayer;
|
||||
import net.minecraft.world.level.chunk.DataLayer;
|
||||
@@ -24,14 +28,43 @@ public class ClientboundLightUpdatePacket implements Packet<ClientGamePacketList
|
||||
private List<byte[]> blockUpdates;
|
||||
private boolean trustEdges;
|
||||
|
||||
+ // 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(ServerPlayer player) {
|
||||
+ remainingSends.incrementAndGet();
|
||||
+ }
|
||||
+
|
||||
+ @Override
|
||||
+ public void onPacketDispatchFinish(ServerPlayer player, ChannelFuture future) {
|
||||
+ if (remainingSends.decrementAndGet() <= 0) {
|
||||
+ // incase of any race conditions, schedule this delayed
|
||||
+ MCUtil.scheduleTask(5, () -> {
|
||||
+ if (remainingSends.get() == 0) {
|
||||
+ cleaner1.run();
|
||||
+ cleaner2.run();
|
||||
+ }
|
||||
+ }, "Light Packet Release");
|
||||
+ }
|
||||
+ }
|
||||
+
|
||||
+ @Override
|
||||
+ public boolean hasFinishListener() {
|
||||
+ return true;
|
||||
+ }
|
||||
+
|
||||
+ // Paper end
|
||||
public ClientboundLightUpdatePacket() {}
|
||||
|
||||
public ClientboundLightUpdatePacket(ChunkPos chunkcoordintpair, LevelLightEngine lightengine, boolean flag) {
|
||||
this.x = chunkcoordintpair.x;
|
||||
this.z = chunkcoordintpair.z;
|
||||
this.trustEdges = flag;
|
||||
- this.skyUpdates = Lists.newArrayList();
|
||||
- this.blockUpdates = Lists.newArrayList();
|
||||
+ this.skyUpdates = Lists.newArrayList();cleaner1 = MCUtil.registerListCleaner(this, this.skyUpdates, DataLayer::releaseBytes); // Paper
|
||||
+ this.blockUpdates = Lists.newArrayList();cleaner2 = MCUtil.registerListCleaner(this, this.blockUpdates, DataLayer::releaseBytes); // Paper
|
||||
|
||||
for (int i = 0; i < 18; ++i) {
|
||||
DataLayer nibblearray = lightengine.getLayerListener(LightLayer.SKY).getDataLayerData(SectionPos.of(chunkcoordintpair, -1 + i));
|
||||
@@ -42,7 +75,7 @@ public class ClientboundLightUpdatePacket implements Packet<ClientGamePacketList
|
||||
this.emptySkyYMask |= 1 << i;
|
||||
} else {
|
||||
this.skyYMask |= 1 << i;
|
||||
- this.skyUpdates.add(nibblearray.getData().clone());
|
||||
+ this.skyUpdates.add(nibblearray.getCloneIfSet()); // Paper
|
||||
}
|
||||
}
|
||||
|
||||
@@ -51,7 +84,7 @@ public class ClientboundLightUpdatePacket implements Packet<ClientGamePacketList
|
||||
this.emptyBlockYMask |= 1 << i;
|
||||
} else {
|
||||
this.blockYMask |= 1 << i;
|
||||
- this.blockUpdates.add(nibblearray1.getData().clone());
|
||||
+ this.blockUpdates.add(nibblearray1.getCloneIfSet()); // Paper
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -64,8 +97,8 @@ public class ClientboundLightUpdatePacket implements Packet<ClientGamePacketList
|
||||
this.trustEdges = flag;
|
||||
this.skyYMask = skyLightMask;
|
||||
this.blockYMask = blockLightMask;
|
||||
- this.skyUpdates = Lists.newArrayList();
|
||||
- this.blockUpdates = Lists.newArrayList();
|
||||
+ this.skyUpdates = Lists.newArrayList();cleaner1 = MCUtil.registerListCleaner(this, this.skyUpdates, DataLayer::releaseBytes); // Paper
|
||||
+ this.blockUpdates = Lists.newArrayList();cleaner2 = MCUtil.registerListCleaner(this, this.blockUpdates, DataLayer::releaseBytes); // Paper
|
||||
|
||||
for (int k = 0; k < 18; ++k) {
|
||||
DataLayer nibblearray;
|
||||
@@ -73,7 +106,7 @@ public class ClientboundLightUpdatePacket implements Packet<ClientGamePacketList
|
||||
if ((this.skyYMask & 1 << k) != 0) {
|
||||
nibblearray = lightProvider.getLayerListener(LightLayer.SKY).getDataLayerData(SectionPos.of(pos, -1 + k));
|
||||
if (nibblearray != null && !nibblearray.isEmpty()) {
|
||||
- this.skyUpdates.add(nibblearray.getData().clone());
|
||||
+ this.skyUpdates.add(nibblearray.getCloneIfSet()); // Paper
|
||||
} else {
|
||||
this.skyYMask &= ~(1 << k);
|
||||
if (nibblearray != null) {
|
||||
@@ -85,7 +118,7 @@ public class ClientboundLightUpdatePacket implements Packet<ClientGamePacketList
|
||||
if ((this.blockYMask & 1 << k) != 0) {
|
||||
nibblearray = lightProvider.getLayerListener(LightLayer.BLOCK).getDataLayerData(SectionPos.of(pos, -1 + k));
|
||||
if (nibblearray != null && !nibblearray.isEmpty()) {
|
||||
- this.blockUpdates.add(nibblearray.getData().clone());
|
||||
+ this.blockUpdates.add(nibblearray.getCloneIfSet()); // Paper
|
||||
} else {
|
||||
this.blockYMask &= ~(1 << k);
|
||||
if (nibblearray != null) {
|
||||
diff --git a/src/main/java/net/minecraft/world/level/chunk/DataLayer.java b/src/main/java/net/minecraft/world/level/chunk/DataLayer.java
|
||||
index 2b798f4e556302f6f79d54182a309f4716a84f04..83e9d8bff9a31fe13a0e22445cd6eecb7abe8561 100644
|
||||
--- a/src/main/java/net/minecraft/world/level/chunk/DataLayer.java
|
||||
+++ b/src/main/java/net/minecraft/world/level/chunk/DataLayer.java
|
||||
@@ -1,18 +1,78 @@
|
||||
// mc-dev import
|
||||
package net.minecraft.world.level.chunk;
|
||||
|
||||
+import com.destroystokyo.paper.util.pooled.PooledObjects; // Paper
|
||||
+
|
||||
+import javax.annotation.Nonnull;
|
||||
import javax.annotation.Nullable;
|
||||
import net.minecraft.Util;
|
||||
+import net.minecraft.server.MCUtil;
|
||||
|
||||
public class DataLayer {
|
||||
|
||||
- @Nullable
|
||||
- protected byte[] data;
|
||||
+ // Paper start
|
||||
+ public static byte[] EMPTY_NIBBLE = new byte[2048];
|
||||
+ private static final int nibbleBucketSizeMultiplier = Integer.getInteger("Paper.nibbleBucketSize", 3072);
|
||||
+ private static final int maxPoolSize = Integer.getInteger("Paper.maxNibblePoolSize", (int) Math.min(6, Math.max(1, Runtime.getRuntime().maxMemory() / 1024 / 1024 / 1024)) * (nibbleBucketSizeMultiplier * 8));
|
||||
+ public static final PooledObjects<byte[]> 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 DataLayer markPoolSafe(byte[] bytes) {
|
||||
+ if (bytes != EMPTY_NIBBLE) this.data = bytes;
|
||||
+ return markPoolSafe();
|
||||
+ }
|
||||
+ public DataLayer markPoolSafe() {
|
||||
+ poolSafe = true;
|
||||
+ return this;
|
||||
+ }
|
||||
+ public byte[] getIfSet() {
|
||||
+ return this.data != null ? this.data : EMPTY_NIBBLE;
|
||||
+ }
|
||||
+ public byte[] getCloneIfSet() {
|
||||
+ if (data == null) {
|
||||
+ return EMPTY_NIBBLE;
|
||||
+ }
|
||||
+ byte[] ret = BYTE_2048.acquire();
|
||||
+ System.arraycopy(getIfSet(), 0, ret, 0, 2048);
|
||||
+ return ret;
|
||||
+ }
|
||||
+
|
||||
+ public DataLayer cloneAndSet(byte[] bytes) {
|
||||
+ if (bytes != null && bytes != EMPTY_NIBBLE) {
|
||||
+ this.data = BYTE_2048.acquire();
|
||||
+ System.arraycopy(bytes, 0, this.data, 0, 2048);
|
||||
+ }
|
||||
+ return this;
|
||||
+ }
|
||||
+ boolean poolSafe = false;
|
||||
+ public java.lang.Runnable cleaner;
|
||||
+ private void registerCleaner() {
|
||||
+ if (!poolSafe) {
|
||||
+ cleaner = MCUtil.registerCleaner(this, this.data, DataLayer::releaseBytes);
|
||||
+ } else {
|
||||
+ cleaner = MCUtil.once(() -> DataLayer.releaseBytes(this.data));
|
||||
+ }
|
||||
+ }
|
||||
+ // Paper end
|
||||
+ @Nullable protected byte[] data;
|
||||
+
|
||||
|
||||
public DataLayer() {}
|
||||
|
||||
public DataLayer(byte[] abyte) {
|
||||
+ // Paper start
|
||||
+ this(abyte, false);
|
||||
+ }
|
||||
+ public DataLayer(byte[] abyte, boolean isSafe) {
|
||||
this.data = abyte;
|
||||
+ if (!isSafe) this.data = getCloneIfSet(); // Paper - clone for safety
|
||||
+ registerCleaner();
|
||||
+ // Paper end
|
||||
if (abyte.length != 2048) {
|
||||
throw (IllegalArgumentException) Util.pauseInIde((Throwable) (new IllegalArgumentException("ChunkNibbleArrays should be 2048 bytes not: " + abyte.length)));
|
||||
}
|
||||
@@ -46,7 +106,8 @@ public class DataLayer {
|
||||
|
||||
public void set(int index, int value) { // PAIL: private -> public
|
||||
if (this.data == null) {
|
||||
- this.data = new byte[2048];
|
||||
+ this.data = BYTE_2048.acquire(); // Paper
|
||||
+ registerCleaner();// Paper
|
||||
}
|
||||
|
||||
int k = this.getPosition(index);
|
||||
@@ -68,14 +129,36 @@ public class DataLayer {
|
||||
public byte[] getData() {
|
||||
if (this.data == null) {
|
||||
this.data = 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.data = this.data.clone();
|
||||
+ cleaner.run(); // release the previously pooled value
|
||||
+ this.cleaner = null;
|
||||
+ }
|
||||
+ }
|
||||
+ // Paper end
|
||||
+
|
||||
+ return this.data;
|
||||
+ }
|
||||
+
|
||||
+ @Nonnull
|
||||
+ public byte[] asBytesPoolSafe() {
|
||||
+ if (this.data == null) {
|
||||
+ this.data = BYTE_2048.acquire(); // Paper
|
||||
+ registerCleaner(); // Paper
|
||||
}
|
||||
|
||||
+ //noinspection ConstantConditions
|
||||
return this.data;
|
||||
}
|
||||
+ // Paper end
|
||||
|
||||
public DataLayer copy() { return this.copy(); } // Paper - OBFHELPER
|
||||
public DataLayer copy() {
|
||||
- return this.data == null ? new DataLayer() : new DataLayer((byte[]) this.data.clone());
|
||||
+ return this.data == null ? new DataLayer() : new DataLayer(this.data); // Paper - clone in ctor
|
||||
}
|
||||
|
||||
public String toString() {
|
||||
diff --git a/src/main/java/net/minecraft/world/level/chunk/storage/ChunkSerializer.java b/src/main/java/net/minecraft/world/level/chunk/storage/ChunkSerializer.java
|
||||
index 6c28a611b9b79c3322ab07883972c07b3bfc3073..1e58958c3d7b10da5a5f22fc9591d9183e53e3cc 100644
|
||||
--- a/src/main/java/net/minecraft/world/level/chunk/storage/ChunkSerializer.java
|
||||
+++ b/src/main/java/net/minecraft/world/level/chunk/storage/ChunkSerializer.java
|
||||
@@ -435,11 +435,11 @@ public class ChunkSerializer {
|
||||
}
|
||||
|
||||
if (nibblearray != null && !nibblearray.isEmpty()) {
|
||||
- nbttagcompound2.putByteArray("BlockLight", nibblearray.getData());
|
||||
+ nbttagcompound2.putByteArray("BlockLight", nibblearray.asBytesPoolSafe().clone()); // Paper
|
||||
}
|
||||
|
||||
if (nibblearray1 != null && !nibblearray1.isEmpty()) {
|
||||
- nbttagcompound2.putByteArray("SkyLight", nibblearray1.getData());
|
||||
+ nbttagcompound2.putByteArray("SkyLight", nibblearray1.asBytesPoolSafe().clone()); // Paper
|
||||
}
|
||||
|
||||
nbttaglist.add(nbttagcompound2);
|
||||
diff --git a/src/main/java/net/minecraft/world/level/lighting/DataLayerStorageMap.java b/src/main/java/net/minecraft/world/level/lighting/DataLayerStorageMap.java
|
||||
index 4c9041f1c1cb4b3ec114fbd0c5d4db50a6f2526d..54cca3b376e5ce02936edc8b9c17e67e17f07147 100644
|
||||
--- a/src/main/java/net/minecraft/world/level/lighting/DataLayerStorageMap.java
|
||||
+++ b/src/main/java/net/minecraft/world/level/lighting/DataLayerStorageMap.java
|
||||
@@ -2,6 +2,7 @@ package net.minecraft.world.level.lighting;
|
||||
|
||||
import it.unimi.dsi.fastutil.longs.Long2ObjectOpenHashMap;
|
||||
import javax.annotation.Nullable;
|
||||
+import net.minecraft.server.MCUtil;
|
||||
import net.minecraft.world.level.chunk.DataLayer;
|
||||
|
||||
public abstract class DataLayerStorageMap<M extends DataLayerStorageMap<M>> {
|
||||
@@ -34,7 +35,9 @@ public abstract class DataLayerStorageMap<M extends DataLayerStorageMap<M>> {
|
||||
|
||||
public void copyDataLayer(long pos) {
|
||||
if (this.isVisible) { throw new IllegalStateException("writing to visible data"); } // Paper - avoid copying light data
|
||||
- this.data.queueUpdate(pos, ((DataLayer) this.data.getUpdating(pos)).copy()); // Paper - avoid copying light data
|
||||
+ DataLayer updating = this.data.getUpdating(pos); // Paper - pool nibbles
|
||||
+ this.data.queueUpdate(pos, new DataLayer().markPoolSafe(updating.getCloneIfSet())); // Paper - avoid copying light data - pool safe clone
|
||||
+ if (updating.cleaner != null) MCUtil.scheduleTask(2, updating.cleaner, "Light Engine Release"); // Paper - delay clean incase anything holding ref was still using it
|
||||
this.clearCache();
|
||||
}
|
||||
|
||||
diff --git a/src/main/java/net/minecraft/world/level/lighting/FlatDataLayer.java b/src/main/java/net/minecraft/world/level/lighting/FlatDataLayer.java
|
||||
index 9b95ae0ff193d7f52650f406c70e76e3f7e07e1c..c0d356ac4d54b952fe9ddaf5125b07177ac44d1f 100644
|
||||
--- a/src/main/java/net/minecraft/world/level/lighting/FlatDataLayer.java
|
||||
+++ b/src/main/java/net/minecraft/world/level/lighting/FlatDataLayer.java
|
||||
@@ -10,7 +10,7 @@ public class FlatDataLayer extends DataLayer {
|
||||
|
||||
public FlatDataLayer(DataLayer nibblearray, int i) {
|
||||
super(128);
|
||||
- System.arraycopy(nibblearray.getData(), i * 128, this.data, 0, 128);
|
||||
+ System.arraycopy(nibblearray.getIfSet(), i * 128, this.data, 0, 128); // Paper
|
||||
}
|
||||
|
||||
@Override
|
||||
@@ -20,7 +20,7 @@ public class FlatDataLayer extends DataLayer {
|
||||
|
||||
@Override
|
||||
public byte[] getData() {
|
||||
- byte[] abyte = new byte[2048];
|
||||
+ byte[] abyte = BYTE_2048.acquire(); // Paper
|
||||
|
||||
for (int i = 0; i < 16; ++i) {
|
||||
System.arraycopy(this.data, 0, abyte, i * 128, 128);
|
||||
diff --git a/src/main/java/net/minecraft/world/level/lighting/LayerLightSectionStorage.java b/src/main/java/net/minecraft/world/level/lighting/LayerLightSectionStorage.java
|
||||
index 177dae992d13674bb285a60b8427df9ea843dc99..5757bcfded35f112d52a7c81586850ba50e0d8dd 100644
|
||||
--- a/src/main/java/net/minecraft/world/level/lighting/LayerLightSectionStorage.java
|
||||
+++ b/src/main/java/net/minecraft/world/level/lighting/LayerLightSectionStorage.java
|
||||
@@ -156,7 +156,7 @@ public abstract class LayerLightSectionStorage<M extends DataLayerStorageMap<M>>
|
||||
protected DataLayer createDataLayer(long sectionPos) {
|
||||
DataLayer nibblearray = (DataLayer) this.queuedSections.get(sectionPos);
|
||||
|
||||
- return nibblearray != null ? nibblearray : new DataLayer();
|
||||
+ return nibblearray != null ? nibblearray : new DataLayer().markPoolSafe(); // Paper
|
||||
}
|
||||
|
||||
protected void clearQueuedSectionBlocks(LayerLightEngine<?, ?> storage, long sectionPos) {
|
||||
@@ -338,12 +338,12 @@ public abstract class LayerLightSectionStorage<M extends DataLayerStorageMap<M>>
|
||||
|
||||
protected void queueSectionData(long sectionPos, @Nullable DataLayer array, boolean flag) {
|
||||
if (array != null) {
|
||||
- this.queuedSections.put(sectionPos, array);
|
||||
+ DataLayer remove = this.queuedSections.put(sectionPos, array); if (remove != null && remove.cleaner != null) remove.cleaner.run(); // Paper - clean up when removed
|
||||
if (!flag) {
|
||||
this.untrustedSections.add(sectionPos);
|
||||
}
|
||||
} else {
|
||||
- this.queuedSections.remove(sectionPos);
|
||||
+ DataLayer remove = this.queuedSections.remove(sectionPos); if (remove != null && remove.cleaner != null) remove.cleaner.run(); // Paper - clean up when removed
|
||||
}
|
||||
|
||||
}
|
||||
diff --git a/src/main/java/net/minecraft/world/level/lighting/SkyLightSectionStorage.java b/src/main/java/net/minecraft/world/level/lighting/SkyLightSectionStorage.java
|
||||
index 410fcfa8c01b7e3d3e3829ebdb92a11badff16ea..88f168f9d4c29cfc93500227bf8a60de4b6e4d8a 100644
|
||||
--- a/src/main/java/net/minecraft/world/level/lighting/SkyLightSectionStorage.java
|
||||
+++ b/src/main/java/net/minecraft/world/level/lighting/SkyLightSectionStorage.java
|
||||
@@ -172,9 +172,9 @@ public class SkyLightSectionStorage extends LayerLightSectionStorage<SkyLightSec
|
||||
j = SectionPos.offset(j, Direction.UP);
|
||||
}
|
||||
|
||||
- return new DataLayer((new FlatDataLayer(nibblearray1, 0)).getData());
|
||||
+ return new DataLayer().markPoolSafe(new FlatDataLayer(nibblearray1, 0).getData()); // Paper - mark pool use as safe (no auto cleaner)
|
||||
} else {
|
||||
- return new DataLayer();
|
||||
+ return new DataLayer().markPoolSafe(); // Paper - mark pool use as safe (no auto cleaner)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -203,7 +203,7 @@ public class SkyLightSectionStorage extends LayerLightSectionStorage<SkyLightSec
|
||||
((SkyLightSectionStorage.SkyDataLayerStorageMap) this.updatingSectionData).copyDataLayer(i);
|
||||
}
|
||||
|
||||
- Arrays.fill(this.getDataLayer(i, true).getData(), (byte) -1);
|
||||
+ Arrays.fill(this.getDataLayer(i, true).asBytesPoolSafe(), (byte) -1); // Paper
|
||||
k = SectionPos.sectionToBlockCoord(SectionPos.x(i));
|
||||
l = SectionPos.sectionToBlockCoord(SectionPos.y(i));
|
||||
int i1 = SectionPos.sectionToBlockCoord(SectionPos.z(i));
|
||||
diff --git a/src/main/java/org/bukkit/craftbukkit/CraftChunk.java b/src/main/java/org/bukkit/craftbukkit/CraftChunk.java
|
||||
index 0f45f4b2486e910d11fd94b260bcd68e49eae31e..77584a2552c0d59d4308342253ad42edaa794c97 100644
|
||||
--- a/src/main/java/org/bukkit/craftbukkit/CraftChunk.java
|
||||
+++ b/src/main/java/org/bukkit/craftbukkit/CraftChunk.java
|
||||
@@ -298,14 +298,14 @@ public class CraftChunk implements Chunk {
|
||||
sectionSkyLights[i] = emptyLight;
|
||||
} else {
|
||||
sectionSkyLights[i] = new byte[2048];
|
||||
- System.arraycopy(skyLightArray.getData(), 0, sectionSkyLights[i], 0, 2048);
|
||||
+ System.arraycopy(skyLightArray.getIfSet(), 0, sectionSkyLights[i], 0, 2048); // Paper
|
||||
}
|
||||
DataLayer emitLightArray = lightengine.getLayerListener(LightLayer.BLOCK).getDataLayerData(SectionPos.of(x, i, z));
|
||||
if (emitLightArray == null) {
|
||||
sectionEmitLights[i] = emptyLight;
|
||||
} else {
|
||||
sectionEmitLights[i] = new byte[2048];
|
||||
- System.arraycopy(emitLightArray.getData(), 0, sectionEmitLights[i], 0, 2048);
|
||||
+ System.arraycopy(emitLightArray.getIfSet(), 0, sectionEmitLights[i], 0, 2048); // Paper
|
||||
}
|
||||
}
|
||||
}
|
Loading…
Add table
Add a link
Reference in a new issue