diff --git a/content/courses/os-ueve/se-01.pdf b/content/courses/os-ueve/se-01.pdf new file mode 100644 index 0000000..d0f2a67 Binary files /dev/null and b/content/courses/os-ueve/se-01.pdf differ diff --git a/content/courses/os-ueve/se-02.pdf b/content/courses/os-ueve/se-02.pdf new file mode 100644 index 0000000..ed9a10c Binary files /dev/null and b/content/courses/os-ueve/se-02.pdf differ diff --git a/content/courses/os-ueve/se-03.pdf b/content/courses/os-ueve/se-03.pdf new file mode 100644 index 0000000..9cb7b0b Binary files /dev/null and b/content/courses/os-ueve/se-03.pdf differ diff --git a/content/courses/os-ueve/se-04.pdf b/content/courses/os-ueve/se-04.pdf new file mode 100644 index 0000000..ca2394c Binary files /dev/null and b/content/courses/os-ueve/se-04.pdf differ diff --git a/content/courses/os-ueve/semaphores.py b/content/courses/os-ueve/semaphores.py new file mode 100644 index 0000000..2b39f41 --- /dev/null +++ b/content/courses/os-ueve/semaphores.py @@ -0,0 +1,111 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +"""Un exemple d'utilisation de sémaphores pour synchroniser des tâches. + +Ce code définit 4 tâches qui devront être exécutées selon la relation +de précédence suivante : + + T1 < T2, T1 < T3, T2 < T4, T3 < T4 + +Le graphe de précédence pour ces tâches forme donc un diamant : + + +-----> T2 -----+ + | | + | \/ + T1 T4 + | /\ + | | + +-----> T3 -----+ + +Ce fichier montre l'utilisation de sémaphores pour assurer l'exécution +de ces 4 tâches dans un ordre qui satisfait cette spécification de +précédence. + + +Cours « Systèmes d'exploitation ». + +Sergiu Ivanov + +""" + +# La librairie de gestion de fils d'exécution. +import threading + + +# Définir 4 sémaphores, un par tâche. +t1_finie = threading.Semaphore(); +t2_finie = threading.Semaphore(); +t3_finie = threading.Semaphore(); +t4_finie = threading.Semaphore(); + +# Le sémaphore ti_finie est relâché à la fin de la tâche Ti. Il est +# donc nécessaire de les acquérir tous au début. +t1_finie.acquire(); +t2_finie.acquire(); +t3_finie.acquire(); +t4_finie.acquire(); + + +# Nos tâches. +# +# Chaque tâche commence par vérifier que les tâches dont elle dépend +# ont fini leur exécution. À la fin de l'exécution, chaque tâche +# relâche le sémaphore qui lui est associé. + +def t1(): + # Tâche initiale, aucune vérification. + + print("Ceci est la tâche T1") + + t1_finie.release(); + +def t2(): + # Cette opération sera bloquée si le sémaphore t1_finie n'est pas + # encore relâché. + t1_finie.acquire(); + + # Si nous sommes arrivés ici, nous savons que le sémaphore + # t1_finie a été relâché. Ne le gardons pas pris, relâchons-le + # pour que les autres puissent avoir les signal. + t1_finie.release(); + + print("Ceci est la tâche T2") + + t2_finie.release(); + +def t3(): + t1_finie.acquire(); + t1_finie.release(); + + print("Ceci est la tâche T3") + + t3_finie.release(); + +def t4(): + # La tâche T4 dépend des tâches T3 et T4 ; on vérifiera donc deux + # sémaphores. + t2_finie.acquire(); + t2_finie.release(); + + t3_finie.acquire(); + t3_finie.release(); + + print("Ceci est la tâche T4") + + t4_finie.release(); + + +# Créer un objet Thread (fil d'exécution) pour chacune de nos tâches. +# +# Les fils ne sont pas encore lancés. +t1_thread = threading.Thread(target = t1) +t2_thread = threading.Thread(target = t2) +t3_thread = threading.Thread(target = t3) +t4_thread = threading.Thread(target = t4) + +# Lancer les fils d'exécution dans un ordre quelconque, pas +# nécessairement correspondant au graphe de précédence exigé. +t4_thread.start() +t3_thread.start() +t2_thread.start() +t1_thread.start() diff --git a/content/courses/os-ueve/ton-paire.cpp b/content/courses/os-ueve/ton-paire.cpp new file mode 100644 index 0000000..bb29a2d --- /dev/null +++ b/content/courses/os-ueve/ton-paire.cpp @@ -0,0 +1,39 @@ +/* + * Un exemple d'utilisation de fork, sleep et waitpid. + * + * Cours « Systèmes d'exploitation ». + * + * Sergiu Ivanov + */ + +#include // pour avoir printf +#include // pour avoir fork +#include // pour avoir waitpid + +int main() { + // fork crée une copie du processus actuel. Après cette ligne il y + // aura deux processus qui exécuteront le code ci-dessous. + // + // Dans le processus qui a initié la création (le père), fork + // renverra le numéro unique (le PID) du processus créé (le + // fils). Dans le fils, fork renverra 0. + int pidFils = fork(); + + if(pidFils == 0) { + // fork a renvoyé 0, donc ce code est exécuté dans le fils. + printf("Coucou, papa"); + + // Attendre 1 seconde pour faire semblant de travailler dur. + sleep(1); + } else { + // On utilisera la fonction waitpid pour attendre. On doit lui + // passer le PID du fils, ainsi que deux autres paramètres de + // service. + int status; // le code de retour du fils; + waitpid(pidFils, &status, 0); // attente fin du fils + + printf("Je suis ton paiiiire !"); + } + + return 0; +} diff --git a/en/home.org b/en/home.org index 8fb9f30..dc8255b 100644 --- a/en/home.org +++ b/en/home.org @@ -62,7 +62,7 @@ Jump to: Here is a list of courses I prepared: - [[file:latex-intro.org][introduction to LaTeX]] - - operating systems + - [[file:os-ueve.org][operating systems]] - a very quick introduction to artificial life - Petri nets for biomodelling - introduction to Cytoscape diff --git a/en/os-ueve.org b/en/os-ueve.org new file mode 100644 index 0000000..9ad5af4 --- /dev/null +++ b/en/os-ueve.org @@ -0,0 +1,93 @@ +#+TITLE: Operating Systems + +#+LANGUAGE: en + +#+ATTR_HTML: :alt in French :class lang-lifted +[[file:../fr/os-ueve.org][file:../content/imgs/fr.png]] + +The goal of this course is to discuss two of the many fundamental +domains in which operating systems must operate: asynchronous +input/output (I/O), and parallelism and concurrency. The course starts +with a brief presentation of large classes of operating systems and +their historic evolution. Then asynchronous, interrupt-driven, and +buffered I/O is discussed. Finally, algorithms for maximising +parallelism and deadlock handling and avoidance are shown and +analysed. + +This course is taught in French to the students of [[https://www.univ-evry.fr/formation/loffre-de-formation/domaines-de-formation/domaine/sciences-technologies-sante/programme/licence-mention-informatique-1.html][L3 informatique]] +(3rd year of bachelor education) at [[http://www.univ-evry.fr/fr/index.html][Université d'Évry]]. Basic +understanding of the computer architecture as well as some programming +experience are required. + +This course is strongly based upon [[https://www.ibisc.univ-evry.fr/~delosme/][Jean-Marc Delosme]]'s notes about +operating systems. Starting with the school year 2018/2019, the course +includes more practical demonstrations and assignments. + +The following sections briefly describe the 4 main chapters of the +course, as well as 2 executable code examples. + +#+ATTR_HTML: :alt image of Creative Commons Attribution Alone licence :class ccby +[[https://en.wikipedia.org/wiki/Creative_Commons_license][file:../content/imgs/ccby.png]] + +The materials of this course are distributed under the [[https://en.wikipedia.org/wiki/Creative_Commons_license][Creative +Commons Attribution Alone licence]]. + + +* Introduction + This chapter introduces the basic terminology used in the study, + design, and development of operating systems: computer system, + operating system, physical machine, abstract machine, etc. Some of + the essential functions of the operating systems are enumerated, + then a generic classification and the historic development of + operating systems are described. + + The slides for this chapter (in French) are available [[file:../content/courses/os-ueve/se-01.pdf][here]]. + +* Execution and communication mechanisms + This chapter describes the design of the communication in a + concurrent and asynchronous open system. The object of study of this + part are the interruptions, hardware and software (including + supervisor calls). Some classical applications of interruptions are + shown, including pseudoparallel process scheduling and buffered + input/output. + + The slides for this chapter (in French) are available [[file:../content/courses/os-ueve/se-02.pdf][here]]. + +* Processes. Models of representation + This chapter defines the notion of a process and describes its role + and its technical representation inside an operating system. The + chapter starts with a technical discussion and transitions into the + abstract model of systems of concurrent tasks. Sequential and + parallel composition operations are then considered. + + The slides for this chapter (in French) are available [[file:../content/courses/os-ueve/se-03.pdf][here]]. + + This chapter comes with a runnable [[file:../content/courses/os-ueve/ton-paire.cpp][code example]] (comments in French) + showing how to use =fork= to create new processes. + +* Process interaction + This chapter focuses on two fundamental issues of any concurrent + system: maximal parallelism and deadlocks. Maximal parallelism is + considered in the framework of systems of tasks. An algorithm for + constructing a maximally parallel system equivalent to a given one + is presented and analysed. Then, a different formal framework is + built for deadlock analysis and a deadlock detection algorithm is + shown. Finally, an approximate algorithm for deadlock avoidance is + described. + + The slides for this chapter (in French) are available [[file:../content/courses/os-ueve/se-04.pdf][here]]. + +* Semaphores + This part of the course aims to define and understand semaphores + through interactive development of a program synchronising several + threads. [[file:../content/courses/os-ueve/semaphores.py][This]] is the runnable code which is to be written by the end + of the interactive session (the inline comments are in French). + + +* Local Variables :noexport: + # Local Variables: + # org-link-file-path-type: relative + # eval: (auto-fill-mode) + # ispell-local-dictionary: "en" + # End: + diff --git a/fr/home.org b/fr/home.org index ef956ae..2516bd5 100644 --- a/fr/home.org +++ b/fr/home.org @@ -65,7 +65,7 @@ Liens rapides : Voici une liste des cours que j'ai préparés : - [[file:latex-intro.org][introduction à LaTeX]] - - systèmes d'exploitation + - [[file:os-ueve.org][systèmes d'exploitation]] - une introduction très rapide à la vie artificielle - réseaux de Petri pour la biomodélisation - introduction à Cytoscape diff --git a/fr/os-ueve.org b/fr/os-ueve.org new file mode 100644 index 0000000..17bceac --- /dev/null +++ b/fr/os-ueve.org @@ -0,0 +1,96 @@ +#+TITLE: Systèmes d'exploitation + +#+LANGUAGE: fr + +#+ATTR_HTML: :alt en anglais :class lang-lifted +[[file:../en/os-ueve.org][file:../content/imgs/en.png]] + +Ce cours présente d'abord brièvement l'historique et la typologie des +systèmes d'exploitation et ensuite se penche sur deux aspects de la +conception et réalisation de ces systèmes : les entrées/sorties et la +gestion du parallélisme et de la concurrence. En ce qui concerne les +entrées/sorties, sont analysées en priorité les notions des +interruptions et des tampons. Pour ce qui est du parallélisme et de la +concurrence, le parallélisme maximal et les blocages sont étudiés. + +Ce cours est enseigné à tous les parcours en formation initiale de [[https://www.univ-evry.fr/formation/loffre-de-formation/domaines-de-formation/domaine/sciences-technologies-sante/programme/licence-mention-informatique-1.html][L3 +informatique]] à l'[[http://www.univ-evry.fr/fr/index.html][Université d'Évry]] et requiert une expérience de base +en programmation et en architecture des ordinateurs. + +Ce cours s'inspire profondément des notes de [[https://www.ibisc.univ-evry.fr/~delosme/][Jean-Marc Delosme]] au +sujet des systèmes d'exploitation. À partir de l'année universitaire +2018/2019, davantage de démonstrations et de travaux pratiques sont +proposés aux étudiants. + +Les sections ci-dessous décrivent brièvement les 4 grands chapitres de +cette matière, ainsi que les 2 exemples de code exécutable proposés +aux étudiants. + +#+ATTR_HTML: :alt image de la licence Creative Commons Attribution Alone :class ccby +[[https://fr.wikipedia.org/wiki/Licence_Creative_Commons][file:../content/imgs/ccby.png]] + +Les matériaux disponibles sur cette page sont distribués sous la +[[https://fr.wikipedia.org/wiki/Licence_Creative_Commons][licence Creative Commons Paternité]]. + + +* Introduction + Ce chapitre explique quelques termes fondamentaux systématiquement + employés dans l'étude, la conception et le développement des + systèmes d'exploitation : système informatique, système + d'exploitation, machine physique, machine abstraite, etc. Quelques + fonctions essentiels d'un système d'exploitation sont énumérées. Une + typologie des systèmes d'exploitation ainsi qu'un bref historique + concluent le chapitre. + + Les diapositives de ce chapitre se trouvent [[file:../content/courses/os-ueve/se-01.pdf][ici]]. + +* Méchanismes d'exécution et de communication + Ce chapitre décrit l'organisation de la communication dans un + système concurrent, asynchrone et ouvert. L'objet central de cette + partie sont les interruptions matérielles ainsi que les déroutements + et les appels au superviseur. Quelques exemples fondamentaux + d'application des interruptions sont expliqués, en particulier + l'organisation du pseudo-parallélisme et les entrées-sorties + tamponnées. + + Les diapositives de ce chapitre se trouvent [[file:../content/courses/os-ueve/se-02.pdf][ici]]. + +* Processus. Modèles de représentation + Ce chapitre définit la notion de processus et décrit son rôle et sa + représentation au sein d'un système d'exploitation. Après une + discussion des aspects techniques généraux, le chapitre débouche sur + le modèle abstrait des systèmes de tâches concurrentes, ainsi que + sur les opérations de composition séquentielle et parallèle. + + Les diapositives de ce chapitre se trouvent [[file:../content/courses/os-ueve/se-03.pdf][ici]]. + + Cette partie comprend également un [[file:../content/courses/os-ueve/ton-paire.cpp][exemple de code]] utilisant la + procédure =fork= pour créer un nouveau processus. + +* Interaction de processus + Ce chapitre se focalise sur les deux problèmes fondamentaux de + gestion de systèmes concurrents : le parallélisme maximal et les + blocages. La question d'optimisation du parallélisme est traitée + dans le cadre général des systèmes de tâches en donnant un + algorithme de construction d'un système de tâches de parallélisme + maximal équivalent à un système de tâche donné. Un cadre formel + différent est ensuite construit pour l'analyse des blocages et un + algorithme de détection des blocages est présenté. Un algorithme + approximatif d'évitement des blocages (l'algorithme du banquier) + concluent le chapitre. + + Les diapositives de ce chapitre se trouvent [[file:../content/courses/os-ueve/se-04.pdf][ici]]. + +* Sémaphores + Cette partie du cours se donne l'objectif d'étudier les sémaphores + dans le contexte de développement interactif d'un programme + synchronisant un ensemble de fils d'exécution parallèles. Le code + vers lequel ce développement devrait aboutir est [[file:../content/courses/os-ueve/semaphores.py][celui-ci]]. + + +* Local Variables :noexport: + # Local Variables: + # org-link-file-path-type: relative + # eval: (auto-fill-mode) + # ispell-local-dictionary: "fr" + # End: