PureBasic

Quelqu'un a déjà utilisé la chose ?

Optimizer

How does this program work:
The new FAsm.exe represents the optimizer. The PB compiler calls it with the FAsm parameters. Now, it optimizes the PureBasic.asm and then calls the real FAsm (FAsm2.exe).

Results (for an unrealistic, good example (you can find it in the German forums)):
without Opt.: 5078ms (PB) versus 2453ms (Asm)
with Opt.: 2542ms versus 2532

bon , je vais me lancer

ok je viens de dézipper la chose , ça semble intéressant

#####################################################################
########################### Optimizations ###########################
#####################################################################
© Copyright by Remi Meier
02.07.2005
Website: http://www.remimeier.ch.vu
#####################################################################

#### Cutting out unused procedures
Not all, but a lot of unused procedures will be removed from the ASM
source.

#### CDQ
Replaced by
MOV Edx, Eax
SAR Edx, 31
cause it is pipeable (chance for parallel processing of commands)

#### Remove CALLs of some PB procedures
The listed PB-Functions are replaced by their equivalent ASM code:
- PokeF()
- PeekF()
- PokeL()
- PeekL()
- PokeW()
- PeekW()
- PokeB()
- PeekB()
- CallFunctionFast()
- Red()
- Green()
- Blue()
- RGB()

#### IMUL replaced by faster code
A lot of multiplications will be replaced by faster code like:
Mul0011:
LEA ebx,[eax+eax*8]
ADD eax,eax
ADD eax,ebx

#### Subtracting of -Values
Ex:
MOV Edi,dword [v_n]
NEG Edi
SUB Ebx,Edi
->
ADD Ebx, Edi

#### Unneeded MOVs and PUSHs
MOV Ebx,dword [v_i2]
PUSH dword [v_e]
MOV Eax,Ebx
POP Ebx
->
MOV Eax,dword [v_i2]
MOV Ebx,dword [v_e]

#### Exchanging values of variables with use of a third
PUSH dword [v_a]
POP dword [v_c]
PUSH dword [v_b]
POP dword [v_a]
PUSH dword [v_c]
POP dword [v_b]
->
MOV eax,dword [v_a]
MOV ebx,dword [v_b]
MOV dword [v_b],eax
MOV dword [v_a],ebx
MOV dword [v_c],eax

#### Modulo with 2^n values like VAR % 64
MOV Ebx,dword [v_a]
MOV Eax,Ebx
MOV Ebx,2
CDQ
IDIV Ebx
MOV Ebx,Edx
MOV dword [v_b],Ebx
->
MOV eax,dword [v_a]
AND eax,1
MOV dword [v_b],eax

© Copyright by Remi Meier
02.07.2005
Website: http://www.remimeier.ch.vu

Effectivement, c'est plutôt interessant, c'est une sorte de compilateur fonctionnant en 2 passes.
Programme à suivre

Traduction : QQun pourrait m'expliquer à quoi ca sert ?

Bah c'est le même interêt qu'un compilateur en 2 passes : ce n'est pas indispensable mais ca peut servir dans certains cas, pour optimiser quelques blocs d'instructions ça et la, enlever des redondances, épurer le code, gagner quelques cycles ça et la, c'est toujours ça de pris

J'ai vu El Chroni dans les crédits .
et ça me fait penser , mais alors avec cet optimizer , Tailbite va utiliser quel fichier asm ? celui généré par l'optimiseur ?

Ca semble interessant

Ca donne quoi tes tests Comtois ?

j'ai pas fait de chono encore

déjà mes progs ne plantent pas cet optimizer ,c'est une bonne chose .
Donc à suivre ...

Je vais essayer ça avec les fonctions de ma librairie effect pour les rotations d'images, on verra de suite la différence (juste la procedure copié dans un nouveau code, sans passer par TailBite).
Le code de la lib ayant été optimisé de manière assez poussé (avec inclusion d'asm), on verra bien le gain entre ce qu'on arrive à faire et ce qu'ajoute cet optimizer. Je pense que ce sera un bon test.

Ca marche également aveec TailBite ?

avec TailBite c'est la question que je me pose.

Si tailbite fonctionne avec l'optimizer , je vais refaire ma lib matrix , il n'y a que des peek et des poke dedans:)

Sinon ce serait intéressant de connaitre le résultat de tes tests

J'admais ne pas bien saisire comment ça marche...

Le principe d'optimisation en dernière passe est tout simple :

Par exemple, tous les Pokex() sont remplacés par l'équivalent ASM. Ce qui ne change rien au rendu du code, mais celà change une chose quand aux perfs.

En effet lorsqu'on fait un PokeL(Address, Value), celà est traduit dans un programme principal en :

! PUSH dword [v_Value]
! MOV eax,dword [v_Address]
! CALL PB_PokeL

Or le PB_PokeL lui_même opère une sauvegarde des registres avec restauration à la sortie avant de rendre la main.

Si à la place on pose systématiquement :

! MOV eax, dword [v_Address]
! MOV ebx, dword [v_Value]
! MOV [eax], ebx

on effectue le même travail en trois instructions machine.

Le travail de l'Optimizer est de ce niveau.

Pourquoi Fred ne l'incluerait-il pas dans els prochaines versions ?

Effectivement, c'est intéressant de proposer des commandes pour débutant comme les peek/poke mais il est dommage que ce soit de vraies fonctions...

Dri

Bon, et bien je vais vous décevoir, pour ma lib effect, sur la rotation d'image avec un angle quelconque et avec antialiazing, le gain est de 0

Comme quoi, soit on des pros de l'optimisation, soit c'est pas terrible terrible, cet optimizer

j'ai également essayé avec mon programme "loupe" que vous retrouverez sur le forum.
Le prog ayant des opération mathématiques complexe sans aucune optimisation ASM
Et la aussi, le gain est de 0

Bref, je ne suis pas convaincu du tout

effectivement , il doit falloir pas mal de commandes prises en compte par l'optimizer pour voir une différence et encore.

dans l'exemple joint à l'optimizer :
Sans Optimizer j'obtiens un peu plus de 25 secondes
Avec Optimizer j'obtiens un peu plus de 24 secondes
en gros , je gagne une seconde ( 4%).
C'est pas flagrant .

Souhaitons que Fred saura faire encore mieux avec la V4

Code : Tout sélectionner

a = 5
b = 6
c = 7
D = 3
e = 1
zahl = 1
i2 = 1
e = 1
c = 5
#N = 49999999
z.l
Delay(1000)

time1 = ElapsedMilliseconds()
For z = 1 To #N
    ;{ Integer
    c - a / D
    c = a % 2
    a % 2
    a = b * 3
    a * 5
    zahl = i2/e
    zahl = -i2 - -c
    zahl * 576
    zahl * 2005
    zahl * 10
    zahl * 20
    zahl * 36
    zahl * 1399
    zahl * 417
    zahl * 427
    PeekL(@c)
    PokeL(@c,2)
    Red(c)
    Green(c)
    Blue(c)
    RGB(a,b,c)
    PeekB(@c)
    PokeB(@c, 2)
    PeekW(@c)
    PokeW(@c,23)
    PeekF(@c)
    PokeF(@c, 2.0)
    ; Austausch von Variablenwerten
    a = b
    b = c
    c = a
    
    ;}
    
Next
time1 = ElapsedMilliseconds() - time1

MessageRequester(Str(zahl), Str(time1))

PureBasic

Optimizer version: 1.2

Optimizer version: 1.2