119 Minnesallokering. Detta kapitel behandlar kort, som vanligt, dessa 'policies' och avslutas med ett avsnitt om 'caches'.

Transkript

1 Allmänt För att realisera ett virtuellt minne behövs minst två nivåer i minneshierarkin och dessutom 1. En virtuell adressrymd som är större än den fysiska,. En adressavbildningsmekanism och 3. Allokerings'policies' som avser a. utbyte av sidor eller segment: Vilket block ska kastas ut vid behov? b. placering av segment: Var ska ett segment som behövs placeras? c. hämtning: När ska ett block läsas in? Detta kapitel behandlar kort, som vanligt, dessa 'policies' och avslutas med ett avsnitt om 'caches'. 7.. Placeringsalgoritmer Syftet med dessa är att uppnå ett så bra minnesutnyttande, dvs så liten extern fragmentering, som möligt. För sidindelade system är detta ett trivialt problem. Vare sidoram duger lika bra och valet påverkar inte prestanda på något vis. För segment med olika storlek finns åtminstone fyra tänkbara metoder. Alla dessa bygger på att minneshanteraren katalogiserar alla lediga utrymmen. Dessa brukar arrangeras som en länkad lista; en sk fri lista: I vare block åtgår en plats som anger nästa "hål" i kedan och en plats som anger storleken 'First fit' betyder att listan över lediga utrymmen genomsöks från böran till dess ett tillräckigt stort ledigt utrymme hittas. Om inget sådant hittas måste processen blockeras till dess en annan process frisläpper minne. I 'rotating first fit' genomsöks listan cirkulärt från den plats som användes gången före 'Best fit' betyder att listan genomsöks till dess minsta tillräckligt stora utrymme hittas. Denna metod tenderar att ackumulera många "hål" som är så små att de förblir outnyttade. Exempel. Det är lätt att konstruera exempel där endera av 'best fit' eller 'first fit' är bäst. Antag att det initialt finns ett ledigt block av storlek 000 och ett av storlek Med en sekvens av behov på 100 och 1600 fås lediga block för First fit: Först 800, 1500, varefter processen måste blockeras. Best fit: Först 000, 300 och sedan 00, 300, så att 'best fit' (bf) är bäst. -- Med en sekvens av behov 100, 100 och 700 fås lediga block för First fit: Först 800, 1500, sedan 800, 100 och sist 100, 100. Best fit: Först 000, 300, sedan 600, 300, varefter processen måste blockeras, så att 'first fit är' (ff) bäst. I båda metoderna är det vanligt att arrangera listorna efter adresser. Om man sorterar efter storlek blir de båda metoderna identiska. Man skulle kunna tro att 'best fit' generellt sett ger bäst minnesutnyttande. Omfattande simuleringsexperiment visar att så inte är fallet. I skenet av detta kunde kanske fölander fungera: 'Worst fit' Tag det största lediga utrymmet. Motivet är att av det block som allokeras skulle tillräckligt mycket plats restera för att kunna användas till ett nytt segment. Experiment visar dock att 'worst fit' (wf) är klart sämst av de tre åtminstone för 'stora' segment.

2 10 Experimentell erfarenhet eller statistisk analys visar att utnyttandegraden för dessa metoder kan uttryckas med den sk 50%-regeln: Givet n allokerade block så förloras 0.5n block på grund av fragmentering. Figur 7.1 påvisar ett någorlunda annat experimentellt resultat. Minnesutnyttande 100% 80% 70% BF WF FF Medelstorlek på "segment" Figur 7.1 BF, FF, WF; en ämförelse Observera att sk kompaktering (= flyttning av allokerade block till en sammanhängande area) har två begränsningar: - Avsevärd tid åtgår för denna process, varför man oftast avstår. - En eventuell kompaktering måste åtfölas av relokering; - alla ingående adresser måste räknas om. En nackdel med både 'first fit' och 'best fit' är att sökmetoden kan ge långa söktider. I 'best fit' måste hela listan sökas igenom; i 'first fit' i genomsnitt halva. En metod som kan sägas vara en kombination av dem båda och som med bara lite extra overhead visat sig fungera bra är den sk 7... 'Buddy'-metoden Metoden bygger på att segment allokeras i block av olika storlek. Som storlekar kan välas två-potenser av given basstorlek; sk 'binary buddy'. Vare blockstorlek har sin egen fria lista. Vid allokering letas efter fritt block av närmast större storlek: skulle inget sådant ledigt block finnas tillgängligt så söker man i listan över närmast större block. Av dessa lediga block delar man det första blocket i två lika stora delar ('buddies'), allokerar första halvan och överför den andra halvan till fria listan över denna blockstorlek. Vid avallokering återförs den ledigblivna blocket till en fri lista. Om den ledigblivna halvan uppstått genom tidigare delning slås den i hop med sin evevtuellt lediga 'buddy' innan den placeras in i rätt lista. Såväl uppdelningen som ihopslagningen kan gå i flera steg. Initialt betraktas minnet som bestående av ett ledigt block med maximal storlek k. 'Buddy'-metoden allokerar minne enligt fölande mall. procedure get-hole (i); begin if i = k + 1 then 'failure' end if; if empty (i-list) then get-hole (i + 1); split hole; put buddies on i-list; end if; take first hole on i-list end;

3 11 Observera att det vid avallokering kan uppstå en situation i vilken två lika stora och intilliggande block inte är 'buddies'. I så fall ska de naturligtvis inte slås ihop. Givet tillstånd Placera in block med s = 1 Frigör block d Adress N s st Adress N s st Adress N s st a l a' 1 u a' 1 u a'' 1 l a'' 1 l b u b u b u c l osv c l d u d' l e l f u f u g l osv h u i 8 l Status (st): l = ledigt, u = upptaget, s = storlek, N = blocknamn. Adresssen A till läget för en 'buddy' till ett block X är A = adress(x) xor längd(x). (Basadress plus längden). Blocken c och d' är inte 'buddies'. I vare block finns i praktiken också en pekare till nästa block i listan över fria block. Figur 7. visar 'Buddy'-metoden i bildversion. Initialtillstånd Efter det att ett block av storlek ( ) 1 placerats in Efter det att block d frigorts a b Fri lista 1 a' c d e 8 1 c d e c d' f g h h Nästa lediga Storlek a delas uppp i a' och a'' d och e slås ihop till d' Men c och d' slås inte ihop Figur 7. 'Buddy'-metoden Notera att metoden både ger intern och extern minnesfragmentering. Den interna fragmenteringen är för 'binary buddy' 5%; hälften av en blockhalva blir över. Externa fragment kan uppstå eftersom flera lediga "hål" kan summera till tilräcklig storlek utan att för den skull ett segment av mindre storlek än så kan rymmas. För att eliminera den interna fragmenteringen kan blockstorlekar 1,, 3,.., max teoretiskt sett användas. Ett mer realistiskt tillvägagångssätt är att basera metoden på storlekar som uttrycks med Fibonacci-tal (använd k = i nedanstående): f i+1 = f i + f i-k, där f 0 = f 1 = 1. (k = 1 ger 'binary buddy')

4 1 7.3.Utbytesalgoritmer Om minnet är fyllt då ett 'page fault' uppstår måste beslut tas om vilken sida som ska skrivas ut för att bereda plats för en ny. Vi vill naturligtvis väla en utbytesalgoritm som ger så få antal (kommande) sidfel som möligt. Fölande algoritmer är tänkbara. Vi kan väla att invalidera, dvs kasta ut eller bara skriva över 'R(andom)':... en sida slumpmässigt.. FIFO ('first in first out'):... den sida som funnits längst tid i primärminnet. 3. LRU ('least recently used'):... den sida som är minst nyligen använd.. LFU ('least frequently used'):... den sida som använts minst antal gånger. 5. NUR ('not used recently'):... en sida som inte använts under senaste tidsintervallet. 6. B o (Beladys optimala):... den sida vars nästkommande referens ligger längst in i framtiden. 7. 'Working set'- baserade metoder. 'Random' kan ge många onödiga sidfel. Sidor refereras vanligen inte slumpmässigt. FIFO-algoritmen är ganska enkel att implementera, men obsevera att åldriga sidor kan komma att refereras snart igen. Metoden bygger inte på någon som helst information om sidreferensmönstret. Vidare lider algoritmen av en defekt (kallas Beladys anomali): Ett utökat antal sidramar kan ge större sidfelfrekvens. Exempel. Referenssträngen (en sekvens sidnummer) w = , ger 9 sidfel för minnesstorleken 3, men 10 för storleken, om minnet initialt är tomt. Tid w 3 ramar sidfel ramar sidfel kommentar n n <-- se nedan n n n Resultat Σ: 9 Σ: 10 LRU bygger på antagandet om lokalitet: Sidor som nyligen refererats kommer troligen att refereras snart igen. LRU har vid simuleringsexperiment visat ge en mycket bra sidfelfrekvens (relativt den optimala). Tyvärr är den lite dyr att implementera. En tidstämpel på vare sida och en genomgående sökning blir nödvändig. Figur 7.3 illustrerar fenomenet lokalitet.

5 13 Antal referenser under intervallet [t, t + T] Rumslokalitet Virtuell adress Allokeras lämpligen till primärminnet Figuren visar rumslokalitet. Figur 7.3 Lokalitet Den optimala algoritmen kan förstås aldrig implementeras; dock kan den användas vid simuleringsexperiment för att se hur bra andra algoritmer är relativt denna. Man kan införa måtten framåtavstånd d(x) och bakåtavstånd b(x) vid en viss (virtuell) tidpunkt t för en referenssträng w =... r t.... Måttet d(x) anger avståndet (= skillnaden i indexvärden) till den första referensen till x efter tiden t och måttet b(x) skillnaden till den närmast föregående. Den optimala algoritmen (OPT, B 0, MIN) väler den sida som maximerar d och LRU den som maximerar b. Därur föler att F(w, LRU) = F(w r, OPT), där w r är den sträng som erhålls om w reverseras och där F är sidfelfrekvensen. LFU bygger på samma idé som LRU men är inte lättare att implemetera och mycket sämre än LRU. NUR är en lättimplementerad och bra approximation till LRU. NUR-sidor känns igen på att u-biten ('page used') i sidtabellen inte är 1 eller att, om u omfattar fler bitar, antalet referenser är litet. Slutsats: Använd en approximation till LRU. Mängden M av sidor som finns i primärminnet med m sidplatser beror förutom av m på w och utbytesalgoritmen A, dvs vi kan skriva M = M(A, w, m). Definition. En algoritm A som för alla w och m uppfyller M(A, w, m + 1) M(a, w, m) kallas stackalgoritm. En sådan algoritm lider inte av Beladys anomali eftersom fler sidfelsavbrott u inte kan ske om vi utgående från visst M lägger till ytterligare sidor i minnet, dvs F(A, w, m+1) F(A, w, m). LRU är en stackalgoritm eftersom de mest nyligen refererade sidorna inte blir mindre nyligen refererade om ännu fler sidor rymms i minnet. FIFO är däremot ingen stackalgorim vilket tex sekvensen w = med m = 3 och m = visar: M(FIFO,w, 3) = {1,,5} och M(FIFO, w, )= {,3,,5}. Se '<---' i bestämningen av sidfel för FIFO ovan. Sidfelfrekvensen påverkas förstås förutom av utbytesalgoritmen även av minnestorleken. För alla metoder kan man generellt observera att felfrekvensen som funktion av minnesstorleken avtar: Först snabbt, för att vid en mycket karakterisk minnesstorlek övergå till att avta långsamt mot 0 vid en primäminnesstorlek lika med det virtuella minnets. Över en viss minnesstorlek lönar det alltså inte så mycket att installera mer primärminne. Experimentellt har man funnit tumregeln, den sk

6 1 30%-regeln: Vare fördubbling av minnet minskar felfrekvensen med 30%. Figur 7. visar karakteristiska statistiska samband mellan minnesstorlek och sidfelfrekvensen för olika algoritmer. Sidfelfrekvens Om inte lokalitet föreligger Realiserbar algoritm; tex NRU Primärminnesstorlek Optimala algoritmen Storlek av virtuella minnet Figur 7. Sidfel vs minnesstorlek 7.. Hämtregler Två kandidater är 1. 'Fetch on demand'. 'Prefetch'. Alla system bygger (väsentligen) på att ett block läses in först då en 'trap' uppstår på grund av att blocket saknas. Detta kallas 'fetch on demand' eller 'demand fetch'. Att hämta in sidor i förväg skulle kunna minska antalet sidfel. Problemet är att det är omöligt att förutse vilka sidor som kommer att refereras. 'Prefetch' används därför endast då en process startas. Operativsystemet läser in en sekvens sidor för att undvika en skur av sidfel då processen startas Andra aspekter Val av sidstorlek Sidstorleken kan påverka antalet sidfel, men ökning av storleken kan beroende på referenssträngen w både ge ett mindre eller ett större antal sidfel, varför andra överväganden dikterar valet av sidstorlek. Om sidstorleken minskas så ökar kostnaden (utrymmet) för sidtabellerna. Om sidstorleken ökas så ökas den interna fragmenteringen. Givet dessa kostnader finns alltså en optimal sidstorlek: För given medelstorlek s på programmen och sidstorlek z blir kostnaden för sidtabellen per process proportionell mot s/z. Kostanden för intern fragmentering blir proportionell mot z/. Sats. Den toala kostnaden C(z) = As/z + Bz/ minimeras för z = (As/B) 1/. Bevis. Lös ekvationen dc/dz = - As/z + B/ = 0 och beakta att d z/dz = As/z 3 > 0. I praktiken väls alltid sidstorleken lika med storleken av en sektor på skivminnet. Detta för att göra disk-i/o så snabb som möligt. Vanligaste sidstorlekarna ligger mellan 0.5 K och K.

7 'Thrashing' Om vi ökar graden av multiporgrammering kommer det effektiva cpu-utnyttandet i allmänhet att öka. Vid virtuellt minne kan dock hända att vid en viss grad av multiprogrammering det effektiva cpu-utnyttandet blir (nära) 0. Detta kallas 'thrashing' och illustreras i figur 7.5 Reellt cpu-utnyttande 100% Grad av multiprogrammering (antal aktiva processer) Figur 7.5 'Thrashing' Fenomenet beror på att vid ökad grad av multiprogrammering minskar antalet sidor vare process har i primärminnet. Vid viss grad av multiprogrammering rymms inte processernas sk 'working sets' så att alla procsser får en mycket hög sidfelfrekvens. Det betyder att operativsystemet väcks upp ofta (det skapar i sig mer overhead) och att trafiken mot disken ökar. Vid viss trafik mättas kanalen mellan cpu-n och disken varför cpu-väntan blir stor. Då detta upptäcks av processplaneraren ('medium term scheduler') försöker denna öka cpu-utnyttandet genom att aktivera ännu fler processer som i sin tur ökar sidfelfrekvensen etc... 'Catch '. 'Thrashing' kan undvikas genom att se till att innan en process aktiveras en rimlig del ('working set') av dess sidor rymms i primärminnet, alternativt att, givet en viss primärminnesstorlek, sätta en övre gräns för hur många processer som tillåts vara aktiva. Detta är ett beslut som 'medium term scheduler' gör. 'The working set' W(t, T) med parameter T vid tiden t består av de sidor en process refererade under det virtuella tidsintervallet [t - T, t]. T kallas fönsterstorleken. Baserat på detta begrepp har Peter Denning formulerat 'the working set principle': "A process may execute only if its working set is resident in main memory. A page may not be removed if it is in the working set of an executing process." Storleken av W beror naturligtvis, förutom på T, av w. Ett enkelt exempel kan påvisa hur programmeringen kan påverka W. Exempel. Betrakta ett avsnitt vars syfte är att 0-ställa en matris: for i := 1 to n do for := 1 to m do a[i,] := 0.0; end for; end for ; Då radindex varierar snabbast sker, om vare kolonn i matrisen ligger lagrad i en sida, inga sidfel i den inre slingan, men om matrisen ligger lagrad radvis "hoppar" den inre slingan mellan många olika sidor, varvid potentiellt många sidfel uppstår. Olika kompilatorer och arkitekturer representerar matriser olika (rad- eller kolonnvis eller via deskriptorer), men vetskap om vad som sker i vare språk gör det möligt för programmeraren att minska antalet sidfel genom att skriva slingorna 'i rätt ordning' (om det går).

8 16 Visserligen kan det invändas att vitsen med virtuellt minne är att användaren inte ska behöva tänka på "implementeringsdetaler" som tex storleken och organisationen av primärminnet, men å andra sidan: Vem organiserar inte sina ärenden efter närhetsprinciper ('caching', 'locality') i andra sammanhang? Det förtänar att påpekas att referenssträngen w vanligen har större inverkan på antalet sidfel än utbytesalgoritmen. Om sidfelen är för många i ett givet system finns i allmänhet bara två utvägar: 1. Kör andra tillämpningar.. Installera mer primärminne. I distribuerade system saknar ibland arbetsstationerna egen disk. Man förlitar sig på sk 'file servers' på vilka även det finns utrymme för 'page swapping'. 'Thrashing'-problemet blir egentligen större då, eftersom kollisioner på mediet (tex koaxialkabel eller fiberoptik) för det lokala nätet inför ännu mer indeterminism och nätet ofta dessutom är långsammare än en lokal buss mellan cpu och disk. De succesivt minskade priserna på primärminnen kanske skulle förleda en att tro att tekniker för virtuellt minne (snart) skulle bli passé. Tro't den som vill; det lär dröa innan primärminnen om 6 ord blir vanliga och programmerare tendera att snabbt utnytta allt tillgängligt virtuellt minne. År 1969, när ag skrev mitt första program, bestod hela universitetets datorkapacitet av en CD3600 med ett primärminne omfattande 3 K ord (ok då, 8-bitars ord); vi kunde skriva kompakta program då (-;)) 'Cache'-minnen Allmänt 'Cache'-minnen (eller slavminnen), cm, är buffertminnen mellan cpu-er och primärminnet med liten ( en tiondels) accesstid ämfört med primärminnets (pm). De återfinns numera vanligen 'on chip' tillsammans med styrenhet, alu och mmu-er ('memory management units'). Skillnaden mellan ett cm och [en] register[fil] är att de förra laddas maskinvarumässigt och de senare under programkontroll, dvs via maskinkod (move, ump etc) eller via mikrokod. Tanken är att sådana cm ska innehålla de flesta av de instruktioner, data eller deskriptorer/sidtabell- element som processerna ust nu behöver trots att vanligen cm << pm. Förutsättningen för att detta ska vara möligt är precis som vid virtuellt minne att processerna uppvisar lokalitet så att en liten "felfrekvens" f eller hög träff-frekvens h kan erhållas; f + h = 1. Överföringen av information (blockutbytet) mellan cm och pm sker maskinvarumässigt enligt tex en lru-approximation Pris/prestanda Om exempelvis accesstiden till pm är 500 ns, accesstiden till cm 50 ns och h = 0.99 så erhålls en upplevt accesstid på (0.99* *50) ns = 5 ns, vilket är nästan 10 gånger bättre än ett rent pm. Om vi schoblonmässigt räknar med att ett cm är 10 gånger dyrare (per bit) än ett pm och dess storlek är 1/100 därav blir totalkostnaden 110% av det rena primärminnets.

9 17 Precis som vid kopplingen mellan primär- och sekundärminne vid virtuellt minne gäller att f minskar då cm respektive pm ökar (30%-regeln). Notera att tex ett f 0.1 är helt acceptabelt i detta sammanhang, men att en felfrekvens av denna storlek skulle vara helt oacceptabel i fallet virtuellt minne Associativitet För att hålla reda på vilka "ord" av hela adressrymden som för stunden återfinns i cm är det i princip möligt att använda ett arrangemang som påminner om den sidtabell som specificerar vilken del av en virtuell adressrymd som återfinns i pm vid virtuellt minne. Eftersom snabbhet är ett mål i detta samanhang och eftersom omständlig "fel"hantering (via disk) inte behövs så arrangeras det i stället så att cm kompletteras med en associativ del (katalog) som katalogiserar den del som är närvarande i cm. Vid "miss" behövs ingen adressöversättning. Denna katalogprincip är precis densamma som är idén bakom sk 'hash'- tabeller, vilket är en programvaruteknik i vilken ett datums plats i en tabell avgörs utifrån dettas värde. Det finns för övrigt några system, tex IBM S/38 och IBM RISC/6000, som använder en likartad teknik för 'paging'; sk inverterade sidtabeller, där platsen f i tabellen för förekomsten av sidnumret p ger ramindex f för den fysiska adressen. Abstrakt sett kan vi säga att när en adress presenteras för cm så konsulteras denna katalog, som 1. avgör om motsvarande element återfinns i cm,. levererar detta om så är fallet 3. och annars signalerar "miss". I fallet 3. går referensen vidare till pm och sker ett utbyte av ett block mellan cm och pm. 'Cache'minnet kombineras alltså alltid med en acssociativ komponent och vi kan uppfatta minneslementen som par <nyckel, data>, där nyckel = adressen och data = minneslementet i detta sammanhang. Till vare element finns i praktiken en komparator som ämför den till cm inkommande adressen (a) med nyckel-delen (n). Alla minneselement ämförs parallellt och det data där likhet föreligger levereras data ut från cm: träff = i [ a i n i ], där i står för "nor" ('oint denial') över alla bitar (index i) och står för bitvis 'exclusive or'. Jämfört med ett vanligt RAM åtgår ca 50% extra grindar (tex not, or, xor). Både detta förhållande och det att cm använder snabbare logik gör ett cm dyrare än ett vanligt RAM Placeringsmetoder Vid "miss" i cm sker vanligtvis ett blockvist utbyte (fr 'paging'). Sådana block brukar kallas rader, rd, ('lines'). För att illustrera de tre olika metoderna för placering av data i ett cm utgår vi från fölande data. - pm = 1 M, dvs 0 bitars adresss - cm = 16 K, - rd = 16, Primärminnet rymmer alltså 6 K rader och cm rymmer 1 K rader a 16 element.

10 18 Direkt adressering ('direct mapping'). Detta är den enklaste metoden. Rad nummer i i pm placeras på rad nummer i mod 10 i cm. Den reella fysiska adressen kan uppfattas som om den består av tre delar - L = ett 10 bitars radnummer i cm - T = en 6 bitars etikett ('tag') - B = ett bitars elementnummer L adresserar den aktuella raden i cm. T används för att ange vilken av de, här 6, möliga raderna som för närvarande finns i cm. B adresserar linärt och sekventiellt inom raden till rätt element. En nackdel med denna metod är att h blir liten (= 0) om två rader som avbildas till samma plats i cm används omväxlande. Fullständig associativitet. Detta representerar den andra extremen. Vare rad i pm kan placeras på godtyckligt radnummer i cm. Den reella fysiska adressen kan uppfattas som om den består av två delar - T = en 16 bitars etikett - B = ett bitars elementnummer Metoden kan användas för att uppnå högsta möliga h till priset av att det blir det dyraste alternativet (störst associativ del) och att det därför också kan bli långsammast. Vid användning för lagring av delar av sidtabeller brukar denna teknik föredras. Partiell asociativitet ('set associativity', 'congruence mapping'), dvs kompromissen. CM delas in i s mängder (kongruens- eller ekvivalensklasser) vardera med storlek l rader. Om det finns m rader i cm gäller alltså m = l*s. Om vi exempelvis väler l = ('four way set associative cache') så blir i vårt exempel s = 56. En rad kan nu finnas genom att uppfatta den reella fysiska adressen som bestående av tre delar - T = en 8 bitars etikett - S = ett 8 bitars mängdnummer - B = ett bitars elementnummer Aktuell rad återfinns via S-fältet. Rad i i pm placeras i mängd i mod 55 i cm och inom den mängden används en fullständig associativ sökning, som alltså blir "kortare" än i fallet med fullständig associativitet. Figur 7.6 visar en ämförelse mellan de tre metoderna. Observera att om s = 1 så återfås fullständig associativitet. Observera att om l = 1 så återfås direkt adressring. För given storlek m på cm är l*s konstant. Högre associativitet, dvs fler rader per mängd eller färre mänger ger bättre h till högre kostnad. Experimentell erfarenhet talar för mängdstorlekar i intervallet [, 16].

11 19 Till 'cache'minnet Från minnet adresser 'Tag' Data Direkt adressering Fullständig associativitet Partiell associativitet Rad 1 1, 105,... Alla Var 56:e adress avbildas till grupper om 'cache'element fullständigt associativt , 07,... 0, 1,, 3,... Ex. 0, 56,..., 1638 till 'cache'element 0,1, och 3. (i mängd/klass # 0) Ex. 55, 16383, till 'cache'element 100,...,103 (i mängd/klass #55) Figur 7.6. Placering i ett 'cache'minne Exempel. Fölande visar några data ur verkligheten. System m l s Vårt ex M IBM Vax Utbytesmetoder Samma kandidater som vid virtuellt minne är aktuella här. Dock bör påpekas att valet av utbytesalgoritm är avhängigt placeringsmetoden. Dessutom har många experiment givit vid handen att placeringsmetoden har större inverkan på prestanda än utbytesalgoritmen. Notera tex att utbytesalgoritmen blir trivial (inget val) vid direkt adresserat 'cache', medan den är som omständligast vid fullständig associativitet. Experiment har också visat att att för små instruktions-cm och för program med många täta slingor så kan ett direkt adresserat cm utklassa ett fullständigt associativt 'cache' med lrualgoritmen, medan det omvända gäller för stora cm eller program med dålig lokalitet 'Cache' och virtuellt minne Associativa 'cache'minnen används vid virtuellt minne för att lagra delar av sidtabeller och kan också användas för att lagra aktuella instruktioner och data. Vi såg i kapitel 5 hur ett associtativt 'cache' med fullständig associativitet kan användas för adressöversättning. Om vi vill använda 'cache' som en ren "uppsnabbningsteknik" är det möligt att placera cm i det fysiska eller i det virtuella minnet. Om cm ligger i det reella minnet går de virtuella adresserna från cpu-n till minneshanteraren (denna kan alltså i sig innehålla ett cm) där de översätts till fysiska adresser och vidare ut på en buss till cm/pm-kombinationen. I denna implementering avsöks därefter först cm och vid "miss" pm. Eftersom det är möligt att arrangera cm så att sidnumret inte påverkar platsen för elementet kan en effektivare parallell implementering göras. I så fall sker cm-referensen via w- komponenten i den virtuella adressen <p, w> samtidigt/parallellt med det att p-komponenten översätts av mmu-n.

12 130 En annan reflexion: Attraktionen vid införandet av 'cache'minnen såväl som virtuella minnen grundar sig på att hög träff-frekvens erhålls (för alla normala processer). Lokaliteten spelar den centrala rollen. Annorlunda uttryckt kan man säga att programreferenssträngen w innehåller (mycken) redundans; så mycket att framtida referenser låter sig predikteras med hög nogrannhet utgående från förhistorien (fr tex lru-algoritmen) Minnesuppdatering En frågeställning som uppkommer när cm används är huruvida pm omedelbart ska uppdateras då ett cm-element förändras eller e. Om inte kommer uppdateringen att ske först då ett "block" byts ut. Detta tillvägagångssätt, 'copy back', kan förorska problem i system med flera processorer med privata cm som är anslutna till ett "globalt" pm. Exempelvis kan vi tänka oss en situation där två processorer refererar samma adress A i pm. Om processor 1 ändrar c(a) i sitt lokala cm utan att pm-innehållet omdelbart uppdateras så kan processor tätt i anslutning därtill erhålla ett ogiltigt eller gammalt värde ('stale data') vid en läsning. 'Copy back' kan ske ovillkorligt då cm innehållet byts ut eller villkorligt genom att bara ändrade rader ger upphov till uppdatering av primärminnet. Det senare kräver en en sk 'dirty bit'; ämför virtuellt minne. Ett alternativ till 'copy back' är 'write through' som innebär att primärminnet uppdateras omedelbart när 'cache'minnet ändras. Metoden undviker 'stale data' till priset av mer trafik till primärminnet. Allmänt bör tilläggas att flera processorer är bestyckade med två (eller cm); ett för [skrivbara] data (D) och ett för instruktioner (I, som förutsätts inte ändras; fr reentrans). Olika policies för såvål placering som för uppdatering förekommer då vanligen för D- respektive I-'caches' Associativa datorer Under historiens lopp har det gorts försök att bygga datorer där (data)minnet är associativt i stället för som i vanliga datorer sekventiellt adresserbart. Ett exempel på en sådan dator är Goodyear's Staran, ca 197. Det associativa minnet blir som tidagare noterats ca 50% dyrare än ett vanligt minne och tanken med maskinen var att den skulle vara lämplig för speciella tillämpningar i vilka "associativa sökningar" är centrala, tex signalanalys, stavningsrättning och mönsterigenkänning. Komplexiteten för vissa beräkningar kan med ett sådant minne och med lämpliga instruktioner reduceras från ordo(n k ) till ordo(n k-1 ): Linär sökning i ett sekventiell minne tar tid ordo(n), medan motsvarande i ett associativt minne bara kräver ordo(1) 'Interleaving' Grundtanken är att man kan öka minneseffektiviteten genom att använda flera minnesmoduler samtidigt. Vare sådan modul innehåller ett 'memory data register', MDR, och ett 'memory address register, MAR. Dessa register är anslutna till en gemensam buss via vilken kommunikation med processorn sker. Processorn kan därmed ha fler minnesreferenser pågående samtidigt. Detta gör systemet snabbare eftersom minnescyklerna är betydligt större än processorcyklerna. Om systemet innehåller N minnesmoduler M 1,..., M N, så kommer en sekvens konsekutiva referenser a 1 a a 3... att distribueras enligt regeln a i går till M precis då i mod N.

13 131 Detta betyder att i det ideala fallet så kan N referenser pågå parallellt. Om, tex, graden av 'interleaving' är N = n och kapaciteten för vare minnesmodul är m, så ger de m mest signifikanta bitarna α1 i adressen a = <α1, α> en (lokal) modulrelativ adress och de n minst signifikanta bitarna ett modulnummer. Ett "parallellt minne uppstår", men observera att succesiva adresser a måste distribueras ämnt över modulerna för att maximal effekt ska uppstå. Observera också att den vanligen är mycket sämre att vända tolkningen av α1 och α! Programkod och datareferenser utnyttar u ofta sekventiella adresser. Om sådana skulle gå till en och samma minnesmodul vore u inget vunnet. Det finns en del prestandamodeller för minnes-'interleaving'. En grov modell ger approximationen x = Σ 1 k N [(N-1)!k ]/[(N-k)!N k ] (för 1 N 5) N 0.56, (*) där x är medelvärdet av antalet minnesmoduler som refereras samtidigt; bandbredden för minnet. Exempel. Denna approximation säger oss tex att i ett system med N =16 minnesmoduler så är cirka moduler "aktiva" samtidigt. Fölande förutsättninger ger oss mölighet att härleda (*): 1. Minnesmodulernas adresser är 1,,..., N; α1 [1,N] och α är tom.. Adresserna som refereras ligger likformigt fördelade i intervallet [1, N]. 3. Minnessystemet behöver aldrig vänta på referenser.. Tiden att avkoda adressen är försumbar med minnesmodulernas cykeltid. 5. Minnesmodulerna kan inte köa ("buffra") referenser. Under dessa förutsättningar blir sannolikheten att den k:te adressen inte är lika med den första, den andra,... eller den (k-1):te lika med 1 - (k-1)/n och sannolikheten för att den (k+1):te är lika med någon av de tidigare lika med k/n. Detta leder oss till att sannolikheten för exakt k olika referenser i en sträng där den (k+1):te är lika med någon av de tidigare; den sannolikheten är [(N-1)(N-)... (N-k+1)k] / N = [(N-1)! k] / [(N-k)! N k ]. Värdet x utgör medelvärdet av längden på en icke-repeterande sekvens. Anmärkning. D. E. Knuth et al har senare (1975) härlett en bättre approximation för x, nämligen x K πn 0.5 / - 1/3 + "lägre ordningens termer".

14 13 Repetition 1. Virtuellt minne. Placeringsalgoritmer VM (196) för segment Mekanismer Baseras på fri listor 1. Namn- och adressrum 1. 'first fit'. Namn- till adressbindning. 'best fit' 'Policies 3. 'worst fit' 3. Algoritmer för. 'buddy' a. segmentplacering b. utbyte c. hämtning 3. Utbuytesalgoritmer. Hämtalgoritmer 1. 'Random' 1. 'fetch on demand'. FIFO. 'prefetch' (anomalin) 3. LRU 5. Parametrar (Stackalgoritm) 1. Sidstorlek. LFU. Sidoreferensmönster 5. NRU 3. 'Thrashing' 6. OPT. 'Working sets' 7. WS 6. 'Caches' 7. 'Interleaving' 1. Direkt adresserat πn 0.5 /. Fullständigt associativt 3. Partiellt associativt