Le nouveau Raspberry Pi 2 modèle B est disponible depuis le début de la semaine dernière. Et les distributeurs ont été suffisamment approvisionnés pour pouvoir répondre aux demandes. J’en ai commandé deux exemplaires lundi dernier à l’annonce de sa mise sur le marché, et j’ai été livré dès mardi matin ! L’un des arguments de vente est « 4 à 6 fois plus rapide que le précédent ». C’est le genre de chose qui titille ma curiosité, j’ai voulu vérifier ce qu’il en est…

Comparaison avec le modèle précédent

Très peu de différences externes entre le modèle 2 et le modèle 1 B+. Les connecteurs et les composants actifs se trouvent aux mêmes emplacements, et même le routage des pistes électroniques a peu changé dans l’essentiel.

On remarque néanmoins un nouveau system-on-chip, le Broadcom 2836 au lieu du 2835. Celui-ci intègre un processeur Arm quadri-cœur.

On peut observer également un bloc de mémoire Ram DDR2 situé sur le dessous du Raspberry Pi, alors que dans les précédents modèles la mémoire se trouvait collée directement sous le system-on-chip.

Enfin, la sérigraphie indique le numéro de ce nouveau Raspberry Pi.

Support sous Linux

Je n’ai essayé sur ce nouveau Raspberry Pi 2 que la distribution Raspbian 2015-01-31. Il est nécessaire de prendre la version la plus récente pour que le support du multicœur soit activé dans le noyau.

Voici quelques commandes systèmes permettant d’avoir un aperçu du support par le noyau Linux.

pi@raspberrypi ~ $ uname -a
Linux raspberrypi 3.18.5-v7+ #225 SMP PREEMPT Fri Jan 30 18:53:55 GMT 2015 armv7l GNU/Linux

Le noyau est très récent. C’est la dernière version stable (ah tiens, non, le noyau 3.19 vient de sortir ce matin !).

pi@raspberrypi ~ $ free
             total       used       free     shared    buffers     cached
Mem:        762384      60252     702132          0       8772      22420
-/+ buffers/cache:      29060     733324
Swap:       102396          0     102396

Le système est doté d’un Go de Ram (une partie est réservée par le noyau). Sur le modèle précédent, la même commande donne :

pi@raspberrypi ~ $ free
             total       used       free     shared    buffers     cached
Mem:        445772      50056     395716          0       7192      21108
-/+ buffers/cache:      21756     424016
Swap:       102396          0     102396

Voyons le processeur :

pi@raspberrypi ~ $ lscpu 
Architecture:          armv7l
Byte Order:            Little Endian
CPU(s):                4
On-line CPU(s) list:   0-3
Thread(s) per core:    1
Core(s) per socket:    4
Socket(s):             1
pi@raspberrypi ~ $

Un processeur, avec 4 cœurs physiques indépendants. Voyons, ses possibilités de réglage de la fréquence de fonctionnement.

pi@raspberrypi ~ $ cd /sys/devices/system/cpu/
pi@raspberrypi /sys/devices/system/cpu $ ls
cpu0  cpu1  cpu2  cpu3  cpufreq  cpuidle  kernel_max  offline  online  possible  power  present  uevent

Les quatre cœurs sont bien réglables séparément.

pi@raspberrypi /sys/devices/system/cpu $ cd cpu0/
pi@raspberrypi /sys/devices/system/cpu/cpu0 $ ls
cpufreq  crash_notes  crash_notes_size  online  power  subsystem  topology  uevent
pi@raspberrypi /sys/devices/system/cpu/cpu0 $ cd cpufreq/
pi@raspberrypi /sys/devices/system/cpu/cpu0/cpufreq $ ls
affected_cpus     cpuinfo_max_freq  cpuinfo_transition_latency  scaling_available_frequencies  scaling_cur_freq  scaling_governor  scaling_min_freq
cpuinfo_cur_freq  cpuinfo_min_freq  related_cpus                scaling_available_governors    scaling_driver    scaling_max_freq  scaling_setspeed
pi@raspberrypi /sys/devices/system/cpu/cpu0/cpufreq $ cat scaling_min_freq 
600000
pi@raspberrypi /sys/devices/system/cpu/cpu0/cpufreq $ cat scaling_max_freq
900000
pi@raspberrypi /sys/devices/system/cpu/cpu0/cpufreq $ cat scaling_cur_freq 
600000
pi@raspberrypi /sys/devices/system/cpu/cpu0/cpufreq $ cat scaling_governor
ondemand
pi@raspberrypi /sys/devices/system/cpu/cpu0/cpufreq $

Le réglage étant sur ondemand, la fréquence (actuellement à 600 MHz) évoluera automatiquement pour monter si besoin à 900 MHz.Il est possible de la faire varier manuellement, pour en savoir plus, voir cet article. Avec le précédent modèle, la fréquence était figée à 700MHz.

Il est toujours possible de faire un overclocking du processeur, comme avec le modèle précédent, en utilisant la commande sudo raspi-config. La fréquence CPU pourra alors monter jusqu’à 1GHz. Attention toutefois, il est bien précisé que cela peut réduire la durée de vie du processeur (dans la pratique je n’en suis pas persuadé).

Comparaison de puissance processeur

Il existe de nombreux benchmarks pour évaluer la puissance d’un processeur, mais j’aime bien mener mes propres tests avec des situations représentatives de ce que je fais au quotidien sur les systèmes que j’utilise.

Puissance monocœur

Pour avoir une idée de la puissance de calcul brute d’un CPU, il y a une possibilité très simple : lui demander de calculer des décimales de Pi (le nombre Pi, pas le Raspberry !). C’est extrêmement simple à faire depuis le shell en invoquant la commande bc et en lui demandant d’afficher 4 * a(1). La fonction a() de bc calcule l’arc-tangente. Or arctan(1) = PI/4.
L’intérêt de bc, c’est que l’on peut lui préciser le nombre de décimales désirées dans sa variable scale. Ici je lui en demande 10.000, et j’encadre l’invocation avec la commande date pour connaître sa durée.

pi@raspberrypi ~/rpi-kernel $ date; echo "scale=10000; 4*a(1)" | bc -l; date
Sat Feb  7 00:26:00 UTC 2015
3.141592653589793238462643383279502884197169399375105820974944592307\
81640628620899862803482534211706798214808651328230664709384460955058\
22317253594081284811174502841027019385211055596446229489549303819644\
[...]
83440869735020141020672358502007245225632651341055924019027421624843\
91403599895353945909440704691209140938700126456001623742880210927645\
79310657922955249887275846101264836999892256959688159205600101655256\
375676
Sat Feb  7 00:41:30 UTC 2015

Le calcul a duré 14 minutes et 30 secondes.

Effectuons la même opération sur un Raspberry Pi 1 modèle B+

pi@raspberrypi ~/rpi-kernel $ date; echo "scale=10000; 4*a(1)" | bc -l; date
Sun Feb  8 18:14:43 UTC 2015
3.141592653589793238462643383279502884197169399375105820974944592307\
81640628620899862803482534211706798214808651328230664709384460955058\
22317253594081284811174502841027019385211055596446229489549303819644\
[...]
83440869735020141020672358502007245225632651341055924019027421624843\
91403599895353945909440704691209140938700126456001623742880210927645\
79310657922955249887275846101264836999892256959688159205600101655256\
375676
Sun Feb  8 18:39:03 UTC 2015

Cette fois le calcul a duré 24 minutes et 20 secondes.

Pour un calcul brut monocœur, le Raspberry Pi 2 est 1,66 fois (5 / 3) plus rapide que son prédécesseur. C’est un peu meilleur que le simple rapport des fréquences CPU (900/700).

Puissance multicœur

La grande nouveauté du Raspberry Pi 2 est son aspect multicœur. Ceci peut grandement améliorer les performances lorsque plusieurs opérations doivent s’exécuter simultanément et peuvent être parallélisées. Ma référence en ce domaine est la compilation de gros projets avec un make paralléle (option -j suivie du nombre de jobs simultanés).

Fidèle à mes habitudes, j’ai testé ceci sur une compilation du noyau Linux. Il faut commencer par ajouter deux packages sur la distribution Raspbian.

pi@raspberrypi ~/rpi-kernel $ sudo apt-get install bc libncurses5-dev

Je télécharge les sources du noyau modifié pour Raspberry Pi.

pi@raspberrypi ~ $ date ; git clone http://github.com/raspberrypi/linux rpi-kernel ; date
Fri Feb  6 07:34:24 UTC 2015
Cloning into 'rpi-kernel'...
[...]
Fri Feb  6 08:21:15 UTC 2015

Le téléchargement dure un peu moins d’une heure, le facteur limitant est naturellement le débit réseau global mais également celui du contrôleur Ethernet du Raspberry Pi 2 (LAN 9514 qui n’a pas changé par rapport au modèle précédent). Avec une carte réseau et une liaison ADSL correctes, le transfert est plutôt de 10 à 15 minutes. Je configure la compilation pour un noyau standard pour Raspberry Pi.

pi@raspberrypi ~/rpi-kernel $ make bcmrpi_defconfig

Je lance la compilation en demandant un total permanent de huit jobs en parallèle (c’est une bonne habitude de compter un à deux jobs par cœur).

pi@raspberrypi ~/rpi-kernel $ date ; make -j 8 ; date
Fri Feb  6 22:16:01 UTC 2015
[...]
Sat Feb  7 00:00:56 UTC 2015
pi@raspberrypi ~/rpi-kernel $

La compilation prend 1h45. C’est long, mais il s’agit d’une configuration pour un noyau complet, avec beaucoup d’options activées.

Pour comparaison, je lance la même opération sur le Raspberry Pi 1 modèle B+.

pi@raspberrypi ~/rpi-kernel $ date; make -j2 ; date
Sat Feb  7 21:54:33 UTC 2015
[...]
Sun Feb  8 10:27:53 UTC 2015
pi@raspberrypi ~/rpi-kernel $

12h33 de compilation !

Dans ce cas, en effet le Raspberry Pi 2 a été 7 fois plus rapide que le modèle 1. La différence est due au nombre de cœurs (probablement dans un rapport 4 environ), mais aussi à la différence de mémoire RAM, ce qui influe sensiblement sur les compilations (taille des caches, etc.).

Conclusion

Mon utilisation courante du Raspberry Pi (tests de drivers, bidouilles sur les GPIO, serveurs HTTP, outils de démo pour des applications réseau, etc.) se déroule essentiellement en console texte, avec une connexion sur l’interface série ou par SSH.

Je verrai une différence de rapidité surtout lors de compilations longues qu’il m’arrive de réaliser pour des sessions de formations sur la programmation de drivers Linux.

Pour l’utilisateur qui emploie l’interface graphique du système, on peut espérer également un gain notable car cet environnement pourra alors tirer parti de la parallélisation : le navigateur, le lecteur vidéo, l’environnement graphique proprement dit, les serveurs réseau, etc. pourront s’exécuter sur des cœurs distincts et rendre le système plus fluide.

Commentaires, remarques et retours d’expériences sont les bienvenus.