Le programme multithreading est bloqué en mode optimisé mais s'exécute normalement en -O0

J'ai écrit un simple programme multithreading comme suit:

static bool finished = false;

int func()
{
    size_t i = 0;
    while (!finished)
        ++i;
    return i;
}

int main()
{
    auto result=std::async(std::launch::async, func);
    std::this_thread::sleep_for(std::chrono::seconds(1));
    finished=true;
    std::cout<<"result ="<<result.get();
    std::cout<<"\nmain thread id="<<std::this_thread::get_id()<<std::endl;
}

Il se comporte normalement en mode débogage dans Visual studio ou -O0en gc c et imprime le résultat après 1quelques secondes. Mais il est bloqué et n'imprime rien en mode Release ou -O1 -O2 -O3.

Deux threads, accédant à une variable non atomique et non gardée sont UB Cela concerne finished. Vous pouvez faire finisheddu type std::atomic<bool>pour résoudre ce problème.

Ma solution:

#include <iostream>
#include <future>
#include <atomic>

static std::atomic<bool> finished = false;

int func()
{
    size_t i = 0;
    while (!finished)
        ++i;
    return i;
}

int main()
{
    auto result=std::async(std::launch::async, func);
    std::this_thread::sleep_for(std::chrono::seconds(1));
    finished=true;
    std::cout<<"result ="<<result.get();
    std::cout<<"\nmain thread id="<<std::this_thread::get_id()<<std::endl;
}

Production:

result =1023045342
main thread id=140147660588864

Démo en direct sur coliru

Quelqu'un peut penser: «C'est un bool- probablement un peu. Comment cela peut-il être non atomique? ' (Je l'ai fait quand j'ai commencé avec le multi-threading moi-même.)

Mais notez que le manque de déchirure n'est pas la seule chose qui std::atomicvous donne. Cela rend également l'accès en lecture + écriture simultané à partir de plusieurs threads bien défini, empêchant le compilateur de supposer que la relecture de la variable verra toujours la même valeur.

La fabrication d'un boolnon-atomique non protégé peut entraîner des problèmes supplémentaires:

• Le compilateur peut décider d'optimiser une variable dans un registre ou même plusieurs accès CSE en un seul et lever une charge d'une boucle.
• La variable peut être mise en cache pour un cœur de processeur. (Dans la vraie vie, les processeurs ont des caches cohérentes . Ce n'est pas un vrai problème, mais la norme C de est assez lâche pour couvrir les implémentations C ++ hypothétique sur la mémoire partagée non cohérente où atomic<bool>avec memory_order_relaxedmagasin / charge fonctionnerait, mais où volatilene serait pas. L' utilisation volatile pour cela serait UB, même si cela fonctionne en pratique sur de vraies implémentations C ++.)

Pour éviter que cela se produise, le compilateur doit être explicitement averti de ne pas le faire.

Je suis un peu surpris par l'évolution de la discussion concernant la relation potentielle de volatilecette question. Ainsi, je voudrais dépenser mes deux cents:

• Est volatile utile avec les threads
• Qui a peur d'un gros compilateur d'optimisation? .

La réponse de Scheff décrit comment réparer votre code. J'ai pensé ajouter quelques informations sur ce qui se passe réellement dans ce cas.

J'ai compilé votre code sur godbolt en utilisant le niveau d'optimisation 1 ( -O1). Votre fonction se compile comme suit:

func():
  cmp BYTE PTR finished[rip], 0
  jne .L4
.L5:
  jmp .L5
.L4:
  mov eax, 0
  ret

Alors, que se passe-t-il ici? Tout d'abord, nous avons une comparaison: cmp BYTE PTR finished[rip], 0- cela vérifie si finishedc'est faux ou non.

Si ce n'est pas faux (ou vrai), nous devons quitter la boucle lors de la première exécution. Ceci accompli par jne .L4lequel j umps quand n ot e qual pour étiqueter .L4où la valeur de i( 0) est stockée dans un registre pour une utilisation ultérieure et la fonction retourne.

S'il est faux cependant, nous passons à

.L5:
  jmp .L5

Il s'agit d'un saut inconditionnel, à étiqueter .L5qui se trouve être la commande de saut elle-même.

En d'autres termes, le thread est placé dans une boucle occupée infinie.

Alors pourquoi est-ce arrivé?

En ce qui concerne l'optimiseur, les threads sont en dehors de sa compétence. Il suppose que les autres threads ne lisent ni n'écrivent les variables simultanément (car ce serait l'UB de la course aux données). Vous devez lui dire qu'il ne peut pas optimiser les accès. C'est là que la réponse de Scheff entre en jeu. Je ne prendrai pas la peine de le répéter.

Étant donné que l'optimiseur n'est pas informé que la finishedvariable peut potentiellement changer pendant l'exécution de la fonction, il voit qu'il finishedn'est pas modifié par la fonction elle-même et suppose qu'elle est constante.

Le code optimisé fournit les deux chemins de code qui résulteront de l'entrée de la fonction avec une valeur booléenne constante; soit il exécute la boucle à l'infini, soit la boucle n'est jamais exécutée.

au -O0compilateur (comme prévu) n'optimise pas le corps de la boucle et la comparaison:

func():
  push rbp
  mov rbp, rsp
  mov QWORD PTR [rbp-8], 0
.L148:
  movzx eax, BYTE PTR finished[rip]
  test al, al
  jne .L147
  add QWORD PTR [rbp-8], 1
  jmp .L148
.L147:
  mov rax, QWORD PTR [rbp-8]
  pop rbp
  ret

par conséquent, la fonction, lorsqu'elle n'est pas optimisée, fonctionne, le manque d'atomicité ici n'est généralement pas un problème, car le code et le type de données sont simples. Le pire que nous pourrions rencontrer ici est probablement une valeur iqui est inférieure de un à ce qu'elle devrait être.

Un système plus complexe avec des structures de données est beaucoup plus susceptible d'entraîner des données corrompues ou une exécution incorrecte.

Par souci d'exhaustivité dans la courbe d'apprentissage; vous devez éviter d'utiliser des variables globales. Vous avez cependant fait du bon travail en le rendant statique, il sera donc local à l'unité de traduction.

Voici un exemple:

class ST {
public:
    int func()
    {
        size_t i = 0;
        while (!finished)
            ++i;
        return i;
    }
    void setFinished(bool val)
    {
        finished = val;
    }
private:
    std::atomic<bool> finished = false;
};

int main()
{
    ST st;
    auto result=std::async(std::launch::async, &ST::func, std::ref(st));
    std::this_thread::sleep_for(std::chrono::seconds(1));
    st.setFinished(true);
    std::cout<<"result ="<<result.get();
    std::cout<<"\nmain thread id="<<std::this_thread::get_id()<<std::endl;
}

En direct sur wandbox