Zamawianie modeli pamięci i widoczność?

Próbowałem szukać szczegółów na ten temat, czytałem nawet standard o muteksach i atomice... ale nadal nie mogłem zrozumieć gwarancji widoczności modelu pamięci C++11. Z tego, co rozumiem, bardzo ważną cechą mutex obok wzajemnego wykluczenia jest zapewnienie widoczności. Aka nie wystarczy, że tylko jeden wątek na raz zwiększa licznik, ważne jest, że wątek zwiększa licznik, który był przechowywany przez wątek, który był ostatnio za pomocą mutex(naprawdę Nie wiem dlaczego ludzie nie wspominają o tym więcej przy omawianiu muteksów, może miałem złych nauczycieli :)). Więc z tego co wiem, atomic nie wymusza natychmiastowej widoczności: (od osoby, która prowadzi wątek boost:: i zaimplementowała wątek c++11 i bibliotekę mutex):

Ogrodzenie z memory_order_seq_cst nie wymusza natychmiastowego widoczność do innych wątków (podobnie jak instrukcja MFENCE). Ograniczenia zamawiania pamięci C++0x są po prostu takie - - - zamawianie ograniczenia. operacje memory_order_seq_cst tworzą całkowity porządek, ale nie ma żadnych ograniczeń co do tego, czym jest to zamówienie, poza tym, że musi być uzgodnione przez wszystkie wątki i nie może naruszać innych zamówień ograniczenia. W szczególności wątki mogą nadal widzieć wartości "stare" przez jakiś czas, pod warunkiem, że widzą wartości w kolejności zgodnej z ograniczenia.

Z tego co mogę powiedzieć std::memory_order_seq_cst wstawia barierę mem, podczas gdy inne wymuszają tylko kolejność operacji w określonym miejscu pamięci.

Więc może ktoś to wyczyścić domyślam się, że wiele osób będzie robić straszne błędy używając std:: atomic, esp jeśli nie używają domyślnego (STD::memory_order_seq_cst memory ordering)
2. jeśli mam rację to znaczy, że druga linia jest redundand w tym kodzie:

atomicVar.store(42);
std::atomic_thread_fence(std::memory_order_seq_cst);  

3. do std:: atomic_thread_fences mają te same wymagania co mutexy w tym sensie, że aby zapewnić spójność seq na nieatomowych var-ach, należy wykonać STD:: atomic_thread_fence(STD::memory_order_seq_cst); przed załadowaniem i std:: atomic_thread_fence (std:: memory_order_seq_cst);
po sklepach?
4. Is

  {
    regularSum+=atomicVar.load();
    regularVar1++;
    regularVar2++;
    }
    //...
    {
    regularVar1++;
    regularVar2++;
    atomicVar.store(74656);
  }

Odpowiednik

std::mutex mtx;
{
   std::unique_lock<std::mutex> ul(mtx);
   sum+=nowRegularVar;
   regularVar++;
   regularVar2++;
}
//..
{
   std::unique_lock<std::mutex> ul(mtx);
    regularVar1++;
    regularVar2++;
    nowRegularVar=(74656);
}

Edytuj: 5. Czy można prowadzić ogień?
Istnieją tylko dwa wątki.

atomic<int*> p=nullptr; 

Pierwszy wątek pisze

{
    nonatomic_p=(int*) malloc(16*1024*sizeof(int));
    for(int i=0;i<16*1024;++i)
    nonatomic_p[i]=42;
    p=nonatomic;
}

Drugi wątek czyta

{
    while (p==nullptr)
    {
    }
    assert(p[1234]==42);//1234-random idx in array
}