Du befindest dich hier: FSI Informatik » Prüfungsfragen und Altklausuren » Prüfungen im Bachelor-Studium (1. - 5. Semester) » gra » Aufgabe 1: Allgemein

Unterschiede

Hier werden die Unterschiede zwischen zwei Versionen der Seite angezeigt.

Link zu der Vergleichsansicht

Nächste Überarbeitung		Vorherige Überarbeitung
pruefungen:bachelor:gra:loesungss14 [30.01.2015 15:44] – angelegt Alpha2000pruefungen:bachelor:gra:loesungss14 [24.09.2015 07:48] (aktuell) – Bild an der richtigen Stelle eingefügt (Aufgabe 4), Rechtschreibkorrekturen dom
Zeile 17: Zeile 17:
  
 Pseudocode: Pseudocode:
 +
 +<code>
 +
 +if(eingabe < 0) goto SPEICHER
 +ZEROCHECK:
 +if(eingabe-1 < 0) goto ENDE
 +SPEICHER:
 +speicher = eingabe
 +
 +</code>
  
 MicroCode: MicroCode:
 +<code>
  
 +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:
 +
 +</code>
 2) 2)
  
-Bei der Festverdrahteten sind die Befehle alle gleich Gross und können daher in einem Takt Decodiert werden. +Bei der Festverdrahteten sind die Befehle alle gleich groß und können daher in einem Takt decodiert werden. 
-Bei der Microprogrammierung dauert das länger und es muss auch erst das Microprogramm geladen werden.+Bei der Mikroprogrammierung dauert das länger und es muss auch erst das Mikroprogramm geladen werden.
  
 3) 3)
Zeile 33: Zeile 61:
 1) 1)
  
-Page tabels Malen+**--TODO--**
  
 2) 2)
Zeile 41: Zeile 69:
 3) 3)
  
-Valid | Virtuelle Adresse | Physikalische Adresse | Write enable | Cache disable+Virtuelle Adresse | Physikalische Adresse | Flags 
 + 
 +Valid-Bit wird nicht gespeichert, denn alle Bits müssen valid sein.
  
 4) 4)
  
-Bei Segmentierung denn da wird die adresse berrechnet ( Segments anfangs adresse + Offset) +Bei Segmentierung, denn da wird die Adresse berechnet (Segmentsanfangsadresse + Offset) wobei bei Paging nur zusammengesetzt wird aus Basis & Offset.
- +
-wobei  +
- +
-bei paging nur zusammengesetzt wird aus Basis & offset.+
  
 5) 5)
  
 2^N * 1 Byte 2^N * 1 Byte
 +
  
 ====== Aufgabe 4: Cache ====== ====== Aufgabe 4: Cache ======
Zeile 59: Zeile 86:
 1) 1)
  
-hort ist schneller weil dadurch die vertikal liegenden Blocke die im Cache stehen besser genutzt werden können bevor ein Cache Miss eintritt+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) 2)
  
-Da Befehle und Daten sich nicht gegenseitig verdrängen +Da Befehle und Daten sich nicht gegenseitig verdrängen. Befehle und Daten werden bei räumlicher und zeitlicher Lokalität anders gemappt.
- +
-Befehle und Daten werden bei Räumlicher und Zeitlicher Lokalität anderes gemappt+
  
 3) 3)
  
-Dann müsste man 2 Speicherblöcke auslesen um 1 Datum zu erhalten was zeit kostet+Dann müsste man 2 Speicherblöcke auslesen um 1 Datum zu erhalten, was Zeit kostet.
  
 4) 4)
Zeile 82: Zeile 107:
 5) 5)
  
-Voll assoziatic denn es gibt für jeden cache eintrag ein vergleicher+Vollassoziativ, denn es gibt für jeden Cache-Eintrag einen Vergleicher und es gibt keinen Index.
  
-und+6)
  
-es gibt kein index+{{:pruefungen:bachelor:gra:img_5933b.jpg?600|}}
  
 ====== Aufgabe 5: Umformung ====== ====== Aufgabe 5: Umformung ======
Zeile 92: Zeile 117:
 1)  1) 
  
-Code umformen auf ALU operation achten+Code umformen und auf ALU-Operation achten. 
 + 
 +<code> 
 +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: 
 + 
 + 
 +</code>
  
 ====== Aufgabe 6: Assembler ====== ====== Aufgabe 6: Assembler ======
Zeile 108: Zeile 163:
 * Globale Variablen * Globale Variablen
  
-Liegen im .daten segment+Liegen im .daten Segment
  
 * Lokale Variablen (auf dem Stack) * Lokale Variablen (auf dem Stack)
Zeile 125: Zeile 180:
 3) 3)
  
-Memory Mapped IO: Damit kann mann ganz normal auf die IO Geräte mit z.b. Mov zugreifen+**Memory-Mapped-I/O**: Damit kann mann ganz normal auf die IO Geräte mit z.b. Mov zugreifen
  
-Isolatet IO: Mann kann nur mit Speziellen Load befehlen auf die IO zugreifen+**Isolated-I/O**: Mann kann nur mit Speziellen Load befehlen auf die IO zugreifen
  
 4) 4)
  
-Bei RISC ist die Code Dichte geringer da Festverdrahtet+**RISC**: Code Dichte geringer, da Festverdrahtet.
  
-Bei CISC ist sie höher wegen der Microprogrammierung+**CISC**: Code Dichte ist wegen der Mikroprogrammierung höher.
  
 5) 5)
  
-Bei Rekursion: da es dort sehr viele Rücksprung adressen gibt+Bei rekursive Algorithmen: Da es dort sehr viele Rücksprungadressen gibt.
  
 ====== Aufgabe 7: Prozessorarchitekturen ====== ====== Aufgabe 7: Prozessorarchitekturen ======
Zeile 143: Zeile 198:
 1) 1)
  
-Speed Up formel einfügen -> speedup = s+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) 2)
  
 VLIW muss die Hardware für den Compiler bekannt sein und damit die anzahl der ALUS damit die programme laufen können 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) 3)
Zeile 163: Zeile 221:
 5) 5)
  
-Pipeline zeichnen und Speedup Berrechnen+^ index ^ BHBD   ^ OH    ^ AS     ^ RS       ^ 
 +| 0        | movl(1)  |      -    | -         | -           | 
 +| 1        | movl(2)  | movl(1) | -         | -           | 
 +| 2        | movl(3)  | movl(2) | mov(1)| -           | 
 +| 3        | addl(4)  | movl(3) | movl(2) | movl(1) | 
 +| 4        | addl(4)  | -           | movl(3) | movl(2) | 
 +| 5        | addl(4)  | -           | -           | movl(3) | 
 +| 6        | addl(5)  | add(4)   | -           |             | 
 +| 7        | addl(5)  | -           | add(4)   | -           | 
 +| 8        | addl(5)  | -           | -           | add(4)   | 
 +| 9        | -           | add(5)   | -           | -           | 
 +| 10      | -           | -           | add(5)   | -           | 
 +| 11      | -           | -           | -           | add(5)   | 
 +| 12      | -           | -           | -           | -           | 
 + 
 + 
 +Speed up daher 
 + 
 +4(Stufen) * 5(befehle) / 12 (ausführungschritte)
  
 6) 6)
Zeile 169: Zeile 245:
 da das programm auf abhängigkeiten warten muss da das programm auf abhängigkeiten warten muss
  
 +====== FORUM ======
 +
 +Falls ihr Fehler findet, oder Fragen habt ist hier der Thread im Forum dazu [[https://fsi.informatik.uni-erlangen.de/forum/thread/12310-Loesungen-SS14|zum Forum]]