close

SSE

Vai alla navigazione Vai alla ricerca

SSE ( Streaming SIMD Extensions , streaming SIMD extension of the processor) è SIMD - ( eng  . Single Instruction, Multiple Data , One instruction - alot of data) un insieme di istruzioni sviluppato da Intel e introdotto per la prima volta nei processori della serie Pentium III come una risposta a un set di istruzioni simile 3DNow! da AMD , introdotto un anno prima. Il nome originale di queste istruzioni era KNI - Katmai New Instructions (Katmai è il nome della prima versione del core del processore Pentium III ).  

La tecnologia SSE consentiva di superare due problemi principali dell'MMX : quando si utilizzava l'MMX, era impossibile utilizzare le istruzioni del coprocessore contemporaneamente , poiché i suoi registri erano condivisi con i registri MMX e la capacità dell'MMX di lavorare solo con numeri interi.

SSE include otto registri a 128 bit e un set di istruzioni che funzionano con tipi di dati scalari e compressi nell'architettura del processore .

Il vantaggio in termini di prestazioni si ottiene quando è necessario eseguire la stessa sequenza di azioni su dati diversi. In questo caso, il blocco SSE parallelizza il processo di calcolo tra i dati.

Caratteristiche

  • 8 (in x86-64  - 16) registri XMM a 128 bit.
  • Registro flag a 32 bit (in x86-64 - 64) (MXCSR).
  • Tipo di dati a virgola mobile a precisione singola compresso a 128 bit .
  • Istruzioni sui numeri reali a precisione singola.
  • Istruzioni per il precaricamento esplicito dei dati, il controllo della memorizzazione nella cache dei dati e il controllo dell'ordine delle operazioni di salvataggio.

Registri

Otto (sedici per x64) registri a 128 bit sono stati aggiunti a SSE, chiamati xmm0 - xmm7 (-xmm15).

XMM registers.svg

Ciascun registro può contenere quattro valori in virgola mobile a precisione singola a 32 bit.

Comandi SSE

Comandi per numeri in virgola mobile

  • Inoltra comandi
    • Tipi scalari - MOVSS
    • Tipi imballati - MOVAPS, MOVUPS, MOVLPS, MOVHPS, MOVLHPS, MOVHLPS
  • Comandi aritmetici
    • Tipi scalari - ADDSS, SUBSS, MULSS, DIVSS, RCPSS, SQRTSS, MAXSS, MINSS, RSQRTSS
    • Tipi imballati - ADDPS, SUBPS, MULPS, DIVPS, RCPPS, SQRTPS, MAXPS, MINPS, RSQRTPS
  • Comandi di confronto
    • Tipi scalari - CMPSS, COMISS, UCOMISS
    • Tipi imballati - CMPPS
  • Miscelazione e disimballaggio
    • Tipi imballati - SHUFPS, UNPCKHPS, UNPCKLPS
  • Digita i comandi di conversione
    • Tipi scalari - CVTSI2SS, CVTSS2SI, CVTTSS2SI
    • Tipi confezionati - CVTPI2PS, CVTPS2PI, CVTTPS2PI
  • Operazioni booleane bit per bit
    • Tipi imballati - ANDPS, ORPS, XORPS, ANDNPS

Comandi per numeri interi

  • Comandi aritmetici
    • PMULHUW, PSADBW, PAVGB, PAVGW, PMAXUB, PMINUB, PMAXSW, PMINSW
  • Inoltra comandi
    • PEXTRW, PINSRW
  • Altro
    • PMOVMSKB, PSHUFW

Altri comandi

  • Lavorare con il registro MXCSR
    • LDMXCSR, STMXCSR
  • Gestione della cache e della memoria
    • MOVNTQ, MOVNTPS, MASKMOVQ, PREFETCH0, PREFETCH1, PREFETCH2, PREFETCHNTA, SFENCE

Esempio

L'esempio seguente mostra la moltiplicazione di quattro coppie di numeri in virgola mobile con un'istruzione mulps :

__declspec ( align ( 16 )) float a [ 4 ] = { 300.0 , 4.0 , 4.0 , 12.0 };         
__declspec ( align ( 16 )) float b [ 4 ] = { 1.5 , 2.5 , 3.5 , 4.5 };            
 
__asm ​​{ 
    modifiche xmm0 , a ; // inserisce 4 variabili in virgola mobile da a nel registro xmm0 movups xmm1 , b ; // inserisce 4 variabili in virgola mobile da b nel registro xmm1 mulps xmm0 , xmm1 ; // moltiplica i pacchetti in virgola mobile: xmm0 = xmm0 * xmm1 ; // xmm00 = xmm10 * xmm00 ; // xmm01 = xmm11 * xmm01 ; // xmm02 = xmm12 * xmm02 ; // xmm03 = xmm13 * xmm03 sposta a , xmm0 ; // scarica i risultati dal registro xmm0 agli indirizzi a };       
           
         
                       
                       
                       
                       
 
           

Lo stesso esempio, ma l' assembler insert asm è realizzato nello standard AT&T (GNU Assembler)

float a [ 4 ] = { 300.0 , 4.0 , 4.0 , 12.0 };        
float b [ 4 ] = { 1,5 , 2,5 , 3,5 , 4,5 };           
 
 __asm__ volatile 
 (
  "movups %[a], %%xmm0 \n\t " // inserisce 4 variabili in virgola mobile da a nel registro xmm0 "movups %[b], %%xmm1 \n\t " // inserisce 4 variabili in virgola mobile point da b per registrare xmm1 "mulps %%xmm1, %%xmm0 \n\t " // moltiplica i pacchetti in virgola mobile: xmm0 = xmm0 * xmm1 // xmm00 = xmm00 * xmm10 // xmm01 = xmm01 * xmm11 // xmm02 = xmm02 * xmm12 // xmm03 = xmm03 * xmm13 "movups %%xmm0, %[a] \n\t " // scarica i risultati dal registro xmm0 agli indirizzi a :	
  	
  	
				
				
				
				
  	
  
  : [ a ] ​​​​"m" ( * a ), [ b ] "m" ( * b )  
  : "%xmm0" , "%xmm1"  
 );

Vedi anche

Collegamenti