Superkomputery - referat

Architektura systemów komputerowych 2014/15 – REFERAT

Patryk Grądys

1.  SUPERKOMPUTERY

         Superkomputer – komputer znacznie przewyższający możliwościami powszechnie używane komputery, w szczególności dysponujący wielokrotnie większą mocą obliczeniową. Określenie to pojawiło się w latach 60.
w odniesieniu do komputerów produkowanych przez CDC i później przez firmę Cray. Były one produkowane w dziesiątkach egzemplarzy i kosztowały po kilka milionów dolarów.

         Współcześnie większość superkomputerów to pojedyncze egzemplarze, zaprojektowane i wyprodukowane na zamówienie, zazwyczaj z seryjnie produkowanych procesorów i innych podzespołów. Koszty ich produkcji sięgają miliarda dolarów. Od czerwca 2013 najszybszym superkomputerem na świecie jest Tianhe-2 (czyli Droga Mleczna 2), zbudowany w Chinach.

         Współczesne superkomputery uzyskują swoją wydajność dzięki połączeniu wielu tysięcy procesorów i zrównoleglaniu wykonywanych obliczeń.
Z powodów ekonomicznych stosuje się procesory dostępne w produkcji masowej, ponieważ koszty zaprojektowania i wyprodukowania nowych typów procesorów są znacznie wyższe niż koszty produkcji superkomputerów

         Postęp techniczny w dziedzinie informatyki powoduje, że każdy superkomputer staje się przestarzały w ciągu kilku lat i jego używanie przestaje być opłacalne. Maszyny zaliczane dwadzieścia lat temu do klasy superkomputerów miały wydajność porównywalną z dzisiejszymi urządzeniami przenośnymi. Przykładowo iPad 3 w 1993 roku znalazłby się wśród
300 najszybszych superkomputerów świata.

2.  PORÓWNYWANIE WYDAJNOŚCI SUPERKOMPUTERÓW

         Główną miarą wydajności, stosowaną obecnie dla superkomputerów, jest liczba wykonywanych w ciągu sekundy operacji na liczbach zmiennoprzecinkowych (FLOPS). Podaje się ją często z odpowiednim przedrostkiem SI. Przykładowo teraflops („TFLOPS”) to 10¹² FLOPS, a petaflops („PFLOPS”) to 10¹⁵ FLOPS. Mierzy się ją za pomocą odpowiednich testów wzorcowych. Najpopularniejszym takim testem jest LINPACK, mierzący szybkość rozwiązywania gęstych układów równań liniowych za pomocą metody Gaussa.

         Ponieważ wiele problemów stawianych superkomputerom daje się sprowadzić do rozwiązywania takich równań, test ten jest wygodną abstrakcją pomiaru efektywności w rozwiązywaniu takich problemów. Superkomputery uzyskujące najwyższe wyniki w tym teście są od 1993 roku publikowane na liście TOP500.

         Inną miarą wydajności superkomputerów jest miara FLOPS/wat, uwzględniająca oprócz szybkości wykonywania obliczeń również zużycie prądu przez superkomputery. Najefektywniejsze według tej miary superkomputery
z listy TOP500 są publikowane od 2007 roku na liście Green500.

3.  NAJSZYBSZY SUPERKOMPUTER ŚWIATA

         Tianhe-2 (czyli Droga Mleczna-2) – superkomputer o mocy obliczeniowej 33,86 PFLOPS, zbudowany przez NUDT w Chinach. W czerwcu 2013 roku znalazł się na pierwszym miejscu listy TOP500 – superkomputerów o największej mocy obliczeniowej na świecie, prześcigając wcześniejszego rekordzistę Titan,
o mocy obliczeniowej 17,59 PFLOPS.

         Koszty budowy Tianhe-2 wyniosły 390 milionów dolarów. Składa się ze 125 szaf co daje 3 120 000 rdzeni. Tianhe-2 posiada 1,34 PB pamięci operacyjnej i 12,4 PB pamięci masowej. Wymaga do zasilania 17,6 MW mocy. Razem z chłodzeniem zużycie mocy wynosi 24 MW.

4.  SUPERKOMPUTERY W POLSCE

         Najszybszym superkomputerem w Polsce jest Zeus z ACK Cyfronet na Akademii Górniczo-Hutniczej w Krakowie. Maszyna działa pod kontrolą systemu operacyjnego Scientific Linux, jej efektywna moc obliczeniowa wynosi niemal 267 TFLOPS i jest wykorzystywana do obliczeń naukowych, m.in. z zakresu chemii i fizyki.

5.  ZASTOSOWANIE SUPERKOMPUTERÓW

         Superkomputery są używane w armii, badaniach naukowych i biznesie. Instytuty naukowe udostępniają czas swoich komputerów recenzowanym projektom naukowym, których lista jest często publicznie dostępna.

         Przykładowo na komputerach w ICM prowadzone są symulacje astrofizyczne, biochemiczne, hydrologiczne, epidemiologiczne i aerodynamiczne, jak również badania należące do teorii liczb i algebry liniowej.

         Przykładowe zastosowania superkomputerów to:

·        badanie struktury dużych biocząsteczek, takich jak lignina i celuloza,
w celu zwiększania wydajności uzyskiwania z nich biopaliw,

·        symulacje procesu spalania w silnikach spalinowych, w celu zwiększania ich wydajności,

·        symulacje aerodynamiki projektowanych samolotów i samochodów ciężarowych,

·        symulacje zachowania plazmy w tokamakach w badaniach nad kontrolowaną syntezą termojądrową,

·        symulacje oddziaływań pomiędzy kwarkami a gluonami aby uzyskać dokładniejsze dane o parametrach cząstek elementarnych,

·        badanie właściwości nanomateriałów w celu opracowania wydajniejszych superkondensatorów,

·        symulacje zachowania elektronów wewnątrz nanostruktur w celu opracowania przyszłych układów elektronicznych.

6.  LISTA TOP500

         Na stronie top500.org znajduje się lista najlepszych superkomputerów na świecie.

Opracowanie: Patryk Grądys na podstawie artykułów Superkomputer i Tianhe-2 na stronie pl.wikipedia.org oraz informacji na stronie top500.org

Czytaj dalej...

PESEL – C/C++

// PESEL 0.5 // patryk.gradys@gmail.com // ©2015 Patryk Gradys //

#include 
#include 

const short biezacyRok = 2015;

// metoda na liczenie "enterow"
int ileRekordow() {
    FILE * pFile = fopen ("plik.txt","r");;
    char c;
    int n = 0;

    do {
        c = fgetc(pFile);

        if (c == '\n') {
            n++;
        }

    }
    while (c != EOF);
    n += 1;     // ostatni rekord pliku nie ma "entera" na koncu
    fclose (pFile);
    printf ("Ilosc rekordow w pliku: %d\n", n);

  return n;
}

bool zbadajPesel(char* nrPesel) {
    char pesel[11];

    if (strlen(nrPesel) != 11) {
        return false;
    }
    else {
        int i;
        for(i = 0; i < 11; i++) {
            pesel[i] = nrPesel[i] - '0';
        }

        // a+3b+7c+9d+e+3f+7g+9h+i+3j+k

        int suma    =     pesel[0]
                    + 3 * pesel[1]
                    + 7 * pesel[2]
                    + 9 * pesel[3]
                    +     pesel[4]
                    + 3 * pesel[5]
                    + 7 * pesel[6]
                    + 9 * pesel[7]
                    +     pesel[8]
                    + 3 * pesel[9]
                    +     pesel[10];

        if (suma % 10 == 0) {
            return true;
        }
        else {
            return false;
        }
    }
}

short obliczWiek(char* nrPesel) {
    char pesel[11];

    int i;
    for(i = 0; i < 11; i++) {
        pesel[i] = nrPesel[i] - '0';
    }

    short wiek;
    short rokUrodzenia        = 10 * pesel[0] + pesel[1];     // w formacie RR
    short miesiacUrodzenia    = 10 * pesel[2] + pesel[3];     // w formacie MM

    if      (miesiacUrodzenia >= 81 && miesiacUrodzenia <= 92){
        wiek = biezacyRok - (rokUrodzenia + 1800);
    }
    else if (miesiacUrodzenia >= 1  && miesiacUrodzenia <= 12){
        wiek = biezacyRok - (rokUrodzenia + 1900);
    }
    else if (miesiacUrodzenia >= 21 && miesiacUrodzenia <= 32){
        wiek = biezacyRok - (rokUrodzenia + 2000);
    }
    else if (miesiacUrodzenia >= 41 && miesiacUrodzenia <= 52){
        wiek = biezacyRok - (rokUrodzenia + 2100);
    }
    else if (miesiacUrodzenia >= 61 && miesiacUrodzenia <= 72){
        wiek = biezacyRok - (rokUrodzenia + 2200);
    }

    return wiek;
}

int main()
{
    FILE * fileIn   = fopen ("plik.txt", "r");
    FILE * fileOut  = fopen ("data_out.txt", "w");
    fseek(fileOut, 0, SEEK_SET);

    if (fileIn != NULL)
    {
        int n = ileRekordow();
        char imie[30], nazwisko[30], pesel[12];
        int i, wzrost, wiek;

        for(i = 0; i < n; i++) {
            fscanf(fileIn, "%s %s %s %d", &imie, &nazwisko, &pesel, &wzrost);
                if (zbadajPesel(pesel)) {
                wiek = obliczWiek(pesel);
                fprintf(fileOut, "%s %s %d\n", imie, nazwisko, wiek);
            }
        }

        fclose (fileIn);
        fclose (fileOut);

    }
    else {
        printf("Blad odczytu pliku");
    }

    return 0;
}

Czytaj dalej...

Pełna transformata Fouriera z filtrem dolnoprzepustowym – C/C++

//*****PELNA TRANSFORMATA FOURIERA Z FILTREM DOLNOPRZEPUSTOWYM*******************************
// ©2015 Patryk Grądys
#include 
#include 
#include 

const int len = 1024;

struct CMPL //struktura liczby zespolonej
{
 double Re;
 double Im;
};

struct Fourier
{
 CMPL DFT[len];
 CMPL iDFT[len];
}; 

int main()
{
 int i, k, n, syg[len];
 double x;

 struct Fourier *p;  
 p  = (Fourier*)malloc(sizeof(Fourier));
 
 FILE *pFile;
 
 for(n = 0; n < len; n++)
 {
  syg[n] = 0; //zerowanie sygnalu; x_k = 0 <=> syg[n] = 0
 }
 
//*****DEFINIOWANIE SYGNALU******************************************************************
 for(n = 0; n < len; n++)
 {
  if((n > 136) && (n < 148)) {syg[n]=250;} // dla danych przedzialow w zadaniu ustawiam sygnal 250
  if((n > 175) && (n < 211)) {syg[n]=250;} // f(x_k)=250 <=> syg[n]=250; k <=> n
 }
   
//******TRANSFORMATA FOURIERA****************************************************************
 for(n = 0; n < len; n++)
 {
  p->DFT[n].Re = 0.0;
  p->DFT[n].Im = 0.0;
  for(k = 0; k < len; k++)
  {
      p->DFT[n].Re +=  syg[k]*cos(2*M_PI*k*n/len);
      p->DFT[n].Im += -syg[k]*sin(2*M_PI*k*n/len);
  }
 } 
 
//******FILTR DOLNOPRZEPUSTOWY***************************************************************
/*
Amplituda jest rowna 250. 4% amplitudy jest rowne 10.

Po kilku probach dla roznych wartosci indeksu 
filtru dolnoprzepustowego (200,50,25,21,20) okazuje sie, 
ze oscylacje nie przekraczaja wartosci 10 
przy indeksie filtru 21 (i mniejszych).

Najwieksze oscylacje wystepuja przy pierwszym, krotszym sygnale, 
gdzie wahaja sie mniej wiecej w przedziale <240 data-blogger-escaped-259="">

(Arkusz FILTR 21)
*/
 for(n = 0; n < 22; n++) 
    {
     p->DFT[512-n].Re = 0.0;
     p->DFT[512+n].Re = 0.0;
     p->DFT[512-n].Im = 0.0;
     p->DFT[512+n].Im = 0.0;
    }
 
//******ODWROTNA TRNSFORAMTA FOURIERA********************************************************
 for(n = 0; n < len; n++)
    {
     p->iDFT[n].Re = 0.0;
     p->iDFT[n].Im = 0.0;
     
     for(k = 0; k < len; k++)
     {
         p->iDFT[n].Re += (p->DFT[k].Re*cos(2*M_PI*k*n/len) - p->DFT[k].Im*sin(2*M_PI*k*n/len));
         p->iDFT[n].Im += (p->DFT[k].Re*sin(2*M_PI*k*n/len) + p->DFT[k].Im*cos(2*M_PI*k*n/len));
        }
    }
    
//***********************************************************************************************
 
 pFile = fopen ("sygnal.txt", "wt");
    fseek(pFile, 0, SEEK_SET);
    
 for(i = 0; i < len; i++)
    {
     printf (    "%5d %4d %12.7f %12.7f %12.7f %12.7f\n", i, syg[i],  p->DFT[i].Re,  p->DFT[i].Im,  p->iDFT[i].Re,      p->iDFT[i].Im);  
     fprintf(pFile, "%5d %4d %12.7f %12.7f %12.7f %12.7f\n", i, syg[i],  p->DFT[i].Re,  p->DFT[i].Im,  p->iDFT[i].Re/(double)len, p->iDFT[i].Im/(double)len);
    }
    
    free(p);
    fclose(pFile);
 system("PAUSE"); 
 return 0;
}

Czytaj dalej...

Funkcje trygonometryczne na przedziale z zadanym rastrem – C/C++

// ©2015 Patryk Grądys
// Funkcje trygonometryczne na przedziale z zadanym rastrem

#include 
#include 
#include 

int main () {

    int i;
    double x, wynik;
    wynik = 0.0;
    double eps = 0.0000001;
    FILE *pFile;
    
    pFile = fopen ("prog2.txt", "wt");
    fseek(pFile, 0, SEEK_SET);

    printf("   i \t x \t wynik \n\n");         
        
    for(i=0; i<=100; i++) { //ustawiamy 100 wartosci
             x = 2.0*i/100.0-1.0; //przeskalowanie
             
             // bezpiecznik na wypadek dzielenia przez zero, 
             
             if(fabs(x) < eps) {                 
                  wynik = 999999.0; //wowczas wynik = 999999.0 (zeby byl latwo rozroznialny)
             }
             
             else {
             //sin^2(x) = (1-cos(2*x))/2 // z tozsamosci trygonometrycznej
             // Przeksztalcam wzor funkcji na jezyk C:
                              
                  wynik = ((1-cos(2.0*x))/2.0) / (sqrt(1.0-cos(2.0*x)));
             }
                 
             // wyswietlanie wynikow z przedzialu <-1 data-blogger-escaped-1="">
             if (i <= 100) { 
                 printf(          "%4d %8.4f %8.4f \n", i, x, wynik);  
                 fprintf(pFile,   "%4d %8.4f %8.4f \n", i, x, wynik);
             }  
             // co prawda w zadaniu jest mowa o odczycie tylko z dysku, 
             // ale wyswietlam pogladowo, zeby sprawdzic czy aby na pewno 
             // wlasciwie wartosci znajduja sie w pliku       
    }
             
    fclose( pFile);
    
    printf("\n Dane wyswietlane z pliku \n");
    
    // Wyswietlanie danych z pliku
    pFile = fopen ("prog2.txt", "rt");
    fseek(pFile, 0, SEEK_SET);
    
    int k;
    float y, fwynik;
    
    for(i = 0; i<=100; i++) { //wyswietlam 100 wartosci z pliku
          fscanf(pFile, "%d %f %f \n", &k, &y, &fwynik);
          printf("%4d %8.4f %8.4f \n", i, y, fwynik);      
    }
    
    fclose( pFile);
    
    system("PAUSE");
    return 0;
}

Czytaj dalej...

Operacje na liczbach zespolonych – C/C++

// ©2015 Patryk Gradys
// OPERACJE NA LICZBACH ZESPOLONYCH

#include 
#include 
#include 

// STRUKTURA LICZBY ZESPOLONEJ ================================================== 

struct CMPL {
       double Re;
       double Im;
       };

// FUNKCJA DODAWANIA LICZB ZESPOLONYCH
CMPL C_SUM(CMPL z1, CMPL z2) {
         CMPL z3;
         z3.Re = z1.Re + z2.Re;
         z3.Im = z1.Im + z2.Im;
         return z3;
         }
         
// FUNKCJA ODEJMOWANIA LICZB ZESPOLONYCH
CMPL C_SUB(CMPL z1, CMPL z2) {
         CMPL z3;
         z3.Re = z1.Re - z2.Re;
         z3.Im = z1.Im - z2.Im;
         return z3;
         } 
           
// FUNKCJA MNOZENIA LICZB ZESPOLONYCH
CMPL C_MULT(CMPL z1, CMPL z2) {
         CMPL z3;
         z3.Re = z1.Re * z2.Re - z1.Im * z2.Im;
         z3.Im = z1.Re * z2.Im + z1.Im * z2.Re;
         return z3;
         }  
         
// FUNKCJA DZIELENIA LICZB ZESPOLONYCH
CMPL C_DIV(CMPL z1, CMPL z2) {
         CMPL z3;
         double w;
         w=z2.Re * z2.Re + z2.Im * z2.Im;
         
         if (w > 0) {       
             z3.Re = (z1.Re * z2.Re + z1.Im * z2.Im)/w;
             z3.Im = (z2.Re * z1.Im - z1.Re * z2.Im)/w;
             return z3;
         }
         else {
             printf("FUNCTION C_DIV ERROR: Wystapil blad podczas dzielenia \n");
             system("PAUSE");
             exit(10);
             }
         }                  
          
// =============================================================================
// FUNKCJA GLOWNA ==============================================================

int main () {
    
    CMPL z1, z2, z3, z4, z1_7, z2_9, z3_3, z4_5, licznik, mianownik, wynik;
    int i = 0;
    
    z1.Re = 1.0; // zmienna dla z1 (przypisywanie wartosci z zadania)
    z2.Re = 1.0;
    z3.Re = 2.0;
    z4.Re = 0.2;  
    
    z1_7.Re = 0.0; // zmienna dla z1^7 (wstepne zerowanie)
    z2_9.Re = 0.0;
    z3_3.Re = 0.0;
    z4_5.Re = 0.0;
    
    licznik.Re = 0.0; // zmienna dla licznika ulamka
    mianownik.Re = 0.0; // zmienna dla mianownika ulamka
    wynik.Re = 0.0; // zmienna dla wyniku
    
    z1.Im = 1.0; //przypisywanie wartosci z zadania
    z2.Im = -0.2;
    z3.Im = -1.0;
    z4.Im = -0.3;
    
    z1_7.Im = 0.0;  
    z2_9.Im = 0.0;
    z3_3.Im = 0.0;
    z4_5.Im = 0.0;
    
    licznik.Im = 0.0;
    mianownik.Im = 0.0;
    wynik.Im = 0.0;
    
    //obliczanie poteg liczb zespolonych
    
    // z1^7         
    z1_7 = z1;
    for(i = 1; i < 7; i++) {
          z1_7 = C_MULT(z1, z1_7);
          }   
    printf("z1^7:\t %8.4f \t %8.4f \n", z1_7.Re, z1_7.Im);           
    
    // z2^9    
    z2_9 = z2;
    for(i = 1; i < 9; i++) {
          z2_9 = C_MULT(z2, z2_9); 
          }   
    printf("z2^9:\t %8.4f \t %8.4f \n", z2_9.Re, z2_9.Im);     
          
    // z3^3          
    z3_3 = z3;
    for(i = 1; i < 3; i++) {
          z3_3 = C_MULT(z3, z3_3); 
          }  
    printf("z3^3:\t %8.4f \t %8.4f \n", z3_3.Re, z3_3.Im);     
       
    // z4^5      
    z4_5 = z4;
    for(i = 1; i < 5; i++) {
          z4_5 = C_MULT(z4, z4_5);     
          }  
    printf("z4^5:\t %8.4f \t %8.4f \n", z4_5.Re, z4_5.Im);  
          
    // mnozenie liczb z licznika
    licznik = C_MULT(z1_7, z2_9); 
    printf("licznik:\t %8.4f \t %8.4f \n", licznik.Re, licznik.Im);  
    
    // odejmowanie liczb z mianownika  
    mianownik = C_SUB(z3_3, z4_5);     
    printf("mianownik:\t %8.4f \t %8.4f \n", mianownik.Re, mianownik.Im); 
    
    //obliczanie ulamka (dzielenie licznika i mianownika)
    wynik = C_DIV(licznik, mianownik);
    printf("\nWYNIK:\t %8.4f \t %8.4f \n\n", wynik.Re, wynik.Im);   
    
    /*
    z3 = C_SUM(z1, z2); // wywolanie funkcji C_SUM
    printf("Dodawanie \n");
    printf("%7.2f %7.2f \n", z1.Re, z1.Im);
    printf("%7.2f %7.2f \n", z2.Re, z2.Im);
    printf("%7.2f %7.2f \n", z3.Re, z3.Im);
    
    z3 = C_SUB(z1, z2); // wywolanie funkcji C_SUB
    printf("Odejmowanie \n");
    printf("%7.2f %7.2f \n", z1.Re, z1.Im);
    printf("%7.2f %7.2f \n", z2.Re, z2.Im);
    printf("%7.2f %7.2f \n", z3.Re, z3.Im);
    
    z3 = C_MULT(z1, z2); // wywolanie funkcji C_MULT
    printf("Mnozenie \n");
    printf("%7.2f %7.2f \n", z1.Re, z1.Im);
    printf("%7.2f %7.2f \n", z2.Re, z2.Im);
    printf("%7.2f %7.2f \n", z3.Re, z3.Im);
    
    z3 = C_DIV(z1, z2); // wywolanie funkcji C_DIV
    printf("Dzielenie \n");
    printf("%7.2f %7.2f \n", z1.Re, z1.Im);
    printf("%7.2f %7.2f \n", z2.Re, z2.Im);
    printf("%7.2f %7.2f \n", z3.Re, z3.Im);
    
// POTEGOWANIE LICZB ZESPOLONYCH
    int i;
    CMPL z4 = z1;
    printf("Potegowanie \n"); 
    for(i = 0; i < 19; i++) {
          z4 = C_MULT(z1, z4);
          
    // Przy jakim indeksie modul potegi liczby zespolonej bedzie wiekszy niz 1024   
    printf("%3d %10.2f %10.2f %10.3f \n", i, z4.Re, z4.Im, sqrt(z4.Re*z4.Re + z4.Im*z4.Im));   
          }
    */  
    
    system("PAUSE");
    return 0;
}

Czytaj dalej...

Kleopatra – szyfrowanie i certyfikaty

Instrukcja tworzenia certyfikatu (klucz prywatny i publiczny)

1. File -> New Certificate 
2. Create a personal OpenPGP key pair 
3. Wypełnij pola -> Next 
4. Create Key 
5. Wprowadź hasło (Stwórz plik .txt z hasłem, żeby go nie zapomnieć 
6. Make a Backup Of Your Key Pair... (Klucz prywatny) 
7. Podaj ścieżkę (dla .asc zaznacz ASCII armor) -> OK -> Finish 
8. Zaznacz certyfikat -> Export Certificates (Klucz publiczny) 

Zaliczenie

1. Zaszyfrować plik, który wysyłamy kluczem publicznym osoby, do której wysyłamy 
2. Podpisujemy ten plik swoim kluczem prywatnym 
3. Deszyfrujemy swoim kluczem prywatnym 
4. Weryfikujemy kluczem publicznym osoby, od której dostaliśmy informację 

Uwaga!Podpisanie nie szyfruje informacji!

Zmiana PIN-u

• PPM na certyfikacie -> Change Passphrase

Szyfrowanie i podpisywanie pliku

1. File -> Sign/Encrypt files... -> wybieramy plik do podpisania 
2. Zaznaczamy Sign and Encrypt (OpenPGP only) i Text output (ASCII armor) -> Next 
3. Wybieramy certyfikat, którym ma być podpisany plik (ewentualnie klikamy Continue)-> Sign & Encrypt 
4. Finish (generuje nam się zaszyfrowany plik z podpisem) 

Podpisywanie pliku

1. File -> Sign/Encrypt files... -> wybieramy plik do podpisania 
2. Zaznaczamy Sign i Text output (ASCII armor) -> Next 
3. Wybieramy certyfikat, którym ma być podpisany plik (ewentualnie klikamy Continue)-> Sign 
4. Finish (generuje nam się zaszyfrowany plik z podpisem) 

Uwaga!

• Jeśli wysyłamy zaszyfrowany plik - jest to jeden plik
• Jeśli wysyłamy podpisany plik - mamy dwa pliki: tekst jawny i funkcję skrótu (podpis)

1. Import Certificates -> Wybieramy certyfikat 
2. PPM na certyfikacie -> Certify Certificate… -> Zaznaczamy certyfikat i zaznaczamy I have verified the fingerprint -> Next 
3. Zaznaczamy Certify only for myself -> Certify-> Wpisujemy swoje hasło -> Finish 

Deszyfrowanie pliku

• File -> Decrypt/Verify Files…-> Wybieramy plik do zdeszyfrowania -> Ewentualnie możemy wybrać/zmienić ścieżkę pliku wyjściowego -> Decrypt/Verify -> OK 

Uwaga!Przed zaliczeniem będzie trzeba zaimportować klucze jeszcze raz

Czytaj dalej...