2.203.127.230: Die Begründung ist teilweise falsch (Overhead) und teilweise architekturunabhängig (explizit sequenziell). Vergleich ist mehr eine beobachtete Parallele (oder Eselsbrücke) ohne unmittelbaren Zusammenhang.

2021-02-04T11:27:30Z

Die Begründung ist teilweise falsch (Overhead) und teilweise architekturunabhängig (explizit sequenziell). Vergleich ist mehr eine beobachtete Parallele (oder Eselsbrücke) ohne unmittelbaren Zusammenhang.

Neue Seite

[[Datei:Processor board cray-1 hg.jpg|mini|Prozessorplatine eines CRAY-YMP-Vektor-Computers]]
{{Belege fehlen}}
'''Vektorprozessoren''' (auch '''Vektorrechner''' oder '''Array-Prozessoren''' genannt) führen eine Berechnung gleichzeitig auf vielen Daten (in einem [[Vektor]] bzw. [[Feld (Datentyp)|Array]]) aus. Wenn viele gleichartige Daten auf gleiche Weise bearbeitet werden sollen (beispielsweise bei [[Matrix (Mathematik)|Matrizenoperationen]]), sind Vektorprozessoren reinen Allzweck-[[Prozessor]]en (z. B. [[X86-Prozessor|x86]]), die alle Daten nacheinander bearbeiten, weit überlegen. Dies ist zumindest dann der Fall, wenn der Vektorrechner auch einen parallelen Zugriff auf den [[Hauptspeicher]] hat.

== Funktionsweise und Anwendungsfelder ==
Vektorprozessoren werden vor allem im [[Hochleistungsrechnen|High-Performance-Computing]] (HPC) genutzt. Die [[Cray]]-Supercomputer nutzten Vektorprozessoren. Anbieter von Vektorrechnern waren [[NEC Corporation|NEC]] und die [[Convex|Convex Computer Corporation]], etwa mit der C38xx-Serie, die [[Galliumarsenid]]-Technologie einsetzte, oder [[Fujitsu|Fujitsu Siemens Computers]] mit ihrer VPP-Serie.

Gerade in HPC-Anwendungen fallen oft viele gleichartige Daten an, die auf ähnliche Weise verarbeitet werden sollen, so zum Beispiel bei Simulationen in der Meteorologie und Geologie, wo vielfach Vektorrechner verwendet werden.

Vektorrechner haben in den letzten Jahren große Konkurrenz durch massiv parallel aufgebaute [[Computercluster|Rechencluster]] bekommen, die aus vielen Tausend Standardprozessoren aufgebaut sind. Durch den Rückgriff auf Standardkomponenten, die über den HPC-Sektor hinaus verbreitet sind, lassen sich Kosten sparen, zumal solche Standardprozessoren durch die intensive technologische Entwicklung sehr leistungsfähig geworden sind. Noch günstiger geht es mit [[Verteiltes Rechnen|verteiltem Rechnen]].

Wegen der Vorteile, die sich durch die gleichzeitige Ausführung einer Rechenoperation auf mehreren Daten ergeben (Single Instruction, Multiple Data, [[Flynnsche Klassifikation#SIMD (Single Instruction, Multiple Data)|SIMD]]) haben auch Standardprozessoren seit den 1990er-Jahren Erweiterungen der jeweiligen Architektur erfahren, um diese Art von Berechnungen zu beschleunigen. Siehe dazu Architektur des [[x86-Prozessor]]s oder [[AltiVec]] für [[PowerPC]]-Prozessoren.

Neben der oben genannten Anwendungen für Vektorprozessoren gehört auch die graphische Simulation zu einer Hauptanwendung. Gerade aufwendige 3D-Spiele verlangen enorm viele Berechnungen (Matrizenoperationen auf 3D-Koordinaten, [[Antialiasing (Computergrafik)|Antialiasing]] der Bildschirmausgabe) auf großen Datenmengen, weshalb heutige [[Grafikprozessor]]en große Ähnlichkeiten zu reinen Vektorprozessoren aufweisen.

== Vektorprozessor bei der Arbeit ==
=== MIPS-Architekturbeispiel ===
Anhand eines einfachen Beispiels soll der Unterschied zwischen [[Skalarprozessor|Skalar-]] und Vektorprozessor gezeigt werden.

<math>Y = a\cdot X + Y</math>

X und Y sind zwei Vektoren gleicher Länge und a ist eine skalare Größe. Dieses Problem wird auf Skalarprozessoren durch eine Schleife gelöst. Die gleiche Schleife wird auch im [[LINPACK]]-Benchmark verwendet, um die Leistung der getesteten Rechner zu bestimmen. In [[C (Programmiersprache)|C]]-Syntax sieht das folgendermaßen aus:

<syntaxhighlight lang="c">
for (i = 0; i < 64; i++)
Y[i] = a * X[i] + Y[i];
</syntaxhighlight>

Hier wird angenommen, dass die Vektoren aus 64 Elementen bestehen.

In [[MIPS-Architektur|MIPS]]-Code sieht dieses Programmfragment folgendermaßen aus:
<syntaxhighlight lang="asm">
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
</syntaxhighlight>

In [[VMIPS]]-Code sieht das Ganze jedoch so aus:
<syntaxhighlight lang="asm">
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
</syntaxhighlight>

Dieses Beispiel zeigt, wie effizient der Vektorprozessor die Aufgabe löst. Bei VMIPS genügen sechs Befehle, während bei MIPS <span style="white-space:nowrap">64·9 + 2 = 578</span> Befehle ausgeführt werden. Hauptsächlich entfällt die Schleife. Bei VMIPS muss also nur ein Bruchteil der Befehle aus dem Speicher geholt und dekodiert werden.

Bei der MIPS-Architektur werden Multiplikationen und Additionen abwechselnd ausgeführt, das heißt die Addition muss immer auf die langsamere Multiplikation warten. Beim Vektorrechner hingegen werden zuerst alle unabhängigen Multiplikationen ausgeführt und darauf folgend alle abhängigen Additionen. Dies ist ein weiterer bedeutender Unterschied.

=== Beispiel einer x86-Architektur, in Hochsprache eingebettet ===

Ein aktuelles x86-Prozessorarchitekturbeispiel unter Verwendung der [[Streaming SIMD Extensions|SSE]]-Befehlserweiterung. Das Beispiel zeigt das vektorisierte Multiplizieren von [[Gleitkommazahl]]-[[Feld (Datentyp)|Arrays]] einfacher Genauigkeit. Der gezeigte Quellcode ist in der [[C (Programmiersprache)|Hochsprache „C“]] geschrieben, mit wesentlichen Inline-Assembler-Anteilen (Intel-Syntax), welcher direkt mit dem [[GNU Compiler Collection|GCC]] kompiliert werden kann.

<syntaxhighlight lang="c">
//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;
}
</syntaxhighlight>

== Programmierung von Vektorprozessoren mit höheren Programmiersprachen ==
Das obige Beispiel ist direkt in der Maschinensprache codiert, was heutzutage allerdings nicht mehr üblich, aber durchaus möglich ist (SIMD [[Intrinsische Funktion|Intrinsics]] oder Inline-Assembler-Code-Anteile).
Architekturen mit speziellen Maschinenanweisungen für Vektoren benötigen zur Nutzung dieser aus höheren Programmiersprachen entweder eine Unterstützung durch
* parallelisierende [[Compiler]] (also solche, die eine ganze Schleife im Quellcode in eine SIMD-Rechenanweisung umwandeln können)
* eine Spracherweiterung für die Generierung der Array-Funktionen
* oder zumindest durch spezielle [[Bibliothek (Programmierung)|Bibliotheksfunktionen]]
Zumindest in den letzten beiden Fällen muss der [[Softwareentwickler]] auf jeden Fall die Architektur kennen und die speziellen Funktionen dann auch verwenden, um die Vektorverarbeitung zu nutzen.

== Siehe auch ==
* [[Flynnsche Klassifikation]]
* [[Parallelrechner]] – Datenverarbeitung in verteilten CPUs
* [[General Purpose Computation on Graphics Processing Unit]]
* [[TensorFlow Processing Unit]]

== Weblinks ==
* {{Webarchiv |url=http://static.cray-cyber.org/Documentation/Vector_C.pdf |text=Anleitung zur Vektorprogrammierung |wayback=20131106210422}} (PDF; 1,03 MB) Cray Research (englisch)
* {{Webarchiv |url=http://www.hs-augsburg.de/~kiefer/hicovec/ |text=HiCoVec |wayback=20100710155403}} Quelloffener, konfigurierbarer Vektorprozessor der HS Augsburg

{{Navigationsleiste Prozessorarchitektur}}

[[Kategorie:Prozessorarchitektur nach Verwendung]]

Vektorprozessor - Versionsgeschichte

2.203.127.230: Die Begründung ist teilweise falsch (Overhead) und teilweise architekturunabhängig (explizit sequenziell). Vergleich ist mehr eine beobachtete Parallele (oder Eselsbrücke) ohne unmittelbaren Zusammenhang.