Soluzione 1:
Il totale "memorizzato nella cache" includerà anche alcune altre allocazioni di memoria, come qualsiasi file system tmpfs. Per vedere questo in effetti prova:
mkdir t
mount -t tmpfs none t
dd if=/dev/zero of=t/zero.file bs=10240 count=10240
sync; echo 3 > /proc/sys/vm/drop_caches; free -m
umount t
sync; echo 3 > /proc/sys/vm/drop_caches; free -m
e vedrai il valore "cache" diminuire dei 100 Mb che hai copiato nel filesystem basato su ram (supponendo che ci fosse abbastanza RAM libera, potresti scoprire che parte di essa è finita in swap se la macchina è già impegnata in eccesso in termini dell'uso della memoria). Il "sync; echo 3> /proc/sys/vm/drop_caches" prima di ogni chiamata a free dovrebbe scrivere qualsiasi cosa in sospeso in tutti i buffer di scrittura (la sincronizzazione) e cancellare tutti i blocchi del disco memorizzati nella cache/buffered dalla memoria, quindi free leggerà solo altro allocazioni nel valore "memorizzato nella cache".
La RAM utilizzata dalle macchine virtuali (come quelle in esecuzione su VMWare) può anche essere conteggiata nel valore "memorizzato nella cache" di Free, così come la RAM utilizzata dai file mappati in memoria attualmente aperti (questo varierà a seconda dell'hypervisor/versione che stai utilizzando e possibilmente anche tra versioni del kernel).
Quindi non è così semplice come "i buffer contano le scritture di file/rete in attesa e i conteggi memorizzati nella cache contano i blocchi letti/scritti di recente conservati nella RAM per salvare future letture fisiche", anche se per la maggior parte degli scopi questa descrizione più semplice andrà bene.
Soluzione 2:
Domanda a trabocchetto. Quando calcoli lo spazio libero devi effettivamente sommare buffer e cache entrambi. Questo è quello che sono riuscito a trovare
Un buffer è qualcosa che deve ancora essere "scritto" su disco. Una cache è qualcosa che è stato "letto" dal disco e memorizzato per un uso successivo.
http://visualbasic.ittoolbox.com/documents/difference-between-buffer-and-cache-12135
Soluzione 3:
Stavo cercando una descrizione più chiara sul buffer e l'ho trovata in "Professional Linux® Kernel Architecture 2008"
Capitolo 16:Pagine e Buffer Cache
Interazione
Impostare un collegamento tra pagine e buffer serve a poco se non ci sono vantaggi per altre parti del kernel. Come già notato, alcune operazioni di trasferimento da e verso dispositivi a blocchi potrebbero dover essere eseguite in unità la cui dimensione dipende dalla dimensione del blocco dei dispositivi sottostanti, mentre molte parti del kernel preferiscono eseguire operazioni di I/O con granularità di pagina poiché questo rende le cose molto più semplici - soprattutto in termini di gestione della memoria. In questo scenario, i buffer fungono da intermediari tra i due mondi.
Soluzione 4:
Spiegato da RedHat :
Cache Pagine:
Una cache è la parte della memoria che memorizza in modo trasparente i dati in modo che le future richieste di tali dati possano essere servite più velocemente. Questa memoria viene utilizzata dal kernel per memorizzare nella cache i dati del disco e migliorare le prestazioni di i/o.
Il kernel Linux è costruito in modo tale da utilizzare quanta più RAM possibile per memorizzare nella cache le informazioni dai file system e dai dischi locali e remoti. Con il passare del tempo vengono eseguite varie letture e scritture sul sistema, il kernel cerca di mantenere i dati archiviati nella memoria per i vari processi in esecuzione sul sistema o i dati dei processi rilevanti che verrebbero utilizzati nel prossimo futuro. La cache non viene recuperata nel momento in cui il processo viene interrotto/chiuso, tuttavia quando gli altri processi richiedono più memoria rispetto alla memoria libera disponibile, il kernel eseguirà l'euristica per recuperare la memoria memorizzando i dati della cache e allocando quella memoria al nuovo processo.
Quando viene richiesto qualsiasi tipo di file/dati, il kernel cercherà una copia della parte del file su cui l'utente sta agendo e, se tale copia non esiste, allocherà una nuova pagina di memoria cache e la riempirà con il contenuto appropriato letto dal disco.
I dati archiviati all'interno di una cache potrebbero essere valori che sono stati calcolati in precedenza o duplicati di valori originali archiviati altrove nel disco. Quando vengono richiesti alcuni dati, la cache viene prima controllata per vedere se contiene quei dati. I dati possono essere recuperati più rapidamente dalla cache che dalla sua origine di origine.
Anche i segmenti di memoria condivisa SysV sono considerati una cache, sebbene non rappresentino alcun dato sui dischi. Si può controllare la dimensione dei segmenti di memoria condivisa usando il comando ipcs -m e controllando la colonna dei byte.
Buffer :
I buffer sono la rappresentazione a blocchi del disco dei dati archiviati nelle cache delle pagine. I buffer contengono i metadati dei file/dati che risiedono nella cache della pagina. Esempio:quando c'è una richiesta di qualsiasi dato presente nella cache della pagina, prima il kernel controlla i dati nei buffer che contengono i metadati che puntano a i file/dati effettivi contenuti nelle cache delle pagine. Una volta che dai metadati è noto l'effettivo indirizzo di blocco del file, questo viene prelevato dal kernel per l'elaborazione.
Soluzione 5:
Liberazione buffer/cache
Avviso Questo spiega un metodo forte non raccomandato sul server di produzione! Quindi sei avvisato, non incolpare me se qualcosa va storto.
Per capire, la cosa, potresti forzare il tuo sistema per delegare quanta più memoria possibile a cache piuttosto che eliminare il file memorizzato nella cache:
Prima di fare il test, puoi aprire un'altra finestra un colpo:
$ vmstat -n 1
procs -----------memory---------- ---swap-- -----io---- -system-- ----cpu----
r b swpd free buff cache si so bi bo in cs us sy id wa
0 1 39132 59740 39892 1038820 0 0 1 0 3 3 5 13 81 1
1 0 39132 59140 40076 1038812 0 0 184 0 10566 2157 27 15 48 11
...
per seguire l'evoluzione dello swap in tempo reale.
Nota: Devi disporre di tanti dischi liberi nella directory corrente, hai mem+swap
La demo$ free
total used free shared buffers cached
Mem: 2064396 2004320 60076 0 90740 945964
-/+ buffers/cache: 967616 1096780
Swap: 3145720 38812 3106908
$ tot=0
$ while read -a line;do
[[ "${line%:}" =~ ^(Swap|Mem)Total$ ]] && ((tot+=2*${line[1]}))
done </proc/meminfo
$ echo $tot
10420232
$ dd if=/dev/zero of=veryBigFile count=$tot
10420232+0 records in
10420232+0 records out
5335158784 bytes (5.3 GB) copied, 109.526 s, 48.7 MB/s
$ cat >/dev/null veryBigFile
$ free
total used free shared buffers cached
Mem: 2064396 2010160 54236 0 41568 1039636
-/+ buffers/cache: 928956 1135440
Swap: 3145720 39132 3106588
$ rm veryBigFile
$ free
total used free shared buffers cached
Mem: 2064396 1005104 1059292 0 41840 48124
-/+ buffers/cache: 915140 1149256
Swap: 3145720 39132 3106588
Nota, l'host su cui l'ho fatto è molto utilizzato. Questo sarà più significativo su una macchina davvero silenziosa.