QEVal - sehr schneller Eval Prozessor

[cxAlex]

Servus.

QEval wird ein Eval wie es schon ein paar im Forum gibt. Darum halt ich mich bei der Beschreibung kurz.

Was macht ein Eval ?
Strings zur Laufzeit berechnen.

Wofür braucht man das?
QEval ist speziell für extrem oft auftretende Berechnungen ausgelegt, z.B. Filter für Images, Sounds, immer wiederkehrende Berechnungen in Spielen wären eine Anwendung.

Was ist der Vorteil gegenüber anderen Eval-Proceduren?
Die Geschwindigkeit. Es ist bereits in der 1. Version gegenüber allen anderen Evals aus dem Forum die ich bisher getestet habe ~8-20 mal schneller, je nach Rechnung. Je komplexer die Rechnung wird desto gravierender wird der Speed - Vorteil.

Sonstige Features:
Beliebig viele Variablen definierbar, PB - Variablen sind ohne Getter/Setter direkt in QEval nutzbar und umgekehrt.
eigene Proceduren aus PB (bsp. Wurzel, Fakultät, ...) können in QEval registriert werden und aufgerufen.

Demo - Download:
64 Bit: http://www.file-upload.net/download-225 ... l.exe.html
32 Bit: http://www.file-upload.net/download-225 ... l.exe.html

Der Haken derzeit: QEval muss derzeit noch mit dem ASM - ähnlichen Code wie in der Demo zu sehen programmiert werden. Ein Übersetzer der aus "normalen" Rechnungen diesen Code erzeugt muss noch integriert werden, dazu hatte ich bisher keine Zeit, bzw. würde ich in der Richtung gerne Hilfe annehmen.

Das ganze wird entweder als DLL oder als Source zur Verfügung gestellt, das muss ich mir noch überlegen.

Ich würde mich darüber freuen wenn ihr eure - Speed Resultate posten würdet, vlt auch im vergleich zu dem Eval das ihr normalerweise benutzt, wenn ihr eins benutzt ^^

Wünsche, Kritik usw. sind natürlich auch willkommen.

Gruß, Alex

[Max_der_Held]

seas,
öha, das ist um einiges weiter, als das was ich vor paar Tagen gemacht habe, respekt
Ich wüsste jedenfalls ein paar Anwendungsmöglichkeiten, er erkennt ja scheinbar sogar syntaxfehler?

viel erfolg also
lg
max

[cxAlex]

Ja, auch für solche Graphen - Funktionen kann man es prima einsetzen, wie gesagt, überall wo man eine Berechnung sehr oft braucht.

Ja, das ganze funktioniert so das der ASM - artige Code unten in einen ByteCode übersetzt wird und er da eben Fehler erkennt wie unbekannte Befehle, nicht registrierte Variablen, aufrufe nicht existenter Funktionen. Nur der Übersetzer Normal - "Pseudo Asm" muss noch entwickelt werden um die Rechnungen etwas bequemer zu programmieren, aber sonst ist alles schon recht stabil.

Ah und ACHTUNG: Die Exe oben ist eine 64 - Bit exe, ich hab das gar nicht gemerkt weil ich nur noch 64 Bit progge
32 Bit exe folgt in Kürze!

Gruß, Alex

[Kiffi]

Ich würde mich darüber freuen wenn ihr eure - Speed Resultate posten würdet, vlt auch im vergleich zu dem Eval das ihr normalerweise benutzt, wenn ihr eins benutzt ^^

sollte man damit nicht noch warten, bis der von Dir erwähnte 'Übersetzer' eingebaut wurde?

Grüße ... Kiffi

[cxAlex]

Das ändert nichts mehr am Speed. Der Code wird 1* übersetzt und der Bytecode wird beliebig oft ausgeführt, die Geschwindigkeit des Übersetzers mischt bei der Ausführung nicht mit.

Gruß, Alex

[STARGÅTE]

ganz blöde frage,
Aber wie kommt deine EXE auf :

Rechnung: rt = (4*Sin(r^3)-12^2)/pi
Ergebnis: -44.5769335670

?

wenn r=0 ist, was ich mal annehme, weils nirgends definiert ist, erhalte ich:

-45.836623610465857

Ich würde mich darüber freuen wenn ihr eure - Speed Resultate posten würdet, vlt auch im vergleich zu dem Eval das ihr normalerweise benutzt, wenn ihr eins benutzt ^^

Deiner:

---------------------------
QEval Techdemo
---------------------------
Durchläufe: 1000000
Rechnung: rt = (4*Sin(r^3)-12^2)/pi
Compiler Meldung: No Error
Ergebnis: -44.5769335670
Laufzeit: 844 ms
ms/Durchlauf: 0.0008440000
Code:

Push #12
PowC #2
Push r
PowC #3
Call sin
MulC #4
Sub
DivV pi
Pop rt
---------------------------
OK
---------------------------

Meiner:

---------------------------
Testergebnis
---------------------------
Time: 390
---------------------------
OK
---------------------------

CodeAusschnitt:

Code: Alles auswählen

#Size = 1000000

*TermTree = CreateTermTree("((4*Sin(x^3))-12^2)/PI")

Time = ElapsedMilliseconds()
For n = 1 To #Size
  EvalTermTree(*TermTree)
Next
Time1 = ElapsedMilliseconds()-Time

MessageRequester("Testergebnis", "Time1: "+Str(Time1)+Chr(10)+"Time2: "+Str(Time2))

Also ich werde weiter hin mein Eval nutzen, wenn ich Funktionen Plotten lasse.
Ich verwende zwar kein ASM, aber CreateTermTree() macht mir aus dem String n sehr kurzen Term-Baum den
EvalTermTree() dann zügig berechnet ...
würde ich noch n Simplify mit reinhauen würde er nicht jedesmal 12^2 usw. rechnen, sondern nur einmal und dann 144 benutzen ...

[cxAlex]

Sry, das hab ich nirgends geschrieben, r ist als 2 definiert.

Das mit 12^2 ist natürlich sinnlos, das hab ich nur zum testen drinnen damit der Ausdruck etwas länger wird, das soll auch noch weg optimiert werden in der fertigen Version.

QEval rechnet derzeit auschließlich mit Doubles, daher ist die 64 Bit Version schneller als die 32 Bit, könnte man aber bei Bedarf leicht auf Floats anpassen. Keine Ahnung was für einen Typ dein Eval verwendet.

Gruß, Alex

[Kiffi]

Das ändert nichts mehr am Speed. Der Code wird 1* übersetzt und der Bytecode wird beliebig oft ausgeführt, die Geschwindigkeit des Übersetzers mischt bei der Ausführung nicht mit.

Meines Erachtens muss die Geschwindigkeit des Übersetzers durchaus mit in den
Vergleich eingerechnet werden.

Denn solange die übersetzende Komponente bei Dir nur ein Mal und bei allen anderen
Systemen immer ausgeführt wird, kann kein aussagekräftiger Vergleich die
Geschwindigkeit betreffend gemacht werden.

In der Praxis ist es überdies wenig sinnvoll, ein- und denselben Ausdruck n-mal auszuführen.
Vielmehr würde ich mir den einmal berechneten Wert zwischenspeichern und dann mit diesem
weiter arbeiten.

Grüße ... Kiffi

[cxAlex]

Wieso soll es nicht sinnvoll sein den Ausdruck n - mal auszuführen? Graphen - Funktionen usw, wie bereits gesagt. Wenn sich die Variablen ändern muss der Ausdruck nicht neu übersetzt werden, ich sehe da durchaus Sinn. Und natürlich kann auch das Ergebniss des letzen Durchlaufs im Ausdruck verwendet werden, alles ohne neu zu übersetzen.

Gruß, Alex

[STARGÅTE]

mein Code rechnet auch mit Doubles ...
allerdings kann man bei mir wirklich nur rechnen, und die einzige Variable wäre eine art "X" welches bei Plots immer eingefügt wird ...

weiß ja nicht wie kompliziert dein endgüliger ByteCode / ASM code oder so aussieht.

Da die Übersetzung hier keine Rolle spielt, reict es ja wenn ich dir kurz zeige wie es bei mir aussieht:

Code: Alles auswählen

Procedure.d EvalTermTree(*TermTree.TermTree)
  With *TermTree
    Select \Operator
      ; [...]
      Case #Command_Add
        ProcedureReturn EvalTermTree(\Term1) + EvalTermTree(\Term2)
      ; [...]
      Case #Command_Pow
        ProcedureReturn Pow( EvalTermTree(\Term1) , EvalTermTree(\Term2) )
      ; [...]
      Case #Command_BasicFunction
        Select \Function$
          ; [...]
          Case "SIN" : ProcedureReturn Sin(EvalTermTree(\Term)*AngleMode)
          ; [...]
        EndSelect
      Default 
        ProcedureReturn \Value
    EndSelect
  EndWith
EndProcedure