Si los hilos comparten el mismo PID, ¿cómo se pueden identificar?

Question

Tengo una consulta relacionada con la implementación de hilos en Linux.

Linux no tiene un soporte explícito de subprocesos. En el espacio de usuario, podríamos usar una biblioteca de hilos (como NPTL) para crear hilos. Ahora si usamos NPTL, admite mapeo 1: 1.

El kernel utilizará la función clone() para implementar subprocesos.

Supongamos que he creado 4 hilos. Entonces significaría que:

• Habrá 4 task_struct.
• Dentro del task_struct, habrá provisión de recursos compartidos según los argumentos para clonar (CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND).

ahora tengo la siguiente consulta:

1. ¿Los 4 hilos tienen el mismo PID? Si alguien puede dar más detalles, cómo se comparten los PID.
2. ¿Cómo se identifican los diferentes hilos? ¿Hay algún concepto TID (ID de hilo)?

Answer 1

Los subprocesos se identifican utilizando PID y TGID (identificación del grupo de subprocesos). También saben de qué hilo es padre de quién, esencialmente, un proceso comparte su PID con cualquier hilo que comience. Las ID de subprocesos generalmente son administradas por la biblioteca de subprocesos (como pthread, etc ...). Si los 4 hilos se inician, deberían tener el mismo PID. El kernel mismo manejará la programación de hilos y demás, pero la biblioteca será la que administre los hilos (ya sea que se ejecuten o no dependiendo del uso de los métodos de unión de hilos y de espera).

Nota: Esto es de mi recuerdo de kernel 2.6.36. Mi trabajo en las versiones actuales del núcleo está en la capa de E/S, así que no sé si eso ha cambiado desde entonces.

Answer 2

Los cuatro hilos tendrán el mismo PID pero solo cuando se ven desde arriba. Lo que (como usuario) llamar a un PID no es lo que el kernel (mirando desde abajo) llama a un PID.

En el núcleo, cada hilo tiene su propia identificación, llamado PID (aunque sería posible tener más sentido para llamar a esto un TID o ID del hilo) y también tienen un (grupo de hilos ID) TGID cuales es el PID del hilo que inició todo el proceso.

Simplísticamente, cuando se crea un nuevo proceso , aparece como un subproceso donde tanto el PID como el TGID son el mismo número (nuevo).

Cuando un subproceso inicia otro subproceso , que el subproceso iniciado tiene su propio PID (para que el planificador pueda programarlo independientemente) pero hereda el TGID del subproceso original.

De esta manera, el kernel puede programar con éxito los hilos independientemente del proceso al que pertenezcan, mientras que los procesos (IDs del grupo de hilos) se le informan.

La siguiente jerarquía de hilos puede ayudar ^(a):

     USER VIEW 
<-- PID 43 --> <----------------- PID 42 -----------------> 
        +---------+ 
        | process | 
        _| pid=42 |_ 
        _/ | tgid=42 | \_ (new thread) _ 
     _ (fork) _/ +---------+     \ 
    /          +---------+ 
+---------+         | process | 
| process |         | pid=44 | 
| pid=43 |         | tgid=42 | 
| tgid=43 |         +---------+ 
+---------+ 
<-- PID 43 --> <--------- PID 42 --------> <--- PID 44 ---> 
        KERNEL VIEW 

Se puede ver que iniciar un nuevo proceso (a la izquierda) le da un nuevo PID y un nuevo TGID (ambos configurados en el mismo valor), al iniciar una nueva secuencia (a la derecha) le proporciona un nuevo PID mientras mantiene el mismo TGID que el hilo que lo inició.

---

^(a)Tiembla en el temor en mis habilidades gráficas impresionantes :-)

Answer 3

Linux ofrecen la llamada fork() sistema con la funcionalidad tradicional de la duplicación de un proceso. Linux también proporciona la capacidad de crear subprocesos mediante la llamada al sistema clone() Sin embargo, Linux no distingue entre procesos y subprocesos.