Cortex A9 NÉON vs VFP l'utilisation de la confusion

Je suis en train de construire une bibliothèque pour un Cortex A9 processeur ARM(un OMAP4 pour être plus précis) et je suis dans un peu de confusion quant à ce qui\lors de l'utilisation de NÉON vs VFP dans le contexte des opérations en virgule flottante et SIMD. À noter que je sais faire la différence entre les 2 matériel coprocesseur unités(ainsi qu'il est décrit ici DONC), je viens d'avoir une certaine incompréhension quant à leur utilisation correcte.

Liées à cela, je suis en utilisant les drapeaux de compilation suivantes:

GCC
-O3 -mcpu=cortex-a9 -mfpu=neon -mfloat-abi=softfp
-O3 -mcpu=cortex-a9 -mfpu=vfpv3 -mfloat-abi=softfp
ARMCC
--cpu=Cortex-A9 --apcs=/softfp
--cpu=Cortex-A9 --fpu=VFPv3 --apcs=/softfp

J'ai lu dans les BRAS de la documentation, un lot de wiki(comme celui-ci), du forum et des articles de blog et tout le monde semble d'accord que l'utilisation de NÉON est mieux que l'aide de VFP
ou au moins le mélange NÉON(par exemple à l'aide de la instrinsics de mettre en œuvre certains algos en SIMD) et VFP n'est pas une bonne idée; je ne suis pas sûr à 100% encore, si cela s'applique dans le contexte de l'ensemble de l'application\bibliothèque ou tout simplement à des endroits spécifiques(fonctions) dans le code.

Donc je suis en utilisant le néon comme la FPU pour mon application que je veux aussi utiliser le intrinsèques. En conséquence, je suis un peu de l'ennui et ma confusion sur la façon d'utiliser au mieux ces caractéristiques(NÉON vs VFP) sur le Cortex A9 juste approfondit davantage au lieu de l'éclaircir. J'ai un code qui fait référence pour mon application et utilise certaines custom made classes timer
dans lequel les calculs sont basés sur virgule flottante double précision. À l'aide de NÉON comme la FPU donne totalement inapproprié de résultats(en essayant d'imprimer ces valeurs résultats d'impression pour la plupart inf et NaN; le même code fonctionne sans accroc lors de la construction pour l'architecture x86). J'ai donc changé mes calculs, à utiliser en virgule flottante simple précision que est documenté que le NÉON ne gère pas en virgule flottante double précision. Mes repères ne donne pas de bon résultats(et ce qui est pire, c'est que maintenant il ne fonctionne plus sur x86; je pense que c'est à cause de la perte de précision, mais je ne suis pas sûr). Donc, je suis presque complètement perdu: d'une part, je veux utiliser NÉON pour le SIMD capacités et en l'utilisant comme le FPU ne donne pas le bon résultats, d'autre part en la mélangeant avec de la VFP ne semble pas une très bonne idée.
Tous les conseils dans ce domaine sera grandement apprécié !!

J'ai trouvé dans l'article ci-dessus mentionné wiki un résumé de ce qui devrait être fait pour virgule flottante d'optimisation dans le contexte de NÉON:

Utiliser uniquement en virgule flottante simple précision
Au NÉON intrinsèques /ASM quand jamais vous trouvez un goulet d'étranglement FP fonction. Vous pouvez faire mieux que le compilateur.
Minimiser Les Branches Conditionnelles
Permettre RunFast mode

Pour softfp:

Inline code de nombres flottants (sauf son très grand)
Passer FP arguments via des pointeurs au lieu d'une valeur de nombre entier de travail entre les appels de fonction.

Je ne peux pas utiliser dur pour le flotteur ABI que je ne peux pas le lien avec les bibliothèques dont je dispose.
La plupart des recommandations de sens pour moi(à l'exception de la "runfast mode" dont je ne comprends pas exactement ce qu'il doit faire et le fait que, à ce moment dans le temps, je pourrais faire mieux que le compilateur) mais je continue à obtenir des résultats incohérents et je ne suis pas sûr de rien en ce moment.

Quelqu'un pourrait jeter une certaine lumière sur la façon d'utiliser correctement les nombres à virgule flottante et les NÉONS pour le Cortex A9/A8 et qui options de compilation dois-je utiliser?

Donner de l'auto-vectorisation un coup de trop. Si vous utilisez le BRAS RVCT compilateur, ajoutez --vectoriser à la ligne de commande (Vous pourriez avoir besoin d'un professionnel RVCT licence afin d'essayer ce bien, ainsi les pls garder cela à l'esprit)
Votre suggestion est liée à la SIMD. Ma question est sur la bonne manière d'utiliser la virgule flottante capacités de NÉON de la VFP unité.
Voir aussi le BRAS de Blog et ARM Cortex-Un des Processeurs et de la GCC en ligne de Commande.

InformationsquelleAutor celavek | 2011-09-01

arm c c++floating-point neon

8

Je pense que cette question devrait être divisé en plusieurs, en ajoutant des exemples de code et les détails plate-forme cible et les versions de toolchains utilisé.

Mais pour couvrir une partie de la confusion:
La recommandation d'utiliser le NÉON comme la FPU" sonne comme un malentendu. Le NÉON est un moteur SIMD, le VFP est une FPU. Vous pouvez utiliser des NÉONS pour single-precision floating-point operations sur 4 en simple précision les valeurs en parallèle, ce qui (si possible) est bon pour la performance.

-mfpu=neon peut être vu comme un raccourci pour -mfpu=neon-vfpv3.

Voir http://gcc.gnu.org/onlinedocs/gcc/ARM-Options.html pour plus d'informations.

InformationsquelleAutor unixsmurf
8

... du forum et des articles de blog et tout le monde semble d'accord que l'utilisation de NÉON est mieux que l'aide de VFP ou au moins le mélange NÉON(par exemple à l'aide de la instrinsics de mettre en œuvre certains algos en SIMD) et VFP n'est pas une bonne idée

Je ne suis pas sûr que ce soit correct. Selon le BRAS à L'introduction de NÉON Développement Article | NEON registres:
Au registre de la banque se compose de 32 registres 64 bits. Si les deux
SIMD avancée et VFPv3 sont mis en œuvre, ils partagent ce registre
la banque. Dans ce cas, VFPv3 est mis en œuvre dans le VFPv3-D32 forme que
prend en charge 32 double-precision floating-point des registres. Cette
l'intégration simplifie la mise en œuvre de la commutation de contexte, parce que
les mêmes routines que d'enregistrer et de restaurer VFP contexte également enregistrer et
restaurer NÉON contexte.

Le NÉON de l'appareil peut afficher le même registre de la banque en tant que:
- seize 128 bits quadword registres, Q0-Q15
- trente-deux 64 bits doubleword registres D0-D31.
Le NÉON D0-D31 registres sont les mêmes que les VFPv3 D0-D31 registres
et chaque de la Q0-Q15 registres de la carte sur une paire de D les registres.
La Figure 1.3 montre les différents points de vue du partage de NÉON et de VFP
registre de la banque. L'ensemble de ces points de vue sont accessibles à tout moment. Logiciel
n'est explicitement basculer entre eux, parce que l'
instruction détermine la vue appropriée.
Les registres ne sont pas en concurrence, mais plutôt co-exister en tant que vue sur le registre de la banque. Il n'y a pas moyen de remettre le NÉON et la FPU engins.
Liées à cela, je suis en utilisant les drapeaux de compilation suivantes:
```
-O3 -mcpu=cortex-a9 -mfpu=neon -mfloat-abi=softfp
-O3 -mcpu=cortex-a9 -mfpu=vfpv3 -mfloat-abi=softfp
```
Voici ce que je fais, votre kilométrage peut varier. Sa dérivée à partir d'un mashup de l'information recueillie à partir de la plate-forme et le compilateur.

gnueabihf me dit la plate-forme de l'utilisation de flotteurs, ce qui peut accélérer la procédure d'appels. En cas de doute, utilisez softfp car il est compatible avec dur flotteurs.

BeagleBone Black:
```
$ gcc -v 2>&1 | grep Target          
Target: arm-linux-gnueabihf

$ cat /proc/cpuinfo
model name  : ARMv7 Processor rev 2 (v7l)
Features    : half thumb fastmult vfp edsp thumbee neon vfpv3 tls vfpd32 
...
```
De sorte que le BeagleBone utilise:
```
-march=armv7-a -mtune=cortex-a8 -mfpu=neon -mfloat-abi=hard
```
CubieTruck v5:
```
$ gcc -v 2>&1 | grep Target 
Target: arm-linux-gnueabihf

$ cat /proc/cpuinfo
Processor   : ARMv7 Processor rev 5 (v7l)
Features    : swp half thumb fastmult vfp edsp thumbee neon vfpv3 tls vfpv4 
```
De sorte que le CubieTruck utilise:
```
-march=armv7-a -mtune=cortex-a7 -mfpu=neon-vfpv4 -mfloat-abi=hard
```
Banana Pi Pro:
```
$ gcc -v 2>&1 | grep Target 
Target: arm-linux-gnueabihf

$ cat /proc/cpuinfo
Processor   : ARMv7 Processor rev 4 (v7l)
Features    : swp half thumb fastmult vfp edsp neon vfpv3 tls vfpv4 idiva idivt
```
De sorte que le Banana Pi utilise:
```
-march=armv7-a -mtune=cortex-a7 -mfpu=neon-vfpv4 -mfloat-abi=hard
```
Raspberry Pi 3:

La RPI3 est unique en ce que son ARMv8, mais son exécution d'un 32-bit OS. Cela signifie qu'elle est efficacement 32-bit ARM ou Aarch32. Il y a un peu plus de 32-bit ARM vs Aarch32, mais cela va vous montrer la Aarch32 drapeaux

Aussi, le RPI3 utilise une Broadcom A53 SoC, et il a le NÉON et l'option CRC32 instructions, mais il lui manque l'option de Chiffrement extensions.
```
$ gcc -v 2>&1 | grep Target 
Target: arm-linux-gnueabihf

$ cat /proc/cpuinfo 
model name  : ARMv7 Processor rev 4 (v7l)
Features    : half thumb fastmult vfp edsp neon vfpv3 tls vfpv4 idiva idivt vfpd32 lpae evtstrm crc32
...
```
De sorte que le Raspberry Pi peut utiliser:
```
-march=armv8-a+crc -mtune=cortex-a53 -mfpu=neon-fp-armv8 -mfloat-abi=hard
```
Ou il peut utiliser (je ne sais pas quoi utiliser pour -mtune):
```
-march=armv7-a -mfpu=neon-vfpv4 -mfloat-abi=hard 
```
ODROID C2:

ODROID C2 utilise un Amlogic A53 SoC, mais il utilise un système d'exploitation 64 bits. Le ODROID C2, il a le NÉON et l'option CRC32 instructions, mais il lui manque l'option de Chiffrement des extensions (config similaire à RPI3).
```
$ gcc -v 2>&1 | grep Target 
Target: aarch64-linux-gnu

$ cat /proc/cpuinfo 
Features    : fp asimd evtstrm crc32
```
De sorte que le ODROID utilise:
```
-march=armv8-a+crc -mtune=cortex-a53
```
Au-dessus de recettes, j'ai appris le processeur ARM (comme Cortex A9 ou A53) en examinant les fiches de données. Selon cette réponse sur Unix et Linux Stack Exchange, qui décrypte la sortie de /proc/cpuinfo:

CPU partie: numéro de la Pièce. 0xd03 indique Cortex-A53 processeur.

Afin que nous puissions être en mesure de rechercher la valeur la forme d'une base de données. Je ne sais pas si il existe ou lorsqu'il se trouve.

InformationsquelleAutor jww
3

Je voudrais rester à l'écart de VFP. Il est juste comme la Thmub mode : C'est censé être pour les compilateurs. Il n'y a aucun point dans l'optimisation de la pour eux.

Il peut paraître impoli, mais je ne vois pas l'intérêt de NÉON intrinsèques soit. C'est plus d'ennuis que de l'aide - si tout.

Investir seulement deux ou trois jours, dans de base, BRAS de montage: vous avez seulement besoin d'apprendre quelques instructions pour la boucle de contrôle/de résiliation.

Alors vous pouvez commencer à écrire natif NÉON codes sans se soucier de le compilateur de faire quelque chose astral de cracher des tonnes d'erreurs/avertissements.

Apprentissage NÉON instructions est moins exigeant que tous ceux intrinsèques des macros. Et tous les ci-dessus, les résultats sont tellement mieux.

Entièrement optimisé NÉON natif codes généralement exécuté plus de deux fois plus rapide que bien écrit intrinsèques homologues.

Il suffit de comparer les OP de la version avec le mien dans le lien ci-dessous, vous saurez ce que je veux dire.

L'optimisation de RVBA8888 à RGB565 de conversion avec des NÉONS

ce qui concerne
- Mauvais support du NÉON intrinsèques est du CCG problème. Mieux les compilateurs d'optimiser très bien. Cependant, je suis d'accord, il est parfois plus facile d'écrire en direct asm que de perdre du temps à essayer de comprendre ce qu'est le droit intrinsèque nom pour certains opcode
- Aussi, VFP et et SIMD sont des choses différentes. Vous allez perdre du temps et peut ne pas obtenir de bons résultats avec des NÉONS pour sqrt par exemple.
- "Il peut paraître impoli, mais je ne vois pas l'intérêt de NÉON intrinsèques soit. C'est plus de mal que de bien..." - NEON fait une différence dans la pratique. Le BLAKE2 de hachage des lignes de base à 35 cpb en C, et les gouttes pour 10 cpb sous NÉON. CÉSAR (Concurrence pour le Chiffrement Authentifié: la Sécurité, la pertinence et la Robustesse) voit également des accélérations dans le candidat algorithmes. Voir aussi SUPERCOP ARMv7 w/ NEON et les critères de référence correspondants.
- tu m'a fait mal. Je parlais de "NEON Intrinsèques". Et je suis absolument convaincue par les NÉONS potentiel. Si vous bénéficiez de 10 avec Intrinsèques, vous obtiendrez 15~20 avec pure assemblée. C'est mon point de vue.
- Mais alors vous aussi besoin d'manuellement dérouler et de pipeline logiciel boucles (en respectant la face!), ne pas mentionner l'allocation de registres et de la programmation (qui sont la cible-dépendant).
- Vous pouvez passer soit -march=armv7-a ou -mcpu=cortex-an que l'option de compilation. Et si vous pensez que ces options en fait aider d'une certaine manière, vous n'avez jamais pris un coup d'oeil au démontage. La main de le dérouler et de la planification est la bonne façon.
- GCC ARM backend est certainement pas le meilleur là-bas (il est de mieux en mieux tout de même). Mais de recommander des gens manuellement SWP et le calendrier des instructions (avec les versions N pour N différents cœurs) n'est pas non plus une solution.
- Si vous pensez que les gens qui écrivent N différentes versions de montage pour les N Processeurs différents, vous êtes très mal. Soit nous écrire v7 ou v8 de la version, l'optimisation pour le LITTLE cluster. La partie la plus ennuyeuse de SIMD programmation est probablement traiter avec les résidus, et c'est exactement où il est beaucoup plus commode et plus efficace dans l'assemblée.
- Je pense que N dépend de la carottes de personnes de la cible et à quel point ils veulent de code sur chacun d'eux. Comme pour les boucles, je ne suis pas sûr que je suis: je suis à la recherche d'32-inst SWPed boucle supplémentaire de 10 insts dans le prologue et 20 dans l'épilogue et je ne veux pas écrire quelque chose comme ça à la main (c'est pas les BRAS tout de même).
InformationsquelleAutor Jake 'Alquimista' LEE

Vous devez vous connecter pour publier un commentaire.