add custom task threads via os api

Author: elebras1

examples/src/main/java/com/github/elebras1/flecs/examples/components/TaskThreadExample.java

@@ -0,0 +1,63 @@
+package com.github.elebras1.flecs.examples.components;
+
+
+import com.github.elebras1.flecs.*;
+import com.github.elebras1.flecs.util.FlecsConstants;
+
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import java.util.concurrent.atomic.AtomicLong;
+
+public class TaskThreadExample {
+
+    private static final int NUMBER_THREADS = 4;
+
+    public static void main(String[] args) {
+        ExecutorService executor = Executors.newFixedThreadPool(NUMBER_THREADS);
+        Map<Long, Future<?>> futures = new ConcurrentHashMap<>();
+        AtomicLong counter = new AtomicLong();
+
+        OsApi osApi = new OsApi();
+        osApi.taskNew(task -> {
+                long id = counter.incrementAndGet();
+                futures.put(id, executor.submit(task));
+                return id;
+            })
+            .taskJoin(id -> {
+                try {
+                    futures.remove(id).get();
+                } catch (Exception e) {
+                    Thread.currentThread().interrupt();
+                }
+            })
+            .set();
+
+        try (World world = new World()) {
+            world.setTaskThreads(NUMBER_THREADS);
+            world.component(Health.class);
+
+            for(int i = 0; i < 100_000; i++) {
+                EntityView entity = world.obtainEntityView(world.entity());
+                entity.set(Health.class, (HealthView health) -> health.value(100));
+            }
+
+            world.system().with(Health.class).kind(FlecsConstants.EcsOnUpdate).multiThreaded().iter(iter -> {
+                Field<Health> healthField = iter.field(Health.class, 0);
+                for(int i = 0; i < iter.count(); i++) {
+                    HealthView health = healthField.getMutView(i);
+                    health.value(health.value() - 1);
+                }
+            });
+
+            for(int i = 0; i < 1000; i++) {
+                world.progress();
+            }
+
+            executor.close();
+        }
+
+    }
+}

src/main/java/com/github/elebras1/flecs/OsApi.java

@@ -0,0 +1,56 @@
+package com.github.elebras1.flecs;
+
+import com.github.elebras1.flecs.util.internal.FlecsLoader;
+
+import java.lang.foreign.Arena;
+import java.lang.foreign.MemorySegment;
+
+public class OsApi implements AutoCloseable {
+    private final Arena arena;
+    private final MemorySegment nativeOsApi;
+
+    static {
+        FlecsLoader.load();
+    }
+
+    @FunctionalInterface
+    public interface TaskNewCallback {
+        long run(Runnable task);
+    }
+
+    @FunctionalInterface
+    public interface TaskJoinCallback {
+        void run(long threadId);
+    }
+
+    public OsApi() {
+        this.arena = Arena.ofConfined();
+        flecs_h.ecs_os_set_api_defaults();
+        this.nativeOsApi = flecs_h.ecs_os_get_api(this.arena);
+    }
+
+    public OsApi taskNew(TaskNewCallback callback) {
+        MemorySegment nativeCallback = ecs_os_api_thread_new_t.allocate((cb, arg) ->
+                callback.run(() -> ecs_os_thread_callback_t.invoke(cb, arg)), this.arena);
+        ecs_os_api_t.task_new_(this.nativeOsApi, nativeCallback);
+        return this;
+    }
+
+    public OsApi taskJoin(TaskJoinCallback callback) {
+        MemorySegment nativeCallback = ecs_os_api_thread_join_t.allocate((threadId) -> {
+            callback.run(threadId);
+            return MemorySegment.NULL;
+        }, this.arena);
+        ecs_os_api_t.task_join_(this.nativeOsApi, nativeCallback);
+        return this;
+    }
+
+    public void set() {
+        flecs_h.ecs_os_set_api(this.nativeOsApi);
+    }
+
+    @Override
+    public void close() throws Exception {
+        this.arena.close();
+    }
+}

src/main/java/com/github/elebras1/flecs/World.java

@@ -412,6 +412,13 @@ public void setThreads(int threads) {
         this.resetStages();
     }
 
+    public void setTaskThreads(int taskThreads) {
+        this.checkClosed();
+        flecs_h.ecs_set_task_threads(this.nativeWorld, taskThreads);
+
+        this.resetStages();
+    }
+
     public void setPipeline(long pipelineId) {
         this.checkClosed();
         flecs_h.ecs_set_pipeline(this.nativeWorld, pipelineId);