2021-06-11 14:02:28 +02:00
From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
From: Spottedleaf <Spottedleaf@users.noreply.github.com>
Date: Sat, 15 Jun 2019 08:54:33 -0700
Subject: [PATCH] Fix World#isChunkGenerated calls
Optimize World#loadChunk() too
This patch also adds a chunk status cache on region files (note that
its only purpose is to cache the status on DISK)
diff --git a/src/main/java/net/minecraft/server/level/ChunkMap.java b/src/main/java/net/minecraft/server/level/ChunkMap.java
2024-01-21 12:53:04 +01:00
index 45ee0cd242271883412284625230822d9c8a5452..56f52d4b9c1af6a04d464640ed06b841a47b4cd9 100644
2021-06-11 14:02:28 +02:00
--- a/src/main/java/net/minecraft/server/level/ChunkMap.java
+++ b/src/main/java/net/minecraft/server/level/ChunkMap.java
2023-12-25 23:51:56 +01:00
@@ -679,9 +679,13 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider
2023-09-22 22:13:57 +02:00
// Paper end
2022-06-08 04:25:49 +02:00
private CompletableFuture<Optional<CompoundTag>> readChunk(ChunkPos chunkPos) {
- return this.read(chunkPos).thenApplyAsync((optional) -> {
- return optional.map((nbttagcompound) -> this.upgradeChunkTag(nbttagcompound, chunkPos)); // CraftBukkit
- }, Util.backgroundExecutor());
+ // Paper start - Cache chunk status on disk
+ try {
+ return CompletableFuture.completedFuture(Optional.ofNullable(this.readConvertChunkSync(chunkPos)));
+ } catch (Throwable thr) {
+ return CompletableFuture.failedFuture(thr);
+ }
+ // Paper end - Cache chunk status on disk
}
// CraftBukkit start
2023-12-25 23:51:56 +01:00
@@ -690,6 +694,63 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider
2022-06-08 04:25:49 +02:00
// CraftBukkit end
}
+ // Paper start - Cache chunk status on disk
+ @Nullable
+ public CompoundTag readConvertChunkSync(ChunkPos pos) throws IOException {
+ CompoundTag nbttagcompound = this.readSync(pos);
2021-06-11 14:02:28 +02:00
+ // Paper start - Cache chunk status on disk
+ if (nbttagcompound == null) {
+ return null;
+ }
+
2022-06-08 04:25:49 +02:00
+ nbttagcompound = this.upgradeChunkTag(nbttagcompound, pos); // CraftBukkit
2021-06-11 14:02:28 +02:00
+ if (nbttagcompound == null) {
+ return null;
+ }
+
+ this.updateChunkStatusOnDisk(pos, nbttagcompound);
+
+ return nbttagcompound;
+ // Paper end
+ }
+
+ // Paper start - chunk status cache "api"
+ public ChunkStatus getChunkStatusOnDiskIfCached(ChunkPos chunkPos) {
2022-06-08 04:25:49 +02:00
+ net.minecraft.world.level.chunk.storage.RegionFile regionFile = regionFileCache.getRegionFileIfLoaded(chunkPos);
+
2021-06-11 14:02:28 +02:00
+ return regionFile == null ? null : regionFile.getStatusIfCached(chunkPos.x, chunkPos.z);
2022-06-08 04:25:49 +02:00
+ }
+
2021-06-11 14:02:28 +02:00
+ public ChunkStatus getChunkStatusOnDisk(ChunkPos chunkPos) throws IOException {
2022-06-08 04:25:49 +02:00
+ net.minecraft.world.level.chunk.storage.RegionFile regionFile = regionFileCache.getRegionFile(chunkPos, true);
2021-06-11 14:02:28 +02:00
+
2021-06-13 15:46:28 +02:00
+ if (regionFile == null || !regionFileCache.chunkExists(chunkPos)) {
2021-06-11 14:02:28 +02:00
+ return null;
+ }
+
+ ChunkStatus status = regionFile.getStatusIfCached(chunkPos.x, chunkPos.z);
+
+ if (status != null) {
+ return status;
+ }
+
+ this.readChunk(chunkPos);
2021-06-13 15:46:28 +02:00
+
2021-06-11 14:02:28 +02:00
+ return regionFile.getStatusIfCached(chunkPos.x, chunkPos.z);
2021-06-13 15:46:28 +02:00
+ }
+
2021-06-11 14:02:28 +02:00
+ public void updateChunkStatusOnDisk(ChunkPos chunkPos, @Nullable CompoundTag compound) throws IOException {
2022-06-08 04:25:49 +02:00
+ net.minecraft.world.level.chunk.storage.RegionFile regionFile = regionFileCache.getRegionFile(chunkPos, false);
2021-06-11 14:02:28 +02:00
+
+ regionFile.setStatus(chunkPos.x, chunkPos.z, ChunkSerializer.getStatus(compound));
+ }
+
+ public ChunkAccess getUnloadingChunk(int chunkX, int chunkZ) {
2022-10-24 21:43:46 +02:00
+ ChunkHolder chunkHolder = io.papermc.paper.chunk.system.ChunkSystem.getUnloadingChunkHolder(this.level, chunkX, chunkZ);
2021-06-11 14:02:28 +02:00
+ return chunkHolder == null ? null : chunkHolder.getAvailableChunkNow();
+ }
2024-01-21 12:53:04 +01:00
+ // Paper end - Cache chunk status on disk
2021-06-11 14:02:28 +02:00
+
2021-11-24 05:25:34 +01:00
boolean anyPlayerCloseEnoughForSpawning(ChunkPos pos) {
2021-06-11 14:02:28 +02:00
// Spigot start
2021-11-24 05:25:34 +01:00
return this.anyPlayerCloseEnoughForSpawning(pos, false);
2021-06-11 14:02:28 +02:00
diff --git a/src/main/java/net/minecraft/world/level/chunk/storage/RegionFile.java b/src/main/java/net/minecraft/world/level/chunk/storage/RegionFile.java
2024-01-21 12:53:04 +01:00
index 69ed808ca5fbfb9191d0818bb0f1c839d11d9d11..0ae3d1ea6f00efcdea5da5bf1a0f984f4473f5a2 100644
2021-06-11 14:02:28 +02:00
--- a/src/main/java/net/minecraft/world/level/chunk/storage/RegionFile.java
+++ b/src/main/java/net/minecraft/world/level/chunk/storage/RegionFile.java
2023-09-22 04:17:21 +02:00
@@ -50,6 +50,30 @@ public class RegionFile implements AutoCloseable {
2023-09-23 00:33:14 +02:00
public final java.util.concurrent.locks.ReentrantLock fileLock = new java.util.concurrent.locks.ReentrantLock(); // Paper
2021-11-24 05:25:34 +01:00
public final Path regionFile; // Paper
2021-06-11 14:02:28 +02:00
+ // Paper start - Cache chunk status
2022-03-01 06:43:03 +01:00
+ private final net.minecraft.world.level.chunk.ChunkStatus[] statuses = new net.minecraft.world.level.chunk.ChunkStatus[32 * 32];
2021-06-11 14:02:28 +02:00
+
+ private boolean closed;
+
+ // invoked on write/read
2022-03-01 06:43:03 +01:00
+ public void setStatus(int x, int z, net.minecraft.world.level.chunk.ChunkStatus status) {
2021-06-11 14:02:28 +02:00
+ if (this.closed) {
+ // We've used an invalid region file.
+ throw new IllegalStateException("RegionFile is closed");
+ }
+ this.statuses[getChunkLocation(x, z)] = status;
+ }
+
2022-03-01 06:43:03 +01:00
+ public net.minecraft.world.level.chunk.ChunkStatus getStatusIfCached(int x, int z) {
2021-06-11 14:02:28 +02:00
+ if (this.closed) {
+ // We've used an invalid region file.
+ throw new IllegalStateException("RegionFile is closed");
+ }
+ final int location = getChunkLocation(x, z);
+ return this.statuses[location];
+ }
2024-01-21 12:53:04 +01:00
+ // Paper end - Cache chunk status
2021-06-11 14:02:28 +02:00
+
2021-11-24 23:26:32 +01:00
public RegionFile(Path file, Path directory, boolean dsync) throws IOException {
this(file, directory, RegionFileVersion.VERSION_DEFLATE, dsync);
2021-06-11 14:02:28 +02:00
}
2023-09-22 22:13:57 +02:00
@@ -397,6 +421,7 @@ public class RegionFile implements AutoCloseable {
2021-06-11 14:02:28 +02:00
return this.getOffset(pos) != 0;
}
2024-01-21 12:53:04 +01:00
+ private static int getChunkLocation(int x, int z) { return (x & 31) + (z & 31) * 32; } // Paper - Cache chunk status; OBFHELPER - sort of, mirror of logic below
2021-06-11 14:02:28 +02:00
private static int getOffsetIndex(ChunkPos pos) {
return pos.getRegionLocalX() + pos.getRegionLocalZ() * 32;
}
2023-09-22 22:13:57 +02:00
@@ -407,6 +432,7 @@ public class RegionFile implements AutoCloseable {
synchronized (this) {
try {
// Paper end
2024-01-21 12:53:04 +01:00
+ this.closed = true; // Paper - Cache chunk status
2021-06-11 14:02:28 +02:00
try {
this.padToFullSector();
} finally {
diff --git a/src/main/java/net/minecraft/world/level/chunk/storage/RegionFileStorage.java b/src/main/java/net/minecraft/world/level/chunk/storage/RegionFileStorage.java
2024-01-21 12:53:04 +01:00
index affd43308ac565066cefa799238e46b75a28b270..8563383d45f89ee01dd5df13af5bd0cf1b3d7b01 100644
2021-06-11 14:02:28 +02:00
--- a/src/main/java/net/minecraft/world/level/chunk/storage/RegionFileStorage.java
+++ b/src/main/java/net/minecraft/world/level/chunk/storage/RegionFileStorage.java
2024-01-21 12:53:04 +01:00
@@ -261,6 +261,7 @@ public class RegionFileStorage implements AutoCloseable {
2021-06-11 14:02:28 +02:00
2021-06-13 15:46:28 +02:00
try {
NbtIo.write(nbt, (DataOutput) dataoutputstream);
2024-01-21 12:53:04 +01:00
+ regionfile.setStatus(pos.x, pos.z, ChunkSerializer.getStatus(nbt)); // Paper - Cache chunk status
2021-06-16 08:25:38 +02:00
regionfile.setOversized(pos.x, pos.z, false); // Paper - We don't do this anymore, mojang stores differently, but clear old meta flag if it exists to get rid of our own meta file once last oversized is gone
2021-06-13 15:46:28 +02:00
} catch (Throwable throwable) {
if (dataoutputstream != null) {
2021-06-11 14:02:28 +02:00
diff --git a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
2024-01-21 12:53:04 +01:00
index af027128cc06f877f745296b2320e1bca29fd02b..d4518b9c1338226a9a814d2512aaddbb76a42da8 100644
2021-06-11 14:02:28 +02:00
--- a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
+++ b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
2023-12-25 23:51:56 +01:00
@@ -310,9 +310,23 @@ public class CraftWorld extends CraftRegionAccessor implements World {
2021-06-11 14:02:28 +02:00
@Override
public boolean isChunkGenerated(int x, int z) {
+ // Paper start - Fix this method
+ if (!Bukkit.isPrimaryThread()) {
2022-06-08 04:25:49 +02:00
+ return java.util.concurrent.CompletableFuture.supplyAsync(() -> {
2021-06-11 14:02:28 +02:00
+ return CraftWorld.this.isChunkGenerated(x, z);
+ }, world.getChunkSource().mainThreadProcessor).join();
+ }
+ ChunkAccess chunk = world.getChunkSource().getChunkAtImmediately(x, z);
+ if (chunk == null) {
+ chunk = world.getChunkSource().chunkMap.getUnloadingChunk(x, z);
+ }
+ if (chunk != null) {
+ return chunk instanceof ImposterProtoChunk || chunk instanceof net.minecraft.world.level.chunk.LevelChunk;
+ }
try {
2022-06-08 04:25:49 +02:00
- return this.isChunkLoaded(x, z) || this.world.getChunkSource().chunkMap.read(new ChunkPos(x, z)).get().isPresent();
- } catch (InterruptedException | ExecutionException ex) {
2021-06-11 14:02:28 +02:00
+ return world.getChunkSource().chunkMap.getChunkStatusOnDisk(new ChunkPos(x, z)) == ChunkStatus.FULL;
2022-12-08 04:24:00 +01:00
+ } catch (java.io.IOException ex) {
2024-01-21 12:53:04 +01:00
+ // Paper end - Fix this method
2021-06-11 14:02:28 +02:00
throw new RuntimeException(ex);
}
2022-06-08 04:25:49 +02:00
}
2023-12-25 23:51:56 +01:00
@@ -426,20 +440,48 @@ public class CraftWorld extends CraftRegionAccessor implements World {
2021-06-11 14:02:28 +02:00
@Override
public boolean loadChunk(int x, int z, boolean generate) {
org.spigotmc.AsyncCatcher.catchOp("chunk load"); // Spigot
2021-06-13 15:46:28 +02:00
- ChunkAccess chunk = this.world.getChunkSource().getChunk(x, z, generate || isChunkGenerated(x, z) ? ChunkStatus.FULL : ChunkStatus.EMPTY, true); // Paper
2021-06-11 14:02:28 +02:00
+ // Paper start - Optimize this method
+ ChunkPos chunkPos = new ChunkPos(x, z);
- // If generate = false, but the chunk already exists, we will get this back.
- if (chunk instanceof ImposterProtoChunk) {
- // We then cycle through again to get the full chunk immediately, rather than after the ticket addition
2021-06-13 15:46:28 +02:00
- chunk = this.world.getChunkSource().getChunk(x, z, ChunkStatus.FULL, true);
2023-03-23 22:57:03 +01:00
- }
2021-06-11 14:02:28 +02:00
+ if (!generate) {
+ ChunkAccess immediate = world.getChunkSource().getChunkAtImmediately(x, z);
+ if (immediate == null) {
+ immediate = world.getChunkSource().chunkMap.getUnloadingChunk(x, z);
+ }
+ if (immediate != null) {
+ if (!(immediate instanceof ImposterProtoChunk) && !(immediate instanceof net.minecraft.world.level.chunk.LevelChunk)) {
+ return false; // not full status
+ }
+ world.getChunkSource().addRegionTicket(TicketType.PLUGIN, chunkPos, 1, Unit.INSTANCE);
+ world.getChunk(x, z); // make sure we're at ticket level 32 or lower
+ return true;
+ }
2023-03-23 22:57:03 +01:00
- if (chunk instanceof net.minecraft.world.level.chunk.LevelChunk) {
- this.world.getChunkSource().addRegionTicket(TicketType.PLUGIN, new ChunkPos(x, z), 1, Unit.INSTANCE);
- return true;
2021-06-11 14:02:28 +02:00
+ net.minecraft.world.level.chunk.storage.RegionFile file;
+ try {
2021-11-24 05:25:34 +01:00
+ file = world.getChunkSource().chunkMap.regionFileCache.getRegionFile(chunkPos, false);
2022-12-08 04:24:00 +01:00
+ } catch (java.io.IOException ex) {
2021-06-11 14:02:28 +02:00
+ throw new RuntimeException(ex);
+ }
+
+ ChunkStatus status = file.getStatusIfCached(x, z);
+ if (!file.hasChunk(chunkPos) || (status != null && status != ChunkStatus.FULL)) {
+ return false;
+ }
+
+ ChunkAccess chunk = world.getChunkSource().getChunk(x, z, ChunkStatus.EMPTY, true);
+ if (!(chunk instanceof ImposterProtoChunk) && !(chunk instanceof net.minecraft.world.level.chunk.LevelChunk)) {
+ return false;
+ }
+
+ // fall through to load
+ // we do this so we do not re-read the chunk data on disk
}
- return false;
+ world.getChunkSource().addRegionTicket(TicketType.PLUGIN, chunkPos, 1, Unit.INSTANCE);
+ world.getChunkSource().getChunk(x, z, ChunkStatus.FULL, true);
+ return true;
2024-01-21 12:53:04 +01:00
+ // Paper end - Optimize this method
2021-06-11 14:02:28 +02:00
}
@Override