DE102020131951A1

DE102020131951A1 - Vektorisierung von schleifen basierend auf vektormasken und vektorzähldistanzen

Info

Publication number: DE102020131951A1
Application number: DE102020131951.7A
Authority: DE
Inventors: Ilya Burylov; Mikhail Plotnikov; Hideki Ido; Ruslan Arutyunyan
Original assignee: Intel Corp
Current assignee: Intel Corp
Priority date: 2020-03-06
Filing date: 2020-12-02
Publication date: 2021-09-09
Also published as: US11853757B2; US20200210183A1; CN113360158A

Abstract

Systeme, Vorrichtungen und Verfahren können eine Technologie bereitstellen, die identifiziert, dass eine iterative Schleife einen ersten Codeabschnitt umfasst, der ansprechend darauf, dass eine Bedingung erfüllt ist, ausführt, eine erste Vektormaske erzeugt, die einen oder mehrere Fälle, dass die Bedingung für einen oder mehrere Werte eines ersten Vektors von Werten erfüllt ist, und einen oder mehrere Fälle, dass die Bedingung für den ersten Vektor von Werten nicht erfüllt ist, darstellen soll, wobei der erste Vektor von Werten einer oder mehreren ersten Iterationen der iterativen Schleife entsprechen soll, und einen Vektorisierungsprozess der iterativen Schleife basierend auf der ersten Vektormaske durchführt.

Description

TECHNISCHES GEBIET
Ausführungsbeispiele betreffen im Allgemeinen effizienzsteigernde Implementierungen eines Computercodes. Insbesondere betreffen Ausführungsbeispiele die Vektorisierung von Schleifen mit rückwärts gerichteten, iterationsübergreifenden Abhängigkeiten.
HINTERGRUND
Einige Computercodes können Schleifen mit rückwärts gerichteten, iterationsübergreifenden Abhängigkeiten aufweisen. Solche Schleifen können Schleifen umfassen, deren Ausführung von einer Bedingung abhängt und/oder deren Ausführung von einer vorherigen Iteration des Computercodes abhängt. Bei solchen Schleifen kann es sich als problematisch erweisen, sie auszurollen und vektorisiert auszuführen. Zum Beispiel können solche Schleifen für die parallele Ausführung schwer zu vektorisieren sein.
Figurenliste
Die verschiedenen Vorteile der Ausführungsbeispiele werden für einen Fachmann auf dem Gebiet durch das Lesen der folgenden Beschreibung und der beigefügten Ansprüche sowie unter Verweis auf die folgenden Zeichnungen deutlich, wobei:

1 ist gemäß einem Ausführungsbeispiel ein Beispiel eines Vektorisierungsprozesses zum Vektorisieren eines iterativen Computercodes;
2 ist gemäß einem Ausführungsbeispiel ein Flussdiagramm eines Beispiels eines Verfahrens zum Durchführen eines Vektorisierungsprozesses;
3A zeigt gemäß einem Ausführungsbeispiel ein Beispiel eines Computercodes, der für die vektorisierte Ausführung verbessert werden kann;
3B zeigt gemäß einem Ausführungsbeispiel eine detailliertere Analyse des Computercodes;
3C zeigt gemäß einem Ausführungsbeispiel eine Analyse des ersten und des zweiten Vektorblocks (vector chunks) des Computercodes;
3D zeigt gemäß einem Ausführungsbeispiel beispielhafte Befehle und Operationen zum Ausführen eines Vektorisierungsprozesses auf dem Computercode;
4A veranschaulicht gemäß einem Ausführungsbeispiel einen Computercode, der eine durch eine Schleife dargestellte Abhängigkeit umfasst;
4B veranschaulicht gemäß einem Ausführungsbeispiel Operationen zum Identifizieren einer Werteverteilung gemäß dem Computercode;
5 ist gemäß einem Ausführungsbeispiel ein Flussdiagramm eines Beispiels eines Verfahrens zum Vektorisieren einer iterativen Schleife;
6 ist gemäß einem Ausführungsbeispiel ein Flussdiagramm eines Beispiels eines Verfahrens zum Aktualisieren von Distanzen eines Vektorblocks;
7 ist gemäß einem Ausführungsbeispiel ein Diagramm von Messungen eines vektorisierten Codes relativ zu einem skalaren Code;
8 ist gemäß einem Ausführungsbeispiel ein Blockdiagramm eines Beispiels eines Rechensystems.
9 ist gemäß einem Ausführungsbeispiel eine Darstellung eines Beispiels einer Halbleitervorrichtung.
10 ist gemäß einem Ausführungsbeispiel ein Blockdiagramm eines Beispiels eines Prozessors.
11 ist gemäß einem Ausführungsbeispiel ein Blockdiagramm eines Beispiels eines auf einem Multiprozessor basierenden Rechensystems.

BESCHREIBUNG VON AUSFÜHRUNGSBEISPIELEN
1 veranschaulicht einen Vektorisierungsprozess 100, um einen iterativen Computercode 102 zu vektorisieren (z. B. Daten und Computercode in ein vektorisiertes Format wie beispielsweise ein Vektorblock zu bringen) und Ausgabewerte zu berechnen (z. B. durch Verarbeiten einer Operation auf mehreren Paaren von Operanden, die Teil eines selben Vektorstücks sind) in einer vektorisierten Operation des vektorisierten Blocks. Die Vektorisierung kann ein Umwandeln eines Computerprogramms von einer skalaren Implementierung, die jeweils ein einzelnes Paar von Operanden verarbeitet, in eine Vektorimplementierung, die eine Operation auf mehreren Paaren von Operanden gleichzeitig verarbeitet, umfassen. Ein Vektorblock kann eine feste Anzahl von Schleifeniterationen und/oder Elementen umfassen, die in einer einzigen Vektorimplementierung ausführt.
Im Prozess 100 kann der iterative Computercode 102 rückwärts gerichtete, iterationsübergreifende Abhängigkeiten umfassen. Rückwärts gerichtete, iterationsübergreifende Abhängigkeiten können ein Vorhandensein einer dynamischen Datenabhängigkeit einer gegebenen Schleifeniteration von einer vorherigen Schleifeniteration umfassen, wodurch es schwierig wird, Ausgabewerte und/oder Speicherorte (z. B. ein X-Array, Y-Array, Werte von Variablen usw.) der gegebenen Schleifeniteration zu ermitteln oder vorherzusagen. Beispielsweise kann der iterative Computercode 102 einen ersten Codeabschnitt umfassen, der bei Ausführung die Modifikation eines oder mehrerer von einem Array oder einem Wert einer Variablen veranlasst. Konventionelle Ansätze zur Vektorisierung können auf einer festen Anzahl von Schleifeniterationen, genannt ein Vektorblock (vector chunk), ausführen, einen Prozessorcode (z. B. eine einzelne Anweisung (single instruction), mehrere Datenanweisungen und/oder Code) für den Vektorblock erzeugen und dann den gesamten Iterationsraum durch Abarbeitung jedes Vektorblocks verarbeiten. Solche konventionellen Ansätze können schwierig, wenn nicht gar unmöglich, auf einen iterativen Code anzuwenden sein, der rückwärts gerichtete, iterationsübergreifende Abhängigkeiten umfasst, da das Ausmaß der Codeoperationen zum Zeitpunkt der Vektorisierung möglicherweise nicht vollständig verstanden oder dargestellt wird. Daher kann selbst das Vorhandensein einer Vektor-API (z. B. wie beispielsweise bei C++ und/oder C++23) für die Werteerzeugung (z. B. Zufallszahlen-API) nicht ausreichen, um die obige Problematik zu mindern. So kann z. B. unklar sein, wie oft eine bedingte Schleife eine bedingte Verzweigung oder die Ausgabewerte der bedingten Schleife aufgrund der rückwärts gerichteten, iterationsübergreifenden Abhängigkeiten ausführen kann.
Im Gegensatz dazu kann der Prozess 100 Schleifen des iterativen Computercodes 102 mit rückwärts gerichteten, iterationsübergreifenden Abhängigkeiten basierend auf einer Analyse des iterativen Computercodes 102 effizient vektorisieren. Insbesondere kann die Analyse iterationsübergreifende Abhängigkeiten identifizieren und bewahren, sodass jeder Vektorblock (der einen Vektor von Werten umfassen kann) zwischen einem ersten und einem letzten Vektorblock spekulativ ausführen kann (z. B. getrennt von einem direkt vorangehenden Vektorblock und einem direkt folgenden Vektorblock, basierend auf den identifizierten iterationsübergreifenden Abhängigkeiten). Anschließend können spekulativ berechnete Werte in Abhängigkeit von einem vorherigen Vektorblock bei Bedarf durch Vektoroperationen aktualisiert (korrigiert) werden (z. B. wird die Aktualisierungsoperation auf allen Vektorelementen gleichzeitig ausgeführt). Nach der Aktualisierungsoperation können die endgültigen Werte basierend auf dem korrigierten Vektorblock und durch eine Vektoroperation berechnet werden. Jeder Vektorblock kann eine oder mehrere Iterationen einer bedingten Schleife umfassen, die die rückwärts gerichteten, iterationsübergreifenden Abhängigkeiten umfassen. Auf diese Weise kann die Effizienz gesteigert werden, da der iterative Computercode 102 vektorisiert werden kann. Die Vektorblöcke können parallel auf verschiedenen Verarbeitungs- und/oder Ausführungseinheiten eines Prozessors ausgeführt werden. Somit kann jeder Vektorblock auf einer anderen Verarbeitungseinheit und/oder Ausführungseinheit ausgeführt werden. Die Vektorblöcke können einen Vektor von Werten umfassen.
Ferner kann der Prozess 100 eine Anzahl von Werten (z. B. Zufallszahlen, die der Vektor von Werten sind) genau erzeugen, die von der Schleife verwendet werden. Die Schleife kann z. B. einen der Werte verwenden (z. B. einen der Zufallswerte in einem Array speichern), wenn die Bedingung erfüllt ist. Während die Bedingung bei jeder Schleifeniteration ausgewertet werden kann, können die Werte nur verwendet werden, wenn die Bedingung erfüllt ist. Der Prozess 100 kann einen Vektor der Werte erzeugen und eine Anzahl von Schleifeniterationen identifizieren (was als Vektorblock bezeichnet werden kann), der alle diese Werte verbraucht, je nachdem, ob die Bedingung erfüllt oder nicht erfüllt ist. Der Vektorblock der Iterationen kann von einer variablen Größe sein (z. B. ist eine Anzahl der Iterationen, die in einem Vektorblock umfasst sind, variabel), während der Vektor der erzeugten Werte des Vektorblocks von einer festen Größe ist. Im Gegensatz dazu können einige konventionelle Implementierungen Werte (z. B. Zufallszahlen) für einen festen Vektorblock von Iterationen erzeugen, was zu einer variablen Anzahl von Werten für jeden Vektorblock von Iterationen führt. In einem solchen Fall basiert das Erzeugen von Werten auf der Annahme, dass die Bedingung immer erfüllt sein wird, was die Verwendung der Werte in jeder Iteration erfordert. Daher können konventionelle Implementierungen Werte erzeugen, die ungenutzt bleiben oder einen Overhead benötigen, um die verbleibenden Werte in den nächsten Vektorblock von Iterationen zu übertragen, um solche Implementierungen ineffizient zu vektorisieren. Als solches kann der Prozess 100 die Verarbeitungszeit reduzieren und Computerressourcennutzung verbessern, während der iterative Computercode 102 in einem vektorisierten Format genau verarbeitet wird.
Der Prozess 100 kann für eine Mehrzahl von Iterationen des iterativen Computercodes 102 identifizieren, wann die Bedingung erfüllt (z. B. ein erster Zustand) und nicht erfüllt (z. B. ein zweiter Zustand) ist. Die Instanzen des ersten und des zweiten Zustands können in einem Masken-Array wie beispielsweise die Vektormaske 106 gespeichert werden. Zum Beispiel kann der Prozess 100 die Vektormaske 106 basierend auf Identifikationen der erfüllten und nicht erfüllten Bedingung 104 erzeugen. Die Vektormaske 106 kann eine Reihe von Werten, die der nicht erfüllten Bedingung entsprechen (z. B. die „0“-Werte), und eine Reihe von Werten, die der erfüllten Bedingung entsprechen (z. B. die „1“ -Werte), umfassen. Jeder der Werte der Vektormaske 106 kann einer Iteration (z. B. 0. Iteration, 1. Iteration, usw.) der bedingten Schleife entsprechen. Bei einigen Ausführungsbeispielen kann mehr als ein Wert einer Iteration der bedingten Schleife entsprechen, abhängig von den exakten Implementierungen. Somit kann die Vektormaske 106 „Unterbrechungspunkte“ (break points) in einem Code (z. B. wenn eine Bedingung nicht erfüllt ist) während einer bestimmten Auswertung der Bedingung (z. B. während verschiedener Iterationen) und eine Distanz von den „Unterbrechungspunkten“ nachverfolgen.
Der Prozess 100 kann Distanzen zählen, da die Bedingung nicht erfüllt war 108 und speichert die Distanzen in einem Zähldistanz-Array 110. Wie dargestellt, kann das Zähldistanz-Array 110 die Distanz (z.B. eine Anzahl von Bit-Positionen zwischen verschiedenen Bit-Positionen) von jedem zu dem nächstgelegenen „0“-Wert (z. B. nicht erfüllte Bedingung) in der Vektormaske 106 aufzeichnen. Somit kann das Zähldistanz-Array 110 eine Distanz (z. B. Anzahl der Bit-Positionen) zwischen einer jeweiligen Bit-Position in der Vektormaske 106 und einer nächstgelegenen vorhergehenden Bit-Position in der Vektormaske 106 aufzeichnen, der ein Wert („0“) zugewiesen ist, der die Bedingung als nicht erfüllt kennzeichnet.
Es ist zu beachten, dass die Nullposition der Vektormaske 106 zunächst keine weiteren vorangehenden Bit-Positionen in der Vektormaske 106 aufweist. Um dies zu kompensieren, kann der Prozess 100 rechts von der Bit-Position Null den Wert „0“ annehmen (z. B. dass die Bedingung in einer vorherigen Iteration nicht erfüllt war). Das Zähldistanz-Array 110 zeichnet eine Startdistanz von „0“ an der Position Null auf, die die ganz rechte Position in dem Zähldistanz-Array 110 ist. Das heißt, das Zähldistanz-Array 110 kann an der Position Null eine Startdistanz von „0“ voreinstellen (z. B. unter der Annahme, dass diese Bedingung nicht erfüllt wurde).
Es wird darauf hingewiesen, dass sich der Begriff „Position“ nach hiesigem Gebrauch auf die „Bit-Position“ in einer jeweiligen Datenstruktur beziehen kann, wie z. B. die Vektormaske 106, das Zähldistanz-Array 110 und das korrigierte Distanz-Array 114. Somit kann die Bit-Position Null gleich der Position Null sein, die Bit-Position Eins gleich der Position Eins und so weiter. Die Bit-Position Null kann sich auf dem ganz rechten Abschnitt einer jeweiligen Datenstruktur befinden, während die Bit-Position Sieben auf dem ganz linken Abschnitt der jeweiligen Datenstruktur gespeichert werden kann.
Die erste Position des Zähldistanz-Arrays 110 ist ein Wert von „1“, da die Position Null (ganz rechte Position) der Vektormaske 106 einen Wert von „1“ aufweist, was bedeutet, dass die Bedingung erfüllt wurde, und den oben diskutierten angenommenen Wert „0“. Die zweite Position des Zähldistanz-Arrays 110 ist ein Wert von „2“, da die Positionen Eins und Null der Vektormaske 106 beide einen Wert von „1“ aufweisen, was bedeutet, dass die Bedingung bei beiden Auswertungen der Bedingung erfüllt wurde. Im Gegensatz dazu ist die dritte Position des Zähldistanz-Arrays 110 ein Wert von „0“, da die Position Zwei der Vektormaske 106 einen Wert von „0“ aufweist, was bedeutet, dass die Bedingung nicht erfüllt wurde. Ebenso können die restlichen Positionen des Zähldistanz-Arrays 110 Distanzen zu der nächstgelegenen entsprechenden „0“ in der Vektormaske 106 speichern.
Der Prozess 100 kann die Distanzen basierend auf der Historie 112 korrigieren. Wie vorangehend erwähnt wurde, kann das Zähldistanz-Array 110 anfangs keine Historie oder frühere Iterationen annehmen und somit den Wert an der Position Null des Zähldistanz-Arrays 110 auf null voreinstellen. Dies ist möglicherweise nicht immer korrekt. Um die Historie zu berücksichtigen, kann der Prozess 100 eine vorherige Vektormaske und/oder ein vorheriges Zähldistanz-Array abrufen, die beide direkt vorangegangenen Iterationen entsprechen (z. B. Iterationen, die auftreten, direkt bevor die aktuellen Iterationen bearbeitet werden).
Basierend auf der Historie 112 und dem Zähldistanz-Array 110 kann ein korrigiertes Distanz-Array 114 erzeugt werden. Es wird zum Beispiel angenommen, dass das vorherige Zähldistanz-Array an der letzten Position (z. B. an der siebten Position oder ganz linken Position) einen Distanzwert von „1“ gespeichert hat und die vorherige Vektormaske an der letzten Position (z. B. an der siebten Position oder ganz linken Position) einen Wert von „1“ (Bedingung erfüllt) gespeichert hat. Dann kann ein Wert von „2“ (um die Distanz von „1“ an der letzten Position des vorherigen Zähldistanz-Arrays und den Wert von „1“ in der vorherigen Vektormaske zu berücksichtigen) zu den ersten drei Positionen des Zähldistanz-Arrays 110 addiert werden, um die vorherige Historie zu berücksichtigen. Somit können die ersten drei Positionen des korrigierten Distanz-Arrays 114 „4, 3 und 2“ sein. Das heißt, der Wert „0“ in dem Zähldistanz-Array 110 (Position Null) kann zu einer „2“ in dem korrigierten Distanz-Array 114 modifiziert werden, der Wert „1“ in dem Zähldistanz-Array 110 (Position Eins) kann zu einer „3“ in dem korrigierten Distanz-Array 114 modifiziert werden, und der Wert „2“ im Zähldistanz-Array 110 (Position Zwei) kann zu einer „4“ in dem korrigierten Distanz-Array 114 modifiziert werden. Jeder der Werte an den Positionen Null bis Zwei des Zähldistanz-Arrays 110 kann um zwei inkrementiert werden.
Insbesondere wird der Wert zwei nicht zu allen Positionen des Zähldistanz-Arrays 110 addiert, um das korrigierte Distanz-Array 114 zu erzeugen. Der Wert zwei wird zu jedem Element in dem Zähldistanz-Array 10 addiert, bis das zweite Nullelement an Position Vier erreicht ist. Das heißt, ein Wert von „0“ für die Zähldistanz setzt die danach folgenden Zähldistanzwerte zurück. Das erste Nullelement wird spekulativ auf null gesetzt und ist nicht immer korrekt gesetzt und wird daher als rücksetzender Distanzwert ignoriert. Daher wird das zweite Nullelement als das erste „rücksetzende Element“ betrachtet Daher weisen die vierten-achten Positionen Werte des korrigierten Distanz-Arrays 114 auf, die gleich sind wie die vierten-achten Positionen des Zähldistanz-Arrays 110.
Der Prozess 100 kann Ausgabewerte 118 basierend auf der korrigierten Distanz des korrigierten Distanz-Arrays 114 erzeugen, um vektorisierte Berechnungen 116 auszuführen. Im Detail können die vektorisierten Berechnungen eine Verwendung einer Vektor-API umfassen, um einen Vektor von Zufallszahlen zu erzeugen, was die Effizienz steigern und die Latenz verringern kann. Das korrigierte Distanz-Array 114 kann verwendet werden, um vektorisierte Berechnungen auszuführen. Das korrigierte Distanz-Array 114 kann z. B. verwendet werden, um Speicherorte von Werten und/oder Werte anzuzeigen, die während der vektorisierten Ausführung verwendet werden sollen (z. B. gehen Werte mit geraden Distanzen an den X-Array-Ort, Werte mit ungeraden Distanzen gehen an den Y-Array-Ort usw.). Als weiteres Beispiel kann das korrigierte Distanz-Array 114 Werte speichern, die während der vektorisierten Operationen verbraucht werden sollen. Die Ausgangswerte 118 können X-Array-Werte 118a und Y-Array-Werte 118b umfassen. Das korrigierte Distanz-Array 114 kann Werte bestimmen, die in den X-Array-Werten 118a und Y-Array-Werten 118b gespeichert werden.
2 zeigt ein Verfahren 300 zum Durchführen eines Vektorisierungsprozesses. Bei einem Ausführungsbeispiel ist das Verfahren 300 implementiert als ein oder mehrere Module als ein Satz von Logik-Anweisungen, die in einem maschinen- oder computerlesbaren Speichermedium gespeichert sind, wie beispielsweise einem Direktzugriffsspeicher (RAM; random access memory), einem Nur-Lese-Speicher (ROM; read only memory), einem programmierbaren ROM (PROM), Firmware, einem Flash-Speicher usw., in konfigurierbarer Logik wie beispielsweise programmierbaren Logik-Arrays (PLAs; programmable logic arrays), feldprogrammierbaren Gate-Arrays (FPGAs; field programmable gate arrays), komplexen programmierbaren Logik-Vorrichtungen (CPLDs; complex programmable logic devices), in Logik-Hardware mit fester Funktionalität, die Schaltungstechnologie wie beispielsweise anwendungsspezifische integrierte Schaltungs- (ASIC; application specific integrated circuit), komplementäre-Metalloxid-Halbleiter- (CMOS; complementary metal oxide semiconductor) oder Transistor-Transistor-Logik- (TTL; transistor-transistor logic) Technologie oder irgendeine Kombinationen derselben verwendet.
Zum Beispiel kann Computerprogrammcode zum Durchführen der in dem Verfahren 300 gezeigten Operationen in irgendeiner Kombination aus einer oder mehreren Programmiersprachen geschrieben sein, umfassend eine objektorientierte Programmiersprache, wie beispielsweise JAVA, SMALLTALK, C++ oder Ähnliches und herkömmliche prozedurale Programmiersprachen, wie beispielsweise die Programmiersprache „C“ oder ähnliche Programmiersprachen. Zusätzlich dazu könnten Logik-Anweisungen umfassen Assembler-Anweisungen, Befehlssatzarchitektur- (ISA; instruction set architecture) Anweisungen, Maschinenanweisungen, maschinenabhängige Anweisungen, Mikrocode, Zustandseinstelldaten, Konfigurationsdaten für integrierte Schaltungsanordnung, Zustandsinformationen, die elektronische Schaltungsanordnung und/oder andere strukturelle Komponenten personalisieren, die nativ für Hardware sind (z. B. Host-Prozessor, zentrale Verarbeitungseinheit/CPU (central processing unit), Mikrocontroller usw.)
Der dargestellte Verarbeitungsblock 302 identifiziert, dass eine iterative Schleife einen ersten Codeabschnitt umfasst, der ansprechend darauf, dass eine Bedingung erfüllt ist, ausführt. Bei einigen Ausführungsbeispielen kann die Bedingung Teil einer bedingten Anweisung (conditional statement) des iterativen Codes sein. Der dargestellte Verarbeitungsblock 304 erzeugt eine erste Vektormaske, die einen oder mehrere Fälle, dass die Bedingung für einen oder mehrere Werte eines ersten Vektors von Werten erfüllt ist, und einen oder mehrere Fälle, dass die Bedingung für den ersten Vektor von Werten nicht erfüllt ist, darstellen soll, wobei der erste Vektor von Werten einer oder mehreren ersten Iterationen der iterativen Schleife entsprechen soll. Der dargestellte Verarbeitungsblock 306 führt einen Vektorisierungsprozess der iterativen Schleife basierend auf der ersten Vektormaske.
3A zeigt ein Beispiel eines Computercodes 350 (z. B. einen Zähldistanzmustercode), der für die vektorisierte Ausführung verbessert werden kann. Der Code 350 berechnet eine Anzahl von Iterationen (die hier beschriebenen Distanzen entsprechen können) zu der nächstgelegenen vorhergehenden Iteration, wobei Bedingung(i) 356 nicht erfüllt ist, und gibt diese Distanzen im Array x 354 aus. Unterbrechungspunkte können die Iterationen sein, bei denen Bedingung(i) 356 nicht erfüllt ist und die Distanz (d. h. der Wert von „k“) auf null gesetzt wird 358. Insbesondere sorgt die bedingte Anweisung von Bedingung(i) 356 für Unsicherheit, wann der Wert k inkrementiert oder auf null gesetzt wird und welcher Wert gespeichert wird.
3B veranschaulicht eine detailliertere Analyse eines Vektorblocks des Computercodes 350, um Distanzen zu einem nächstgelegenen vorhergehenden Bedingungnicht-Erfüllt- Wert (z. B. dem Wert „0“) zu bestimmen. Eine Tabelle 360 veranschaulicht verschiedene Abschnitte der Analyse. Die Eingabezeile 362 zeigt an, ob die Bedingung bei einem bestimmten Versatz 368 erfüllt oder nicht erfüllt ist. Eingabe 362 kann einer „k-Maske“ oder einer Vektormaske entsprechen. Eine „0“ in der Eingabezeile 362 bedeutet, dass die Bedingung nicht erfüllt ist, während eine „1‟ in der Eingabezeile 362 bedeutet, dass die Bedingung erfüllt ist. Die Zeilen 364 veranschaulichen verschiedene Operationen und Befehle, die ausgeführt werden können, um einen Vektor von Distanzen zu berechnen, auch bezeichnet als „Vdistance“, 366. Der Versatz 368 kann sich auf eine Position (z. B. eine Spalte) innerhalb der Tabelle 360 beziehen. Zum Beispiel kann die Position Null des Versatzes 368 einen „1“-Wert für die Eingabezeile 362 und einen „0“-Wert für Vdistance 366 (distance = Distanz) aufweisen.
Vdistance 366 misst die Distanz zu der nächstgelegenen vorhergehenden „0“ in der Eingabezeile 362. Die nächstgelegene vorhergehende „0“ kann eine „0“ in der Eingabezeile 362 bedeuten, die sich an einer früheren Position des Versatzes 368 befindet, die vor einer aktuellen Position des Versatzes 368 liegt, innerhalb der ein bestimmtes Element von Vdistance 366 gespeichert wird. Der Wert des bestimmten Elements von Vdistance 366 kann eine Anzahl von Positionen des Versatzes 368 sein, die zwischen der vorherigen Position und der aktuellen Position sind.
Wenn es in der Eingabezeile 362 für die aktuelle Position keine vorhergehende „0“ gibt, kann eine neue Versatzposition erzeugt werden. Zum Beispiel kann die Eingabezeile 362 mit vorhergehender „0“ verkettet sein. Dabei kann Vdistance 366 basierend auf einem Wert von „0“ berechnet werden, der effektiv in einer Negative-Eins- (d.h. „-1“) Position des Versatzes 368 (nicht abgebildet) und/oder Eins-Position rechts von der Position Null des Versatzes 368 ist.
So wird z. B. der Vdistance 366 an Position Sechs des Versatzes 368 auf den Wert „2“ gesetzt, weil die nächstgelegene vorhergehende „Null“ der Eingabezeile 362 zwei Positionen entfernt oder an Position Drei des Versatzes 368 ist. Als weiteres Beispiel wird der Vdistance 366 an Position Zwei des Versatzes 368 auf den Wert „2“ gesetzt, weil es in der Eingabezeile 362 keine nächstgelegene vorhergehende „Null“ gibt. Im Detail kann eine „0“ an einer Versatz 468- Position unmittelbar rechts von der Versatzposition „0“ (z. B. Position „-1“) hinzuaddiert werden. Somit ist die Distanz zwischen der Position Zwei des Versatzes 368 und der Position Negative Eins des Versatzes 368 2, und somit weist Vdistance 366, der der Position zwei des Versatzes 368 entspricht, den Wert zwei auf. Es ist zu beachten, dass die „0“ an der Position „-1“ des Versatzes 368 nur unter bestimmten, oben beschriebenen Umständen zur Berechnung des Vdistance 366 verwendet werden kann, und nicht für andere Berechnungen genutzt werden kann. Somit kann die „0“ an der Versatz- 368 Position Negative Eins nach der Berechnung des entsprechenden Vdistance 366 verworfen werden.
Die Versätze 368 können einer Anzahl von Elementen in einem Vektor oder Vektorblock entsprechen. Bei diesem speziellen Beispiel kann ein Vektor oder ein Vektorblock acht Elemente aufweisen. Es wird jedoch darauf hingewiesen, dass unterschiedliche Anzahlen von Elementen und Vektorgrößen verwendet werden können, ohne von dem Schutzbereich der hier beschriebenen Ausführungsbeispiele abzuweichen. Es ist ferner zu beachten, dass Zeilen 364 eine Sequenz von 4 AVX512-Befehlen umfassen, die als „CountRightZeroDist“ bezeichnet werden kann, die Distanzen zu der nächstgelegenen vorhergehenden Null in einer Eingabe-k-Maske zählt (d. h. Distanz zu der Iteration, bei der die Abhängigkeit k++ abbricht). AVX512 können 512-Bit-Erweiterungen einer 256-Bit-Advanced-Vector-Extensions-Anweisung für SIMD-Anweisungen (Single Instruction, Multiple Data) für die x86-Befehlssatzarchitektur (ISA) sein. Je nach der zugrundeliegenden Architektur eines Rechensystems können auch andere Befehlsarten (types of instructions) verwendet werden.
3C zeigt eine Analyse des ersten und des zweiten Vektorblocks 378, 376 des Codes 350 von 3A nebeneinander in Tabelle 370. Abschnitte der Tabelle 360 werden in den zweiten Vektorblock 376 übernommen. Das heißt, die Tabelle 360 kann dem zweiten Vektorblock 376 entsprechen. Die Analyse umfasst eine Maske von Bedingungsergebnissen für den ersten Vektorblock 378 von 8 Iterationen (K1_previous) als Eingabe, dann kann eine Operation (z. B. CountRightZeroDist) einen Vektor von Distanzen (Vdistance (previous)) des ersten Vektorblocks 378 erzeugen.
Wird beim Abtasten vom i-ten Bit nach rechts kein „Null“-Wert angetroffen, geben einige Operationen (z. B. CountRightZeroDist) für dieses Bit die Positionsnummer (i) zurück, als ob in dem K1_previous (z. B. der Maske) eine 0 unmittelbar vorhergegangen wäre. Solche Operationen können über den ersten Vektorblock 378 korrekt ausführen, sodass der sich ergebende Vektor von Vdistance mit den tatsächlichen Distanzen für den ersten Vektorblock 378 genau übereinstimmt. Der erste Vektorblock 378 kann zum Beispiel die ersten Iterationen des Computercodes 350 sein. Solche Operationen führen möglicherweise nicht mit absoluter Präzision auf dem zweiten Vektorblock 376 aus, was zu einem Vektor für den Vdistance führt, der sich von einer sich ergebenden korrigierten Ausgabe für die ersten 3 Elemente unterscheidet (z. B. bis zu Positionen umfassend die erste 0 in den Bits der Bedingungsergebnisse k1).
Das heißt, die Prüfungsiterationen 372 können die Iterationen 8-10 in dem zweiten Vektorblock 376 umfassen, die die Iterationen sind, die das erste 0-Bit (Iteration 10) in den Bits der Bedingungsergebnis-k1-Maske und irgendwelche vorhergehenden Iterationen (Iterationen 8 und 9) umfassen, die dem ersten 0-Bit vorausgehen. Das heißt, da es vorhergehende 1en in k1 Previous gibt, die nicht berücksichtigt wurden, sollten die Vdistance-Werte der Prüfungsiterationen 372 auf die tatsächlichen Distanzen und basierend auf den vorhergehenden 1en in k1 Previous modifiziert werden. Diese inkorrekten Elemente können ausgewählt und aktualisiert werden, indem eine Basisdistanz aus dem ersten Vektorblock 378 hinzuaddiert wird. Bei diesem speziellen Beispiel können die Vdistance-Werte der Prüfungsiterationen 372 basierend auf den Bits der Bedingungsergebnisse (K1 previous) der fünften, sechsten und siebten Iteration 374 des ersten Vektorblocks 378 und/oder Vdistance(previous) der siebten Iteration des ersten Vektorblocks 378 aktualisiert werden.
Zum Beispiel kann ein Wert von zwei zu den Vdistance-Werten der Prüfungsiterationen 372 hinzuaddiert werden. Der Wert zwei kann einer Anzahl der Iterationen (oder Bit-Positionen bei einigen Ausführungsbeispielen) des ersten Vektorblocks 378 entsprechen, die von der höchsten Iterationsnummer (z. B. 7. Iteration) in Richtung der niedrigsten Iterationsnummer (z. B. 0. Iteration) durchlaufen werden, bis das erste „0“-Bit in den Bits der Bedingungsergebnisse (K1 Previous) erreicht wird. Bei diesem speziellen Beispiel werden die beiden Iterationen (Iteration 7 und Iteration 6) durchlaufen, bis das erste „0“-Bit bei Iteration 5 erreicht wird. Somit wird die Zahl auf zwei gesetzt. Bei einigen Ausführungsbeispielen kann ein solches Durchlaufen durch Zählen führender Nullen einer negierten K1_Previous-Maske (z. B. einer invertierten K1_Previous-Maske) erfolgen. Der Wert zwei für die Basisdistanz kann auch aus dem Vdistance (previous) hergeleitet werden. Zum Beispiel kann der Wert des Vdistance (previous) in Iteration 7 um eins inkrementiert werden (um zu berücksichtigen, dass der Bitwert des K1 Previous ein Wert von „1“ ist) und zu den Vdistance-Werten der Prüfungsiterationen 372 des zweiten Vektorblocks 376 hinzuaddiert werden, um die tatsächlichen Distanzen zu erzeugen.
Insbesondere werden die Iterationen 11-15 des zweiten Vektorblocks 376 nicht basierend auf dem ersten Vektorblock 378 angepasst, da die Iterationsnummer 10 einen Wert von 0 in den Bits der Bedingungsergebnisse (K1) aufweist, der die Kontinuität mit dem ersten Vektorblock 378 unterbricht (setzt den aktuellen Distanzwert auf 0 zurück). Die X-Array-Ausgabe des zweiten Vektorblocks 376 kann gleich den tatsächlichen Distanzen des zweiten Vektorblocks 376 sein. Somit kann während der Vektorisierungsoperationen die X-Array-Ausgabe des zweiten Vektorblocks 376 basierend auf den tatsächlichen Distanzen des zweiten Vektorblocks 376 bestimmt werden. So können z. B. die tatsächlichen Distanzen in die Vektoroperation übergeben und zum Bestimmen der X-Array-Ausgaben für die richtigen Indizes des X-Arrays verwendet werden.
Es ist zu beachten, dass Vdistance und Vdistance (previous) ein Ergebnis einer „CountRightZeroDist“-Operation sein können. Die Operation „CountRightZeroDist“ wurde oben beschrieben und eine weitere Beschreibung wird der Kürze halber weggelassen.
3D zeigt beispielhafte Befehle (commands) und Operationen zum Ausführen eines Vektorisierungsprozesses auf dem Computercode 350. Das heißt, 3D zeigt eine detaillierte Reihe von Befehlen und Operationen in Form einer Tabelle 390, die die Vdistance-Werte der Prüfungsiterationen 372 von 3C auswählen und auf die tatsächlichen Distanzen aktualisieren kann. Wie dargestellt, umfasst K3 Werte 392, die auf 1 gesetzt sind. Die Werte 392 können den Prüfungsiterationen 372 entsprechen. K3 kann eine Maske sein, die Einstellungsbits für Prüfungsiterationen 372 von 3C hält, und nicht gesetzte Bits für alle anderen Iterationen 11-15 von 3C. Bei einem Ausführungsbeispiel kann diese Maske durch eine Sequenz von zwei Anweisungen erzeugt werden, wie beispielsweise K2=K1+1 und K3=KXOR(K1,K2). Wie vorangehend beschrieben wurde, ist die aus dem ersten Vektorblock 378 beibehaltene Basisdistanz 2, da es zwei führende Einsen im Abschnitt 394 der Maske K1_previous gibt. Bei diesem Beispiel wird die Basisdistanz durch führende Nullen des Abschnitts 396 der negierten Maske K1_previous gezählt. Der Wert „2“ der Basisdistanz kann dann an den vtmp-Vektor der Korrekturanalyseiterationen 398 rundgesendet werden, die den Prüfungsiterationen 372 von 3C entsprechen. Anschließend kann der Wert zwei zu jedem der Vdistance-Werte der Korrekturanalyse 398 hinzuaddiert werden, um die tatsächlichen Vdistance-Werte der Korrekturanalyse 398 zu erhalten.
Eine vektorisierte Schleife, die dem Code 350 von 3A entspricht, der gemäß dem
oben Beschriebenen verarbeitet wird, kann als folgender Pseudocode dargestellt werden:

           base-dist = 0;
           for(i=0; i<N; i+=VL){
              k1 = vector_condition(i);
              vdistance = CountRightZeroDist(k1);
              k3 = kxor(k1+1, k1);
              vtmp{k3}{z} = broadcast(base_dist);
              vdistance{k3} = vadd(vdistance, vtmp);
              vstore(X+i, vdistance);
              base-dist = lzcnt(knot(k1));

Pseudocode-Beispiel

4A stellt einen Computercode 400 dar, der ein Beispiel einer Abhängigkeit umfasst, die durch die Schleife 402 dargestellt wird (z. B. eine bedingte Zufallszahlengenerierungsschleife). Die Schleife 402 konsumiert eine Eingabefolge von Werten (z. B. eine Folge von Pseudo-/Quasi-Zufallszahlen) und teilt die Werte basierend auf der Bedingung 406 bedingt in 2 Bins an Eingabe- und Ausgabesequenzen 404 und 408. Konventionelle Implementierungen identifizieren vor der Ausführung möglicherweise nicht, wie viele Werte von Vektorblöcken der Iterationen oder von der gesamten Schleife 402 verbraucht werden. Weiterhin konsumiert eine Ausgabefolge 408 Werte aus derselben Eingabefolge 404. Das bedeutet, dass eine dynamische Datenabhängigkeit einer bestimmten Schleifeniteration von der Vorhergehenden besteht. Wenn es somit eine Folge von 24 Zufallszahlen gibt, ist es möglicherweise nicht offensichtlich, welche der Werte in X-bin und welche in Y-bin fallen, ohne alle vorherigen Iterationen zu berücksichtigen, und wie viele Werte in jedem Bin sein werden.

4B veranschaulicht Operationen in einer Tabelle 450, um zu identifizieren, ob und an welchen Punkten bei der Ausführung des Codes 400 Zufallswerte in den Y-Bin eingegeben werden. Im Detail kann eine Folge von Zufallszahlen 456 vor Vektorisierungsoperationen durch mehrere Vektorblöcke von Werten unter Verwendung einer spezialisierten Vektorisierungs-Anwendungsprogrammierschnittstelle für Vektorisierungsoperationen erzeugt werden. Zum Beispiel kann der Vektorisierungsprozess 100 sicherstellen, dass Werte aus allen Blöcken, wie beispielsweise dem ersten und zweiten Block 468, 470, mit Ausnahme des letzten Blocks, wie beispielsweise dem dritten Vektorblock 472, vollständig von dem Code 400 konsumiert werden. Dies kann die Effizienz steigern. Das heißt, da einige andere Implementierungen möglicherweise nicht identifizieren, wie viele Zufallszahlen verwendet werden, können die anderen Implementierungen ineffizient ein Modell übernehmen, das auf dem Erzeugen von mehr Zufallszahlen beruht, als wahrscheinlich benötigt werden. Der letzte Block, wie beispielsweise der dritte Vektorblock 472, kann eine separate Verarbeitung durch skalare Ausführung oder durch Vektorausführung mit spezifischer Restmaske erfordern (z. B. eine Anzahl von generierten Werten, die noch verschwendet werden können, ist nicht mehr als die Größe des Vektorblocks).

Bei der ausgewerteten Bedingung (Vergleichsmaske) 458 stellt ein „*“-Wert Elemente dar, für die die Bedingung 406 bei skalarer Ausführung nicht ausgewertet wird. Das heißt, in einigen Fällen kann die Bedingung 406 irrelevant sein, um zu bestimmen, in welchem Array die Zufallszahl verteilt wird. Wenn z. B. die Bedingung 406 wahr ist, wird die nächste Zufallszahl in dem Y-Bin gespeichert. Nachdem die Zufallszahl in dem Y-Bin gespeichert ist, wird die folgende Zufallszahl unabhängig von dem Ergebnis der Bedingung in dem X-Bin gespeichert. Somit kann der der Bedingungsmaske zugewiesen werden, wobei die Zufallszahl in dem Y-Array gespeichert wird, und somit wird unabhängig von dem Bedingungswert eine folgende Zufallszahl in dem X-Array gespeichert. Die Ausgabeverteilung 462 stellt dar, wo die Zufallszahlen gespeichert werden (z. B. ein bestimmtes Array-Element in dem X-Array oder Y-Array).

Bei einigen Ausführungsbeispielen können die „*“-Werte auf „1“-Werte gesetzt werden. Dies kann zu durchgehenden Blöcken von „1“-Werten führen, wie beispielsweise in den Elementen 452. In dem Block der Elemente 452 soll an geraden Positionen (0, 2, 4, 6 von dem rechten Rand aus gezählt) die Zufallszahl in dem X-Array gespeichert werden und an ungeraden Positionen (z. B. 1, 3, 5, 7 von dem rechten Rand) die Zufallszahlen in dem Y-Array gespeichert werden. Der Vdistance 460 kann basierend auf der Annahme bestimmt werden, dass die „*“-Werte „1“-Werte sind. Der Vdistance460 kann sich danach richten, ob eine Zufallszahl der Folge von Zufallszahlen 456 in dem X-Array oder in dem Y-Array gespeichert ist, wie oben angegeben. Einige hier beschriebene Ausführungsbeispiele können veranschaulichen, dass tatsächliche Werte von „*“ für die Korrektheit der Vektorisierung des Codes 400 keine Rolle spielen. Das heißt, gerade Werte von Vdistance 460 repräsentieren, dass die Ausgabe (z. B. eine Zufallszahl) in dem X-Array gespeichert wird, während ungerade Werte von Vdistance 460 repräsentieren, dass die Ausgabe (z. B. eine Zufallszahl) in dem Y-Array gespeichert wird.

Bei einigen Ausführungsbeispielen können ein oder mehrere „*“-Werte der Elemente 452 als ein Wert „0“ anstelle eines Wertes „1“ interpretiert werden. Die oben genannten Regeln können jedoch nicht geändert werden: X-Elemente entsprechen geraden Werten von Vdistance 460 und Y-Elemente entsprechen ungeraden Werten von Vdistance 460. Weiterhin kann das nächste Element zu „0“ in der ausgewerteten Bedingung (Vergleichsmaske) 458, d. h. das Element mit einem Vdistance 460- Wert von „0“, immer in das X-Array gehen. Das bedeutet also, dass ein Wert von „0“ in der ausgewerteten Bedingung (Vergleichsmaske) 458 die Datenabhängigkeit unterbricht und die gesamte Vorgeschichte der X- und Y-Elemente löscht.

Es ist zu beachten, dass Elemente 454 der Iterationsnummer 10 den zweiten Vektorblock 470 und den dritten Vektorblock 472 überspannen, was eine Aktualisierung ähnlich der oben beschriebenen Tabelle 390 erfordern kann, z. B. ähnlich der Beschreibung von 3D. Zum Beispiel wird e15 während des zweiten Vektorblocks 470 im X-Array gespeichert. Außerdem zeigt die ausgewertete Bedingung (Vergleichsmaske) 458 an, dass die Bedingung während derselben Iteration erfüllt ist, in der e15 in dem X-Array gespeichert wird. Wenn der dritte Vektorblock 472 nicht wusste, dass die Bedingung in e15 erfüllt ist, dann kann die Zufallszahl e16 in dem X-Array anstatt dem Y-Array gespeichert werden, was ein Fehler wäre. Um darauf einzugehen wird eine Basisdistanz durch Zählen führender „1‟ er in der Vergleichsmaske 458 des zweiten Vektorblocks 470 berechnet und zu den Elementen des dritten Vektorblocks 472 hinzuaddiert, die durch eine Korrekturanalyse identifiziert wurden, ähnlich wie oben in Bezug auf die Korrekturanalyse 398 beschrieben. Im Gegensatz dazu können einige Ausführungsbeispiele eine Vorgeschichte der ersten, zweiten und dritten Vektorblöcke 468, 470, 472 über die ausgewertete Bedingung (Vergleichsmaske) 458 und Vdistance 460 bereitstellen. Die Generierung der ausgewerteten Bedingung (Vergleichsmaske) 458 und des Vdistance 460 kann somit genaue Berechnungen während der Ausführung des ersten, zweiten und dritten Vektorblocks 468, 470, 472 ermöglichen.

Somit kann während der Ausführung des ersten, zweiten und dritten Vektorblocks 468, 470, 472 ein Bestimmen, ob der Vdistance 460, der in der ausgewerteten Bedingung (Vergleichsmaske) 458 zu der nächstgelegenen Null zählt, ungerade oder gerade ist, die Erzeugung der X-Maske 464 und der Y-Maske 466 ermöglichen. Wenn z. B. der Wert von Vdistance 460 ungerade ist, wird die Zufallszahl in dem Y-Array gespeichert, und ein Wert in der Y-Maske 466 wird auf „1" gesetzt, um anzuzeigen, dass die Zufallszahl in dem Y-Array gespeichert wird. Wenn der Wert von Vdistance 460 gerade ist, wird außerdem eine Zufallszahl in dem X-Array gespeichert, und ein Wert in der X-Maske 464 wird auf „1“ gesetzt, um anzuzeigen, dass die Zufallszahl in dem X-Array gespeichert wird. Die X-Maske 464 ist also komplementär zu der Y-Maske 466. Ein Prozessor kann während der Ausführung des ersten, zweiten und dritten Vektorblocks 468, 470, 472 auf die X-Maske 464 und die Y-Maske 466 zugreifen oder dieselben erzeugen, um Elemente basierend auf Komprimierungsanweisungen in entsprechende X- und Y-Ausgabe-Arrays zu komprimieren.

Eine letzte Vektoriteration erfordert möglicherweise eine spezielle Bearbeitung. Wenn z. B. eine Gesamtzahl von Iterationen N=12 ist, dann ist das letzte X-Element X11 und das letzte Y-Element ist Y6, da einige Iterationen jeweils einen X-Wert und einen Y-Wert während derselben Iteration verarbeiten können. Alle anderen Elemente 474 sollten durch zusätzliches Anwenden geeigneter Masken auf die X-Maske 464 und die Y-Maske 466 ausgeblendet (masked out) werden. Alternativ kann der gesamte Rest nicht vektoriell, sondern skalar verarbeitet werden (z. B. skalare Elemente Y5, X11, Y6).

Der folgende Pseudocode kann ein Verarbeiten von 32-Bit-Fließkommazahlen gemäß einigen Ausführungsbeispielen ermöglichen:

      static _m512i countRightZeroDist(_mmask16 cmp_mask){

       _m512i vconstFFFF = _mm512_setl_epi32(-1);
       _m512i vcount = _mm512_set_epi32(17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27,

      28,29, 30, 31, 32);

       _m512i v1 = _mm512_broadcastmw_epi32(cmp_mask);
       _m512i v2 = _mm512_sllv_epi32(v1,vcount);
       _m512i v3 = _mm512_andnot_epi32(v2,vconstFFFF);
       _m512i dest = _mm512_lzcnt_epi32(v3);

       return dest;

      }

      void ref065(float* x, float* y, float xIfConst){

       const int n = iter_count;
       svrng_engine_t svrng_generator = svrng_new_rand0_engine(555);
       svrng_distribution_t svrng_dis =

      svrng_new_uniform_distribution_float(0.0f,1.0f),

       _m512 const_05 = _mm512_setl_ps(xIfConst);
       _m512i const_one = _mm512_setl_epi32(1);
       _m512i vlanes = _mm512_set_epi32(15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0);
       _m512i vperm =

      _mm512_set_epi32(15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15);

       _m512i vAddDistance = _mm512_setl_epi32(0);
       _m512 tmp_rng;
       _mmask16 x_mask,y_mask;
       int i, xPopCnt, yPopCnt, k=0; 

       for(i=0; i<n;)
       {
       //Vektor für Zufallszahlen erzeugen
       tmp mg = svrng_generate16_float(svrng_generator,svrng_dis);
       //Maske mit Bedingungsergebnissen für jedes Element erzeugen
       _mmask16 cmp_mask = _mm512_cmp_ps_mask(tmp_rng, const_05,

      _CMP_GT_OS);

       //Zählen der Distanzen zu der nächstgelegenen rechten Null unter der Annahme,

      dass die Distanz von cmp_mask[0]==0 ist

       _m512i distances = countRightZeroDist(cmpmask);

       //Berechnen der Maske für Elemente unterhalb und umfassend Position der ersten

      0 in cmp_mask

       _mmask16 ones_mask = _kxor_maskl6(cmp_mask+1, cmpmask);
       //Addieren der Distanz aus der vorherigen Iteration, d. h. wenn

      distance(cmp_mask[0])!=0

       distances = _mm512_mask_add_epi32(distances, onesmask, distances,

      vAddDistance);

       //Y-Elemente weisen ungerade Distanz zur nächstgelegenen Null auf
       y_mask = _mm512_test_epi32-maskedistances,const_one);
       x_mask = _knot_mask16(y_mask); //X-Elemente sind der Rest

       //Zählen, wie viele X-Elemente in diesem Vektor sind, dies ist auch eine Anzahl

      von Iterationen

       xPopCnt = _mm_popcnt_u32(x_mask);
       //Zählen, wie viele Y-Elemente in diesem Vektor sind
       yPopCnt = _mm_popcnt_u32(y_mask);

       //Vorbereiten der Anfangsdistanz zum Hinzuaddieren für die nächste Iteration
       distances = _mm512_maskz_add_epi32(cmp_mask,distances,const_one);
       //Rundsenden desselben an den gesamten Vektor
       vAddDistance = _mm512_permutexvar_epi32(vperm,distances);

       if((i + xPopCnt) >n){ 

      //Anzahl der erzeugten X-Elemente ist mehr als für die Schleife erforderlich,
      Notwendigkeit Überschuss auszublenden

       _m512i vec1 = _mm512_maskz_expand_epi32(x_mask,

      _mm512_add_epi32(_mm512_set1_epi32(i), vlanes));

       //Maske zum Entfernen überschüssiger X-Elemente
       _mmask16 mask1 = _mm512_mask_cmplt_epi32_mask(x_mask, vec1,

      _mm512_set1_epi32(n));

       _mmask16 mask2 = _mm512_mask_cmplt_epi32_mask(x_mask, vec1,

      _mm512_set1_epi32(n+1));

       //Maske zum Entfernen überschüssiger Y-Elemente
       _mmask16 mask3 = _kxor_mask16(mask1, mask2) - 1;
       x_mask = _kand_mask16(x_mask, mask1); //Ausblenden überschüssiger X-

      Elemente

       y_mask = _kand_mask16(ymask, mask3); //Ausblenden überschüssiger Y-

      Elemente

       vAddDistance = _mm512_setl_epi32(0); //keine Notwendigkeit, die Historie an

      die nächste Iteration zu übergeben, da dies die Letzte ist

       }

       //X-Elemente in Speicher komprimieren
       _mm512_mask_compressstoreu_ps(x+i, x_mask, tmp_rng);
       //Y-Elemente in Speicher komprimieren
       _mm512_mask_compressstoreu_ps(y+k, y_mask, tmp_mg);

       i += xPopCnt; //Vorbereiten des X-Zeigers für die nächste Iteration
       k += yPopCnt; //Vorbereiten des Y-Zeigers für die nächste Iteration
       }

       //Prüfen, ob noch ein Y-Element zu erzeugen ist
       _mmask16 yFlag = _mm512_test_epi32_mask(vAddDistance, const_one);

       if(yFlag){ //Bei Bedarf das letzte Y-Element erzeugen
       y[k] = svrng_generate_float(svrng_generator, svrng_dis);
       }

      }

5 zeigt ein Verfahren 500 der Vektorisierung einer iterativen Schleife. Das Verfahren 500 kann ohne Weiteres mit irgendeinem der hierin beschrieben Ausführungsbeispiele implementiert werden. Insbesondere kann das Verfahren 500 in einem oder mehreren Modulen als Satz von Logik-Anweisungen implementiert werden, die in einem maschinen- oder computerlesbaren Speicherungsmedium gespeichert sind, wie beispielsweise RAM, ROM, PROM, Firmware, Flash-Speicher usw., in konfigurierbarer Logik wie beispielsweise PLAs, FPGAs, CPLDs, Logik-Hardware mit fester Funktionalität, die Schaltungstechnologie, wie beispielsweise ASIC, CMOS, TTL-Technologie, oder irgendeine Kombination davon verwendet.

Der dargestellte Verarbeitungsblock 502 initiiert eine Basisdistanz auf einen Wert von Null. Die Basisdistanz kann einer Anzahl von Werten mit erfüllten Bedingungen entsprechen, da eine Bedingung das letzte Mal in einem vorherigen Vektor (Block) von Werten nicht erfüllt (unsatisfied) war. Der abgebildete Verarbeitungsblock 504 erhält einen Vektor von Werten. Der Vektor kann aus dem Speicher geladen oder erzeugt werden, um eine Bedingung der iterativen Schleife auszuwerten. Der abgebildete Verarbeitungsblock 506 wertet die Bedingung basierend auf dem Vektor von Werten aus und speichert Bits der Vergleiche in einer Vektormaske. Der abgebildete Verarbeitungsblock 508 zählt Distanzen zu der nächstgelegenen vorhergehenden Null (wenn die Bedingung zuletzt nicht erfüllt war) in der Vektormaske und speichert die Distanzen in einem Vektor von Distanzen. Der abgebildete Verarbeitungsblock 510 aktualisiert Elemente basierend auf einer Historie (z. B. von vorherigen Vektorblöcken). Der abgebildete Verarbeitungsblock 510 kann ein Auswählen von Elementen in dem Vektor von Distanzen umfassen, die Aktualisierungen aus der Vorgeschichte erfordern, und ein Hinzuaddieren von Basisdistanzwert(en) zu den ausgewählten Elementen.

Der abgebildete Verarbeitungsblock 512 zählt die Anzahl von abgeschlossenen Iterationen, die in dem Vektor von Werten dargestellt sind. Insbesondere werden nur abgeschlossene Iterationen gezählt. Zum Beispiel und in Bezug auf 4B stellt der zweite Vektorblock 470 nur 5 Iterationen (5-9) dar, da Iterationsnummer 10 noch nicht abgeschlossen ist und einen weiteren Wert aus dem dritten Block 472 erfordert, um abgeschlossen zu werden. Die Anzahl der abgeschlossenen Iterationen kann eine Gesamtzahl von Iterationen darstellen, die durch Verwendung eines Vektors von Werten bis zum Ende abgearbeitet werden können. Die Anzahl der noch auszuführenden Schleifeniterationen kann zunächst auf eine Gesamtzahl von erwarteten Schleifeniterationen gesetzt und wie unten beschrieben dekrementiert werden.

Der abgebildete Verarbeitungsblock 514 bestimmt, ob die Anzahl von abgeschlossenen Iterationen, die in dem Vektor von Werten dargestellt sind, eine Anzahl von noch auszuführenden Schleifeniterationen (z. B. verbleibende Iterationen) übersteigt. Das heißt, wie in 4B dargestellt, wenn der Vektorisierungsblock über eine bestimmte Anzahl von Datensätzen (z. B. hier 8 Datensätze) arbeitet, kann der dritte Vektor von Werten, der durch den dritten Vektorblock 472 dargestellt wird, 5 abgeschlossene Iterationen darstellen (z. B. Iterationen 10, 11, 12, 13, 14), was die Anzahl von abgeschlossenen Iterationen ist. Von Bedeutung ist, dass Iteration 15 nicht abgeschlossen ist, da die Bedingung bei e23 erfüllt ist und ein weiterer Wert erforderlich ist, um die Iteration abzuschließen. Es sind nur noch 2 Schleifeniterationen auszuführen (Iterationen 10 und 11), daher wird die Anzahl von noch auszuführenden Schleifeniterationen durch die Anzahl der abgeschlossenen Iterationen überschritten. Wenn dies der Fall ist, erzeugt der abgebildete Verarbeitungsblock 516 eine Restmaske, um nicht verwendete Auslösungen (engl. trips) zu maskieren, die den Elementen e19-e23 des dritten Vektorblocks 472 in 4B entsprechen, die zur Verarbeitung des Vektors oder der Werte nicht benötigt werden, und der abgebildete Verarbeitungsblock 518 führt Berechnungen über den Vektor von Distanzen unter der Restmaske aus.

Andernfalls berechnet und speichert der abgebildete Verarbeitungsblock 520 neue Basisdistanzwerte. Der abgebildete Verarbeitungsblock 524 führt Berechnungen über einen Vektor von Distanzen aus und dekrementiert die Anzahl der noch auszuführenden Schleifeniterationen um die Anzahl von abgeschlossenen Iterationen, die durch den Vektor abgeschlossen wurden.

6 zeigt ein Verfahren 600 zum Aktualisieren von Distanzen eines Vektorblocks. Das Verfahren 600 kann ohne Weiteres mit irgendeinem der hierin beschrieben Ausführungsbeispiele implementiert werden. Insbesondere kann das Verfahren 600 in einem oder mehreren Modulen als Satz von Logik-Anweisungen implementiert werden, die in einem maschinen- oder computerlesbaren Speicherungsmedium gespeichert sind, wie beispielsweise RAM, ROM, PROM, Firmware, Flash-Speicher usw., in konfigurierbarer Logik wie beispielsweise PLAs, FPGAs, CPLDs, Logik-Hardware mit fester Funktionalität, die Schaltungstechnologie, wie beispielsweise ASIC, CMOS, TTL-Technologie, oder irgendeine Kombination davon verwendet.

Der abgebildete Verarbeitungsblock 602 bestimmt Distanzen für einen ersten Vektorblock. Der abgebildete Verarbeitungsblock 604 identifiziert Distanzen und Vektormaske aus einem vorhergehenden zweiten Vektorblock. Der zweite Vektorblock kann dem ersten Vektorblock direkt vorausgehen. Der abgebildete Verarbeitungsblock 606 bestimmt, ob es notwendig ist, den ersten Vektorblock basierend auf der Distanz und der Vektormaske des zweiten Vektorblocks zu aktualisieren. Beispielsweise ist es möglicherweise erforderlich, die Distanzen des ersten Vektorblocks zu aktualisieren, wenn ein Wert in der Vektormaske des zweiten Vektorblocks, der dem ersten Vektorblock direkt vorangeht, anzeigt, dass eine Bedingung erfüllt ist. Wenn dies der Fall ist, aktualisiert der abgebildete Verarbeitungsblock 608 Distanzen des ersten Vektorblocks. Andernfalls behält der abgebildete Verarbeitungsblock 610 den ersten Vektorblock ohne Modifikationen bei.

7 veranschaulicht eine Messung von vektorisiertem Code (die durchgezogene Linie), wie er bei einigen Ausführungsbeispielen implementiert ist, relativ zu skalarem Referenzcode (die gestrichelte Linie). Wie in Diagramm 650 dargestellt, werden auf einigen Prozessoren wie beispielsweise SkyLake-SP- (Scalable Performance) Prozessoren deutliche Verstärkungen (z. B. bis zum 7,2-fachen) gegenüber dem skalaren Referenzcode gemessen. Daher können Ausführungsbeispiele erhebliche Vorteile gegenüber skalaren Implementierungen bereitstellen.

Bezugnehmend nun auf 8 ist ein performance-gesteigertes Rechensystem 158 gezeigt. Das Rechensystem 158 kann im Allgemeinen Teil einer elektronischen Vorrichtung/Plattform sein, die/das eine Rechenfunktionalität (z. B. Personaldigitalassistent/PDA (personal digital assistant), Notebook-Computer, Tablet-Computer, Convertible Tablet, Server), Kommunikationsfunktionalität (z. B. Smartphone), Bildgebungsfunktionalität (z. B. Kamera, Camcorder), Medien-Wiedergabe-Funktionalität (z. B. Smarter Fernseher/TV), tragbare (wearable) Funktionalität (z. B. Armbanduhr, Brillen und Kontaktlinsen, Kopfbedeckung, Schuhwerk, Schmuck), Fahrzeug-Funktionalität (z. B. Kraftfahrzeug, Lastkraftwagen, Kraftrad) usw. oder irgendeine Kombination davon aufweist. Bei dem dargestellten Beispiel umfasst das System 158 einen Host-Prozessor 160 (z. B. eine zentrale Verarbeitungseinheit mit einem oder mehreren Prozessorkernen), der eine integrierte Speichersteuerung (IMC; integrated memory controller) 162 aufweist, die mit einem Systemspeicher 164 gekoppelt ist. Bei dem vorliegenden Beispiel umfasst der Host-Prozessor erste Ausführungseinheiten bis N Ausführungseinheiten zum Unterstützen von Vektorisierungsoperationen (z. B. einzelne Anweisung, Mehrfachdatenoperationen). Somit kann der Host-Prozessor 160 ausgebildet sein, vektorisierte Operationen auszuführen.

Das dargestellte System 158 umfasst außerdem einen Grafikprozessor 168 (z. B. Grafikverarbeitungseinheit/GPU (graphics processing unit)) und ein Eingabe-Ausgabe-(IO; input-output) Modul 166, das zusammen mit dem Prozessor 160 (z.B. als Mikrocontroller) auf einem Halbleiter-Die 170 als System-auf-einem-Chip (SOC; system on chip) implementiert ist, wobei das IO-Modul 166 z. B. mit einer Anzeige 172 (z. B. Touchscreen, Flüssigkristallanzeige/LCD (liquid crystal display), Leuchtdiode/LED-Anzeige), einer Netzwerksteuerung 174 (z. B. verdrahtet und/oder drahtlos) und einem Massenspeicher 176 (z. B. HDD, optische Platte, SSD, Flash-Speicher oder anderer nichtflüchtiger Speicher/NVM (non-volatile memory)) kommunizieren kann. Der Grafikprozessor 168 kann ausgebildet sein, vektorisierte Operationen auszuführen.

Der Systemspeicher 164 umfasst Anweisungen 190, die bei Ausführung durch einen oder mehrere des Host-Prozessors 160 oder des Grafikprozessors 168 das Rechensystem 158 veranlassen, einen oder mehrere Aspekte des Vektorisierungsprozesses 100 (1) des Verfahrens 300 (2), des Verfahrens 500 (5), des Verfahrens 600 (6) und irgendeines der bereits erörterten Ausführungsbeispiele auszuführen. Im Detail kann die Anzeige eine grafische Benutzeroberfläche 192 darstellen. Die grafische Benutzeroberfläche 192 kann einem Computercode 196 zugeordnet sein, der eine iterative Schleife umfasst. Ein Benutzer kann einen Befehl über eine Eingabeperipherievorrichtung 194 (z. B. eine Maus, eine Tastatur, ein Mikrofon usw.) ausführen, um die grafische Benutzeroberfläche 192 zu veranlassen, den Computercode 196 auszuführen.

Die Anweisungen 190 können einen oder mehrere des Host-Prozessors 160 oder des Grafikprozessors 168 veranlassen, rückwärts gerichtete, iterationsübergreifend-abhängige Schleifen in dem Computercode 196 zu vektorisieren, indem eine Vektormaske erzeugt wird, die identifiziert, wann Bedingungen in dem Computercode 196 erfüllt und wann sie nicht erfüllt sind, sowie Distanzen der Vektormaske. Der Host-Prozessor 160 kann den vektorisierten Code basierend auf den Distanzen ausführen, um Masken für die Verarbeitung zu erzeugen sowie Werte basierend auf den Masken zu erzeugen und zu verteilen. Somit kann das Rechensystem 158 dahingehend als performance-gesteigert angesehen werden, dass das Rechensystem 158 den Computercode 196 mit weniger Computerressourcen und in kürzerer Zeit ausführen kann, indem es die Parallelverarbeitungstechniken verwendet.

9 zeigt eine Halbleiter-Package-Vorrichtung 180. Die dargestellte Vorrichtung 180 umfasst ein oder mehrere Substrate 184 (z. B. Silizium, Saphir, Galliumarsenid) und die Logik 182 (z. B. Transistor-Array und andere integrierte Schaltungs-/IC- (integrated circuit) Komponenten), gekoppelt mit dem/den Substrat(en) 184. Bei einem Beispiel wird die Logik 182 zumindest teilweise in konfigurierbarer Logik oder Logik-Hardware mit fester Funktionalität implementiert. Die Logik 182 kann einen oder mehrere Aspekte des Vektorisierungsprozesses 100 (1), des Verfahrens 300 (2), des Verfahrens 500 (5), des Verfahrens 600 (6) und irgendeines der bereits erörterten Ausführungsbeispiele implementieren. Bei einem Beispiel umfasst die Logik 182 Transistorkanalregionen, die innerhalb des Substrats/der Substrate 184 positioniert (z. B. eingebettet) sind. Somit ist die Schnittstelle zwischen der Logik 182 und dem/den Substrat(en) 184 möglicherweise kein abrupter Übergang. Die Logik 182 kann auch als eine epitaxiale Schicht umfassend betrachtet werden, die auf einem ersten Wafer des Substrats/der Substrate 184 gewachsen ist.

10 stellt einen Prozessorkern 200 gemäß einem Ausführungsbeispiel dar. Der Prozessorkern 200 kann der Kern für irgendeine Art von Prozessor sein, z. B. ein Mikroprozessor, ein eingebetteter Prozessor, ein digitaler Signalprozessor (DSP), ein Netzwerkprozessor oder eine andere Vorrichtung zum Ausführen eines Codes. Obgleich nur ein Prozessorkern 200 in 10 dargestellt ist, kann ein Verarbeitungselement alternativ mehr als einen des in 10. Dargestellten Prozessorkerns 200 umfassen. Der Prozessorkern kann ein Einzel-Thread-Kern sein oder bei zumindest einem Ausführungsbeispiel kann der Prozessorkern dahingehend multi-threaded sein, dass er mehr als einen Hardware-Thread-Kontext (oder „logischen Prozessor“) pro Kern umfassen kann.

10 stellt auch einen Speicher 270 dar, der mit dem Prozessorkern 200 gekoppelt ist. Der Speicher 270 kann irgendeiner einer breiten Vielzahl von Speichern (umfassend verschiedene Schichten von Speicherhierarchie) sein, wie sie Fachleuten auf dem Gebiet bekannt oder anderweitig für sie verfügbar sind. Der Speicher 270 kann eine oder mehrere Code 213 -Anweisung(en) 213 umfassen, die von dem Prozessorkern 200 auszuführen sind, wobei der Code 213 einen oder mehrere Aspekte des Vektorisierungsprozesses 100 (1), des Verfahrens 300 (2), des Verfahrens 500 (5), des Verfahrens 600 (6) und irgendeines der bereits erörterten Ausführungsbeispiele implementieren kann. Der Prozessorkern 900einer Programmfolge von Anweisungen, die durch den Code 213 angezeigt wird. Jede Anweisung kann in einen Frontend-Abschnitt 210 eingehen und durch einen oder mehrere Decodierer 220 verarbeitet werden. Der Decodierer 220 kann als seine Ausgabe eine Mikrooperation wie z. B. eine Feste-Breite-Mikrooperation in einem vordefinierten Format erzeugen, oder kann andere Anweisungen, Mikroanweisungen oder Steuersignale erzeugen, die die ursprüngliche Code-Anweisung widerspiegeln. Der dargestellte Frontend-Abschnitt 210 umfasst auch eine Register-Umbenennungslogik 225 und eine Zeitplanungs-Logik 230, die im Allgemeinen Ressourcen zuweisen, und die Operation, die der Umwandlungs-Anweisung zur Ausführung entspricht, in eine Warteschlange stellen.

Der Prozessorkern 200 ist als eine Ausführungslogik 250 umfassend gezeigt, die einen Satz von Ausführungseinheiten 255-1 bis 255-N aufweist. Einige Ausführungsbeispiele können eine Anzahl von Ausführungseinheiten umfassen, die für spezifische Funktionen oder Sätze von Funktionen zweckgebunden sind. Andere Ausführungsbeispiele können nur eine Ausführungseinheit oder eine Ausführungseinheit, die eine bestimmte Funktion ausführen kann, umfassen. Die dargestellte Ausführungslogik 250 führt die durch Code-Anweisungen spezifizierten Operationen aus.

Nach Abschluss der Ausführung der durch die Code-Anweisungen spezifizierten Operationen zieht die Backend-Logik 260 die Anweisungen des Codes 213 zurück. Bei einem Ausführungsbeispiel erlaubt der Prozessorkern 200 die Ausführung außerhalb der Reihenfolge, fordert aber ein Zurückziehen von Anweisungen der Reihenfolge nach. Die Zurückziehen-Logik 265 kann eine Vielzahl von Formen annehmen, wie sie Fachleuten auf dem Gebiet bekannt sind (z. B. Neuanordnungs- (re-order) Puffer oder Ähnliches). Auf diese Weise wird der Prozessorkern 200 während der Ausführung des Codes 213 transformiert, zumindest hinsichtlich der Ausgabe, die durch den Decodierer, die Hardware-Register und Tabellen, die durch die Registerumbenennungslogik 225 verwendet werden, und irgendwelche Register (nicht gezeigt), die durch die Ausführungslogik 250 modifiziert werden, erzeugt wird.

Obwohl es in 10 nicht dargestellt ist, kann ein Verarbeitungselement andere Elemente auf einem Chip mit dem Prozessorkern 200 umfassen. Zum Beispiel kann ein Verarbeitungselement zusammen mit dem Prozessorkern 200 eine Speichersteuerungslogik umfassen. Das Verarbeitungselement kann eine I/O-Steuerungslogik umfassen und/oder kann eine mit der Speichersteuerungslogik integrierte I/O-Steuerungslogik umfassen. Das Verarbeitungselement kann auch einen oder mehrere Caches umfassen.

Bezugnehmend nun auf 6 ist ein Blockdiagramm eines Rechensystems- 1000 Ausführungsbeispiels gemäß einem Ausführungsbeispiel gezeigt. Wie in 11 gezeigt, ist ein Multiprozessorsystem 1000 gezeigt, das ein erstes Verarbeitungselement 1070 und ein zweites Verarbeitungselement 1080 umfasst. Während zwei Verarbeitungselemente 1070 und 1080 gezeigt sind, versteht es sich, dass ein Ausführungsbeispiel des Systems 1000 auch nur ein solches Verarbeitungselement umfassen kann.

Das System 1000 ist als Punkt-zu-Punkt-Verbindungssystem dargestellt, wobei das erste Verarbeitungselement 1070 und das zweite Verarbeitungselement 1080 über eine Punkt-zu-Punkt-Verbindung 1050 gekoppelt sind. Es versteht sich, dass irgendeine oder alle der in 11 dargestellten Verbindungen als Multidrop-Bus statt als Punkt-zu-Punkt-Verbindung implementiert werden.

Wie in 11 gezeigt, kann jedes der Verarbeitungselemente 1070 und 1080 ein Multikern-Prozessor sein, der einen ersten und einen zweiten Prozessorkern umfasst (d. h. die Prozessorkerne 1074a und 1074b und die Prozessorkerne 1084a und 1084b). Solche Kerne 1074a, 1074b, 1084a, 1084b können ausgebildet sein, einen Anweisungscode in ähnlicher Weise ausführen, wie dies oben in Verbindung mit 10 erörtert ist.

Jedes Verarbeitungselement 1070, 1080 kann zumindest einen gemeinschaftlich verwendeten Cache 1896a, 1896b umfassen. Der gemeinschaftlich verwendete Cache 1896a, 1896b kann Daten speichern (z. B. Anweisungen), die von einer oder mehreren Komponenten des Prozessors, wie beispielsweise jeweils den Kernen 1074a, 1074b und 1084a, 1084b, verwendet werden. Zum Beispiel kann der gemeinschaftlich verwendete Cache 1896a, 1896b Daten, die in einem Speicher 1032, 1034 gespeichert sind, lokal zwischenspeichern, für einen schnelleren Zugriff durch Komponenten des Prozessors. Bei einem oder mehreren Ausführungsbeispielen kann der gemeinschaftlich verwendete Cache 1896a, 1896b einen oder mehrere Mid-Level-Caches wie beispielsweise ein Level 2 (L2), ein Level 3 (L3), ein Level 4 (L4) oder andere Cache-Level, einen Last-Level-Cache (LLC) und/oder Kombinationen derselben umfassen.

Obwohl nur zwei Verarbeitungselemente 1070, 1080 gezeigt sind, versteht es sich, dass der Schutzbereich der Ausführungsbeispiele nicht so eingeschränkt ist. Bei anderen Ausführungsbeispielen können ein oder mehrere zusätzliche Verarbeitungselemente in einem bestimmten Prozessor vorhanden sein. Alternativ kann ein oder mehrere der Verarbeitungselemente 1070, 1080 ein anderes Element als ein Prozessor sein, wie beispielsweise ein Beschleuniger oder ein feldprogrammierbares Gate-Array. (Ein) zusätzliche(s) Verarbeitungselement(e) können beispielsweise (einen) zusätzliche(n) Prozessor(en) umfassen, die mit einem ersten Prozessor 1070 der Verarbeitungselemente 1070, 1080 identisch sind, zusätzliche(r) Prozessor(en), die heterogen oder asymmetrisch zu einem ersten Prozessor 1070 sind, Beschleuniger (wie z. B. Grafikbeschleuniger oder digitale Signalverarbeitungs- (DSP-) Einheiten), feldprogrammierbare Gate-Arrays oder irgendein anderes Verarbeitungselement. Es kann eine Vielzahl von Unterschieden zwischen den Verarbeitungselementen 1070, 1080 hinsichtlich eines Spektrums von Leistungsmerkmalen geben, umfassend architektonische, mikroarchitektonische, thermische, leistungsverbrauchsbezogene Charakteristika und Ähnliches. Diese Unterschiede können sich effektiv als Asymmetrie und Heterogenität zwischen den Verarbeitungselementen 1070, 1080 manifestieren. Bei zumindest einem Ausführungsbeispiel können sich die verschiedenen Verarbeitungselemente 1070, 1080 in demselben Die-Package befinden.

Das erste Verarbeitungselement 1070 umfasst ferner eine Speicher-Steuer-Logik (MC; memory controller logic) 1072 und die Punkt-zu-Punkt- (P-P-) Schnittstellen 1076 und 1078. Auf ähnliche Weise kann das zweite Verarbeitungselement 1080 eine MC 1082 und P-P-Schnittstellen 1086 und 1088 umfassen. Wie in 11 gezeigt, koppeln die MCs 1072 und 1082 die Prozessoren mit jeweiligen Speichern, nämlich einem Speicher 1032 und einem Speicher 1034, die Abschnitte des Hauptspeichers sein können, die lokal an die jeweiligen Prozessoren angebracht sind. Während die MC 1072 und 1082 als in die Verarbeitungselemente 1070, 1080 integriert dargestellt ist, kann bei alternativen Ausführungsbeispielen die MC-Logik eine diskrete Logik außerhalb der Verarbeitungselemente 1070, 1080 sein, anstatt darin integriert zu sein.

Das erste Verarbeitungselement 1070 und das zweite Verarbeitungselement 1080 können jeweils über die P-P-Verbindungen 1076 und 1086 mit ein I/O-Teilsystem 1090 gekoppelt sein. Wie in 11 gezeigt, umfasst das I/O-Teilsystem 1090 die P-P-Schnittstellen 1094 und 1098. Ferner umfasst das I/O-Teilsystem 1090 eine Schnittstelle 1092 zum Koppeln des I/O-Teilsystem 1090 mit einer Hoch-Performance-Grafik-Engine 1038. Bei einem Ausführungsbeispiel kann der Bus 1049 zum Koppeln der Grafik-Engine 1038 mit dem I/O-Subsystem 1090 verwendet werden. Alternativ kann eine Punkt-zu-Punkt-Verbindung diese Komponenten koppeln.

Das I/O-Teilsystem 1090 kann seinerseits über eine Schnittstelle 1096 mit einem ersten Bus 1016 gekoppelt sein. Bei einem Ausführungsbeispiel kann der erste Bus 1016 ein Peripheral Component Interconnect- (PCI-) Bus oder ein Bus wie beispielsweise ein PCI-Express-Bus oder ein anderer IO-Verbindungsbus der dritten Generation sein, obwohl der Schutzbereich der Ausführungsbeispiele nicht so eingeschränkt ist.

Wie in 11 gezeigt ist, können verschiedene IO-Vorrichtungen 1014 (z.B. biometrische Scanner, Lautsprecher, Kameras, Sensoren) mit dem ersten Bus 1016 gekoppelt sein, zusammen mit einer Busbrücke 1018, die den ersten Bus 1016 mit einem zweiten Bus 1020 koppeln kann. Bei einem Ausführungsbeispiel kann der zweite Bus 1020 ein Low-Pin-Count-(LPC-) Bus sein. Verschiedene Vorrichtungen können mit dem zweiten Bus 1020 gekoppelt sein, z. B. umfassend eine Tastatur/Maus 1012, Kommunikationsvorrichtung(en) 1026 und eine Datenspeicherungseinheit 1019, wie z. B. ein Plattenlaufwerk oder eine andere Massenspeichervorrichtung, die bei einem Ausführungsbeispiel einen Code 1030 umfassen kann. Der dargestellte Code 1030 kann einen oder mehrere Aspekte des Vektorisierungsprozesses 100 (1), des Verfahrens 300 (2), des Verfahrens 500 (5), des Verfahrens 600 (6) und irgendeines der bereits erörterten Ausführungsbeispiele implementieren. Außerdem kann ein Audio-IO 1024 mit dem zweiten Bus 1020 gekoppelt sein und eine Batterie 1010 kann das Rechensystem 1000 mit Leistung versorgen.

Es wird darauf hingewiesen, dass andere Ausführungsbeispiele in Betracht gezogen werden können. Zum Beispiel kann anstelle der Punkt-zu-Punkt-Architektur von 11 ein System einen Multi-Drop-Bus oder eine andere solche Kommunikationstopologie implementieren. Ferner können die Elemente von 11 alternativ unter Verwendung von mehr oder weniger integrierten Chips als in 11 gezeigt partitioniert werden.

Zusätzliche Anmerkungen und Beispiele:

Beispiel 1 kann ein Rechensystem umfassen, umfassend einen Speicher zum Speichern eines Computercodes, der eine iterative Schleife umfassen soll, einen oder mehrere von einem Host-Prozessor, der ausgebildet ist, vektorisierte Operationen auszuführen, oder einem Grafikprozessor, der ausgebildet ist, vektorisierte Operationen auszuführen, einen Speicher, der einen Satz von Anweisungen umfasst, die bei Ausführung durch den einen oder die mehreren von dem Grafikprozessor oder dem Host-Prozessor das Rechensystem veranlassen zu identifizieren, dass die iterative Schleife einen ersten Codeabschnitt umfassen soll, der ansprechend darauf, dass eine Bedingung erfüllt ist, ausführen soll, eine erste Vektormaske zu erzeugen, die einen oder mehrere Fälle, dass die Bedingung für einen oder mehrere Werte eines ersten Vektors von Werten erfüllt ist, und einen oder mehrere Fälle, dass die Bedingung für den ersten Vektor von Werten nicht erfüllt ist, darstellen soll, wobei der erste Vektor von Werten einer oder mehreren ersten Iterationen der iterative Schleife entsprechen soll; und einen Vektorisierungsprozess der iterativen Schleife basierend auf der ersten Vektormaske durchzuführen.

Beispiel 2 kann das Rechensystem von Beispiel 1 umfassen, wobei die Anweisungen bei Ausführung das Rechensystem veranlassen eine Anzahl von abgeschlossenen Iterationen des ersten Vektors von Werten zu bestimmen, eine Anzahl von verbleibenden Iterationen zu bestimmen, die die iterative Schleife ausführen soll, eine Identifikation durchzuführen, dass die Anzahl der abgeschlossenen Iterationen die Anzahl der verbleibenden Iterationen übersteigen soll; und ansprechend auf die Identifikation eine Restmaske zu erzeugen.

Beispiel 3 kann das System von Beispiel 2 umfassen, wobei die Anweisungen bei Ausführung das Rechensystem veranlassen, erste Distanzen zwischen verschiedenen Bit-Positionen in der ersten Vektormaske zu zählen, wobei jede der ersten Distanzen eine Distanz zwischen einer jeweiligen Bit-Position in der ersten Vektormaske und einer nächstgelegenen vorhergehenden Bit-Position in der ersten Vektormaske darstellen soll, der ein Wert zugewiesen ist, der die Bedingung als nicht erfüllt identifiziert, und den Vektorisierungsprozess basierend auf den ersten Distanzen durchzuführen.

Beispiel 4 kann das System von Beispiel 3 umfassen, wobei die Anweisungen bei Ausführung das Rechensystem veranlassen, eine Analyse einer zweiten Vektormaske durchzuführen, um zu bestimmen, dass die ersten Distanzen korrigiert werden sollen, wobei die zweite Vektormaske einen oder mehrere Fälle, dass die Bedingung für einen oder mehrere Werte eines zweiten Vektors von Werten erfüllt ist, und einen oder mehrere Fälle, dass die Bedingung für den zweiten Vektor von Werten nicht erfüllt ist, darstellen soll, wobei der zweite Vektor von Werten einer oder mehreren zweiten Iterationen der iterative Schleife entsprechen soll; und ansprechend auf die Analyse korrigierte erste Distanzen zu erzeugen, die auf einer Korrektur der ersten Distanzen basierend auf einem oder mehreren von einer zweiten Distanz oder der zweiten Vektormaske basieren, wobei die zweite Distanz basierend auf der zweiten Vektormaske bestimmt werden soll.

Beispiel 5 kann das System von Beispiel 4 umfassen, wobei die Anweisungen bei Ausführung das Rechensystem veranlassen zu bestimmen, dass die iterative Schleife eine oder mehrere rückwärts gerichtete, iterationsübergreifende Abhängigkeiten umfassen soll, die erste Vektormaske ansprechend auf die iterative Schleife zu erzeugen, die eine oder mehrere rückwärts gerichtete, iterationsübergreifende Abhängigkeiten umfasst, und eine Vektoroperation basierend auf den korrigierten ersten Distanzen auszuführen.

Beispiel 6 kann das System gemäß einem der Ansprüche 1-5 umfassen, wobei die Ausführung des ersten Codeabschnitts eine Modifikation eines oder mehrerer von einem Array oder einem Wert einer Variablen veranlassen soll.

Beispiel 7 kann eine Halbleitervorrichtung umfassen, umfassend ein oder mehrere Substrate, und eine mit dem einen oder den mehreren Substraten gekoppelte Logik, wobei die Logik in einer oder mehreren von einer konfigurierbaren Logik oder einer Logik-Hardware mit fester Funktionalität implementiert ist, wobei die Logik mit dem einen oder den mehreren Substraten gekoppelt ist, um zu identifizieren, dass eine iterative Schleife einen ersten Codeabschnitt umfassen soll, der ansprechend darauf, dass eine Bedingung erfüllt ist, ausführen soll, eine erste Vektormaske zu erzeugen, die einen oder mehrere Fälle, dass die Bedingung für einen oder mehrere Werte eines ersten Vektors von Werten erfüllt ist, und einen oder mehrere Fälle, dass die Bedingung für den ersten Vektor von Werten nicht erfüllt ist, darstellen soll, wobei der erste Vektor von Werten einer oder mehreren ersten Iterationen der iterativen Schleife entsprechen soll, und einen Vektorisierungsprozess der iterative Schleife basierend auf der ersten Vektormaske durchzuführen.

Beispiel 8 kann die Vorrichtung von Beispiel 7 umfassen, wobei die mit dem einen oder den mehreren Substraten gekoppelte Logik ausgebildet ist, eine Anzahl von abgeschlossenen Iterationen des ersten Vektors von Werten zu bestimmen, eine Anzahl von verbleibenden Iterationen zu bestimmen, die die iterative Schleife ausführen soll, eine Identifikation durchzuführen, dass die Anzahl der abgeschlossenen Iterationen die Anzahl der verbleibenden Iterationen übersteigen soll und ansprechend auf die Identifikation eine Restmaske zu erzeugen.

Beispiel 9 kann die Vorrichtung von Beispiel 8 umfassen, wobei die mit dem einen oder den mehreren Substraten gekoppelte Logik ausgebildet ist, erste Distanzen zwischen verschiedenen Bit-Positionen in der ersten Vektormaske zu zählen, wobei jede der ersten Distanzen eine Distanz zwischen einer jeweiligen Bit-Position in der ersten Vektormaske und einer nächstgelegenen vorhergehenden Bit-Position in der ersten Vektormaske darstellen soll, der ein Wert zugewiesen ist, der die Bedingung als nicht erfüllt identifiziert, und den Vektorisierungsprozess basierend auf den ersten Distanzen durchzuführen.

Beispiel 10 kann die Vorrichtung von Beispiel 9 umfassen, wobei die mit dem einen oder den mehreren Substraten gekoppelte Logik ausgebildet ist, eine Analyse einer zweiten Vektormaske durchzuführen, um zu bestimmen, dass die ersten Distanzen korrigiert werden sollen, wobei die zweite Vektormaske einen oder mehrere Fälle, dass die Bedingung für einen oder mehrere Werte eines zweiten Vektors von Werten erfüllt ist, und einen oder mehrere Fälle, dass die Bedingung für den zweiten Vektor von Werten nicht erfüllt ist, darstellen soll, wobei der zweite Vektor von Werten einer oder mehreren zweiten Iterationen der iterativen Schleife entsprechen soll, und ansprechend auf die Analyse korrigierte erste Distanzen zu erzeugen, die auf einer Korrektur der ersten Distanzen basierend auf einem oder mehreren von einer zweiten Distanz oder der zweiten Vektormaske basieren, wobei die zweite Distanz basierend auf der zweiten Vektormaske bestimmt werden soll.

Beispiel 11 kann die Vorrichtung von Beispiel 10 umfassen, wobei die mit dem einen oder den mehreren Substraten gekoppelte Logik ausgebildet ist, zu bestimmen, dass die iterative Schleife eine oder mehrere rückwärts gerichtete, iterationsübergreifende Abhängigkeiten umfassen soll, die erste Vektormaske ansprechend auf die iterative Schleife zu erzeugen, die eine oder mehrere rückwärts gerichtete, iterationsübergreifende Abhängigkeiten umfasst, und eine Vektoroperation basierend auf den korrigierten ersten Distanzen auszuführen.

Beispiel 12 kann die Vorrichtung von einem der Beispiele 7-11 umfassen, wobei die Ausführung des ersten Codeabschnitts eine Modifikation eines oder mehrerer von einem Array oder einem Wert einer Variablen veranlassen soll.

Beispiel 13 kann die Vorrichtung von einem der Beispiele 7-11 umfassen, wobei die mit dem einen oder den mehreren Substraten gekoppelte Logik Transistorkanalregionen umfasst, die innerhalb des einen oder der mehreren Substrate positioniert sind.

Beispiel 14 kann zumindest ein computerlesbares Speicherungsmedium umfassen, umfassend einen Satz von Anweisungen, die bei Ausführung durch eine Rechenvorrichtung die Rechenvorrichtung veranlassen zu identifizieren, dass eine iterative Schleife einen ersten Codeabschnitt umfassen soll, der ansprechend darauf, dass eine Bedingung erfüllt ist, ausführen soll eine erste Vektormaske zu erzeugen, die einen oder mehrere Fälle, dass die Bedingung für einen oder mehrere Werte eines ersten Vektors von Werten erfüllt ist, und einen oder mehrere Fälle, dass die Bedingung für den ersten Vektor von Werten nicht erfüllt ist, darstellen soll, wobei der erste Vektor von Werten einer oder mehreren ersten Iterationen der iterative Schleife entsprechen soll, und einen Vektorisierungsprozess der iterativen Schleife basierend auf der ersten Vektormaske durchzuführen.

Beispiel 15 kann das zumindest eine computerlesbare Speicherungsmedium von Beispiel 14 umfassen, wobei die Anweisungen bei Ausführung die Rechenvorrichtung veranlassen eine Anzahl von abgeschlossenen Iterationen des ersten Vektors von Werten zu bestimmen, eine Anzahl von verbleibenden Iterationen zu bestimmen, die die iterative Schleife ausführen soll, eine Identifikation durchzuführen, dass die Anzahl der abgeschlossenen Iterationen die Anzahl der verbleibenden Iterationen übersteigen soll, und ansprechend auf die Identifikation eine Restmaske zu erzeugen.

Beispiel 16 kann das zumindest eine computerlesbare Speicherungsmedium von Beispiel 15 umfassen, wobei die Anweisungen bei Ausführung die Rechenvorrichtung veranlassen erste Distanzen zwischen verschiedenen Bit-Positionen in der ersten Vektormaske zu zählen, wobei jede der ersten Distanzen eine Distanz zwischen einer jeweiligen Bit-Position in der ersten Vektormaske und einer nächstgelegenen vorhergehenden Bit-Position in der ersten Vektormaske darstellen soll, der ein Wert zugewiesen ist, der die Bedingung als nicht erfüllt identifiziert, und den Vektorisierungsprozess basierend auf den ersten Distanzen durchzuführen.

Beispiel 17 kann das zumindest eine computerlesbare Speicherungsmedium von Beispiel 16 umfassen, wobei die Anweisungen bei Ausführung die Rechenvorrichtung veranlassen eine Analyse einer zweiten Vektormaske durchzuführen, um zu bestimmen, dass die ersten Distanzen korrigiert werden sollen, wobei die zweite Vektormaske einen oder mehrere Fälle, dass die Bedingung für einen oder mehrere Werte eines zweiten Vektors von Werten erfüllt ist, und einen oder mehrere Fälle, dass die Bedingung für den zweiten Vektor von Werten nicht erfüllt ist, darstellen soll, wobei der zweite Vektor von Werten einer oder mehreren zweiten Iterationen der iterativen Schleife entsprechen soll, und ansprechend auf die Analyse korrigierte erste Distanzen zu erzeugen, die auf einer Korrektur der ersten Distanzen basierend auf einem oder mehreren von einer zweiten Distanz oder der zweiten Vektormaske basieren, wobei die zweite Distanz basierend auf der zweiten Vektormaske bestimmt werden soll.

Beispiel 18 kann das zumindest eine computerlesbare Speicherungsmedium von Beispiel 17 umfassen, wobei die Anweisungen bei Ausführung die Rechenvorrichtung veranlassen zu bestimmen, dass die iterative Schleife eine oder mehrere rückwärts gerichtete, iterationsübergreifende Abhängigkeiten umfassen soll, die erste Vektormaske ansprechend auf die iterative Schleife zu erzeugen, die eine oder mehrere rückwärts gerichtete, iterationsübergreifende Abhängigkeiten umfasst, und eine Vektoroperation basierend auf den korrigierten ersten Distanzen auszuführen.

Beispiel 19 kann das zumindest eine computerlesbare Speicherungsmedium von einem der Beispiele 14-18 umfassen, wobei die Ausführung des ersten Codeabschnitts eine Modifikation eines oder mehrerer von einem Array oder einem Wert einer Variablen veranlassen soll.

Beispiel 20 kann ein Verfahren umfassen, umfassend Identifizieren, dass eine iterative Schleife einen ersten Codeabschnitt umfasst, der ansprechend darauf, dass eine Bedingung erfüllt ist, ausführt, Erzeugen einer ersten Vektormaske, die einen oder mehrere Fälle, dass die Bedingung für einen oder mehrere Werte eines ersten Vektors von Werten erfüllt ist, und einen oder mehrere Fälle, dass die Bedingung für den ersten Vektor von Werten nicht erfüllt ist, darstellen soll, wobei der erste Vektor von Werten einer oder mehreren ersten Iterationen der iterative Schleife entsprechen soll, und Durchführen eines Vektorisierungsprozesses der iterativen Schleife basierend auf der ersten Vektormaske.

Beispiel 21 kann das Verfahren von Beispiel 20 umfassen, ferner umfassend Bestimmen einer Anzahl von abgeschlossenen Iterationen des ersten Vektors von Werten, Bestimmen einer Anzahl von verbleibenden Iterationen, die die iterative Schleife ausführen soll, Durchführen einer Identifikation, dass die Anzahl der abgeschlossenen Iterationen die Anzahl der verbleibenden Iterationen übersteigen soll, und Erzeugen einer Restmaske ansprechend auf die Identifikation.

Beispiel 22 kann das Verfahren von Beispiel 21 umfassen, ferner umfassend Zählen erster Distanzen zwischen verschiedenen Bit-Positionen in der ersten Vektormaske, wobei jede der ersten Distanzen eine Distanz zwischen einer jeweiligen Bit-Position in der ersten Vektormaske und einer nächstgelegenen vorhergehenden Bit-Position in der ersten Vektormaske darstellt, der ein Wert zugewiesen ist, der die Bedingung als nicht erfüllt identifiziert, und Durchführen des Vektorisierungsprozesses basierend auf den ersten Distanzen.

Beispiel 23 kann das Verfahren von Beispiel 22 umfassen, ferner umfassend Durchführen einer Analyse einer zweiten Vektormaske, um zu bestimmen, dass die ersten Distanzen korrigiert werden sollen, wobei die zweite Vektormaske einen oder mehrere Fälle, dass die Bedingung für einen oder mehrere Werte eines zweiten Vektors von Werten erfüllt ist, und einen oder mehrere Fälle, dass die Bedingung für den zweiten Vektor von Werten nicht erfüllt ist, darstellen soll, wobei der zweite Vektor von Werten einer oder mehreren zweiten Iterationen der iterativen Schleife entsprechen soll, und ansprechend auf die Analyse ein Erzeugen korrigierter erster Distanzen, die auf einer Korrektur der ersten Distanzen basierend auf einem oder mehreren von einer zweiten Distanz oder der zweiten Vektormaske basieren, wobei die zweite Distanz basierend auf der zweiten Vektormaske bestimmt werden soll.

Beispiel 24 kann das Verfahren von Beispiel 23 umfassen, ferner umfassend Bestimmen, dass die iterative Schleife eine oder mehrere rückwärts gerichtete, iterationsübergreifende Abhängigkeiten umfasst, Erzeugen der ersten Vektormaske ansprechend auf die iterative Schleife, die eine oder mehrere rückwärts gerichtete, iterationsübergreifende Abhängigkeiten umfasst, und Ausführen einer Vektoroperation basierend auf den korrigierten ersten Distanzen.

Beispiel 25 umfasst das Verfahren von einem der Beispiele 20-24, wobei das Ausführen des ersten Codeabschnitts eine Modifikation eines oder mehrerer von einem Array oder einem Wert einer Variablen veranlasst.

Beispiel 26 kann eine Halbleitervorrichtung umfassen, umfassend ein Mittel zum Identifizieren, dass eine iterative Schleife einen ersten Codeabschnitt umfasst, der ansprechend darauf, dass eine Bedingung erfüllt ist, ausführt, ein Mittel zum Erzeugen einer ersten Vektormaske, die einen oder mehrere Fälle, dass die Bedingung für einen oder mehrere Werte eines ersten Vektors von Werten erfüllt ist, und einen oder mehrere Fälle, dass die Bedingung für den ersten Vektor von Werten nicht erfüllt ist, darstellen soll, wobei der erste Vektor von Werten einer oder mehreren ersten Iterationen der iterative Schleife entsprechen soll, und ein Mittel zum Durchführen eines Vektorisierungsprozesses der iterativen Schleife basierend auf der ersten Vektormaske.

Beispiel 27 kann die Vorrichtung von Beispiel 26 umfassen, wobei die mit dem einen oder den mehreren Substraten gekoppelte Logik ausgebildet ist, ein Mittel zum Bestimmen einer Anzahl von abgeschlossenen Iterationen des ersten Vektors von Werten, ein Mittel zum Bestimmen einer Anzahl von verbleibenden Iterationen, die die iterative Schleife ausführen soll, ein Mittel zum Durchführen einer Identifikation, dass die Anzahl der abgeschlossenen Iterationen die Anzahl der verbleibenden Iterationen übersteigen soll, und ein Mittel zum Erzeugen einer Restmaske ansprechend auf die Identifikation zu umfassen.

Beispiel 28 kann die Vorrichtung von Beispiel 27 umfassen, wobei die mit dem einen oder den mehreren Substraten gekoppelte Logik ausgebildet ist, ein Mittel zum Zählen erster Distanzen zwischen verschiedenen Bit-Positionen in der ersten Vektormaske, wobei jede der ersten Distanzen eine Distanz zwischen einer jeweiligen Bit-Position in der ersten Vektormaske und einer nächstgelegenen vorhergehenden Bit-Position in der ersten Vektormaske darstellen soll, der ein Wert zugewiesen ist, der die Bedingung als nicht erfüllt identifiziert, und ein Mittel zum Durchführen eines Vektorisierungsprozesses basierend auf den ersten Distanzen zu umfassen.

Beispiel 29 kann die Vorrichtung von Beispiel 28 umfassen, wobei die mit dem einen oder den mehreren Substraten gekoppelte Logik ausgebildet ist, ein Mittel zum Durchführen einer Analyse einer zweiten Vektormaske, um zu bestimmen, dass die ersten Distanzen korrigiert werden sollen, wobei die zweite Vektormaske einen oder mehrere Fälle, dass die Bedingung für einen oder mehrere Werte eines zweiten Vektors von Werten erfüllt ist, und einen oder mehrere Fälle, dass die Bedingung für den zweiten Vektor von Werten nicht erfüllt ist, darstellen soll, wobei der zweite Vektor von Werten einer oder mehreren zweiten Iterationen der iterativen Schleife entsprechen soll, und ansprechend auf die Analyse ein Mittel zum Erzeugen korrigierter erster Distanzen, die auf einer Korrektur der ersten Distanzen basierend auf einem oder mehreren von einer zweiten Distanz oder der zweiten Vektormaske basieren, wobei die zweite Distanz basierend auf der zweiten Vektormaske bestimmt werden soll, zu umfassen.

Beispiel 30 kann die Vorrichtung von Beispiel 29 umfassen, wobei die mit dem einen oder den mehreren Substraten gekoppelte Logik ausgebildet ist, ein Mittel zum Bestimmen, dass die iterative Schleife eine oder mehrere rückwärts gerichtete, iterationsübergreifende Abhängigkeiten umfasst, ein Mittel zum Erzeugen der ersten Vektormaske ansprechend auf die iterative Schleife, die eine oder mehrere rückwärts gerichtete, iterationsübergreifende Abhängigkeiten umfasst, und ein Mittel zum Ausführen einer Vektoroperation basierend auf den korrigierten ersten Distanzen, zu umfassen.

Beispiel 31 kann die Vorrichtung von Beispielen 26-30 umfassen, wobei das Mittel zum Ausführen des ersten Codeabschnitts eine Modifikation eines oder mehrerer von einem Array oder einem Wert einer Variablen veranlasst.

Somit kann die hier beschriebene Technologie verbesserte Vektorisierungsoperationen unterstützen, die basierend auf API-Aufrufen und/oder -Operationen ausgeführt werden können. Die Technologie kann auch eine einfachere, effizientere und weniger latenzanfällige Ausführung von Operationen ermöglichen.

Ausführungsbeispiele sind für die Verwendung mit allen Arten von Halbleiterchips mit integrierter Schaltung („IC“) anwendbar. Beispiele für diese IC-Chips umfassen, sind jedoch nicht beschränkt auf, Prozessoren, Steuerungen, Chipsatzkomponenten, programmierbare Logik-Arrays (PLAs; programmable logic arrays (PLAs), Speicherchips, Netzwerkchips, Systeme-auf-einem-Chip (SOCs; systems on chip), SSD/NAND-Steuerungs-ASICs und Ähnliches. Zusätzlich sind bei einigen der Zeichnungen Signalleiter-Leitungen mit Linien dargestellt. Einige können unterschiedlich sein, um konstituierendere Signalpfade anzuzeigen, eine Nummernbezeichnung aufweisen, um eine Anzahl konstituierender Signalpfade anzuzeigen, und/oder Pfeile an einem oder mehreren Enden aufweisen, um die primäre Richtung des Informationsflusses anzuzeigen. Dies sollte jedoch nicht einschränkend ausgelegt werden. Vielmehr kann ein solches hinzugefügtes Detail in Verbindung mit einem oder mehreren beispielhaften Ausführungsbeispielen verwendet werden, um ein leichteres Verständnis einer Schaltung zu ermöglichen. Jede dargestellte Signalleitung, unabhängig davon, ob sie zusätzliche Informationen aufweist oder nicht, kann tatsächlich ein oder mehrere Signale umfassen, die sich in mehrere Richtungen bewegen können, und kann mit irgendeiner geeigneten Art von Signalschema implementiert sein, z. B. digitale oder analoge Leitungen, die mit differentiellen Paaren, Glasfaserleitungen und/oder asymmetrischen (single-ended) Leitungen implementiert sind.

Beispielhafte Größen/Modelle/Werte/Bereiche können gegeben worden sein, obwohl die Ausführungsbeispiele nicht auf dieselben beschränkt sind. Da Fertigungstechniken (z. B. Photolithographie) im Laufe der Zeit ausgereifter werden, wird erwartet, dass Vorrichtungen kleinerer Größe hergestellt werden könnten. Zusätzlich werden zur Vereinfachung der Darstellung und Erörterung, und um bestimmte Aspekte der Ausführungsbeispiele nicht zu verunklaren, bekannte Leistungs-/Masseverbindungen zu IC-Chips oder andere Komponenten möglicherweise in den Figuren gezeigt oder nicht gezeigt. Ferner können Anordnungen in Blockdiagrammform gezeigt sein, um ein Verunklaren der Ausführungsbeispiele zu vermeiden, und auch angesichts der Tatsache, dass Details im Hinblick auf die Implementierung solcher Blockdiagrammanordnungen stark von dem Rechensystem abhängig sind, innerhalb dessen das Ausführungsbeispiel implementiert sein soll, d. h. solche Details sollten einem Fachmann gut bekannt sein. Wo spezielle Details (z. B. Schaltungen) ausgeführt sind, um beispielhafte Ausführungsbeispiele zu beschreiben, sollte es für Fachleute auf dem Gebiet offensichtlich sein, dass Ausführungsbeispiele ohne oder mit Variation dieser speziellen Details in der Praxis ausgeführt werden können. Die Beschreibung ist deshalb als darstellend anstatt als beschränkend zu betrachten.

Der Begriff „gekoppelt“ kann hierin verwendet werden, um sich auf irgendeine Art von Beziehung, direkt oder indirekt, zwischen den betreffenden Komponenten zu beziehen, und kann für elektrische, mechanische, flüssige, optische, elektromagnetische, elektromechanische oder andere Verbindungen gelten. Zusätzlich werden die Begriffe „erste“, „zweite“ usw. hierin möglicherweise nur zur Erleichterung der Erörterung verwendet und weisen, sofern nicht anders angegeben, keine besondere zeitliche oder chronologische Bedeutung auf.

Gemäß der Verwendung in dieser Anmeldung und in den Patentansprüchen, kann eine Liste von Elementen, die durch den Ausdruck „eines oder mehrere von“ verbunden sind, irgendeine Kombination der aufgezählten Ausdrücke bedeuten. Zum Beispiel können die Phrasen „eines oder mehrere von A, B oder C“ A, B, C; A und B; A und C; B und C; oder A, B und C bedeuten.

Fachleute auf dem Gebiet werden aus der vorstehenden Beschreibung erkennen, dass die breiten Techniken der Ausführungsbeispiele in einer Vielzahl von Formen implementiert sein können. Daher sollte, obwohl die Ausführungsbeispiele in Verbindung mit bestimmten Beispielen von denselben beschrieben wurden, der wahre Schutzbereich der Ausführungsbeispiele nicht so begrenzt sein, da dem Fachmann nach dem Studium der Zeichnungen, Beschreibung und der folgenden Ansprüche andere Modifikationen ersichtlich werden.

Claims

Ein Rechensystem, umfassend: einen Speicher zum Speichern eines Computercodes, der eine iterative Schleife umfassen soll; einen oder mehrere von einem Host-Prozessor, der ausgebildet ist, vektorisierte Operationen auszuführen, oder einem Grafikprozessor, der ausgebildet ist, vektorisierte Operationen auszuführen; einen Speicher, der einen Satz von Anweisungen umfasst, die bei Ausführung durch den einen oder die mehreren von dem Grafikprozessor oder dem Host-Prozessor das Rechensystem veranlassen: zu identifizieren, dass die iterative Schleife einen ersten Codeabschnitt umfassen soll, der ansprechend darauf, dass eine Bedingung erfüllt ist, ausführen soll; eine erste Vektormaske zu erzeugen, die einen oder mehrere Fälle, dass die Bedingung für einen oder mehrere Werte eines ersten Vektors von Werten erfüllt ist, und einen oder mehrere Fälle, dass die Bedingung für den ersten Vektor von Werten nicht erfüllt ist, darstellen soll, wobei der erste Vektor von Werten einer oder mehreren ersten Iterationen der iterativen Schleife entsprechen soll; und einen Vektorisierungsprozess der iterativen Schleife basierend auf der ersten Vektormaske durchzuführen.
Das Rechensystem gemäß Anspruch 1, wobei die Anweisungen bei Ausführung das Rechensystem veranlassen: eine Anzahl von abgeschlossenen Iterationen des ersten Vektors von Werten zu bestimmen; eine Anzahl von verbleibenden Iterationen zu bestimmen, die die iterative Schleife ausführen soll; eine Identifikation durchzuführen, dass die Anzahl der abgeschlossenen Iterationen die Anzahl der verbleibenden Iterationen übersteigen soll; und ansprechend auf die Identifikation eine Restmaske zu erzeugen.
Das System gemäß Anspruch 2, wobei die Anweisungen bei Ausführung das Rechensystem veranlassen: erste Distanzen zwischen verschiedenen Bit-Positionen in der ersten Vektormaske zu zählen, wobei jede der ersten Distanzen eine Distanz zwischen einer jeweiligen Bit-Position in der ersten Vektormaske und einer nächstgelegenen vorhergehenden Bit-Position in der ersten Vektormaske darstellen soll, der ein Wert zugewiesen ist, der die Bedingung als nicht erfüllt identifiziert; und den Vektorisierungsprozess basierend auf den ersten Distanzen durchzuführen.
Das System gemäß Anspruch 3, wobei die Anweisungen bei Ausführung das Rechensystem veranlassen: eine Analyse einer zweiten Vektormaske durchzuführen, um zu bestimmen, dass die ersten Distanzen korrigiert werden sollen, wobei die zweite Vektormaske einen oder mehrere Fälle, dass die Bedingung für einen oder mehrere Werte eines zweiten Vektors von Werten erfüllt ist, und einen oder mehrere Fälle, dass die Bedingung für den zweiten Vektor von Werten nicht erfüllt ist, darstellen soll, wobei der zweite Vektor von Werten einer oder mehreren zweiten Iterationen der iterativen Schleife entsprechen soll; und ansprechend auf die Analyse korrigierte erste Distanzen zu erzeugen, die auf einer Korrektur der ersten Distanzen basierend auf einem oder mehreren von einer zweiten Distanz oder der zweiten Vektormaske basieren, wobei die zweite Distanz basierend auf der zweiten Vektormaske bestimmt werden soll.
Das System gemäß Anspruch 4, wobei die Anweisungen bei Ausführung das Rechensystem veranlassen: zu bestimmen, dass die iterative Schleife eine oder mehrere rückwärts gerichtete, iterationsübergreifende Abhängigkeiten umfassen soll; die erste Vektormaske ansprechend auf die iterative Schleife zu erzeugen, die eine oder mehrere rückwärts gerichtete, iterationsübergreifende Abhängigkeiten umfasst; und eine Vektoroperation basierend auf den korrigierten ersten Distanzen auszuführen.
Das System gemäß einem der vorherigen Ansprüche, wobei die Ausführung des ersten Codeabschnitts eine Modifikation eines oder mehrerer von einem Array oder einem Wert einer Variablen veranlassen soll.
Eine Halbleitervorrichtung, umfassend: ein oder mehrere Substrate; und eine mit dem einen oder den mehreren Substraten gekoppelte Logik, wobei die Logik in einer oder mehreren von einer konfigurierbaren Logik oder einer Logik-Hardware mit fester Funktionalität implementiert ist, wobei die Logik mit dem einen oder den mehreren Substraten gekoppelt ist, um: zu identifizieren, dass eine iterative Schleife einen ersten Codeabschnitt umfassen soll, der ansprechend darauf, dass eine Bedingung erfüllt ist, ausführen soll; eine erste Vektormaske zu erzeugen, die einen oder mehrere Fälle, dass die Bedingung für einen oder mehrere Werte eines ersten Vektors von Werten erfüllt ist, und einen oder mehrere Fälle, dass die Bedingung für den ersten Vektor von Werten nicht erfüllt ist, darstellen soll, wobei der erste Vektor von Werten einer oder mehreren ersten Iterationen der iterativen Schleife entsprechen soll; und einen Vektorisierungsprozess der iterativen Schleife basierend auf der ersten Vektormaske durchzuführen.
Die Vorrichtung gemäß Anspruch 7, wobei die mit dem einen oder den mehreren Substraten gekoppelte Logik ausgebildet ist: eine Anzahl von abgeschlossenen Iterationen des ersten Vektors von Werten zu bestimmen; eine Anzahl von verbleibenden Iterationen zu bestimmen, die die iterative Schleife ausführen soll; eine Identifikation durchzuführen, dass die Anzahl der abgeschlossenen Iterationen die Anzahl der verbleibenden Iterationen übersteigen soll; und ansprechend auf die Identifikation eine Restmaske zu erzeugen.
Die Vorrichtung gemäß Anspruch 8, wobei die mit dem einen oder den mehreren Substraten gekoppelte Logik ausgebildet ist: erste Distanzen zwischen verschiedenen Bit-Positionen in der ersten Vektormaske zu zählen, wobei jede der ersten Distanzen eine Distanz zwischen einer jeweiligen Bit-Position in der ersten Vektormaske und einer nächstgelegenen vorhergehenden Bit-Position in der ersten Vektormaske darstellen soll, der ein Wert zugewiesen ist, der die Bedingung als nicht erfüllt identifiziert; und den Vektorisierungsprozess basierend auf den ersten Distanzen durchzuführen.
Die Vorrichtung gemäß Anspruch 9, wobei die mit dem einen oder den mehreren Substraten gekoppelte Logik ausgebildet ist: eine Analyse einer zweiten Vektormaske durchzuführen, um zu bestimmen, dass die ersten Distanzen korrigiert werden sollen, wobei die zweite Vektormaske einen oder mehrere Fälle, dass die Bedingung für einen oder mehrere Werte eines zweiten Vektors von Werten erfüllt ist, und einen oder mehrere Fälle, dass die Bedingung für den zweiten Vektor von Werten nicht erfüllt ist, darstellen soll, wobei der zweite Vektor von Werten einer oder mehreren zweiten Iterationen der iterativen Schleife entsprechen soll; und ansprechend auf die Analyse korrigierte erste Distanzen zu erzeugen, die auf einer Korrektur der ersten Distanzen basierend auf einem oder mehreren von einer zweiten Distanz oder der zweiten Vektormaske basieren, wobei die zweite Distanz basierend auf der zweiten Vektormaske bestimmt werden soll.
Die Vorrichtung gemäß Anspruch 10, wobei die mit dem einen oder den mehreren Substraten gekoppelte Logik ausgebildet ist: zu bestimmen, dass die iterative Schleife eine oder mehrere rückwärts gerichtete, iterationsübergreifende Abhängigkeiten umfassen soll; die erste Vektormaske ansprechend auf die iterative Schleife zu erzeugen, die eine oder mehrere rückwärts gerichtete, iterationsübergreifende Abhängigkeiten umfasst; und eine Vektoroperation basierend auf den korrigierten ersten Distanzen auszuführen.
Die Vorrichtung gemäß einem der Ansprüche 7-11, wobei die Ausführung des ersten Codeabschnitts eine Modifikation eines oder mehrerer von einem Array oder einem Wert einer Variablen veranlassen soll.
Die Vorrichtung gemäß einem der Ansprüche 7-12, wobei die mit dem einen oder den mehreren Substraten gekoppelte Logik Transistorkanalregionen umfasst, die innerhalb des einen oder der mehreren Substrate positioniert sind.
Zumindest ein computerlesbares Speicherungsmedium, umfassend einen Satz von Anweisungen, die bei Ausführung durch eine Rechenvorrichtung die Rechenvorrichtung veranlassen: zu identifizieren, dass eine iterative Schleife einen ersten Codeabschnitt umfassen soll, der ansprechend darauf, dass eine Bedingung erfüllt ist, ausführen soll; eine erste Vektormaske zu erzeugen, die einen oder mehrere Fälle, dass die Bedingung für einen oder mehrere Werte eines ersten Vektors von Werten erfüllt ist, und einen oder mehrere Fälle, dass die Bedingung für den ersten Vektor von Werten nicht erfüllt ist, darstellen soll, wobei der erste Vektor von Werten einer oder mehreren ersten Iterationen der iterativen Schleife entsprechen soll; und einen Vektorisierungsprozess der iterativen Schleife basierend auf der ersten Vektormaske durchzuführen.
Das zumindest eine computerlesbare Speicherungsmedium gemäß Anspruch 14, wobei die Anweisungen bei Ausführung die Rechenvorrichtung veranlassen: eine Anzahl von abgeschlossenen Iterationen des ersten Vektors von Werten zu bestimmen; eine Anzahl von verbleibenden Iterationen zu bestimmen, die die iterative Schleife ausführen soll; eine Identifikation durchzuführen, dass die Anzahl der abgeschlossenen Iterationen die Anzahl der verbleibenden Iterationen übersteigen soll; und ansprechend auf die Identifikation eine Restmaske zu erzeugen.
Das zumindest eine computerlesbare Speicherungsmedium gemäß Anspruch 15, wobei die Anweisungen bei Ausführung die Rechenvorrichtung veranlassen: erste Distanzen zwischen verschiedenen Bit-Positionen in der ersten Vektormaske zu zählen, wobei jede der ersten Distanzen eine Distanz zwischen einer jeweiligen Bit-Position in der ersten Vektormaske und einer nächstgelegenen vorhergehenden Bit-Position in der ersten Vektormaske darstellen soll, der ein Wert zugewiesen ist, der die Bedingung als nicht erfüllt identifiziert; und den Vektorisierungsprozess basierend auf den ersten Distanzen durchzuführen.
Das zumindest eine computerlesbare Speicherungsmedium gemäß Anspruch 16, wobei die Anweisungen bei Ausführung die Rechenvorrichtung veranlassen: eine Analyse einer zweiten Vektormaske durchzuführen, um zu bestimmen, dass die ersten Distanzen korrigiert werden sollen, wobei die zweite Vektormaske einen oder mehrere Fälle, dass die Bedingung für einen oder mehrere Werte eines zweiten Vektors von Werten erfüllt ist, und einen oder mehrere Fälle, dass die Bedingung für den zweiten Vektor von Werten nicht erfüllt ist, darstellen soll, wobei der zweite Vektor von Werten einer oder mehreren zweiten Iterationen der iterativen Schleife entsprechen soll; und ansprechend auf die Analyse korrigierte erste Distanzen zu erzeugen, die auf einer Korrektur der ersten Distanzen basierend auf einem oder mehreren von einer zweiten Distanz oder der zweiten Vektormaske basieren, wobei die zweite Distanz basierend auf der zweiten Vektormaske bestimmt werden soll.
Das zumindest eine computerlesbare Speicherungsmedium gemäß Anspruch 17, wobei die Anweisungen bei Ausführung die Rechenvorrichtung veranlassen: zu bestimmen, dass die iterative Schleife eine oder mehrere rückwärts gerichtete, iterationsübergreifende Abhängigkeiten umfassen soll; die erste Vektormaske ansprechend auf die iterative Schleife zu erzeugen, die eine oder mehrere rückwärts gerichtete, iterationsübergreifende Abhängigkeiten umfasst; und eine Vektoroperation basierend auf den korrigierten ersten Distanzen auszuführen.
Das zumindest eine computerlesbare Speicherungsmedium gemäß einem der Ansprüche 14-18, wobei die Ausführung des ersten Codeabschnitts eine Modifikation eines oder mehrerer von einem Array oder einem Wert einer Variablen veranlassen soll.
Ein Verfahren, umfassend: Identifizieren, dass eine iterative Schleife einen ersten Codeabschnitt umfasst, der ansprechend darauf, dass eine Bedingung erfüllt ist, ausführt; Erzeugen einer ersten Vektormaske, die einen oder mehrere Fälle, dass die Bedingung für einen oder mehrere Werte eines ersten Vektors von Werten erfüllt ist, und einen oder mehrere Fälle, dass die Bedingung für den ersten Vektor von Werten nicht erfüllt ist, darstellen soll, wobei der erste Vektor von Werten einer oder mehreren ersten Iterationen der iterative Schleife entsprechen soll; und Durchführen eines Vektorisierungsprozesses der iterativen Schleife basierend auf der ersten Vektormaske.
Das Verfahren gemäß Anspruch 20, ferner umfassend: Bestimmen einer Anzahl von abgeschlossenen Iterationen des ersten Vektors von Werten; Bestimmen einer Anzahl von verbleibenden Iterationen, die die iterative Schleife ausführen soll; Durchführen einer Identifikation, dass die Anzahl der abgeschlossenen Iterationen die Anzahl der verbleibenden Iterationen übersteigen soll; und Erzeugen einer Restmaske ansprechend auf die Identifikation.
Das Verfahren gemäß Anspruch 21, ferner umfassend: Zählen erster Distanzen zwischen verschiedenen Bit-Positionen in der ersten Vektormaske, wobei jede der ersten Distanzen eine Distanz zwischen einer jeweiligen Bit-Position in der ersten Vektormaske und einer nächstgelegenen vorhergehenden Bit-Position in der ersten Vektormaske darstellt, der ein Wert zugewiesen ist, der die Bedingung als nicht erfüllt identifiziert; und Durchführen des Vektorisierungsprozesses basierend auf den ersten Distanzen.
Das Verfahren gemäß Anspruch 22, ferner umfassend: Durchführen einer Analyse einer zweiten Vektormaske, um zu bestimmen, dass die ersten Distanzen korrigiert werden sollen, wobei die zweite Vektormaske einen oder mehrere Fälle, dass die Bedingung für einen oder mehrere Werte eines zweiten Vektors von Werten erfüllt ist, und einen oder mehrere Fälle, dass die Bedingung für den zweiten Vektor von Werten nicht erfüllt ist, darstellen soll, wobei der zweite Vektor von Werten einer oder mehreren zweiten Iterationen der iterativen Schleife entsprechen soll; und ansprechend auf die Analyse ein Erzeugen korrigierter erster Distanzen, die auf einer Korrektur der ersten Distanzen basierend auf einem oder mehreren von einer zweiten Distanz oder der zweiten Vektormaske basieren, wobei die zweite Distanz basierend auf der zweiten Vektormaske bestimmt werden soll.
Das Verfahren gemäß Anspruch 23, ferner umfassend: Bestimmen, dass die iterative Schleife eine oder mehrere rückwärts gerichtete, iterationsübergreifende Abhängigkeiten umfasst; Erzeugen der ersten Vektormaske ansprechend auf die iterative Schleife, die eine oder mehrere rückwärts gerichtete, iterationsübergreifende Abhängigkeiten umfasst; und Ausführen einer Vektoroperation basierend auf den korrigierten ersten Distanzen.
Das Verfahren gemäß einem der Ansprüche 20-24, wobei das Ausführen des ersten Codeabschnitts eine Modifikation eines oder mehrerer von einem Array oder einem Wert einer Variablen veranlasst.