Raspberry Pi 3 et noyau 64 bits, différences entre armv7 et armv8

Existe-t-il un noyau 64 bits pour Raspberry Pi 3? J'ai regardé autour et à partir de sources, je vérifie la page officielle et les noyaux suivants y sont répertoriés:

1. NOOBS - c'est l'installateur, pas d'OS en soi, non?
2. Rapsbian - juste un téléchargement, donc je suppose 32 bits compatible avec toutes les versions de Pi
3. Ubuntu MATE - aarch32 (ARMv7)
4. Ubuntu Ubuntu Core - ressemble à 32 bits uniquement
5. OSMC - mêmes téléchargements pour "Raspberry Pi 2/3", donc 32 bits
6. LibreELEC - version combinée pour 2 et 3, donc 32 bits uniquement
7. PiNet - ne sais pas ce que c'est, mais doute 64 bits
8. RISC OS - ne ressemble pas à Linux
9. Station météo - oui, juste non

Il ne semble donc pas qu'il existe un noyau 64 bits officiel? Y en a-t-il un non officiel? Puis-je simplement en compiler un et m'attendre à ce qu'il fonctionne (je suppose que non, mais ça ne fait pas de mal de demander ..)? Quelqu'un y travaille-t-il au moins? J'aimerais avoir accès aux numéros 64 bits natifs.

D'un autre côté, quelle est la différence entre armv7 et armv8? Gentoo propose des tarballs de stade 3 pour armv7. Est-ce que cela fonctionnera sur Pi 3 qui est armv8?

D'après le peu que j'ai trouvé, il n'y a rien de stable et officiel. Certains en ont obtenu un à compiler, mais il y a ensuite des problèmes avec les pilotes / modules.

Ces liens peuvent vous intéresser concernant ce sujet.

Entrée dans l'état d'exécution aarch64

Raspbian Jessie (64bit) pour RPi3?

Le consensus général est qu'un noyau 64 bits n'augmentera pas les performances du Pi, car les 2 seuls avantages réels d'un noyau 64 bits sont:

1. des valeurs int plus grandes, que vous pouvez spécifier manuellement dans un noyau 32 bits de toute façon
2. la possibilité d'avoir plus de 4 Go de RAM, ce qui est inutile sur le Pi car la RAM est intégrée et non extensible.

De plus, 64 bits contre 32 bits sur les puces ARM n'est pas le grand saut de performance qu'il était sur les puces x86, car les puces x86 avaient des mises à niveau importantes de l'architecture lorsqu'elles sont passées à 64 bits, tandis que les puces ARM étaient déjà assez solides dans les versions 32 bits.

N'hésitez pas à expérimenter cependant! :)

Un avantage de 64 bits que tout le monde semble oublier est que ARMv8 a beaucoup plus de registres que ARMv7 Il a également de bien meilleures performances en virgule flottante.

Ce n'est pas seulement un module complémentaire à ARMv7, c'est une toute nouvelle architecture.

OpenSUSE a publié son image Raspberry Pi 64 bits.

https://en.opensuse.org/HCL:Raspberry_Pi3

J'ai constaté des gains de performances significatifs de compilations 64 bits par rapport à 32 bits lors de l'exécution de mes tests Android sur une tablette à l'aide d'un ARM Cortex-A53 à 1,3 GHz. Les dernières sont compilées via Eclipse et, au moment de l'exécution, détectent si le CPU est ARM, Intel ou MIPS, puis l'architecture 32 bits ou 64 bits.

Sur les compilations Windows précédentes pour les processeurs Intel, le fonctionnement 64 bits pouvait être beaucoup plus rapide que 32 bits en raison de l'utilisation d'instructions SIMD de type SSE. Cependant, le compilateur 32 bits ultérieur, avec une incompatibilité vers l'arrière, produit pratiquement le même code et une vitesse similaire.

Les détails des benchmarks Android sont les suivants, montrant les résultats 32 bits et 64 bits de l'A53 et via un Cortex-A9 1,2 GHz. À la fin se trouvent quelques listes de codes d'assemblage qui identifient les différentes instructions utilisées. Voici un résumé des résultats.

http://www.roylongbottom.org.uk/android%2064%20bit%20benchmarks.htm#anchorStart

Whetstone Benchmark - (minuscules boucles) performances similaires, avec une note globale influencée par la compilation du test à l'aide des fonctions EXP.

Dhrystone Benchmark - dernier MIPS / MHz 1.09 32 bits, 1.96 64 bits, 1.10 A9 - peut-être 64 bits optimisé.

Linpack Benchmark - (N = 100) 64 bits DP 1,97 x plus rapide, SP 2,67 x - voir code d'assemblage.

Livermore Loops - (24 noyaux) en moyenne 1,5 fois plus rapide, plage de 0,8 à 7,9 fois

Tests de cache et de RAM L1 / L2

MemSpeed ​​- calculs flottants et entiers - gagne des caches 2,2 x, RAM 1,5 x.

BusSpeed ​​- streaming de données entières et lecture en rafale - streaming 2,0 x L1, 1,5 x L2, 1,25 x RAM - rafales 2,6 x L1, L2 et RAM similaires.

RandMem - lecture et lecture / écriture série et aléatoire à partir de la même structure d'indexation complexe - généralement un peu plus rapide à la lecture mais lecture / écriture similaire / plus lente.

Ensuite, il existe des versions MP de ce qui précède et tente de mesurer le maximum SP MFLOPS (MP-MFLOPS) avec un maximum de 4 cœurs de 2,7 GFLOPS 32 bits et 5,5 GFLOPS 64 bits. Il existe également une version utilisant les intrinsèques NEON où le compilateur 64 bits génère des instructions alternatives jusqu'à 10,8 GFLOPS contre 5,7 à 32 bits - voir la liste des assembleurs. J'ai également des versions de ces benchmarks pour Windows 10 et les tablettes basées sur Intel Intel Atom - Windows 64 bits et 32 ​​bits, Android 32 bits - 64 bits complets pas complètement implémentés - Noyau Linux 64 bits mais Android 32 bits.

http://www.roylongbottom.org.uk/android%20benchmarks.htm

De plus, j'ai des versions Linux / Intel 32 bits et 64 bits.

Roy Londubat

Voici comment je compile le noyau RPI3 Aarch64:

Tout d'abord, vous aurez besoin de Linaro aarch64: https://releases.linaro.org/components/toolchain/binaries/latest/aarch64-linux-gnu/gcc-linaro-6.2.1-2016.11-x86_64_aarch64-linux-gnu.tar .xz

Décompressez, placez-le quelque part, exemple: /opt/toolchains/gcc-linaro-6.2.1-2016.11-x86_64_aarch64-linux-gnu

Voici mon script pour télécharger le firmware, le VC, la source du noyau et compiler le noyau avec les modules, j'utilise ce script pour mon serveur Jenkins, alors choisissez ce dont vous avez besoin:

git clone https://github.com/raspberrypi/linux.git -b rpi-4.8.y --depth=1
cd linux
export CROSS_COMPILE=/opt/toolchains/gcc-linaro-6.2.1-2016.11-x86_64_aarch64-linux-gnu/bin/aarch64-linux-gnu-
export ARCH=arm64
export INSTALL_MOD_PATH=MODULES/
export KERNEL=kernel8

rm -rf BOOT
rm -rf MODULES
rm -rf rpi-proprietary/

mkdir -p BOOT/overlays
mkdir MODULES

git clone https://github.com/Hexxeh/rpi-firmware.git --depth=1 rpi-proprietary/

cp ./rpi-proprietary/COPYING.linux ./BOOT/
cp ./rpi-proprietary/LICENCE.broadcom ./BOOT/
cp ./rpi-proprietary/bootcode.bin ./BOOT/
cp ./rpi-proprietary/fixup.dat ./BOOT/
cp ./rpi-proprietary/fixup_cd.dat ./BOOT/
cp ./rpi-proprietary/fixup_db.dat ./BOOT/
cp ./rpi-proprietary/fixup_x.dat ./BOOT/
cp ./rpi-proprietary/start.elf ./BOOT/
cp ./rpi-proprietary/start_cd.elf ./BOOT/
cp ./rpi-proprietary/start_db.elf ./BOOT/
cp ./rpi-proprietary/start_x.elf ./BOOT/

cd ./rpi-proprietary/vc/hardfp/opt/

tar -cvzf VC.tar.gz vc/

cd ../../../../
mv ./rpi-proprietary/vc/hardfp/opt/VC.tar.gz ./
rm -rf rpi-proprietary/

make bcmrpi3_defconfig
make modules
make module_install
make -j10

rm -rf MODULES/lib/modules/*v8*/build MODULES/lib/modules/*v8*/source

cp ./arch/arm64/boot/Image ./BOOT/kernel8.img
cp ./arch/arm64/boot/dts/broadcom/*.dtb ./BOOT/
cp ./arch/arm64/boot/dts/overlays/*.dtbo ./BOOT/overlays/
cp ./arch/arm64/boot/dts/overlays/README ./BOOT/overlays/

tar -cvzf MODULES.tar.gz MODULES/
tar -cvzf BOOT.tar.gz BOOT/

make mrproper

Maintenant, décompressez simplement BOOT.tar.gz et placez-le sur votre carte SD.

IMPORTANT : vous devez mettre arm_control = 0x200 dans config.txt pour qu'il démarre le noyau AARCH64

Ou vous pouvez simplement utiliser mon préconfiguré sur mon Jenkins: https://jenkins.sandpox.org/job/RPI3_KERNEL_AARCH64/

À ce jour, il semble que Fedora et Archlinux soient bien pris en charge.

Si vous suivez la voie Arch, cela vous aidera à construire l'image (pour moi sur linux / rpi3, c'était le cas make linux) et cela vous aidera à démarrer le wifi.

Dans le cas où vous devez être sûr de la framboise que vous avez, utilisez ce guide .

Aussi arm_control=0x200est obsolète et arm_64bitdoit être utilisé à la place dans /boot/config.txt.