Program multithreading terjebak dalam mode yang dioptimalkan tetapi berjalan secara normal di -O0

Saya menulis program multithreading sederhana sebagai berikut:

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

Ini berperilaku normal dalam mode debug di Visual studio atau -O0di gc c dan mencetak hasilnya setelah beberapa 1detik. Tetapi macet dan tidak mencetak apa pun dalam mode Rilis atau -O1 -O2 -O3.

Dua utas, mengakses variabel non-atomik, non-dijaga adalah UB Kekhawatiran ini finished. Anda dapat membuat finishedtipe std::atomic<bool>untuk memperbaikinya.

Perbaikan saya:

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

Keluaran:

result =1023045342
main thread id=140147660588864

Demo langsung di coliru

Seseorang mungkin berpikir 'Ini bool- mungkin sedikit. Bagaimana ini bisa non-atom? ' (Saya lakukan ketika saya mulai dengan multi-threading sendiri.)

Tetapi perhatikan bahwa kekurangan air mata bukanlah satu-satunya hal yang terjadi std::atomic memberi Anda. Itu juga membuat akses baca + tulis bersamaan dari banyak utas didefinisikan dengan baik, menghentikan kompiler dari asumsi bahwa membaca ulang variabel akan selalu melihat nilai yang sama.

Membuat boolnon-atomic yang tidak dijaga dapat menyebabkan masalah tambahan:

• Compiler mungkin memutuskan untuk mengoptimalkan variabel menjadi register atau bahkan beberapa akses CSE menjadi satu dan menambah beban keluar dari satu loop.
• Variabel mungkin di-cache untuk inti CPU. (Dalam kehidupan nyata, CPU memiliki cache yang koheren . Ini bukan masalah nyata, tetapi standar C ++ cukup longgar untuk mencakup implementasi C ++ hipotetis pada memori bersama non-koheren di mana atomic<bool>dengan memory_order_relaxedstore / load akan bekerja, tetapi di mana volatiletidak. Menggunakan volatile untuk ini adalah UB, meskipun itu bekerja dalam praktik pada implementasi C ++ nyata.)

Untuk mencegah hal ini terjadi, kompiler harus diberitahu secara eksplisit untuk tidak melakukannya.

Saya sedikit terkejut tentang diskusi yang berkembang tentang potensi hubungan volatiledengan masalah ini. Jadi, saya ingin menghabiskan dua sen:

• Mudah menguap dengan utas
• Siapa yang takut akan kompiler optimisasi buruk yang besar? .

Jawaban Scheff menjelaskan cara memperbaiki kode Anda. Saya pikir saya akan menambahkan sedikit informasi tentang apa yang sebenarnya terjadi dalam kasus ini.

Saya mengkompilasi kode Anda di godbolt menggunakan optimasi level 1 ( -O1). Fungsi Anda mengkompilasi seperti:

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

Jadi, apa yang terjadi di sini? Pertama, kami memiliki perbandingan: cmp BYTE PTR finished[rip], 0- ini memeriksa untuk melihat apakah finishedsalah atau tidak.

Jika tidak salah (alias benar) kita harus keluar dari loop pada proses pertama. Hal ini dicapai dengan jne .L4yang j umps ketika n ot e qual ke label .L4dimana nilai i( 0) disimpan dalam register untuk digunakan dan fungsi kembali.

Jika adalah palsu namun, kami pindah ke

.L5:
  jmp .L5

Ini adalah lompatan tanpa syarat, untuk memberi label .L5yang kebetulan merupakan perintah lompatan itu sendiri.

Dengan kata lain, utas dimasukkan ke dalam loop sibuk tanpa batas.

Jadi mengapa ini terjadi?

Sejauh menyangkut optimiser, utas berada di luar ruang lingkupnya. Ini mengasumsikan utas lainnya tidak membaca atau menulis variabel secara bersamaan (karena itu akan menjadi data-ras UB). Anda perlu mengatakan bahwa itu tidak dapat mengoptimalkan akses jauh. Di sinilah jawaban Scheff masuk. Saya tidak akan repot-repot mengulanginya.

Karena pengoptimal tidak diberitahu bahwa finishedvariabel berpotensi berubah selama eksekusi fungsi, ia melihat bahwa finisheditu tidak dimodifikasi oleh fungsi itu sendiri dan mengasumsikan bahwa itu konstan.

Kode yang dioptimalkan menyediakan dua jalur kode yang akan dihasilkan dari memasukkan fungsi dengan nilai bool konstan; baik itu menjalankan loop secara tak terbatas, atau loop tidak pernah berjalan.

di -O0compiler (seperti yang diharapkan) tidak mengoptimalkan loop body dan perbandingannya:

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

oleh karena itu fungsinya, ketika tidak dioptimalkan berhasil, kurangnya atomisitas di sini biasanya tidak menjadi masalah, karena kode dan tipe data sederhana. Mungkin yang terburuk kita bisa lari ke sini adalah nilai iyang off per satu untuk apa yang harus menjadi.

Sistem yang lebih kompleks dengan struktur data jauh lebih mungkin menghasilkan data yang rusak, atau eksekusi yang tidak tepat.

Demi kelengkapan dalam kurva pembelajaran; Anda harus menghindari menggunakan variabel global. Anda melakukan pekerjaan dengan baik dengan menjadikannya statis, sehingga akan bersifat lokal ke unit terjemahan.

Berikut ini sebuah contoh:

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

Langsung di kotak tongkat