From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 From: Martijn Muijsers Date: Tue, 22 Aug 2023 21:38:37 +0200 Subject: [PATCH] Optimize VarInt#write and 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 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/VarInt.java b/src/main/java/net/minecraft/network/VarInt.java index 74ed47659d3e615c2dae7da98d5a8cf1559625bf..82a8354b5ce503508716af3966b9809a6b4d956c 100644 --- a/src/main/java/net/minecraft/network/VarInt.java +++ b/src/main/java/net/minecraft/network/VarInt.java @@ -51,6 +51,41 @@ public class VarInt { } public static ByteBuf write(ByteBuf buf, int i) { + // Gale start - Velocity - optimized VarInt#write + if ((i & 0xFFFFFF80) == 0) { + buf.writeByte(i); + } else if ((i & 0xFFFFC000) == 0) { + int w = (i & 0x7F) << 8 + | (i >>> 7) + | 0x00008000; + buf.writeShort(w); + } else if ((i & 0xFFE00000) == 0) { + int w = (i & 0x7F) << 16 + | (i & 0x3F80) << 1 + | (i >>> 14) + | 0x00808000; + buf.writeMedium(w); + } else if ((i & 0xF0000000) == 0) { + int w = (i & 0x7F) << 24 + | ((i & 0x3F80) << 9) + | (i & 0x1FC000) >> 6 + | (i >>> 21) + | 0x80808000; + buf.writeInt(w); + } else { + int w = (i & 0x7F) << 24 + | (i & 0x3F80) << 9 + | (i & 0x1FC000) >> 6 + | ((i >>> 21) & 0x7F) + | 0x80808080; + buf.writeInt(w); + buf.writeByte(i >>> 28); + } + return buf; + } + + static ByteBuf writeOld(ByteBuf buf, int i) { // public -> package-private + // Gale end - Velocity - optimized VarInt#write // Paper start - Optimize VarInts // Peel the one and two byte count cases explicitly as they are the most common VarInt sizes // that the proxy will write, to improve inlining. @@ -60,11 +95,11 @@ public class VarInt { int w = (i & 0x7F | 0x80) << 8 | (i >>> 7); buf.writeShort(w); } else { - writeOld(buf, i); + writeOld2(buf, i); // rename } return buf; } - public static ByteBuf writeOld(ByteBuf buf, int i) { + public static ByteBuf writeOld2(ByteBuf buf, int i) { // rename // Paper end - Optimize VarInts while ((i & -128) != 0) { buf.writeByte(i & 127 | 128); diff --git a/src/main/java/net/minecraft/network/VarLong.java b/src/main/java/net/minecraft/network/VarLong.java index 11339185fc70b1a34130c92d28c397d4b05569cb..c127dd051572177e4fc379bb7e2d40571d0abeed 100644 --- a/src/main/java/net/minecraft/network/VarLong.java +++ b/src/main/java/net/minecraft/network/VarLong.java @@ -51,6 +51,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 writeOld(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 bbea09ffc2180c3c62e15d7dff51f8c220425bfe..0c11670d8d7307307a7cd12be5d0dca40155829d 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(buf1.writerIndex(), buf2.writerIndex(), "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) + ")"); + for (int i = 0; i < capacity; i++) { + Assertions.assertEquals(buf1.getByte(i), buf2.getByte(i), "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) + ")"); + } + }); + } + + @Test + public void testWriteVarLongComparedToOld() { + longCases.forEach(value -> { + // given + int capacity = 10; + FriendlyByteBuf buf1 = new FriendlyByteBuf(Unpooled.buffer(capacity)); + FriendlyByteBuf buf2 = new FriendlyByteBuf(Unpooled.buffer(capacity)); + VarLong.writeOld(buf1, value); + + // when + buf2.writeVarLong(value); + + // then + Assertions.assertEquals(buf1.writerIndex(), buf2.writerIndex(), "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) + ")"); + for (int i = 0; i < capacity; i++) { + Assertions.assertEquals(buf1.getByte(i), buf2.getByte(i), "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) + ")"); + } + }); + } + // Gale end - Velocity - optimized VarInt#write and VarLong#write + }