I informatikk er virtuelt minne en systemarkitektur som er i stand til å simulere et sentralt minnerom ( primært minne ) som er større enn det som er fysisk til stede eller tilgjengelig, og gir brukeren en illusjon av en enorm mengde minne [1] .
Operativsystemet , ved hjelp av en kombinasjon av maskinvare og programvare, kartlegger minneadressene som brukes av et program, kalt virtuelle adresser , til fysiske adresser . Hovedminne , fra en prosess synspunkt, vises som et sammenhengende adresseområde (eller liste over segmenter). Operativsystemet administrerer virtuelt rom og tilordning av fysisk minne til virtuelt minne. Oversettelsen av adresser gjøres av en maskinvare som finnes i CPU , vanligvis kalt MMU , som oversetter de forskjellige adressene. Programvare som finnes i operativsystemet kan utvide disse funksjonene til å gi virtuelt rom som overstiger det fysiske minnet, og adresserer dermed mer minne enn det som er fysisk tilstede i datamaskinen.
Hovedfordelene med denne arkitekturen er større sikkerhet på grunn av minneisolering, muligheten til å dele noen sider med minne mellom forskjellige prosesser (spesielt bibliotekene ), og å kunne bruke mer minne enn det som er tilgjengelig med en teknikk som kalles swap .
Dette oppnås ved å bruke sekundær lagringsplass på andre lagringsenheter eller medier, vanligvis diskstasjoner . Det fysisk tilstedeværende sentrale minnet blir da den faktisk brukte delen av det virtuelle, større: denne strategien er nyttig i kraft av prinsippet om lokalitet og gjenbruk av programkjøring .
I POSIX -miljøet kalles masseminnet som brukes til dette formålet " swap " eller " swap space " (engelsk verb som betyr "å bytte"), mens det i Windows-miljøet kalles " paging file ". Operasjonene med å flytte sider fra bytteplass til fysisk minne kalles " bytte ".
I et system utstyrt med virtuelt minne refererer prosessoren og programmene til det sentrale minnet med logiske , virtuelle adresser, som blir oversatt til virkelige fysiske adresser av en spesiell enhet, MMU eller minnestyringsenhet som vanligvis er innlemmet i prosessorene.
MMU utfører følgende oppgaver:
Denne mekanismen kommer til en pris når det gjelder ytelse: det tar MMU litt tid å oversette den logiske adressen til en fysisk adresse, og det tar mye mer tid å laste et minneområde fra bytteplass: til slutt, å implementere en virtuell minne betyr å ofre datakraft for å kunne kjøre et større antall samtidige prosesser.
Sagt T a den normale tilgangstiden til det fysiske minnet, T t adresseoversettelsestiden til MMU og T laster tiden som er nødvendig for å laste et minneområde fra byttet, er den (gjennomsnittlige) tilgangstiden i tilfelle av virtuelt minne:
T av = T t + T a + T last * P feil
der P - feil er sannsynligheten for en sidefeil , det vil si å kjøre inn i en side som ikke er tilstede i hovedminnet og derfor må laste den fra byttet.
Det er hovedsakelig to måter å implementere et virtuelt minnesystem: dele minnet inn i mange identiske sider, administrert av maskinvaren, eller la programmereren og/eller kompilatoren som brukes av programmereren til å "segmentere" programmet sitt i flere segmenter (forhåpentligvis) uavhengig.
Begge metodene har fordeler og ulemper: i nyere tid er systemet langt mer brukt det sidede minnet, på grunn av større homogenitet og uavhengighet fra programvaren.
Med denne ordningen er minnet delt inn i sider som alle har samme størrelse (4 eller 8 kilobyte ): programmer trenger ikke å vite noe om hvordan minnet er organisert og må ikke ha noen spesiell intern struktur; den nøyaktige plasseringen og fysiske arrangementet av minnet de opptar angår dem ikke, og hele det virtuelle minnesystemet administreres fullstendig av MMU gjennom et komplekst system av assosiative registre. Nettopp dette systemet av registre er det svake punktet ved denne typen mekanismer: hvis antall sider er veldig stort (små sider, eller store mengder virtuelt minne å emulere) kan den assosiative mekanismen bli for kompleks, noe som reduserer tilgangen til minne (og dermed hele systemet).
Et mulig middel er å øke størrelsen på minnesidene, til prisen av en større sløsing med selve minnet («intern fragmentering»: jo større sidene, desto mer øker antallet delvis tomme sider og jo mer plass er bortkastet). .
Mer detaljert er den virtuelle minneadministrasjonsmekanismen med personsøking som følger. Bildet av en jobb er delt inn i sider med fast størrelse. Hovedminnet (RAM) er også delt inn i "biter" av samme størrelse som sidene, kalt siderammer. Hver prosess er assosiert med en tabell, som holdes i hoved- eller sekundærminne avhengig av størrelsen, kalt sidetabellen. Hvert element (rad) i sidetabellen inneholder:
De logiske adressene er representert av paret (sidenummer, offset). Oversettelsen skjer på denne måten: linjen som tilsvarer sidenummeret til den logiske adressen blir funnet, hvis Present-biten er 0, er siden ikke til stede i hovedminnet, en sidefeil genereres og siden lastes inn i minne, til slutt genereres den fysiske adressen (rammenummer, offset)
Den modifiserte biten indikerer om siden har blitt endret eller ikke. Faktisk, hvis en side ikke har blitt endret, når du bytter det sekundære minnet, gir det ingen mening å omskrive sidene til disk. Dermed sparer du tid, og delvis forbedrer ytelsen.
En siste teknisk detalj. Anta at vi har logiske og fysiske adresser med lengde k bits. Av disse vil n bli tildelt n. em side for å forskyve. Vi har derfor k = n + m. Fra dette trekker vi ut at hver side, og hver ramme, har en størrelse på 2 ^ m biter. Anta nå at hvis vi ønsker å oversette en logisk adresse (sidenummer, offset), finner vi at rammen som tilsvarer den gitte siden er i-te. Dette tilsvarer imidlertid ennå ikke den virkelige fysiske adressen, men kun til rammeindeksen. For å få den fysiske adressen må vi nå gange i * 2 ^ m. Fordelen med denne teknikken er at i det binære systemet kan denne operasjonen utføres ved å sette sammen m nuller til den binære representasjonen av i. En veldig rask operasjon, som kan utføres direkte i maskinvare.
Segmentert minneI dette tilfellet er den virtuelle minnemekanismen delvis programvare. Programmene som kjører på systemer med segmentert minne er strukturert i funksjonelt homogene segmenter : MMU holder styr på hvilke og hvor mange segmenter som finnes i minnet og hvor. Hovedfordelen med dette systemet er at det drar full nytte av det nevnte prinsippet om lokalitet, og minimerer bruken av bytteplass: når et program har segmentene det trenger i hovedminnet, vil det svært sjelden be om nye. Den betydelige ulempen med dette systemet er derimot den store sløsingen med minne på grunn av ekstern fragmentering : med tidens gang og rekkefølgen av kjørende prosesser, blir minnet allokert og deallokert i blokker av forskjellige størrelser som etterlater en evig større antall tomme "hull", for lite til å være nyttig allokert: dette gjør det nødvendig å utføre en kostbar periodisk komprimering av det tildelte fysiske minnet, og/eller bruk av svært sofistikerte allokeringsalgoritmer .
Mer presist er den segmenterte virtuelle minnestyringsmekanismen som følger. En segmenttabell er knyttet til hver prosess; hver oppføring i denne tabellen representerer et segment av prosessen og inneholder minst følgende felt: Present-biten, Modified-biten og basisadressen til segmentet i minnet.
De logiske adressene er representert av paret (segmentnummer, forskyvning). Oversettelsen skjer på denne måten: du finner oppføringen i tabellen som tilsvarer nr. segmentet; hvis Present-biten er 0, er ikke segmentet tilstede i hovedminnet, derfor genereres en Segment Fault og segmentet ventes på å bli lastet inn i minnet. Til slutt genereres den fysiske adressen ved å legge til forskyvningen til basisadressen til segmentet i minnet.
Noen maskinvaremekanismer, for eksempel DMA , krever programmet som bruker dem til å lese og/eller skrive til veldefinerte og ikke-bevegelige fysiske minnesider. For dette implementerer det virtuelle minneskjemaet av arkitekturer som bruker DMA en sidelåsmekanisme som et program kan binde en serie av sammenhengende sider med virtuelt minne til en tilsvarende serie av sammenhengende sider med fysisk minne; av åpenbare grunner blir sider som er låst med denne mekanismen verken forkastet eller flyttet for å bytte plass.
Det er viktig at mengden fysisk minne som er tilstede minst er tilstrekkelig til å opprettholde lokaliteten til systemet, eller den delen av data og informasjon som brukes umiddelbart av hver prosess. Hvis dette ikke var tilfelle, burde systemet kontinuerlig utføre bytteoperasjoner for å sikre at hver prosess har dataene den trenger.
Anta for eksempel at det fysiske minnet på et gitt tidspunkt er mettet og inneholder nøyaktig plasseringen til systemet (det vil si at summen av alle "arbeidssettene" til prosessene som behandles er nøyaktig lik den fysiske RAM-en som er til stede), og at i denne situasjonen vil starte et nytt program. Prosessen som opprettes trenger å allokere noe minne. Men siden hovedminnet er fullt, frigjør operativsystemet en del av den lagrede plassen som er en del av informasjonen i sekundærminnet. Senere, når kontrollen går tilbake til prosessen hvis data nettopp har blitt flyttet, kreves en bytteoperasjon for å laste dataene inn i hovedminnet på nytt. Siden all informasjonen i hovedminnet er uunnværlig, forekommer dette fenomenet veldig ofte. Siden sekundærminnet er mye tregere (hundrevis eller tusenvis av ganger) enn hovedminnet, forårsaker dette en betydelig nedgang i systemet, som nesten utelukkende er engasjert i I/O-operasjoner, og snart blir ubrukelig og lite eller ikke i det hele tatt reagerer på brukeren. kommandoer. Dette fenomenet kalles thrashing .
Teknisk sett, når det ledige sentrale minnet (RAM) (og derfor antallet ledige rammer) ikke er tilstrekkelig til å inneholde det nåværende arbeidssettet til en prosess, vil sistnevnte snart begynne å generere flere sidefeil, noe som reduserer utførelseshastigheten betraktelig. . Når flere prosesser begynner å rase, det vil si bruker mer tid på personsøking enn på å utføre, kan operativsystemet feilaktig bli ledet til å konkludere at det er nødvendig å øke graden av multiprogrammering (gitt at CPU forblir for det meste inaktiv tid på grunn av intens I / O-aktivitet). På denne måten settes det i gang nye prosesser som imidlertid på grunn av mangelen på ledige rammer igjen vil begynne å tøffe: Kort sagt kollapser ytelsen til systemet inntil operatøren må tvangsterminere noen prosesser. En måte å begrense dette fenomenet på er å bruke en lokal erstatningsprosedyre, det vil si å gi den virtuelle minnebehandleren muligheten til å erstatte sidene som er knyttet til den eneste prosessen som ber om dem. Dette hindrer hele systemet fra å svirre.
Det finnes ulike teknikker for å bestemme hvilke områder av minnet som skal flyttes fra primær til sekundær lagring. Følgende er de vanligste:
Denne teknikken består i å erstatte minnesiden som vil bli gjenbrukt senere. Det er klart at for å bli virkelig implementert, vil det kreve at operativsystemet på forhånd kjenner sidene som brukes i fremtiden av prosessene. Den kan derfor ikke brukes som en algoritme for å erstatte sider i hovedminnet, men som en målestokk for sammenligning av de andre strategiene.
FIFO - teknikken ( First In First Out ) er den enkleste, den holder oversikt i en tabell over når et minneområde er tildelt. Når det er en ny forespørsel om tildeling av minnesider, hvis det fortsatt er plass i hovedminnet, tildeles den nye siden ganske enkelt, ellers konsulteres det gjennom tabellen hvilke sider som har blitt tildelt lengst og flyttes til sekundærminnet .
Denne algoritmen er veldig enkel og rask å utføre, men har den ulempen at den flytter eldre sider til sekundært minne selv om de brukes ofte, den produserer også den såkalte Belady-anomalien .
Det er en enkel optimalisering av FIFO-teknikken som unngår problemet med å bytte selv svært brukte sider. Det er tilstrekkelig å legge til litt i tabellen som holder styr på sidenes alder: hver gang operativsystemet går inn på en side, setter det denne biten til 1 mens sidebyttealgoritmen , hvis den finner biten til 1, setter den til 0 og flytter en side med biten allerede satt til 0 i sekundærminnet. På denne måten har ofte brukte sider stor sannsynlighet for å forbli i hovedminnet.
I verste fall har alle sidene biten satt til 1, i dette tilfellet tilbakestiller algoritmen alle bitene til den går tilbake til den første siden tatt i betraktning. Finner det nå med bit 0, erstatter det det. I dette tilfellet reduseres andrevalgssubstitusjonen til en FIFO-erstatning.
Det er en modifisert versjon av følgende algoritme som har to biter som sporer bruk og endring. Faktisk er det følgende kombinasjoner:
Når det er nødvendig å utføre en sideerstatning, ser algoritmen først etter den beste siden å erstatte med tanke på ikke bare det faktum at den ikke har blitt brukt nylig, men også at den ikke har blitt endret. Faktisk, når siden har blitt endret, er det nødvendig å lagre innholdet igjen i det sekundære minnet. Hvis den ikke er endret, og det allerede er en kopi i sekundærminnet, er ingen I/O- operasjon nødvendig .
Den best mulige løsningen vil være å flytte sidene som ikke skal brukes på det lengste, men selvfølgelig er ikke operativsystemet i stand til å ha denne informasjonen. Kompromissløsningen er å flytte de sidene som ikke har vært brukt på lengst (LRU dvs. Least Recently Used ) da de har en god sjanse for ikke å bli brukt igjen umiddelbart. En tidsmarkør (Tn) er knyttet til hver side, som identifiserer øyeblikket den sist ble brukt.
For å effektivt administrere denne algoritmen, kreves det maskinvarestøtte, siden de kontinuerlige oppdateringene av tidsstemplet forårsaker en kontinuerlig stokking av sidene og manglende evne til å bestemme siden som skal erstattes. Denne teknikken kan implementeres på to måter:
Begge metodene har en betydelig innvirkning på systemytelsen, og av denne grunn er de vanligvis laget i maskinvare.
De er algoritmer basert på å telle antall referanser til hver side.