Algorithmen auf Zeit testen...

[Schlingel]

Hallo,

da es innerhalb von PB(4.02) ja lediglich die ElapsedMilliseconds() gibt, wird das Ergebnis meist 0 da sie unterhalb der milli's liegen.

Darum habe ich mir folgende möglk. ausgedacht aber glaube die ist nicht unbedingt sinnvoll... gibt es evtl. ne Api oder so ?
Das lediglich ein kleines Demobeispiel... denkweise dahinter ist klar pro Zeile ein Delay summiert sicht auf und erhalte so ne Zahl um zumind. die Komplexität abzuleiten. Aber das gibt mir nicht. den Realen Zeitaufwand..

(einfache aufgabe a*sqr(x) + b*sqr(y), nur Demo)

Code: Alles auswählen

a=7
x=27
b=4
y=48
zeit_on = ElapsedMilliseconds()
  a=a*a : Delay(1) 
  b=b*b : Delay(1) 
  
  x=a*x : Delay(1) 
  y=b*y : Delay(1) 
  
  x = Sqr(x) : Delay(1) 
  y = Sqr(y) : Delay(1)
  
  x = x+y : Delay(1) 
zeit_off = ElapsedMilliseconds()

Code: Alles auswählen

zeit_on = ElapsedMilliseconds()
  Gosub ggt:

  x = x/x2 : Delay(1) 
  y = y/x2 : Delay(1) 
  
  x = Sqr(x) : Delay(1) 
  y = Sqr(y) : Delay(1) 
  
  a = a*x : Delay(1) 
  b = b*y : Delay(1)
  
  
  a = a + b : Delay(1) 
  x = a * Sqr(x2) : Delay(1)
  
zeit_off = ElapsedMilliseconds()

ggt:

  h.l
  y2.l
  
  x2 = x : Delay(1) 
  y2 = y : Delay(1) 
  
  While (y2 <> 0)
  
    h = x2 % y2 : Delay(1) 
    x2 = y2 : Delay(1) 
    y2 = h : Delay(1) 
    
  Wend

  ;x2 als "return"
Return

[Thorium]

Eine Methode, die oft verwendet wird, ist es einfach eine Schleife draus zu machen. Dabei gibt es zwar einen Overhead durch die Schleife. Aber der ist vernachlässigbar. Vorallem wenn es um Vergleichstests geht.

Du verlängerst dadurch die Ausführungszeit halt auf eine messbare Zeit.

Code: Alles auswählen

a=7
x=27
b=4
y=48

zeit_on = ElapsedMilliseconds()

For i = 1 To 10000000

  a=a*a
  b=b*b
 
  x=a*x
  y=b*y
 
  x = Sqr(x)
  y = Sqr(y)
 
  x = x+y

Next

zeit_off = ElapsedMilliseconds()

Debug zeit_off - zeit_on

Ansonsten gibt es noch High-Res-Timer, z.b. über die API den QueryPerformanceCounter. Aber man ist bei einem Multitasking-System besser bedient, wenn man Messungen über einen längeren Zeitraum durchführt.

[GreyEnt]

ich hätte da mal eine frage der ausführgeschwindigkeit.
Und zwar hab ich eine Schleife die ca. 21000Millisec zur ausführung braucht. Klasse da kann man was dran optimieren. dachte ich.

Alt
schleifenanfang
a= ( (b-1)*xk+c ) * 100 / (xk*yk)
schleifenende

Neu
p.f=1/(xk*yk)*100
schleifenanfang
a= ( (b-1)*xk+c ) * p.f
schleifenende

Aber die Neue Schleife braucht länger als die Alte, obwohl die neue einfacher ist.

[THEEX]

Wird wohl an Fload hängen, Longs sind schneller als Fload...

[AND51]

Verstehe ich richtig, du möchtest Zeitabstände <10 ms messen?
In diesem Forum wurde bereits vielfach diskutiert, dass auf unterschiedlichen Betriebssystem, vor allem Windows, die Differenz zwischen zwei ElapsedMilliseconds() aufrufen bis zu 16 ms betragen kann.

Es gibt eine API, die einen sogenannten "hochauflösenden Timer" (sofern vorhanden, ist ein Hardwareteil im PC) verwednet.
Schau dir dazu mal bitte QueryPerformanceCounter() an. Dazu gibt es noch ein oder zwei QueryPerformance*-Befehle, die mir momentan nicht einfallen. Das steht aber in der MSDN, natürlich.

Lies dir doch bitte dazu diesen Thread hier durch, dort wird über das Messen von sehr kurzen Zeitabständen in Verbindung mit Screens/FPS diskutiert: http://www.purebasic.fr/german/viewtopi ... erformance

[Schlingel]

Naja als Beispiel z.b. wenn ich Fibonacci Zahlen zusammen rechne da würde Rekursiv schnell ja enorme Zeit brauchen während iterativ entsprechend sehr schnell geht auch bei einem großen n. D.h. da würde selbst bei solch vielen durchläufen für ElapsedMilliseconds() noch nicht messbares sein.

Du verlängerst dadurch die Ausführungszeit halt auf eine messbare Zeit.


For i = 1 To 10000000
...

Aber QueryPerformanceCounter() werde ich mir mal anschauen ... bei Gelegenheit.
Erstmal danke für die Antworten.