Tamaño del pool de hilos para una carga
La misión
Problema
Un servicio atiende solicitudes con un pool de hilos (thread pool) fijo. Cada solicitud calcula en la CPU durante compute_ms y luego espera a la red o a un disco durante wait_ms, y mientras un hilo espera, su núcleo puede ejecutar otro hilo. Una regla común de dimensionamiento es hilos = núcleos × utilización objetivo × (1 + espera / cómputo). Dados el número de núcleos, la utilización objetivo como porcentaje entero y los dos tiempos en milisegundos, devuelve el tamaño del pool redondeado hacia arriba. Usa aritmética entera para que la respuesta no dependa del redondeo de punto flotante.
Ejemplos
Input: cores = 8, utilization = 100, wait_ms = 90, compute_ms = 10
Output: 80
Por qué: cada núcleo está ocupado solo una décima parte del tiempo, así que diez hilos lo comparten
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é: caso límite: el trabajo puramente de CPU no gana nada con más hilos que núcleos
Pistas
0 / 3
Pregúntate qué fracción de su vida pasa realmente un hilo en un núcleo. El resto del tiempo, el núcleo queda libre para otro.
1 + espera / cómputo es lo mismo que (cómputo + espera) / cómputo, así que toda la fórmula es una sola fracción con numerador y denominador enteros.
Multiplica los núcleos, el porcentaje y (cómputo + espera) para el numerador, usa 100 × cómputo como denominador y toma el techo entero con división entera negada.
- Tiempo objetivo
- O(1)
- Espacio objetivo
- O(1)
Restricciones
- utilization is a whole percentage
Solución
Un hilo ocupa un núcleo solo durante la parte de cómputo de cada solicitud, así que un núcleo puede mantener ocupados (cómputo + espera) / cómputo hilos, y la utilización objetivo reduce esa cifra para dejar margen. Escribir la regla como una sola fracción mantiene todos los valores enteros hasta el final, y el techo se calcula con división entera negada, -(-a // b), que redondea hacia arriba de forma exacta. Redondear hacia arriba y no hacia abajo importa: un pool con un hilo de menos deja un núcleo inactivo durante cada espera. Cualquier fracción positiva se redondea hacia arriba a al menos un hilo. El tiempo y el espacio son 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)) # -> 1¿Lo que te frena es la idea y no el código? Dimensionar un pool de hilos lo explica.