Raspberry Pi 3 e kernel de 64 bits, diferenças entre armv7 e armv8

Existe algum kernel de 64 bits para o Raspberry Pi 3? Olhei em volta e de fontes, verifico a página oficial e os seguintes kernels estão listados lá:

1. NOOBS - este é o instalador, nenhum sistema operacional por si só, certo?
2. Rapsbian - apenas um download, então eu assumo que 32 bits são compatíveis com todas as versões do Pi
3. Ubuntu MATE - aarch32 (ARMv7)
4. Ubuntu Ubuntu Core - parece apenas 32 bits
5. OSMC - mesmos downloads para "Raspberry Pi 2/3", então 32 bits
6. LibreELEC - compilação combinada para 2 e 3, portanto, apenas 32 bits
7. PiNet - não sei o que é isso, mas duvide de 64 bits
8. OS RISC - não parece Linux
9. Estação meteorológica - sim, apenas não

Portanto, não parece que haja um kernel oficial de 64 bits disponível? Existe algum não oficial? Posso apenas compilar um e esperar que funcione (acho que não, mas não custa perguntar ..)? Alguém pelo menos trabalha nisso? Eu adoraria ter acesso a números nativos de 64 bits.

Por outro lado, qual a diferença entre armv7 e armv8? O Gentoo oferece tarballs do estágio 3 para o armv7. Isso funcionará no Pi 3, que é armv8?

Pelo pouco que encontrei, não há nada estável e oficial. Alguns conseguiram um para compilar, mas há problemas com drivers / módulos.

Esses links podem lhe interessar em relação a este tópico.

Entrando no estado de execução aarch64

Raspbian Jessie (64 bits) para RPi3?

O consenso geral é que um kernel de 64 bits não aumentará o desempenho no Pi, pois os únicos 2 benefícios reais de um kernel de 64 bits são:

1. valores int maiores, que você pode especificar manualmente em um kernel de 32 bits de qualquer maneira
2. a possibilidade de ter mais de 4 Gb de RAM, o que é inútil no Pi, pois a RAM é interna e não expansível.

Além disso, 64 bits vs 32 bits nos chips ARM não é o grande salto de desempenho que ocorreu nos chips x86, porque os chips x86 tiveram atualizações significativas na arquitetura quando foram para os 64 bits, enquanto os chips ARM já eram bastante sólidos nas versões de 32 bits.

Sinta-se livre para experimentar! :)

Um benefício de 64 bits que todo mundo parece esquecer é que o ARMv8 possui um número significativamente maior de registros do que o ARMv7. Ele também tem um desempenho muito melhor de ponto flutuante.

Não é apenas um complemento para o ARMv7, é uma arquitetura totalmente nova.

O OpenSUSE lançou sua imagem Raspberry Pi de 64 bits.

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

Eu encontrei alguns ganhos significativos de desempenho de compilações de 64 bits vs 32 bits ao executar meus benchmarks do Android em um tablet usando um ARM Cortex-A53 de 1,3 GHz. As últimas são compiladas via Eclipse e, em tempo de execução, detectam se a CPU é ARM, Intel ou MIPS e, em seguida, arquitetura de 32 ou 64 bits.

Nas compilações anteriores do Windows para CPUs Intel, o funcionamento de 64 bits poderia ser muito mais rápido que 32 bits devido ao uso de instruções SIMD do tipo SSE. No entanto, o compilador posterior de 32 bits, com incompatibilidade com versões anteriores, produz praticamente o mesmo código e velocidade semelhante.

Os detalhes dos benchmarks do Android são os seguintes, mostrando resultados de 32 e 64 bits do A53 e através de um Cortex-A9 de 1,2 GHz. No final, estão algumas listagens de códigos de montagem que identificam instruções diferentes sendo usadas. Abaixo está um resumo dos resultados.

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

Whetstone Benchmark - desempenho semelhante (pequenas voltas), com a classificação geral influenciada pela compilação do teste usando as funções EXP.

Dhrystone Benchmark - MIPS / MHz mais recente 1,09 32 bits, 1,96 64 bits, 1,10 A9 - talvez 64 bits otimizado demais.

Benchmark Linpack - (N = 100) DP de 64 bits 1,97 x mais rápido, SP 2,67 x - consulte o código de montagem.

Livermore Loops - (24 kernels) média 1,5 vezes mais rápido, intervalo de 0,8 a 7,9 vezes

Testes de cache e RAM L1 / L2

MemSpeed ​​- cálculos flutuantes e inteiros - obtém caches 2,2 x, RAM 1,5 x.

BusSpeed ​​- streaming de dados inteiros e leitura burst - streaming de 2,0 x L1, 1,5 x L2, 1,25 x RAM - explode 2,6 x L1, L2 e RAM semelhantes.

RandMem - leitura e leitura / gravação serial e aleatória da mesma estrutura de indexação complexa - geralmente um pouco mais rápido na leitura, mas leitura / gravação semelhante / mais lenta.

Existem as versões MP acima e tentam medir o máximo de MF MFPS SP (MP-MFLOPS) com 4 núcleos no máximo de 2,7 GFLOPS de 32 bits e 5,5 GFLOPS de 64 bits. Há também uma versão usando intrínsecas NEON, em que o compilador de 64 bits gera instruções alternativas em até 10,8 GFLOPS vs 5,7 em 32 bits - consulte a lista de montagem. Também tenho versões desses benchmarks para tablets baseados no Windows 10 e Android Intel Atom - Windows de 64 e 32 bits, Android de 32 bits - 64 bits completos não totalmente implementados - kernel Linux de 64 bits, mas Android de 32 bits.

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

Além disso, tenho versões Linux / Intel de 32 e 64 bits.

Roy Longbottom

Aqui está como eu compilo o kernel RPI3 Aarch64:

Primeiro, você precisará do 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

Descompacte, coloque-o em algum lugar, por exemplo: /opt/toolchains/gcc-linaro-6.2.1-2016.11-x86_64_aarch64-linux-gnu

Aqui está o meu script para baixar firmware, VC, fonte do kernel e compilar o kernel com módulos, eu uso esse script para o meu servidor Jenkins para escolher o que você precisa:

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

Agora, basta descompactar o BOOT.tar.gz e colocá-lo no seu sdcard.

IMPORTANTE : você deve colocar arm_control = 0x200 em config.txt para inicializar o kernel AARCH64

Ou você pode simplesmente usar o meu pré-construído no meu Jenkins: https://jenkins.sandpox.org/job/RPI3_KERNEL_AARCH64/

Atualmente, parece que o Fedora e o Archlinux são bem suportados.

Se você seguir o caminho do Arch, isso ajudará você a construir a imagem (para mim, no linux / rpi3 make linux) e isso ajudará você a iniciar o wifi.

Caso você precise ter certeza de qual framboesa possui, use este guia .

Também arm_control=0x200está obsoleto e arm_64bitdeve ser usado no /boot/config.txt.