SteamWar/Paper
13
0
Fork 0
geforkt von Mirrors/Paper
Code Issues Pull-Requests 1 Projekte Releases Wiki Aktivität
adc286112e
Paper/Spigot-Server-Patches/0100-Optimize-Chunk-Unload-Queue.patch

353 Zeilen
16 KiB
Diff
Originalformat Normale Ansicht Verlauf

Paper 1.9.2 Update
2016-03-31 02:50:23 +02:00
From 37286df2722a024569953f7d0627bc1c231a1826 Mon Sep 17 00:00:00 2001
Optimize Chunk Unload Queue Removing chunks from the unload queue when performing chunk lookups is a costly activity. It drastically slows down server performance as many methods call getChunkAt, resulting in a bandaid to skip removing chunks from the unload queue. This patch optimizes the unload queue to instead use a boolean on the Chunk object itself to mark if the chunk is active, and then insert into a LinkedList queue. The benefits here is that all chunk unload queue actions are now O(1) constant time. A LinkedList will never need to resize, and can be removed from in constant time when used in a queue like method. We mark the chunk as active in many places that notify it is still being used, so that when the chunk unload queue reaches that chunk, and sees the chunk became active again, it will skip it and move to next.
2016-03-18 23:03:44 +01:00
From: Aikar <aikar@aikar.co>
Date: Fri, 18 Mar 2016 17:57:25 -0400
Subject: [PATCH] Optimize Chunk Unload Queue
Removing chunks from the unload queue when performing chunk lookups is a costly activity.
It drastically slows down server performance as many methods call getChunkAt, resulting in a bandaid
to skip removing chunks from the unload queue.
This patch optimizes the unload queue to instead use a boolean on the Chunk object itself to mark
if the chunk is active, and then insert into a LinkedList queue.
The benefits here is that all chunk unload queue actions are now O(1) constant time.
A LinkedList will never need to resize, and can be removed from in constant time when
used in a queue like method.
We mark the chunk as active in many places that notify it is still being used, so that
when the chunk unload queue reaches that chunk, and sees the chunk became active again,
it will skip it and move to next.
Another attempt at unload queue, including EAR improvements. should be fully working now as I pretty much fell back to existing methods so anything touching the unloadQueue set should behave correctly. And maintained NMS Reflection safe change too
2016-03-22 03:51:14 +01:00
Also optimize EAR to use these methods.
Optimize Chunk Unload Queue Removing chunks from the unload queue when performing chunk lookups is a costly activity. It drastically slows down server performance as many methods call getChunkAt, resulting in a bandaid to skip removing chunks from the unload queue. This patch optimizes the unload queue to instead use a boolean on the Chunk object itself to mark if the chunk is active, and then insert into a LinkedList queue. The benefits here is that all chunk unload queue actions are now O(1) constant time. A LinkedList will never need to resize, and can be removed from in constant time when used in a queue like method. We mark the chunk as active in many places that notify it is still being used, so that when the chunk unload queue reaches that chunk, and sees the chunk became active again, it will skip it and move to next.
2016-03-18 23:03:44 +01:00
diff --git a/src/main/java/net/minecraft/server/Chunk.java b/src/main/java/net/minecraft/server/Chunk.java
Add MCUtils helper This will be used by my next commit. But trying to get the build going since CI blew up
2016-03-29 03:01:42 +02:00
index 8b11266..ac35cf4 100644
Optimize Chunk Unload Queue Removing chunks from the unload queue when performing chunk lookups is a costly activity. It drastically slows down server performance as many methods call getChunkAt, resulting in a bandaid to skip removing chunks from the unload queue. This patch optimizes the unload queue to instead use a boolean on the Chunk object itself to mark if the chunk is active, and then insert into a LinkedList queue. The benefits here is that all chunk unload queue actions are now O(1) constant time. A LinkedList will never need to resize, and can be removed from in constant time when used in a queue like method. We mark the chunk as active in many places that notify it is still being used, so that when the chunk unload queue reaches that chunk, and sees the chunk became active again, it will skip it and move to next.
2016-03-18 23:03:44 +01:00
--- a/src/main/java/net/minecraft/server/Chunk.java
+++ b/src/main/java/net/minecraft/server/Chunk.java
Add Lighting Queue The lighting queue spreads out the processing of light updates across multiple ticks based on how much free time the server has left at the end of the tick.
2016-03-25 07:38:38 +01:00
@@ -53,6 +53,8 @@ public class Chunk {
Optimize Chunk Unload Queue Removing chunks from the unload queue when performing chunk lookups is a costly activity. It drastically slows down server performance as many methods call getChunkAt, resulting in a bandaid to skip removing chunks from the unload queue. This patch optimizes the unload queue to instead use a boolean on the Chunk object itself to mark if the chunk is active, and then insert into a LinkedList queue. The benefits here is that all chunk unload queue actions are now O(1) constant time. A LinkedList will never need to resize, and can be removed from in constant time when used in a queue like method. We mark the chunk as active in many places that notify it is still being used, so that when the chunk unload queue reaches that chunk, and sees the chunk became active again, it will skip it and move to next.
2016-03-18 23:03:44 +01:00
// Keep this synced with entitySlices.add() and entitySlices.remove()
private final int[] itemCounts = new int[16];
private final int[] inventoryEntityCounts = new int[16];
+ public boolean isChunkActive = true;
+ public boolean isInUnloadQueue = false;
// Paper end
// CraftBukkit start - Neighbor loaded cache for chunk lighting and entity ticking
diff --git a/src/main/java/net/minecraft/server/ChunkProviderServer.java b/src/main/java/net/minecraft/server/ChunkProviderServer.java
Add Lighting Queue The lighting queue spreads out the processing of light updates across multiple ticks based on how much free time the server has left at the end of the tick.
2016-03-25 07:38:38 +01:00
index 450bf9b..f5a2580 100644
Optimize Chunk Unload Queue Removing chunks from the unload queue when performing chunk lookups is a costly activity. It drastically slows down server performance as many methods call getChunkAt, resulting in a bandaid to skip removing chunks from the unload queue. This patch optimizes the unload queue to instead use a boolean on the Chunk object itself to mark if the chunk is active, and then insert into a LinkedList queue. The benefits here is that all chunk unload queue actions are now O(1) constant time. A LinkedList will never need to resize, and can be removed from in constant time when used in a queue like method. We mark the chunk as active in many places that notify it is still being used, so that when the chunk unload queue reaches that chunk, and sees the chunk became active again, it will skip it and move to next.
2016-03-18 23:03:44 +01:00
--- a/src/main/java/net/minecraft/server/ChunkProviderServer.java
+++ b/src/main/java/net/minecraft/server/ChunkProviderServer.java
@@ -21,7 +21,7 @@ import org.bukkit.event.world.ChunkUnloadEvent;
public class ChunkProviderServer implements IChunkProvider {
private static final Logger a = LogManager.getLogger();
- public final LongHashSet unloadQueue = new LongHashSet(); // CraftBukkit - LongHashSet
+ public final ChunkUnloadQueue unloadQueue = new ChunkUnloadQueue(); // CraftBukkit - LongHashSet // Paper -> ChunkUnloadQueue
public final ChunkGenerator chunkGenerator; // CraftBukkit - public
private final IChunkLoader chunkLoader;
public LongObjectHashMap<Chunk> chunks = new LongObjectHashMap<Chunk>(); // CraftBukkit
Add Lighting Queue The lighting queue spreads out the processing of light updates across multiple ticks based on how much free time the server has left at the end of the tick.
2016-03-25 07:38:38 +01:00
@@ -77,14 +77,24 @@ public class ChunkProviderServer implements IChunkProvider {
Another attempt at unload queue, including EAR improvements. should be fully working now as I pretty much fell back to existing methods so anything touching the unloadQueue set should behave correctly. And maintained NMS Reflection safe change too
2016-03-22 03:51:14 +01:00
return (chunk == null) ? getChunkAt(x, z) : chunk;
}
Optimize Chunk Unload Queue Removing chunks from the unload queue when performing chunk lookups is a costly activity. It drastically slows down server performance as many methods call getChunkAt, resulting in a bandaid to skip removing chunks from the unload queue. This patch optimizes the unload queue to instead use a boolean on the Chunk object itself to mark if the chunk is active, and then insert into a LinkedList queue. The benefits here is that all chunk unload queue actions are now O(1) constant time. A LinkedList will never need to resize, and can be removed from in constant time when used in a queue like method. We mark the chunk as active in many places that notify it is still being used, so that when the chunk unload queue reaches that chunk, and sees the chunk became active again, it will skip it and move to next.
2016-03-18 23:03:44 +01:00
Another attempt at unload queue, including EAR improvements. should be fully working now as I pretty much fell back to existing methods so anything touching the unloadQueue set should behave correctly. And maintained NMS Reflection safe change too
2016-03-22 03:51:14 +01:00
- public Chunk getChunkIfLoaded(int x, int z) {
- return chunks.get(LongHash.toLong(x, z));
Fix chunk unload issues - Resolves #97
2016-03-19 16:29:46 +01:00
+ // Paper start
+ public Chunk getLoadedChunkAtWithoutMarkingActive(int i, int j) {
+ return chunks.get(LongHash.toLong(i, j));
Improve chunk unload queue to maintain some previous expectations While the previous logic was logically correct, some CB API's before would request a chunk without removing it from the unload queue. While this is logically wrong, some plugins seem to be causing unload issues. This change will make anything using that one API that use to not remove from queue, no longer remove from queue. Hopefully other activities on the server will touch the chunk if it REALLY is in use.
2016-03-20 05:13:20 +01:00
}
+ // getChunkIfLoaded -> getChunkIfActive
+ // this is only used by CraftBukkit now, and plugins shouldnt mark things active
+ public Chunk getChunkIfActive(int x, int z) {
+ Chunk chunk = chunks.get(LongHash.toLong(x, z));
+ return (chunk != null && chunk.isChunkActive) ? chunk : null;
Another attempt at unload queue, including EAR improvements. should be fully working now as I pretty much fell back to existing methods so anything touching the unloadQueue set should behave correctly. And maintained NMS Reflection safe change too
2016-03-22 03:51:14 +01:00
+ }
Improve chunk unload queue to maintain some previous expectations While the previous logic was logically correct, some CB API's before would request a chunk without removing it from the unload queue. While this is logically wrong, some plugins seem to be causing unload issues. This change will make anything using that one API that use to not remove from queue, no longer remove from queue. Hopefully other activities on the server will touch the chunk if it REALLY is in use.
2016-03-20 05:13:20 +01:00
+ // Paper end
Another attempt at unload queue, including EAR improvements. should be fully working now as I pretty much fell back to existing methods so anything touching the unloadQueue set should behave correctly. And maintained NMS Reflection safe change too
2016-03-22 03:51:14 +01:00
+
Optimize Chunk Unload Queue Removing chunks from the unload queue when performing chunk lookups is a costly activity. It drastically slows down server performance as many methods call getChunkAt, resulting in a bandaid to skip removing chunks from the unload queue. This patch optimizes the unload queue to instead use a boolean on the Chunk object itself to mark if the chunk is active, and then insert into a LinkedList queue. The benefits here is that all chunk unload queue actions are now O(1) constant time. A LinkedList will never need to resize, and can be removed from in constant time when used in a queue like method. We mark the chunk as active in many places that notify it is still being used, so that when the chunk unload queue reaches that chunk, and sees the chunk became active again, it will skip it and move to next.
2016-03-18 23:03:44 +01:00
public Chunk getLoadedChunkAt(int i, int j) {
Chunk chunk = chunks.get(LongHash.toLong(i, j)); // CraftBukkit
Another attempt at unload queue, including EAR improvements. should be fully working now as I pretty much fell back to existing methods so anything touching the unloadQueue set should behave correctly. And maintained NMS Reflection safe change too
2016-03-22 03:51:14 +01:00
- this.unloadQueue.remove(i, j); // CraftBukkit
+ //this.unloadQueue.remove(i, j); // CraftBukkit // Paper
+ markChunkActive(chunk); // Paper
return chunk;
}
Add Lighting Queue The lighting queue spreads out the processing of light updates across multiple ticks based on how much free time the server has left at the end of the tick.
2016-03-25 07:38:38 +01:00
@@ -112,6 +122,7 @@ public class ChunkProviderServer implements IChunkProvider {
Another attempt at unload queue, including EAR improvements. should be fully working now as I pretty much fell back to existing methods so anything touching the unloadQueue set should behave correctly. And maintained NMS Reflection safe change too
2016-03-22 03:51:14 +01:00
// CraftBukkit end
}
+ markChunkActive(chunk); // Paper
Optimize Chunk Unload Queue Removing chunks from the unload queue when performing chunk lookups is a costly activity. It drastically slows down server performance as many methods call getChunkAt, resulting in a bandaid to skip removing chunks from the unload queue. This patch optimizes the unload queue to instead use a boolean on the Chunk object itself to mark if the chunk is active, and then insert into a LinkedList queue. The benefits here is that all chunk unload queue actions are now O(1) constant time. A LinkedList will never need to resize, and can be removed from in constant time when used in a queue like method. We mark the chunk as active in many places that notify it is still being used, so that when the chunk unload queue reaches that chunk, and sees the chunk became active again, it will skip it and move to next.
2016-03-18 23:03:44 +01:00
return chunk;
}
Add Lighting Queue The lighting queue spreads out the processing of light updates across multiple ticks based on how much free time the server has left at the end of the tick.
2016-03-25 07:38:38 +01:00
@@ -120,7 +131,7 @@ public class ChunkProviderServer implements IChunkProvider {
Another attempt at unload queue, including EAR improvements. should be fully working now as I pretty much fell back to existing methods so anything touching the unloadQueue set should behave correctly. And maintained NMS Reflection safe change too
2016-03-22 03:51:14 +01:00
}
public Chunk getChunkAt(int i, int j, Runnable runnable) {
- unloadQueue.remove(i, j);
+ //unloadQueue.remove(i, j); // Paper
Chunk chunk = chunks.get(LongHash.toLong(i, j));
ChunkRegionLoader loader = null;
Add Lighting Queue The lighting queue spreads out the processing of light updates across multiple ticks based on how much free time the server has left at the end of the tick.
2016-03-25 07:38:38 +01:00
@@ -144,12 +155,13 @@ public class ChunkProviderServer implements IChunkProvider {
Another attempt at unload queue, including EAR improvements. should be fully working now as I pretty much fell back to existing methods so anything touching the unloadQueue set should behave correctly. And maintained NMS Reflection safe change too
2016-03-22 03:51:14 +01:00
if (runnable != null) {
Optimize Chunk Unload Queue Removing chunks from the unload queue when performing chunk lookups is a costly activity. It drastically slows down server performance as many methods call getChunkAt, resulting in a bandaid to skip removing chunks from the unload queue. This patch optimizes the unload queue to instead use a boolean on the Chunk object itself to mark if the chunk is active, and then insert into a LinkedList queue. The benefits here is that all chunk unload queue actions are now O(1) constant time. A LinkedList will never need to resize, and can be removed from in constant time when used in a queue like method. We mark the chunk as active in many places that notify it is still being used, so that when the chunk unload queue reaches that chunk, and sees the chunk became active again, it will skip it and move to next.
2016-03-18 23:03:44 +01:00
runnable.run();
}
Another attempt at unload queue, including EAR improvements. should be fully working now as I pretty much fell back to existing methods so anything touching the unloadQueue set should behave correctly. And maintained NMS Reflection safe change too
2016-03-22 03:51:14 +01:00
+ markChunkActive(chunk); // Paper
Optimize Chunk Unload Queue Removing chunks from the unload queue when performing chunk lookups is a costly activity. It drastically slows down server performance as many methods call getChunkAt, resulting in a bandaid to skip removing chunks from the unload queue. This patch optimizes the unload queue to instead use a boolean on the Chunk object itself to mark if the chunk is active, and then insert into a LinkedList queue. The benefits here is that all chunk unload queue actions are now O(1) constant time. A LinkedList will never need to resize, and can be removed from in constant time when used in a queue like method. We mark the chunk as active in many places that notify it is still being used, so that when the chunk unload queue reaches that chunk, and sees the chunk became active again, it will skip it and move to next.
2016-03-18 23:03:44 +01:00
return chunk;
}
Another attempt at unload queue, including EAR improvements. should be fully working now as I pretty much fell back to existing methods so anything touching the unloadQueue set should behave correctly. And maintained NMS Reflection safe change too
2016-03-22 03:51:14 +01:00
public Chunk originalGetChunkAt(int i, int j) {
- this.unloadQueue.remove(i, j);
+ //this.unloadQueue.remove(i, j); // Paper
Chunk chunk = this.chunks.get(LongHash.toLong(i, j));
boolean newChunk = false;
// CraftBukkit end
Add Lighting Queue The lighting queue spreads out the processing of light updates across multiple ticks based on how much free time the server has left at the end of the tick.
2016-03-25 07:38:38 +01:00
@@ -195,7 +207,7 @@ public class ChunkProviderServer implements IChunkProvider {
Fix chunk unload issues - Resolves #97
2016-03-19 16:29:46 +01:00
continue;
}
- Chunk neighbor = this.getChunkIfLoaded(chunk.locX + x, chunk.locZ + z);
+ Chunk neighbor = this.getLoadedChunkAtWithoutMarkingActive(chunk.locX + x, chunk.locZ + z); // Paper
if (neighbor != null) {
neighbor.setNeighborLoaded(-x, -z);
chunk.setNeighborLoaded(x, z);
Add Lighting Queue The lighting queue spreads out the processing of light updates across multiple ticks based on how much free time the server has left at the end of the tick.
2016-03-25 07:38:38 +01:00
@@ -206,6 +218,7 @@ public class ChunkProviderServer implements IChunkProvider {
Another attempt at unload queue, including EAR improvements. should be fully working now as I pretty much fell back to existing methods so anything touching the unloadQueue set should behave correctly. And maintained NMS Reflection safe change too
2016-03-22 03:51:14 +01:00
chunk.loadNearby(this, this.chunkGenerator);
world.timings.syncChunkLoadTimer.stopTiming(); // Spigot
}
+ markChunkActive(chunk); // Paper
return chunk;
}
Add Lighting Queue The lighting queue spreads out the processing of light updates across multiple ticks based on how much free time the server has left at the end of the tick.
2016-03-25 07:38:38 +01:00
@@ -294,10 +307,17 @@ public class ChunkProviderServer implements IChunkProvider {
Optimize Chunk Unload Queue Removing chunks from the unload queue when performing chunk lookups is a costly activity. It drastically slows down server performance as many methods call getChunkAt, resulting in a bandaid to skip removing chunks from the unload queue. This patch optimizes the unload queue to instead use a boolean on the Chunk object itself to mark if the chunk is active, and then insert into a LinkedList queue. The benefits here is that all chunk unload queue actions are now O(1) constant time. A LinkedList will never need to resize, and can be removed from in constant time when used in a queue like method. We mark the chunk as active in many places that notify it is still being used, so that when the chunk unload queue reaches that chunk, and sees the chunk became active again, it will skip it and move to next.
2016-03-18 23:03:44 +01:00
if (!this.world.savingDisabled) {
// CraftBukkit start
Server server = this.world.getServer();
- for (int i = 0; i < 100 && !this.unloadQueue.isEmpty(); ++i) {
- long chunkcoordinates = this.unloadQueue.popFirst();
- Chunk chunk = this.chunks.get(chunkcoordinates);
- if (chunk == null) continue;
+ // Paper start
+ final Iterator<Chunk> iterator = this.unloadQueue.iterator();
+ for (int i = 0; i < 100 && iterator.hasNext(); ++i) {
+ Chunk chunk = iterator.next();
+ iterator.remove();
+ long chunkcoordinates = LongHash.toLong(chunk.locX, chunk.locZ);
+ chunk.isInUnloadQueue = false;
+ if (chunk.isChunkActive) {
+ continue;
+ }
+ // Paper end
Add Lighting Queue The lighting queue spreads out the processing of light updates across multiple ticks based on how much free time the server has left at the end of the tick.
2016-03-25 07:38:38 +01:00
if (chunk.hasLightUpdates()) continue; // Paper - Don't unload chunks with pending light updates.
Optimize Chunk Unload Queue Removing chunks from the unload queue when performing chunk lookups is a costly activity. It drastically slows down server performance as many methods call getChunkAt, resulting in a bandaid to skip removing chunks from the unload queue. This patch optimizes the unload queue to instead use a boolean on the Chunk object itself to mark if the chunk is active, and then insert into a LinkedList queue. The benefits here is that all chunk unload queue actions are now O(1) constant time. A LinkedList will never need to resize, and can be removed from in constant time when used in a queue like method. We mark the chunk as active in many places that notify it is still being used, so that when the chunk unload queue reaches that chunk, and sees the chunk became active again, it will skip it and move to next.
2016-03-18 23:03:44 +01:00
ChunkUnloadEvent event = new ChunkUnloadEvent(chunk.bukkitChunk);
Add Lighting Queue The lighting queue spreads out the processing of light updates across multiple ticks based on how much free time the server has left at the end of the tick.
2016-03-25 07:38:38 +01:00
@@ -320,7 +340,7 @@ public class ChunkProviderServer implements IChunkProvider {
Fix chunk unload issues - Resolves #97
2016-03-19 16:29:46 +01:00
continue;
}
- Chunk neighbor = this.getChunkIfLoaded(chunk.locX + x, chunk.locZ + z);
+ Chunk neighbor = this.getLoadedChunkAtWithoutMarkingActive(chunk.locX + x, chunk.locZ + z); // Paper
if (neighbor != null) {
neighbor.setNeighborUnloaded(-x, -z);
chunk.setNeighborUnloaded(x, z);
Add Lighting Queue The lighting queue spreads out the processing of light updates across multiple ticks based on how much free time the server has left at the end of the tick.
2016-03-25 07:38:38 +01:00
@@ -362,4 +382,69 @@ public class ChunkProviderServer implements IChunkProvider {
Optimize Chunk Unload Queue Removing chunks from the unload queue when performing chunk lookups is a costly activity. It drastically slows down server performance as many methods call getChunkAt, resulting in a bandaid to skip removing chunks from the unload queue. This patch optimizes the unload queue to instead use a boolean on the Chunk object itself to mark if the chunk is active, and then insert into a LinkedList queue. The benefits here is that all chunk unload queue actions are now O(1) constant time. A LinkedList will never need to resize, and can be removed from in constant time when used in a queue like method. We mark the chunk as active in many places that notify it is still being used, so that when the chunk unload queue reaches that chunk, and sees the chunk became active again, it will skip it and move to next.
2016-03-18 23:03:44 +01:00
public boolean e(int i, int j) {
return this.chunks.containsKey(LongHash.toLong(i, j)); // CraftBukkit
}
+
+ // Paper start
Another attempt at unload queue, including EAR improvements. should be fully working now as I pretty much fell back to existing methods so anything touching the unloadQueue set should behave correctly. And maintained NMS Reflection safe change too
2016-03-22 03:51:14 +01:00
+ public static void markChunkActive(Chunk chunk) {
+ if (chunk != null) {
+ chunk.isChunkActive = true;
+ }
+ }
+ public class ChunkUnloadQueue extends LongHashSet { // Provide compat with NMS plugins
+ private java.util.LinkedList<Chunk> unloadQueue = new java.util.LinkedList<Chunk>();
+
+ @Override
+ public boolean isEmpty() {
+ return unloadQueue.isEmpty();
+ }
+
+ @Override
+ public boolean contains(long value) {
+ throw new UnsupportedOperationException("contains on unload queue");
+ }
+
+ @Override
+ public boolean add(long value) {
+ throw new UnsupportedOperationException("add on unload queue");
+ }
+
+ @Override
+ public boolean remove(long value) {
+ throw new UnsupportedOperationException("remove on unload queue");
+ }
+
+ @Override
+ public int size() {
+ return unloadQueue.size();
+ }
+
+ @Override
+ public Iterator iterator() {
+ return unloadQueue.iterator();
+ }
+
+ @Override
+ public boolean contains(int x, int z) {
+ final Chunk chunk = chunks.get(LongHash.toLong(x, z));
+ return (chunk != null && chunk.isInUnloadQueue);
+ }
+
Optimize Chunk Unload Queue Removing chunks from the unload queue when performing chunk lookups is a costly activity. It drastically slows down server performance as many methods call getChunkAt, resulting in a bandaid to skip removing chunks from the unload queue. This patch optimizes the unload queue to instead use a boolean on the Chunk object itself to mark if the chunk is active, and then insert into a LinkedList queue. The benefits here is that all chunk unload queue actions are now O(1) constant time. A LinkedList will never need to resize, and can be removed from in constant time when used in a queue like method. We mark the chunk as active in many places that notify it is still being used, so that when the chunk unload queue reaches that chunk, and sees the chunk became active again, it will skip it and move to next.
2016-03-18 23:03:44 +01:00
+ public void remove(int x, int z) {
Another attempt at unload queue, including EAR improvements. should be fully working now as I pretty much fell back to existing methods so anything touching the unloadQueue set should behave correctly. And maintained NMS Reflection safe change too
2016-03-22 03:51:14 +01:00
+ final Chunk chunk = chunks.get(LongHash.toLong(x, z));
+ if (chunk != null) {
+ chunk.isChunkActive = true;
+ }
Optimize Chunk Unload Queue Removing chunks from the unload queue when performing chunk lookups is a costly activity. It drastically slows down server performance as many methods call getChunkAt, resulting in a bandaid to skip removing chunks from the unload queue. This patch optimizes the unload queue to instead use a boolean on the Chunk object itself to mark if the chunk is active, and then insert into a LinkedList queue. The benefits here is that all chunk unload queue actions are now O(1) constant time. A LinkedList will never need to resize, and can be removed from in constant time when used in a queue like method. We mark the chunk as active in many places that notify it is still being used, so that when the chunk unload queue reaches that chunk, and sees the chunk became active again, it will skip it and move to next.
2016-03-18 23:03:44 +01:00
+ }
Another attempt at unload queue, including EAR improvements. should be fully working now as I pretty much fell back to existing methods so anything touching the unloadQueue set should behave correctly. And maintained NMS Reflection safe change too
2016-03-22 03:51:14 +01:00
+ public boolean add(int x, int z) {
Optimize Chunk Unload Queue Removing chunks from the unload queue when performing chunk lookups is a costly activity. It drastically slows down server performance as many methods call getChunkAt, resulting in a bandaid to skip removing chunks from the unload queue. This patch optimizes the unload queue to instead use a boolean on the Chunk object itself to mark if the chunk is active, and then insert into a LinkedList queue. The benefits here is that all chunk unload queue actions are now O(1) constant time. A LinkedList will never need to resize, and can be removed from in constant time when used in a queue like method. We mark the chunk as active in many places that notify it is still being used, so that when the chunk unload queue reaches that chunk, and sees the chunk became active again, it will skip it and move to next.
2016-03-18 23:03:44 +01:00
+ final Chunk chunk = chunks.get(LongHash.toLong(x, z));
+ if (chunk != null) {
+ chunk.isChunkActive = false;
+ if (!chunk.isInUnloadQueue) {
+ chunk.isInUnloadQueue = true;
Another attempt at unload queue, including EAR improvements. should be fully working now as I pretty much fell back to existing methods so anything touching the unloadQueue set should behave correctly. And maintained NMS Reflection safe change too
2016-03-22 03:51:14 +01:00
+ return unloadQueue.add(chunk);
Optimize Chunk Unload Queue Removing chunks from the unload queue when performing chunk lookups is a costly activity. It drastically slows down server performance as many methods call getChunkAt, resulting in a bandaid to skip removing chunks from the unload queue. This patch optimizes the unload queue to instead use a boolean on the Chunk object itself to mark if the chunk is active, and then insert into a LinkedList queue. The benefits here is that all chunk unload queue actions are now O(1) constant time. A LinkedList will never need to resize, and can be removed from in constant time when used in a queue like method. We mark the chunk as active in many places that notify it is still being used, so that when the chunk unload queue reaches that chunk, and sees the chunk became active again, it will skip it and move to next.
2016-03-18 23:03:44 +01:00
+ }
+ }
Another attempt at unload queue, including EAR improvements. should be fully working now as I pretty much fell back to existing methods so anything touching the unloadQueue set should behave correctly. And maintained NMS Reflection safe change too
2016-03-22 03:51:14 +01:00
+ return false;
Optimize Chunk Unload Queue Removing chunks from the unload queue when performing chunk lookups is a costly activity. It drastically slows down server performance as many methods call getChunkAt, resulting in a bandaid to skip removing chunks from the unload queue. This patch optimizes the unload queue to instead use a boolean on the Chunk object itself to mark if the chunk is active, and then insert into a LinkedList queue. The benefits here is that all chunk unload queue actions are now O(1) constant time. A LinkedList will never need to resize, and can be removed from in constant time when used in a queue like method. We mark the chunk as active in many places that notify it is still being used, so that when the chunk unload queue reaches that chunk, and sees the chunk became active again, it will skip it and move to next.
2016-03-18 23:03:44 +01:00
+ }
+ }
+ // Paper end
}
diff --git a/src/main/java/net/minecraft/server/SpawnerCreature.java b/src/main/java/net/minecraft/server/SpawnerCreature.java
index 63e118d..721bcae 100644
--- a/src/main/java/net/minecraft/server/SpawnerCreature.java
+++ b/src/main/java/net/minecraft/server/SpawnerCreature.java
@@ -28,7 +28,7 @@ public final class SpawnerCreature {
Long coord = it.next();
int x = LongHash.msw( coord );
int z = LongHash.lsw( coord );
- if ( !((ChunkProviderServer)server.chunkProvider).unloadQueue.contains( coord ) && server.isChunkLoaded( x, z, true ) )
+ if ( server.isChunkLoaded( x, z, true ) ) // Paper
{
i += server.getChunkAt( x, z ).entityCount.get( oClass );
}
Improve chunk unload queue to maintain some previous expectations While the previous logic was logically correct, some CB API's before would request a chunk without removing it from the unload queue. While this is logically wrong, some plugins seem to be causing unload issues. This change will make anything using that one API that use to not remove from queue, no longer remove from queue. Hopefully other activities on the server will touch the chunk if it REALLY is in use.
2016-03-20 05:13:20 +01:00
diff --git a/src/main/java/net/minecraft/server/World.java b/src/main/java/net/minecraft/server/World.java
Add MCUtils helper This will be used by my next commit. But trying to get the build going since CI blew up
2016-03-29 03:01:42 +02:00
index d658fa2..0a3cfbc 100644
Improve chunk unload queue to maintain some previous expectations While the previous logic was logically correct, some CB API's before would request a chunk without removing it from the unload queue. While this is logically wrong, some plugins seem to be causing unload issues. This change will make anything using that one API that use to not remove from queue, no longer remove from queue. Hopefully other activities on the server will touch the chunk if it REALLY is in use.
2016-03-20 05:13:20 +01:00
--- a/src/main/java/net/minecraft/server/World.java
+++ b/src/main/java/net/minecraft/server/World.java
Add Lighting Queue The lighting queue spreads out the processing of light updates across multiple ticks based on how much free time the server has left at the end of the tick.
2016-03-25 07:38:38 +01:00
@@ -159,9 +159,15 @@ public abstract class World implements IBlockAccess {
Another attempt at unload queue, including EAR improvements. should be fully working now as I pretty much fell back to existing methods so anything touching the unloadQueue set should behave correctly. And maintained NMS Reflection safe change too
2016-03-22 03:51:14 +01:00
// Paper end
Improve chunk unload queue to maintain some previous expectations While the previous logic was logically correct, some CB API's before would request a chunk without removing it from the unload queue. While this is logically wrong, some plugins seem to be causing unload issues. This change will make anything using that one API that use to not remove from queue, no longer remove from queue. Hopefully other activities on the server will touch the chunk if it REALLY is in use.
2016-03-20 05:13:20 +01:00
public Chunk getChunkIfLoaded(int x, int z) {
- return ((ChunkProviderServer) this.chunkProvider).getChunkIfLoaded(x, z);
+ return ((ChunkProviderServer) this.chunkProvider).getLoadedChunkAtWithoutMarkingActive(x, z); // Paper - This is added by CB, and will not mark as active. Simply an alias
}
+ // Paper start
+ public Chunk getChunkIfActive(int x, int z) {
+ return ((ChunkProviderServer) this.chunkProvider).getChunkIfActive(x, z);
+ }
+ // Paper end
+
protected World(IDataManager idatamanager, WorldData worlddata, WorldProvider worldprovider, MethodProfiler methodprofiler, boolean flag, ChunkGenerator gen, org.bukkit.World.Environment env) {
this.spigotConfig = new org.spigotmc.SpigotWorldConfig( worlddata.getName() ); // Spigot
this.paperConfig = new com.destroystokyo.paper.PaperWorldConfig(worlddata.getName(), this.spigotConfig); // Paper
Optimize Chunk Unload Queue Removing chunks from the unload queue when performing chunk lookups is a costly activity. It drastically slows down server performance as many methods call getChunkAt, resulting in a bandaid to skip removing chunks from the unload queue. This patch optimizes the unload queue to instead use a boolean on the Chunk object itself to mark if the chunk is active, and then insert into a LinkedList queue. The benefits here is that all chunk unload queue actions are now O(1) constant time. A LinkedList will never need to resize, and can be removed from in constant time when used in a queue like method. We mark the chunk as active in many places that notify it is still being used, so that when the chunk unload queue reaches that chunk, and sees the chunk became active again, it will skip it and move to next.
2016-03-18 23:03:44 +01:00
diff --git a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
Add Entity Origin API This replaces the TNT and Falling Block Source Location API with a more general purpose API that works with all entities.
2016-03-25 10:02:35 +01:00
index 3f2d83a..c81dfee 100644
Optimize Chunk Unload Queue Removing chunks from the unload queue when performing chunk lookups is a costly activity. It drastically slows down server performance as many methods call getChunkAt, resulting in a bandaid to skip removing chunks from the unload queue. This patch optimizes the unload queue to instead use a boolean on the Chunk object itself to mark if the chunk is active, and then insert into a LinkedList queue. The benefits here is that all chunk unload queue actions are now O(1) constant time. A LinkedList will never need to resize, and can be removed from in constant time when used in a queue like method. We mark the chunk as active in many places that notify it is still being used, so that when the chunk unload queue reaches that chunk, and sees the chunk became active again, it will skip it and move to next.
2016-03-18 23:03:44 +01:00
--- a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
+++ b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
Improve chunk unload queue to maintain some previous expectations While the previous logic was logically correct, some CB API's before would request a chunk without removing it from the unload queue. While this is logically wrong, some plugins seem to be causing unload issues. This change will make anything using that one API that use to not remove from queue, no longer remove from queue. Hopefully other activities on the server will touch the chunk if it REALLY is in use.
2016-03-20 05:13:20 +01:00
@@ -206,7 +206,7 @@ public class CraftWorld implements World {
}
// Paper start - Don't create a chunk just to unload it
- net.minecraft.server.Chunk chunk = world.getChunkProviderServer().getChunkIfLoaded(x, z);
+ net.minecraft.server.Chunk chunk = world.getChunkProviderServer().getChunkIfActive(x, z); // Paper
if (chunk == null) {
return false;
}
Fix chunk unload issues - Resolves #97
2016-03-19 16:29:46 +01:00
@@ -232,7 +232,7 @@ public class CraftWorld implements World {
continue;
}
- net.minecraft.server.Chunk neighbor = world.getChunkProviderServer().getChunkIfLoaded(chunk.locX + x, chunk.locZ + z);
+ net.minecraft.server.Chunk neighbor = world.getChunkProviderServer().getLoadedChunkAtWithoutMarkingActive(chunk.locX + x, chunk.locZ + z); // Paper
if (neighbor != null) {
neighbor.setNeighborUnloaded(-xx, -zz);
chunk.setNeighborUnloaded(xx, zz);
Another attempt at unload queue, including EAR improvements. should be fully working now as I pretty much fell back to existing methods so anything touching the unloadQueue set should behave correctly. And maintained NMS Reflection safe change too
2016-03-22 03:51:14 +01:00
@@ -294,6 +294,7 @@ public class CraftWorld implements World {
// Use the default variant of loadChunk when generate == true.
return world.getChunkProviderServer().getChunkAt(x, z) != null;
}
+ if (true) { return world.getChunkProviderServer().getOrLoadChunkAt(x, z) != null; } // Paper
Optimize Chunk Unload Queue Removing chunks from the unload queue when performing chunk lookups is a costly activity. It drastically slows down server performance as many methods call getChunkAt, resulting in a bandaid to skip removing chunks from the unload queue. This patch optimizes the unload queue to instead use a boolean on the Chunk object itself to mark if the chunk is active, and then insert into a LinkedList queue. The benefits here is that all chunk unload queue actions are now O(1) constant time. A LinkedList will never need to resize, and can be removed from in constant time when used in a queue like method. We mark the chunk as active in many places that notify it is still being used, so that when the chunk unload queue reaches that chunk, and sees the chunk became active again, it will skip it and move to next.
2016-03-18 23:03:44 +01:00
Another attempt at unload queue, including EAR improvements. should be fully working now as I pretty much fell back to existing methods so anything touching the unloadQueue set should behave correctly. And maintained NMS Reflection safe change too
2016-03-22 03:51:14 +01:00
world.getChunkProviderServer().unloadQueue.remove(x, z);
net.minecraft.server.Chunk chunk = world.getChunkProviderServer().chunks.get(LongHash.toLong(x, z));
@@ -319,7 +320,7 @@ public class CraftWorld implements World {
Fix chunk unload issues - Resolves #97
2016-03-19 16:29:46 +01:00
continue;
}
- net.minecraft.server.Chunk neighbor = world.getChunkProviderServer().getChunkIfLoaded(chunk.locX + x, chunk.locZ + z);
+ net.minecraft.server.Chunk neighbor = world.getChunkProviderServer().getLoadedChunkAtWithoutMarkingActive(chunk.locX + x, chunk.locZ + z); // Paper
if (neighbor != null) {
neighbor.setNeighborLoaded(-x, -z);
chunk.setNeighborLoaded(x, z);
Add Entity Origin API This replaces the TNT and Falling Block Source Location API with a more general purpose API that works with all entities.
2016-03-25 10:02:35 +01:00
@@ -1536,7 +1537,7 @@ public class CraftWorld implements World {
Optimize Chunk Unload Queue Removing chunks from the unload queue when performing chunk lookups is a costly activity. It drastically slows down server performance as many methods call getChunkAt, resulting in a bandaid to skip removing chunks from the unload queue. This patch optimizes the unload queue to instead use a boolean on the Chunk object itself to mark if the chunk is active, and then insert into a LinkedList queue. The benefits here is that all chunk unload queue actions are now O(1) constant time. A LinkedList will never need to resize, and can be removed from in constant time when used in a queue like method. We mark the chunk as active in many places that notify it is still being used, so that when the chunk unload queue reaches that chunk, and sees the chunk became active again, it will skip it and move to next.
2016-03-18 23:03:44 +01:00
}
// Already unloading?
- if (cps.unloadQueue.contains(chunk.locX, chunk.locZ)) {
Another attempt at unload queue, including EAR improvements. should be fully working now as I pretty much fell back to existing methods so anything touching the unloadQueue set should behave correctly. And maintained NMS Reflection safe change too
2016-03-22 03:51:14 +01:00
+ if (chunk.isInUnloadQueue) { // Paper
Optimize Chunk Unload Queue Removing chunks from the unload queue when performing chunk lookups is a costly activity. It drastically slows down server performance as many methods call getChunkAt, resulting in a bandaid to skip removing chunks from the unload queue. This patch optimizes the unload queue to instead use a boolean on the Chunk object itself to mark if the chunk is active, and then insert into a LinkedList queue. The benefits here is that all chunk unload queue actions are now O(1) constant time. A LinkedList will never need to resize, and can be removed from in constant time when used in a queue like method. We mark the chunk as active in many places that notify it is still being used, so that when the chunk unload queue reaches that chunk, and sees the chunk became active again, it will skip it and move to next.
2016-03-18 23:03:44 +01:00
continue;
}
Fix chunk unload issues - Resolves #97
2016-03-19 16:29:46 +01:00
diff --git a/src/main/java/org/bukkit/craftbukkit/chunkio/ChunkIOProvider.java b/src/main/java/org/bukkit/craftbukkit/chunkio/ChunkIOProvider.java
index 482af17..a1a6d5a 100644
--- a/src/main/java/org/bukkit/craftbukkit/chunkio/ChunkIOProvider.java
+++ b/src/main/java/org/bukkit/craftbukkit/chunkio/ChunkIOProvider.java
@@ -62,7 +62,7 @@ class ChunkIOProvider implements AsynchronousExecutor.CallBackProvider<QueuedChu
continue;
}
- Chunk neighbor = queuedChunk.provider.getChunkIfLoaded(chunk.locX + x, chunk.locZ + z);
+ Chunk neighbor = queuedChunk.provider.getLoadedChunkAtWithoutMarkingActive(chunk.locX + x, chunk.locZ + z); // Paper
if (neighbor != null) {
neighbor.setNeighborLoaded(-x, -z);
chunk.setNeighborLoaded(x, z);
Improve chunk unload queue to maintain some previous expectations While the previous logic was logically correct, some CB API's before would request a chunk without removing it from the unload queue. While this is logically wrong, some plugins seem to be causing unload issues. This change will make anything using that one API that use to not remove from queue, no longer remove from queue. Hopefully other activities on the server will touch the chunk if it REALLY is in use.
2016-03-20 05:13:20 +01:00
diff --git a/src/main/java/org/spigotmc/ActivationRange.java b/src/main/java/org/spigotmc/ActivationRange.java
Relocate Timings v2 patch
2016-03-25 05:59:37 +01:00
index a1bd1a6..7fcd437 100644
Improve chunk unload queue to maintain some previous expectations While the previous logic was logically correct, some CB API's before would request a chunk without removing it from the unload queue. While this is logically wrong, some plugins seem to be causing unload issues. This change will make anything using that one API that use to not remove from queue, no longer remove from queue. Hopefully other activities on the server will touch the chunk if it REALLY is in use.
2016-03-20 05:13:20 +01:00
--- a/src/main/java/org/spigotmc/ActivationRange.java
+++ b/src/main/java/org/spigotmc/ActivationRange.java
Relocate Timings v2 patch
2016-03-25 05:59:37 +01:00
@@ -126,9 +126,9 @@ public class ActivationRange
Another attempt at unload queue, including EAR improvements. should be fully working now as I pretty much fell back to existing methods so anything touching the unloadQueue set should behave correctly. And maintained NMS Reflection safe change too
2016-03-22 03:51:14 +01:00
{
for ( int j1 = k; j1 <= l; ++j1 )
{
- if ( world.getWorld().isChunkLoaded( i1, j1 ) )
- {
- activateChunkEntities( world.getChunkAt( i1, j1 ) );
+ Chunk chunk = world.getChunkIfActive(i1, j1); // Paper
+ if (chunk != null) { // Paper
+ activateChunkEntities( chunk ); // Paper
}
}
}
Relocate Timings v2 patch
2016-03-25 05:59:37 +01:00
@@ -276,7 +276,7 @@ public class ActivationRange
Improve chunk unload queue to maintain some previous expectations While the previous logic was logically correct, some CB API's before would request a chunk without removing it from the unload queue. While this is logically wrong, some plugins seem to be causing unload issues. This change will make anything using that one API that use to not remove from queue, no longer remove from queue. Hopefully other activities on the server will touch the chunk if it REALLY is in use.
2016-03-20 05:13:20 +01:00
int x = MathHelper.floor( entity.locX );
int z = MathHelper.floor( entity.locZ );
// Make sure not on edge of unloaded chunk
- Chunk chunk = entity.world.getChunkIfLoaded( x >> 4, z >> 4 );
Another attempt at unload queue, including EAR improvements. should be fully working now as I pretty much fell back to existing methods so anything touching the unloadQueue set should behave correctly. And maintained NMS Reflection safe change too
2016-03-22 03:51:14 +01:00
+ Chunk chunk = isActive ? entity.world.getChunkIfActive( x >> 4, z >> 4 ) : null; // Paper
Improve chunk unload queue to maintain some previous expectations While the previous logic was logically correct, some CB API's before would request a chunk without removing it from the unload queue. While this is logically wrong, some plugins seem to be causing unload issues. This change will make anything using that one API that use to not remove from queue, no longer remove from queue. Hopefully other activities on the server will touch the chunk if it REALLY is in use.
2016-03-20 05:13:20 +01:00
if ( isActive && !( chunk != null && chunk.areNeighborsLoaded( 1 ) ) )
{
isActive = false;
Optimize Chunk Unload Queue Removing chunks from the unload queue when performing chunk lookups is a costly activity. It drastically slows down server performance as many methods call getChunkAt, resulting in a bandaid to skip removing chunks from the unload queue. This patch optimizes the unload queue to instead use a boolean on the Chunk object itself to mark if the chunk is active, and then insert into a LinkedList queue. The benefits here is that all chunk unload queue actions are now O(1) constant time. A LinkedList will never need to resize, and can be removed from in constant time when used in a queue like method. We mark the chunk as active in many places that notify it is still being used, so that when the chunk unload queue reaches that chunk, and sees the chunk became active again, it will skip it and move to next.
2016-03-18 23:03:44 +01:00
--
Paper 1.9.2 Update
2016-03-31 02:50:23 +02:00
2.8.0
Optimize Chunk Unload Queue Removing chunks from the unload queue when performing chunk lookups is a costly activity. It drastically slows down server performance as many methods call getChunkAt, resulting in a bandaid to skip removing chunks from the unload queue. This patch optimizes the unload queue to instead use a boolean on the Chunk object itself to mark if the chunk is active, and then insert into a LinkedList queue. The benefits here is that all chunk unload queue actions are now O(1) constant time. A LinkedList will never need to resize, and can be removed from in constant time when used in a queue like method. We mark the chunk as active in many places that notify it is still being used, so that when the chunk unload queue reaches that chunk, and sees the chunk became active again, it will skip it and move to next.
2016-03-18 23:03:44 +01:00
In neuem Issue referenzieren Permalink kopieren