os-ueve: Add.

This commit is contained in:
Sergiu Ivanov 2018-09-22 18:53:51 +02:00
parent 72c8d2f059
commit a9d846fa50
10 changed files with 341 additions and 2 deletions

Binary file not shown.

Binary file not shown.

Binary file not shown.

Binary file not shown.

View file

@ -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()

View file

@ -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;
}

View file

@ -62,7 +62,7 @@ Jump to:
Here is a list of courses I prepared: Here is a list of courses I prepared:
- [[file:latex-intro.org][introduction to LaTeX]] - [[file:latex-intro.org][introduction to LaTeX]]
- operating systems - [[file:os-ueve.org][operating systems]]
- a very quick introduction to artificial life - a very quick introduction to artificial life
- Petri nets for biomodelling - Petri nets for biomodelling
- introduction to Cytoscape - introduction to Cytoscape

93
en/os-ueve.org Normal file
View file

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

View file

@ -65,7 +65,7 @@ Liens rapides :
Voici une liste des cours que j'ai préparés : Voici une liste des cours que j'ai préparés :
- [[file:latex-intro.org][introduction à LaTeX]] - [[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 - une introduction très rapide à la vie artificielle
- réseaux de Petri pour la biomodélisation - réseaux de Petri pour la biomodélisation
- introduction à Cytoscape - introduction à Cytoscape

96
fr/os-ueve.org Normal file
View file

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