Changeset 147 for MicroThreading/UMicroThreading.pas

Timestamp:

Jan 26, 2011, 8:06:25 AM (14 years ago)

Author:

george

Message:

• Added: Now multiple thread managers are running within single scheduler.

File:

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

MicroThreading/UMicroThreading.pas

@@ -34 +34 @@
     FStackSize: Integer;
     FBasePointer: Pointer;
-    FWakeupTime: TDateTime;
+    FWakeUpTime: TDateTime;
     FTerminated: Boolean;
     FExecuted: Boolean; // At first go through Execute method, then switch context
     FFinished: Boolean;
+    FSuspended: Boolean;
+    FState: TMicroThreadState;
+    FScheduler: TMicroThreadScheduler;
+    FManager: TMicroThreadManager;
+    FId: Integer;
   public
-    Id: Integer;
     Name: string;
     Priority: Integer;
-    State: TMicroThreadState;
-    Manager: TMicroThreadManager;
-    Scheduler: TMicroThreadScheduler;
     Completion: Single; // Can be used for progress information in range <0, 1>
     procedure Execute; virtual;
 
-    // Internal execution
     procedure Yield;
     procedure Sleep(Duration: TDateTime);
     function WaitForSignal(Signal: TEvent): TWaitResult;
-
-    // External execution
     procedure WaitFor;
     procedure Terminate;
     procedure Start;
-    procedure Stop;
+    procedure Resume;
+    procedure Suspend;
 
     constructor Create(CreateSuspended: Boolean;
       const StackSize: SizeUInt = DefaultStackSize);
     destructor Destroy; override;
+    property Id: Integer read FId;
+    property State: TMicroThreadState read FState;
     property ExecutionTime: TDateTime read FExecutionTime;
     property FreeOnTerminate: Boolean read FFreeOnTerminate
       write FFreeOnTerminate;
     property Terminated: Boolean read FTerminated;
+    property Scheduler: TMicroThreadScheduler read FScheduler;
+    property Manager: TMicroThreadManager read FManager;
   end;
 
@@ -80 +83 @@
 
   TMicroThreadSchedulerPoolThread = class(TThread)
-    Scheduler: TMicroThreadScheduler;
     Manager: TMicroThreadManager;
     procedure Execute; override;
+    constructor Create(CreateSuspended: Boolean;
+      const StackSize: SizeUInt = DefaultStackSize);
+    destructor Destroy; override;
   end;
 
   TThreadPool = class(TObjectList)
-
   end;
 
@@ -116 +120 @@
     ThreadPool: TThreadPool;
     RoundRobinIndex: Integer;
-    LastId: Integer;
+    FLastId: Integer;
     FFrequency: Int64;
-    FThreadPoolSize: Integer;
     FTerminated: Boolean;
     function GetMicroThreadCount: Integer;
@@ -171 +174 @@
         TMicroThread(MicroThreads[I]).FStackSize))) do Inc(I);
       if I < MicroThreads.Count then begin
-        Result := TMicroThread(MicroThreads[I]).Id;
+        Result := TMicroThread(MicroThreads[I]).FId;
       end else Result := -1;
     finally
@@ -194 +197 @@
 var
   I: Integer;
-  Time: TDateTime;
-begin
-  Time := Scheduler.GetNow;
+  CurrentTime: TDateTime;
+begin
+  CurrentTime := Scheduler.GetNow;
   if Assigned(CurrentMicroThread) then begin
-    CurrentMicroThread.FExecutionEndTime := Time;
+    CurrentMicroThread.FExecutionEndTime := CurrentTime;
     CurrentMicroThread.FExecutionTime := CurrentMicroThread.FExecutionTime +
       (CurrentMicroThread.FExecutionEndTime - CurrentMicroThread.FExecutionStartTime);
-    if CurrentMicroThread.State = tsRunning then
-      CurrentMicroThread.State := tsWaiting;
+    if CurrentMicroThread.FState = tsRunning then
+      CurrentMicroThread.FState := tsWaiting;
     StaticMicroThread := CurrentMicroThread;
     asm
@@ -212 +215 @@
       mov [eax].TMicroThread.FBasePointer, edx
     end;
-    StaticManager := CurrentMicroThread.Manager;
+    StaticManager := CurrentMicroThread.FManager;
     asm
       // Restore scheduler stack
@@ -221 +224 @@
       mov ebp, edx
     end;
-    CurrentMicroThread.Manager := nil;
+    CurrentMicroThread.FManager := nil;
     CurrentMicroThread := nil;
   end;
@@ -228 +231 @@
 
   if Assigned(CurrentMicroThread) and (FExecutedCount < FExecuteCount) then begin
-    CurrentMicroThread.Manager := Self;
+    CurrentMicroThread.FManager := Self;
     Inc(FExecutedCount);
     asm
@@ -240 +243 @@
     if not CurrentMicroThread.FExecuted then begin
       CurrentMicroThread.FExecuted := True;
-      CurrentMicroThread.State := tsRunning;
-      CurrentMicroThread.FExecutionStartTime := Time;
+      CurrentMicroThread.FState := tsRunning;
+      CurrentMicroThread.FExecutionStartTime := CurrentTime;
       StaticMicroThread := CurrentMicroThread;
       asm
@@ -257 +260 @@
       end;
       //FSelected.Method(FSelected);
-      StaticManager := CurrentMicroThread.Manager;
+      StaticManager := CurrentMicroThread.FManager;
       asm
         // Restore scheduler stack
@@ -266 +269 @@
         mov ebp, edx
       end;
-      CurrentMicroThread.Manager := nil;
-      CurrentMicroThread.FExecutionEndTime := Time;
+      CurrentMicroThread.FManager := nil;
+      CurrentMicroThread.FExecutionEndTime := CurrentTime;
       CurrentMicroThread.FExecutionTime := CurrentMicroThread.FExecutionTime +
        (CurrentMicroThread.FExecutionEndTime - CurrentMicroThread.FExecutionStartTime);
@@ -285 +288 @@
     if CurrentMicroThread.State = tsWaiting then begin
       // Execute selected thread
-      CurrentMicroThread.State := tsRunning;
-      CurrentMicroThread.FExecutionStartTime := Time;
+      CurrentMicroThread.FState := tsRunning;
+      CurrentMicroThread.FExecutionStartTime := CurrentTime;
       FTempPointer := CurrentMicroThread.FStackPointer;
       asm
@@ -334 +337 @@
 end;
 
+constructor TMicroThreadSchedulerPoolThread.Create(CreateSuspended: Boolean;
+  const StackSize: SizeUInt);
+begin
+  inherited;
+  Manager := TMicroThreadManager.Create;
+end;
+
+destructor TMicroThreadSchedulerPoolThread.Destroy;
+begin
+  Manager.Free;
+  inherited Destroy;
+end;
+
 { TMicroThreadMethod }
 
@@ -352 +368 @@
 procedure TMicroThread.Yield;
 begin
-  Manager.Yield;
+  FManager.Yield;
 end;
 
@@ -365 +381 @@
 procedure TMicroThread.Sleep(Duration: TDateTime);
 begin
-  FWakeUpTime := Scheduler.GetNow + Duration;
-  State := tsSleeping;
+  FWakeUpTime := FScheduler.GetNow + Duration;
+  FState := tsSleeping;
   Yield;
 end;
@@ -387 +403 @@
   FExecutionTime := 0;
   FTerminated := False;
-  if CreateSuspended then
-    State := tsSuspended;
+  if CreateSuspended then begin
+    FState := tsSuspended;
+    FSuspended := True;
+  end else FSuspended := False;
   FFreeOnTerminate := True;
 end;
@@ -395 +413 @@
 begin
   FTerminated := True;
+end;
+
+procedure TMicroThread.Start;
+begin
+  FState := tsWaiting;
 end;
 
@@ -405 +428 @@
 end;
 
-procedure TMicroThread.Start;
-begin
-  State := tsWaiting;
-end;
-
-procedure TMicroThread.Stop;
-begin
-  State := tsSuspended;
+procedure TMicroThread.Resume;
+begin
+  FSuspended := False;
+  if FState = tsSuspended then
+    FState := tsWaiting;
+end;
+
+procedure TMicroThread.Suspend;
+begin
+  FSuspended := True;
+  //Yield;
 end;
 
@@ -440 +466 @@
 function TMicroThreadScheduler.Add(MicroThread: TMicroThread): Integer;
 begin
-  Inc(LastId);
-  MicroThread.Scheduler := Self;
-  MicroThread.Id := LastId;
+  Inc(FLastId);
+  MicroThread.FScheduler := Self;
+  MicroThread.FId := FLastId;
   Result := MicroThreads.Add(MicroThread);
 end;
@@ -452 +478 @@
   NewMicroThread := TMicroThreadMethod.Create(False);
   NewMicroThread.Method := Method;
-  NewMicroThread.Scheduler := Self;
+  NewMicroThread.FScheduler := Self;
   Result := Add(NewMicroThread);
 end;
@@ -482 +508 @@
 var
   Executed: Integer;
+  I: Integer;
 begin
   FTerminated := False;
+  for I := 0 to ThreadPool.Count - 1 do
+    TMicroThreadSchedulerPoolThread(ThreadPool[I]).Start;
   repeat
     Executed := MainThreadManager.Execute(10);
@@ -492 +521 @@
 
 procedure TMicroThreadScheduler.Stop;
-begin
+var
+  I: Integer;
+begin
+  for I := 0 to ThreadPool.Count - 1 do
+    TMicroThreadSchedulerPoolThread(ThreadPool[I]).Terminate;
   FTerminated := True;
 end;
@@ -499 +532 @@
 var
   I: Integer;
-begin
+  CurrentTime: TDateTime;
+begin
+  CurrentTime := GetNow;
   Result := nil;
   try
@@ -510 +545 @@
      (TMicroThread(MicroThreads[RoundRobinIndex]).State <> tsWaiting) do begin
       // WakeUp sleeping threads
-      if (TMicroThread(MicroThreads[RoundRobinIndex]).State = tsSleeping) and
-        (TMicroThread(MicroThreads[RoundRobinIndex]).FWakeupTime < Time) then
-          TMicroThread(MicroThreads[RoundRobinIndex]).State := tsWaiting else
+      if (TMicroThread(MicroThreads[RoundRobinIndex]).FState = tsSleeping) and
+        (TMicroThread(MicroThreads[RoundRobinIndex]).FWakeupTime < CurrentTime) then
+          TMicroThread(MicroThreads[RoundRobinIndex]).FState := tsWaiting else
       begin
         // Go to next thread
@@ -541 +576 @@
 function TMicroThreadScheduler.GetThreadPoolSize: Integer;
 begin
-  Result := FThreadPoolSize;
+  Result := ThreadPool.Count;
 end;
 
 procedure TMicroThreadScheduler.SetThreadPoolSize(const AValue: Integer);
-begin
-  FThreadPoolSize := AValue;
+var
+  I: Integer;
+  NewThread: TMicroThreadSchedulerPoolThread;
+begin
+  if AValue > ThreadPool.Count then begin
+    ThreadPool.Capacity := AValue;
+    while ThreadPool.Count < AValue do begin
+      NewThread := TMicroThreadSchedulerPoolThread.Create(True);
+      NewThread.Manager.Scheduler := Self;
+      ThreadPool.Add(NewThread);
+    end;
+  end else
+  ThreadPool.Count := AValue;
 end;