Rechenzeit stoppen

[dezz]

Hallo,

ich bearbeite ein Projekt zu Sortierverfahren mit Delphi. Um diese dann auf Geschwindigkeit und Effizienz zu vergleichen, muss ich die Zeit stoppen koennen, die der Algorithmus braucht um eine Liste mit n Elementen zu sortieren.

Als Beispiel habe ich folgenden Sortieralgorithmus: Sortieren durch direkte Auswahl:

Delphi-Quellcode:

procedure TForm1.Button1Click(Sender: TObject);
var i,j,hilf,platz,kleinste:integer;
begin
timer.Enabled:=true;

for i:=1 to 99999 do
begin
kleinste:=f[i];
platz:=i;
   for j:=i to 100000 do
    begin
      if f[j]<kleinste then
        begin
          kleinste:=f[j];
          platz:=j;

        end;
    end;
   hilf:=f[i];
   f[i]:=f[platz];
   f[platz]:=hilf;


end;
timer.enabled:=false;
listbox1.Items.clear;
for i:=1 to 100000 do
  listbox1.items.add(inttostr(f[i]));


end;

nicht ueber die grossen Zahlen wundern, nur zum Test genommen damit es auch ne weile dauert *g*

Mit Hilfe des Timers wollte ich die Zeit festhalten die der Algo braucht, nur scheinbar wird das OnTimer Event nicht aufgerufen.

Kann mir jemand sagen wie ich dies mit dem Timer realisieren kann oder ob es eine bessere Moeglichkeit gibt die Zeit des Algo zu stoppen?

danke mfg dezz

[malo]

Im sortier-Algo: Wenn fertig, dann boolsche Variable auf true setzen. Im OnTimer dann abfragen, ob die jeweilige Variable true ist. Wenn ja, dann Timer disablen

Ansonsten im OnTimer einfach nur eine Variable von 1-* hochzählen und am Ende die Zahl ausgeben lassen

//edit: Hab deinen Code nochmal überflogen: Den Teil mit dem Timer disablen von mir kannste dann weglassen

[dezz]

hab das schon so probiert, im OnTimer ne Zahl hochzaehlen zu lasssen ....
quasi inc(a) .. und am ende dann a ausgeben lassen, nur dass a immer Null bleibt, OnTimer also anscheinend garnicht aufgerufen wird.
(kann es sein, dass der Computer waehrend er in der Schleife des Algo ist OnTimer nicht abfragt?)

[jfheins]

Nimm 2 Variablen vom Typ Int64.
Bei beginn der Zeitmessung machst du queryperformancecounter (variable1); am ende sowas wie

Delphi-Quellcode:

queryperformancecounter (variable2);
variable1 := variable2 - variable1
queryperformancefrequency (variable2);
showmessage ('Abgelaufene Zeit: ' + floattostr (variable1 / variable2) + ' sek');

[dezz]

danke jfheins,

also es funktioniert schonmal, nur koenntest du mir bitte erklaeren wie genau das funktioniert? also was welcher schritt macht und was queryperformancecounter macht? hab in der hilfe nichts dazu gefunden und muesste schon wissen wie es funktioniert da ich das projekt fuer die schule mache und auch erklaeren muss wie es funktioniert.

mfg dezz

[Lantis]

Hi,
mann könnte es doch sicher auch einfachso machen:

Delphi-Quellcode:

var start:TTime;

begin
  start:=now;

  ...//sortieren


  ShowMessage(TimeToStr(now-start));
end;

nur so für grobe Sekunden

Gruß Lantis

[dezz]

ja danke dir auch Lantis,

so wird es sicher auch funktionieren, hilft mir aber bei meinem Projekt nicht weiter, da ich die Zeit doch wenigstens auf hundertstel Sekunden genau brauche um die Verfahren moeglichst genau zu vergleichen.

trotzdem danke

[Oxmyx]

So verwendet man den High Performance Counter:

Delphi-Quellcode:

function GetTime(): Double;
{$WRITEABLECONST ON}
const
  bInitialized:   BOOL = FALSE;
  qwTicksPerSec:  Int64 = 0;
  qwTime:         Int64 = 0;
{$WRITEABLECONST OFF}
begin
  if not bInitialized then begin
    QueryPerformanceFrequency(qwTicksPerSec);
    bInitialized := TRUE;
  end;
  QueryPerformanceCounter(Int64(qwTime));
  Result := qwTime / qwTicksPerSec;
end;


{...}

var
  dTime1, dTime2: Double;
begin
  dTime1 := GetTime();
  {
    Berechnungen....
  }
  dTime2 := GetTime();
  ShowMessage('Zeit: ' + FloatToStr(dTime2 - dTime1));
end;

Bevor du die Funktion zum Zeitmessen verwendest, solltest du sie wohl mindestens einmal aufgerufen haben, dass sie bereits initialisiert ist. Sonst kann das Ergebnis verfälscht werden.

Das ganze funktioniert so:
Wenn die Funktion zum ersten Mal aufgerufen wird, fragt sie die Taktfrequenz eines bestimmten Chips auf dem Mainboard ab. Dieser tickt im Regelfall mit ca. 3-4 Millionen Ticks pro Sekunde. Die Frequenz wird gespeichert. Danach wird die Funktion QueryPerformanceCounter aufgerufen, die die Ticks seit Start des Computers zurückliefert. Wenn man diese Anzahl nun durch die Taktfrequenz des Counters teilt, erhält man einen sehr exakten Wert, seit wann das System läuft. Aus der Differenz zweier Zeitmessungen kann man dann die verstrichene Zeit auf wenige Mikrosekunden genau berechnen.

[Binärbaum]

Man kann das auch mit GetTickCount machen:

Delphi-Quellcode:

var start: Cardinal;
    i: Integer;
begin
 start:= GetTickCount; 
 for i:=0 to 9999 do begin
  //Mach irgendwas...

 end;
 start:= GetTickCount - start;
 ShowMessage('Zeit: '+IntToStr(start)+' ms');
end;

[Edit]
Zur Erklärung:
GetTickCount liefert die Zeit seit Systemstart in Millisekunden.
[/Edit]

MfG
Binärbaum

[Tubos]

Zitat:

Man kann das auch mit GetTickCount machen

Das ist zwar möglich, aber eine eher schlechte Idee da GetTickCount nur auf etwa 4 ms genau ist, d.h. der Aufruf von GetTickCount liefert 4 ms lang den selben Wert.