Kapitel 4

Das Von-Neumann-Rechnermodell

Von-Neumann-Modell (abb4-1.jpg)
Abb. 4-1: Das Von-Neumann-Modell

Zur E/A-Steuerung s.S. 72 (Krummskript) Machinenbefehle des Prozessors 1.) Akku:= ReadStatus(x) 2.) WriteA-Puffer(x,Akku) 3.) Akku:=ReadE-Puffer(x)

Maschinensprachebene:

- Prozessor, Arbeitsspeicher und E/A bilden Maschine zur Ausführung von Maschinensprachprogrammen, zentrales Element: der Prozessor - Maschinensprache: - Syntax: Befehlsformate (Bitmuster) abstrakt : Assemblersprache - Semantik: operational definiert -> Prozessor-, Speicher-, E/A-Modell zentral: Prozessormodell - Prozessormodell: - Registersatz des Prozessors - Operationen mit Umgebung ( Arbeitsspeicher, E/A, Unterbrechungen ) - Prozessorzyklus Prozessorverhalten: - Unterbrechungsbearbeitung - Befehlsbearbeitung -Maschinentypen: Allgemeine Form eines Befehls: Drei-Adreß-Befehl (Drei-Operanden-Befehl) (Ergebnisadresse):=(OP1-Adresse)+(OP2-Adresse)
Befehlsabarbeitung (abb4-2.jpg)
Abb.4-2: Schema einer Befehlsbearbeitung

Maschinentypen

Die Drei-Adress-Maschine Befehlsbeispiel: (205):=(220)+Betrag(222) Drei Speicheradressen oder +Betrag,220,222,205 oder als Bitmuster
Bitmuster des 3-A-Befehls (abb4-3.jpg)
Abb. 4-3 Bitmuster eines 3-Adreß-Befehls
Nachteile: -lange Befehle -3 Speicherzugriffe je Befehlsausführung (+ den Zugriff, um Befehl in Prozessor zu lesen) Folge: - Zwei-Adress-Maschinen - Ein-Adress-Maschinen - Null-Adress-Maschinen - Registermaschinen => bewirkt folgende Veränderungen: * andere Befehlslänge * Zwischenspeicherung im Prozessor Die Zwei-Adress-Maschine -> eine Adressangabe erfüllt doppelten Zweck: Operandenart und Ergebnisart Befehlsbeispiel: (205):=(205)+Betrag(222) 2 Speicheradressen oder +Betrag,205,222 oder als Bitmuster
Bitmuster des 2-A-Befehls (abb4-4.jpg)
Abb. 4-4: Bitmuster eines 2-Adreß-Befehls
Darstellung eines Drei-Adress-Befehls auf einer Zwei-Adress-Maschine Beispiel: (205):=(220)+Betrag(222) dieser Befehl muß auf eine Folge zweier Befehle abgebildet werden: 1.) (205):=(220) (+0) 2.) (205):=(205)+Betrag(222) Die Ein-Adress-Maschine (auch AKKU-Maschine genannt) - Ein spezieller festgelegter Speicherort, der Akkumulator, enthält immer den 1. Operanden und nimmt das Ergebnis auf - Akkumulator kann eine reservierte Arbeitsspeicherzelle sein, oder ein Register im Prozessor Befehlsbeispiel: Akku:=Akku+Betrag(222) oder +Betrag,222 oder als Bitmuster
Bitmuster des 1A-Befehls (abb4-5.jpg)
Abb. 4-5: Bitmuster des 1-Adreß-Befehls
Darstellung eines Drei-Adress-Befehls auf einer Ein-Adress-Maschine Beispiel: (205):=(220)+Betrag(222) dieser Befehl muß auf eine Folge dreier Befehle abgebildet werden: 1.) AKKU:= (220) 2.) AKKU:= AKKU+Betrag(222) 3.) (205):= AKKU Einschub zur Vorbereitung der Null-Adress-Maschine Datenstruktur Keller als ADT empty: ->Keller push: Gtyp->x Keller->Keller top: Keller->Gtyp pop: Keller->Keller is.empty: Keller->boolean is.empty(empty)=true is.empty(push(x,k))=false top(push(x,k))=x pop(push(x,k))=k Beispiele: das LIFO-Prinzip k=push(3,push(2,push(1,empty))) k= x=top(k) x=3 m=pop(k) m= y=top(m) y=2 n=pop(m) n= z=top(n) z=1 o=pop(n)=empty o= Implementierung (z.B.: Pascal-Abklatsch) Const Max=100; var Stsp:array[0..Max] of Integer; SP:Integer; procedure Init; begin SP:=Max+1; end; procedure Push(x:Integer); begin SP:=SP-1; Stsp[SP]:=x; end; procedure Top:Integer; begin return Stsp[Sp] end; end; procedure Pop:Integer; var h:Integer; begin h:=Stsp[Sp]; SP:=SP+1; return Stsp[SP]; end; procedure IsEmpty:boolean; begin return SP>Max; end;
Stack (abb4-6.jpg)
Abb. 4-6: Darstellung eines Kellerspeichers/Stack
Keller und Ausdrucksspeicherung: Beispiel einer Rechnung: x:=(y+500)*z-1000 in Postfix-Notation x y 500 + z * 1000 - := Abarbeitung der Postfix-Notation mittels Kellerstruktur: push(Adr(x)) push(y) push(500) push(pop+pop) push(z) push(pop*pop) push(1000) push(pop-pop) Store(pop->pop) Die Ein-Adress-Maschine Festgelegte Speicherorte für Operanden und Ergebnis: Keller Befehlsbeispiel: Push(Pop+BetragPop) oder +Betrag oder als Bitmuster
Bitmuster Stackbefehl (abb4-7.jpg)
Abb. 4-7: Bitmuster eines Stackbefehls
Zur Operandenhinterlegung und zum Ergebnistransfer werden i.a. zusätzlich Ein-Adress-Maschinen benötigt unser oben genanntes Beispiel in der Ein-Adress-Maschine: 1.) LOAD 220 2.) LOAD 222 3.) +Betrag 4.) STORE 205 Registermaschine - besondere Speicherzellen (Register) mit "kurzer" Adresse i.a. im Prozessor untergrbracht (Zugriffsgeschwindigkeit) - Universalregistermaschinen - Spezielle Registersätze (AKKU, Indexregister) - oft: - 2 Adress-Maschine - eine Adresse ist immer eine Registeradresse (Registernummer) Beispiel: 16 Universalregister R0,R1,...,R15 Befehl: Rx:= Rx+ Betrag(220) oder +Betrag,x,220 oder als Bitmuster
Bitmuster Registermaschine (abb4-8.jpg)
Abb. 4-8: Bitmuster einer Registermaschine
und wieder unser Beispiel diesmal auf die Registermaschine angewandt: (205):=(220)+Betrag(222) Ausdrucksberechnung: - Register als schnelle Zwischenspeicher Infix: x:=(y+500)*z-1000 ;u:=y+500 Postfix: x y 500 + z * 1000 - := ;u y 500 + := 1) Load R1,(Adr(y)) R1:=y 2) + R1,(Adr("500")) R1:=R1+500 3) Load R2,(Adr(z)) R2:=z 4) * R2,R1 R2:=R2*R1 5) - R2,(Adr("1000")) R2:=R2-1000 6) Store R2,(Adr(x)) x:=R2 7) Store R1,(Adr(u)) u:=R1 [etc. ...] Vergleiche: Speicherzugriffszeiten - Arbeitsspeicher z.B. 10ns - Prozessorregister z.B. 1ns Gängige Prozessoren - Kombination - Zwei-Adress-Maschine - Registermaschine - Kellermaschine - auch Ein-Adress-Befehle - zahlreiche Operandenzugriffsarten Beispiel: - 8 Universalregister D0,...,D7 - 7 Adressrechenregister - 1Kellerpegelregister - Verknüpfungsbefehle in 2-Adress-Form - Push/Pop-Befehle - Unterprogrammsprung/Rücksprung - Spezialbefehle (z.B. Lade Statusregister) als 1-Adress-Befehl Befehlsformate: Grundlegende Form eines Zwei-Adress-Befehls:
Zwei-Adress-Befehl (abb4-9.jpg)
Abb. 4-9: Form eines Zwei-Adress-Befehls
Operationsadressen: - direkt, z.B. 32bit-Muster - Register, z.B. 4bit-Muster - modifiziert weitere Formate, etc. s. Krumm-Skript Codierung nach dem Fano-Code: "kein Kennwort darf mit dem Anfang des nächsten identisch sein" (sinngemäß) Operandenzugriff: s. Krumm-Skript S. 78

Speicherbausteine

( siehe Krumm-Skript Seite 59 ) Ein einfaches 4 - bit Register ( siehe Krumm-Skript Seite 60 ) Betriebsarten:
Schreib! Lies!  
0
0
1
1
0
1
0
1
speichern, Ausgänge passiv
speichern, Auslesen
Einschrieben
Verboten !
Tab. 4-1: Registerbaustein
Registertransferebene: Registerinhalte ( in mehreren Phasen ) transferieren

Register:

Beispiel: Einfaches Rechenwerk mit Registern zur Argumentversorgung und Ergebnisablage

Einfache ALU ( Rechenwerk, arithmetische logische Unit ):

Einfache ALU (abb4-10.jpg)
Abb. 4-10: Einfache ALU

RAM: Schreib / Lesespeicher:

Entwurf eines 1-bit Haltespeichers RS - FlipFlop ( Reset, Set - FlipFlop ) Organisation: Feld von Wörtern Wort: Feld von Bits Aktives Wort durch Adressierung Speicherzelle: 1 - bit Speicher für Einbettung in Matrix ( 2N x M )- RAM N Adreßeingänge M Wortbreite Beispiel: 22 x 4-RAM ( siehe Krumm-Skript Seite 62 ) Zyklischer Speicher

Integrierte PLA`s:

PLA mit eingebautem Speicher zur Firmware - Realisierung von in Grenzen beliebigen Schaltwerken. Anwendung: Allgemeines Blockbild: siehe Krumm-Skript Seite 63

Abstecher: Integrierte Schaltkreise:

1940 Elektronenröhren 1. Generation diskrete Verdrahtung zum Teil schon Leiterplatten 1958 Transistoren ( bipolar ) 2. Generation Leiterplatten Module (Leiterplatten auf Leiterplatten) Dickschichttechnik 1965 Integrierte Schaltkreise 3. Generation Träger = Element - Material SSI <= 10 Gatter pro Chip MSI <= 100 Gatter pro Chip 1972 Hochintegrierte Schaltkreise 4. Generation LSI <= 100.000 Gatter pro Chip ULSI > 100.000 Gatter pro Chip 4 - Mbit Speicherchips 1 - Chip Prozessoren ASIC„s: Application Specific IC„s Rechnergestützter Entwurf und Produktionsvorbereitung Verbesserung folgender Eigenschaften ist möglich:

VLSI - Entwurf:

siehe Krumm-Skript Seite 65

H - Bäume:

siehe Krumm-Skript Seite 66

Rechnerarchitektur:

Von Neumann Rechner John von Neumann ( 1903 -1957 ) Bild siehe Krumm-Skript Seite 68

Wesentliches der Von - Neumann - Architektur:

3 Komponenten:
    Prozessor}Zentraleinheit
    Speicher
    E / A
I. Speicher: Befehle und Daten ( von Darstellung und Ablageart her nicht seperiert. ) ( Programm kann Daten berechnen, die später als Befehle interpretiert werden können ) II. Prozessor: - sequentielle Programmausführung durch Folge von Befehlsausführungen - Befehl: Operationscode; Operationsadressen - interne Struktur:
  • Befehlzeiger
  • Statusregister
  • Steuerwerk
  • Rechenwerk
III. Verbindungen zwischen Komponenten: - Steuerleitungen - Meldeleitungen - Adreßleitungen - Datenleitungen Gesamtablauf wird zentral durch Prozessor ( dort vom Steuerwerk ) gesteuert Eine Variante der Busarchitektur: ( Bild siehe Krumm-Skript Seite 69 ) Arbeitsspeicher: ( siehe Krumm-Skript Seite 70 unten ) array [ 0 ... MaxAdr ] of Speicherwort Speicherwort = array [ 0 ... ( Wortlänge - 1 )] of Bit Befehle und Daten im Speicher: 100: Addiere Inhalt von 200 als Betragszahl zu Inhalt von 201 und lege Ergebnis in Wort 202 ab 101: Gib Inhalt von Zelle 202 an E / A - Anschluß mit Nr. aus Wort 203 aus 102: Vergleiche Inhalt von 202 mit Inhalt von 204 als Betragszahl 103: Springe zu 100, falls Vergleichsergebnis „ > „ 104: Springe unbedingt zu Zelle 50 _____________________________________________________________________ 200: 100 201: 10 202: 390 203: 5 204: 1100 Prozessor: Aktive Komponente: Prozessorregister: BZ Befehlszeiger Speicheradresse PS Prozessorstatus Vergleichsanzeigen, Betriebsart, flags AKKU Akkumulator Zwischenergebnisse ____ _______________ ______________________________________ BR Befehlsregister aktueller Befehl HR Hilfsregister temporäre Zwischenergebnisse
Prozessor und Umgebung (abb4-11.jpg)
Abb. 4-11: Der Prozessor und Umgebung

Prozessorverhalten: ( Bild siehe Krumm-Skript Seite 71 ) Kelleroperationen per Dekrement-/Inkrementbefehl
Kelleroperationen (abb4-12.jpg)
Abb. 4-12: Kelleroperation
1. Leerer Keller: Speicher reservieren R2 (Kellerzeiger) auf Ende+1 setzen 2. Einschreiben (push) ('R2):=5 ('R2):=4 ('R2):=3 3. Auslesen (pop/top) R1:=(R2') R3:=(R2') -> R1=3 und R3=4 4. Einschreiben (push) ('R2):=10 ('R2):=11 ('R2):=12

Befehlstypen

Transportbefehle Ortsbewegung
Transportbefehl (abb4-13.jpg)
Abb. 4-13: Darstellung eines Transportbefehls
Laden, Speichern, Vertauschen Arithmetische Befehle Arithmetische Operationen + , - , * , / , mod , *(-1) (die Negation) Vergleichsbefehle Operandenvergleiche entsprechend des Datentyps -> Vergleichsanzeigen setzen Sprungbefehle BZ-Manipulation bedingter/unbedingter Sprung Unterprogrammsprung Bitmusterbefehle Bitmusteroperationen AND , OR , XOR , EQU , shift Bitbefehle Bitmustermanipulationen Bit testen , Bit setzen , Bit löschen E/A-Befehle Transport zwischen Register/Speicher und E/A- Steuerung out , in Spezialbefehle Transport von/zu Spezialregistern Betriebsart-Manipulation Unterbrechungbehandlung Speicherverwaltung dynamischer Stop

Ein-/Ausgabe und Unterbrechungen

E/A-Steuerung und Unterbrechung (abb4-14.jpg)
Abb. 4-14: E/A und Interrupts
- Langsame E/A-Befehle
Langsame E/A-Befehle (abb4-15.jpg)
Abb. 4-15: Langsame E/A-Befehle
- Prozessor ist blockiert, während Gerät arbeitet - Geräte oft um ein Vielfaches langsamer als Prozessor -> ins Gewicht fallendes Verschenken von Prozessorleistung -> inzwischen fast nur noch E/A-Formen mit nebenläufiger Prozessor- und Gerätetätigkeit - Programmgesteuerte E/A unter Abfrage (Polling)
Programmgesteuerte E/A (abb4-16.jpg)
Abb. 4-16: Programmgesteuerte E/A
Nachteile: Prozessor muß (programmgesteuert) abfragen (u.U. wiederholt), ob E/A beendet ist -> aufwendige Synchronisation der nebenläufigen Prozessor- und Gerätetätigkeit -> Unterbrechungen / Interrupts - Unterbrechungsgesteuerte E/A
Unterbrechungsgesteuerte E/A (abb4-17.jpg)
Abb. 4-17: Unterbrechungsgesteuerte E/A
= Standart bei sogenannten langsamen zeichenweise arbeitenden Geräten = Bei E/A langer Blöcke: Häufige Prozessorunterbrechungen = Bei schnellen Geräten zu langsam => DMA -> Interessant bei Mehrprozeßbetrieb (BS) - Selbstständiger Blocktransfer (DMA)
DMA (abb4-18.jpg)
Abb. 4-18: Selbstständiger Blocktransfer (DMA)
Aufträge an DMA-Steuerung - Richtung: Eingabe/ Ausgabe - Geräteadresse - Speicheradresse - Blocklänge Standart bei schnellen Geräten - Platte - schnelle Fernübertragung - Graphik-Geräte - Video-E/A aber: Speicherzugang kann zum Engpaß werden - Cycle Stealing


Assemblersprache

symbolische Maschinenprogrammierung Beispiel:
Operationssymbol  Operandensymbol(e)
MOVE  N, D0
JUMP  Fertig
Operandensymbole können sein: - Speicher- - Registeradressen * Datenadressen * Codeadressen zusätzlich: - Konstantenschreibweisen - Konstantensymbole - Ausdrücke -> z.B. Labels die Assemblersprache Prozessor:
  • Maschinensprache
  • Registertransferebene ( RT - Ebene )
Befehlsbearbeitung:
  • Befehlszeiger => Speicheradreßregister
  • Speicher: Lesen!
  • Datenleitungen => Befehlsregister
  • Befehlszeiger: Inhalt inkrementieren
jetzt in Abhängigkeit zum Opcode des Befehls:
  • Operandenadresse ( aus Befehl ) => Speicheradreßregister
  • Speicher: Lesen!
  • Datenleitungen => Hilfsregister
  • Operation ( Akku, Hilfsregister ) durch Rechenwerk => Akku
  • Anzeigen => Prozessorstatus
oder Speicherbefehl:
  • Operandenadresse ( aus Befehl ) => Speicheradreßregister
  • Akkuinhalt => Speicherdatenregister
  • Speicher: Schreiben!
=> Zentrale Komponente: Steuerwerk

Steuerwerk:

Im Ablauf der Zeit ( Taktgenerator, Phasen ): - in Abhängigkeit zu Meldeleitungen und Befehlsregisterinhalt ( Opcode ): Steuerleitungen belegen ( Bild siehe Seite 86 im Krumm-Skript )
Steuerwerk (abb4-19.jpg)
Abb. 4-19: Steuerwerk

Mikroprogrammiertes Steuerwerk:

( Bilder siehe Seite 86, 88 im Krumm-Skript ) Horizontale Mikroprogrammierung:
Horizontaler Aufbau (abb4-20.jpg)
Abb. 4-20: Horizontaler Aufbau zur Mikroprogrammierung
je Makrobefehl: 5 - 500 ” Befehle ” P - ROM : breit ( wenige lange Wörter ) breit => horizontale Orientierung Vertikale Mikroprogrammierung: - Mikroadreßregister mit Inkrementierer im Normalfall: Weiterschalten auf Folgeadresse
Vertikaler Aufbau (abb4-21.jpg)
Abb. 4-21: Vertikaler Aufbau zur Mikroprogrammierung
” P - ROM : schmal ( mehrere, aber kürzere Wörter )

schmal => vertikale Orientierung

Varianten:
  • PLA statt ROM
  • Zweistufige Mikroprogrammierung ( Mikro - und Nanobefehle)

Zweistufige Mikroprogrammierung:

- statt Steuerkombination steht im Mikrobefehl: Adresse eines Nanounterprogramms ” - Befehl:
” - Befehl (abb4-22.jpg)
Abb. 4-22: Aufbau der 2-stufigen Mikroprogrammierung
Unterprogramme für Teilabläufe:
  • Operanden holen
  • Ergebnis speichern
  • Operandenzugriffsarten, Adreßvermittlung

Prozessortypen:

...1960: mit wenig teurer Hardware überhaupt funktionsfähigen Prozessor bilden:
  • einfache Maschinensprache
  • Akku - Maschine
  • wenige Operandenzugriffsarten
...1970: CISC - Prozessoren (Complex Instruction Set Computer): - mächtige Maschinenbefehle
  • mächtige Maschinensprache
  • Register - Maschine
  • viele Operandenzugriffsarten
  • viele Spezialbefehle
... 1980: RISC - Prozessoren (Reduced Instruction Set Computers): - sehr schnelle Programmbearbeitung für ( übersetzte ) Hochsprachprogramme
  • äußerst schnelle Hardware
  • reduzierter Befehlssatz
=> Maschinensprache wird von Compilern automatisch erzeugt Trend: in Workstations ( 10 Mips, ... ) statt CISC - Prozessoren ( 80386, 68030 ) RISC - Prozessoren

RISC und CISC - Prozessoren:

CISC:  
  • umfangreicher Befehlssatz,
    viele Operandenzugriffsarten
  • Hardwareaufwand durch ” - Programmierung vermindert
  • Beschleunigung: Bitbreite, Pipelining
RISC:  
  • eingeschränkter Befehlssatz,
    wenige Operandenzugriffsarten
  • keine ” - Programmierung,
    fest verdrahtetes Steuerwerk
  • flüssig zu bearbeitende Befehlspipeline

Beispiel: Prozessor Motorola M 68000

  • Aufbau eines Mikrorechners mit diesem Prozessor
  • Aufbau des Prozessors selbst ( Register - Transfer - Ebene )
} nur einführend
  • Maschinensprach- / Assemblerprogrammierung
    - Rechnermodell
    - Maschinensprache
    • Datentypen
    • Operandenzugriffe
    • Befehle
    - Assemblersprache
    - Assemblerprogrammierung ( Beispiele )
  • Wie funktioniert die Hardware eines Rechners
    Grundzüge der Rechnerarchitektur
  • Wie wird die Hardware eines Rechners benutzt / genutzt
    Grundzüge der Maschinensprachprogrammierung
=> Basiswissen auch für Problembereich der Systemsoftware

Prozessor M 68000

seit 1979 auf dem Markt; einer der ersten 16 / 32 bit - ” - Prozessoren
inzwischen:   68010
68020
68030
68040
  => echte 32 bit Breite Speicherverwaltung
  • höhere Taktfrequenz
  • etwas ausgebauter Befehlssatz
Grobe Daten: - Chipfläche 6,2 * 7,1 mm2 24 Adreßbits - 64 Anschlußbeine ( 2* ) 16 Datenbits intern 32 - bit - Register - Für Busarchitektur Arbeitsspeicher in Wort / Byte - Struktur Adresse identifiziert Byte oder Folge zweier Byte ( Wort ) falls Adresse gerade - Befehlslänge: 16, 32, 48, 64 bit - Register: 8 Daten, 8 Adreßregister - Unterbrechungsfähigkeiten - 4 - 12,5 MHz Taktfrequenz - 2- Adreßbefehle: Register, Speicher Rechner mit M 68000 Prozessor: Grundarchitektur ( Bild siehe Seite 91 im Krumm-Skript )
  • Busarchitektur
  • Arbeitsspeicher:
    16 Datenbits ( 8 Datenbits )
    24 Adreßbits ( 224 Byte )
  • Buskontrolle auf Prozessorchip
  • Geräteanschaltungen ( wie Arbeitsspeicher ) an Bus
  • Bus ( 2 Varianten unterstützt ):
    - schneller asynchroner Bus für 68000 - Peripherie
    - aus Kompatibilitätsgründen synchroner 8 - bit Bus des 68000 zusätzlich

Die Architektur

Prozessor als Hardwarebaustein:

( Bild siehe Seite 92 im Krumm-Skript )

Funktionscode:
  • Befehl holen: System / Nutzer
  • Daten: System / Nutzer
  • Unterbrechungszyklus aktiv
}

für Speicherverwaltung


Unterbrechungen: Meldungen: Adressen: Speichersteuerung: Datenleitungen: Synchroner Busbetrieb:

( siehe auch Krumm-Skript Seite 92 )

Asynchroner Busbetrieb:

( siehe auch Krumm-Skript Seite 92 )

Maschinensprache - M 68000:
Zugriff auf den Bus (abb4-23.jpg)
Abb. 4-23: Zugriff auf den Bus

Prozessorregister des M 68000:

( Bilder siehe Seite 93, 94 im Krumm-Skript )

Befehlsausführung: Zustandsänderung
Befehlsausführung (abb4-24.jpg)
Abb. 4-24: Befehlsausführung

Datentypen des M 68000:

Bit, Bitmuster - Operationen

Speicher:

Ablage im Speicher (abb4-25.jpg)
Abb. 4-25: Ablage im Speicher

Register:

Ablage im Register (abb4-26.jpg)
Abb. 4-26: Ablage im Register
Datentypen des M 68000: Steuerwerk:

Operandenzugriffsarten des M68000:

( Bild siehe Seite 95 im Krumm-Skript )

AS 68000 Assemblersprache:

AS 68000 - Befehle = M 68000 Maschinenbefehle:
Unterprogrammentwurf:
Unterprogrammentwurf (abb4-27.jpg)
4-27: Unterprogrammentwurf
Unterprogrammschachtelung: rekursive Unterprogramme durch Speicherung der Rücksprungadresse im Keller beliebig möglich ( wobei beliebig heißt: solange genügend Platz im Keller vorhanden ist) Programmunterbrechung (Interrupt):
Programmunterbrechung (abb4-28.jpg)
Abb. 4-28: Programmunterbrechung (Interrupt)
Um nach Rückkehr von Interrupt-routine das Programm -so als wäre nichts gewesen- fortsetzen zu können, müssen: - PC und CCR durch den Prozessor gerettet werden - zu Beginn der ITR-Routine programmgesteuert die übrigen Register gerettet werden - vor Rücksprung aus ITR-Routine die übrigen Register wiederhergestellt werden - der Rücksprung durch RTR-Befehl erfolgen: PC, CCR wiederherstellen Dekrementiere und Springe MOVE.W #13, D1 D1:=13 MOVE.W #4, D2 D1:=4 SKOPF m: SUB.W X, D1 D1:=D1-X DBLT D2, SKOPF if D1>= 0 then (dekrementiere bis <0) D2:=D2-1 (Dekrement Bit until Lower Than 0) if D2 <> -1 then goto m; Beispiel für x=5:
x=5 (abb4-29.jpg)
Abb. 4-29: Beispiel x=5
Beispiel für x=5:
x=1 (abb4-30.jpg)
Abb. 4-30: Beispiel x=1
Maschinensprache M68000 die Sonderbefehle: -NOP No OPeration -Softwareinterrupts:
Beispiel eines Softwareinterrupts (abb4-31.jpg)
Abb. 4-31: Beispiel eines Softwareinterrupts
wie Unterprogrammaufruf, aber -Programm i.d.R. im Nutzermodus -ITR-Routine im Systemmodus -> Identitätswechsel Anwendung: Supervisorcall Betriebssystemaufruf Aufruf: TRAP #NR Rufe ITR-Routine NR TRAPV Falls V in CCR: rufe ITR-Routineüberlauf CHK Op1, Dn Falls Dn außerhalb 0..(Op1) rufe ITR-Routine CHK Die letzten beiden Aufrufe dienen dem : Programmlaufbesonderheiten-Test und der Maßnahmen-Einleitung Prozeduren => Unterprogramm, Keller Beispiel: procedure Summe (I,J : integer):integer; var H:integer; begin H:=I+J; H:=H+H; return H; end Summe; => Hauptprogramm: * D1 enthalte X,D2,Y * es soll Summe gerufen werden SUBA.L #2, A7 Platz für Ergebnis MOVE.W D1, -(A7) Parameter I MOVE.W D2, -(A7) Parameter J JSR Summe UP-Aufruf ADDA.L #4, A7 Parameter entfernen MOVE.W (A7)+, D1 Ergebnis->D1 Unterprogramm: H EQU -2 J EQU +8 I EQU +10 result EQU +12 Distanzen der formalen Parameter und Hilfsvariablen in Schachtel Summe: LINK A6, #-2 MOVE.W J(A6), D1 ADD.W I(A6),D1 MOVE.W D1, H(A6) ADD.W D1, D1 MOVE.W D1, H(A6) MOVE.W D1, result(A6) UNLK A6 RTS
Keller (abb4-32.jpg)
Abb. 4-32: Beispiel eines Unterprogramms, Keller
AS-68000-Beispiele: for i:=1 downto 1 do m[i]:=0; MOVE.W N,D0 LEA M,A0 BLT M2 M1 MOVE.W D0, D1 ASL.W #1, D1 CLR.W 0(A0, D1.W) SUBQ.W #1, D0 BGT M1 M2 ... N DC.W 27 M DS.W 28 MOVE.W N,D0 LEA M,A0 ADDA #2, A0 BSR CLEAR ... N DC.W 27 M DS.W 28 ... * UPS CLEAR Speicherbereich mit Nullen belegen * * Ein: * D0 Länge in Wörtern D0>0 * A0 Anfangsadresse * Aus: * Mem [A0,...,A0+2*D0+1]=0,...,0 * Verändert: CCR, A0, D0 CLEAR SUB.W #1,D0 M1 CLR.W (A0)+ DBF D0, M1 RTS

Peripheriegeräte:

Anschluß von Peripherie (abb4-33.jpg)
Abb. 4-33: Anschluß von Peripheriegeräten

E / A - Geräte:

  • Standard E/A - Geräte:

    => Ausgabe
    <= Eingabe
    <=> interaktiv / Dialog
    - Texte, Textzeichen
    - Graphiken
    - Graubilder / Farbbilder
    - Bilder / bewegt
    - Stimme / akustisch
    - Multimedia / ( Verbund)
  • Speichergeräte:

    - Schreib / Lesespeicher
    - Einmalchreibspeicher
    - wahlfreier Zugriff
    - segmentieller Zugriff
    - dateiorientiert
  • Sonderperipherie:
    - digitale / analoge Ein- / Ausgabe
  Kommunikation: Mensch - Rechner

Bildschirm
Tastatur
Drucker, Plotter
Maus, Digitalisierer
Filmbelichter
Mikrophon
Lautsprecher
Videokamera

Kommunikation: Rechner - ( derselbe ) Rechner in der Zeit

magnetische Schichten ( Platte, Floppy, Band )
optischer Speicher
Magnetblasen,
Ladungsverschiebung ( CCD )

Kommunikation: technischer Prozeß --- Rechner

Peripheriesteuerung (abb4-34.jpg)
Abb. 4-34: Peripheriesteuerung
  • Speicherhierarchie:

    teuer <- günstig
    schnell -> langsam

    Prozessor - Cache - Arbeitsspeicher
    Register
  • dauerhafter Speicher ( persistent )

Peripheriegeräte:

Trends der Mensch-/ Maschine - Kommunikation:

früher: Orientierung am Rechner

- Rechnerkosten überwiegen Personalkosten
- Rechner nur belasten mit tatsächlicher Verarbeitung
- Datenaufbereitung durch Mensch

schwierige Steuersprachen, komplexes Operating,
"arme" Peripherie, Batch - Betrieb

Trend: Orientierung am Menschen

- Personalkosten überwiegen Rechnerkosten
- Rechner unterstützen bei Ein- / Ausgabe und Dialog
- Daten möglichst früh an Rechner

graphische objektorientierte Oberflächen
Operating an Anwenderparadigmen orientiert,
interaktiver Betrieb / Dialogbetrieb

Teure Schwelle ( Mensch - Rechner ) möglichst selten überwinden !

- Datenhaltung im Rechner ( Speicherperipherie ) ausgeprägt,
Wiederverwendung früher eingegebener Daten

Trend: auch Langzeitarchivierung per Rechner

- Persönliche Rechner als Zugang zum Gesamtrechensystem:
Mensch <=> Mensch ==> Mensch <=> Rechner <=> Rechner <=> Mensch
z. B. : papierloses Büro
- Daten unmittelbar am Ort der Entstehung aufnehmen:
Betriebsdatenerfassungsgeräte
- Rechnernetze / Verteilte Systeme

integrierte, verteilte Mensch-/ Rechner- Systeme
( Vorstufen: BTX, E-Mail, DTP )