Comment contrôler sur quel noyau un processus s'exécute?

Question

Je peux comprendre comment on peut écrire un programme qui utilise plusieurs threads ou processus: fork() un nouveau processus et d'utilisation de la CIB, ou créer plusieurs threads et l'utilisation de ces sortes de mécanismes de communication.

Je comprends aussi que le changement de contexte. Qui est, avec seulement une fois que le CPU, le système d'exploitation horaires de temps pour chaque processus (et il y a des tonnes d'algorithmes de planification de là) et donc nous parvenir à l'exécution de plusieurs processus simultanément.

Et maintenant que nous avons processeurs multi-core (ou multi-processeurs des ordinateurs), nous pourrions avoir deux processus en cours d'exécution simultanément dans les deux noyaux.

Ma question est sur le dernier scénario: comment le noyau de contrôle de la base d'un processus s'exécute sur? Qui appels système (Linux, ou même Windows) planifier un processus sur une base spécifique?

La raison pour laquelle je suis en demandant: "je travaille sur un projet pour l'école où nous en sommes pour explorer un sujet récent dans l'informatique et j'ai choisi architectures multicœurs. Il semble y avoir beaucoup de matériel sur la façon de programmer ce genre d'environnement (comment regarder des blocages ou des conditions de course) mais pas beaucoup sur le contrôle de l'individu cœurs eux-mêmes. J'aimerais être capable d'écrire quelques programmes de démonstration et de présenter certains des instructions de montage ou de code C à l'effet de "Voir, je suis en cours d'exécution d'une boucle infinie sur le 2e core, regarder le pic de l'utilisation du PROCESSEUR pour que de base".

Tous les exemples de code? Ou des tutoriels?

edit: Pour clarifier - beaucoup de gens ont dit que c'est le but de l'OS, et que l'on doit laisser l'OS en prendre soin. Je suis complètement d'accord! Mais alors ce que je demande (ou d'essayer d'obtenir une sensation pour) est ce que le système d'exploitation ne fait pour cela. Pas l'algorithme de planification, mais en plus "une fois un coeur est choisi, ce que les instructions doivent être exécutées pour avoir que le noyau de commencer l'extraction des instructions?"

Answer 1

Comme d'autres l'ont mentionné, l'affinité du processeur est spécifique du Système d'Exploitation. Si vous voulez le faire hors des limites du système d'exploitation, vous êtes dans un beaucoup de plaisir, et j'entends par là que la douleur.

Cela dit, d'autres l'ont mentionné SetProcessAffinityMask pour Win32. Personne n'a mentionné le noyau Linux façon de définir l'affinité du processeur, et donc je ne. Vous devez utiliser l' sched_set_affinity fonction. Voici un bon tutoriel sur comment.

Answer 2

Normalement, la décision sur base d'une application fonctionnera sur est faite par le système. Toutefois, vous pouvez définir le "affinité" pour une application à une base spécifique à dire le système d'exploitation pour exécuter l'application sur le cœur. Normalement, ce n'est pas une bonne idée, mais il existe quelques rares cas où il pourrait faire sens.

Pour ce faire, dans windows, utilisez le gestionnaire des tâches, clic droit sur le processus, et choisissez "Définir l'Affinité". Vous pouvez le faire par programme dans Windows à l'aide de fonctions comme SetThreadAffinityMask, SetProcessAffinityMask ou SetThreadIdealProcessor.

ETA:

Si vous êtes intéressé par la façon dont le système d'exploitation ne fait que de la programmation, vous pouvez consulter ces liens:

Article de wikipédia sur la commutation de contexte

Article de wikipédia sur la planification de la

L'ordonnancement dans le noyau linux

Avec plus modernes OS, le système d'exploitation prévoit un thread à exécuter sur une base pour une courte tranche de temps. Lorsque la tranche de temps expire, ou le fil ne se déroule une opération e / s qui provoque volontairement de rendement de la base, le système d'exploitation programmer un autre thread à exécuter sur la base (s'il y a des threads prêts à exécuter). Exactement le thread qui est prévue dépendent du système d'exploitation de l'algorithme d'ordonnancement.

Les détails de mise en œuvre de exactement comment le changement de contexte sont CPU & OS dépendante. Généralement, il impliquera un commutateur de mode noyau, le système d'exploitation enregistrement de l'état du thread précédent, le chargement de l'état du nouveau thread, puis en passant en mode utilisateur et en reprenant le nouvellement chargée fil. La commutation de contexte de l'article j'ai lié ci-dessus a un peu plus de détails à ce sujet.

Answer 3

Rien n'indique de base "maintenant commencer l'exécution de ce processus".

Le noyau ne voit pas le processus, il connait le code exécutable et les différents niveaux de fonctionnement et les limites associées à des instructions qui peuvent être exécutées.

Lorsque l'ordinateur démarre, par souci de simplicité, un seul core/processeur est actif et fonctionne en fait de n'importe quel code. Ensuite, si l'OS est Multiprocesseur capable, il active d'autres cœurs avec un système spécifique d'instructions, d'autres cœurs les plus susceptibles de ramasser exactement même endroit que les autres et exécuter à partir de là.

Donc, ce que le planificateur n'est il regarde à travers les OS, les structures internes (tâche/processus/thread file d'attente) et en choisit un et le marque comme à son cœur. Puis d'autres instances de planificateur en cours d'exécution sur les autres noyaux de ne pas la toucher jusqu'à ce que la tâche est dans l'état d'attente (et non marqués comme épinglé à la base). Après la tâche est marquée comme étant en cours d'exécution, le planificateur s'exécute passer à un système de base de la tâche de reprendre au point où il était suspendue.

Techniquement, il n'en est rien, que ce soit l'arrêt de cœurs d'exécuter exactement le même code à exactement le même temps (et beaucoup d'déverrouillé fonctions de le faire), mais à moins que le code est écrit de s'attendre à ce que, il sera probablement pisse tous dessus lui-même.

Scénario va encore plus bizarre, avec plus exotiques modèles de mémoire (ci-dessus suppose que "d'habitude" linéaire simple espace mémoire de travail) où les cœurs n'ont pas nécessairement tous voir la même mémoire et il peut y avoir des exigences sur l'extraction de code de base de griffes, mais il est beaucoup plus facile traitées en gardant simplement la tâche épinglé à noyau (autant que je sache, la PS3 de Sony architecture avec SPU est comme ça).

Answer 4

Le OpenMPI projet a une bibliothèque pour définir l'affinité du processeur sur Linux de façon portable.

Certains tandis que l'arrière, j'ai utilisé ce dans un projet et il a bien fonctionné.

Mise en garde: j'ai le vague souvenir qu'il y avait quelques problèmes à trouver comment le système d'exploitation numéros de la carottes de. J'ai utilisé ce dans un 2 Xeon système CPU avec 4 cœurs de chacun.

Un coup d'oeil à l' cat /proc/cpuinfo pourrait aider. Sur la boîte, j'ai utilisé, c'est assez bizarre. Bouilli vers le bas la sortie est à la fin.

De toute évidence, la uniformément conducteurs numérotés sont sur le premier processeur et la bizarrement conducteurs numérotés sur le deuxième processeur. Cependant, si je me souviens bien, il y a un problème avec les caches. Sur ces processeurs Intel Xeon, deux cœurs sur chaque CPU partager leurs caches L2 (je ne me souviens pas si le processeur a un cache L3). Je pense que les processeurs virtuels 0 et 2 partagent une mémoire cache L2, 1 et 3 partagent une, 4 et 6 avaient l'un et de 5 et 7 partagée.

En raison de cette étrangeté (1.5 ans en arrière, je ne pouvais pas trouver toute la documentation sur le processus de numérotation sous Linux), je serais prudent de faire ce genre de bas niveau de réglage. Cependant, il n'y a clairement certaines utilisations. Si votre code s'exécute sur quelques types de machines alors il pourrait être utile de faire ce genre de réglage. Une autre application serait dans certains domaines spécifiques de la langue comme StreamIt où le compilateur pourrait faire ce sale travail et de calculer une smart annexe.

processor       : 0
physical id     : 0
siblings        : 4
core id         : 0
cpu cores       : 4

processor       : 1
physical id     : 1
siblings        : 4
core id         : 0
cpu cores       : 4

processor       : 2
physical id     : 0
siblings        : 4
core id         : 1
cpu cores       : 4

processor       : 3
physical id     : 1
siblings        : 4
core id         : 1
cpu cores       : 4

processor       : 4
physical id     : 0
siblings        : 4
core id         : 2
cpu cores       : 4

processor       : 5
physical id     : 1
siblings        : 4
core id         : 2
cpu cores       : 4

processor       : 6
physical id     : 0
siblings        : 4
core id         : 3
cpu cores       : 4

processor       : 7
physical id     : 1
siblings        : 4
core id         : 3
cpu cores       : 4

Answer 5

Comme d'autres l'ont mentionné, il est contrôlé par le système d'exploitation. Selon le système d'exploitation, il peut ou peut ne pas vous donner des appels système qui vous permettent d'influer sur la base d'un processus s'exécute sur. Cependant, vous devez généralement laisser les OS ne le comportement par défaut. Si vous avez un 4-core system avec 37 processus en cours d'exécution, et 34 de ces processus sont à dormir, il va planifier les 3 autres processus actifs sur différents noyaux.

Vous aurez probablement seulement voir un boost de vitesse sur jouer avec le cœur des affinités très spécialisés pour des applications multithread. Par exemple, supposons que vous avez un système avec 2 processeurs double-cœur. Supposons que vous avez une application avec 3 fils, et deux de threads fonctionnent lourdement sur le même jeu de données, alors que le troisième thread utilise un ensemble de données différent. Dans ce cas, vous pourriez bénéficier le plus de par le fait d'avoir les deux fils qui interagissent sur le même processeur et la troisième fil sur l'autre processeur, depuis lors, ils peuvent partager un cache. L'OS n'a aucune idée de ce que la mémoire de chaque thread doit accéder, de sorte qu'il ne peut pas allouer des threads noyaux de façon appropriée.

Si vous êtes intéressé à la façon dont le système d'exploitation, de lire sur la planification. Les détails concrets de multitraitement sur x86 peuvent être trouvés dans la Intel ® 64 et IA-32 Architectures Développeur de Logiciels les Manuels d'utilisation. Le Volume 3A, Chapitres 7 et 8 contiennent des informations pertinentes, mais gardez à l'esprit ces manuels sont extrêmement techniques.