O programa multithreading travou no modo otimizado, mas é executado normalmente em -O0

Eu escrevi um simples programa multithreading da seguinte maneira:

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;
}

Ele se comporta normalmente no modo de depuração no Visual studio ou -O0no gc c e imprime o resultado após 1segundos. Mas ficou preso e não imprime nada no modo Release ou -O1 -O2 -O3.

Dois tópicos, acessando um não-atômica, variável não vigiado são UB Isto diz respeito finished. Você pode fazer finisheddo tipo std::atomic<bool>para corrigir isso.

Minha correção:

#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;
}

Resultado:

result =1023045342
main thread id=140147660588864

Demonstração ao vivo no coliru

Alguém pode pensar: 'É um bool- provavelmente um pouco. Como isso pode ser não atômico? (Eu fiz quando comecei com o multi-threading.)

Mas observe que a falta de rasgo não é a única coisa que std::atomiclhe dá. Também torna bem definido o acesso simultâneo de leitura e gravação de vários threads, impedindo o compilador de assumir que a leitura da variável sempre verá o mesmo valor.

Criar um boolnão-atômico e desprotegido pode causar problemas adicionais:

• O compilador pode decidir otimizar a variável em um registro ou até vários acessos CSE em um e elevar a carga de um loop.
• A variável pode ser armazenada em cache para um núcleo de CPU. (Na vida real, CPUs têm caches coerentes . Isto não é um problema real, mas padrão do C ++ é suficiente solta para cobrir hipotética C ++ implementações na memória não-coerente compartilhado onde atomic<bool>com memory_order_relaxedloja / carga iria trabalhar, mas onde volatilenão. Usando volátil para isso seria UB, embora funcione na prática em implementações reais de C ++.)

Para impedir que isso aconteça, o compilador deve ser informado explicitamente para não fazer isso.

Estou um pouco surpreso com a discussão em evolução sobre a possível relação volatilecom esse problema. Assim, eu gostaria de gastar meus dois centavos:

• É volátil útil com threads
• Quem tem medo de um compilador de otimização ruim? .

A resposta de Scheff descreve como corrigir seu código. Eu pensei em acrescentar um pouco de informação sobre o que realmente está acontecendo neste caso.

Compilei seu código no godbolt usando o nível de otimização 1 ( -O1). Sua função compila da seguinte maneira:

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

Então o que está acontecendo aqui? Primeiro, temos uma comparação: cmp BYTE PTR finished[rip], 0- isso verifica se finishedé falso ou não.

Se é não falsa (aka true) devemos sair do loop na primeira execução. Isto conseguido jne .L4pelo qual j umps quando n ot e qua a etiqueta .L4em que o valor de i( 0) é armazenada num registo para utilização posterior e a função retorna.

Se for falso, no entanto, passamos para

.L5:
  jmp .L5

Este é um salto incondicional, para rotular .L5que por acaso é o próprio comando de salto.

Em outras palavras, o encadeamento é colocado em um loop ocupado infinito.

Então, por que isso aconteceu?

No que diz respeito ao otimizador, os threads estão fora de seu alcance. Ele assume que outros threads não estão lendo ou gravando variáveis ​​simultaneamente (porque isso seria UB de corrida de dados). Você precisa dizer que ele não pode otimizar acessos ausentes. É aqui que a resposta de Scheff entra. Não vou me incomodar em repeti-lo.

Como o otimizador não é informado de que a finishedvariável pode potencialmente mudar durante a execução da função, ela vê que finishednão é modificada pela própria função e assume que é constante.

O código otimizado fornece os dois caminhos de código que resultarão da entrada na função com um valor bool constante; ou ele executa o loop infinitamente, ou o loop nunca é executado.

no -O0compilador (como esperado) não otimiza o corpo do loop e a comparação:

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

portanto, a função, quando não otimizada, funciona, a falta de atomicidade aqui normalmente não é um problema, porque o código e o tipo de dados são simples. Provavelmente, o pior que podemos encontrar aqui é um valor ique está fora de um para o que deveria ser.

Um sistema mais complexo com estruturas de dados tem muito mais probabilidade de resultar em dados corrompidos ou execução incorreta.

Por uma questão de completude na curva de aprendizado; você deve evitar o uso de variáveis ​​globais. Você fez um bom trabalho ao torná-lo estático, para que ele seja local na unidade de tradução.

Aqui está um exemplo:

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;
}

Ao vivo na wandbox