Performances ARM vs Thumb sur iPhone 3GS, code non à virgule flottante

Question

Je me demandais si quelqu'un avait des chiffres précis sur les performances du code ARM vs Thumb sur l'iPhone 3GS.Spécifiquement pour le code à virgule non flottante (VFP ou NEON) - je suis conscient des problèmes liés aux performances en virgule flottante en mode Thumb.

Y a-t-il un moment où la taille supplémentaire du code des instructions ARM plus grandes devient un risque pour les performances ?En d'autres termes, si mon code exécutable est relativement petit par rapport à la mémoire disponible, y a-t-il un mesuré différence de performances par rapport à l'activation du mode Thumb ?

La raison pour laquelle je demande est que même si je peux activer ARM pour les fichiers sources spécifiques à NEON dans Xcode en utilisant l'option "-marm", cela interrompt la construction du simulateur car GCC construit x86.Je me demandais si je devais simplement désactiver "compiler en tant que pouce" et en finir avec cela.

Answer 1

Je ne sais pas sur l'iPhone, mais une déclaration générale que le pouce est plus lent que ARM n'est pas correct du tout. Compte tenu de 32 bits de large mémoire d'état zéro d'attente, le pouce sera un peu plus lent, des chiffres comme 5% ou 10%. Maintenant, s'il est thumb2 qui est une autre histoire, il est dit que thumb2 peut courir plus vite, je ne sais pas ce que l'iPhone a je suppose que ce n'est pas thumb2.
Si vous n'êtes pas à court de zéro état d'attente mémoire 32 bits alors vos résultats peuvent varier. Une grande chose est de 32 bits de large mémoire. Si vous utilisez un bus large de 16 bits comme la famille GameBoy Advance, et il y a quelques états d'attente sur cette mémoire ou ROM, puis le pouce peut facilement à exécuter ARM pour des performances même si cela prend plus d'instructions de pouce pour effectuer la même tâche.

Testez votre code! Il est pas difficile d'inventer un test qui fournit les résultats qui vous intéressent ou non. Il est aussi facile de montrer le bras souffle loin le pouce car il est le pouce souffle loin bras. Qui se soucie de ce que les test dhrystones sont, il est comment rapide courir votre code aujourd'hui que les questions.

Ce que j'ai trouvé au fil des ans dans les tests des performances de code pour ARM est que votre code et votre compilateur sont le facteur. Donc, le pouce est un peu plus lent pour cent en théorie, car il utilise quelques pour cent de plus des instructions pour peform la même tâche. Mais saviez-vous que votre compilateur favori pourrait être horrible et simplement passer compilateurs vous pouvez exécuter plusieurs fois plus rapide (gcc tombe dans cette catégorie)? Ou en utilisant le même compilateur et mélanger les options d'optimisation. De toute façon, vous pouvez ombre la différence bras / pouce en étant intelligent sur l'utilisation des outils. Vous savez sans doute cela, mais vous seriez surpris de savoir combien de personnes pensent que la seule façon de savoir comment compiler le code est le seul moyen et la seule façon d'obtenir de meilleures performances est de lancer plus de mémoire ou tout autre matériel au problème.

Si vous êtes sur l'iPhone que j'entends les gens utilisent LLVM? J'aime le concept de LLVM à bien des égards et je suis impatient de l'utiliser comme mon chauffeur tous les jours quand il arrive à maturité, mais trouvé pour produire du code qui était de 10 à 20% (ou plus) plus lent pour la tâche particulière que je faisais. J'étais en mode bras, je ne l'ai pas essayer le mode pouce, et j'avais un cache L1 et L2. Si je l'avais testé sans les caches à comparer vraiment le pouce pour armer je ne serais probablement voir le pouce quelques pour cent plus lent, mais si vous pensez (que je n'étais pas intéressé à l'époque), vous pouvez mettre en cache deux fois plus de code du pouce que le code de bras qui pourrait impliquer que même si il y a quelques pour cent plus de code global pour la tâche, en mettant en cache beaucoup plus de celui-ci et en réduisant le temps de pouce chercher moyenne peut être nettement plus rapide. Je dois aller essayer.

Si vous utilisez LLVM, vous avez l'autre problème de plusieurs endroits pour effectuer des optimisations. Allant de C à bytecode, vous pouvez optimiser, vous pouvez optimiser le bytecode lui-même, vous pouvez fusionner tous vos bytecode et optimiser que dans son ensemble, puis lors du passage du code octet assembleur vous pouvez optimiser. Si vous aviez seulement 3 fichiers source et supposiez il n'y avait que deux niveaux d'optimisation par opportunité, ceux-ci étant Do not optimiser ou le niveau d'optimisation, avec gcc vous avez 8 combinaisons à tester, avec LLVM le nombre d'expériences est presque un ordre de grandeur supérieur . Plus que vous ne pouvez vraiment courir, des centaines de milliers. Pour une épreuve que je courais, pas opimizing sur C à l'étape de bytecode, puis pas optimiser le bytecode quand ils étaient séparés, mais l'optimisation après la fusion des fichiers bytecode dans un grand (ger) un. Le optimiser ayant llc sur le chemin de bras a produit les meilleurs résultats.

Bottom line ... test, test, test.

EDIT:

J'utilise le mot bytecode, je pense que le terme correct est dans le monde de code binaire LLVM. Le code dans les fichiers .BC est ce que je veux dire ...

Si vous allez de C à l'aide d'ARM LLVM, il y a code binaire (bc) au milieu. Il y a des options de ligne de commande pour optimiser le C bc step. Une fois bc vous pouvez optimiser par fichier, bc à bc. Si vous choisissez, vous pouvez fusionner deux ou plusieurs fichiers bc dans des fichiers plus gros bc, ou tout simplement transformer tous les fichiers en un seul gros fichier bc. Ensuite, chacun de ces fichiers combinés peuvent également être optimisés.

Ma théorie, qui a seulement quelques cas de test derrière elle jusqu'à présent, est que si vous ne faites pas l'optimisation jusqu'à ce que vous avez l'ensemble du programme / projet dans un grand fichier bc, l'optimiseur a le montant maximum si l'information avec lequel pour faire son travail. Cela signifie donc que passer de C à bc sans optimisation. Ensuite, fusionner tous les fichiers bc dans un grand fichier bc. Une fois que vous avez la chose comme un grand fichier bc puis laissez l'optimiseur effectuer son étape d'optimisation, ce qui maximise les informations et nous espérons que la qualité de l'optimisation. Ensuite, allez à partir du fichier bc optimisé pour assembleur ARM. Le réglage par défaut est llc avec l'optimisation, vous ne voulez permettre que l'optimisation car il est la seule étape qui sait comment optimiser pour la cible. Bc d'optimisations bc sont génériques et non cibles spécifiques (AFAIK).

Il vous reste à tester, tester, tester. Allez-y et expérimenter avec des optimisations entre les étapes, voir si elle rend votre programme plus rapide ou plus lent.

Answer 2

Consultez ce PDF d'ARM/Thumb pour connaître les compromis performances/taille du code/consommation d'énergie.

Sélection guidée de profil d'instructions de bras et de pouce
- Département d'informatique, Université de l'Arizona par Rajiv Gupta

Answer 3

Code de pouce sera essentiellement toujours plus lent que ARM équivalent. Le seul cas où le code de pouce peut être une grande victoire de la performance est si elle fait la différence entre votre code montage dans la mémoire ou le cache sur puce.

Il est difficile de donner des chiffres exacts sur les différences de performance, car il dépend entièrement de ce que votre code ne fait.

Vous pouvez définir des drapeaux du compilateur par l'architecture dans XCode, ce qui éviterait briser la construction du simulateur. Consultez la documentation de réglage de construction XCode.