Lösungsvorschlag

a) TODO

b) 2,4,7,8

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      |  

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.