b'\n_START_ARTICLE_\nRAM\n_START_SECTION_\nHovedminnets oppgaver\n_START_PARAGRAPH_\nEt program m\xc3\xa5 alltid legges i minnet f\xc3\xb8r det kan kj\xc3\xb8res. Alle data m\xc3\xa5 legges i minnet f\xc3\xb8r datamaskinen kan regne med dem eller manipulere dem, dessuten m\xc3\xa5 alle inndata og utdata innom minnet._NEWLINE_Innholdet i RAM kan leses og skrives tilfeldig og uten noen bestemt rekkef\xc3\xb8lge, derav navnet, og g\xc3\xa5r tapt n\xc3\xa5r maskinen skrus av._NEWLINE_Datamaskiner har ogs\xc3\xa5 en raskere type minne, kalt hurtigminne (cache). Under kj\xc3\xb8ring vil det hele tiden kopieres instruksjoner og data over fra hovedhukommelsen til hurtigminnet, da m\xc3\xa5 ting innom der f\xc3\xb8r de g\xc3\xa5r videre til prosessoren._NEWLINE_Leser man minnet, henter man ut data uten \xc3\xa5 forandre dem. Ved skriving til minnet, vil data som ligger p\xc3\xa5 de tilskrevne plassene i minnet g\xc3\xa5 tapt. Skriving til minnet kalles derfor en destruktiv operasjon.\n_START_SECTION_\nAdressering av minnet\n_START_PARAGRAPH_\nMinnekapasitet m\xc3\xa5les typisk i megabyte eller gigabyte. Hver byte (enhet) i minnet f\xc3\xa5r tildelt sin egen unike adresse, som regel sekvensielt, begynnende fra 0._NEWLINE_Maskinvare bruker ofte absolutt adressering av minnet. Da leser enheten en bestemt byte fra minnet, for eksempel byte 23\xc2\xa0425. Dette er den raskeste m\xc3\xa5ten \xc3\xa5 lese av minnet p\xc3\xa5._NEWLINE_N\xc3\xa5r en ny prosess legges inn i minnet, legges den inn p\xc3\xa5 et ledig sted som ikke kan forutsees av programutvikleren. En prosess vil ofte legges forskjellig sted hver gang den kj\xc3\xb8res. Det blir derfor sv\xc3\xa6rt upraktisk \xc3\xa5 bruke absolutt adressering i slike tilfeller. L\xc3\xb8sningen blir da \xc3\xa5 bruke relativ adressering. Med relativ adressering angis en minneplass som relativ i forhold til en basisadresse i minnet, og i l\xc3\xb8pet av kj\xc3\xb8retiden kan da den absolutte minneadressen regnes ut p\xc3\xa5 grunnlag av summen av basisadressen og den relative adressen.\n_START_SECTION_\nEn oversikt over minneomr\xc3\xa5det til en prosess\n_START_PARAGRAPH_\nEn prosess f\xc3\xa5r ved oppstart tildelt sitt eget minneomr\xc3\xa5de. Dette omr\xc3\xa5det kan i hovedsak bare brukes av den enkelte prosessen, operativsystemet har sperrer mellom minneomr\xc3\xa5dene som forhindrer at en prosess f\xc3\xa5r lov til \xc3\xa5 skrive til andres minneomr\xc3\xa5der._NEWLINE_En prosess sitt minneomr\xc3\xa5de deles inn i fire hovedomr\xc3\xa5der:\n_START_SECTION_\nSystemdatasegmentet\n_START_PARAGRAPH_\nDette segmentet ligger i omr\xc3\xa5det med de laveste minneadressene. Det inneholder blant annet pekere til de andre segmentene og til stacken, samt pid-en til prosessen.\n_START_SECTION_\nKodesegmentet\n_START_PARAGRAPH_\nI dette segmentet ligger all programkoden til programmet. Denne kopieres hit under oppstarten av programmet, og prosessen kan ikke skrive til dette segmentet under kj\xc3\xb8ring._NEWLINE_Dette segmentet kan deles av flere prosesser.\n_START_SECTION_\nDatasegmentet\n_START_PARAGRAPH_\nDette segmentet inneholder alle globale variable, b\xc3\xa5de initierte og ikke-initierte. Dessuten inneholder segmentet den s\xc3\xa5kalte Heapen, et omr\xc3\xa5de programmereren kan bruke til \xc3\xa5 allokere minne dynamisk. Om tilgangen til ikke-globale variable skal kunne deles av flere funksjoner under kj\xc3\xb8ring, m\xc3\xa5 disse legges her. Heapen vokser inn i den ledige minnedelen, mot h\xc3\xb8yere minneadresser.\n_START_SECTION_\nStakken\n_START_PARAGRAPH_\nstakken (stabelminnet) inneholder alle lokale variable i en funksjon. Den inneholder ogs\xc3\xa5 alle registertilstander._NEWLINE_Stakken vokser mot lavere minneadresser.\n_START_SECTION_\nOppsett av minne\n_START_PARAGRAPH_\nMinnet i en datamaskin er delt i flere omr\xc3\xa5der. De laveste minneomr\xc3\xa5dene er reservert for operativsystemet, og kan ikke brukes av brukerinitierte prosesser. _NEWLINE_Resten av minnet brukes av de forskjellige applikasjonene. Det finnes flere m\xc3\xa5ter \xc3\xa5 fordele dette mellom de forskjellige prosessene.\n_START_SECTION_\nPartisjonering\n_START_PARAGRAPH_\nMed partisjonering (partitioning) deles minneomr\xc3\xa5det inn i partisjoner, under oppstarten av datamaskinen. Disse partisjonene kan enten v\xc3\xa6re like store med statisk st\xc3\xb8rrelse og inndelt ved oppstart av datamaskinen, eller av dynamisk st\xc3\xb8rrelse og inndelt fortl\xc3\xb8pende. I den grad moderne operativsystemer bruker partisjonering, brukes dynamisk partisjonering. Dette er fordi partisjoner av lik st\xc3\xb8rrelse setter en maksimal \xc3\xb8vre grense p\xc3\xa5 st\xc3\xb8rrelsen til programmer som kan flyttes over i minnet, og gj\xc3\xb8r at sm\xc3\xa5 prosesser bruker mye mer minne enn hva som egentlig er n\xc3\xb8dvendig. _NEWLINE_Med bruk av dynamisk partisjonering kan st\xc3\xb8rrelsen p\xc3\xa5 minnepartisjonene avgj\xc3\xb8res f\xc3\xb8r kj\xc3\xb8ring, og partisjonen kan fjernes igjen etter en prosess er ferdig. Det vil imidlertid v\xc3\xa6re vanskelig for operativsystemkjernen \xc3\xa5 ansl\xc3\xa5 den n\xc3\xb8dvendige st\xc3\xb8rrelsen p\xc3\xa5 en partisjon f\xc3\xb8r programmet skal kj\xc3\xb8re. Denne strategien har derfor den ulempen at den vil f\xc3\xb8re til fragmentering av minnet etterhvert som systemet kj\xc3\xb8rer. Defragmentering av minnet vil da senere stjele tid og ressurser fra systemet, da dette er en kostbar prosedyre.\n_START_SECTION_\nSegmentering\n_START_PARAGRAPH_\nBruker man segmentering (segmentation) til \xc3\xa5 h\xc3\xa5ndtere minneblokker innf\xc3\xb8res det en ekstra tabell over minnet i operativsystemet. Denne tabellen holder rede p\xc3\xa5 minneblokkene, som da kan v\xc3\xa6re av ulik st\xc3\xb8rrelse. Denne st\xc3\xb8rrelsen bestemmes av programmereren. _NEWLINE_Med segmentering blir problemet med fragmentering av minnet mye mindre enn med bruk av partisjonering. Ulempen er at den ekstra tabellen legger til en ekstra omregning for at man skal finne en minneadresse.\n_START_SECTION_\nPaging\n_START_PARAGRAPH_\nMed bruk av paging deles minnet inn i flere minnerammer. En prosess vil s\xc3\xa5 deles opp i flere pages, og disse vil kunne fordeles rundt i minnerammen. Siden de forskjellige pages til en prosess ikke trenger \xc3\xa5 ligge sekvensielt, vil man eliminere problemene med ekstern fragmentering som man har med bruk av partisjonering og segmentering. Det vil imidlertid v\xc3\xa6re en liten intern fragmentering med bruk av paging, avhengig av st\xc3\xb8rrelsen p\xc3\xa5 rammene._NEWLINE_Som med segmentering krever paging fortl\xc3\xb8pende omregning av minneadresser under kj\xc3\xb8ring._NEWLINE_Det er ogs\xc3\xa5 mulig \xc3\xa5 kombinere paging med fragmentering av minnet.\n_START_SECTION_\nVirtuelt minne\n_START_PARAGRAPH_\nModerne operativsystemer som Microsoft Windows og Unix bruker paging i kombinasjon med virtuelt minne (\xc2\xabtilsynelatende minne\xc2\xbb, ogs\xc3\xa5 kalt swapping). Med virtuelt minne settes en seksjon av platelageret til side, og gis funksjonalitet som minne p\xc3\xa5 tross av den store hastighetsforskjellen mellom \xc2\xabekte\xc2\xbb minne og platelagere._NEWLINE_Det virtuelle minnet f\xc3\xa5r tildelt minneadresser akkurat som det ordin\xc3\xa6re minnet. En egen tabell holder rede p\xc3\xa5 disse adressene og den samsvarende delen av platelageret. Om prosessoren (via hurtigminnet) ber om innholdet i en minneadresse som ligger i det virtuelle minnet, kastes lite brukt innhold i det egentlige minnet ut til fordel for de etterspurte dataene som ligger i det virtuelle minnet. Da dette er en sv\xc3\xa6rt dyr operasjon finnes det mange forskjellige algoritmer som pr\xc3\xb8ver \xc3\xa5 gj\xc3\xb8re dette p\xc3\xa5 en best mulig m\xc3\xa5te. En typisk strategi vil v\xc3\xa6re \xc3\xa5 kopiere over ogs\xc3\xa5 n\xc3\xa6rliggende minneomr\xc3\xa5der i tillegg til det som egentlig var etterspurt, da sjansen er stor for at ogs\xc3\xa5 disse vil bli etterspurt i n\xc3\xa6r fremtid. Samtidig m\xc3\xa5 ogs\xc3\xa5 operativsystemet gj\xc3\xb8re antagelser om hvilke data i minnet som vil bli minst etterspurt fremover, slik at man kan \xc2\xabkaste ut\xc2\xbb disse fra minnet og dermed minimere sjansen for nye bytter mellom det egentlige minnet og det virtuelle minnet.'