Plusieurs threads et mémoire

Question

Je lis dans la documentation de Visual C++ que plusieurs threads peuvent lire en toute sécurité à partir du même objet.

Ma question est: comment un processeur X86-64 avec plusieurs cœurs gère-t-il cela?

Disons que vous avez un bloc de mémoire de 1 Mo. Des threads différents sont-ils littéralement capables de lire exactement les mêmes données en même temps ou bien les cœurs lisent-ils un mot à la fois, un seul noyau pouvant lire un mot particulier à la fois?

Answer 1

Non seulement sont différents noyaux autorisés à lire à partir du même bloc de mémoire, ils sont autorisés à écrire en même temps aussi. Si c'est «sûr» ou non, c'est une histoire complètement différente. Vous devez implémenter une sorte de garde dans votre code (généralement fait avec des sémaphores ou des dérivés de ceux-ci) pour vous protéger contre plusieurs cœurs qui se disputent le même bloc de mémoire d'une manière que vous n'autorisez pas spécifiquement. A propos de la taille de la mémoire d'un noyau lit à la fois, c'est généralement la valeur d'un registre, 32 bits sur un processeur 32 bits, 64 bits pour un processeur 64 bits et ainsi de suite. Même le streaming est fait dword par dword (regardez memcpy par exemple). En ce qui concerne les coeurs multiples simultanés, chaque cœur utilise un seul bus pour lire et écrire en mémoire, donc accéder à toutes les ressources (mémoire vive, périphériques externes, unité de traitement en virgule flottante) est une requête à la fois, une noyau à la fois. Le traitement réel à l'intérieur du noyau est cependant complètement concurrent. Les transferts DMA ne bloquent pas non plus le bus, les transferts simultanés sont mis en file d'attente et traités un à la fois (je crois, pas sûr à 100% sur ce point). Edit: juste pour clarifier, contrairement à l'autre réponse ici, je ne parle que d'un scénario sans cache. Bien sûr, si la mémoire est mise en cache, l'accès en lecture seule est complètement simultané.

Answer 2

S'il n'y a vraiment pas d'écritures dans votre bloc de 1 Mo, alors oui, chaque core peut lire sa propre ligne de cache sans problème car aucune écriture n'est validée et donc aucun problème de cohérence de cache.

Dans une architecture multicœur, il existe fondamentalement un cache pour chaque cœur et un «protocole de cohérence du cache» qui invalide le cache sur certains cœurs qui ne disposent pas des informations les plus à jour. Je pense que la plupart des processeurs implémentent le MOESI protocol pour la cohérence du cache.

La cohérence du cache est un sujet complexe qui a été largement discuté (j'aime particulièrement certains articles de Joe Duffy here et here). La discussion tourne néanmoins autour des pénalités de performance possibles du code qui, tout en étant apparemment sans verrou, peut ralentir en raison du protocole de cohérence de la mémoire cache pour maintenir la cohérence entre les caches des processeurs, mais tant qu'il n'y a pas d'écriture, cohérence à maintenir et donc pas perdu sur la performance. Pour clarifier, comme indiqué dans le commentaire, la RAM ne peut pas être accédée simultanément puisque les architectures x86 et x64 implémentent un seul bus qui est partagé entre les cœurs avec SMP garantissant l'équité d'accès à la mémoire principale. Néanmoins, cette situation est cachée par chaque cache central qui permet à chaque core d'avoir sa propre copie des données. Pour 1 Mo de données il serait possible d'engager sur certains conflits alors que le core mettrait à jour son cache mais cela serait négligeable.

Quelques liens utiles:

• Cache Coherence Protocols
• Cache Coherence