\documentclass[10pt,aspectratio=169]{beamer}

% --- Thème ---
\usetheme[language=french]{Celestia}

% Avec [allowframebreaks] sur les frames de questions, Beamer ajoute
% par défaut « (1) », « (2) », « (3) »... sur chaque sous-slide. On
% supprime entièrement cette annotation : un template vide pour
% « frametitle continuation ». L'enseignant identifie visuellement la
% continuation par le contenu de la slide. (Les variantes [from second]
% et [roman] interagissent mal avec un titre contenant \textemdash{}
% sous Celestia : elles déclenchent une erreur « Missing $ inserted ».)
\setbeamertemplate{frametitle continuation}{}

\subject{Numérique et sciences informatiques}
\title{Processus et système}
\subtitle{QCM}
\author{Terminale}
\date{\today}

\begin{document}

\begin{frame}
    \titlepage
\end{frame}

% Q1 - Réponse en A
\begin{frame}[fragile]{Question 1 \textemdash{} Notion de processus}
    Qu'est-ce qu'un \textbf{processus} ?\medskip
    \begin{itemize}
        \item[\alert<2>{A.}] \alert<2>{Un programme en cours d'exécution, accompagné de sa mémoire, de ses ressources et de son contexte (registres, pile d'appels)}
        \item[B.] Un type particulier de mémoire
        \item[C.] Un fichier exécutable stocké sur le disque
        \item[D.] Une fonction définie dans un programme Python
    \end{itemize}
\end{frame}

% Q2 - Réponse en B
\begin{frame}[fragile]{Question 2 \textemdash{} Fil d'exécution}
    Qu'est-ce qu'un \textbf{fil d'exécution}
(parfois appelé \textit{thread}) ?\medskip
    \begin{itemize}
        \item[A.] Un protocole utilisé sur Internet
        \item[\alert<2>{B.}] \alert<2>{Une unité d'exécution légère au sein d'un processus, qui partage la mémoire avec les autres fils du même processus}
        \item[C.] Un fichier de configuration du système
        \item[D.] Un type de fichier sur le disque
    \end{itemize}
\end{frame}

% Q3 - Réponse en B
\begin{frame}[fragile]{Question 3 \textemdash{} Identifiant de processus}
    Que désigne le \textbf{PID} d'un processus ?\medskip
    \begin{itemize}
        \item[A.] Un pilote interne pour gérer les processus
        \item[\alert<2>{B.}] \alert<2>{Un numéro unique attribué par le système d'exploitation à chaque processus pour pouvoir l'identifier}
        \item[C.] Un descripteur de permissions
        \item[D.] Un domaine personnel sur Internet
    \end{itemize}
\end{frame}

% Q4 - Réponse en C
\begin{frame}[fragile]{Question 4 \textemdash{} États d'un processus}
    Quels sont les \textbf{états principaux} par
lesquels passe un processus au cours de
sa vie ?\medskip
    \begin{itemize}
        \item[A.] Démarré et terminé, uniquement
        \item[B.] Sain et malade
        \item[\alert<2>{C.}] \alert<2>{Prêt, en exécution, bloqué (en attente d'une ressource ou d'une entrée-sortie), terminé}
        \item[D.] Visible et caché
    \end{itemize}
\end{frame}

% Q5 - Réponse en C
\begin{frame}[fragile]{Question 5 \textemdash{} Ordonnanceur}
    Quel composant choisit \textbf{quel processus}
reçoit le processeur à chaque instant ?\medskip
    \begin{itemize}
        \item[A.] L'interpréteur de commandes (ou \textit{shell})
        \item[B.] Le pilote
        \item[\alert<2>{C.}] \alert<2>{L'ordonnanceur, qui est un composant du noyau du système d'exploitation}
        \item[D.] L'utilisateur, à chaque instant
    \end{itemize}
\end{frame}

% Q6 - Réponse en A
\begin{frame}[fragile]{Question 6 \textemdash{} Parallélisme et concurrence}
    Quelle est la différence entre
\textbf{parallélisme} et \textbf{concurrence} ?\medskip
    \begin{itemize}
        \item[\alert<2>{A.}] \alert<2>{La concurrence désigne plusieurs tâches en cours logiquement (qui se partagent un même processeur en alternant). Le parallélisme désigne plusieurs tâches s'exécutant réellement en même temps sur des cœurs différents}
        \item[B.] La concurrence n'existe pas en informatique
        \item[C.] Aucune différence, ce sont deux mots pour la même chose
        \item[D.] Le parallélisme est toujours plus rapide
    \end{itemize}
\end{frame}

% Q7 - Réponse en A
\begin{frame}[fragile]{Question 7 \textemdash{} Mémoire partagée entre fils d'exécution}
    Pourquoi les fils d'exécution d'un même
processus \textbf{partagent-ils} leur mémoire ?\medskip
    \begin{itemize}
        \item[\alert<2>{A.}] \alert<2>{Pour permettre une communication rapide entre fils d'exécution (lire et écrire des variables communes), au prix d'une nécessaire gestion de la synchronisation}
        \item[B.] Par défaut, ils ne partagent rien
        \item[C.] Pour économiser des cœurs de processeur
        \item[D.] Aucune raison particulière
    \end{itemize}
\end{frame}

% Q8 - Réponse en C
\begin{frame}[fragile]{Question 8 \textemdash{} Signal}
    Qu'est-ce qu'un \textbf{signal} sous Unix ?\medskip
    \begin{itemize}
        \item[A.] Un message textuel envoyé sur un réseau social
        \item[B.] Une instruction du processeur
        \item[\alert<2>{C.}] \alert<2>{Une notification asynchrone envoyée à un processus pour lui demander une action (terminaison, suspension, reprise…)}
        \item[D.] Un protocole utilisé sur Internet
    \end{itemize}
\end{frame}

% Q9 - Réponse en A
\begin{frame}[fragile]{Question 9 \textemdash{} Lister les processus}
    Quelle commande Unix affiche la \textbf{liste
des processus} en cours d'exécution ?\medskip
    \begin{itemize}
        \item[\alert<2>{A.}] \alert<2>{\texttt{ps}, ou \texttt{top} pour un suivi en temps réel}
        \item[B.] \texttt{ls}
        \item[C.] \texttt{cat}
        \item[D.] \texttt{grep}
    \end{itemize}
\end{frame}

% Q10 - Réponse en C
\begin{frame}[fragile]{Question 10 \textemdash{} Démon}
    Qu'appelle-t-on un \textbf{démon} sur un
système d'exploitation ?\medskip
    \begin{itemize}
        \item[A.] Une commande Unix particulière
        \item[B.] Un programme malveillant
        \item[\alert<2>{C.}] \alert<2>{Un processus qui s'exécute en arrière-plan, sans interface utilisateur, généralement lancé au démarrage du système et fournissant un service comme un serveur web, une base de données ou un service de journalisation}
        \item[D.] Un fichier caché du système
    \end{itemize}
\end{frame}

% Q11 - Réponse en D
\begin{frame}[fragile]{Question 11 \textemdash{} Course critique}
    Qu'appelle-t-on une \textbf{course critique}
(parfois nommée \textit{race condition}) ?\medskip
    \begin{itemize}
        \item[A.] Une optimisation utilisée par le compilateur
        \item[B.] Une compétition sportive informatisée
        \item[C.] Un phénomène sans rapport avec les fils d'exécution
        \item[\alert<2>{D.}] \alert<2>{Un bug qui survient lorsque l'ordre d'exécution de plusieurs fils d'exécution accédant à une même ressource partagée influence le résultat de manière imprévisible}
    \end{itemize}
\end{frame}

% Q12 - Réponse en D
\begin{frame}[fragile]{Question 12 \textemdash{} Verrou d'exclusion mutuelle}
    À quoi sert un \textbf{verrou d'exclusion
mutuelle} ?\medskip
    \begin{itemize}
        \item[A.] À stocker des données partagées
        \item[B.] À ralentir intentionnellement le programme
        \item[C.] À chiffrer les données pour les protéger
        \item[\alert<2>{D.}] \alert<2>{À garantir qu'un seul fil d'exécution à la fois accède à une ressource partagée, ce qui évite les courses critiques}
    \end{itemize}
\end{frame}

% Q13 - Réponse en D
\begin{frame}[fragile]{Question 13 \textemdash{} Interblocage}
    Qu'appelle-t-on un \textbf{interblocage} ?\medskip
    \begin{itemize}
        \item[A.] Un arrêt brutal du programme
        \item[B.] Un signal d'erreur émis par le système
        \item[C.] Un blocage de l'écran
        \item[\alert<2>{D.}] \alert<2>{Une situation dans laquelle plusieurs fils d'exécution ou processus s'attendent mutuellement sans fin, chacun détenant une ressource demandée par un autre}
    \end{itemize}
\end{frame}

% Q14 - Réponse en C
\begin{frame}[fragile]{Question 14 \textemdash{} Communication entre processus}
    Comment deux processus \textbf{isolés}
peuvent-ils communiquer entre eux ?\medskip
    \begin{itemize}
        \item[A.] Uniquement par le clavier
        \item[B.] Uniquement via Internet
        \item[\alert<2>{C.}] \alert<2>{À l'aide de tubes de communication, de connexions réseau (sockets), de fichiers partagés, d'une mémoire partagée explicite, ou de files de messages}
        \item[D.] Il leur est impossible de communiquer
    \end{itemize}
\end{frame}

% Q15 - Réponse en C
\begin{frame}[fragile]{Question 15 \textemdash{} Création d'un processus}
    Sur les systèmes Unix, l'appel système
\texttt{fork} permet de :\medskip
    \begin{itemize}
        \item[A.] Exécuter un nouveau programme depuis le processus courant
        \item[B.] Terminer immédiatement le processus appelant
        \item[\alert<2>{C.}] \alert<2>{Dupliquer le processus appelant : on obtient un processus parent et un processus enfant, qui partagent au départ le même code et la même mémoire}
        \item[D.] Créer un nouveau fichier sur le disque
    \end{itemize}
\end{frame}

% Q16 - Réponse en A
\begin{frame}[fragile]{Question 16 \textemdash{} Processus zombie}
    Qu'appelle-t-on un \textbf{processus zombie} ?\medskip
    \begin{itemize}
        \item[\alert<2>{A.}] \alert<2>{Un processus terminé dont le code de retour n'a pas encore été récupéré par son parent. Il occupe encore une entrée dans la table des processus}
        \item[B.] Un processus dangereux pour le système
        \item[C.] Un signal système particulier
        \item[D.] Un processus pris dans une boucle infinie
    \end{itemize}
\end{frame}

% Q17 - Réponse en C
\begin{frame}[fragile]{Question 17 \textemdash{} Le verrou global de l'interpréteur Python}
    Qu'est-ce que le \textbf{verrou global de
l'interpréteur} dans l'implémentation
principale de Python ?\medskip
    \begin{itemize}
        \item[A.] Un module standard de la bibliothèque Python
        \item[B.] Une fonction de la bibliothèque standard
        \item[\alert<2>{C.}] \alert<2>{Un verrou interne à l'interpréteur qui garantit qu'un seul fil d'exécution Python à la fois exécute du bytecode, ce qui simplifie l'implémentation de l'interpréteur mais limite le parallélisme effectif sur le processeur}
        \item[D.] Un éditeur de texte particulier
    \end{itemize}
\end{frame}

% Q18 - Réponse en B
\begin{frame}[fragile]{Question 18 \textemdash{} Priorité d'un processus}
    Pourquoi un système d'exploitation
attribue-t-il des \textbf{priorités}
différentes aux processus ?\medskip
    \begin{itemize}
        \item[A.] Aucune raison particulière
        \item[\alert<2>{B.}] \alert<2>{Pour s'assurer que les processus importants (interactifs, système) reçoivent davantage de temps processeur que les processus moins prioritaires (calculs en arrière-plan)}
        \item[C.] Pour des raisons de sécurité
        \item[D.] Pour faire plaisir aux développeurs
    \end{itemize}
\end{frame}

% Q19 - Réponse en A
\begin{frame}[fragile]{Question 19 \textemdash{} Lister les processus sous Windows}
    Comment afficher les processus actifs
sur \textbf{Windows} ?\medskip
    \begin{itemize}
        \item[\alert<2>{A.}] \alert<2>{Avec le Gestionnaire des tâches (raccourci Ctrl + Maj + Échap), ou avec la commande PowerShell \texttt{Get-Process}}
        \item[B.] Avec la commande \texttt{ps}
        \item[C.] Il est impossible d'observer les processus sous Windows
        \item[D.] En éteignant et en rallumant Windows
    \end{itemize}
\end{frame}

% Q20 - Réponse en D
\begin{frame}[fragile]{Question 20 \textemdash{} Tracer les appels système}
    Quelle commande Linux permet de tracer
les \textbf{appels système} effectués par un
programme ?\medskip
    \begin{itemize}
        \item[A.] \texttt{ls}
        \item[B.] \texttt{grep}
        \item[C.] \texttt{top}
        \item[\alert<2>{D.}] \alert<2>{\texttt{strace}}
    \end{itemize}
\end{frame}

% Q21 - Réponse en D
\begin{frame}[fragile]{Question 21 \textemdash{} Conditions nécessaires à un interblocage}
    Quelles sont les \textbf{quatre conditions
nécessaires} pour qu'un interblocage
puisse se produire (selon Coffman,
$1971$) ?\medskip
    \begin{itemize}
        \item[A.] La mémoire, le processeur, le disque et le réseau
        \item[B.] Trois conditions seulement suffisent
        \item[C.] Aucune condition particulière
        \item[\alert<2>{D.}] \alert<2>{L'exclusion mutuelle, la détention et l'attente, la non-préemption et l'attente circulaire}
    \end{itemize}
\end{frame}

% Q22 - Réponse en B
\begin{frame}[fragile]{Question 22 \textemdash{} Réservoir de fils d'exécution}
    Pourquoi utiliser un \textbf{réservoir de
fils d'exécution} plutôt que créer un
nouveau fil pour chaque tâche ?\medskip
    \begin{itemize}
        \item[A.] Pour économiser sur l'achat du clavier
        \item[\alert<2>{B.}] \alert<2>{La création d'un fil d'exécution a un coût (allocation de mémoire, mise en place d'un contexte). Un réservoir réutilise un nombre fixe de fils pour de nombreuses tâches, ce qui réduit ce coût et limite le degré de concurrence}
        \item[C.] Il n'y a aucun avantage à utiliser un réservoir
        \item[D.] Pour avoir un nombre illimité de fils d'exécution
    \end{itemize}
\end{frame}

% Q23 - Réponse en B
\begin{frame}[fragile]{Question 23 \textemdash{} Producteurs et consommateurs}
    En quoi consiste le motif des
\textbf{producteurs et consommateurs} ?\medskip
    \begin{itemize}
        \item[A.] Une optimisation de la mémoire
        \item[\alert<2>{B.}] \alert<2>{Il s'agit d'un patron dans lequel des producteurs déposent des éléments dans une file partagée (avec verrou) et des consommateurs retirent ces éléments pour les traiter. Cela permet de découpler la production de la consommation}
        \item[C.] Un patron sans intérêt pratique
        \item[D.] C'est un motif d'achat-vente
    \end{itemize}
\end{frame}

% Q24 - Réponse en A
\begin{frame}[fragile]{Question 24 \textemdash{} Choisir entre multiprocessing et fils d'exécution}
    Pour du \textbf{calcul intensif} en Python,
faut-il préférer les fils d'exécution
ou les processus ?\medskip
    \begin{itemize}
        \item[\alert<2>{A.}] \alert<2>{Les processus, par exemple avec le module \texttt{multiprocessing} ou avec \texttt{concurrent.futures.ProcessPoolExecutor}, qui contournent le verrou global en utilisant de vrais processus séparés}
        \item[B.] Uniquement le module asyncio
        \item[C.] Aucune des deux solutions ne convient
        \item[D.] Toujours les fils d'exécution
    \end{itemize}
\end{frame}

% Q25 - Réponse en C
\begin{frame}[fragile]{Question 25 \textemdash{} Synthèse}
    Parmi les affirmations suivantes sur
les processus et les fils d'exécution,
laquelle est \textbf{fausse} ?\medskip
    \begin{itemize}
        \item[A.] Plusieurs fils d'exécution d'un même processus partagent la mémoire
        \item[B.] Un interblocage requiert la conjonction des quatre conditions de Coffman
        \item[\alert<2>{C.}] \alert<2>{Une course critique est résolue automatiquement par le système d'exploitation}
        \item[D.] Un processus dispose de sa propre mémoire isolée
    \end{itemize}
\end{frame}

% Q26 - Réponse en D
\begin{frame}[fragile]{Question 26 \textemdash{} Appel système}
    Qu'appelle-t-on un \textbf{appel système}
(\textit{system call}) ?\medskip
    \begin{itemize}
        \item[A.] Une fonction interne au programme
utilisateur

        \item[B.] Un appel téléphonique automatisé

        \item[C.] Un protocole de communication
réseau

        \item[\alert<2>{D.}] \alert<2>{Une demande de service adressée
par un programme au noyau du
système d'exploitation, par
exemple pour ouvrir un fichier,
allouer de la mémoire, créer un
processus ou communiquer sur le
réseau
}
    \end{itemize}
\end{frame}

% Q27 - Réponse en C
\begin{frame}[fragile]{Question 27 \textemdash{} Mémoire virtuelle}
    Pourquoi les systèmes d'exploitation
modernes utilisent-ils la \textbf{mémoire
virtuelle} pour les processus ?\medskip
    \begin{itemize}
        \item[A.] Pour économiser de l'électricité

        \item[B.] Parce que la mémoire physique
n'existe plus dans les
ordinateurs modernes

        \item[\alert<2>{C.}] \alert<2>{Pour donner à chaque processus
l'illusion d'un espace mémoire
contigu et privé, en mappant les
adresses virtuelles utilisées par
le processus sur des adresses
physiques réelles ; cela permet
aussi l'isolation entre processus
et la possibilité de gérer plus
de mémoire que la mémoire physique
disponible (via le swap)
}
        \item[D.] Pour rendre les programmes plus
rapides à coder

    \end{itemize}
\end{frame}

\begin{frame}[standout]{}
    Fin de l'évaluation
\end{frame}

\end{document}
