TParallels For-Schleife abbrechen

[Uwe Raabe]

Zitat von günni0:

Ich belasse es bei beim Standard. Das sind je nachdem 5 bis 15 die da erzeugt werden.
Sollte aber durch mein Exit der Code nach meiner Bedingung gar nicht erst ausgeführt werden wenn meine Bedingung zutrifft?

TParallel.For teilt den von-bis Bereich in mehrere Happen auf und startet dann separate Tasks für jeden. In der Standardeinstellung sind das zweimal die Anzahl verfügbarer CPU-Kerne. Die Tasks starten dann mehr oder weniger gleichzeitig und es ist durchaus möglich, daß schon eine entsprechende Anzahl die Abfrage bereits negativ durchlaufen hat. Diese werden dann natürlich noch bis zum Ende ausgeführt. Im Worst Case wird die Abbruchbedingung erst dann gesetzt, wenn schon alle Iterationen darüber hinweg sind, und dann bringt das gar nichts.

Du kannst ja mal ausprobieren, die Bedingung schon vor dem Aufruf der For-Schleife zu setzen. Braucht es dann auch noch genauso lang? In dem Fall ist der Overhead für die Parallelisierung vermutlich höher als der Aufwand für die eigentliche Aufgabe. Dann wäre eine normale For-Schleife vielleicht die bessere Wahl.

[günni0]

Ohne diese parallele For-Schleife wird quasi sofort abgebrochen.
Das werden wohl einfach zu viele parallele For-Schleifen sein die da erstellt werden.

Setze ich eine eigene boolsche Variable noch vor die For-Schleife, setze diese im Block der Abbruchbedingung auf True und frage die danach ab nach dem Motto...

Delphi-Quellcode:

weiter := true
schleife von a bis 2

 wenn abbrechen dann
  begin
   weiter := false
   parallel.stop
   exit
  end

 if weiter dann
  ....

Klappt es auch relativ gut mit dem Abbrechen.

[Schokohase]

Lass mal diesen Code laufen:

Delphi-Quellcode:

program ParallelForBreak;

{$APPTYPE CONSOLE}

{$R *.res}

uses
  System.Diagnostics,
  System.SysUtils,
  System.SyncObjs,
  System.Threading;

var
  s: string;
  sw: TStopwatch;
  ccount, wcount: Integer;
  r: TParallel.TLoopResult;

begin
  try
    ccount := 0;
    wcount := 0;

    sw := TStopwatch.StartNew( );

    r := TParallel.for( 1, 5000,
      procedure( idx: Integer; loopstate: TParallel.TLoopState )
      begin
        TInterlocked.Increment( ccount );

        if loopstate.ShouldExit then
          Exit;

        // Workload
        TInterlocked.Increment( wcount );
        Sleep( 1 );

        // Abbruchbedingung
        if idx = 3800 then
        begin
          loopstate.Break;
        end;
      end );

    sw.Stop( );

    WriteLn( 'LoopResult:' );
    WriteLn( '  Completed: ', r.Completed );
    Writeln( '  LowestBreakIteration: ', r.LowestBreakIteration );

    WriteLn( 'Statistics:' );
    WriteLn( '  IteratorEvent called: ', ccount );
    WriteLn( '  IteratorEvent processed: ', wcount );
    WriteLn( '  Execution time: : ', sw.ElapsedMilliseconds, ' ms' );

    ReadLn( s );
  except
    on E: Exception do
      Writeln( E.ClassName, ': ', E.Message );
  end;
end.

Das Ergebnis hier:

Code:

LoopResult:
  Completed: FALSE
  LowestBreakIteration: 3800
Statistics:
  IteratorEvent called: 3984
  IteratorEvent processed: 3820
  Execution time: : 12799 ms

Soll bedeuten:
- Der IteratorEvent wurde 3984 mal aufgerufen
- Im IteratorEvent wurden 3820 Berechnungen ausgeführt
- Im IteratorEvent wurden somit 164 Berechnungen nicht ausgeführt (vorzeitig abgebrochen)

[günni0]

Abbruchbedingung ist 3800. Es wurde aber 3820 berechnet. Heißt das, dass es nicht wirklich zuverlässig ist eine TParallel zu verwenden?

Ich denke jedoch LoopState.ShouldExit hat mir geholfen.

[Schokohase]

Was ist daran nicht zuverlässig?

Willst du zuverlässig nur 3800 Aufrufe? Dann rufe es nur 3800 mal auf.

Oder sollen die Aufrufe solange erfolgen, bis man das passende Ergebnis gefunden hat? Dann ist es wurscht, ob es 3800 oder 3820 Aufrufe sind.

[KodeZwerg]

Ich vermute es sind mehr als in Bedingung steht weil da der von Uwe genannte "Kernel werden erstmal ausgenutzt" effekt aktiv ist, könnte das sein?

[Sherlock]

Ist es nicht ein grundsätzliches Problem? Eine For-Schleife benutzt man, wenn man genau weiß, wie oft eine Schleife ausgeführt werden soll, für alles andere nimmt man repeat oder while. Ein Abbrechen von For-Schleifen ist zwar möglich, aber IMHO schlechter Stil, und scheint sich im TParallel-Fall zu rächen.

Sherlock

[Uwe Raabe]

Zitat von Sherlock:

Ist es nicht ein grundsätzliches Problem? Eine For-Schleife benutzt man, wenn man genau weiß, wie oft eine Schleife ausgeführt werden soll, für alles andere nimmt man repeat oder while. Ein Abbrechen von For-Schleifen ist zwar möglich, aber IMHO schlechter Stil, und scheint sich im TParallel-Fall zu rächen.

So krass würde ich das nicht formulieren. Ich finde es z.B. kein schlechtes Design, wenn beim Durchsuchen eines Arrays eine For-Schleife verwendet wird und bei dem gesuchten Element ein Break stattfindet. Die Elemente werden über einen Index angesprochen und die Bereichsgrenzen sind im Voraus bekannt. Die Abbruchbedingung beschränkt sich auf das eigentliche Suchkriterium und muss sich nicht noch um die Bereichsgrenzen kümmern. Das reduziert den Code, ist klar strukturiert und jeder sieht sofort, was mit dieser Schleife bezweckt wird. Bei while- und repeat-Schleifen sehe ich auch oft eine Duplizierung der Abbruchbedingung (manchmal gecached in einer lokalen Variable), weil beim Abbruch bestimmte Code-Teile innerhalb der Schleife nicht mehr durchlaufen werden müssen. In solchen Fällen ziehe ich ein Break (selbiges gilt auch für Continue) vor - auch innerhalb while- und repeat-Schleifen.

Allerdings eignet sich so eine Schleife dann halt nicht für die Parallelisierung (aber auch keine mit while oder repeat).

Bei einem Parallel-For geht man eigentlich davon aus, daß alle Elemente vollkommen autark bearbeitet werden und keine gegenseitigen Wechselwirkungen haben. Ich weiß allerdings nichts über den angesprochenen Fall.