In Linux, qual è la differenza tra "buffer" e "cache" segnalata dal comando gratuito?

Questa è una vecchia domanda che ho visto di volta in volta. La mia comprensione è piuttosto limitata (avendo letto delle differenze molto tempo fa, ma i factoidi coinvolti non sono mai rimasti bloccati).

A quanto ho capito,

• buffer

  Sono utilizzati da programmi con operazioni di I / O attive, ovvero dati in attesa di essere scritti su disco

• nascondiglio

  È il risultato di operazioni di I / O completate, ad esempio buffer che sono stati scaricati o dati letti dal disco per soddisfare una richiesta.

Posso avere una chiara spiegazione per i posteri?

Il totale "memorizzato nella cache" includerà anche alcune altre allocazioni di memoria, come qualsiasi file system tmpfs. Per vederlo 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 di "cache" scendere di 100Mb che hai copiato nel filesystem basato su ram (supponendo che ci fosse abbastanza RAM libera, potresti trovarne un po 'finito in swap se la macchina è già impegnata eccessivamente in termini di uso della memoria). Il "sync; echo 3> / proc / sys / vm / drop_caches" prima di ogni chiamata gratuita dovrebbe scrivere qualsiasi cosa in sospeso in tutti i buffer di scrittura (la sincronizzazione) e cancellare tutti i blocchi del disco memorizzati nella cache / buffer dalla memoria in modo che liberi siano solo altri allocazioni nel valore "memorizzato nella cache".

La RAM utilizzata dalle macchine virtuali (come quelle in esecuzione su VMWare) può anche essere conteggiata nel valore "cache" gratuito, così come la RAM utilizzata dai file mappati in memoria attualmente aperti (questo varierà a seconda dell'hypervisor / versione che si sta utilizzando e eventualmente anche tra le versioni del kernel).

Quindi non è così semplice come "i conteggi dei buffer in attesa di scritture di file / rete e conteggi cache blocchi di lettura / scrittura recentemente conservati nella RAM per salvare future letture fisiche", sebbene per molti scopi questa descrizione più semplice lo farà.

Domanda ingannevole. Quando si calcola lo spazio libero, in realtà è necessario aggiungere buffer e cache entrambi. Questo è quello che potrei trovare

Un buffer è qualcosa che deve ancora essere "scritto" sul disco. Una cache è qualcosa che è stata "letta" dal disco e memorizzata per un uso successivo.

http://visualbasic.ittoolbox.com/documents/difference-between-buffer-and-cache-12135

Stavo cercando una descrizione più chiara del buffer e l'ho trovato in "Professional Linux® Kernel Architecture 2008"

Capitolo 16: Pagina e cache buffer

Interazione

L'impostazione di un collegamento tra pagine e buffer ha pochi scopi se non ci sono benefici per altre parti del kernel. Come già notato, potrebbe essere necessario eseguire alcune operazioni di trasferimento da e verso dispositivi a blocchi in unità le cui dimensioni dipendono dalla dimensione del blocco dei dispositivi sottostanti, mentre molte parti del kernel preferiscono eseguire operazioni di I / O con granularità della pagina in quanto rende le cose molto più semplici, soprattutto in termini di gestione della memoria. In questo scenario, i buffer agiscono come intermediari tra i due mondi.

Spiegato da RedHat :

Pagine della cache:

Una cache è la parte della memoria che archivia in modo trasparente i dati in modo che le future richieste per 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 di Linux è costruito in modo tale da utilizzare quanta più RAM possibile per memorizzare nella cache informazioni dai file system e dai dischi locali e remoti. Man mano che il tempo passa su varie letture e scritture vengono eseguite sul sistema, il kernel cerca di conservare i dati archiviati nella memoria per i vari processi in esecuzione sul sistema o quelli dei processi rilevanti che verrebbero utilizzati nel prossimo futuro. La cache non viene recuperata nel momento in cui il processo ottiene l'arresto / uscita, tuttavia quando gli altri processi richiedono più memoria della memoria disponibile libera, il kernel eseguirà l'euristica per recuperare la memoria archiviando i dati della cache e allocando quella memoria a un nuovo processo.

Quando viene richiesto qualsiasi tipo di file / dati, il kernel cercherà una copia della parte del file su cui sta agendo l'utente e, se tale copia non esiste, allocherà una nuova pagina di memoria cache e la riempirà di il contenuto appropriato letto dal disco.

I dati archiviati in una cache potrebbero essere valori che sono stati calcolati in precedenza o duplicati di valori originali archiviati in altre parti del 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.

I segmenti di memoria condivisa SysV sono anche considerati come cache, sebbene non rappresentino alcun dato sui dischi. Si può verificare 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 della pagina. Buffer contiene i metadati dei file / dati che risiedono nella cache della pagina. Esempio: quando c'è una richiesta di qualsiasi dato presente nella cache della pagina, per prima cosa il kernel controlla i dati nei buffer che contengono i metadati che puntano ai file / dati effettivi contenuti nella cache delle pagine. Una volta dai metadati è noto l'indirizzo di blocco effettivo del file, che viene raccolto dal kernel per l'elaborazione.

Liberare buffer / cache

Avvertenza Questo spiega un metodo efficace non raccomandato sul server di produzione! Quindi sei avvisato, non incolparmi se qualcosa va storto.

Per quanto riguarda la cosa, potresti forzare il tuo sistema a delegare cachequanta più memoria possibile per eliminare il file memorizzato nella cache:

Prima di fare il test, potresti 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: è necessario disporre di altrettanti dischi liberi nella directory corrente, è necessario mem + swap

$ 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 ho fatto questo è fortemente utilizzato. Ciò sarà più significativo su una macchina molto silenziosa.