Leaf/leaf-server/minecraft-patches/features/0122-Faster-sequencing-of-futures-for-chunk-structure-gen.patch

From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
From: Dreeam <61569423+Dreeam-qwq@users.noreply.github.com>
Date: Tue, 2 Jan 2024 21:13:53 -0500
Subject: [PATCH] Faster sequencing of futures for chunk structure gen

Replace `thenApply` with `thenCompose`. Once one task is completed then the next task starts immediately,
to prevent blocking threads while waiting to complete all tasks. But may cause the sequence of future compose disorder.

diff --git a/net/minecraft/Util.java b/net/minecraft/Util.java
index 138a58c5e5698b926b01e0170733dc3dbc5589ec..64372e0fd4eb7018fc36d0feb667c296ea48f927 100644
--- a/net/minecraft/Util.java
+++ b/net/minecraft/Util.java
@@ -625,17 +625,39 @@ public class Util {
         return Maps.transformValues(map, mapper);
     }
 
+    // Leaf start - Faster sequencing of futures for chunk structure gen
     public static <V> CompletableFuture<List<V>> sequence(List<? extends CompletableFuture<V>> futures) {
+        return sequence(futures, false);
+    }
+    public static <V> CompletableFuture<List<V>> sequence(List<? extends CompletableFuture<V>> futures, boolean useFaster) {
+        // Leaf end - Faster sequencing of futures for chunk structure gen
         if (futures.isEmpty()) {
             return CompletableFuture.completedFuture(List.of());
         } else if (futures.size() == 1) {
             return futures.get(0).thenApply(List::of);
         } else {
             CompletableFuture<Void> completableFuture = CompletableFuture.allOf(futures.toArray(new CompletableFuture[0]));
+            if (useFaster) return sequenceFaster(futures, completableFuture); // Leaf - Faster sequencing of futures for chunk structure gen
             return completableFuture.thenApply(_void -> futures.stream().map(CompletableFuture::join).toList());
         }
     }
 
+    // Leaf start - Faster sequencing of futures for chunk structure gen
+    private static <V> CompletableFuture<List<V>> sequenceFaster(List<? extends CompletableFuture<V>> futures, CompletableFuture<Void> completableFuture) {
+        return completableFuture.thenCompose($ ->
+            CompletableFuture.supplyAsync(() -> {
+                    List<V> list = new java.util.ArrayList<>();
+
+                    for (CompletableFuture<V> future : futures) {
+                        list.add(future.join());
+                    }
+
+                    return list;
+                }
+            ));
+    }
+    // Leaf end - Faster sequencing of futures for chunk structure gen
+
     public static <V> CompletableFuture<List<V>> sequenceFailFast(List<? extends CompletableFuture<? extends V>> completableFutures) {
         CompletableFuture<List<V>> completableFuture = new CompletableFuture<>();
         return fallibleSequence(completableFutures, completableFuture::completeExceptionally).applyToEither(completableFuture, Function.identity());
diff --git a/net/minecraft/server/ReloadableServerRegistries.java b/net/minecraft/server/ReloadableServerRegistries.java
index 512d59188ff43e34463e2845aa8a174792c407a7..ca84304526050176ca7406f7a13c144798a0ed74 100644
--- a/net/minecraft/server/ReloadableServerRegistries.java
+++ b/net/minecraft/server/ReloadableServerRegistries.java
@@ -50,7 +50,7 @@ public class ReloadableServerRegistries {
         List<CompletableFuture<WritableRegistry<?>>> list1 = LootDataType.values()
             .map(lootDataType -> scheduleRegistryLoad((LootDataType<?>)lootDataType, registryOps, resourceManager, backgroundExecutor, conversions)) // Paper
             .toList();
-        CompletableFuture<List<WritableRegistry<?>>> completableFuture = Util.sequence(list1);
+        CompletableFuture<List<WritableRegistry<?>>> completableFuture = Util.sequence(list1, false); // Leaf - Faster sequencing of futures for chunk structure gen
         return completableFuture.thenApplyAsync(
             list2 -> createAndValidateFullContext(registryAccess, provider, (List<WritableRegistry<?>>)list2), backgroundExecutor
         );
diff --git a/net/minecraft/world/level/chunk/ChunkGeneratorStructureState.java b/net/minecraft/world/level/chunk/ChunkGeneratorStructureState.java
index 619b98e42e254c0c260c171a26a2472ddf59b885..f07a5416e5dc7e9a798a78ce9573a0c42bc59d04 100644
--- a/net/minecraft/world/level/chunk/ChunkGeneratorStructureState.java
+++ b/net/minecraft/world/level/chunk/ChunkGeneratorStructureState.java
@@ -255,7 +255,7 @@ public class ChunkGeneratorStructureState {
                 }
             }
 
-            return Util.sequence(list).thenApply(completed -> {
+            return Util.sequence(list, org.dreeam.leaf.config.modules.opt.FasterStructureGenFutureSequencing.enabled).thenApply(completed -> { // Leaf - Faster sequencing of futures for chunk structure gen
                 double d2 = stopwatch.stop().elapsed(TimeUnit.MILLISECONDS) / 1000.0;
                 LOGGER.debug("Calculation for {} took {}s", structureSet, d2);
                 return completed;