Streaming SIMD Extensions

SSE (ang. Streaming SIMD Extensions) jest nazwą zestawu instrukcji wprowadzonego w 1999 roku po raz pierwszy w procesorach Pentium III firmy Intel. SSE daje przede wszystkim możliwość wykonywania działań zmiennoprzecinkowych na 4-elementowych wektorach liczb pojedynczej precyzji (48 rozkazów). Ponadto wprowadzono jedenaście nowych rozkazów stałoprzecinkowych w zestawie MMX, a także dano możliwość wskazywania, które dane powinny znaleźć się w pamięci podręcznej.

SSE to również zmiany w architekturze procesora: dodano 8 rejestrów XMM o rozmiarze 128 bitów oraz 32-bitowy rejestr kontrolny MXCSR; w 64-bitowych wersjach procesorów (AMD64, EM64T) dostępne jest jeszcze 8 dodatkowych rejestrów XMM. Rejestry 128-bitowe, na zawartości których wykonywana jest większość rozkazów SSE (nazywane w asemblerze xmm0, xmm1, ..., xmm15), stanowią zupełnie odrębne komórki pamięci – w odróżnieniu od rejestrów MMX nie zostały zamapowane na inne rejestry.

Typy danych

SSE wprowadza nowy typ danych: 4-elementowy wektor liczb zmiennoprzecinkowych pojedynczej precyzji (ang. 128-bit packed single-precision floating-point); liczba zmiennoprzecinkowa ma rozmiar 32 bitów. Poza tym wykorzystuje typy wektorowe zdefiniowane w MMX.

Rozkazy SSE mogą wykonywać działania arytmetyczne na wektorach liczb zmiennoprzecinkowych na dwa sposoby:

1. packed (równoległe) – wykonując równocześnie 4 niezależne działania zmiennoprzecinkowe na odpowiadających sobie elementach wektorów;
2. scalar (skalarne) – wykonując działanie tylko na pierwszych elementach wektorów.

Przykład – mnożenie dwóch wektorów (rozkazem MULPS xmm0, xmm1):

+-------+-------+-------+-------+
|   x3  |   x2  |   x1  |   x0  | xmm0
+-------+-------+-------+-------+
    *       *       *       *
+-------+-------+-------+-------+
|   y3  |   y2  |   y1  |   y0  | xmm1
+-------+-------+-------+-------+
    =       =       =       =
+-------+-------+-------+-------+
| x3*y3 | x2*y2 | x1*y1 | x0*y0 | xmm0
+-------+-------+-------+-------+

Przykład – mnożenie pierwszych elementów wektorów (rozkazem MULSS xmm0, xmm1):

+-------+-------+-------+-------+
|   x3  |   x2  |   x1  |   x0  | xmm0
+-------+-------+-------+-------+
                            *
+-------+-------+-------+-------+
|   y3  |   y2  |   y1  |   y0  | xmm1
+-------+-------+-------+-------+
    =       =       =       =
+-------+-------+-------+-------+
|   x3  |   x2  |   x1  | x0*y0 | xmm0
+-------+-------+-------+-------+

Mnemoniki rozkazów

Mnemoniki instrukcji SSE działających na wektorach liczb całkowitych zostały wybrane zgodnie z konwencję wprowadzoną w MMX – nazwy zaczynają się najczęściej od litery P.

Dla nazw instrukcji działających na liczbach zmiennoprzecinkowych nie wprowadzono żadnego prefiksu; jednak podobnie jak w MMX sufiks nazwy określa typ:

• PS (packed single) – działanie na wektorach,
• SS (scalar single) – działanie na skalarach.

Ponadto jeśli rozkazy działają na połówkach rejestrów XMM (tj. albo odnoszą się do bitów 0..63, albo 64..127), w mnemonikach rozkazu występuje litera – odpowiednio – L albo H, od angielskich słów low („niski”) i high („wysoki”).

Działania zmiennoprzecinkowe

SSE jest zgodne ze standardem IEEE-754. Możliwe jest jednak włączenie pewnych niestandardowych cech, które w niektórych przypadkach przyspieszają obliczenia.

 +---------+---------+---------+---------+
 |   1.0   |  -5.3   |   16.5  |   17.2  | xmm0
 +---------+---------+---------+---------+
      ≠         ≠         ≠         ≠
 +---------+---------+---------+---------+
 |   7.0   |  -5.3   |   16.5  |   17.3  | xmm1
 +---------+---------+---------+---------+
      =         =         =         =
 +---------+---------+---------+---------+
 |111..1111|000..0000|000..0000|111..1111| xmm0
 +---------+---------+---------+---------+

temp[0] := xmm1[0]
temp[1] := xmm2[0]
temp[2] := xmm1[1]
temp[3] := xmm2[1]
xmm1 := temp

temp[0] := xmm1[2]
temp[1] := xmm2[2]
temp[2] := xmm1[3]
temp[3] := xmm2[3]
xmm1 := temp

           3     2     1     0
        +-----+-----+-----+-----+
 xmm1 = |  d  |  c  |  b  |  a  |
        +-----+-----+-----+-----+
        
        +-----+-----+-----+-----+
 xmm2 = |  h  |  g  |  f  |  e  |
        +-----+-----+-----+-----+

        +-----+-----+-----+-----+
 xmm1 = |  f  |  b  |  e  |  a  |
        +-----+-----+-----+-----+

        +-----+-----+-----+-----+
 xmm1 = |  h  |  d  |  g  |  c  |
        +-----+-----+-----+-----+

{ pobranie indeksów }
index1_0 := (imm8 AND 00000011b)
index1_1 := (imm8 AND 00001100b) SHR 2
index2_0 := (imm8 AND 00110000b) SHR 4
index2_1 := (imm8 AND 11000000b) SHR 6

{ rozmieszczenie elementów }
temp[0] := xmm1[index1_0]
temp[1] := xmm1[index1_1]
temp[2] := xmm2[index2_0]
temp[3] := xmm2[index2_1]
xmm1 := temp

MXCSR – rejestr kontrolny/statusu

Rejestr MXCSR przechowuje:

1. Ustawienia operacji zmiennoprzecinkowych:
   • sposób zaokrąglanie wyniku:
     • do najbliższej liczby całkowitej
     • zaokrąglanie w stronę plus nieskończoności
     • zaokrąglanie w stronę minus nieskończoności
     • ucinanie (zaokrąglanie w stronę zera)
   • flaga flush-to-zero – jeśli ustawiona w przypadku niedomiaru zamiast zgłaszania wyjątku, zapisywana jest liczba zero; działanie nie jest zgodne ze standardem, ale powoduje przyspieszenie programów
2. Maski włączające zgłaszanie wyjątków przy błędach; wykrywane błędy:
   • niewłaściwe argumenty (np. pierwiastkowanie ujemnej liczby),
   • dzielenie przez zero,
   • nadmiar (wynik jest zbyt duży),
   • niedomiar (wynikiem jest liczba nie znormalizowana),
   • niedokładny wynik (wynik nie może być dokładnie reprezentowany).
3. Flagi wskazujące rodzaj błędu – ustawiane automatycznie przez procesor, niezależnie od tego, czy dany błąd jest zgłaszany, czy nie; muszą zostać wyzerowane programowo (zwykle w procedurze obsługi wyjątków SSE).

Przesłania liczb zmiennoprzecinkowych między rejestrami i pamięcią

Rozkazy działają na wektorach liczb zmiennoprzecinkowych (4 elementy).

Pamięć podręczna

W SSE dostępne są trzy grupy rozkazów odnoszące się do pamięci podręcznej.

64-bitowe rozkazy całkowitoliczbowe

Operandami dodatkowych rozkazów całkowitoliczbowych są tylko rejestry MMX; w SSE2 pojawiła się już możliwość wykorzystania również rejestrów SSE.

Rozkazy:

• PAVGB, PAVGW – średnia bajtów/słów bez znaku (tutaj: słowo ma 16-bitów)
• PMAXUB, PMINUB – wybranie bajtów bez znaku o maksymalnej/minimalnej wartości
• PMAXSW, PMINSW – wybranie słów ze znakiem o maksymalnej/minimalnej wartości
• PMOVMSKB – utworzenie maski bitowej z najstarszych bitów wszystkich bajtów
• PMULHUW – starsze słowo z wyniku mnożenia słów bez znaku
• PSADBW – suma modułów różnicy bajtów (tj. ${\displaystyle \sum _{i=0}^{7}|a_{i}-b_{i}|,}$ czyli odległość w metryce manhattan)
• PEXTRW, PINSRW – pobranie/wstawienie dowolnego słowa wektora
• PSHUFW – rozmieszczenie słów w wektorze

Rozszerzenia SSE

Kolejne rozszerzenia do zestawu instrukcji SSE:

• SSE2 – 2000 rok (wprowadzone przez firmę Intel):
  • wprowadzenie działań wektorowych i skalarnych na liczbach zmiennoprzecinkowych podwójnej precyzji,
  • umożliwienie wykonywania działań całkowitoliczbowych na 128-bitowych rejestrach XMM,
  • większa kontrola nad pamięcią podręczną.
• SSE3 – 2004 rok (Intel):
  • dodatkowe rozkazy wektorowe działające na liczbach zmiennoprzecinkowych pojedynczej i podwójnej precyzji,
  • sprzętowe wspomaganie synchronizacji wątków.
• SSSE3 – 2006 rok (Intel):
  • dodatkowe rozkazy wektorowe działające na liczbach całkowitych,
  • rozkaz umożliwiający wyznaczenie zadanej permutacji bajtów w rejestrze XMM.
• SSE4 – 2007 rok (Intel):
  • dodatkowe rozkazy wektorowe działające zarówno na liczbach całkowitych jak zmiennoprzecinkowych,
  • rozkazy wektorowe wspomagające kompresję wideo,
  • rozkazy wektorowe wykonujące działania na łańcuchach znaków,
  • rozkaz wyznaczający sumę CRC-32.
• SSE5 – 2009 rok (AMD):
  • dodatkowe rozkazy wektorowe działające zarówno na liczbach całkowitych jak zmiennoprzecinkowych,
  • wprowadzenie rozkazów trój- i czteroargumentowych, w który jeden z argumentów jest docelowy (rozwiązanie z architektury RISC) – dotychczas rozkazy były 2-argumentowe, z czego jeden był równocześnie docelowy i jeśli jego wartość była potrzebna w dalszej części obliczeń, należało go zapamiętać – w rozkazach 3- i 4-argumentowych takiego problemu nie ma,
  • rozkazy 4-argumentowe pozwalają akumulować wyniki mnożenia według schematu ${\displaystyle w=\pm z+(\pm x\cdot y).}$
• Advanced Vector Extensions – 2010 rok (Intel):
  • dodanie nowych, 256-bitowych rejestrów: część istniejących rozkazów SSE, SSE2, SSE3 i SSSE3, głównie zmiennoprzecinkowych może wykonywać działania na tych rejestrach,
  • kilka rozkazów wektorowych działających wyłącznie na 256-bitowych rejestrach,
  • część istniejących rozkazów może być wykonywana wariantach 3-argumentowych (jak w SSE5),
  • rozkazy 4-argumentowe pozwalają akumulować wyniki mnożenia na liczbach zmiennoprzecinkowych według schematu ${\displaystyle w=\pm z+(\pm x\cdot y),}$
  • zwiększono z 8 do 32 liczbę relacji, które można sprawdzić rozkazami porównania (CMPPS, CMPPD),
  • sprzętowe wsparcie szyfrowania AES.

Zobacz też

• MMX
• 3DNow!
• SSE, SSE2, SSE3, SSSE3, SSE4, SSE5, AVX

Przypisy