3
0
Mirror von https://github.com/PaperMC/Paper.git synchronisiert 2024-12-16 19:40:07 +01:00
Paper/Spigot-Server-Patches/0370-Synchronize-DataPaletteBlock-instead-of-ReentrantLoc.patch

102 Zeilen
4.4 KiB
Diff

From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
From: Aikar <aikar@aikar.co>
Date: Fri, 29 May 2020 20:29:02 -0400
Subject: [PATCH] Synchronize DataPaletteBlock instead of ReentrantLock
Mojang has flaws in their logic about chunks being concurrently
wrote to. So we constantly see crashes around multiple threads writing.
Additionally, java has optimized synchronization so well that its
in many times faster than trying to manage read wrote locks for low
contention situations.
And this is extremely a low contention situation.
diff --git a/src/main/java/net/minecraft/server/DataPaletteBlock.java b/src/main/java/net/minecraft/server/DataPaletteBlock.java
2020-06-26 01:38:24 +02:00
index bcf249aab7d8223f6d9b597fcb20c1aa523ab862..4d397dc5a5127d5e9eb1ba5675239b022a1544c0 100644
--- a/src/main/java/net/minecraft/server/DataPaletteBlock.java
+++ b/src/main/java/net/minecraft/server/DataPaletteBlock.java
2020-06-26 01:38:24 +02:00
@@ -23,7 +23,7 @@ public class DataPaletteBlock<T> implements DataPaletteExpandable<T> {
private int i; private int getBitsPerObject() { return this.i; } // Paper - OBFHELPER
private final ReentrantLock j = new ReentrantLock();
- public void a() {
+ public void a() { /* // Paper start - disable this - use proper synchronization
if (this.j.isLocked() && !this.j.isHeldByCurrentThread()) {
String s = (String) Thread.getAllStackTraces().keySet().stream().filter(Objects::nonNull).map((thread) -> {
return thread.getName() + ": \n\tat " + (String) Arrays.stream(thread.getStackTrace()).map(Object::toString).collect(Collectors.joining("\n\tat "));
2020-06-26 01:38:24 +02:00
@@ -35,11 +35,11 @@ public class DataPaletteBlock<T> implements DataPaletteExpandable<T> {
throw new ReportedException(crashreport);
} else {
this.j.lock();
- }
+ } */ // Paper end
}
public void b() {
- this.j.unlock();
+ //this.j.unlock(); // Paper - disable this
}
public DataPaletteBlock(DataPalette<T> datapalette, RegistryBlockID<T> registryblockid, Function<NBTTagCompound, T> function, Function<T, NBTTagCompound> function1, T t0) {
2020-06-26 01:38:24 +02:00
@@ -75,7 +75,7 @@ public class DataPaletteBlock<T> implements DataPaletteExpandable<T> {
}
@Override
- public int onResize(int i, T t0) {
+ public synchronized int onResize(int i, T t0) { // Paper - synchronize
this.a();
DataBits databits = this.a;
DataPalette<T> datapalette = this.h;
2020-06-26 01:38:24 +02:00
@@ -98,18 +98,18 @@ public class DataPaletteBlock<T> implements DataPaletteExpandable<T> {
}
public T setBlock(int i, int j, int k, T t0) {
- this.a();
- T t1 = this.a(b(i, j, k), t0);
+ //this.a(); // Paper - remove to reduce ops - synchronize handled below
+ return this.a(b(i, j, k), t0); // Paper
- this.b();
- return t1;
+ //this.b(); // Paper
+ //return t1; // PAper
}
public T b(int i, int j, int k, T t0) {
return this.a(b(i, j, k), t0);
}
- protected T a(int i, T t0) {
+ protected synchronized T a(int i, T t0) { // Paper - synchronize - writes
int j = this.h.a(t0);
int k = this.a.a(i, j);
T t1 = this.h.a(k);
2020-06-26 01:38:24 +02:00
@@ -134,7 +134,7 @@ public class DataPaletteBlock<T> implements DataPaletteExpandable<T> {
}
public void writeDataPaletteBlock(PacketDataSerializer packetDataSerializer) { this.b(packetDataSerializer); } // Paper - OBFHELPER
- public void b(PacketDataSerializer packetdataserializer) {
+ public synchronized void b(PacketDataSerializer packetdataserializer) { // Paper - synchronize
this.a();
packetdataserializer.writeByte(this.i);
this.h.b(packetdataserializer);
2020-06-26 01:38:24 +02:00
@@ -142,7 +142,7 @@ public class DataPaletteBlock<T> implements DataPaletteExpandable<T> {
this.b();
}
- public void a(NBTTagList nbttaglist, long[] along) {
+ public synchronized void a(NBTTagList nbttaglist, long[] along) { // Paper - synchronize
this.a();
2020-06-26 01:38:24 +02:00
int i = Math.max(4, MathHelper.e(nbttaglist.size()));
2020-06-26 01:38:24 +02:00
@@ -175,7 +175,7 @@ public class DataPaletteBlock<T> implements DataPaletteExpandable<T> {
this.b();
}
- public void a(NBTTagCompound nbttagcompound, String s, String s1) {
+ public synchronized void a(NBTTagCompound nbttagcompound, String s, String s1) { // Paper - synchronize
this.a();
DataPaletteHash<T> datapalettehash = new DataPaletteHash<>(this.d, this.i, this.c, this.e, this.f);
T t0 = this.g;