Rozdział 10: Niezawodność i tolerancja na błędy w projektowaniu GPU

Wraz z coraz większą powszechnością GPU w zastosowaniach związanych z bezpieczeństwem, takich jak pojazdy autonomiczne, robotyka i urządzenia medyczne, zapewnienie ich niezawodności i tolerancji na błędy staje się kluczowe. Układy GPU są podatne na różne rodzaje usterek i błędów, które mogą prowadzić do awarii systemu, uszkodzenia danych lub nieprawidłowych wyników. W tym rozdziale zbadamy rodzaje usterek i błędów w GPU, schematy wykrywania i korygowania błędów, mechanizmy kontrolne i odzyskiwania, a także zasady projektowania pod kątem niezawodności i odporności.

Rodzaje usterek i błędów w GPU

Usterki i błędy w GPU można sklasyfikować w kilku kategoriach w zależności od ich pochodzenia, czasu trwania i wpływu na system. Zrozumienie tych różnych rodzajów usterek i błędów jest kluczowe dla opracowania skutecznych strategii łagodzenia.

Błędy miękkie

Błędy miękkie, znane również jako usterki przejściowe, są tymczasowymi błędami spowodowanymi przez czynniki zewnętrzne, takie jak promieniowanie kosmiczne, cząstki alfa lub zakłócenia elektromagnetyczne. Błędy te nie powodują trwałego uszkodzenia sprzętu i można je skorygować przez ponowne zapisanie dotkniętych danych lub ponowne uruchomienie dotkniętej operacji.

Błędy miękkie mogą występować w różnych częściach układu GPU, takich jak:

Przerzutniki i rejestry: Pojedyncze zakłócenie zdarzenia (SEU) może spowodować zmianę stanu przerzutnika lub rejestru, prowadząc do nieprawidłowych danych lub przepływu sterowania.
Komórki SRAM: Błędy miękkie w komórkach SRAM, takich jak te używane w pamięciach podręcznych i rejestrach, mogą uszkodzić przechowywane dane.
Komórki DRAM: Chociaż rzadsze niż błędy miękkie w SRAM, komórki DRAM mogą również doświadczać odwrócenia bitów z powodu czynników zewnętrznych.

Rysunek 10.1 ilustruje wpływ błędu miękkiego na przerzutnik.

           Promieniowanie kosmiczne
               |
               |
               v
        +------------+
        |            |
D ----->|  Przerzutnik|----> Q
        |            |
        +------------+
               |
               |
               v
```Miękki błąd

Rysunek 10.1: Miękki błąd spowodowany przez promieniowanie kosmiczne uderzające w przerzutnik.

Twarde błędy

Twarde błędy, znane również jako stałe usterki, są nieodwracalnymi fizycznymi defektami w sprzęcie, które utrzymują się w czasie. Błędy te mogą być spowodowane przez wady produkcyjne, zużycie lub fizyczne uszkodzenie urządzenia.

Przykłady twardych błędów w GPU obejmują:

Błędy typu "stuck-at": Sygnał lub element pamięci jest trwale ustawiony na wartość logiczną '0' lub '1', niezależnie od danych wejściowych.
Błędy zwarciowe: Dwie lub więcej linii sygnałowych są przypadkowo połączone, powodując zwarcie.
Błędy rozłączenia: Linia sygnałowa jest przypadkowo odłączona, powodując nieokreśloną wartość.
Błędy opóźnienia: Sygnał zajmuje więcej czasu niż oczekiwano, aby się rozprzestrzenić przez ścieżkę, prowadząc do naruszeń czasowych.

Rysunek 10.2 pokazuje przykład błędu typu "stuck-at-0" w bramce logicznej.

        Błąd typu "stuck-at-0"
               |
               |
               v
           +---+
        -->| & |-->
           |   |
        -->|   |
           +---+

Rysunek 10.2: Błąd typu "stuck-at-0" w bramce AND.

Błędy przejściowe

Błędy przejściowe to usterki, które występują sporadycznie i trudno je odtworzyć w sposób spójny. Błędy te mogą być spowodowane przez różne czynniki, takie jak:

Marginalne podzespoły: Komponenty działające blisko ich określonych limitów, co czyni je bardziej podatnymi na czynniki środowiskowe lub starzenie się.
Czynniki środowiskowe: Wahania temperatury, zmiany napięcia lub zakłócenia elektromagnetyczne mogą wyzwalać błędy przejściowe.
Efekty starzenia: Wraz z wiekiem urządzenia, niektóre komponenty mogą stawać się bardziej podatne na błędy przejściowe z powodu zużycia lub degradacji.

Błędy przejściowe stanowią znaczne wyzwanie dla wykrywania i korygowania błędów, ponieważ mogą nie być rejestrowane przez tradycyjne techniki testowania lub monitorowania.

Ciche uszkodzenie danych

Ciche uszkodzenie danych (SDC) odnosi się do błędów, które uszkadzają dane bezOto tłumaczenie na język polski:

Wykrywanie błędów cichych (SDC) w GPU

Błędy ciche (SDC, Silent Data Corruption) to błędy, które nie są wykrywane przez sprzęt lub oprogramowanie. SDC może prowadzić do niepoprawnych wyników lub awarii systemu, które mogą pozostać niezauważone przez dłuższy czas.

Przykłady SDC w GPU obejmują:

Błędy arytmetyczne: Usterki w jednostkach arytmetycznych, takich jak dodawacze lub mnożniki, mogą generować niepoprawne wyniki bez podnoszenia jakichkolwiek flag błędów.
Błędy pamięci: Błędy miękkie lub trwałe usterki w komórkach pamięci mogą uszkadzać dane bez wykrycia przez mechanizmy sprawdzania błędów.
Błędy przepływu sterowania: Usterki w logice sterującej lub dekoderach instrukcji mogą spowodować, że program będzie odbiegać od zamierzonej ścieżki wykonania bez wyzwalania wyjątków.

SDC jest szczególnie niebezpieczny, ponieważ może rozprzestrzeniać się w systemie i wpływać na końcowe wyjście bez widocznych objawów. Wykrywanie i łagodzenie SDC wymaga kombinacji technik sprzętowych i programowych.

Schematy wykrywania i korekcji błędów

Aby złagodzić wpływ usterek i błędów w GPU, opracowano różne schematy wykrywania i korekcji błędów. Te schematy mają na celu identyfikację obecności błędów, a w niektórych przypadkach ich korektę, aby zapewnić prawidłowe działanie systemu.

Sprawdzanie parzystości

Sprawdzanie parzystości to prosta technika wykrywania błędów, która dodaje dodatkowy bit (bit parzystości) do każdego słowa danych, aby całkowita liczba bitów '1' była parzysta (parzystość parzysta) lub nieparzysta (parzystość nieparzysta). Sprawdzając parzystość słowa danych, można wykryć pojedyncze błędy bitowe.

Rysunek 10.3 ilustruje przykład sprawdzania parzystości parzystej.

    Słowo danych: 1011010
    Bit parzystości:      1
    Przesłane: 10110101

    Odebrane:   10110111
    Bit parzystości:      0
    Wykryto błąd!

Rysunek 10.3: Sprawdzanie parzystości parzystej w celu wykrywania błędów.

Sprawdzanie parzystości można zastosować do różnych komponentów w GPU, takich jak rejestry, pamięci podręczne i interfejsy pamięci. Jednak sprawdzanie parzystości może wykrywać tylko nieparzyste liczby błędów bitowych i nie może ich korygować.

Kody korekcji błędów (ECC)

Kody korekcji błędów (ECC, Error Correcting Codes) to...Proszę o dostarczenie polskiego tłumaczenia tego pliku Markdown. W przypadku kodu, nie tłumacz kodu, tylko tłumacz komentarze. Oto plik:

Bardziej zaawansowane schematy wykrywania i korygowania błędów, które nie tylko mogą wykrywać błędy, ale także je korygować. ECC działa poprzez dodawanie nadmiarowych bitów do słowa danych, co pozwala odbiorcy na identyfikację i korektę ograniczonej liczby błędów bitowych.

Jednym z powszechnych schematów ECC jest kod Pojedynczej Korekcji Błędu, Podwójnej Detekcji Błędu (SECDED), który może korygować pojedyncze błędy bitowe i wykrywać podwójne błędy bitowe. Kody SECDED są często używane w systemach pamięci, takich jak DRAM i pamięci podręczne, aby chronić przed błędami miękkimi.

Rysunek 10.4 pokazuje przykład kodu SECDED.

    Słowo danych: 1011010
    Bity ECC:      01101
    Przesłane:     101101001101

    Odebrane:      101101011101
                         ^
                         |
                     Błąd bitu

    Skorygowane:   101101001101

Rysunek 10.4: Kod SECDED do korekcji i wykrywania błędów.

Inne schematy ECC, takie jak kody Bose-Chaudhuri-Hocquenghem (BCH) i kody Reeda-Solomona, mogą korygować wiele błędów bitowych kosztem większej redundancji i złożoności.

Redundantne wykonywanie

Redundantne wykonywanie to technika, która wykonuje te same obliczenia wielokrotnie, albo na tym samym sprzęcie, albo na różnych jednostkach sprzętowych, i porównuje wyniki, aby wykryć błędy. Jeśli wyniki nie pasują, wykryto błąd i system może podjąć odpowiednie działania, takie jak ponowienie obliczenia lub zainicjowanie procesu odzyskiwania.

Redundantne wykonywanie może być wdrażane na różnych poziomach w GPU:

Redundancja na poziomie instrukcji: Każda instrukcja jest wykonywana wielokrotnie, a wyniki są porównywane przed zapisaniem do rejestru lub pamięci.
Redundancja na poziomie wątku: Wiele wątków wykonuje te same obliczenia, a ich wyniki są porównywane, aby wykryć błędy.
Redundancja na poziomie jądra: Całe jądro jest wykonywane wielokrotnie, a końcowe wyniki są porównywane, aby wykryć błędy.

Rysunek 10.5 ilustruje redundancję na poziomie wątku w GPU.

    Wątek 0   Wątek 1   Wątek 2   Wątek 3
```Oto polski przekład pliku Markdown. Komentarze w kodzie zostały przetłumaczone, ale sam kod pozostał niezmieniony.

|          |          |          |          |
|----------|----------|----------|----------|
| Comp.    | Comp.    | Comp.    | Comp.    |
|----------|----------|----------|----------|
|          |          |          |          |
|          |          |          |          |
+------------+------------+------------+
|          Komparator                 |
+------------+------------+------------+
|                                    |
|                                    |
            Wykrywanie błędów

Rysunek 10.5: Redundancja na poziomie wątków do wykrywania błędów.

Redundantne wykonywanie może wykrywać szeroką gamę błędów, w tym błędy miękkie, usterki sprzętowe i SDC. Wiąże się to jednak z dłuższym czasem wykonywania i większym zużyciem energii.

Liczniki watchdog

Liczniki watchdog to mechanizmy sprzętowe lub programowe, które monitorują wykonywanie GPU i wykrywają, czy system staje się nieodpowiadający lub nie może ukończyć zadania w określonym limicie czasu. Jeśli licznik watchdog wygaśnie, wskazuje to na błąd, a system może zainicjować proces odzyskiwania, taki jak resetowanie GPU lub ponowne uruchomienie dotkniętej operacji.

Liczniki watchdog mogą być wdrażane na różnych poziomach w GPU:

Licznik watchdog na poziomie jądra: Monitoruje czas wykonywania każdego jądra i wykrywa, jeśli jądro nie zostanie ukończone w określonym limicie czasu.
Licznik watchdog na poziomie wątku: Monitoruje czas wykonywania każdego wątku i wykrywa, jeśli wątek nie zostanie ukończony w określonym limicie czasu.

Mechanizmy kontrolnych punktów i odzyskiwania

Mechanizmy kontrolnych punktów i odzyskiwania służą do zapisywania stanu aplikacji GPU w regularnych odstępach czasu i przywracania stanu w przypadku awarii. Poprzez okresowe zapisywanie stanu aplikacji, system może odzyskać się z awarii bez konieczności ponownego uruchamiania całego obliczenia od początku.

Mechanizmy kontrolnych punktów i odzyskiwania mogą być wdrażane na różnych poziomach w GPU:

Kontrolne punkty na poziomie aplikacji: Sama aplikacja jest odpowiedzialna za zapisywanie i przywracanie swojego stanu.Oto tłumaczenie na język polski:
Checkpointing na poziomie aplikacji: Aplikacja jest odpowiedzialna za zapisywanie swojego stanu w regularnych odstępach czasu. Można to zrobić, jawnie zapisując zawartość pamięci i rejestrów do pliku kontrolnego.
Checkpointing na poziomie systemu: System środowiska uruchomieniowego lub sterownik GPU jest odpowiedzialny za zapisywanie stanu aplikacji. Można to zrobić w sposób przezroczysty dla aplikacji, bez konieczności modyfikowania kodu aplikacji.
Checkpointing na poziomie sprzętu: Sam sprzęt GPU zapewnia wsparcie dla zapisywania i przywracania stanu aplikacji. Można to zrobić przy użyciu dedykowanych mechanizmów sprzętowych, takich jak pamięć nieulotna lub specjalne rejestry.

Rysunek 10.8 ilustruje typowy proces kontrolny i odzyskiwania.

    Normalne wykonywanie
          |
          |
          v
      Checkpoint
          |
          |
          v
    Normalne wykonywanie
          |
          |
          v
       Awaria
          |
          |
          v
        Przywracanie
          |
          |
          v
    Normalne wykonywanie

Rysunek 10.8: Proces kontrolny i odzyskiwania.

Podczas normalnego wykonywania system okresowo zapisuje stan aplikacji do punktu kontrolnego. W przypadku awarii system przywraca stan z ostatniego punktu kontrolnego i wznawia wykonywanie od tego momentu.

Mechanizmy kontrolne i odzyskiwania mogą pomóc w zwiększeniu niezawodności i odporności aplikacji GPU, zwłaszcza w przypadku długotrwałych obliczeń. Jednak wprowadzają one również narzut w postaci miejsca na dysku i czasu wykonywania, ponieważ zapisywanie i przywracanie stanu wymaga dodatkowych zasobów.

Projektowanie pod kątem niezawodności i odporności

Projektowanie GPU pod kątem niezawodności i odporności wymaga połączenia technik sprzętowych i programowych. Niektóre kluczowe zasady i techniki projektowe obejmują:

Wykrywanie i korekcja błędów: Wbudowywanie mechanizmów wykrywania i korekcji błędów, takich jak ECC i kontrola parzystości, na różnych poziomach w GPU, w tym w pamięciach, podręcznych i połączeniach.
Redundancja: Wykorzystywanie redundancji, na przykład przez replikację kluczowych komponentów lub zastosowanie technik tolerancji na błędy.Tutaj jest tłumaczenie na język polski tego pliku Markdown. Dla kodu, nie tłumaczono kodu, tylko komentarze.

Komponenty sprzętowe ant, takie jak dodatkowe rdzenie lub moduły pamięci, w celu zapewnienia odporności na awarie i umożliwienia stopniowej degradacji w przypadku awarii.

Checkpoint i odzyskiwanie: Wdrażanie mechanizmów checkpoint i odzyskiwania, aby zapisywać stan aplikacji i umożliwić odzyskiwanie po awariach.
Izolacja awarii: Projektowanie architektury GPU w celu ograniczenia propagacji błędów i zapobiegania rozprzestrzenianiu się usterek w całym systemie. Można to osiągnąć poprzez techniki takie jak partycjonowanie, izolacja i bariery izolacji błędów.
Odporność oprogramowania: Opracowywanie technik programistycznych, takich jak odporność na błędy oparta na algorytmach (ABFT), które umożliwiają aplikacjom wykrywanie i odzyskiwanie z błędów poprzez redundancję i sprawdzanie na poziomie oprogramowania.
Planowanie uwzględniające niezawodność: Dostosowywanie planowania zadań i zasobów w GPU, aby uwzględnić charakterystykę niezawodności różnych komponentów i zoptymalizować pod kątem wydajności i niezawodności.

Przykład: Planowanie uwzględniające niezawodność w GPU

Rozważmy GPU z wieloma rdzeniami, gdzie niektóre rdzenie są bardziej podatne na błędy niż inne. Planista uwzględniający niezawodność może przypisywać krytyczne zadania lub zadania o wysokich wymaganiach niezawodnościowych do bardziej niezawodnych rdzeni, a mniej krytyczne zadania do mniej niezawodnych rdzeni.

Rysunek 10.9 ilustruje podejście do planowania uwzględniającego niezawodność.

    Kolejka zadań
    +-------+
    | Zadanie1 |
    | Zadanie2 |
    | Zadanie3 |
    | Zadanie4 |
    +-------+
        |
        |
        v
    Planista uwzględniający niezawodność
        |
        |
        v
    +--------+--------+
    | Rdzeń 1 | Rdzeń 2 |
    |  (WN)  |  (NN)  |
    +--------+--------+
    | Zadanie1 | Zadanie3 |
    | Zadanie2 | Zadanie4 |
    +--------+--------+

Rysunek 10.9: Planowanie uwzględniające niezawodność w GPU (WN: Wysoka Niezawodność, NN: Niska Niezawodność).

W tym przykładzie planista przypisuje Zadanie1 i Zadanie2, które mają wysokie wymagania niezawodnościowe, do Rdzenia 1, który jest bardziej niezawodny.Poniżej znajduje się tłumaczenie na język polski:

Wniosek

Niezawodność i tolerancja na błędy są kluczowymi aspektami projektowania i działania GPU, zwłaszcza że GPU są coraz częściej wykorzystywane w aplikacjach o krytycznym znaczeniu dla bezpieczeństwa. Zrozumienie rodzajów usterek i błędów, które mogą wystąpić w GPU, a także technik wykrywania, korygowania i odzyskiwania z tych usterek, jest niezbędne do projektowania niezawodnych i odpornych systemów GPU.

Schematy wykrywania i korygowania błędów, takie jak ECC i sprawdzanie parzystości, odgrywają kluczową rolę w identyfikowaniu i łagodzeniu błędów miękkich i twardych usterek w różnych komponentach GPU. Mechanizmy punktów kontrolnych i odzyskiwania umożliwiają systemowi zapisywanie stanu aplikacji i odzyskiwanie po awariach, poprawiając ogólną odporność systemu.

Projektowanie GPU pod kątem niezawodności i odporności wymaga holistycznego podejścia, łączącego techniki sprzętowe i programowe. Redundancja, izolacja błędów, odporność oprogramowania i planowanie uwzględniające niezawodność to niektóre z kluczowych technik, które można zastosować, aby poprawić niezawodność i tolerancję na błędy GPU.

Ponieważ GPU nadal ewoluują i znajdują nowe zastosowania w dziedzinach takich jak pojazdy autonomiczne, robotyka i ochrona zdrowia, zapewnienie ich niezawodności i odporności będzie coraz ważniejsze. Nowe techniki wykrywania i korygowania błędów, punkty kontrolne i odzyskiwanie oraz zarządzanie zasobami uwzględniające niezawodność będą niezbędne do umożliwienia kolejnej generacji niezawodnych i odpornych na błędy GPU.

Chapter 9 Power Energy and Thermal Management Chapter 11 Gpu Research Directions on Scalarization and Affine Execution