Comment faire pour tester si votre Linux Support SSE2

En fait j'ai 2 questions:

Est SSE2 Compatibilité d'un PROCESSEUR question ou le Compilateur problème?
Comment vérifier si votre PROCESSEUR ou de la prise en charge du Compilateur SSE2?

Je suis en utilisant la Version de GCC:

gcc (GCC) 4.5.1

Quand j'ai essayé de compiler un code me donne cette erreur:

$ gcc -O3 -msse2 -fno-strict-aliasing -DHAVE_SSE2=1 -DMEXP=19937 -o test-sse2-M19937 test.c
cc1: error: unrecognized command line option "-msse2"

Et cpuinfo a montré ceci:

processor  : 0
vendor     : GenuineIntel
arch       : IA-64
family     : 32
model      : 1
model name : Dual-Core Intel(R) Itanium(R) Processor 9140M
revision   : 1
archrev    : 0
features   : branchlong, 16-byte atomic ops
cpu number : 0
cpu regs   : 4
cpu MHz    : 1669.000503
itc MHz    : 416.875000
BogoMIPS   : 3325.95
siblings   : 2
physical id: 0
core id    : 0
thread id  : 0

Vous utilisez GCC qui est destiné à IA64 par défaut. Le IA64 jeu d'instructions est radicalement différente de la x86. Si vous voulez compiler pour x86, vous devez essentiellement cross-compiler le binaire.
Vous avez également une Itanium2 processeur, qui n'a pas de support natif pour le jeu d'instructions x86. Même si vous ne le cross-compiler le binaire pour les architectures x86, les tests sur ce système va être difficile, si pas impossible.
Quelle distribution Linux utilisez-vous en chemin ?
Si vous voulais tester le SSE2 version de la Mersenne Twister sur un Itanium. Vous devriez avoir demandé en premier lieu: "Pourquoi je ne peux pas compiler le SSE2 version de MT sur un Itanium?" et vous avez tout de suite eu une réponse utile.

OriginalL'auteur neversaint | 2010-11-17

6
1. C'est les deux. Le compilateur/assembleur besoin pour être en mesure d'émettre/poignée instructions SSE2, puis le PROCESSEUR doit les soutenir. Si votre binaire a instructions SSE2 avec est assorti d'aucune condition et que vous essayez de l'exécuter sur un processeur Pentium II, vous êtes hors de la chance.
2. La meilleure façon est de vérifier votre manuel de GCC. Par exemple, mon GCC page de manuel se réfère à l'-msse2 option qui vous permettra d'activer explicitement instructions SSE2 dans les fichiers binaires. Toute relativement récente de GCC ou de la CPI doit être pris en charge. Comme pour votre cpu, vérifiez les drapeaux de la ligne dans /proc/cpuinfo.
Il serait préférable, cependant, de chèques dans votre code à l'aide de cpuid, etc, de sorte que SSE2 sections peut être désactivé dans les Processeurs qui ne la supportent pas et votre code peut tomber sur un jeu d'instructions.

EDIT:

Noter que votre compilateur doit être soit un compilateur natif en cours d'exécution sur un système x86, ou un cross-compilateur pour x86. Sinon, il n'aura pas les options nécessaires pour compiler des binaires pour les processeurs x86, qui comprend quoi que ce soit avec SSE2.

Dans votre cas, le PROCESSEUR ne prend pas en charge x86. Selon votre distribution Linux, il existe peut-être des paquets avec le processeur Intel IA32EL couche d'émulation pour x86-logiciel-sur-IA64, qui vous permettent d'exécuter x86 logiciel.

Par conséquent, vous avez les options suivantes:
- Utiliser un cross-compilateur qui va s'exécuter sur IA64 et de produire des binaires pour x86. Cross-compilateur toolchains ne sont pas une chose facile à l'installation, parce que vous avez besoin de plus que le compilateur (binutils, bibliothèques, etc).
- Utiliser Intel IA32EL pour exécuter un natif x86 compilateur. Je ne sais pas comment vous allez sur l'installation d'un natif x86 ensemble d'outils et de toutes les bibliothèques que les besoins de votre projet, dans vos distributions ne prend pas en charge directement. Peut-être une pleine soufflé un chroot l'installation d'un système x86 à la distribution ?
Alors si vous voulez tester votre construction sur ce système, vous ont pour installer Intel IA32EL pour Linux.

EDIT2:

Je pense qu'on pourrait aussi fonctionner à plein x86 distribution linux sur un émulateur comme Bochs ou QEMU (sans la virtualisation de cours). Vous êtes certainement pas va être ébloui par la vitesse.

merci. Pls voir la mise à jour ci-dessus. Comment vérifiez-vous les drapeaux, mon cpu info ci-dessus ne semblent pas montrer que.

OriginalL'auteur
13

Le PROCESSEUR doit être capable d'exécuter des instructions SSE2, et le compilateur a besoin pour être en mesure de générer.

Pour vérifier si votre cpu prend en charge SSE2:
```
# cat /proc/cpuinfo
```
Il sera quelque part en dessous de "drapeaux" si elle est soutenue.

Mise à jour: Si vous cpu ne le supporte pas.

Pour le compilateur:
```
# gcc -dumpmachine
# gcc --version
```
Cible de votre compilateur a besoin d'une sorte de x86*, car seule cette processeurs support sse2, qui fait partie du jeu d'instructions x86

ET

version de gcc doit être >= 3.1 (le plus probable, puisque c'est environ 10 ans ou quelque chose) pour le soutien SSE2.

Mise à jour: Si votre compilateur ne le supporte pas sur cette cible, il le fera si vous l'utilisez comme un cross compilateur pour x86.

Je pense que SSE/SSE2 a été introduit dans le CCAG-3.1
Oui, vous avez raison: gcc.gnu.org/gcc-3.1/changes.html. J'ai mis à jour ma réponse.
grep -o sse2 /proc/cpuinfo est utile, parce qu'il y a beaucoup de drapeaux de regarder à travers les yeux sur certains Processeurs.

OriginalL'auteur
5

Un autre truc pas encore mentionné, c'est faire:
```
gcc -march=native -dM -E - </dev/null | grep SSE2
```
et obtenez:
```
#define __SSE2_MATH__ 1
#define __SSE2__ 1
```
Avec -march=native vous de vérifier à la fois votre compilateur et de votre CPU. Si vous donnez à un autre -mars pour un CPU, comme -mars=bonnell vous pouvez vérifier que le CPU.

Consulter votre gcc docs pour la bonne version de gcc:

https://gcc.gnu.org/onlinedocs/gcc-4.9.0/gcc/Submodel-Options.html

comment puis-je désactiver le SSE2?
Super réponse, je l'aime parce qu'il est portable 🙂

OriginalL'auteur
3

utiliser l'asm à vérifier l'existence de sse2
```
enter code here
static
bool HaveSSE2()
{
    return false;
    __asm mov EAX,1              ;
    __asm cpuid                  ;
    __asm test EDX, 4000000h     ;test whether bit 26 is set
    __asm jnz yes                ;yes
    return false;
yes:
    return true;
}
```
Cela ressemble à MSVC asm syntaxe, de sorte que vous ne pouvez pas l'utiliser facilement sur Linux. Aussi, il semble buggy, avec un return false; comme la première déclaration. Il serait plus "propre" pour le mettre yes: étiquette à l'intérieur d'une instruction asm; cela ressemble à de sauter à une étiquette C à partir d'un asm déclaration, en faisant le compilateur la vie plus difficile. Probablement mieux juste de l'extrait de bits dans un vrai/faux boolean au lieu d'utiliser une branche conditionnelle.

OriginalL'auteur
2

Essayez de lancer:
```
lshw -class processor | grep -w sse2
```
et regardez sous le processeur de la section.

est-il, vraiment? -1
ok, peut-être pas tout, mais une juste part

OriginalL'auteur

Vous devez vous connecter pour publier un commentaire.