geforkt von Mirrors/Paper
8c5b837e05
Firstly, the old methods all routed to the CompletableFuture method. However, the CF method could not guarantee that if the caller was off-main that the future would be "completed" on-main. Since the callback methods used the CF one, this meant that the callback methods did not guarantee that the callbacks were to be called on the main thread. Now, all methods route to getChunkAtAsync(x, z, gen, urgent, cb) so that the methods with the callback are guaranteed to invoke the callback on the main thread. The CF behavior remains unchanged; it may still appear to complete on main if invoked off-main. Secondly, remove the scheduleOnMain invocation in the async chunk completion. This unnecessarily delays the callback by 1 tick. Thirdly, add getChunksAtAsync(minX, minZ, maxX, maxZ, ...) which will load chunks within an area. This method is provided as a helper as keeping all chunks loaded within an area can be complicated to implement for plugins (due to the lacking ticket API), and is already implemented internally anyways. Fourthly, remove the ticket addition that occured with getChunkAt and getChunkAtAsync. The ticket addition may delay the unloading of the chunk unnecessarily. It also fixes a very rare timing bug where the future/callback would be completed after the chunk unloads.
126 Zeilen
6.1 KiB
Diff
126 Zeilen
6.1 KiB
Diff
From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
|
|
From: Aikar <aikar@aikar.co>
|
|
Date: Sun, 3 May 2020 22:35:09 -0400
|
|
Subject: [PATCH] Optimize Voxel Shape Merging
|
|
|
|
This method shows up as super hot in profiler, and also a high "self" time.
|
|
|
|
Upon analyzing, it appears most usages of this method fall down to the final
|
|
else statement of the nasty ternary.
|
|
|
|
Upon even further analyzation, it appears then the majority of those have a
|
|
consistent list 1.... One with Infinity head and Tails.
|
|
|
|
First optimization is to detect these infinite states and immediately return that
|
|
VoxelShapeMergerList so we can avoid testing the rest for most cases.
|
|
|
|
Break the method into 2 to help the JVM promote inlining of this fast path.
|
|
|
|
Then it was also noticed that VoxelShapeMergerList constructor is also a hotspot
|
|
with a high self time...
|
|
|
|
Well, knowing that in most cases our list 1 is actualy the same value, it allows
|
|
us to know that with an infinite list1, the result on the merger is essentially
|
|
list2 as the final values.
|
|
|
|
This let us analyze the 2 potential states (Infinite with 2 sources or 4 sources)
|
|
and compute a deterministic result for the MergerList values.
|
|
|
|
Additionally, this lets us avoid even allocating new objects for this too, further
|
|
reducing memory usage.
|
|
|
|
Feature patch
|
|
|
|
diff --git a/src/main/java/net/minecraft/world/phys/shapes/IndirectMerger.java b/src/main/java/net/minecraft/world/phys/shapes/IndirectMerger.java
|
|
index e164c524aef4fa81fe96ac43454eecff1c38b9c1..9cfbbc61fcfc678f0988d6d45c7994d128051744 100644
|
|
--- a/src/main/java/net/minecraft/world/phys/shapes/IndirectMerger.java
|
|
+++ b/src/main/java/net/minecraft/world/phys/shapes/IndirectMerger.java
|
|
@@ -10,12 +10,33 @@ public class IndirectMerger implements IndexMerger {
|
|
private final int[] firstIndices;
|
|
private final int[] secondIndices;
|
|
private final int resultLength;
|
|
+ // Paper start
|
|
+ private static final int[] INFINITE_B_1 = new int[]{1, 1};
|
|
+ private static final int[] INFINITE_B_0 = new int[]{0, 0};
|
|
+ private static final int[] INFINITE_C = new int[]{0, 1};
|
|
+ // Paper end
|
|
|
|
public IndirectMerger(DoubleList first, DoubleList second, boolean includeFirstOnly, boolean includeSecondOnly) {
|
|
double d = Double.NaN;
|
|
int i = first.size();
|
|
int j = second.size();
|
|
int k = i + j;
|
|
+ // Paper start - optimize common path of infinity doublelist
|
|
+ int size = first.size();
|
|
+ double tail = first.getDouble(size - 1);
|
|
+ double head = first.getDouble(0);
|
|
+ if (head == Double.NEGATIVE_INFINITY && tail == Double.POSITIVE_INFINITY && !includeFirstOnly && !includeSecondOnly && (size == 2 || size == 4)) {
|
|
+ this.result = second.toDoubleArray();
|
|
+ this.resultLength = second.size();
|
|
+ if (size == 2) {
|
|
+ this.firstIndices = INFINITE_B_0;
|
|
+ } else {
|
|
+ this.firstIndices = INFINITE_B_1;
|
|
+ }
|
|
+ this.secondIndices = INFINITE_C;
|
|
+ return;
|
|
+ }
|
|
+ // Paper end
|
|
this.result = new double[k];
|
|
this.firstIndices = new int[k];
|
|
this.secondIndices = new int[k];
|
|
diff --git a/src/main/java/net/minecraft/world/phys/shapes/Shapes.java b/src/main/java/net/minecraft/world/phys/shapes/Shapes.java
|
|
index 5a0b0b47da3d796c391ac15eb573af25a1dfcd32..76d7435e6fe81a3f1d24b35eae72d06232a1792b 100644
|
|
--- a/src/main/java/net/minecraft/world/phys/shapes/Shapes.java
|
|
+++ b/src/main/java/net/minecraft/world/phys/shapes/Shapes.java
|
|
@@ -267,9 +267,21 @@ public final class Shapes {
|
|
}
|
|
|
|
@VisibleForTesting
|
|
- protected static IndexMerger createIndexMerger(int size, DoubleList first, DoubleList second, boolean includeFirst, boolean includeSecond) {
|
|
+ private static IndexMerger createIndexMerger(int size, DoubleList first, DoubleList second, boolean includeFirst, boolean includeSecond) { // Paper - private
|
|
+ // Paper start - fast track the most common scenario
|
|
+ // doublelist is usually a DoubleArrayList with Infinite head/tails that falls to the final else clause
|
|
+ // This is actually the most common path, so jump to it straight away
|
|
+ if (first.getDouble(0) == Double.NEGATIVE_INFINITY && first.getDouble(first.size() - 1) == Double.POSITIVE_INFINITY) {
|
|
+ return new IndirectMerger(first, second, includeFirst, includeSecond);
|
|
+ }
|
|
+ // Split out rest to hopefully inline the above
|
|
+ return lessCommonMerge(size, first, second, includeFirst, includeSecond);
|
|
+ }
|
|
+
|
|
+ private static IndexMerger lessCommonMerge(int size, DoubleList first, DoubleList second, boolean includeFirst, boolean includeSecond) {
|
|
int i = first.size() - 1;
|
|
int j = second.size() - 1;
|
|
+ // Paper note - Rewrite below as optimized order if instead of nasty ternary
|
|
if (first instanceof CubePointRange && second instanceof CubePointRange) {
|
|
long l = lcm(i, j);
|
|
if ((long)size * l <= 256L) {
|
|
@@ -277,15 +289,22 @@ public final class Shapes {
|
|
}
|
|
}
|
|
|
|
- if (first.getDouble(i) < second.getDouble(0) - 1.0E-7) {
|
|
+ // Paper start - Identical happens more often than Disjoint
|
|
+ if (i == j && Objects.equals(first, second)) {
|
|
+ if (first instanceof IdenticalMerger) {
|
|
+ return (IndexMerger) first;
|
|
+ } else if (second instanceof IdenticalMerger) {
|
|
+ return (IndexMerger) second;
|
|
+ }
|
|
+ return new IdenticalMerger(first);
|
|
+ } else if (first.getDouble(i) < second.getDouble(0) - 1.0E-7) {
|
|
return new NonOverlappingMerger(first, second, false);
|
|
} else if (second.getDouble(j) < first.getDouble(0) - 1.0E-7) {
|
|
return new NonOverlappingMerger(second, first, true);
|
|
} else {
|
|
- return (IndexMerger)(i == j && Objects.equals(first, second)
|
|
- ? new IdenticalMerger(first)
|
|
- : new IndirectMerger(first, second, includeFirst, includeSecond));
|
|
+ return new IndirectMerger(first, second, includeFirst, includeSecond);
|
|
}
|
|
+ // Paper end
|
|
}
|
|
|
|
public interface DoubleLineConsumer {
|