Leaf/leaf-archived-patches/unapplied/server/minecraft-patches/features/0031-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 80a7a85e1a03a1ca406259207e1ae3b909b3284f..b097f685e826e70008e3a096ee5f1d4fccf25680 100644
--- a/net/minecraft/Util.java
+++ b/net/minecraft/Util.java
@@ -607,17 +607,42 @@ public class Util {
         return map;
     }
 
+    // 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(void_ ->
+            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 d8c472b8c6aadcaadef14abd8ab43f466e94417e..bc079b6c3d751f2a63d089bf209cf7d8e0da76e8 100644
--- a/net/minecraft/server/ReloadableServerRegistries.java
+++ b/net/minecraft/server/ReloadableServerRegistries.java
@@ -52,7 +52,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;