WorkerThreadPool

public static WorkerThreadPoolInstance Singleton { get; }

Borrowed wrapper of the engine shared pool; repeated access uses a cached wrapper. Do not Dispose/Free the Singleton or try to shut down the pool from a game job. Use static methods and collect only the task/group IDs you own.

public static long AddGroupTask(Callable action, int elements, int tasksNeeded = -1, bool highPriority = false, string description = "");

Distributes elements Callable invocations, each with an index from 0 to elements−1. tasksNeeded controls worker-task count rather than element count or guaranteed concurrently active CPU cores; −1 selects from the pool. Do not pass 0 with elements>0: current code creates no workers and can leave the group unfinished; source-reviewed without executing a hang. elements=0 creates a completed empty group that still requires collection. Negative elements is invalid. Write results into preallocated independent slots; do not resize input/output while running. Index order is not promised. Confirm completion by status and call WaitForGroupTaskCompletion once.

public static long AddTask(Callable action, bool highPriority = false, string description = "");

Queues one no-argument Callable in the shared pool. Returns a task ID rather than the callback result; the pool exposes no callback return value. Publish your result through coordinated owned storage. Retain the Callable target and input through completion. After observing IsTaskCompleted, call WaitForTaskCompletion exactly once. Receiving an ID proves neither successful work nor a valid Callable; validate input yourself. highPriority guarantees no order/speedup. Implement application-level cancellation and error handling.

public static long GetCallerGroupId();

Returns the group ID for the current group worker. Returns −1 on the main thread, outside the pool, or in an ordinary AddTask task. Not an element index: that index is supplied as a callback argument. All elements of a group report the same group ID.

public static long GetCallerTaskId();

Returns the current ordinary pool task ID. Outside pool context it is −1. Group workers have no assigned public individual task ID and also return −1; use GetCallerGroupId for a group. Not an OS thread ID or main-thread ID. Do not collect a task from itself.

public static uint GetGroupProcessedElementCount(long groupId);

Counts group element invocations that have returned, not assigned workers or started calls. Increments after the callback returns. Even count==elements does not replace IsGroupTaskCompleted and required WaitForGroupTaskCompletion. Query only before collection; an invalid/already collected ID emits diagnostics and returns 0, which does not prove an empty group.

public static bool IsGroupTaskCompleted(long groupId);

Checks group completion without collecting it. True does not free the registry entry: one WaitForGroupTaskCompletion is still required. Poll across frames rather than busy-waiting the main thread. Stop using the ID after collection. False for an invalid ID comes with diagnostics and does not mean a running group.

public static bool IsTaskCompleted(long taskId);

Checks whether an ordinary task callback returned. Extracts no user result and does not free the task. After true call WaitForTaskCompletion and check the Error. Stop using the ID after successful collection. Do not pass a group ID; invalid IDs yield false with native diagnostics.

public static void WaitForGroupTaskCompletion(long groupId);

Waits for the group and collects its registry entry. Blocks the caller while work is unfinished; the main thread cannot process ordinary frames during that wait. Assign one collection owner, call once and discard the ID. Do not wait on a group from its own callback or while holding locks it needs: deadlock is possible. Returns no per-element results/errors; the application stores them. Provides no timeout/cancellation; invalid IDs are diagnosed.

public static Error WaitForTaskCompletion(long taskId);

Waits for and collects an ordinary task, returning a wait Error rather than the callback result. After Ok stop using the ID. An unfinished task must not wait for itself; a pool worker attempting to await an unfinished task with an ID no newer than its own can receive Busy. Busy is not successful collection. Invalid IDs return InvalidParameter. Internal prevention of some deadlocks does not make arbitrary dependency cycles safe; hold no locks needed by workers and do not await main-thread actions from a blocked main thread. Invalid nested waits were source-reviewed only.