Changeset 156 for MicroThreading/UMicroThreading.pas

Timestamp:

Jan 28, 2011, 2:12:42 PM (14 years ago)

Author:

george

Message:

• Modified: Restructuralized code for support for pending state changes.

File:

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

MicroThreading/UMicroThreading.pas

@@ -28 +28 @@
   TMicroThreadManager = class;
 
-  TMicroThreadState = (tsWaiting, tsRunning, tsBlocked, tsSuspended);
+  TMicroThreadState = (tsNone, tsWaiting, tsRunning, tsBlocked, tsSuspended);
   TMicroThreadBlockState = (tbsNone, tbsSleeping, tbsWaitFor, tbsTerminating,
     tbsTerminated);
@@ -58 +58 @@
     FExecutionEndTime: TDateTime;
     FExecutionTime: TDateTime;
+    FExecutionCount: Integer;
     FStack: Pointer;
     FStackPointer: Pointer;
@@ -73 +74 @@
     function GetStackUsed: Integer;
     function GetTerminated: Boolean;
+    procedure SetManager(const AValue: TMicroThreadManager);
     procedure SetScheduler(const AValue: TMicroThreadScheduler);
+    procedure CheckStack;
   public
     Name: string;
@@ -97 +100 @@
     property BlockState: TMicroThreadBlockState read FBlockState;
     property ExecutionTime: TDateTime read FExecutionTime;
+    property ExecutionCount: Integer read FExecutionCount;
     property FreeOnTerminate: Boolean read FFreeOnTerminate
       write FFreeOnTerminate;
@@ -102 +106 @@
     property Scheduler: TMicroThreadScheduler read FScheduler
       write SetScheduler;
-    property Manager: TMicroThreadManager read FManager;
+    property Manager: TMicroThreadManager read FManager write SetManager;
     property StackUsed: Integer read GetStackUsed;
   end;
@@ -140 +144 @@
     FScheduler: TMicroThreadScheduler;
     FThread: TMicroThreadThread;
+    FId: Integer;
+    procedure SetCurrentMicroThread(const AValue: TMicroThread);
     function Execute(Count: Integer): Integer;
+    property CurrentMicroThread: TMicroThread read FCurrentMicroThread
+      write SetCurrentMicroThread;
   public
-    Id: Integer;
     procedure Yield;
     procedure Synchronize(AMethod: TThreadMethod);
@@ -148 +155 @@
     destructor Destroy; override;
     property Scheduler: TMicroThreadScheduler read FScheduler;
-    property CurrentMicroThread: TMicroThread read FCurrentMicroThread;
   end;
 
@@ -176 +182 @@
     procedure SetActive(const AValue: Boolean);
     procedure SetThreadPoolSize(const AValue: Integer);
-    function GetNextMicroThread: TMicroThread;
+    procedure GetNextMicroThread(Manager: TMicroThreadManager);
     procedure ReleaseMicroThread(MicroThread: TMicroThread);
     procedure SetUseMainThread(const AValue: Boolean);
@@ -206 +212 @@
 
 const
-  MicroThreadStateText: array[TMicroThreadState] of string = ('Waiting',
+  MicroThreadStateText: array[TMicroThreadState] of string = ('None', 'Waiting',
     'Running', 'Blocked', 'Suspended');
   MicroThreadBlockStateText: array[TMicroThreadBlockState] of string = ('None',
@@ -214 +220 @@
 procedure MTSleep(Duration: TDateTime);
 function MTWaitForEvent(Event: TMicroThreadEvent; Duration: TDateTime): TWaitResult;
+procedure Log(Text: string);
+
+const
+  LogFileName: string = 'Log.txt';
 
 implementation
@@ -284 +294 @@
 end;
 
+var
+  LogLock: TCriticalSection;
+
+procedure Log(Text: string);
+var
+  LogFile: TextFile;
+begin
+  try
+    LogLock.Acquire;
+    AssignFile(LogFile, LogFileName);
+    if FileExists(LogFileName) then Append(LogFile)
+      else Rewrite(LogFile);
+    WriteLn(LogFile, Text);
+    CloseFile(LogFile);
+  finally
+    LogLock.Release;
+  end;
+end;
+
 { TMicroThreadMethod }
 
@@ -323 +352 @@
 
 { TMicroThreadManager }
+
+procedure TMicroThreadManager.SetCurrentMicroThread(const AValue: TMicroThread
+  );
+begin
+  if FCurrentMicroThread = AValue then Exit;
+  if Assigned(FCurrentMicroThread) then
+    FCurrentMicroThread.FManager := nil;
+  FCurrentMicroThread := AValue;
+  if Assigned(FCurrentMicroThread) then
+    FCurrentMicroThread.FManager := Self;
+end;
 
 function TMicroThreadManager.Execute(Count: Integer): Integer;
@@ -345 +385 @@
       mov eax, [ecx].TMicroThreadManager.FCurrentMicroThread
       mov edx, esp
+      mov ebx, ebp
       mov [eax].TMicroThread.FStackPointer, edx
-      mov edx, ebp
-      mov [eax].TMicroThread.FBasePointer, edx
-
-      // Restore FScheduler stack
+      mov [eax].TMicroThread.FBasePointer, ebx
+
+      // Restore manager stack
       mov edx, [ecx].TMicroThreadManager.FStackPointer
+      mov ebx, [ecx].TMicroThreadManager.FBasePointer
       mov esp, edx
-      mov edx, [ecx].TMicroThreadManager.FBasePointer
-      mov ebp, edx
+      mov ebp, ebx
     end;
-    FCurrentMicroThread.FManager := nil;
+    FCurrentMicroThread.CheckStack;
+    if FCurrentMicroThread = nil then
+      raise Exception.Create('x');
     FScheduler.ReleaseMicroThread(FCurrentMicroThread);
-    FCurrentMicroThread := nil;
   end;
 
   if FExecutedCount < FExecuteCount then begin
-    FCurrentMicroThread := FScheduler.GetNextMicroThread;
-
+    FScheduler.GetNextMicroThread(Self);
     if Assigned(FCurrentMicroThread) then begin
       Inc(FExecutedCount);
       FCurrentMicroThread.FExecutionStartTime := NowPrecise;
-      FCurrentMicroThread.FManager := Self;
       asm
-        // Store FScheduler stack
+        // Store manager stack
         mov eax, Self
         mov edx, esp
+        mov ebx, ebp
         mov [eax].TMicroThreadManager.FStackPointer, edx
-        mov edx, ebp
-        mov [eax].TMicroThreadManager.FBasePointer, edx
+        mov [eax].TMicroThreadManager.FBasePointer, ebx
       end;
       if not FCurrentMicroThread.FExecuted then begin
+        // First time micro thread execution
         FCurrentMicroThread.FExecuted := True;
         asm
@@ -382 +422 @@
           mov eax, [ecx].TMicroThreadManager.FCurrentMicroThread
           mov edx, [eax].TMicroThread.FStackPointer
+          mov ebx, [eax].TMicroThread.FBasePointer
           mov esp, edx
-          mov edx, [eax].TMicroThread.FBasePointer
-          mov ebp, edx
+          mov ebp, ebx
           // We want to call virtual method Execute
           // but virtual methods can be called only statically
@@ -390 +430 @@
           call TMicroThread.CallExecute
 
-          // Restore FScheduler stack
+          // Restore manager stack
           // ecx register is set by CallExecute to running micro thread
           mov eax, [ecx].TMicroThread.FManager
           mov edx, [eax].TMicroThreadManager.FStackPointer
+          mov ebx, [eax].TMicroThreadManager.FBasePointer
           mov esp, edx
-          mov edx, [eax].TMicroThreadManager.FBasePointer
-          mov ebp, edx
+          mov ebp, ebx
         end;
-
+        FCurrentMicroThread.CheckStack;
         FCurrentMicroThread.FExecutionEndTime := NowPrecise;
         FCurrentMicroThread.FExecutionTime := FCurrentMicroThread.FExecutionTime +
          (FCurrentMicroThread.FExecutionEndTime - FCurrentMicroThread.FExecutionStartTime);
-        FCurrentMicroThread.FState := tsBlocked;
+        FCurrentMicroThread.FStatePending := tsBlocked;
         FCurrentMicroThread.FBlockState := tbsTerminated;
         if FCurrentMicroThread.FFreeOnTerminate then begin
@@ -414 +454 @@
           end;
         end else begin
-          FCurrentMicroThread.FManager := nil;
           FScheduler.ReleaseMicroThread(FCurrentMicroThread);
         end;
         //FCurrentMicroThread.FManager := nil;
         //FScheduler.ReleaseMicroThread(FCurrentMicroThread);
-        FCurrentMicroThread := nil;
+        //FCurrentMicroThread := nil;
       end else
-      //if FCurrentMicroThread.State = tsWaiting then
       begin
-        // Execute selected thread
+        // Regular selected microthread execution
+        FCurrentMicroThread.CheckStack;
         asm
           // Restore microthread stack
@@ -429 +468 @@
           mov eax, [ecx].TMicroThreadManager.FCurrentMicroThread
           mov edx, [eax].TMicroThread.FStackPointer
+          mov ebx, [eax].TMicroThread.FBasePointer
           mov esp, edx
-          mov edx, [eax].TMicroThread.FBasePointer
-          mov ebp, edx
+          mov ebp, ebx
         end;
       end;
@@ -464 +503 @@
   try
     repeat
-      ExecutedCount := Manager.Execute(10);
+      ExecutedCount := Manager.Execute(100000);
       if ExecutedCount = 0 then Sleep(1);
     until Terminated;
   except
-    on E: Exception do
+    on E: Exception do ;
       //ExceptionHandler(E);
   end;
@@ -485 +524 @@
   Terminate;
   repeat
-    Application.ProcessMessages;
     Sleep(1);
   until ExecuteTerminated;
@@ -522 +560 @@
 end;
 
+procedure TMicroThread.SetManager(const AValue: TMicroThreadManager);
+begin
+  if FManager = AValue then Exit;
+  if Assigned(FManager) then FManager.CurrentMicroThread := nil;
+  FManager := AValue;
+  if Assigned(FManager) then FManager.CurrentMicroThread := Self;
+end;
+
 procedure TMicroThread.SetScheduler(const AValue: TMicroThreadScheduler);
 begin
@@ -527 +573 @@
 end;
 
+procedure TMicroThread.CheckStack;
+begin
+  if not ((FStackPointer > FStack) and (FStackPointer < (FStack + FStackSize)))
+    then raise EStackOverflow.Create(Format('Microthread %d stack error', [FId]));
+end;
+
 procedure TMicroThread.Execute;
 begin
@@ -534 +586 @@
 procedure TMicroThread.Yield;
 begin
+  if not Assigned(FManager) then
+    raise Exception.Create('Manager reference lost');
+  FStatePending := tsWaiting;
   FManager.Yield;
 end;
@@ -582 +637 @@
   FExecutionTime := 0;
   FState := tsWaiting;
-  FStatePending := tsWaiting;
+  FStatePending := tsNone;
   if CreateSuspended then begin
     FState := tsSuspended;
-    FStatePending := tsSuspended;
   end;
   FFreeOnTerminate := True;
@@ -717 +771 @@
     Application.ProcessMessages;
     Sleep(1);
-  until FMainThreadTerminated and (ThreadPoolSize = 0);
+  until FMainThreadTerminated and (ThreadPoolCount = 0);
   FState := ssStopped;
 end;
@@ -730 +784 @@
     FThreadPool.OwnsObjects := False;
     ThreadIndex := FThreadPool.IndexOf(Sender);
-    if ThreadIndex <> -1 then FThreadPool.Delete(ThreadIndex);
+    if ThreadIndex = -1 then
+      raise Exception.Create('Trying to free thread not found in thread pool');
+    FThreadPool.Delete(ThreadIndex);
+  finally
     FThreadPool.OwnsObjects := True;
-  finally
     FThreadPoolLock.Release;
   end;
@@ -748 +804 @@
         NewThread := TMicroThreadThread.Create(True);
         NewThread.Manager.FScheduler := Self;
-        NewThread.Manager.Id := FThreadPool.Count + 1;
+        NewThread.Manager.FId := FThreadPool.Count + 1;
         NewThread.Manager.FThread := NewThread;
         NewThread.OnTerminate := PoolThreadTerminated;
+        NewThread.FreeOnTerminate := True;
         ThreadPool.Add(NewThread);
         NewThread.Resume;
@@ -778 +835 @@
 end;
 
-function TMicroThreadScheduler.GetNextMicroThread: TMicroThread;
+procedure TMicroThreadScheduler.GetNextMicroThread(Manager: TMicroThreadManager);
 var
   I: Integer;
   CurrentTime: TDateTime;
-begin
-  CurrentTime := NowPrecise;
-  Result := nil;
+  Selected: TMicroThread;
+begin
   try
     FMicroThreadsLock.Acquire;
+    CurrentTime := NowPrecise;
     I := 0;
+    Selected := nil;
     Inc(FRoundRobinIndex);
     if FRoundRobinIndex >= FMicroThreads.Count then
@@ -793 +851 @@
     while (I < FMicroThreads.Count) do
     with TMicroThread(FMicroThreads[FRoundRobinIndex]) do begin
-      FState := FStatePending;
       if (FState = tsWaiting) then Break
       else
@@ -815 +872 @@
       // Go to next thread
       Inc(I);
-      Inc(FRoundRobinIndex);
-      if FRoundRobinIndex >= FMicroThreads.Count then
-        FRoundRobinIndex := 0;
+      FRoundRobinIndex := (FRoundRobinIndex + 1) mod FMicroThreads.Count;
     end;
     if I < FMicroThreads.Count then begin
-      Result := TMicroThread(FMicroThreads[FRoundRobinIndex]);
-      Result.FState := tsRunning;
-      Result.FStatePending := tsWaiting;
+      if Assigned(Manager.FCurrentMicroThread) then
+        raise Exception.Create('Manager have already have running microthread');
+      Selected := TMicroThread(FMicroThreads[FRoundRobinIndex]);
+      Selected.FState := tsRunning;
+      Inc(Selected.FExecutionCount);
     end;
+    Manager.CurrentMicroThread := Selected;
   finally
     FMicroThreadsLock.Release;
@@ -831 +889 @@
 procedure TMicroThreadScheduler.ReleaseMicroThread(MicroThread: TMicroThread);
 begin
+  if not Assigned(MicroThread) then
+    raise Exception.Create('Can''t realease nil thread.');
   try
     FMicroThreadsLock.Acquire;
-    MicroThread.FState := MicroThread.FStatePending;
+    if MicroThread.FStatePending <> tsNone then begin
+      MicroThread.FState := MicroThread.FStatePending;
+      MicroThread.FStatePending := tsNone;
+    end;
+    MicroThread.Manager := nil;
   finally
     FMicroThreadsLock.Release;
@@ -893 +957 @@
 initialization
 
+DeleteFile(LogFileName);
+LogLock := TCriticalSection.Create;
 MainScheduler := TMicroThreadScheduler.Create;
 
@@ -898 +964 @@
 
 MainScheduler.Free;
+LogLock.Free;
 
 end.