Skip to content

Commit 64e23a9

Browse files
SebastianZugSebastianZug
authored
Merge pull request #44 from Kneemund/master
fix: UML/DITAA and MAR length
2 parents 4e4a40a + dc08f9f commit 64e23a9

4 files changed

Lines changed: 60 additions & 89 deletions

File tree

‎10_CPU_Basis.md‎

Lines changed: 16 additions & 24 deletions
Original file line numberDiff line numberDiff line change
@@ -124,8 +124,7 @@ Arithmetische Funktionen: ADD, SUB, (MUL), (DIV)
124124
Sonstige: SHIFT LEFT (arithmetisch, logisch), SHIFT RIGHT (arithmetisch, logisch)
125125

126126
```text @plantUML.png
127-
@startuml
128-
ditaa
127+
@startditaa
129128
Daten Daten
130129
| |
131130
| |
@@ -175,7 +174,7 @@ ditaa
175174
| +---------------------+ | --+---+--+
176175
| | | Status
177176
+-------------------------+ v S
178-
@enduml
177+
@endditaa
179178
```
180179

181180
Der Status S umfasst eine Zusammenstellung der Resultate der Operationen codiert als 1-Bit Werte:
@@ -220,8 +219,7 @@ Zwischenstand
220219
Für diesen Schritt fassen wir das obige Schaltbild unserer hypothetischen ALU mit 8 Funktionen in einem abstrakteren Schaubild zusammen.
221220

222221
```text @plantUML.png
223-
@startuml
224-
ditaa
222+
@startditaa
225223
+-----+-----+
226224
| A | B |
227225
Daten +-----+-----+
@@ -233,7 +231,7 @@ ditaa
233231
Status | |
234232
<----------+ |
235233
+-----------+
236-
@enduml
234+
@endditaa
237235
```
238236

239237

@@ -255,8 +253,7 @@ Der Speicher umfasst unsere Programmbestandteile `AND_B` usw. in jeweils einem 4
255253
Analog zur Diskussion um die abstraktere Darstellung der ALU fassen wir auch den Speicher in einem Block-Symbol zusammen.
256254

257255
```text @plantUML.png
258-
@startuml
259-
ditaa
256+
@startditaa
260257
+------------------+
261258
|c88F |
262259
| Speicher |
@@ -273,7 +270,7 @@ ditaa
273270
Status | |
274271
<--------+ |
275272
+-----------+
276-
@enduml
273+
@endditaa
277274
```
278275

279276

@@ -282,8 +279,7 @@ Wie allerdings setzen wir den Fortschritt im Programm um? Nach welcher Methodik
282279
Eine weitere Komponente, das Steuerwerk übernimmt diese Aufgabe. Anstatt nun eine Folge von Kontrollflags vorzugeben, erzeugen wir intern eine Folge von Adressen, die auf Speicherbereiche verweisen, in denen die Konfigurationen der ALU hinterlegt sind.
283280

284281
```text @plantUML.png
285-
@startuml
286-
ditaa
282+
@startditaa
287283
+------------------+
288284
|c88F |
289285
| Speicher |
@@ -300,14 +296,13 @@ ditaa
300296
| | Status | |
301297
| | <--------+ |
302298
+----------+ +-----------+
303-
@enduml
299+
@endditaa
304300
```
305301

306302
Allerdings bleibt bei dieser Konfiguration unser Status auf der Strecke! Im Grund müssen wir die Information dazu aber Operationsspezifisch auswerten. Es genügt also nicht allein eine Adressberechung zu realsieren, vielmehr bedarf es einer generellen Steuerungskomponente, die die Ausführung von Befehlen initiiert und überwacht.
307303

308304
```text @plantUML.png
309-
@startuml
310-
ditaa
305+
@startditaa
311306
+------------------+
312307
|c88F |
313308
| Speicher |
@@ -326,7 +321,7 @@ ditaa
326321
| | Status | |
327322
| +<------------------------------+ |
328323
+----------+ +-----------+
329-
@enduml
324+
@endditaa
330325
```
331326

332327
Das Steuerwerk ist nun dafür verantwortlich:
@@ -354,8 +349,7 @@ Zwischenstand
354349
Wo kommen aber die Daten her? Bislang haben wir uns damit begnügt anzunehmen, dass diese auf "magische" Art und Weise in unseren Registern stehen.
355350

356351
```text @plantUML.png
357-
@startuml
358-
ditaa
352+
@startditaa
359353
+------------------+
360354
|c88F |
361355
| Speicher |
@@ -374,7 +368,7 @@ ditaa
374368
| | Status | |
375369
| |<------------------------------+ |
376370
+----------+ +-----------+
377-
@enduml
371+
@endditaa
378372
```
379373

380374
Im Speicher stehen nun nicht nur Befehle für die Ausführung unserer ALU-Funktionen, sondern auch die Daten für unsere Berechnungen. Auf diese verweisen wir mit separaten Befehlen.
@@ -418,8 +412,7 @@ Zwischenstand
418412
Das Steuerwerk koordiniert neben der ALU die Ein- und Ausgabeschnittstelle.
419413

420414
```text @plantUML.png
421-
@startuml
422-
ditaa
415+
@startditaa
423416
+------------------+
424417
|c88F |
425418
| Speicher |
@@ -451,7 +444,7 @@ ditaa
451444
| Ein/Ausgabe |
452445
| |
453446
+-------------------+
454-
@enduml
447+
@endditaa
455448
```
456449

457450
## 1945: Von-Neumann Architektur
@@ -461,8 +454,7 @@ John von Neumann beschrieb 1945 in seinem Aufsatz ”First Draft of a Report on
461454
Einige der Ideen des Konzepts wurden bereits von Konrad Zuse erkannt und teilweise in der Z1 und der Z3 realisiert.
462455

463456
```text @plantUML.png
464-
@startuml
465-
ditaa
457+
@startditaa
466458
^ |
467459
| V
468460
+-+----+ +----------------------------+
@@ -483,7 +475,7 @@ ditaa
483475
| | | | | | ALU | |
484476
| | | | | +--------+ |
485477
+------+ +----------+ +------------+
486-
@enduml
478+
@endditaa
487479
```
488480

489481
## Hausaufgaben

‎11_Modell_CPU.md‎

Lines changed: 28 additions & 41 deletions
Original file line numberDiff line numberDiff line change
@@ -89,8 +89,7 @@ style="width: 80%; min-width: 420px; max-width: 720px;"
8989
## Ausgangspunkt
9090

9191
```text @plantUML.png
92-
@startuml
93-
ditaa
92+
@startditaa
9493
+------------------+
9594
|c88F |
9695
| Speicher |
@@ -122,7 +121,7 @@ ditaa
122121
| Ein/Ausgabe |
123122
| |
124123
+-------------------+
125-
@enduml
124+
@endditaa
126125
```
127126

128127
Der Prozessor ist die Einheit eines Rechners, die Daten nach einem vom Anwender spezifizierten Programm manipuliert. Das Programm wird als eine Folge von Anweisungen oder Befehlen für die CPU formuliert. Die CPU besteht daher:
@@ -183,25 +182,23 @@ Nun muss die Aufteilung ein Befehlswort in ein Feld für den Operationscode und
183182
Befehlsformat:
184183

185184
```text @plantUML.png
186-
@startuml
187-
ditaa
185+
@startditaa
188186
15 12 11 0
189187
+------------+-------------------------------+
190188
|c00F OPCODE | cFF0 Operantenaddresse |
191189
+------------+-------------------------------+
192-
@enduml
190+
@endditaa
193191
```
194192

195193
Datenformat:
196194

197195
```text @plantUML.png
198-
@startuml
199-
ditaa
196+
@startditaa
200197
15 0
201198
+--------------------------------------------+
202199
| cFF0 Datensatz |
203200
+--------------------------------------------+
204-
@enduml
201+
@endditaa
205202
```
206203

207204
Negative Zahlen werden im Zweierkomplement dargestellt.
@@ -314,8 +311,7 @@ zu finden.
314311
### Speicherbezogene Komponente
315312

316313
```text @plantUML.png
317-
@startuml
318-
ditaa
314+
@startditaa
319315
+-----------------------------------------------------+
320316
| Speicherbezogene Komponenten |
321317
| c88F |
@@ -331,15 +327,15 @@ ditaa
331327
| +----------------------+ +-----------------------+ |
332328
+-----------------------------------------------------+
333329
334-
@enduml
330+
@endditaa
335331
```
336332

337333

338334
In einem Speicherzyklus muss der Prozessor zunächst eine Adresse liefern, die während des gesamten Speicherzyklus anliegen muss. Für einen Schreibzyklus betrifft dies auch das entsprechend abzulegende Datum. Bei einem Lesezyklus steht das gewünschte Wort erst mit einer gewissen Verzögerung an der Schnittstelle zur Verfügung. Da der Speicher sowohl zum Schreiben als auch zum Auslesen eines Wortes länger braucht als die Zeit, in der der Prozessor eine elementare Operation ausführen kann, sind zwei Pufferregister vorgesehen:
339335

340-
1. Das Speicher-Adress-Register (MAR : Memory Address Register), in das die Adresse zu Beginn des Speicherzyklus geschrieben wird. In unserem Fall ist das MAR 16 Bit breit.
336+
1. Das Speicher-Adress-Register (MAR : Memory Address Register), in das die Adresse zu Beginn des Speicherzyklus geschrieben wird. In unserem Fall ist das MAR 12 Bit breit.
341337

342-
2. Das Speicher-Puffer-Register (MBR : Memory Buffer Register). Bei einer Schreiboperation legt der Prozessor ein Datenwort hier ab, so dass es durch den (langsamen) Schreibvorgang im Speicher unter der Adresse abgespeichert wird, die im MAR spezifiziert ist. Beim Lesen stößt der Prozessor den Lesevorgang an und kann später das adressierte Wort aus dem MBR auslesen. Die Adresse ist bei uns 11Bit breit. Wir können also 2^11 Adressen ansprechen, die jeweils 16 Bit Daten repräsentieren.
338+
2. Das Speicher-Puffer-Register (MBR : Memory Buffer Register). Bei einer Schreiboperation legt der Prozessor ein Datenwort hier ab, so dass es durch den (langsamen) Schreibvorgang im Speicher unter der Adresse abgespeichert wird, die im MAR spezifiziert ist. Beim Lesen stößt der Prozessor den Lesevorgang an und kann später das adressierte Wort aus dem MBR auslesen. Die Adresse ist bei uns 12 Bit breit. Wir können also 2^12 Adressen ansprechen, die jeweils 16 Bit Daten repräsentieren.
343339

344340
Durch MBR und MAR sind Prozessor und Speicher bezüglich ihrer Zykluszeiten weitgehend entkoppelt.
345341

@@ -354,8 +350,7 @@ Der Datenpfad besteht aus der ALU, dem allgemeinen Register A (Akkumulator), ein
354350
Sie setzen voraus, daß der eine Operand in A steht, der zweite Operand muss aus dem Speicher von Adresse `addr` gelesen wird. Dabei gehen wir davon aus, dass der Operand im MBR zur Verfügung steht. Da die ALU rein kombinatorisch aufgebaut werden soll, müssen beide Operanden während der Verarbeitungszeit an den Eingängen anliegen. Das Ergebnis der Operation wird in A verfügbar gemacht. Damit das Ergebnis der Operation nicht einen der Operanden in A überschreibt, ist das Hilfsregister Z vorgesehen. Während der Befehlsausführung wird der Operand aus A nach Z transferiert, damit das Ergebnis in A gespeichert werden kann.
355351

356352
```text @plantUML.png
357-
@startuml
358-
ditaa
353+
@startditaa
359354
-----+ +---------------------------------+
360355
| | Datenpfadbezogene Komponenten |
361356
| | c88F |
@@ -380,7 +375,7 @@ ditaa
380375
|
381376
382377
-----+
383-
@enduml
378+
@endditaa
384379
```
385380

386381
[Link auf den Simulator](https://tubaf-ifi-liascript.github.io/VL_EingebetteteSysteme/programs/rechenwerk/index.html)
@@ -396,8 +391,7 @@ Die Kontrolleinheit besteht aus:
396391
5. dem Automaten, der die der sequentiellen Kontrolle realisiert.
397392

398393
```text @plantUML.png
399-
@startuml
400-
ditaa
394+
@startditaa
401395
+-------------------------------------------------+
402396
| 11 0 |
403397
| +-------------------------------+ |
@@ -419,7 +413,7 @@ ditaa
419413
| +-----------------+ +-------------+ |
420414
| Kontrolleinheit bezogene Komponenten c88F |
421415
+-------------------------------------------------+
422-
@enduml
416+
@endditaa
423417
```
424418

425419
Der Prozessor liest eine neue Instruktution aus dem MBR in das Instruction Register. Die Control Unit interpretiert den Operationscode und startet die Ausführung, währenddessen wird der Programmzähler bereits auf die Adresse der Instruktion gesetzt, die als nächste ausgeführt werden soll. Über den Programmzähler wird also die Sequenzierung der Instruktionen bei der Abarbeitung eines Programms gesteuert. Das State FF übernimmt die unterschiedliche Abarbeitung von Befehlen, die in einem Zyklus und zwei Zyklen umgesetzt werden können (HLT vs ADD).
@@ -429,8 +423,7 @@ Der Prozessor liest eine neue Instruktution aus dem MBR in das Instruction Regis
429423
### Und jetzt alles zusammen
430424

431425
```text @plantUML.png
432-
@startuml
433-
ditaa
426+
@startditaa
434427
+-----------------------------------------------------+ +---------------------------------+
435428
| Speicherbezogene Komponenten | | Datenpfadbezogene Komponenten |
436429
| c88F | | c88F |
@@ -467,7 +460,7 @@ ditaa
467460
| +-----------------+ +-------------+ |
468461
| Kontrolleinheit bezogene Komponenten c88F |
469462
+-----------------------------------------------------+
470-
@enduml
463+
@endditaa
471464
```
472465

473466
1. Der Akkumulator (`Register A`). In dem Modellrechner ist der Akkumulator das einzige allgemeine Register. Alle arithmetischen und logischen Befehle arbeiten auf diesem Register.
@@ -625,8 +618,7 @@ Jsr2 --> Fetch1
625618
## Umsetzung als Schaltnetz / Schaltwerk
626619

627620
```text @plantUML.png
628-
@startuml
629-
ditaa
621+
@startditaa
630622
Instruction Register
631623
+---------+------------+
632624
|OPCODE | |
@@ -651,16 +643,15 @@ Clock--->| Sequentielles Schaltnetz |
651643
| | Flags:
652644
| |<--- Signum, Zero, Overflow, Carry, ...
653645
+-----------------------------------------------------------------+
654-
@enduml
646+
@endditaa
655647
```
656648

657649
### Taktvorgabe
658650

659651
Die Kontrolleinheit benötigt einen Trigger für die Abarbeitung der Instruktionen. Grundlage für den Zeitablauf einer Maschinenoperation ist der Speicherzyklus und der Prozessortakt. Im Modellrechner wird der Ablauf in Phasen zu 8 Taktintervalle unterteilt. In jedem dieser Taktintervalle kann eine Instruktion vollständig oder zur Hälfte ausgeführt werden.
660652

661653
```text @plantUML.png
662-
@startuml
663-
ditaa
654+
@startditaa
664655
Dauer einer Phase Fetch/Execute
665656
RUN/HLT 3 Bit |<-------------->|
666657
| Zähler +---+
@@ -690,7 +681,7 @@ Oscillator |---| | |
690681
| |
691682
+---+
692683
3 zu 8 Decoder
693-
@enduml
684+
@endditaa
694685
```
695686

696687
### Integrierung der Taktvorgabe in Steuerwerk
@@ -703,8 +694,7 @@ Die folgende Abbildung gibt die Kontrolleinheit im schematische Aufbau wieder.
703694
4. das kombinatorische Schaltnetz zu Erzeugung der Steuersignale.
704695

705696
```text @plantUML.png
706-
@startuml
707-
ditaa
697+
@startditaa
708698
Instruction Register
709699
+---------+------------+
710700
|OPCODE | |
@@ -748,7 +738,7 @@ Oscillator |---| | | |
748738
| | | |
749739
+---+ +-----------------------------------------------------------------+
750740
3 zu 8 Decoder
751-
@enduml
741+
@endditaa
752742
```
753743

754744
### Realsierung der kombinatorischen Logik in der Kontrolleinheit
@@ -766,8 +756,7 @@ Oscillator |---| | | |
766756
## Beschränkungen der aktuellen Lösung
767757

768758
```text @plantUML.png
769-
@startuml
770-
ditaa
759+
@startditaa
771760
+----------------------------------+
772761
|c42C +------->
773762
| |
@@ -795,7 +784,7 @@ ditaa
795784
| Neuer Zustand
796785
|
797786
Clock
798-
@enduml
787+
@endditaa
799788
```
800789

801790
{{0-1}}
@@ -808,8 +797,7 @@ ditaa
808797

809798
{{1-2}}
810799
```text @plantUML.png
811-
@startuml
812-
ditaa
800+
@startditaa
813801
+----------------------------------+
814802
|c8C2 +------->
815803
| |
@@ -842,7 +830,7 @@ ditaa
842830
Opcodes +-----------+
843831
Folgezustands
844832
Kontrolle
845-
@enduml
833+
@endditaa
846834
```
847835

848836
{{1-2}}
@@ -898,8 +886,7 @@ style="width: 80%; min-width: 420px; max-width: 720px;"
898886
Das Mikroprogrammwortes umfasst alle Steuersignale für Register, ALU, Speicher, usw., die jeweils durch ein Bit in der repräsentiert sind. Eine Steuerleitung wird aktiviert, wenn dieses Bit auf "1" gesetzt ist. Wird das Bit auf "0" gesetzt, wird die Steuerleitung deaktiviert. Der erste Teil des Mikroprogrammwortes wird entsprechend als Steuerwort bezeichnet.
899887

900888
```text @plantUML.png
901-
@startuml
902-
ditaa
889+
@startditaa
903890
Instruction Register
904891
+---------+-------------------+
905892
A_15 | OPCODE | |
@@ -933,7 +920,7 @@ ditaa
933920
| Read | Write | | on Bus | off Bus | | | | | | | |
934921
|cC42 | cC42 | cC42 |cC42 | cC42 |cC42 |cC42 |cC42 |cC42 |cC42 |cC42 |cC42 |
935922
+------+-------+-------+--------+---------+-------+-----+-----+-------+-----+-----+-------+
936-
@enduml
923+
@endditaa
937924
```
938925

939926
Das Mikroprogrammwort enthält außer dem Steuerteil noch den Adressteil. Der Adressteil eines Mikroprogrammwortes enthält direkt die Adresse des nächsten Mikroprogrammwortes. Allerdings muss der Modellrechner auch auf Statusinformation der ALU und auf den Inhalt des OPCODE-Feldes des IR reagieren, so dass der Ablauf des Mikroprogramms nicht immer gleich ist.

0 commit comments

Comments
 (0)