procedure of object Threadsafe?

[alleinherrscher]

TFunctionParameters ist nur ein Record. Okay dann ist es keine procedure of Object. Wie nennt man es denn, wenn ich als Parameter eine Funktion übergebe?

Delphi-Quellcode:

       function Integrate(FunctionToIntegrate:TCommonFunction; Parameters:TFunctionParameters; From:double; Too:double;dx:double):double;
       var width,dummy:double;
           i,steps:cardinal;
           vz:integer;
       begin
          if (dx=0) or (Too=From) then
            begin
              result:=0;
              exit;
            end;
          width:=Too-From;
          dx:=abs(dx)*(Too-From)/abs(Too-From);
          if width/dx>high(steps) then
             begin
               output('Integration-Error: dx is set too small. Using smallest acceptable dx = '+floattostr(width/high(steps)));
               dx:=width/high(steps);
             end;
          steps:=round(width/dx);
          result:=0;

          for i := 1 to steps do
              result:=result+FunctionToIntegrate(From+(i-0.5)*dx, Parameters)*dx;
       end;

[TiGü]

Zitat von alleinherrscher:

Wie nennt man es denn, wenn ich als Parameter eine Funktion übergebe?

Callback!
http://www.michael-puff.de/Programmi...Callback.shtml

[Der schöne Günther]

Eventuell auch Closure
Das kommt dem "Function of object" auch noch ein Stückchen näher.

[Blup]

Die Funktion "Integrate" ist threadsicher wenn:

- die intern genutzte Funktion "output" threadsicher ist
- die übergebene und intern genutzte Funktion "FunctionToIntegrate" threadsicher ist
- der Parameter "Parameters" keine Objekte, Zeiger, Arrays enthält, oder die dadurch referenzierten Inhalte nicht aus anderen Threads angesprochen werden

[BUG]

Ich denke, Output könnte man im Zweifelsfall durch einen Mutex schützen; die Funktion sollte eh nicht so oft aufgerufen werden.
Es wird wahrscheinlicher irgendwas an FunctionToIntegrate sein. Ist das eine Funktion im mathematischen Sinne oder hat sie Seiteneffekte?

Außerdem: Es kann sein, das der Fehler schon vorher auftritt aber erst in Integrate zu einer Exception führt.

[sx2008]

Du musst dein Problem in so viele Teile zerlegen wie dein Rechner CPU-Kerne hat.
Mehr Threads als CPUs vorhanden sind wirken bei reinen Berechnungen bremsend auf die Gesamtleistung.
Pro CPU startest du dann einen Thread.
Der Thread (TThread-Klasse) bekommt von Aussen vor dem Start alle Parameter die für die Berechnung nötig sind.
Diese Parameter können durchaus auch eine Funktion (Zeiger auf eine Funktion/Methode) enthalten.
Wichtig ist nur, dass die Funktion nicht schreibend auf einen gemeinsamen Status zugreift.
Nur lesender Zugriff auf einen gemeinsamen Status der sich nicht ändert ist kein Problem.
(= Funktion ohne Seiteneffekte)
Das Ergebnis der Berechnungen wird in Variablen/Properties des Thread-Objekts gespeichert.
Nachdem alle Threads durchgelaufen sind sammelt der Hauptthread die Ergebnisse ein und fügt sie zusammen.

Ein Problem könnte sein, dass die Threads unterschiedlich viel Zeit brauchen und der langsamste Thread die Gesamtdauer bestimmt.
Um dies zu entschärfen kannst du das Problem auch in mehr Teile als Threads vorhanden sind zerlegen.
Wenn ein Teilproblem von einem Thread gelöst ist bekommt er vom Hauptthread ein weiteres Teilproblem zugeteilt.
(ggf. den alten Thread beenden und neuen Thread starten)

[grl]

Wo bekommst du denn genau deine AV? Wo steht der Debugger danach?

Was tut deine FunctionToIntegrate?

GRL

[Sir Rufo]

Wann ist etwas threadsicher?

Wenn absolut sichergestellt ist, dass der Speicherbereich x zu jedem Zeitpunkt t nur von einem Thread gelesen oder beschrieben wird.

Eigentlich gibt es dazu nicht mehr zu sagen, ausser

Bei mehr als einem Thread muss man davon ausgehen, dass zu jedem Zeitpunkt t jeder Thread auf den Speicherbereich x zugreifen möchte/könnte.

[Bjoerk]

Zitat von Sir Rufo:

[..] Eigentlich gibt es dazu nicht mehr zu sagen, ausser [..]

daß Integrate Traperförmig aufsummiert. Bei einem einfachen Simpson müßte man nicht so stark verfeinern und man bräuchte vermutlich überhaupt keinen Thread mehr.