I file mappati di memoria Linux riservano molta memoria fisica

Question

Ho un problema che è stato descritto in più thread riguardanti la mappatura della memoria e un crescente consumo di memoria sotto Linux.

Quando apro un file da 1 GB sotto Linux o MacOS X e la mappa in memoria usando

me.data_begin = mmap(NULL, capacity(me), prot, MAP_SHARED, me.file.handle, 0); 

e sequenzialmente leggere la memoria mappata, il mio programma utilizza la memoria più fisica, anche se ho usato posix_madvise (anche chiamato più volte durante il processo di lettura):

posix_madvise(me.data_begin, capacity(me), MMAP_SEQUENTIAL); 

senza successo. :-(

ho provato:

• diverse bandiere MMAP_RANDOM, MMAP_DONTNEED, MMAP_NORMAL senza successo
• posix_fadvise (me.file.handle, 0, capacità (ME), POSIX_FADV_DONTNEED) prima e dopo la chiamata mmap -> nessun successo

E funziona con Mac OS X !!! quando combino

posix_madvise(.. MMAP_SEQUENTIAL) 

e

msync(me.data_begin, capacity(me), MS_INVALIDATE). 

La memoria residente è inferiore a 16M (I periodicamente chiamato msync dopo 16mio gradini).

Ma sotto Linux niente funziona. Qualcuno ha un'idea o una storia di successo per il mio problema sotto Linux?

Cheers, David

Answer 1

gestione della memoria di Linux è diverso da altri sistemi. Il principio chiave è che la memoria che non viene utilizzata è sprecata memoria. In molti modi, Linux cerca di massimizzare l'utilizzo della memoria, risultante (il più delle volte) in prestazioni migliori.

Non è che "nulla funzioni" in Linux, ma che il suo comportamento è leggermente diverso da quello che ci si aspetta.

Quando le pagine di memoria vengono estratte dal file mmapp, il sistema operativo deve decidere quali pagine di memoria fisica verranno rilasciate (o scambiate) per poter essere utilizzate. Cerca le pagine che sono più facili da sostituire (non richiedono la scrittura immediata del disco) e hanno meno probabilità di essere riutilizzate.

La chiamata POSIX di madvice() serve a comunicare al sistema in che modo l'applicazione utilizzerà le pagine. Ma come dice il nome, è un avviso in modo che il sistema operativo sia meglio strumentato nel prendere le decisioni di paging e swap. Non è né una politica né un ordine.

Per dimostrare gli effetti di madvice() su Linux, ho modificato uno degli esercizi che do ai miei studenti. Vedi lo complete source code here. Il mio sistema è a 64 bit e ha 2 GB di RAM, che attualmente è in uso per circa il 50%. Usando il programma per mmap un file da 2 GB, leggerlo in modo sequenziale e scartare tutto. Segnala l'utilizzo di RSS ogni 200 MB viene letto.I risultati senza madvice():

<juliano@home> ~% ./madvtest file.dat n 
    0 :  3 MB 
    200 : 202 MB 
    400 : 402 MB 
    600 : 602 MB 
    800 : 802 MB 
    1000 : 1002 MB 
    1200 : 1066 MB 
    1400 : 1068 MB 
    1600 : 1078 MB 
    1800 : 1113 MB 
    2000 : 1113 MB 

Linux continuato a spingere le cose fuori di memoria fino a circa 1 GB è stato letto. Successivamente, ha iniziato a pressare il processo stesso (poiché l'altro 50% della memoria era attivo dagli altri processi) e si è stabilizzato fino alla fine del file.

Ora, con madvice():

<juliano@home> ~% ./madvtest file.dat y 
    0 :  3 MB 
    200 : 202 MB 
    400 : 402 MB 
    600 : 494 MB 
    800 : 501 MB 
    1000 : 518 MB 
    1200 : 530 MB 
    1400 : 530 MB 
    1600 : 530 MB 
    1800 : 595 MB 
    2000 : 788 MB 

Nota che Linux ha deciso di assegnare pagine al processo unico fino a raggiungere circa 500 MB, molto prima di quanto senza madvice(). Questo perché dopo, le pagine attualmente in memoria sembravano molto più preziose delle pagine che erano contrassegnate come accesso sequenziale da questo processo. C'è una soglia in VMM che definisce quando iniziare a rilasciare vecchie pagine dal processo.

Si potrebbe chiedere perché Linux ha continuato a allocare pagine fino a circa 500 MB e non si è interrotto molto prima, poiché sono stati contrassegnati come accesso sequenziale. È che il sistema aveva comunque abbastanza pagine di memoria libere, o le altre pagine residenti erano troppo vecchie per essere conservate. Tra tenere in memoria le pagine antiche che non sembrano più utili e portare più pagine a servire un programma che è in esecuzione ora, Linux sceglie la seconda opzione.

Anche se erano contrassegnati come accesso sequenziale, era solo un consiglio. L'applicazione potrebbe comunque voler tornare a quelle pagine e leggerle di nuovo. O un'altra applicazione nel sistema. La chiamata a madvice() dice solo ciò che l'applicazione stessa sta facendo, Linux prende in considerazione l'immagine più grande.