Beste antwoord
Welnu, paginaformaat is de ruimte die 1 pagina nodig heeft. (Dat is vrij eenvoudig )
Om hier wat achtergrondinformatie te hebben, is een paginatabel een tabel met conversies van virtuele naar fysieke adressen die het besturingssysteem gebruikt om kunstmatig verhoog de totale hoeveelheid hoofdgeheugen die beschikbaar is in een systeem. Fysiek geheugen zijn de feitelijke bits die zich op adressen in het geheugen (DRAM) bevinden, virtueel geheugen is waar het besturingssysteem tegen processen liegt om hen te vertellen waar het zich bevindt om dingen te doen zoals 2 ^ 64 bits adresruimte toestaan ondanks het feit dat 2 ^ 34 bits de meeste RAM is die normaal wordt gebruikt. (2 ^ 32 bits is 4 gigabyte, dus 2 ^ 34 is 16 GB.)
Nu zijn de meeste standaard paginatabelformaten 4096 kb voor elk proces, maar het aantal paginatabelitems kan toenemen als het proces meer procesruimte nodig heeft. Paginatabelformaten kunnen in eerste instantie ook worden toegewezen aan kleinere of grotere hoeveelheden of geheugen. “Het is gewoon dat 4 kb gewoonlijk de beste grootte is voor de meeste processen. Dus de paginatabelinvoergrootte zou precies de juiste hoeveelheid ruimte hebben voor elk adres in een 32-bits adresruimte.
Laten we eens kijken naar een voorbeeld: Beschouw een systeem met een 32-bits logische adresruimte. Als de pagina de grootte in een dergelijk systeem 4 KB (212) is, kan een paginatabel uit maximaal 1 miljoen items (232/212) bestaan. Ervan uitgaande dat elk item uit 4 bytes bestaat , kan elk proces tot 4 MB fysieke adresruimte nodig hebben voor alleen de paginatabel.
Hoe het volledig te begrijpen?
Antwoord: 4 bytes (32 bits ) is precies de juiste hoeveelheid ruimte voor elk adres in een 32-bits adresruimte. Omdat 1 miljoen ingangen van elk 4 bytes 4 MB zijn, heeft een proces “mogelijk” 4 MB fysieke adresruimte nodig.
Antwoord
Een pagina ta ble wordt per proces door het besturingssysteem onderhouden. Elk proces heeft zijn eigen paginatabel , en daarom hoeven we geen proces-ID (s) op te slaan in de paginatabel. Paginatabel wijst een gegeven logisch / virtueel paginanummer toe aan het daadwerkelijke fysieke frame / pagina-adres.
Het logische adres voor een geheugenreferentie heeft de volgende vorm:
Logisch adres:
Paginanummer (virtueel paginanummer) wordt gebruikt om de paginatabel op te zoeken en het basisadres op te halen van het fysieke frame waaraan het is toegewezen. Het basisadres van het frame (f) wordt dan gecombineerd met offset in de pagina (d) om het fysieke geheugenframe-adres te krijgen als:
f = page-table [p]
Fysiek adres:
Beschouw nu een systeem met:
1. logische adresruimte: 32-bits 2. paginaformaat: 4KB (2 ^ 12) 3. invoergrootte paginatabel: 4 bytes 4. fysiek geheugen: 2GB
Houd er rekening mee dat 4 bytes van een paginatabelinvoer slaat effectief meerdere soorten informatie op, afgezien van het basisadres van het fysieke frame. Deze informatie kan zijn voor geheugenbescherming (geldige / ongeldige bit), type toegang (lezen / schrijven), boekhouding enz. Dus, wanneer Ik verwijs naar het fysieke frameadres (f), ik verwijs eigenlijk naar dit specifieke deel van de invoer van 4 bytes.
Laten we de grootte van een paginatabel berekenen:
Grootte van de paginatabel = (aantal items * grootte van elk item).
Gegeven de bovenstaande parameters, zal een 32-bits logisch adres worden gepartitioneerd in:
of
.
We kunnen nu berekenen dat het aantal items in de paginatabel (totaal aantal virtuele paginanummers) zo groot kan zijn als 2 ^ 20. Daarom zou de grootte van de paginatabel zijn:
(2 ^ 20) * 4 bytes = 4 MB ruimte (per proces).
Zoveel ruimte zou nodig zijn in fysiek geheugen voor de paginatabel van elk proces. Vergeet niet dat we slechts 2 GB hoofdgeheugen hebben, en 4 MB van die ruimte voor paginatabel van elk proces is misschien geen goed idee. Ook is er aan veel van de virtuele adressen misschien geen fysiek pagina-adres toegewezen. Maar , zal de grootte van de paginatabel nog steeds groot zijn. Zelfs als de “geldige” bit niet is ingesteld voor een virtueel paginanummer, moet er een ruimte voor zijn in de paginatabel.
In het geval van gedeelde geheugen, vereist het hebben van een paginatabel per proces een invoer van dezelfde fysieke pagina in de paginatabel van elk proces dat een gedeelde toegang tot die pagina heeft, zodat het systeem uiteindelijk meerdere vermeldingen voor hetzelfde fysieke frame-adres zal behouden. Geen erg goed gebruik van fysiek geheugen.
We kunnen ook begrijpen dat een paginatabel voor elk proces één vermelding per virtueel adres bevat. De grootte van de tabel is dus evenredig met de grootte van logisch / virtueel adresruimte die enorm kan blijken te zijn.
Ons doel is het verminderen / optimaliseren van de hoeveelheid fysiek geheugen die nodig is om de paginatabellen op te slaan. Omgekeerde paginatabel is zon oplossing.
Omgekeerde paginatabel is een globale paginatabel die door het besturingssysteem wordt bijgehouden voor alle processen. Er is slechts één paginatabel in het hele systeem, wat inhoudt dat er aanvullende informatie in de paginatabel moet worden opgeslagen om paginatabel-items te identificeren die overeenkomen met elk proces.
Het slaat één invoer per fysiek frame op, en is een lineaire array waar de inhoud op elke locatie
Dit betekent meteen dat er geen opzoekingen meer kunnen plaatsvinden op het virtuele paginanummer. De hele tabel moet item voor item worden doorzocht om een overeenkomend item te vinden waarvan de pid gelijk is aan “id” en het virtuele paginanummer gelijk is aan “p”. De indexlocatie die overeenkomt met de overeenkomst is het fysieke frame-adres (f), dat vervolgens gecombineerd met de offset (d) het fysieke adres geeft.
We kunnen die opzoektijd gemakkelijk afleiden in een omgekeerde pagina tabel kan aanzienlijk hoger zijn in vergelijking met een eenvoudige paginatabel .
Echter, omdat de tabel één invoer per fysiek frame-adres opslaat en er een enkele paginatabel in het hele systeem is, is de hoeveelheid geheugen die door de omgekeerde paginatabel wordt gebruikt aanzienlijk verminderd. Hoe?
Overweeg nogmaals dezelfde parameters:
1. logische adresruimte: 32-bits 2. paginagrootte: 4KB (2 ^ 12) 3. invoergrootte paginatabel: 4 bytes. 4. fysiek geheugen: 2GB (2 ^ 31)
Aantal vermeldingen in de paginatabel = aantal fysieke paginas =
(2 ^ 31) / (2 ^ 12) = 2 ^ 19 fysieke paginas of frames.
Laten we zeggen dat we proces-IDs van 1 byte gebruiken. De grootte van elk paginatabelinvoer zou zijn:
8 bits (PID) + 20 bits ( virtueel paginanummer) + 4 bits (toegangsinformatie) = 32 bits = 4 bytes.
Grootte van de paginatabel = (2 ^ 19) * 4 = 2 MB voor het hele systeem.
Prestaties van geïnverteerde paginatabellen worden meestal aangepakt via gehashte paginatabellen. Maar er is nog een nadeel van het gebruik van geïnverteerde paginatabellen, afgezien van prestaties. Het is gedeeld geheugen.
Omdat er maar één item is in de paginatabel per fysiek frame, en dat precies één virtueel paginanummer bevat, kunnen we hetzelfde fysieke frame niet langer toewijzen aan meerdere virtuele paginanummers in verschillende processen. Er zijn manieren om dit te omzeilen, maar niet op de hoogte van de details om hier te schrijven .
Bron – Besturingssysteemconcepten (Silberschatz et al)