Cours copiés au premier semestre

OS/3-ordonnancement.tex

@@ -0,0 +1,143 @@
+\chapter{Ordonnancement des processus}
+
+\section{Généralités}
+
+La durée de cycle d'un processus, c'est la durée moyenne d'un cycle de
+Von-Neuman non intérompu (pour des entrées/sorties).
+
+Globalement, pour un ordinateur grand public, la plus grande majorité
+des programmes se trouvent être majoritairement tributaire des
+entrées/sorties.
+
+\subsection{Ordonnancement et réquisition}
+
+Il existe deux familles d'ordonnanceurs : avec ou sans
+réquisitions. On parle alors de système coopératifs ou préemptifs.
+
+Pour commuter, il peut se passer deux choses :
+ - soit ce n'est pas un choix : le processus s'est bloqué pour une E/S
+ ou s'est terminé.
+ - un choix : par exemple lorsqu'un nouveau processus arrive ; passage
+ des états actifs ou bloqués à l'état prêt.
+
+Les ordonnanceurs sans réquisition ne passe la main à d'autres
+processus que dans le cas où un autre processus se bloque.
+Dans un système de ce type, on demande au programmeur de placer dans
+son code des yield, un appel système pour passer la main à un autre
+programme.
+
+Le problème d'un système préemptif c'est la synchronisation (il ne
+faudrait pas arrêter un processus en pleine transaction réseau ou
+lors d'un appel système, ...)
+Pour une horloge à temps fixe est nécessaire pour ce genre de système.
+
+\subsection{Critères d'ordonnancement}
+
+Pour tous les systèmes, les grandes lignes sont~:
+\begin{itemize}
+  \item \textbf{Équité~:} répartition du CPU entre processus différent
+    (faut-il donner autant de CPU à tous)
+  \item \textbf{Respect de politique~:} imposer les choix
+    d'ordonnacement. Regarder que tous les processus respectent bien
+    les règles d'ordonnancement définies.
+  \item \textbf{Équilibre~:} le choix de l'ordonnanceur ne doit pas
+    conduire à un trop grand nombre de périphériques inactifs.
+\end{itemize}
+
+Pour un système de traitement par lot, les grandes lignes sont
+plutôt~:
+\begin{itemize}
+  \item \textbf{Capacité de traitement/rendement~:} mombre de
+    processus exécutés par unité de temps.
+    \item \textbf{Temps de restitution/service~:} délai entre la
+      soumission d'un processus et sa terminaison (mise en mémoire,
+      atente en état prêt, attente E/S, exécution)
+\end{itemize}
+
+Pour des processus interactifs, les grandes lignes sont~:
+\begin{itemize}
+  \item \textbf{Temps de réponse~:} délai entre la soumission et le
+    moment où l'oin commence à répondre.\\
+    Paradoxalement, un processus plus long à s'exécuter peut être
+    préféré s'il répond plus vite.
+  \item \textbf{Temps d'attente~:} temps passé en état prêt.\\
+    C'est évidemment du gachi pour l'utilisateur.
+  \item \textbf{Proportionnalité~:} aux attentes des utilisateurs.\\
+    Répondre en fonction des critères de l'utilisateur. (commande
+    \texttt{nice}).
+\end{itemize}
+
+Dans le cas des systèmes temps réels, les deux critères importants
+sont~: le respect des dates limites (éviter la perte de données) et la
+prédictibilité (pour la stabilité des applications multimédia).
+
+\section{Algorithmes d'ordonnancement}
+
+\subsection{Premier arrivé premier servi}
+
+C'est le premier algorithme à avoir été implémenté, directement issue
+du traitement par lot.
+
+Il s'agit d'un algorithme sans réquistion. Il est facile à comprendre
+est facile à programmer.
+Il y a une file d'attente des processus « prêt ». C'est relativement
+optimal et peut couteux~: des simples mises à jour de pointeurs pour
+la gestion de la file.
+
+Il est intrinsèquement équitable pour des processus équivalent.
+
+Les problèmes de cet algo sont la grande variance dans les critères
+d'ordonnancement ; mais également l'effet d'accumulation~: les petits
+processus qui font de nombreux accès aux périphériques perdent
+énormément de temps car les périphériques sont inactifs le temps qu'un
+processus long s'exécute.
+
+
+\subsection{Plus court d'abord}
+
+Il s'agit d'un algorithme sans réquisition
+
+C'est le meilleur algo pour avoir un temps d'attente moyen minimal.
+
+Le problème de cet algo est que l'on est pas capable de
+l'implémenter, car on est pas capable de calculer la durée du prochain
+cycle :D
+
+Cet algo n'est pas adapté pour l'ordonnancement à court terme, mais
+reste valable pour les systèmes de traitement par lots.
+Étant donné qu'il est optimal, on peut l'utiliser pour benchmarker les
+autres types d'ordonnanceurs.
+
+\subsection{Ordonnancement avec priorité}
+
+
+\subsection{Tourniquet}
+
+Concu spécialement pour le temps partagé.
+C'est un FCFS avec réquisition sur une base de quantums (20-50ms).
+Il nécesite une horloge pour permettre d'être préamptif.
+
+Il y a quelques précautions à prendre~:
+  - Le quantum doit être grand par rapport au temps de commutation
+  - Le quantum ne doit pas être trop grand
+
+\subsection{Files d'attentes multi-niveau}
+
+On découpe la file d'attente des processus prêts en plusieurs files (processus système, interactifs, arrière-plan, ...)
+Il est donc possible d'utiliser un algorithme d'ordonnancement différent pour chaque file. On peut également ordonnancer les files entre-elles (priorité fixes, 
+allocation de tranches de temps, ...)
+
+Il est généralement utilisé conjointement avec un ordinnancement avec feedback (ou recyclage) comme algo de veillissement : il s'agit de la possibilité de 
+déplacer les processus d'une file d'attente à l'autre. L'implementation est légère.
+
+\subsection{Loterie}
+
+OVNI dans la théorie de l'ordonnancement.
+
+Chaque processus qui arrive dans la liste se voit attribuer un numéro, puis à intervalle régulier, il va choisir un processus aléatoirement.
+
+Il a quelques avantages :
+  - L'implémentation de priorité est légère : il suffit de lui donner deux tickets d'ordonnanceur ou plus !
+
+\subsection{Ordonnancement temps-réel}
+

OS/7-memoirevirtuelle.tex

@@ -0,0 +1,63 @@
+\subsection{Algorithme de l'ensemble de travail (WS), 1970}
+
+\textbf{Phénomène de localisation~:} l'ensemble des pages référencées
+dépend de \og phases\fg{} dans l'exécution.
+
+\subsection{Bufferisation}
+
+Maintenir un ensemble de cadres de pages libres en permanance.
+Lorsqu'un processus demande un nouveau cadre, on sélectionne une
+victime, mais on ne la supprime pas tout de suite.
+
+On attend que le MMU soit inactif pour le faire.\\
+
+Implémentation grâce à un \og paging daemon\fg.
+
+\section{Problèmes liés à la conception}
+
+\subsection{Politiques de sélection des pages}
+
+Deux politiques sont possibles~:
+\begin{itemize}
+  \item \textbf{Allocation globale~:} considérer toutes les pages
+    actuellement en mémoire.
+  \item  \textbf{Allocation locale~:} lorsque l'on choisit une
+    victime, on va chercher a supprimer une page du processus
+    courant.
+\end{itemize}
+
+\subsection{Répartition des cadres de page}
+
+\begin{itemize}
+  \item \textbf{Allocation équitable~:} chaque processus a un nombre
+    de cadres de pages identiques aux autres processus.
+  \item \textbf{Allocation proportionnelle~:} on alloue un nombre de
+    cadre de page en fonction de la taille du processus.
+  \item \textbf{Allocation mixte~:} on effectue une allocation
+    proportionelle, en regardant aussi la priorité du processus.
+  \item \textbf{Prépagination~:} on commence a allouer les premières
+    pages du processus (_start, main, ...) pour éviter le grand nombre
+    de défaut de page au lancement.
+\end{itemize}
+
+\subsection{Autres}
+
+\textbf{Contrôle de charge~:} gérer \og l'écroulement\fg{} (la somme
+des ensembles de travail dépasse la capacité
+mémoire). Swapping/refuser d'en faire plus...\\
+
+\paragraph{Pages partagées~:} en allocation locale, on peut supprimer une
+page partagée non utilisé dans un processus donné, mais très utilisée
+par d'autres processus.
+
+\paragraph{Structure des programmes~:} la manière dont on organise le
+code a une incidence sur le pagineur.
+
+\paragraph{Vérouillage des E/S~:} il faut a tout prix éviter
+l'éviction d'une page qui est en attente d'une E/S. Pour cela, on
+utilise le bit verrou.\\
+On peut aussi utiliser ce bit pour vérouiller les pages d'un programme
+nouvellement chargé en mémoire.
+
+\section{Problèmes liés à l'implémentation}
+

OS/8-FS.tex

@@ -0,0 +1,140 @@
+\chapter{Systèmes de fichiers}
+
+\section{Généralités}
+
+\begin{itemize}
+  \item Persistande des informations
+  \item Partage d'informations (entre les processus, ...)
+\end{itemize}
+
+La notion de fichier apporte une espace de stockage important, un
+stockage statique de l'information et une indépendance vis-à-vis des
+processus qui l'utilisent ou l'ont utilisés.
+
+\subsection{Structure}
+
+\begin{itemize}
+  \item \textbf{Fichiers~:} unité logique de stockage d'information.
+  \item \textbf{Répertoire~:} organisation logique de l'information.
+  \item \textbf{Partitions~:} organisation de plus haut niveau.
+\end{itemize}
+
+On a une vision logique et uniformisée de l'information. Les
+caractéristiques physiques du stockage font une abstraction des
+caractéristiques physiques.
+Les formats, type du système sont choisis par le créateur.
+
+\subsection{Méthodes d'accès}
+
+\subsubsection{Accès séquentiel}
+
+Méthode historique, basé sur le modèle des bandes magnétiques~:
+pointeur de lecteur/écriture (offset) automatiquement incrémenté. Et
+des privitives de positionnement (seek).
+
+\subsubsection{Accès direct/relatif}
+
+\og Random access\fg, modèle des disques durs.\\
+
+Les primitives de lecture et d'écriture sont paramétrées par un
+numéro de bloc relatif. Un fichier est vu comme un enregistrement de
+blocs de taille fixe.
+
+\subsubsection{Remarques}
+
+\begin{itemize}
+  \item Certains systèmes fournissent plusieurs méthodes d'accès,
+    comme IBM.
+  \item Le mode d'accès peut faire partie du type de fichier.
+  \item Il est trivial d'implémenter l'accès séquentiel à partir de
+    l'accès de l'accès direct.
+\end{itemize}
+
+\subsection{Table de fichiers (ouverts)}
+
+Mise en cache des descripteurs de fichiers actuellement utilisés
+
+\section{Organisation des systèmes de fichiers}
+
+\subsection{Macro-niveaux d'organisation}
+
+\begin{itemize}
+  \item \textbf{Partition~:} \og mini-disque\fg (chez IBM), \og
+    volume\fg (chez Mac).\\
+    Selon les systèmes, plusieurs partitions par disques, ou plusieurs
+    disques par partitions.
+  \item \textbf{Répertoire~:} analogue à une table des symboles.
+    Contient des informations sur les fichiers sous-jacents (nom,
+    emplacement, taille, type\ldots).
+\end{itemize}
+
+\subsection{Niveaux de répertoires}
+
+\subsubsection{Niveau 1}
+
+Structure simpliste d'une unique répertoire.
+
+On a des problèmes d'unicité des noms (11 caractères pour MS-DOS et
+255 pour Unix).
+
+\subsubsection{Niveau 2}
+
+Un répertoire principal (\og MFD\fg) contient des répertoires
+utilisateurs (\og UFD\fg). Accès implicite à son propre UFD.
+
+On voit apparaître la notion de session (login/password).
+
+\subsubsection{Nommage}
+
+\paragraph{MS-DOS~:} \verbatim{C:\dupont\test.exe}
+\paragraph{Unix~:} \verbatim{/var/spool/mail/dupont}
+\paragraph{VAX-VMS~:} \verbatim{u:[dir1.dir2]foo.com;1}
+
+\section{Méthode d'allocation}
+
+\subsection{Allocation contiguë}
+
+Les fichiers sont stockés par blocs contigus sur le disque.\\
+
+Le temps de positionnement des têtes est minimal. Accès direct et
+séquentiel faciles à implémenter.
+
+Problèmes~: fragmentation interne s'il y a trop d'espace ; pas assez
+d'espace~: déplacement couteux des fichiers ; pas toujours possible.\\
+
+Utilisé sur les CD et DVD.
+
+\subsection{Allocation chaînée}
+
+Chaque bloc se termine par un pointeur sur le bloc suivant.\\
+
+Une entrée de répertoire contient un pointeur sur le premier bloc.
+
+Pas de fragmentation externe, pas de limite de taille. Mais accès
+direct inefficasse. Au niveau de la fiabilité, la perte d'un pointeur
+est critique.
+
+\subsection{File Allocation Table (FAT)}
+
+Il y a une FAT au début de chaque partition. Il s'agit d'une table
+indexée par numéros de bloc. Chaque entrée pointe sur le numéro de
+bloc suivant.
+
+Une entrée de répertoire contient un pointeur sur le premier bloc.
+
+\subsection{Allocation indexée}
+
+Chaque fichier possède un bloc d'index.
+
+Une entrée de répertoire pointe sur le bloc d'index
+
+La ie entrée du bloc d'index pointe sur le ue bloc de donnée du
+fichier.
+
+La table des i-nodes est de taille proportionnelle au nombre de
+fichiers.
+
+Par contre, la fragmentation interne est plus grande qu'avec
+l'allocation chaînée et un problème de taille des inodes.
+
+\section{Performances des systèmes de fichiers}