La Memòria Virtual

La memòria
virtual
Enric Morancho Llena
Dolors Royo Vallés
PID_00215286
© FUOC • PID_00215286 La memòria virtual
Cap part d'aquesta publicació, incloent-hi el disseny general i la coberta, no pot ser copiada,
reproduïda, emmagatzemada o transmesa de cap manera ni per cap mitjà, tant si és elèctric com
químic, mecànic, òptic, de gravació, de fotocòpia o per altres mètodes, sense l'autorització
prèvia per escrit dels titulars del copyright.
© FUOC • PID_00215286 La memòria virtual
Índex
Introducció.................................................................................................. 5
Objectius....................................................................................................... 6
1. Concepte de memòria virtual......................................................... 7
2. Suport de maquinari........................................................................ 9
2.1. Funcionalitats mínimes que ha d’oferir una MMU .................... 9
2.2. Consideracions d’eficiència ......................................................... 10
3. Polítiques de gestió de la memòria virtual................................. 13

3.1. Polítiques de reemplaçament ...................................................... 14
3.1.1. L’algorisme de reemplaçament òptim ........................... 15
3.1.2. L’algorisme de reemplaçament FIFO ............................. 16
3.1.3. L’algorisme de reemplaçament LRU .............................. 17
3.1.4. Els algorismes de reemplaçament LFU i MFU ............... 20
3.1.5. Consideració final: pàgines modificades ....................... 20
3.2. Polítiques d’assignació ................................................................ 20
3.2.1. Algorismes d’assignació ................................................. 21
3.2.2. Conjunt de treball ......................................................... 22
Resum............................................................................................................ 24
Activitats...................................................................................................... 25
Exercicis d'autoavaluació........................................................................ 26
Solucionari.................................................................................................. 28
Glossari......................................................................................................... 29
Bibliografia................................................................................................. 30
Annexos........................................................................................................ 31
© FUOC • PID_00215286 5 La memòria virtual
Introducció
En aquest mòdul didàctic s’estudia amb detall la gestió de la memòria virtual

o, més concretament, la gestió de la memòria virtual paginada. Els continguts
del mòdul es poden dividir en tres parts ben diferenciades:
1) Primer es repassen alguns conceptes importants que són necessaris per a

poder seguir els continguts de la resta del mòdul.
2) Després es descriu el suport de maquinari necessari per a la implementació

de la memòria virtual paginada.
3) Finalment, es descriuen algunes de les polítiques d’assignació, reemplaça-

ment i càrrega proposades en explicar la implementació de la memòria virtual.
A més a més, en un annex del mòdul es descriuen algunes característiques de

la gestió de memòria en el nucli Linux.
Objectius
Els materials didàctics d’aquest mòdul contenen les eines necessàries perquè
assoliu els objectius següents:
1. Ampliar el concepte de memòria virtual que heu après en altres assigna-

tures mitjançant la descripció de les necessitats de maquinari i de progra-
mari que té el sistema per a implementar de manera eficient la gestió de
la memòria virtual paginada.
2. Conèixer les diferents polítiques de gestió de la càrrega, d’assignació i de

reemplaçament de pàgines i analitzar-ne els avantatges i els inconvenients.
3. Veure de quina manera la gestió de la memòria afecta l’execució de codi

de programes.
4. Conèixer els aspectes més importants de l’assignació de memòria en el

nucli Linux.
1. Concepte de memòria virtual
Vegeu també
L’objectiu principal de la memòria�virtual és oferir als processos una
visió idealitzada de la memòria. En el mòdul “Gestió de memò-
ria” de l’assignatura Sistemes
operatius es presenta el con-
cepte de memòria virtual.
Entre d’altres coses, aquesta idealització permet que cada procés disposi, com
a mínim, d’un espai d’adreces (espai lògic) per a ell sol, independent dels de
la resta de processos en execució; a més a més, pot permetre als processos dis-
posar d’un espai lògic de mida superior al de la memòria física instal·lada. Per
tant, la memòria virtual amaga als processos diverses problemàtiques relacio-
nades amb la memòria com ara la compartició de la memòria física entre di-
versos processos, la fragmentació externa, el fet de tenir tota la memòria física
ocupada i haver de gestionar una jerarquia de memòria... Tot i el cost de pro-
gramari i maquinari de les implementacions de memòria virtual, els avantat-
ges de disposar de memòria virtual són considerables.
Avantatges de disposar de memòria virtual
Alguns dels avantatges són, per exemple, simplificar la tasca del programador, reduir el
temps de càrrega dels programes (per a començar a executar un programa, no cal que
estigui carregat totalment a la memòria física), permetre l’augment del grau de multipro-
gramació (la suma de les mides dels espais lògics de tots els processos pot superar la capa-
citat de la memòria física amb escreix), permetre compartir dades i codi entre processos...
(1)
En l’assignatura que tracta de sistemes operatius es veu una possible imple- En anglès, swap area.
mentació de memòria virtual basada en paginació. Aquesta implementació
utilitza un maquinari especialitzat anomenat memory management unit (MMU)
que tradueix dinàmicament, és a dir, en temps d’execució, les adreces lògiques
generades pels processos en adreces físiques. A més, disposa d’un espai en disc
(àrea d’intercanvi1) per a poder emmagatzemar tota aquella informació que,
en un moment donat, no pot ser emmagatzemada a la memòria física.
Les implementacions de memòria virtual tenen un component de maquinari Nota

i un altre de programari. Això es deu a dos factors:
Tot i que hi ha diverses imple-
mentacions possibles de me-
a) Els sistemes computadors accedeixen contínuament a memòria. Penseu que mòria virtual, en aquest mòdul
també assumirem, sense pèr-
el pas previ a executar qualsevol instrucció de llenguatge màquina és llegir-la dua de generalitat, una imple-
mentació basada en paginació.
de la memòria. A més a més, una quantitat molt significativa d’instruccions de
llenguatge màquina (típicament, el 40% de les instruccions executades) també
requereix llegir o escriure a la memòria (són instruccions de tipus load o store).
Per tant, per no penalitzar el rendiment de la màquina és aconsellable que, en
el cas general, la implementació de memòria virtual es faci íntegrament per
maquinari.
b) Algunes de les tasques que ha de dur a terme una implementació de me- Implementació de
mòria virtual poden ser relativament complexes i poden variar d’una versió memòria virtual
a una altra del sistema operatiu. Per tant, aquestes tasques acostumen a ser Alguns exemples de les tas-
implementades per codi propi del sistema operatiu, és a dir, estan implemen- ques que ha de dur a terme
una implementació de memò-
tades per programari. ria virtual són decidir quina
part de l’espai lògic d’un pro-
cés es troba a la memòria físi-
ca i quina a l’àrea d’intercanvi,
En aquest mòdul farem un breu repàs al component de maquinari de les im- decidir quantes pàgines pot
plementacions de memòria virtual i veurem en detall el component de pro- tenir carregades el procés a
la memòria, portar pàgines
gramari de la implementació de memòria virtual. des de l’àrea d’intercanvi a la
memòria física (swap-in), i a
l’inrevés, des de la memòria fí-
sica a l’àrea d’intercanvi (swap-
out)...
2. Suport de maquinari
Aquest apartat fa un breu repàs del suport de maquinari necessari per a imple-
mentar memòria virtual basada en paginació. A més, es faran algunes consi-
deracions que cal tenir en compte en una implementació de memòria virtual.
2.1. Funcionalitats mínimes que ha d’oferir una MMU
(2)
MMU és la sigla de memory ma-
Les funcionalitats�mínimes que ha d’oferir l’MMU que implementi 2 nagement unit.
memòria virtual són un mecanisme de traducció i la capacitat de generar

excepcions en determinats escenaris.
(3)
1)�Mecanisme�de�traducció. Tradueix cada adreça lògica generada per un pro- Bit�de�validesa: indica si la pàgi-
na pertany a l’espai lògic del pro-
cés a l’adreça física equivalent. Un sistema de gestió de memòria basat en pagi-
cés.
nació divideix l’espai lògic i l’espai físic en porcions de mida fixa anomenades Bit�de�presència: indica si una pà-
gina vàlida està carregada a la me-
pàgines. L’MMU descompon les adreces lògiques en dos components (identifi- mòria física.
cador de pàgina i desplaçament dins de la pàgina). Per a fer la traducció, con-
(4)
sulta una taula de pàgines en què cada entrada conté l’identificador de trama En anglès, read only.
(pàgina física) on s’emmagatzema la pàgina lògica i també un seguit de bits
(5)
de control –com a mínim, validesa i presència3, però en pot tenir altres com En anglès, dirty bit.
“només lectura4”, execució, modificació5, accedit...
Taula de pàgines
La taula de pàgines és inicialitzada pel sistema operatiu en crear el procés. A mesura que
el procés s’executa, el sistema operatiu l’actualitza.
(6)
2)�Generació�d’excepcions. En cas que el mecanisme de traducció no pugui En anglès, page fault.
fer la traducció, l’MMU generarà una excepció. L’MMU pot generar diversos
tipus d’excepcions, però les més habituals són: adreça lògica invàlida (genera-
da quan el procés intenta accedir a una pàgina invàlida) i fallada de pàgina6
(generada quan el procés intenta accedir a una pàgina vàlida però que no és
present a la memòria física perquè es troba a l’àrea d’intercanvi).
Les rutines de tractament per a aquestes excepcions són rutines pròpies del
sistema operatiu. Quan es produeixi una excepció, el sistema operatiu pren-
drà el control de la situació i intentarà posar remei al problema: si no és pos-
sible solucionar-lo, el sistema operatiu avortarà el procés; si és possible soluci-
onar-lo, el sistema operatiu farà reprendre l’execució del procés des de l’accés
a memòria que ha provocat l’excepció.
Exemples de generació d’excepcions
Si un procés intenta accedir a una pàgina vàlida però que no està present a la memòria
física, la rutina d’atenció a l’excepció de fallada de pàgina llegirà a l’àrea d’intercanvi la
pàgina sol·licitada i la copiarà a memòria física (possiblement, també calgui copiar la pà-
gina de memòria física que se sobreescriu a l’àrea d’intercanvi), actualitzarà les estructu-
res de dades del sistema operatiu relatives a memòria virtual i farà que el procés continuï
l’execució des de l’accés a memòria que ha provocat l’excepció.
Un altre escenari que pot provocar una excepció és el desbordament de la pila d’execució,
és a dir, quan un procés intenta empilar alguna dada a aquesta pila (per exemple, una
variable local, un paràmetre d’una rutina, l’adreça de retorn a una funció...) però resulta
que aquesta ja és plena, ja que en crear el procés, el sistema operatiu assigna un determi-
nat nombre de pàgines lògiques a la pila. Si aquest nombre resulta insuficient, s’acabarà
produint un desbordament de la pila. Aquest escenari provoca que el procés intenti acce-
dir a una pàgina marcada com a invàlida. La rutina del sistema operatiu que atén aquesta
excepció intentarà augmentar la mida de la pila d’execució i farà que el procés es torni
a executar des de la instrucció que ha provocat el desbordament de la pila. En cas que
la mida de la pila d’execució ja hagi arribat a la mida màxima que permet el sistema
operatiu, la rutina de tractament a l’excepció farà avortar el procés.
La figura 1 mostra un diagrama amb la implementació d’una MMU basada en

paginació. L’MMU rep una adreça lògica (@L), la separa en dos components
(identificador de pàgina lògica i desplaçament) i, en funció del contingut de la
taula de pàgines, genera la traducció a adreça física (@F) o genera una excepció
(adreça lògica invàlida o fallada de pàgina).
Figura 1. Implementació d’una MMU basada en paginació que suporti memòria virtual
2.2. Consideracions d’eficiència
Les implementacions de memòria virtual topen amb alguns problemes

d’eficiència i d’ús de recursos. El maquinari dóna un cert suport per a mini-
mitzar l’impacte d’aquests problemes.
1)�Estructura�de�la�taula�de�pàgines
En les implementacions més senzilles de paginació, la taula de pàgines ha de

tenir tantes entrades com el nombre de pàgines que pot arribar a tenir l’espai
lògic del procés, independentment de la validesa de les pàgines. Assumint un
espai lògic de 232 posicions de memòria i pàgines de 4 kB, això comporta que
la taula de pàgines tingui 220 entrades; si cada entrada de la taula de pàgines
ocupa 4 octets, la taula de pàgines ocuparà 4 MB. Aquestes mesures coincidei-
xen amb les que fa servir l’arquitectura IA-32.
Per tant, en general, la taula de pàgines no es pot emmagatzemar en re-

gistres sinó que cal emmagatzemar-la en memòria. La manera més senzilla
d’emmagatzemament seria la contigua, però això comporta desaprofitar me-
mòria perquè els processos no acostumen a utilitzar totes les entrades de la
taula de pàgines.
Per a solucionar aquests problemes algunes arquitectures permeten organitzar

les taules de pàgines en dos nivells o suportar diverses mides de pàgines simul-
tàniament (per exemple, l’arquitectura IA-32 suporta pàgines de 4 kB, 2 MB i 4
MB). L’organització en dos nivells permet emmagatzemar la taula de pàgines
de manera no contigua i reduir l’espai ocupat per la taula de pàgines si moltes
pàgines no són vàlides.
2)�TLB�(translation�lookaside�buffer).
(7)
Conceptualment, la traducció d’adreces basada en paginació requereix fer dos TLB és la sigla de translation lo-
okaside buffer.
accessos a memòria física per a cada referència a memòria lògica: el primer per
a accedir a l’entrada corresponent de la taula de pàgines i el segon per a accedir (8)
En anglès, TLB miss.
realment a la dada. Com que aquest sobrecost no és tolerable, els sistemes de
traducció basats en paginació acostumen a disposar d’una memòria cau que
Vegeu també
conté les darreres entrades utilitzades de la taula de pàgines. Aquesta memòria
rep el nom de TLB7. Abans d’accedir a la taula de pàgines, l’MMU accedeix La localitat temporal i espacial
es tracten en l’annex 1, “Loca-
al TLB: si la traducció es troba al TLB, no caldrà accedir a la taula de pàgines; litat temporal i localitat espaci-
al d’un procés” d’aquest mò-
altrament, es produeix una fallada de TLB8 i caldrà accedir a la taula de pàgines dul didàctic.
(com si no hi hagués TLB). Els TLB són molt eficaços i estalvien una part molt
important dels accessos a la taula de pàgines perquè els accessos a memòria
dels processos exhibeixen localitat temporal i espacial, amb la qual cosa és
habitual que un procés accedeixi múltiples vegades a una mateixa pàgina.
(9)
La gestió de les fallades de TBL depèn de l’arquitectura. Per exemple, en el En anglès, page walk.
cas d’IA-32, les fallades de TBL són gestionades directament pel maquinari; és
responsabilitat del maquinari buscar la traducció a la taula de pàgines9 i actu-
alitzar el contingut del TLB. En canvi, altres arquitectures generen una excep-
ció i és el sistema operatiu el qui s’encarrega d’accedir a la taula de pàgines i
d’actualitzar el contingut del TLB.
En cas de canvi de context, en algunes arquitectures cal invalidar el contingut Processador Intel Core i7
del TLB perquè les traduccions emmagatzemades en el TLB són vàlides úni-
Com a referència, el processa-
cament per al procés que estava en execució. Altres arquitectures permeten dor Intel Core i7 disposa d’un
identificar les traduccions corresponents a accessos propis del sistema opera- TLB organitzat en dos nivells.
El primer nivell conté 64 tra-
tiu; aquestes traduccions no s’invaliden en cas de canvi de context. Finalment, duccions i el segon nivell 512
traduccions. Tant el primer
altres arquitectures permeten associar una mena d’identificador de procés a com el segon nivell són me-
mòries cau amb associativitat
les entrades del TLB; en aquest cas, no cal invalidar el contingut del TLB quan 4. Quan cal fer una traducció,
es produeix un canvi de context. es consulta el primer nivell de
TLB; si no es troba la traduc-
ció, es consulta el segon nivell
de TLB; si tampoc no es troba
(fallada de TBL), cal accedir la
taula de pàgines emmagatze-
mada en memòria.
3. Polítiques de gestió de la memòria virtual
Quan un procés fa una referència a una adreça dins el seu espai lògic, es calcula
a quina pàgina lògica correspon i, a continuació l’MMU comprova si aques-
ta pàgina està carregada a la memòria. En el cas que no hi sigui, es produeix
una excepció de tipus fallada de pàgina. La rutina d’atenció a aquesta excep-
ció és l’encarregada de portar la pàgina a la memòria principal des de l’àrea
d’intercanvi. Aquesta tasca no és senzilla, ja que si no hi ha pàgines lliures a
la memòria principal s’ha de prendre una decisió: o bé es bloqueja el procés i
s’espera que algun altre procés finalitzi l’execució i deixi pàgines de la memò-
ria lliures, o bé s’escull una pàgina de la memòria principal i es porta a l’àrea
d’intercanvi per fer lloc a la pàgina que ha generat la fallada de pàgina.
Un gestor de la memòria virtual paginada ha de tenir:
• Una política de càrrega i descàrrega de pàgines per a decidir en quin mo-

ment ha de portar una pàgina a la memòria i quan l’ha de treure.
• Una política�d’emplaçament per a saber on ha de posar una pàgina nova.
• Una política�de�reemplaçament per a escollir, quan el sistema no té cap

pàgina lliure i necessita carregar una nova pàgina d’algun procés que s’està
executant, l’algorisme que convé aplicar per a seleccionar una pàgina de les
que hi ha carregades a la memòria principal i tornar-la a l’àrea d’intercanvi.
• Una política�d’assignació que, coneixent el grau de multiprogramació,

indiqui quantes pàgines d’un mateix procés poden estar a la memòria de
manera simultània.
En un sistema de gestió de memòria basat en paginació, la gran majoria de Dispositius d’entrada/

les pàgines lliures de la memòria física són igualment bones per a ser escolli- sortida
des a l’hora de carregar una nova pàgina a la memòria. Per tant, la política Una única excepció a aquesta
d’emplaçament no afectarà l’eficiència del gestor de la memòria virtual pagi- política de gestió de memòria
basada en paginació serien les
nada. pàgines utilitzades per disposi-
tius d’entrada/sortida que tre-
ballen directament amb direc-
cions físiques de memòria. De
En un sistema amb paginació pura (sota demanda), només es carrega una pà- totes maneres, aquestes pàgi-
gina a la memòria principal quan es produeix una fallada de pàgina amb una nes acostumen a estar assigna-
des al sistema operatiu i mai
adreça que fa referència a la pàgina en qüestió. Una altra alternativa és que, no estaran disponibles per als
processos.
aprofitant la localitat espacial dels accessos a memòria, a més de carregar la
pàgina que ha provocat la fallada també es carreguin un cert nombre addici-
(10)
onal de pàgines lògicament contigües a la que ha provocat la fallada. Aquesta En anglès, prefetching.
10
alternativa rep el nom de precerca .
Una política trivial de descàrrega de pàgines consisteix a descarregar una pà- Vegeu també
gina (i actualitzar l’àrea d’intercanvi, si cal) quan sigui necessari carregar una
Recordeu que la localitat espa-
nova pàgina i no sigui possible carregar-la en cap trama lliure. Ara bé, la ma- cial es tracta en l’annex 1, “Lo-
joria de sistemes operatius intenten disposar sempre d’algunes trames lliu- calitat temporal i localitat es-
pacial d’un procés” d’aquest
res abans que siguin necessàries; per exemple, algunes rutines de tractament mòdul didàctic.
d’interrupció poden haver de demanar memòria i no és possible bloquejar

l’execució d’aquestes rutines. Per a garantir que sempre hi hagi trames dispo-
nibles, un procés del sistema operatiu s’encarrega d’analitzar periòdicament la
utilització de trames de memòria física i intercanvia en disc els que considera
oportuns. La descàrrega de pàgines també es fa quan el sistema és hivernat.
A continuació es descriuen algunes polítiques de reemplaçament i d’assignació

de pàgines que han estat proposades per diferents autors.
3.1. Polítiques de reemplaçament
Fallades de pàgina
S’han proposat diverses polítiques de reemplaçament i, molt probable-
ment, cada sistema operatiu implementa una política diferent. En qual- Cada cop que es produeix una
fallada de pàgina es genera
sevol cas, una política�de�reemplaçament ha de tenir com a objectiu una excepció que ha de ser
tractada pel sistema operatiu,
que el percentatge de fallades de pàgina (taxa de fallades de pàgina) res- amb el canvi conseqüent de
pecte al total de referències efectuades a la memòria física sigui com més mode d’execució i transferèn-
cia de control a una rutina prò-
petit millor. pia del sistema operatiu. Com
aquestes accions tenen un cost
computacional apreciable, una
taxa excessivament gran de
fallades de pàgina pot impac-
En alguns sistemes operatius (com ara Linux) la política de reemplaçament tria tar de manera apreciable en el
únicament pàgines assignades a processos, en cap cas no escollirà una pàgina rendiment de la màquina.
assignada al nucli del sistema operatiu. Això és perquè algunes porcions de

codi/dades/pila del sistema operatiu en cap cas no poden ser intercanviades
a l’àrea d’intercanvi (per exemple, les pàgines que contenen el codi d’atenció
a l’excepció de la fallada de pàgina). A més, per una qüestió d’eficiència, és
recomanable que tot el nucli del sistema operatiu estigui present a la memòria
física. En aquest mòdul assumirem que únicament podran ser reemplaçades
pàgines assignades a processos.
Els diferents algorismes proposats en aquest apartat s’avaluen executant-los

per a una determinada cadena de referències a les pàgines de la memòria. Su-
posem (si no s’indica el contrari) que tenim la cadena de referències següent:
7, 0, 1, 2, 0, 3, 0, 4, 2, 3, 0, 3, 2, 1, 2, 0, 1, 7, 0. Això significa que el procés ha
d’accedir a determinades adreces de la memòria que són a les pàgines lògiques
indicades en la seqüència.
A l’hora d’estudiar les polítiques de reemplaçament hem de tenir en compte

el nombre de pàgines de la memòria física que es poden assignar a un procés.
En funció d’aquest nombre, podem distingir les dues polítiques següents:
1)�Política�de�reemplaçament�global. Si les polítiques són globals, es consi-

dera que totes les pàgines de la memòria física són candidates a ser reempla-
çades. Un reemplaçament pot treure de la memòria una pàgina assignada a
un procés diferent del procés que ha generat la fallada de pàgina. Amb les po-
lítiques de reemplaçament global, un procés pot tenir un nombre variable de
pàgines carregades a la memòria: des de zero fins a totes les pàgines a què hagi
fet referència fins a un cert instant. Aleshores el nombre de fallades de pàgina
d’un procés depèn de la càrrega del sistema i, molt probablement, el temps
d’execució del procés serà variable entre execucions diferents.
2)�Polítiques�de�reemplaçament�local. Si les polítiques són locals, tan sols un

subconjunt de pàgines de la memòria física són candidates a ser reemplaçades.
La pàgina candidata s’escull entre el conjunt de pàgines de la memòria física
assignades a un procés. D’aquesta manera, l’execució d’un procés no influeix
en l’execució de la resta de processos. També s’aconsegueix un cert control del
grau de multiprogramació que ha de suportar el sistema. El nombre de fallades
de pàgina d’un procés serà molt similar cada vegada que s’executi el procés,
i el temps d’execució no variarà gaire entre diferents execucions del mateix
procés.
Per als exemples proposats en els subapartats següents suposarem que els pro-
cessos disposen d’un nombre determinat de pàgines de la memòria física (tres).
Inicialment, en començar a executar el procés, totes estan lliures. En tots els
exemples, si no es diu el contrari, suposem un reemplaçament local.
3.1.1. L’algorisme de reemplaçament òptim
Un algorisme de reemplaçament òptim és aquell que té la taxa de fa-

llada de pàgines més petita de tots els algorismes. Aquest algorisme de
reemplaçament es podria descriure com l’algorisme que reemplaça la
pàgina que no s’utilitzarà durant un període de temps més llarg.
Aquest algorisme no es pot implementar, ja que per a fer-ho és necessari saber

en un instant determinat quin comportament tindrà el procés en el futur (qui-
nes referències a la memòria es faran). El resultat de l’aplicació de l’algorisme
òptim s’utilitza principalment en estudis comparatius.
Si apliquem l’algorisme òptim a la cadena de referències del nostre exemple

es generen nou fallades de pàgina (taxa de fallades de pàgina del 47,4%), tal
com es mostra a la figura 2.
Figura 2. Algorisme de reemplaçament òptim
Les tres primeres referències provoquen tres fallades de pàgina. La referència

a la pàgina 2 fa que surti de la memòria la pàgina 7, ja que no s’utilitzarà fins
a la referència 18, mentre que la pàgina 0 es farà servir en la referència 5, i la
pàgina 1, en la referència 14. La referència 3 fa sortir la pàgina 1, i així fins
que es completi la seqüència de referències.
3.1.2. L’algorisme de reemplaçament FIFO
L’algorisme�de�reemplaçament�FIFO (first in, first out) necessita saber

l’ordre en què es carreguen les pàgines a la memòria principal. Quan
convé fer un reemplaçament, la pàgina candidata a ser reemplaçada és
la que fa més temps que es va carregar a la memòria física, és a dir, la
més antiga.
Si apliquem aquest algorisme a la seqüència de referències del nostre exemple

es produeix un total de 14 fallades de pàgina (taxa de fallades de pàgina del
73,7%). La figura 3 mostra un esquema del funcionament de l’algorisme:
Figura 3. Algorisme de reemplaçament FIFO

De nou, les tres primeres referències produeixen 3 fallades de pàgina. Quan es

fa referència a la pàgina 2 es fa sortir la pàgina 7, ja que és la primera pàgina
que s’ha portat a la memòria. La referència següent, a la pàgina 0, no produeix
fallada de pàgina perquè ja la tenim a la memòria. La referència següent, a la
pàgina 3, fa sortir la pàgina 0 perquè és la segona pàgina que s’ha portat a la
memòria, i la primera ja s’ha tret. Aquest procediment se segueix en la resta
de referències.
(11)
L’algorisme FIFO11 és fàcil d’implementar (només cal una memòria intermè- FIFO és la sigla de first in, first
out.
12
dia circular i un punter), però té algunes mancances, com ara les següents:
(12)
En anglès, buffer.
• A l’hora d’escollir una pàgina candidata no es té en compte si una pàgina
ha estat molt referenciada o no. Això pot fer que es tregui de la memòria
una pàgina que s’utilitza moltíssim i, per tant, indirectament augmentem
les possibilitats que es produeixin més fallades de pàgina.
• El més lògic és que si augmentem el nombre de pàgines que un procés pot

tenir carregades a la memòria, el nombre de fallades de pàgina disminuei-
xi, però està demostrat que l’algorisme de reemplaçament FIFO no sempre
compleix aquest principi.
L’anomalia de Belady
Vegem un exemple concret per a il·lustrar el fet que un augment del nombre de pàgines
carregades a la memòria no implica una disminució del nombre de fallades de pàgina.
Suposem que tenim a la memòria la seqüència de referències 1, 2, 3, 4, 1, 2, 5, 1, 2, 3, 4, 5

i imaginem que fem servir l’algorisme de reemplaçament FIFO. Podeu comprovar que si
permetem tenir solament una pàgina a la memòria es produeixen 12 fallades de pàgina;
amb 2 pàgines carregades a la memòria constatem 12 fallades de pàgina; amb 3 pàgines
a la memòria es produeixen 9 fallades de pàgina, i amb 4 pàgines a la memòria tenim 10
fallades de pàgina. Aquest problema rep el nom d’anomalia�de�Belady.
3.1.3. L’algorisme de reemplaçament LRU
L’algorisme de reemplaçament LRU (least recently used) consisteix a regis-

trar el moment en què cada pàgina ha estat referenciada per últim cop.
En cas que alguna pàgina hagi de sortir de la memòria física, s’escollirà
aquella que fa més temps que no ha estat referenciada.
(13)
A la figura 4 mostrem el resultat d’aplicar l’algorisme de reemplaçament LRU13 LRU és la sigla de least recently
used.
a la seqüència de referències a la memòria que hem proposat com a exemple:
Figura 4. Algorisme de reemplaçament LRU
Aquí es produeixen 12 fallades de pàgina en total (taxa de fallades de pàgina

del 63,2%). Les tres primeres referències provoquen tres fallades de pàgina. La
referència a la pàgina 2 fa sortir de la memòria física la pàgina 7, que és la
que fa més temps que no ha estat referenciada. La referència a la pàgina 0 no
provoca cap fallada de pàgina. La referència a la pàgina 4 fa sortir la pàgina
1, que és aquella a la qual fa més temps que no s’ha fet referència, i així per
a totes les referències de la seqüència.
En general, l’algorisme LRU té més bon rendiment que el FIFO, però el cost
d’implementació de l’LRU és molt més costós que el FIFO.
Es poden aconseguir algunes de les implementacions possibles de l’algorisme

LRU de les maneres següents:
a) Afegint comptadors a cada entrada de la taula de pàgines que indiquen

quant de temps fa que s’ha efectuat l’última referència a la pàgina. Per això
cal tenir un rellotge lògic que ho assenyali. A cada referència a la memòria
s’actualitza el comptador de l’entrada de la taula de pàgines referenciada i es
treu de la memòria la pàgina que té el comptador més petit. Això requereix fer
una cerca entre totes les entrades de la taula de pàgines per trobar la pàgina
que té el comptador més baix. Tenim el problema que el comptador es pot
saturar, és a dir, es pot produir el que s’anomena un desbordament.
b) Utilitzant una pila. La idea és mantenir una estructura de tipus pila amb
el nombre de pàgines que es referencien. Sempre que es fa una referència a
una pàgina, aquesta passa al cim de la pila, de manera que les pàgines que fa
menys temps que han estat referenciades es troben a prop del cim de la pila,
i les pàgines que fa més temps que no han estat referenciades són a prop de
la base de la pila. Per a implementar aquest esquema es necessita una llista
doblement encadenada. Efectuar una actualització té un cost més gran que
fer servir els comptadors, perquè s’han d’actualitzar molts punters, però així
evitem fer una cerca de totes les pàgines.
Totes dues opcions requereixen suport de maquinari per a ser implementades, i

fer una implementació per programari pot ser molt costós en temps d’execució
a l’hora de gestionar una fallada de pàgina.
Aproximacions�a�l’algorisme�LRU
S’han proposat aproximacions a l’algorisme LRU que fan servir un bit de refe-
rència. S’associa a cada entrada de la taula de pàgines un bit de referència que
s’actualitza (es posa a 1) cada cop que es referencia la pàgina. A continuació
presentem tres d’aquestes aproximacions:
1)�Desar�la�història�de�les�referències. En aquest cas, a més del bit de refe-

rència, per a cada pàgina s’afegeix un registre de k bits que desa la història de
les referències a la pàgina (dels últims k intervals de temps) i indica si s’ha fet
referència a la pàgina almenys un cop cada interval. Aquest registre històric
s’actualitza a intervals regulars descartant la posició menys significativa i in-
corporant a la posició més significativa el bit de referència, el qual es posa a
zero cada vegada que s’actualitza el registre d’història de la pàgina (els k bits).
La pàgina que té el registre d’història amb el valor més petit és la candidata a

sortir de la memòria. Si hi ha més d’una pàgina amb el mateix valor del registre
històric, es pot aplicar qualsevol algorisme de selecció (per exemple, el FIFO)
que indiqui quina és la pàgina candidata a sortir de la memòria, o bé es poden
treure totes les possibles candidates.
2)�Donar�una�segona�oportunitat. En aquest cas podríem considerar que no

tenim constància de les referències a les pàgines i que només tenim en compte
el bit de referència. L’algorisme de la segona oportunitat es basa en un algoris-
me FIFO. Quan se selecciona la pàgina que s’ha de treure de la memòria mirem
el seu bit de referència. Si aquest bit és igual a 0, es reemplaça la pàgina. En
canvi, si el bit és igual a 1, la pàgina no es reemplaça (se li dóna una segona
oportunitat); es torna a inserir a la cua (com si fos una pàgina nova) i la can-
didata a ser reemplaçada passa a ser la pàgina següent de la cua FIFO. Quan es
dóna la segona oportunitat a una pàgina, el seu bit de referència es posa a 0.
3)�Algorisme�del�rellotge. És una sofisticació de l’algorisme de segona oportu- Algorisme del rellotge

nitat. Utilitza una memòria intermèdia circular de pàgines i manté un punter
El Linux utilitza una variant
a la darrera posició examinada. La diferència respecte l’algorisme de segona d’aquest algorisme com a al-
oportunitat és que no mou dins de l’estructura les pàgines a les quals es dóna gorisme de reemplaçament.
una segona oportunitat. Si decideix que cal donar una segona oportunitat a
una pàgina, l’únic que cal fer és moure el punter a la posició següent de la
memòria intermèdia circular.
3.1.4. Els algorismes de reemplaçament LFU i MFU
L’algorisme LFU (least frequently used) reemplaça la pàgina que ha estat

menys referenciada. La implementació és molt senzilla: consisteix a po-
sar un comptador a cada pàgina, i cada vegada que es fa referència a una
pàgina, el seu comptador s’incrementa. Quan cal treure una pàgina, es
treu la que té el comptador més petit.
El problema que tenim és la saturació del comptador; i que periòdicament cal

posar a 0 els valors de tots els comptadors.
Si, en canvi, traiem de la memòria la pàgina que té el comptador més

gran, ja que considerem que la pàgina amb el comptador més petit pro-
bablement ha estat carregada fa menys temps i es farà servir força, ales-
hores implementem l’algorisme MFU (most frequently used).
3.1.5. Consideració final: pàgines modificades
En treure una pàgina de la memòria és important tenir en compte que, si

ha estat modificada, s’haurà d’actualitzar a l’àrea d’intercanvi (caldrà fer una
transferència de la memòria a l’àrea d’intercanvi). Un cop l’àrea d’intercanvi
ha estat actualitzada, ja es pot carregar la pàgina nova (fent una transferència
de l’àrea d’intercanvi a la memòria).
Si una pàgina no ha estat modificada, el cost de treure-la de la memòria es

redueix a actualitzar la pàgina de la memòria amb la nova pàgina lògica (fent
una transferència de l’àrea d’intercanvi a la memòria). Podem considerar que
aquesta operació, respecte del cas anterior, redueix el cost significativament.
Per tant, si tenim diferents pàgines candidates a sortir de la memòria, interes-

sarà treure aquelles que no hagin estat modificades.
3.2. Polítiques d’assignació
En un sistema multiprogramat és necessari establir alguna regla�per�a

distribuir�la�memòria�física entre els diversos processos que s’executen
de manera concurrent en el sistema.
A l’hora de distribuir la memòria entre els processos trobem dues grans res-
triccions:
1)�El�nombre�màxim�de�pàgines�de�la�memòria�física�que�es�poden�assignar
a�un�procés. Aquest nombre està determinat per la mida de la memòria física
del sistema. Si permetem a un únic procés ocupar tota la memòria del sistema,
limitem el grau de multiprogramació.
2)�El�nombre�mínim�de�pàgines�de�la�memòria�física�que�hem�d’assignar�a
un�procés. Aquest nombre està determinat per l’arquitectura del computador
on s’executa el procés. Cal recordar que per a poder executar una instrucció,
totes les pàgines de l’espai lògic a què es fa referència durant l’execució han
d’estar carregades a la memòria.
Per exemple, en un llenguatge màquina en què les instruccions tan sols puguin
tenir un operand a la memòria i totes les referències a la memòria siguin di-
rectes, és a dir, si l’adreça especificada en la instrucció és l’adreça de l’operand,
el pitjor que pot passar és que la instrucció estigui en una pàgina lògica i la
dada estigui en una altra pàgina lògica. Per tant, a tot procés, com a mínim,
se li han d’assignar dues pàgines a la memòria principal.
En canvi, si les referències als operands poden ser adreces indirectes, és a dir, Computadors PDP-8 o
si en la instrucció s’especifica una adreça de la memòria que conté l’adreça de PDP-11
l’operand buscat, llavors per a assegurar que tot procés es podrà executar cor- En els computadors PDP-8 o
rectament al sistema se li han d’assignar almenys tres pàgines de la memòria: els PDP-11, que disposaven
d’una arquitectura de llenguat-
una que contingui la instrucció, una altra amb l’adreça de l’operand i una ter- ge màquina molt complexa
(de tipus CISC), el nombre mí-
cera pàgina que inclogui l’operand. En les arquitectures actuals, de tipus RISC, nim de pàgines que s’havia
d’assignar a un procés per a
en què el llenguatge màquina és molt senzill, les necessitats mínimes solen ser assegurar una execució cor-
de dues pàgines, una per a la instrucció i una altra per a l’operand. recta podia ser considerable;
per exemple, fins a sis en el
PDP-11.
Considerant aquests valors límit, l’algorisme d’assignació haurà de determinar
el nombre de pàgines que pot tenir carregades a memòria cada procés.
3.2.1. Algorismes d’assignació
El nombre de pàgines de la memòria principal que el sistema assigna a cada

procés determina el grau de multiprogramació i l’ús que es pot fer del proces-
sador.
La política d’assignació de pàgines més senzilla consisteix a dividir en parts

iguals la memòria del sistema entre tots els processos que s’executen i a definir
un màxim i un mínim de pàgines que es poden assignar al procés. Llavors tots
els processos tenen un tractament igualitari dintre el sistema.
Tenint en compte que no tots els processos tenen requisits de memòria iguals,
amb aquesta distribució hi ha casos en què a un procés se li assignen més
pàgines o menys pàgines de les que realment necessita.
Altres polítiques intenten assignar el nombre de pàgines en funció de la mida

de l’espai lògic de cada procés. Serien polítiques proporcionals.
Altres polítiques també tenen en consideració la prioritat dels processos i as-

signen més pàgines a aquells processos més prioritaris. No són més que una
sofisticació de les polítiques proporcionals.
També hi ha polítiques adaptatives que intenten identificar les fases d’execució

existents a la majoria del programes (inicialització, període permanent...) i
assignar el nombre de pàgines adient per a cada fase.
Hiperpaginació
Independentment del tipus de política aplicada, si el nombre de pàgines assignades a un

procés és inferior al nombre requerit pel procés, l’execució d’aquest procés constantment
produirà fallades de pàgina. Aleshores el procés passa més temps “paginant” –intercan-
viant pàgines entre memòria i l’àrea d’intercanvi– que executant-se. Aquesta situació rep
el nom d’hiperpaginació (thrashing).
Un sistema entra en hiperpaginació quan, a causa d’una sobrecàrrega del sistema o d’una
configuració inadequada dels gestors d’assignació i de reemplaçament de pàgines, el sis-
tema està paginant contínuament i no té temps per a executar processos. A conseqüència
d’això, la utilització efectiva de l’UCP és molt baixa, i el planificador podria interpretar
malament aquest descens en el rendiment de l’UCP i incrementar el grau de multipro-
gramació, decisió que agreuja encara més el mal funcionament del sistema, que pot ar-
ribar a col·lapsar-se.
3.2.2. Conjunt de treball
(14)
El model del conjunt de treball14 s’intenta adaptar a la localitat dels processos. En anglès, working set.
En aquest algorisme es defineix una finestra de treball en la qual es tenen

en compte un nombre determinat de referències. El nombre de referències Vegeu també
determina la mida de la finestra (T), i el nombre de pàgines diferents que es Recordeu que la localitat espa-
referencien dintre la finestra de treball és el que forma el conjunt de treball. cial es tracta a l’annex 1, “Lo-
calitat temporal i localitat es-
Si una pàgina s’utilitza, estarà dintre del conjunt de treball, i si no es fa servir, pacial d’un procés” d’aquest
mòdul didàctic.
sortiran del conjunt de treball T referències després de ser referenciada per
darrera vegada.
El problema d’aquest algorisme és determinar la mida de la finestra. Si és massa

petita, no es podrà treure profit de la localitat del procés, i si és massa gran,
s’encavalcaran diferents localitats.
El fet d’utilitzar el conjunt de treball a l’hora d’assignar pàgines al procés és

bastant senzill. El sistema avalua el conjunt de treball per cada procés i assig-
na al procés un nombre de pàgines suficient per a tenir el conjunt de treball
carregat a la memòria. Si queden pàgines de la memòria lliures, el sistema pot
iniciar l’execució d’un altre procés. Si en algun moment la suma del conjunt
de treball de tots els processos que s’executen en el sistema supera la capacitat
de la memòria física, el sistema pot suspendre l’execució d’algun procés i des-
carregar totes les pàgines assignades a aquest procés.
Amb aquesta estratègia s’aconsegueix un bon ús de l’UCP, s’evita que el sistema

entri en situació d’hiperpaginació i, a més, s’aconsegueix assolir un grau de
multiprogramació del sistema raonablement alt.
Exemple d’utilització del conjunt de treball
Si tenim la seqüència de referències a pàgines lògiques següent: {1, 0, 1, 5, 1, 1, 2, 8, 7,

1, 2, 3, 0}, i la mida de la finestra és 3, llavors el conjunt de treball en el moment en què
es referencia la pàgina 5 és {0, 1, 5}, i quan es referencia per primer cop la pàgina 2 el
conjunt de treball, és {1, 2}.
Resum
En un sistema operatiu és important poder executar processos de qualsevol

mida, independentment de la memòria física instal·lada. La memòria virtual
és una tècnica que permet establir un enllaç entre un espai d’adreces gran
(l’espai lògic del procés) i un espai d’adreces més petit (les adreces físiques de
la memòria principal), cosa que fa possible executar programes molt grans i
incrementar el grau de multiprogramació.
En aquest mòdul didàctic s’ha presentat una descripció detallada del funci-
onament de la gestió de la memòria virtual paginada: s’han descrit les es-
tructures de dades necessàries per a implementar-la (i s’ha destacat el tipus
d’implementació, per maquinari o per programari, més adient per a cadascu-
na) i hem identificat els diferents tipus d’accions que ha de dur a terme un
gestor de la memòria virtual paginada: la càrrega inicial, l’assignació i el reem-
plaçament de pàgines.
En l’última part del mòdul s’han descrit algunes polítiques d’assignació i re-
emplaçament de pàgines de la memòria, que han estat proposades per la bi-
bliografia, i n’hem avaluat els avantatges i els inconvenients.
Activitats
1. Una màquina ofereix als usuaris un espai d’adreces virtual de 224 paraules. La màquina té
218 paraules de la memòria física. La memòria virtual s’implementa per paginació, i la mida
de la pàgina és de 256 paraules. Una operació d’usuari genera l’adreça virtual 111234A6 (en
hexadecimal). Expliqueu com estableix el sistema la posició física corresponent a aquesta
adreça.
2. Com influeix en la gestió de la memòria virtual paginada la mida de la pàgina?
3. Busqueu informació sobre el format de les entrades de les taules de pàgines (PDE i PTE)
en l’arquitectura IA32. Quina és la diferència entre una PDE i la PTE? Quina és la funció de
cadascun dels bits de control?
4. Compareu el format de les entrades de les taules de pàgines dels processadors Intel de 64
bits amb el format dels processadors Intel de 32 bits.
5. Quan hi ha un canvi de context, què passa amb la informació que tenim a la TLB? Recordeu
que el terme canvi de context fa referència a les accions que porta a terme el sistema quan deixa
d’executar un procés i passa a executar-ne un altre que estava a l’espera per a ser executat.
6. A la TLB, podem tenir informació d’un procés, o de diversos processos a la vegada? Quins
camps hauria de tenir una entrada de la TLB per a poder suportar diversos processos simul-
tàniament?
7. Digueu si les estructures i les tècniques de programació següents són útils en un entorn de
programació amb precerca. Recordeu que heu de tenir en compte que quan es produeix una
fallada de la pàgina k, l’algorisme de precerca carrega a la memòria la pàgina k i la k + 1.
a) La pila.
b) La recerca seqüencial.
c) La recerca dicotòmica.
d) El codi d’un programa.
e) Operacions amb vectors.
f) L’adreçament indirecte.
8. Considereu la seqüència següent de referències a la memòria d’un programa que consta

de 460 paraules: 10, 11, 104, 170, 73, 309, 185, 245, 246, 434, 458, 364.
a) Indiqueu la seqüència de referències a la memòria suposant que la mida de la pàgina és

de 100 paraules.
b) Calculeu la taxa de fallades de pàgina d’aquesta cadena de referències suposant que el

programa disposa d’una memòria de 200 paraules per a ser executat, i que l’algorisme de
reemplaçament que s’aplica és el FIFO.
c) Quina taxa de fallades de pàgina es generarà si l’algorisme de reemplaçament és l’LRU?
d) Quina taxa de fallades de pàgina es generarà si l’algorisme de reemplaçament emprat és

l’algorisme òptim?
9. Suposeu que en un sistema amb gestió de la memòria virtual paginada apliquem una po-
lítica de reemplaçament que consisteix a examinar cada pàgina regularment i descarregar-la
de la memòria física si no s’ha fet servir des de l’última consulta. Què guanyaríem o perdrí-
em utilitzant aquesta política en lloc d’aplicar la política de reemplaçament LRU o la de la
segona oportunitat?
10. Imagineu que volem utilitzar un algorisme que necessita un bit de referència (com
l’algorisme de la segona oportunitat o bé el que té en compte el conjunt de pàgines de tre-
ball), però el maquinari del sistema no en proporciona. Podríeu proposar alguna manera de
simular el bit de referència? En el cas que fos possible, seria molt costós?
11. Quins problemes poden sorgir si es treuen de la memòria pàgines que intervenen en una
operació d’entrada/sortida per DMA? Com es podrien solucionar?
12. Podem tenir algun problema si un algorisme de reemplaçament treu pàgines de la me-
mòria que continguin dades o codi del nucli del sistema operatiu? Per què?
13. Considerem la matriu bidimensional A declarada des del llenguatge d’alt nivell C de la
manera següent: int A[256][256]; podeu assumir que un enter ocupa 4 octets, que la matriu
es carrega a la memòria contigua per files, que A[0][0] es troba a l’adreça 2048 de l’espai lògic
i que el sistema de gestió de memòria és paginat amb una mida de pàgina igual a 1 kB.
A la pàgina 0 (que només conté codi) tenim un petit programa que inicialitza la matriu a 0.
El codi del bucle principal és:
int A[256][256];
for (i=0; i<256; i++) {
for (k=0; k<256; k++) {
A[k][i] = 0;
}
}
Contesteu les preguntes següents:
a) Suposant que tenim una limitació de tres pàgines físiques, quantes fallades de pàgina es
produiran si s’aplica l’algorisme de reemplaçament LRU? (Negligiu l’accés al codi del progra-
ma i tingueu en compte únicament l’accés a les dades de la matriu.)
b) Quantes fallades de pàgina es produiran si canviem l’ordre dels bucles?
c) Feu la mateixa anàlisi dels apartats anteriors a partir d’un sistema amb pàgines de 2 kB.
Suposeu que la matriu està carregada a la memòria per files.
14. La crida al sistema fork() d’Unix crea un procés nou que és una còpia gairebé idèntica del
procés que l’ha invocada. Per a reduir el cost computacional d’aquesta crida, la implementa-
ció d’aquesta crida utilitza una tècnica denominada copy on write (COW). Busqueu informa-
ció per a saber en què consisteix i com està implementada.
Exercicis d'autoavaluació
1. Disposem d’un sistema de gestió de memòria basat en paginació amb les característiques
següents:
• Pàgines de 4 quilobytes.
• Espai lògic de 64 quilobytes
• Espai físic de 32 quilobytes
• Nombre de pàgines físiques que pot arribar a ocupar un procés: 4.
Donada la seqüència següent d’accessos a octet (les adreces estan codificades en hexadecimal)
fetes per un procés: 6b45, 2244, 3540, 6340, 4200, 5001, 2200, 6000, 2000, 4300, 5034, 6002,
2008...
a) Indiqueu quines fallades de pàgina es produiran assumint:
• Que s’aplica l’algorisme de reemplaçament LRU.

• Que s’aplica l’algorisme de reemplaçament FIFO.
b) Indiqueu quin és el contingut de la taula de pàgines del procés un cop finalitzada la

cinquena referència a memòria utilitzant el primer dels algorismes.
2. Considereu la matriu bidimensional A declarada des del llenguatge d’alt nivell C de la

manera següent: int A[256][256]. Podeu assumir que un enter ocupa 4 octets, que la matriu
es carrega a la memòria contigua per files, que A[0][0] es troba a l’adreça 2048 de l’espai lògic
i que el sistema de gestió de memòria és paginat, amb una mida de pàgina igual a 1 kB.
A la pàgina 0 (que únicament conté codi) tenim un petit programa que inicialitza la matriu
a 0. Si el codi del bucle principal és:
int A[256][256];
for (i=0; i<256; i++) {
for (k=0; k<256; k++) {
A[k][i] = 0;
}
}
Contesteu les preguntes següents:
a) Quantes fallades de pàgina es produiran si suposem que el procés pot tenir tres pàgines
de la memòria física, una de les quals sempre té la pàgina que conté el codi i les altres dues
són per a les dades?
b) I si canviem l’ordre d’execució dels bucles?
c) Què passaria si s’executés el mateix codi, però escrit en llenguatge d’alt nivell Fortran?
Solucionari
Exercicis d'autoavaluació
1. Com les pàgines són de 4 kB i les adreces lògiques són de 16 bits, els 4 bits alts de les
adreces lògiques (és a dir, el primer dígit hexadecimal) indiquen el número de pàgina lògica
a la qual s’accedeix.
• LRU
En acabar la cinquena referència, la taula de pàgines tindrà (s’ha assumit que únicament les
pàgines referenciades pel procés són vàlides i que les trames físiques s’assignen començant
pel 0):
• FIFO
2.a) Per a calcular-ho és important saber com s’emmagatzema la matriu a la memòria. En el

llenguatge C, una matriu es carrega a la memòria física de manera contigua per files. Tenint
en compte aquest fet, a partir de l’adreça 2048 (pàgina 2) de l’espai lògic del procés, trobem
els elements A[0][0]; a l’adreça 2052, l’element A[0][1]; a l’adreça 2056, l’element A[0][2]; i
així fins a l’element A[255][255], que és a la pàgina 258 de l’espai lògic. Les adreces van de
quatre en quatre, ja que els elements de la matriu són enters que ocupen 4 octets.
Si mirem el patró d’accés a la matriu del codi que s’executa, veiem que s’accedeix a la matriu
per columnes. El primer accés, A[0][0], provoca una fallada de pàgina, i carrega la pàgina
2 a la memòria física. El segon accés, A[1][0], provoca una altra fallada de pàgina, atès que
aquest element es mapa a la pàgina 3 de l’espai lògic del procés. El tercer accés, A[2][0], també
provoca una fallada de pàgina, i així en tots els accessos de la primera columna. Obtindrem
un total de 256 fallades de pàgina.
Quan s’accedeix a la segona columna torna a passar al mateix, ja que tenim carregades a la
memòria les pàgines 257 i 258, i el primer element de la segona columna és a la pàgina 2.
Per tant, es produeixen un total de 2562 fallades de pàgina, un resultat pèssim.
b) Si canviem l’ordre dels bucles, la cosa va millor. L’accés a la matriu es fa per files i, per
tant, aprofitem la localitat espacial de la matriu. El procés funcionarà de la manera següent:
el primer accés a l’element A[0][0] provoca una fallada de pàgina i la pàgina 2 es carrega a
la memòria principal. Els 255 accessos següents no originaran cap fallada de pàgina, perquè
tots els elements de la primera fila de la matriu es mapen a la pàgina 2.
L’accés a l’element A[1][0] tornarà a provocar una fallada de pàgina i la pàgina 3 es carregarà
a la memòria física; els 255 accessos següents no provocaran cap fallada de pàgina. Aquest
esquema es repeteix en totes les files de la matriu.
Per tant, amb el nou codi passem a tenir 256 fallades de pàgina, un nombre molt més raonable
que en el cas anterior. Si s’hagués aplicat la precerca, encara hauríem pogut reduir més el
nombre de fallades de pàgina.
c) En el supòsit que el codi s’hagués escrit en Fortran, els resultats haurien estat a la inversa.
El llenguatge d’alt nivell Fortran introdueix les matrius a la memòria per columnes. L’accés
a les matrius per columnes (com en l’apartat a) és més eficient que l’accés per files.
Glossari
bit de presència m Bit associat a cada entrada de la taula de pàgines d’un procés que
indica si una pàgina és present a la memòria física, o no. Si el bit és 0, la pàgina no hi és;
si el bit és 1, la pàgina hi és.
bit de referència m Bit associat a cada entrada de la taula de pàgines d’un procés que
indica si la pàgina ha estat referenciada.
bit de validesa m Bit associat a cada entrada de la taula de pàgines d’un procés que indica
si la pàgina pertany a l’espai lògic del procés.
conjunt de treball m Conjunt de pàgines que són referenciades per un procés en un

interval de T referències consecutives.
fallada de pàgina f Situació que es produeix quan s’accedeix a una adreça de l’espai lògic
del procés que no està carregada a la memòria. Després de la fallada es genera una excepció,
i la rutina associada a aquesta excepció s’ocupa de carregar a la memòria la pàgina que ha
provocat la fallada.
finestra f Valor (T) de l’interval de referències consecutives que defineix el conjunt de

treball.
memòria virtual f Mètode de gestió de la memòria que permet l’execució de processos

sense que els seus espais lògics hagin d’estar totalment carregats a la memòria i sense que les
parts dels processos carregades a la memòria hagin d’ocupar posicions contigües.
memòria virtual paginada f Mètode de gestió de la memòria virtual que divideix l’espai
lògic del procés en pàgines.
precerca f Mecanisme que intenta treure profit de la localitat espacial de les pàgines dels
processos carregant a la memòria, a més de la pàgina que ha provocat una fallada de pàgina,
les k pàgines següents a fi d’evitar fallades de pàgina posteriors durant l’execució del procés.
taula de traducció d’adreces f Taula implementada en maquinari que emmagatzema

les darreres entrades de la taula de pàgines que han estat utilitzades per l’MMU.
Sigla TLB
Bibliografia
Bibliografia bàsica
Silberschatz, A.; Galvin, P.; Gagne. G. (2008). Operating Systems Concepts (8a. ed.). John
Wiley & Sons.
Tamenbaum, A. (2009). Modern Operating Systems. Prentice Hall.
Bibliografia complementària
Bovet, D.; Cesati, M. (2006). Understanding the Linux Kernel (3a. ed.). O’Reilly.
Gorman, M. (2004). Understanding the Linux Virtual Memory Manager. Prentice Hall.
Annexos
Annex�1.�Localitat�temporal�i�localitat�espacial�d’un�procés
Segons el principi de localitat, els programes accedeixen a una part bastant

reduïda del seu espai lògic dintre d’un període de temps. Podem trobar els dos
tipus de localitat següents:
a)�Localitat�temporal. Si una pàgina és referenciada una vegada, hi ha mol-

tes possibilitats que torni a ser referenciada aviat. En canvi, si una pàgina no
ha estat referenciada des de fa bastant temps, segurament no es tornarà a re-
ferenciar.
b)�Localitat�espacial. Si una pàgina és referenciada, és molt probable que les

pàgines següents (contigües en l’espai d’adreces virtual del procés) siguin re-
ferenciades en breu.
El principi de localitat és aplicable a l’execució d’instruccions de processos i a

l’accés a les dades d’un procés.
Exemple. Principi de localitat
Vegem un exemple que il·lustra el principi de localitat. Suposem que tenim el procés
següent:
#define MAX 1024

int v[MAX];
main(){
int i;
for (i = 0; i < MAX; i++)
v[i] = i;
}/* fi main */
Aquest procés té definit un vector de 1.024 enters. Un enter ocupa 4 octets (32 bits) de
la memòria i, per tant, l’espai que ocupa el vector a la memòria és de 4.096 octets. El
procés inicialitza el contingut del vector, i per això executa el bucle for (i = 0; i < MAX; i
++) amb MAX igual a 1.024. Considerem que el procés s’executa en un sistema dotat de
memòria virtual paginada i que la mida de cada pàgina de la memòria física és igual a 1
kB. Suposem que l’espai d’adreces virtual del procés és el que s’indica a la figura 5.
Figura 5. Espai lògic del procés
Quan el procés executi la primera instrucció, el sistema intentarà accedir a la pàgina

virtual 0, la que conté el codi del programa. Podem suposar perfectament que el codi
del programa ocupa menys d’1 kB. Per tant, totes les referències al codi per a executar
qualsevol instrucció del programa faran una referència a la pàgina virtual 0. Així, si mirem
la seqüència de pàgines referenciades a l’hora d’executar les instruccions del programa, el
patró de referències és: 0000 ... 0000. Des del punt de vista de la localitat, les referències
al codi del programa tenen localitat temporal.
Si ens fixem en les dades, veiem que quan s’accedeix al primer element del vector, v[0],
aquest genera l’adreça lògica 1024, que correspon a la pàgina 1. Les 255 referències se-
güents als elements v[1], v[2], ..., v[255] corresponen a les adreces lògiques 1028, 1032,
1036..., totes mapades a la pàgina 1. Els 256 elements següents del vector, del v[256] al
v[511], generen accessos a la pàgina 2 de l’espai d’adreces virtual del procés. L’accés als
elements següents del vector, del v[512] al v[767], genera l’accés a la pàgina 3 de l’espai
d’adreces virtual i, finalment, les últimes 256 referències accedeixen a la pàgina 4.
Si mirem la seqüència de pàgines referenciades trobem el patró següent:
1,1,1, ... 1,1,1, 2,2,2, ... 2,2,2, 3,3,3, ... 3,3,3,4,4,4, ... 4,4,4
En analitzar quin tipus de localitat apareix en aquest cas, veiem que, d’una banda, hi
ha localitat temporal mentre s’accedeix als elements d’una mateixa pàgina, i de l’altra,
trobem localitat espacial, ja que els elements del vector ocupen pàgines contigües en
l’espai d’adreces virtual, i aquestes pàgines són referenciades seqüencialment. Per tant,
es compleix la tendència que quan referenciem una pàgina hi ha una probabilitat molt
alta que al cap d’un temps relativament no gaire gran es referenciï la pàgina següent.
Podem treure profit d’aquest comportament del procés per a evitar treure pàgines que
són molt referenciades. Per exemple, si es fa referència contínuament a la pàgina 0, seria
molt poc eficient portar-la al disc mentre s’executa el procés, ja que es produirien moltes
fallades de pàgina i hi hauria un increment del temps total d’execució del procés. Així
doncs, la localitat temporal dels processos ens pot ajudar a definir polítiques per a decidir
quina pàgina és candidata a sortir de la memòria.
Com�es�pot�aprofitar�la�localitat�espacial
Hem vist que en un sistema amb paginació pura només portem pàgines a la
memòria principal si es produeix una fallada de pàgina. Si suposem que els
processos tenen localitat espacial, podem avançar feina i, quan es produeix
una fallada de pàgina, a més de carregar a la memòria la pàgina en qüestió
(pàgina k), hi podem carregar també la pàgina següent, la k + 1 –la pàgina
contigua en l’espai d’adreces lògiques del procés. Aquesta tècnica s’anomena
precerca.
En el cas que es compleixi que el procés té localitat espacial, quan es fa refe-

rència a la pàgina k + 1, no es produirà una fallada de pàgina, perquè ja havia
estat carregada a la memòria. A l’hora de fer la precerca és possible carregar
més d’una pàgina.
En l’exemple anterior, si s’apliqués la precerca d’una pàgina, a l’hora d’accedir

al primer element del vector es carregarien a la memòria les pàgines 1 i 2.
Quan féssim la primera referència a la pàgina 3, carregaríem la pàgina 3 i la 4.
L’exemple que originalment donava quatre fallades de pàgina quan s’accedia
al vector, en aplicar la precerca només dóna dues fallades de pàgina.
Annex�2.�Assignació�de�memòria�en�el�nucli�Linux
Aquest annex descriu algunes peculiaritats de la gestió de memòria en el Linux,

centrada en l’arquitectura IA-32.
Al llarg del cicle de vida dels processos d’usuari, aquests sol·liciten memòria
tant en el moment de la creació (per a ubicar el codi, les dades i la pila del nou
procés) com en temps d’execució (si el procés demana memòria dinàmica, si
cal fer créixer la pila, si es carrega un nou executable utilitzant alguna de les
crides exec). El nucli utilitza la granularitat de pàgina per a assignar/desassignar
memòria als processos d’usuari.
Ara bé, el nucli del sistema operatiu també té necessitats de memòria dinàmi-
ca: memòries intermèdies, estructures de dades... Cal notar que les peticions
de memòria fetes pel nucli de l’SO tenen unes particularitats respecte a les pe-
ticions dels processos d’usuari:
• El nucli sol·licita memòria per a estructures de dades de mides diverses, en

molts casos inferiors a la mida de pàgina. Assignar una pàgina sencera a
cada petició de memòria provocaria un desaprofitament de la memòria a
causa de la fragmentació interna. Aquest fet és especialment crític perquè
la memòria assignada al nucli Linux mai no és intercanviada a disc.
• El nucli sol·licita/allibera memòria freqüentment perquè la implementació

de moltes crides al sistema requereix utilitzar memòries intermèdies, es-
tructures de dades que, en alguns casos, s’alliberen en finalitzar l’execució
de la crida mateixa al sistema o en fer una altra crida al sistema.
• En alguns casos, el nucli necessita garantir que una memòria intermèdia

estigui ubicada en posicions contigües de memòria física. Això és perquè
alguns elements del maquinari treballen directament amb adreces físiques.
A més a més, el fet d’assignar memòria físicament contigua permet que
no calgui modificar les taules de pàgines, amb la millora conseqüent de
rendiment del TLB.
Tot plegat fa que el nucli del sistema operatiu utilitzi un gestor de memòria
específic per a satisfer les seves necessitats de memòria dinàmica. A continua-
ció veurem els gestors de memòria utilitzats pel nucli Linux per a satisfer les
peticions de memòria del nucli mateix.
1)�Espai�d’adreces�lògic�del�nucli�Linux�en�IA-32
En l’arquitectura IA-32, l’espai lògic té una mida màxima de 4 GB. El Linux

divideix aquest espai lògic en dues parts:
• Des de l’adreça 0 fins a la 3 GB ([0x00000000-0xbfffffff]: aquest rang és

propi de cada procés en execució. S’hi emmagatzemen el codi/dades/pila
de cada procés. Cada cop que es produeix un canvi de context, es canvia
la taula de pàgines utilitzada per l’MMU, i per tant es modifiquen quines
són les pàgines físiques associades a aquestes pàgines lògiques.
• Des de l’adreça 3 GB fins a la 4 GB ([0xc0000000-0xffffffff]: aquest rang

és propi del nucli Linux. Té el mateix contingut per a tots els processos
en execució.
Dins del rang d’adreces lògic del nucli Linux, trobem aquestes parts:
• Des de l’adreça 3 GB fins a l’adreça 3 GB + 896 MB: aquest rang d’adreces

lògiques mapa directament la memòria física instal·lada, és a dir, l’adreça
lògica 3 GB + p està mapada sobre l’adreça física p.
• Un forat de 8 MB (marcat com a pàgines invàlides a la taula de pàgines)

que s’inicia a l’adreça 3 GB + 896 MB. Aquest forat té la funció d’ajudar a
detectar desbordaments en els accessos a memòria que fa el nucli Linux.
• Les assignacions de memòria físicament no contigua. Cada assignació és

de mida múltiple de la mida de pàgina (4 KB) i entre dues assignacions
consecutives hi ha un forat d’una pàgina, que té una funció anàloga al del
punt anterior.
• Altres dades que obviarem per tractar-se de casos molt particulars.
2)�Assignació�de�memòria�al�nucli
El nucli considera tres escenaris:
• Assignació de pàgines físicament contigües: satisfà peticions de mida múl-

tiple de la mida de pàgina.
• Assignació de memòria físicament contigua: satisfà peticions de mida ar-
bitrària.
• Assignació de memòria físicament no contigua: es pot utilitzar per a assig-

nar al nucli memòria físicament no contigua.
Tot seguit discutim aquests escenaris.
a)�Assignació�de�pàgines�físicament�contigües:�buddy�system
Aquest gestor permet obtenir pàgines físicament contigües. Ara bé, està disse-
nyat per a intentar minimitzar l’impacte de la fragmentació externa que pot
provocar la contigüitat. El buddy system es fonamenta en dues característiques:
• La unitat d’assignació són blocs de mida una potència de 2 (per tant, podrà
tenir un cert grau de fragmentació interna). Si el nucli sol·licita K pàgines,
i
l’algorisme satisfarà la petició assignant-hi 2 pàgines, en què 2i-1 < K ≤ 2i.
L’exponent i es denomina ordre de la petició.
• Disposa d’un mecanisme de compactació de blocs lliures (compacta dos

blocs lliures contigus de mida 2k en un de mida 2k+1).
La implementació del mecanisme utilitza MAX_ORDER (típicament 10) llistes.

La llista número i conté la llista de blocs lliures d’ordre i, és a dir, blocs lliures
i
de mida 2 pàgines.
El buddy system s’inicialitza assignant-hi un bloc de pàgines lliures físicament

contigües. Aquest nombre de pàgines ha de ser una potència de 2. Per exemple,
9
assumint pàgines de 4 KB, un buddy de 512 pàgines (2 ) gestionaria 2.048 kB
contigus de memòria física. Aquest bloc s’insereix a la llista de blocs lliures
d’ordre 9.
Quan el nucli sol·licita K pàgines, es calcula l’ordre corresponent a aquesta

petició (i) i es comprova si hi ha algun bloc lliure a la llista corresponent a
aquest ordre.
• En cas d’haver-n’hi, s’elimina aquest bloc de la llista de blocs lliures i

s’assigna al nucli.
• En cas de no haver-n’hi, es comproven les llistes de blocs lliures d’ordre

superior (i + 1, i + 2, ...) fins a trobar algun bloc lliure. El bloc s’elimina
de la llista i, assumint que el bloc sigui d’ordre k, es divideix en dos blocs
d’ordre i, un d’ordre i + 1, un d’ordre i + 2, ... i un d’ordre k – 1. Un dels
blocs d’ordre i s’assigna al nucli i la resta de blocs s’insereixen a les llistes
de blocs lliures corresponents.
Quan el nucli allibera un bloc, aquest s’incorpora a la llista de blocs lliures

corresponent al seu ordre. A més, el sistema pot compactar dos blocs lliures
contigus d’ordre i per a obtenir un bloc lliure d’ordre i + 1, i repetir aquesta
operació recursivament. La implementació del mecanisme utilitza mapes de
bits per a detectar blocs lliures contigus.
La figura 6 mostra un exemple del funcionament d’aquest gestor. Es mostra

el contingut de la llista de blocs lliures per a cada ordre, i com evolucionen a
mesura que es fan un seguit de peticions.
Figura 6. Exemple de funcionament del buddy system
Les versions 2.6 del nucli Linux utilitzen aquest gestor.
En el fitxer /proc/buddyinfo podem obtenir informació sobre la utilització ac-

tual. Cada línia correspon a una zona de memòria i cada columna correspon al
nombre de pàgines lliures d’aquell ordre. A continuació teniu un exemple de
la informació que podem obtenir consultant aquest fitxer. El concepte de node
fa referència a màquines NUMA (non-uniform memory access), en què un rang
d’adreces físiques pot tenir un temps d’accés diferent a un altre rang d’adreces
físiques. El concepte de zone respon a peculiaritats de l’arquitectura IA-32, en
què no tota la memòria física instal·lada té el mateix tractament: DMA corres-
pon a les pàgines per sota de l’adreça 16 MB (per una limitació dels busos ISA
antics, calia fer les transferències per DMA en aquest rang), normal correspon
a pàgines entre l’adreça 16 MB i l’adreça 896 MB, i la high mem correspon a les
pàgines per sobre de l’adreça 896 MB (com s’ha comentat al punt 1 d’aquest
annex, el nucli Linux instal·lat sobre un processador IA-32 no pot accedir di-
rectament a tot l’espai físic de memòria per sobre d’aquesta adreça. En pro-
cessadors de 64 bits, aquesta zona és buida). Quan el nucli sol·licita memòria
utilitzant el buddy system, ha d’especificar de quina zona la vol.
b)�Assignació�de�memòria�físicament�contigua�(mida�arbitrària)
En aquest escenari pensem en peticions de memòria de mida arbitrària i, en

molts casos, de mida inferior a la mida de pàgina. Tot i que la idea del buddy
system pot ser ampliada per a satisfer peticions de mida inferior a la mida de
pàgina, la fragmentació que pot causar i la gestió dels bitmaps necessaris per a
poder fer les compactacions fan que no sigui la millor opció.
El nucli Linux ha utilitzat diferents gestors per a aquest escenari. A continuació

es fa una descripció de les principals característiques d’alguns. En compilar
el nucli Linux és possible triar quin gestor volem fer servir. Els tres gestors
presentats tenen la mateixa interfície.
Aquests gestors estan implementats sobre el gestor anterior (buddy system).
SLAB�allocator
Aquest gestor està disponible en el nucli de Linux des de la versió 2.2. Les seves
característiques principals són:
• Un slab (llosa) és un conjunt d’una o més pàgines físiques contigües.
• Una slab-cache està formada per una o més lloses. Totes les slabs d’una slab-
cache són de la mateixa mida.
• Hi ha una slab-cache per a cada objecte o estructura de dades que el nucli

necessiti crear dinàmicament (per exemple, el task_struct dels processos o
els inodes dels fitxers). Cada slab-cache pot tenir la seva mida pròpia de slab.
La figura 7 mostra un exemple que relaciona aquests conceptes:

Figura 7. Exemple en què es mostren dues slab-cache, una amb dues lloses (de 3
pàgines) i l’altra amb una llosa (de 2 pàgines)
En crear una slab-cache, s’assigna un slab a l’slab-cache i l’slab-cache passa a

contenir un cert nombre d’objectes que inicialment estan marcats com a lliu-
res. Per exemple, si considerem una slab-cache per a objectes de mida 504 oc-
tets, les pàgines són de 4.096 octets i cada slab d’aquesta slab-cache conté 2
pàgines, l’slab-cache podria arribar a contenir tants objectes com la part entera
de 4.096 * 2/504, és a dir, 16 objectes. En funció de la mida dels objectes, el
gestor emmagatzema l’estat dels objectes i les cues que permeten gestionar-los
en l’slab mateix o en una estructura externa a la llosa.
Cada llosa d’una slab-cache té un d’aquests tres estats: empty (tots els seus ob-
jectes estan marcats com a lliures), partial (alguns objectes estan marcats com
a lliures i altres com a utilitzats) i full (tots els objectes estan marcats com a
utilitzats). Inicialment, la llosa està empty.
Quan el nucli sol·licita memòria per a un objecte a l’slab-cache corresponent,

el gestor actua de la manera següent:
• Si l’slab-cache té alguna llosa marcada com a partial, obté memòria per a

l’objecte d’aquesta llosa.
• Altrament, si l’slab-cache té alguna llosa marcada com a empty, obté me-
mòria per a l’objecte d’aquesta llosa.
• Altrament, el gestor assigna una nova llosa a l’slab-cache (utilitzant el buddy
system) i obté memòria per a l’objecte d’aquesta llosa.
Quan el nucli retorna la memòria d’un objecte, només cal marcar l’objecte
com a lliure i, si cal, actualitzar l’estat de la llosa corresponent.
Els avantatges d’aquest gestor són que minimitza la fragmentació interna i que
és molt ràpid assignant/desassignant objectes al nucli (observeu que la memò-
ria ha estat preassignada al gestor en crear cada slab-cache). L’inconvenient
principal és la manca d’escalabilitat a sistemes amb molts processadors.
En el fitxer /proc/slabinfo podem obtenir informació sobre totes les slab-cac-

hes gestionades per aquest gestor. A continuació teniu un exemple de la infor-
mació que podem obtenir consultant aquest fitxer. Escrivint sobre aquest fit-
xer és possible modificar la configuració del gestor. La instrucció slabtop tam-
bé ens dóna informació sobre la utilització d’aquestes slab-caches. Cada línia
correspon a una slab-cache. Significat de les sis primeres columnes: nom de
l’slab-cache, nombre d’objectes de l’slab-cache assignats al nucli, nombre to-
tal d’objectes a l’slab-cache, mida de l’objecte (en octets), nombre d’objectes
a cada llosa, nombre de pàgines a cada slab. La penúltima columna indica el
nombre de lloses a l’slab-cache.
SLUB�allocator
SLUB és un gestor que intenta millorar el rendiment i l’escalabilitat del gestor

SLAB mitjançant la reducció de la quantitat de metainformació emmagatze-
mada (de fet, elimina la metainformació emmagatzemada als slabs) i la simpli-
ficació de l’estructura general del gestor. De fet, la U del nom SLUB indica un-
queued perquè SLUB elimina la majoria de cues d’objectes existents en l’SLAB.
SLOB�allocator
SLOB (simply list of blocks) és un gestor que està implementat pensant en dis-
positius petits i encastats. Per tant, el seu cost computacional és molt inferior
al dels gestors SLAB i SLUB. L’inconvenient d’aquest gestor és que la fragmen-
tació interna li pot fer desaprofitar la memòria disponible.
c)�Assignació�no�contigua
El nucli Linux també pot sol·licitar memòria sense imposar la restricció que
les pàgines de memòria física assignades hagin de ser físicament contigües.
El nucli Linux utilitza aquest tipus d’assignació quan l’usuari instal·la algun
mòdul, en fer entrada/sortida sobre alguns dispositius i quan necessita accedir
a memòria física per sobre de l’adreça física 896 MB.
Les assignacions han de tenir mida múltiple de la mida de pàgina. A més, el

gestor separa les assignacions consecutives mitjançant una pàgina marcada
com a invàlida. Això permet detectar desbordaments dins de cada assignació
de memòria d’aquest tipus.

La Memòria Virtual

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

La Memòria Virtual

Uploaded by

Copyright:

Available Formats

La memòria

1. Concepte de memòria virtual......................................................... 7

3. Polítiques de gestió de la memòria virtual................................. 13

En aquest mòdul didàctic s’estudia amb detall la gestió de la memòria virtual

1) Primer es repassen alguns conceptes importants que són necessaris per a

2) Després es descriu el suport de maquinari necessari per a la implementació

3) Finalment, es descriuen algunes de les polítiques d’assignació, reemplaça-

A més a més, en un annex del mòdul es descriuen algunes característiques de

1. Ampliar el concepte de memòria virtual que heu après en altres assigna-

2. Conèixer les diferents polítiques de gestió de la càrrega, d’assignació i de

3. Veure de quina manera la gestió de la memòria afecta l’execució de codi

4. Conèixer els aspectes més importants de l’assignació de memòria en el

1. Concepte de memòria virtual

Avantatges de disposar de memòria virtual

Les implementacions de memòria virtual tenen un component de maquinari Nota

2.1. Funcionalitats mínimes que ha d’oferir una MMU

memòria virtual són un mecanisme de traducció i la capacitat de generar

“només lectura4”, execució, modificació5, accedit...

Exemples de generació d’excepcions

La figura 1 mostra un diagrama amb la implementació d’una MMU basada en

2.2. Consideracions d’eficiència

Les implementacions de memòria virtual topen amb alguns problemes

En les implementacions més senzilles de paginació, la taula de pàgines ha de

Per tant, en general, la taula de pàgines no es pot emmagatzemar en re-

Per a solucionar aquests problemes algunes arquitectures permeten organitzar

3. Polítiques de gestió de la memòria virtual

Un gestor de la memòria virtual paginada ha de tenir:

• Una política de càrrega i descàrrega de pàgines per a decidir en quin mo-

• Una política�d’emplaçament per a saber on ha de posar una pàgina nova.

• Una política�de�reemplaçament per a escollir, quan el sistema no té cap

• Una política�d’assignació que, coneixent el grau de multiprogramació,

En un sistema de gestió de memòria basat en paginació, la gran majoria de Dispositius d’entrada/

d’interrupció poden haver de demanar memòria i no és possible bloquejar

A continuació es descriuen algunes polítiques de reemplaçament i d’assignació

3.1. Polítiques de reemplaçament

assignada al nucli del sistema operatiu. Això és perquè algunes porcions de

Els diferents algorismes proposats en aquest apartat s’avaluen executant-los

A l’hora d’estudiar les polítiques de reemplaçament hem de tenir en compte

1)�Política�de�reemplaçament�global. Si les polítiques són globals, es consi-

2)�Polítiques�de�reemplaçament�local. Si les polítiques són locals, tan sols un

3.1.1. L’algorisme de reemplaçament òptim

Un algorisme de reemplaçament òptim és aquell que té la taxa de fa-

Aquest algorisme no es pot implementar, ja que per a fer-ho és necessari saber

Si apliquem l’algorisme òptim a la cadena de referències del nostre exemple

Figura 2. Algorisme de reemplaçament òptim

Les tres primeres referències provoquen tres fallades de pàgina. La referència

3.1.2. L’algorisme de reemplaçament FIFO

L’algorisme�de�reemplaçament�FIFO (first in, first out) necessita saber

Si apliquem aquest algorisme a la seqüència de referències del nostre exemple

Figura 3. Algorisme de reemplaçament FIFO

De nou, les tres primeres referències produeixen 3 fallades de pàgina. Quan es

• El més lògic és que si augmentem el nombre de pàgines que un procés pot

Suposem que tenim a la memòria la seqüència de referències 1, 2, 3, 4, 1, 2, 5, 1, 2, 3, 4, 5

3.1.3. L’algorisme de reemplaçament LRU

L’algorisme de reemplaçament LRU (least recently used) consisteix a regis-

Figura 4. Algorisme de reemplaçament LRU

Aquí es produeixen 12 fallades de pàgina en total (taxa de fallades de pàgina

Es poden aconseguir algunes de les implementacions possibles de l’algorisme

a) Afegint comptadors a cada entrada de la taula de pàgines que indiquen

Totes dues opcions requereixen suport de maquinari per a ser implementades, i

1)�Desar�la�història�de�les�referències. En aquest cas, a més del bit de refe-

La pàgina que té el registre d’història amb el valor més petit és la candidata a

2)�Donar�una�segona�oportunitat. En aquest cas podríem considerar que no