Remove my courses SYE and PPP (LaTeX).
I now give direct links to eCampus, so no need to store these files on my site.
This commit is contained in:
Sergiu Ivanov
parent
4cc3203a7b
commit
d619d62655
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
|
|
@ -1,111 +0,0 @@
|
|||
#!/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()
|
||||
|
|
@ -1,39 +0,0 @@
|
|||
/*
|
||||
* 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;
|
||||
}
|
||||
|
|
@ -1,45 +0,0 @@
|
|||
#+TITLE: Introduction to LaTeX
|
||||
|
||||
#+LANGUAGE: en
|
||||
|
||||
#+ATTR_HTML: :alt in French :class lang-lifted
|
||||
[[file:../fr/latex-intro.org][file:../content/imgs/fr.png]]
|
||||
|
||||
#+ATTR_HTML: :alt return home :class home
|
||||
[[file:../index.org][file:../content/imgs/home.png]]
|
||||
|
||||
This a short course (3 to 5 sessions) giving a short example-based
|
||||
introduction to [[https://en.wikipedia.org/wiki/LaTeX][LaTeX]]. The goal is to explain the basics of LaTeX and
|
||||
then to have the students explore the language and the ecosystem on
|
||||
their own. The subjects covered in the slides include sectioning,
|
||||
paragraph formatting, tables, figures, and mathematical notation. At
|
||||
the end of the presentation, Beamer and TikZ are mentioned as possible
|
||||
further study directions.
|
||||
|
||||
After going through the slides, the teacher shows three documents
|
||||
prepared with LaTeX (typically, an assignment text, some slides, etc.)
|
||||
and explains how to typeset them. On completing the guided part of the
|
||||
course, the students pick technical subjects within their domain and
|
||||
write up a one-page LaTeX document briefly presenting the subject.
|
||||
|
||||
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]]. No particular
|
||||
prerequisites are required for taking this course.
|
||||
|
||||
The slides for this course (in French) are [[file:../content/courses/latex-intro/latex-course.pdf][here]]. The slides presenting
|
||||
the organisation of the this course (in French) are [[file:../content/courses/latex-intro/latex-plan.pdf][here]].
|
||||
|
||||
|
||||
#+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]].
|
||||
|
||||
|
||||
* Local Variables :noexport:
|
||||
# Local Variables:
|
||||
# org-link-file-path-type: relative
|
||||
# eval: (auto-fill-mode)
|
||||
# ispell-local-dictionary: "en"
|
||||
# End:
|
||||
|
|
@ -1,96 +0,0 @@
|
|||
#+TITLE: Operating Systems
|
||||
|
||||
#+LANGUAGE: en
|
||||
|
||||
#+ATTR_HTML: :alt in French :class lang-lifted
|
||||
[[file:../fr/os-ueve.org][file:../content/imgs/fr.png]]
|
||||
|
||||
#+ATTR_HTML: :alt return home :class home
|
||||
[[file:../index.org][file:../content/imgs/home.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:
|
||||
|
||||
|
|
@ -1,47 +0,0 @@
|
|||
#+TITLE: Introduction à LaTeX
|
||||
|
||||
#+LANGUAGE: fr
|
||||
|
||||
#+ATTR_HTML: :alt en anglais :class lang-lifted
|
||||
[[file:../en/latex-intro.org][file:../content/imgs/en.png]]
|
||||
|
||||
#+ATTR_HTML: :alt retourner à l'accueil :class home
|
||||
[[file:index.org][file:../content/imgs/home.png]]
|
||||
|
||||
Ce cours de courte durée (9 heures environ) est une introduction à
|
||||
[[http://fr.wikipedia.org/wiki/LaTeX][LaTeX]] faite à base d'exemples. Le but est d'expliquer quelques notions
|
||||
de LaTeX et ensuite de laisser les étudiants explorer le langage et
|
||||
l'écosystème indépendemment. Les sujets couverts dans les slides
|
||||
comprennent : structuration du document, format des paragraphes,
|
||||
tableaux, figures, notations mathématiques. Les slides concluent par
|
||||
des références vers les documentations de Beamer et TikZ, suggérant
|
||||
ainsi ces deux librairies pour une étude individuelle.
|
||||
|
||||
À la suite des slides, l'enseignant proposera trois documents mis en
|
||||
page avec LaTeX (typiquement une consigne de TD, quelques slides,
|
||||
etc.) et expliquera leur code source. Après cette partie guidée du
|
||||
cours, les étudiants choisiront des sujets techniques de leur domaine
|
||||
et rédigeront, en LaTeX, un rapport technique d'une page.
|
||||
|
||||
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]]. Aucun prérequis particulier n'est
|
||||
exigé pour suivre cette matière.
|
||||
|
||||
Les slides sont trouvent [[file:../content/courses/latex-intro/latex-course.pdf][ici]]. Les slides de présentation de la
|
||||
structure du cours se trouvent [[file:../content/courses/latex-intro/latex-plan.pdf][ici]].
|
||||
|
||||
|
||||
#+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é]].
|
||||
|
||||
|
||||
* Local Variables :noexport:
|
||||
# Local Variables:
|
||||
# org-link-file-path-type: relative
|
||||
# eval: (auto-fill-mode)
|
||||
# ispell-local-dictionary: "fr"
|
||||
# End:
|
||||
|
||||
|
|
@ -1,99 +0,0 @@
|
|||
#+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]]
|
||||
|
||||
#+ATTR_HTML: :alt retourner à l'accueil :class home
|
||||
[[file:index.org][file:../content/imgs/home.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écanismes 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:
|
||||
Loading…
Reference in New Issue