Si tengo un código que se ve algo como:siguientes puntos en un entorno multiproceso
typedef struct {
bool some_flag;
pthread_cond_t c;
pthread_mutex_t m;
} foo_t;
// I assume the mutex has already been locked, and will be unlocked
// some time after this function returns. For clarity. Definitely not
// out of laziness ;)
void check_flag(foo_t* f) {
while(f->flag)
pthread_cond_wait(&f->c, &f->m);
}
¿Hay algo en el estándar de C prevenir un optimizador de la reescritura check_flag como:
void check_flag(foo_t* f) {
bool cache = f->flag;
while(cache)
pthread_cond_wait(&f->c, &f->m);
}
En otra palabras, ¿el código generado tiene para seguir el puntero f
cada vez que pasa el ciclo, o es el compilador libre de sacar la desreferencia?
Si es es libre de sacarlo, ¿hay alguna manera de evitar esto? ¿Necesito rociar una palabra clave volátil en alguna parte? No puede ser el parámetro check_flag
porque planeo tener otras variables en esta estructura que no me importe que el compilador optimice de esta manera.
puedo tener que recurrir a:
void check_flag(foo_t* f) {
volatile bool* cache = &f->some_flag;
while(*cache)
pthread_cond_wait(&f->c, &f->m);
}
+1 por pensar en este tipo de problema antes de escribir código enhebrado por prueba y error. –