{ "chapter": { "id": "processus-systeme", "level": "terminale", "theme": "Architectures", "title": "Processus et système", "description": "Approfondissement de la gestion des processus par\nun système d'exploitation : notion de processus,\nétats, ordonnancement, communication entre\nprocessus, synchronisation par verrous, risque\nd'interblocage et notion de signal. Composants\nintégrés d'un système sur puce et avantages de\nleur intégration en vitesse et en consommation.", "parties": [ { "id": "processus", "title": "Processus et états" }, { "id": "ordonnancement", "title": "Ordonnancement" }, { "id": "interblocage", "title": "Interblocage et verrous" }, { "id": "soc", "title": "Systèmes sur puce" } ], "prerequisites": [], "references": [] }, "questions": [ { "id": "q01", "difficulty": 1, "skills": [ "processus" ], "title": "Notion de processus", "partie": "processus", "statement": "Qu'est-ce qu'un **processus** ?", "options": [ { "text": "Le fichier exécutable rangé sur le disque, tel qu'il existe avant son lancement", "correct": false, "feedback": "Cette description correspond plutôt\nà un **programme** au sens du\nfichier exécutable. Un processus\nest, lui, dynamique : il représente\nun programme **en cours d'exécution**.\n" }, { "text": "Un programme en cours d'exécution, avec sa mémoire et son contexte propres", "correct": true, "feedback": "C'est une abstraction centrale du\nsystème d'exploitation. Un même\nprogramme lancé deux fois donne\ndeux processus indépendants, qui\ndisposent chacun de leur propre\nmémoire et de leur propre contexte\nd'exécution.\n" }, { "text": "Une zone particulière de la mémoire vive réservée par le noyau", "correct": false, "feedback": "Un processus utilise de la mémoire\n(sa zone de mémoire), mais il\nn'est pas lui-même un type de\nmémoire.\n" }, { "text": "Une fonction particulière définie à l'intérieur d'un programme", "correct": false, "feedback": "Une fonction n'est qu'un fragment\nde code à l'intérieur d'un\nprogramme. Un processus est une\nnotion bien plus large, qui\nenglobe l'intégralité d'un\nprogramme en exécution.\n" } ], "explanation": "Il faut bien distinguer la notion de\n**programme** (un fichier exécutable\nsur le disque) et celle de **processus**\n(une instance dynamique de ce programme\nen cours d'exécution). Sous Linux, les\ncommandes `ps` ou `top` permettent\nd'observer les processus actifs ; sous\nWindows, on utilise le Gestionnaire des\ntâches." }, { "id": "q02", "difficulty": 1, "skills": [ "ordonnancement", "multitache" ], "title": "Impression de simultanéité sur un seul cœur", "partie": "ordonnancement", "statement": "Sur un ordinateur dont le processeur n'a qu'**un seul cœur**, un élève écoute de la musique tout en tapant un texte : les deux programmes semblent s'exécuter en même temps. Comment est-ce possible ?", "options": [ { "text": "Le cœur exécute les deux programmes exactement au même instant", "correct": false, "feedback": "Erreur : un cœur n'exécute qu'une instruction à la fois, donc un seul processus à un instant donné. La simultanéité n'est ici qu'apparente.\n" }, { "text": "L'ordonnanceur alterne très rapidement entre les deux processus", "correct": true, "feedback": "Bonne réponse : l'ordonnanceur donne le processeur à chaque processus pendant une très courte durée, puis passe à un autre. Ces alternances, des centaines de fois par seconde, sont imperceptibles pour l'utilisateur.\n" }, { "text": "Le système fusionne les deux programmes en un seul processus", "correct": false, "feedback": "Erreur : chaque programme lancé donne son propre processus, avec son propre PID. Le système ne mélange pas deux programmes en un seul.\n" }, { "text": "La carte son exécute le lecteur de musique à la place du processeur", "correct": false, "feedback": "Erreur : la carte son se contente de transformer les données reçues en signal sonore. Le programme de lecture, lui, est bien exécuté par le processeur.\n" } ], "explanation": "Sur un seul cœur, un seul processus est élu à chaque instant. L'ordonnanceur du système d'exploitation fait alterner les processus prêts en leur attribuant tour à tour le processeur pendant de très courtes durées, ce qui donne l'illusion d'une exécution simultanée." }, { "id": "q03", "difficulty": 1, "skills": [ "pid" ], "title": "Identifiant de processus", "partie": "processus", "statement": "Que désigne le **PID** d'un processus ?", "options": [ { "text": "Un module interne du noyau spécialement chargé de créer et de gérer les processus", "correct": false, "feedback": "Cette interprétation est\nfantaisiste. Le sigle PID désigne\nsimplement un identifiant\nnumérique unique attribué par le\nsystème.\n" }, { "text": "Un numéro unique attribué par le système à chaque processus pour l'identifier", "correct": true, "feedback": "Le PID, pour *Process IDentifier*,\npermet d'identifier les processus\nde manière unique. On l'utilise\npar exemple avec la commande\n`kill `. Sur les systèmes\nUnix, le numéro $1$ est\ntraditionnellement attribué au\nprocessus de démarrage.\n" }, { "text": "Le descripteur des permissions et des droits d'accès d'un processus", "correct": false, "feedback": "Les permissions et le PID sont des\nnotions distinctes. Le PID\nidentifie un processus ; les\npermissions définissent ce que ce\nprocessus peut faire.\n" }, { "text": "Un nom de domaine personnel réservé sur Internet", "correct": false, "feedback": "Aucun rapport avec les domaines\nInternet. Le PID est un numéro\ninterne au système d'exploitation.\n" } ], "explanation": "Sur les systèmes Unix, la commande `ps` affiche les processus en cours avec leur PID, et la commande `kill ` demande au système de terminer le processus désigné par ce numéro." }, { "id": "q04", "difficulty": 1, "skills": [ "etat-processus" ], "title": "États d'un processus", "partie": "processus", "statement": "Quels sont les **états principaux** par\nlesquels passe un processus au cours de\nsa vie ?", "options": [ { "text": "Démarré, en exécution et terminé, sans état d'attente intermédiaire", "correct": false, "feedback": "Ces états ne suffisent pas à\ndécrire le cycle de vie d'un\nprocessus : il manque l'état\n**bloqué**, où le processus attend\nune ressource ou une entrée-sortie.\n" }, { "text": "Compilé, chargé en mémoire, puis exécuté par le processeur", "correct": false, "feedback": "Ce sont les étapes de fabrication\net de chargement d'un programme,\npas les états d'ordonnancement d'un\nprocessus en cours de vie.\n" }, { "text": "Prêt, en exécution, bloqué en attente d'une ressource, puis terminé", "correct": true, "feedback": "C'est le modèle classique en\nsystème d'exploitation.\nL'ordonnanceur gère les\ntransitions entre l'état « prêt »\net l'état « en exécution ».\nL'état « bloqué » correspond à\nl'attente d'une ressource (un\nfichier, le réseau, un verrou).\n" }, { "text": "Ouvert, modifié, puis enregistré et fermé par l'utilisateur du logiciel", "correct": false, "feedback": "Ce sont les états d'un **fichier**\nque l'on édite, pas ceux d'un\nprocessus géré par l'ordonnanceur.\n" } ], "explanation": "Sous Linux, la commande `ps -aux`\naffiche l'état de chaque processus :\n`R` pour *running* (prêt ou en\nexécution), `S` pour *sleeping* (bloqué\nen attente d'un événement), `D` pour\n*disk wait* (bloqué en attente\nd'entrée-sortie disque)." }, { "id": "q05", "difficulty": 1, "skills": [ "ordonnanceur" ], "title": "Ordonnanceur", "partie": "ordonnancement", "statement": "Quel composant choisit **quel processus**\nreçoit le processeur à chaque instant ?", "options": [ { "text": "L'interpréteur de commandes, qui lance les programmes depuis le terminal", "correct": false, "feedback": "L'interpréteur de commandes sert\nà lancer des programmes, mais ce\nn'est pas lui qui décide à quel\nmoment chaque processus reçoit le\nprocesseur.\n" }, { "text": "Le pilote du processeur, qui dialogue avec le matériel", "correct": false, "feedback": "Un pilote est un module qui\npermet au système de communiquer\navec un périphérique matériel\n(carte réseau, imprimante, etc.).\nCe n'est pas son rôle de choisir\nquel processus s'exécute.\n" }, { "text": "L'utilisateur, qui fixe l'ordre d'exécution à chaque instant", "correct": false, "feedback": "L'utilisateur peut influencer\nindirectement l'ordonnancement\n(en modifiant la priorité d'un\nprocessus, par exemple), mais il\nne décide pas à chaque instant\nquel processus reçoit le\nprocesseur.\n" }, { "text": "L'ordonnanceur, un composant du noyau du système", "correct": true, "feedback": "L'ordonnanceur décide selon plusieurs critères : la priorité du processus, l'équité entre les processus, le temps d'attente de chacun.\n" } ], "explanation": "Plusieurs stratégies d'ordonnancement\nexistent : le tour de rôle, la\npriorité statique ou dynamique, ou\nencore l'ordonnancement fondé sur la\nlatence. Pour les systèmes\nd'exploitation à contraintes temps\nréel, il faut des garanties strictes\nsur les délais d'exécution." }, { "id": "q06", "difficulty": 1, "skills": [ "multicoeur", "etats" ], "title": "Processus élus sur un processeur à quatre cœurs", "partie": "processus", "statement": "Une machine possède un processeur à **quatre cœurs**. Dix processus y sont en cours, et aucun n'est bloqué. Combien de ces processus peuvent, au plus, être dans l'état **élu** au même instant ?", "options": [ { "text": "$1$", "correct": false, "feedback": "Erreur : un seul processus élu à la fois, c'est le cas d'un processeur à un seul cœur. Ici chacun des quatre cœurs peut exécuter un processus.\n" }, { "text": "$4$", "correct": true, "feedback": "Bonne réponse : chaque cœur exécute un processus à la fois, donc au plus quatre processus sont élus simultanément. Les six autres sont prêts et attendent leur tour.\n" }, { "text": "$6$", "correct": false, "feedback": "Erreur : $6$ est le nombre de processus qui restent en attente lorsque les quatre cœurs sont occupés. Ces processus-là sont prêts, pas élus.\n" }, { "text": "$10$", "correct": false, "feedback": "Erreur : pour que les dix processus soient élus en même temps, il faudrait dix cœurs. Avec quatre cœurs, l'ordonnanceur fait alterner les dix processus.\n" } ], "explanation": "Un processus élu est un processus qui dispose d'un cœur du processeur. Le nombre de processus élus simultanément est donc limité par le nombre de cœurs ; les autres processus non bloqués sont prêts et attendent que l'ordonnanceur les élise." }, { "id": "q07", "difficulty": 1, "skills": [ "creation-processus", "systeme" ], "title": "Lancement d'un programme enregistré", "partie": "processus", "statement": "Un utilisateur lance un programme enregistré sur le disque de son ordinateur. Que fait alors le système d'exploitation ?", "options": [ { "text": "Il exécute le programme directement sur le disque, sans le copier", "correct": false, "feedback": "Erreur : le processeur n'exécute pas les instructions depuis le disque, beaucoup trop lent. Le programme est d'abord chargé en mémoire vive.\n" }, { "text": "Il charge le programme en mémoire vive et crée un processus pour l'exécuter", "correct": true, "feedback": "Bonne réponse : le système copie le programme depuis la mémoire de masse vers la mémoire vive, puis crée un processus, doté d'un PID, que l'ordonnanceur pourra élire.\n" }, { "text": "Il transforme le fichier en processus, qui disparaît alors du disque", "correct": false, "feedback": "Erreur : le fichier reste intact sur le disque. On peut d'ailleurs lancer le même programme plusieurs fois, ce qui crée plusieurs processus.\n" }, { "text": "Il attend que l'utilisateur attribue un numéro de PID au programme", "correct": false, "feedback": "Erreur : le PID est attribué automatiquement par le système au moment de la création du processus ; l'utilisateur n'a pas à le choisir.\n" } ], "explanation": "Un programme est un fichier stocké en mémoire de masse. Pour l'exécuter, le système d'exploitation le charge en mémoire vive et crée un processus, identifié par un PID, qui entre dans l'état prêt en attendant d'être élu par l'ordonnanceur." }, { "id": "q08", "difficulty": 1, "skills": [ "top", "observation" ], "title": "Suivre les processus en direct", "partie": "processus", "statement": "Un élève veut surveiller en direct, avec un affichage rafraîchi toutes les quelques secondes, les processus qui consomment le plus de temps processeur sur sa machine Linux. Quelle commande utiliser ?", "options": [ { "text": "`ps`", "correct": false, "feedback": "Erreur : `ps` affiche bien la liste des processus, mais une seule fois, au moment où on la lance. Pour suivre l'évolution, il faudrait la relancer sans cesse.\n" }, { "text": "`kill`", "correct": false, "feedback": "Erreur : `kill` n'affiche rien, elle demande l'arrêt d'un processus désigné par son PID.\n" }, { "text": "`ls`", "correct": false, "feedback": "Erreur : `ls` liste les fichiers d'un répertoire, pas les processus en cours d'exécution.\n" }, { "text": "`top`", "correct": true, "feedback": "Bonne réponse : `top` affiche les processus en cours et met la liste à jour régulièrement, en classant par défaut les processus selon leur consommation de processeur.\n" } ], "explanation": "`ps` donne une photographie des processus à un instant donné, tandis que `top` en donne un suivi continu. Sous Windows, le gestionnaire des tâches joue un rôle comparable." }, { "id": "q09", "difficulty": 1, "skills": [ "exemple-processus" ], "title": "Lister les processus", "partie": "processus", "statement": "Quelle commande Unix affiche la **liste des processus** en cours d'exécution ?", "options": [ { "text": "`ps`, ou `top` pour un suivi en temps réel", "correct": true, "feedback": "On utilise par exemple `ps aux`\nou `ps -ef` pour obtenir la\nliste complète des processus.\nPour un suivi interactif et\ndynamique, on emploie plutôt\n`top` ou `htop`.\n" }, { "text": "`ls`, qui liste le contenu d'un répertoire", "correct": false, "feedback": "La commande `ls` sert à lister\nle contenu d'un répertoire,\nc'est-à-dire les fichiers, pas\nles processus.\n" }, { "text": "`cat`, qui affiche le contenu d'un fichier", "correct": false, "feedback": "La commande `cat` sert à\nafficher le contenu d'un\nfichier, et n'a aucun rapport\navec la liste des processus.\n" }, { "text": "`grep`, qui recherche un motif dans un texte", "correct": false, "feedback": "La commande `grep` sert à\nrechercher un motif dans un\ntexte, mais pas à lister les\nprocessus en cours.\n" } ], "explanation": "Sous Windows, on peut utiliser le\nGestionnaire des tâches\n(`taskmgr.exe`) ou la commande\nPowerShell `Get-Process`. Quel\nque soit le système d'exploitation,\nla liste des processus est\nmaintenue par le noyau." }, { "id": "q10", "difficulty": 1, "skills": [ "etats", "bloque" ], "title": "Fin d'une lecture sur disque", "partie": "processus", "statement": "Un processus est dans l'état **bloqué** : il attend la fin d'une lecture sur disque. La lecture se termine. Dans quel état passe alors ce processus ?", "options": [ { "text": "Il passe directement à l'état élu", "correct": false, "feedback": "Erreur : le processeur est peut-être occupé par un autre processus. C'est l'ordonnanceur qui décidera quand l'élire ; en attendant, il est prêt.\n" }, { "text": "Il passe à l'état prêt", "correct": true, "feedback": "Bonne réponse : l'événement attendu est arrivé, le processus peut de nouveau avancer. Il rejoint les processus prêts et attend que l'ordonnanceur lui attribue le processeur.\n" }, { "text": "Il est terminé et quitte la mémoire", "correct": false, "feedback": "Erreur : la lecture n'était qu'une étape du travail du processus. Il a encore des instructions à exécuter, par exemple traiter les données lues.\n" }, { "text": "Il reste bloqué jusqu'à ce que l'utilisateur le relance", "correct": false, "feedback": "Erreur : le système sait que l'événement attendu s'est produit et débloque lui-même le processus, sans intervention de l'utilisateur.\n" } ], "explanation": "Un processus bloqué ne revient jamais directement à l'état élu. La fin de l'attente le fait passer à l'état prêt, et seul l'ordonnanceur peut ensuite le faire passer de prêt à élu." }, { "id": "q11", "difficulty": 2, "skills": [ "interblocage", "debranche" ], "title": "Le carrefour bloqué", "partie": "interblocage", "statement": "Quatre voitures arrivent en même temps, une par route, à un carrefour sans feux où chacune doit laisser passer la voiture venant de sa droite. Chaque voiture attend donc celle qui est à sa droite, et aucune ne démarre. Quelle situation entre processus ce blocage illustre-t-il ?", "options": [ { "text": "Un ordonnancement à tour de rôle entre quatre processus", "correct": false, "feedback": "Erreur : dans un ordonnancement à tour de rôle, chaque processus avance à son tour. Ici aucune voiture ne passe jamais, personne n'avance.\n" }, { "text": "Un interblocage entre processus qui s'attendent en cycle", "correct": true, "feedback": "Bonne réponse : chaque voiture occupe sa place et attend que la suivante libère le passage, et la chaîne des attentes revient à son point de départ. Comme dans un interblocage, aucune ne peut avancer sans intervention extérieure.\n" }, { "text": "Un processus bloqué qui attend la fin d'une lecture sur disque", "correct": false, "feedback": "Erreur : un processus en attente d'une lecture repart seul quand la lecture se termine. Ici les voitures s'attendent les unes les autres, et rien ne viendra les débloquer.\n" }, { "text": "Un processeur trop lent pour traiter quatre processus", "correct": false, "feedback": "Erreur : un processeur lent ralentit les processus mais les fait tous avancer. Le blocage vient ici de l'attente mutuelle, pas d'un manque de puissance.\n" } ], "explanation": "Un interblocage apparaît quand des processus détiennent chacun une ressource et attendent celle d'un autre, de sorte que les attentes forment un cycle. Il faut alors une intervention extérieure, comme un agent qui fait passer une voiture, ou le système qui termine un processus." }, { "id": "q12", "difficulty": 2, "skills": [ "verrou" ], "title": "Verrou d'exclusion mutuelle", "partie": "interblocage", "statement": "À quoi sert un **verrou d'exclusion mutuelle** ?", "options": [ { "text": "À stocker les données partagées entre plusieurs processus", "correct": false, "feedback": "Un verrou ne stocke pas de\ndonnées, il contrôle l'accès à\ndes données stockées par\nailleurs.\n" }, { "text": "À ralentir volontairement le programme pour économiser le processeur", "correct": false, "feedback": "Un verrou peut effectivement\nralentir le programme, mais ce\nn'est pas son objectif. Son\nrôle premier est de garantir la\ncohérence des données\npartagées.\n" }, { "text": "À chiffrer les données partagées pour les protéger d'une lecture extérieure", "correct": false, "feedback": "Le chiffrement relève de la sécurisation des communications, pas du partage d'une ressource entre processus.\n" }, { "text": "À garantir qu'un seul processus à la fois accède à une ressource", "correct": true, "feedback": "Le motif classique est le suivant : on acquiert le verrou, on effectue les opérations sur la ressource, puis on libère le verrou pour que les autres processus puissent y accéder à leur tour.\n" } ], "explanation": "Un verrou protège la cohérence d'une ressource partagée, comme un fichier. Il crée aussi un risque : deux processus qui détiennent chacun un verrou et attendent celui de l'autre se retrouvent en interblocage." }, { "id": "q13", "difficulty": 2, "skills": [ "interblocage" ], "title": "Interblocage", "partie": "interblocage", "statement": "Qu'appelle-t-on un **interblocage** ?", "options": [ { "text": "Un arrêt brutal et immédiat de l'ensemble du programme, déclenché par le noyau", "correct": false, "feedback": "Un interblocage n'est pas un\narrêt brutal : les processus\nimpliqués restent actifs, mais\nils sont bloqués en attente\nmutuelle. Aucun ne s'arrête de\nlui-même.\n" }, { "text": "Un signal d'erreur particulier émis automatiquement par le système", "correct": false, "feedback": "L'interblocage n'émet pas de\nsignal particulier. Au\ncontraire, il se manifeste par\nun blocage silencieux que le\nprogrammeur doit détecter\nlui-même.\n" }, { "text": "Un gel de l'affichage de l'écran le temps d'un calcul lourd", "correct": false, "feedback": "Le mot peut faire penser à un\ngel de l'affichage, mais le\nsens technique en informatique\nest tout autre. Il s'agit d'un\nblocage logique entre\nprocessus.\n" }, { "text": "Une situation où plusieurs processus s'attendent mutuellement sans fin", "correct": true, "feedback": "Exemple : le processus $P_1$ détient la ressource $A$ et attend $B$, tandis que le processus $P_2$ détient $B$ et attend $A$. Aucun des deux ne peut progresser.\n" } ], "explanation": "Une façon simple de prévenir l'interblocage consiste à imposer à tous les processus le même ordre d'acquisition des ressources (toujours $A$ puis $B$) : l'attente circulaire devient alors impossible." }, { "id": "q14", "difficulty": 2, "skills": [ "ordonnancement", "premier-arrive" ], "title": "Attente dans l'ordre d'arrivée", "partie": "ordonnancement", "statement": "Trois processus deviennent prêts au même instant, dans l'ordre $P_1$, $P_2$, $P_3$. Ils ont besoin respectivement de $6$ ms, $3$ ms et $1$ ms de processeur. L'ordonnanceur les exécute dans leur ordre d'arrivée, chacun jusqu'au bout. Pendant combien de temps $P_3$ attend-il avant d'être élu ?", "options": [ { "text": "$0$ ms", "correct": false, "feedback": "Erreur : tu fais passer $P_3$ en premier parce qu'il est le plus court. L'ordonnanceur décrit ici suit l'ordre d'arrivée, et $P_3$ est arrivé en dernier.\n" }, { "text": "$1$ ms", "correct": false, "feedback": "Erreur : $1$ ms est la durée d'exécution de $P_3$, pas son attente. Il doit d'abord laisser passer $P_1$ et $P_2$.\n" }, { "text": "$9$ ms", "correct": true, "feedback": "Bonne réponse : $P_1$ occupe le processeur de $0$ à $6$ ms, puis $P_2$ de $6$ à $9$ ms. $P_3$ est élu à $9$ ms, après avoir attendu $6 + 3 = 9$ ms.\n" }, { "text": "$10$ ms", "correct": false, "feedback": "Erreur : $10$ ms est l'instant où $P_3$ se termine, pas celui où il commence. Son attente s'arrête dès qu'il est élu, à $9$ ms.\n" } ], "explanation": "Dans l'ordre d'arrivée, un processus attend la somme des durées des processus arrivés avant lui. Un processus court placé derrière des processus longs attend donc longtemps : c'est la faiblesse de cette méthode d'ordonnancement.", "variants": [ { "statement": "Trois processus deviennent prêts au même instant, dans l'ordre $P_1$, $P_2$, $P_3$. Ils ont besoin respectivement de $6$ ms, $3$ ms et $1$ ms de processeur. L'ordonnanceur les exécute dans leur ordre d'arrivée, chacun jusqu'au bout. Pendant combien de temps $P_3$ attend-il avant d'être élu ?", "options": [ { "text": "$0$ ms", "correct": false, "feedback": "Erreur : tu fais passer $P_3$ en premier parce qu'il est le plus court. L'ordonnanceur décrit ici suit l'ordre d'arrivée, et $P_3$ est arrivé en dernier.\n" }, { "text": "$1$ ms", "correct": false, "feedback": "Erreur : $1$ ms est la durée d'exécution de $P_3$, pas son attente. Il doit d'abord laisser passer $P_1$ et $P_2$.\n" }, { "text": "$9$ ms", "correct": true, "feedback": "Bonne réponse : $P_1$ occupe le processeur de $0$ à $6$ ms, puis $P_2$ de $6$ à $9$ ms. $P_3$ est élu à $9$ ms, après avoir attendu $6 + 3 = 9$ ms.\n" }, { "text": "$10$ ms", "correct": false, "feedback": "Erreur : $10$ ms est l'instant où $P_3$ se termine, pas celui où il commence. Son attente s'arrête dès qu'il est élu, à $9$ ms.\n" } ], "explanation": "Dans l'ordre d'arrivée, un processus attend la somme des durées des processus arrivés avant lui. Un processus court placé derrière des processus longs attend donc longtemps : c'est la faiblesse de cette méthode d'ordonnancement." }, { "statement": "Trois processus deviennent prêts au même instant, dans l'ordre $P_1$, $P_2$, $P_3$. Ils ont besoin respectivement de $4$ ms, $6$ ms et $2$ ms de processeur. L'ordonnanceur les exécute dans leur ordre d'arrivée, chacun jusqu'au bout. Pendant combien de temps $P_3$ attend-il avant d'être élu ?", "options": [ { "text": "$0$ ms", "correct": false, "feedback": "Erreur : tu fais passer $P_3$ en premier parce qu'il est le plus court. L'ordonnanceur décrit ici suit l'ordre d'arrivée, et $P_3$ est arrivé en dernier.\n" }, { "text": "$2$ ms", "correct": false, "feedback": "Erreur : $2$ ms est la durée d'exécution de $P_3$, pas son attente. Il doit d'abord laisser passer $P_1$ et $P_2$.\n" }, { "text": "$10$ ms", "correct": true, "feedback": "Bonne réponse : $P_1$ occupe le processeur de $0$ à $4$ ms, puis $P_2$ de $4$ à $10$ ms. $P_3$ est élu à $10$ ms, après avoir attendu $4 + 6 = 10$ ms.\n" }, { "text": "$12$ ms", "correct": false, "feedback": "Erreur : $12$ ms est l'instant où $P_3$ se termine, pas celui où il commence. Son attente s'arrête dès qu'il est élu, à $10$ ms.\n" } ], "explanation": "Dans l'ordre d'arrivée, un processus attend la somme des durées des processus arrivés avant lui. Un processus court placé derrière des processus longs attend donc longtemps : c'est la faiblesse de cette méthode d'ordonnancement." }, { "statement": "Trois processus deviennent prêts au même instant, dans l'ordre $P_1$, $P_2$, $P_3$. Ils ont besoin respectivement de $7$ ms, $5$ ms et $3$ ms de processeur. L'ordonnanceur les exécute dans leur ordre d'arrivée, chacun jusqu'au bout. Pendant combien de temps $P_3$ attend-il avant d'être élu ?", "options": [ { "text": "$0$ ms", "correct": false, "feedback": "Erreur : tu fais passer $P_3$ en premier parce qu'il est le plus court. L'ordonnanceur décrit ici suit l'ordre d'arrivée, et $P_3$ est arrivé en dernier.\n" }, { "text": "$3$ ms", "correct": false, "feedback": "Erreur : $3$ ms est la durée d'exécution de $P_3$, pas son attente. Il doit d'abord laisser passer $P_1$ et $P_2$.\n" }, { "text": "$12$ ms", "correct": true, "feedback": "Bonne réponse : $P_1$ occupe le processeur de $0$ à $7$ ms, puis $P_2$ de $7$ à $12$ ms. $P_3$ est élu à $12$ ms, après avoir attendu $7 + 5 = 12$ ms.\n" }, { "text": "$15$ ms", "correct": false, "feedback": "Erreur : $15$ ms est l'instant où $P_3$ se termine, pas celui où il commence. Son attente s'arrête dès qu'il est élu, à $12$ ms.\n" } ], "explanation": "Dans l'ordre d'arrivée, un processus attend la somme des durées des processus arrivés avant lui. Un processus court placé derrière des processus longs attend donc longtemps : c'est la faiblesse de cette méthode d'ordonnancement." } ] }, { "id": "q15", "difficulty": 2, "skills": [ "creation-processus" ], "title": "Création d'un processus", "partie": "processus", "statement": "Sur les systèmes Unix, l'appel système\n`fork` permet de :", "options": [ { "text": "Remplacer le programme courant par un nouveau programme à exécuter", "correct": false, "feedback": "Cette opération correspond à\nl'appel système `exec`, qui\nest souvent combiné avec\n`fork` pour lancer un nouveau\nprogramme dans un nouveau\nprocessus.\n" }, { "text": "Arrêter immédiatement le processus appelant et libérer sa mémoire", "correct": false, "feedback": "La terminaison d'un processus\nse fait avec un appel système\ncomme `exit`, et non avec\n`fork`.\n" }, { "text": "Dupliquer le processus appelant en un parent et un enfant", "correct": true, "feedback": "Après l'appel à `fork`, on\ndistingue le parent et l'enfant\npar la valeur renvoyée : la\nfonction renvoie $0$ dans le\nprocessus enfant, et le\nnuméro de l'enfant dans le\nprocessus parent. Ce mécanisme\nest fondamental sous Unix.\n" }, { "text": "Créer un nouveau fichier vide sur le disque pour le processus", "correct": false, "feedback": "La création d'un fichier\nrelève d'autres appels\nsystème, comme `open` avec\nl'option de création. L'appel\n`fork` concerne les processus,\npas les fichiers.\n" } ], "explanation": "Le motif classique sous Unix est\nl'enchaînement `fork` puis `exec` :\non duplique le processus, puis on\nremplace l'image mémoire de\nl'enfant par un autre programme.\nLe parent peut ensuite continuer\nen parallèle ou attendre la fin\nde l'enfant avec un appel à\n`wait`." }, { "id": "q16", "difficulty": 2, "skills": [ "creation-processus", "ppid", "observation" ], "title": "Enfants d'un interpréteur de commandes", "partie": "processus", "statement": "Voici un extrait de la liste des processus d'une machine, réduit à trois colonnes : le PID, le PPID (PID du processus parent) et la commande exécutée.\n\n```text\nPID PPID CMD\n880 1 login\n912 880 bash\n1043 912 python3 jeu.py\n1051 912 firefox\n1060 1051 firefox-onglet\n```\n\nCombien de processus de cet extrait ont été créés directement par le processus `bash` ?", "options": [ { "text": "$1$", "correct": false, "feedback": "Erreur : `python3 jeu.py` a bien pour PPID $912$, mais `firefox` aussi. Il faut relever toutes les lignes dont le PPID vaut $912$.\n" }, { "text": "$2$", "correct": true, "feedback": "Bonne réponse : deux lignes ont pour PPID $912$, le PID de `bash` : `python3 jeu.py` et `firefox`.\n" }, { "text": "$3$", "correct": false, "feedback": "Erreur : `firefox-onglet` a pour PPID $1051$ ; il a été créé par `firefox`, pas directement par `bash`.\n" }, { "text": "$4$", "correct": false, "feedback": "Erreur : tu comptes toutes les lignes situées sous `bash`. Or `login` est le parent de `bash`, et `firefox-onglet` est un enfant de `firefox`.\n" } ], "explanation": "Tout processus est créé par un autre processus, son parent, dont le PID figure dans la colonne PPID. En suivant ces numéros, on reconstitue l'arborescence des processus : ici `login` a créé `bash`, qui a créé `python3 jeu.py` et `firefox`, lequel a créé `firefox-onglet`." }, { "id": "q18", "difficulty": 2, "skills": [ "priorite" ], "title": "Priorité d'un processus", "partie": "ordonnancement", "statement": "Pourquoi un système d'exploitation\nattribue-t-il des **priorités**\ndifférentes aux processus ?", "options": [ { "text": "Pour donner plus de temps processeur aux processus les plus importants", "correct": true, "feedback": "Une priorité élevée conduit l'ordonnanceur à choisir ce processus avant les processus moins prioritaires, qui reçoivent donc moins de temps processeur.\n" }, { "text": "Pour renforcer la sécurité en isolant les processus les uns des autres", "correct": false, "feedback": "La sécurité est gérée par les\npermissions et les\nmécanismes d'isolation, pas\npar les priorités, qui\nconcernent l'allocation du\ntemps processeur.\n" }, { "text": "Pour réserver une quantité de mémoire vive fixe à chaque processus", "correct": false, "feedback": "La priorité ne fixe pas la\nmémoire allouée : elle agit sur\nle partage du temps processeur,\npas sur celui de la mémoire.\n" }, { "text": "Pour respecter l'ordre exact dans lequel les programmes ont été lancés", "correct": false, "feedback": "L'ordre de lancement ne\ndétermine pas la priorité : un\nprocessus lancé tardivement peut\nêtre plus prioritaire qu'un\nautre lancé avant lui.\n" } ], "explanation": "Les systèmes d'exploitation à\ncontraintes temps réel offrent\ndes garanties strictes sur la\npriorité. Les systèmes\ngénéralistes adoptent une\npolitique « au mieux », tout en\ncherchant à maintenir une équité\nglobale entre les processus." }, { "id": "q19", "difficulty": 2, "skills": [ "exemples-windows" ], "title": "Lister les processus sous Windows", "partie": "processus", "statement": "Comment afficher les processus actifs\nsur **Windows** ?", "options": [ { "text": "Avec le Gestionnaire des tâches, ou la commande PowerShell `Get-Process`", "correct": true, "feedback": "Le Gestionnaire des tâches\n(raccourci Ctrl + Maj + Échap)\noffre une interface graphique\nriche. En ligne de commande,\non dispose de `tasklist`\n(commande historique) ou de\n`Get-Process` dans\nPowerShell.\n" }, { "text": "Avec la commande `ps`, comme sur les systèmes Unix", "correct": false, "feedback": "La commande `ps` est propre\naux systèmes Unix. Elle n'est\npas disponible nativement\nsous Windows.\n" }, { "text": "C'est impossible : Windows masque ses processus à l'utilisateur", "correct": false, "feedback": "Plusieurs outils permettent\nau contraire d'observer les\nprocessus (Gestionnaire des\ntâches, `tasklist`,\n`Get-Process`).\n" }, { "text": "En redémarrant complètement Windows pour afficher la liste au prochain démarrage", "correct": false, "feedback": "Redémarrer le système ne permet\npas d'observer les processus en\ncours : il faut au contraire un\noutil de supervision sur un\nsystème en fonctionnement.\n" } ], "explanation": "Sur tous les systèmes\nd'exploitation modernes, on peut\nobserver les processus, mesurer\nleur consommation de ressources\net les terminer. Les outils\ndiffèrent, mais les fonctions\nproposées sont équivalentes." }, { "id": "q21", "difficulty": 3, "skills": [ "ordonnancement", "tourniquet" ], "title": "Instant de fin au tourniquet", "partie": "ordonnancement", "statement": "Trois processus sont prêts à l'instant $0$, dans l'ordre $P_1$, $P_2$, $P_3$. Ils ont besoin respectivement de $3$ ms, $2$ ms et $4$ ms de processeur. L'ordonnanceur procède à tour de rôle : chaque processus reçoit au plus $2$ ms, puis, s'il n'a pas fini, repasse en fin de file. À quel instant $P_1$ se termine-t-il ?", "options": [ { "text": "$3$ ms", "correct": false, "feedback": "Erreur : tu laisses $P_1$ s'exécuter jusqu'au bout. Il est interrompu au bout de $2$ ms et doit attendre que $P_2$ et $P_3$ aient eu leur tour.\n" }, { "text": "$5$ ms", "correct": false, "feedback": "Erreur : tu oublies le tour de $P_3$. Après $P_2$ (de $2$ à $4$ ms), c'est $P_3$ qui reçoit le processeur, de $4$ à $6$ ms, avant le retour de $P_1$.\n" }, { "text": "$7$ ms", "correct": true, "feedback": "Bonne réponse : $P_1$ s'exécute de $0$ à $2$ ms, $P_2$ de $2$ à $4$ ms (il a fini), $P_3$ de $4$ à $6$ ms, puis $P_1$ termine sa dernière milliseconde de $6$ à $7$ ms.\n" }, { "text": "$9$ ms", "correct": false, "feedback": "Erreur : $9$ ms est l'instant où le dernier processus, $P_3$, se termine. $P_1$ a fini avant, à $7$ ms.\n" } ], "explanation": "Pour suivre un tourniquet, on écrit la chronologie tranche par tranche : $P_1$ de $0$ à $2$, $P_2$ de $2$ à $4$, $P_3$ de $4$ à $6$, $P_1$ de $6$ à $7$, $P_3$ de $7$ à $9$. Chaque processus avance un peu à chaque tour, et aucun n'attend la fin complète des autres.", "variants": [ { "statement": "Trois processus sont prêts à l'instant $0$, dans l'ordre $P_1$, $P_2$, $P_3$. Ils ont besoin respectivement de $3$ ms, $2$ ms et $4$ ms de processeur. L'ordonnanceur procède à tour de rôle : chaque processus reçoit au plus $2$ ms, puis, s'il n'a pas fini, repasse en fin de file. À quel instant $P_1$ se termine-t-il ?", "options": [ { "text": "$3$ ms", "correct": false, "feedback": "Erreur : tu laisses $P_1$ s'exécuter jusqu'au bout. Il est interrompu au bout de $2$ ms et doit attendre que $P_2$ et $P_3$ aient eu leur tour.\n" }, { "text": "$5$ ms", "correct": false, "feedback": "Erreur : tu oublies le tour de $P_3$. Après $P_2$ (de $2$ à $4$ ms), c'est $P_3$ qui reçoit le processeur, de $4$ à $6$ ms, avant le retour de $P_1$.\n" }, { "text": "$7$ ms", "correct": true, "feedback": "Bonne réponse : $P_1$ s'exécute de $0$ à $2$ ms, $P_2$ de $2$ à $4$ ms (il a fini), $P_3$ de $4$ à $6$ ms, puis $P_1$ termine sa dernière milliseconde de $6$ à $7$ ms.\n" }, { "text": "$9$ ms", "correct": false, "feedback": "Erreur : $9$ ms est l'instant où le dernier processus, $P_3$, se termine. $P_1$ a fini avant, à $7$ ms.\n" } ], "explanation": "Pour suivre un tourniquet, on écrit la chronologie tranche par tranche : $P_1$ de $0$ à $2$, $P_2$ de $2$ à $4$, $P_3$ de $4$ à $6$, $P_1$ de $6$ à $7$, $P_3$ de $7$ à $9$. Chaque processus avance un peu à chaque tour, et aucun n'attend la fin complète des autres." }, { "statement": "Trois processus sont prêts à l'instant $0$, dans l'ordre $P_1$, $P_2$, $P_3$. Ils ont besoin respectivement de $3$ ms, $4$ ms et $1$ ms de processeur. L'ordonnanceur procède à tour de rôle : chaque processus reçoit au plus $2$ ms, puis, s'il n'a pas fini, repasse en fin de file. À quel instant $P_1$ se termine-t-il ?", "options": [ { "text": "$3$ ms", "correct": false, "feedback": "Erreur : tu laisses $P_1$ s'exécuter jusqu'au bout. Il est interrompu au bout de $2$ ms et doit attendre que $P_2$ et $P_3$ aient eu leur tour.\n" }, { "text": "$5$ ms", "correct": false, "feedback": "Erreur : tu oublies le tour de $P_3$. Après $P_2$ (de $2$ à $4$ ms), c'est $P_3$ qui reçoit le processeur, de $4$ à $5$ ms, avant le retour de $P_1$.\n" }, { "text": "$6$ ms", "correct": true, "feedback": "Bonne réponse : $P_1$ s'exécute de $0$ à $2$ ms, $P_2$ de $2$ à $4$ ms, $P_3$ de $4$ à $5$ ms (il a fini), puis $P_1$ termine sa dernière milliseconde de $5$ à $6$ ms.\n" }, { "text": "$8$ ms", "correct": false, "feedback": "Erreur : $8$ ms est l'instant où le dernier processus, $P_2$, se termine. $P_1$ a fini avant, à $6$ ms.\n" } ], "explanation": "Pour suivre un tourniquet, on écrit la chronologie tranche par tranche : $P_1$ de $0$ à $2$, $P_2$ de $2$ à $4$, $P_3$ de $4$ à $5$, $P_1$ de $5$ à $6$, $P_2$ de $6$ à $8$. Chaque processus avance un peu à chaque tour, et aucun n'attend la fin complète des autres." }, { "statement": "Trois processus sont prêts à l'instant $0$, dans l'ordre $P_1$, $P_2$, $P_3$. Ils ont besoin respectivement de $4$ ms, $3$ ms et $5$ ms de processeur. L'ordonnanceur procède à tour de rôle : chaque processus reçoit au plus $2$ ms, puis, s'il n'a pas fini, repasse en fin de file. À quel instant $P_1$ se termine-t-il ?", "options": [ { "text": "$4$ ms", "correct": false, "feedback": "Erreur : tu laisses $P_1$ s'exécuter jusqu'au bout. Il est interrompu au bout de $2$ ms et doit attendre que $P_2$ et $P_3$ aient eu leur tour.\n" }, { "text": "$6$ ms", "correct": false, "feedback": "Erreur : tu oublies le tour de $P_3$. Après $P_2$ (de $2$ à $4$ ms), c'est $P_3$ qui reçoit le processeur, de $4$ à $6$ ms, avant le retour de $P_1$.\n" }, { "text": "$8$ ms", "correct": true, "feedback": "Bonne réponse : $P_1$ s'exécute de $0$ à $2$ ms, $P_2$ de $2$ à $4$ ms, $P_3$ de $4$ à $6$ ms, puis $P_1$ termine ses deux dernières millisecondes de $6$ à $8$ ms.\n" }, { "text": "$12$ ms", "correct": false, "feedback": "Erreur : $12$ ms est l'instant où le dernier processus, $P_3$, se termine. $P_1$ a fini avant, à $8$ ms.\n" } ], "explanation": "Pour suivre un tourniquet, on écrit la chronologie tranche par tranche : $P_1$ de $0$ à $2$, $P_2$ de $2$ à $4$, $P_3$ de $4$ à $6$, $P_1$ de $6$ à $8$, $P_2$ de $8$ à $9$, $P_3$ de $9$ à $11$, $P_3$ de $11$ à $12$. Chaque processus avance un peu à chaque tour, et aucun n'attend la fin complète des autres." } ] }, { "id": "q25", "difficulty": 3, "skills": [ "synthese", "etats", "interblocage" ], "title": "Affirmation fausse sur les processus", "partie": "interblocage", "statement": "Parmi les affirmations suivantes sur les processus, laquelle est **fausse** ?", "options": [ { "text": "Un processus bloqué redevient prêt avant de pouvoir être élu", "correct": false, "feedback": "Cette affirmation est correcte : la fin de l'attente fait passer le processus à l'état prêt, et seul l'ordonnanceur peut ensuite l'élire.\n" }, { "text": "Lancer deux fois le même programme crée deux processus de PID différents", "correct": false, "feedback": "Cette affirmation est correcte : chaque lancement crée un nouveau processus, et le système attribue à chacun un PID unique.\n" }, { "text": "Un interblocage se dénoue de lui-même au prochain tour de l'ordonnanceur", "correct": true, "feedback": "Cette affirmation est fausse, c'est donc la bonne réponse : les processus en interblocage n'attendent pas le processeur mais des ressources détenues par les autres. L'ordonnanceur ne libère aucune ressource, le blocage persiste sans intervention extérieure.\n" }, { "text": "Sur un processeur à un cœur, un seul processus est élu à chaque instant", "correct": false, "feedback": "Cette affirmation est correcte : un cœur exécute un processus à la fois, et l'ordonnanceur fait alterner les processus prêts.\n" } ], "explanation": "L'ordonnanceur répartit le processeur entre les processus prêts, mais il ne règle pas les attentes de ressources. Un interblocage exige une intervention : terminer un processus, ou mieux, l'empêcher en imposant un ordre d'acquisition des ressources." }, { "id": "q26", "difficulty": 2, "skills": [ "interruption", "systeme" ], "title": "Appui sur une touche pendant un calcul", "partie": "processus", "statement": "Pendant qu'un processus effectue un long calcul, l'utilisateur appuie sur une touche du clavier. Que se passe-t-il ?", "options": [ { "text": "La frappe est ignorée tant que le calcul n'est pas terminé", "correct": false, "feedback": "Erreur : le système ne laisse pas un calcul rendre la machine sourde au clavier. La frappe est prise en compte presque immédiatement.\n" }, { "text": "Le calcul est définitivement arrêté pour laisser place à la frappe", "correct": false, "feedback": "Erreur : le calcul n'est suspendu qu'un bref instant, le temps de traiter la frappe. Il reprend ensuite là où il en était.\n" }, { "text": "Le clavier signale une interruption, que le système traite avant de reprendre", "correct": true, "feedback": "Bonne réponse : le clavier envoie un signal matériel d'interruption. Le système suspend brièvement le processus en cours, traite la frappe, puis l'exécution des processus reprend.\n" }, { "text": "Le clavier traite lui-même la frappe, sans solliciter le processeur", "correct": false, "feedback": "Erreur : le clavier est un périphérique d'entrée, il se contente de signaler la touche appuyée. Le traitement de cette information est confié au système d'exploitation, exécuté par le processeur.\n" } ], "explanation": "Les périphériques préviennent le système d'exploitation par des interruptions. Le système suspend alors momentanément le processus en cours, traite l'événement (touche appuyée, fin d'une lecture sur disque, paquet reçu), puis rend la main à l'ordonnancement habituel." }, { "id": "q27", "difficulty": 3, "skills": [ "interblocage", "cycle-attente" ], "title": "Cycle d'attente parmi quatre processus", "partie": "interblocage", "statement": "Un relevé indique, pour quatre processus, la ressource exclusive que chacun détient et celle qu'il attend :\n\n- $P_1$ détient $R_1$ et attend $R_2$ ;\n- $P_2$ détient $R_2$ et attend $R_3$ ;\n- $P_3$ détient $R_3$ et attend $R_2$ ;\n- $P_4$ détient $R_4$ et attend $R_1$.\n\nQuels processus forment un cycle d'attente ?", "options": [ { "text": "$P_2$ et $P_3$", "correct": true, "feedback": "Bonne réponse : $P_2$ attend $R_3$, détenue par $P_3$, qui attend $R_2$, détenue par $P_2$. La chaîne revient à son point de départ : c'est un cycle.\n" }, { "text": "$P_1$, $P_2$ et $P_3$", "correct": false, "feedback": "Erreur : $P_1$ attend bien $P_2$, mais seul $P_4$ attend $R_1$, et aucun processus n'attend $P_4$ : la chaîne ne revient jamais à $P_1$, bloqué derrière le cycle sans en faire partie.\n" }, { "text": "Les quatre processus", "correct": false, "feedback": "Erreur : $P_4$ attend $P_1$, qui attend $P_2$, mais aucun processus n'attend $R_4$. La chaîne partie de $P_4$ ne revient jamais à lui.\n" }, { "text": "Aucun, les attentes ne font que se suivre en chaîne", "correct": false, "feedback": "Erreur : en suivant les attentes à partir de $P_2$, on passe par $P_3$ et l'on revient à $P_2$. Cette chaîne-là se referme.\n" } ], "explanation": "Pour repérer un interblocage, on suit les attentes : un processus attend celui qui détient la ressource demandée. Ici $P_2$ et $P_3$ forment un cycle, et $P_1$ puis $P_4$ restent bloqués derrière eux : tant que le cycle n'est pas brisé, aucun des quatre n'avance." }, { "id": "q22", "difficulty": 3, "skills": [ "synthese", "interblocage" ], "title": "Reconnaître un interblocage", "partie": "interblocage", "statement": "Deux processus $P_1$ et $P_2$ utilisent deux\nressources $A$ et $B$ que le système d'exploitation\nn'autorise qu'à un seul processus à la fois (ressources\nnon préemptibles). À un instant donné, $P_1$ détient\n$A$ et attend $B$, pendant que $P_2$ détient $B$ et\nattend $A$. Aucun des deux ne lâchera la ressource\nqu'il détient. Quelle situation s'est produite ?", "options": [ { "text": "Un interblocage, car chacun attend la ressource que l'autre détient", "correct": true, "feedback": "Bonne réponse : l'interblocage (en anglais *deadlock*) se reconnaît ici à tous ses ingrédients : les ressources sont exclusives, chaque processus en tient une tout en demandant l'autre, le système ne peut pas les retirer de force, et la chaîne d'attente forme un cycle.\n" }, { "text": "Un simple manque de processeur, réglé au prochain tour de l'ordonnanceur", "correct": false, "feedback": "Erreur : $P_1$ et $P_2$ n'attendent pas le processeur mais une ressource détenue par l'autre. Leur donner le processeur ne changerait rien, puisque ni $A$ ni $B$ ne sera libérée.\n" }, { "text": "Un arrêt des deux processus, que le système a terminés", "correct": false, "feedback": "Erreur : aucun des deux processus n'est terminé. Ils existent toujours et détiennent chacun leur ressource, mais ils restent figés en attente.\n" }, { "text": "Une file d'attente normale du système, sans problème particulier", "correct": false, "feedback": "Erreur : dans une file d'attente normale, les\nprocessus progressent à tour de rôle. Ici, aucun\ndes deux n'avance et aucun n'avancera, c'est tout\nsauf normal.\n" } ], "explanation": "On sort d'un interblocage en brisant le cycle d'attente, par exemple en imposant à tous les processus le même ordre d'acquisition des ressources, ou en autorisant le système à retirer une ressource à un processus. Les bases de données et les systèmes d'exploitation surveillent ce type de situation." }, { "id": "q23", "difficulty": 3, "skills": [ "synthese", "etats", "ordonnancement" ], "title": "Comprendre l'état bloqué", "partie": "interblocage", "statement": "Sur un ordinateur en fonctionnement, un processus est\nobservé dans l'état « **en attente** » (ou « bloqué »)\ndepuis plusieurs secondes. Que peut-on en déduire de\nplus probable ?", "options": [ { "text": "Il attend un événement extérieur ; l'ordonnanceur a donné le processeur à d'autres", "correct": true, "feedback": "Bonne réponse : l'état « en attente » signale que le\nprocessus ne peut pas progresser parce qu'il attend\nun événement extérieur (saisie clavier, lecture\ndisque, réception réseau, libération d'une\nressource). L'ordonnanceur ne lui alloue pas le\nprocesseur pendant ce temps : il attribue les\ncycles à des processus qui sont, eux, à l'état\n« prêt ».\n" }, { "text": "Il utilise activement le processeur pour effectuer un calcul intensif", "correct": false, "feedback": "Erreur : un processus qui utilise le processeur est\ndans l'état « élu » (ou « en exécution »), pas dans\nl'état « en attente ».\n" }, { "text": "Il consomme une grande quantité de mémoire vive sur la machine", "correct": false, "feedback": "Erreur : la consommation de mémoire n'a aucun\nrapport avec l'état d'ordonnancement du processus.\nUn processus en attente peut détenir beaucoup ou\npeu de mémoire.\n" }, { "text": "Il a planté et le système d'exploitation s'apprête à le supprimer", "correct": false, "feedback": "Erreur : un processus planté passe à l'état\n« terminé ». L'état « en attente » est, lui, un\nétat tout à fait normal dans le cycle de vie d'un\nprocessus.\n" } ], "explanation": "Un processus typique alterne plusieurs fois entre les\nétats « prêt », « élu » et « en attente » au cours de\nsa vie. C'est ce qui rend la multiprogrammation\nefficace : pendant qu'un processus attend une lecture\nlente sur disque, l'ordonnanceur donne le processeur à\nun autre qui a du travail à faire. La transition entre\nétats est entièrement gérée par le noyau." }, { "id": "q28", "difficulty": 1, "skills": [ "systeme-sur-puce", "definition" ], "title": "Système sur puce", "partie": "soc", "statement": "Qu'appelle-t-on un **système sur puce** (SoC, pour\n*system on a chip*) ?", "options": [ { "text": "Un circuit unique qui regroupe processeur, mémoire, interfaces et contrôleurs", "correct": true, "feedback": "Toutes ces fonctions, autrefois réparties sur\nplusieurs circuits d'une carte, sont gravées sur\nla même puce.\n" }, { "text": "Une carte mère sur laquelle on enfiche séparément processeur et mémoire", "correct": false, "feedback": "C'est l'organisation classique d'un ordinateur de\nbureau, avec des composants séparés et\nremplaçables : l'inverse de l'intégration sur une\npuce.\n" }, { "text": "Un processeur qui possède plusieurs cœurs gravés sur le même circuit", "correct": false, "feedback": "Un processeur multicœur n'intègre que des unités\nde calcul ; un système sur puce y ajoute mémoire,\ninterfaces radio, contrôleurs vidéo et gestion\nd'énergie.\n" }, { "text": "Un programme du système d'exploitation chargé de piloter une puce", "correct": false, "feedback": "Un système sur puce est un composant matériel,\npas un logiciel ; c'est le système d'exploitation\nqui pilote ses blocs.\n" } ], "explanation": "La miniaturisation des circuits a permis de réunir\nsur une seule puce des fonctions autrefois réparties\nsur une carte entière : cœurs de processeur,\nmémoires locales, interfaces radio et filaires,\ncontrôleurs vidéo, gestion d'énergie. C'est\nl'architecture des téléphones et des objets\nconnectés." }, { "id": "q29", "difficulty": 1, "skills": [ "systeme-sur-puce", "exemples" ], "title": "Où trouve-t-on des systèmes sur puce", "partie": "soc", "statement": "Dans quels appareils rencontre-t-on le plus souvent\nun système sur puce ?", "options": [ { "text": "Dans les superordinateurs des centres de calcul uniquement", "correct": false, "feedback": "Les superordinateurs assemblent au contraire des\nmilliers de processeurs et de cartes séparés ;\nl'intégration sur une puce vise d'abord les\nappareils compacts.\n" }, { "text": "Dans les téléphones, tablettes et objets connectés", "correct": true, "feedback": "Compacité et faible consommation sont décisives\npour un appareil qui fonctionne sur batterie.\n" }, { "text": "Dans les ordinateurs de bureau à carte graphique séparée", "correct": false, "feedback": "Une carte graphique séparée est justement un\ncomposant non intégré ; l'ordinateur de bureau\nreste l'exemple type des composants dissociés.\n" }, { "text": "Dans aucun appareil grand public, ils restent expérimentaux", "correct": false, "feedback": "Les systèmes sur puce équipent depuis des années\ntous les téléphones et nombre d'ordinateurs\nportables récents.\n" } ], "explanation": "Un téléphone doit tenir dans la main et fonctionner\nune journée sur batterie : regrouper les fonctions\nsur une seule puce réduit l'encombrement, la\nconsommation et le coût d'assemblage. Les\nordinateurs portables récents adoptent la même\napproche." }, { "id": "q30", "difficulty": 2, "skills": [ "systeme-sur-puce", "vitesse" ], "title": "Pourquoi l'intégration accélère les échanges", "partie": "soc", "statement": "Pourquoi le regroupement des composants sur une\nseule puce rend-il leurs échanges plus rapides ?", "options": [ { "text": "Parce que les signaux parcourent quelques millimètres au lieu de traverser toute une carte", "correct": true, "feedback": "Des liaisons courtes et nombreuses, gravées dans\nla puce, transmettent les données avec un délai\nbien plus faible.\n" }, { "text": "Parce que la fréquence d'horloge d'un système sur puce est toujours plus élevée", "correct": false, "feedback": "La fréquence dépend du processeur choisi ;\nbeaucoup de systèmes sur puce tournent moins vite\nque les processeurs de bureau et restent\nréactifs grâce aux liaisons courtes.\n" }, { "text": "Parce que les données n'ont plus besoin de passer par la mémoire", "correct": false, "feedback": "Les programmes et leurs données résident toujours\nen mémoire ; c'est le chemin entre la mémoire et\nle processeur qui se raccourcit.\n" }, { "text": "Parce qu'une seule puce exécute plusieurs instructions par cycle, ce qu'une carte ne permet pas", "correct": false, "feedback": "Exécuter plusieurs instructions par cycle est une\npropriété du processeur, présente aussi sur les\nprocesseurs de bureau.\n" } ], "explanation": "Sur une carte, un signal qui va du processeur à la\nmémoire traverse des pistes de plusieurs centimètres\net des connecteurs ; sur une puce, les blocs sont\nvoisins et reliés par un réseau interne très large.\nMoins de distance, c'est moins de délai et moins\nd'énergie." }, { "id": "q31", "difficulty": 2, "skills": [ "systeme-sur-puce", "consommation" ], "title": "Pourquoi l'intégration économise l'énergie", "partie": "soc", "statement": "Un téléphone équipé d'un système sur puce consomme\nnettement moins qu'un ordinateur à composants\nséparés de puissance comparable. Quelle explication\nest juste ?", "options": [ { "text": "Les liaisons internes très courtes coûtent peu d'énergie et les blocs inactifs sont mis en veille", "correct": true, "feedback": "Deux effets s'ajoutent : faire transiter un signal\nsur quelques millimètres coûte peu, et le bloc de\ngestion d'énergie coupe ce qui ne sert pas.\n" }, { "text": "Un système sur puce ne contient pas de processeur, le composant le plus gourmand", "correct": false, "feedback": "Il en contient un, souvent à plusieurs cœurs ;\nc'est l'intégration et la gestion fine de\nl'alimentation qui réduisent la consommation.\n" }, { "text": "Un système sur puce exécute les programmes plus lentement qu'un ordinateur, donc chauffe et consomme moins", "correct": false, "feedback": "Les systèmes sur puce actuels sont rapides ; leur\néconomie vient de la distance parcourue par les\nsignaux et de la mise en veille des blocs, pas\nd'une lenteur.\n" }, { "text": "La mémoire vive y est remplacée par du stockage flash, qui ne consomme rien", "correct": false, "feedback": "Le téléphone garde une mémoire vive pour exécuter\nles programmes ; le stockage flash consomme lui\naussi, surtout en écriture.\n" } ], "explanation": "La consommation d'un circuit vient surtout des\ndéplacements de données et des blocs qui tournent\npour rien. Intégrer les fonctions sur une puce\nraccourcit les trajets, et un contrôleur de gestion\nd'énergie éteint ou ralentit chaque bloc selon\nl'activité : écran éteint, le processeur baisse sa\nfréquence et la radio ne se réveille que par\nintermittence." }, { "id": "q32", "difficulty": 2, "skills": [ "systeme-sur-puce", "composants" ], "title": "Identifier le bloc chargé des images", "partie": "soc", "statement": "Le schéma simplifié du système sur puce d'un\ntéléphone montre cinq blocs : cœurs de processeur,\naccélérateur graphique, interface radio, contrôleur\nde gestion d'énergie et mémoire locale. Lequel\ncalcule l'affichage d'un jeu en trois dimensions ?", "options": [ { "text": "La mémoire locale, qui contient les images à afficher", "correct": false, "feedback": "Elle stocke les données ; elle ne calcule rien.\n" }, { "text": "L'interface radio, qui reçoit les images du réseau", "correct": false, "feedback": "Elle assure les liaisons Wi-Fi et mobiles ; les\nimages d'un jeu sont calculées sur place, pas\nreçues du réseau.\n" }, { "text": "L'accélérateur graphique, spécialisé dans ce calcul", "correct": true, "feedback": "Ce bloc effectue en parallèle les millions\nd'opérations géométriques et de coloriage de\npixels qu'exige une image en trois dimensions.\n" }, { "text": "Le contrôleur de gestion d'énergie, qui règle l'écran", "correct": false, "feedback": "Il règle l'alimentation des blocs et la\nluminosité éventuelle ; il ne produit pas\nd'images.\n" } ], "explanation": "Un système sur puce réunit des blocs spécialisés :\nles cœurs de processeur exécutent les programmes\ngénéraux, l'accélérateur graphique calcule les\nimages, l'interface radio communique, la gestion\nd'énergie alimente chacun selon ses besoins. Lire\nun schéma, c'est associer chaque bloc à sa\nfonction." }, { "id": "q33", "difficulty": 2, "skills": [ "systeme-sur-puce", "composants", "roles" ], "title": "Repérer l'association bloc et rôle fausse", "partie": "soc", "statement": "Parmi ces associations entre un bloc d'un système\nsur puce et son rôle, laquelle est **fausse** ?", "options": [ { "text": "L'interface radio relie l'appareil au Wi-Fi et au réseau mobile", "correct": false, "feedback": "C'est bien son rôle : elle contient les\németteurs-récepteurs des liaisons sans fil.\n" }, { "text": "Le réseau sur puce transporte les données d'un bloc à l'autre", "correct": false, "feedback": "Exact : il joue sur la puce le rôle des bus d'une\ncarte mère.\n" }, { "text": "Le contrôleur vidéo stocke les programmes en cours d'exécution", "correct": true, "feedback": "Le contrôleur vidéo pilote l'écran ; les\nprogrammes en cours résident en mémoire vive.\n" }, { "text": "Le bloc de gestion d'énergie coupe l'alimentation des parties inactives", "correct": false, "feedback": "Exact : c'est lui qui met en veille les blocs\ninutilisés pour économiser la batterie.\n" } ], "explanation": "Chaque bloc a une fonction précise : radio pour\ncommuniquer, réseau sur puce pour relier les blocs,\ncontrôleur vidéo pour l'écran, gestion d'énergie\npour l'alimentation. Les programmes, eux, sont\nchargés en mémoire vive, qu'elle soit sur la puce ou\ndans un circuit voisin." }, { "id": "q34", "difficulty": 3, "skills": [ "systeme-sur-puce", "limites", "comparaison" ], "title": "Composants séparés sur un ordinateur évolutif", "partie": "soc", "statement": "Pour un ordinateur de bureau destiné à être amélioré\nau fil des ans, on préfère des composants séparés à\nun système sur puce. Pourquoi ?", "options": [ { "text": "Parce qu'un composant séparé se remplace ou s'ajoute sans toucher au reste", "correct": true, "feedback": "Changer la carte graphique ou doubler la mémoire\nvive est impossible quand tout est gravé sur la\nmême puce.\n" }, { "text": "Parce qu'un système sur puce ne peut pas faire tourner un système d'exploitation complet", "correct": false, "feedback": "Téléphones et ordinateurs portables à système sur\npuce exécutent des systèmes d'exploitation\ncomplets.\n" }, { "text": "Parce que des composants séparés consomment moins que la même fonction intégrée", "correct": false, "feedback": "C'est l'inverse : l'intégration réduit les\ndistances parcourues par les signaux, donc la\nconsommation.\n" }, { "text": "Parce qu'un système sur puce ne peut contenir qu'un seul cœur de processeur", "correct": false, "feedback": "Les systèmes sur puce actuels embarquent\ncouramment huit cœurs ou plus.\n" } ], "explanation": "L'intégration a un prix : ce qui est gravé ensemble\nne se sépare plus. Un système sur puce se change en\nbloc, quand une carte mère accepte une nouvelle\ncarte graphique ou une barrette de mémoire\nsupplémentaire. On choisit donc selon l'usage :\ncompacité et autonomie d'un côté, évolutivité de\nl'autre." }, { "id": "q35", "difficulty": 3, "skills": [ "systeme-sur-puce", "gestion-energie", "veille" ], "title": "Un téléphone en veille", "partie": "soc", "statement": "Un téléphone dont l'écran est éteint tient plusieurs\njours sur sa batterie, alors qu'une heure de jeu la\nvide d'un quart. Comment le système sur puce\nobtient-il cette différence ?", "options": [ { "text": "Il arrête complètement tous ses blocs, radio comprise, tant que l'écran reste éteint, puis les relance au réveil", "correct": false, "feedback": "La radio doit rester à l'écoute des appels et des\nmessages, par brèves périodes ; tout couper\nrendrait le téléphone injoignable.\n" }, { "text": "La gestion d'énergie ralentit les cœurs, met l'accélérateur graphique en veille et réveille la radio par intermittence", "correct": true, "feedback": "La consommation suit l'activité réelle de chaque\nbloc, réglée en permanence par ce contrôleur.\n" }, { "text": "Il confie ses calculs au réseau mobile, qui les exécute à sa place tant que l'écran reste éteint", "correct": false, "feedback": "Les calculs restent sur l'appareil ; en veille, il\nn'y en a presque plus à faire.\n" }, { "text": "Il abaisse la tension fournie par la batterie, ce qui divise d'un coup la consommation de tous les blocs", "correct": false, "feedback": "La tension d'alimentation est maintenue par le\ncircuit de gestion d'énergie ; c'est l'activité\ndes blocs qui est réduite, pas la batterie qui\nest bridée.\n" } ], "explanation": "Le contrôleur de gestion d'énergie est un bloc à\npart entière du système sur puce. Il adapte la\nfréquence et l'alimentation de chaque bloc à\nl'activité : en veille, les cœurs tournent au\nralenti, l'accélérateur graphique dort, la radio se\nréveille quelques millisecondes à intervalles\nréguliers. En jeu, tout fonctionne à plein régime." }, { "id": "q36", "difficulty": 2, "skills": [ "systeme-sur-puce", "conception", "compromis" ], "title": "Un système sur puce conçu sur mesure", "partie": "soc", "statement": "Plusieurs fabricants de téléphones conçoivent leur propre système\nsur puce au lieu d'assembler des composants du commerce. Qu'y\ngagnent-ils ?", "options": [ { "text": "Des blocs taillés pour leurs besoins exacts en vitesse et en autonomie", "correct": true, "feedback": "Bonne réponse : concevoir la puce permet de choisir le nombre de\ncœurs, la taille de l'accélérateur graphique ou les circuits\ndédiés à la photo, pour le compromis recherché entre vitesse,\nencombrement et autonomie.\n" }, { "text": "Un téléphone que le client peut faire évoluer composant par composant, comme un PC", "correct": false, "feedback": "Erreur : c'est le contraire. Tout étant gravé sur la même puce,\nrien ne se remplace séparément : la conception sur mesure\nsacrifie l'évolutivité à la compacité.\n" }, { "text": "Une conception moins coûteuse qu'un assemblage de composants déjà existants", "correct": false, "feedback": "Erreur : concevoir une puce coûte très cher en études et en\nfabrication. Cet investissement ne se justifie que par de très\ngrands volumes de production.\n" }, { "text": "L'absence de système d'exploitation, la puce se pilotant seule sans logiciel", "correct": false, "feedback": "Erreur : un système sur puce exécute un système d'exploitation\ncomme tout ordinateur. Ses blocs spécialisés sont justement\nexploités par le système et ses pilotes.\n" } ], "explanation": "Le système sur puce fige l'architecture au moment de la\nconception. En échange, chaque bloc est taillé pour l'usage prévu,\nce qui explique l'autonomie et la finesse des appareils mobiles." }, { "id": "q37", "difficulty": 2, "skills": [ "ordonnancement", "quantum", "tourniquet" ], "title": "La durée du quantum au tourniquet", "partie": "ordonnancement", "statement": "Un ordonnanceur au tourniquet donne à chaque processus un quantum\nde temps avant de passer au suivant. Que se passe-t-il si le\nquantum est choisi très court ?", "options": [ { "text": "Les commutations se multiplient et leur coût ronge le temps utile", "correct": true, "feedback": "Bonne réponse : chaque changement de processus demande de\nsauvegarder et restaurer un contexte. Avec un quantum minuscule,\nle processeur passe plus de temps à commuter qu'à calculer.\n" }, { "text": "Les processus se terminent plus vite, étant servis plus souvent", "correct": false, "feedback": "Erreur : être servi plus souvent ne donne pas plus de temps de\ncalcul au total.\n" }, { "text": "Un seul processus monopolise le processeur jusqu'à sa fin", "correct": false, "feedback": "Erreur : c'est au contraire un quantum infini qui produirait\ncet effet.\n" }, { "text": "Les processus bloqués en entrée-sortie sont réveillés plus tôt", "correct": false, "feedback": "Erreur : un processus bloqué attend la fin de son entrée-sortie,\npas un quantum.\n" } ], "explanation": "Le quantum arbitre entre réactivité, qui veut un quantum court, et\nrendement, qui veut un quantum long." }, { "id": "q38", "difficulty": 3, "skills": [ "ordonnancement", "tourniquet", "trace", "calcul" ], "title": "Le temps d'attente avant le premier service", "partie": "ordonnancement", "statement": "Un ordonnanceur au tourniquet sert $3$ processus prêts, dans\nl'ordre, avec un quantum de $4$ ms. Aucun ne se bloque ni ne\ntermine pendant le premier tour. Combien de temps le dernier de la\nliste attend-il avant de recevoir le processeur pour la première\nfois ?", "options": [ { "text": "$8$ ms, les $2$ quanta qui le précèdent", "correct": true, "feedback": "Bonne réponse : les $2$ processus placés avant lui\nconsomment chacun un quantum entier, soit\n$2 \\times 4 = 8$ ms.\n" }, { "text": "$12$ ms, un tour complet de tourniquet", "correct": false, "feedback": "Erreur : son propre quantum ne fait pas partie de l'attente.\n" }, { "text": "$4$ ms, un seul quantum d'attente", "correct": false, "feedback": "Erreur : il doit laisser passer tous ceux qui le précèdent, pas\nun seul.\n" }, { "text": "$0$ ms, tous les processus démarrant ensemble", "correct": false, "feedback": "Erreur : un seul processus occupe le processeur à la fois.\n" } ], "explanation": "Au tourniquet, l'attente avant le premier service croît avec le\nnombre de processus prêts et la taille du quantum.", "variants": [ { "statement": "Un ordonnanceur au tourniquet sert $3$ processus prêts, dans\nl'ordre, avec un quantum de $4$ ms. Aucun ne se bloque ni ne\ntermine pendant le premier tour. Combien de temps le dernier de la\nliste attend-il avant de recevoir le processeur pour la première\nfois ?", "options": [ { "text": "$8$ ms, les $2$ quanta qui le précèdent", "correct": true, "feedback": "Bonne réponse : les $2$ processus placés avant lui\nconsomment chacun un quantum entier, soit\n$2 \\times 4 = 8$ ms.\n" }, { "text": "$12$ ms, un tour complet de tourniquet", "correct": false, "feedback": "Erreur : son propre quantum ne fait pas partie de l'attente.\n" }, { "text": "$4$ ms, un seul quantum d'attente", "correct": false, "feedback": "Erreur : il doit laisser passer tous ceux qui le précèdent, pas\nun seul.\n" }, { "text": "$0$ ms, tous les processus démarrant ensemble", "correct": false, "feedback": "Erreur : un seul processus occupe le processeur à la fois.\n" } ], "explanation": "Au tourniquet, l'attente avant le premier service croît avec le\nnombre de processus prêts et la taille du quantum." }, { "statement": "Un ordonnanceur au tourniquet sert $5$ processus prêts, dans\nl'ordre, avec un quantum de $2$ ms. Aucun ne se bloque ni ne\ntermine pendant le premier tour. Combien de temps le dernier de la\nliste attend-il avant de recevoir le processeur pour la première\nfois ?", "options": [ { "text": "$8$ ms, les $4$ quanta qui le précèdent", "correct": true, "feedback": "Bonne réponse : les $4$ processus placés avant lui\nconsomment chacun un quantum entier, soit\n$4 \\times 2 = 8$ ms.\n" }, { "text": "$10$ ms, un tour complet de tourniquet", "correct": false, "feedback": "Erreur : son propre quantum ne fait pas partie de l'attente.\n" }, { "text": "$2$ ms, un seul quantum d'attente", "correct": false, "feedback": "Erreur : il doit laisser passer tous ceux qui le précèdent, pas\nun seul.\n" }, { "text": "$0$ ms, tous les processus démarrant ensemble", "correct": false, "feedback": "Erreur : un seul processus occupe le processeur à la fois.\n" } ], "explanation": "Au tourniquet, l'attente avant le premier service croît avec le\nnombre de processus prêts et la taille du quantum." }, { "statement": "Un ordonnanceur au tourniquet sert $4$ processus prêts, dans\nl'ordre, avec un quantum de $5$ ms. Aucun ne se bloque ni ne\ntermine pendant le premier tour. Combien de temps le dernier de la\nliste attend-il avant de recevoir le processeur pour la première\nfois ?", "options": [ { "text": "$15$ ms, les $3$ quanta qui le précèdent", "correct": true, "feedback": "Bonne réponse : les $3$ processus placés avant lui\nconsomment chacun un quantum entier, soit\n$3 \\times 5 = 15$ ms.\n" }, { "text": "$20$ ms, un tour complet de tourniquet", "correct": false, "feedback": "Erreur : son propre quantum ne fait pas partie de l'attente.\n" }, { "text": "$5$ ms, un seul quantum d'attente", "correct": false, "feedback": "Erreur : il doit laisser passer tous ceux qui le précèdent, pas\nun seul.\n" }, { "text": "$0$ ms, tous les processus démarrant ensemble", "correct": false, "feedback": "Erreur : un seul processus occupe le processeur à la fois.\n" } ], "explanation": "Au tourniquet, l'attente avant le premier service croît avec le\nnombre de processus prêts et la taille du quantum." } ] }, { "id": "q39", "difficulty": 2, "skills": [ "ordonnancement", "blocage", "entree-sortie" ], "title": "Un processus qui attend une lecture sur disque", "partie": "ordonnancement", "statement": "Un processus élu demande une lecture sur le disque, qui prendra\nplusieurs millisecondes. Que fait l'ordonnanceur ?", "options": [ { "text": "Il le passe à l'état bloqué et élit un autre processus prêt", "correct": true, "feedback": "Bonne réponse : attendre le disque en occupant le processeur\nserait du gaspillage ; le processus redeviendra prêt quand la\nlecture sera finie.\n" }, { "text": "Il le laisse élu, le processeur attendant le disque avec lui", "correct": false, "feedback": "Erreur : le processeur serait inutilisé pendant toute\nl'attente.\n" }, { "text": "Il le termine, une lecture bloquante étant interdite", "correct": false, "feedback": "Erreur : lire sur le disque est une opération ordinaire.\n" }, { "text": "Il le remet aussitôt dans la file des processus prêts", "correct": false, "feedback": "Erreur : un processus qui attend une entrée-sortie n'est pas\nprêt, il est bloqué.\n" } ], "explanation": "L'état bloqué existe précisément pour libérer le processeur\npendant les attentes d'entrée-sortie." }, { "id": "q40", "difficulty": 2, "skills": [ "interblocage", "prevention", "ordre-des-verrous" ], "title": "Prévenir l'interblocage par l'ordre des verrous", "partie": "interblocage", "statement": "Plusieurs processus ont besoin des mêmes verrous. Quelle règle,\nimposée à tous, empêche tout interblocage ?", "options": [ { "text": "Prendre les verrous toujours dans le même ordre, fixé à l'avance", "correct": true, "feedback": "Bonne réponse : si tous demandent d'abord `A` puis `B`, aucun\nprocessus ne peut détenir `B` en attendant `A` ; le cycle\nd'attente devient impossible.\n" }, { "text": "Donner à chaque processus un verrou supplémentaire", "correct": false, "feedback": "Erreur : davantage de verrous multiplie les occasions\nd'attente mutuelle.\n" }, { "text": "Augmenter la priorité des processus déjà bloqués", "correct": false, "feedback": "Erreur : la priorité ne libère aucun verrou détenu par un\nautre.\n" }, { "text": "Attendre que les processus se débloquent d'eux-mêmes", "correct": false, "feedback": "Erreur : un interblocage ne se résout jamais seul.\n" } ], "explanation": "Un interblocage exige un cycle d'attente ; un ordre global\nd'acquisition rend tout cycle impossible." }, { "id": "q41", "difficulty": 3, "skills": [ "interblocage", "trace", "deux-verrous" ], "title": "Deux processus et deux fichiers", "partie": "interblocage", "statement": "Les fichiers `A` et `B` sont protégés par un verrou chacun. P1\nverrouille `A` puis demande `B` ; en même temps, P2 verrouille\n`B` puis demande `A`. Un interblocage est-il possible ?", "options": [ { "text": "Oui, chacun attend le verrou que l'autre détient", "correct": true, "feedback": "Bonne réponse : il y a interblocage seulement si chaque\nprocessus détient ce que l'autre attend. Dérouler les deux\ndemandes dans l'ordre le fait apparaître ou non.\n" }, { "text": "Non, P2 finira par obtenir `A` quand P1 aura terminé", "correct": false, "feedback": "Erreur : reprends les deux demandes dans l'ordre et note qui\ndétient quoi au moment de chaque attente.\n" }, { "text": "Oui, deux processus ne peuvent jamais partager deux fichiers", "correct": false, "feedback": "Erreur : partager est possible, tout dépend de l'ordre des\ndemandes.\n" }, { "text": "Non, un verrou se libère de lui-même après un délai", "correct": false, "feedback": "Erreur : un verrou reste détenu jusqu'à sa libération\nexplicite.\n" } ], "explanation": "L'interblocage naît d'un cycle : P1 attend P2 qui attend P1. Sans\ncycle, les attentes finissent par se résoudre.", "variants": [ { "statement": "Les fichiers `A` et `B` sont protégés par un verrou chacun. P1\nverrouille `A` puis demande `B` ; en même temps, P2 verrouille\n`B` puis demande `A`. Un interblocage est-il possible ?", "options": [ { "text": "Oui, chacun attend le verrou que l'autre détient", "correct": true, "feedback": "Bonne réponse : il y a interblocage seulement si chaque\nprocessus détient ce que l'autre attend. Dérouler les deux\ndemandes dans l'ordre le fait apparaître ou non.\n" }, { "text": "Non, P2 finira par obtenir `A` quand P1 aura terminé", "correct": false, "feedback": "Erreur : reprends les deux demandes dans l'ordre et note qui\ndétient quoi au moment de chaque attente.\n" }, { "text": "Oui, deux processus ne peuvent jamais partager deux fichiers", "correct": false, "feedback": "Erreur : partager est possible, tout dépend de l'ordre des\ndemandes.\n" }, { "text": "Non, un verrou se libère de lui-même après un délai", "correct": false, "feedback": "Erreur : un verrou reste détenu jusqu'à sa libération\nexplicite.\n" } ], "explanation": "L'interblocage naît d'un cycle : P1 attend P2 qui attend P1. Sans\ncycle, les attentes finissent par se résoudre." }, { "statement": "Les fichiers `A` et `B` sont protégés par un verrou chacun. P1\nverrouille `A` puis demande `B` ; en même temps, P2 verrouille\n`A` puis demande `B`. Un interblocage est-il possible ?", "options": [ { "text": "Non, P2 attend dès sa première demande et P1 peut terminer", "correct": true, "feedback": "Bonne réponse : il y a interblocage seulement si chaque\nprocessus détient ce que l'autre attend. Dérouler les deux\ndemandes dans l'ordre le fait apparaître ou non.\n" }, { "text": "Oui, les deux processus demandant les deux mêmes verrous", "correct": false, "feedback": "Erreur : reprends les deux demandes dans l'ordre et note qui\ndétient quoi au moment de chaque attente.\n" }, { "text": "Oui, deux processus ne peuvent jamais partager deux fichiers", "correct": false, "feedback": "Erreur : partager est possible, tout dépend de l'ordre des\ndemandes.\n" }, { "text": "Non, un verrou se libère de lui-même après un délai", "correct": false, "feedback": "Erreur : un verrou reste détenu jusqu'à sa libération\nexplicite.\n" } ], "explanation": "L'interblocage naît d'un cycle : P1 attend P2 qui attend P1. Sans\ncycle, les attentes finissent par se résoudre." } ] }, { "id": "q42", "difficulty": 1, "skills": [ "interblocage", "verrou", "liberation" ], "title": "Un verrou jamais libéré", "partie": "interblocage", "statement": "Un processus prend un verrou sur une ressource et ne le libère\njamais. Qu'arrive-t-il aux autres processus qui demandent cette\nressource ?", "options": [ { "text": "Ils restent bloqués en attente du verrou, indéfiniment", "correct": true, "feedback": "Bonne réponse : un verrou interdit l'accès à tout autre\nprocessus tant qu'il est détenu ; les demandeurs passent à\nl'état bloqué sans issue.\n" }, { "text": "Le système leur retire le verrou du processus fautif", "correct": false, "feedback": "Erreur : le système ne reprend pas un verrou de lui-même.\n" }, { "text": "Ils accèdent à la ressource en lecture seulement", "correct": false, "feedback": "Erreur : le verrou d'exclusion mutuelle interdit tout accès.\n" }, { "text": "Ils reçoivent une copie de la ressource", "correct": false, "feedback": "Erreur : aucune copie n'est faite, la ressource est unique.\n" } ], "explanation": "Libérer un verrou dès que la ressource n'est plus nécessaire est\nla règle de base : un verrou oublié bloque tout le monde." }, { "id": "q43", "difficulty": 2, "skills": [ "ordonnancement", "preemption", "reactivite" ], "title": "La préemption d'un processus", "partie": "ordonnancement", "statement": "Que fait un ordonnanceur qui préempte un processus ?", "options": [ { "text": "Il lui retire le processeur avant la fin de son travail", "correct": true, "feedback": "Bonne réponse : le processus passe de l'état élu à l'état prêt,\nson contexte est sauvegardé, et il reprendra plus tard là où il\nen était.\n" }, { "text": "Il le termine définitivement pour libérer la mémoire", "correct": false, "feedback": "Erreur : le processus n'est pas tué, il attend son tour.\n" }, { "text": "Il augmente sa priorité pour qu'il finisse plus vite", "correct": false, "feedback": "Erreur : la préemption retire le processeur, elle ne favorise\npas le processus.\n" }, { "text": "Il double la durée de son quantum pour qu'il finisse", "correct": false, "feedback": "Erreur : c'est au contraire l'expiration du quantum qui\ndéclenche souvent la préemption.\n" } ], "explanation": "La préemption est ce qui permet le partage du processeur : sans\nelle, un processus garderait le processeur jusqu'à ce qu'il le\nrende." }, { "id": "q44", "difficulty": 3, "skills": [ "ordonnancement", "priorites", "famine" ], "title": "Un processus de faible priorité", "partie": "ordonnancement", "statement": "Un ordonnanceur élit toujours le processus prêt de plus haute\npriorité. Que risque un processus de faible priorité si des\nprocessus prioritaires arrivent sans cesse ?", "options": [ { "text": "Attendre indéfiniment, sans jamais obtenir le processeur", "correct": true, "feedback": "Bonne réponse : tant qu'un processus plus prioritaire est prêt,\nil passe devant. Les systèmes corrigent ce risque en augmentant\npeu à peu la priorité des processus qui attendent.\n" }, { "text": "Être exécuté dès l'expiration du quantum en cours", "correct": false, "feedback": "Erreur : à l'expiration du quantum, c'est encore le plus\nprioritaire qui est élu.\n" }, { "text": "Être supprimé par l'ordonnanceur faute de place", "correct": false, "feedback": "Erreur : l'ordonnanceur ne supprime pas de processus.\n" }, { "text": "Obtenir le processeur à chaque tour, comme les autres", "correct": false, "feedback": "Erreur : le tour de rôle vaut entre processus de même priorité.\n" } ], "explanation": "Les priorités strictes créent un risque d'attente sans fin ;\nl'équité exige de faire vieillir les demandes en attente." } ] }