Multitasking Interna verstehen

[delphifan2004]

Hallo, ich will mal an den API Funktionen und der Thread Klasse vorbei Multitasking "von Hand" programmieren, als ob ich ein Betriebssystem vor mir hätte, welches das nicht schon selber kann. Bill Gates, der Erfinder von Windows musste das einst auch tun, weil das alte DOS kein Multitasking konnte. So musste die gesamte Threadlogik erst geschaffen werden als Unterbau von Windows. Diese Vorgehensweise möchte ich gerne nachvollziehen. Wie sollte ich vorgehen? Ich habe für den Registers Typ diese Deklaration gefunden:

Delphi-Quellcode:

TParameters = packed record
{$IFDEF CPUX86}
    Registers: array[paEDX..paECX] of Cardinal;   //gibt es da auch die Konstante paEIP?
    EAXRegister: Cardinal;
    ReturnAddress: Pointer;
{$ENDIF CPUX86}
    Stack: array[0..1023] of Byte;
  end;

In diesem Registers Array könnten also die Registerinhalte schon mal abgelegt werden. Wie komme ich aber da ran, wenn ich nicht das WinAPI zu Hilfe nehmen will, sondern so tun will, als gäbe es Windows noch gar nicht?

Ist ReturnAddress der aktuelle Befehlszählerstand?

Dann hätte ich ja schon mal eine Datenstruktur, welche meine Registerinhalte speichert, wenn ich Taskwechsel vornehmen will. Was muss ich noch beachten. Außer der Synchronisation wenn 2 Threads auf eine Zälervariable zugreifen? Allerdings 1024 Byte Stack kommt mir sehr wenig vor bei heutigen Programmen. Reicht denn das wirklich?

Ich würde Speicherbereiche für meine Programme in einer Liste verwalten welche die Startadressen hält. Dann wäre der jeweilige Befehlszählerstand ein Offset zur Anfangsadresse des Speicherbereiches. Allerdings hat jede .exe Datei ja noch einen Header vorne dran, die Startadresse folgt erst danach Was meint ihr daher zu meiner Idee?

[mkinzler]

Das Wegsichern der Register ist wohl das kleinste Problem beim Multitasking; um das man sich bei moderneren Prozessoren auch nicht mehr so sehr kümmern muss (Registerrenaming usw.)
Wichtiger ist es wie/wann der Prozesswechsel stattfindet (kooperativ/präemptiv; Zeitscheiben/round-robin; ...), IPC, Speicherverwaltung, Caching, ...

http://www.kolibrios.org/de/
https://github.com/vapaamies/KolibriOS

[Rollo62]

Mit "kooperativ" habe ich sehr gute Erfahrungen gemacht, selbst auf 8-Bit MCUs.
Mit etwas Disziplin funktioniert das bei moderater Anferorderung and RTOS sehr gut,
und kann sogar in der realen Welt Echtzeitstuerungen übernehmen.
Größere Aufgaben in Teil-Blöcke zerlegen.

Die grobe Überlegung dahinter:
Wenn man eine Haupt-Schleife mit ca. 1 kHZ durchfahren kann, ohne irgendwo länger zu blockieren,
dann reicht das für 99.5% der Fälle im realen Leben aus.
Selbst wenn die 1 kHz nur mit +/- 20% erreicht werden.
Weil die reale Welt da draussen eben nicht so schnell durchläuft, Sensoren nicht so schnell liefern und Aktoren nicht so schnell schalten, ... :stupid:

[Sinspin]

Ich habe auch als DOS und Assembler Programmierer angefangen und mir sowas selber gebaut. Als ich dann was unter Windows machen musste kam ich mir vor wie kastriert.
Was da damals in den CPUs implementiert wurde um multithread handling auf CPU Ebene zu ermöglichen halte ich noch immer für eine der genialsten Erfindungen in der Geschichte der Computertechnik.

Um Heutzutage selber das Threadingverhalten zu implementieren würde bedeuten dass Du einen Thread dann aufteilen würdest. Ansonsten müsstest Du auf Kernelebene runter. Und der wird dich nicht lassen.
Was allerdings interessanter wäre, eine Routine zu schreiben die mit einem Ausfürungspfad die Zeitschnipsel verschiedener Threads vereint. Kann mir nicht vorstellen dass das geht.

[delphifan2004]

Ich werde also erst mal probieren Datenstrukturen zu bauen und dann wie ein Kind rumprobieren um erste Erfahrungen zu sammeln.

[TiGü]

Zitat:

Zitat von delphifan2004 (Beitrag 1469673)

Ich werde also erst mal probieren Datenstrukturen zu bauen und dann wie ein Kind rumprobieren um erste Erfahrungen zu sammeln.

Du könntest natürlich auch erstmal dich in das Thema einlesen und versuchen zu verstehen, wie das bspw. in Windows gelöst ist.
Beispiel:
https://www.codeproject.com/Articles...Windows-Thread

[HintByError]

Zu beachten ist, dass die Maschineninstruktionen des Prozessors zur Implementierung von Threads privilegiert sind. Das heißt, dass eine Windows-Anwendung nicht auf diese Instruktionen zugreifen darf. Diese Instruktionen darf nur das Betriebssystem verwenden.

[Stevie]

Der Record den du da oben gepostet hast hat rein gar nichts mit Multitasking zu tun sondern stammt aus

Delphi-Quellcode:

System.ObjAuto.pas

und ist für die Parameterübergabe beim dynamische Aufrufen von Methoden. Die 1024 Byte da reichen für mehr Parameter als man jemals an eine Methode übergibt.

[delphifan2004]

Zitat:

Zitat von TiGü (Beitrag 1469689)

Zitat:

Zitat von delphifan2004 (Beitrag 1469673)

Ich werde also erst mal probieren Datenstrukturen zu bauen und dann wie ein Kind rumprobieren um erste Erfahrungen zu sammeln.

Du könntest natürlich auch erstmal dich in das Thema einlesen und versuchen zu verstehen, wie das bspw. in Windows gelöst ist.
Beispiel:
https://www.codeproject.com/Articles...Windows-Thread

... und mit Threads programmieren wie das unter Windows gemacht wir. Klar! Danke für den Link. Habe auch schon Michael Puff's Seite aufgesucht und dort auch Dokus gefunden über Win-API und auch über Threads mit Delphi ist ein Tutorial dabei. Das wäre dann erst mal die Verwendung der Threadlogik wie sie in Windows implementiert ist. Danach will ich aber weiter. Und lernen wie das "unter der Haube" gemacht wird. Das API ist ja nur das Interface dazu.

Zitat:

Zitat von HintByError

Zu beachten ist, dass die Maschineninstruktionen des Prozessors zur Implementierung von Threads privilegiert sind. Das heißt, dass eine Windows-Anwendung nicht auf diese Instruktionen zugreifen darf. Diese Instruktionen darf nur das Betriebssystem verwenden.

Danke für den wichtigen Tipp. Dann wird das ja innerhalb von Windows schwierig umzusetzen. Mit Delphi ein Programm schreiben wird da nicht so einfach weil das ja auf Windows läuft.

Zitat:

Zitat von Stevie

Der Record den du da oben gepostet hast hat rein gar nichts mit Multitasking zu tun sondern stammt aus System.ObjAuto.pas und ist für die Parameterübergabe beim dynamische Aufrufen von Methoden. Die 1024 Byte da reichen für mehr Parameter als man jemals an eine Methode übergibt.

Wie speichere ich denn da die aktuellen Registerinhalte vor dem Taskwechsel? Dafür wollte ich diese Struktur verwenden. Oder gibt es da in der CPU eine Methode? Ich habe eine AMD Athlon(tm) II X2 B24 CPU mit 2 Kernen je 3 GHz. Das ist aber meine konkrete CPU. Wenn ich aber mit meinem Entwurf auch auf anderen CPUs Erfolg haben will? Habe noch einen älteren Rechner mit Pentium 400MHz.

Welche Taskwechselmechanismen gibt es da auf der CPU Serie X86? WO finde ich Dokus dazu? Die möglichst auch verständlich geschrieben sind für einen der sowas noch nie gemacht hat?

Das Buch Programmierhandbuch 80386/80486 von Claßen der Reihe Technische Informatik vom Verlag Technik Berlin besitze ich bereits. Wahrscheinlich aber brauche ich noch mehr Infos als in diesem Buch zu finden.

[himitsu]

Statt das alles selber zu machen, oder um da bissl abzugucken, würde ich empfehlen sich mal die Fiber anzusehn.
Im Prinzip machen die genau das, was du willst.

https://docs.microsoft.com/en-us/win...d/using-fibers


Und sogar die neue Threading-API im Delphi hat mit TTask und TFuture etwas, was vom Verhalten dem sehr nah kommt.
System.Threading

[TiGü]

Zitat:

Zitat von delphifan2004 (Beitrag 1469775)

Zitat:

Zitat von TiGü (Beitrag 1469689)

Zitat:

Zitat von delphifan2004 (Beitrag 1469673)

Ich werde also erst mal probieren Datenstrukturen zu bauen und dann wie ein Kind rumprobieren um erste Erfahrungen zu sammeln.

Du könntest natürlich auch erstmal dich in das Thema einlesen und versuchen zu verstehen, wie das bspw. in Windows gelöst ist.
Beispiel:
https://www.codeproject.com/Articles...Windows-Thread

... und mit Threads programmieren wie das unter Windows gemacht wir. Klar! Danke für den Link. Habe auch schon Michael Puff's Seite aufgesucht und dort auch Dokus gefunden über Win-API und auch über Threads mit Delphi ist ein Tutorial dabei. Das wäre dann erst mal die Verwendung der Threadlogik wie sie in Windows implementiert ist. Danach will ich aber weiter. Und lernen wie das "unter der Haube" gemacht wird. Das API ist ja nur das Interface dazu.

Ja ja, bla bla...hast du dir den Link überhaupt angeguckt?
Da geht es eben NICHT darum wie man die WinAPI bedient - also Funktionen aufruft usw. - sondern ist ein erster einfacher Einstieg über den Hintergrund, also was da in Windows passiert und welche Datenobjekte der Kernel dafür braucht und anlegt.

Wenn du es dann wirklich im Detail verstehen willst, empfehle ich das "Windows Internals" Buch:
https://www.amazon.de/dp/B0711FDMRR/...ng=UTF8&btkr=1
https://www.amazon.de/dp/B07D3BTQTG/...ng=UTF8&btkr=1
https://docs.microsoft.com/en-us/sys...dows-internals

In der neusten englischen Ausgabe wird da über 107 Seiten alles über Threads behandelt.

Wenn du gebraucht die vorige Edition sechs findest und günstig erwerben kannst, dann tut es das auch.
Jede bessere Bibliothek sollte zumindest per Fernleihe eine Ausgabe (deutsch oder englisch) verfügbar haben.

[TiGü]

Wenn man nur Quelltext lesen möchte, kann man sich natürlich ab Zeile 136 ff. der thread.c vom ReactOS-Projekt verlieren:
https://doxygen.reactos.org/d0/d85/d...8c_source.html

[delphifan2004]

Zuerst schau ich mir Codeproject gründlicher an. Bin da noch dabei. Hatte zunächst nur oberflächlich rein geschaut und nicht sofort gesehen, dass dort die Thread Internals unterhalb der Windows Ebene beschrieben werden. Erst als ich weiter runter gescrollt habe, hab ich das richtig erfasst. Windows Internals ist auch ein guter Tipp. Aber alles nacheinander. Danke für die Link's! Muss mich da erst mal rein arbeiten.

Auf Quelltextebene ist nicht genug für mich, ich brauch da schon die andere Doku mit den Windows Internals. Dennoch danke!

[OT]
Muss mal wieder die aktuelle Version von ReactOS runter laden. Leider läuft ReactOS bisher nicht auf meinem Rechner, obwohl Linux durchaus läuft, ich nutze Knoppix. Und soweit ich weiß hat ReactOS einen Linux Kernel.[/OT]

[TiGü]

Zitat:

Zitat von delphifan2004 (Beitrag 1469817)

Und soweit ich weiß hat ReactOS einen Linux Kernel.[/OT]

Nee, das verwechselst du gerade mit dem Wine-Projekt.

[delphifan2004]

Zitat:

Zitat von TiGü (Beitrag 1469819)

Zitat:

Zitat von delphifan2004 (Beitrag 1469817)

Und soweit ich weiß hat ReactOS einen Linux Kernel.[/OT]

Nee, das verwechselst du gerade mit dem Wine-Projekt.

Ups. Das wusste ich nicht! Also eigener Kernel dort?

[TiGü]

Ja. Wikipedia gibt nähere Auskunft.

[himitsu]

Jo, Wine und ReactOS nutzen gegenseitig quasi vom Frontend (APIs für die ausgeführten Programme) einge OpenSource-Teile. Auch von Haiku (einem anderen Betriebssystem) und anderen offenen Quellen werden Teile benutzt (alles selbst zu machen zu wollen wäre auch bissl "blöd", für so ein kleines Team) und die API-Definitionen werden "absichtlich" von Windows abgeguckt.
Für die auszuführenden Programme haben Wine und ReactOS ja praktisch das "selbe" Ziel,
blos dass Wine eben "nur" als Übersetzer für Linux arbeitet und ReactOS als eigenständiges Betriebssystem konzeptioniert ist.

Intern quasi alles "neu", aber nach außen soll alles so aussehen wie im Windows, denn schließlich soll es "kompatibel" sein.
Stell es dir z.B. fast ein Bissl wie MariaDB gegen MySQL vor.


Auch wenn also die APIs für's Multitasking/Threadding/... abgeguckt wurden, kann es intern funktionell "ähnlich" arbeiten, aber kann/wird/muss es intern natürlich anders implementiert sein, da es ja kein 100%-Klon sein soll/darf.


PS: Wer wirklich "mehr" wissel will, der sollte Wiki auch mal in anderen Sprachen fragen,
da es meistenst keine Übersetzungen, sondern eigenständige Artikel sind, die überall unterschiedlich ausführlich sind. (und da es z.B. mehr Englischsprachige als Deutschsprachige gibt .....)

[delphifan2004]

Ich will gerade das hier durchspieln, um Übung in der Programmierung mit Threads unter Windows zu kriegen. Das ist aus Luckies Thread Tutorioal von Seite 12:

Delphi-Quellcode:

type 
  TThreadParams = packed record 
    Number: Integer; 
    Text: String; 
  end; 
  PThreadParams = ^TThreadParams;


function ThreadFunc(tp: PThreadParams): Integer; 
var Number : Integer; Text : string; s : string; 
begin 
  // Parameter lokalen Variablen zuweisen. 
  Number := PThreadParams(tp)^.Number; Text := PThreadParams(tp)^.Text; 
  s := ’Zahl: ’ + IntToStr(Number) + #13#10 + ’Text: ’ + Text; 
  
  // ExitCode enthält Rückgabewert der Messagebox. 
  Result := MessageBox(0, PChar(s), ’Thread’, MB_YESNO or MB_ICONINFORMATION); 
  // Reservierten Speicher für Parameter wieder freigeben. 
  Dispose(tp); 
end;

procedure RunThread; 
var 
  tp : PThreadParams; 
  Thread : THandle; 
  ThreadID : Cardinal; 
  ExitCode : Cardinal; 

begin 
  // Speicher für Struktur reservieren. 
  New(tp); // Daten den feldern der Struktur zuweisen. 
  tp.Number := 42; 
  tp.Text := ’Die Antwort.’; 
  
  // Thread erzeugen. 
  
  Thread := BeginThread(nil, 0, @ThreadFunc, tp, 0, ThreadID); 
  
  // Auf Beendigung des Threads warten. 
  
  WaitForSingleObject(Thread, INFINITE); 
  // Rückgabewert ermitteln... 
  GetExitCodeThread(Thread, ExitCode); 
  // ...und auswerten. 
  case ExitCode of 
    IDYES: Writeln(’Benutzer hat "Ja" angeklickt.’); 
    IDNO: Writeln(’Benutzer hat "Nein" angeklickt.’); 
  end; // Thread-Handle schliessen udn somit das Thread-Objekt zerstören. 
  CloseHandle(Thread); 
end;

Wo stehen die Zahlenwerte für die Konstanten IDYES und IDNO? In der Unit Windows?

Der Grund ist, in der Case Anweisung wird für die Ausgabe Writeln verwendet, in der Threadfunc aber die Messagebox. In einer VCL Anwendung aber mit writeln hantieren?

Ich will deshalb anstelle der Messagebox eine Funktion unter Verwendung von Readln schreiben, die mir diese beiden Werte erzeugt. Aber dazu brauche ich ja diese Werte. Wenn die in der Windows Unit stehen passt alles. Wenn nicht, wo stehen sie dann? Dann kann ich für meine Thread Gehversuche eine Konsolenanwendung anlegen.

[TiGü]

Immer dieses Rumraten und "Wo steht denn das und dies, ich weiß nicht wie man danach sucht"? :roll:

Einfach mal IDE auf und machen, zack zack zack! *Peitschen-Smiley*

Hier, der Bequemlichkeit halber musst du das nur kopieren.
Und nein, der Aufruf von MessageBox hat nichts mit der VCL zu tun, das ist der direkte Aufruf auf die WinAPI-Funktion (https://docs.microsoft.com/en-us/win...ser-messagebox).

Ja, das ist ein Konsolenprojekt.

Delphi-Quellcode:

program Project1;

{$APPTYPE CONSOLE}

{$R *.res}

uses
  SysUtils,
  Windows;

type
  TThreadParams = packed record
    Number: Integer;
    Text: String;
  end;
  PThreadParams = ^TThreadParams;


function ThreadFunc(tp: PThreadParams): Integer;
var Number : Integer; Text : string; s : string;
begin
  // Parameter lokalen Variablen zuweisen.
  Number := PThreadParams(tp)^.Number;
  Text := PThreadParams(tp)^.Text;
  s := 'Zahl: ' + IntToStr(Number) + #13#10 + 'Text: ' + Text;
  
  // ExitCode enthält Rückgabewert der Messagebox.
  Result := MessageBox(0, PChar(s), 'Thread', MB_YESNO or MB_ICONINFORMATION);
  // Reservierten Speicher für Parameter wieder freigeben.
  Dispose(tp);
end;

procedure RunThread;
var
  tp : PThreadParams;
  Thread : THandle;
  ThreadID : Cardinal;
  ExitCode : Cardinal;

begin
  // Speicher für Struktur reservieren.
  New(tp); // Daten den feldern der Struktur zuweisen.
  tp.Number := 42;
  tp.Text := 'Die Antwort.';
  
  // Thread erzeugen.
  
  Thread := BeginThread(nil, 0, @ThreadFunc, tp, 0, ThreadID);
  
  // Auf Beendigung des Threads warten.
  
  WaitForSingleObject(Thread, INFINITE);
  // Rückgabewert ermitteln...
  GetExitCodeThread(Thread, ExitCode);
  // ...und auswerten.
  case ExitCode of
    IDYES: Writeln('Benutzer hat "Ja" angeklickt.');
    IDNO: Writeln('Benutzer hat "Nein" angeklickt.');
  end; // Thread-Handle schliessen udn somit das Thread-Objekt zerstören.
  CloseHandle(Thread);
end;

begin
  try
    RunThread;
  except
    on E: Exception do
      Writeln(E.ClassName, ': ', E.Message);
  end;
  Readln;
end.

[delphifan2004]

Ok, danke, also kann ich das als Konsolenprojekt machen. Ich dachte, die messagebox sei schon VCL, aber klar, viele Windows Objekte sind ja schon in der API enthalten, stimmt ja auch wieder. Und die Konstantenwerte stehen also in der Windows Unit. Das war es was ich wissen wollte. Wenn ich IDYES im Delphi Editor eingebe kommt keine Hilfe dazu. Ok, ich hätte es mit der Windows Unit auch einfach ausprobieren können, bei fehlerfreier Übersetzung ist alles gut. Aber manchmal weiß es einer hier schon ohne erst groß selber nachzuschauen.

[Dalai]

Zitat:

Zitat von delphifan2004 (Beitrag 1470041)

Wo stehen die Zahlenwerte für die Konstanten IDYES und IDNO?

Zitat:

Zitat von delphifan2004 (Beitrag 1470055)

Und die Konstantenwerte stehen also in der Windows Unit. Das war es was ich wissen wollte. Wenn ich IDYES im Delphi Editor eingebe kommt keine Hilfe dazu.

Wenn man nicht weiß, wo etwas definiert ist, einfach Strg drücken und mit der Maus auf das Wort klicken. Schon kommt man genau an der Stelle raus, wo das Ding definiert ist. Das funktioniert mindestens mit Variablen und Konstanten, bei Funktionen bin ich grad nicht sicher (hab seit Wochen kein Delphi benutzt).

Gerade die von der Win32 API definierten Werte stehen nicht in der Delphi-Hilfe, weil sie eben von MS definiert sind und nicht von Delphi.

Grüße
Dalai

[himitsu]

> Code Insight

Man kann auch die Maus drüber halten und sieht im Hint den Wert stehen.

Für die WinAPI kann man Online im MSDN bzw. docs.microsoft.com suchen (aber oft/manchmal stehen in deren Hilfe auch keine Werte ... manchmal doch, untendrunter in den Kommentaren)
oder man läd sich das Windows SDK runter (da sind nahezu alle C-Header-Dateien zu allen möglichen Windows-DLLs enthalten, samt Definition der APIs (exportierte Funktionen und nötige Typen, Enums, Konstanten, ...)
Oder man fragt eine Suchmaschine des Vertrauens nach der Konstante und findet irgendwo was.