test CPU

[invite2562e666]

Bonjour,

Je viens de tomber sur un petit test (c'est assez rare) de CPU de microcontrôleurs réalisés sur un bout de code C par Atmel: http://www.atmel.com/dyn/resources/p...ts/doc7926.pdf

Il s'agit de tester le code suivant (page 3 du document):

int max(int *array)
{
char a;
int maximum=-32768;
for (a=0;a<16;a++)
if (array[a]>maximum)
maximum=array[a];
return (maximum);
}

Et j'ai mis dans mon main.c le code suivant, avec deux breakpoints devant les « asm(NOP) »:

void main(void) {
int test;
int array[17]={
-1000, 23456, 12, 22, 8888, 222, 6942, -333,
 288, 16, 0, 22255, 2255, 67, 25, 31000  };
 
  EnableInterrupts; /* enable interrupts */

   for(;;) {
    __RESET_WATCHDOG(); /* feeds the dog */
    
    asm(nop);
            test=max(array);
            asm (nop); 
    
  } /* loop forever */
 }

En ne modifiant pas les options standard de compilation , j'ai fait ce test (en simulation) sur un 9S08 et sur un MCF51 (IDE CodeWarrior).

Sur un MC9S08QE64 (cpu 8 bit, 64ko flash):
Taille du code en flash : 49 octets
Nombre de cycles (entre les deux breakpoints) : 926 cycles ( ou 653 cycles en plaçant les variables en « page 0 » : 256 premiers octets de la RAM )
soit à la vitesse nominale du processeur : 20Mhz : 46,3 µsec (32,7 µsec)
Coût du processeur MC9S08QE64 (farnell.fr, mai 2008): 5,56€ (hors taxes)

Sur un MCF51QE64 (bas de gamme 32 bits, 100% compatible MC9S08QE64)
Taille du code en flash : 31 octets
Nombre de cycles : 219 cycles
soit à la vitesse nominale du processeur : 20Mhz : 11 µsec
Coût du processeur MCF51QE64 (farnell.fr, mai 2008): 5,66€ (hors taxes)

Je suis bien conscient qu'il s'agit d'un cas particulier avec des int (donc pas besoin de répondre par des considérations philosophiques), et qu'il ne faut pas en tirer de conclusion générale mais je serais intéressé si des gens pouvaient compléter ces résultats par d'autres processeurs (AVR, PIC16, PIC18, MSP430, ARM, ...) par des test réalisés par eux (non des chiffres trouvés dans la littérature et/ou calculs/extrapolations) dans la même gamme de prix et/ou aussi proposer d'autres tests.

thierry
-----

[jiherve]

Bonjour
Des test ils en existe des milliers, dont les résultats ne sont généralement pas simples à interpréter. Même ton petit test peut fournir des résultats ininterprétables si l'on ne connait pas l'environement du processeur.
Bien souvent dans les data sheet il s'agit de MIPS musicales.
En plus selon qu'il y a breakpoint ou pas la durée peut varier.
Le chemin qui même à la vérité est tortueux!
JR

[invite2562e666]

Bonsoir,

Pas de volontaires pour ce petit test, HULK ?

thierry

[freepicbasic]

quelques remarques ;

Le test est un test de rapidité simplement.
La qualité va dépendre du compilateur en partie.
Si l'on prend le nombre de cycles 926 et un pic à 20mhz soit 5 instuctions par µs, On obtient 926 / 5 = 185.2 cycle.
à priori donc inutile de faire un test de vitesse la lecture des datasheets suffis.

Il faudrait le code asm pour le traduire en asm pic.
Pour voir si le code est plus long ou plus court en Microchip.

[A voir en vidéo sur Futura]

[invite2562e666]

Bonjour, Freepicbasic

Le résultat va bien sûr dépendre du compilateur mais aussi du jeu d'instructions.
La taille du code généré est aussi intéressante.
Je ne comprends pas ton calcul 926/5 : 926 est un nombre de cycles (pas d'instructions) HC08 et 5 est le nombre d'instructions par µsec. Et le chiffre 926 dépend du jeu d'instruction spécifique au cpu. Pour un pic 16, le document Atmel chiffre 2492.

C'est pour cela que ça autrait été intéressant de refaire ce test sur d'autres CPU:
C18 pour pic18, CSS (ou autre pour pic 16), etc, etc

thierry

PS: je veux bien mettre le code asm si cela peut aider.

[freepicbasic]

Bonjour, Freepicbasic
Je ne comprends pas ton calcul 926/5 : 926 est un nombre de cycles (pas d'instructions) HC08 et 5 est le nombre d'instructions par µsec. Et le chiffre 926 dépend du jeu d'instruction spécifique au cpu. Pour un pic 16, le document Atmel chiffre 2492.

Bien sur c'est pourquoi , je dis qu'il faut traduire le source asm.
Pour faire un test le plus sérieux possible et avoir un code le plus équivalent possible.
A moins d'avoir le même compilo sur les 2 marques ... pas évident

Mon estimation est purement pifométrique et simplifiée , j'estime le plus significatif ,mais elle dit tout simplement que l'Atmel est plus rapide , c'est tout, mais là rien de bien mystérieux de dévoiler.

Si l'on veut faire une vrai comparaison , il faut faire une batterie de tests comme pour les PC.

[invite2562e666]

Voilà le code asm
Pour le MC9S08QE64

  0000 89       [2]             PSHX  
  0001 8b       [2]             PSHH  
  0002 a7fd     [2]             AIS   #-3
    6:  char a;
    7:  int maximum=-32768;
  0004 458000   [3]             LDHX  #-32768
  0007 9eff02   [5]             STHX  2,SP
    8:  for (a=0;a<16;a++)
  000a 95       [2]             TSX   
  000b 7f       [4]             CLR   ,X
  000c          LC:     
    9:  if (array[a]>maximum)
  000c f6       [3]             LDA   ,X
  000d 48       [1]             LSLA  
  000e 5f       [1]             CLRX  
  000f 59       [1]             ROLX  
  0010 9eeb05   [4]             ADD   5,SP
  0013 87       [2]             PSHA  
  0014 9f       [1]             TXA   
  0015 95       [2]             TSX   
  0016 e904     [3]             ADC   4,X
  0018 87       [2]             PSHA  
  0019 8a       [3]             PULH  
  001a 88       [3]             PULX  
  001b 9eae     [5]             LDHX  ,X
  001d 9ef302   [6]             CPHX  2,SP
  0020 9303     [3]             BLE   L25 ;abs = 0025
   10:  maximum=array[a];
  0022 9eff02   [5]             STHX  2,SP
  0025          L25:    
  0025 95       [2]             TSX   
  0026 7c       [4]             INC   ,X
  0027 f6       [3]             LDA   ,X
  0028 a110     [2]             CMP   #16
  002a 25e0     [3]             BCS   LC ;abs = 000c
   11:  return (maximum);
  002c 9efe02   [5]             LDHX  2,SP
   12:  }
  002f a705     [2]             AIS   #5
  0031 81       [6]             RTS

et pour le MCF51QE64

;    4: int max(int *array) 
;    5: { 
;    6: char a; 
;    7: int maximum=-32768; 
;
0x00000000                    _max:
;                             max:
0x00000000  0x717C8000               mvs.w    #-32768,d0
;
;    8: for (a=0;a<16;a++) 
;
0x00000004  0x4202                   clr.b    d2
0x00000006  0x6010                   bra.s    *+18                  ; 0x00000018
;
;    9: if (array[a]>maximum) 
;
0x00000008  0x1202                   move.b   d2,d1
0x0000000A  0x49C1                   extb.l   d1
0x0000000C  0x22301C00               move.l   (a0,d1.l*4),d1
0x00000010  0xB081                   cmp.l    d1,d0
0x00000012  0x6C02                   bge.s    *+4                   ; 0x00000016
;
;   10: maximum=array[a]; 
;   11: return (maximum); 
;
0x00000014  0x2001                   move.l   d1,d0
0x00000016  0x5282                   addq.l   #1,d2
0x00000018  0x0C020010               cmpi.b   #16,d2                ; '.'
0x0000001C  0x6DEA                   blt.s    *-20                  ; 0x00000008
;
;   12: } 
;
0x0000001E  0x4E75                   rts

Mais je ne crois pas que tu pourras en faire grand chose

thierry

[jiherve]

Bonjour
Ce qui est évident du premier coup d'oeuil c'est que d'un coté on a une UC primitive 8 bits et de l'autre une machine plus évoluée 16bits.
Les comparaisons sont alors un peu spécieuses.
Il est intérressant de noter que pour le proc Freescale le code est très proche de celui d'un PPC on pourrait alors le faire tourner à 1GHz ou plus.
JR

[invite2562e666]

Bonjour
Ce qui est évident du premier coup d'oeuil c'est que d'un coté on a une UC primitive 8 bits et de l'autre une machine plus évoluée 16bits.
Les comparaisons sont alors un peu spécieuses.
Il est intérressant de noter que pour le proc Freescale le code est très proche de celui d'un PPC on pourrait alors le faire tourner à 1GHz ou plus.
JR

Oui, et je n'ai jamais dit le contraire.
Mais dans les 2 cas il s'agit de µC à 5 euros utilisés dans des montages (simples) amateur.
Ce n'est pas un test de pentium ou PPC
th

[jiherve]

Re
Pour la bricole la différence se fait beaucoup plus sur la disponibilité gratuite des outils de développement et de programmation, la performance de l'UC est souvent secondaire, elle est à mon avis moins critique que la palette d'interfaces disponibles ou bien même que le type de boitier.
JR

[freepicbasic]

J'ai chargé le datasheet du MC9S08QE64.

La différence fondamentale des 2 µp ,
Microchip est RISC et
Atmel ne l'est pas.



Une première mauvaise surprise ,les instructions semblent différentes de l'Atmel bas de gamme sauf les instructions vraiment de base comme ADC ADD. (Mais je ne suis spécialiste.)
La RAM est au moins 20 fois plus grande que le Pic16F876 , l'eeprom 16 fois , on est pas dans la même gamme de produits.
Il faut toutefois appliquer un coefficient pour l'EEPROM les codes Atmel étant plus long.
Pour la Ram aucune comparaison Atmel est bien plus confortable.
Et le langage C sera bien à l'aise avec cette structure.
Pour le Pic l'assembleur semble incontournable.

Le mode relatif n'existe pas en pic.
L'adressage indirect est limité à seulement 256 (8 bits) sur pic et sur 16 bits sur ce µc
Donc le même prog (dans la mesure du possible évidemment) sera plus long en PIC.

Les cycles d'exécutions pour les instructions varie de 1 à 8 , avec 4 pour une majorité , on peut donc estimer "pifomètriquement" que l'on divise par 4 en moyenne la fréquence d'horloge , ce qui comparé au pic revient au même.
Les boitiers sont PLCC ou QFP avec 80 ou 40 pins pas de DIL ou CMS.
Donc là, une différence d'utilisation flagrante.
Pouvant déterminer une décision.
Les versions miniatures pic seront plus adaptés aux petites applications et les AMD plus adaptés aux applications qui ont plus d'IO.
Pour un programme orienté contrôle de bit , il n'est pas sur que l'Atmel soit meilleur vu le nombre de cycles nécessaires aux tests.
Pour un programme orienté calculs et traitement de données Atmel est forcément meilleur.

Si le but est de comparer ce µc avec des pic16F , vu que les prix sont comparables , au delà du fait que le choix de base demande un investissement en temps et études qui de toute façon penchera de façon fatidique pour l'un ou l'autre.


En résumé;
Le choix devrait dépendre de l'application ;
Petite en taille , PCB simple et faible en ressources ; le pic.
Plus d'I/O et de calculs et manipulations de données l'Atmel.

Pour le portage du code asm l'Atmel devrait avoir un avantage de vitesse pour cette exemple prècis. Car l'utilisation d'un int16 le favorise.
Un exemple bien choisit de manipulation de bits sur un port favorisera le pic.

Donc je comprend que le Pic moins puissant rivalisent avec les Atmel.
Une Ferrari dans Paris , ne va pas forcément plus vite qu'un scooter.

[invite2562e666]

Non,

Ce code est compilé exactement de la même manière sur un MC9S08QG8 en TSOP 16 pattes (5mmx5mm) ou en DIP 8 pins. Le CPU 9S08 est rigoureusement identique.

Je tentais simplement d'obtenir un chiffre en µsec pour une petite routine en C de traitement de données sur un µC 8 bits. Il n'y a pas de considération "d'application" dans ce test.

Il semble que cela ne soit pas possible.

thierry

[DavidDB]

Salut,

Une fois de plus tu ramènes la puissance d'un µC simplement sur base de sa vitesse d'exécution...
Cela te fait une belle jambe si ton micro préféré exécute cette routine en 50µSec mais n'envoie le résultat par l'UART que toutes les 100mSec et le reste du temps il ne fait qu'attendre (évidement ce n'est qu'un exemple parmis des milliers )...

Mais bon, voici le résultat que tu souhaites sous MikroC (en incluant l'appel et la sortie complète de la routine) :

Pour un 12F, c'est 68 octets de mémoire et 761 cycles pour exécuter la routine "max".

Pour un 16F, c'est 68 octets de mémoire et 761 cycles pour exécuter la routine "max".

Pour un 18F, c'est 74 octets de mémoire et 769 cycles pour exécuter la routine "max".

Au final, on est très loin des chiffres annoncés par Atmel...

j'ajoute aussi que si je devais faire cette routine en Assembleur (qui sort du tableau sa plus grande valeur, si j'ai compris) on serait très très loin des chiffres sortis du compilo...
Mais, cette différence serait identique peu importe la marque et le type de µC.

David.

[invite2562e666]

Merci pour ces résultats, tes commentaires d'introduction n'étaient cependant pas indispensables.
Tu as ces valeurs pour C18 ?


th

[DavidDB]

Commentaire malheureusement indispensable étant donné que seule la vitesse d'exécution ne signifie rien!

Sinon, pas de valeur sous C18, C30 ou C32, car pas installé sur la machine où je réside pour le moment...

J'ajouterais, que si l'on utilise le même temps d'exécution d'un cycle en choisissant le quartz adéquat suivant le µC, un tout petit 12F fera au moins aussi bien qu'un 9S08 (voir même mieux, vu qu'il s'agit d'un test sans toucher à la config du compilo)...

Evidemment, si on travaille à la fréquence de cycle maximale du 9S08, il est évident qu'il écrase le 12F, étant donné que le 9S08 peut avoir un cycle de 50nS!

David.