Threads dans l'espace utilisateur et le rendement

Question

Je suis censé implémenter une bibliothèque de threads userlevel en C. Pour ce faire, j'ai besoin de mettre en œuvre les fonctions yield(), createThread() et destroyThread(). Je crois que j'ai les bonnes bases:

Pour garder une trace de fils, je vais utiliser une file d'attente d'ThreadControlBlock éléments (qui ressemblent à PCBs dans un OS) qui ressemblent à ceci:

struct ThreadControlBlock { 
    int ThreadId, 
    u_context *context }; 

Nous peut utiliser la famille de fonctions setcontext() pour "sauvegarder" et "charger" le contexte. Lors de l'initialisation du programme, initialisez ThreadQueue sans éléments.

Maintenant, la partie que je ne reçois pas: quand un thread appelle yield(), j'obtiens le contexte actuel et l'enregistre dans un ThreadControlBlock et mettre dans la file d'attente. Ensuite, récupérez le premier élément dans la file d'attente et chargez le contexte, puis l'exécution se poursuit.

La question est, si je fais cela, dites que je suis un fil appelant yield() et le prochain fil est moi-même. Si je sauve le contexte et que je le charge à nouveau, je ne serais pas au même endroit où je me trouvais (avant d'appeler le yield()?) Et cela continuerait toujours?

Answer 1

Le même problème s'applique en fait si vous passez à une autre tâche, puisque cette autre tâche a enregistré son contexte au même point (où il était sur le point de passer à une seconde tâche). En utilisant setcontext() et getcontext(), vous devez utiliser une variable statique pour garder la trace si vous passez ou déconnectant:

static volatile int switched; 

switched = 0; 
getcontext(current->context); 
if (!switched) 
{ 
    switched = 1; 
    setcontext(next->context); 
} 

Alternativement, vous pouvez simplement utiliser swapcontext(current->context, next->context);

Answer 2

Il est parfaitement raisonnable dans votre implémentation yield() de vérifier si le thread suivant est le thread en cours et de traiter ce cas comme un no-op.

Answer 3

Lorsqu'un thread appelle yield(), vous devez enregistrer l'état d'un thread sur le point de revenir d'un appel yield(). Ne sauvegardez pas le contexte immédiatement avant le yield().

Answer 4

S'il n'y a pas d'autres threads à exécuter en dehors du thread actuel, il n'y a rien d'autre à faire que de revenir simplement du rendement. Je ne voudrais pas appeler swapcontext dans ce cas, cependant - juste détecter et retourner.

Je pense que ce que vous avez réellement à faire est ce qu'il faut faire quand aucun thread (y compris le courant) lorsque le rendement est appelé. Une façon simple de gérer cela est d'avoir un thread inactif, qui n'est exécuté que lorsque la file d'attente d'exécution (threads prêts) est vide. Ce fil sera probablement:

{ 
     while (1) { 
      yield(); 
      pause(); 
     } 
    } 

Cela permet à votre programme d'aller dormir (via pause) jusqu'à ce qu'un signal arrive. Espérons que le signal sera un événement qui rendra l'un des autres threads prêt à fonctionner, donc le prochain appel à yield lancera l'autre thread au lieu d'exécuter à nouveau le thread inactif.