le compilateur manque de performances dans les boucles !

flaith · Message par **flaith** » sam. 03/janv./2009 19:59

Sous GNU/Linux avec un (vieil) Athlon 1.4 Ghz:

ASM ........... 1948
Semi ASM/PB ... 3052
PB ............ 5142
PB For/Next.... 5491

Ar-S · Message par **Ar-S** » sam. 03/janv./2009 21:26

Avec mon bourrin de Core2Duo E8200 - 2go

impressionnant..

Le psychopathe · Message par **Le psychopathe** » sam. 03/janv./2009 22:23

J'ai voulu restester vu que je viens de formater et reinstaller mon vista mais cela plante ( je suis sous vista 64bits et PB 64).

Backup · Message par **Backup** » dim. 04/janv./2009 1:05

apparemment ya pas photo !!

faudrai ptete en parler a Fred !!

l'Asm est beaucoup plus rapide alors !

Oliv · Message par **Oliv** » dim. 04/janv./2009 11:13

Sur un MacBook d'il y a un an : (1Go de ram, 2.18Ghz je crois)

Code : Tout sélectionner

ASM ........... 469 
Semi ASM/PB ... 1625 
PB ............ 3258 
PB For/Next.... 2859

Ganagyre · Message par **Ganagyre** » sam. 27/juin/2009 12:52

Interressant ces diverse boucles possibles et leur vitesses.

S'il reste "facile" à comprendre le fonctionnement, comment on utilise le code assembleur pour recuperer la valeur incrementé = a ?

Code : Tout sélectionner

;Classique en for next

max = 999999999
a.l = 0

for a= 1 to max
i=a+1
next a

debug i

; mais en ASM on procede comment ?

!PUSH Eax
!PUSH Ebx
!MOV Eax,[v_a]
!MOV Ebx,[v_max]
!LP1:
!INC Eax
!CMP Eax,Ebx
!JNE LP1
!MOV [v_a],Eax
!POP Ebx
!POP Eax

Merci de toute explication

poshu · Message par **poshu** » sam. 27/juin/2009 13:30

Y'aurait moyen d'en faire un zolie macro?

(je comprends RIEN à l'asm, alors patapé si j'ai dit une connerie plus grosse que moi)

zaphod · Message par **zaphod** » sam. 27/juin/2009 14:45

Pour récupérer le compteur dans une variable :

Code : Tout sélectionner

max = 999999999 
Delay(1000) 

;=================================(ASM)============================ 
Delay(1000) 
t.d = ElapsedMilliseconds() 
a.l = 0 
i.l=0
;
!PUSH EAX 
!PUSH EBX 
!MOV EAX,[v_a] 
!MOV EBX,[v_max] 
!LP1: 
!INC EAX 
!CMP EAX,EBX 
!JNE LP1 
!MOV [v_a],EAX 
!mov [v_i],eax ; on recupère le compteur dans i
!POP EBX 
!POP EAX 
S1.d = ElapsedMilliseconds()-t 
Debug i
MessageRequester("ASM",StrD(S1))

Z@ph0d//

Ollivier · Message par **Ollivier** » sam. 27/juin/2009 16:05

Bonjour cher tous, j'ai pris le code de Mytic page 1, et j'ai testé sur mon engin:

Version 4.30 :

ASM : 4375
ASM/PB : 5406
PB : 4375

Version 4.31 :

ASM : 4328
ASM/PB : 5328
PB : 4360

(XP SP3)

Je n'ai pas de commentaire... Si quelqu'un peut m'expliquer où est votre problème, ça m'enlèverait un grain...

Ollivier · Message par **Ollivier** » sam. 27/juin/2009 16:57

Vista (+ double coeur)

ASM 1544
PB/ASM 1607
PB 3807

zaphod · Message par **zaphod** » sam. 27/juin/2009 17:26

sur mon p4 3.06 ht

asm =594
semi = 1328
pb=2000

en desactivant le debuger.

Ollivier · Message par **Ollivier** » sam. 27/juin/2009 19:55

Atomo avait posté un test de boucle multi-thread: ptêt qu'il faudrait relier ces tests avec ces comparatifs chronométrés?

Atomo · Message par **Atomo** » sam. 27/juin/2009 21:09

J'ai testé avec le code de la boucle mutli-threadée, le resultat est encore pire

Apparement, c'est éfficace que dans certaines situations.

djes · Message par **djes** » sam. 27/juin/2009 23:38

Juste pour info, il faudrait que vous sépariez vos codes, car le fait qu'ils soient les uns derrière les autres change la donne. En effet, un code non correctement aligné en mémoire peut être sensiblement plus lent. Exemple (commentez le !nop) :

Code : Tout sélectionner

max = 999999999
Delay(1000)

;=================================(ASM)============================
Delay(1000)
!nop
t.d = ElapsedMilliseconds()
a.l = 0
i.l=0
;
!PUSH EAX
!PUSH EBX
!MOV EAX,[v_a]
!MOV EBX,[v_max]
!LP1:
!INC EAX
!CMP EAX,EBX
!JNE LP1
!MOV [v_a],EAX
!mov [v_i],eax ; on recupère le compteur dans i
!POP EBX
!POP EAX
S1.d = ElapsedMilliseconds()-t
Debug i
MessageRequester("ASM",StrD(S1))

Ganagyre · Message par **Ganagyre** » lun. 29/juin/2009 9:22

Test sur :

XP
Intel Core Duo E6850 3.00 Ghz
4 Go de Ram

ASM________328
Semi ASM___1172
PB_________2344
PB For Next__1922

Z@ph0d, ok pour la recup de la variable en fin de boucle.

Code : Tout sélectionner


max = 999999999
Delay(1000)

;=================================(ASM)============================
Delay(1000)
t.d = ElapsedMilliseconds()
a.l = 0
i.l=0
;
!PUSH EAX
!PUSH EBX
!MOV EAX,[v_a]
!MOV EBX,[v_max]
!LP1:
!INC EAX
!CMP EAX,EBX
!JNE LP1
!MOV [v_a],EAX
!mov [v_i],eax ; on recupère le compteur dans i
!POP EBX
!POP EAX
S1.d = ElapsedMilliseconds()-t
Debug i
MessageRequester("ASM",StrD(S1))

Et si l'on souhaite utiliser la valeur de la variable i pendant l'incrementation , on procede comment ?

Merci de tout explicatif.