Discussion :

[PyNub]

Bonjour,

Je me pose quelques questions sur les multicoeurs pour lesquelles je ne trouve pas de réponses sur le net.

Je sais qu'il existe de nombreux modèle de programmation pour utiliser le parallèlisme offert par les architectures multicoeurs openHMPP entre autres. Ce que je ne comprends pas c'est comment cela se passe au niveau matériel et plus précisément au niveau du code machine/assembleur.

Comment un processus est assigné à un coeur particulier ? Est-ce qu'il existe une instruction ? ou sinon quel est le mécanisme qui est utilisé ? J'ai pensé à un système d'interruption qui déclencherait le chargement du compteur ordinal d'un coeur particulier avec une nouvelle adresse d'instruction. Quoi qu'il en soit il doit exister une instruction spéciale qui déclenche la dite interruption. Or ça fait quelques jours que je cherche, rien dans le jeu d'instructions des intel I7 ou AMDK6, ne semble exister pour commander un tel mécanisme. J'ai survolé le chapitre de la documentation Intel concernant l'APIC mais c'est assez ardu...

Autre chose, au moment du démarrage quel est le coeur qui exécute les première instructions ?

Si quelqu'un connait un bon site de référence en français je suis preneur...

Bien à vous

[souviron34]

Tu peux déjà, comme informaton, lire ici-même :

• Multithreading et multicore
  
  
• Programmation pour processeur multi-coeurs ?

et éventuellement (pour le fun :

Il faut repenser les os pour les processeurs multi-coeurs d'après Microsoft

Enjoy...

[PyNub]

Bonjour et merci pour ta réponse,

Tu peux déjà, comme informaton, lire ici-même :
Multithreading et multicore

Je viens de survoler la discussion, je vais approfondir ma lecture, cependant ce que je recherche c'est de l'information au plus proche du matériel. La discussion à l'air d'être orienté vers les langages de haut niveau. Cela m'interesse aussi. Mais ce que je voudrais comprendre avant tout c'est les mécanismes internes au processeur pour assigner les threads à chaque coeur.

Programmation pour processeur multi-coeurs ?

Je connaissais openMP mais pas MPI je vais me renseigner dessus... Mais ce que je voudrais comprendre avant tout etc...

A bientôt j'espère

[souviron34]

Mais ce que je voudrais comprendre avant tout c'est les mécanismes internes au processeur pour assigner les threads à chaque coeur.

Le noeud du problème tient en 2 mots :

• scheduler
• syncrhronsation

Quel que soit ce qu'on utilise, que ce soit langage ou matériel.

D'autre part,comme mentionné dans une des discussions , la notion de "thread" n'a que peu à voir avec le parallélisme : c'est plutôt de l'accès concurrent..

[PyNub]

Oui en effet il y a accès concurrent à la mémoire puisqu'elle est partagé, mais elle est partagée soit par des processus soit par des threads.

Quoi qu'il en soit la notion de threads et de processus ne peut s'appliquer qu'au système d'exploitation. Pour le processeur tout est question d'adresse, d'instruction et de mot mémoire. Et c'est justement c'est de ce point de vue que je veux comprendre ce qu'il se passe.

Sur un système monoprocesseur toutes les adresse d'instructions sont données par le compteur ordinal, en revanche sur un multicoeur il y a un compteur ordinal pour chaque coeur. Comment est traduite par exemple en assembleur :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
!$OMP PARALLEL PRIVATE(rang) NUM_THREADS(3)
  rang=OMP_GET_NUM_THREAD()
  !$OMP SECTIONS
   !$OMP SECTION
   call lecture_champ_initial_x(a)
   print *,"Tâche numéro ",rang,": init. champ en X"
   !$OMP SECTION
   call lecture_champ_initial_y(b)
   print *,"Tâche numéro ",rang,": init. champ en Y"
   !$OMP SECTION
   pas_x      = 1./real(m-1)
   pas_y      = 2./real(n-1)
   coord_x(:) = (/ (real(i-1)*pas_x,i=1,m) /)
   coord_y(:) = (/ (real(i-1)*pas_y,i=1,n) /)
   print *,"Tâche numéro ",rang,": init. maillage"
   !$OMP END SECTIONS NOWAIT
 !$OMP END PARALLEL

Quelle est l'instruction (ou le mécanisme) du point de vue de l'assembleur qui permet de répartir les trois sections sur chaque processeur ?

[Invité]

Quelle est l'instruction (ou le mécanisme) du point de vue de l'assembleur qui permet de répartir les trois sections sur chaque processeur ?

Sur les architectures x86, il me semble que c'est géré par le système d'exploitation : c'est un appel système particulier (donc une interruption logicielle un peu spéciale) qui va démarrer le thread/processus ou autre sur le processeur qu'il faut. Donc tu devrais voir une instruction d'appel d'interruption quelque part pour exécuter un thread/processus en parallèle du reste, mais attention : c'est l'interruption qui elle-même qui décide (ou pas) sur quel processeur lancer le processus/thread. Elle seule est potentiellement capable de répartir le processus/thread sur les processeurs de l'ordinateur, et il se peut que sur certaines systèmes d'exploitations incapables de faire autre chose que du time-sharing, cette interruption n'utilise qu'un seul processeur.

Pour arrêter ou mettre en pause l’exécution d'un thread/processus quand son travail est fini, il existe l'instruction HLT.

[PyNub]

Sur les architectures x86, il me semble que c'est géré par le système d'exploitation : c'est un appel système particulier

Oui, mais au final tout termine par du code machine...

Donc tu devrais voir une instruction d'appel d'interruption quelque part pour exécuter un thread/processus en parallèle du reste

Oui en effet je suppose que le mécanisme permettant à un coeur d'exécuter des instructions située dans une zone particulière de la mémoire passe par une interruption, par contre dans le cas d'une interruption "classique" j'entends par là une frappe sur le clavier, le fin d'un E/s... Le CO est toujours chargée avec les mêmes adresses. Dans le cas d'une programmation parallèle les coeurs exécutent des instructions par définition changeante (puiqu'il s'agit ici de programmes différents). Donc il faut pouvoir avant de déclencher une interruption configurer le vecteur que la dite interruption va appeler sur le processeur concerné...

[Mat.M]

Ce que je ne comprends pas c'est comment cela se passe au niveau matériel et plus précisément au niveau du code machine/assembleur.

Comment un processus est assigné à un coeur particulier ? Est-ce qu'il existe une instruction ? ou sinon quel est le mécanisme qui est utilisé ? J'ai pensé à un système d'interruption qui déclencherait le chargement du compteur ordinal d'un coeur particulier avec une nouvelle adresse d'instruction. Qu

Sous Windows il y a des API pour assigner un processus à un coeur en particulier comme SetProcessAffinityMask
http://msdn.microsoft.com/en-us/libr...(v=VS.85).aspx
je conseille de parcourir la doc du MSDN
http://msdn.microsoft.com/en-us/libr...(v=VS.85).aspx

Open MP c'est une bibliothèque multiplateforme ça évite de faire du code spécifique à Windows et à Linux.

Maintenant pour ce qui est de l'assembleur il vaut mieux laisser les outils d'Intel comme Thread Building Block qui permettent d'optimiser le code pour exploiter le parallèlisme.

A noter que maintenant Visual Studio 2010 possède des classes et des directives pour ces technologies

Oui, mais au final tout termine par du code machine...

si tu veux optimiser du code assembleur pour cela il faut installer TBB
http://threadingbuildingblocks.org/

Sinon VS2010 permet les directives pour la programmation parallèle.
L'outil doit certainement optimiser le code au niveau machine.

Maintenant si tu veux faire cela à la "main" cela risque d'être trop pointu à faire

Autre chose, au moment du démarrage quel est le coeur qui exécute les première instructions ?

je pense que c'est bêtement les 2 si tu as un dual core par exemple.

[PyNub]

Maintenant si tu veux faire cela à la "main" cela risque d'être trop pointu à faire

Pas focément le faire mais le comprendre... Ou en avoir une idée à tout le moins.

Ceci-dit merci pour les infos.

[souviron34]

Dans le cas d'une programmation parallèle les coeurs exécutent des instructions par définition changeante (puiqu'il s'agit ici de programmes différents).

Au risque de me répéter, tu as une interprétation bien à toi du parallèlisme...


Reprenons :

• Une application multi-threadée (qui n'est PAS une application parallèle) peut s'exécuter sur un seul ou sur plusieurs coeurs.
  
  
• Une application SANS threads peut s'exécuter sur un ou plusieurs coeurs si elle a été parallélisée

Dans les threads ne s'éxécutent pas des "programmes différents" (un programme est un "exe", une application), mais des morceaux du même programme.

Cependant, ce n'est pas du parallèlisme au vrai sens, puisqu'à priori les différents coeurs doivent être sur la même machine.

Le principe d'une application parallèle est cependant le même, à la différence près que justement ces "morceaux" de code peuvent être éxécutés sur d'autres machines (connues ou non).

Dans le cas d'une vraie application parallèle, il est (très éventuellement) possible de sélectionner le CPU , mais de toutes façons absolument pas souhaitable. D'où les instructions de synchronisation.

Dans le cas d'une application multi-threadée, je ne sais pas comment ça se passe, mais je soupçonne que l'algo est relativement simple : pour N coeurs, si coeur no i non utilisé, alors on l'utilise, sinon, si tous les coeurs sont utilisés, on prend le moins chargé, et on fait agir un scheduler dessus.

Enfin, en général ce qui change , que ce soit dans un thread ou dans un CPU utilisé pour du parallèlisme, ce n'est pas le code, mais les valeurs et le contexte, choses qui sont en général effectuées et transférées par le uploader, soit général, soit spécifique au coeur.

[PyNub]

je pense que c'est bêtement les 2 si tu as un dual core par exemple.

Il faut bien qu'il y est 1 processus initiateur... Par exemple l'init de Linux ou le NTLDR de Windows...

[souviron34]

Tu confonds beaucoup de choses.. processus, CPU, threads, parallèlisme...


Mais pour cette question, forcément les toutes premières instructions sont éxécutées par le coeur 0 (le premier à l'adresse la plus basse).

Après, vraisemblablement cela dépend des programmes appelés, mais j'aurais tendance à dire que pour les init cela restera sur le coeur 0 (sauf expréssement prévu, mais je n'y crois pas pour des questions de maintenance et portabilité)

[Invité]

Oui en effet je suppose que le mécanisme permettant à un coeur d'exécuter des instructions située dans une zone particulière de la mémoire passe par une interruption, par contre dans le cas d'une interruption "classique" j'entends par là une frappe sur le clavier, le fin d'un E/s... Le CO est toujours chargée avec les mêmes adresses.

Dans le cas d'une programmation parallèle les cœurs exécutent des instructions par définition changeante (puisqu'il s'agit ici de programmes différents). Donc il faut pouvoir avant de déclencher une interruption configurer le vecteur que la dite interruption va appeler sur le processeur concerné...

Il suffit de copier l'adresse à laquelle commence notre thread dans un registre du processeur définit par l'interruption. Et notre interruption n'a plus qu'à faire exécuter un branchement indirect vers cette adresse au processeur qui doit exécuter le thread.

Seul problème : il faut préciser quel core doit se réveiller. Ça doit surement avoir un rapport avec l'affinité processeur ou quelque chose dans le genre.

EDIT : tu as pensé à regarder la documentation intel ? Plus précisément, cherche le system programming developper's guide sur leur site. Le chapitre 10 aura réponse à tes questions. Plus précisément, tu dois lire le sous-chapitre 10.6 : Issuing Inter Processor Interrupts

En fait, le choix du processeur qui exécutera l'interruption qui le réveillera et lui fera exécuter le thread en parallèle se fait par configuration de certains registres accessibles un Kernel-mode.

[PyNub]

Tu confonds beaucoup de choses.. processus, CPU, threads, parallèlisme...

Non... Tu me parle de programmation alors que j'essaie de comprendre le fonctionnement interne d'un multicoeur....

Dans les threads ne s'éxécutent pas des "programmes différents" (un programme est un "exe", une application), mais des morceaux du même programme.

Au risque de me répéter au final pour le processeur tout est du code machine le processeur ne distingue pas les threads ni les programmes.

Mais pour cette question, forcément les toutes premières instructions sont éxécutées par le coeur 0

je pense que c'est bêtement les 2 si tu as un dual core par exemple

on fait un vote ou quoi ?

[PyNub]

Il suffit de copier l'adresse à laquelle commence notre thread dans un registre du processeur définit par l'interruption. Et notre interruption n'a plus qu'à faire exécuter un branchement indirect vers cette adresse au processeur qui doit exécuter le thread.

Oui je suppose en effet que ça doit se passer de la sorte...

Seul problème : il faut préciser quel core doit se réveiller. Ça doit surement avoir un rapport avec l'affinité processeur ou quelque chose dans le genre.

Oui par affinité je pense que tu veux parler du fait qu'il y a plus intérêt à ordonnancer un processus (ou un threads quoiqu'il en soit une séquence de code...) sur le coeur ou celui-ci s'est exécuté auparavant car cela peut eviter entre autre une reconfiguration de la TLB. Mais cela est de l'ordre du système d'exploitation. Ce qui serait intéressant de savoir c'est le mécanisme utilisé pour connaitre la charge du processeur. Si c'est l'OS qui s'en occupe ou si l'information est donnée par le matériel. Je penche plutôt pour la première solution car il suffit juste d'ajouter cette information à la table des processus.

[PyNub]

EDIT : tu as pensé à regarder la documentation intel ? Plus précisément, cherche le system programming developper's guide sur leur site. Le chapitre 10 aura réponse à tes questions. Plus précisément, tu dois lire le sous-chapitre 10.6 : Issuing Inter Processor Interrupts

En fait, le choix du processeur qui exécutera l'interruption qui le réveillera et lui fera exécuter le thread en parallèle se fait par configuration de certains registres accessibles un Kernel-mode.

Oui je suis dessus justement. But my english is very bad... Je traduis le chapitre en français (ça me fait travailler mon anglais...).

Tu me rends un grand service en m'indiquant le bon passage, Merci beaucoup.

[Mat.M]

Mais pour cette question, forcément les toutes premières instructions sont éxécutées par le coeur 0 (le premier à l'adresse la plus basse).

salut je crois que tu confonds ring 0 et coeur 1ou 0
Un CPU multitâche possède plusieurs couches ring 0,ring 1....du moins dans l'architecture x86 Intel
l'OS tourne en ring 0 ,les drivers en ring 1 et le code exécutable en ring n...

Au risque de me répéter au final pour le processeur tout est du code machine le processeur ne distingue pas les threads ni les programmes.

oui absolument ;le CPU ne connait que les mnemoniques x86 comme MOV EAX,valeur etc...LEA adresse,valeur...
Pour ce qui est du multitâche la notion de thread c'est exclusivement au niveau de l'OS qui gère l'allocation mémoire et une pile pour un thread particulier.
Le mécanisme des threads a été rendu possible grâce à la technologie mulitâche des CPU d'Intel notamment avec l'apparition du "mode protégé"
Avec le mode protégé ily a des tables spéciales et des pointeurs ( je crois que c'est les descripteurs ) bref il faut voir la doc d'Intel

Non... Tu me parle de programmation alors que j'essaie de comprendre le fonctionnement interne d'un multicoeur....

un multicoeur ce n'est ni plus ni moins qu'un système à plusieurs CPU....
avant il y avait des cartes bi-processeurs mais maintenant cela n'existe plus ( sauf peut-être pour les sytèmes à base de CPU Xeon)
Les cartes bi-processeurs ont été abandonnées et Intel a eu l'idée de plutôt fusionner des CPU parce qu'en électronique tout le monde sait que plus le chemin entre les composants est court plus la transmission des électrons est rapide...
mais un multicoeur ce n'est pas forcément deux CPU distincts gravés sur le même waffer de silicium.

Pour ce qui est de savoir comment au niveau chipset:hardware on met des blocs de code sur un coeur et non l'autre c.a.d. l'ordonnancement du code il doit certainement exister ( je*suppose*) un contrôleur qui envoit le code soit sur l'un coeur ou l'autre.
Avec les systèmes bi-processeurs il y avait un contrôleur de CPU donc je suppose que sur un système multicoeur ce contrôleur est fusionné avec les coeurs

http://en.wikipedia.org/wiki/Multi-core_processor

[PyNub]

oui absolument ;le CPU ne connait que les mnemoniques x86 comme MOV EAX,valeur etc...LEA adresse,valeur...
Pour ce qui est du multitâche la notion de thread c'est exclusivement au niveau de l'OS qui gère l'allocation mémoire et une pile pour un thread particulier.
Le mécanisme des threads a été rendu possible grâce à la technologie mulitâche des CPU d'Intel notamment avec l'apparition du "mode protégé"
Avec le mode protégé ily a des tables spéciales et des pointeurs ( je crois que c'est les descripteurs ) bref il faut voir la doc d'Intel

Oui les descripteurs servent pour stocker les informations sur les segments notamment la base et la limite du segment. ils sont stockés en mémoire dans les (GDT et LDT) leur adresses sont données par les registre GDTR et LDTR repectivement. Le déplacement est donné par un sélecteur de segment qui est stocké (par l'OS) dans les registres CS et DS. Ceci-dit l'intérêt d'un thread est d'utiliser le même espace d'adressage...

[PyNub]

un multicoeur ce n'est ni plus ni moins qu'un système à plusieurs CPU....
avant il y avait des cartes bi-processeurs mais maintenant cela n'existe plus ( sauf peut-être pour les sytèmes à base de CPU Xeon)

Oui... il existe encore des trucs de ce genre

Les cartes bi-processeurs ont été abandonnées et Intel a eu l'idée de plutôt fusionner des CPU parce qu'en électronique tout le monde sait que plus le chemin entre les composants est court plus la transmission des électrons est rapide...
mais un multicoeur ce n'est pas forcément deux CPU distincts gravés sur le même waffer de silicium.

Oui il existe beaucoup d'architectures différentes ce qui complique la portabilité et la programmation. Il existe des système avec des coeurs dédié au calcul en virgule flottante (voir le Cell). Mais je pense que pour ce qui est des architectures X86 je commence vraiment à penser que l'ordonnancement se fait au niveau de l'OS le matériel ne fournit que les outils (comme pour la pagination)

Pour ce qui est de savoir comment au niveau chipset:hardware on met des blocs de code sur un coeur et non l'autre c.a.d. l'ordonnancement du code il doit certainement exister ( je*suppose*) un contrôleur qui envoit le code soit sur l'un coeur ou l'autre.
Avec les systèmes bi-processeurs il y avait un contrôleur de CPU donc je suppose que sur un système multicoeur ce contrôleur est fusionné avec les coeurs

Je crois que c'est un contrôleur d'interruptions...

The following sections describe the local APIC facilities that are provided for issuing
interprocessor interrupts (IPIs) from software. The primary local APIC facility for
issuing IPIs is the interrupt command register (ICR). Intel

[PyNub]

Je crois que c'est un contrôleur d'interruptions...

Evolué voir avancé il va sans dire...