Repo-Mirror/Gale
9
0
Fork 0
mirror of https://github.com/Dreeam-qwq/Gale.git synced 2025-12-29 11:39:10 +00:00
Code Issues Releases Activity

Updated Upstream (Paper)

Browse Source
This commit is contained in:
Dreeam
2024-03-06 07:14:37 -05:00
parent 84c9345252
commit 377da10d2e
101 changed files with 297 additions and 371 deletions
Download Patch File Download Diff File Expand all files Collapse all files

213
patches/server/0134-Optimize-VarLong-write.patch Normal file
View File

@@ -0,0 +1,213 @@
From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
From: Martijn Muijsers <martijnmuijsers@live.nl>
Date: Tue, 22 Aug 2023 21:38:37 +0200
Subject: [PATCH] Optimize VarLong#write
License: GPL-3.0 (https://www.gnu.org/licenses/gpl-3.0.html)
Gale - https://galemc.org
This patch is based on the following commit:
"Reapply "Optimize varint writing""
By: Andrew Steinborn <git@steinborn.me>
As part of: Velocity (https://github.com/PaperMC/Velocity)
Licensed under: GPL-3.0 (https://www.gnu.org/licenses/gpl-3.0.html)
* Velocity description *
Inspired by the approach described at the bottom of https://richardstartin.github.io/posts/dont-use-protobuf-for-telemetry
Given that we do a lot of varint writing as well, this should provide a small performance boost for larger/complex packets whilst not regressing hard on smaller packets.
This includes a test to ensure that the behavior is as expected and fixes the initialization loop so that the correct results will be given. Much thanks to @octylFractal for acting as my duck while trying to figure this out.
diff --git a/src/main/java/net/minecraft/network/VarLong.java b/src/main/java/net/minecraft/network/VarLong.java
index 4c1fbf3e2e6cfaf5f5db199b232d007ec6a9d226..10546fb8b47b54989f5f98ddf37f202699abfb6d 100644
--- a/src/main/java/net/minecraft/network/VarLong.java
+++ b/src/main/java/net/minecraft/network/VarLong.java
@@ -54,6 +54,127 @@ public class VarLong {
}
public static ByteBuf write(ByteBuf buf, long l) {
+ // Gale start - Velocity - optimized VarLong#write
+ if ((l & 0xFFFFFFFFFFFFFF80L) == 0) {
+ buf.writeByte((int) l);
+ } else if (l < 0) {
+ // The case of writing arbitrary longs is common
+ // Here, the number is negative, which has probability 1/2 for arbitrary numbers
+ int least7bits = (int) (l & 0xFFFFFFFL);
+ int w = (least7bits & 0x7F) << 24
+ | (least7bits & 0x3F80) << 9
+ | (least7bits & 0x1FC000) >> 6
+ | ((least7bits >>> 21) & 0x7F)
+ | 0x80808080;
+ long nonLeast7Bits = l >>> 28;
+ int secondLeast7bits = (int) (nonLeast7Bits & 0xFFFFFFFL);
+ int w2 = (secondLeast7bits & 0x7F) << 24
+ | ((secondLeast7bits & 0x3F80) << 9)
+ | (secondLeast7bits & 0x1FC000) >> 6
+ | (secondLeast7bits >>> 21)
+ | 0x80808080;
+ int thirdLeast7Bits = (int) (nonLeast7Bits >>> 28);
+ int w3 = (thirdLeast7Bits & 0x7F) << 8
+ | (thirdLeast7Bits >>> 7)
+ | 0x00008000;
+ buf.writeInt(w);
+ buf.writeInt(w2);
+ buf.writeShort(w3);
+ } else if ((l & 0xFFFFFFFFFFFFC000L) == 0) {
+ int least7bits = (int) l;
+ int w = (least7bits & 0x7F) << 8
+ | (least7bits >>> 7)
+ | 0x00008000;
+ buf.writeShort(w);
+ } else if ((l & 0xFFFFFFFFFFE00000L) == 0) {
+ int least7bits = (int) l;
+ int w = (least7bits & 0x7F) << 16
+ | (least7bits & 0x3F80) << 1
+ | (least7bits >>> 14)
+ | 0x00808000;
+ buf.writeMedium(w);
+ } else if ((l & 0xFFFFFFFFF0000000L) == 0) {
+ int least7bits = (int) l;
+ int w = (least7bits & 0x7F) << 24
+ | ((least7bits & 0x3F80) << 9)
+ | (least7bits & 0x1FC000) >> 6
+ | (least7bits >>> 21)
+ | 0x80808000;
+ buf.writeInt(w);
+ } else if ((l & 0xFFFFFFF800000000L) == 0) {
+ int least7bits = (int) (l & 0xFFFFFFFL);
+ int w = (least7bits & 0x7F) << 24
+ | (least7bits & 0x3F80) << 9
+ | (least7bits & 0x1FC000) >> 6
+ | ((least7bits >>> 21) & 0x7F)
+ | 0x80808080;
+ buf.writeInt(w);
+ buf.writeByte((int) (l >>> 28));
+ } else if ((l & 0xFFFFFC0000000000L) == 0) {
+ int least7bits = (int) (l & 0xFFFFFFFL);
+ int w = (least7bits & 0x7F) << 24
+ | (least7bits & 0x3F80) << 9
+ | (least7bits & 0x1FC000) >> 6
+ | ((least7bits >>> 21) & 0x7F)
+ | 0x80808080;
+ int secondLeast7bits = (int) (l >>> 28);
+ int w2 = (secondLeast7bits & 0x7F) << 8
+ | (secondLeast7bits >>> 7)
+ | 0x00008000;
+ buf.writeInt(w);
+ buf.writeShort(w2);
+ } else if ((l & 0xFFFE000000000000L) == 0) {
+ int least7bits = (int) (l & 0xFFFFFFFL);
+ int w = (least7bits & 0x7F) << 24
+ | (least7bits & 0x3F80) << 9
+ | (least7bits & 0x1FC000) >> 6
+ | ((least7bits >>> 21) & 0x7F)
+ | 0x80808080;
+ int secondLeast7bits = (int) (l >>> 28);
+ int w2 = (secondLeast7bits & 0x7F) << 16
+ | (secondLeast7bits & 0x3F80) << 1
+ | (secondLeast7bits >>> 14)
+ | 0x00808000;
+ buf.writeInt(w);
+ buf.writeMedium(w2);
+ } else if ((l & 0xFF00000000000000L) == 0) {
+ int least7bits = (int) (l & 0xFFFFFFFL);
+ int w = (least7bits & 0x7F) << 24
+ | (least7bits & 0x3F80) << 9
+ | (least7bits & 0x1FC000) >> 6
+ | ((least7bits >>> 21) & 0x7F)
+ | 0x80808080;
+ int secondLeast7bits = (int) (l >>> 28);
+ int w2 = (secondLeast7bits & 0x7F) << 24
+ | ((secondLeast7bits & 0x3F80) << 9)
+ | (secondLeast7bits & 0x1FC000) >> 6
+ | (secondLeast7bits >>> 21)
+ | 0x80808000;
+ buf.writeInt(w);
+ buf.writeInt(w2);
+ } else {
+ int least7bits = (int) (l & 0xFFFFFFFL);
+ int w = (least7bits & 0x7F) << 24
+ | (least7bits & 0x3F80) << 9
+ | (least7bits & 0x1FC000) >> 6
+ | ((least7bits >>> 21) & 0x7F)
+ | 0x80808080;
+ long nonLeast7Bits = l >>> 28;
+ int secondLeast7bits = (int) (nonLeast7Bits & 0xFFFFFFFL);
+ int w2 = (secondLeast7bits & 0x7F) << 24
+ | ((secondLeast7bits & 0x3F80) << 9)
+ | (secondLeast7bits & 0x1FC000) >> 6
+ | (secondLeast7bits >>> 21)
+ | 0x80808080;
+ buf.writeInt(w);
+ buf.writeInt(w2);
+ buf.writeByte((int) (nonLeast7Bits >>> 28));
+ }
+ return buf;
+ }
+
+ static ByteBuf writeOriginal(ByteBuf buf, long l) { // public -> package-private
+ // Gale end - Velocity - optimized VarLong#write
while((l & -128L) != 0L) {
buf.writeByte((int)(l & 127L) | 128);
l >>>= 7;
diff --git a/src/test/java/net/minecraft/network/VarIntLongTest.java b/src/test/java/net/minecraft/network/VarIntLongTest.java
index a1892a904042fcfad9137df592dabd46d4d1c30b..892877b1a1ebfe42bb7a7af7555606329c39e9b3 100644
--- a/src/test/java/net/minecraft/network/VarIntLongTest.java
+++ b/src/test/java/net/minecraft/network/VarIntLongTest.java
@@ -2,6 +2,7 @@
package net.minecraft.network;
+import io.netty.buffer.Unpooled;
import it.unimi.dsi.fastutil.ints.IntOpenHashSet;
import it.unimi.dsi.fastutil.ints.IntSet;
import it.unimi.dsi.fastutil.longs.LongOpenHashSet;
@@ -156,4 +157,46 @@ public class VarIntLongTest {
}
// Gale end - Velocity - pre-compute VarInt and VarLong sizes
+ // Gale - Velocity - optimized VarInt#write and VarLong#write
+ @Test
+ public void testWriteVarIntComparedToOld() {
+ integerCases.forEach(value -> {
+ // given
+ int capacity = 5;
+ FriendlyByteBuf buf1 = new FriendlyByteBuf(Unpooled.buffer(capacity));
+ FriendlyByteBuf buf2 = new FriendlyByteBuf(Unpooled.buffer(capacity));
+ VarInt.writeOld(buf1, value);
+
+ // when
+ buf2.writeVarInt(value);
+
+ // then
+ Assertions.assertEquals(Float.parseFloat("Writer index of optimized buffer (" + buf2.writerIndex() + ") is not equal to writer index of original buffer (" + buf1.writerIndex() + ") for test case value " + value + " (binary: " + padStringWithLeadingZeros(Integer.toBinaryString(value), 32) + ")"), buf1.writerIndex(), buf2.writerIndex());
+ for (int i = 0; i < capacity; i++) {
+ Assertions.assertEquals(Float.parseFloat("Buffer byte (at index " + i + ") in optimized buffer (" + buf2.getByte(i) + " (binary: " + padStringWithLeadingZeros(Integer.toBinaryString(Byte.toUnsignedInt(buf2.getByte(i))), 8) + ")) is not equal to the same byte in original buffer (" + buf1.getByte(i) + " (binary: " + padStringWithLeadingZeros(Integer.toBinaryString(Byte.toUnsignedInt(buf1.getByte(i))), 8) + ")) for test case value " + value + " (binary: " + padStringWithLeadingZeros(Integer.toBinaryString(value), 32) + ")"), buf1.getByte(i), buf2.getByte(i));
+ }
+ });
+ }
+
+ @Test
+ public void testWriteVarLongComparedToOriginal() {
+ longCases.forEach(value -> {
+ // given
+ int capacity = 10;
+ FriendlyByteBuf buf1 = new FriendlyByteBuf(Unpooled.buffer(capacity));
+ FriendlyByteBuf buf2 = new FriendlyByteBuf(Unpooled.buffer(capacity));
+ VarLong.writeOriginal(buf1, value);
+
+ // when
+ buf2.writeVarLong(value);
+
+ // then
+ Assertions.assertEquals(Float.parseFloat("Writer index of optimized buffer (" + buf2.writerIndex() + ") is not equal to writer index of original buffer (" + buf1.writerIndex() + ") for test case value " + value + " (binary: " + padStringWithLeadingZeros(Long.toBinaryString(value), 64) + ")"), buf1.writerIndex(), buf2.writerIndex());
+ for (int i = 0; i < capacity; i++) {
+ Assertions.assertEquals(Float.parseFloat("Buffer byte (at index " + i + ") in optimized buffer (" + buf2.getByte(i) + " (binary: " + padStringWithLeadingZeros(Integer.toBinaryString(Byte.toUnsignedInt(buf2.getByte(i))), 8) + ")) is not equal to the same byte in original buffer (" + buf1.getByte(i) + " (binary: " + padStringWithLeadingZeros(Integer.toBinaryString(Byte.toUnsignedInt(buf1.getByte(i))), 8) + ")) for test case value " + value + " (binary: " + padStringWithLeadingZeros(Long.toBinaryString(value), 64) + ")"), buf1.getByte(i), buf2.getByte(i));
+ }
+ });
+ }
+ // Gale end - Velocity - optimized VarInt#write and VarLong#write
+
}