Como limitar o cache de arquivos no CentOS (Linux)? Configurando Swappiness e cache no Linux Gerenciando o cache no kernel Linux 2.4.
Muitas vezes é importante verificar o uso de memória compartilhada e de processo em servidores, bem como recursos não utilizados. Se você estiver executando um servidor web, o servidor deverá ter memória suficiente para atender os visitantes do site. Caso contrário, o site ficará muito lento ou até mesmo indisponível quando houver um aumento no tráfego, simplesmente porque não haverá memória suficiente. A mesma coisa que acontece em um computador desktop.
1. Comando grátis
O comando free é o comando mais simples e fácil de usar para verificar o uso de memória no Linux. Aqui está um pequeno exemplo
$ free -m total de buffers compartilhados gratuitos usados em cache Mem: 7976 6459 1517 0 865 2248 -/+ buffers/cache: 3344 4631 Troca: 1951 0 1951
Opção -m exibe todos os dados em megabytes. Volume total total BATER 7.976 MB instalados no sistema, ou seja, 8 GB. Coluna usado mostra a quantidade de RAM que pode ser usada no Linux, no nosso caso será cerca de 6,4 GB. O problema aqui são os alto-falantes armazenado em cache E buffers. A segunda linha diz que 4,6 GB são gratuitos. Esta é a memória livre na primeira linha com adição de buffers e memória cache.
O Linux tem o hábito de armazenar em cache para melhorar o desempenho, para que a memória possa ser liberada e usada quando necessário.
A última linha é troca de memória ( trocar), que neste caso é totalmente gratuito.
2. /proc/meminfo
A próxima maneira de verificar o uso da memória é ler o arquivo /proc/meminfo. Esteja ciente de que o sistema de arquivos /proc não contém arquivos reais. São arquivos virtuais que contêm informações dinâmicas sobre o kernel e o sistema.
$ cat /proc/meminfo MemTotal: 8167848 kB MemFree: 1409696 kB Buffers: 961452 kB Em cache: 2347236 kB SwapCached: 0 kB Ativo: 3124752 kB Inativo: 2781308 kB Ativo (anon): 2603376 kB Inativo (anon): 309 056kB Ativo (arquivo): 521376 kB Inativo (arquivo): 2472252 kB Inevicável: 5864 kB Mlocked: 5880 kB SwapTotal: 1998844 kB SwapFree: 1998844 kB Sujo: 7180 kB Writeback: 0 kB AnonPages: 2603272 kB Mapeado: kB Shmem: Laje de 311596 kB : 200468 kB SReclaimable: 151760 kB SUnreclaim: 48708 kB KernelStack: 6488 kB PageTables: 78592 kB NFS_Unstable: 0 kB Bounce: 0 kB WritebackTmp: 0 kB CommitLimit: 6082768 kB Committed_AS: 9397536 kB Vmalloc Total: 34359738367 kB VmallocUsado: 420204 kB VmallocChunk: 34359311104 kB HardwareCorrompido: 0 kB AnonHugePages: 0 kB HugePages_Total: 0 HugePages_Free: 0 HugePages_Rsvd: 0 HugePages_Surp: 0 Hugepagesize: 2048 kB DirectMap4k: 62464 kB DirectMap2M: 8316928 kB
Vamos mudar o comportamento do Ubuntu em relação ao uso de RAM e swap (partição swap). Existe um parâmetro chamado vm.swappiness, que tem um valor padrão de 60 e controla a porcentagem de memória livre na qual o despejo ativo de páginas na partição swap começará. Em outras palavras, com 100-60=40% de memória ocupada, o Ubuntu já começará a usar a partição swap. No grandes quantidades RAM no computador, é melhor alterar o parâmetro vm.swappiness para 10 e assim ordenar ao Ubuntu que não use swap até que a RAM ocupada atinja 100-10=90%. Vamos definir o valor como 10 em vez de 60. No console, digite o seguinte comando:
Eco 10 > /proc/sys/vm/swappiness
Sysctl -w vm.swappiness=10
Para salvar a configuração após uma reinicialização, adicione a seguinte linha ao final do arquivo /etc/sysctl.conf:
VM.swappiness=10
Para aplicar imediatamente a configuração:
Sysctl-p
Além disso, podemos falar sobre mais alguns parâmetros.
O pseudoarquivo vfs_cache_pression armazena um valor - o nível de memória alocada para o cache. Valor padrão: 100. Aumentar este parâmetro faz com que o kernel despeje mais ativamente as páginas de memória não utilizadas do cache, ou seja, A quantidade de RAM alocada para o cache crescerá mais lentamente, o que por sua vez reduzirá a probabilidade de a partição swap ser usada. Ao diminuir este parâmetro, o kernel, ao contrário, manterá as páginas de memória no cache por mais tempo, inclusive no swap. Isso faz sentido quando há uma pequena quantidade de RAM, por exemplo, se tivermos 512 MB de memória, então o. O parâmetro vfs_cache_pression pode ser definido como 50. Isso reduzirá o número de operações de disco na partição swap, portanto, a remoção de páginas não utilizadas ocorrerá com menos frequência.
Se você quiser acelerar o sistema e tiver RAM suficiente (2 GB ou mais), altere o valor do sistema assim: swappiness = 10, vfs_cache_pression = 1000 (padrão 100), adicione a seguinte linha ao /etc/sysctl Arquivo .conf:
Vm.vfs_cache_pressão=1000
ou em tempo real:
Sysctl -w vm.vfs_cache_pressão = 1000
Cache no Linux
Quando os dados são gravados no disco (por qualquer programa), o Linux armazena essas informações em uma área de memória chamada Page Cache. As informações sobre esta área de memória podem ser visualizadas usando os comandos free, vmstat ou top. Informação completa Você pode ver mais sobre esta área de memória no arquivo /proc/meminfo. Abaixo está um exemplo deste arquivo em um servidor com 4 GB de RAM:
Memória total: 3950112 kB
MemFree: 622560 kB
Buffers: 78.048 kB
Em cache: 2901484 kB
SwapCached: 0 kB
Ativo: 3108012 KB
Inativo: 55296 kB
Total Alto: 0 kB
AltaLivre: 0 kB
Total Baixo: 3950112 kB
Baixo Livre: 622560 kB
Total de trocas: 4198272 kB
Troca grátis: 4198244 kB
Sujo: 416 kB
Write-back: 0 kB
Mapeado: 999852 kB
Laje: 57104 kB
Comprometido_AS: 3340368 KB
Tabelas de páginas: 6.672 KB
VmallocTotal: 536870911 kB
VmallocUsado: 35300 kB
VmallocChunk: 536835611 kB
HugePages_Total: 0
HugePages_Free: 0
Tamanho de página enorme: 2.048 kB
O tamanho do cache da página é mostrado no parâmetro "Cached", neste exemplo é 2,9 GB. À medida que as páginas são gravadas na memória, o tamanho do parâmetro "Dirty" aumenta. Ao começar a gravar no disco, o parâmetro "Writeback" aumentará até o final da gravação. É bastante difícil ver o parâmetro "Writeback" alto, pois seu valor só aumenta durante o polling, quando as operações de entrada/saída (E/S) estão enfileiradas, mas ainda não foram gravadas no disco.
O Linux normalmente grava dados de cache em disco usando o processo pdflush. A qualquer momento, existem de 2 a 8 threads pdflush em execução no sistema. No arquivo /proc/sys/vm/nr_pdflush_threads você pode ver quantos no momento tópicos ativos. Sempre que todos os threads existentes do pdflush estiverem ocupados por pelo menos 1 segundo. Novos threads tentam gravar dados em filas de dispositivos livres, de modo que para cada dispositivo ativo houve 1 thread liberando dados do cache. Cada vez que passa um segundo sem qualquer atividade do pdflush, 1 thread é removido. No Linux, você pode configurar o número mínimo e máximo de threads pdflush.
Configurando o pdflush
Cada thread pdflush é controlado por vários parâmetros em /proc/sys/vm:
- /proc/sys/vm/dirty_writeback_centisecs (padrão 500): em centésimos de segundos. Esta configuração indica com que frequência o pdflush continua a gravar dados no disco. Por padrão, 2 threads são retomados a cada 5 segundos.
Pode haver um comportamento não documentado que frustra as tentativas de reduzir dirty_writeback_centisecs para permitir que o processo pdflush armazene dados em cache de forma mais agressiva. Por exemplo, nas primeiras versões do kernel Linux 2.6, o arquivo mm/page-writeback.c incluía uma lógica que dizia "se as gravações no disco demorarem mais do que o parâmetro dirty_writeback_centisecs, defina o intervalo para 1 segundo". Esta lógica é descrita apenas no código do kernel e seu funcionamento depende da versão do kernel Linux. Como isso não é muito bom, você estará protegido contra a redução deste parâmetro. - code>/proc/sys/vm/dirty_expire_centiseconds (padrão 3000): em centésimos de segundos. Este parâmetro especifica por quanto tempo os dados podem permanecer no cache antes de serem gravados no disco. O valor padrão é muito longo: 30 segundos. Isto significa que quando operação normal Até que dados suficientes tenham sido gravados no cache para chamar outro método pdflush, o Linux não gravará dados no disco que estejam no cache por menos de 30 segundos.
- /proc/sys/vm/dirty_background_ratio (padrão 10): A porcentagem máxima de RAM que pode ser preenchida pelo cache de página antes de gravar dados no disco. Algumas versões do kernel Linux podem definir este parâmetro para 5%.
A maior parte da documentação descreve esse parâmetro como uma porcentagem da RAM total, mas de acordo com códigos-fonte O kernel do Linux não é. Observando o meminfo, o parâmetro dirty_background_ratio é calculado a partir do valor MemFree + Cached - Mapped. Portanto, para nosso sistema de demonstração, 10% é um pouco menos que 250 MB, mas não 400 MB.
Quando o pdflush começa a gravar?
Na configuração padrão, os dados gravados no disco permanecem na memória até:
Se as operações de gravação ocorrerem com frequência no servidor, um dia o parâmetro dirty_background_ratio será alcançado e você poderá ver que todas as gravações no disco passam apenas por esse parâmetro, sem esperar que o parâmetro dirty_expire_centiseconds expire.
Processo de escrita de página
O parâmetro /proc/sys/vm/dirty_ratio (padrão 40) é a porcentagem máxima do total de RAM que pode ser alocada para o cache da página antes que o pdflush grave os dados no disco.
Nota: Durante a gravação no disco, todos os processos de gravação são bloqueados, não apenas aquele que preencheu o buffer de gravação. Isso pode fazer com que um processo bloqueie todas as operações de E/S no sistema.
Melhores práticas para otimizar o Linux para operações com uso intensivo de gravação
Normalmente, ao tentar aumentar o desempenho do subsistema de disco, eles encontram o problema de que o Linux armazena muitas informações em buffer de uma só vez. Isto é especialmente perceptível para operações que requerem sincronização do sistema de arquivos usando chamadas fsync. Se durante essa chamada houver muitos dados no cache, o sistema poderá congelar até que a chamada termine.
Outro problema comum ocorre porque muita coisa precisa ser gravada antes de o disco físico ser gravado, fazendo com que as operações de E/S ocorram com mais frequência do que a operação normal.
- dirty_background_ratio: Ferramenta básica de ajuste. Normalmente este parâmetro é reduzido. Se o seu objetivo é reduzir a quantidade de dados armazenados no cache, para que os dados sejam gravados no disco gradualmente, em vez de todos de uma vez, reduzir esse parâmetro é a maneira mais eficaz. O valor padrão é mais adequado para sistemas com muita RAM e discos lentos.
- dirty_ratio: O segundo parâmetro mais importante a ser configurado. Se esta configuração for significativamente reduzida, os aplicativos que precisam ser gravados no disco serão bloqueados por completo.
- dirty_expire_centisecs: Tente reduzir este parâmetro, mas não muito. Ele permite reduzir o tempo que as páginas passam no cache antes de serem gravadas no disco, mas, por outro lado, reduzirá significativamente a velocidade média de gravação no disco, o que será especialmente perceptível em sistemas com discos lentos.
Como resultado obtemos
No arquivo /etc/sysctl.conf adicionamos:
Vm.dirty_background_ratio = 10 vm.dirty_ratio = 40
Em seguida, sincronizamos o cache e os dados do disco, limpamos o cache e salvamos os parâmetros:
Sincronizar; echo 3 > /proc/sys/vm/drop_caches; sysctl -p
Para reduzir o número de finalizações de gravação em disco, você precisa ajustar:
VM.dirty_writeback_centisecs = 15.000
Como qualquer outro sistema operacional,O Linux é muito eficiente com RAM. A memória disponível é distribuída livremente entre os processos, as páginas não utilizadas são liberadas para a partição swap do disco e, em caso de estouro de memória, um mecanismo especial embutido no kernel é acionado, que analisa todos os processos e destrói o culpado.
Quando qualquer processo grava dados no disco, eles são armazenados pelo kernel em um cache separado. Muitas vezes esse cache ocupa muito espaço. Neste artigo veremos como liberar memória no Linux, ou mais precisamente, como limpar o cache criado pelos programas.
Em cada distribuição Linux, você pode usar três comandos para limpar o cache de memória do Linux. Além disso, não precisamos concluir nenhum processo. Estes são os comandos:
Limpando PageCache:
sincronizar; eco 1 > /proc/sys/vm/drop_caches
Limpeza de inode e dentrie:
sincronizar; eco 2 > /proc/sys/vm/drop_caches
Limpeza de inode e dentrie e PageCache:
sincronizar; eco 3 > /proc/sys/vm/drop_caches
Antes de executar qualquer um desses comandos, execute:
Isso é necessário porque cada comando requer direitos de superusuário para funcionar. Agora vamos ver o que acontece quando esses comandos são executados.
O utilitário de sincronização força o sistema a gravar no disco todos os dados armazenados em cache, mas ainda não gravados. Isso é necessário para liberar o máximo de memória possível. Por padrão, os dados não são excluídos do cache após serem gravados no disco; isso é necessário para que o programa possa lê-los mais rapidamente, se necessário.
Se não executarmos o comando de sincronização, também liberaremos espaço, mas após executá-lo o resultado será melhor.
Símbolo de divisão; diz ao shell para esperar até que o primeiro comando seja concluído antes de executar outro comando. O último comando echo 1 > /proc/sys/vm/drop_caches grava o valor 1 no arquivo /proc/sys/vm/drop_caches. Isso sinaliza ao kernel que precisamos limpar o tipo de cache que selecionamos.
Tipos de cache no Linux
Agora vamos ver os tipos de cache que permitem limpar esses comandos e como tudo funciona.
Cache de página ou cache de página é onde o kernel coloca todos os dados que você gravou ou leu do disco. Isso acelera bastante o sistema, pois se o programa precisar dos mesmos dados uma segunda vez, eles serão simplesmente retirados da RAM. Mas por esta razão, este cache ocupa mais espaço.
Você pode visualizar o tamanho do cache da página usando o utilitário gratuito. Aqui é mostrado na última coluna - em cache:
Este tipo de cache é o mais eficiente e seguro para limpar.
Cache de inode e dentrie também se aplica ao sistema de arquivos. Só que não são os dados em si que são gravados nele, mas a estrutura do sistema de arquivos, a localização dos arquivos e pastas. Quando solicitado a localização de um arquivo ou o conteúdo de uma pasta, o kernel gera estruturas especiais que contêm todas essas informações. Na próxima vez que a solicitação for feita, as estruturas já estarão armazenadas na memória. Cada sistema de arquivos possui seu próprio cache de inode e um cache dentrie compartilhado.
Este cache ocupa muito pouca memória. Os dados são apresentados em bytes e, como você pode ver, são muito pequenos. Você pode visualizá-lo com o comando:
gato /proc/slabinfo | egrep dentry\|inode
Não é recomendado limpá-lo para liberar memória do Linux, pois pouca memória é consumida e uma nova verificação do sistema de arquivos leva um tempo relativamente longo.
Preciso limpar o cache?
Primeiro, se houver muita memória sendo usada, você pode querer limpar o cache da página, especialmente se for o cache da página que estiver ocupando muita memória. Em segundo lugar, você pode precisar limpar o cache de memória do Linux se tiver alterado qualquer sistema de arquivos ou configurações do kernel e agora quiser verificar como isso afetou a velocidade das operações de leitura/gravação. Nesse caso, você pode limpar todos os caches e fazer isso sem reinicializar, o que é muito conveniente.
O sistema operacional Linux é projetado de forma que antes de acessar o disco, o cache do disco será visualizado e, se os dados necessários estiverem lá, o disco não será acessado. Se você limpar o cache do Linux, o sistema operacional ficará um pouco mais lento porque terá que procurar dados no disco.
Limpeza automática de cache
Vejamos como limpar automaticamente o cache de memória todos os dias às duas da manhã usando o agendador de tarefas cron.
Primeiro vamos criar script bash com o seguinte conteúdo:
sudo vi /usr/local/bin/clearcache.sh
sincronizar; eco 1 > /proc/sys/vm/drop_caches
Limparemos apenas o cache da página, pois é o que ocupa mais espaço. Não tocaremos em outros tipos, para não reduzir desnecessariamente o desempenho do sistema.
sudo chmod 755 /usr/local/bin/clearcache.sh
Resta apenas adicionar a tarefa ao agendador cron. Para fazer isso, execute o comando:
E no editor que se abre, adicione a linha:
0 2 * * * /usr/local/bin/clearcache.sh
Agora este script será executado todas as noites e limpará a memória para que o servidor possa funcionar normalmente.
Configurando o tamanho do cache de memória
É muito mais conveniente não limpar o cache todas as vezes, mas definir um limite, caso seja excedido, o próprio sistema excluirá páginas desnecessárias. Você não pode limitar explicitamente quantos megabytes o sistema pode usar para cache. Toda a memória disponível será usada conforme necessário, mas a taxa na qual as páginas expiradas são removidas do cache pode ser ajustada.
O arquivo /proc/sys/vm/vfs_cache_pression é responsável por isso. Ele contém uma medida relativa de quão agressivamente você deve remover páginas do cache. Por padrão, o parâmetro é definido como 100. Se você reduzi-lo, o kernel excluirá páginas com menos frequência e isso levará a um aumento muito rápido no cache. Se definido como zero, as páginas não serão excluídas. Se o valor for superior a 100, o tamanho do cache crescerá mais lentamente e as páginas não utilizadas serão removidas imediatamente.
Por exemplo, vamos definir o tamanho mínimo do cache:
eco 1000 > /proc/sys/vm/vfs_cache_pression
Não se esqueça de que isso reduzirá bastante o desempenho do seu sistema porque os dados serão lidos do disco em vez do cache.
Como limpar a memória swap
Limpar o espaço de troca é muito fácil. Para fazer isso, execute:
trocaoff -a && trocaon -a
Tenha em mente que ao limpar o swap, todos os dados serão transferidos de volta para a RAM.
Conclusões
Isso é tudo. Você já sabe como limpar o cache do Linux e liberar memória. Não se esqueça que todos os comandos fornecidos neste artigo devem ser executados como superusuário, caso contrário nada funcionará. Se você tiver alguma dúvida, pergunte nos comentários!
Postagens relacionadas:
Recentemente em um dos servidores virtuais Encontrei um problema que demorava muito para gravar no disco. E neste tópico encontrei um interessante, que discutiu em detalhes a questão de como funciona o cache das operações de gravação de disco no Linux. Hoje haverá uma tradução deste artigo.
Cache no Linux
Quando os dados são gravados no disco (por qualquer programa), o Linux armazena essas informações em cache em uma área de memória chamada Page Cache. Informações sobre esta área de memória podem ser visualizadas usando os comandos grátis, vmstat ou principal. Informações completas sobre esta área de memória podem ser encontradas no arquivo /proc/meminfo. Abaixo está um exemplo deste arquivo em um servidor com 4 GB de RAM:
MemTotal: 3950112 kB MemFree: 622560 kB Buffers: 78048 kB em cache: 2901484 kB SwapCached: 0 kB Ativo: 3108012 kB Inativo: 55296 kB HighTotal: 0 kB HighFree: 0 kB LowTotal: 3950112 kB LowFree: 62256 0 kB SwapTotal: 4198272 kB SwapFree : 4198244 kB Sujo: 416 kB Writeback: 0 kB Mapeado: 999852 kB Laje: 57104 kB Comprometido_AS: 3340368 kB PageTables: 6672 kB VmallocTotal: 536870911 kB VmallocUsed: 35300 kB VmallocChunk 536 835 611 kB HugePages_Total: 0 HugePages_Free: 0 Hugepagesize: 2048 kB
O tamanho do cache da página é mostrado no parâmetro "Cached", neste exemplo é 2,9 GB. À medida que as páginas são gravadas na memória, o tamanho do parâmetro "Dirty" aumenta. Ao começar a gravar diretamente no disco, o parâmetro "Writeback" aumentará até o final da gravação. É bastante difícil ver o parâmetro "Writeback" alto, pois seu valor só aumenta durante o polling, quando as operações de entrada/saída (E/S) estão enfileiradas, mas ainda não foram gravadas no disco.
O Linux normalmente grava dados do cache no disco usando um processo pdflush. A qualquer momento existem de 2 a 8 threads em execução no sistema pdflush. Em arquivo /proc/sys/vm/nr_pdflush_threads Você pode ver quantos threads ativos estão ativos no momento. Sempre que todos os threads existentes do pdflush estiverem ocupados por pelo menos 1 segundo. Novos threads tentam gravar dados em filas de dispositivos livres, de modo que para cada dispositivo ativo haja 1 thread liberando dados do cache. Cada vez que passa um segundo sem qualquer atividade do pdflush, 1 thread é removido. No Linux, você pode configurar o número mínimo e máximo de threads pdflush.
Configurando o pdflush
Cada fluxo de pdflush é controlado por vários parâmetros em /proc/sys/vm:
- /proc/sys/vm/dirty_writeback_centisecs(padrão 500): em centésimos de segundos. Esta configuração indica com que frequência o pdflush continua a gravar dados no disco. Por padrão, 2 threads são retomados a cada 5 segundos.
Pode haver um comportamento não documentado que frustra as tentativas de reduzir dirty_writeback_centisecs para permitir que o processo pdflush armazene dados em cache de forma mais agressiva. Por exemplo, nas primeiras versões do kernel Linux 2.6, o arquivo mm/page-writeback.c incluía uma lógica que dizia "se as gravações no disco demorarem mais do que o parâmetro dirty_writeback_centisecs, defina o intervalo para 1 segundo". Esta lógica é descrita apenas no código do kernel e seu funcionamento depende da versão do kernel Linux. Como isso não é muito bom, você estará protegido contra a redução deste parâmetro. - /proc/sys/vm/dirty_expire_centiseconds(padrão 3000): em centésimos de segundos. Este parâmetro especifica por quanto tempo os dados podem permanecer no cache antes de serem gravados no disco. O valor padrão é muito longo: 30 segundos. Isso significa que durante a operação normal, até que dados suficientes tenham sido gravados no cache para chamar outro método pdflush, o Linux não gravará dados no disco que estejam no cache por menos de 30 segundos.
- /proc/sys/vm/dirty_background_ratio(padrão 10): A porcentagem máxima de RAM que pode ser preenchida pelo cache de página antes de gravar dados no disco. Algumas versões do kernel Linux podem definir este parâmetro para 5%.
A maior parte da documentação descreve essa configuração como uma porcentagem da RAM total, mas de acordo com o código-fonte do kernel Linux, esse não é o caso. Olhando para meminfo, o parâmetro dirty_background_ratio é calculado a partir do valor MemFree + em cache - mapeado. Portanto, para nosso sistema de demonstração, 10% é um pouco menos que 250 MB, mas não 400 MB.
Total: Quando o pdflush começa a gravar?
Na configuração padrão, os dados gravados no disco permanecem na memória até:
- permanecem na memória por mais de 30 segundos;
- as páginas em cache ocupam mais de 10% da memória de trabalho.
Se as operações de gravação ocorrerem com frequência no servidor, um dia o parâmetro dirty_background_ratio será alcançado e você poderá ver que todas as gravações no disco passam apenas por esse parâmetro, sem esperar que o parâmetro dirty_expire_centiseconds expire.
Processo de escrita de página
Parâmetro /proc/sys/vm/dirty_ratio(padrão 40): A porcentagem máxima do total de RAM que pode ser alocada para o cache da página antes que o pdflush grave os dados no disco.
Observação: durante a gravação no disco, todos os processos são bloqueados para gravação, não apenas aquele que preencheu o buffer de gravação. Isso pode fazer com que um processo bloqueie todas as operações de E/S no sistema. Faça isso
Recomendações para otimizar o Linux para operações que exigem gravação frequente
Normalmente, as pessoas que tentam aumentar o desempenho do subsistema de disco se deparam com o problema de que o Linux armazena muitas informações em buffer de uma só vez. Isto é especialmente difícil para operações que requerem sincronização do sistema de arquivos usando chamadas fsync. Se durante essa chamada houver muitos dados no cache, o sistema poderá congelar até que a chamada termine.
Outro problema comum ocorre porque muitas coisas precisam ser gravadas antes do início da gravação no disco físico. As operações de E/S ocorrem com mais frequência do que a operação normal. Você terá períodos mais longos em que nenhuma gravação no disco ocorrerá até que o cache grande esteja cheio, momento em que um dos gatilhos do pdflush será acionado e os dados serão gravados na velocidade máxima.
proporção_de_fundo_suja: A principal ferramenta de ajuste, geralmente reduz este parâmetro. Se o seu objetivo é reduzir a quantidade de dados armazenados no cache, para que os dados sejam gravados no disco gradualmente, em vez de todos de uma vez, reduzir esse parâmetro é a maneira mais eficaz. O valor padrão é mais aceitável para sistemas com muita RAM e discos lentos.
proporção_suja: O segundo parâmetro mais importante a ser configurado. Se esta configuração for significativamente reduzida, os aplicativos que precisam ser gravados no disco serão bloqueados por completo.
sujo_expire_centisecs: Tente reduzir, mas não muito. Permite reduzir o tempo que as páginas passam no cache antes de serem gravadas no disco, mas isso reduzirá significativamente a velocidade média de gravação no disco, porque é menos eficiente. Isto será especialmente perceptível em sistemas com discos lentos.
Instruções para definir parâmetros
Em arquivo /etc/sysctl.conf Entramos, por exemplo:
Vm.dirty_background_ratio = 10 vm.dirty_ratio = 40
Em seguida, sincronizamos o cache e os dados do disco, limpamos o cache e salvamos as configurações.
Sincronizar; echo 3 > /proc/sys/vm/drop_caches; sysctl -p
Quando se trata de otimização de desempenho Sistemas Linux, a memória física é o fator mais importante. Naturalmente, o Linux oferece muitas opções para controlar o uso de recursos preciosos de memória. Diferentes ferramentas variam em termos de granularidade de monitoramento (por exemplo, em todo o sistema, por processo, por usuário), interface (por exemplo, gráfica, linha de comando, ncurses) ou modo de operação (por exemplo, interativo, modo em lote).
Aqui está uma lista parcial de programas com interface gráfica ou a linha de comando para que você tenha muito por onde escolher para verificar a memória usada e livre nas plataformas Linux.
1. /proc/meminfo
A maneira mais fácil de verificar o uso de RAM é através de /proc/meminfo. Este arquivo virtual atualizado dinamicamente é na verdade a fonte de informações de exibição para muitas outras ferramentas relacionadas à memória, como ferramentas free, top e ps. Da quantidade disponível/ memória física para a quantidade de buffer que deve ser gravada no disco, /proc/meminfo tem tudo o que você deseja saber sobre o uso memória do sistema. As informações da memória do processo também estão disponíveis em /proc/
$ gato /proc/meminfo
2. no topo
O comando atop é um sistema interativo baseado em ncurses e observador de processos para o ambiente do terminal. Ele mostra informações resumidas atualizadas dinamicamente sobre fontes do sistema (CPU, memória, rede, E/S, kernel) com avisos codificados por cores no caso carga alta sistemas. Ele também pode classificar processos (ou usuários) na ordem de maior consumo de recursos, para que administrador do sistema pode dizer qual processo ou usuário é responsável pela inicialização do sistema. Os relatórios de estatísticas de memória incluem memória total/livre, memória em cache/buffer e informações de memória. memória virtual.
$ sudo no topo
3. grátis
O comando free é uma maneira rápida e fácil de obter uma visão geral do uso de memória obtida em /proc/meminfo. Ele mostra um instantâneo da memória física total/disponível e da troca do sistema, bem como do espaço de buffer usado/livre no kernel.
4. Monitor do sistema GNOME
O Monitor do Sistema GNOME é aplicação gráfica que é mostrado uma breve história usar recursos do sistema para CPU, memória, espaço de troca e rede. Ele também oferece um processo de monitoramento do uso de CPU e memória.
$ monitor do sistema gnome
5.htop
O comando htop é um visualizador de processos interativo baseado em ncurses que mostra o uso de memória por processo em tempo real. Ele pode relatar o consumo de memória do processo na memória principal (RSS), o tamanho total do programa na memória, o tamanho da biblioteca, o tamanho total da página e o tamanho da página suja (em cache) para todos os processos em execução. Você pode rolar horizontalmente ou verticalmente pela lista (classificada) de todos os processos.
6. Monitor do sistema KDE
Embora a área de trabalho GNOME possua o Monitor do Sistema GNOME, a área de trabalho KDE possui sua própria contraparte: o Monitor do Sistema KDE. Sua funcionalidade é principalmente semelhante à versão GNOME, ou seja, mostra o histórico em tempo real do uso de recursos do sistema, bem como o consumo de CPU/memória de processos individuais.
$ksysguard
7. memstat
O utilitário memstat é útil para identificar quais processos executáveis e bibliotecas compartilhadas estão consumindo memória virtual. Ao obter o ID do processo, o memstat revela quanta memória virtual é usada pelo código executável, dados e bibliotecas compartilhadas associadas a esse processo.
$memstat-p
8.nmon
O utilitário nmon é uma ferramenta de benchmark de sistema baseada em ncurses que monitora CPU, memória, E/S de disco, kernel, sistema de arquivos e fontes on-line. Com base no uso da memória, ele pode mostrar informações como memória total/livre, espaço de troca, memória em buffer/em cache, estatísticas de memória virtual carregada/descarregada, tudo em tempo real.
9.ps
O comando ps pode mostrar o uso de memória de processos individuais em tempo real. As informações de uso de memória exibidas incluem %MEM (porcentagem de memória física usada), VSZ (quantidade total de memória virtual usada) e RSS (quantidade total de memória física usada). Você pode classificar a lista de processos usando a opção “–sort”. Por exemplo, para classificar em ordem decrescente de RSS:
$ ps aux --sort -rss
10. smem
O comando smem permite medir o uso da memória física de vários processos e usuários com base nas informações disponíveis em /proc. Este utilitário usa a métrica Proportional Set Size (PSS) para estimar com precisão o uso efetivo de memória dos processos Linux. A análise de uso de memória pode ser exportada para gráficos de barras e fatias.
$ sudo smem --pie nome -c "pss"
11. topo
O comando top oferece monitoramento em tempo real dos processos em execução, juntamente com várias estatísticas de processos relacionadas ao uso de recursos. As informações relacionadas à memória incluem% MEM (porcentagem de memória usada), VIRT (quantidade total de memória virtual usada), SWAP (quantidade de memória virtual trocada), CODE (quantidade de memória física alocada para execução de código), DATA (quantidade de memória física memória alocada para não execução). -dados executáveis), RES (quantidade total de memória física usada, CODE+DATA) e SHR (quantidade de memória potencialmente compartilhada com outros processos). Você pode classificar a lista de processos com base no uso ou tamanho da memória.
12.vmstat
O utilitário de linha de comando vmstat exibe estatísticas imediatas e médias para diversas atividades do sistema, incluindo CPU, memória, interrupções e E/S de disco. Como fonte de informações de memória, este comando mostra não apenas o uso da memória física (por exemplo, memória total/usada e buffer/cache de memória), mas também estatísticas de memória virtual (por exemplo, páginas carregadas/memória paginada, paginada/carregada).
O utilitário de linha de comando vmstat exibe estatísticas instantâneas e médias de diversas atividades do sistema, abrangendo CPU, memória, interrupções, e disco E/S. Quanto às informações de memória, o comando mostra não apenas o uso da memória física (por exemplo, memória total/utilizada e memória buffer/cache), mas também estatísticas de memória virtual (por exemplo, memória paginada de entrada/saída, entrada/saída trocada).
$ vmstat -s
