TObjectList-Einträge auf meherere Threads aufteilen

[DieDolly]

Ich habe eine TObjectList die eine Dateiliste repräsentiert.
Ich möchte basierend auf dieser Liste gerne Threads erstellen.
Beispielzahlen: 1000 Dateien, 8 Threads. Jeder Thread verarbeitet 125 Dateien.
Wie stellt man das am besten an? Ich meine nicht rechnerisch sondern das Erstellen der Threads, ohne temporäre Zwischenlisten.

Edit:
es besteht schon eine Prozedur, der ich einfach nur eine Liste übergeben kann und diese Prozedur erzeugt dann daraus einen Thread.
Es geht hier nur darum, wie ich das mit der Aufteilung am besten anstelle.

[Klaus01]

..anderer Ansatz.

- eine WorkerPool mit 8 Threads
- jeder Thread nimmt sich ein Object aus der ObjectListe
- wenn der Thread fertig ist, nimmt er sich das nächste Object.

Die Liste müsste dann für den Entnahmevorgang gesperrt werden.

Grüße
Klaus

[TiGü]

Mach mit Zwischenlisten und Datenübergabe beim Erstellen der Threads, alles andere macht nur unnötig Aufwand und Heckmeck.

Wobei Threads und "Dateiliste" schon wieder so ne Sache für sich ist.
Schreib- und Lesezugriffe sind ja am Ende durch die Hardware limitiert.
Da muss man ein paar Messungen machen, wo da der Tradeoff ist.

[DieDolly]

Zitat:

..anderer Ansatz.

Ich muss mein aktuelles System beibehalten, alles andere kostet zuviel Zeit die ich nicht habe.

Zitat:

Mach mit Zwischenlisten und Datenübergabe beim Erstellen der Threads,

Genau so mache ich es. Die Frage war nur, wie ich die Aufteilung richtig mache. Wie geagt nicht rechnerisch sondern Code.

[OlafSt]

Naja, man wird ja noch TObjectList.Count durch 8 teilen können und dann diese Anzahl Entries auf die 8 anderen Lists verteilen können...

Blöd nur, das das ganze nicht so funktionieren wird, wie du dir das vorstellst. Nicht jeder Thread hat gleich große Files, somit sind nicht alle gleichzeitig fertig - im Gegenteil.
Außerdem sind File-I/O-Operationen ohnehin sequentiell, eine Festplatte ist bereits mit 2 zeitgleichen Zugriffen völlig am Ende, bei SSD dauert das nur ein wenig länger.

Ergo: Anderes Konzept.

[Uwe Raabe]

TParallel.For hat eine Überladung mit einem Stride Parameter. Damit ließe sich das im genannten Beispiel so lösen:

Delphi-Quellcode:

  TParallel.For(125, 1, 1000,
    procedure(Index: Integer)
    begin
      { Bearbeite Listeneintrag[Index] }
    end
  );

Das Stride = 125 sorgt bewirkt, dass ein WorkerThread 125 Indizes hintereinander abarbeitet. Damit wird die For-Schleife auf bis zu acht Threads aufgeteilt.

[jaenicke]

Für die Verteilung auf die Threads hat Uwe ja schon eine Lösung genannt. Da reicht es die Indizes irgendwie zu verteilen, egal ob auf dem Weg oder anders, da die Liste bei reinen Lesezugriffen threadsicher ist.

Zitat:

Zitat von DieDolly (Beitrag 1481161)

Ich habe eine TObjectList die eine Dateiliste repräsentiert.
Ich möchte basierend auf dieser Liste gerne Threads erstellen.
Beispielzahlen: 1000 Dateien, 8 Threads. Jeder Thread verarbeitet 125 Dateien.
Wie stellt man das am besten an? Ich meine nicht rechnerisch sondern das Erstellen der Threads, ohne temporäre Zwischenlisten.

Temporäre Zwischenlisten sind bei normalen Festplatten der bessere Weg. Ein Thread geht die Liste durch, lädt nur stur die Dateien und übergibt diese geladen an die Threads zur Verarbeitung. So kann man die Leserate der Festplatte am besten ausnutzen.
Denn wenn du einfach nur auf 8 Threads verteilst, wird das ganze eher noch langsamer als vorher, wenn die Verarbeitung einer Datei nicht gerade ein Vielfaches der Lesezeit von der Festplatte benötigt.

Bei SSDs könnte man auch beim Lesen der Dateien parallele Zugriffe versuchen, aber auch nicht unbeschränkt viele, da kommt es auf die Größe der Dateien an wo hier Optimierungspotential ist.

Man könnte auch mit MMFs arbeiten um Windows so eine Optimierung der Zugriffe zu ermöglichen, wenn es sich um große Dateien handelt.

[DieDolly]

Zitat:

Bei SSDs könnte man auch beim Lesen der Dateien parallele Zugriffe versuchen, aber auch nicht unbeschränkt viele, da kommt es auf die Größe der Dateien an wo hier Optimierungspotential ist.

Man könnte auch mit MMFs arbeiten um Windows so eine Optimierung der Zugriffe zu ermöglichen, wenn es sich um große Dateien handelt.

Ich lese keine Dateien. Es geht nur um die Aufteilung der Listen.


Ich kann euch ja mal meinen absolut scheuslichen Code zeigen. Dann versteht ihr, warum ich hier nachfrage.
An der Sache mit den Threads kann ich nichts ändern. Es geht nur um die Aufteilung / Zuweisung in die Threads/Erstellung der Threads

Delphi-Quellcode:

MaxThreadCount := 8;
FilesPerThread := MainProcessFileList_ObjectList.Count div MaxThreadCount;
SetLength(TmpFileLists_ObjectList, MaxThreadCount);

for i := 0 to MaxThreadCount - 1 do
 begin
  try
   if MainProcessFileList_ObjectList.Count >= FilesPerThread then
    begin
     TmpFileLists_ObjectList[i] := TObjectList<TFileEntry_CopyProcess>.Create;
     TmpFileLists_ObjectList[i].OwnsObjects := False;
     TmpFileLists_ObjectList[i].Clear;

     iCnt := FilesPerThread;

     for j := 0 to iCnt - 1 do
      begin
       TmpFileLists_ObjectList[i].Insert(j, MainProcessFileList_ObjectList.Items[j]);
      end;

     for j := iCnt - 1 downto 0 do
      begin
       MainProcessFileList_ObjectList.Delete(j);
      end;

     // Thread erstellen
     if TmpFileLists_ObjectList[i].Count > 0 then
      begin
       createCopyThread(TmpFileLists_ObjectList[i], ..., ...); // ERSTELLUNG DES THREADS MIT DEM REST DER IN TmpFileLists_ObjectList DRIN IST
      end;
    end
   else
    Break;
  except
   // Mache dies und das im Fall des Falles
  end;
 end; // for

// Wenn noch Dateien "übrig" bleiben (z.B. bei 130 Dateien, 8 Threads bleiben 2 Dateien "übrig")
if (MainProcessFileList_ObjectList.Count > 0) then
 begin
  // Thread erstellen
  createCopyThread(TmpFileLists_ObjectList[i], ..., ...); // ERSTELLUNG DES THREADS MIT DEM REST DER IN TmpFileLists_ObjectList DRIN IST

  for i := MainProcessFileList_ObjectList.Count - 1 downto 0 do
   begin
    MainProcessFileList_ObjectList.Items[i].Free;
    MainProcessFileList_ObjectList.Delete(i);
   end;
 end;

Zitat:

TParallel.For hat eine Überladung mit einem Stride Parameter. Damit ließe sich das im genannten Beispiel so lösen:

Wofür ist denn das Low- und HighInclusive?
Low = einfach 1 und High = Anzahl der Dateien?

In meinem Fall also?

Delphi-Quellcode:

TParallel.For(MainProcessFileList_ObjectList.Count div MaxThreadCount, 1, MainProcessFileList_ObjectList.Count,
 procedure(Index: Integer)
  begin
   // Bearbeite Listeneintrag[Index]
  end);

Dieses Parallel.For verstehe ich noch nicht so richtig. Wie packe ich die Listeneinträge jetzt in einen Thread? Also bei 125 Dateien 16 Dateien pro Thread?
createCopyThread() darf ich in diesem Fall nur 8x aufrufen.
createCopyThread erwartet als letzten Parameter "IsLastThreads: Boolean". Ich muss also auch irgendwie rausfinden, welcher der letzte Thread ist.

Wie mache ich das alles mit TParallel.For? Kann man meinen Code ansonsten irgendwie verbessern:

[TiGü]

Zeig uns doch mal das Execute von diesen "CopyThread".

[DieDolly]

Wofür ist das Execute wichtig? Das ist doch egal. Es geht -nur- um die Aufteilung der ObjectList in mehrere ObjectListen, damit ich daraus Threads befüllen kann.
TFor.Parallel ist gut, aber da fehlen mir ein paar Dinge. Ich muss da drin u.a. eine Zählervariable haben.

Das Execute ist egal und tut nichts zur Sache. Den Code davon ändere ich ohnehin nicht.

[jaenicke]

Zitat:

Zitat von DieDolly (Beitrag 1481175)

In meinem Fall also?

Delphi-Quellcode:

TParallel.For(MainProcessFileList_ObjectList.Count div MaxThreadCount, 1, MainProcessFileList_ObjectList.Count,
 procedure(Index: Integer)
  begin
   // Bearbeite Listeneintrag[Index]
  end);

Das geht so, aber dann musst du Listeneintrag[Index - 1] bearbeiten, denn schließlich zählt die Schleife ja von 1 los. Deshalb solltest du die lieber bei 0 loslaufen lassen und bis Count - 1 laufen lassen wie es üblich ist. Ansonsten stimmt das, ja.

Zitat:

Zitat von DieDolly (Beitrag 1481189)

Das Execute ist egal und tut nichts zur Sache. Den Code davon ändere ich ohnehin nicht.

Wenn dort dann die Dateien von der Festplatte gelesen werden, wird die Aufteilung in Threads das ganze eben wie gesagt eher langsamer machen, es sei denn die Verarbeitung dauert deutlich länger als das Lesen von der Festplatte. Das ist aber oft gar nicht so.

[DieDolly]

Ich habe das TFor.Parallel noch immer nicht richtig verstanden.

Wenn ich 20 Dateien habe und 2 Threads daraus machen möchte, wie genau zählt Schleife 1 und wie Schleife 2?
Fängt Schleife 1 an zu zählen bei Index 0 an bis 9 und Schleife bei 10 von 19 ?
Weil ich brauche in irgendeiner Art und Weise eine Schleifenvariable die ich in jeder dieser For-Dinger nutzen kann. Ich muss wissen wann "0" ist.

Bei 0 erstelle ich eine temporäre ObjectList. Bei Index = MaxForFürDiesenDurchgang erzeuge ich den Thread.


Eine andere Idee. Jetzt gerade ist es so, dass Unit A die ObjectList in mehrere aufteilt und daraus Daten für Unit B (ein Thread) baut.
1000 Dateien, 8 Threads sollen gebaut werden, jeder Thread 125 Dateien.

Wenn ich das mit der neuen Herangehensweise mache, gäbe es nur noch EINEN Thread, der intern TParallel.For nutzt. Die Aufteilung und Verwaltung macht dann also TParallel.For.

Hat das irgendwelche Vorteile?

[Uwe Raabe]

Zitat:

Zitat von DieDolly (Beitrag 1481196)

Ich habe das TFor.Parallel noch immer nicht richtig verstanden.

Wenn ich 20 Dateien habe und 2 Threads daraus machen möchte, wie genau zählt Schleife 1 und wie Schleife 2?
Fängt Schleife 1 an zu zählen bei Index 0 an bis 9 und Schleife bei 10 von 19 ?
Weil ich brauche in irgendeiner Art und Weise eine Schleifenvariable die ich in jeder dieser For-Dinger nutzen kann. Ich muss wissen wann "0" ist.

Bei 0 erstelle ich eine temporäre ObjectList. Bei Index = MaxForFürDiesenDurchgang erzeuge ich den Thread.

Lös dich doch mal von deinem Thread, der mehrere Einträge aus einer temporären Liste bearbeitet.
Das TParallel.For behandelt alle Listeneinträge von 0 bis Count - 1 (Danke Sebastian), wobei die Arbeit an einem Eintrag innerhalb der anonymen Methode erfolgt.

Stell dir das erstmal wie bei einer ganz normalen Schleife vor:

Delphi-Quellcode:

for I := 0 to MainProcessFileList_ObjectList.Count - 1 do
begin
  { Tue was mit MainProcessFileList_ObjectList[I] }
end;

Willst du das parallel mit 8 Threads erledigen, schreibst du das so:

Delphi-Quellcode:

MaxThreadCount := 8;
FilesPerThread := MainProcessFileList_ObjectList.Count div MaxThreadCount;
TParallel.For(FilesPerThread, 0, MainProcessFileList_ObjectList.Count - 1,
  procedure(Index: Integer)
  begin
    { Tue was mit MainProcessFileList_ObjectList[Index] }
  end);

Das

Delphi-Quellcode:

{ Tue was mit MainProcessFileList_ObjectList[I] }

versteckt sich aktuell noch irgendwo in der Execute Methode deines Threads. Insofern ist das eben nicht egal. Vielleicht passiert innerhalb dieser Methode ja auch etwas, dass diesen Ansatz unmöglich macht oder eine Änderung dessen erfordert, aber das wissen wir nicht.

[DieDolly]

Im Execute meines Threads passiert davor und danach eine ganze Menge. Vor- und Nachbereitungen von Daten. I/O-mäßig passiert da sonst nix mehr.

Kann ich das TParallel.For auch IN den Thread verlagern? Weil mit dem TParallel.For im Hauptthread wird die GUI sonst geblockt.
Dafür wären nur wenige Änderungen notwendig und diesen Code der in temporäre Listen auslagert könnte ich komplett löschen.

[jaenicke]

Zitat:

Zitat von DieDolly (Beitrag 1481201)

Kann ich das TParallel.For auch IN den Thread verlagern? Weil mit dem TParallel.For im Hauptthread wird die GUI sonst geblockt.

Ja, sicher. TParallel.For ist genau dafür da, dass du die Arbeit der Schleife auf Threads aufteilst, aber danach das Ergebnis dann synchron weiterverarbeiten kannst. Der aufrufende Thread ist daher in der Tat blockiert.

[DieDolly]

Die Idee mit, das TParallel.For ins Execute auszulagern kam, weil TiGü nach dem Execute gefragt hat.

Ich habe das zum Testen mal ausgelagert.
11 Dateien ergibt

Zitat:

Threads: 4 (meine Vorgabe)
Files per thread: 2 (FFileList.Count div 4)
FFileList.Count: 11 (FFileList.Count)

Delphi-Quellcode:

TParallel.For(FFileList.Count div 4, 1, FFileList.Count - 1,

10 Dateien werden verarbeitet, die 11. leider nicht. Gibt es hier einen Trick, dass TParallel.For im letzten Durchgang den "Rest" mitnimmt, der bei der Rechnung nicht aufgeht?

Ist egal ich bin dumm!
Die Zählung muss natürlich bei 0 beginnen, nicht bei 1.

Danke an alle. Ich habe jetzt eine Mischung aus allen Vorschlägen.

[generic]

Zitat:

Zitat von DieDolly (Beitrag 1481161)

Ich habe eine TObjectList die eine Dateiliste repräsentiert.
Wie stellt man das am besten an? Ich meine nicht rechnerisch sondern das Erstellen der Threads, ohne temporäre Zwischenlisten.

TObjectList ist nicht threadsafe, daher Vorsicht walten lassen!

Du machst dir schon vorher Gedanken über die Lastverteilung.

Wenn du die Aufgaben (Dateien) in eine Blocking Collection packst,
dann können die Threads sich selbst bedienen, je nachdem ob einer mal schneller oder langsamer ist.
Du kannst auch Threads abhängig von der CPU erstellen (lassen) - also nicht gleich auf x festlegen.








___
von 0 auf 100 - Omni Thread Lib (OTL) - Multithreading einfach in Delphi
https://www.youtube.com/watch?v=OBBjqxxw31Y

[jaenicke]

Zitat:

Zitat von generic (Beitrag 1481304)

TObjectList ist nicht threadsafe, daher Vorsicht walten lassen!

Solange man sie nur einmal befüllt und die Threads nur lesend darauf zugreifen, sehe ich im Quelltext nichts, das dabei Probleme machen würde.

[Uwe Raabe]

Zitat:

Zitat von jaenicke (Beitrag 1481307)

Solange man sie nur einmal befüllt und die Threads nur lesend darauf zugreifen, sehe ich im Quelltext nichts, das dabei Probleme machen würde.

Nur solange das Befüllen beendet ist sobald das Lesen los geht. Beim Add könnte das implementierende Array der Liste neu zugewiesen werden. Das ohne Synchronisation durchzuführen wäre mir zu heikel. Selbst wenn das aktuell safe ist, könnte sich die Implementierung in Zukunft ja ändern.

[DieDolly]

Zitat:

Solange man sie nur einmal befüllt und die Threads nur lesend darauf zugreifen, sehe ich im Quelltext nichts, das dabei Probleme machen würde.

Zitat:

Nur solange das Befüllen beendet

Ich befülle die ObjectList aus dem Main-Thread heraus.
Erst dann erzeuge ich einen Thread, der mit der ObjectList (lesend) arbeitet.

[Uwe Raabe]

Zitat:

Zitat von DieDolly (Beitrag 1481367)

Ich befülle die ObjectList aus dem Main-Thread heraus.
Erst dann erzeuge ich einen Thread, der mit der ObjectList (lesend) arbeitet.

:thumb:

[himitsu]

TThreadList

Das ist keine Liste von Threads (TObjectList ist ja eine Liste von Objekten),
sondern es ist eine TList mit eingebauter Threadabsicherung. (also eigentlich eine TThreadsaveList)



Wieso Manuell aufteilen?
Lass die Einträge sich doch einfach dynamisch vereilen. (wer Zeit hat, der macht es)

* alle Aufgaben/Dateien in eine TThreadList
* dann X Threads starten (so viele, wie gewünscht)
* jeder Thread holt sich via ThreadList.Pop einwas raus
* * verarbeitet das
* * und wiederholt dann seine Schleife so oft, bis nichts mehr in der ThreadList drin ist
* dann kann er sich beenden (oder wartet, bis wieder was rein kommt, und arbeitet weiter)

Vorteile
* die ThreadList ist schon thread-sicher (hat die CriticalSection/Monitor bereits einbebaut)
* und wenn nicht alle Aufgaben gleich lange dauern, dann geht es auch schneller