Definicja intuicyjna:
SSE to dodatkowe rozkazy rozpoznawane przez mikroprocesory firmy Intel oraz kompatybilnych, które pozwalają znacznie szybciej wykonywać obliczenia matematyczne, szczególnie te wykorzystywane w dziedzinie multimediów, co przekłada się na zwiększenie efektywności działania m.in. gier komputerowych, programów graficznych, muzycznych, kodowania filmów i muzyki.
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.
Spis treści |
SSE wprowadza nowy typ danych: 4-elementowy wektor liczb zmiennoprzecinkowych pojedynczej precyzji (ang. 128-bit packed sigle-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:
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 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:
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").
SSE jest zgodne ze standardem IEEE-754. Możliwe jest jednak włączenie pewnych niestandardowych cech, które w niektórych przypadkach przyspieszają obliczenia.
Działania logiczne są wykonywane na poziomie bitów, nie na liczbach zmiennoprzecinkowych:
Porównania w SSE są dwojakiego rodzaju:
Ad. 1. Modyfikujące rejestr SSE w sposób analogiczny jak w MMX: dla tych elementów, dla których wynik porównania jest prawdziwy wszystkie bity w rejestrze docelowym są ustawiane, gdy nieprawdziwy – zerowane. Ten sposób porównania może być zastosowany zarówno dla wektorów (rozkaz CMPPS) jak i skalarów (rozkaz CMPSS).
Przykład testowania, czy liczby są różne (rozkaz CMPNEQPS xmm0, xmm1[1]):
+---------+---------+---------+---------+ | 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 +---------+---------+---------+---------+
Można testować 8 różnych relacji:
Ad. 2. Modyfikujące rejestr flag, dzięki czemu można sterować przepływem sterowania za pomocą rozkazów skoku warunkowego; rozpoznawane są 4 różne relacje liczb: mniejszy, większy, równy oraz unordered. Ten sposób porównania może być stosowany tylko do skalarów, przy czym dostępne są dwa rozkazy: COMISS – sygnalizujący błąd gdy wystąpi nieprawidłowa liczba zmiennoprzecinkowa QNaN lub SNaN oraz UCOMISS – sygnalizująca błąd tylko w przypadku SNaN.
| # | typ źródłowy | typ docelowy | instrukcja |
|---|---|---|---|
| 1 | liczba całkowita | liczba zmiennoprzecinkowa | CVTSI2SS |
| 2 | para liczb całkowitych | para liczb zmiennoprzecinkowych | CVTPI2PS |
| 3 | liczba zmiennoprzecinkowa | liczba całkowita | CVTSS2SI |
| 4 | CVTTPS2PI | ||
| 5 | para liczb zmiennoprzecinkowych | para liczb całkowitych | CVTPS2PI |
| 6 | CVTTPS2PI |
Uwagi:
Rozkazy SHUFPS, UNPCKLPS, UNPCKHPS umożliwiają różnorakie rozmieszczenie ("wymieszanie") elementów, np. odwrócenie kolejności elementów w wektorze.
Rozkazy ustawia na przemian 2 elementy z obu wektorów. UNPCKLPS bierze dwa młodsze elementy (tj. o indeksach 0 i 1), natomiast UNPCKHPS dwa starsze (indeksy 2 i 3). Rozkaz UNPCKLPS xmm1, xmm2 wykonuje:
temp[0] := xmm1[0]temp[1] := xmm2[0]temp[2] := xmm1[1]temp[3] := xmm2[1]xmm1 := temp
zaś UNPCKHPS xmm1, xmm2
temp[0] := xmm1[2]temp[1] := xmm2[2]temp[2] := xmm1[3]temp[3] := xmm2[3]xmm1 := temp
Np.
3 2 1 0 +-----+-----+-----+-----+ xmm1 = | d | c | b | a | +-----+-----+-----+-----+ +-----+-----+-----+-----+ xmm2 = | h | g | f | e | +-----+-----+-----+-----+
Wynik UNPCKLPS:
+-----+-----+-----+-----+ xmm1 = | f | b | e | a | +-----+-----+-----+-----+
Wynik UNPCKHPS:
+-----+-----+-----+-----+ xmm1 = | h | d | g | c | +-----+-----+-----+-----+
Rozkaz bardziej ogólny niż UNPCKxPS, umożliwia wskazanie dowolnych indeksów z wektorów źródłowych za pomocą trzeciego argumentu (stałej natychmiastowej), w którym na każdych kolejnych dwóch bitach zapisane są 4 indeksy. Rozkazowi SHUFPS xmm1, xmm2, imm8 odpowiada:
{ pobranie indeksów }index1_0 := (imm8 AND 00000011b)index1_1 := (imm8 AND 00001100b) SHR 2index2_0 := (imm8 AND 00110000b) SHR 4index2_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 := tempRejestr MXCSR przechowuje:
Rozkazy działają na wektorach liczb zmiennoprzecinkowych (4 elementy).
Przesłanie 4 liczb zmiennoprzecinkowych pomiędzy rejestrem XMM, a pamięcią lub innym rejestrem XMM:
Przesłanie jednej liczby zmiennoprzecinkowej pomiędzy rejestrem XMM, a pamięcią lub innym rejestrem XMM. Rozkaz działa na elemencie 0 rejestrów XMM: przy przesłaniach z rejestru do rejestru tylko on jest zmieniany, przy przesłaniu z pamięci do rejestru zerowane są pozostałe elementy.
Przesłanie 2 liczb zmiennoprzecinkowych pomiędzy rejestrem XMM i pamięcią. Rozkaz MOVLPS działa na elementach 0 i 1 rejestru XMM, natomiast MOVHPS na elementach 2 i 3.
Przesłanie między rejestrami 64-bitów (2 liczb zmiennoprzecinkowych)
Utworzenie 4-bitowej maski z najstarszych bitów każdej z liczb (tj. z bitów znaku) i zapisanie jej do rejestru ogólnego przeznaczenia x86 (EAX, EBX itd.).
W SSE dostępne są trzy grupy rozkazów odnoszące się do pamięci podręcznej.
Rozkazy PREFETCH (PREFETCHT0, PREFETCHT1, PREFETCHT2, PREFETCHNTA) są rodzajami podpowiedzi (ang. hint) dla procesora, wskazującymi, że obszar pamięci powinien znaleźć się wyżej w hierarchii pamięci podręcznej: poziom 1 znajduje się najbliżej procesora, poziom 2 dalej itd. Im "bliżej" procesora znajdują się dane, tym mniejszy jest czas oczekiwania na nie; np. jeśli dane są już w pamięci podręcznej pierwszego poziomu, prawie w ogóle nie trzeba czekać, w przeciwnym razie czas oczekiwania może wynieść kilkanaście, a nawet kilkadziesiąt lub kilkaset cykli maszynowych[3].
Programista czy kompilator wie lepiej kiedy i które dane wykorzystuje – za pomocą rozkazów PREFETCH może odpowiednio wcześniej powiadomić procesor o zapotrzebowaniu i uniknąć tym samym oczekiwania, kiedy dane będą już potrzebne.
Należy zauważyć, że procesor może owych "podpowiedzi" w ogóle nie uwzględnić.
Pamięć podręczna służy m.in. do szybkiego sięgania po ostatnio zapisane informacje. Jednak zauważono, że pewnych przypadkach dane zapisywane z rejestrów do pamięci nie są więcej używane i dlatego nie ma potrzeby, aby zapisywać je w pamięci podręcznej (oraz marnować przy okazji jej ograniczone zasoby).
W SSE wprowadzono trzy rozkazy pozwalające przesłać dane do pamięci z pominięciem pamięci podręcznej:
W przypadku innych przesłań do pamięci, procesor może zakładać, że wszystkie zapisy do pamięci są tymczasowe (ang. temporal) i w ogóle nie uaktualniać zawartości pamięci głównej. Za pomocą rozkazu SFENCE wymusza się synchronizację - patrz bariera pamięci.
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:
, czyli odległość w metryce manhattan)Kolejne rozszerzenia do zestawu instrukcji SSE:
.,