1. Qué es el nice
El nice es un valor que indica la «amabilidad» de un proceso: cuánta CPU está dispuesto a ceder a otros procesos. Un nice bajo (negativo) significa que el proceso es «poco amable» y quiere más CPU. Un nice alto (positivo) significa que el proceso es «amable» y cede CPU a otros.
El nombre viene del comando nice, que se usaba para lanzar procesos con una prioridad ajustada: «ser nice» con los demás procesos. En Unix, el nice es una forma de que el usuario indique la importancia relativa de sus procesos.
El nice es un atributo del proceso que el usuario puede modificar (con nice y renice). El planificador (CFS) lo usa para calcular la prioridad interna del proceso y repartir la CPU en consecuencia.
El nice solo afecta a la clase fair (SCHED_OTHER). Los procesos de tiempo real (SCHED_FIFO, SCHED_RR) no usan nice: tienen prioridades del 1 al 99. Un proceso nice -20 (máxima prioridad en fair) se ejecuta después de cualquier proceso de tiempo real.
2. El rango de nice
El nice va de -20 a +19:
| Nice | Significado | Uso típico |
|---|---|---|
| -20 | Máxima prioridad (menos nice) | Procesos críticos del usuario. |
| -10 | Alta prioridad | Procesos importantes. |
| 0 | Prioridad por defecto | La mayoría de los procesos. |
| +10 | Baja prioridad | Procesos en segundo plano. |
| +19 | Mínima prioridad (más nice) | Procesos de baja prioridad (backup, indexación). |
Un usuario normal solo puede aumentar el nice (hacer el proceso más amable), no disminuirlo. Para disminuir el nice (aumentar la prioridad), se necesita privilegio (root o CAP_SYS_NICE).
La diferencia entre nice -20 y nice +19 es enorme: un proceso con nice -20 recibe aproximadamente 40 veces más CPU que uno con nice +19 (según la tabla de pesos).
3. La prioridad interna
CFS no usa el nice directamente. Lo convierte en una prioridad interna (prio) que va de 100 a 139:
prio = 120 + nice
Así, nice -20 → prio 100 (máxima prioridad en fair), y nice +19 → prio 139 (mínima prioridad en fair). La prioridad por defecto (nice 0) es prio 120.
La prioridad interna se usa para calcular el peso del proceso, que determina cuánta CPU recibe.
4. La tabla de pesos
CFS usa una tabla de pesos que asigna un peso a cada prioridad interna. El peso determina la fracción de CPU que recibe el proceso:
| Nice | Prio | Peso | Fracción de CPU (relativa a nice 0) |
|---|---|---|---|
| -20 | 100 | 88761 | ≈ 40× (más CPU) |
| -15 | 105 | 29154 | ≈ 13× |
| -10 | 110 | 9548 | ≈ 4,3× |
| -5 | 115 | 3121 | ≈ 1,4× |
| 0 | 120 | 1024 | 1× (base) |
| +5 | 125 | 335 | ≈ 0,33× |
| +10 | 130 | 110 | ≈ 0,11× |
| +15 | 135 | 36 | ≈ 0,035× |
| +19 | 139 | 15 | ≈ 0,015× |
Los pesos no son lineales: cada nivel de nice cambia el peso por un factor de aproximadamente 1,25. Esto significa que cada nivel de nice da un 25 % más (o menos) de CPU que el anterior.
La tabla de pesos está definida en el código del núcleo (kernel/sched/core.c) y es fija. No se puede modificar sin recompilar el núcleo.
Cada nivel de nice cambia el peso por un factor de ~1,25. Un proceso con nice -5 (peso 3121) recibe aproximadamente 3 veces más CPU que uno con nice +5 (peso 335), porque 3121/335 ≈ 9,3. Pero respecto al nice 0, nice -5 recibe 3 veces más y nice +5 recibe 0,33 veces.
5. Cómo funciona el nice en CFS
CFS usa el peso para calcular el vruntime (tiempo virtual) de cada proceso. El vruntime se acumula a medida que el proceso se ejecuta, pero la velocidad de acumulación depende del peso:
vruntime += tiempo_real × (peso_base / peso_proceso)
Donde peso_base es el peso de nice 0 (1024). Un proceso con mayor peso (nice más bajo) acumula vruntime más lentamente, lo que significa que se ejecuta más antes de que su vruntime alcance el del siguiente proceso.
Por ejemplo, un proceso con nice -5 (peso 3121) acumula vruntime a un tercio de la velocidad de uno con nice 0 (peso 1024). Así, recibe aproximadamente 3 veces más CPU.
El reparto es proporcional a los pesos: si hay dos procesos, uno con peso 1024 (nice 0) y otro con peso 3121 (nice -5), el primero recibe 1024/(1024+3121) = 25 % de la CPU y el segundo recibe 3121/(1024+3121) = 75 %.
6. Un ejemplo desarrollado
Dos procesos con nice 0 y nice -5, ambos con ráfaga 10, llegando en 0:
| Proceso | Nice | Peso | Fracción de CPU |
|---|---|---|---|
| P1 | 0 | 1024 | 1024/(1024+3121) = 24,7 % |
| P2 | -5 | 3121 | 3121/(1024+3121) = 75,3 % |
En CFS, P2 (nice -5) recibe aproximadamente 3 veces más CPU que P1 (nice 0). Si ambos necesitan 10 unidades de CPU, P2 termina en 10/0,753 ≈ 13,3 unidades de tiempo, y P1 en 10/0,247 ≈ 40,5 unidades.
El Gantt sería algo como: P2, P2, P2, P1, P2, P2, P2, P1, ... (P2 recibe 3 turnos por cada turno de P1).
7. Observar y modificar en Linux
# Ver el nice de los procesos
$ ps -o pid,ni,comm -p $$
PID NI COMMAND
453 0 bash
# Lanzar un proceso con nice +10
$ nice -n 10 ./mi_programa
# Lanzar con nice -5 (requiere privilegio)
$ sudo nice -n -5 ./mi_programa
# Ver la prioridad interna (prio) en /proc
$ grep prio /proc/self/sched
prio : 120La columna NI de ps muestra el nice. La prioridad interna (prio) se lee de /proc/PID/sched y es 120 + nice.
8. Usar renice
renice permite cambiar el nice de un proceso en ejecución:
# Cambiar el nice de un proceso a +10
$ renice -n 10 -p 1234
1234 (process ID) old priority 0, new priority 10
# Cambiar el nice de todos los procesos de un usuario
$ renice -n 5 -u usuario
# Cambiar el nice de un grupo de procesos
$ renice -n -3 -g 1234Un usuario normal solo puede aumentar el nice (hacer el proceso más amable). Para disminuir el nice (aumentar la prioridad), se necesita privilegio (root).
9. Propiedades
| Propiedad | ¿La cumple? | Comentario |
|---|---|---|
| Flexibilidad | Sí | El usuario puede ajustar la prioridad de sus procesos. |
| Granularidad | 40 niveles | De -20 a +19. |
| Predecibilidad | Sí | El reparto es proporcional a los pesos. |
| Fairness | Parcial | El reparto es proporcional, no igual. |
| Uso real | Sí | Todos los procesos normales de Linux. |
10. Simulador interactivo
Este simulador muestra cómo el nice afecta al reparto de CPU. Dos procesos con nice distintos compiten por la CPU:
Simulador · nice y reparto de CPU
| Proceso | Nice | Peso | Fracción de CPU | Inicio | Fin | Retorno |
|---|
11. Resumen
- El nice indica la amabilidad de un proceso: bajo = más prioridad, alto = menos.
- El rango es -20 a +19. El valor por defecto es 0.
- La prioridad interna es prio = 120 + nice.
- CFS usa una tabla de pesos para convertir la prioridad en peso.
- El peso determina la fracción de CPU que recibe el proceso.
- Cada nivel de nice cambia el peso por un factor de ~1,25.
- El vruntime se acumula a velocidad inversamente proporcional al peso.
- Se observa con ps y /proc/PID/sched.
- Se modifica con nice y renice.
12. Preguntas de repaso
Intenta responder cada una antes de abrir la respuesta.
1. ¿Qué es el nice?
Un valor que indica la amabilidad de un proceso: cuánta CPU está dispuesto a ceder.
2. ¿Cuál es el rango del nice?
De -20 (máxima prioridad) a +19 (mínima prioridad).
3. ¿Cómo se calcula la prioridad interna a partir del nice?
prio = 120 + nice.
4. ¿Qué peso tiene un proceso con nice 0?
1024.
5. ¿Qué peso tiene un proceso con nice -20?
88761.
6. ¿Cómo afecta el peso al vruntime?
El vruntime se acumula a velocidad inversamente proporcional al peso: mayor peso = acumulación más lenta = más CPU.
7. ¿Un usuario normal puede disminuir el nice?
No. Solo puede aumentarlo. Para disminuirlo se necesita privilegio.
8. ¿Qué comando se usa para cambiar el nice de un proceso en ejecución?
renice.
9. ¿Afecta el nice a los procesos de tiempo real?
No. Solo afecta a la clase fair (SCHED_OTHER).
10. ¿Dónde se define la tabla de pesos?
En el código del núcleo (kernel/sched/core.c).
Para practicar
- Lanza dos procesos con nice 0 y nice 10 y compara el tiempo de CPU que reciben.
- Usa renice para cambiar el nice de un proceso en ejecución y observa el efecto.
- Calcula la fracción de CPU para nice -10 y nice +10.
- Explica por qué los pesos no son lineales.
- Investiga cómo se define la tabla de pesos en el código del núcleo.
- Modifica el simulador para añadir un tercer proceso con nice distinto.