FILS: threads du noyau vs threads pris en charge par le noyau vs threads de niveau utilisateur?

Quelqu'un sait-il quelle est la différence entre ceux-ci?

Il me semble que les threads du noyau correspondent au code qui exécute le noyau (intuitivement), mais je ne suis pas sûr des deux autres ...

De plus, la norme pthreads serait-elle considérée au niveau de l'utilisateur et prise en charge par le noyau, puisque vous accédez à une bibliothèque pendant que le noyau effectue toute la planification / commutation des threads?

multithreading

— Templier noir
source

Le terme «threads du noyau» peut être utilisé pour faire référence à des threads réels qui s'exécutent entièrement dans l'espace du noyau ou il peut faire référence à des threads de l'espace utilisateur planifiés par le noyau. Le terme threads "supportés par le noyau" désigne ces derniers, des threads qui s'exécutent dans l'espace utilisateur mais qui sont facilités par le noyau, ce qui signifie généralement que le noyau les planifie.

"Threads au niveau de l'utilisateur" signifie généralement des threads visibles dans l'espace utilisateur. C'est-à-dire ce que vous créez lorsque vous appelez la fonction "créer un fil" de votre norme de thread. Généralement, le terme «thread au niveau de l'utilisateur» est utilisé pour désigner un thread créé par le code d'application, quelle que soit la façon dont il est implémenté par le système. Il peut s'agir d'un thread d'espace utilisateur pur avec peu ou pas de prise en charge du noyau ou il peut s'agir d'un thread planifié par le noyau.

La norme pthreads peut être implémentée en tant que threads de l'espace utilisateur pur (où le noyau planifie le processus et le processus planifie les threads), threads pris en charge par le noyau (où le noyau planifie directement les threads), ou une approche hybride (où le noyau planifie un thread au niveau du noyau qui planifie ensuite, dans l'espace utilisateur, un thread au niveau de l'utilisateur). La norme n'exige aucun moyen particulier de mise en œuvre. L'implémentation la plus courante est le mappage 1 à 1 où chaque thread de niveau utilisateur a un thread correspondant qui est planifié par le noyau.

— David Schwartz
source

comment est l'implémentation sous Linux?

— yati sagade

Sur tous les systèmes Linux modernes (noyau 2.6 ou ultérieur) que je connais, l'implémentation de threading par défaut du système est de 1 à 1, chaque thread de niveau utilisateur a un KSE correspondant (entité de planification du noyau - en gros, un thread planifié par le Noyau Linux). Le thread que vous créez avec 'pthread_create' sera directement planifié par le noyau. Les systèmes modernes utilisent généralement NPTL , les anciens systèmes utilisent LinuxThreads - ils sont tous les deux 1 à 1.

— David Schwartz

"ou une approche hybride (où le noyau planifie un thread au niveau du noyau qui, ensuite, dans l'espace utilisateur, planifie un thread au niveau de l'utilisateur)." Hey David, pourriez-vous expliquer cela à nouveau? Je ne suis pas sûr de ce qui se passe ... Quand vous dites le mappage 1 à 1, faites-vous référence aux blocs de contrôle des threads lorsque vous mentionnez les threads au niveau du noyau?

— Dark Templar

Par 1 à 1, je veux dire que chaque fois que vous appelez 'pthread_create', un nouveau contexte est créé qui est planifié par le noyau. Dans une approche hybride , le nombre de contextes planifiés par le noyau est inférieur au nombre de threads créés - le noyau planifie l'un de ces contextes, puis la bibliothèque de threads planifie l'un des threads créés par l'application.

— David Schwartz