Stoffsammlung Technische Informatik Issenn.de/files/Formeln_tik1.pdf · Einführung in C Aufbau eines Source-Files Jedes Source-File ist wie folgt aufgebaut: Man beachte, dass bei

StoffsammlungTechnische Informatik I

von Stephan Senn, D-ITET

InhaltsverzeichnisEinführung in C.................................................................................................................. 3

Aufbau eines Source-Files............................................................................................... 3Externe Deklaration.......................................................................................................... 3Pointer.............................................................................................................................. 3Arrays............................................................................................................................... 4

Komponenten eines Rechnersystems............................................................................. 4Neumann-Zyklus................................................................................................................. 4Aufbau des MIPS-R3000-Prozessors................................................................................ 5

Schematischer Aufbau..................................................................................................... 5Register............................................................................................................................ 5Instruktionskodierung....................................................................................................... 5Adressierungsarten.......................................................................................................... 6Datenformate................................................................................................................... 6

Big Endian / Little Endian..........................................................................................................................7MIPS Assemblerprogrammierung..................................................................................... 7

Aufruf von Unterprogrammen........................................................................................... 7Warum müssen die Register gesichert werden?......................................................................................7Vereinbarung zwischen Caller und Callee................................................................................................8Wie wird der Stack gegliedert?.................................................................................................................8Wie erfolgt nun die Sicherung der Register bei einem Unterprogrammaufruf?........................................9

Unterbrechungen (Interrupts)......................................................................................... 10Assemblerbefehle.......................................................................................................... 11

Instruktionssätze.............................................................................................................. 11Klassifikation nach Ort der Operanden und des Resultats............................................ 11Anzahl von Adressierungsarten..................................................................................... 12Instruktionslänge............................................................................................................ 12

Bewertung der Rechenleistung...................................................................................... 12Schichtenmodell eines Rechnersystems....................................................................... 13I/O-Einheit......................................................................................................................... 14

Schema ......................................................................................................................... 14IO-Arten.......................................................................................................................... 14Producer-Server-Modell................................................................................................. 14Busse............................................................................................................................. 14

Master-Slave-Verfahren..........................................................................................................................14Vor- und Nachteile..................................................................................................................................14Synchronisation......................................................................................................................................15Übertragungsmechanismen....................................................................................................................15Hohe Leistung versus geringe Kosten....................................................................................................15Arbitrierung.............................................................................................................................................15Arbitrierungsverfahren............................................................................................................................16

Polling / Interrupt driven................................................................................................. 16Direct Memory Access (DMA)........................................................................................ 16Memory Mapped IO....................................................................................................... 17

Anforderungen an das Betriebssystem (BS)................................................................. 17Rechnerarchitektur.......................................................................................................... 17

Datenpfad und Kontrollpfad........................................................................................... 17

Stephan Senn, D-ITET -1- 06.08.04

Grundkonzepte............................................................................................................... 17Instruktionsverarbeitung................................................................................................. 18

Überblick.................................................................................................................................................18Einzyklenverarbeitung: Single Cycle......................................................................................................18Mehrzyklenverarbeitung: Multiple Cycle.................................................................................................18Pipelineverarbeitung: Pipelining..............................................................................................................19

Hazards.......................................................................................................................... 21Struktureller Hazard................................................................................................................................21Daten-Hazard..........................................................................................................................................21Ablauf-Hazard.........................................................................................................................................21

Vermeidung von Hazards............................................................................................... 21Vermeidung von Hazards durch den Compiler.......................................................................................21Vermeidung von Daten-Hazards durch Forwarding...............................................................................22Vermeidung von Ablauf-Hazards............................................................................................................23Vermeidung von Hazards durch Stalls...................................................................................................23

Synchrone Digitalschaltungen........................................................................................ 23Shortest Path Delay (SPD)............................................................................................ 23Longest Path Delay (LPD)............................................................................................. 23Setup Time, Hold Time, ClkToQ.................................................................................... 24Clock Period................................................................................................................... 24

Mikroprogrammierung..................................................................................................... 24Funktionsweise.............................................................................................................. 24

Kontrollflussgraphen und Datenpfade........................................................................... 25Datenabhängigkeitsgraph.............................................................................................. 25Kontrollflussgraph.......................................................................................................... 26Datenpfad...................................................................................................................... 26Vom Kontrollflussgraph, Datenpfad zum Automat......................................................... 28

Speicherhierarchie........................................................................................................... 29Schema.......................................................................................................................... 29Zugriffszeit einer Harddisk............................................................................................. 29Lokalität.......................................................................................................................... 29Caching.......................................................................................................................... 29

Aufbau.....................................................................................................................................................30Funktionsweise.......................................................................................................................................30Datenkonsistenz.....................................................................................................................................32

Quellenverzeichnis........................................................................................................... 32


Einführung in C

Aufbau eines Source-FilesJedes Source-File ist wie folgt aufgebaut:

Man beachte, dass bei reinem C die Deklarationen jeweils ausserhalb einer Schleife definiertwerden müssen.int i;for(i=0;i<10;i++){...}

Externe DeklarationDie externe Deklaration mit dem Schlüsselwort extern einer Variablen oder Funktion teilt demCompiler mit, dass sie in einem anderen Modul definiert wurden.File a.c...int global=0;int func(int n);...int func(int n){...}...

File b.c...extern int global;extern int func(int n);...Mit Hilfe des Schlüsselwortes extern lässt sich auch Assemblercode in bestehenden C-Codeintegrieren. Es gilt:File m.c...extern skalar(int* a, int* b, int n);...

File k.s (Assemblerfile)# Das Register a0 enthält die Adresse von a.# Das Register a1 enthält die Adresse von b.# Das Register a2 enthält den Wert von n.....globl skalar...

PointerEs gilt:


int *p, *q;int a=3, b;p=&a;b=*p+1;q=(int*)0x8010;

Pointer auf IntegervariablenPointer p auf Adresse von a referenzierenPointer p dereferenzieren: b=a+1Adresse 0x8010 dem Pointer q zuweisen

int n[]={'a','b','c'};int *k;k=n;k=&(n[0]);char b=*k;k++;b=*k;

Referenzierungb=n[0]Zeiger auf nächstes Element im Array legenb=n[1]

ArraysEs gilt:int n[]={1,2,3,4}int c[]={'a','b','c'};int e[]=“de“ Dasselbe wie e[]={'d','e','\0'}.

Komponenten eines RechnersystemsEin Rechnersystem besteht im allgemeinen aus folgenden Komponenten:

Neumann-ZyklusDer Neumann-Zyklus lautet:

1. Instruktion aus dem Hauptspeicher holen.

2. Instruktion dekodieren.

3. Operanden aus dem Hauptspeicher oder von den Registern holen.

4. Instruktion ausführen.

5. Resultat der Instruktion im Hauptspeicher oder in Register abspeichern.

6. Nächste Instruktion beginnen. (Gehe zu Schritt 1!)


Aufbau des MIPS-R3000-Prozessors

Schematischer Aufbau

Register

InstruktionskodierungJede Instruktion ist 32Bit lang. Es gibt 3 Instruktionstypen:


AdressierungsartenDer MIPS-Prozessor unterstützt 4 Adressierungsarten:

• Registeradressierung (Typ I, J, R): Der Operand der Instruktion ist ein Register.

z.B. add $t2,$t1,$t2• Direkte Adressierung (Typ I, J): Der Operand ist eine Konstante.

z.B. addi $t2,$t1,2• Basisadressierung (Typ I): Der Operand ist im Speicher. Die Speicheradresse wird mit Hilfe

dem Inhalt eines Registers und einem Offset bestimmt. Es gilt: Adresse=RegisterOffset .

z.B. sw $s0,4($sp) # mit Offset 4• PC-relative Adressierung (Typ I, J): Der Operand ist im Speicher. Die Speicheradresse wird

mit Hilfe des Programmzählers PC und einem Offset bestimmt. Es gilt:Adresse=PCOffset .

z.B. lw $s1,8($pc) # mit Offset 8Bemerkung:

Man beachte, dass ein Word 32 Bit (4 Bytes) hat. Dies entspricht also einem Offset von 4, weiljeder Speicherplatz aus 8 Bit, also 1 Byte, besteht.

DatenformateDer MIPS-Prozessor verwendet die Big-Endian-Konvention und besitzt folgende Datenformate:

• Byte: 8 Bit

• Halfword: 16 Bit

• Word: 32 Bit


Big Endian / Little Endian

MIPS Assemblerprogrammierung

Aufruf von Unterprogrammen

Warum müssen die Register gesichert werden?Der Aufruf von Unterprogrammen (Prozeduren, Funktionen) beinhaltet einige Schwierigkeiten. Einaufgerufenes Unterprogramm überschreibt bisher gebrauchte Register. Deshalb ist es nötig, dieseRegister im Memory zu sichern. Die Sicherung erfolgt aber nicht irgendwo im Memory, sondern ineinem bestimmten Bereich, der Stack genannt wird. Der Stackpointer ($sp) zeigt auf den erstenfreien Platz im Stack. Man muss vorausschicken, dass der Stack bei der höchsten Adresse beginntund demenstprechend bei der kleinsten endet. Der folgende Code speichert das Register $t0 bei $spund setzt den Stackpointer auf den nächst freien Platz:sw $t0,0($sp) addi $sp,$sp,-4Die Null im ersten Ausdruck beschreibt den Offset zur Basisadresse $sp. 4($sp) bedeutet also:$sp+4.

Es ist nun klar, dass der Aufruf eines Unterprogramms in einem Hauptprogramm oder in einemanderen Unterprogramm (bei Rekursion) die Sicherung der Register auf dem Stack verlangt. DieSicherung kann sich im Prinzip auf alle Register erstrecken. Wichtig dabei ist folgender Grundsatz:

Wird ein Register durch den Aufruf von Unterprogrammen mehrmals überschrieben bzw.von verschiedenen Unterprogrammen gemeinsam benutzt, dann muss es auf dem Stackgesichert werden. Dasselbe gilt natürlich für das Hauptprogramm, das ein Unterprogrammaufruft.


msb lsb……msb: most significant bytelsb: least significant byte

Word

Vereinbarung zwischen Caller und CalleeDas aufgerufene Unterprogramm wird Callee genannt. Die Unterprogramme oder dasRahmenprogramm, das die Unterprogramme aufruft, wird Caller bezeichnet. Zwischen Caller undCallee gibt es eine Vereinbarung über die gemeinsame Nutzung der Register. Die temporärenRegister können vom Callee vorbehaltlos benutzt werden. Denn sie sind schliesslich temporär undder Callee kann davon ausgehen, dass der Caller sie nicht mehr benötigt. Der Caller muss also dieWerte in den temporären Registern vorab sichern, sollte er einige Register auch nach Beendigungdes Callees brauchen. Anders sieht es bei den sicheren Registern aus. Der Caller erwartet vomCallee, dass die sicheren Register nicht verändert werden. Für den Callee bedeutet dies, dass jedeÄnderung dieser Register mit einer Sicherung verbunden ist. Der Callee kann also diese Registerbenutzen, muss aber deren Anfangswerte sichern. Die Rücksprungadresse muss nur dann vomCallee gesichert werden, wenn der Caller selbst ein Unterprogramm ist. Dies ist meist beirekursiven Strukturen der Fall. Schwierig wird die Regelung bei den v- und a-Registern.Normalerweise sind diese Register für den Caller zum Zeitpunkt eines Unterprogrammaufrufs vongeringem Interesse. Schliesslich werden die v-Register ja erst am Ende eines Programms benötigt.Die a-Register werden aber vorallem bei rekursiven Strukturen schon zu Beginn einesUnterprogrammaufrufs verwendet und müssen, sofern ein neuer Unterprogrammaufruf bevorsteht,gesichert werden. Generell geht man bei diesen Registern wie bei temporären Registern vor. DerCaller sichert diese Register und der Callee geht davon aus, dass er darüber frei verfügen kann.

Wie wird der Stack gegliedert?Da ein Hauptprogramm mitunter verschachtelte Unterprogramme beinhaltet, ist es notwendig, denStack klar zu gliedern. Dies geschieht einerseits mit Hilfe des Stackpointers, der immer auf eineleere Stelle im Stack zeigt, und andererseits durch einen sogenannten Framepointer $fp, der immerauf den Anfang eines Sicherungsblocks zeigt. Der Sicherungsblock eines Haupt- oderUntergprogramms besteht also aus einem bestimmten Bereich des Stacks, einem Rahmen, den manFrame bezeichnet. Es ist nun anschaulich klar, dass die Sicherung des Framepointers für den Sprungvon Sicherungsblock zu Sicherungsblock unentbehrlich ist. Daneben existiert ein optionalerglobaler Pointer $gp, den man im Prinzip beliebig setzen kann. Er zeigt aber per Definition auf denstatischen Memorybereich und kann deshalb als Adresspointer für Speicheroperationen verwendetwerden. Die folgende Darstellung zeigt die Verwendung des Stack- und des Framepointers:


$fp

$t0

$fp

$sp

High Address

Low Address

points to nothing,$zero

Frameaddi $sp,$sp,-4

addi $sp,$sp,+4

-

+

points to first element

points to first element

$fp

$t0

$t0

Wie erfolgt nun die Sicherung der Register bei einem Unterprogrammaufruf?Sicherung der Register beim Caller und Sprung zum Unterprogramm: Teil I1. Sind die a- und v-Register bereits durch den Caller belegt und ist davon auszugehen, dass der

Caller die Werte dieser Register nach dem Aufruf des Unterprogramms braucht, dann sind dieseRegister auf dem Stack zu sichern.

2. Die neuen Funktionsargumente für das Unterprogramm werden in die a-Register geschrieben($a0 - $a3). Sind mehr als vier Argumente vorhanden, dann werden die restlichen Argumente aufdem Stack gespeichert.

3. Anschliessend werden die Werte in jenen temporären t-Register gesichert, die der Caller nachdem Aufruf des Unterprogramms weiter braucht.

4. Mit der Instruktion jal wird die Rücksprungadresse im Register $ra gespeichert und dasProgramm verzweigt zur ersten Zeile des Unterprogramms. Die Rücksprungadresse ist dieAdresse der nächsten Programmzeile des Callers.

Unterprogrammaufruf: Teil II5. Nun erfolgt das Allozieren von Speicher auf dem Stack. Ein neuer leerer Sicherungsblock, Frame

genannt, wird dadurch angelegt. Dies zeigt die folgende Abbildung:

6. Die Rücksprungadresse im Register $ra muss nur dann gespeichert werden, wenn dasUntergprogramm wiederum ein anderes Unterprogramm aufruft, wie dies bei Rekursion der Fallist.

7. Der Framepointer muss auf jeden Fall auf dem Stack gesichert werden. Er zeigt immer auf denAnfang eines Frames. Meist zeigt der gesicherte Framepointer nicht auf den Anfang des eigenenFrames, sondern auf den Anfang eines Nachbarframes. Dies ist umso wichtiger, wenn Werte ausdem Nachbarframe verwendet werden. Dies kann vorallem bei rekursiven Strukturen besondersvon Interesse sein.

8. Nun erfolgt das Sichern der sicheren s-Register auf dem Stack, sofern solche Register verwendetwerden.

9. Nun muss noch der Framepointer nachgeführt werden. Er zeigt immer auf den Anfang desFrames.

Unterprogramm ausführen:10....

Unterprogramm beenden: Teil III11.Resultate werden in den v-Registern gespeichert.12.Der Framepointer wird zurückgespeichert.13.Die Rücksprungadresse wird, sofern nötig, zurückgespeichert.14.Die sicheren s-Register werden zurückgespeichert. Sind die v-Register von dieser Massnahme

auch betroffen, dann müssen die Resultate des Unterprogramms in temporären Registerngespeichert werden. In diesem Fall muss mit dem Caller eine Absprache getroffen werden.


High Address

Low Address

allocated memoryon stack (empty)

$sp

15.Nun wird der Speicher des Stacks wieder freiegegeben. Der Frame wird damit aufgelöst. Manspricht in diesem Zusammenhang auch vom Deallozieren von Stackspeicher.

16. Nun erfolgt der eigentliche Rücksprung vom Callee zum Caller. Dies geschieht mit dem Befehljr $ra.

Rückspeicherung der Register beim Caller: Teil IV17.Die temporären t-Register werden zurückgespeichert.18.Der Caller kann nun sein Programm fortsetzen. ...

Die folgende Abbildung zeigt die Teilabschnitte im Gesamtkontext:

Für die Rückspeicherung gilt der alte Grundsatz:First in – Last out! / Last in – First out!

Unterbrechungen (Interrupts)Ausnahmen (Exceptions) wie z.B. Division durch Null (arithmetische Ausnahme), u.a. resultierenin abrupten Unterbrüchen des Programmablaufs. Der MIPS-Prozessor behandelt Unterbrüche wiefolgt:

1. Der folgende Programmzähler PC wird im speziellen Register EPC gesichert.

2. Der Programmzähler PC wird nun auf eine spezielle Adresse gesetzt.

3. Weitere Unterbrechungen werden durch das Setzen des globalen Maskierungsbits im Status-Register (Bit 0) verhindert.

4. Im Cause-Register wird die Ursache der Unterbrechung festgehalten.

5. Das Betriebssystem ist nun bemüht, ein Unterprogramm zur Behandlung der Unterbrechung zurVerfügung zu stellen. An der speziellen Adresse wird ein Handler des Betriebssystemsaufgerufen, der abhängig von der Unterbrechung entscheidet, welches Unterprogramm gestartetwerden muss, um die nötigen Schritte einzuleiten (z.B. Register setzen, Programm beenden,usw.).

6. Nach der Behandlung der Unterbrechung, wird der Programmzähler PC aus dem EPC-Registergeholt und das Programm kann fortgesetzt werden; sofern dies das Betriebssystem zulässt.


Caller

CalleePart I

Part II

Code

Code

Code

Part III

Part IV

Operationson Stack

AssemblerbefehleDie wichtigsten Assemblerbefehle sind:

Alle Assemblerbefehle sind im Anhang des Buches 'Computer Organization & Design' vonPatterson und Hennesy auf Seite A-10ff aufgelistet und beschrieben.

InstruktionssätzeInstruktionssätze unterscheiden sich aufgrund ihrer Formate und Kodierungen. Zudemunterscheiden sie sich im Datenformat; also wie die Daten im Speicher abgelegt werden.

Klassifikation nach Ort der Operanden und des Resultats• Akkumulator: nur ein Register für arithm. Operationen, übrigen Operanden im Hauptspeicher

• Kellerspeicher: keine Register, nur Operationen auf den obersten Speicherpositionen


• Spezifische Register: zusätzlich Register vorhanden, Operanden im Hauptspeicher oder inRegistern

• Speicher-Speicher: alle Operanden im Hauptspeicher

• Register-Register: alle Operanden in Registern

Anzahl von Adressierungsarten• Instruktionssätze mit wenig Adressierungsarten: Wenn einfache Hardware aufgrund kurzer

Programmausführungszeit (kurze Taktperiode) gefordert wird, dann versucht man, mit möglichstwenig Adressierungsarten auszukommen.

• Instruktionssätze mit vielen Adressierungsarten: Wenn die Ausführung von komplexen,wiederkehrenden Programmabläufen schnell und effizient erfolgen soll, so ist man bemüht, dieAdressierungsarten auszudehnen. Dies hat den Vorteil, dass für komplexe Codesegmentespezielle Instruktionen zur Verfügung gestellt werden können (z.B. Grafikinstruktionen).

Instruktionslänge• Variable Länge: Wenn die Länge der Instruktion von Bedeutung ist, dann wird man variable

Instruktionslängen bevorzugen.

• Feste Länge: Ist die Rechenzeit von grosser Bedeutung, dann wählt man vorwiegend festeLängen.

Bewertung der RechenleistungFür die Ausführungszeit gilt allgemein:

CPU Time= SecondsProgram

= InstructionsProgram

×Clock CyclesInstruction

× SecondsClock Cycle

Für die Einheit MIPS (Million Instructions Per Second) gilt:

MIPS= Instruction countExecutionTime×106

= Instruction countProgram×106

× 1CPU Time

Daneben gibt es noch die Einheit MFLOPS (Million FLoat Operations Per Second).

Weiter gilt:

CPI: Cycles per Instruction, mittlere Anzahl der Takte pro Instruktion

n: Zahl der unterschiedlichen Instruktionsarten im Instruktionssatz

CPIi: Anzahl der Takte für Instruktionsart i

Fi: Anteil der Instruktionsart i an der Gesamtzahl der Instruktionen

Ni: Anzahl der Instruktionen der Instruktionsart i im Programm

N: Gesamtzahl der Instruktionen im Programm

CPI=∑i=1

n

CPI i×F i , F i=N i

N


Für die Einflussfaktoren gilt dann:

Instruktionen proProgramm

CPI Taktdauer

Programm x x

Compiler x x

Instruktionssatz x x x

Rechnerarchitektur x x

Technologie x

Schichtenmodell eines RechnersystemsFür das Schichtenmodell eines Rechnersystems gilt:

Höhere Programmiersprache CompilerAssemblersprache AssemblerMaschinensprache MaschineninterpreterMikroprogrammsprache Funktionseinheiten

Für die Softwareschichten gilt:

• Compiler: Übersetzung eines Programms in einer Hochsprache in Assemblercode

• Assembler: Übersetzung eines Programms in Assemblersprache in ein Objektprogramm

• Binder (Linker): Der Binder setzt das Programm, bestehend aus Ojektdateien (auch Modulegenannt) und nicht aufgelösten Querbezügen und Marken in ein ausführbares Programmzusammen. Dazu müssen alle undefinierten Marken und Querbezüge aufgelöst werden. Zudemwerden Teilprogramme aus Bibliotheken ersetzt. Der Binder berechnet weiter denSpeicherbedarf jeder Objektdatei und errechnet so den absoluten Speicherbedarf des Programms.Nicht aufgelöste relative Speicheradressen können so bestimmt werden.

• Lader (Loader): Aus dem Header des Programms wird die Grösse des Programmtexts und derDaten ermittelt. Dann wird ein Adressbereich für den Programmtext, die Daten und den Stackfreigegeben. Anschliessend wird der Programmtext und die Daten in den Adressbereich kopiert.Die Argumente des Programms werden in den Stack kopiert. Die Maschinenregister werdeninitialisiert. Nun wird ein Startprogramm ausgeführt, das die Argumente vom Stack in dieMaschinenregister speichert und zur main-Routine des Programms springt.

Für weitere Informationen siehe Anhang A im Buch 'Computer Organization & Design' vonHennessy und Patterson.


I/O-Einheit

Schema

IO-Arten• Transaktions-I/O: hohe Anzahl Zugriffe pro Zeiteinheit

• File-I/O: grosse Datenmenge pro Zeiteinheit

• Ereignis-I/O: kurze Reaktionszeit; hohe Anzahl verarbeiteter Ereignisse pro Zeiteinheit

Producer-Server-ModellZwischen Producer und Server existiert ein Buffer (z.B. Warteschlange), der für Anpassung sorgt.

Busse

Master-Slave-VerfahrenDer Master beginnt die Bustransaktion indem er den Bus für sich reserviert und an den Slave diegewünschte Adresse anlegt. Das Anlegen der Adresse geschieht über den Adressbus. Somit wird dergewünschte Slave aktiviert, während die anderen deaktiviert sind. Steuer- und Datenbus sindnormalerweise voneinander getrennt.

Vor- und Nachteile

Vorteile: Nachteile:• vielfältig einsetzbar: Der Bus kann ganz

verschiedene Komponenten bedienen.

• erweiterbar mit neuen Komponenten

• billig

• Flaschenhals in der Kommunikation: Allesläuft über eine Leitung!

• Geschwindigkeit wird durch die langsamsteEinheit am Bus vorgegeben

• muss sehr unterschiedliche Einheitenunterstützen


Synchronisation• asynchron: Die Transaktionen müssen mittels Handshaking-Protokollen aufeinander

abgestimmt werden. Dies geschieht mit Hilfe einer speziellen Logik. Dazu werden Steuersignalewie ACK und NACK verwendet. Der grosse Vorteil besteht nun darin, dass Verzögerungszeitenkeine grosse Rolle spielen und damit Geräte mit ganz unterschiedlichen Verzögerungszeitenbedient werden können.

• synchron: Alle Transaktionen sind taktgesteuert (z.B. nur bei steigender Flanke). Alle Geräte amBus arbeiten im Gleichtakt.

Übertragungsmechanismen• Geteilte Übertragung: Der Bus überträgt Daten in mehreren Teilen.

• Blockübertragung: Der Bus überträgt mehrere Dateneinheiten (Blöcke) auf einmal. Der Buswird erst wieder freigegeben, wenn alle Daten übermittelt wurden.

Hohe Leistung versus geringe Kosten

Forderung nach... hoher Leistung: geringen Kosten:Sychronisation synchron (vorausgesetzt, die

Taktverschiebung ist klein)asynchron

Busbreite separate Adress- und Datenleitungen multiplexen von Adress- undDatenleitungen

Datenbreite mehrere Bytes können pro Buszyklusübertragen werden

enger ist billiger

Blockgrösse Übertragung mehrer Worte pro Transaktionreduziert Verluste durch Protokoll

Einzelwortübertragung ist billiger

Busmaster mehrere Master (erfordert Arbitrierung) ein Master (keine Arbitrierungerforderlich)

Geteilte Übertragung getrennte Anforderungs- undÜbertragungstransaktionen (erfordertArbitrierung)

Anforderung und Übertragung in einerTransaktion

ArbitrierungUnter Arbitrierung versteht man das Zuteilen des Buses an einen bestimmten Master. Wennmehrere Geräte gleichzeitig Master sind, dann braucht es eine Kontrolleinheit, Arbitrierungseinheitoder Arbiter genannt, die entscheidet welcher Master den Bus für sich beanspruchen darf. DieArbitrierung läuft im wesentlichen wie folgt:

1. Mehrere Busmaster signalisieren dem Arbiter, dass sie den Bus für sich beanspruchen wollen(Request).

2. Der Arbiter wählt nach einem bestimmten Kritierium einen davon aus und signalisiert demBusmaster, dass er den Bus nun verwenden kann (Grant).

3. Nach Beendigung der Transaktion signalisiert der Busmaster dem Arbiter, dass seine Transaktionbeendet ist.


Arbitrierungsverfahren• Daisy Chain Arbitrierung: Die Arbitrierung erfolgt von der höchsten zur niedrigsten Priorität.

Der Arbiter reicht die Priorität von Gerät zu Gerät weiter. Ein Gerät mit einer hohen Prioritätklemmt ein Gerät mit niedrigerer Priorität ab. Somit ist keine faire Verteilung möglich.

• Zentrale oder parallele Arbitrierung: Die Geräte signalisieren Busanfragen, die von einemzentralen Arbiter nach einem bestimmten Schema abgearbeitet werden. Der Arbiter aktiviertdann nacheinander die betreffenden Geräte.

• Verteilte Arbitrierung durch Selstselektion: Hier ist kein Arbiter notwendig. Jeder Master hateine bestimmte Priorität, die er auf einen bestimmten Steuerbus anlegt. Der Master mit derhöchsten Priorität erhält den Bus.

• Verteilte Arbitrierung durch Kollisionserkennung: Die Geräte signalisieren, dass sie den Busfür sich beanspruchen wollen. Nur dasjenige Gerät, dessen Anfrage zuerst eintrifft, erhält dieFreigabe. Die übrigen Geräte versuchen dann weiter, den Bus für sich zu beanspruchen. Esherrscht also ein ständiger Zugangskampf. Wenn mehrere Anfragen gleichzeitig eintreffen, danntritt ein Kollisionsproblem auf, das mit einem Kollisionsprotokoll geregelt wird.

Polling / Interrupt driven• Polling: Der Prozessor fragt bei jedem Taktzyklus Statusbits von IO-Geräten ab. Damit ist

sichergestellt, dass der Prozessor seine Arbeit verrichten kann und dass die IO-Geräte bedientsind. Dies kann aber mitunter viel Rechenzeit verschwenden. Geräte, die nur selten aktiviertwerden oder die eine sehr langsame Reaktionszeit (langsamer Schreib- oder Leseprozess)aufweisen, sollten nicht gepollt werden, da der Prozessor unnötig pollt und damit Rechenzeitverschwendet.

• Interrupt driven: Das IO-Gerät unterbricht die Abarbeitung eines Prozesses mittelsSignalisierung eines Interrupts. Die Tätigkeit des Prozessors wird unterbrochen. DieUnterbrechungsbehandlungsroutine des Betriebssystem wird in Gang gesetzt. Der Prozessorwidmet seine Tätigkeit nun dem IO-Gerät. Nach Beendigung der IO-Anfrage, wird derunterbrochene Prozess wieder fortgesetzt. Interrupt driven ist dort zu vermeiden, wo dauernd IO-Anfragen anfallen. Der Prozessor wird dann unnötig oft unterbrochen, was sich die Rechenzeitunnötig verlangsamt, da Unterbrechungen mit einem gewissen Overhead verbunden sind.

Direct Memory Access (DMA)Es wird schnell klar, dass der Prozessor unnötig viel Rechenzeit verschwenden würde, wenn alleIO-Anfragen über den Prozessor abgewickelt würden. Um den Prozessor zu entlasten, führt maneine spezielle Kontrolleinheit ein, den Direct Memory Access-Controler, kurz DMA-Controler.Dieser hat die Aufgabe, den Lese- und Schreibprozess der IO-Geräte abzuwickeln. Dies geschiehtwie folgt:

1. Der Prozessor wird durch eine IO-Anfrage unterbrochen und übergibt die IO-Anfrage an denDMA-Controler. Der Prozessor übergibt dabei dem DMA-Controler die nötigen Informationen,um eine Transaktion zu tätigen.

2. Der DMA-Controler wartet auf die Arbitrierung des Buses und setzt die Transaktion mit dembetreffenden IO-Gerät in Gang.

3. Der DMA-Controler unterbricht den Prozessor, um ihm mitzuteilen, dass die Transaktionerfolgreich beendet wurde.

Mit Hilfe dieser Technik wird der Prozessor wesentlich entlastet. Oft werden mehrere DMA-Controler in einem Computersystem verwendet.


Memory Mapped IOAnstelle dass der Prozessor spezielle Instruktionen zum Schreiben und Lesen von IO-Gerätenbereitstellt, kann der Prozessor auch Memory Mapped IO anbieten. Bei dieser Technik wird derAdressbereich eines IO-Geräts (Steueradressen) in den Adressbereich des Prozessors integriert. DasSchreiben und Lesen einer derartigen Adresse entspricht dem Schreiben und Lesen auf bzw. vomIO-Gerät. Das Memory-System des Hauptspeichers erkennt nun, dass diese Adresse keineSpeicheradresse darstellt, sondern eine IO-Adresse ist. Ein Controler (z.B. DMA-Controler) kannnun die Übertragung der Daten vom bzw. zum Gerät abwickeln. Der Prozessor wird dadurch nichtbelastet. Allerdings wird der Bus belegt, was indirekt die Performance des Prozessors schmälernkann, wenn er auf IO-Rückmeldungen angewiesen ist.

Anforderungen an das Betriebssystem (BS)Das Betriebssystem ist die Schnittstelle zwischen Hardware und dem Benutzerprogramm. Es erfülltdie folgenden Aufgaben:

• Schutzfunktion für die gemeinsam genutzten IO-Einheiten

• fairer Zugang für alle Benutzer

• Abstraktion: Das BS stellt Dienste als Funktionen zur Verfügung.

• Behandlung von Unterbrechungen der CPU

• Kommunikation zwischen dem BS und den IO-Einheiten: Befehle, Meldungen, Datenaustausch

Rechnerarchitektur

Datenpfad und Kontrollpfad• Datenpfad: Der Datenpfad ist für den Transport und die Verarbeitung von Instruktionen und

Daten verantwortlich.

• Kontrollpfad: Der Kontrollpfad ist für die Verarbeitung und den Transport von Steuerungsdatenverantwortlich.

Grundkonzepte• Make the common case fast• Simplicity favors regularity


Instruktionsverarbeitung

ÜberblickDie Instruktionsverarbeitung erfolgt normalerweise synchron mit einem festen Takt. Die folgendeAbbildung zeigt die unterschiedlichen Verarbeitungsarten:

Einzyklenverarbeitung: Single CycleAlle Instruktionen werden in einem Takt abgearbeitet. Die Taktrate wird durch die langsamsteInstruktion vorgegeben.

Mehrzyklenverarbeitung: Multiple CycleDer Neumann-Zyklus lässt sich in 5 Schritte aufteilen:

• Instruction Fetch (IF): Instruktion aus dem Hauptspeicher holen

• Instruction Decode (ID) / Register Fetch (RF): Instruktion dekodieren / Lesen vonRegisterinhalten


• Execute (EX): Instruktion ausführen oder Adresse berechnen

• Memory (MEM): Zugriff auf den Datenspeicher

• Write Back (WB): Speichern der Resultate im Registerfeld

IF ID/RF EX MEM WB

Damit lässt sich die Taktrate drastisch erhöhen, da sie nun durch die langsamste Teiloperationgegeben ist; und nicht wie beim Single Cycle durch die langsamste Instruktion. Allerdings sindRegister zur Zwischenspeicherung notwendig.

Pipelineverarbeitung: PipeliningBeim Multiple Cycle-Betrieb bleibt jede Teiloperation nach der Verarbeitung für vier Takteungenutzt. Um die Effizienz zu steigern, überlappt man nun die Instruktionen und nutzt dabei aus,dass bei jedem Taktzyklus alle Teiloperationen für verschiedene Instruktionen gleichzeitigverarbeitet werden. Dies ist aber nur dann möglich, wenn zwischen den Teiloperationen Register alsZwischenspeicherung eingeführt und die Informationen weitergeleitet werden. Pipelining ist sehrschnell besitzt aber die unagnehme Eigenschaft, dass das Überlappen der Instruktionen scheiternkann, wenn sie voneinander abhängen. In diesem Fall ensteht ein Hazard.

IF ID/RF EX MEM WBIF ID/RF EX MEM WB


Für die Effizienz der Pipelineverarbeitung gilt:

• Bei gleicher Rechenzeit pro Teiloperation:

• Wenn jede Teiloperation verschieden lang dauert, dann gilt:


Hazards

Struktureller HazardDie Rechnerarchitektur kann die Kombination von Instruktionen, die derzeit ausgeführt werdensollen, nicht unterstützen.

Daten-HazardEin Operand einer Instruktion hängt vom Ergebnis einer vorherigen Instruktion ab.

Ablauf-HazardDas Ergebnis einer Instruktionsausführung wird benötigt, um zu entscheiden, welche Instruktionenanschliessend ausgeführt werden. Dieser Hazard konzentriert sich auf logische Instruktionen.

Vermeidung von HazardsStrukturelle Hazards können nur vermieden werden, wenn die Architektur angepasst wird. Daten-und Ablauf-Hazards können entweder durch den Compiler oder durch das Hinzufügen vonspeziellen Hardwarekomponenten behoben werden.

Vermeidung von Hazards durch den CompilerDer Compiler stellt die Instruktionen so um, dass keine Hazards mehr auftreten. Er kann imschlimmsten Fall NOP1-Instruktionen einfügen, um Hazards zu verhindern. Der Hardware-Hazardwird also mit Hilfe von intelligenter Software vermieden.

1 N ot an OPeration


Branch Delay Slot

Die erste Instruktion nach einer Verzweigung wird mit einer sinnvollen Instruktion aufgefüllt. Es istdie Aufgabe des Compilers oder des Assemblers, diese Lücke sinnvoll zu füllen.

Vermeidung von Daten-Hazards durch ForwardingAnstelle zu warten bis das gewünschte Register berechnet wurde, kann man auch das Resultat direktnach der Berechnung durch die ALU abfangen und weiterleiten. Dies zeigt das folgende Beispiel:

Die Forwarding-Einheit wird wie folgt in die bestehende Pipelining-Struktur eingefügt:

Wir führen folgenden Syntax ein: [Pipelineregister].{Register}.

Es müssen dann folgende Bedingungen gelten:EX hazard:if( EX/MEM.RegWrite AND

EX/MEM.RegisterRd ≠ 0 AND EX/MEM.RegisterRd = ID/EX.RegisterRs ) ForwardA = 10;

if( EX/MEM.RegWrite ANDEX/MEM.RegisterRd ≠ 0 AND EX/MEM.RegisterRd = ID/EX.RegisterRt ) ForwardB = 10;

MEM hazard:if( MEM/WB.RegWrite AND

MEM/WB.RegisterRd ≠ 0 AND EX/MEM.RegisterRd ≠ ID/EX.RegisterRs ANDMEM/WB.RegisterRd = ID/EX.RegisterRs ) ForwardA = 01;

if( MEM/WB.RegWrite ANDMEM/WB.RegisterRd ≠ 0 AND EX/MEM.RegisterRd ≠ ID/EX.RegisterRt ANDMEM/WB.RegisterRd = ID/EX.RegisterRt ) ForwardB = 01;

else { ForwardA = 00; ForwardB = 00; }


Vermeidung von Ablauf-HazardsStatistische Vorhersage

Der Prozessor nimmt an, dass der Programmfluss nicht verzweigt. Falls diese Vorhersage eintrifft,wird das Programm wie vorgesehen ausgeführt. Andernfalls werden die laufenden, fäschlicherweisebegonnenen Instruktionen abgebrochen und die korrekte Instruktion geladen.

Dynamische Vorhersage

Der Prozessor trifft nun die Vorhersage nicht statisch, sondern auf der Grundlage der vergangenenVerzweigungentscheidungen.

Vermeidung von Hazards durch StallsMan wartet solange, bis das Resultat am MEM/WB-Pipelineregister anliegt. Oft spricht man indiesem Zusammenhang von 'Blasen', die man bei der Instruktionsverarbeitung einfügt. Gemeint sinddamit Taktzyklen, bei denen nichts berechnet wird (NOP-Anweisungen).

Synchrone DigitalschaltungenAlle Komponenten einer synchronen Digitalschaltungen haben einen gemeinsamen Takt.

Shortest Path Delay (SPD)

Longest Path Delay (LPD)


Setup Time, Hold Time, ClkToQ

Clock Period

MikroprogrammierungDie Steuerung von Prozessoren mit reinen Logikelementen wird schnell recht unübersichtlich undkompliziert. Die Mikroprogrammierung geht dabei einen anderen Weg. Der neue Zustand desProzessors wird dann mit Hilfe einer programmierten Zustandstabelle ausgehend vomvorhergehenden Zustand ermittelt.

FunktionsweiseDer Datenpfad muss durch Steuerleitungen kontrolliert werden. Jeder Zustand des Prozessors wirdeindeutig durch das Anliegen der Steuersignale beschrieben. Diese Steuersignale werden nun Zeilefür Zeile meist in einem ROM oder EEPROM abgelegt. Da die Steuersignale die Zustände desProzessors eindeutig festlegen, bezeichnet man die Gesamtheit der Steuersignale auch Mikrocode.Das Mikroprogramm sorgt nun für den richtigen Ablauf des Mikrocodes. Jedes Steuersignal besitztnun eine eindeutige Zeile. Der Kontrollflussgraph beschreibt den Ablauf der Steuerung. Wird nuneine Instruktion im Prozessor abgearbeitet, so bestimmt der Opcode, um welche Instruktion es sichhandelt. Jeder Opcode einer Instruktion besitzt einen Satz von vordefinierten Steuersignalen, dieanliegen müssen, um die Instruktion abzuarbeiten. Ausgehend vom Initialzustand der Instruktionwird nun Schritt für Schritt die Instruktion pro Takt abgearbeitet. Dabei wird im Prinzip nichtsanderes gemacht, als von Zeile zu Zeile gesprungen und die entsprechenden Steuersignaleausgegeben.


Im Prinzip ist nur ein MPC (Machine Process Counter) und ein Multiplexer notwendig. Der MPCzeigt jeweils auf den nächsten Zustand bzw. die nächste Zeile und dadurch werden die Steuersignaleam Ausgang für den nächsten Zustand angelegt. Zusätzlich besitzt das ROM mit dem Mikrocodeeine Spalte namens SeqCtrl (Sequence Control). Damit wird der Multiplexer gesteuert. Verzweigtder Kontrollflussgraph, so muss zusätzlich ein Dispatch ROM (Jump Memory) verwendet werden,der die Zeile im ROM mit dem Mikrocode angibt. Schliesslich muss die Steuerung wissen, welcherZustand nun kommt. Dies zeigt die folgende Abbildung.

Kontrollflussgraphen und Datenpfade

DatenabhängigkeitsgraphDer Datenabhängigkeitsgraph beschreibt die Abhängigkeit der Register und Speicher in einerdigitalen Schaltung.

Der Datenabhängigkeitsgraph besteht aus folgenden Komponenten:

• Knoten: Abhängigkeiten der Register oder Speicherglieder

• Kanten: Übergang zum nächsten Datenzustand

Das folgende Beispiel zeigt eine add-Instruktion:


KontrollflussgraphDer Kontrollflussgraph ist dazu da, den Kontrollfluss einer digitalen Schaltung darzustellen. Dabeiwandert eine Zustandsmarkierung durch die einzelnen Zustände der Schaltung. Bei jedem Knotenwird eine Operation oder Aktion ausgelöst. Die Kanten beschreiben die Übergänge.

Der Kontrollflussgraph besteht aus folgenden Komponenten:

• Knoten: Aktionen, Operationen

• Kanten: Richtung des Kontrollflusses

• Marken: Darstellung des aktuellen Zustandes der Schaltung

Es gibt drei Arten von Knoten:

• Flussknoten• Verbindungsknoten• VerzweigungsknotenDie folgende Abbildung zeigt ein Beispiel:

DatenpfadDer Datenpfad beschreibt den Datenfluss in einer digitalen Schaltung. Zusätzlich können auchSteuerleitungen eingezeichnet und beschriftet werden. Der Datenpfad besteht aus folgendenElementen:


Multiplexer

ALU (Arithmetic Logic Unit)

Extend

Shift

Register

Registerfeld / Speicherglied


Die folgende Abbildung zeigt den Datenpfad (inklusive Steuerleitungen, rot eingezeichnet) einesProzessors mit Multiple Cycle-Instruktionsverarbeitung:

Vom Kontrollflussgraph, Datenpfad zum AutomatFür die Implementierung der Steuerung gilt allgemein:

Für den Aufbau von endlichen Automaten gilt:

1. Abbildung der Knoten des Kontrollflussgraphen auf Zustände des endlichen Automaten

2. Bestimmung der Zustandsübergänge

3. Abbilden der Kanten des Kontrollflussgraphen auf Zustandsübergänge

4. Bestimmung des Datenpfades anhand der den Knoten zugeordneten Operationen imKontrollflusgraphen und der Übergangsfunktion

5. Festlegung der Steuerleitungen für jeden Zustand der Schaltung anhand des Datenpfades und derKnoten zugeordneten Operationen im Kontrollflusgraphen in Tabellenform

6. Implementierung der Kontrollogik:

• Zustandszuordnung bzw. Codierung in einer Tabelle

• Ausgangszuordnungen bzw. Codierung für Komponenten (für z.B. ALU) in Tabellenform

• Logiksynthese: Karnaugh, CAD,...


Speicherhierarchie

SchemaDas Hauptanliegen ist es, möglichst viel Speicherplatz anzubieten mit einer verhältnismässig kurzenZugriffszeit. Diese Forderung widerspricht sich leider. Dennoch ist man bemüht, durch Methodenwie etwa Caching dieser Forderung nachzukommen.

Zugriffszeit einer HarddiskDie Zugriffszeit hängt von folgenden Zeiten ab:

• Suchzeit der Daten

• Rotationslatenz

• Übertragungslatenz

• Controlerlatenz

• Warteschlangenverzögerung

LokalitätProgramme greifen in einem kleinen Zeitintervall auf einen relativ kleinen Teil des Adressraumeszu. Deshalb gilt:

• zeitliche Lokalität: Daten oder Instruktionen, die benutzt wurden, werden bald wieder benutzt.

• örtliche Lokalität: Es werden Daten oder Instruktionen referenziert, die in der nähe von bereitsreferenzierten sind.

CachingCaching nutzt die örtliche Lokalität von Daten gezielt aus. Der Cache ist ein Speicher zwischen denSpeicherregistern und dem Hauptspeicher und dient der Verringerung der Zugriffszeit zwischendiesen beiden Speichern. Es ist nämlich so, dass der Hauptspeicher im Vergleich zu denSpeicherregistern des Prozessors viel zu langsam ist. Diesem Missverhältnis wird mit Hilfe einesCachespeichers, der sich ebenfalls auf dem Prozessor befindet, begegnet.

Caching ist dann ineffizient, wenn der Prozessor immer mit neuen Blöcken arbeitet und diese ausdem Hauptspeicher in den Cache stellt; und demzufolge selten einen Block aus dem Cache holt.


AufbauEs wird eine Abbildung vom Hauptspeicher zum Cache definiert.

Dabei gilt:

• Direkt (Direct mapped): Hier wird eine direkte Abbildung zwischen den Blöcken des Hauptspeichers und denjenigen imCache definiert. Es gilt:[Block number] modulo [Number of cache blocks]

• Teil assoziativ (Set associative):Hier wird eine direkte Abbildung zwischen den Blöcken des Hauptspeichers und den Sets vonBlöcken definiert. Ein Set besteht aus einer festen Anzahl von Blöcken. Es gilt:[Block number] modulo [Number of sets in the cache]Jedes Set muss nach einem bestimmten Block durchsucht werden.Unter einem n-fach teilassoziativem Cache versteht man einen Cache, der pro Set aus n Blöckenbesteht.

• Voll assoziativ (Fully associative):Es wird keine Abbildung definiert. Die Blöcke müssen im Cache durchsucht werden. ImGegensatz zum teil assoziativen Fall, wo nur ein Set von Blöcken durchsucht werden muss, mussnun beim voll assoziativen Fall der gesamte Cache durchsucht werden, da es ja nur ein Set mitallen Blöcken gibt.

FunktionsweiseJede Speicheradresse2 wird in folgende Bereiche aufgeteilt:

Tag Index Offset

Ein Cache besteht im wesentlichen aus einer Valid-Bit-Spalte, einer Tag-Spalte und einer Spalte fürdie Datenblöcke. Das Valid-Bit gibt an, ob der entsprechende Eintrag gültig ist. Für einenerfolgreichen Cachezugriff (Cache Hit) muss der Tag der Speicheradresse mit dem Tag-Eintrag inder entsprechenden Zeile im Cache-Table übereinstimmen. Im anderen Fall resultiert ein erfolgloserCachezugriff (Cache Miss). Der Cache ist also wie folgt aufgebaut:

Valid-Bit Tag Datenblock... ... ...

2 Bei einem vollassoziativen Cache besteht die Adresse nur aus einem Tag und einem Offset.


Für die verschiedenen Cache-Typen gilt nun:

Voll assoziativer Cache

Der gesamte Cachespeicher muss nach dem Tag des Datenblockes durchsucht werden. Wird einpassender Tag gefunden, dann resultiert ein Cache Hit; im anderen Fall ein Cache Miss.

Es gibt hier also nur 1 Set und deshalb spielt der Index der Speicheradresse keine Rolle.

Teil assoziativ Cache

Der Index der Speicheradresse gibt an, in welchem Set sich der Datenblock befindet. Dasentsprechende Set wird nun nach dem gewünschten Tag durchsucht. Wird der Tag gefunden, dannresultiert ein Cache Hit; im anderen Fall ein Cache Miss. Es folgt ein Beispiel:Index 2; Tag 8 Cache Miss

Index 2; Tag 6 Cache Hit

Index 1 = Set 1

Tag 1 Datenblock 1

Tag 2 Datenblock 2

Tag 3 Datenblock 3

Index 2 = Set 2

Tag 4 Datenblock 4

Tag 5 Datenblock 5

Tag 6 Datenblock 6

...

... ...

... ...

... ...

Direkter Cache

Der Index der Speicheradresse gibt an, in welcher Zeile sich der Datenblock befindet. Entspricht derTag in der angeforderten Zeile dem Tag der Speicheradresse, dann resultiert ein Cache Hit; imanderen Fall ein Cache Miss. Das folgende Beispiel macht dies deutlich:Index 3; Tag 2 Cache Miss

Index 4; Tag 4 Cache Hit

Index 1

Index 2

Index 3

Tag 1 Datenblock 1

Tag 2 Datenblock 2

Tag 3 Datenblock 3

Index 4

Index 5

...

Tag 4 Datenblock 4

Tag 5 Datenblock 5

... ...

Man unterscheidet also zwei Fälle:

• Cache Hit: Der Datenblock ist im Cache vorhanden.

• Cache Miss: Der gesamte Datenblock muss aus dem Hauptspeicher zuerst in den Cache geladenwerden. Besitzt der Cache keinen freien Speicherplatz mehr, so wird ein Datenblock durch einenneuen ersetzt.


Weiter ist folgendes zu beachten:

• Es wird der gesamte Datenblock eingelesen oder ersetzt; nicht nur Teile davon!• Datenblöcke können mit Hilfe eines Offsets unterteilt werden. Der Offset hat weiter für

den Cache keine Bedeutung. Der Vergleich der beiden Tags ist von Interesse!Die folgende Abbildung zeigt den Aufbau und die Funktionsweise eines Direct-Mapped Caches.

DatenkonsistenzDer Cache kann zu einer Dateninkonsistenz führen, nämlich dann, wenn die gleichen Daten einmalim Cache und im Hauptspeicher vorhanden sind. Der Prozessor wird in diesem Fall mit den Datenim Cache operieren. Doch was ist, wenn die Daten im Hauptspeicher aktueller sind, da sie von einervorhergehenden Instruktion verändert wurden? - Um dies zu vermeiden, gibt es zwei Strategien:

• Write Through: Der Prozessor schreibt bei jeder Instruktion die Daten in den Hauptspeicherund in den Cache. Damit ist aber ein Performanceverlust verbunden.

• Write Back: Der Prozessor schreibt die Daten nur in den Cache. Wird der Cache-Eintrag durcheinen neuen Eintrag ersetzt, so wird der modifizierte Eintrag in den Hauptspeicher geschrieben.

Quellenverzeichnis• Computer Organization & Design, David A. Patterson und John L. Hennessey, Second Edition,

Morgan Kaufmann Publishers, Inc.

• Vorlesungsskript von Prof. L. Thiele

• Skript zu den Übungen von Alex Maxiaguine


Documents

Stoffsammlung Technische Informatik Issenn.de/files/Formeln_tik1.pdf · Einführung in C Aufbau eines Source-Files Jedes Source-File ist wie folgt aufgebaut: Man beachte, dass bei