| 102 | | * C'est un ''thread switching overhead cosT'', ce qui signifie ''frais de commutation''. C'est le temps que le noyau met pour sélectionner un nouveau thread (avec l'ordonnanceur), sauver le contexte du thread entrant et charger le contexte du thread entrant. Nous n'avons pas plusieurs processus dans notre application, cet ''overhead'' est donc assez court car tout les threads partage le même espace d'adressage, mais quand il y a plusieurs processus, le coût de changement de thread de 2 processus distincts est beaucoup plus cher, car il faut vider (''flush'') les caches, nous en parlerons au prochain cours. |
| | 102 | * C'est un ''thread switching overhead cost'', ce qui signifie ''frais de commutation''. C'est le temps que le noyau met pour sélectionner un nouveau thread (avec l'ordonnanceur), sauver le contexte du thread entrant et charger le contexte du thread entrant. Nous n'avons pas plusieurs processus dans notre application, cet ''overhead'' est donc assez court car tout les threads partage le même espace d'adressage, mais quand il y a plusieurs processus, le coût de changement de thread de 2 processus distincts est beaucoup plus cher, car il faut vider (''flush'') les caches, nous en parlerons au prochain cours. |
| 108 | | * |
| 109 | | ''' |
| 110 | | }}} |
| 111 | | 1. Dans cette politique équitable, quelle est la fréquence type de changement de thread ? |
| 112 | | {{{#!protected ------------------------------------------------------------------ |
| 113 | | ''' |
| 114 | | * |
| | 108 | * C'est une politique ''round robin'' ou ''robin des bois'', ou à tour de rôle équitablement. Attention à ne pas la confondre avec la politique ''fifo'', dans cette dernière ce que l'ordonnanceur, c'est le prochain thread entrant sera celui qui est sorti depuis le plus longtemps, ou dit autrement, quand un processeur sort (perd le processeur), il sera le dernier à le regagner. Vous allez dire que c'est du ''round robin'', mais non, dans la politique ''fifo'', ce sont les threads eux-mêmes qui décident quand ils rendent le processeur, par un appel explicite à `thread_yield()` ou lorsqu'il demande une ressource indisponible. Il n'y a pas de recherche d'équité alors qu'avec la politique ''round robin'', le noyau utilise un timer pour que chaque thread dispose du même temps d'exécution en imposant des `thread_yield()`. |
| | 109 | ''' |
| | 110 | }}} |
| | 111 | 1. Dans cette politique équitable, quelle est la fréquence type de changement de thread ? Donnez une justification. |
| | 112 | {{{#!protected ------------------------------------------------------------------ |
| | 113 | ''' |
| | 114 | * Ça dépend un peu de la fréquence du processeur. Il faut que la commutation soit assez rapide pour donner l'illusion du parallélisme (l'impression que tout les threads s'exécutent en même temps), mais pas trop à cause de l'overhead de changement de thread. La réponse est entre 10 et 100Hz. Plus la fréquence du processeur est grande plus la fréquence de commutation peut être rapide. À 1Ghz, un processeur exécutent 10 millions de cycles en 10ms (100Hz), si l'overhead de changement de thread est de 1000 cycles (un ordre de grandeur), l'overhead prend 0.01% du temps d'exécution du processeur, c'est négligeable. |
| 120 | | * |
| 121 | | ''' |
| 122 | | }}} |
| 123 | | 1. Comment se nomme la perte du processeur par le thread en cours par un nouveau thread ? |
| 124 | | {{{#!protected ------------------------------------------------------------------ |
| 125 | | ''' |
| 126 | | * |
| | 120 | * L'ordonnanceur réalise : |
| | 121 | * l'élection du thread entrant qu'il choisit parmi tous les threads prêts en suivant une politique explicite. Pour le ''round robin'', l'élu sera celui qui attend depuis le plus longtemps. |
| | 122 | * La sauvegarde du contexte du thread sortant. |
| | 123 | * Le chargement du contexte du thread entrant. |
| | 124 | ''' |
| | 125 | }}} |
| | 126 | 1. Comment se nomme la fonction qui provoque la perte du processeur par le thread en cours au profit d'un nouveau thread ? |
| | 127 | {{{#!protected ------------------------------------------------------------------ |
| | 128 | ''' |
| | 129 | * C'est la fonction `thread_yield()`. `yield` signifie `cession`, le thread cède ou lâche le processeur. |
| 138 | | * |
| | 141 | * Alors non, il faut vraiment faire attention au vocabulaire. Le contexte d'un thread et le contexte d'une fonction sont deux concepts très différent. Cela signifie que la question ''Qu'est-ce qu'un contexte ?'' n'a pas une seule réponse et pour être précis, il faut demander ''contexte de quoi ?''. |
| | 142 | * Le contexte d'une fonction est un segment d'adresse dans la pile d'exécution, dans lequel la fonction |
| | 143 | * sauvegarde la valeur des registres persistants afin des restaurer avant de retourner dans la fonction appelante ; |
| | 144 | * alloue ses variables locales |
| | 145 | * alloue la place pour les arguments des fonctions qu'elle appelle. |
| | 146 | |
| | 147 | * Une fonction accède exclusivement à son propre contexte et à la partie des arguments du contexte de la fonction appelante. |
| | 148 | * |
