====== Lösungsvorschlag ======



==== Aufgabe 1.2: Mehrfachauswahl-Fragen ====

**a)** TODO

**b)** 2,4,7,8

==== Aufgabe 3: ====

**a)** 

a) 
  worst-fit:
  - Erklaerung: Speicherbereich vom groessten (dem ersten Speicher abziehen) und   Anfangsadresse um den selben Wert erhoehen
  - vor/fuer den naechsten Schritt den groessten freien Speicheraum unabhaengig von der  Adresse nach vorne ziehen


  624|400 -> 300|60
  //1. Freispeicherblock: 624B frei zwischen 400 und 1024 (so rum, da worst fit: Liste  absteigend sortiert)
  //2. Freispeicherblock: 300B frei zwischen 60 und 360
  
  1 malloc(300 )
  1. Block ist größter -> allokation von 400 bis 700
  324|700 -> 300|60
  //1. Freispeicherblock: 324B frei zwischen 700 und 1024
  //2. Freispeicherblock: 300B frei zwischen 60 und 360
  
  2 malloc(50)
  -> allokation von 700 bis 750
  300|60 -> 274|750
  //1. Freispeicherblock: 300B frei zwischen 60 und 360
  //2. Freispeicherblock: 274B frei zwischen 750 und 1024
  
  3 malloc(70)
  -> allokation von 60 bis 130
  274|750 -> 230|130
  //1. Freispeicherblock: 274B frei zwischen 750 und 1024
  //2. Freispeicherblock: 230 frei zwischen 130 und 360
  
  4 malloc(200)
  -> allokation von 750 bis 950
  230 |130 ->74|950
  //1. Freispeicherblock: 230 frei zwischen 130 und 360
  //2. Freispeicherblock: 74B frei zwischen 750 und 1024
  
  5 malloc(60)
  -> allokation von 130 bis 190
  170|190 ->74|950
  //1. Freispeicherblock: 170 B frei ab 130
  //2. Freispeicherblock:   74 B frei ab 950
  
b) 
Buddyverfahren: 

  initial sind zwei 64 B-Blöcke (für 40 B und 60 B) von 0-63 und von 64-127 belegt.
  Größe - Adresse
  1024 -
  512 - 512
  256 - 256
  128 - 128
  64 -
  32 -
       |:::::::::|               |                       |                              |
            128           256               512

  malloc(300)
  Da  Malloc 300 und im Buddyverfahren nur zweierpotenzen => 512 belegen,  wir sehen 512 ist   frei  => 512 belegen und aus der Freispeichertabelle löschen 
       |:::::::::|             |                       |:::::::::::::::::::::::::::::::::::::::::::::|
            128         256               512
  Größe - Adresse
  1024 -
  512   -
  256   -256
  128   - 128
  64     -
  32     -
  
 malloc(50)
  Da   Malloc 50 und im Buddyverfahren nur zweierpotenzen => 64belegen,   wir sehen 64  gibt   es nicht , also gucken wir eins drüber- wir sehen bei 128 ist was frei (addr: 128) ,  128  kann man aber noch teilen /2 => 64 
  wir teilen es und belegen ab addr. 128   64 bit => bis addr. 192 => es wird ein neuer   Speicherblock noch frei, nämlich die andere hälfte des gerade geteilten 128 blocks =>  64 großer block ab 192
       |:::::::::|:::::::|         |                       |:::::::::::::::::::::::::::::::::::::::::::::|
            128  192   256               512
  Größe | Addr
  1024   |
  512     |
  256     |256
  128     |  
  64       |192
  32      |
   
malloc(70)
   weil 192 nur 64 groß ist
  malloc(70) =>  128 , da 192 zu klein, nehme 256  - teile 256 durch 2 
       |:::::::::|:::::::|         |::::::::::::::|            |:::::::::::::::::::::::::::::::::::::::::::::|
            128  192   256      384    512
  Größe | Addr
  1024   |
  512     |
  256     |
  128     |384  
  64       |192
  32      | 
  
malloc(200)
  null (not enough memory)
       |:::::::::|:::::::|         |::::::::::::::|            |:::::::::::::::::::::::::::::::::::::::::::::|
            128  192   256      384    512
  Größe | Addr
  1024   |
  512     |
  256     |
  128     |384  
  64       |192
  32      |
   
   
malloc(60)
  null (not enough memory)//passt doch rein
       |:::::::::|:::::::|:::::::::|::::::::::::::|            |:::::::::::::::::::::::::::::::::::::::::::::|
            128  192   256      384    512
  Größe | Addr
  1024   |
  512     |
  256     |
  128     |384  
  64       |
  32      |  



==== Aufgabe 4: ====
**a)** TODO

**b)**
Seitenflatter ist das ständige einlagern gerade erst ausgelagerter Segmente im Speicher nur um danach schnell wieder ausgelagert zu werden. Passiert dies häufig in einem gewissen Zeitraum, 
ist der Prozessor nurnoch mit dem Ein und Auslagern beschäftigt. Dann spricht man von Seitenflattern.