Perguntas[memory](unix)

Pergunta extremamente "de novato": Tenho um sistema operacional rodando sudo memtester ...em uma máquina Ubuntu 22.04, mas dei muita memória para ele testar e está demorando muito (vejo que ele está rodando e atualizando, então me certifiquei de que a RAM fornecida para teste era menor do que a disponível). Gostaria de pará-lo. Estava pensando em tentar com um simples comando Ctrl-c, mas me pergunto se isso causaria algum tipo de travamento, me forçando a reiniciar.

Infelizmente, as páginas de manual não dizem nada sobre como pará-lo.

Olá, especialistas em Kernel I/O,

Tenho uma pergunta sobre os contadores pgpgine em , focando especificamente em . Tenho explorado ferramentas de monitoramento de desempenho como e , que são ferramentas de linha de comando muito práticas para observar o desempenho de E/S. Ao examinar seu código, notei que essas ferramentas relatam "E/S atual" usando os contadores e em vez de ler diretamente as estatísticas de E/S atuais de dispositivos de bloco, como ferramentas como fazem.pgpgout/proc/vmstatpgpginvmstatiotoppgpginpgpgoutfio

Primeira pergunta: Estou tentando entender a relação exata entre os pgpgincontadores pgpgoute e a largura de banda de E/S real. Por que essas ferramentas dependem de contadores relacionados à paginação para representar a atividade de E/S? Como exatamente o pgpgin e o pgpgout são atualizados, e quais componentes do sistema são responsáveis ​​por essas atualizações? Em resumo, você poderia explicar quando e por que esses contadores refletem as operações de E/S do disco?

Segunda pergunta (caso extremo): Existem cenários específicos ou casos extremos em que pgpgina largura de banda não corresponde com precisão à largura de banda real do disco?

Ao fazer benchmarking de desempenho de leitura de SSD usando fiopolling io_uring, observei que a largura de banda de E/S relatada por fio(e estatísticas de SSD) é significativamente menor do que a largura de banda indicada por pgpgin. Essa discrepância me levou a investigar como pgpginreflete a atividade de E/S (daí a primeira pergunta acima).

Confirmei que essa incompatibilidade é consistente e não causada por ruído transitório do sistema.

Qualquer insight sobre esses contadores, seus mecanismos de atualização e sua relação com o desempenho real de E/S seria muito apreciado. Obrigado!

A página man do sistema de arquivos proc diz que o uso de memória para /proc/[pid]/statme outros é "medido em páginas". Não tenho certeza do que isso significa quando vários tamanhos de página são usados.

Digamos que meu processo use duas páginas, uma de 4 KiB e uma de 2 MiB, e sysconf(_SC_PAGE_SIZE)retorne 4096 bytes. Qual dos seguintes resultados retornará proc/[pid]/statmneste caso?

1. 2, porque o processo está usando uma página de 4 KiB e uma página de 2 MiB.
2. 513, porque o processo usa 2101248 bytes e isso é dividido pelo tamanho de página "padrão" (4096 bytes).

alguns processos no meu computador estão usando muita memória da placa de vídeo para as tarefas que estão realizando. Eu gostaria de impor um limite a essas tarefas para que o sistema operacional limite o uso de RAM no cartão dessas tarefas. normalmente, eu poderia usar ulimitse o alvo fosse o sistema de arquivos, CPU ou memória do sistema. Este utilitário, no entanto, parece não ter nenhum recurso relacionado à memória da placa de vídeo em um PC.

Então esta é a minha pergunta: dado que eu conheço o caminho de um executável para o qual gostaria de impor um limite superior ao consumo de memória da placa de vídeo, como impor esse limite? A placa neste caso é baseada em NVidia.

uptimecanalizado para sedcorrige a primeira parte, mas e quanto ao uso de memória? topé executado, pelo menos por padrão, de forma interativa.

Portanto: preciso observar a RAM usada, excluindo o cache oportunista (que é descartado assim que a memória é necessária). E pergunte sobre ambos, porque espero que uma única ferramenta padrão possa fazer isso, em vez de duas. Ou - melhor ainda - algo na /procindicação da parte RAM.

Atualmente estou estudando Linux. Eu sei que o thread é um tipo de processo leve no Linux. Mas gostaria de saber de onde vem o espaço da pilha de threads.

A pilha do encadeamento é privada. É independente da pilha de processos. Com base na minha pesquisa, algumas pessoas disseram que a pilha de threads foi criada por mmap(). E também, algumas pessoas disseram que mmap()o espaço não é heap. Está entre pilha e heap. Portanto, a pilha de threads vem do segmento de mapeamento de memória do processo. Isso é correto?

O Firefox 105.0.1 consome toda a minha memória (mate-system-monitor relata 100%), travando regularmente o Linux Mint 20 (ulyan), normalmente várias vezes por semana.

Meu sistema trava completamente, mouse e teclado param de responder, bater <ctrl>+<alt>+<F5>não funciona.

O Mint certamente é o culpado: os sistemas operacionais devem se proteger contra softwares mal escritos que esgotam a memória.

Versões anteriores do Mint / Firefox não sofriam desse problema.

O que pode ser feito?

ATUALIZAÇÃO: A atualização para o Linux Mint 20.3 não resolveu.

As rotinas em ambas as linguagens são baratas : as goroutines têm 2 KB cada, enquanto os processos Elixir têm 0,5 KB cada.

Entendo que para iniciar um processo no BEAM é necessário 0,5KB de memória. Por ser tão leve no caso de Elixir e Erlang, e em menor grau no caso de Go , parece ser a vantagem de usar esses tempos de execução quando comparados com outras linguagens que dependem de seus próprios processos e threads não tão baratos ou em os processos e threads do SO subjacente (que também supostamente requerem mais memória).

Eu quero saber quanta memória requer iniciar um processo em um sistema baseado em Linux. Estou ciente de que o uso de memória depende do que o processo está fazendo. Mas suponho que há um custo de memória de apenas iniciar um processo que não faz nada). Qual é esse custo?
Onde posso ler mais sobre isso? Existem arquivos / comandos com os quais posso inspecionar isso?

Eu quero executar cerca de 200 processos com meus experimentos. Cada um deles realmente precisa de menos de um GB :

  PID USER      PR  NI    VIRT    RES    SHR S  %CPU %MEM     TIME+ COMMAND
24688 rinkman   20   0 6082416 335536  15680 S 116.9  0.3  77:32.92 java
25314 rinkman   20   0 6614936 379040  15700 S 116.6  0.4  73:43.02 java
25780 rinkman   20   0 6082408 348140  15664 S 116.6  0.4  72:12.34 java
25994 rinkman   20   0 6082408 350592  15656 S 114.6  0.4  71:42.34 java
30472 rinkman   20   0 6749092 441492  15664 S 108.6  0.4  64:54.38 java
27052 rinkman   20   0 6548364 403040  15692 S 106.3  0.4  66:38.30 java
29314 rinkman   20   0 6022012 393656  15660 S 105.0  0.4  65:57.09 java
28173 rinkman   20   0 6681492 427816  15660 S 104.3  0.4  66:17.47 java

Eu tenho acesso a 6 nós com 100 GB de RAM por cada um deles. Então, se eles levarem apenas um GB , não houve problemas. Mas, como você vê acima, cada um ocupa mais de 6 GB .

Fiquei muito surpreso quando olhei para a saída de free -m:

              total        used        free      shared  buff/cache   available
Mem:          96481       15396         326          75       80758       80448
Swap:         16383        2336       14047

Ele mostra apenas 15,4 GB usados. Isso me levou a um pensamento, os processos podem compartilhar memória não utilizada? 80,4 GB estão realmente disponíveis? Infelizmente, não consegui pesquisar no Google informações interessantes. Eu só encontrei artigos sobre multiprocessamento/threading com troca de dados, cache comum etc. Por favor, poderia me esclarecer essa dúvida?

PS Se isso for impossível, existe alguma maneira de diminuir a memória alocada para esses processos (acabei de executar apenas 8 de 200)? O problema está no fato de que o script bash fornece apenas 2 GB para java (isso faz parte de):

java -Xms64m -Xmx2048m -Djava.library.path="$BEAST_LIB:/usr/local/lib:$LD_LIBRARY_PATH" -cp "$BEAST_LIB/beast.jar:$BEAST_LIB/beast-beagle.jar" dr.app.beast.BeastMain $*

Portanto, não consigo entender o motivo pelo qual sempre leva de 4 a 5 GB a mais. Eu tenho o mesmo fenômeno com outros programas Java, por exemplo, BEAST 2 ou treeannotator .

vmalloc(size)aloca uma memória de sizecomprimento que é virtualmente contígua, mas o mapeamento físico não seria contíguo. Isso significa que a sizememória longa virtualmente alocada na verdade está em diferentes quadros de página da memória física?