procedure of object Threadsafe?

[alleinherrscher]

Hi@all!

Ich habe eine Funktion Integrate, der ich eine (wenn ich es richtig verstanden habe) function of Object übergeben kann, um diese quasi mathematisch zu integrieren:

Delphi-Quellcode:

       TCommonFunction     =  function(x: double; Parameters:TFunctionParameters): double;

//[...]
       function Integrate(FunctionToIntegrate:TCommonFunction; Parameters:TFunctionParameters; From:double; Too:double;dx:double):double;
       begin
         //tu etwas
       end;

Damit ich mein Problem schneller berechnen kann, wollte ich es über mehrere Threads laufen lassen. Jeder Thread muss einige hundert mal eine Funktion integrieren. Allerdings ist die Funktion "integrate" nicht teil meines TThreads, sondern global in meinem Projekt definiert. Beim Ausführen bekomme ich immer Access Violations in dem Bereich der Integration. Daher meine Frage: Ist mein Verfahren nicht Thread-Safe und wie kann ich dies am besten Thread-safe lösen? Muss die Integrationsfunktion in meinen TThread?

Besten Dank und viele Grüße,
Michael

[Der schöne Günther]

Wo ist da eine function of object? TCommonFunction ist schonmal keine. Die Definition von TFunctionParameters lässt du weg.

"In meiner Methode X bekomme ich Zugriffsverletzungen". Ohne die Methode X zu zeigen ist diese Information weitgehend wertlos

[jaenicke]

Zitat von alleinherrscher:

Ist mein Verfahren nicht Thread-Safe und wie kann ich dies am besten Thread-safe lösen? Muss die Integrationsfunktion in meinen TThread?

Soweit du es gepostet hast (also quasi nichts vom eigentlichen Code) ist es threadsafe.

Wenn es ein Problem dabei gibt, dann greifst du auf etwas zu, das auch in anderen Threads benutzt wird. Zum Beispiel gemeinsame Objekte oder ähnliches.

[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