Planification des threads sous Unix

Dans la politique de planification RR, que se passe-t-il si un thread de faible priorité verrouille un mutex et est supprimé par le planificateur car un autre thread de haute priorité est en attente?

Va-t-il également libérer le verrou contenu par un thread de faible priorité?

Par exemple, considérez 3 threads en cours d’exécution dans un processus avec les priorités 10,20 et 30 dans la stratégie de planification RR.

Maintenant, à un moment donné, le thread de basse priorité 1 verrouille le mutex et continue d’exécuter la moyenne alors que le thread de priorité élevée apparaît et attend également le mutex tenu par le thread 1. Maintenant, le thread 2 entre dans l’image qui nécessite également le même mutex verrouillé par fil 1.

Autant que je sache, selon l’algorithme de planification, les threads en veille ou en attente de mutex, sémaphore, etc. sont supprimés et les autres, même peu prioritaires, sont autorisés à s’exécuter. Est-ce correct? Si tel est le cas, dans l’exemple ci-dessus, les threads de haute priorité attendent finalement l’achèvement d’un thread de faible priorité qui n’a aucun sens. Est-ce comme ça que le système fonctionne si à tous les threads sont conçus comme je l’ai dit ci-dessus?

ou la priorité du thread devrait être définie de telle manière que les priorités les plus élevées ne dépendront pas des mutexe de faible priorité?

Quelqu’un peut-il aussi m’expliquer comment la planification fonctionne au niveau du processus? Comment définissons-nous la priorité d’un processus?

En règle générale, la planification et les verrous ne sont liés dans aucun autre aspect qu’un “thread en attente n’est pas planifié jusqu’à ce qu’il ait fini d’attendre”. Il serait plutôt idiot d’avoir un MUTEX qui “empêche les autres threads d’accéder à mes données” mais cela ne fonctionne que si l’autre thread a la même priorité ou moins que le thread actuel.

Le phénomène de “priorité faible contient un verrou dont un thread de haute priorité” a besoin “est appelé inversion de priorité, et c’est un scénario bien connu en théorie informatique.

Certains schémas «augmentent temporairement la priorité d’un thread de locking jusqu’à ce qu’il libère le verrou à la plus haute priorité des threads en attente» (ou la priorité du premier thread en attente s’il est plus élevé que le thread en cours, ou une autre variante) sur ce thème). Ceci est fait pour combattre l’inversion de priorité – mais il a aussi d’autres inconvénients, de sorte qu’il n’est pas implémenté dans tous les OS / ordonnanceurs (après tout, cela affecte d’autres threads que celui qui attend aussi).

Modifier:

Le point d’un mutex (ou d’autres verrous similaires) est qu’il empêche deux threads d’accéder aux mêmes ressources à la fois. Par exemple, disons que nous voulons mettre à jour cinq variables différentes avec un traitement assez long (calculs compliqués, extraction de données depuis un port série ou un lecteur réseau, etc.), mais si nous ne faisons que deux variables, un autre processus utilisant ceux-ci obtiendraient un résultat invalide, alors nous ne pouvons clairement pas “lâcher” la serrure.

Le thread de haute priorité doit simplement attendre que les cinq variables soient mises à jour et le verrou de faible priorité.

Il n’existe pas de solution de contournement simple que l’application peut résoudre pour résoudre ce problème – ne gardez pas les verrous plus que nécessaire bien sûr [et il se peut que nous puissions résoudre le problème décrit ci-dessus en effectuant le traitement long le verrou, et ne font que le “stocker dans les 5 variables” avec le verrou activé. Cela réduirait le temps d’attente que le thread de priorité élevée doit attendre, mais si le système est vraiment occupé, il ne résoudra pas vraiment le problème.

Il y a toute une thèse de doctorat écrite sur ce sujet, et je ne suis pas un spécialiste sur “comment écrire un ordonnanceur” – j’ai une idée juste de comment on fonctionne, tout comme je sais comment fonctionne le moteur de ma voiture – m’a donné un tas de formes de base appropriées d’acier et d’aluminium, et les outils / espace de travail requirejs et m’a dit de construire un moteur, je doute que cela fonctionnerait très bien … Idem avec un programmateur – je sais ce que les pièces sont appelées, mais pas comment en construire un.

Si un thread de haute priorité doit attendre sur un thread de faible priorité (sémaphore de mutex, etc.), le thread de faible priorité est temporairement élevé à la même priorité que le thread de haute priorité.

Le thread haute priorité ne va pas avoir le verrou pour lequel il demande jusqu’à ce que le thread de priorité basse le déverrouille.

Pour éviter cela, nous pouvons utiliser un sémaphore où tout autre thread peut se lancer pour déverrouiller, mais ce n’est pas possible dans mutex.