Le P4, quelle belle machine ! - Page 1

J'ai un programme de bench:

Grosso modo:

cycle = (cpuid(), rdtsc()); ma_func (); cycle = (cpuid(), rdtsc()) - cycle; 

Sur P4, une boucle vide (ma_func() = rien) est plus lente qu'un appel de fonction complexe (addition de deux flottants multiprecisons) !!!!!!!!!!!!!!!!!!

Quelle belle machine !
(Boucle vide: 540 cycles, contre 500 pour l'autre)...

c'est pas ton compilo qui merde ? il ressemble à quoi l'asm donné ?

Le P4, belle machine!

./1 enfin, ça m'étonnerait que tu n'ais pas déjà un peu regardé ça

Vide:

.L100:
#APP
        cpuid 
        .byte 0x0f, 0x31
#NO_APP
        movl    %eax, -168(%ebp)
        movl    %edx, -164(%ebp)
#APP
        cpuid 
        .byte 0x0f, 0x31
#NO_APP
        movl    -168(%ebp), %ecx
        subl    %ecx, %eax
        movl    -164(%ebp), %ebx
        sbbl    %ebx, %edx
        subl    -176(%ebp), %eax
        sbbl    -172(%ebp), %edx
        movl    %eax, -168(%ebp)
        movl    %edx, -164(%ebp)
        movl    -168(%ebp), %ecx
        movl    -164(%ebp), %ebx

Appel:

#APP
        cpuid 
        .byte 0x0f, 0x31
#NO_APP
        movl    %eax, -168(%ebp)
        movl    %edx, -164(%ebp)
        leal    -120(%ebp), %edx
        pushl   %eax
        pushl   %edx
        leal    -104(%ebp), %eax
        pushl   %eax
        leal    -88(%ebp), %edx
        pushl   %edx
        call    __gmpf_add
        addl    $16, %esp
#APP
        cpuid 
        .byte 0x0f, 0x31
#NO_APP
        movl    -168(%ebp), %ecx
        subl    %ecx, %eax
        movl    -164(%ebp), %ebx
        sbbl    %ebx, %edx
        subl    overhead, %eax
        sbbl    overhead+4, %edx
        movl    %eax, -168(%ebp)
        movl    %edx, -164(%ebp)
        movl    -168(%ebp), %ecx
        movl    -164(%ebp), %ebx
        movl    -160(%ebp), %eax
        movl    -156(%ebp), %edx

Problème d'alignement ?

En tout cas je ne me fierais pas à des bench sur un faible nombre d'instructions...

>Problème d'alignement ?
t'en as d'autres des comme ca ?

>En tout cas je ne me fierais pas à des bench sur un faible nombre d'instructions...
rdtsc est cense etre fiable sur un faible nombre d'instructions (c'est le but de l'instruction !).

elle se serait pas fait interrompre ?

PpHd :
>Problème d'alignement ?
t'en as d'autres des comme ca ?

Bah je connais pas cpuid en détail, mais ça pourrait éventuellement nécessiter le vidage de cache de décodage ou une connerie comme ça...

>En tout cas je ne me fierais pas à des bench sur un faible nombre d'instructions... rdtsc est cense etre fiable sur un faible nombre d'instructions (c'est le but de l'instruction !).

Oué, je connais pas les specs. Comment ça interagit avec le multitâche sur les différents OS ?

>Bah je connais pas cpuid en détail, mais ça pourrait éventuellement nécessiter le vidage de cache de décodage ou une connerie comme ça...
cpuid a pour consequence de flusher le pipeline (c'est le but)
Mais au point qu'une boucle vide soit plus lente qu'une fonction...

>Comment ça interagit avec le multitâche sur les différents OS ?
Les OS l'autorise, et ca compte le # de cycles depuis le debut de l'allumage de l'ordi.

Et oui, j'ai bien tenu compte des interruptions potentielles : y'a un filtre derriere.

Les resultats:

Athlon (cycles min / moy / max):
 MPF:::::::::::: 64 / 64.00 / 64 <-- vide
 add: 170 / 191.01 / 206
 sub: 175 / 193.73 / 211
 mul: 195 / 195.00 / 195
 div: 327 / 360.43 / 424
 sqrt: 811 / 978.70 / 1197
 cmp: 64 / 64.00 / 64
 set: 101 / 101.00 / 101
 set0: 73 / 73.08 / 74
 set1: 96 / 96.00 / 96
 swap: 87 / 87.00 / 87
P4 (cycles min / moy / max) :
 MPF:::::::::::: 540 / 540.00 / 540 <--vide
 add: 496 / 506.44 / 520
 sub: 492 / 495.84 / 504
 mul: 728 / 732.44 / 736
 div: 944 / 1010.48 / 1128
 sqrt: 1448 / 1764.44 / 2184
 cmp: 540 / 540.00 / 540
 set: 588 / 588.00 / 588
 set0: 396 / 396.32 / 400
 set1: 392 / 392.00 / 392

La mesure:

#define NUM_TRY 4327
#define MEASURE(TEST) \
  ({ \
  volatile unsigned long long int num_cycle, min_num_cycle; \
  int i_; \
  min_num_cycle = 0xFFFFFFFFFFFFFFFFLL; \
  for(i_ = 0 ; i_ < NUM_TRY ; i_++) \
    { \
          num_cycle = rdtsc(); \
          TEST; \
          num_cycle = rdtsc() - num_cycle - overhead; \
      if (num_cycle < min_num_cycle) \
        min_num_cycle = num_cycle; \
    } \
  min_num_cycle; })

J'oublaiis: overhead vaut tout le temps 0 dans ce test.

Le P4, belle machine!

et sur athlon, ça donne quoi ?

Ben j'ai donne les resultats sur athlon aussi.

merde, je sais plus lire maintenant

Mais sinon,
Le P4, belle machine!

on comprend pourquoi ils ont besoin de monter en fréquence, chez Intel ...

Comme la Graph 100, le P4 est une belle machine !

Vraiment une machine magnifique, ce P4 !!

et hop, remontage d'un topic d'actualité enterré

Le P4, belle machine!!

Le P4, quelle belle machine !

Athlon powa

!slap croustx
• Hippopotame slaps croustx around a bit with a large trout !


Quelle belle machine, le P4!!!

Quelle belle machine l'Athlon!!!

!slap croustx
• Hippopotame slaps croustx around a bit with a large trout !


Le P4, belle machine!!

!slap Hippopotamu
• Thomas slaps Hippopotamu around a bit with a large trout !


L'Athlon, belle machine!!

!slap croustx
• flanker slaps croustx around a bit with a large trout !

le P4, quelle belle machine