Vektor processzor

CRAY-YMP vektor számítógép processzorlapja

Vektor processzorok (más néven vektor számítógépek vagy tömbprocesszorokra ) végrehajt egy bizonyos számítást nagyszámú adat (egy vektorban , vagy tömb ) ugyanabban az időben . Ha sok ugyanolyan típusú adatot ugyanúgy kell feldolgozni (például mátrix műveleteknél ), akkor a vektorprocesszorok jóval felülmúlják a tisztán általános célú processzorokat (pl. X86 ), amelyek az összes adatot egymás után dolgozzák fel. Legalábbis ez az eset áll fenn, amikor a vektor számítógépnek párhuzamos hozzáférése van a fő memóriához is .

Funkcionalitás és alkalmazási területek

A vektorprocesszorokat elsősorban a nagy teljesítményű számítástechnikában (HPC) használják. A Cray szuperszámítógépek vektoros processzorokat használtak. A vektoros számítógépek szállítói a NEC és a Convex Computer Corporation voltak , például a gallium-arzén technológiát alkalmazó C38xx sorozattal , vagy a Fujitsu Siemens Computers VPP sorozatával.

Különösen a HPC-alkalmazásokban gyakran sok azonos típusú adat van, amelyet hasonló módon kell feldolgozni, például a meteorológia és a geológia szimulációiban, ahol gyakran használnak vektoros számítógépeket.

A vektorkomputerek az utóbbi években nagy versennyel szembesültek a párhuzamosan felépített és sok ezer standard processzorból álló számítási klaszterekkel . A HPC-szektoron kívül is elterjedt szabványos alkatrészek igénybevételével a költségek megtakaríthatók, különösen azért, mert az ilyen szabványos processzorok az intenzív technológiai fejlődés következtében nagyon erősek lettek. Az elosztott számítás még olcsóbb .

Azon előnyök miatt, amelyek egy aritmetikai művelet egyidejű végrehajtásából adódnak több adaton (egyetlen utasítás, több adat, SIMD ), az 1990-es évek óta a szokásos processzorokat is kibővítették a megfelelő architektúrára az ilyen típusú számítások felgyorsítása érdekében. Lásd: Az x86-os processzor vagy az AltiVec for PowerPC- processzorok felépítése .

A fent említett vektorprocesszoros alkalmazások mellett a grafikus szimuláció is az egyik fő alkalmazás. Különösen a bonyolult 3D-s játékokhoz kell hatalmas mennyiségű számítás (óriási mátrixműveletek 3D koordinátákon, a képernyő kimenetének antialiazálása ) nagy mennyiségű adatra, ezért a mai grafikus processzorok nagyon hasonlítanak a tiszta vektoros processzorokra.

Vektor processzor a munkahelyen

MIPS architektúra példa

Egy egyszerű példával mutatjuk be a skalár és a vektor processzor közötti különbséget .

${\ displaystyle Y = a \ cdot X + Y}$

X és Y két azonos hosszúságú vektor, az a pedig skaláris mennyiség. Ezt a problémát skaláris processzorokon egy hurok oldja meg. Ugyanezt a hurkot használják a LINPACK benchmarkban is a tesztelt számítógépek teljesítményének meghatározásához. A C szintaxis ez így néz ki:

 for (i = 0; i < 64; i++)
     Y[i] = a * X[i] + Y[i];

Itt feltételezzük, hogy a vektorok 64 elemből állnak.

A MIPS kódban ez a programrészlet így néz ki:

        L.D     F0, a          ; Skalar a laden
        DADDIU  R4, Rx, #512   ; letzte Adresse 512/8 = 64
 Loop:  L.D     F2, 0(Rx)      ; X(i) laden
        MUL.D   F2, F2, F0     ; a * X(i)
        L.D     F4, 0(Ry)      ; Y(i) laden
        ADD.D   F4, F4, F2     ; a * X(i) + Y(i)
        S.D     0(Ry), F4      ; Y(i) speichern
        DADDIU  Rx, Rx, #8     ; Index (i) von X inkrementieren
        DADDIU  Ry, Ry, #8     ; Index (i) von Y inkrementieren
        DSUBU   R20, R4, Rx    ; Rand berechnen
        BNEZ    R20, Loop      ; wenn 0, dann fertig

A VMIPS kódban azonban így néz ki:

 L.D      F0, a       ; Skalar a laden
 LV       V1, Rx      ; Vektor X laden
 MULVS.D  V2, V1, F0  ; Vektor-Skalar-Multiplikation
 LV       V3, Ry      ; Vektor Y laden
 ADDV.D   V4, V2, V3  ; Vektor-Addition
 SV       Ry, V4      ; Resultat speichern

Ez a példa megmutatja, hogy a vektorprocesszor mennyire hatékonyan oldja meg a feladatot. VMIPS esetén hat parancs elegendő, míg a MIPS esetén 64 * 9 + 2 = 578 parancsot hajtanak végre. Főleg nincs hurok. A VMIPS használatával a parancsoknak csak a töredékét kell beolvasni a memóriából és dekódolni.

A MIPS architektúrában a szorzásokat és összeadásokat felváltva hajtják végre, vagyis az összeadásnak mindig meg kell várnia a lassabb szorzást. A vektorkalkulátorban azonban először minden független szorzást végrehajtunk, majd az összes függő összeadást. Ez egy másik jelentős különbség.

Példa egy x86-os architektúrára, magas szintű nyelvbe ágyazva

Az SS86 utasítás kiterjesztést használó x86 processzorarchitektúra aktuális példája . A példa a vektorizált szorzó lebegőpontot mutatja - tömbök egyetlen pontossággal. A bemutatott forráskód magas szintű "C" nyelven van megírva , lényeges inline összeállító részekkel (Intel szintaxis), amelyeket közvetlenül a GCC- vel lehet összeállítani.

//SSE-Funktion zum vektorisierten Multiplizieren von 2 Arrays mit Single-precision-Gleitkommazahlen
//Erster Parameter Zeiger auf Ziel/Quellarray, zweiter Parameter 2. Quellarray, dritter Parameter Anzahl der Gleitkommazahlen in jedem Array
//32-Bit-Version
void mul_asm(float* out, float* in, unsigned int leng)
{
     unsigned int count, rest;

     rest  = (leng*4)%16;
     count = (leng*4)-rest;

     if (count>0){
     // vectorized part; 4 floats per loop iteration
     __asm __volatile__  (".intel_syntax noprefix\n\t"
     "loop:                 \n\t"
     "movups xmm0,[ebx+ecx] ;loads 4 floats in first register (xmm0)\n\t"
     "movups xmm1,[eax+ecx] ;loads 4 floats in second register (xmm1)\n\t"
     "mulps xmm0,xmm1       ;multiplies both vector registers\n\t"
     "movups [eax+ecx],xmm0 ;write back the result to memory\n\t"
     "sub ecx,16            ;increase address pointer by 4 floats\n\t"
     "jnz loop              \n\t"
     ".att_syntax prefix    \n\t"
       : : "a" (out), "b" (in), "c"(count), "d"(rest): "xmm0","xmm1");
     }

     // scalar part; 1 float per loop iteration
     if (rest!=0)
     {
      __asm __volatile__  (".intel_syntax noprefix\n\t"
     "add eax,ecx           \n\t"
     "add ebx,ecx           \n\t"

     "rest:                 \n\t"
     "movss xmm0,[ebx+edx]  ;load 1 float in first register (xmm0)\n\t"
     "movss xmm1,[eax+edx]  ;load 1 float in second register (xmm1)\n\t"
     "mulss xmm0,xmm1       ;multiplies both scalar registers\n\t"
     "movss [eax+edx],xmm0  ;write back the result\n\t"
     "sub edx,4             \n\t"
     "jnz rest              \n\t"
     ".att_syntax prefix    \n\t"
       : : "a" (out), "b" (in), "c"(count), "d"(rest): "xmm0","xmm1");
     }

     return;
}

Vektor processzorok programozása magas szintű programozási nyelvekkel

A fenti példa közvetlenül a gépnyelven van kódolva, ami ma már nem általános, de mindenképpen lehetséges (SIMD Intrinsics vagy inline assembler kódrészek ). A vektorokhoz speciális gépi utasításokkal ellátott architektúrák bármelyiküktől támogatást igényelnek

• párhuzamosító fordítók (vagyis azok, amelyek a forráskódban egy teljes ciklust képesek átalakítani SIMD számítási utasítássá)
• nyelv kiterjesztés a tömb függvények előállításához
• vagy legalábbis speciális könyvtári funkciók révén

Legalábbis az utóbbi két esetben a szoftverfejlesztőnek feltétlenül ismernie kell az architektúrát, majd a speciális funkciókat kell használnia a vektorfeldolgozás használatához.

Lásd még

• Flynn osztályozása
• Párhuzamos számítógépes adatfeldolgozás elosztott processzorokban
• Általános célú számítás a grafikus feldolgozó egységen
• TensorFlow feldolgozó egység

web Linkek

• Utasítások a vektoros programozáshoz ( Memento , 2013. november 6., az Internet Archívumban ) (PDF; 1,03 MB) Cray Research (angol)
• HiCoVec ( Memento 2010. július 10-től az Internet Archívumban ) A HS Augsburg nyílt forráskódú, konfigurálható vektorprocesszora