DE10353267B3

DE10353267B3 - Multithread-Prozessorarchitektur zum getriggerten Thread-Umschalten ohne Zykluszeitverlust und ohne Umschalt-Programmbefehl

Info

Publication number: DE10353267B3
Application number: DE10353267A
Authority: DE
Inventors: Jinan Lin; Xiaoning Nie
Original assignee: Infineon Technologies AG
Current assignee: Infineon Technologies AG
Priority date: 2003-11-14
Filing date: 2003-11-14
Publication date: 2005-07-28
Anticipated expiration: 2023-11-15
Also published as: US20050149931A1

Abstract

Ein Multithread-Prozessor nach der erfinderischen Architektur ist ein getakteter Multithread-Prozessor zur Datenverarbeitung von Threads mit einer Standardprozessorrumpfeinheit (1), bei dem Threads ohne Taktzyklusverlust durch ein Thread-Umschalt-Trigger-Datenfeld (11) getriggert von dem aktuell durch die Standardprozessorrumpfeinheit (1) abzuarbeitenden Thread T¶j¶ auf einen anderen Thread T¶l¶ umschaltbar sind, wobei ein jeder Programmbefehl I¶jk¶ eines Threads T¶j¶ ein solches Thread-Umschalt-Trigger-Datenfeld (11) aufweist.

Description

Die Erfindung betrifft eine Architektur eines Multithread-Prozessors zum getriggerten Umschalten von Threads, welche in einer Standardprozessoreinheits-Pipeline eines Multithread-Prozessors abgearbeitet werden, ohne einen Taktzyklusverlust und ohne Einsatz eines zusätzlichen Umschalt-Programmbefehls.
Ein Multithread-Prozessor nach der erfinderischen Architektur weist eine Befehlsholeinheit zum Holen von Programmbefehlen mehrerer (N) Threads aus einem Programmbefehlsspeicher auf, wobei innerhalb eines jeden gespeicherten Programmbefehls ein Thread-Umschalt-Trigger-Datenfeld vorgesehen ist, ein erweitertes Befehlsregister zum Zwischenspeichern von mindestens einem geholten Programmbefehl und zum Auslesen von dessen Thread-Umschalt-Trigger-Datenfeld, eine Standardprozessorrumpfeinheit zur Befehlsausführung der zwischengespeicherten Programmbefehle mehrerer (N) Threads, wobei die Standardprozessorrumpfeinheit durch ein Taktsignal mit vorbestimmter Taktzykluszeit getaktet ist, mehrere (N) Kontextspeicher, welche jeweils einen aktuellen Kontext eines Threads zwischenspeichern, einen Umschalt-Detektor zum Auslesen des Thread-Umschalt-Trigger-Datenfeldes, wobei der Umschalt-Detektor in Abhängigkeit des Thread-Umschalt-Trigger-Datenfeldes und eines Umschalt-Programmbefehls ein Umschalt-Trigger-Signal generiert und wobei der Umschalt-Detektor in Abhängigkeit des Thread-Umschalt-Trigger-Datenfeldes und des Umschalt-Programmbefehls den adressierten Thread für eine Anzahl n verzögerter Taktzyklen mittels einer Verzögerungsstre cke sperrt, wobei die Anzahl n verzögerter Taktzyklen dem Wert des Thread-Umschalt-Trigger-Datenfeldes entspricht oder innerhalb eines Umschalt-Programmbefehls vorliegt, und der Umschalt-Detektor nach Ablauf der Anzahl n verzögerter Taktzyklen ein Thread-Reaktivierungssignal für den adressierten Thread bereitstellt und eine Thread-Kontrolleinheit, welche die Reihenfolge der durch die Standardprozessorrumpfeinheit auszuführenden Programmbefehle der verschiedenen Threads in Abhängigkeit der Umschalt-Trigger-Signale und der Thread-Reaktivierungssignale derart steuert, dass ein Umschalten zwischen Threads ohne Taktzykluszeit erfolgt.

Nachdem verschiedene Methoden zur Vermeidung von Latenzzeiten nach dem Stand der Technik, beispielsweise Methoden der Instruction-Level-Parallelisierung (ILP), zum Beispiel Multiple Issue, Out-of-Order Execution oder Prefetching, an ihre technischen Grenzen stoßen, zielt die Erfindung auf eine Tolerierung von Latenzzeiten und eine gleichzeitige Verbesserung der Auslastung des Prozessors. Die Erfindung gehört zum Gebiet der Thread-Level-Parallelisierung (TLP), wobei ein Thread solange bearbeitet wird, bis dieser zur Umschaltung getriggert wird (Switching on Trigger). Die Anzahl der Onboard-Threads ist dabei skalierbar (Course-Grained-Multithreading).

Die Erfindung basiert auf der bekannten Tatsache, dass Latenzzeiten von Programmbefehlen von Threads nach ihrer Dauer und ihrem Auftreten charakterisiert werden können. Eine Latenzzeit wird charakterisiert durch ihr deterministisches oder nicht deterministisches Auftreten und durch ihre deterministische oder nicht deterministische Dauer.

Kurze Latenzzeiten sind im Wesentlichen von deterministischem Auftreten. Lange Latenzzeiten sind im Wesentlichen von nicht deterministischem Auftreten.

Lange Latenzzeiten werden wie in herkömmlichen Course-Grained-Multithreaddingprozessoren behandelt. Die Erfindung zielt darauf ab, für Latenzzeiten mit deterministischem Auftreten ein Umschalten von Threads bereitzustellen, welches ohne Taktzyklusverlust erfolgt.

Eingebettete Prozessoren und deren Architekturen werden an ihrem Leistungsverbrauch, ihrem Durchsatz, ihrer Auslastung (Utilization), ihren Kosten und ihrer Realzeitfähigkeit gemessen. Um den Durchsatz und die Auslastung zu erhöhen, kommt das Prinzip des Pipelining zum Einsatz. Die Grundidee des Pipelining basiert darauf, beliebige Instruktionen bzw. Befehle in Bearbeitungsphasen gleicher zeitlicher Dauer zu unterteilen. Eine Pipeline mit verschiedenen Verarbeitungselementen ist dann möglich, wenn die Verarbeitung einer Instruktion selbst in mehrere Phasen mit disjunkten und nacheinander durchführbaren Prozessschritten einteilbar ist. Die ursprünglichen zwei Befehlsausführungsphasen des Von-Neumann-Modells, nämlich Befehlsholung und Befehlsbearbeitung werden dabei weiter unterteilt, da sich die Teilung in zwei Phasen für ein Pipelining als zu grob erweist. Die bei RISC-Prozessoren im Wesentlichen angewendete Pipelinevariante beinhaltet vier Phasen der Befehlsbearbeitung nämlich Befehlholen, Befehlcodieren/Operandenholen, Befehlausführung und Zurückschreiben.

Ein Thread T bezeichnet einen Kontrollfaden eines Codes bzw. Quellcodes bzw. Programms, wobei innerhalb eines Threads T Datenabhängigkeiten bestehen und zwischen verschiedenen Threads T schwache Datenabhängigkeiten bestehen (wie in Kap. 3 in T. Bayerlein, O. Hagenbruch: „Taschenbuch Mikroprozessortechnik", 2. AuTeilsignale Fachbuchverlag Leipzig im Karl Hanser Verlag München – Wien, ISBN 3-446-21686-3 beschrieben).

Eine Eigenschaft eines Prozesses ist, dass ein Prozess stets auf einen eigenen Speicherbereich zugreift. Ein Prozess besteht aus mehreren Threads. Demnach ist ein Thread ein Programmteil eines Prozesses. Ein Kontext eines Threads ist der Prozessorzustand eines Prozessors, welcher diesen Thread bzw. Instruktionen dieses Threads bearbeitet. Demnach ist der Kontext eines Threads definiert als ein temporärer Prozessorzustand während der Bearbeitung des Threads durch diesen Prozessor. Der Kontext wird von der Hardware des Prozessors, nämlich dem Programmzählregister PZR bzw. Programmcounter PC, dem Registerfile bzw. Kontextspeicher K und dem dazu gehörigen Statusregister SR gehalten.

In 1 ist schematisch ein herkömmlicher Multithread-Prozessor MT dargestellt, bei der eine Standardprozessoreinheit SPE mehrere Threads T bzw. Kontrollfäden, leichtgewichtige Tasks, separate Programmcodes, gemeinsame Datenbereiche abarbeitet. Ein Thread T bezeichnet einen Kontrollfaden eines Codes bzw. Quellcodes bzw. Programms, wobei innerhalb eines Threads T Datenabhängigkeiten bestehen und zwischen verschiedenen Threads T schwache Datenabhängigkeiten bestehen (wie in Kap. 3 in T. Bayerlein, 0. Hagenbruch: „Taschenbuch Mikroprozessortechnik", 2. AuTeilsignale Fachbuchverlag Leipzig im Karl Hanser Verlag München – Wien, ISBN 3-446-21686-3 beschrieben). In 1 repräsentieren ohne Beschränkung der Allgemeinheit die Threads T-A, T-B eine beliebige Anzahl N an Threads und sind innerhalb eines Multithread-Prozessors MT mit der Standardprozessorrumpfeinheit SPE fest verdrahtet, wobei eine effizientere Umschaltung zwischen einzelnen Threads T gewährleistet wird. Dadurch vermindert sich die Blockierwahrscheinlichkeit p_MT eines Multithread-Prozessors MT gegenüber der Blockierwahrscheinlichkeit p_VN einer Von-Neumann-Maschine bei gleichbleibender Thread-Blockierwahrscheinlichkeit p_T, da ineffiziente Wartestellungen des Prozessors durch Ergebnisoperationen des Speichers minimiert werden.

In 2 ist ein Übergangsdiagramm dargestellt, das zeigt, wie ein herkömmlicher Multithread-Prozessor einen Thread T zwischen den Threadzuständen, nämlich einem ersten Threadzustand „In Ausführung" TZ-A, einem zweiten Threadzustand „Rechenbereit" TZ-B, einem dritten Threadzustand „Wartend" TZ-C und einem vierten Threadzustand „Schlafend" TZ-D, umschaltet. Zu einem bestimmten Taktzyklus ist ein Thread T genau in einem Threadzustand. Die möglichen Übergänge von einem Threadzustand zu einem anderen Threadzustand sollen im Folgenden aufgezeigt werden.

Davor werden die einzelnen Zustände erläutert. Der erste Threadzustand „In Ausführung" TZ-A bedeutet, dass Programmbefehle dieses Threads T_j aus einem Programmbefehlsspeicher PBS von der Befehlsholeinheit BHE geholt werden. Zu jedem Zeitpunkt bzw. Taktzyklus existiert nur ein Thread T_j, welcher sich in dem ersten Threadzustand „In Ausführung" TZ-A befindet.

Der zweite Threadzustand „Rechenbereit" TZ-B bedeutet, dass ein Thread T_j bereit ist, in den ersten Threadzustand „In Ausführung" TZ-A umgeschaltet zu werden, was beispielsweise heißt, dass keine Instruktionen dieses Threads T_j, der sich in dem zweiten Threadzustand „Rechenbereit" TZ-B befindet, auf externe Speicherzugriffe warten.

Der dritte Threadzustand „Wartend" TZ-C bedeutet, dass der Thread T_j zum aktuellen Zeitpunkt nicht in den ersten Threadzustand „In Ausführung" TZ-A umgeschaltet werden kann, da beispielsweise auf externe Speicherzugriffe bzw. Registerzugriffe gewartet wird.

Der vierte Threadzustand „Schlafend" TZ-D bedeutet, dass der Zustand T_j in keinem der drei vorher genannten Threadzuständen ist.

Folgende Übergänge eines Threadzustandes auf einen anderen Threadzustand sind möglich.

Der Übergang von dem ersten Threadzustand „In Ausführung" TZ-A in den zweiten Threadzustand „Rechenbereit" TZ-B für den Thread T_j:
Der Übergang des Threads T_j von dem ersten Threadzustand „In Ausführung" TZ-A in den zweiten Threadzustand „Rechenbereit" TZ-B findet statt, wenn für einen anderen Thread T₁ ein expliziter Startbefehl ausgeführt wird, ein externer Interrupt den Thread T_j in den Threadzustand „Rechenbereit" TZ-B setzt oder wenn ein Timeout für den Thread T_j auftritt.

Der Übergang des ersten Threadzustandes „In Ausführung" TZ-A in den vierten Threadzustand „Schlafend" TZ-D für den Thread T_j:
Dieser Übergang findet statt, wenn für den Thread T_j ein terminierender Programmbefehl auftritt.

Der Übergang von dem ersten Threadzustand „In Ausführung" TZ-A in den dritten Threadzustand „Wartend" TZ-C für den Thread T_j:
Dieser Übergang tritt auf durch einen Umschalttrigger während einer Latenzzeit oder auf Grund einer Synchronisierung des Threads T_j mit einem anderen Thread T₁.

Der Übergang des zweiten Threadzustandes „Rechenbereit" TZ-B in den ersten Threadzustand „In Ausführung" TZ-A für den Thread T_j:
Dieser Übergang findet statt, wenn der Thread T_j von einem externen Steuerprogramm, welches die Umschalttriggersignale verwaltet, ausgewählt wird.

Der Übergang des zweiten Threadzustandes „Rechenbereit" TZ-B in den dritten Threadzustand „Wartend" TZ-C für den Thread T_j:
Dieser Übergang findet statt, wenn der Thread T_j durch eine Ausnahme (Exception) oder einen Programmbefehl beendet wird.

Der Übergang des dritten Threadzustandes „Wartend" TZ-C in den zweiten Threadzustand „Rechenbereit" TZ-B:
Dieser Übergang findet in Folge eines Thread-Reaktivierungssignales TRS oder eines Ereignissteuersignals statt.

Der Übergang des dritten Threadzustandes „Wartend" TZ-C in den vierten Threadzustand „Schlafend" TZ-D für den Thread T_j:
Dieser Übergang findet statt, wenn der Thread T_j durch eine Ausnahme (Exception) oder einen Programmbefehl beendet wird.

In 3 sind die vier Phasen der Befehlsbearbeitung einer Standardprozessoreinheit SPE eines Multithread-Prozessors abgebildet, wobei in der ersten Phase, welche in einer Befehlholeinheit BHE abgearbeitet wird, die Instruktionen bzw. Programmbefehle aus dem Befehlspeicher in ein Befehlsregister BR der Standardprozessoreinheit SPE geladen werden.

Die zweite Befehlsphase, welche in einer Befehldecodieren/Operandenholeinheit BD/OHE abgearbeitet wird, besteht aus zwei datenunabhängigen Prozessschritten, nämlich dem Befehldecodieren und dem Holen von Operanden. Im Befehldecodier-Schritt werden in einer ersten Datenverarbeitung die im Befehlscode codierten Daten decodiert. Hierbei werden bekanntermaßen die Operationsvorschrift (Opcode), die Anzahl der zu ladenden Operanden, die Adressierungsart und weitere Zusatzsignale bestimmt, die im Wesentlichen die nachfolgenden Befehlsausführungsphasen steuern. Im Operandenholen-Prozessschritt werden alle für die nachfolgende Befehlsausführung benötigten Operanden aus den Registern (nicht gezeigt) des Prozessors geladen.

In der dritten Befehlsphase, welche in einer Befehlsausführungseinheit BAE abgearbeitet wird, werden die Rechenoperationen bzw. die Operationsvorschriften (Opcode) entsprechend den decodierten Befehlen ausgeführt. Die Operation selbst, sowie die dabei in Anspruch genommenen Schaltungsteile bzw. Register des Prozessors sind im Wesentlichen von der Art des abzuarbeitenden Befehls abhängig.

Bekanntermaßen werden in der vierten und letzten Phase, welche in einer Zurückschreibeeinheit abgearbeitet wird, die Ergebnisse der Operationen einschließlich sogenannter Zusatzsignale bzw. StatusTeilsignals bzw. Teilsignals in die entsprechenden Register oder Speicher (nicht gezeigt) gespeichert. Mit dieser Phase ist die Bearbeitung bzw. Abarbeitung eines Maschinenbefehls bzw. einer Maschineninstruktion beendet.

Des Weiteren zeigt die 3, wie eine Standardprozessoreinheit SPE eines herkömmlichen Multithread-Prozessors MT beispielsweise von einem Thread T₁ auf einen anderen Thread T₂ umschaltet. Im gezeigten Beispiel werden die Instruktionen bzw. Programmbefehle I₁₁, I₁₂ und I₁₃ des Threads T₁ und die Instruktionen I₂₁, I₂₂ des Thread T₂ von einem Programmbefehlspeicher PBS (nicht gezeigt) in die Pipeline der Standardprozessoreinheit SPE übertragen. In dem Taktzyklus z-1 wird der Programmbefehl I₁₁ des Threads T₁ mittels der Befehlholeinheit BHE in das Befehlsregister BR zwischengespeichert.

In dem Taktzyklus z-2 wird der Programmbefehl I₁₁ des Threads T₁ von der Befehlsdecodier/Operandenholeinheit BD/OHE bearbeitet, während von der Befehlsholeinheit BHE die Instruktion I₁₂ in das Befehlsregister BR zwischengespeichert wird.

In dem Taktzyklus z-3 bearbeitet die Befehlsausführungseinheit BAE die Instruktion I₁₁, die Befehlsdecodier/Operandenholeinheit BD/OHE decodiert den Befehl I₁₂ und detektiert, dass es sich bei dem Programmbefehl I₁₂ um einen Umschaltbefehl (Switch-Befehl) handelt. Der Umschaltbefehl bewirkt, dass in den folgenden Taktzyklen keine Instruktionen des Thread T₁ geholt werden, sondern dass der Thread T₁ von dem ersten Threadzustand „In Ausführung" TZ-A in den zweiten Threadzustand „Rechenbereit" TZ-B oder in den dritten Thread zustand „Wartend" TZ-C umgeschaltet wird. Des Weiteren bewirkt der Umschaltbefehl, dass in den folgenden Taktzyklen Instruktionen eines anderen Threads T₂ geholt werden. In dem Taktzyklus z-3 wird noch eine Instruktion I₁₃ des Threads T₁ von der Befehlsholeinheit BHE in das Befehlsregister BR zwischengespeichert. Die Instruktion I₁₃ des Threads T₁ füllt in den nachfolgenden Taktzyklen die restlichen Pipeline-Stufen, wird aber nicht mehr von diesen bearbeitet, da der Thread T₁ in dem dritten Threadzustand „Wartend" TZ-C ist. In dem Taktzyklus z-4 wird die erste Instruktion I₂₁ des Threads T₂ von der Befehlsholeinheit BHE in das Befehlsregister BR zwischengespeichert. In den nachfolgenden Taktzyklen werden Instruktionen des Threads T₂ bearbeitet, solange dieser Thread T₂ nicht durch einen Umschaltbefehl umgeschalten wird.

Dieses Beispiel zeigt, dass der Einsatz eines Umschalt-Programmbefehls zum Umschalten zwischen zwei Threads T_j und T₁ innerhalb einer Pipeline einer Standardprozessoreinheit SPE eines Multithread-Prozessors MT den Nutzungsausfall von mindestens zwei Taktzyklen bedeutet. In dem gezeigten Beispiel werden in den Instruktionen I₁₃ und I₁₂ keine Befehle bzw. Programmbefehle des Threads T₁ ausgeführt, die Auslastung des Prozessors ist reduziert.

In 4 ist ein herkömmlicher Multithread-Prozessor MT zur Datenverarbeitung von Programmbefehlen von mehreren Threads dargestellt, wobei der Multithread-Prozessor MT Programmbefehle aus einem Programmbefehlsspeicher PBS ausliest, die Programmbefehle innerhalb einer Standardprozessoreinheit SPE abarbeitet und die Ergebnisse der Abarbeitung der Programmbefehle in den N mit der Standardprozessoreinheit SPE festverdrahteten Kontextspeichern K abspeichert oder mittels eines Datenbuses DB weiterleitet. Über den Datenbus DB werden die Daten im Fall eines Speicherbefehls an einen externen Speicher gesendet und dort extern abgespeichert. Der Multithread-Prozessor MT weist eine Standardprozessoreinheit SPE zur Abarbeitung von Programmbefehlen, N verschiedene Kontextspeicher K zum Zwischenspeichern der Speicherinhalte der Threads und eine Thread-Kontrolleinheit TK auf.

Die Thread-Kontrolleinheit TK hat die Funktion, bei einer Blockierung eines Threads, welcher sich in dem ersten Threadzustand „In Ausführung" TZ-A befindet, diesen Thread von dem ersten Threadzustand „In Ausführung" TZ-A in den dritten Threadzustand „Wartend" TZ-C umzuschalten und einen anderen Thread, der sich in dem zweiten Threadzustand „Rechenbereit" TZ-B befindet, schnell in den ersten Threadzustand „In Ausführung" TZ-A umzuschalten, so dass Instruktionen des Threads, der sich nun im ersten Threadzustand „In Ausführung" TZ-A befindet, bereitgestellt werden.

Nachdem jede Pipeline-Stufe der Standardprozessoreinheit SPE einen Programmbefehl eines anderen Threads abarbeiten bzw. bearbeiten kann, hat die Thread-Kontrolleinheit TK die Funktion, den NxM-Multiplexer NxM-MUX derart zu steuern, dass jeder Pipeline-Stufe die geeigneten Operanden des jeweiligen Threads bereitgestellt werden. Ein Demultiplexer DEMUX hat die Funktion, Operationsergebnisse von Programmbefehlen eines bestimmten Threads diese auf den Kontextspeicher K des bestimmten Threads zurückzuschreiben.

Die Thread-Kontrolleinheit TK steuert den NxM-Multiplexer NxM-MUX mittels des Steuersignals S1 und den Demultiplexer DEMUX mittels des Steuersignals S2.

Die Standardprozessoreinheit SPE weist vorzugsweise eine Befehlsholeinheit BHE, ein Befehlsregister BR, eine Befehlsdecodier/Operandenholeinheit BD/OHE, eine Befehlsausführungseinheit BAE und eine Zurückschreibeeinheit ZSE auf, wobei diese Einheiten eine Pipeline zur Programmbefehlsabarbeitung innerhalb der Standardprozessoreinheit SPE ausbilden. Wird ein Programmbefehl, welcher eine Blockierung der Pipeline der Standardprozessoreinheit SPE verursachen wird, von der Befehlsholeinheit BHE des Standardprozessoreinheit SPE aus dem Programmbefehlsspeicher PBS geholt und in ein Befehlsregister BR zwischengespeichert, so wird dieser Programmbefehl in einem nachfolgenden Taktzyklus von der Befehlsdecodier/Operandeneinheit BD/OHE decodiert. Nachdem dieser Programmbefehl eine Blockierung, beispielsweise auf Grund einer Wartezeit auf einen externen Speicher, verursacht, generiert die Befehlsdecodier/Operandenholeinheit BD/OHE ein internes Ereignissteuersignal intESS-A für einen Umschalt-Programmbefehl. Das interne Ereignissteuersignal intESS-A für einen Umschaltbefehl wird an die Thread-Kontrolleinheit TK übertragen. Auf Grund dieses internen Ereignissteuersignals intESS-A für einen Umschaltbefehl schaltet die Thread-Kontrolleinheit TK den Thread T_j, welcher den Programmbefehl, der die Blockierung der Pipeline der Standardprozessoreinheit SPE verursacht, aufweist, von dem ersten Threadzustand „In Ausführung" TZ-A in den dritten Threadzustand „Wartend" TZ-C um und schaltet einen anderen Thread T₁, welcher sich in dem zweiten Threadzustand „Rechenbereit" TZ-B befindet, in den ersten Threadzustand „In Ausführung" TZ-A um.

Die Thread-Kontrolleinheit TK steuert einen Multiplexer MUX derart, dass aus dem Programmzählregister K-A des Kontextspeichers K des Threads T₁ Adressen von Programmbefehlen des Threads T₁ ausgelesen werden und an den Programmbefehlsspei cher PBS gesendet werden, um Programmbefehle des Threads T₁ bereitzustellen. Damit können diese von der Befehlsholeinheit BHE der Standardprozessoreinheit SPE geholt werden.

In der Anordnung nach dem Stand der Technik, welche in 4 dargestellt ist, ist gezeigt, wie aufgrund eines blockierenden Programmbefehls eines Threads T_j von diesem Thread T_j auf einen anderen Thread T₁ umgeschaltet wird. Das Umschalten wird getriggert durch ein internes Ereignissteuersignal intESS-A für einen Umschalt-Programmbefehl. Das Umschalten kann wie oben durch einen eigenen Umschalt-Programmbefehl aus dem Programmbefehlsspeicher PBS oder durch einen externen Interrupt initialisiert werden. Nachdem das interne Ereignissteuersignal intESS-A für einen Umschaltbefehl erst in einer tieferen Stufe der Pipeline der Standardprozessoreinheit SPE detektiert bzw. decodiert wird, sind nach diesem Beispiel mindestens zwei Taktzyklen zum Umschalten von einem Thread T_j auf einen anderen Thread T₁ notwendig. Diese zum Umschalten benötigten Taktzyklen sind für die Abarbeitung von Programmbefehlen verloren.

In dem Dokument „A Survey of Processors with explicit Multithreading", erschienen in ACM-Computing Surveys, März 2003, PP. 29-63, zählen die Autoren Theo Ungerer, Borut Robič und Jurij Šilc eine Vielzahl bekannter Multithread-Prozessoren und Multithread-Techniken auf.

Es ist daher Aufgabe der vorliegenden Erfindung, einen Multithread-Prozessor zu schaffen, der zwischen mehreren Threads ohne Taktzyklusverlust und ohne notwendigen eigenen Umschalt-Programmbefehl umschaltet.

Diese Aufgabe wird erfindungsgemäß durch einen getakteten Multithread Prozessor mit den Merkmalen des Patentanspruchs 1 und ein Verfahren mit den Merkmalen des Patentanspruchs 46 gelöst.

Die der vorliegenden Erfindung zugrundeliegende Idee besteht im Wesentlichen darin, von einem Thread T_j, welcher in m Taktzyklen einen die Pipeline der Standardprozessorrumpfeinheit blockierenden Programmbefehl I_jk, welcher eine Latenzzeit mit deterministischem Auftreten zur Folge hat, aufweist, frühzeitig auf einen anderen rechenbereiten Thread T₁ umzuschalten.

Ein Multithread-Prozessor nach der erfinderischen Architektur ist ein getakteter Multithread-Prozessor zur Datenverarbeitung von Programmbefehlen, wobei die Programmbefehle jeweils ein Programmbefehlsformat mit einem Thread-Umschalt-Trigger-Datenfeld aufweisen, wobei das Thread-Umschalt-Trigger-Datenfeld mehrere Steuerbits aufweist, welche einen TSTF-Wert ausbilden, wobei ein Umschalt-Trigger-Signal zur Umschaltung von Threads durch einen TSTF-Wert größer Null generiert wird.

Die Vorteile der erfindungsgemäßen Anordnung liegen insbesondere darin, dass der Multithread-Prozessor die Blockierungszeit, welche durch einen die Standardprozessorrumpfeinheit blockierenden Programmbefehl verursacht wird, ausnutzt, um Programmbefehle anderer Threads abzuarbeiten.

In den Unteransprüchen finden sich vorteilhafte Weiterbildungen der Multithread-Prozessorarchitektur zum Thread-Umschalten ohne Zykluszeitverlust und ohne einen notwendigen Einsatz eines Umschalt-Programmbefehls.

Gemäß einer bevorzugten Weiterbildung befindet sich ein Thread T in dem ersten Threadzustand "In Ausführung", in einem zweiten Threadzustand "Rechenbereit", in dem dritten Threadzustand "Wartend" oder in einem vierten Threadzustand "Schlafend".

Gemäß einer weiteren bevorzugten Weiterbildung weist der Multithread-Prozessor folgende Einheiten auf. Eine Befehlsholeinheit zum Holen von Programmbefehlen I_jk von mindestens einem Thread T aus dem Programmbefehlsspeicher, wobei jeder Programmbefehl ein Thread-Umschalt-Trigger-Datenfeld aufweist. Das Thread-Umschalt-Trigger-Datenfeld gibt an, ob ein Thread T_j von dem ersten Threadzustand "In Ausführung" in den dritten Threadzustand "Wartend" umgeschaltet wird. Außerdem gibt das Thread-Umschalt-Trigger-Datenfeld an, für welche Anzahl n verzögerter Taktzyklen der Thread T_j in dem dritten Threadzustand "Wartend" gehalten wird.

Ein Vorteil dieser Weiterbildung ist, dass durch das Thread-Umschalt-Trigger-Datenfeld ein einfaches Datenformat zum Umschalten von Threads innerhalb eines Multithread-Prozessors bereitgestellt wird. Das Thread-Umschalt-Trigger-Datenfeld ist einheitlich jeweils in einem vorstehenden Programmbefehl vorgesehen, um frühzeitig ausgelesen werden zu können. Vorteilhafterweise wird durch das frühzeitige Auslesen eine Umschaltung ohne Taktzykluszeitverlust (Zero-Overhead-Switching) gewährleistet.

Gemäß einer weiteren bevorzugten Weiterbildung weist der Multithread-Prozessor ein erweitertes Befehlsregister zum Zwischenspeichern von mindestens einem geholten Programmbefehl I_jk auf.

Ein Vorteil dieser erfindungsgemäßen Weiterbildung ist, dass bereits aus dem erweiterten Befehlsregister, welches sich vor der Pipeline der Standardprozessorrumpfeinheit befindet, das Thread-Umschalt-Trigger-Datenfeld ausgelesen werden kann. Dadurch wird ein frühzeitiges Umschalten von Threads ermöglicht.

Gemäß einer weiteren bevorzugten Weiterbildung ist die Standardprozessorrumpfeinheit zur sequenziellen Befehlsausführung des zwischengespeicherten Programmbefehls vorgesehen. Dabei ist die Standardprozessorrumpfeinheit mit vorbestimmter Taktzykluszeit getaktet.

Ein Vorteil dieser erfindungsgemäßen Weiterbildung ist, dass durch die Taktung der Standardprozessorrumpfeinheit eine Echtzeitfähigkeit des Multithread-Prozessors gewährleistet wird.

Gemäß einer weiteren bevorzugten Weiterbildung sind innerhalb des Multithread-Prozessors N Kontextspeicher vorgesehen. Die N Kontextspeicher speichern jeweils einen aktuellen Kontext eines Threads zwischen.

Ein Vorteil dieser erfindungsgemäßen Weiterbildung ist, dass durch die Bereitstellung von N verschiedenen Kontexten innerhalb des Multithread-Prozessors ein schnelles hardwaretechnisches Umschalten zwischen Threads gewährleistet wird.

Gemäß einer weiteren bevorzugten Weiterbildung sind innerhalb eines Umschalt-Programmbefehls eines Threads T_j Daten vorgesehen, welche angeben, für welche Anzahl n verzögerter Taktzyklen der Thread T_j in dem Thread-Zustand „Wartend" gehalten wird. Für den Fall n=0 wird der abzuarbeitende Thread T_j in den zweiten Threadzustand „Rechenbereit" umgeschaltet.

Ein Vorteil dieser bevorzugten Weiterbildung ist, dass auch mittels herkömmlicher Umschalt-Programmbefehle ein Umschalten von Threads gewährleistet wird. Erfindungsgemäß sind innerhalb eines Umschalt-Programmbefehls Daten vorgesehen, welche angeben, für welche Anzahl n verzögerter Taktzyklen der Thread T in dem Thread-Zustand „Wartend" gehalten wird. Somit kann ein bestimmter Thread sowohl durch einen Umschalt-Programmbefehl als auch durch einen TSTF-Wert größer 0 umgeschalten werden. Auch die Anzahl n verzögerter Taktzyklen wird von beiden, dem TSTF-Wert und dem Umschalt-Programmbefehl, bereitgestellt.

Gemäß einer weiteren bevorzugten Weiterbildung weist der Multithread-Prozessor einen Umschalt-Detektor auf. Der Umschalt-Detektor generiert in Abhängigkeit von dem Thread-Umschalt-Trigger-Datenfeld oder in Abhängigkeit von einem internen Ereignissteuersignal intESS-A für einen Umschalt-Programmbefehl ein Umschalt-Trigger-Signal. Der TSTF-Wert des Thread-Umschalt-Trigger-Datenfeldes entspricht einer Anzahl n verzögerter Taktzyklen. Ist ein TSTF-Wert eines Thread-Umschalt-Trigger-Datenfeldes ungleich Null, wird ein Umschalt-Trigger-Signal zur Umschaltung des Threads T_j von den ersten Threadzustand „In Ausführung" in den dritten Threadzustand „Wartend". Mittels einer Verzögerungsstrecke generiert der Umschalt-Detektor nach Ablauf der Anzahl n verzögerter Taktzyklen ein Thread-Reaktivierungssignal für den Thread T_j und dieser wird von dem dritten Threadzustand „Wartend" in den zweiten Threadzustand „Rechenbereit" umgeschaltet.

Ein Vorteil dieser erfindungsgemäßen Weiterbildung ist, dass die Bereitstellung eines Umschalt-Detektors es ermöglicht, frühzeitig Threads, die die Pipeline der Standardprozessorrumpfeinheit blockieren würden, umzuschalten. Außerdem stellt der Umschalt-Detektor eine Möglichkeit zur Verfügung, den jeweiligen blockierenden Thread für die geeignete Anzahl n verzögerter Taktzyklen in dem Threadzustand "Wartend" zu halten.

Für einen Programmbefehl, welcher eine Latenzzeit mit deterministischem Auftreten zur Folge hat, wird Thread-Umschalt-Trigger-Datenfeld eines Vorgängerbefehls derart gesetzt, so dass der TSTF-Wert der zu erwartenden Dauer der Latenzzeit entspricht.

Gemäß einer weiteren bevorzugten Weiterbildung weist der Multithread-Prozessor eine Thread-Kontrolleinheit auf, welche die Reihenfolge der durch die Standardprozessorrumpfeinheit abzuarbeitenden Programmbefehle der verschiedenen Threads in Abhängigkeit des Umschalt-Trigger-Signals und der Thread-Reaktivierungssignale derart steuert, dass ein Umschalten zwischen Threads ohne Taktzyklusverlust erfolgt. Aufgrund des Umschalt-Trigger-Signals für den Thread T_j wird der Thread T_j von dem ersten Threadzustand "In Ausführung" in den dritten Threadzustand "Wartend" umgeschaltet. Gleichzeitig wird aufgrund des Umschalt-Trigger-Signals ein anderer Thread T₁ von dem zweiten Threadzustand "Rechenbereit" in den ersten Threadzustand "In Ausführung" umgeschaltet. Aufgrund des Thread-Reaktivierungssignals für den Thread T_j wird der Thread T_j von dem dritten Threadzustand "Wartend" in den zweiten Threadzustand "Rechenbereit" umgeschaltet.

Gemäß einer weiteren bevorzugten Weiterbildung steuert die Thread-Kontrolleinheit einen N×1 Multiplexer derart, dass Programmbefehle eines Threads, welcher sich in dem ersten Threadzustand "In Ausführung" befindet, von dem Programmbefehlsspeicher ausgelesen und von der Standardprozessorrumpfeinheit abgearbeitet werden.

Gemäß einer weiteren bevorzugten Weiterbildung steuert die Thread-Kontrolleinheit einen N×1 Multiplexer derart, dass Programmbefehle eines Threads T_j, welcher sich in dem zweiten Threadzustand "Rechenbereit" befindet, dann von dem Programmbefehlsspeicher ausgelesen und von der Standardprozessorrumpfeinheit abgearbeitet werden, wenn sich kein anderer Thread T₁ in dem ersten Threadzustand "In Ausführung" befindet. D.h. der Thread T_j wird in den ersten Threadzustand „In Ausführung" umgeschaltet.

Gemäß einer weiteren bevorzugten Weiterbildung steuert die Thread-Kontrolleinheit den N×1 Multiplexer derart, dass Programmbefehle eines Threads T_j, welcher sich in dem dritten Threadzustand "Wartend" befindet, erst dann vom Programmbefehlsspeicher ausgelesen und von der Standardprozessorrumpfeinheit abgearbeitet werden, wenn die Thread-Kontrolleinheit das Thread-Reaktivierungssignal für den Thread T_j empfängt. Im Folgenden wird derselbe Thread T_j in den zweiten Threadzustand "Rechenbereit" umgeschaltet, wenn sich kein anderer Thread T₁ in dem ersten Threadzustand "In Ausführung" befindet, wird der Thread T_j in den ersten Threadzustand „In Ausführung" umgeschaltet.

Gemäß einer weiteren bevorzugten Weiterbildung steuert die Thread-Kontrolleinheit den N×1 Multiplexer derart, dass keine Programmbefehle eines Threads T_j, der sich in dem vierten Threadzustand "Schlafend" befindet, von dem Programmbefehlsspeicher ausgelesen und von der Standardprozessorrumpfeinheit abgearbeitet werden.

Gemäß einer weiteren bevorzugten Weiterbildung weist der Umschalt-Detektor eine Verzögerungsschaltung für N Threads und eine Trigger-Schaltung für das Umschalt-Trigger-Signal auf.

Gemäß einer weiteren bevorzugten Weiterbildung weist die Verzögerungsschaltung für N Threads für jeden der N Threads eine Verzögerungsstrecke auf. Eine Verzögerungsstrecke für den entsprechenden Thread verzögert diesen um die Anzahl n verzögerter Taktzyklen, wobei die Anzahl n verzögerter Taktzyklen dem TSTF-Wert des entsprechenden Thread-Umschalt-Trigger-Datenfeldes entspricht. Mittels der Verzögerungsstrecke 14 wird der entsprechende Thread T_j für die Anzahl n verzögerter Taktzyklen in dem dritten Threadzustand "Wartend" gehalten.

Gemäß einer weiteren bevorzugten Weiterbildung liegt das Thread-Umschalt-Trigger-Datenfeld eines bestimmten Programmbefehls in einem mehrere m Taktzyklen vorstehenden Programmbefehl vor, wobei dieses Vorschieben des Thread-Umschalt-Trigger-Datenfeldes beispielsweise durch einen Assembler bereitgestellt wird.

Ein Vorteil dieser bevorzugten Weiterbildung ist, dass mittels des Thread-Umschalt-Trigger-Datenfeldes eine frühzeitige Detektion von Umschalt-Daten über einen Programmbefehl an den Umschalt-Detektor gesendet werden, wobei dieser Programmbefehl noch im Programmbefehlsspeicher ist.

Gemäß einer weiteren bevorzugten Weiterbildung weist das Thread-Umschalt-Trigger-Datenfeld ein um mehrere Steuerbits erweitertes Programmbefehlsformat auf. Die Steuerbits bilden einen TSTF-Wert aus.

Gemäß einer weiteren bevorzugten Weiterbildung wird das Umschalt-Trigger-Signal durch einen TSTF-Wert größer Null generiert. Mittels des Thread-Umschalt-Trigger-Datenfeldes eines Programmbefehls des Threads T_j wird der Thread T_j von dem ersten Threadzustand "In Ausführung" in den dritten Threadzustand "Wartend" umgeschaltet.

Gemäß einer weiteren bevorzugten Weiterbildung gibt der TSTF-Wert des Thread-Umschalt-Trigger-Datenfeldes des Programmbefehls I_jk des Threads T_j an, für welche Anzahl n verzögerter Taktzyklen der Thread T_j in den dritten Threadzustand "Wartend" gesetzt werden wird, wobei der TSTF-Wert die Länge der Verzögerungsstrecke angibt.

Gemäß einer weiteren bevorzugten Weiterbildung wird mittels des Thread-Reaktivierungssignals für den Thread T_j nach Ablauf der Anzahl n verzögerter Taktzyklen der Thread T_j aus dem dritten Threadzustand "Wartend" in den zweiten Threadzustand "Rechenbereit" umgeschaltet.

Gemäß einer weiteren bevorzugten Weiterbildung weist die Standardprozessorrumpfeinheit einen Befehlsdecoder zur Decodierung eines Programmbefehls, eine Befehlsausführungseinheit zum Ausführen des decodierten Programmbefehls und eine Zurückschreibeeinheit zum Zurückschreiben von Operationsergebnissen auf.

Gemäß einer weiteren bevorzugten Weiterbildung weist jeder Kontextspeicher ein Programmzählregister zum Zwischenspeichern eines Programmzählers, eine Registerbank zum Zwischenspeichern von Operanden und ein Statusregister zum Zwischenspeichern von Status-Teilsignals auf.

Gemäß einer weiteren bevorzugten Weiterbildung der Erfindung ist die Anzahl N an Kontextspeichern vorbestimmt.

Gemäß einer weiteren bevorzugten Weiterbildung bilden die Speicherinhalte des Programmzählregisters, der Registerbank und des Statusregisters den Kontext des entsprechenden Threads aus.

Gemäß einer bevorzugten Weiterbildung ist die Befehlsholeinheit zum Auslesen von Programmbefehlen mit dem Programmbefehlsspeicher verbunden. Dabei werden die aus dem Programmbefehlsspeicher ausgelesenen Programmbefehle durch die Programmzählregister der Kontextspeicher adressiert.

Gemäß einer weiteren bevorzugten Weiterbildung ist die Standardprozessorrumpfeinheit mit einem Datenbus verbunden, um die verarbeiteten Daten über diesen Datenbus an einen Datenspeicher weiterzuleiten.

Gemäß einer weiteren bevorzugten Weiterbildung arbeitet die Standardprozessorrumpfeinheit die ihr von der Thread-Kontrolleinheit zugeschalteten Programmbefehle sequenziell in einem Pipeline-Verfahren ab.

Gemäß einer weiteren bevorzugten Weiterbildung arbeitet die Standardprozessorrumpfeinheit einen abzuarbeitenden Programmbefehl innerhalb einer vorbestimmten Anzahl von Taktzyklen ab.

Gemäß einer weiteren bevorzugten Weiterbildung empfangen die Thread-Kontrolleinheit Ereignissteuersignale.

Gemäß einer weiteren bevorzugten Weiterbildung umfassen die empfangenen Ereignissteuersignale, welche von der Thread-Kontrolleinheit empfangen werden, interne Ereignissteuersignale und externe Ereignissteuersignale.

Gemäß einer weiteren bevorzugten Weiterbildung werden die internen Ereignissteuersignale von der Befehlsdecodiereinheit der Standardprozessorrumpfeinheit erzeugt.

Gemäß einer weiteren bevorzugten Weiterbildung umfassen die internen Ereignissteuersignale unter anderem ein internes Ereignissteuersignal intESS-A für einen Umschalt-Programmbefehl, welches von der Standardprozessorrumpfeinheit generiert wird.

Gemäß einer weiteren bevorzugten Weiterbildung wird das Umschalt-Trigger-Signal durch das interne Ereignissteuersignal intESS-A für einen Umschalt-Programmbefehl generiert. Das Signal intESS-A beinhaltet ein Teilsignal intESS-A-n, in welchem die Anzahl n verzögerter Taktzyklen vorliegt. Somit schaltet das Umschalt-Trigger-Signal eines Threads T_j den Thread T_j von dem ersten Threadzustand "In Ausführung" oder von dem zweiten Threadzustand "Rechenbereit" in den dritten Threadzustand "Wartend" um.

Gemäß einer weiteren bevorzugten Weiterbildung wird eine Verzögerungsstrecke für den Thread T_j durch das interne Ereignissteuersignal für einen Umschalt-Programmbefehl bereitgestellt. Nach Ablauf der Anzahl n verzögerter Taktzyklen der Verzögerungsstrecke schaltet das Thread-Reaktivierungssignal für den Thread T_j den Thread T_j aus dem dritten Threadzustand "Wartend" in den zweiten Threadzustand "Rechenbereit" um.

Gemäß einer weiteren bevorzugten Weiterbildung bildet ein ODER-Gatter, welches das interne Ereignissteuersignal für einen Umschalt-Programmbefehl mit dem TSTF-Wert des Thread-Umschalt-Trigger-Datenfeldes logisch verknüpft, die Trigger-Schaltung für ein Umschalt-Trigger-Signal aus.

Gemäß einer weiteren bevorzugten Weiterbildung wird die Verzögerungsschaltung von einem 1×N Demultiplexer, welcher den TSTF-Wert des Thread-Umschalt-Trigger-Datenfeldes eingangs seitig empfängt, und von einem 1×N Demultiplexer, welcher das interne Ereignissteuersignal für einen Umschaltbefehl eingangsseitig empfängt, angesteuert.

Gemäß einer weiteren bevorzugten Weiterbildung wird ein Thread-Identifikationssignal, welches den abzuarbeitenden Programmbefehl adressiert, von der Thread-Kontrolleinheit bereitgestellt.

Gemäß einer weiteren bevorzugten Weiterbildung synchronisiert das Thread-Identifikationssignal die beiden 1×N Demultiplexer, damit diese zum richtigen Zeitpunkt schalten.

Gemäß einer weiteren bevorzugten Weiterbildung werden die externen Ereignissteuersignale von externen Baugruppen erzeugt.

Ein Vorteil dieser Weiterbildung ist, dass durch die Bereitstellung der Ereignissteuersignale ein Thread-Umschalten sowohl von internen als auch von externen Baugruppen getriggert werden kann.

Gemäß einer weiteren bevorzugten Weiterbildung ist die Standardprozessorrumpfeinheit ein Teil eines DSP-Prozessors, eines Protokollprozessors oder eines Universalprozessors.

Gemäß einer weiteren bevorzugten Weiterbildung kann die Befehlsausführungseinheit der Standardprozessorrumpfeinheit eine arithmetisch-logische Einheit (ALU) und/oder eine Adressengeneratoreinheit (AGU) enthalten.

Gemäß einer weiteren bevorzugten Weiterbildung steuert die Thread-Kontrolleinheit in Abhängigkeit von den internen und externen Ereignissteuersignalen Schaltnetzwerke an.

Ausführungsbeispiele der Erfindung sind in den Zeichnungen dargestellt und in der nachfolgenden Beschreibung näher er läutert. Gleiche Bezugszeichen in den Figuren bezeichnen gleiche oder funktionsgleiche Elemente.
Es zeigen:
1 eine schematische Abbildung eines herkömmlichen Multithread-Prozessors nach dem Stand der Technik
2 ein Übergangsdiagramm aller potentiellen Thread zustände eines Threads des Standes der Technik
3 ein Ablaufdiagramm einer Abarbeitung von Programmbefehlen von zwei Threads mittels einer Pipeline einer Standardprozessoreinheit eines herkömmlichen Multithread-Prozessors, wobei zwischen den beiden Threads durch einen Umschalt-Programmbefehl umgeschaltet wird.
4 einen Blockschaltplan eines herkömmlichen Multithread-Prozessors nach dem Stand der Technik
5 eine erfindungsgemäße Erweiterung eines herkömmlichen Programmbefehlformats um ein Thread-Umschalt-Trigger-Datenfeld
6 ein Ablaufdiagramm einer erfindungsgemäßen Abarbeitung von Programmbefehlen von zwei Threads mittels einer Pipeline einer Standardprozessorrumpfeinheit eines Multithread-Prozessors, wobei zwischen den beiden Threads ohne einen Umschalt-Programmbefehl umgeschaltet wird.
7 einen Blockschaltplan eines erfindungsgemäßen Multithread-Prozessors mit einem Umschalt-Detektor
8 einen detaillierten Blockschaltplan des erfindungsgemäßen Umschalt-Detektors.
In den Figuren bezeichnen gleiche Bezugszeichen gleiche oder funktionsgleiche Bestandteile.
Obwohl die vorliegende Erfindung nachfolgend mit Bezug auf Prozessoren bzw. Mikroprozessoren bzw. deren Architekturen beschrieben wird, ist sie darauf nicht beschränkt, sondern auf vielfältige Weise einsetzbar.
In 5 ist ein erfindungsgemäßes Programmbefehlsformat dargestellt, welches bei einem erfindungsgemäßen Multithread-Prozessor zum Einsatz kommt. Das erfindungsgemäße Programmbefehlsformat ist eine Erweiterung eines herkömmlichen Programmbefehlsformats 20 um ein Thread-Umschalt-Trigger-Datenfeld 11. In dem Thread-Umschalt-Trigger-Datenfeld 11 sind mehrere Steuerbits vorgesehen, welche einen TSTF-Wert 19 ausbilden. Der in 5 dargestellte Programmbefehl I_jk ist der k-te Programmbefehl des Threads T_j.
In 6 ist ein Ablaufdiagramm einer erfindungsgemäßen Abarbeitung von Programmbefehlen von zwei Threads mittels einer Pipeline einer Standardprozessorrumpfeinheit 1 eines Multithread-Prozessors MT dargestellt, wobei zwischen den beiden Threads ohne einen Umschalt-Programmbefehl umgeschaltet wird. Die Standardprozessorrumpfeinheit 1 weist eine Befehlsdecodier/Operandenholeinheit 7, eine Befehlsausführungseinheit 8 und eine Zurückschreibeeinheit 9 auf. Die Pipeline des erfindungsgemäßen Multithread-Prozessors wird durch die Befehls decodier/Operandenholeinheit 7, der Befehlsausführungseinheit 8 der Zurückschreibeeinheit 9 der Standardprozessoreinheit 1 sowie einer Befehlsholeinheit 5 und einem Befehlsregister 6 ausgebildet. Eine gepunktete Umrandung eines Pipelineschrittes bzw. von Pipelineschritten zeigt an, dass für diesen Pipelineschritt bzw. diese Pipelineschritte genau ein Taktzyklus 32 benötigt wird.
In dem Taktzyklus t₁ wird der Programmbefehl I₁₁ des Threads T₁ von der Befehlsholeinheit 5 aus dem Programmbefehlsspeicher 10 (nicht gezeigt) geholt und in das Befehlsregister 6 zwischengespeichert. Der Programmbefehl I₁₁, der erste Programmbefehl des Threads T₁, weist neben seinem herkömmlichen Programmbefehlsformat 20 ein Thread-Umschalt-Trigger-Datenfeld 11 auf, welches angibt, ob der Programmbefehl I₁₂, welcher in dem Taktzyklus t₂ von der Befehlsholeinheit 5 aus dem Programmbefehlsspeicher 10 geholt werden wird, die Pipeline der Standardprozessorrumpfeinheit 1 blockieren wird und für wie viele Taktzyklen dieser Programmbefehl die Pipeline der Standardprozessoreinheit 1 blockieren wird.
Ist das mit dem Programmbefehl I₁₁ geholte Thread-Umschalt-Trigger-Datenfeld 11 Null, so wird der in dem Taktzyklus t₂ geholte Programmbefehl I₁₂ die Pipeline der Standardprozessorrumpfeinheit nicht blockieren. Ist das Thread-Umschalt-Trigger-Datenfeld 11 größer als Null, gibt der TSTF-Wert 19 des Thread-Umschalt-Trigger-Datenfeldes 11 an, um wie viele Taktzyklen dieser Programmbefehl I₁₂ die Pipeline der Standardprozessoreinheit 1 blockieren wird. Nachdem im vorliegenden Beispiel der mit dem Programmbefehl I₁₁ geholte TSTF-Wert 19 des Thread-Umschalt-Trigger-Datenfeld 11 nicht gleich Null ist, würde der nächste Programmbefehl des Threads T₁, nämlich der Programmbefehl I₁₂, die Pipeline blockieren, wenn keine Thread-Umschaltung ausgeführt wird.
In dem Taktzyklus t₂ decodiert die Befehlsdecodier/Operandenholeinheit 7 den Programmbefehl I₁₁ des Threads T₁ und die Befehlsholeinheit 5 holt den Programmbefehl I₁₂ des Threads T₁ aus dem Programmbefehlsspeicher 10 und speichert diesen in dem Befehlsregister 6 zwischen. Gleichzeitig wird der mit dem Programmbefehl I₁₁ geholte TSTF-Wert 19 (nach dem Beispiel ist der TSTF-WERT 19 gleich 2) des Thread-Umschalt-Trigger-Datenfeld 11 durch den Umschalt-Detektor 4 erkannt, welcher das Umschalt-Trigger-Signal UTS generiert und und das Umschalt-Trigger-Signal UTS an die Thread-Kontrolleinheit 3 überträgt, welche den Thread T₁ von dem ersten Threadzustand „In Ausführung" (25) in den dritten Threadzustand „Wartend" (27) und gleichzeitig einen anderen Thread T₂ von dem zweiten Threadzustand „Rechenbereit" (26) in den ersten Threadzustand „In Ausführung" (25) umschaltet. Somit ist I₁₂ der letzte geholte Programmbefehl des Threads T₁. Da der mit dem Programmbefehl I₁₁ geholte TSTF-Wert 19 des Thread-Umschalt-Trigger-Datenfeld 11 gleich 2 ist, wird für 2 Taktzyklen kein weiterer Programmbefehl vom Thread T₁ geholt werden.
In dem Taktzyklus t₃ bearbeitet die Befehlsausführungseinheit 8 der Standardprozessorrumpfeinheit 1 den Programmbefehl I₁₁ des Threads T₁, die Befehlsdecodier/Operandenholeinheit 7 der Standardprozessorrumpfeinheit 1 decodiert den Programmbefehl I₁₂ des Threads T₁ und die Befehlsholeinheit 5 holt einen Programmbefehl I₂₁ des Threads T₂, da eine Umschaltung des „In Ausführung"-Thread von Threads T₁ nach Threads T₂ in dem Taktzyklus t₂ vorgenommen wurde.
In den folgenden Taktzyklen t₄, t₅, usw. werden die Programmbefehle des Threads T₁, nämlich der Programmbefehl I₁₁ und der Programmbefehl I₁₂, von der Pipeline der Standardrozessorrumpfeinheit 1 weiter bearbeitet. Doch es werden von der Befehlsholeinheit 5 nur noch Programmbefehle des Threads T₂ geholt, bis dieser Thread T₂ aufgrund eines TSTF-Wertes 19 eines Thread-Umschalt-Trigger-Datenfeldes 11 eines Programmbefehles, welcher ungleich Null ist, umgeschaltet wird. In dem Taktzyklus t₅ wird Threads T₁ von dem dritten Threadzustand „Wartend" (27) in den zweiten Threadzustand „Rechenbereit" (26) umgeschaltet, d.h., Threads T₁ kann später jederzeit wieder ausgeführt werden, sobald Thread T₂ von dem ersten Threadzustand „In Ausführung" (25) in den dritten Threadzustand „Wartend" (27) umgeschaltet wird.
Die erfindungsgemäße Anordnung nach 6 zeigt, dass zwischen Threads T₁ und T₂ ohne den Verlust eines Taktzyklus und ohne den Einsatz eines Umschalt-Programmbefehls umgeschaltet wird.
In 7 ist ein Blockschaltplan eines erfindungsgemäßen Multithread-Prozessors mit einem Umschalt-Detektor dargestellt. Der Multithread-Prozessor MT ist mit einem Programmbefehlsspeicher 10 und einem Datenbus 21 verbunden.
Der Multithread-Prozessor MT nach der Erfindung weist im Wesentlichen eine Standardprozessorrumpfeinheit 1, N Kontextspeicher 2, eine Thread-Kontrolleinheit 3, einen Umschalt-Detektor 4, eine Befehlsholeinheit 5, ein Befehlsregister 6 und einen N×1 Multiplexer 12 auf.
Die Standardprozessorrumpfeinheit 1 ist nach dem Pipeline-Prinzip nach Von-Neumann organisiert. Die Pipeline der Standardprozessorrumpfeinheit 1 weist einen Befehlsdecoder 7, eine Befehlsausführungseinheit 8 und eine Zurückschreibeeinheit 9 auf.
Jeder der N Kontextspeicher 2 weist ein Programmzählregister 2-A, eine Registerbank 2-B und ein Statusregister 2-C auf.
Über die Registerbänke 2-B und die Statusregister 2-C der Kontextspeicher 2 werden bekanntermaßen den Pipeline-Stufen der Standardprozessorrumpfeinheit taktzyklussensitiv mittels des N×3 Multiplexers Operanden und Status-Teilsignals bereitgestellt.
Nach der Pipeline-Stufe der Befehlsbearbeitungseinheit 8 schreibt die Zurückschreibeinheit 9 Operationsergebnisse und StatusTeilsignals über einen 1×N Demultiplexer 18 auf den entsprechenden Kontextspeicher 2 bzw. auf die entsprechende Registerbank 2-B bzw. auf das entsprechende Statusregister 2-C. Außerdem stellt die Zurückschreibeeinheit 9 die berechneten Operationsergebnisse und Status-Teilsignals externen Speichern über einen Datenbus 21 zur Verfügung.
Die Programmzählregister 2-A der Kontextspeicher 2 adressieren die auszulesenden Programmbefehle. Welche Programmbefehle bezüglich des abzuarbeitenden Threads ausgelesen werden sollen, wird von der Thread-Kontrolleinheit 3 über den N×1 Multiplexer 12 gesteuert. Der N×1 Multiplexer 12 liest die Adressen der Programmbefehle aus dem Programmzählregister 2-i bezüglich des abzuarbeitenden Threads T_i. Über eine Adressleitung 22 werden die Adressen der auszulesenden Programmbefehle von dem N×1 Multiplexer 12 an den Programmbefehlsspeicher 10 übertragen. Die Befehlsholeinheit 5 liest die adressierten und von dem Programmbefehlsspeicher 10 auszulesenden Programmbefehle aus und speichert diese auf einem Befehlsregister 6 zwischen.
Der Befehlsdecoder 7 holt jeweils einen Programmbefehl aus dem Befehlsregister 6 und decodiert diesen. Handelt es sich bei dem decodierten Programmbefehl um einen Umschaltprogrammbefehl, generiert der Befehlsdecoder 7 ein internes Ereignissteuersignal intESS-A für den Umschallprogrammbefehl und sendet dieses Signal an die Umschalt-Detektor 4. In den folgenden Pipeline-Stufen wird der Programmbefehl entsprechend des Standes der Technik abgearbeitet.
Der Umschalt-Detektor 4 liest das Thread-Umschalt-Trigger-Datenfeld 11 eines Programmbefehls aus dem Befehlsregister 6 aus. Ist der TSTF-Wert 19 des ausgelesenen Thread-Umschalt-Trigger-Datenfelds 11 ungleich Null oder liegt ein internes Ereignissteuersignal intESS-A für einen Umschalt-Programmbefehl vor, generiert der Umschalt-Detektor 4 ein Umschalt-Trigger-Signal UTS und sendet dieses an die Thread-Kontrolleinheit 3. Außerdem setzt der Umschalt-Detektor 4 den durch das Thread-Umschalt-Trigger-Datenfeld 11 oder durch ein internes Ereignissteuersignal intESS-A für einen Umschalt-Programmbefehl adressierten Thread T_j in den Threadzustand "Wartend". Nach Ablauf der von dem TSTF-Wert 19 oder einem Umschalt-Programmbefehl (Teilsignal intESS-A-n) angegebenen Anzahl n verzögerter Taktzyklen generiert der Umschalt-Detektor 4 ein Thread-Reaktivierungssignal TRS für den entsprechenden Thread T_j und sendet dieses an die Thread-Kontrolleinheit 3.
Die Thread-Kontrolleinheit 3 generiert ein Steuersignal S1 zur Steuerung des N×3-Multiplexers 22 und generiert ein Steuersignal S2 zur Steuerung des 1×N-Demultiplexers 18.
Die Thread-Kontrolleinheit 3 empfängt die Umschalt-Trigger-Signale UTS sowie die Thread-Reaktivierungssignale TRS als auch Ereignissteuersignale ESS und generiert daraus eine optimierte Reihenfolge abzuarbeitender Threads. Mittels der optimierten Reihenfolge abzuarbeitender Threads wird der Multiplexer 12 angesteuert.
In 8 ist der Aufbau des Umschalt-Detektors 4 detailliert dargestellt. Der Umschalt-Detektor 4 weist im Wesentlichen eine Verzögerungsschaltung 13 und eine Trigger-Schaltung 15 auf.
Die Trigger-Schaltung 15 weist eine logische Verknüpfung zweier logischer ODER-Verknüpfungen 16-1 und 16-2 auf.
Die logische ODER-Verknüpfung 16-1 empfängt eingangsseitig den TSTF-Wert 19 des Thread-Umschalt-Trigger-Datenfeldes 11. Ist der TSTF-Wert 19 des Thread-Umschalt-Trigger-Datenfeldes 11 größer als Null, so wird der Ausgang der logischen ODER-Verknüpfung 16-1 auf Eins gesetzt.
Die zweite logische ODER-Verknüpfung 16-2 der Trigger-Schaltung 15 empfängt eingangsseitig den Ausgang der logischen ODER-Verknüpfung 16-1 und ein Switch-Teilsignal intESS-A-SW eines internes Ereignissteuersignal intESS-A für einen Umschalt-Programmbefehl. Ist entweder der Ausgang der logischen ODER-Verknüpfung 16-1 oder das Switch-Teilsignal intESS-A-SW eines internen Ereignissteuersignal intESS-A für einen Umschalt-Programmbefehl auf Eins, so ist der Ausgang der logischen ODER-Verknüpfung 16-2, welche gleichzeitig den Ausgang der Trigger-Schaltung 15 ausbildet, auf Eins gesetzt. Der Ausgang der Trigger-Schaltung 15 bildet das Umschalt-Trigger-Signal UTS aus. Wie in 7 dargestellt, wird das Umschalt-Trigger-Signal UTS von der Thread-Kontrolleinheit 3 (nicht gezeigt) empfangen.
Die Verzögerungsschaltung 13 weist im Wesentlichen N Verzögerungsstrecken 14 für N Threads auf.
Eine logische ODER-Verknüpfung 16-3 verknüpft eingangsseitig den TSTF-Wert 19 mit einem n-Teilsignal eines internen Ereignissteuersignals für einen Umschalt-Programmbefehl IntESS-A-n zur Angabe der Anzahl n verzögerter Taktzyklen 30. Der Ausgang der logischen ODER-Verknüpfung 16-3 steuert einen 1×N-Demultiplexer 18-1 an. Der 1×N-Demultiplexer 18-1 hat die Funktion, für die entsprechende Verzögerungsstrecke 14 die richtige Anzahl n verzögerter Taktzyklen 30 bereitzustellen.
Neben den Signalen intESS-A-SW und intESS-A-n beinhaltet das Ereignissteuersignal intESS-A für einen Umschaltbefehl ein disable-Delay-Line-Teilsignal intESS-A-dDL. Das Signal intESS-A-dDL (dDL = disable Delay Line) hat die Funktion für Latenzzeiten mit nicht-deterministischer Dauer die Verzögerungsstrecke 14-j für den entsprechenden Thread T_j auszuschalten. Somit kann der Thread T_j nicht durch die entsprechende Verzögerungsstrecke 14-j reaktiviert, d.h. vom dritten Threadzustand „Wartend" 27 in den zweiten Threadzustand „Rechenbereit" 26 umgeschaltet werden. Dieses Umschalten wird für Latenzzeiten mit nicht-deterministischer Dauer und deterministischem Auftreten durch ein Ereignissteuersignal ESS gesteuert.
Die logische UND-Verknüpfung 17 verundet die Negation des Signals intESS-A-dDL und den Ausgang der logischen ODER-Verknüpfung 16-1.
Der Ausgang der logischen UND-Verknüpfung 17 steuert den 1×N Demultiplexer 18-2 an, welcher die N Verzögerungsstrecken 14 triggert.
Sowohl der 1×N Demultiplexer 18-1 als auch der 1×N Demultiplexer 18-2 werden von einem Thread-Identifikationssignal TIS, welches von der Thread-Kontrolleinheit 3 (nicht gezeigt) bereitgestellt wird, synchronisiert. Die Synchronisation ist notwendig, damit die entsprechende Verzögerungsschaltung 14-j für den entsprechenden Thread T_j zum richtigen Taktzyklus für diesen Thread T_j schaltet.
Eine Verzögerungsstrecke 14-j verzögert einen Thread T_j, nachdem für diesen Thread T_j die Verzögerungsstrecke 14-j entweder durch den TSTF-Wert 19 eines Thread-Umschalt-Trigger-Datenfeldes 11 oder durch ein internes Ereignissteuersignal intESS-A für einen Umschalt-Programmbefehl angesteuert wurde. Der Thread T_j wird für die entsprechende Anzahl n verzögerter Taktzyklen 30 verzögert und der Umschalt-Detektor 4 stellt nach Ablauf der Anzahl n verzögerter Taktzyklen 30 ein Thread-Reaktivierungssignal TRS-j bereit. Das Thread-Reaktivierungssignal TRS-j wird von der Thread-Kontrolleinheit 3 (nicht gezeigt) empfangen und weiterverarbeitet.
Obwohl die vorliegende Erfindung vorstehend anhand bevorzugter Ausführungsbeispiele beschrieben wurde, ist sie darauf nicht beschränkt, sondern auf vielfältige Art und Weise modifizierbar.

MT: Multithread-Prozessor
SPE: Standardprozessoreinheit
K: Kontextspeicher
K-A; K-A-1,..., K-A-N: Programmzählregister
K-B; K-B-1,..., K-B-N: Registerbank
K-C; K-C-1,..., K-C-N: Statusregister
T: Thread
TK: Thread-Kontrolleinheit
BHE: Befehlsholeinheit
BR: Befehlsregister
BD/OHE: Befehlsdecoder/Operandenholeinheit
BAE: Befehlsausführungseinheit
ZSE: Zurückschreibeeinheit
PBS: Programmbefehlsspeicher
MUX: N×1 Multiplexer
DEMUX: 1×N Demultiplexer
UTS: Umschalt-Trigger-Signal
DB: Datenbus
TIS: Thread-Identifikationssignal
ESS: Ereignissteuersignale
intESS-A: internes Ereignissteuersignal für
: Umschalt-Programmbefehl
TZ-A: Threadzustand "In Ausführung"
TZ-B: Threadzustand "Rechenbereit
TZ-C: Threadzustand "Wartend"
TZ-D: Threadzustand "Schlafend"
I_jk: k-te Instruktion des j-ten Threads
1: Standardprozessorrumpfeinheit
2: Kontextspeicher
2-A; 2-A-1,..., 2-A-N: Programmzählregister
2-B; 2-B-1,..., 2-B-N: Registerbank
2-C; 2-C-1,..., 2-C-N: Statusregister
3: Thread-Kontrolleinheit
4: Umschalt-Detektor
5: Befehlsholeinheit
6: Befehlsregister
7: Befehlsdecoder
8: Befehlsausführungseinheit
9: Zurückschreibeeinheit
10: Programmbefehlsspeicher
11: Thread-Umschalt-Trigger-Datenfeld
: (TSTF)
12: N×1 Multiplexer
13: Verzögerungsschaltung
14; 14-1,..., 14-N: Verzögerungsstrecke
15: Trigger-Schaltung
16; 16-1,..., 16-3: logische ODER-Verknüpfung
17: logische UND-Verknüpfung
18; 18-A, 18-B: 1×N Demultiplexer
19: TSTF-Wert
20: herkömmliches Programmbefehlsformat
21: Datenbus
22: N×3-Multiplexer
UTS: Umschalt-Trigger-Signal

TRS; TRS-1,..., TRS-N: Thread-Reaktivierungssignal
TIS: Thread-Identifikationssignal
25: Threadzustand „In Ausführung"
26: Threadzustand „Rechenbereit"
27: Threadzustand „Wartend"
28: Threadzustand „Schlafend"
intESS-A: internes Ereignissteuersignal für
: Umschalt-Programmbefehl
intESS-A-SW: Switch-Teilsignal eines internen Er
: eignissteuersignal für einen Um
: schalt-Programmbefehl
intESS-A-n: n-Teilsignal eines internen Ereig
: nissteuersignal für einen Umschalt-
: Programmbefehl
intESS-A-dDL: Verzögerungsstreckensteuer-
: Teilsignal eines internen Ereignis
: steuersignal für einen Umschalt-
: Programmbefehl
CLK: Taktsignal
30: Anzahl n verzögerter Taktzyklen
31: m Taktzyklen
32: ein Taktzyklus

Claims

Getakteter Multithread-Prozessor zur Datenverarbeitung von Programmbefehlen, wobei die Programmbefehle jeweils ein Programmbefehlsformat mit einem Thread-Umschalt-Trigger-Datenfeld (11) aufweisen, wobei das Thread-Umschalt-Trigger-Datenfeld (11) mehrere Steuerbits aufweist, welche einen TSTF-Wert (19) ausbilden, wobei ein Umschalt-Trigger-Signal (UTS) zur Umschaltung von Threads durch einen TSTF-Wert (19) größer Null generiert wird.
Multithread-Prozessor nach Anspruch 1, dadurch gekennzeichnet, dass ein Thread T sich in einem ersten Threadzustand „In Ausführung" (25), in einem zweiten Threadzustand „Rechenbereit" (26), in einem dritten Threadzustand „Wartend" (27) oder in einem vierten Threadzustand „Schlafend" (28) befindet.
Multithread-Prozessor nach Anspruch 1 und 2, dadurch gekennzeichnet, dass der Multithread-Prozessor aufweist: eine Befehlsholeinheit (5) zum Holen von Programmbefehlen I_jk von mindestens einem Thread T_j aus dem Programmbefehlsspeicher (10), wobei jeder Programmbefehl ein Thread-Umschalt-Trigger-Datenfeld (11) aufweist, welches angibt, ob ein Thread T_j von dem ersten Threadzustand „In Ausführung" (25) in den dritten Threadzustand „Wartend" (27) umgeschaltet wird und beim Umschalten des Thread T_j von dem ersten Threadzustand „In Ausführung" (25) in den dritten Threadzustand „Wartend" (27) angibt, für welche Anzahl n verzögerter Taktzyklen (30) der Thread T_j in dem dritten Threadzustand „Wartend" (27) gehalten wird.
Multithread-Prozessor nach Anspruch 1, dadurch gekennzeichnet, dass der Multithread-Prozessor aufweist: ein erweitertes Befehlsregister (6) zum Zwischenspeichern von mindestens einem geholten Programmbefehl I_jk.
Multithread-Prozessor nach Anspruch 4, dadurch gekennzeichnet, dass die Standardprozessorrumpfeinheit (1) zur sequentiellen Befehlsausführung des zwischengespeicherten Programmbefehls vorgesehen ist, wobei die Standardprozessorrumpfeinheit (1) durch ein Taktsignal (CLK) mit vorbestimmter Taktzykluszeit getaktet ist.
Multithread-Prozessor nach Anspruch 1, dadurch gekennzeichnet, dass mehrere (N) Kontextspeicher (2) vorgesehen sind, welche jeweils einen aktuellen Kontext eines Threads zwischenspeichern.
Multithread-Prozessor nach Anspruch 1, dadurch gekennzeichnet dass innerhalb eines Umschalt-Programmbefehls eines Threads T_j Daten vorgesehen sind, welche angeben, für welche Anzahl n verzögerter Taktzyklen (30) der Thread T_j in dem Thread-Zustand „wartend" (27) gehalten wird.
Multithread-Prozessor nach Anspruch 3 und 7, dadurch gekennzeichnet, dass der Multithread-Prozessor einen Umschalt-Detektor (4) aufweist, welcher in Abhängigkeit von dem Thread-Umschalt-Trigger-Datenfeld (11) oder eines Umschalt-Programmbefehls ein Umschalt-Trigger-Signal (UTS) generiert und den Thread T_j für eine Anzahl n verzögerter Taktzyklen (30) mittels einer Verzögerungsstrecke (14) verzögert, wobei die Anzahl n verzögerter Taktzyklen (30) dem Wert des Thread-Umschalt-Trigger-Datenfeldes (11) entspricht oder innerhalb des Umschalt-Programmbefehls vorgesehen ist, und wobei der Umschalt-Detektor (4) nach Ablauf der Anzahl n verzögerter Taktzyklen (30) ein Thread-Reaktivierungssignal (TRS) für den Thread T_j generiert.
Multithread-Prozessor nach Anspruch 8, dadurch gekennzeichnet, dass der Multithread-Prozessor eine Thread-Kontrolleinheit (3) aufweist, welche die Reihenfolge der durch die Standardprozessorrumpfeinheit (1) abzuarbeitenden Programmbefehle der verschiedenenen Threads in Abhängigkeit des Umschalt-Trigger-Signals (UTS) und der Thread-Reaktivierungssignale (TRS) derart steuert, dass ein Umschalten zwischen Threads ohne Taktzyklusverlust erfolgt, indem das Umschalt-Trigger-Signal (UTS) für den Thread T_j den Thread T_j von dem ersten Threadzustand „In Ausführung" (25) in den dritten Threadzustand „Wartend" (27) und einen Thread T₁ von dem zweiten Threadzustand „Rechenbereit" (26) in den ersten Threadzustand „In Ausführung" (27) umschaltet und indem das Thread-Reaktivierungssignal (TRS) für den Thread T_j den Thread T_j von dem dritten Threadzustand „Wartend" (27) in den zweiten Threadzustand „Rechenbereit" (26) umschaltet.
Multithread-Prozessor nach Anspruch 9, dadurch gekennzeichnet, dass die Thread-Kontrolleinheit (3) einen N×1 Multiplexer (12) derart steuert, dass Programmbefehle eines Threads, welcher sich in dem ersten Threadzustand „In Ausführung" (25) befindet, von dem Programmbefehlsspeicher (10) ausgelesen und von der Standardprozessorrumpfeinheit (1) abgearbeitet werden.
Multithread-Prozessor nach Anspruch 9, dadurch gekennzeichnet, dass die Thread-Kontrolleinheit (3) einen N×1 Multiplexer (12) derart steuert, dass Programmbefehle eines Threads T_j, welcher sich in dem zweiten Threadzustand „Rechenbereit" (26) befindet, dann von dem Programmbefehlsspeicher (10) ausgelesen und von der Standardprozessorrumpfeinheit (1) abgearbei tet werden, wenn sich kein anderer Thread T₁ in dem ersten Threadzustand „In Ausführung" (25) befindet.
Multithread-Prozessor nach Anspruch 9, dadurch gekennzeichnet, dass die Thread-Kontrolleinheit (3) den N×1 Multiplexer (12) derart steuert, dass Programmbefehle eines Threads T_j, welcher sich in dem dritten Threadzustand „Wartend" (26) befindet, erst dann vom Programmbefehlsspeicher (10) ausgelesen und von der Standardprozessorrumpfeinheit (1) abgearbeitet werden, wenn die Thread-Kontrolleinheit (3) das Thread-Reaktivierungssignal (TRS) für den Thread T_j empfängt und denselben Thread T_j in den zweiten Threadzustand „Rechenbereit" (26) umschaltet und wenn sich kein anderer Thread T₁ in dem ersten Threadzustand „In Ausführung" (25) befindet.
Multithread-Prozessor nach Anspruch 9, dadurch gekennzeichnet, dass die Thread-Kontrolleinheit (3) den N×1 Multiplexer (12) derart steuert, dass keine Programmbefehle eines Threads T_j, welcher sich in dem vierten Threadzustand „Schlafend" (28) befindet, von dem Programmbefehlsspeicher (10) ausgelesen und von der Standardprozessorrumpfeinheit (1) abgearbeitet werden.
Multithread-Prozessor nach Anspruch 8, dadurch gekennzeichnet, dass der Umschalt-Detektor (4) die Verzögerungsschaltung (13) für N Threads und eine Trigger-Schaltung (15) für das Umschalt-Trigger-Signal (UTS) aufweist.
Multithread-Prozessor nach Anspruch 8 und 14, dadurch gekennzeichnet, dass eine Verzögerungsschaltung (13) für N Threads eine Verzögerungsstrecke (14) für jeden der N Threads aufweist, wobei eine Verzögerungsstrecke (14) den entsprechenden Thread für die Anzahl n verzögerter Taktzyklen (30), wobei die Anzahl n verzögerter Taktzyklen (30) dem Wert des Thread-Umschalt-Trigger-Datenfeldes (11) entspricht oder von einem Umschalt-Programmbefehl gegeben ist, in dem dritten Threadzustand "Wartend" (27) hält.
Multithread-Prozessor nach Anspruch 3, dadurch gekennzeichnet, dass das Thread-Umschalt-Trigger-Datenfeld (11) eines bestimmten Programmbefehls in einem mehrere m Taktzyklen (31) vorstehenden Programmbefehl vorliegt.
Multithread-Prozessor nach Anspruch 3, dadurch gekennzeichnet, dass das Thread-Umschalt-Trigger-Datenfeld (11) ein herkömmliches Programmbefehlsformat um mehrere Steuerbits, welche einen TSTF-Wert (19) ausbilden, erweitert.
Multithread-Prozessor nach Anspruch 8 und 17, dadurch gekennzeichnet, dass das Umschalt-Trigger-Signal (UTS) durch einen TSTF-Wert (19) größer Null generiert wird, so dass das Umschalt-Trigger-Signal (UTS) für den Thread T_j denselben Thread T_j von dem ersten Threadzustand "In Ausführung" (25) in den dritten Threadzustand "Wartend" (27) umschaltet.
Multithread-Prozessor nach Anspruch 8 und 15, dadurch gekennzeichnet, dass der TSTF-Wert (19) des Thread-Umschalt-Trigger-Datenfeldes (11) des Programmbefehls I_jk des Threads T_j angibt, für welche Anzahl n verzögerter Taktzyklen (30) der Thread T_j in den dritten Threadzustand "Wartend" gesetzt werden wird, wobei der TSTF-Wert (19) die Länge der Verzögerungsstrecke (14) angibt.
Multithread-Prozessor nach Anspruch 8, dadurch gekennzeichnet, dass das Thread-Reaktivierungssignal (TRS) für den Thread T_j nach Ablauf der Anzahl n verzögerter Taktzyklen (30) der Verzögerungsstrecke (14) den Thread T_j aus dem dritten Threadzustand "Wartend" (27) in den zweiten Threadzustand "Rechenbereit" eine Umschaltung triggert.
Multithread-Prozessor nach Anspruch 1, dadurch gekennzeichnet, dass die Standardprozessorrumpfeinheit (1) einen Befehlsdecoder (7) zur Decodierung eines Programmbefehls, eine Befehlsausführungseinheit (8) zum Ausführen des decodierten Programmbefehls und eine Zurückschreibeeinheit (9) zum Zurückschreiben von Operationsergebnissen aufweist.
Multithread-Prozessor nach Anspruch 6, dadurch gekennzeichnet, dass jeder Kontextspeicher (2) ein Programmzählregister (2-A) zum Zwischenspeichern eines Programmzählers, eine Registerbank (2-B) zum Zwischenspeichern von Operanden und ein Statusregister (2-C) zum Zwischenspeichern von Status-Teilsignalen aufweist.
Multithread-Prozessor nach Anspruch 6, dadurch gekennzeichnet, dass die Anzahl N an Kontextspeichern (2) vorbestimmt ist.
Multithread-Prozessor nach Anspruch 22, dadurch gekennzeichnet, dass die Speicherinhalte des Programmzählregisters (2-A), der Registerbank (2-B) und des Statusregisters (2-C) den Kontext des entsprechenden Threads angeben.
Multithread-Prozessor nach Anspruch 3 und 22, dadurch gekennzeichnet, dass die Befehlsholeinheit (5) zum Auslesen von Programmbefehlen mit dem Programmbefehlsspeicher (10) verbunden ist, wobei die aus dem Programmbefehlsspeicher (10) ausgelesenen Programmbefehle durch die Programmzählregister (2-A) der Kontextspeicher (2) adressiert sind.
Multithread-Prozessor nach Anspruch 1, dadurch gekennzeichnet, dass die Standardprozessorrumpfeinheit (1) die verarbeiteten Daten über einen Datenbus (21) an einen Datenspeicher abgeben.
Multithread-Prozessor nach Anspruch 9, dadurch gekennzeichnet, dass die Standardprozessorrumpfeinheit (1) die ihr von der Thread-Kontrolleinheit (3) zugeschalteten Programmbefehle sequentiell in einem Pipeline-Verfahren abarbeitet.
Multithread-Prozessor nach Anspruch 1, dadurch gekennzeichnet, dass die Standardprozessorrumpfeinheit (1) einen abzuarbeitenden Programmbefehl innerhalb einer vorbestimmten Anzahl von Taktzyklen abarbeitet.
Multithread-Prozessor nach Anspruch 8 und 9, dadurch gekennzeichnet, dass die Thread-Kontrolleinheit (3) und der Umschalt-Detektor (4) Ereignissteuersignale empfangen.
Multithread-Prozessor nach Anspruch 29, dadurch gekennzeichnet, dass die Ereignissteuersignale (ESS) interne Ereignissteuersignale und externe Ereignissteuersignale umfassen.
Multithread-Prozessor nach Anspruch 30, dadurch gekennzeichnet, dass die internen Ereignissteuersignale von der Standardprozessorrumpfeinheit (1) erzeugt werden.
Multithread-Prozessor nach Anspruch 31, dadurch gekennzeichnet, dass ein internes Ereignissteuersignal (intESS-A) für einen Umschalt-Programmbefehl von der Standardprozessorrumpfeinheit (1) bereitgestellt ist.
Multithread-Prozessor nach Anspruch 32, dadurch gekennzeichnet, dass ein internes Ereignissteuersignal (intESS-A) für einen Umschaltbefehl ein Switch-Teilsignal (intESS-A-SW), ein n-Teilsignal (intESS-A-n) und ein Verzögerungsstreckensteuer-Teilsignal (intESS-A-dDL) aufweist.
Multithread-Prozessor nach Anspruch 2, 8 und 33, dadurch gekennzeichnet, dass durch das Switch-Teilsignal (intESS-A-SW) für einen Umschalt-Programmbefehl das Umschalt-Trigger-Signal (UTS) generiert wird, so dass das Umschalt-Trigger-Signal (UTS) eines Threads T_j denselben von dem ersten Threadzustand "In Ausführung" (25) oder von dem zweiten Threadzustand "Rechenbereit" (26) in den dritten Threadzustand "Wartend" (27) umschaltet.
Multithread-Prozessor nach Anspruch 2, 8 und 33, dadurch gekennzeichnet, dass durch das n-Teilsignal (intESS-A-n) für einen Umschalt-Programmbefehl die Verzögerungsstrecke (14) für den Thread T_j bereitgestellt wird, wobei nach Ablauf der Anzahl n verzögerter Taktzyklen (30) der Verzögerungsstrecke (14) das Thread-Reaktivierungssignal (TRS) für den Thread T_j denselben Thread T_j aus dem dritten Threadzustand "Wartend" (27) in den zweiten Threadzustand "Rechenbereit" (26) umschaltet.
Multithread-Prozessor nach Anspruch 14, 15 und 33, dadurch gekennzeichnet, dass ein ODER-Gatter (16-2) eine logische Verknüpfung des Switch-Teilsignal (intESS-A-SW) für einen Umschalt-Programmbefehl mit dem TSTF-Wert (19) des Thread-Umschalt-Trigger-Datenfeldes (11) die Trigger-Schaltung (15) für ein Umschalt-Trigger-Signal (UTS) ausbildet.
Multithread-Prozessor nach Anspruch 14, 15 und 33, dadurch gekennzeichnet, dass ein ODER-Gatter (16-3) eine logische Verknüpfung des Ausgangs des ODER-Gatters (16-1) und des n-Teilsignals (intESS-A-n) für einen Umschalt-Programmbefehl ausbildet.
Multithread-Prozessor nach Anspruch 14, 15 und 33, dadurch gekennzeichnet, dass ein UND-Gatter (17) eine logische Verknüpfung des Ausgangs des ODER-Gatters (16-2) und der Negation des Verzögerungsstreckensteuer-Teilsignals (intESS-A-dDL) für einen Umschalt-Programmbefehl ausbildet.
Multithread-Prozessor nach Anspruch 37 und 38, dadurch gekennzeichnet, dass ein Demultiplexer (18-1), der eingangsseitig den Ausgang des ODER-Gatters (16-3) empfängt, und ein Demultiplexer (18-2), der eingangsseitig den Ausgang des UND-Gatters (17) empfängt, die Verzögerungsschaltung (13) ansteuern.
Multithread-Prozessor nach Anspruch 21, dadurch gekennzeichnet, dass ein Thread-Identifikationssignal (TIS), das den abzuarbeitenden Programmbefehl adressiert, von der Thread-Kontrolleinheit (3) bereitgestellt ist.
Multithread-Prozessor nach Anspruch 39 und 40, dadurch gekennzeichnet, dass das Thread-Identifikationssignal (TIS) den Demultiplexer (18-1) und den Demultiplexer (18-2) synchronisiert.
Multithread-Prozessor nach Anspruch 30, dadurch gekennzeichnet, dass die Ereignissteuersignale (ESS) von externen Baugruppen erzeugt werden.
Multithread-Prozessor nach Anspruch 1, dadurch gekennzeichnet, dass die Standardprozessorrumpfeinheit (1) ein Teil eines DSP-Prozessores, eines Protokollprozessors oder eines Universal-Prozessors (General-Purpose-Processor) ist.
Multithread-Prozessor nach Anspruch 21, dadurch gekennzeichnet, dass die Befehlsausführungseinheit (8) einer Standardprozessorrumpfeinheit (1) eine Arithmetisch-Logische-Einheit (ALU) und/oder eine Adressengeneratoreinheit (AGU) enthält.
Multithread-Prozessor nach Anspruch 6 und 29, dadurch gekennzeichnet, dass die Thread-Kontrolleinheit (3) in Abhängigkeit von den Ereignissteuersignalen (ESS) Schaltnetzwerke ansteuert.
Verfahren zum Umschalten von Threads T eines getakteten Multithread-Prozessors nach Patentanspruch 1, welcher eine Standardprozessorrumpfeinheit (1) enthält, bei dem Threads ohne Taktzyklusverlust durch ein Thread-Umschalt-Trigger-Datenfeld (11) getriggert von dem aktuell durch die Standardprozessorrumpfeinheit (1) abzuarbeitenden Thread T_j auf einen anderen Thread T₁ umschaltbar sind, wobei ein jeder Programmbefehl I_jk eines Thread T_j ein solches Thread-Umschalt-Trigger-Datenfeld (11) aufweist.
Verfahren nach Anspruch 46, bei dem Programmbefehle I_jk von mindestens einem Thread T_j aus dem Programmbefehlsspeicher (10) mittels einer Befehlsholeinheit (5) geholt werden, wobei jeder Programmbefehl ein Thread-Umschalt-Trigger-Datenfeld (11) aufweist, welches angibt, ob ein Thread T_j von dem ersten Threadzustand „In Ausführung" (25) in den dritten Threadzustand „Wartend" (27) umgeschaltet wird und beim Umschalten des Thread T_j von dem ersten Threadzustand „In Ausführung" (25) in den dritten Threadzustand „Wartend" (27) angibt, für welche Anzahl n verzögerter Taktzyklen (30) der Thread T_j in dem dritten Threadzustand „Wartend" (27) gehalten wird.
Verfahren nach Anspruch 46, bei dem mindestens ein geholter Programmbefehl I_jk in einem erweiterten Befehlsregister (6) zwischengespeichert wird.
Verfahren nach Anspruch 48, bei dem die zwischengespeicherten Programmbefehle mittels der Standardprozessorrumpfeinheit (1) sequentiell ausgeführt werden, wobei die Standardprozessorrumpfeinheit (1) durch ein Taktsignal (29) mit vorbestimmter Taktzykluszeit getaktet wird.
Verfahren nach Anspruch 46, bei dem mehrere (N) Kontextspeicher (2) jeweils einen aktuellen Kontext eines Threads zwischenspeichern.
Verfahren nach Anspruch 47, bei dem ein Umschalt-Trigger-Signal (UTS) in Abhängigkeit von dem Thread-Umschalt-Trigger-Datenfeld (11) mittels eines Umschalt-Detektors (4) generiert wird und der Thread T_j für die Anzahl n verzögerter Taktzyklen (30) mittels einer Verzögerungsstrecke (14) verzögert wird, wobei die Anzahl n verzögerter Taktzyklen (30) dem Wert des Thread-Umschalt-Trigger-Datenfeldes (11) entspricht, und wobei ein Thread-Reaktivierungssignal (TRS) für den Thread T_j nach Ablauf der Anzahl n verzögerter Taktzyklen (30) mittels des Umschalt-Detektors (4) generiert wird.
Verfahren nach Anspruch 51, bei dem die Reihenfolge der durch die Standardprozessorrumpfeinheit (1) abzuarbeitenden Programmbefehle der verschiedenenen Threads in Abhängigkeit des Umschalt-Trigger-Signals (UTS) und der Thread-Reaktivierungssignale (TRS) mittels einer Thread-Kontrolleinheit (3) derart gesteuert wird, dass ein Umschalten zwischen Threads ohne Taktzyklusverlust erfolgt, indem das Umschalt-Trigger-Signals (UTS) für den Thread T_j den Thread T_j von dem ersten Threadzustand „In Ausführung" (25) in den dritten Threadzustand „Wartend" (27) und einen Thread T₁ von einem zweiten Threadzustand „Rechenbereit" (26) in den ersten Threadzustand „In Ausführung" (27) umschaltet und indem das Thread-Reaktivierungssignal (TRS) für den Thread T_j den Thread T_j von dem dritten Threadzustand „Wartend" (27) in den zweiten Threadzustand „Rechenbereit" (26) umschaltet.