Le programme ci-dessous<\/a> n’a d’int\u00e9r\u00eat que s’il y a une lutte pour le CPU entre T1 et T2, ce qui signifie qu’ils doivent s’ex\u00e9cuter sur le m\u00eame processeur (m\u00eame coeur).<\/p>\ntest-inversion.c<\/strong>\n#define _GNU_SOURCE \/\/ Pour sched_setaffinty\n#include\n#include\n#include\n#include\n#include\n#include \n\nstatic void * T1 (void * unused);\nstatic void * T2 (void * unused);\nstatic void * T3 (void * unused);\n\nstatic pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;\n\nint main(void)\n{\n cpu_set_t cpu_set;\n pthread_t t1, t2, t3;\n\n \/\/ Fixer l'execution sur un seul coeur\n CPU_ZERO(& cpu_set);\n CPU_SET(0, & cpu_set); \/\/ Coeur 0\n if (sched_setaffinity(0, sizeof(cpu_set), & cpu_set) != 0) {\n perror(\"sched_setaffinity\");\n exit(EXIT_FAILURE);\n }\n\n \/\/ Creer les trois threads\n if ((pthread_create(& t1, NULL, T1, NULL) != 0)\n || (pthread_create(& t2, NULL, T2, NULL) != 0)\n || (pthread_create(& t3, NULL, T3, NULL) != 0)) {\n fprintf(stderr, \"Erreur de creation des threads\");\n exit(EXIT_FAILURE);\n }\n \/\/ Terminer le thread main\n pthread_exit(NULL);\n}\n\n#define BOUCLE_1 50000\n#define BOUCLE_2 50000\n\nstatic void * T1 (void * unused)\n{\n int i;\n int j;\n struct sched_param param;\n\n fprintf(stderr, \"T1 : Creationn\");\n\n \/\/ passer en temps reel faible priorite\n param.sched_priority = 5;\n if (pthread_setschedparam(pthread_self(), SCHED_FIFO, & param) != 0) {\n perror(\"pthread_setschedparam\");\n exit(EXIT_FAILURE);\n }\n\n \/\/ verrouiller le mutex\n pthread_mutex_lock(& mutex);\n\n \/\/ travail actif\n fprintf(stderr, \"T1 : Debut bouclen\");\n for (i = 0; i < BOUCLE_1; i ++)\n for (j = 0; j < BOUCLE_2; j ++)\n ;\n fprintf(stderr, \"T1 : Fin Bouclen\");\n\n \/\/ liberer le mutex\n pthread_mutex_unlock(& mutex);\n return NULL;\n}\n\nstatic void * T2 (void * unused)\n{\n int i;\n int j;\n struct sched_param param;\n\n fprintf(stderr, \"T2 : Creationn\");\n\n \/\/ passer en temps reel moyenne priorite\n param.sched_priority = 15;\n if (pthread_setschedparam(pthread_self(), SCHED_FIFO, & param) != 0) {\n perror(\"pthread_setschedparam\");\n exit(EXIT_FAILURE);\n }\n \/\/ attendre deux secondes\n sleep(2);\n \/\/ travail actif\n fprintf(stderr, \"T2 : Debut bouclen\");\n for (i = 0; i < BOUCLE_1; i ++)\n for (j = 0; j < BOUCLE_2; j ++)\n ;\n fprintf(stderr, \"T2 : Fin bouclen\");\n return NULL;\n}\n\nstatic void * T3 (void * unused)\n{\n int i;\n int j;\n struct sched_param param;\n\n fprintf(stderr, \"T3 : Creationn\");\n\n \/\/ passer en temps reel haute priorite\n param.sched_priority = 45;\n if (pthread_setschedparam(pthread_self(), SCHED_FIFO, & param) != 0) {\n perror(\"pthread_setschedparam\");\n exit(EXIT_FAILURE);\n }\n \/\/ attendre une seconde\n sleep(1);\n \/\/ prendre le mutex\n pthread_mutex_lock(& mutex);\n \/\/ travail actif\n fprintf(stderr, \"T3 : Debut bouclen\");\n for (i = 0; i < BOUCLE_1; i ++)\n for (j = 0; j < BOUCLE_2; j ++)\n ;\n fprintf(stderr, \"T3 : Fin bouclen\");\n \/\/ liberer le mutex\n pthread_mutex_unlock(&mutex);\n\n return NULL;\n}<\/pre>\nPensez \u00e0 calibrer les valeurs de BOUCLE_1<\/code> et BOUCLE_2<\/code> pour que l’ex\u00e9cution du programme dure une dizaine de secondes. Voici un r\u00e9sultat d’ex\u00e9cution :<\/p>\n# cc test-inversion.c -o test-inversion -pthread -lrt -Wall<\/strong>\n# .\/test-inversion<\/strong>\nT3 : Creation\nT2 : Creation\nT1 : Creation\nT1 : Debut boucle\nT2 : Debut boucle\nT2 : Fin boucle\nT1 : Fin Boucle\nT3 : Debut boucle\nT3 : Fin boucle\n#<\/pre>\nNous voyons bien que le thread T2 s’ex\u00e9cute int\u00e9gralement avant que T3 puisse obtenir le mutex et commencer son travail. C’est un cas d’inversion de priorit\u00e9<\/p>\n
Un rem\u00e8de<\/h1>\n
Il existe un rem\u00e8de aux probl\u00e8mes d’inversions de priorit\u00e9s : le syst\u00e8me PIP<\/strong>. Toutefois pr\u00e9cisons tout de suite qu’il ne fonctionne pas dans tous les cas. Il permit de sauver le robot Pathfinder mais il existe d’autres situations dans lesquelles le rem\u00e8de est pire que le mal et l’on risque de voir les performances du syst\u00e8me s’effondrer.<\/p>\nPIP (priority inheritance protocol<\/em>) est un m\u00e9canisme reposant sur deux r\u00e8gles et sur une valeur de priorit\u00e9 appliqu\u00e9e \u00e0 chaque mutex (et \u00e9ventuellement \u00e0 toutes les ressources de synchronisation). Reprenons la situation d\u00e9crite plus haut, T1 est actif, T2 et T3 dorment. T1 verrouille le mutex. La premi\u00e8re r\u00e8gle de PIP s’applique alors :<\/p>\n\n- Premi\u00e8re r\u00e8gle<\/strong> : un mutex h\u00e9rite de la priorit\u00e9 la plus \u00e9lev\u00e9e parmi celles de tous les threads qui essayent de le verrouiller<\/li>\n<\/ul>\n
Le thread T1 s’ex\u00e9cutant avec la priorit\u00e9 P1, le mutex h\u00e9rite alors de cette valeur.<\/p>\n
Ensuite T3 se r\u00e9veille et demande \u00e0 son tour le mutex. La priorit\u00e9 de celui-ci monte alors \u00e0 la valeur P3. La seconde r\u00e8gle s’applique<\/p>\n
\n- Seconde r\u00e8gle<\/strong> : un thread s’ex\u00e9cute avec la priorit\u00e9 la plus \u00e9lev\u00e9e parmi celles de tous les mutex qu’il a verrouil\u00e9.<\/li>\n<\/ul>\n
Le thread T1 est alors propuls\u00e9 \u00e0 la priorit\u00e9 P3. Le thread T2 se r\u00e9veille, mais sa priorit\u00e9 \u00e9tant \u00e0 pr\u00e9sent inf\u00e9rieure \u00e0 celle de T1 il ne peut le pr\u00e9empter, et T1 va s’ex\u00e9cuter int\u00e9gralement, rel\u00e2cher le mutex, redrescendre alors \u00e0 la priorit\u00e9 P1. T3 pourra alors prendre le mutex et s’ex\u00e9cuter avant enfin de laisser passer T2.<\/p>\n
Dans le programme suivant<\/a>, j’ai ajout\u00e9 quelques lignes au d\u00e9but de la fonction main()<\/code>, qui activent le protocol PIP sur le mutex.<\/p>\ntest-pip.c<\/strong>\n[...]\nint main(void)\n{\n cpu_set_t cpu_set;\n pthread_t t1, t2, t3;\n\n pthread_mutexattr_t attr;\n pthread_mutexattr_init(& attr);\n pthread_mutexattr_setprotocol(& attr, PTHREAD_PRIO_INHERIT);\n pthread_mutex_init(& mutex, & attr);\n\n \/\/ Fixer l'execution sur un seul coeur\n [...]<\/pre>\nVoyons l'ex\u00e9cution avec PIP :\n# cc test-pip.c -o test-pip -pthread -lrt -Wall<\/strong>\n# .\/test-pip <\/strong>\nT3 : Creation\nT2 : Creation\nT1 : Creation\nT1 : Debut boucle\nT1 : Fin Boucle\nT3 : Debut boucle\nT3 : Fin boucle\nT2 : Debut boucle\nT2 : Fin boucle\n#<\/pre>\nCette fois, T3 a la possibilit\u00e9 de s’ex\u00e9cuter enti\u00e8rement avant que T2 d\u00e9marre. L’inversion de priorit\u00e9 est \u00e9vit\u00e9e.<\/p>\n
Conclusion<\/h1>\n
La vraie solution au probl\u00e8me d’inversion de priorit\u00e9 r\u00e9side dans la conception du syst\u00e8me temps-r\u00e9el. Il ne faut pas laisser de t\u00e2ches de priorit\u00e9s interm\u00e9diaires entre deux t\u00e2ches partageant des ressources communes. Naturellement ceci est tr\u00e8s contraignant et ne peut pas toujours \u00eatre respect\u00e9. PIP repr\u00e9sente un correctif plus qu’une v\u00e9ritable solution, mais il a le m\u00e9rite d’\u00eatre facilement activable sur les mutex Posix.<\/p>","protected":false},"excerpt":{"rendered":"
Dans les applications temps-réel il est très important d’éviter les situations dites « d’inversion de priorité ». Il s’agit de cas dans lesquels une tâche de haute priorité est bloquée en attente de la terminaison d’une tâche de plus faible priorité alors qu’elles n’ont rien en commun.<\/p>","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[8,14],"tags":[],"class_list":["post-1011","post","type-post","status-publish","format-standard","hentry","category-linux-2","category-temps-reel"],"_links":{"self":[{"href":"https:\/\/www.blaess.fr\/christophe\/wp-json\/wp\/v2\/posts\/1011","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.blaess.fr\/christophe\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.blaess.fr\/christophe\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.blaess.fr\/christophe\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.blaess.fr\/christophe\/wp-json\/wp\/v2\/comments?post=1011"}],"version-history":[{"count":0,"href":"https:\/\/www.blaess.fr\/christophe\/wp-json\/wp\/v2\/posts\/1011\/revisions"}],"wp:attachment":[{"href":"https:\/\/www.blaess.fr\/christophe\/wp-json\/wp\/v2\/media?parent=1011"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.blaess.fr\/christophe\/wp-json\/wp\/v2\/categories?post=1011"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.blaess.fr\/christophe\/wp-json\/wp\/v2\/tags?post=1011"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}