Quel modèle de mémoire est implémenté dans .NET Core?

La spécification ECMA CLI définit un modèle de mémoire faible. Cela permet de réorganiser l'ordre d'exécution des commandes (ce qui est utile pour les performances). Mais écrire du code de bas niveau pour un tel modèle est très difficile.

Et le plus important - les architectures de processeur X86 / AMD64 ont un modèle de mémoire plus strict (fort). En conséquence, Microsoft a implémenté un modèle de mémoire plus puissant dans son implémentation CLR que celui décrit dans la spécification.

Le modèle de mémoire a-t-il changé dans .NET Core? Potentiellement, ce cadre peut fonctionner sur des architectures avec un modèle de mémoire plus faible que X86 / AMD64.

De plus, .NET Core intègre Mono et autres. Et pour autant que je sache, le modèle de mémoire mono est plus faible, correspond à l'ECMA.

Dans cet article Présentation de .NET 5 écrit:

Développez les capacités de .NET en tirant le meilleur parti de .NET Core, .NET Framework, Xamarin et Mono.

Donc, je pense que si ce n'est pas maintenant, alors à l'avenir, ces durées d'exécution fusionneront en un seul ensemble.
Ci-dessous dans l'article, il est écrit:

Nous sommes en train de faire des remplacements CoreCLR et Mono l'un pour l'autre. Nous allons le rendre aussi simple qu'un commutateur de construction pour choisir entre les différentes options d'exécution.

Si je comprends bien, il y aura deux (ou plus) runtimes. Et probablement chacun aura son propre modèle de mémoire.

De quoi parle-t-on: modèle de mémoire .

Le modèle de mémoire est spécifique à l'exécution, donc votre question est en fait "existe-t-il des différences dans les modèles de mémoire de CLR, CoreCLR et MonoRuntime".

Après des recherches un peu, la question est vraiment, vraiment difficile à répondre. Il y a la spécification ECMA que vous avez mentionnée, qui vous donne le minimum de garanties que toutes les implémentations doivent fournir. Il y a une très belle description concise sur le blog de Joe Duffy pour CLR 2.0. Ensuite, pour .NET Framework, il y a cet article en deux parties qui parle du modèle CLR avec probablement plus de détails qu'il n'est sain de le savoir. Il y a même un document écrit à ce sujet.

Pour MonoRuntime, j'ai trouvé ce document qui parle d'atomique et décrit en fait la façon dont Mono implémente cela, bien que le niveau de détail soit plutôt faible.

Trouver les détails de CoreCLR est encore plus difficile. Il y a quelques points clés mis en évidence dans ce thread GitHub dotnet / coreclr et une discussion sur les lectures / écritures volatiles dans celui-ci .

La façon la plus simple de répondre est - oui, elle a changé, en fonction des ressources ci-dessus.

Cependant, il existe une deuxième façon de répondre à votre question et c'est simplement de nier sa prémisse - il semble supposer que le modèle de mémoire a changé dans le sens où certaines personnes intelligentes se sont assises, ont réécrit la spécification ECMA CLI, en ont fait le CoreCLR spécifications de modèle de mémoire et c'est le nouveau modèle de mémoire. Ce n'est pas le cas. Les personnes intelligentes mentionnées se sont assises et, au cours de plusieurs mois, ont affiné la conception pour qu'elle soit fiable, rapide, sensiblement facile à mettre en œuvre et ne viole pas les garanties minimales de la spécification. Citation du blog lié de Joe Duffy:

Nous avons construit notre modèle au fil des années de travail informel et de conception par exemple (...) cela est susceptible de changer d'une implémentation à l'autre.

La spécification ECMA informelle est, malheureusement, aussi formelle que celle que nous obtenons pour l'instant. Il n'y a pas de description formelle des changements entre la spécification ECMA et la mise en œuvre du CLR, ni de description formelle des changements entre CLR et CoreCLR. Et, plus important encore, les différences spécifiques à l'implémentation entre l'ECMA CLI et CLR / CoreCLR ne sont que cela - spécifiques à l'implémentation - et ne doivent pas être prises en compte . La seule source 100% fiable de la façon dont le modèle de mémoire .NET Core est implémenté est le code source. Et cela change évidemment avec chaque commit, chaque version, et il n'y a aucune garantie que l'équipe ne jettera pas la gigue entière par la fenêtre et ne la réécrira pour .NET 5 pour être exactement la même que la spécification ECMA (mais il est extrêmement improbable que cela soit ).