c - pthread_join - pthreads php

¿Protege una variable con un pthread mutex garantiza que tampoco está en caché?

Question

Considere una variable simple (global en mi caso):

int i;

En alguna parte se accede a esta variable

pthread_mutex_lock(i_mutex);
if(i == other value) {
  do_something();
}
pthread_mutex_unlock(i_mutex);

Otro subproceso actualiza i mientras contiene i_mutex . ¿Podría el compilador almacenar en caché el valor de i para que no obtenga el valor reciente? ¿Debo ser volátil?

Answer 1

Las respuestas simples a tu pregunta son:
- No, seré el valor más reciente.
- No, no tengo que ser volátil.

I_mutex protege su acceso a i ... siempre y cuando bloquee el mutex cada vez que lo lea y lo escriba. Simple como eso.

En otras palabras, no tiene que preocuparse por el almacenamiento en caché o volátil.

Disfruta, Randy

Answer 2

Los bloqueos pthread implementan barreras de memoria que garantizarán que los efectos de caché se hagan visibles para otros hilos. No necesita volatilidad para tratar adecuadamente la variable compartida i si los accesos a la variable compartida están protegidos por pthread mutexes.

de http://www.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap04.html#tag_04_11 :

Las siguientes funciones sincronizan la memoria con respecto a otros hilos:

fork()
pthread_barrier_wait()
pthread_cond_broadcast()
pthread_cond_signal()
pthread_cond_timedwait()
pthread_cond_wait()
pthread_create()
pthread_join()
pthread_mutex_lock()       // <====
pthread_mutex_timedlock()
pthread_mutex_trylock()
pthread_mutex_unlock()     // <====
pthread_spin_lock()
pthread_spin_trylock()
pthread_spin_unlock()
pthread_rwlock_rdlock()
pthread_rwlock_timedrdlock()
pthread_rwlock_timedwrlock()
pthread_rwlock_tryrdlock()
pthread_rwlock_trywrlock()
pthread_rwlock_unlock()
pthread_rwlock_wrlock()
sem_post()
sem_timedwait()
sem_trywait()
sem_wait()
semctl()
semop()
wait()
waitpid()

Answer 3

Un compilador no debe almacenar en caché dicho valor global a través de una llamada a función.

Pero creo que tu pregunta está mal planteada. En primer lugar, el mutex POSIX solo funciona cuando se mantiene en su semántica. Por lo tanto, debe aplicar cierta disciplina en su código para acceder solo a las variables globales ( i en ese caso) desde donde se retiene su exclusión mutua.

En segundo lugar, no crea que volatile declaraciones volatile le impedirían cualquier daño que pudiera causar tal incumplimiento de las reglas de acceso. La lectura y escritura concurrente en la memoria es un tema sutil.