Une variable locale statique peut-elle être faussement optimisée?

Question

std::uint64_t foo() 
{ 
    static std::uint64_t var = 0u; 

    std::lock_guard<std::mutex> lock(mutex); 

    std::uint64_t b; 

    do 
    { 
     b = bar(); 
    } 
    while (b <= var); 

    var = b; 

    return b; 
} 

Supposons que nous ayons deux threads. Laissez le premier thread lu variable var dans un registre avant d'appeler lock() et le deuxième thread lire la variable var dans un registre avant d'appeler lock(). Ensuite, le premier thread change var mais le deuxième thread ne voit pas la modification car il conserve la valeur dans le registre. Est-ce que cette situation vraiment mauvaise peut arriver? En général, seules les variables locales sont optimisées de cette façon: elles sont placées dans des registres et lues par la suite plutôt qu'à partir de la mémoire principale. Et les variables globales ne devraient pas être optimisées de cette manière que je comprends. Mais qu'en est-il des variables locales statiques?

Answer 1

La variable locale statique a une durée de vie de la variable globale, elle a simplement une portée de fonction. Vous devez le protéger comme vous le feriez avec une variable globale appropriée (mutex/atomic).

Note: Si vous utilisez tout type de variable dans plusieurs threads (je veux dire quand les fils utilisent la variable même), alors vous devez le rendre thread-safe. Même, si c'est une variable globale. Même, si la variable est stockée en mémoire. Stocker une variable en mémoire ne la rend pas sûre. La sécurité des threads n'est pas une préoccupation car certaines variables peuvent figurer dans les registres. Il pourrait y avoir une CPU, où différents cœurs ne synchronisent pas automatiquement leurs caches. Ainsi, pour une variable, il peut y avoir plusieurs valeurs dans le cache de chaque core.