¿Por qué pthread_cond_wait tiene despertadores espurios?

Para citar la página del manual:

Cuando se usan variables de condición, siempre hay un predicado booleano que involucra variables compartidas asociadas con cada espera de condición que es verdadero si el hilo debe continuar. Pueden ocurrir activaciones espurias de las funciones pthread_cond_timedwait () o pthread_cond_wait (). Dado que el retorno de pthread_cond_timedwait () o pthread_cond_wait () no implica nada sobre el valor de este predicado, el predicado debe ser reevaluado en dicho retorno.

Por lo tanto, pthread_cond_waitpuede regresar incluso si no lo ha señalado. A primera vista, al menos, eso parece bastante atroz. Sería como una función que devolvió aleatoriamente el valor incorrecto o regresó aleatoriamente antes de que realmente alcanzara una declaración de retorno adecuada. Parece un error importante. Pero el hecho de que eligieron documentar esto en la página del manual en lugar de corregirlo parece indicar que hay una razón legítima por la que pthread_cond_waittermina despertando espuriosamente. Presumiblemente, hay algo intrínseco en su funcionamiento que hace que no se pueda evitar. La pregunta es qué.

¿ Por quépthread_cond_wait vuelve espuriamente? ¿Por qué no puede garantizar que solo se despertará cuando se haya señalado correctamente? ¿Alguien puede explicar la razón de su comportamiento espurio?

David R. Butenhof da la siguiente explicación en "Programación con hilos POSIX" (p. 80):

Las activaciones espurias pueden sonar extrañas, pero en algunos sistemas multiprocesador, hacer que la activación de la condición sea completamente predecible podría ralentizar sustancialmente todas las operaciones variables de la condición.

En la siguiente discusión de comp.programming.threads , él amplía el pensamiento detrás del diseño:

Patrick Doyle escribió: 
> En el artículo, Tom Payne escribió: 
>> Kaz Kylheku escribió: 
>>: Esto es así porque las implementaciones a veces no pueden evitar insertar 
>>: estos espurios despertares; Puede ser costoso prevenirlos.

>> ¿Pero por qué? Porque esto es tan difícil? Por ejemplo, ¿estamos hablando de
>> situaciones donde se agota el tiempo de espera justo cuando llega una señal? 

> Sabes, me pregunto si los diseñadores de pthreads usaron una lógica como esta: 
> los usuarios de variables de condición tienen que verificar la condición al salir de todos modos, 
> por lo que no les aplicaremos ninguna carga adicional si permitimos 
> despertares espurios; y dado que es concebible que permitir espurias
> wakeups podría acelerar la implementación, solo puede ayudar si 
> permitirlos. 

> Es posible que no hayan tenido en mente ninguna implementación en particular. 

En realidad no estás muy lejos, excepto que no lo empujaste lo suficiente. 

La intención era forzar el código correcto / robusto al requerir bucles de predicados. Esto era
impulsado por el contingente académico probablemente correcto entre los "hilos centrales" en 
el grupo de trabajo, aunque no creo que nadie esté realmente en desacuerdo con la intención 
una vez que entendieron lo que significaba. 

Seguimos esa intención con varios niveles de justificación. El primero fue que
El uso "religioso" de un bucle protege la aplicación contra su propio imperfecto. 
prácticas de codificación La segunda fue que no era difícil imaginar abstractamente
máquinas y código de implementación que podrían explotar este requisito para mejorar 
El rendimiento de las operaciones de espera de condición promedio a través de la optimización de 
Mecanismos de sincronización. 
/ ------------------ [David.Buten ... @ compaq.com] ------------------ \ 
El | Compaq Computer Corporation POSIX Thread Architect |
El | Mi libro: http://www.awl.com/cseng/titles/0-201-63392-2/ |
\ ----- [http://home.earthlink.net/~anneart/family/dave.html] ----- / 

Hay al menos dos cosas que podría significar 'despertar espurio':

• Un hilo bloqueado en pthread_cond_waitpuede volver de la llamada a pesar de que no hay ninguna llamada a pthread_call_signalo pthread_cond_broadcasten la condición haya ocurrido.
• Un hilo bloqueado en pthread_cond_waitrendimientos debido a una llamada a pthread_cond_signalo pthread_cond_broadcast, sin embargo después de readquirir el mutex el predicado subyacente se encuentra que ya no es cierto.

Pero el último caso puede ocurrir incluso si la implementación de la variable de condición no permite el primer caso. Considere una cola de consumidor productor y tres hilos.

• El subproceso 1 acaba de retirar un elemento y libera el mutex, y la cola ahora está vacía. El hilo está haciendo lo que hace con el elemento que adquirió en alguna CPU.
• El subproceso 2 intenta eliminar un elemento, pero encuentra que la cola está vacía cuando se verifica bajo el mutex, llama pthread_cond_wait y bloques en la llamada en espera de señal / transmisión.
• El subproceso 3 obtiene el mutex, inserta un nuevo elemento en la cola, notifica la variable de condición y libera el bloqueo.
• En respuesta a la notificación del subproceso 3, el subproceso 2, que estaba esperando la condición, está programado para ejecutarse.
• Sin embargo, antes de que el hilo 2 logre subir a la CPU y tomar el bloqueo de la cola, el hilo 1 completa su tarea actual y regresa a la cola para más trabajo. Obtiene el bloqueo de la cola, comprueba el predicado y descubre que hay trabajo en la cola. Se procede a retirar el elemento que insertó el subproceso 3, libera el bloqueo y hace lo que sea que haga con el elemento que el subproceso 3 puso en cola.
• El subproceso 2 ahora se conecta a una CPU y obtiene el bloqueo, pero cuando comprueba el predicado, descubre que la cola está vacía. El hilo 1 'robó' el artículo, por lo que la activación parece ser espuria. El subproceso 2 debe esperar la condición nuevamente.

Por lo tanto, dado que siempre necesita verificar el predicado bajo un bucle, no hay diferencia si las variables de condición subyacentes pueden tener otros tipos de activaciones espurias.

La sección "Múltiples despertares por señal de condición" en pthread_cond_signal tiene una implementación de ejemplo de pthread_cond_wait y pthread_cond_signal que involucra despertadores espurios.

Si bien no creo que se haya considerado en el momento del diseño, aquí hay una razón técnica real: en combinación con la cancelación de subprocesos, hay condiciones bajo las cuales puede ser absolutamente necesario tomar la opción de despertar "espuriosamente", al menos a menos que usted estamos dispuestos a imponer restricciones muy muy fuertes sobre qué tipo de estrategias de implementación son posibles.

El problema clave es que, si un hilo actúa sobre la cancelación mientras está bloqueado pthread_cond_wait, los efectos secundarios deben ser como si no consumiera ninguna señal en la variable de condición. Sin embargo, es difícil (y altamente restrictivo) asegurarse de que no haya consumido una señal cuando comience a actuar en la cancelación, y en esta etapa puede ser imposible "volver a publicar" la señal en la variable de condición, ya que puede estar en una situación en la que la persona que llama pthread_cond_signalya está justificada por haber destruido el condvar y haber liberado la memoria en la que residía.

La asignación para la estela espuria te da una salida fácil. En lugar de continuar actuando sobre la cancelación cuando llega mientras está bloqueado en una variable de condición, si ya ha consumido una señal (o si desea ser perezoso, pase lo que pase), puede declarar que ha ocurrido una estela espuria. y volver con exito. Esto no interfiere en absoluto con la operación de cancelación, porque una persona que llama correctamente simplemente actuará en la cancelación pendiente la próxima vez que realice un bucle y pthread_cond_waitvuelva a llamar .