Speicherverwaltung in Minix

Transkript

1 Speicherverwaltung in Minix

2 Speicher-Layout ausführbare Datei wird in Speicher geladen a.out-header bestimmt Gesamt-Speicherplatz Resultat: Gap zwischen Stack- und Daten-Segmenten

3 Segment-Liste (kombinierte I/D) Stack, Gap, Data und Text bilden eine Einheit Virtuelle Stack-Adresse: Offset zu Daten-Segment Benötigt für Überlauf-Test

4 Segment-Liste (getrennte I/D) Stack, Gap, und Data bilden eine Einheit, Text ist separat

5 Segmente-Liste gemeinsam genutztes Textsegment

6 Speicher-Belegung Ausgangssituation nach fork nach exec

7 Minix- Speicherlayout Speicherplatz für Benutzerprozesse besteht aus zwei Bereichen unterhalb 640 kb oberhalb des Betriebssystems ab ca. 2 MB

8 Speicherverwaltung Freispeicherverwaltung durch Lochliste nach Speicheradresse sortiert bei Freigabe Einsortieren/Zusammenlegen von Löchern zusätzlicher Auslagerungsbereich (swap space) repräsentiert als Löcher am Ende der Lochliste ausgelagert = Adressen > phys. Speicher (swap_base) Basiseinheit für verwalteten Speicher: clicks kleiner Wertebereich verwaltet viel Speicher z.zt Byte (CLICK_SIZE) bytes = clicks << CLICK_SHIFT clicks = bytes >> CLICK_SHIFT

9 Speicheranforderung fork/exec benötigen neuen Speicher MM: Strategie (alloc_mem) Lochliste durchsuchen Auswahl nach first-fit ggf. Auslagerung (swap_out) Kernel: Mechanismus kopieren von Speicherbereichen (sys_copy) abgleichen der Segment-Liste (sys_newmap)

10 PUBLIC phys_clicks alloc_mem(phys_clicks clicks) { register struct hole *hp, *prev_ptr; phys_clicks old_base; do { hp = hole_head; while (hp!= NIL_HOLE && hp->h_base < swap_base) { if (hp->h_len >= clicks) { /* We found a hole that is big enough. Use it. */ old_base = hp->h_base; /* remember where it started */ hp->h_base += clicks; /* bite a piece off */ hp->h_len -= clicks; /* ditto */ /* Delete the hole if used up completely. */ if (hp->h_len == 0) del_slot(prev_ptr, hp); } return(old_base); /* start addr of acquired block. */ } prev_ptr = hp; hp = hp->h_next; } /* no hole big enough */ } while (swap_out()); /* try to swap some other process out */ return(no_mem);

11 Auslagerung (Swapping) nachträglich in Minix eingeführt, optional kein separater Swapper-Prozess MM übernimmt Verwaltung Auslagerung ggf. bei Speicher-Anforderung (alloc_mem) Vorbereitung der Einlagerung bei Signalen, Antwort- Nachrichten, usw. (swap_inqueue) Abarbeitung der Einlagerungs-Warteschlange in Server-Schleife (swap_in) Prozess-Flags für Status (mp_flags,onswap/swapin/...)

12 Auslagerung (swap_out) /* 1. Kandidat finden blockiert, wartend, noch nicht ausgelagert * if (!(rmp->mp_flags & (PAUSED WAITING SIGSUSPENDED))) continue; if (rmp->mp_flags & (TRACED REPLY ONSWAP)) continue; /* 2. Speicher-Platz jenseits swap_base finden und belegen */ for (hp = hole_head; hp!= NIL_HOLE; prev_ptr = hp, hp = hp->h_next) if (hp->h_base >= swap_base && hp->h_len >= size) break; if (hp == NIL_HOLE) continue; new_base = hp->h_base; hp->hp_base += size; hp->hp_len -= size;... /* 3. Prozessabbild von Hauptspeicher in Swap umlagern */ off = swap_offset + ((off_t) (new_base - swap_base) << CLICK_SHIFT); lseek(swap_fd, off, SEEK_SET); /* Offset in Umlagerungsdatei ber. */ rw_seg(1, swap_fd, proc_nr, D, (phys_bytes)size << CLICK_SHIFT); /* 4. Segmentadressen anpassen und dem Kern mitteilen */ old_base = rmp->mp_seg[d].mem_phys; rmp->mp_seg[d].mem_phys = new_base; rmp->mp_seg[s].mem_phys = rmp->mp_seg[d].mem_phys + (rmp->mp_seg[s].mem_vir - rmp->mp_seg[d].mem_vir); sys_newmap(proc_nr, rmp->mp_seg); /* 5. Hauptspeicher-Platz freigeben, Status anpassen */ free_mem(old_base, size); rmp->mp_flags = ONSWAP; Speicher, Clicks Swap-Bereich, Bytes

13 Einlagerung (swap_in) /* 1. Platz im Hauptspeicher finden */ new_base = alloc_mem(size);... /* 2. Segmentadressen anpassen und dem Kern mitteilen */ old_base = rmp->mp_seg[d].mem_phys; /* virt. Addr. im Swap */ rmp->mp_seg[d].mem_phys = new_base; rmp->mp_seg[s].mem_phys = rmp->mp_seg[d].mem_phys + (rmp->mp_seg[s].mem_vir rmp->mp_seg[d].mem_vir); sys_newmap(proc_nr, rmp->mp_seg); /* 3. Prozessabbild von Swap in Hauptspeicher umlagern */ off = swap_offset + ((off_t) (old_base-swap_base)<<click_shift); lseek(swap_fd, off, SEEK_SET); rw_seg(0, swap_fd, proc_nr, D, (phys_bytes)size << CLICK_SHIFT); /* 4. Swap-Platz freigeben, Status anpassen, ggf. Prozess aufwecken*/ free_mem(old_base, size); rmp->mp_flags &= ~(ONSWAP SWAPIN); /* nicht ausgel. oder in Einl. */ check_pending(rmp); Achtung: alloc_mem() kann swap_out() auslösen! -> Während der Einlagerung eines Prozesses werden u.u. andere Prozesse ausgelagert.

14 Physikalische Umlagerung PUBLIC void rw_seg(rw, fd, proc, seg, seg_bytes0) int rw; /* 0 = read, 1 = write */ int fd; /* file descr to read from/write to*/ int proc; /* process number */ int seg; /* T, D, or S */ phys_bytes seg_bytes0; /* how much is to be transferred? */ bezieht sich auf Segmentadressen eines Prozesses Segmentadressen VOR Aufruf anpassen Länge in Bytes, aus Clicks ausrechnen

15 pause.c: #include <unistd.h> int main() { pause(); return 0; } Testen blockiert wegen pause(), nicht bereit, auslagerbar Stacksegment vergrößern, z.b. auf 8 MB cc stack 8m o pause pause.c chmem = pause (text + 8 MB) Auslagerungsbereich einrichten mkswap f /usr/swapfile 8m mount s /usr/swapfile