web-dev-qa-db-fra.com

Calcul de la taille du tableau des pages

Je lis un exemple de tableaux de pages et je viens de trouver ceci:

Considérez un système avec un espace d'adressage logique 32 bits. Si la taille de page dans un tel système est de 4 Ko (2 ^ 12), alors une table de pages peut être constituée de jusqu'à à 1 million d'entrées (2 ^ 32/2 ^ 12). En supposant que chaque entrée se compose de 4 octets, chaque processus peut nécessiter jusqu'à 4 Mo d'espace d'adressage physique pour la table de pages uniquement.

Je ne comprends pas vraiment ce que représente ce résultat de 4 Mo. Représente-t-il l'espace occupé par le tableau de pages réel?

memory-managementpaging
37
mino

Puisque nous avons un espace d'adressage virtuel de 2 ^ 32 et que chaque taille de page est 2 ^ 12, nous pouvons stocker (2 ^ 32/2 ^ 12 2 ^ 20 pages) ==. Puisque chaque entrée dans ce tableau de pages a une adresse de taille 4 octets, nous avons alors 2 ^ 20 * 4 = 4 Mo. Ainsi, le le tableau des pages occupe 4 Mo de mémoire.

57
mino

Mon explication utilise des blocs de construction élémentaires qui m'ont aidé à comprendre. Notez que je tire parti de @ la réponse de Deepak Goyal ci-dessus car il a fourni la clarté:

On nous a donné un espace d'adressage logique 32 bits (c'est-à-dire que nous avons un ordinateur 32 bits)

Envisagez un système avec un espace d'adressage logique 32 bits

On nous a également dit que

chaque taille de page est de 4 Ko

  • 1 Ko (kilo-octet) = 1 x 1024 octets = 2 ^ 10 octets
  • 4 x 1024 octets = 2 ^ 2 x 2 ^ 10 octets => 4 Ko (soit 2 ^ 12 octets)
  • La taille de chaque page est donc de 4 [~ # ~] ko [~ # ~] (Kilo octets PAS kilo bits ).

Comme l'a dit Depaak, nous calculons le nombre de pages dans le tableau des pages avec cette formule:

Num_Pages_in_PgTable = Total_Possible_Logical_Address_Entries / page size 
Num_Pages_in_PgTable =         2^32                           /    2^12
Num_Pages_in_PgTable = 2^20 (i.e. 1 million)

Les auteurs donnent ensuite le cas où chaque entrée du tableau des pages prend 4 octets. Cela signifie que la taille totale de la table des pages dans la mémoire physique sera de 4 Mo:

Memory_Required_Per_Page = Size_of_Page_Entry_in_bytes x Num_Pages_in_PgTable
Memory_Required_Per_Page =           4                 x     2^20
Memory_Required_Per_Page =     4 MB (Megabytes)

Donc oui, chaque processus nécessiterait au moins 4 Mo de mémoire pour s'exécuter, par incréments de 4 Mo.

Exemple

Maintenant, si un professeur voulait rendre la question un peu plus difficile que l'explication du livre, il pourrait poser des questions sur un ordinateur 64 bits. Disons qu'ils veulent de la mémoire en bits . Pour résoudre la question, nous suivrions le même processus, en étant sûr de convertir MB en Mbits.

Passons en revue cet exemple.

Donne:

  • Espace d'adressage logique: 64 bits
  • Taille de la page: 4 Ko
  • Entry_Size_Per_Page: 4 octets

Rappel: Une entrée 64 bits peut pointer vers l'un des 2 ^ 64 cadres de page physiques - Comme la taille de la page est de 4 Ko, nous avons encore 2 ^ 12 tailles de page en octets

  • 1 Ko (kilo-octet) = 1 x 1024 octets = 2 ^ 10 octets
  • Taille de chaque page = 4 x 1024 octets = 2 ^ 2 x 2 ^ 10 octets = 2 ^ 12 octets

Combien de pages dans le tableau des pages?

`Num_Pages_in_PgTable = Total_Possible_Logical_Address_Entries / page size 
Num_Pages_in_PgTable =         2^64                            /    2^12
Num_Pages_in_PgTable =         2^52 
Num_Pages_in_PgTable =      2^2 x 2^50 
Num_Pages_in_PgTable =       4  x 2^50 `

Combien de mémoire dans BITS par page?

Memory_Required_Per_Page = Size_of_Page_Entry_in_bytes x Num_Pages_in_PgTable 
Memory_Required_Per_Page =   4 bytes x 8 bits/byte    x     2^52
Memory_Required_Per_Page =     32 bits                x   2^2 x 2^50
Memory_Required_Per_Page =     32 bits                x    4  x 2^50
Memory_Required_Per_Page =     128 Petabits

[2]: Concepts du système d'exploitation (9e édition) - Gagne, Silberschatz et Galvin

14
CodeSamurai-like

Supposons que l'espace d'adressage logique soit ** 32 bits pour que le nombre total d'entrées logiques possibles soit 2 ^ 32 et d'autre part supposent que chaque taille de page est 4 octets alors la taille d'une page est * 2 ^ 2 * 2 ^ 10 = 2 ^ 12 ... * maintenant nous savons que non. des pages dans le tableau de pages est pages = total des entrées d'adresses logiques possibles/taille de la page donc pages = 2 ^ 32/2 ^ 12 = 2 ^ 20 Supposons maintenant que chaque entrée du tableau de pages prenne 4 octets, puis la taille totale du tableau de pages en * la mémoire physique sera = 2 ^ 2 * 2 ^ 20 = 2 ^ 22 = 4 Mo ***

4
DEEPAK GOYAL

Étant donné que l'espace d'adresse logique est de 32 bits, cela signifie que la taille du programme est de 2 ^ 32 octets, soit 4 Go. Nous avons maintenant la taille de la page de 4 Ko, soit 2 ^ 12 octets. Le nombre de pages dans le programme est donc de 2 ^ 20 (nombre de pages dans le programme = taille du programme/taille de la page). octet donc la taille du tableau des pages est de 2 ^ 20 * 4 = 4 Mo (taille du tableau des pages = nombre de pages dans le programme * taille d'entrée du tableau des pages). Par conséquent, 4 Mo d'espace sont nécessaires dans la mémoire pour stocker la table de pages.

3
Ravi Kashyap

Dans un système d'adresse virtuelle 32 bits, nous pouvons avoir 2 ^ 32 adresse unique, car la taille de page donnée est de 4 Ko = 2 ^ 12, nous aurons besoin de (2 ^ 32/2 ^ 12 = 2 ^ 20) entrées dans le tableau des pages, si chaque entrée est de 4 octets, puis la taille totale du tableau de pages = 4 * 2 ^ 20 octets = 4 Mo

2
udion