Wo sind wir angekommen? Also was haben wir jetzt vor Weihnachten noch vor? Ich möchte

also das Kapitel 2 noch abschließen. Das heißt, wir werden das jetzt mit diesem Ruflan-Modell

dann noch zu Ende bringen heute und dann auch noch mal darauf eingehen, wie jetzt die Dinge,

die wir bisher gelernt haben, auch aus dem Kapitel 2.1, sich dann widerspiegeln in modernen

Architekturen und dazu machen wir dann einen kleinen Überblick, wie sich das von der Core2

Architektur, also angefangen eigentlich mehr von der Halem, da gehe ich eher darauf ein,

also schon von diesen Core IX Architekturen bis zur Haswell Architektur weiterentwickelt hat und geht

dann am Ende bei der Haswell Architektur nochmal etwas auf dieses neue Konzept, was jetzt da in

diesen Mikroarchitekturen enthalten ist, nämlich den Transactional Memory. Gut, ja dann, ich hatte

letztes Jahr dann noch AMD Prozessoren, die Pulte aus der Mikroarchitektur drin, ich glaube,

die lasse ich weg, weil nächste Woche will ich dann eigentlich zu den Grafikkarten kommen und

nochmal zu den Ficern Architekturen und nach Weihnachten dann soll eigentlich, wird es dann

einen kleinen Umstieg geben, auch bei den Übungen. Hat der Max mit Ihnen schon Grafikkarten gemacht?

Noch nicht, okay, das wäre vielleicht nächste Woche, vielleicht noch die erste Woche nach Weihnachten und

dann muss man schauen, weil dann soll der Mark Reichenbach einsteigen und dann ziehen wir das

Kapitel 4, was ich in den vergangenen Jahren, das sind die eingebreteten Prozessoren habe,

das wollen wir zu wenig Platz, das ziehen wir dann vor, machen das jetzt zum Kapitel 3,

dann haben sie da mehr Platz und tatsächlich dann auch mal im FPGA und durch Simulation eigene,

in Anführungsstriche Multikernarchitekturen zu entwerfen werden. Jetzt bis jetzt haben sie in

Übungen halt auf bestehende aufgesetzt und dann sollen sie ja selber mal im vorgegebenen Rahmen

welche entwickeln. So, also wir sind jetzt hier angekommen bei dieser, bei der grafischen,

bei dem Ruflaunmodell und das nochmal kurz zu wiederholen. Das Ruflaunmodell sieht also

folgendermaßen aus, ich habe hier so eine Dachkennlinienstruktur und je nachdem hier

auf der x-Axis aufgetragen, also die arithmetische Intensität, die wird nochmal gemessen in Flops pro

Byte, also wie viele Fließkummeroperationen kann ich auf dem Byte, das was ich mal aus dem Speicher

geholt habe, anwenden und je nachdem, wenn ich weiter rechts hier bin, ist mein Kern, also der

Ausschnitt, der die wesentliche Rechenzahl verursacht, das Compute Bound, also durch die

Berechnung begrenzt, das heißt ich bin am vollen Anschlag, mehr geht hier nicht und wenn ich weiter

links bin, das heißt ich rechne nicht so viel auf diesen Byte, die ich aus dem Speicher geholt habe,

dann bin ich ja durch die Speicherbandbreite begrenzt, das heißt meine Kerne könnten mehr

arbeiten, wenn sie es denn schaffen würden, bzw. wenn sie denn mit genügend Daten versorgt

werden würden, das ist der entscheidende Punkt. Die werden dann also nicht mit ausreichend Daten

versorgt und hängen sozusagen in der Luft. So und das hat man also schon bestimmt, ach ja genau,

die Schräge hier, die sagt dann auch etwas aus, wie gut die Speicherbandbreite ist und das kann man

sich dann mathematisch überlegen, wenn ich einfach die arithmetische Intensität, also gegeben in

Flops pro Byte, Multipliz, Flops pro Byte, rauskommen müssen Byte pro Sekunde und das Ganze mit der,

genau, die Steigung mir ausrechne und je besser die Bandbreite ist, umso höher, umso mehr Flops pro

Sekunde kann ich erreichen und das heißt also je steiler das Ganze, genau, wenn ich dann hier

eins hätte, dividiere ich durch die eins so rum und dann kann ich hier genau ablesen, wie viel Bytes

pro Sekunde ich übertragen kann. Das heißt also, um diese Schräge hier zu ermitteln vom Ruhflaut-Modell

muss ich mir halt ausrechnen, zum Beispiel mit dem Stream Benchmark kann ich messen, was ist meine

maximale Speicherbandbreite, die möglich ist und dann trage ich bei der eins genau den Wert hier

an, dann steht hier drüben halt nicht Gigaflop pro Sekunde, sondern die Flops haben sich dann sozusagen

rausgekürzt und dann muss ich das so interpretieren, dass der Wert an der Y-Axis

den Bytes pro Sekunde entspricht und die Gerade hier, die bekomme ich eben raus,

dadurch dass ich den maximalen Anschlag ausrechne, also was möglich wäre, das heißt aus der Takt-

frequenz und aus der Anzahl der Operationen, die ich im Maximalfall heraus bekomme, aus der

Maximalanzahl der Kerne, kann ich dann ausrechnen, wie viele Flops ich theoretisch erreichen könnte,

wenn meine Kerne immer voll am Anschlag sind und alle Superskalaneinheiten sozusagen voll

am Anschlag sind und ständig pro Takt ein Datum produzieren, was in der Regel nicht passieren wird.