Changeset 166 for MicroThreading/UMicroThreading.pas

Timestamp:

Feb 9, 2011, 1:35:28 PM (14 years ago)

Author:

george

Message:

• Modified: Sync functions now not accept main thread context. Instead MainScheduler.AddMethod have to by used.

File:

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

MicroThreading/UMicroThreading.pas

@@ -32 +32 @@
   SManagerReferenceLost = 'Reference to manager lost';
   SCantDetermineThreadID = 'Can''t determine thread for id %d';
-  SNotInThread = 'Not in thread';
-  SReleaseNotAcquiredLock = 'Release not acquired lock';
+  SNotInMicroThread = 'Not in microthread';
+  SReleaseNotAcquiredLock = 'Release on not acquired lock';
+  SMethodNotAssigned = 'Method for microthread not assigned';
 
 
 type
+  EMicroThreadError = class(Exception);
+
   TMicroThread = class;
   TMicroThreadScheduler = class;
@@ -43 +46 @@
   TMicroThreadState = (tsNone, tsWaiting, tsRunning, tsBlocked, tsSuspended);
   TMicroThreadBlockState = (tbsNone, tbsSleeping, tbsWaitFor, tbsTerminating,
-    tbsTerminated);
+    tbsTerminated, tbsCriticalSection);
 
   { TMicroThreadCriticalSection }
 
   TMicroThreadCriticalSection = class
+  private
+    FMicroThreads: TObjectList;
     Lock: TCriticalSection;
-    Counter: Integer;
+    FCounter: Integer;
+  public
     procedure Acquire;
     procedure Release;
@@ -111 +117 @@
     procedure Yield;
     procedure MTSleep(Duration: TDateTime); // No conflicting name to global Sleep procedure
+    procedure WaitForCriticalSection(CriticalSection: TMicroThreadCriticalSection);
     function WaitForEvent(Event: TMicroThreadEvent; Duration: TDateTime): TWaitResult;
     procedure WaitFor;
@@ -141 +148 @@
 
   TMicroThreadSimple = class(TMicroThread)
-    Method: TMicroThreadMethod;
+    Method: TProcedureOfObject;
     procedure Execute; override;
   end;
@@ -228 +235 @@
     BurstCount: Integer;
     function Add(MicroThread: TMicroThread): Integer;
-    function AddMethod(Method: TMicroThreadMethod): Integer;
+    function AddMethod(Method: TProcedureOfObject; WaitForFinish: Boolean = False): Integer;
     procedure Remove(MicroThread: TMicroThread; Free: Boolean = True);
     constructor Create;
@@ -263 +270 @@
     'Running', 'Blocked', 'Suspended');
   MicroThreadBlockStateText: array[TMicroThreadBlockState] of string = ('None',
-    'Sleeping', 'WaitFor', 'Terminating', 'Terminated');
+    'Sleeping', 'WaitFor', 'Terminating', 'Terminated', 'CriticalSection');
   MicroThreadThreadStateText: array[TMicroThreadThreadState] of string = (
     'Ready', 'Running', 'Terminated');
@@ -294 +301 @@
 begin
   MT := GetCurrentMicroThread;
-  if Assigned(MT) then Result := MT.Id else Result := -1;
+  if Assigned(MT) then Result := MT.Id
+    else Result := -1;
 end;
 
@@ -322 +330 @@
   MT := GetCurrentMicroThread;
   if Assigned(MT) then MT.MTSleep(Duration)
-    else Sleep(Trunc(Duration / OneMillisecond));
+    else raise EMicroThreadError.Create(SNotInMicroThread);
 end;
 
@@ -332 +340 @@
     Thread := TThreadEx.CurrentThread;
     if Assigned(Thread) then TThread.Synchronize(Thread, Method)
-      else raise Exception.Create(Format(SCantDetermineThreadID, [GetCurrentThreadId]));
+      else raise EMicroThreadError.Create(Format(SCantDetermineThreadID, [GetCurrentThreadId]));
   end else Method;
 end;
@@ -342 +350 @@
   MT := GetCurrentMicroThread;
   if Assigned(MT) then Result := MT.WaitForEvent(Event, Duration)
-    else begin
-      while not Event.Signaled do begin
-        Sleep(1);
-        Application.ProcessMessages;
-      end;
-      //raise Exception.Create(SNotInThread);
-//    else Result := Event.WaitFor(Trunc(Duration / OneMillisecond));
-    end;
+    else raise EMicroThreadError.Create(SNotInMicroThread);
 end;
 
@@ -374 +375 @@
 
 procedure TMicroThreadCriticalSection.Acquire;
-begin
-  try
+var
+  MT: TMicroThread;
+  Event: TMicroThreadEvent;
+begin
+  MT := GetCurrentMicroThread;
+  if Assigned(MT) then MT.WaitForCriticalSection(Self)
+    else raise EMicroThreadError.Create(SNotInMicroThread);
+end;
+
+procedure TMicroThreadCriticalSection.Release;
+begin
+  try
+    MainScheduler.FMicroThreadsLock.Acquire;
     Lock.Acquire;
-    while Counter > 0 do begin
-      try
-        Lock.Release;
-        MTSleep(1 * OneMillisecond);
-      finally
-        Lock.Acquire;
-      end;
-    end;
-    Inc(Counter);
+    Dec(FCounter);
+    if FMicroThreads.Count > 0 then begin
+      // Release one waiting micro thread and lower counter
+      TMicroThread(FMicroThreads[0]).FState := tsWaiting;
+      FMicroThreads.Delete(0);
+    end;
   finally
     Lock.Release;
-  end;
-end;
-
-procedure TMicroThreadCriticalSection.Release;
-begin
-  try
+    MainScheduler.FMicroThreadsLock.Release;
+  end;
+end;
+
+constructor TMicroThreadCriticalSection.Create;
+begin
+  Lock := TCriticalSection.Create;
+  FMicroThreads := TObjectList.Create;
+  FMicroThreads.OwnsObjects := False;
+end;
+
+destructor TMicroThreadCriticalSection.Destroy;
+begin
+  try
+    MainScheduler.FMicroThreadsLock.Acquire;
     Lock.Acquire;
-    if Counter > 0 then Dec(Counter)
-      else raise Exception.Create(SReleaseNotAcquiredLock);
+
+    while FMicroThreads.Count > 0 do begin
+      // Release one waiting micro thread and lower counter
+      TMicroThread(FMicroThreads[0]).FState := tsWaiting;
+      FMicroThreads.Delete(0);
+    end;
   finally
     Lock.Release;
-  end;
-end;
-
-constructor TMicroThreadCriticalSection.Create;
-begin
-  Lock := TCriticalSection.Create;
-end;
-
-destructor TMicroThreadCriticalSection.Destroy;
-begin
-  Acquire;
+    MainScheduler.FMicroThreadsLock.Release;
+  end;
+  FMicroThreads.Free;
   Lock.Free;
   inherited Destroy;
@@ -456 +470 @@
   MT := GetCurrentMicroThread;
   if Assigned(MT) then Result := MT.WaitForEvent(Self, Duration)
-    else Result := wrSignaled;
+    else raise EMicroThreadError.Create(SNotInMicroThread);
 end;
 
@@ -689 +703 @@
 begin
   inherited Execute;
-  Method(Self);
+  if Assigned(Method) then Method
+    else raise EMicroThreadError.Create(SMethodNotAssigned);
 end;
 
@@ -700 +715 @@
   except
     on E: Exception do
-      if Assigned(ExceptionHandler) then ExceptionHandler(Self, E);
+      if Assigned(ExceptionHandler) then
+        if GetCurrentThreadId = MainThreadID then ExceptionHandler(Self, E)
+          else ExceptionHandler(TThreadEx.CurrentThread, E);
   end;
   asm
@@ -745 +762 @@
 procedure TMicroThread.Yield;
 begin
-  if not Assigned(FManager) then
-    raise Exception.Create(SManagerReferenceLost);
+//  if not Assigned(FManager) then
+//    raise EMicroThreadError.Create(SManagerReferenceLost);
   if FStatePending = tsNone then
     FStatePending := tsWaiting;
@@ -774 +791 @@
   FStatePending := tsBlocked;
   Yield;
+end;
+
+procedure TMicroThread.WaitForCriticalSection(
+  CriticalSection: TMicroThreadCriticalSection);
+begin
+  try
+    CriticalSection.Lock.Acquire;
+    Inc(CriticalSection.FCounter);
+    if CriticalSection.FCounter > 1 then begin
+      CriticalSection.FMicroThreads.Add(Self);
+      FBlockState := tbsCriticalSection;
+      FStatePending := tsBlocked;
+      try
+        CriticalSection.Lock.Release;
+        Yield;
+      finally
+        CriticalSection.Lock.Acquire;
+      end;
+    end;
+  finally
+    CriticalSection.Lock.Release;
+  end;
 end;
 
@@ -862 +901 @@
 function TMicroThreadScheduler.Add(MicroThread: TMicroThread): Integer;
 begin
-  Inc(FLastId);
-  MicroThread.FScheduler := Self;
-  MicroThread.FId := FLastId;
   try
     FMicroThreadsLock.Acquire;
+    Inc(FLastId);
+    MicroThread.FScheduler := Self;
+    MicroThread.FId := FLastId;
     Result := FMicroThreads.Add(MicroThread);
   finally
@@ -873 +912 @@
 end;
 
-function TMicroThreadScheduler.AddMethod(Method: TMicroThreadMethod): Integer;
+function TMicroThreadScheduler.AddMethod(Method: TProcedureOfObject; WaitForFinish: Boolean): Integer;
 var
   NewMicroThread: TMicroThreadSimple;
-begin
-  NewMicroThread := TMicroThreadSimple.Create(False);
-  NewMicroThread.Method := Method;
-  NewMicroThread.FScheduler := Self;
-  Result := Add(NewMicroThread);
+  CurrentMT: TMicroThread;
+begin
+  try
+    NewMicroThread := TMicroThreadSimple.Create(False);
+    NewMicroThread.Method := Method;
+    NewMicroThread.FScheduler := Self;
+    NewMicroThread.FreeOnTerminate := not WaitForFinish;
+    if WaitForFinish then begin
+      CurrentMT := GetCurrentMicroThread;
+      while not ((NewMicroThread.FState = tsBlocked) and
+      (NewMicroThread.FBlockState = tbsTerminated)) do begin
+        try
+          FMicroThreadsLock.Release;
+          if Assigned(CurrentMT) then CurrentMT.MTSleep(1 * OneMillisecond)
+          else begin
+            Sleep(1);
+            Application.ProcessMessages;
+          end;
+        finally
+          FMicroThreadsLock.Acquire;
+        end;
+      end;
+    end;
+  finally
+    if WaitForFinish then NewMicroThread.Free;
+  end;
 end;
 
@@ -1066 +1126 @@
     end;
     if I < FMicroThreads.Count then begin
-      if Assigned(Manager.FCurrentMicroThread) then
-        raise Exception.Create(SManagerMicroThreadRunning);
+//      if Assigned(Manager.FCurrentMicroThread) then
+//        raise EMicroThreadError.Create(SManagerMicroThreadRunning);
       Selected := TMicroThread(FMicroThreads[FRoundRobinIndex]);
       Selected.FState := tsRunning;
@@ -1080 +1140 @@
 procedure TMicroThreadScheduler.ReleaseMicroThread(MicroThread: TMicroThread);
 begin
-  if not Assigned(MicroThread) then
-    raise Exception.Create(SNilThreadReference);
+//  if not Assigned(MicroThread) then
+//    raise EMicroThreadError.Create(SNilThreadReference);
   try
     FMicroThreadsLock.Acquire;