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.