new: use FlowSched for worldgen scheduling

Doesn't build artifacts but devlaunch works

.github/workflows/build.yml

@@ -10,9 +10,10 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v4
       with:
         fetch-depth: 0
+        submodules: true
 
     - name: Set up JDK 17
       uses: actions/setup-java@v2

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "FlowSched"]
+	path = FlowSched
+	url = https://github.com/RelativityMC/FlowSched.git

build.gradle

@@ -37,6 +37,8 @@ configure(allprojects) {
 
 archivesBaseName = "${project.archives_base_name}-mc${project.minecraft_version}"
 
+clean.dependsOn gradle.includedBuild('FlowSched').task(':clean')
+
 configure (allprojects - project(":tests")) {
     if (project != project(":") && project.parent != project(":")) return
 
@@ -122,6 +124,7 @@ configure (allprojects - project(":tests")) {
         implementation "org.threadly:threadly:${threadly_version}"
         implementation "net.objecthunter:exp4j:${exp4j_version}"
         implementation "com.github.LlamaLad7:MixinExtras:${mixinextras_version}"
+        implementation "com.ishland.flowsched:flowsched"
 
         annotationProcessor "com.github.LlamaLad7:MixinExtras:${mixinextras_version}"
     }
@@ -152,6 +155,7 @@ dependencies {
     include implementation("org.threadly:threadly:${threadly_version}")
     include implementation("net.objecthunter:exp4j:${exp4j_version}")
     include implementation("com.github.LlamaLad7:MixinExtras:${mixinextras_version}")
+    include implementation("com.ishland.flowsched:flowsched")
 
     // PSA: Some older mods, compiled on Loom 0.2.1, might have outdated Maven POMs.
     // You may need to force-disable transitiveness on them.

c2me-base/src/main/java/com/ishland/c2me/base/common/GlobalExecutors.java

@@ -3,13 +3,15 @@
 import com.google.common.util.concurrent.ThreadFactoryBuilder;
 import com.ishland.c2me.base.ModuleEntryPoint;
 import com.ishland.c2me.base.common.util.C2MENormalWorkerThreadFactory;
+import com.ishland.flowsched.executor.ExecutorManager;
 
 import java.util.concurrent.Executor;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.concurrent.LinkedBlockingQueue;
 import java.util.concurrent.ThreadPoolExecutor;
 import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
 
 public class GlobalExecutors {
 
@@ -23,6 +25,11 @@ public class GlobalExecutors {
 //            true
 //    );
     public static final ExecutorService executor = Executors.newFixedThreadPool(GLOBAL_EXECUTOR_PARALLELISM, factory);
+    private static final AtomicInteger prioritizedSchedulerCounter = new AtomicInteger(0);
+    public static final ExecutorManager prioritizedScheduler = new ExecutorManager(GlobalExecutors.GLOBAL_EXECUTOR_PARALLELISM, thread -> {
+        thread.setDaemon(true);
+        thread.setName("c2me-prioritized-%d".formatted(prioritizedSchedulerCounter.getAndIncrement()));
+    });
     public static final Executor invokingExecutor = r -> {
         if (Thread.currentThread().getThreadGroup() == factory.getThreadGroup()) {
             r.run();

c2me-base/src/main/java/com/ishland/c2me/base/common/scheduler/LockTokenImpl.java

@@ -0,0 +1,6 @@
+package com.ishland.c2me.base.common.scheduler;
+
+import com.ishland.flowsched.executor.LockToken;
+
+public record LockTokenImpl(int ownerTag, long pos) implements LockToken {
+}

c2me-base/src/main/java/com/ishland/c2me/base/common/scheduler/ScheduledTask.java

@@ -1,13 +1,60 @@
 package com.ishland.c2me.base.common.scheduler;
 
-public interface ScheduledTask {
+import com.ishland.flowsched.executor.LockToken;
+import com.ishland.flowsched.executor.Task;
 
-    public boolean tryPrepare();
+import java.util.concurrent.CompletableFuture;
+import java.util.function.Supplier;
 
-    public void runTask(Runnable postAction);
+public class ScheduledTask<T> implements Task {
 
-    public long centerPos();
+    private final long pos;
+    private final Supplier<CompletableFuture<T>> action;
+    private final LockToken[] lockTokens;
+    private final CompletableFuture<T> future = new CompletableFuture<>();
+    private int priority = Integer.MAX_VALUE;
 
-    public boolean isAsync();
+    public ScheduledTask(long pos, Supplier<CompletableFuture<T>> action, LockToken[] lockTokens) {
+        this.pos = pos;
+        this.action = action;
+        this.lockTokens = lockTokens;
+    }
 
+    @Override
+    public void run() {
+        action.get().whenComplete((t, throwable) -> {
+            if (throwable != null) {
+                future.completeExceptionally(throwable);
+            } else {
+                future.complete(t);
+            }
+        });
+    }
+
+    @Override
+    public void propagateException(Throwable t) {
+        future.completeExceptionally(t);
+    }
+
+    @Override
+    public LockToken[] lockTokens() {
+        return this.lockTokens;
+    }
+
+    @Override
+    public int priority() {
+        return this.priority;
+    }
+
+    public void setPriority(int priority) {
+        this.priority = priority;
+    }
+
+    public long getPos() {
+        return this.pos;
+    }
+
+    public CompletableFuture<T> getFuture() {
+        return this.future;
+    }
 }