Aus der Gleichung gibt es zwei Ansatzpunkte die Geschwindigkeit zu erhöhen: höhere Taktfrequenz und mehr Instruktionen pro Takt (IPC: Instructions per Clock). Fangen wir mit dem komplizierten an, dem IPC.<\/p>\n
Als der 8086 erschien, brauchten alle Befehle mehrere Takte, selbst einfache Befehle oder welche, die gar nichts taten wie der Befehl NOP. Im Schnitt brauchte ein Befehl beim 8086<\/a> in der Ausführung 7,7 Takte. Er hatte die klassische Architektur der damaligen Zeit implementiert: Befehl aus dem Speicher holen, Befehl dekodieren, Ergebnis ausgeben und eventuell Ergebnis zurückschreiben. Jede Operation benötigte einen Takt, oft mehrere. Komplexe Befehle wie Multiplikation oder Division brauchten sogar über 100 Takte.<\/p>\n Die nächste Generation, der 80286<\/a>, hatte eine Pipeline eingebaut. Sie holte bei jedem Takt einen Befehl, nicht nur wenn ein Befehl gerade fertig war. Bei jedem Takt wurde der Befehl in der Pipeline eine Stufe weitere befördert. Das ist eine erste Stufe der Parallelisierung. Es befinden sich immer mehrere Befehle in verschiedenen Stadien der Ausführung in der Pipeline. So brauchte der 80286 für die meisten einfachen Befehle nur noch zwei bis drei Takte. Er war beim gleichen Takt mindestens um den Faktor, 2, oft sogar um den Faktor 3 schneller als sein Vorgänger. Noch brauchten aber alle Befehle mehr als einen Takt, weil die Pipeline nur drei Stufen hat – wenn der Durchschnitt bei 8 Takten pro Befehl liegt, müsste sie acht Stufen umfassen, um einen Befehl pro Takt abzuarbeiten.<\/p>\n Bei den nächsten beiden Generationen wurde die Pipeline immer länger und der 486<\/a> erreichte nun tatsächlich, dass 80 % der Befehle in einem Takt ausgeführt wurden. Sie war nun fünf Stufen lang. Mit der Ausführung von einem Befehl pro Takt war die erste Grenze der Architektur erreicht. Unter diesen Wert kann man die Geschwindigkeit mit einer Pipeline nicht mehr drücken, auch wenn es sehr viele Stufen sind (den Rekord hält hier der Pentium 4 bei dem es bis zu 32 Stufen waren).<\/p>\n Beim Pentium<\/a> gab es daher einen Bruch mit der Architektur. Er hatte zwei arithmetisch-logische Einheiten (ALU), mit denen Ganzzahlberechnungen, aber auch Bitverknüpfungen oder Vergleiche durchgeführt wurden. Die Pipeline konnte nun beide Einheiten versorgen, das heißt, Befehle die diese Einheiten konnten nun parallel<\/a> ablaufen. Das Problem: Code wird linear ausgeführt, so schreiben ihn Menschen aber auch Compiler. Ein Schritt nach einem anderen kann unabhängig vom Ersten sein, muss aber nicht, kann z.B. ein Rechenergebnis verwenden, das erst errechnet werden muss.<\/p>\n Eine Geschwindigkeitssteigerung ergibt sich wenn der Prozessor feststellen kann ob Befehle voneinander abhängig sind und wenn das der Fall ist, einen anderen Befehl vorzieht., Mit diesem Feature \u201eOut of Order execution\u201c kann die Geschwindigkeit stark steigern, die CPU werden aber auch sehr komplex. Beim Übergang der CPU-Core des Raspberry Pi von Version 3 zu 4 kam dieses Feature auf und das hat den Prozessur enorm beschleunigt.<\/p>\n Bei „Out of Order Execution“ muss genau Buch geführt werden, welcher Befehl von welchem unabhängig ist, welche Einheit gerade frei ist und wann ein Ergebnis zur Verfügung steht. Dazu kam ein zweites Feature, die spekulative Ausführung: Das parallele Ausführen macht keinen Sinn, wenn bei einem Sprung (und den gibt es in Programmen häufig) man Befehle ausführt, die gar nicht mehr gültig sind. Eine Sprungvorhersage<\/a> ermittelt daher, wohin wahrscheinlich beim nächsten Sprung gesprungen wird. Diese Sprungvorhersage oder spekulative Ausführung ist die zweite Architekturänderung, die nötig ist. Die beiden Sicherheitslücken, die es bis in die Nachrichten schafften Meltdown und Spectre<\/a> basieren darauf, dass man die Out-of-Order und Sprungvorhersage Einheiten so trainierte, dass man auf Speicherbereiche zugreifen konnte, die nicht zum eigenen Prozess gehörten, indem diese schon vorsorglich in die Caches geladen wurden. Trotz des Sicherheitsmankos ist das Feature mächtig. Bei Intel beherrschen nur die Atoms kein Out-Of-Order Scheduling. Vergleicht man die Geschwindigkeit eines Atoms mit dem einfachsten \u201enormalen\u201c Prozessor von Intel, früher ein Celeron, heute steht der Begriff nicht mehr für eine Architektur, so zeigt sich das ein Atom bei gleichem Takt enorm viel langsamer ist.<\/p>\n Im Prinzip hat sich seitdem nicht mehr viel geändert. Beim Pentium war das Feature der parallelen Ausführung noch rudimentär, beim Pentium Pro voll ausgebaut. Auf dessen Architektur basiert noch die heutige Skylake Architektur. Zwischendurch versuchte Intel einen Wechsel \u2013 die mit dem Pentium 4<\/a> eingebaute Netburst Architektur basiert auf nicht so vielen Einheiten, dafür schnellerer Ausführung, doch diese erwies sich als eine Sackgasse. Skylake hat heute 22 Funktionseinheiten, die von 7 Ports gefüttert werden. Diese große Zahl ergibt sich daraus, dass zwar durch eine Pipeline ein Befehl pro Takt ausgeführt wird, die Ausführungszeit aber immer noch mehrere Takte beträgt. Solange ist eine Einheit belegt und daher braucht man mehrere. Die Portzahl ist daher aussagekräftiger. 7 Ports bedeuten: maximal 7 Befehle können gleichzeitig aktiv sein. In der Praxis sind es 3 bis 4.<\/p>\n Erst mit der letzten Pentium-4-Generation führte Intel mehrere Prozessorkerne ein. Der Unterschied zu parallelen Funktionseinheiten ist, dass der gesamte Prozessor mehrfach vorkommt. Er ist auch dem Betriebssystem bekannt, das so verschiedene Prozesse an verschiedene Kerne verteilen kann. Das können Anwendungsprogramme, aber auch Systemtreiber sein. Die Kernzahl ist seitdem nur langsam gestiegen. Intel versprach mit jeder Generation die Kernzahl zu verdoppeln, das hat sich nicht bewahrheitet, denn dann müssten Skylake<\/a> Prozessoren mindestens 32 Kerne haben. Tatsächlich hat das Einsteigersegment zwei Kerne, die etwas besseren Prozessoren vier und nur im Spitzensegment (der Desktop-Prozessoren) gibt es mehr, wobei auch hier erst durch die Ryzen von AMD Bewegung kam. Bei der Serverlinie, den Xeons, gibt es aber tatsächlich Prozessoren mit bis zu 36 Kernen. Der einfache Grund: Server, die viele Benutzer haben oder hochparallele Programme ausführen, nutzen so viele Kerne auch aus, Programme für Desktop-Rechner, die meist interaktiv sind dagegen nicht. Ein Zwischenschritt zwischen echten Kernen und den für das Programm unsichtbaren mehrfach vorhandenen Funktionseinheiten ist das Hyperthreading oder als allgemeiner Begriff, Simultaneous Multithreading. Dabei werden dem Betriebssystem mehr Kerne gemeldet, als es gibt. Die Befehle werden dann in die laufende Abarbeitung eingefügt, wobei man da es getrennte Threads sind, dies einfacher ist als das Umsortieren von Befehlen eines Threads. Allerdings kann man mit SMT, da es eben nicht zwei vollständige Kerne sind niemals so viel Leistung erreichen wie mit zwei eigenen Kernen.<\/span><\/p>\n Kommen wir zum zweiten Kriterium: der Taktfrequenz. Die stieg lange Zeit dauernd an. Anfangs erst langsam. Der 8086 erschien mit 8 MHz, auch der 286, der 386<\/a> mit 16 MHz, der 486 mit 20 MHz. Ab dem Pentium gab es eine Phase, in der die Taktfrequenz pro Generation rapide anstieg: 66 MHz beim Pentium, 233 MHz beim Pentium II, 450 MHz beim Pentium III, 1.200 MHz beim Pentium 4. Von 1978 bis 1994 stieg in 16 Jahren die Taktfrequenz um den Faktor 8. Von 1994 bis 2003 in neun Jahren um den Faktor 45. Der Pentium 4 erreichte eine Spitzentaktfrequenz von 3,83 GHz, doch das war nicht mehr weiter steigerbar. Die erste Generation der iCore<\/a> Architektur ging wieder auf 3,33 GHz Spitzentakt herunter. Heute werden wieder 4 GHz erreicht und überschritten aber um nicht mehr viel.<\/p>\n Das heißt, wir haben zwei Dead-Ends: Die Spitzentaktfrequenz ist seit über 15 Jahren kaum gestiegen, die interne Architektur ist seit derselben Zeit nahezu unverändert, wenn man sie auf den Pentium Pro <\/a>zurückführt, sogar seit über 20 Jahren. Natürlich gab es immer wieder Verbesserungen in der Zeit dazwischen, aber eben doch evolutionäre Änderungen. Damit komme ich zum Ausgangspunkt zurück \u2013 lohnt es sich heute einen 4 bis 6 Jahre alten PC auszuwechseln, nur weil der Prozessor zu lahm ist. Nach Intels Angaben wurde die Geschwindigkeit wie folgt gesteigert:<\/p>\n <\/p>\n Skylake ist da noch nicht dabei, soll aber bei maximal 10 % liegen. Immerhin, in 13 Jahren sind es summierte 177 %. Doch es gibt noch einen anderen Faktor. Seit die Parallelisierung einzog, ist es so, dass der Geschwindigkeitsgewinn nicht linear abhängig ist, sondern stark vom Programm abhängig. Beim Pentium war es so, dass er den damals noch weit verbreiteten 16-Bit-Code in DOS kaum beschleunigte. Bei so vielen Generationen wie in der oberen Tabelle kommen dann noch Befehle hinzu, die ein neueres Programm nutzen kann. Vor allem bei Fließkommabefehlen hat Intel in den letzten Jahren viel gemacht. Die Angaben von Intel kann man also als optimistisch ansehen.<\/p>\n Eine andere Webseite kam auf folgende Werte beim Auswerten der Geschwindigkeit gängiger Programme:<\/p>\n\n
\n \n<\/th>\n Technik<\/th>\n ST-IPC-Gewinn<\/th>\n ST-IPC vs. Dothan<\/th>\n<\/tr>\n<\/thead>\n \n Dothan<\/strong><\/td>\n Pentium M (Refresh), 2C ohne HT\/TM, 90nm (2004)<\/td>\n –<\/td>\n 100%<\/em><\/td>\n<\/tr>\n \n Merom<\/strong><\/td>\n Core 2 Duo, 2C ohne HT\/TM, 65nm (2007)<\/td>\n +15%<\/td>\n 115%<\/td>\n<\/tr>\n \n Penryn<\/strong><\/td>\n Core 2 Duo (Refresh), 2C ohne HT\/TM, 45nm (2008)<\/td>\n +2%<\/td>\n 117,5%<\/td>\n<\/tr>\n \n Nehalem<\/strong><\/td>\n Core 9xx, 4C +HT +TM, 45nm (2008)<\/td>\n +12%<\/td>\n 131,5%<\/td>\n<\/tr>\n \n Sandy Bridge<\/strong><\/td>\n Core 2xxx, 4C +HT +TM, 32nm (2011)<\/td>\n +10%<\/td>\n 144,5%<\/td>\n<\/tr>\n \n Ivy Bridge<\/strong><\/td>\n Core 3xxx, 4C +HT +TM, 22nm (2012)<\/td>\n +5%<\/td>\n 152%<\/td>\n<\/tr>\n \n Haswell<\/strong><\/td>\n Core 4xxx, 4C +HT +TM, 22nm (2013)<\/td>\n +10,5%<\/td>\n 167,5%<\/td>\n<\/tr>\n \n Broadwell<\/strong><\/td>\n Core 5xxx, 4C +HT +TM, 14nm (2015)<\/td>\n +5,5%<\/td>\n 177%<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n