Como o CFS do Linux agenda os processos x threads de forma justa nos kernels 2018 4.9?

Question

O escalonador de Linux continua evoluindo: como o kernel agencia os processos x threads hoje em dia? Preciso de autogrupos?

A pergunta anterior sobre estouro de pilha semelhante tem muitos anos e provavelmente obsoleto.

Eu acredito que em 2018 o padrão é o Completely Fair Scheduler ( CFS ) de O (1) ou outro programador.

Para o Linux, algumas documentações mencionam que o SO manipula tarefas que representam indiferentemente um processo ou um thread de um processo, ou não claramente faça a distinção, embora seja crítico para o agendamento.

Por motivos de clareza, um processo executa um programa e pode gerar 1 ou mais segmentos quando ele é multi-threaded. Para mim, a distinção é que todos os segmentos de um processo usam o mesmo espaço de endereço virtual. No entanto, para programar em uma CPU, essa distinção é irrelevante.

Se eu executo P, processo cada um com diferentes contagens de threads Tp:

• Justiciabilidade do processo : Como posso garantir que um processo com muitos threads não irá usar todos os recursos e dominar um processo com apenas 1 thread? A programação formal e justa significaria: o processo P deveria obter 1 / Pth do recurso da CPU e dividir 1 / Pth uniformemente para 1 / (Pth * Tp) por thread de P. É o que o CFS garante por padrão?
• Eu preciso de autogrupos ? Grupos autônomos permitem que um processo agende grupos de tarefas juntos. Por padrão, há um grupo, mas se você girar um segundo, ele receberá 1/2 da CPU, girará 10 e cada grupo de segmentos receberá 1/10. Simples (veja agendamento de gangue).
• multi-core : Eu não ligo muito para turvar a resposta com considerações sobre balanceamento de carga para vários núcleos e migração de processos entre núcleos.

Resultado experimental: O CFS parece ser justo entre os processos.

Eu tentei no 4.9.27 para monitorar o tempo de execução de um processo pequeno versus um processo de execução longa com muitos threads. Parece que o agendador no meu kernel agenda por processo, não por threads. Assim, o pequeno processo foi tratado de maneira justa e obteve 50% da CPU. Quando usei 2 processos de longa duração, obtive 33%. As lentidões foram como 2,2x e 3,4x, respectivamente.

Este kernel não parece ter compilações autógradas compiladas; setsid () funciona, mas parece não fazer nada, E / proc / * / autogroup não existe, então tentar usar o autogroup enquanto o CFS parece fazer a coisa certa é um empreendimento caro. No entanto, alguns outros pontos de dados parecem indicar, por vezes, que o comportamento não é justo para um processo.

Pergunta secundária

Existe algum truque para garantir que um processo seja executado com mais regularidade do que todos os outros? Não posso promovê-lo para tempo real devido ao uso de LD_LIBRARY_PATH, acredito. E mesmo assim, eu suspeito porque lê / proc para monitorar o sistema, às vezes ainda é atrasado maciçamente quando o sistema está sobrecarregado.

Obrigado!