Att mappa en fil till minnet (till minnet) är ett sätt att arbeta med filer i vissa operativsystem, där hela filen eller någon kontinuerlig del av den tilldelas ett visst minnesområde (ett antal RAM-adresser) . I det här fallet leder läsning av data från dessa adresser faktiskt till läsning av data från den mappade filen, och skrivning av data till dessa adresser leder till att dessa data skrivs till filen. Du kan ofta mappa till minnet inte bara vanliga filer utan även enhetsfiler.
Ett alternativ till mappning är att direkt läsa filen eller skriva till filen. Detta sätt att arbeta är mindre bekvämt av följande skäl:
En ytterligare fördel med att använda en mappning är den lägre belastningen på operativsystemet jämfört med att läsa/skriva - faktum är att när man använder mappningar så laddar inte operativsystemet in hela filen i minnet på en gång, utan gör det efter behov, i blockerar storleken på en minnessida (vanligtvis 4 kilobyte). Således, även med en liten mängd fysiskt minne (till exempel 32 megabyte), kan du enkelt visa en fil på 100 megabyte eller mer utan att orsaka mycket overhead för systemet. Förstärkningen uppstår också när du skriver från minne till disk: om du har uppdaterat en stor mängd data i minnet kan de samtidigt (i ett pass med huvudet över disken) skrivas till disken.
En minneskartad fil är också bekväm genom att du enkelt kan ändra dess storlek och samtidigt (efter ommappning) få till ditt förfogande en kontinuerlig minnesbit av önskad storlek. Med dynamiskt minne är ett sådant trick inte alltid möjligt på grund av fenomenet fragmentering. När vi arbetar med en minnesmappad fil konfigurerar minneshanteraren automatiskt processorn så att RAM-sidorna som lagrar intilliggande fragment av filen bildar ett kontinuerligt adressintervall.
Den främsta anledningen till att använda kartläggning är prestandavinst. Du måste dock vara medveten om de kompromisser som måste göras. Normal I/O är fylld med omkostnader för ytterligare systemanrop och onödig kopiering av data, användningen av mappningar är fylld med avmattningar på grund av sidåtkomstfel. Låt oss säga att sidan som är relaterad till den önskade filen redan finns i cachen, men inte är associerad med denna visning. Om den har modifierats av en annan process kan ett försök att associera den med mappningen misslyckas och resultera i att man behöver läsa om data från disk eller spara data på disk. Även om programmet gör färre operationer för att komma åt via kartan, kan operationen att skriva data till någon plats i filen ta längre tid än att använda fil-I/O-operationer (även om att använda kartor i genomsnitt ger en förstärkning).
En annan nackdel är att skärmstorleken beror på vilken arkitektur som används. Teoretiskt kan 32-bitars arkitekturer (Intel 386, ARM 9) inte skapa mappningar som är större än 4 GB.
Den kanske vanligaste användningen av fil-till-minne-mappning är att ladda en process i minnet (detta är sant för både Microsoft Windows och Unix -liknande system). Efter att en process har startat mappar operativsystemet sin fil till ett minne som får köras (det körbara attributet). De flesta system som använder filmappning använder page-on-demand- tekniken , där filen laddas in i minnet inte helt, utan i små delar, storleken på en minnessida, medan sidan bara laddas när den verkligen behövs [1] . När det gäller körbara filer tillåter den här tekniken operativsystemet att endast behålla de delar av maskinkoden i minnet som faktiskt behövs för att köra programmet.
Ett annat vanligt användningsfall för mappningar är att skapa minnesbitar som delas av flera processer. I moderna operativsystem (med skyddat läge ) tillåter en process i allmänhet inte att andra processer kommer åt "dess" minne. Program som försöker få åtkomst till annat minne än sina egna skapar ogiltiga sidfel eller undantag för segmenteringsöverträdelser .
Att använda minneskartade filer är ett av de mest populära och säkra (utan att göra undantag) sätten att göra minne tillgängligt för flera processer. Två eller flera applikationer kan samtidigt mappa samma fysiska fil till sitt minne och komma åt det minnet.
De flesta moderna operativsystem eller skal stöder någon form av minneskartad filmanipulation. Till exempel är funktionen mmap () [2] , som skapar en mappning för en fil med en given deskriptor, med början på någon plats i filen och med en viss längd, en del av POSIX- specifikationen . Således stödjer ett stort antal POSIX -kompatibla system, såsom UNIX , Linux , FreeBSD , Mac OS X [3] eller OpenVMS , en vanlig filmappningsmekanism. Microsoft Windows stöder också ett specifikt API för detta ändamål, såsom CreateFileMapping() [4] .