os-ueve: Add.

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 <sergiu.ivanov@univ-evry.fr>
+
+"""
+
+# 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()

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 <sergiu.ivanov@univ-evry.fr>
+ */
+
+#include <stdio.h>     // pour avoir printf
+#include <unistd.h>    // pour avoir fork
+#include <sys/wait.h>  // 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;
+}

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

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:
+

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

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: