Tamanho do pool de threads para a carga
A missão
Problema
Um serviço atende requisições em um pool de threads de tamanho fixo. Cada requisição computa na CPU por compute_ms e depois espera a rede ou um disco por wait_ms, e, enquanto uma thread espera, o núcleo dela pode executar outra thread. Uma regra comum de dimensionamento é threads = núcleos × utilização alvo × (1 + espera / computação). Dados o número de núcleos, a utilização alvo como porcentagem inteira e os dois tempos em milissegundos, retorne o tamanho do pool arredondado para cima. Use aritmética inteira para que a resposta não dependa de arredondamento de ponto flutuante.
Exemplos
Input: cores = 8, utilization = 100, wait_ms = 90, compute_ms = 10
Output: 80
Por quê: cada núcleo fica ocupado só um décimo do tempo, então dez threads o compartilham
Input: cores = 4, utilization = 50, wait_ms = 30, compute_ms = 20
Output: 5
Por quê: 4 × 0,5 × 2,5 = 5
Input: cores = 16, utilization = 100, wait_ms = 0, compute_ms = 5
Output: 16
Por quê: edge case: trabalho puramente de CPU não ganha nada com mais threads do que núcleos
Dicas
0 / 3
Pergunte-se que fração da vida uma thread realmente passa em um núcleo. No resto do tempo, o núcleo fica livre para outra.
1 + espera / computação é o mesmo que (computação + espera) / computação, então a fórmula inteira vira uma única fração com numerador e denominador inteiros.
Multiplique os núcleos, a porcentagem e (computação + espera) para obter o numerador, use 100 × computação como denominador e calcule o teto inteiro com a divisão inteira negada.
- Tempo-alvo
- O(1)
- Espaço-alvo
- O(1)
Restrições
- utilization is a whole percentage
Solução
Uma thread ocupa um núcleo só durante a parte de computação de cada requisição, então um núcleo consegue manter (computação + espera) / computação threads ocupadas, e a meta de utilização reduz esse número para deixar uma folga. Escrever a regra como uma única fração mantém todos os valores inteiros até o fim, e o teto é calculado com a divisão inteira negada, -(-a // b), que arredonda para cima de forma exata. Arredondar para cima, e não para baixo, faz diferença: um pool com uma thread a menos deixa um núcleo ocioso durante cada espera. Qualquer fração positiva é arredondada para pelo menos uma thread. O tempo e o espaço são O(1).
def pool_size(cores, utilization_pct, wait_ms, compute_ms):
# threads = cores * utilization * (1 + wait / compute), rounded up
num = cores * utilization_pct * (compute_ms + wait_ms)
den = 100 * compute_ms
return -(-num // den) # integer ceiling
print(pool_size(8, 100, 90, 10)) # -> 80
print(pool_size(4, 50, 30, 20)) # -> 5
print(pool_size(16, 100, 0, 5)) # -> 16
print(pool_size(1, 10, 5, 10)) # -> 1Travou na ideia, e não no código? Como dimensionar um pool de threads explica isso.