1. Speicher

wahr | falsch (nicht alle) | wahr | falsch (nicht bit sondern Byte)

2. Assemblerprogrammierung

wahr | flasch(Flag register bedingt) | wahr | wahr | falsch(.date auch möglich) | falsch

3. Speicherschutz

falsch(mischform möglich) | wahr | wahr | falsch (mmu nur paging) | falsch | falsch (gilt nur für phy.A.) | wahr | falsch

1)

Pseudocode:

if(eingabe < 0) goto SPEICHER
ZEROCHECK:
if(eingabe-1 < 0) goto ENDE
SPEICHER:
speicher = eingabe

MicroCode:

START:
eingabe -> D
D-> B | D -> E
B->C
if(C>=0) goto ZEROCHECK

SPEICHER:
E-> Speicher
goto START

ZEROCHECK:
B-1 -> C
if(C>=0) goto SPEICHER

ENDE:

2)

Bei der Festverdrahteten sind die Befehle alle gleich groß und können daher in einem Takt decodiert werden. Bei der Mikroprogrammierung dauert das länger und es muss auch erst das Mikroprogramm geladen werden.

3)

Da Macro auf Micro abgebildet wird. Bei Macro gibt es ja die Sprünge.

1)

–TODO–

2)

Page fault. da das pressend bit nicht gesetzt ist

3)

Virtuelle Adresse | Physikalische Adresse | Flags

Valid-Bit wird nicht gespeichert, denn alle Bits müssen valid sein.

4)

Bei Segmentierung, denn da wird die Adresse berechnet (Segmentsanfangsadresse + Offset) wobei bei Paging nur zusammengesetzt wird aus Basis & Offset.

5)

2^N * 1 Byte

1)

hort ist schneller, weil dadurch die vertikal liegenden Blöcke, welche im Cache stehen, besser genutzt werden können bevor ein Cache Miss auftritt.

2)

Da Befehle und Daten sich nicht gegenseitig verdrängen. Befehle und Daten werden bei räumlicher und zeitlicher Lokalität anders gemappt.

3)

Dann müsste man 2 Speicherblöcke auslesen um 1 Datum zu erhalten, was Zeit kostet.

4)

#blocke = s / b
#menge = (#blocke / n)

f(addr_i) = (addr_i / b) % #menge

5)

Vollassoziativ, denn es gibt für jeden Cache-Eintrag einen Vergleicher und es gibt keinen Index.

6)

1)

Code umformen und auf ALU-Operation achten.

int test (int x , int n){
  int akku = 0;
  int ret = 0;
  int i = 0;
  akku = i;
  goto LCOND
  
LOOP:
  int diff2 = 0;
  akku = wert[i];
  akku = akku - x;
  akku = akku * akku;
  diff2 = akku;
  if(akku > 100){
    ret = 1;
    goto END
  }
  akku = i;
  akku = akku + 1;
  i = akku;

LCOND:
if(akku < n) goto LOOP

END:

1)

* Sprungmarken(Labels)

Sprungadresse

* Funktionsaufrufe mit Parametern

call

* Globale Variablen

Liegen im .daten Segment

* Lokale Variablen (auf dem Stack)

Stack reservierung Push Pop

* Kommentare

Keine

2)

ebp: er zeigt auf denn den befehl nach dem call befehl und weis damit auf den Letzten Stack Frame wo das Programm wieder zurück springt

3)

Memory-Mapped-I/O: Damit kann mann ganz normal auf die IO Geräte mit z.b. Mov zugreifen

Isolated-I/O: Mann kann nur mit Speziellen Load befehlen auf die IO zugreifen

4)

RISC: Code Dichte geringer, da Festverdrahtet.

CISC: Code Dichte ist wegen der Mikroprogrammierung höher.

5)

Bei rekursive Algorithmen: Da es dort sehr viele Rücksprungadressen gibt.

1)

Speedup = T1/ Tk = (n*s*t) / (s+(n-1))*t = n*s / s+(n-1) = lim n→inf n*s/s+(n-1) = s

Speedup = s

2)

VLIW muss die Hardware für den Compiler bekannt sein und damit die anzahl der ALUS damit die programme laufen können Superskalar wird komplet vom Prozessor gehändelt und die programme müssen nicht speziel für geschrieben werden(compiler).

3)

Zeitscheiben MT: Jeder Prozess hat immer genau gleich viel zeit zu arbeiten keiner verhungert

Erreignis gesteuerte MT: Wenn der prozessor auf etwas warten muss bis etwas fertig ist dann kann er so lange einen anderen Prozess abarbeiten.

Simultanes MT: es werden Prozesse ausgewahlt die gerade ausgeführt werden (was abgearbeitet werden kann wird abgearbeitet)

4)

Er muss Threads Erstellen

5)

Speed up daher

4(Stufen) * 5(befehle) / 12 (ausführungschritte)

6)

da das programm auf abhängigkeiten warten muss

Falls ihr Fehler findet, oder Fragen habt ist hier der Thread im Forum dazu zum Forum