Changeset 154 for MicroThreading/UMicroThreading.pas

Timestamp:

Jan 27, 2011, 2:15:57 PM (14 years ago)

Author:

george

Message:

• Add: Not completed event signaling support.

File:

• MicroThreading/UMicroThreading.pas (modified) (13 diffs)

MicroThreading/UMicroThreading.pas

@@ -30 +30 @@
   TMicroThreadState = (tsWaiting, tsRunning, tsBlocked, tsSuspended,
     tsSleeping);
+
+  { TMicroThreadEvent }
+
+  TMicroThreadEvent = class
+  private
+    FAutoReset: Boolean;
+    FSignaled: Boolean;
+    FMicroThreads: TObjectList;
+    FMicroThreadsLock: TCriticalSection;
+  public
+    procedure SetEvent;
+    procedure ResetEvent;
+    procedure WaitFor(Duration: TDateTime);
+    constructor Create;
+    destructor Destroy; override;
+    property Signaled: Boolean read FSignaled;
+    property AutoReset: Boolean read FAutoReset write FAutoReset;
+  end;
 
   { TMicroThread }
@@ -48 +66 @@
     FFinished: Boolean;
     FSuspended: Boolean;
+    FBlocked: Boolean;
     FState: TMicroThreadState;
     FScheduler: TMicroThreadScheduler;
     FManager: TMicroThreadManager;
     FId: Integer;
+    FBlockCondition: Boolean;
     procedure CallExecute;
     function GetStackUsed: Integer;
@@ -58 +78 @@
     Name: string;
     Priority: Integer;
-    Completion: Single; // Can be used for progress information in range <0, 1>
+    Completion: Single; // Can be used for progress information usually in range <0, 1>
     procedure Execute; virtual;
 
     procedure Yield;
-    procedure Sleep(Duration: TDateTime);
-    function WaitForSignal(Signal: TEvent): TWaitResult;
+    procedure MTSleep(Duration: TDateTime); // No conflicting name to global Sleep procedure
+    function WaitForEvent(Event: TMicroThreadEvent; Duration: TDateTime): TWaitResult;
     procedure WaitFor;
     procedure Terminate;
@@ -86 +106 @@
   end;
 
-  TMicroThreadEvent = procedure(MicroThread: TMicroThread) of object;
-
-  { TMicroThreadMethod }
-
-  TMicroThreadMethod = class(TMicroThread)
-    Method: TMicroThreadEvent;
+  TMicroThreadMethod = procedure(MicroThread: TMicroThread) of object;
+
+  { TMicroThreadSimple }
+
+  TMicroThreadSimple = class(TMicroThread)
+    Method: TMicroThreadMethod;
     procedure Execute; override;
   end;
@@ -166 +186 @@
   public
     function Add(MicroThread: TMicroThread): Integer;
-    function AddMethod(Method: TMicroThreadEvent): Integer;
+    function AddMethod(Method: TMicroThreadMethod): Integer;
+    procedure Remove(MicroThread: TMicroThread);
     constructor Create;
     destructor Destroy; override;
@@ -187 +208 @@
   MicroThreadStateText: array[TMicroThreadState] of string = ('Waiting',
     'Running', 'Blocked', 'Suspended', 'Sleeping');
+
+function GetCurrentMicroThread: TMicroThread;
+procedure MTSleep(Duration: TDateTime);
+function MTWaitForEvent(Event: TMicroThreadEvent; Duration: TDateTime): TWaitResult;
 
 implementation
@@ -218 +243 @@
     end;
   end;
+end;
+
+function GetCurrentMicroThread: TMicroThread;
+var
+  I: Integer;
+begin
+  with MainScheduler do
+  try
+    FThreadPoolLock.Acquire;
+    if MainThreadID = ThreadID then Result := MainThreadManager.CurrentMicroThread
+    else begin
+      I := 0;
+      while (I < FThreadPool.Count) and (TMicroThreadThread(FThreadPool[I]).ThreadID <> ThreadID) do Inc(I);
+      if I < FThreadPool.Count then Result := TMicroThreadThread(FThreadPool[I]).Manager.CurrentMicroThread
+        else Result := nil;
+    end;
+  finally
+    FThreadPoolLock.Release;
+  end;
+end;
+
+procedure MTSleep(Duration: TDateTime);
+var
+  MT: TMicroThread;
+begin
+  MT := GetCurrentMicroThread;
+  if Assigned(MT) then MT.MTSleep(Duration)
+    else Sleep(Trunc(Duration / OneMillisecond));
+end;
+
+function MTWaitForEvent(Event: TMicroThreadEvent; Duration: TDateTime): TWaitResult;
+var
+  MT: TMicroThread;
+begin
+  MT := GetCurrentMicroThread;
+  if Assigned(MT) then Result := MT.WaitForEvent(Event, Duration);
+//    else Result := Event.WaitFor(Trunc(Duration / OneMillisecond));
+end;
+
+{ TMicroThreadMethod }
+
+procedure TMicroThreadEvent.SetEvent;
+var
+  I: Integer;
+begin
+  for I := 0 to FMicroThreads.Count - 1 do
+    TMicroThread(FMicroThreads[I]).FBlockCondition := True;
+  if not FAutoReset then FSignaled := True;
+end;
+
+procedure TMicroThreadEvent.ResetEvent;
+begin
+  FSignaled := False;
+end;
+
+procedure TMicroThreadEvent.WaitFor(Duration: TDateTime);
+var
+  MT: TMicroThread;
+begin
+  MT := GetCurrentMicroThread;
+  if Assigned(MT) then MT.WaitForEvent(Self, Duration);
+end;
+
+constructor TMicroThreadEvent.Create;
+begin
+  FMicroThreads := TObjectList.Create;
+  FMicroThreads.OwnsObjects := False;
+  FMicroThreadsLock := TCriticalSection.Create;
+end;
+
+destructor TMicroThreadEvent.Destroy;
+begin
+  FMicroThreadsLock.Free;
+  FMicroThreads.Free;
+  inherited Destroy;
 end;
 
@@ -390 +490 @@
 end;
 
-{ TMicroThreadMethod }
-
-procedure TMicroThreadMethod.Execute;
+{ TMicroThreadSimple }
+
+procedure TMicroThreadSimple.Execute;
 begin
   inherited Execute;
@@ -433 +533 @@
   if GetMicroThreadId <> -1 then
   while not FFinished do begin
-    Sleep(1);
-  end;
-end;
-
-procedure TMicroThread.Sleep(Duration: TDateTime);
+    MTSleep(1);
+  end;
+end;
+
+procedure TMicroThread.MTSleep(Duration: TDateTime);
 begin
   FWakeUpTime := NowPrecise + Duration;
@@ -444 +544 @@
 end;
 
-function TMicroThread.WaitForSignal(Signal: TEvent): TWaitResult;
-begin
+function TMicroThread.WaitForEvent(Event: TMicroThreadEvent; Duration: TDateTime): TWaitResult;
+begin
+  try
+    Event.FMicroThreadsLock.Acquire;
+    Event.FMicroThreads.Add(Self);
+  finally
+    Event.FMicroThreadsLock.Release;
+  end;
+  FBlocked := True;
+  Yield;
   repeat
-    Result := Signal.WaitFor(1);
-    Sleep(1);
+    if FState = tsBlocked then MTSleep(1);
   until Result <> wrTimeout;
+  try
+    Event.FMicroThreadsLock.Acquire;
+    Event.FMicroThreads.Remove(Self);
+  finally
+    Event.FMicroThreadsLock.Release;
+  end;
 end;
 
@@ -520 +633 @@
 end;
 
-function TMicroThreadScheduler.AddMethod(Method: TMicroThreadEvent): Integer;
-var
-  NewMicroThread: TMicroThreadMethod;
-begin
-  NewMicroThread := TMicroThreadMethod.Create(False);
+function TMicroThreadScheduler.AddMethod(Method: TMicroThreadMethod): Integer;
+var
+  NewMicroThread: TMicroThreadSimple;
+begin
+  NewMicroThread := TMicroThreadSimple.Create(False);
   NewMicroThread.Method := Method;
   NewMicroThread.FScheduler := Self;
   Result := Add(NewMicroThread);
+end;
+
+procedure TMicroThreadScheduler.Remove(MicroThread: TMicroThread);
+begin
+  try
+    FMicroThreadsLock.Acquire;
+    FMicroThreads.Remove(MicroThread);
+  finally
+    FMicroThreadsLock.Release;
+  end;
 end;
 
@@ -664 +787 @@
       if (TMicroThread(FMicroThreads[FRoundRobinIndex]).FState = tsSleeping) and
         (TMicroThread(FMicroThreads[FRoundRobinIndex]).FWakeupTime < CurrentTime) then
-          TMicroThread(FMicroThreads[FRoundRobinIndex]).FState := tsWaiting else
-      begin
+          TMicroThread(FMicroThreads[FRoundRobinIndex]).FState := tsWaiting
+      else
+      if (TMicroThread(FMicroThreads[FRoundRobinIndex]).FState = tsBlocked) and
+        (TMicroThread(FMicroThreads[FRoundRobinIndex]).FBlockCondition) then
+          TMicroThread(FMicroThreads[FRoundRobinIndex]).FState := tsWaiting
+      else begin
         // Go to next thread
         Inc(I);
@@ -748 +875 @@
 initialization
 
-//StaticManagers := TObjectList.Create;
-//MainScheduler := TMicroThreadScheduler.Create;
+MainScheduler := TMicroThreadScheduler.Create;
 
 finalization
 
-//MainScheduler.Free;
-//StaticManagers.Free;
+MainScheduler.Free;
 
 end.