\thumb

\begin{qcm}{Connaître le cours}{5} % titre , temps
Pour chaque question, 4 propositions de réponses sont faites. Une seule est correcte. Laquelle ?
\begin{questions}
\item Un processeur peut atteindre 3,5 GHz. Cela correspond à combien de cycles d'horloge par seconde ?

\choix \numprint{3500000000}

\choix \numprint{3500000}

\choix \numprint{3500000000000}

\choix \numprint{3500}

\item \resetchoix Dans l'architecture de Von Neumann, l'UAL est généralement représentée par :

\choix un \og N \fg{} 

\choix un \og V \fg{} 

\choix un \og C \fg{} 

\choix un \og U \fg{} 

\item\resetchoix Une UAL ne peut pas :

\choix faire des additions

\choix calculer des puissances entières de nombres entiers

\choix faire des racines carrées

\choix faire des opérations logiques

\item\resetchoix Dans le protocole TCP/IP, il y a :

\choix 3 couches

\choix 4 couches

\choix 5 couches

\choix 7 couches
\end{questions}
\end{qcm}

\begin{corrige}
\begin{questions}
\item Réponse \choix[a]. Une fréquence de 3,5 GHz correspond à $3,5\times10^9$ cycles d'horloge, soit \numprint{3500000000}.

\item Réponse \choix[b]. La représentation conventionnelle d'une UAL est un \og V \fg. 

\item Réponse \choix[c]. Une UAL ne peut pas faire des racines carrées car elle ne peut faire que des additions, soustractions, multiplications (donc les calculs de puissances entières sont possibles) et divisions.

\item Réponse \choix[b]. Dans le protocole TCP/IP, il y a 4 couches :  \og Accès\linebreak réseau \fg, \og Internet \fg, \og Transport \fg{} et \og Application \fg.
\end{questions}
\end{corrige}

%%% 2

\begin{vf}{Connaître le cours}{5} % titre , temps
Indiquer si les propositions suivantes sont vraies ou fausses.
\begin{questions}
\item Dans l'architecture de Von Neumann, l'unité de commande donne les ordres aux autres parties.

\item Une carte réseau possède une adresse IP.

\item Le réseau d'un établissement scolaire comme un lycée est un réseau PAN.

\item La topologie en étoile est la topologie réseau la plus répandue. 
\end{questions}
\end{vf}

\begin{corrige}
\begin{questions}
\item La proposition est \textit{vraie}. Des 4 parties, l'unité de commande agit comme le cerveau de la machine : c'est elle qui décide ce qui doit être fait. Elle donne donc les ordres.

\item La proposition est \textit{fausse}. Une carte réseau possède une adresse MAC, mais pas une adresse IP.

\item La proposition est \textit{fausse}. Un réseau PAN est un réseau que l'on peut retrouver chez soi par exemple, mais pas dans une structure à la taille d'un lycée. Il s'agit plutôt d'un réseau LAN.

\item  La proposition est \textit{vraie}. En effet, la topologie en étoile est facile à mettre en place et un dysfonctionnement d'un poste n'entraîne pas le plantage du réseau tout entier, ce qui constitue un avantage majeur de cette topologie.
\end{questions}
\end{corrige}

%%% 3

\begin{exo}{IPv4 et IPv6}{Lycée François Villon, Les Mureaux}{1}{5} 
\begin{questions}
\item Quel est le format d'une adresse IPv4 ? 

Sur combien de bits est codée une adresse IPv4 ?

\item En déduire le nombre total d'adresses IPv4 disponibles en théorie. 

Est-ce suffisant à l'heure actuelle ?

\item Mêmes questions avec IPv6.
\end{questions}
\end{exo}

\begin{corrige}
\begin{questions}
\item Une adresse IPv4 est composée de 4 octets, et représentée par 4 nombres décimaux de 0 à 255 séparés par un point (format décimal pointé). Chaque octet correspondant à 8 bits, une adresse IPv4 est codée sur 32 bits.

Ainsi, une adresse IPv4 comme 192.168.1.1 se représenterait ainsi : 

\begin{center}
11000000.10101000.00000001.00000001
\end{center}

\item Il y a 256 possibilités pour chaque octet, soit un total de 
\[
256^4=2^{32}=\numprint{4294967296}
\]
adresses IPv4 possibles.

\newpage

De plus, il faut retirer les adresses réservées, ainsi que les adresses de réseau et les masques, ce qui fait encore moins. On constate donc que quatre milliards d'adresses sont insuffisantes pour adresser de manière unique toutes les machines sur internet.

\item Une adresse IPv6 est composée de 16 octets, soit 128 bits. Il y a 2 possibilités pour chaque bit (0 ou 1). Il y a donc $2^{128}\approx3,4\times10^{38}$ IPv6 possibles, ce qui semble très largement suffisant.
\end{questions}
\end{corrige}


%%%


\begin{exo}{La commande chmod sous Linux}{\null}{2}{10} 
\NathanLiveVideo[\PictoVideo\ Retrouvez plus d'explications sur la commande chmod sous Linux en vidéo.]{commande chmod sous Linux}{https://media.prepamath.fr/IL1NSIch06exChmod}

\qrset{height=1.1cm,version=5}\rput(-1,0.8){
\psframebox{\qrcode{https://media.prepamath.fr/IL1NSIch06exChmod}}}
\vspace*{-20pt}

Sous Linux, il existe trois groupes d'utilisateurs :
\begin{itemize}
\item propriétaire;
\item groupe du propriétaire;
\item autre.
\end{itemize}

Pour chaque fichier, il y a trois types de droits :
\begin{itemize}
\item \textit{r} : droit de lecture (\og r \fg{} pour \textit{read});
\item \textit{w} : droit d'écriture (\og w \fg{} pour \textit{write});
\item \textit{x} : droit d'exécution (\og x \fg{} pour... la consonance !).
\end{itemize}

À chaque fichier, on attribue un triplet de 3 bits représentant le droit de chaque groupe. Par exemple, \og 111 101 100 \fg{} signifie que :
\begin{itemize}
\item le propriétaire a tous les droits (111 = 7 en décimal);
\item le groupe a le droit de lecture et d'exécution (101 = 5 en décimal);
\item les autres ont le seul droit de lecture (100 = 4 en décimal).
\end{itemize}

Pour donner ces droits, on peut utiliser la commande \textit{chmod} ainsi :
\begin{center}
\texttt{chmod 754 monfichier.sh}.
\end{center}
\begin{questions}
\item Quelle ligne de commande un propriétaire souhaitant donner tous les droits à tout le monde doit-il écrire ?
\item Que doit-il écrire pour se donner tous les droits sans en donner un seul aux autres ?
\item Il écrit : \texttt{chmod 123 fichier.ext}; quels droits a-t-il donné ?
\end{questions}
\end{exo}

\begin{corrige}
\begin{questions}
\item \qrset{height=1.1cm,version=5}\rput(-1.5,-0.4){
\psframebox{\qrcode{https://media.prepamath.fr/IL1NSIch06exChmod}}}
\vspace*{-16pt}

Si tous les droits sont à donner à tout le monde, cela se traduit par le\linebreak triplet binaire 111 111 111, soit 777 en décimal. 

Le propriétaire du fichier devra alors taper :
\begin{center}
\texttt{chmod 777 fichier.ext}
\end{center}

\item Si lui seul a tous les droits, cela se traduit par le triplet binaire\linebreak 111 000 000, soit 700 en décimal. Il devra donc taper :
\begin{center}
\texttt{chmod 700 fichier.ext}
\end{center}

\item Le nombre décimal 123 correspond au triplet binaire 001 010 011. Il s'est donc donné le seul droit d'exécution, puis a donné le droit d'écriture à son groupe, et enfin a donné les droits d'exécution et d'écriture à tous les autres... ce qui n'est pas très malin!
\end{questions}

\begin{Remarque}
pour modifier de façon plus rapide les droits, on peut utiliser la manière symbolique : \texttt{chmod [ugoa]$\pm$[rwx]}, le premier argument étant une des lettres entre les crochets.
\begin{itemize}
\item \og u \fg{} pour \textit{user}  : le propriétaire;
\item \og g \fg{} pour \textit{group} : le groupe;
\item \og o \fg{} pour \textit{others} : les autres;
\item \og a \fg{} pour \textit{all} : tout le monde.
\end{itemize} 
Ainsi, en écrivant \texttt{chmod u+w fichier.ext}, il se redonne le droit d'écriture. En écrivant \texttt{chmod o-w, o-x, o+r}, il enlève les droits d'exécution et d'écriture, et ajoute les droits de lecture.
\end{Remarque}
\end{corrige}
%%%

\begin{exo}{Ordinateur virtuel et mémoire}{Lycée François Mauriac, Bordeaux}{2}{20} 
On imagine un ordinateur ultra simplifié d'une mémoire centrale constituée d'un tableau de 32 cellules, chacune d'elles étant constituée d'un octet. Chaque instruction est constituée d'un code opération sur 3 bits et d'une partie adresse sur 5 bits.

On dispose du tableau d'instructions suivant :

\Par

\begin{center}
\begin{tabular}{|Zc|Zc|}
\tabulartitle\hline
Instruction & Effet\\
\hline
LD X & Lit le contenu de la cellule X (ACC $\leftarrow$ M[X])\\
\hline
STO X & Enregistre dans la cellule X (M(X] $\leftarrow$ ACC)\\
\hline
ADD X & Ajoute le contenu de la cellule X (ACC $\leftarrow$ ACC+M[X])\\
\hline
SUB X & Soustrait le contenu de la cellule X\\
\hline
JMP ADR & Saute à l'adresse ADR (CO $\leftarrow$ A)\\
\hline
JMPZ ADR & Saute à l'adresse ADR si nul\\
\hline
JMPP ADR & Saute à l'adresse ADR si positif\\
\hline
JMPN ADR & Saute à l'adresse ADR si négatif\\
\hline
\end{tabular}
\end{center}

\Par

On considèrera qu'un programme commence à l'adresse 8, les adresses de 0 à 7 étant réservées au stockage des données.
\begin{questions}
\item Que fait le programme suivant :
\begin{center}
\begin{tabular}{|Zc|Zc|}
\tabulartitle\hline
Adresse & Contenu\\
\hline
0 & 48\\
\hline
1 & 37\\
\hline
... & ...\\
\hline
8 & LD 0\\
\hline
9 & SUB 1\\
\hline
10 & STO 2\\
\hline
11 & END\\
\hline
\end{tabular}
\end{center}

\item On suppose qu'une valeur est dans la case mémoire 0, et une autre dans la case mémoire 1.

\'Ecrire un programme qui lit celle de la case mémoire 1, qui la compare à celle de la case mémoire 0 et si elle est supérieure ou égale, l'écrit dans la case mémoire 2.

\item \'Ecrire un programme qui lit une valeur $x$ dans la case mémoire 0, et qui calcule le plus grand exposant $n$ tel que $2^n<x$ pour le stocker en case mémoire 2.
\end{questions}
\end{exo}

\begin{corrige}
\begin{questions}
\item Le programme commence par lire la donnée dans la cellule 0 (donc 48), puis soustrait le contenu de la cellule 1 ($48-37=11$), et enfin stocke le résultat (11) dans la cellule 2.
\newpage
\item On a le programme suivant :
\begin{center}
\begin{tabular}{|Zc|Zc|Zc|}
\tabulartitle\hline
Adresse & Contenu & Interprétation\\
\hline
0 & $x$ & \\
\hline
1 & $y$ & \\
\hline
$\vdots$ & $\vdots$ & \\
\hline
8 & LD 1 & Lit $y$\\
\hline
9 & SUB 0 & Calcule $y-x$\\
\hline
10 & JMPP 12 & Si $y-x>0$, va en 13\\
\hline
11 & JMPZ 12 & Si $y-x=0$, va en 13\\
\hline
12 & JMPN 14 & Si $y-x<0$, va en 14\\
\hline
13 & STO 2 & Stocke le résultat en 2\\
\hline
14 & END & Fin du programme\\
\hline
\end{tabular}
\end{center}

\item Le programme est le suivant :

\begin{center}
\begin{tabular}{|Zc|Zc|Zc|}
\tabulartitle\hline
Adresse & Contenu & Interprétation\\
\hline
0 & $x$ & \\
\hline
1 & 1 & $v$ : valeur courante de $2^n$ (initialement $2^0=1$) \\
\hline
2 & 0 & exposant $n$ (initialement 0)\\
\hline
3 & 1 & valeur d'incrément pour $n$ \\
\hline
$\vdots$ & $\vdots$ & \\
\hline
8 & LD 1 & Lit $v = 2^n$\\
\hline
9 & SUB 0 & Calcule $2^n-x$\\
\hline
10 & JMPP 19 & Si $2^n-x>0$, va en 19 \\
\hline
11 & JMPZ 19 & Si $2^n-x=0$, va en 19 \\
\hline
12 & LD 2 & Lit $n$ \\
\hline
13 & ADD 3 & Incrémente $n$ \\
\hline
14 & STO 2 & Stocke la nouvelle valeur de $n$ \\
\hline
15 & LD 1 & Lit $v = 2^n$ courant \\
\hline
16 & ADD 1 & Multiplie par 2 \\
\hline
17 & STO 1 & Stocke nouvelle valeur de $2^n$ \\
\hline
18 & JMP 9 & Retour en 9 pour nouvelle itération \\
\hline
19 & LD 2 & Lit $n$ \\
\hline
20 & SUB 3 & Décrémente $n$ \\
\hline
21 & STO 2 & Stocke la plus grande valeur $n$ telle que $2^n<x$ \\
\hline
22 & END & Fin du programme \\
\hline
\end{tabular}
\end{center}
\end{questions}
\end{corrige}

% NEW 2025

\begin{exo}{Adressage IP et sous-Réseaux \newexo}{Lycée Richelieu, Versailles}{2}{20}
Un réseau est caractérisé par son \textit{masque de sous-réseau} (\textit{subnet mask}) est une adresse dont la représentation binaire est de la forme \fbox{\texttt{1...1 0...0}}, c'est-à-dire une suite de \texttt{1} ininterrompue suivie d'une suite de \texttt{0} ininterrompue. Ce masque permet de séparer une adresse IP en deux parties (\textit{composante réseau} et \textit{composante hôtes}) et de retrouver, dans une adresse IP, la partie désignant le réseau lui-même (les bits du masque égaux à \texttt{1}) et celle désignant les hôtes (les bits du masque égaux à \texttt{0}).
\begin{questions}
\item Représenter en binaire l’adresse 255.255.0.0 et vérifier que c’est un masque de sous-réseau valide.
\item Quel est le nombre de machines adressables au total dans ce sous-réseau ?
\item Mêmes questions pour le masque 255.255.248.0.
%\item Indiquer si les adresses IP suivantes appartiennent au même sous-réseau que celui de la question précédente :
%\begin{center}
%192.168.129.10, 192.168.135.200 et 192.168.145.1
%\end{center}
\end{questions}
\end{exo}

\begin{corrige}
\begin{questions}
%Q1
\item Pour représenter l'adresse 255.255.0.0 en binaire, nous devons convertir chaque octet en binaire :
\begin{itemize}
\item 255 en binaire est 11111111;
\item 0 en binaire est 00000000.
\end{itemize}
Donc, 255.255.0.0 en binaire est :
\begin{center}
11111111.11111111.00000000.00000000
\end{center}

Pour être un masque de sous-réseau valide :
\begin{itemize}
\item tous les bits de la partie \og 1 \fg{} (bits de réseau) doivent être en continu, sans interruption;
\item tous les bits de la partie \og 0 \fg{} (bits d’hôtes) doivent être également en continu.
\end{itemize}

L’adresse binaire 11111111.11111111.00000000.00000000 respecte bien cette règle, car les 16 premiers bits sont des 1 (partie réseau), suivis de 16 bits à 0 (partie hôtes).

%Q2
\item Dans un masque de sous-réseau, les bits à 1 représentent la partie réseau, et les bits à 0 représentent la partie hôtes.

\Par

Dans 255.255.0.0, les 16 premiers bits sont à 1 (partie réseau). Les 16 derniers bits sont à 0 (partie hôtes).

Ainsi, il y a 16 bits pour les hôtes.

\Par

Le nombre total d’adresses possibles est donné par $2^n$, où $n$ est le nombre de bits pour les hôtes:
\[
2^{16} = \numprint{65536}\text{ adresses possibles.}
\]

Dans chaque sous-réseau, deux adresses sont réservées :
\begin{itemize}
\item l'adresse réseau (où tous les bits d’hôtes sont à 0);
\item l'adresse de \textit{broadcast} (où tous les bits d’hôtes sont à 1).
\end{itemize}

Le nombre d’adresses utilisables pour les machines est donc :
\[
\numprint{65536}-2 = \numprint{65534}\text{ machines adressables.}
\]

\item En binaire, 255.255.248.0 est :
\begin{center}
11111111 11111111 11111000 00000000.
\end{center}

Ce réseau peut comporter $2^{11}-2 = 2~046$ hôtes.
\end{questions}
\end{corrige}

% NEW 2025

\begin{exo}{Architecture Von Neumann \newexo}{Lycée François Mauriac, Bordeaux}{3}{30}
L'objectif de cet exercice est d'appliquer vos connaissances sur l'architecture Von Neumann et les interactions avec les systèmes d'exploitation en analysant et en simulant des opérations simples.

\begin{itemize}
    \item \textit{Initialisation de la mémoire :} vous disposez d'une mémoire centrale organisée en 16 cellules, où chaque cellule peut contenir une instruction ou une donnée. Le contenu initial de la mémoire est le suivant :
    \begin{verbatim}
    Adresse | Contenu
    --------|--------
    0       | 10 (X)
    1       | 20 (Y)
    2       | 0  (Résultat Z)
    3       | LD 0
    4       | ADD 1
    5       | STO 2
    6       | END
    \end{verbatim}
    
    \item \textit{Instructions disponibles :}
    \begin{itemize}
        \item \texttt{LD X} : charge la valeur de l'adresse \texttt{X} dans l'accumulateur.
        \item \texttt{ADD X} : ajoute la valeur de l'adresse \texttt{X} à l'accumulateur.
        \item \texttt{SUB X} : soustrait la valeur de l'adresse \texttt{X} à l'accumulateur.
        \item \texttt{STO X} : stocke la valeur de l'accumulateur à l'adresse \texttt{X}.
        \item \texttt{END} : arrête l'exécution.
    \end{itemize}
\end{itemize}

\begin{questions}
    \item Décrivez pas à pas l'exécution de ce programme en précisant le contenu de l'accumulateur et les modifications apportées à la mémoire après chaque instruction.

    \item Proposez une modification de ce programme pour calculer \texttt{Z = X - Y} au lieu de \texttt{Z = X + Y}.

    \item Imaginez que ce programme soit exécuté sur une architecture multi-cœur. Expliquez comment cette architecture pourrait améliorer les performances si plusieurs programmes similaires doivent être exécutés en parallèle.
    
    \item Implémentez une version en pseudo-assembleur pour calculer\linebreak \texttt{Z = X × Y}, en supposant que l'instruction \texttt{MUL X} soit disponible.
\end{questions}

\end{exo}

\begin{corrige}
\begin{questions}
\item 
\begin{itemize}
\item Instruction \texttt{LD 0} : charge \texttt{10} dans l'accumulateur.

\Par

\item Instruction \texttt{ADD 1} : ajoute \texttt{20} à l'accumulateur, qui contient maintenant \texttt{30}.

\Par

\item Instruction \texttt{STO 2} : stocke \texttt{30} à l'adresse \texttt{2}.

\Par

\item Instruction \texttt{END} : arrête le programme.
\end{itemize}

Nous avons donc l'état final de la mémoire suivant:

\textbf{État final de la mémoire :}

\begin{verbatim}
Adresse | Contenu
--------|--------
0       | 10
1       | 20
2       | 30
3       | LD 0
4       | ADD 1
5       | STO 2
6       | END
\end{verbatim}

\item Voici une modification du programme précédent pour calculer\linebreak \texttt{Z = X - Y} au lieu de \texttt{Z = X + Y}: 
\begin{verbatim}
3       | LD 0
4       | SUB 1
5       | STO 2
6       | END
\end{verbatim}

\item Dans une architecture multi-cœur, plusieurs instances de ce programme pourraient être exécutées en parallèle, chaque cœur traitant une instance distincte. Cela permettrait de traiter simultanément plusieurs calculs indépendants, réduisant ainsi le temps total d'exécution.

\item Voici une version en pseudo-assembleur pour calculer \texttt{Z = X × Y}, en supposant que l'instruction \texttt{MUL X} soit disponible:
\begin{verbatim}
3       | LD 0
4       | MUL 1
5       | STO 2
6       | END
\end{verbatim}
\end{questions}

\end{corrige}

\thumb
\AfficheCorrige
