Estou observando uma média de carga alta em uma determinada máquina (cerca de 9) em todos os três campos de carga. Eu entendo load como o número de processos em estado "run" / atualmente desejando tempo de CPU. Estou correto em argumentar que, se N processos estão sendo executados em minha máquina, isso não pode 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 "duração média da fila de execução". Portanto, poucos processos ou threads que consomem CPU podem elevar LA acima de 1. Não há problema se LA for menor que o número total de núcleos de CPU. Mas se ficar mais alto que o número de CPUs, isso significa que alguns threads / processos ficarão na fila, prontos para serem executados, mas aguardando a CPU livre.
Os números usados para calcular a média de carga são tarefas na execução ou estado ininterrupto e a quantidade de trabalho realizada na fatia de tempo da média móvel. Essas tarefas podem fazer parte de um processo multithread. Os campos são confusos quanto mais atrasos no tempo devido aos resultados de suavização do algoritmo usado.
Uma carga de 1 é igual a 100% do valor de um trabalho de CPUs. Se você tivesse um aplicativo multithreaded que conseguisse ter um número de threads ativos além do número de CPUs disponíveis, então você poderia ter uma única unidade de processo com a carga acima de 1. Isso provavelmente seria um pico de curto prazo e não refletido no exibições de fatia de tempo mais longas da média de carga.
Além disso, como a média de carga foi desenvolvida antes de haver sistemas com vários núcleos, é importante dividir os números de carga pelo número total de núcleos disponíveis. Se esta for uma carga sustentada de 9 em um sistema quad core de 4 soquetes, então esta é uma carga de 9 de 16 e não é realmente um problema.
Veja 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 decrescente do número de encadeamentos executáveis (a "fila de execução") mais o número de encadeamentos ininterruptos (aguardando E / S ou esperando em 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 hotswap, falta de código de ponto flutuante que exija uma implementação de ponto fixo de exp (n). Mas é fácil ver que todos estão trabalhando para implementar fielmente o método descrito no comentário.
Você notará que o Linux conta threads , não apenas os processos, que respondem à sua pergunta.
As 3 médias de carga são algo 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 deixada aqui que menciona isso.
Carregamento instantâneo: número de tarefas em execução ou em espera, ou de outra forma, o número de tarefas dispostas a serem executadas
Média de carga: a medida acima, mas com média exponencial de amostras anteriores da mesma medida
Ambos os números são ilimitados e geralmente muito maiores que N.
Para ser claro: a contagem de carga no Linux inclui tópicos, não há dúvidas sobre isso. Você pode produzir uma carga arbitrariamente grande com um único processo que cria muitos threads.
Mais sobre isso aqui