Entendendo a média superior e de carga

Estou observando uma alta média de carga em uma determinada máquina (cerca de 9) nos três campos de carga. Entendo carga como o número de processos no estado "run" / atualmente desejando tempo de CPU. Estou correto ao raciocinar que, se N processos estiverem em execução na minha máquina, isso não poderá produzir uma carga maior que N?

Além disso, a carga conta em relação a processos ou threads? Em outras palavras, um processo multithread pode produzir uma carga maior que 1?

A média de carga é geralmente descrita como "comprimento médio da fila de execução". Portanto, poucos processos ou threads que consomem CPU podem aumentar o LA acima de 1. Não há problema se o LA for menor que o número total de núcleos da CPU. Mas se for maior que o número de CPUs, isso significa que alguns threads / processos permanecerão na fila, prontos para execução, mas aguardando CPU livre.

Os números usados ​​para calcular a média de carga são tarefas no estado de execução ou ininterrupto e a quantidade de trabalho realizado no intervalo de tempo da média móvel. Essas tarefas podem fazer parte de um processo multithread. Os campos ficam confusos no tempo devido aos resultados de suavização do algoritmo usado.

Uma carga de 1 é igual a 100% de uma CPU em trabalho. Se você tivesse um aplicativo multithread que conseguisse ter um número de encadeamentos ativos além do número de CPUs disponíveis, um processo único conduziria a carga acima de 1. Isso provavelmente seria um pico de curto prazo e não refletido no visualizações de fatia de tempo mais longas da média de carga.

Além disso, como a média de carga foi desenvolvida antes da existência de sistemas com vários núcleos, é importante dividir os números de carga pelo número total disponível de núcleos. Se essa é uma carga sustentada de 9 em um sistema quad core de 4 soquetes, essa é uma carga de 9 de 16 e não é realmente um problema.

Veja o kernel / sched / loadavg.c, que tem um comentário longo e excelente no início, explicando a derivação da média de carga de uma média exponencialmente decadente do número de threads executáveis ​​(a "fila de execução") mais o número de threads ininterruptos (aguardando E / S ou aguardando um bloqueio).

Aqui está a essência do comentário, mas vale a pena ler na íntegra:

 * The global load average is an exponentially decaying average of
 * nr_running + nr_uninterruptible.
 *
 * Once every LOAD_FREQ:
 *     nr_active = 0;
 *     for_each_possible_cpu(cpu)
 *         nr_active += cpu_of(cpu)->nr_running +
 *                      cpu_of(cpu)->nr_uninterruptible;
 *     avenrun[n] = avenrun[0] *
 *                  exp_n + nr_active *
 *                  (1 - exp_n)

A vida real torna o código um tanto complexo: contadores por CPU, kernels sem ticks, CPUs com hotswap, falta de código de ponto de floaing que requer uma implementação de exp (n) em ponto fixo. Mas é fácil perceber que todos eles estão trabalhando para implementar fielmente o método descrito no comentário.

Você observará que o Linux conta threads , não apenas processos, o que responde à sua pergunta.

As três médias de carga são como uma função logarítmica que gira em torno do número 1. Algo semelhante a f (x) = eX (e ao expoente X). Tecnicamente, uma representação de ponto fixo de uma função de decaimento exponencial simulando uma média. Eles são aditivos por CPU; portanto, uma carga completa pode parecer 4,00 em um sistema quad-core. O primeiro número é a média do último minuto, o segundo é a média dos últimos cinco minutos e o terceiro é a média dos últimos 15 minutos. Eu pensei que uma resposta deveria ser descartada aqui que menciona isso.

Carregamento instantâneo: número de tarefas em execução ou aguardando execução, ou de outra maneira, o número de tarefas que desejam executar

Carga média: a medida acima, mas exponencialmente com média de amostras anteriores da mesma medida

Esses dois números são ilimitados e geralmente muito maiores que N.

Para ser claro: a contagem de carga no Linux inclui threads, não há dúvida sobre isso. Você pode produzir uma carga arbitrariamente grande com um único processo que cria muitos encadeamentos.

Mais sobre isso aqui

http://blog.angulosolido.pt/2015/04/linux-load-average-definitive-summary.html