diff --git a/luminol-server/build.gradle.kts.patch b/luminol-server/build.gradle.kts.patch index 93c39e2..d5cf00d 100644 --- a/luminol-server/build.gradle.kts.patch +++ b/luminol-server/build.gradle.kts.patch @@ -64,6 +64,21 @@ implementation("ca.spottedleaf:concurrentutil:0.0.3") implementation("org.jline:jline-terminal-ffm:3.27.1") // use ffm on java 22+ implementation("org.jline:jline-terminal-jni:3.27.1") // fall back to jni on java 21 +@@ -204,6 +_,14 @@ + implementation("me.lucko:spark-paper:1.10.119-SNAPSHOT") + } + ++ ++// Pufferfish Start ++tasks.withType { ++ val compilerArgs = options.compilerArgs ++ compilerArgs.add("--add-modules=jdk.incubator.vector") ++} ++// Pufferfish End ++ + tasks.jar { + manifest { + val git = Git(rootProject.layout.projectDirectory.path) @@ -216,14 +_,14 @@ val gitBranch = git.exec(providers, "rev-parse", "--abbrev-ref", "HEAD").get().trim() attributes( diff --git a/luminol-server/minecraft-patches/features/0031-Gale-Variable-entity-wake-up-duration.patch b/luminol-server/minecraft-patches/features/0031-Gale-Variable-entity-wake-up-duration.patch new file mode 100644 index 0000000..13dc691 --- /dev/null +++ b/luminol-server/minecraft-patches/features/0031-Gale-Variable-entity-wake-up-duration.patch @@ -0,0 +1,56 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: MrHua269 +Date: Sun, 12 Jan 2025 14:12:07 +0800 +Subject: [PATCH] Gale Variable entity wake-up duration + + +diff --git a/io/papermc/paper/entity/activation/ActivationRange.java b/io/papermc/paper/entity/activation/ActivationRange.java +index 76e0b50b2dc9c718a67f89de720a891b398cec2a..4f0d6495fe8ae1d8104f31614350da7f84647505 100644 +--- a/io/papermc/paper/entity/activation/ActivationRange.java ++++ b/io/papermc/paper/entity/activation/ActivationRange.java +@@ -54,27 +54,41 @@ public final class ActivationRange { + if (entity.activationType == ActivationType.VILLAGER) { + if (inactiveFor > config.wakeUpInactiveVillagersEvery && worldData.wakeupInactiveRemainingVillagers > 0) { // Folia - threaded regions + worldData.wakeupInactiveRemainingVillagers--; // Folia - threaded regions +- return config.wakeUpInactiveVillagersFor; ++ return getWakeUpDurationWithVariance(entity, config.wakeUpInactiveVillagersFor); // Gale - variable entity wake-up duration + } + } else if (entity.activationType == ActivationType.ANIMAL) { + if (inactiveFor > config.wakeUpInactiveAnimalsEvery && worldData.wakeupInactiveRemainingAnimals > 0) { // Folia - threaded regions + worldData.wakeupInactiveRemainingAnimals--; // Folia - threaded regions +- return config.wakeUpInactiveAnimalsFor; ++ return getWakeUpDurationWithVariance(entity, config.wakeUpInactiveAnimalsFor); // Gale - variable entity wake-up duration + } + } else if (entity.activationType == ActivationType.FLYING_MONSTER) { + if (inactiveFor > config.wakeUpInactiveFlyingEvery && worldData.wakeupInactiveRemainingFlying > 0) { // Folia - threaded regions + worldData.wakeupInactiveRemainingFlying--; // Folia - threaded regions +- return config.wakeUpInactiveFlyingFor; ++ return getWakeUpDurationWithVariance(entity, config.wakeUpInactiveFlyingFor); // Gale - variable entity wake-up duration + } + } else if (entity.activationType == ActivationType.MONSTER || entity.activationType == ActivationType.RAIDER) { + if (inactiveFor > config.wakeUpInactiveMonstersEvery && worldData.wakeupInactiveRemainingMonsters > 0) { // Folia - threaded regions + worldData.wakeupInactiveRemainingMonsters--; // Folia - threaded regions +- return config.wakeUpInactiveMonstersFor; ++ return getWakeUpDurationWithVariance(entity, config.wakeUpInactiveMonstersFor); // Gale - variable entity wake-up duration + } + } + return -1; + } + ++ // Gale start - variable entity wake-up duration ++ private static final java.util.concurrent.ThreadLocalRandom wakeUpDurationRandom = java.util.concurrent.ThreadLocalRandom.current(); ++ ++ private static int getWakeUpDurationWithVariance(Entity entity, int wakeUpDuration) { ++ double deviation = me.earthme.luminol.config.modules.optimizations.GaleVariableEntityWakeupConfig.entityWakeUpDurationRatioStandardDeviation; ++ if (deviation <= 0) { ++ return wakeUpDuration; ++ } ++ return (int) Math.min(Integer.MAX_VALUE, Math.max(1, Math.round(wakeUpDuration * wakeUpDurationRandom.nextGaussian(1, deviation)))); ++ } ++ // Gale end - variable entity wake-up duration ++ ++ ++ + //static AABB maxBB = new AABB(0, 0, 0, 0, 0, 0); // Folia - threaded regions - replaced by local variable + + /** diff --git a/luminol-server/minecraft-patches/features/0032-Gale-Use-platform-math-functions.patch b/luminol-server/minecraft-patches/features/0032-Gale-Use-platform-math-functions.patch new file mode 100644 index 0000000..d4f858c --- /dev/null +++ b/luminol-server/minecraft-patches/features/0032-Gale-Use-platform-math-functions.patch @@ -0,0 +1,159 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: MrHua269 +Date: Sun, 12 Jan 2025 14:15:24 +0800 +Subject: [PATCH] Gale Use platform math functions + +License: GPL-3.0 (https://www.gnu.org/licenses/gpl-3.0.html) +Gale - https://galemc.org + +This patch is based on the following patch: +"Use Math.floor instead of fastfloor" +By: Xymb +As part of: Kaiiju (https://github.com/KaiijuMC/Kaiiju) +Licensed under: GPL-3.0 (https://www.gnu.org/licenses/gpl-3.0.html) + +* Comparison of floor methods used in Paper * + +Measure shown is floored number of milliseconds +(nanoseconds integer-divided by 1_000_000 +taken to get the floor of 1000 randomly chosen doubles +(all in the range of [-Integer.MAX_VALUE + 10, Integer.MAX_VALUE - 10]) +100_000 times (making it 100_000_000 floor operations total) +and adding it to a total. + +We are testing the following methods: +* net.minecraft.util.Mth.floor +* java.lang.Math.floor +* java.lang.StrictMath.floor +* org.apache.commons.math3.util.FastMath.floor +* org.apache.commons.math3.util.FastMath.floor, but with a hot start (see comment in code) +* io.papermc.paper.util.MCUtil.fastFloor + +The tests performed clearly show that Math.floor is the fastest. +This is most likely due to java.lang.Math's usage of the @IntrinsicCandidate +annotation, which allows the JVM to use a more optimized implementation at runtime. +However, in the case that there is no intrinsic replacement for Math.floor, +it defers to StrictMath.floor, which relies on a number of native methods, and is +still much faster than the existing Minecraft utility functions. +Therefore, using Math.floor instead of these functions is better regardless. +In Apache Commons Math 4, FastMath.floor has also been removed in favor of Math.floor. + +The versions used: +* Windows 10 Home 21H2 19044.3086 +* OpenJDK Runtime Environment Temurin-19.0.2+7 (build 19.0.2+7) +* Paper a3c760e6af1e8c7244ef75c6da6e6df278a79e14 on Minecraft 1.20.1 +* Apache Commons Math 3.6.1 + +Results: +Total is of type int Total is of type double +---------------------------------------------------------------------------------- +Mth.floor 2113 (double) Mth.floor 2658 +(int) Math.floor 130 Math.floor 194 +(int) StrictMath.floor 835 StrictMath.floor 381 +(int) FastMath.floor 412 FastMath.floor 376 +(int) FastMath.floor with hot start 359 FastMath.floor with hot start 321 +MCUtil.fastFloor 2284 (double) MCUtil.fastFloor 2469 + +Code is below: +```java +package somepackage; + +import io.papermc.paper.util.MCUtil; +import net.minecraft.util.Mth; + +import java.util.Random; + +public class Main { + + public static void main(String[] args) { + + // IF FastMath.floor with a hot start: + // FastMath.floor(37485.5); + + var random = new Random(4889338); + int size = 1000; + var values = new double[size]; + double bound = Integer.MAX_VALUE - 10; + for (int i = 0; i < size; i++) { + values[i] = random.nextDouble(bound * 2) - bound; + } + int repeats = 100_000; + + // int total = 0; + // OR + // double total = 0; + + long start = System.nanoTime(); + for (int repeat = 0; repeat < repeats; repeat++) { + for (int index = 0; index < size; index++) { + total += insert_function_being_tested_here(values[index]); + } + } + long diff = System.nanoTime() - start; + System.out.println(total); + System.out.println(diff / 1_000_000L); + + } + +} +``` + +diff --git a/net/minecraft/util/Mth.java b/net/minecraft/util/Mth.java +index d5d8134da9423cec199cf44762460104677194d6..e0eed27cb33348fcb46858c40014b5fe5dbaf426 100644 +--- a/net/minecraft/util/Mth.java ++++ b/net/minecraft/util/Mth.java +@@ -58,18 +58,15 @@ public class Mth { + } + + public static int floor(float value) { +- int i = (int)value; +- return value < i ? i - 1 : i; ++ return (int) Math.floor(value); // Gale - use platform math functions + } + + public static int floor(double value) { +- int i = (int)value; +- return value < i ? i - 1 : i; ++ return (int) Math.floor(value); // Gale - use platform math functions + } + + public static long lfloor(double value) { +- long l = (long)value; +- return value < l ? l - 1L : l; ++ return (long) Math.floor(value); // Gale - use platform math functions + } + + public static float abs(float value) { +@@ -81,13 +78,11 @@ public class Mth { + } + + public static int ceil(float value) { +- int i = (int)value; +- return value > i ? i + 1 : i; ++ return (int) Math.ceil(value); // Gale - use platform math functions + } + + public static int ceil(double value) { +- int i = (int)value; +- return value > i ? i + 1 : i; ++ return (int) Math.ceil(value); // Gale - use platform math functions + } + + public static int clamp(int value, int min, int max) { +@@ -123,15 +118,7 @@ public class Mth { + } + + public static double absMax(double x, double y) { +- if (x < 0.0) { +- x = -x; +- } +- +- if (y < 0.0) { +- y = -y; +- } +- +- return Math.max(x, y); ++ return Math.max(Math.abs(x), Math.abs(y)); // Gale - use platform math functions + } + + public static int floorDiv(int dividend, int divisor) { diff --git a/luminol-server/paper-patches/files/src/main/java/me/earthme/luminol/config/modules/optimizations/GaleVariableEntityWakeupConfig.java.patch b/luminol-server/paper-patches/files/src/main/java/me/earthme/luminol/config/modules/optimizations/GaleVariableEntityWakeupConfig.java.patch new file mode 100644 index 0000000..70f5dd7 --- /dev/null +++ b/luminol-server/paper-patches/files/src/main/java/me/earthme/luminol/config/modules/optimizations/GaleVariableEntityWakeupConfig.java.patch @@ -0,0 +1,23 @@ +--- /dev/null ++++ b/src/main/java/me/earthme/luminol/config/modules/optimizations/GaleVariableEntityWakeupConfig.java +@@ -1,0 +_,20 @@ ++package me.earthme.luminol.config.modules.optimizations; ++ ++import me.earthme.luminol.config.ConfigInfo; ++import me.earthme.luminol.config.EnumConfigCategory; ++import me.earthme.luminol.config.IConfigModule; ++ ++public class GaleVariableEntityWakeupConfig implements IConfigModule { ++ @ConfigInfo(baseName = "entity_wakeup_duration_ratio_standard_deviation") ++ public static double entityWakeUpDurationRatioStandardDeviation = 0.2; ++ ++ @Override ++ public EnumConfigCategory getCategory() { ++ return EnumConfigCategory.OPTIMIZATIONS; ++ } ++ ++ @Override ++ public String getBaseName() { ++ return "variable_entity_waking_up"; ++ } ++}