Refactoring

Src/Myc.Core.Tasks.pas

@@ -4,55 +4,55 @@ interface
 
 uses
     System.SysUtils, System.Classes, System.SyncObjs,
-    Myc.Core.Atomic, Myc.Signals; // Myc.Signals now requires direct use of TMycLatch static members
+    Myc.Core.Atomic, Myc.TaskManager, Myc.Signals; // Myc.Signals now requires direct use of TMycLatch static members
 
 type
-    IMycTaskFactory = interface
-        {$region 'property access'}
-        // Retrieves the number of worker threads.
-        function GetThreadCount: Integer;
-        {$endregion}
-
-        // Creates and starts a new, independent thread executing Proc.
-        // Returns IMycState to await thread completion.
-        // Exceptions within Proc are caught; the first one is stored
-        // and can be re-raised in the main thread via WaitFor or Teardown.
-        function CreateThread(const Proc: TProc): IMycState;
-
-        // Returns True if called from the main application thread.
-        function InMainThread: Boolean;
-
-        // Returns True if called from one of the factory's worker threads.
-        function InWorkerThread: Boolean;
-
-        // Schedules Job for execution by a worker thread.
-        // If StartCount > 0, Job is deferred until Notify is called StartCount times on the returned IMycSubscriber.
-        // If StartCount <= 0, Job is enqueued immediately.
-        // Returns IMycSubscriber for deferred jobs, or TMycLatch.Null for immediate jobs or if Job is nil.
-        // Exceptions during Job execution are caught; the first one is stored
-        // and can be re-raised in the main thread via WaitFor or Teardown.
-        // Raises ETaskException if the factory is already terminated.
-        function Run(Job: TProc): IMycSubscriber;
-
-        procedure EnqueueJob(const Job: TProc);
-
-        // Shuts down the task factory: terminates worker threads and cleans up resources.
-        // Before shutdown, any first stored exception from a worker thread (from Run or CreateThread tasks managed by this factory)
-        // will be re-raised in the calling (main) thread.
-        procedure Teardown;
-
-        // Waits for the operation associated with State to complete.
-        // Must not be called from a worker thread of this factory.
-        // After waiting, or if the state is already set, any first stored exception
-        // from any worker thread of this factory will be re-raised in the calling (main) thread.
-        // Raises ETaskException if called from within a worker thread.
-        procedure WaitFor(State: IMycState);
-
-        // Gets the number of worker threads.
-        property ThreadCount: Integer read GetThreadCount;
-    end;
+    IMycTaskFactory = interface( IMycTaskManager )
+        {$region 'property access'}
+        // Retrieves the number of worker threads.
+        function GetThreadCount: Integer;
+        {$endregion}
 
-    TMycTaskFactory = class(TInterfacedObject, IMycTaskFactory)
+        // Creates and starts a new, independent thread executing Proc.
+        // Returns IMycState to await thread completion.
+        // Exceptions within Proc are caught; the first one is stored
+        // and can be re-raised in the main thread via WaitFor or Teardown.
+        function CreateThread(const Proc: TProc): IMycState;
+
+        // Returns True if called from the main application thread.
+        function InMainThread: Boolean;
+
+        // Returns True if called from one of the factory's worker threads.
+        function InWorkerThread: Boolean;
+
+        // Schedules Job for execution by a worker thread.
+        // If StartCount > 0, Job is deferred until Notify is called StartCount times on the returned IMycSubscriber.
+        // If StartCount <= 0, Job is enqueued immediately.
+        // Returns IMycSubscriber for deferred jobs, or TMycLatch.Null for immediate jobs or if Job is nil.
+        // Exceptions during Job execution are caught; the first one is stored
+        // and can be re-raised in the main thread via WaitFor or Teardown.
+        // Raises ETaskException if the factory is already terminated.
+        function Run(Job: TProc): IMycSubscriber;
+
+        procedure EnqueueJob(const Job: TProc);
+
+        // Shuts down the task factory: terminates worker threads and cleans up resources.
+        // Before shutdown, any first stored exception from a worker thread (from Run or CreateThread tasks managed by this factory)
+        // will be re-raised in the calling (main) thread.
+        procedure Teardown;
+
+        // Waits for the operation associated with State to complete.
+        // Must not be called from a worker thread of this factory.
+        // After waiting, or if the state is already set, any first stored exception
+        // from any worker thread of this factory will be re-raised in the calling (main) thread.
+        // Raises ETaskException if called from within a worker thread.
+        procedure WaitFor(State: IMycState);
+
+        // Gets the number of worker threads.
+        property ThreadCount: Integer read GetThreadCount;
+    end;
+
+    TMycTaskFactory = class(TInterfacedObject, IMycTaskManager, IMycTaskFactory)
     type
         ETaskException = class(Exception) end;
     private
@@ -67,6 +67,8 @@ type
         FWorkStack: TMycAtomicStack<TProc>; // Stack of pending jobs
         FWorkThreads: TArray<TThread>; // Array of worker threads
         procedure WorkerThread;
+    class var
+        FTaskManagerLock: Integer;
 
     protected
         procedure ExecuteJob;
@@ -81,10 +83,14 @@ type
         procedure HandleException;
         procedure EnqueueJob(const Job: TProc);
         function Run(Job: TProc): IMycSubscriber;
+        function CreateTask(const Gate: IMycState; const Proc: TProc): TMycSubscription;
         procedure WaitFor(State: IMycState);
         procedure Teardown;
         function InMainThread: Boolean;
         function InWorkerThread: Boolean;
+
+        class procedure AquireTaskManager;
+        class procedure ReleaseTaskManager;
     end;
 
 implementation
@@ -175,6 +181,20 @@ begin
         Result.NameThreadForDebugging(DbgName); // Set thread name for debugging
 end;
 
+function TMycTaskFactory.CreateTask(const Gate: IMycState; const Proc: TProc):
+    TMycSubscription;
+begin
+    if not Assigned(Gate) or Gate.IsSet then
+    begin
+        EnqueueJob( Proc );
+    end
+    else
+    begin
+        // The job will run when Gate notifies the subscriber returned by Run.
+        Result := Gate.Subscribe( Run( Proc ) );
+    end;
+end;
+
 function TMycTaskFactory.CreateThread(const Proc: TProc): IMycState;
 var
     res: IMycLatch;
@@ -261,6 +281,20 @@ begin
     exit(false); // Not found in worker thread list
 end;
 
+class procedure TMycTaskFactory.AquireTaskManager;
+begin
+    if not Assigned(TaskManager) then
+        TaskManager := TMycTaskFactory.Create;
+    inc( FTaskManagerLock );
+end;
+
+class procedure TMycTaskFactory.ReleaseTaskManager;
+begin
+    dec( FTaskManagerLock );
+    if FTaskManagerLock = 0 then
+        TaskManager := nil;
+end;
+
 function TMycTaskFactory.Run(Job: TProc): IMycSubscriber;
 begin
     if FTerminated <> 0 then
@@ -361,7 +395,6 @@ end;
 
 function TMycPendingJob.Notify: Boolean;
 var
-    newCount: Integer;
     P: TProc;
 begin
     PPointer(@P)^ := TInterlocked.Exchange( PPointer(@FJob)^, nil );