DE10110504B4

DE10110504B4 - Verfahren und Computersystem zur Verwaltung von Threads

Info

Publication number: DE10110504B4
Application number: DE10110504A
Authority: DE
Inventors: Gordon Taylor Davis; Marco C. Heddes; Ross Boyd Leavens; Frabrice Jean Verplanken
Original assignee: International Business Machines Corp
Current assignee: Intel Corp
Priority date: 2000-04-04
Filing date: 2001-03-03
Publication date: 2006-11-23
Anticipated expiration: 2021-03-04
Also published as: KR20010094951A; CA2334393A1; KR100368350B1; US8006244B2; US6931641B1; DE10110504A1; JP2001350638A; US20050022196A1

Abstract

Verfahren zur Verwaltung von Threads in einem Prozessor, bei dem ein zweiter Thread aus einer Warteschlange mit mehr als zwei Threads zur Ausführung abgerufen wird, wenn ein Ereignis eintritt, das einen ersten Thread blockiert und die Verwaltung der Threads die Latenzzeit des Ereignisses berücksichtigt, mit folgenden Schritten:
a) eine Steuerungslogik in einer Threadausführungssteuerung, die eine Komponente eines Prozessors ist, überwacht konstant den aktuellen, ersten Ausführungsthread und stellt fest, ob die Latenzzeit des den ersten Thread blockierenden Ereignisses kleiner als eine von einem Programmierer in einem Schwellwertregister einstellbare Anzahl von Machinenzyklen ist und damit eine kurze Latenzzeit vorliegt;
b) bei einem Ereignis mit einer kurzen Latenzzeit bewirkt die Threadausführungssteuerung, dass die Steuerung der Ausführung vorübergehend an den zweiten Thread übergeben wird und an den ersten Thread zurückgegeben wird, wenn das Ereignis mit kurzer Latenzzeit beendet ist.

Description

Gebiet der Erfindung
Gegenstand der vorliegenden Erfindung ist ein Verfahren zur Verwaltung von Threads in einem Computersystem und ein entsprechendes Computersystem zur Durchführung des Verfahrens.
Hintergrund der Erfindung
Netzwerkprozessoren sollen Schalt- und Routingfunktionen effizient implementieren. Die kritische Größe zur Messung der Performanz bei Netzwerkprozessoren ist die Anzahl der Maschinenzyklen, die für die Verarbeitung eines typischen Pakets oder Datenrahmens benötigt werden. Diese Verarbeitung ist im typischen Fall in zwei Hauptabschnitte unterteilt: die von der CPU (Central Processing Unit) des Netzwerkprozessors ausgeführten Befehle und der Zugriff auf Routing- und Steuerungstabellen, die im typischen Fall in einem Speicher gespeichert sind, den sich die CPUs mehrerer Netzwerkprozessoren teilen. Die Ausführung der Befehle durch die CPU wird beim Zugriff auf die Routingtabellen typischerweise unterbrochen, wodurch sich die Zahl der zur Verarbeitung eines Pakets erforderlichen Maschinenzyklen beträchtlich erhöht. Die Zeit für den Zugriff auf eine dieser Baumstrukturen kann tatsächlich zwei- bis dreimal länger sein, als die von der CPU für die Vorbereitung des Zugriffs und die Verarbeitung der resultierenden Daten benötigte Zeit. Die Daten für diese Routing- und Steuerungstabellen sind typischerweise in einer Baumstruktur formatiert, die einen spezialisierten Coprozessor oder eine Baumsuchmaschine (Tree Search Engine, TSE) erfordert, damit in effizienter Weise auf den gewünschten Tabelleneintrag zugegriffen werden kann. Andere Coprozessoren, die für die Arbeit mit Daten im lokalen Datenspeicher eingerichtet sind, können die CPU ebenfalls blockieren, jedoch für eine kürzere Zeit.

Der Stand der Technik weist eine Reihe von bereits patentierten Implementierungssystemen mit mehreren Threads auf:
US Patentschrift Nr. 5,357,617 (Davis et al.) – Diese Patentschrift behandelt das Umschalten von einem Ausführungsthread auf einen anderen mit einem Overhead von Null. Die CPU schaltet hierbei kontinuierlich zwischen mehreren Befehlsthreads bei einer im Zeitmultiplex durchgeführten Zuweisung der CPU-Ressourcen um. Mit anderen Worten, mehrere Befehlsthreads werden über einen statischen Verschachtelungsmechanismus gesteuert.

US Patentschrift Nr. 5,404,469 – Mit dieser Patentschrift wird das Konzept der Zeitmultiplexzuweisung von CPU-Ressourcen auf einen Prozessor mit VLIW-Architektur (VLIW = very long instruction word) erweitert.

US Patentschrift Nr. 5,694,604 – Diese Patentschrift beschreibt eine typische Software-Multiprocessing-Methode, bei der ein ausgewählter Befehlsthread einer betimmten Ausführungszeit zugeordnet wird, nach deren Ablauf sein Kontext gesichert und ein vorheriger Kontext für den nächsten Befehlsthread zurückgespeichert wird. Bei diesem System wird jeder Thread typischerweise länger ausgeführt, da wesentliche Kosten (in Form von Maschinenzyklen) zum Sichern und Zurückspeichern von Maschinenkontext anfallen, wenn von einem Thread auf einen anderen umgeschaltet wird.

US Patentschrift Nr. 5,812,811 – Diese Patentschrift betrifft das parallele Ablaufen mehrerer Befehlsthreads, die Teil desselben Programms sind, um die Beendigung des Programms zu beschleunigen. Sie behandelt außerdem die spekulative Ausführung von Pfaden, die für den Abschluss der Programmausführung erforderlich sein können oder nicht.

US Patentschrift Nr. 5,933,627 – Diese Patentschrift beschreibt das Umschalten auf einen alternativen Thread, wenn die CPU angehalten wird, weil benötigte Daten nicht im lokalen Cache gefunden werden. Bei diesem System muss die CPU ausdrücklich bestimmen, welcher Thread die CPU steuern darf. Diese Patentschrift beschreibt auch mehrere Threads als Teile desselben Programms und nicht als voneinander unabhängige Prozesse.

US Patentschrift Nr. 5,694,603 – Diese Patentschrift ist eine andere Beschreibung einer typischen Software-Multiprocessing-Methode, die das preemptive Umschalten von einem Thread auf einen anderen umfasst.

Aus der US 5,933,627 ist ein Verfahren und eine Vorrichtung zum übertragen der Kontrolle der Ausführung zwischen mehreren Threads eines Computerprogramms als Antwort auf ein Ereignis, das die Ausführung des Threads für eine längere Zeit blockiert, bekannt. Ein solches Ereignis kann in Lade- und Speicheroperationen liegen, die dann eine Übertragung der Kontrolle von einem Thread auf einen anderen auslösen. In der Vorrichtung werden separate Gruppen von Registern den mehreren Threads zur Verfügung gestellt, darüber hinaus ist eine Gruppe von Programmadressregistern zur Verfügung gestellt, die auf die verschiedenen Threads verweisen. Ein Übertragungsmechanismus schaltet zwischen den Programmadressregistern als Antwort auf ein Ereignis, das die Ausführung des Threads für eine längere Zeit blockiert, um.

In Andreas Voss: Das große Computer Lexikon 98, 1. Auflage, 1998 Data Becker GmbH & Co. KG, ISBN 3-8158-1599-1, Seiten 126, 127, 394, 459 und 639 werden zwei grundlegende Methoden der Betriebsmittelvergabe unterschieden. Es ist zum einen möglich, dass die Prozesse sich kooperativ die vorhandenen Betriebsmittel teilen. Zum anderen kann aber auch das Betriebssystem die Vergabe der Betriebsmittel zentral steuern und überwachen.

Zusammenfassung der Erfindung

Aufgabe der vorliegenden Erfindung ist es, ein verbessertes Verfahren zur Verwaltung von Threads in einem Prozessor, z.B. einem Netzwerkprozessor, und eine entsprechende Vorrichtung zur Durchführung des Verfahrens bereitzustellen, welche das Umschalten von einem Thread auf einen anderen innerhalb des Prozessors steuern, um eine effizientere Ausnutzung der Prozessorresourcen zu erreichen.

Diese Aufgabe wird durch ein Verfahren und Computersystem gemäß den nebengeordneten Ansprüchen gelöst.

Eine vorteilhafte Weiterbildung der vorliegenden Erfindung umfasst, einem alternativen Ausführungsthread temporär die Steuerung zu überlassen, wenn ein Ereignis mit kurzer Latenzzeit angetroffen wird, und einem alternativen Ausführungsthread die volle Steuerung zu überlassen, wenn ein Ereignis mit langer Latenzzeit angetroffen wird.

Eine weitere vorteilhafte Weiterbildung der Erfindung umfasst einen Prioritäts-FIFO, der so konfiguriert ist, dass seine Ausgänge die Ausführungspriorität für zwei oder mehr Ausführungsthreads innerhalb eines Prozessors steuern, basierend auf der Zeitdauer, die jeder Ausführungsthread im FIFO resident war. Der FIFO wird jedesmal dann mit einer Ausführungsthreadnummer geladen, wenn eine neue Task (beispielsweise, wenn ein Netzpaket innerhalb eines Netzwerks klassifiziert und geroutet werden muss) zur Verarbeitung abgeschickt wird, wobei die in den FIFO geladene Ausführungsthreadnummer der Threadnummer entspricht, die für die Verarbeitung der Task zugewiesen wurde. Wenn ein bestimmter Ausführungsthread die Verarbeitung einer bestimmten Task abgeschlossen hat und die Ergebnisse für die nachfolgende Abwicklung in eine Warteschlange einreiht, wird der Prioritäts-FIFO weiter so gesteuert, dass die betreffende Ausführungsthreadnummer aus dem FIFO entfernt wird. Wenn ein aktiver Ausführungsthread auf ein Ereignis mit langer Latenzzeit trifft, wird die betreffende Threadnummer innerhalb des FIFO von der Position mit hoher Priorität innerhalb des FIFO entfernt und an die Position mit niedrigster Priorität im FIFO plaziert.

Eine zusätzliche vorteilhafte Weiterbildung der Erfindung umfasst auch eine Threadsteuerungs-Zustandsmaschine für jeden von dem Prozessor unterstützten Ausführungsthread. Die Threadsteuerungs-Zustandsmaschine umfasst weiter vier Zustände. Ein Initialisierungs-Zustand wird verwendet, während ein Ausführungsthread auf die Verarbeitung einer Task wartet. Nachdem eine Task zur Bearbeitung in die Warteschlange eingereiht wurde, werden in einem Bereit-Zustand Ausführungszyklen angefordert. Nachdem der Zugriff auf den Prozessor freigegeben ist, wird in einem Ausführungs-Zustand die eigentliche Ausführung durch den Prozessor unterstützt. Anforderungen zusätzlicher Prozessorzyklen können sowohl vom Bereit-Zustand als auch vom Ausführungs-Zustand aus erfolgen. Die Zustandsmaschine wird in den Initialisierungs-Zustand zurückgeführt, nachdem die Verarbeitung der zugewiesenen Task abgeschlossen ist. In einem Warte-Zustand werden Anforderungen von Ausführungszyklen in der Schwebe gehalten, während der Ausführungsthread entweder aufgrund eines Ereignisses mit langer Latenzzeit oder eines Ereignisses mit kurzer Latenzzeit unterbrochen wird.

Eine andere Weiterbildung der vorliegenden Erfindung umfasst weiter eine Zuteilungsvorrichtung, die anhand von Threadnummern im Prioritäts-FIFO feststellt, welchem Ausführungsthread der Zugriff auf die Prozessorressourcen erteilt werden soll. Die Zuteilungsvorrichtung verarbeitet weiter Anforderungen der einzelnen Ausführungsthreads zur Überlassung der Ausführungssteuerung und wählt einen Ausführungsthread aus, dem dann der Zugriff auf die Prozessorressourcen für jeden Prozessorausführungszyklus erteilt wird, indem die Threadnummern von den anfordernden Ausführungsthreads mit den entsprechenden Threadnummern im Prioritäts-FIFO verglichen werden. Die logische Funktion der Zuteilungsvorrichtung wird weiter durch den folgenden Booleschen Ausdruck definiert:

Hierbei gilt:

G_n: ist eine Zuteilung von einem gegebenen Thread n;
R_n: ist eine Anforderung von einem gegebenen Thread n;
P_A, P_B und P_C: stellen Threads dar, die in alphabetischer Reihenfolge der tiefgestellten Indexzahlen entsprechend der Priorität geordnet sind;
n: ist eine tiefgestellte Indexzahl, die einen Thread durch die Bit- oder die Binärzahl kennzeichnet.

Eine zusätzliche vorteilhafte Weiterbildung der Erfindung umfasst auch die Verwendung eines Prefetch-Puffers in Verbindung mit einer Vielzahl von voneinander unabhängigen Thread-Prozessen in der Weise, dass eine unmittelbare Unterbrechung vermieden wird, wenn die Ausführung einem Thread übergeben wird, der sich im Leerlauf befindet. Hierbei muss festgestellt werden, ob der Puffer von einem aktiven Ausführungsthread genutzt wird. In Perioden, in denen der Puffer nicht von dem aktiven Ausführungsthread verwendet wird, kann der Puffer vorab Befehle für einen im Leerlauf befindlichen Ausführungsthread holen.

Kurze Beschreibung der Zeichnungen

1 zeigt eine Netzwerkprozessorarchitektur mit zwei Coprozessoren; und

2 zeigt ein Ausführungsbeispiel der vorliegenden Erfindung; und

3 ist ein Threadausführungs-Steuerungsdiagramm; und

4 zeigt Wellenformen für zwei Ausführungsthreads und eine einzelne CPU.

Ausführliche Beschreibung der Erfindung

Die vorliegende Erfindung unterscheidet sich dadurch vom Stand der Technik, dass sie insbesondere unabhängige Prozesse in jedem der Befehlsausführungsthreads betrifft (die jeweils ein anderes zu verarbeitendes Paket betreffen) und insbesondere Latenzzeiten beim Zugriff auf Daten behandelt. Jeder der Ausführungsthreads ist ein unabhängiger Prozess, der eine Befehlsfolge ausführt, wenn den Threads Zugriff auf die Prozessor-Hardware erteilt wird. In der bevorzugten Ausführungsform der Erfindung arbeitet ein Baumsuch-Coprozessor im Pipeline-Verfahren, so dass mehrere Ausführungsthreads gleichzeitig, jedoch zu verschiedenen Phasen (überlappend) in der Baumsuch-Pipeline Zugriff haben können. In einer besonders vorteilhaften Ausgestaltung werden mehrere Befehlsausführungsthreads mit Null Overhead verwendet, um die Ausführung von einem Thread zum nächsten umzuschalten. Die Threads werden in eine Warteschlange eingereiht, um eine schnelle Verteilung des Zugriffs auf den gemeinsam genutzten Speicher zu ermöglichen. Durch das Einreihen der Threads in eine Warteschlange kann der Thread mit der höchsten Priorität so schnell wie möglich zu seinem Ereignis mit langer Latenzzeit gelangen.

Die bevorzugte Ausführungsform der vorliegenden Erfindung umfasst einen Prefetch-Puffer für mehrere Befehle, einen für jeden Ausführungsthread. Diese Prefetch-Puffer ermöglichen das Vorab-Holen von Befehlen für Ausführungsthreads im Leerlauf in Intervallen, in denen die Befehlsbandbreite von aktiven Ausführungsthreads nicht voll genutzt wird. Hiermit kann sichergestellt werden, dass beim Umschalten der Steuerung auf einen neuen Ausführungsthread der Befehls-Prefetch-Puffer für diesen Thread voll ist, wodurch die Möglichkeit vermieden wird, dass der neue Thread sofort aufgrund des Mangels an verfügbaren auszuführenden Befehlen unterbrochen wird. Die Zugriffspriorität auf den Befehlsspeicher wird also so gesteuert, dass der gerade ausgeführte Thread oberste Priorität erhält, während der Ausführungsthread, der die Steuerung übernehmen soll, wenn der aktuelle Thread unterbrochen wird, zweite Priorität erhält. Entsprechend erhält der Ausführungsthread, der sich in der Ausführungswarteschlange am weitesten unten befindet, für den Zugriff zur Befehlsholung letzte Priorität.

Die bevorzugte Ausführungsform der vorliegenden Erfindung umfasst weiterhin eine Zustandsmaschine zur Steuerung von Threads, die den momentan aktiven Ausführungsthread bestimmt und dem nächsten Thread die volle Steuerung erteilt, wenn die Ausführung des aktiven Threads aufgrund eines Ereignisses mit langer Latenzzeit (also einer Baumsuche) unterbrochen wird, oder die dem nächsten Thread die temporäre Steuerung erteilt, wenn die Ausführung aufgrund eines Ereignisses mit kurzer Latenzzeit (zum Beispiel eine Aktion des Coprozessors im lokalen Datenspeicher oder eine Latenzzeit aufgrund eines Befehlsholvorgangs) unterbrochen wird. wenn die temporäre Steuerung einem anderen Thread übergeben wurde, wird die Steuerung an den ursprünglichen Thread zurückgegeben, sobald dieser nicht mehr blockiert ist. Wenn dagegen die volle Steuerung einem anderen Thread übergeben wird, behält dieser andere Thread die Steuerung so lange, bis er selbst unterbrochen wird. Hierdurch wird das verschwenden von Zyklen für Ereignisse mit kurzer Latenzzeit vermieden, und darüber hinaus wird es dem primären Ausführungsthread ermöglicht, das Ereignis mit langer Latenzzeit früher zu erreichen. Andernfalls könnten mehrere Ausführungsthreads ein Ereignis mit langer Latenzzeit ungefähr zur gleichen Zeit erreichen, wodurch die Vorteile des Überlappens bei der Ausführung eines Threads durch die CPU mit einer Baumsuche eines anderen Threads geringer würden.

1 zeigt eine typische Konfiguration eines Netzwerkprozessors mit einer zentralen Verarbeitungseinheit (CPU) 10 für einen einzelnen Thread und einer Vielzahl von universellen Registern 12, die in einem Einzelregister-Array in Form einer Zweiwege-Kommunikation mit der CPU implementiert sind. Befehle werden zwischen einem Befehlsspeicher 16 und einer einzelnen Prefetch-Warteschlange 18 übertragen, die mit der CPU gekoppelt ist. Ein erster Coprozessor 20 kommuniziert mit der CPU 10 und greift auf Daten in dem externen Speicher 22 zu. Dieser externe Speicher kann Daten mit einer Vielzahl anderer Prozessoren (nicht gezeigt) über den Coprozessor 20 gemeinsam nutzen. Der lokale Datenspeicher 26 wird ausschließlich vom Coprozessor 24 genutzt und nicht gemeinsam mit den anderen Prozessoren. Bei mehreren Threads haben alle Threads Zugriff auf den lokalen Datenspeicher.
Wenden wir uns nun 2 zu; hier wurden zur Bezeichnung identischer Komponenten dieselben Nummern verwendet, wie in 1; es wird eine CPU 110 gezeigt, die mit mehreren Ausführungsthreads konfiguriert ist. Die Befehle werden zwischen einem Befehlsspeicher 16 und den Prefetch-Warteschlangen 118 übertragen, die mit der CPU 110 gekoppelt sind. Eine Vielzahl von universellen Registern 112 wurde in einem Einzelregister-Array implementiert, das die CPU bedient. Die Anordnung hat ein Adressenbit, das von einer Threadausführungssteuerung (TEC) 30 gesteuert wird, die bestimmt, welcher Teil des Register-Arrays von einem Thread verwendet wird. Das oder die übrigen Adressenbits werden von der CPU gesteuert. In einem bevorzugten Ausführungsbeispiel wird der lokale Speicher 126 in Segmente unterteilt, so dass jeder Thread seinen eigenen logischen Bereich in dem lokalen Speicher hat. Zum Beispiel würden sich zwei Threads jeweils einen Speicherraum zur Hälfte teilen, vier Threads würden sich den lokalen Speicherraum jeweils zu einem viertel teilen. Die TEC 30 bestimmt auch, welches Segment des lokalen Datenspeichers 126 für einen bestimmten Thread verwendet werden soll. Die Daten können direkt zwischen dem lokalen Datenspeicher 126 und der CPU 110 ausgetauscht werden. Der lokale Datenspeicher ist seitens der CPU voll adressierfähig, wobei die Arbeitsbereiche von einem Indexregister innerhalb des universellen Register-Arrays gekennzeichnet sind. Ein erster Coprozessor 120 arbeitet zwischen der CPU 110 und dem gemeinsam genutzten externen Speicher 22 im Pipeline-Verfahren. Ein zweiter Coprozessor 24 greift auf den lokalen Datenspeicher 126 zu und kommuniziert mit der CPU 110.
Erneut Bezug nehmend auf 2; obwohl die CPU mehrere Threads unterstützt, unterscheidet sie sich nicht wesentlich von der einthreadigen CPU der 1. Der Hauptunterschied, der zur Unterstützung mehrerer Threads erforderlich ist, findet sich in der Funktionsweise der Threadausführungssteuerung (TEC) 30. Die Steuerungslogik innerhalb der TEC überwacht konstant den aktuellen Ausführungsthread. Wenn der aktuelle Thread blockiert ist, schaltet die Steuerungslogik auf einen anderen Ausführungsthread um. Außerdem identifiziert die Steuerungslogik, durch welchen Ereignistyp ein aktiver Ausführungsthread blockiert wird, und übergibt dann, je nach Länge des Ereignisses, entweder die temporäre oder die volle Steuerung.
3 zeigt die Threadausführungssteuerung (TEC) 30 mit dem FIFO 52, der Zuteilungsvorrichtung 46 und einer Vielzahl von Threadsteuerungen von 0 bis N. Jede Threadsteuerung umfasst eine Threadsteuerungs-Zustandsmaschine 38. Steuerungen, die sich von der Zustandsmachine 38 unterscheiden, können ohne Abweichung von den Lehren der vorliegenden Erfindung verwendet werden.
Die Threadausführungssteuerung arbeitet wie folgt. Wenn der Rechner eingeschaltet wird, befindet sich jeder Thread im Initialisierungszustand 40. Wenn an den Prozessor ein Paket 42 abgeschickt wird, geht der entsprechende Thread in den Bereit-Zustand 44 über und fordert ab diesem Zeitpunkt Zyklen für die Ausführung an.
Die Zuteilungsvorrichtung 46 ist für die Zuteilung der Ausführungszyklen an einen Thread verantwortlich. Nach Zuteilung eines Zyklus geht der Thread vom Bereit-Zustand 44 in den Ausführungs-Zustand 48 über. Im Ausführungszustand fordert der Thread weitere Zyklen an, bis die Ausführung aufgrund eines Latenzzeitereignisses, oder weil das zu verarbeitende Paket in die Warteschlange eingereiht wird, unterbrochen wird, womit angezeigt wird, dass die Code-Arbeit für dieses Paket abgeschlossen ist. Wenn keine weiteren Zyklen zugeteilt werden, wird hierdurch impliziert, dass ein anderer Thread die Steuerung übernommen hat. Das ist der einzige Grund für die Zuteilungsvorrichtung 46, der Threadsteuerungs-Zustandsmaschine 38 keinen Zyklus zuzuteilen. In beiden Zuständen (Bereit oder Ausführen) fordert der Thread jedoch ständig neue Ausführungszyklen an und pausiert aufgrund von Latenzzeitereignissen, bis das Ende der Paketverarbeitung erreicht ist und das nächste Paket 42 in die Warteschlange eingereiht wird, um an die Zuteilungsvorrichtung abgeschickt zu werden. Das System geht dann zurück in den Initialisierungszustand und wartet auf das nächste Paket 42.
Der Wartezustand 50 bearbeitet entweder ein Ereignis mit langer oder mit kurzer Latenzzeit. Unabhängig davon, welches Ereignis eintritt, unterbricht der Prozessor und der aktive Thread geht standardmäßig in den Wartezustand über. Der Thread fordert dann so lange keine Ausführungszyklen an, bis das Latenzzeitereignis beendet ist.
Mit derselben Abschickaktion, die einen Thread von der Initialisierungsstufe 40 in den Bereit-Zustand 44 überführt, wird die Threadnummer in den FIFO 52 eingetragen, so dass der Thread, an den das erste Paket abgeschickt wird, der Thread mit der höchsten Priorität P_A wird. Durch spätere Abschickaktionen werden weitere Threadnummern in den FIFO eingetragen. Die Threadnummer, die im FIFO an der Stelle mit der höchsten Priorität steht, bleibt an dieser Stelle, bis sie auf ein Ereignis mit langer Latenzzeit trifft. Der Thread wird dann an den Anfang des FIFO zurückgestellt und wird von einem Thread mit der höchsten Priorität P_A zu einem Thread mit der niedrigsten Priorität P_X. Ein Ereignis mit kurzer Latenzzeit führt nicht dazu, dass der Thread seine Priorität im FIFO verliert.
Wenn der Thread die Verarbeitung des Pakets 42 beendet hat, wird das Paket zur Übertragung an einen Ausgangsport in die Warteschlange eingereiht, die Threadsteuerungs-Zustandsmaschine geht vom Ausführungs- in den Initialisierungszustand über und die Threadnummer wird aus dem FIFO 52 entfernt.
Neue Pakete werden von einem High-Level-Controller (nicht dargestellt) abgeschickt. Dieser Controller außerhalb des Prozessors wählt für die Abwicklung eines jeden Pakets einen Thread und einen Prozessor aus. Das Ergebnis geht als Eingangsbefehl an den FIFO 52. Außerdem geht das Ergebnis als Eingang an die Zustandsmaschine 38 und weist diese Maschine an, vom Initialisierungszustand in den Bereit-Zustand überzugehen. Zusammen mit diesem Befehl von dem externen Controller muss auch die Threadnummer, an die das Paket geschickt werden soll, vom Controller an den FIFO geliefert werden. Beispiel: bei vier Threads kennzeichnet der zwei Bit große Binärcode (00; 01; 10; oder 11) den Thread, der das zu schickende Paket abwickeln soll. Wenn das System zwei Threads verwendet, werden diese von einem ein Bit großen Binärcode (0 oder 1) gekennzeichnet.
Vom FIFO gehen für jeden Thread mehrere Ausgänge zu der Zuteilungsvorrichtung 46, wenn alle Threads aktiv sind. Zwei solche Ausgänge wurden für den Thread mit der höchsten Priorität, P_A, mit 60 bezeichnet, für den Thread mit der niedrigsten Priorität, Px, mit 62. Bei zwei Threads ist P_X = P_B und es gibt zwei Ausgänge. Bei vier Threads ist P_X = P_D, woraus sich 4 Ausgänge ergeben. Am wahrscheinlichsten ist, dass das System Threads als ein Mehrfaches von zwei abwickeln würde. Es ist jedoch auch möglich, dass drei oder eine andere Zahl verwendet wird.
Wie bereits weiter oben erwähnt, kommt es bei vier Threads zu einer gewissen Steigerung der Performanz, wobei jedoch zusätzliche Hardware und die damit einhergehenden Unkosten zu berücksichtigen wären. Vier Threads würden bei unterschiedlichen Auslegungsparametern Sinn machen. Das bevorzugte Ausführungsbeispiel der vorliegenden Erfindung nutzt jedoch zwei Threads. Die Entscheidung, ob zwei oder vier Threads sinnvoll sind, hängt von einer Reihe von Faktoren ab.
Ein Faktor ist die Größe des lokalen Speichers. Je kleiner der Speicher, desto logischer ist die Verwendung von vier oder mehr Threads. Außerdem spielt die Frage, welche Latenzzeit das Ereignis in Relation zur Länge des Codeausführungspfads hat, eine Rolle.
Das Zuteilen von Ausführungszyklen an einen bestimmten Thread durch die Threadausführungssteuerung basiert auf der logischen Funktion der Zuteilungsvorrichtung, welcher der folgende Boolesche Ausdruck zugrundeliegt:
Diese Gleichung ist eine generalisierte Gleichung, die ausdrückt, in welcher Weise die Zuteilungsvorrichtung entscheidet, ob das Zuteilungssignal (G) aktiviert wird oder nicht, unter der gegebenen Voraussetzung, dass von der Zustandsmaschine 38 eine Anforderung (R) eintrifft. In der Formel ist G_n gleich G₀, G₁ etc., entsprechend der Anzahl der vorhandenen Threads. Die Priorität, die einem Thread gegeben werden soll, wird dargestellt durch (P). Die Gleichung verkürzt sich auf zwei Terme für zwei Threads und verlängert sich auf vier Terme für vier Threads.
Wenn es sich bei der Anforderung um einen Befehl für R₀ und G₀ handelt, hat die Zuteilung mehrere Elemente. Betrachten wir zunächst R₀; dieses Element muss aktiv sein, bevor das System eine Zuteilung G₀ in Erwägung zieht. Das System betrachtet dann mehrere Möglichkeiten, um zu entscheiden, dass diese Zuteilung ausgeführt wird, unter der Annahme, dass die Anforderung aktiv ist. wenn der Thread die höchste Priorität hat, muss nicht berücksichtigt werden, was einer der anderen Threads tut. Die Zuteilungsvorrichtung signalisiert der Threadnummer sofort eine Zuteilung und ermöglicht deren Ausführung. Andernfalls findet das System mit der Threadnummer P_A eine Anforderungsnummer R_PA für diesen Thread, welche die Anforderung mit der höchsten Priorität ist. Wenn die Anforderung mit höchster Priorität nicht aktiv ist, wird die Anforderung (R_PB) mit der zweithöchsten Priorität betrachtet und mit dem Thread (P_B) verglichen, an dem das System interessiert ist. Diese Threadnummer wird durch ein Bit dargestellt (für 2 Threads) oder durch zwei Bits (für 4 Threads). Die Gleichung stoppt bei zwei Termen, wenn zwei Threads vorhanden sind, oder bei vier Termen, wenn vier Threads vorhanden sind.
Wenden wir uns nun 4 zur hier werden zwei Taktdiagramme 70, 72 für zwei Baumsuch-Threads gezeigt, die allgemein die Überlappung der Baumsuche und einer CPU-Ausführung auf den beiden Thread-Wellenformen zeigen. wenn die Wellenformen unten sind, ist die CPU ausführend. Wenn die Wellenformen oben sind, wartet die CPU auf eine Baumsuche. Beim Vergleich der Wellenformen des Taktdiagramms für die beiden Threads kann man feststellen, dass diese niemals gleichzeitig unten sind. Sie teilen sich beide dieselbe CPU und es ist selbstverständlich, dass sie nicht beide gleichzeitig CPU-Zyklen ausführen können. Wegen der Pipeline-Struktur der Baumsuchmaschine können sie sich jedoch zum gleichen Zeitpunkt in verschiedenen, sich überlappenden Stadien befinden.
Es gibt grundsätzlich zwei Ereignistypen, die dazu führen könnten, dass die Ausführung eines Threads unterbrochen wird, und zwar diejenigen, die eine kurze Unterbrechung, und diejenigen, die eine längere Unterbrechung des aktuellen Programmflusses herbeiführen. Eine kurze Unterbrechung kann beispielsweise durch einen Verzweigungsbefehl verursacht werden, der erfordert, dass die Befehls-Prefetch-Warteschlange aufgrund einer Veränderung im Programmfluss neu aufgefüllt wird. Das Programm kann aber auch unterbrochen werden, während es darauf wartet, dass ein Coprozessor eine Task ausführt, die sich auf Daten im lokalen Speicher des Prozessors bezieht. Ein Beispiel hierfür wäre ein Prüfsummen-Coprozessor, der eine neue Prüfsumme auf einem modifizierten Header-Feld berechnet. Ein Ereignis gilt als kurzzeitige Unterbrechung, wenn die Latenzzeit unter 25 Prozessorzyklen liegt. Ereignisse mit langer Latenzzeit leiten im typischen Fall eine Latenzzeit von mehr als 25 und typischerweise von mehr als 50 bis 100 Prozessorzyklen ein. Diese haben einen wesentlich größeren Einfluss auf die Gesamt-Performanz.
Es gibt zahlreiche alternative Mittel, um festzustellen, ob es sich um ein Ereignis mit langer oder ein Ereignis mit kurzer Latenzzeit handelt. Die Länge der Latenzzeit kann vom Programmierer gesteuert werden, wodurch die Hardware oder deren Konfiguration bei der Entscheidung keine Rolle spielt. Andererseits könnte ein Schwellenregister auf einen Schwellenwert von 25 Zyklen gesetzt werden und die Hardware würde bestimmen, wie viele Zyklen eine Operation beanspruchen würde, und würde anhand dieser Feststellung eine automatische Entscheidung treffen.
Ein Coprozessor-Befehl ist ein Befehlstyp, den der Prozessor ausführt. Einige der Bits in dem Feld geben an, welcher Coprozessor beabsichtigt ist. Ein Bit definiert den jeweiligen Befehl als ein Ereignis mit langer oder ein Ereignis mit kurzer Latenzzeit. Dadurch ist es möglich, dass ein Programmierer zwei identische Zugriffe auf den Steuerspeicher definieren kann, wobei einer als Ereignis mit langer Latenzzeit und der andere als Ereignis mit kurzer Latenzzeit definiert ist. Die Funktionsweise der Threadausführungssteuerung wurde so konzipiert, dass sie den Einfluss dieser Ereignisse mit langer Latenzzeit minimiert. Ein Ereignis mit langer Latenzzeit bewirkt also, dass die volle Steuerung auf einen anderen Ausführungsthread umgeschaltet wird, während ein Ereignis mit kurzer Latenzzeit bewirkt, dass nur eine temporäre Umschaltung auf einen anderen Thread stattfindet.
Obwohl die Multi-Thread-CPU im wesentlichen einer Einzel- Thread-CPU entspricht, wird eine Reihe von Peripheriefunktionen für jeden Ausführungsthread dupliziert. Sowohl die universellen Register als auch der lokale Datenspeicher werden für jeden Befehlsthread dupliziert, wie in 2 dargestellt ist. Dies ermöglicht eine komplette Kontextumschaltung mit Null Overhead (im Sinne von Prozessortaktzyklen). In dem bevorzugten Ausführungsbeispiel sind die vielen Gruppen von universellen Registern tatsächlich in einem einzelnen größeren Register-Array implementiert, wobei ein Adressenbit (oder mehrere, wenn die Anzahl der Threads über 2 liegt) von der Steuerungslogik für die Threadausführung gesteuert wird und die übrigen Adressenbits von der CPU entsprechend den auszuführenden Befehlen gesteuert werden.
Alternativ könnten gleichzeitig zwei Register-Arrays von der CPU adressiert werden und die Steuerungslogik für die Threadausführung kann eine Array-Auswahl oder Multiplexschaltung steuern, um zu bestimmen, welcher Array-Ausgang an die CPU gehen soll. Jeder Ausführungsthread kann in dem lokalen Datenspeicher einen vollständig unabhängigen Arbeitsbereich erhalten, wobei ein Adressenbit (oder mehrere, wenn die Anzahl der Threads über 2 liegt) von der Steuerungslogik für die Threadausführung gesteuert wird und die übrigen Adressenbits entsprechend den auszuführenden Befehlen von der CPU gesteuert werden. Alternativ kann der lokale Datenspeicher seitens der CPU voll adressierfähig sein, wobei die einzelnen Arbeitsbereiche durch ein Indexregister innerhalb des universellen Register-Arrays gekennzeichnet sind. Dies hat den Vorteil, dass ein gewisser Speicherbereich für gemeinsame Daten, beispielsweise Tabellen, gemeinsam genutzt werden kann, dass jedoch alle Zugriffe auf den eigenen Speicherraum mit indizierten Adressen erfolgen müßten, wodurch die Flexibilität der verfügbaren Befehle eingeschränkt werden könnte.
Obwohl es einen gemeinsamen Pfad zum Befehlsspeicher gibt, ist jedem Befehls-Thread ein anderer Befehlszeiger und eine andere Prefetch-Warteschlange zugeordnet, die jeweils mehrere, für die spätere Ausführung gestaffelte Befehlsworte enthalten können. In dem bevorzugten Ausführungsbeispiel gibt es zwei Ausführungsthreads, jeder hat eine Prefetch-Warteschlange mit acht Befehlen. Der aktive Ausführungsthread hat beim Holen der Befehle erste Priorität. In dem bevorzugten Ausführungsbeispiel werden mehrere Netzwerkprozessoren auf demselben Chip implementiert und nutzen einen gemeinsamen Befehlsspeicher. Wenn also mehrere Prozessoren gleichzeitig auf den Befehlsspeicher zugreifen wollen, haben immer die Befehlsholanforderungen der aktiven Threads Vorrang gegenüber denjenigen der im Leerlauf befindlichen Threads, auch dann, wenn eine Anforderung eines im Leerlauf befindlichen Threads früher eintrifft.
Zwar wurden die Arbeitsregister und der lokale Speicher für jeden Befehls-Thread dupliziert, jedoch nutzen alle Threads eine gemeinsame CPU (einschließlich ihrer Coprozessoren) und einen gemeinsamen Pfad zum Befehlsspeicher. Die Anforderung der höchsten Bandbreite für die Befehlsholung erhöht sich nicht, jedoch die effektive Nutzung der verfügbaren Bandbreite für die Befehlsholung erhöht sich bei mehreren Ausführungsthreads beträchtlich.
Die typische Verarbeitung eines Netzwerkverarbeitungssystems erfordert einen Baumsuchzugriff, der das Zwei- bis Dreifache der Anzahl der Maschinenzyklen in Anspruch nehmen kann, die für das Einrichten der Suche und das Verarbeiten der Ergebnisse erforderlich ist. Hieraus ergeben sich zwei wesentliche Begleiterscheinungen. Erstens kann die Ausführung eines jeden von zwei Threads durch die CPU leicht mit den Baumsuchzyklen für den jeweils anderen Thread verzahnt werden. Bei nur zwei Threads gibt es in der Tat immer noch eine beträchtliche Anzahl von CPU-Zyklen, in denen beide Threads blockieren, was nahelegt, dass drei oder vier Threads die Ausnutzung der CPU weiter verbessern würden. Während die Verdoppelung von ein auf zwei Threads die CPU-Nutzung im wesentlichen verdoppelt, wird durch das erneute Verdoppeln der Thread-Anzahl auf vier die Effizienz der CPU-Ausnutzung nicht ganz auf das Vierfache verdoppelt, zumindest nicht innerhalb des Rahmens des bevorzugten Ausführungsbeispiels der vorliegenden Erfindung. Der Grund hierfür ist, dass bei vier Threads die Baumsuch-Latenzzeit nicht lang genug ist, um sicherzustellen, dass die anderen drei Threads laufen. Das bevorzugte Ausführungsbeispiel ist auf zwei Threads begrenzt, weil die zusätzlichen Kosten für zusätzliche Threads (größerer lokaler Datenspeicher und größere universelle Register-Arrays) wesentlich höher sind, als die Kosten, die dadurch eingespart werden, dass die CPU nicht dupliziert wird. Es macht also Sinn, wenn das Verdoppeln der Threads zu einer entsprechenden Verdoppelung der Verarbeitungsleistung führt. Wenn jedoch das Verdoppeln der Threads nicht zu einer Verdoppelung der Verarbeitungsleistung führt (wenn es sich zum Beispiel nur um eine 1,5 fache Verdoppelung handelt), ist es vorteilhafter, zusätzliche unabhängige CPUs hinzuzufügen. Die Entscheidung, wie viele Threads zu bevorzugen sind, muss von einer Person mit den entsprechenden technischen Kenntnissen getroffen werden und hängt ab von der relativen Differenz zwischen den CPU-Taktzyklen und den Baumsuch-Taktzyklen für das betreffende Verarbeitungssystem, wie auch von den Kosten für die Implementierung der Kern-CPU im Verhältnis zu den Kosten für die Duplizierung der universellen Register und des lokalen Datenspeichers.
Die zweite Überlegung bei der Verteilung der Maschinenzyklen zwischen CPU-Ausführung und Baumsuch-Vorgang ist die, dass, wenn die Verzahnung mit der Forderung implementiert wird, dass eine Baumsuche vor dem Starten der nächsten Baumsuche zuerst abgeschlossen sein muss, die Verzahnung der beiden Befehls-Threads nicht ganz so effizient ist. Jeder Paketprozess wird durch zahlreiche Fälle, in denen eine Baumsuche von der CPU gestartet wird, die Baumsuche jedoch blockiert und auf den Abschluss der Baumsuche des anderen Threads wartet, tatsachlich verlängert. Um diesen ungünstigen Umstand zu vermeiden, wird der Baumsuch-Coprozessor so modifiziert, dass er mehrere im Pipeline-Verfahren ablaufende Phasen umfasst. So muss eine Baumsuche eines Threads nicht warten, bis die Baumsuche des anderen Threads abgeschlossen ist, sondern nur solange, bis die Baumsuche des anderen Threads bis zu der zweiten Phase ihrer Pipeline fortgeschritten ist. In der Realität sieht das dann so aus, dass zu dem Zeitpunkt, an dem ein zweiter Thread die Befehle zum Einrichten einer Baumsuche ausgeführt hat, eine vorherige Baumsuche eines anderen Threads aller Wahrscheinlichkeit nach bereits über die erste Pipeline-Phase hinaus sein wird, wodurch Blockierungen im Baumsuchprozess völlig vermieden werden. Dies wiederum führt natürlich zu einer zusätzlichen Motivierung für die temporäre Umschaltung des Threads bei Ereignissen mit kurzer Latenzzeit, die bereits oben beschrieben wurde, um zu vermeiden, dass verschiedene Threads bei Baumsuchvorgängen um dieselbe Pipeline-Phase miteinander konkurrieren.
Ein weiteres Verfahren ist die Duplizierung von CPUs mit einzelnen Threads. Der Nachteil dieser Methode ist jedoch, dass es relativ teuer ist, dasselbe Leistungsniveau zu erreichen. Außerdem erhöhen sich die Anforderungen der höchsten Bandbreite auf den verschiedenen Bussen (das heißt, zum Befehlsspeicher oder zum gemeinsam genutzten externen Speicher). Mehrere Threads führen zu derselben durchschnittlichen Bandbreite, jedoch zur halben Spitzen-Bandbreite (bei zwei Threads), was signifikante Sekundäreffekte auf die Leistung haben kann, aufgrund des Konkurrierens um diese gemeinsam genutzten Ressourcen.
Die Erfindung wurde in Zusammenhang mit einem Netzwerkprozessor und einer Baumsuchstruktur beschrieben. Die Erfindung könnte jedoch auch für andere Prozessorsysteme und für das Abrufen von Daten aus Quellen nützlich sein, die keine Baumsuchmaschinen sind. Zum Beispiel kann die Thread-Ausführungssteuerung auch für den Zugriff auf andere Coprozessoren verwendet werden.
Zwar wurde die Erfindung in Verbindung mit entsprechenden Ausführungsbeispielen beschrieben, doch liegt es für den Fachmann auf der Hand, dass angesichts der oben beschriebenen Lehren viele Alternativen, Modifizierungen und Variationen möglich wären. Daher soll die Erfindung sämtliche dieser Alternativen, Modifizierungen und Variationen als sinn- und umfangsgemäß zu den Ansprüchen im Anhang gehörend beinhalten.

Claims

Verfahren zur Verwaltung von Threads in einem Prozessor, bei dem ein zweiter Thread aus einer Warteschlange mit mehr als zwei Threads zur Ausführung abgerufen wird, wenn ein Ereignis eintritt, das einen ersten Thread blockiert und die Verwaltung der Threads die Latenzzeit des Ereignisses berücksichtigt, mit folgenden Schritten: a) eine Steuerungslogik in einer Threadausführungssteuerung, die eine Komponente eines Prozessors ist, überwacht konstant den aktuellen, ersten Ausführungsthread und stellt fest, ob die Latenzzeit des den ersten Thread blockierenden Ereignisses kleiner als eine von einem Programmierer in einem Schwellwertregister einstellbare Anzahl von Machinenzyklen ist und damit eine kurze Latenzzeit vorliegt; b) bei einem Ereignis mit einer kurzen Latenzzeit bewirkt die Threadausführungssteuerung, dass die Steuerung der Ausführung vorübergehend an den zweiten Thread übergeben wird und an den ersten Thread zurückgegeben wird, wenn das Ereignis mit kurzer Latenzzeit beendet ist.
Verfahren nach Anspruch 1, dadurch gekennzeichnet, dass die Threads in der Threadausführungssteuerung priorisiert werden und die Steuerung der Priorität bei der Ausführung mehrerer unabhängiger Threads auf dem folgenden Booleschen Ausdruck beruht: Gn = Rn·{(PA = n) + RPA·(PB = n) + RPA·RPB·(PC = n)···}wobei gilt: G ist eine Zuteilung zur Ausführung; R_n ist eine Anforderung eines gegebenen Threads; P_A, P_B und P_C stellen Threads dar, alphabetisch geordnet nach ihren tief gestellten Indexzahlen entsprechend ihrer Priorität; _n ist eine Indexzahl, die einen Thread anhand einer Threadnummer kennzeichnet; und die Schritte durchgeführt werden: a) Bestimmen, ob eine Anforderung R aktiv oder inaktiv ist; b) Bestimmen der Priorität der Threads P; c) Abstimmen der Anforderung R mit dem entsprechenden Thread P; und d) Zuteilen einer Anforderung zur Ausführung, wenn die Anforderung aktiv ist und wenn der entsprechende Thread P die höchste Priorität hat.
Verfahren nach Anspruch 1 oder 2, weiter gekennzeichnet durch: – Bereitstellen eines getrennten Befehls-Prefetch-Puffers für jeden Thread, und Sammeln von Befehlen für einen Thread in den jeweiligen Befehls-Prefetch-Puffer, wenn der Thread im Leerlauf ist und wenn die Befehlsbandbreite nicht voll ausgenutzt wird.
Computersystem mit einer Threadausführungssteuerung zur Durchführung des Verfahrens nach einem der Ansprüche 1 bis 3.
Computersystem nach Anspruch 4, mit einem separaten Befehls-Prefetch-Puffer für jeden Thread und Mitteln zum Sammeln der Befehle in einem Befehls-Prefetch-Puffer für einen Thread im Leerlauf, wenn die Ausführungsbandbreite nicht voll ausgenutzt wird.
Computersystem nach Anspruch 4 oder 5, mit einem FIFO-Speicher und zugeordneten Steuermitteln, die zur Erteilung der Thread-Priorität die folgenden Schritte durchführen: a) Laden einer Threadnummer in den FIFO, wenn ein Thread an die CPU abgeschickt wird; b) Entfernen einer Threadnummer aus dem FIFO, wenn eine Thread abgeschlossen wurde; c) Verschieben einer Threadnummer von der höchsten Priorität zur niedrigsten Priorität in dem FIFO, wenn ein Ereignis mit langer Latenzzeit eintritt; d) Erteilen der Priorität abhängig davon, wie lange sich ein Thread im FIFO befunden hat.