{"id":14918,"date":"2020-08-22T17:21:41","date_gmt":"2020-08-22T15:21:41","guid":{"rendered":"https:\/\/www.bernd-leitenberger.de\/blog\/?p=14918"},"modified":"2020-08-24T16:45:43","modified_gmt":"2020-08-24T14:45:43","slug":"mach-dem-speicher-beine","status":"publish","type":"post","link":"https:\/\/www.bernd-leitenberger.de\/blog\/2020\/08\/22\/mach-dem-speicher-beine\/","title":{"rendered":"Mach dem Speicher Beine"},"content":{"rendered":"<p>Als Erg&auml;nzung zu meiner kleinen Zusammenfassung der Schritte wie man einen Prozessor beschleunigt m&ouml;chte ich heute erg&auml;nzen, wie man den Speicher beschleunigt. Wie bei meinem <a href=\"https:\/\/www.bernd-leitenberger.de\/blog\/2020\/07\/30\/prozessorarchitekturentwicklung\/\">ersten Aufsatz<\/a> geht es dabei um Computerentwicklung allgemein und nicht nur um Mikroprozessoren, die meisten Technologien wurden sogar entwickelt, bevor es &uuml;berhaupt Mikroprozessoren gab.<img loading=\"lazy\" decoding=\"async\" style=\"display: none !important;\" hidden=\"\" src=\"https:\/\/vg04.met.vgwort.de\/na\/d488326c06db4f539777d7b4b9772dc4\" alt=\"\" width=\"1\" height=\"1\" \/><!--more--><\/p>\n<h3 class=\"western\">Das Problem<\/h3>\n<p>Das grundlegende Problem war schon immer, und daran hat sich bis heute nichts ge&auml;ndert, das Speicher langsamer als die Logik war. Das muss nicht so sein. Jeder Prozessor, selbst der einfachste ben&ouml;tigt etwas lokalen Speicher zumindest f&uuml;r die Arbeitsregister, heute auch Caches (dazu sp&auml;ter) auf dem Chip. Man kann also Speicher aus denselben Elementen aufbauen, wie Logik die in Prozessoren vorherrscht. Nur macht man dies aus wirtschaftlichen Gr&uuml;nden nicht. Dazu ein Beispiel. Gerade auf den Markt gekommen ist der <a href=\"https:\/\/amzn.to\/32f846b\">Ryzen 4750G Prozessor<\/a>. Er hat 9,8 Milliarden Transistoren und kostet 275 Euro. In etwa genauso viel kosten heute <a href=\"https:\/\/amzn.to\/3j8ak6b\">64 GB DDR4 RAM<\/a> also Speicher.<\/p>\n<p>Man kann aus vier Transistoren ein Element konstruieren, das ein Bit speichert, ein Flip-Flop. Mit 9,8 Milliarden Transistoren k&ouml;nnte man also rund 2,5 Milliarden Bits speichern oder rund 300 MByte. Das sind aber nur ein Zwanzigstel der Speichermenge, die der Arbeitsspeicher f&uuml;r denselben Preis speichert. Arbeitsspeicher in der Technologie aufzubauen, die man f&uuml;r die Logik verwendet geht, ist also sehr teuer. Die Technologie f&uuml;r RAM ist dagegen billiger, aber sie ist langsamer und dieses Problem muss man l&ouml;sen.<\/p>\n<p>Das war &uuml;brigens schon immer so, auch wenn die Technologien wechselten. Die ersten Speicher speicherten die Information akustisch, als Wellen in einer R&ouml;hre gef&uuml;llt mit Quecksilber, dann kamen magnetisch-mechanische Speicher in Mode (Trommelspeicher, die nach dem Prinzip einer Festplatte arbeiteten, nur war es keine Platte, sondern eine Zylinderoberfl&auml;che) und dann die rein magnetische Speicherung auf Ringkernspeichern. Nach einer kurzen Episode, in der tats&auml;chlich f&uuml;r den Speicher dieselbe Technologie wie f&uuml;r die Logik eingesetzt wurde, (heute als SRAM bezeichnet) kam dann der bis heute &uuml;bliche DRAM auf, bei dem die Information in dotiertem Silizium gespeichert wird, das sich wie ein Kondensator verh&auml;lt.<\/p>\n<p>Alle Technologien f&uuml;r Speicher haben das Problem, das sie langsamer als die Logik ihrer Zeit waren. Man kann dies an einer Gr&ouml;&szlig;e festmachen, die fr&uuml;her g&auml;ngig war, bei aktuellem DDR-RAM aber durch eine Liste von Timings ersetzt wurde, die Zugriffszeit und Zykluszeit.<\/p>\n<p>Jeder Prozessor arbeitet mit einem Takt und bei jedem Takt macht er nur eine Aufgabe. Spricht er den Speicher an, so legt er bei einem Takt die Informationen auf den Bus und verst&auml;ndigt den Speicher das er Daten holen oder schrieben m&ouml;chte und beim n&auml;chsten Takt will er diese Information holen oder schreiben (es k&ouml;nnen auch mehrere Takte sein, im Folgenden gehe ich aber mal von einem Takt aus, was bei allen modernen Prozessoren auch so ist). Jeder Speicher hat eine Zugriffszeit, das ist die Zeit, die vergeht, zwischen der Anforderung des Prozessors als Signal auf dem Bus und dem Anliegen der Daten auf dem Bus die vom Speicher kommen. Bei den meisten Speichertypen gibt es noch eine zweite Zeit, die Zykluszeit. Sie entsteht dadurch, dass das Auslesen von Daten meistens den Inhalt zerst&ouml;rt und er neu geschrieben werden muss und auch Schreib-\/Lesepuffer Zeit brauchen bis ihre Ladung abgebaut ist. Das obige Flip Flop ist eine Ausnahme von der Regel es hat keine Zykluszeit, bzw. diese ist genauso lange wie die Zugriffszeit. Die Zykluszeit gibt an, wie lange man nach einer Anforderung warten muss, bis man erneut eine Anfrage an den Speicher stellen muss.<\/p>\n<p>Wer wie ich seine ersten Versuche Anfang der Achtziger mit einem <a href=\"https:\/\/www.bernd-leitenberger.de\/c64.shtml\">C64<\/a>, <a href=\"https:\/\/www.bernd-leitenberger.de\/cpc464.shtml\">CPC 464<\/a>, Sinclair <a href=\"https:\/\/www.bernd-leitenberger.de\/sinclair-spectrum.shtml\">Spectrum<\/a> oder &auml;hnlichem Computer machte, der hatte in diesem DRAM Bausteine mit einer Zugriffszeit von 150 bis 200 ns und einer Zykluszeit von 260 bis 350 ns. Prozessoren dieser Zeit (in 8 Bit Rechnern) hatten Taktfrequenzen von 1 bis 4 MHz), der Kehrwert davon waren dann 250 bis 1000 ns, das hei&szlig;t, die Prozessoren konnten verz&ouml;gerungsfrei lesen. Das galt, aber nur weil es die langsamsten Prozessoren ihrer Zeit war. Gro&szlig;computer arbeiteten dagegen damals schon mit bis zu 250 MHz und f&uuml;r diese waren dann diese Zugriffszeiten viel zu langsam.<\/p>\n<p>Das Dumme nur: Seitdem ist die Taktfrequenz eines PC um etwa das Tausendfache auf 2 bis 5 GHz gestiegen, die Zugriffzeit von DRAM aber nur auf 7 bis 10 ns gesunken, also den Faktor 30. Speicher ist im Vergleich zum Prozessor noch langsamer geworden und unsere Computer w&auml;ren unertr&auml;glich langsam, wenn man diesen Nachteil nicht kaschieren w&uuml;rde. L&ouml;st man es nicht, so muss der Prozessor warten, bis der Speicher bereit ist, das kam auch vor, als die Prozessoren nur etwas schnellerals das RAM ihrer Zeit\u00a0 waren. Rechner der AT-&Auml;ra gab es mit 0, 1 oder 2 Wartezyklen zu kaufen \u2013 je nach Taktfrequenz und verbautem Speicher.<\/p>\n<h3 class=\"western\">Taktiken das Problem zu l&ouml;sen<\/h3>\n<p>Es gibt im Prinzip folgende Methoden die Langsamkeit des Speichers zu kaschieren:<\/p>\n<ul>\n<li>Zwischenspeichern<\/li>\n<li>Vorausschauendes Lesen<\/li>\n<li>Verteilter Zugriff<\/li>\n<li>Lesen gr&ouml;&szlig;erer Datenmengen als eigentlich ben&ouml;tigt<\/li>\n<\/ul>\n<p>Alle Techniken basieren im Wesentlichen auf einer Eigenschaft, sowohl von Code wie Daten: die Linearit&auml;t. Daten werden nach Deklaration nacheinander im Speicher abgelegt, gr&ouml;&szlig;ere Strukturen wie Felder sind von sich aus linear organisiert. Code wird meist linear abgewickelt \u2013 die Ausnahme sind Spr&uuml;nge in Unterprogramme und bei Schleifen. Das bedeutet, mit einer gro&szlig;en Wahrscheinlichkeit ben&ouml;tigt man im n&auml;chsten Taktzyklus die Daten, die an der n&auml;chsten Adresse im Speicher sitzen. Alle Techniken beruhen darauf, diese bereitzustellen, bevor &uuml;berhaupt eine Anforderung kommt und dann f&auml;llt die Zugriffszeit weg oder ist verk&uuml;rzt. Wechselt die abgerufene Region, dann ist der Vorteil weg. Das ist besonders bei Code ein Problem, weshalb heute Prozessoren sich gro&szlig;e M&uuml;he geben Spr&uuml;nge vorherzusagen und die Daten schon vorab vom Speicher abzuholen.<\/p>\n<h3 class=\"western\">Zwischenspeichern<\/h3>\n<p>F&uuml;r das Zwischenspeichern baut man einen kleinen Speicher in einer schnellen Technologie wie den obigen Flip-Flops. Er nimmt Daten, auf die man eventuell nochmals braucht oder bald braucht. Die Technologie kommt in verschiedensten Techniken vor.<\/p>\n<p>Seymour <a href=\"https:\/\/www.bernd-leitenberger.de\/cray-artikel.shtml\">Crays Supercomputer<\/a> hatten einen Instruktionsbuffer. Er nahm die letzten Anweisungen auf, gab es einen Sprung, der meist bei einer Schleife am Schleifenende ist, so wurden die Instruktionen nochmals abgearbeitet und befanden sich im Instruktionsbuffer, mussten also nicht aus dem Speicher geholt werden.<\/p>\n<p>Speicherb&auml;nke (Erkl&auml;rung folgt noch) speicherten ebenfalls die n&auml;chsten Informationen aus der Adresse die der aktuellen folgt, in einem kleinen Buffer, den sie automatisch f&uuml;llten und auf den so verz&ouml;gerungsfrei zugegriffen werden konnte.<\/p>\n<p>Die g&auml;ngigste Umsetzung des Prinzips ist aber der <a href=\"https:\/\/www.bernd-leitenberger.de\/sram-dram-caches.shtml\">Cache<\/a>, der zuerst bei der IBM System 360 eingef&uuml;hrt wurde. Das Prinzip ist recht einfach. Immer wenn Daten oder Code geholt wird, landet eine Koppe in einem schnellen Zwischenspeicher dem Cache. Der Prozessor sieht bei jedem Transfer zuerst nach, ob sich die Daten im Cache befinden und nutzt diese und erst dann zum Speichern. In der Praxis kann die Verwaltung eines Caches durchaus komplex sein, doch daf&uuml;r verweise ich auf meinen <a href=\"https:\/\/www.bernd-leitenberger.de\/cache.shtml\">Artikel auf der Webseite<\/a>. Heutige Prozessoren haben mehrere Caches, die unterschiedlich gro&szlig; und schnell sind und oft auch aufgeteilt nach Daten oder Code. Sie machen heute von der Chipfl&auml;che und Transistorenzahl sogar das Gro&szlig; des Die aus.<\/p>\n<p>Vorausschauendes Lesen<\/p>\n<p>Wegen der Lokalit&auml;t und Linearit&auml;t macht es Sinn Daten zu lesen, bevor der Prozessor sie &uuml;berhaupt anfordert, auch wenn man sie sp&auml;ter verwerfen muss. Praktisch alle Techniken setzen dies, da es wenig Aufwand macht, zus&auml;tzlich ein. In der Intel x86 Serie hatte der <a href=\"https:\/\/www.bernd-leitenberger.de\/80386.shtml\">80386<\/a> zuerst Unterst&uuml;tzung f&uuml;r einen externen Cache, beim Nachfolger <a href=\"https:\/\/www.bernd-leitenberger.de\/80486.shtml\">80486<\/a> war dann der erste Cache intern verbaut, es gab aber noch einen externen Cache.<\/p>\n<p>Die einfachste Form ist der Prefetch, den z. B. Der <a href=\"https:\/\/www.bernd-leitenberger.de\/8086.shtml\">8086<\/a> hatte. Da nach jedem Lesen eines Befehls (Speicherzugriff) dieser immer erst dekodiert und ausgef&uuml;hrt werden musste hatte die I\/O Einheit die mit dem Speicher kommuniziert, einige Takte lang nichts zu tun und sie nutzte dies, um ein Byte einzulesen. Das kostet wenig Aufwand ist uns weit verbreitet.<\/p>\n<p>Caches sind in Cachelines organisiert, die l&auml;nger als ein Befehlswort sind, bei aktuellen Prozessoren sind sie z.B. 8 Bytes lang. Auch hier liegt es nahe das man die n&auml;chsten Bytes einer Cacheline bald ben&ouml;tigt und es wird immer eine komplette Cacheline aus dem Speicher geholt.<\/p>\n<p>Speicherb&auml;nke, die bei Gro&szlig;computern verbreitet waren (heute noch in Form von Speicherkan&auml;len auf dem Mainboard) lasen auch meist das n&auml;chste Befehlswort aus und speicherten es in einem schnellen Speicher zwischen.<\/p>\n<p>Vorausschauendes Lesen ist aber die Basis f&uuml;r die Performance von DDR-Speicher. Nach dem ersten langsamen Zugriff, der mit der Zugriffszeit eines DRAM erfolgt, liest der Speicher intern nicht die angeforderten Daten aus, sondern 8 weitere Bl&ouml;cke zu jeweils 64 Bit und &uuml;bertr&auml;gt sie bei jedem Flankenwechsel, also zwei Transfers pro Takt. Die Gr&ouml;&szlig;e ist abgestimmt auf die Cachelines, da es wie bei einer Cacheline genau 64 Bit pro Anforderung sind.<\/p>\n<h3 class=\"western\">Verteilter Zugriff<\/h3>\n<p>Die bei Gro&szlig;computern g&auml;ngigste Taktik ist es, den Speicher in einzelne Sektionen genannt Speicherb&auml;nke zu unterteilen. Ein Gro&szlig;computer konnte durchaus 256 Speicherb&auml;nke haben. Sie waren im Adressbereich so angeordnet, dass ein sequenzieller Zugriff jeweils auf eine andere Speicherbank ging und so im Idealfall bei n Speicherb&auml;nken erst nach n Taktzyklen die gleiche Bank wieder zum Zug kam. So kann man die Zykluszeit auf die Zugriffszeit reduzieren. Um auch diese zu umgehen, setzen die B&auml;nke die Technik des Prefetch ein und haben so die Daten der n&auml;chsten Adresse schon bereit, wenn der n&auml;chste Zugriff kommt. Bei Crays Supercomputern funktionierte das so gut, das diese Computer ohne Caches auskamen und trotzdem es keine Wartezyklen bei linear ausgef&uuml;hrtem Code gab. Dabei war die CPU schon bei der Cray 1 viermal schneller als der Speicher. Ein PC hat meist 2 oder 4 Speicherkan&auml;le, die technisch je eine Bank sind und meist einem Modulsteckplatz entsprechen. Server haben meist mehr Speicherb&auml;nke &uuml;blich sind 8 oder 16 Kan&auml;le, die jeweils mit einem Modul best&uuml;ckt werden. Durch Caches ist der Vorteil bei einem PC allerdings relativ klein und liegt bei einer Verdopplung von einem auf zwei Kan&auml;le unter 10 % Geschwindigkeitszuwachs.<\/p>\n<h3 class=\"western\">Lesen gr&ouml;&szlig;erer Datenmengen<\/h3>\n<p>Auch diese Technik findet man h&auml;ufig. Angesprochen wurde, das Cachelines l&auml;nger als ein Befehl sind. Das hat allerdings vor allem organisatorische Gr&uuml;nde. Das Lesen gro&szlig;er Datenmengen hat im eigentlichen Sinn die Aufgabe, gleichzeitig mehrere Befehle oder gro&szlig;e Datenbl&ouml;cke in die Kern-CPU zu transferieren. Der Intel Itanium Prozessor fasste immer drei Instruktionen zu einem Block zusammen der bei einem Transfer &uuml;bermittelt wurde. Im Allgemeinen hei&szlig;t die Technik VLIW (Very Long Instruction Word) wenn mehrere Befehle zu einem Block zusammengefasst werden oder SIMD (Single Instruction, Multiple Data) wenn eine Instruktion mehrere Daten bearbeitet und dies ebenfalls einen Block ergibt.<\/p>\n<p>Bei Gro&szlig;rechnern baute man Bussysteme, die relativ breit waren, 256, 512 oder 1024 Bit auf einmal lasen oder schreiben und dabei auch mehrere Speicherb&auml;nke parallel ansprachen. Damit waren die Daten f&uuml;r mehrere Instruktionen in Prozessor, selbst wenn der Speicher nur einen Bruchteil dessen Taktfrequenz hatte, man gleich also dessen Langsamkeit damit aus, das das Bussystem viel mehr Daten transferierte, als der Prozessor auf einmal verarbeiten konnte, so hatte der Speicher Zeit, bis diese verarbeitet, waren neue Daten bereitzustellen-<\/p>\n<p>Beim heutigen PC findet man die Technik bei Grafikkarten, wo die CPU festverl&ouml;tet ist. Dann ist es leichter die vielen Leitungen die man ben&ouml;tigt. zum Speicher zu ziehen, als wenn die CPU getrennt ist und jeder Pin eine bestimmte Mindestgr&ouml;&szlig;e haben muss, damit er sich nicht zu leicht bei der Montage verbiegt. Dagegen sind Kupferleitungen auf einer Platine viel d&uuml;nner und enger platzierbar.<\/p>\n<h3 class=\"western\">Testen des Effekts der Ma&szlig;nahmen<\/h3>\n<p>Das folgende C-Programm ist eine einfache Matrizenmultiplikation. Sei wird dreimal durchgef&uuml;hrt, wobei jedoch die Schleifenreihenfolge variiert. Wer das Programm &uuml;bersetzt, wird feststellen, dass die Ausf&uuml;hrungsgeschwindigkeit variiert, weil nur in einer Reihenfolge die Caches voll ausgen&uuml;tzt werden. Je nach Gr&ouml;&szlig;e der Caches (Variieren der Konstante DIM) kann eine Schleifenreihefolge, die zum regelm&auml;&szlig;igen Cache-Miss f&uuml;hrt, die Geschwindigkeit des Programms um den Faktor 100 heruntersetzen.<\/p>\n<p><span style=\"color: #008080;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"><span style=\"font-size: small;\">#pragma hdrstop<\/span><\/span><\/span><\/p>\n<p><span style=\"color: #008080;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"><span style=\"font-size: small;\">#pragma argsused<\/span><\/span><\/span><\/p>\n<p><span style=\"color: #008080;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"><span style=\"font-size: small;\">#include &lt;tchar.h&gt;<\/span><\/span><\/span><\/p>\n<p><span style=\"color: #008080;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"><span style=\"font-size: small;\">#include &lt;stdio.h&gt;<\/span><\/span><\/span><\/p>\n<p><span style=\"color: #008080;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"><span style=\"font-size: small;\">#include &lt;time.h&gt;<\/span><\/span><\/span><\/p>\n<p><span style=\"color: #008080;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"><span style=\"font-size: small;\">#define DIM 1000<\/span><\/span><\/span><\/p>\n<p><span style=\"font-size: small;\"><span style=\"color: #ff0000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"><b>typedef<\/b><\/span><\/span> <span style=\"color: #ff0000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"><b>double<\/b><\/span><\/span><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"> mat[DIM][DIM];<\/span><\/span><\/span><\/p>\n<p><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"><span style=\"font-size: small;\">mat a, b, c;<\/span><\/span><\/span><\/p>\n<p><span style=\"font-size: small;\"><span style=\"color: #ff0000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"><b>void<\/b><\/span><\/span><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"> clear()<\/span><\/span><\/span><\/p>\n<p><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"><span style=\"font-size: small;\">{<\/span><\/span><\/span><\/p>\n<p><span style=\"font-size: small;\"> <span style=\"color: #ff0000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"><b>for<\/b><\/span><\/span><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"> (<\/span><\/span><span style=\"color: #ff0000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"><b>int<\/b><\/span><\/span><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"> i = <\/span><\/span><span style=\"color: #0000ff;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\">0<\/span><\/span><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\">; i &lt; DIM; i++)<\/span><\/span><\/span><\/p>\n<p><span style=\"font-size: small;\"> <span style=\"color: #ff0000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"><b>for<\/b><\/span><\/span><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"> (<\/span><\/span><span style=\"color: #ff0000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"><b>int<\/b><\/span><\/span><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"> j = <\/span><\/span><span style=\"color: #0000ff;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\">0<\/span><\/span><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\">; j &lt; DIM; j++) {<\/span><\/span><\/span><\/p>\n<p><span style=\"font-size: small;\"><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"> c[i][j] = <\/span><\/span><span style=\"color: #004080;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\">0.0<\/span><\/span><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\">;<\/span><\/span><\/span><\/p>\n<p><span style=\"font-size: small;\"><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"> b[i][j] = i * <\/span><\/span><span style=\"color: #004080;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\">1.2<\/span><\/span><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\">;<\/span><\/span><\/span><\/p>\n<p><span style=\"font-size: small;\"><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"> a[i][j] = j * <\/span><\/span><span style=\"color: #004080;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\">1.1<\/span><\/span><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\">;<\/span><\/span><\/span><\/p>\n<p><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"><span style=\"font-size: small;\"> }<\/span><\/span><\/span><\/p>\n<p><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"><span style=\"font-size: small;\">}<\/span><\/span><\/span><\/p>\n<p><span style=\"font-size: small;\"><span style=\"color: #ff0000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"><b>int<\/b><\/span><\/span><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"> _tmain(<\/span><\/span><span style=\"color: #ff0000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"><b>int<\/b><\/span><\/span><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"> argc, _TCHAR* argv[]) {<\/span><\/span><\/span><\/p>\n<p><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"><span style=\"font-size: small;\"> time_t zeit1, zeit2;<\/span><\/span><\/span><\/p>\n<p><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"><span style=\"font-size: small;\"> clear();<\/span><\/span><\/span><\/p>\n<p><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"><span style=\"font-size: small;\"> zeit1 = time(NULL);<\/span><\/span><\/span><\/p>\n<p><span style=\"font-size: small;\"> <span style=\"color: #ff0000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"><b>for<\/b><\/span><\/span><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"> (<\/span><\/span><span style=\"color: #ff0000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"><b>int<\/b><\/span><\/span><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"> k = <\/span><\/span><span style=\"color: #0000ff;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\">0<\/span><\/span><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\">; k &lt; DIM; k++)<\/span><\/span><\/span><\/p>\n<p><span style=\"font-size: small;\"> <span style=\"color: #ff0000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"><b>for<\/b><\/span><\/span><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"> (<\/span><\/span><span style=\"color: #ff0000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"><b>int<\/b><\/span><\/span><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"> j = <\/span><\/span><span style=\"color: #0000ff;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\">0<\/span><\/span><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\">; j &lt; DIM; j++)<\/span><\/span><\/span><\/p>\n<p><span style=\"font-size: small;\"> <span style=\"color: #ff0000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"><b>for<\/b><\/span><\/span><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"> (<\/span><\/span><span style=\"color: #ff0000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"><b>int<\/b><\/span><\/span><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"> i = <\/span><\/span><span style=\"color: #0000ff;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\">0<\/span><\/span><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\">; i &lt; DIM; i++) {<\/span><\/span><\/span><\/p>\n<p><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"><span style=\"font-size: small;\"> c[i][j] += a[i][k] * b[k][j];<\/span><\/span><\/span><\/p>\n<p><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"><span style=\"font-size: small;\"> }<\/span><\/span><\/span><\/p>\n<p><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"><span style=\"font-size: small;\"> zeit2 = time(NULL);<\/span><\/span><\/span><\/p>\n<p><span style=\"font-size: small;\"><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"> printf(<\/span><\/span><span style=\"color: #800080;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\">&#8222;kji: %f\\n&#8220;<\/span><\/span><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\">, difftime(zeit2, zeit1));<\/span><\/span><\/span><\/p>\n<p><span style=\"font-size: small;\"><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"> printf(<\/span><\/span><span style=\"color: #800080;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\">&#8222;%.0f\\n&#8220;<\/span><\/span><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\">, <\/span><\/span><span style=\"color: #004080;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\">2.0<\/span><\/span><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\">*DIM*DIM*DIM \/ difftime(zeit2, zeit1) \/ <\/span><\/span><span style=\"color: #0000ff;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\">1000000<\/span><\/span><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\">);<\/span><\/span><\/span><\/p>\n<p><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"><span style=\"font-size: small;\"> clear();<\/span><\/span><\/span><\/p>\n<p><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"><span style=\"font-size: small;\"> zeit1 = time(NULL);<\/span><\/span><\/span><\/p>\n<p><span style=\"font-size: small;\"> <span style=\"color: #ff0000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"><b>for<\/b><\/span><\/span><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"> (<\/span><\/span><span style=\"color: #ff0000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"><b>int<\/b><\/span><\/span><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"> k = <\/span><\/span><span style=\"color: #0000ff;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\">0<\/span><\/span><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\">; k &lt; DIM; k++)<\/span><\/span><\/span><\/p>\n<p><span style=\"font-size: small;\"> <span style=\"color: #ff0000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"><b>for<\/b><\/span><\/span><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"> (<\/span><\/span><span style=\"color: #ff0000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"><b>int<\/b><\/span><\/span><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"> i = <\/span><\/span><span style=\"color: #0000ff;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\">0<\/span><\/span><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\">; i &lt; DIM; i++)<\/span><\/span><\/span><\/p>\n<p><span style=\"font-size: small;\"> <span style=\"color: #ff0000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"><b>for<\/b><\/span><\/span><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"> (<\/span><\/span><span style=\"color: #ff0000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"><b>int<\/b><\/span><\/span><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"> j = <\/span><\/span><span style=\"color: #0000ff;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\">0<\/span><\/span><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\">; j &lt; DIM; j++) {<\/span><\/span><\/span><\/p>\n<p><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"><span style=\"font-size: small;\"> c[i][j] += a[i][k] * b[k][j];<\/span><\/span><\/span><\/p>\n<p><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"><span style=\"font-size: small;\"> }<\/span><\/span><\/span><\/p>\n<p><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"><span style=\"font-size: small;\"> zeit2 = time(NULL);<\/span><\/span><\/span><\/p>\n<p><span style=\"font-size: small;\"><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"> printf(<\/span><\/span><span style=\"color: #800080;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\">&#8222;kij: %f \\n&#8220;<\/span><\/span><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\">, difftime(zeit2, zeit1));<\/span><\/span><\/span><\/p>\n<p><span style=\"font-size: small;\"><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"> printf(<\/span><\/span><span style=\"color: #800080;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\">&#8222;%.0f\\n&#8220;<\/span><\/span><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\">, <\/span><\/span><span style=\"color: #004080;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\">2.0<\/span><\/span><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\">*DIM*DIM*DIM \/ difftime(zeit2, zeit1) \/ <\/span><\/span><span style=\"color: #004080;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\">1000000.0<\/span><\/span><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\">);<\/span><\/span><\/span><\/p>\n<p><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"><span style=\"font-size: small;\"> clear();<\/span><\/span><\/span><\/p>\n<p><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"><span style=\"font-size: small;\"> zeit1 = time(NULL);<\/span><\/span><\/span><\/p>\n<p><span style=\"font-size: small;\"> <span style=\"color: #ff0000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"><b>for<\/b><\/span><\/span><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"> (<\/span><\/span><span style=\"color: #ff0000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"><b>int<\/b><\/span><\/span><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"> i = <\/span><\/span><span style=\"color: #0000ff;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\">0<\/span><\/span><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\">; i &lt; DIM; i++)<\/span><\/span><\/span><\/p>\n<p><span style=\"font-size: small;\"> <span style=\"color: #ff0000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"><b>for<\/b><\/span><\/span><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"> (<\/span><\/span><span style=\"color: #ff0000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"><b>int<\/b><\/span><\/span><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"> j = <\/span><\/span><span style=\"color: #0000ff;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\">0<\/span><\/span><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\">; j &lt; DIM; j++)<\/span><\/span><\/span><\/p>\n<p><span style=\"font-size: small;\"> <span style=\"color: #ff0000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"><b>for<\/b><\/span><\/span><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"> (<\/span><\/span><span style=\"color: #ff0000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"><b>int<\/b><\/span><\/span><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"> k = <\/span><\/span><span style=\"color: #0000ff;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\">0<\/span><\/span><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\">; k &lt; DIM; k++) {<\/span><\/span><\/span><\/p>\n<p><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"><span style=\"font-size: small;\"> c[i][j] += a[i][k] * b[k][j];<\/span><\/span><\/span><\/p>\n<p><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"><span style=\"font-size: small;\"> }<\/span><\/span><\/span><\/p>\n<p><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"><span style=\"font-size: small;\"> zeit2 = time(NULL);<\/span><\/span><\/span><\/p>\n<p><span style=\"font-size: small;\"><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"> printf(<\/span><\/span><span style=\"color: #800080;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\">&#8222;ijk: %f\\n&#8220;<\/span><\/span><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\">, difftime(zeit2, zeit1));<\/span><\/span><\/span><\/p>\n<p><span style=\"font-size: small;\"><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"> printf(<\/span><\/span><span style=\"color: #800080;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\">&#8222;%.0f\\n&#8220;<\/span><\/span><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\">, <\/span><\/span><span style=\"color: #004080;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\">2.0<\/span><\/span><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\">*DIM*DIM*DIM \/ difftime(zeit2, zeit1) \/ <\/span><\/span><span style=\"color: #004080;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\">1000000.0<\/span><\/span><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\">);<\/span><\/span><\/span><\/p>\n<p><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"><span style=\"font-size: small;\"> clear();<\/span><\/span><\/span><\/p>\n<p><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"><span style=\"font-size: small;\"> zeit1 = time(NULL);<\/span><\/span><\/span><\/p>\n<p><span style=\"font-size: small;\"> <span style=\"color: #ff0000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"><b>for<\/b><\/span><\/span><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"> (<\/span><\/span><span style=\"color: #ff0000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"><b>int<\/b><\/span><\/span><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"> j = <\/span><\/span><span style=\"color: #0000ff;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\">0<\/span><\/span><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\">; j &lt; DIM; j++)<\/span><\/span><\/span><\/p>\n<p><span style=\"font-size: small;\"> <span style=\"color: #ff0000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"><b>for<\/b><\/span><\/span><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"> (<\/span><\/span><span style=\"color: #ff0000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"><b>int<\/b><\/span><\/span><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"> i = <\/span><\/span><span style=\"color: #0000ff;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\">0<\/span><\/span><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\">; i &lt; DIM; i++)<\/span><\/span><\/span><\/p>\n<p><span style=\"font-size: small;\"> <span style=\"color: #ff0000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"><b>for<\/b><\/span><\/span><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"> (<\/span><\/span><span style=\"color: #ff0000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"><b>int<\/b><\/span><\/span><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"> k = <\/span><\/span><span style=\"color: #0000ff;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\">0<\/span><\/span><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\">; k &lt; DIM; k++) {<\/span><\/span><\/span><\/p>\n<p><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"><span style=\"font-size: small;\"> c[i][j] += a[i][k] * b[k][j];<\/span><\/span><\/span><\/p>\n<p><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"><span style=\"font-size: small;\"> }<\/span><\/span><\/span><\/p>\n<p><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"><span style=\"font-size: small;\"> zeit2 = time(NULL);<\/span><\/span><\/span><\/p>\n<p><span style=\"font-size: small;\"><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"> printf(<\/span><\/span><span style=\"color: #800080;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\">&#8222;jik: %f\\n&#8220;<\/span><\/span><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\">, difftime(zeit2, zeit1));<\/span><\/span><\/span><\/p>\n<p><span style=\"font-size: small;\"><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"> printf(<\/span><\/span><span style=\"color: #800080;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\">&#8222;%.0f\\n&#8220;<\/span><\/span><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\">, <\/span><\/span><span style=\"color: #004080;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\">2.0<\/span><\/span><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\">*DIM*DIM*DIM \/ difftime(zeit2, zeit1) \/ <\/span><\/span><span style=\"color: #004080;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\">1000000.0<\/span><\/span><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\">);<\/span><\/span><\/span><\/p>\n<p><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"><span style=\"font-size: small;\"> clear();<\/span><\/span><\/span><\/p>\n<p><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"><span style=\"font-size: small;\"> zeit1 = time(NULL);<\/span><\/span><\/span><\/p>\n<p><span style=\"font-size: small;\"> <span style=\"color: #ff0000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"><b>for<\/b><\/span><\/span><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"> (<\/span><\/span><span style=\"color: #ff0000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"><b>int<\/b><\/span><\/span><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"> i = <\/span><\/span><span style=\"color: #0000ff;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\">0<\/span><\/span><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\">; i &lt; DIM; i++)<\/span><\/span><\/span><\/p>\n<p><span style=\"font-size: small;\"> <span style=\"color: #ff0000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"><b>for<\/b><\/span><\/span><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"> (<\/span><\/span><span style=\"color: #ff0000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"><b>int<\/b><\/span><\/span><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"> k = <\/span><\/span><span style=\"color: #0000ff;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\">0<\/span><\/span><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\">; k &lt; DIM; k++)<\/span><\/span><\/span><\/p>\n<p><span style=\"font-size: small;\"> <span style=\"color: #ff0000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"><b>for<\/b><\/span><\/span><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"> (<\/span><\/span><span style=\"color: #ff0000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"><b>int<\/b><\/span><\/span><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"> j = <\/span><\/span><span style=\"color: #0000ff;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\">0<\/span><\/span><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\">; j &lt; DIM; j++) {<\/span><\/span><\/span><\/p>\n<p><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"><span style=\"font-size: small;\"> c[i][j] += a[i][k] * b[k][j];<\/span><\/span><\/span><\/p>\n<p><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"><span style=\"font-size: small;\"> }<\/span><\/span><\/span><\/p>\n<p><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"><span style=\"font-size: small;\"> zeit2 = time(NULL);<\/span><\/span><\/span><\/p>\n<p><span style=\"font-size: small;\"><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"> printf(<\/span><\/span><span style=\"color: #800080;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\">&#8222;ikj: %f\\n&#8220;<\/span><\/span><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\">, difftime(zeit2, zeit1));<\/span><\/span><\/span><\/p>\n<p><span style=\"font-size: small;\"><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"> printf(<\/span><\/span><span style=\"color: #800080;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\">&#8222;%.0f\\n&#8220;<\/span><\/span><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\">, <\/span><\/span><span style=\"color: #004080;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\">2.0<\/span><\/span><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\">*DIM*DIM*DIM \/ difftime(zeit2, zeit1) \/ <\/span><\/span><span style=\"color: #004080;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\">1000000.0<\/span><\/span><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\">);<\/span><\/span><\/span><\/p>\n<p><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"><span style=\"font-size: small;\"> clear();<\/span><\/span><\/span><\/p>\n<p><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"><span style=\"font-size: small;\"> zeit1 = time(NULL);<\/span><\/span><\/span><\/p>\n<p><span style=\"font-size: small;\"> <span style=\"color: #ff0000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"><b>for<\/b><\/span><\/span><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"> (<\/span><\/span><span style=\"color: #ff0000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"><b>int<\/b><\/span><\/span><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"> j = <\/span><\/span><span style=\"color: #0000ff;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\">0<\/span><\/span><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\">; j &lt; DIM; j++)<\/span><\/span><\/span><\/p>\n<p><span style=\"font-size: small;\"> <span style=\"color: #ff0000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"><b>for<\/b><\/span><\/span><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"> (<\/span><\/span><span style=\"color: #ff0000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"><b>int<\/b><\/span><\/span><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"> k = <\/span><\/span><span style=\"color: #0000ff;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\">0<\/span><\/span><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\">; k &lt; DIM; k++)<\/span><\/span><\/span><\/p>\n<p><span style=\"font-size: small;\"> <span style=\"color: #ff0000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"><b>for<\/b><\/span><\/span><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"> (<\/span><\/span><span style=\"color: #ff0000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"><b>int<\/b><\/span><\/span><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"> i = <\/span><\/span><span style=\"color: #0000ff;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\">0<\/span><\/span><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\">; i &lt; DIM; i++) {<\/span><\/span><\/span><\/p>\n<p><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"><span style=\"font-size: small;\"> c[i][j] += a[i][k] * b[k][j];<\/span><\/span><\/span><\/p>\n<p><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"><span style=\"font-size: small;\"> }<\/span><\/span><\/span><\/p>\n<p><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"><span style=\"font-size: small;\"> zeit2 = time(NULL);<\/span><\/span><\/span><\/p>\n<p><span style=\"font-size: small;\"><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"> printf(<\/span><\/span><span style=\"color: #800080;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\">&#8222;jki: %f\\n&#8220;<\/span><\/span><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\">, difftime(zeit2, zeit1));<\/span><\/span><\/span><\/p>\n<p><span style=\"font-size: small;\"><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"> printf(<\/span><\/span><span style=\"color: #800080;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\">&#8222;%.0f\\n&#8220;<\/span><\/span><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\">, <\/span><\/span><span style=\"color: #004080;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\">2.0<\/span><\/span><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\">*DIM*DIM*DIM \/ difftime(zeit2, zeit1) \/ <\/span><\/span><span style=\"color: #004080;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\">1000000.0<\/span><\/span><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\">);<\/span><\/span><\/span><\/p>\n<p><span style=\"font-size: small;\"><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"> printf(<\/span><\/span><span style=\"color: #800080;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\">&#8222;Ende&#8220;<\/span><\/span><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\">);<\/span><\/span><\/span><\/p>\n<p><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"><span style=\"font-size: small;\"> getchar();<\/span><\/span><\/span><\/p>\n<p><span style=\"font-size: small;\"> <span style=\"color: #ff0000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"><b>return<\/b><\/span><\/span> <span style=\"color: #0000ff;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\">0<\/span><\/span><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\">;<\/span><\/span><\/span><\/p>\n<p><span style=\"color: #000000;\"><span style=\"font-family: DejaVu Sans Mono, monospace;\"><span style=\"font-size: small;\">}<\/span><\/span><\/span><\/p>\n","protected":false},"excerpt":{"rendered":"<p>Als Erg&auml;nzung zu meiner kleinen Zusammenfassung der Schritte wie man einen Prozessor beschleunigt m&ouml;chte ich heute erg&auml;nzen, wie man den Speicher beschleunigt. Wie bei meinem ersten Aufsatz geht es dabei um Computerentwicklung allgemein und nicht nur um Mikroprozessoren, die meisten Technologien wurden sogar entwickelt, bevor es &uuml;berhaupt Mikroprozessoren gab.<\/p>\n","protected":false},"author":169,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_jetpack_memberships_contains_paid_content":false,"footnotes":""},"categories":[4],"tags":[3625,1926,1924,3602,1922,3596,4559],"class_list":["post-14918","post","type-post","status-publish","format-standard","hentry","category-computer","tag-arbeitsspeicher","tag-cache","tag-ddr-ram","tag-dram","tag-ram","tag-simd","tag-vilw","entry"],"a3_pvc":{"activated":false,"total_views":488,"today_views":0},"jetpack_featured_media_url":"","jetpack-related-posts":[{"id":18612,"url":"https:\/\/www.bernd-leitenberger.de\/blog\/2026\/03\/28\/galileos-cds-teil-2\/","url_meta":{"origin":14918,"position":0},"title":"Galileos CDS \u2013 Teil 2","author":"Bernd Leitenberger","date":"28. M\u00e4rz 2026","format":false,"excerpt":"So, heute geht es weiter mit Teil 2 \u00fcber Galileos CDS, dieser Beitrag schlie\u00dft nahtlos an den ersten Beitrag von gestern an, wie man schon an der ersten Textzeile sieht. Nach der Einleitung im ersten Teil geht es heute weiter damit warum der RCA 1802 genutzt wurde und was seine\u2026","rel":"","context":"In &quot;Raumfahrt&quot;","block_context":{"text":"Raumfahrt","link":"https:\/\/www.bernd-leitenberger.de\/blog\/category\/raumfahrt\/"},"img":{"alt_text":"","src":"https:\/\/vg07.met.vgwort.de\/na\/191e4b0728de42829cf656027b84dc82","width":350,"height":200},"classes":[]},{"id":18614,"url":"https:\/\/www.bernd-leitenberger.de\/blog\/2026\/03\/29\/galileos-cds-teil-3\/","url_meta":{"origin":14918,"position":1},"title":"Galileos CDS &#8211; Teil 3","author":"Bernd Leitenberger","date":"29. M\u00e4rz 2026","format":false,"excerpt":"So nun zum dritten Teil \u00fcber das prim\u00e4re Computersystem von Galileo, das CDS. Nachdem sich die ersten beiden Teile nur mit dem RCA 1802, warum er gew\u00e4hlt wurde und seiner Architektur befassten geht es heute um das Computersystem selbst. Der Artikel schlie\u00dft so an seine beiden Vorg\u00e4nger gestern und vorgestern\u2026","rel":"","context":"In &quot;Raumfahrt&quot;","block_context":{"text":"Raumfahrt","link":"https:\/\/www.bernd-leitenberger.de\/blog\/category\/raumfahrt\/"},"img":{"alt_text":"","src":"https:\/\/vg07.met.vgwort.de\/na\/6e7f572a246b4ac395de9c260733b707","width":350,"height":200},"classes":[]},{"id":18610,"url":"https:\/\/www.bernd-leitenberger.de\/blog\/2026\/03\/27\/galileos-cds-teil-1\/","url_meta":{"origin":14918,"position":2},"title":"Galileos CDS &#8211; Teil 1","author":"Bernd Leitenberger","date":"27. M\u00e4rz 2026","format":false,"excerpt":"Hall\u00f6chen, es wird Zeit das ich mich mal wieder melde. Es gab zwei Gr\u00fcnde, warum ich mich so rar gemacht habe. Das eine ist das es gerade nicht so viel aktuelles gibt, au\u00dfer einem Update zu Artemis, zu dem ich vielleicht noch etwas schreibe. W\u00e4hrend Trump das ganze Programm nach\u2026","rel":"","context":"In &quot;Raumfahrt&quot;","block_context":{"text":"Raumfahrt","link":"https:\/\/www.bernd-leitenberger.de\/blog\/category\/raumfahrt\/"},"img":{"alt_text":"","src":"https:\/\/vg07.met.vgwort.de\/na\/4fb81c7bafbd4d9d88b5695abdb33d29","width":350,"height":200},"classes":[]},{"id":18380,"url":"https:\/\/www.bernd-leitenberger.de\/blog\/2025\/09\/03\/die-glorreichen-10-das-war-mal-weg-pc-hardware\/","url_meta":{"origin":14918,"position":3},"title":"Die glorreichen 10 &#8211; Das war mal weg: PC Hardware","author":"Bernd Leitenberger","date":"3. September 2025","format":false,"excerpt":"Ich will heute mal zwei ZDF Info \/ Neo Sendungen verbinden. Die glorreichen 10, die bei mir als Vorlage f\u00fcr einige Blogs dienten und die von mir noch mehr gesch\u00e4tzte Sendung \"Das war mal weg\", wo es um Dinge geht, die fr\u00fcher fast jeder hatte und die heute aus unserem\u2026","rel":"","context":"In &quot;Die Glorreichen 10&quot;","block_context":{"text":"Die Glorreichen 10","link":"https:\/\/www.bernd-leitenberger.de\/blog\/category\/allgemein\/die-glorreichen-10\/"},"img":{"alt_text":"","src":"https:\/\/vg02.met.vgwort.de\/na\/876c61d389304d98aa0332fadd769381","width":350,"height":200},"classes":[]},{"id":5216,"url":"https:\/\/www.bernd-leitenberger.de\/blog\/2011\/08\/10\/fcea2\/","url_meta":{"origin":14918,"position":4},"title":"FCEA2","author":"Bernd Leitenberger","date":"10. August 2011","format":false,"excerpt":"CEA2 (Chemical Equilibrium with Applications) ist ein seit gut 30 Jahren entwickeltes NASA Programm mit dem verschiedenste Probleme bei Gasphasen berechnet werden k\u00f6nnen. Ich beschr\u00e4nke mich auf das, was Raumfahrtliebhaber wohl am meisten machen: Die Berechnung der Performance von Triebwerken bei Raketen. Ich will die Benutzung des Programmes einmal erl\u00e4utern,\u2026","rel":"","context":"In &quot;Raumfahrt&quot;","block_context":{"text":"Raumfahrt","link":"https:\/\/www.bernd-leitenberger.de\/blog\/category\/raumfahrt\/"},"img":{"alt_text":"","src":"https:\/\/vg01.met.vgwort.de\/na\/89efc24160614a1a93d97d19447e81a6","width":350,"height":200},"classes":[]},{"id":18511,"url":"https:\/\/www.bernd-leitenberger.de\/blog\/2026\/01\/27\/musks-ki-rechenzentren-im-orbit\/","url_meta":{"origin":14918,"position":5},"title":"Musks KI-Rechenzentren im Orbit","author":"Bernd Leitenberger","date":"27. Januar 2026","format":false,"excerpt":"Bei meinem regelm\u00e4\u00dfigen Besuch des Space Reviews stie\u00df ich auf diesen Artikel: SpaceX, orbital data centers, and the journey to Mars. Ich hatte in meiner Nachlese schon erw\u00e4hnt das Elon Musk, nachdem er dies lange verschoben hat nun plant SpaceX an die B\u00f6rse zu bringen. Ich meinte aber, das l\u00e4ge\u2026","rel":"","context":"In &quot;SpaceX&quot;","block_context":{"text":"SpaceX","link":"https:\/\/www.bernd-leitenberger.de\/blog\/category\/raumfahrt\/spacex\/"},"img":{"alt_text":"","src":"https:\/\/vg06.met.vgwort.de\/na\/0ee72da693054bc3b5c3f00214a7e2b3","width":350,"height":200},"classes":[]}],"jetpack_sharing_enabled":true,"amp_enabled":true,"_links":{"self":[{"href":"https:\/\/www.bernd-leitenberger.de\/blog\/wp-json\/wp\/v2\/posts\/14918","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.bernd-leitenberger.de\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.bernd-leitenberger.de\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.bernd-leitenberger.de\/blog\/wp-json\/wp\/v2\/users\/169"}],"replies":[{"embeddable":true,"href":"https:\/\/www.bernd-leitenberger.de\/blog\/wp-json\/wp\/v2\/comments?post=14918"}],"version-history":[{"count":0,"href":"https:\/\/www.bernd-leitenberger.de\/blog\/wp-json\/wp\/v2\/posts\/14918\/revisions"}],"wp:attachment":[{"href":"https:\/\/www.bernd-leitenberger.de\/blog\/wp-json\/wp\/v2\/media?parent=14918"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.bernd-leitenberger.de\/blog\/wp-json\/wp\/v2\/categories?post=14918"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.bernd-leitenberger.de\/blog\/wp-json\/wp\/v2\/tags?post=14918"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}