Cómo comprobar si un planificador de núcleo está configurado en Linux

Introducción

En este laboratorio, aprenderá cómo verificar la configuración del planificador de núcleo (kernel scheduler) en Linux. El planificador es un componente fundamental que gestiona cómo los procesos comparten el tiempo de CPU. Comprender sus configuraciones es crucial para el análisis de rendimiento y la resolución de problemas.

A través de pasos prácticos, explorará tres métodos para inspeccionar las configuraciones del planificador: utilizar el comando sysctl para ver los parámetros del núcleo, examinar el sistema de archivos /proc/sys/kernel en busca de archivos relacionados con el planificador y revisar los registros del núcleo a través de dmesg en busca de mensajes específicos del planificador. Estas técnicas brindan diferentes perspectivas sobre el estado y el comportamiento actual del planificador.

Skills Graph

Verificar la configuración del planificador con sysctl kernel.sched

En este paso, exploraremos cómo verificar la configuración del planificador del núcleo (kernel) utilizando el comando sysctl. El planificador es una parte crucial del núcleo de Linux que decide qué proceso se ejecuta en la CPU y durante cuánto tiempo. Comprender sus configuraciones puede ser útil para ajustar el rendimiento y resolver problemas.

El comando sysctl se utiliza para modificar los parámetros del núcleo en tiempo de ejecución. También podemos usarlo para ver los valores actuales de estos parámetros. Los parámetros del núcleo se organizan en una estructura jerárquica, similar a un sistema de archivos.

Para ver los parámetros relacionados con el planificador del núcleo, podemos usar sysctl con el prefijo kernel.sched.

Abra su terminal si no está abierta. Puede encontrar el icono de Xfce Terminal en el lado izquierdo de su escritorio.

Ahora, escriba el siguiente comando y presione Enter:

sysctl kernel.sched

Debería ver una salida similar a esta, que muestra varios parámetros relacionados con el planificador y sus valores actuales:

kernel.sched_child_runs_first = 0
kernel.sched_min_granularity_ns = 8000000
kernel.sched_wakeup_granularity_ns = 9000000
kernel.sched_latency_ns = 24000000
kernel.sched_migration_cost_ns = 50000
kernel.sched_nr_migrate = 32
kernel.sched_tunable_scaling = 1
kernel.sched_domain.cpu0.domain0 = ...
kernel.sched_domain.cpu0.domain1 = ...
...

La salida exacta puede variar ligeramente dependiendo de la versión específica del núcleo y la configuración del sistema. Este comando le da una instantánea de cómo está configurado actualmente el planificador.

Comprender cada uno de estos parámetros está fuera del alcance de este laboratorio introductorio, pero la principal idea es que sysctl kernel.sched es el comando que debe usar cuando desee inspeccionar estas configuraciones.

Haga clic en Continuar para pasar al siguiente paso.

Verificar el planificador en /proc/sys/kernel

En el paso anterior, usamos sysctl para ver los parámetros del núcleo (kernel). Otra forma de acceder y, en ocasiones, modificar estos parámetros es a través del sistema de archivos /proc. El sistema de archivos /proc es un sistema de archivos virtual que proporciona información sobre procesos y otra información del sistema.

Los parámetros del núcleo accesibles a través de sysctl a menudo se reflejan en el directorio /proc/sys. En concreto, los parámetros relacionados con el planificador se pueden encontrar en /proc/sys/kernel/.

Vayamos a este directorio y listemos su contenido. Usaremos el comando cd para cambiar de directorio y ls para listar archivos y directorios.

Escriba el siguiente comando para cambiar su directorio actual a /proc/sys/kernel/:

cd /proc/sys/kernel/

Ahora, liste los archivos en este directorio:

ls

Verá una larga lista de archivos, cada uno de los cuales representa un parámetro del núcleo. Busque archivos que comiencen con sched_. Estos archivos corresponden a los parámetros kernel.sched que vimos con sysctl.

...
sched_child_runs_first
sched_latency_ns
sched_migration_cost_ns
sched_min_granularity_ns
sched_nr_migrate
sched_rr_timeslice_ms
sched_rt_period_us
sched_rt_runtime_us
sched_shares_window_ns
sched_tunable_scaling
sched_wakeup_granularity_ns
...

Puede ver el contenido de estos archivos utilizando comandos como cat. Por ejemplo, para ver el valor de sched_latency_ns, escriba:

cat sched_latency_ns

Debería ver un número, que es el mismo valor que vio para kernel.sched_latency_ns cuando usó sysctl.

24000000

Esto demuestra que la información proporcionada por sysctl kernel.sched proviene de archivos dentro del directorio /proc/sys/kernel/. Si bien sysctl suele ser más conveniente para ver y modificar parámetros, comprender el sistema de archivos /proc le brinda una comprensión más profunda de cómo el núcleo expone su estado interno.

Haga clic en Continuar para continuar.

Inspeccionar los registros del planificador en dmesg

En este último paso, examinaremos los mensajes del núcleo (kernel) relacionados con el planificador utilizando el comando dmesg. dmesg es un comando que muestra los mensajes del buffer circular del núcleo. Estos mensajes son generados por el núcleo durante el arranque y la ejecución del sistema y pueden contener información valiosa sobre el hardware, los controladores y los eventos del sistema, incluyendo las actividades del planificador.

Mientras que sysctl y /proc/sys muestran la configuración actual, dmesg a veces puede mostrar mensajes relacionados con la inicialización del planificador o eventos importantes.

Para ver los mensajes del núcleo, escriba el siguiente comando:

dmesg

Es probable que esto produzca una salida muy larga, ya que muestra todos los mensajes del núcleo desde que se inició el sistema. Para encontrar mensajes específicamente relacionados con el planificador, podemos usar el comando grep para filtrar la salida. Buscaremos líneas que contengan la palabra "sched".

Escriba el siguiente comando:

dmesg | grep sched

El símbolo | se llama tubería (pipe). Toma la salida del comando de la izquierda (dmesg) y la envía como entrada al comando de la derecha (grep sched). grep sched luego busca líneas que contengan "sched" en la entrada que recibe.

Puede ver una salida similar a esta, que muestra mensajes relacionados con el planificador durante el inicio del sistema:

[    0.000000] Linux version ... (gcc version ...) #... SMP ...
[    0.000000] Command line: BOOT_IMAGE=/boot/vmlinuz-... root=... ro quiet splash vt.handoff=...
[    0.000000] Kernel command line: BOOT_IMAGE=/boot/vmlinuz-... root=... ro quiet splash vt.handoff=...
[    0.000000] PID scheduler: ...
[    0.000000] Mount-cache hash table entries: ... (order: ..., 65536 bytes, linear)
[    0.000000] Mountpoint-cache hash table entries: ... (order: ..., 65536 bytes, linear)
[    0.000000] CPU: Testing write buffer coherency: ...
[    0.000000] smpboot: CPU0: ...
[    0.000000] setup_percpu: System has ... CPUs.
[    0.000000] percpu: Embedded ... pages/cpu s...
[    0.000000] pcpu: PCPU: ...
[    0.000000] Built 1-level schedule group tree
[    0.000000] rcu: Hierarchical RCU implementation.
[    0.000000] rcu: RCU calculated value of scheduler-enlistment delay is ...
[    0.000000] rcu: Adjusting scheduler-enlistment delay with ...
[    0.000000] rcu: RCU restricting CPUs from NR_CPUS=... to nr_cpu_ids=...
[    0.000000] rcu: rcu_sched detected stalls on CPUs/tasks:
...

Nuevamente, la salida exacta variará. Este comando es útil para diagnosticar problemas o entender cómo el núcleo inicializó el planificador.

Ahora ha aprendido tres formas diferentes de obtener información sobre el planificador del núcleo de Linux: usando sysctl para obtener los parámetros actuales, inspeccionando archivos en /proc/sys/kernel/ y comprobando los mensajes del núcleo con dmesg.

Haga clic en Continuar para completar este laboratorio.

Resumen

En este laboratorio, aprendimos cómo verificar la configuración del planificador del núcleo (kernel) en Linux utilizando dos métodos principales. Primero, utilizamos el comando sysctl kernel.sched para ver varios parámetros relacionados con el planificador y sus valores actuales, lo que nos brindó una instantánea de la configuración en tiempo de ejecución del planificador.

En segundo lugar, exploramos el sistema de archivos /proc como una forma alternativa de acceder a los parámetros del núcleo, centrándonos específicamente en la ruta /proc/sys/kernel, que refleja los parámetros accesibles a través de sysctl. Estos pasos demostraron cómo inspeccionar la configuración del planificador del núcleo tanto a través de utilidades de línea de comandos como del sistema de archivos virtual.