Come verificare se il supporto Linux SSE2

Question

realtà ho 2 domande:

1. E` SSE2 Compatibilità un problema di CPU o un problema del compilatore?
2. Come verificare se la CPU o il compilatore supportano SSE2?

Sto usando GCC versione:

gcc (GCC) 4.5.1 

Quando ho provato a compilare un codice mi dà questo errore:

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

E cpuinfo ha mostrato questo:

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 

Answer 1

1. Sono entrambi. Il compilatore/assemblatore deve essere in grado di emettere/gestire le istruzioni SSE2 e quindi la CPU deve supportarle. Se il tuo binario contiene istruzioni SSE2 senza condizioni e provi a eseguirlo su un Pentium II sei sfortunato.

2. Il modo migliore è controllare il manuale GCC. Ad esempio la mia manpage GCC fa riferimento all'opzione -msse2 che consente di abilitare esplicitamente le istruzioni SSE2 nei binari. Qualsiasi GCC o ICC relativamente recente dovrebbe supportarlo. Per quanto riguarda la tua CPU, controlla la riga delle bandiere in/proc/cpuinfo.

Sarebbe meglio, però, di avere controlli nel codice utilizzando CPUID, ecc, in modo che le sezioni SSE2 possono essere disabilitate nelle CPU che non supportano e il codice può ripiegare su un set di istruzioni più comune .

EDIT:

Si noti che il compilatore ha bisogno di essere un compilatore nativo in esecuzione su un sistema x86, o di un cross-compilatore per x86. Altrimenti non avrà le opzioni necessarie per compilare i binari per i processori x86, che include qualsiasi cosa con SSE2.

Nel tuo caso la CPU non supporta affatto x86. A seconda della distribuzione Linux, potrebbero esserci pacchetti con il livello di emulazione Intel IA32EL per x86-software-on-IA64, che potrebbe consentire l'esecuzione del software x86.

Pertanto sono disponibili le seguenti opzioni:

• utilizzare un cross-compilatore che verrà eseguito su IA64 e produrre file binari per x86. Tuttavia, i toolchain cross-compiler non sono una cosa facile da configurare, perché è necessario molto più del semplice compilatore (binutils, librerie, ecc.).

• Utilizzare Intel IA32EL per eseguire un compilatore x86 nativo. Non so come andresti sull'installazione di una toolchain nativa x86 e tutte le librerie che il tuo progetto ha bisogno nelle tue distribuzioni non la supportano direttamente. Forse un'installazione chroot completa di una distribuzione x86?

Poi, se si desidera verificare il vostro costruire su questo sistema si deve installare ia32el di Intel per Linux.

EDIT2:

Immagino che si potrebbe anche eseguire una distribuzione Linux x86 completo su un emulatore come Bochs o QEMU (senza virtualizzazione naturalmente). Sei sicuramente non andando ad essere abbagliato dalle velocità risultanti però.

Answer 2

La CPU deve essere in grado di eseguire le istruzioni SSE2 e il compilatore nee ds per essere in grado di generarli.

Per verificare se la CPU supporta SSE2:

# cat /proc/cpuinfo 

Sarà da qualche parte sotto "bandiere" se è supportato.

Aggiornamento: Quindi la CPU non lo supporta.

per il compilatore:

# gcc -dumpmachine 
# gcc --version 

Obiettivo del compilatore ha bisogno di una sorta di x 86 *, dal momento che solo questo supporto SSE2 CPU, che fa parte del set di istruzioni x86

E

La versione di gcc

deve essere> = 3.1 (molto probabilmente, dato che ha circa 10 anni o qualcosa del genere) per supportare SSE2.

Aggiornamento: Quindi il tuo compilatore non lo supporta su questo target, lo sarà se lo stai usando come cross-compilatore per x86.

Answer 3

prova ad eseguire:

lshw 

e guardare sotto la sezione del processore.

Answer 4

uso asm per verificare l'esistenza di 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; 
} 

Answer 5

Un altro trucco non ancora citato è fare:

gcc -march=native -dM -E - </dev/null | grep SSE2 

e ottenere:

#define __SSE2_MATH__ 1 
#define __SSE2__ 1 

Con -march = native voi stanno controllando sia il tuo compilatore che la tua CPU. Se fornisci un altro -march per una CPU specifica, come -march = bonnell puoi controllare quella CPU.

consultare il proprio documentazione di GCC per la versione corretta di gcc:

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