feat(anvil): experimental multithreaded chunkloader

.github/workflows/build-pr.yml

@@ -20,4 +20,16 @@ jobs:
           distribution: temurin
           java-version: 25
       - name: Build on ${{ matrix.os }}
-        run: ./gradlew clean build
+        run: ./gradlew clean build
+      # Gradle's console summary names the failing test and the exception type, but not the
+      # message, the path or the stack trace. For a failure that only happens on one operating
+      # system, that is the difference between reading the cause and guessing at it.
+      - name: Upload test reports
+        if: failure()
+        uses: actions/upload-artifact@v4
+        with:
+          name: test-reports-${{ matrix.os }}
+          path: |
+            build/reports/tests/
+            build/test-results/
+          retention-days: 7

.gitignore

@@ -32,4 +32,7 @@ bin/
 
 # OS-spezifisch
 .DS_Store
-Thumbs.db
+Thumbs.db
+
+# Serena (MCP code navigation)
+.serena/

build.gradle.kts

@@ -2,6 +2,7 @@ plugins {
     `java-library`
     `maven-publish`
     jacoco
+    alias(libs.plugins.jmh)
 }
 
 group = "net.theevilreaper"
@@ -25,14 +26,52 @@ dependencies {
     implementation(libs.slf4j.api)
 
     compileOnly(libs.adventure)
+    compileOnly(libs.adventure.nbt)
+    compileOnly(libs.annotations)
     compileOnly(libs.minestom)
 
     testImplementation(libs.adventure)
+    testImplementation(libs.adventure.nbt)
+    testImplementation(libs.annotations)
     testImplementation(libs.minestom)
     testImplementation(libs.cyano)
     testImplementation(libs.junit.jupiter)
     testImplementation(libs.junit.platform.launcher)
     testRuntimeOnly(libs.junit.jupiter.engine)
+
+    // The benchmarks live in their own source set (src/jmh/java). Nothing declared here reaches the
+    // main or the test classpath, so the published library never carries a jmh dependency.
+    jmhImplementation(platform(libs.mycelium.bom))
+    jmhImplementation(platform(libs.adventure.bom))
+    jmhImplementation(libs.adventure.nbt)
+    jmhImplementation(libs.annotations)
+    jmhImplementation(libs.jmh.core)
+    // Minestom is needed only by the comparison benchmark, which measures our light engine against
+    // the one the server ships with. It stays out of every other benchmark on purpose, so those
+    // measure this library and not a registry lookup.
+    jmhImplementation(libs.minestom)
+    jmhImplementation(libs.fastutil)
+    // No jmh annotation processor is declared on purpose. The plugin already generates the harness
+    // classes with its bytecode generator, and declaring the processor as well makes both of them
+    // emit the same classes, which leaves the jar with two copies of every benchmark.
+}
+
+jmh {
+    jmhVersion.set(libs.versions.jmh)
+    // The tests of this project need a Minestom server, which a benchmark jar cannot start.
+    includeTests.set(false)
+    resultFormat.set("JSON")
+    resultsFile.set(layout.buildDirectory.file("reports/jmh/results.json"))
+    humanOutputFile.set(layout.buildDirectory.file("reports/jmh/human.txt"))
+
+    // A full run takes the better part of an hour, so a single benchmark has to be reachable
+    // without editing this file.
+    // Usage: ./gradlew jmh -Pjmh.include='BitPackerBenchmark.pack'
+    val include = providers.gradleProperty("jmh.include").orNull
+
+    if (include != null) {
+        includes.set(listOf(include))
+    }
 }
 
 tasks {
@@ -41,6 +80,18 @@ tasks {
         options.release.set(25)
     }
 
+    compileJmhJava {
+        options.encoding = "UTF-8"
+    }
+
+    // The benchmarks are compiled by a normal build but never executed by one. A run takes the
+    // better part of an hour and its numbers are far too noisy on a shared runner to gate anything
+    // on, while a benchmark that stopped compiling after a refactoring should fail like any other
+    // source set.
+    check {
+        dependsOn(compileJmhJava)
+    }
+
     jacocoTestReport {
         dependsOn(rootProject.tasks.test)
         reports {
@@ -52,6 +103,10 @@ tasks {
     test {
         finalizedBy(rootProject.tasks.jacocoTestReport)
         useJUnitPlatform()
+        // The chunk loader tests allocate payloads of about one mebibyte to cover the external
+        // chunk file path. Without an explicit heap the worker can die while other build tasks
+        // run in parallel, which surfaces as an EOFException instead of a test failure.
+        maxHeapSize = "1g"
         jvmArgs("-Dminestom.inside-test=true")
         testLogging {
             events("passed", "skipped", "failed")