Synchronisation après la fin du fil

Question

Du fait partie de this question n'a pas été abordée, je fais une autre question:

#include<iostream> 
#include<thread> 
using namespace std; 

void f2(double* ret) { 
    *ret=5.; 
} 

int main() { 
    double ret=0.; 
    thread t2(f2, &ret); 
    t2.join(); 
    cout << "ret=" << ret << endl; 
} 

Est-ce programme de données course libre?
Y a-t-il des garanties, en ce qui concerne le nouveau modèle de mémoire C++, qui accède à la variable ret du thread t2 et le thread main sont synchronisés?

Je veux dire, il est évident que les accès de t2 et main ne vont pas entrer en collision si le programme est exécuté sur le même noyau.
Mais que se passe-t-il si t2 et main sont exécutés sur différents cœurs?
Y a-t-il des garanties que les caches de core se synchroniseront avant que main poursuive l'exécution?

J'apprécierais que quelqu'un puisse fournir les mêmes références.

Merci.

Answer 1

Votre programme est libre de données. [Thread.thread.member]/p5 décrit join() avec une synchronisation paragraphe:

Synchronisation: La réalisation du fil représenté par * ce synchronise avec (1.10) le retour join() correspondant réussi. [Remarque: Les opérations sur * ne sont pas synchronisées. -endnote]

(1.10) fait référence à [intro.multithread] qui est une section trop longue pour être citée mais définit avec une précision extrême l'expression "synchronise with".

La dernière version de travail est N3225.