Vous êtes ici : FIL > Portail > Licence Info > L3S5 Info > PDS

Programmation des Systèmes

Objectifs

L'objet de ce module est de permettre à l'étudiant de maîtriser les paradigmes de programmation des systèmes (et plus particulièrement des systèmes Unix). Les concepts fournis par l'interface des systèmes et leurs principes d'utilisation sont étudiés.

Contenu

Les notions de processus, signaux, système de fichiers, entrée/sortie, mémoire, communication inter-processus, et processus légers sont présentées. Elles sont illustrées par le fonctionnement de l'interface normalisée POSIX.

Équipe pédagogique

Responsable
Intervenants

Ce cours est très largement hérité de Philippe Marquet.

Volume horaire

Chaque semaine, 1h30 de cours, 1h30 de TD et 2h de TP.

Prérequis

Crédits

5 ECTS

Samuel Hym
dernière modification : 4 août 2017

Semainier

Attention : le semainier suivant est prévisionnel, il évoluera suivant les besoins avec l’avancement du cours.

Les supports de TP sont disponibles depuis l'onglet « Documents ».

Le travail à effectuer pour chaque TP est détaillé à l'onglet « TPs ».

SemaineCoursTDTPRemarque
1 4 sept.introduction – système de fichiers (1)Pas de TD/TP cette semaine
2 11 sept.système de fichiers (2)système de fichiers : whichsystème de fichiers : access
3 18 sept.système de fichiers (3)système de fichiers : dusystème de fichiers : du
4 25 sept.processus (1)système de fichiers : tampons mémoiressystème de fichiers : performances
5 2 oct.processus (2)système de fichiers : pwd et tailsystème de fichiers : tail
6 9 oct.signauxprocessus : clonage de processusprocessus : multif, course et observe
7 16 oct.processus : mutation de processusprocessus : doDSi
8 23 oct.communication par tubesgestionnaire de travauxmshell (1)
9 6 nov.synchronisation d’activités concurrentesgestionnaire de travaux : tubesmshell (2) : tubes
10 13 nov.processus légers (threads) (1)synchronisation d’activités concurrentesmshell (3, fin)
11 20 nov.processus légers (threads) (2)manipulation de processus légers (1)multithreads concrets (1)
12 27 nov.manipulation de processus légers (2)multithreads concrets (2)
13 4 déc.recetterattrapages de TD/TP
14 11 déc.DSf
Samuel Hym
dernière modification : 19 septembre 2017

Évaluation

L'évaluation s'effectue suivant une procédure de contrôle continu.

Trois notes seront attribuées à chaque étudiant durant le semestre :

  • DSi : une note d'un premier devoir qui se déroulera en milieu de semestre.
  • DSf : une note d'un second devoir qui se déroulera en fin de semestre.
  • TP : une note de contrôle continu évaluant les travaux pratiques rendus tout au long du semestre et une démonstration de ces travaux réalisée en fin de semestre.

La note finale (N) est calculée comme une moyenne pondérée de ces notes :

ÉCRIT = sup((DSi + 2 DSf) / 3, DSf)
N = 25% TP + 75% ÉCRIT

Pour la session de rattrapage, la note TP est conservée, la note du devoir surveillé de rattrapage remplace la note d’écrit.

L'unité acquise apporte 5 ECTS.

Samuel Hym
dernière modification : 3 septembre 2015

Calendrier de remise des TP/projets

Les TP/projets sont à rendre via gitlab.

De manière générale, vous devez avoir poussé votre travail de la semaine sur le serveur gitlab avant la séance de TP suivante.

  1. TP access : exercices de la section Vérifier les droits d’accès... et expliquer.

  2. TP du : exercices de la section Parcours d’une hiérarchie pour fournir une commande du.

  3. Voir avec votre chargé de TD le travail à effectuer. Il pourrait s’agir de la section Performances des entrées/sorties hormis l’exercice avec synchronisation.

  4. TP tail : les versions simpliste et efficace de tail dans la section Afficher la fin d’un fichier.

    En complément à l’énoncé, si une implémentation ne peut être utilisée car il n’est pas possible de repositionner le curseur dans le fichier, on terminera par un message d’erreur explicite.

  5. TP multif, course et observe : exercices Multi-fourche, À vos marques... et Observation.

    Rendre avant votre 6e séance de TP une archive contenant les sources pour ces exercices avec des tests pour tous les cas (pour multif, penser à des fonctions qui font une erreur de segmentation, etc.).

  6. TP do : exercice « Exécutions de commandes » de Mutation de processus. Rendre avant votre 7e séance de TP une archive contenant exclusivement les fichiers suivants : Readme, Makefile, do.c. Vous pourrez utiliser la fonction makeargv() du fichier /home/enseign/PDS/src/makeargv.c sur le réseau du FIL pour vous aider à gérer les arguments de la commande.

  7. TP mshell : exercices de la feuille de TD/TP gestionnaire de travaux, à réaliser en plusieurs étapes :
  8. TP multithreads concrets : section Applications à des exemples concrets, les exercices « Calcul du taux de GC » et « Tri rapide multithreadé ».

Samuel Hym
dernière modification : 14 septembre 2017

Mini-man

Le mini-man, constitué d’extraits du manuel, a été distribué en cours. Les exemplaires restants sont disponibles auprès de l’AEI.

Exemples de code vus en cours

Les morceaux de code écrits pendant le cours sont disponibles dans un dépôt git que vous pouvez cloner en tapant :

git clone http://www.fil.univ-lille1.fr/~hym/d/pds.git

Cela crée un répertoire (pds par défaut) contenant un clone local du dépôt en ligne. Vous pourrez par la suite mettre à jour votre copie en lançant, dans le répertoire cloné :

git pull

Supports de travaux pratiques

  1. Système de fichiers et entrées/sorties
  2. Gestion des processus
  3. Gestionnaire de travaux
  4. Synchronisation, Processus légers

Commandes utilisées en cours

Liste de commandes utilisées pendant le cours (consultez leur page de manuel pour les détails) :

  • bash, l’interprète de commandes (et ses commandes internes cd, bg, fg, jobs, pwd, popd, pushd, ulimit …)
  • cat
  • chmod
  • cpp
  • cut
  • dmesg
  • echo
  • false
  • hd
  • kill
  • less
  • ln, en particulier ln -s
  • ls
  • lsof
  • mkfifo
  • mount
  • pidof
  • ps, en particulier ps faux et ps -Tm (options de GNU ps)
  • rm
  • sed
  • sleep
  • stat
  • time
  • top
  • touch
  • true
  • umask

Bibliographie

  • Unix, programmation et communication, Jean-Marie Rifflet et Jean-Baptiste Yunès, Dunod, 2003
  • Systèmes d'exploitation, 3e ed., Andrew Tanenbaum, Pearson Education France, 2008, traduction française de Modern Operating Systems, 3rd edition, Prentice Hall, 2007
  • POSIX
  • Les pages de manuel Linux et POSIX (la commande man connaît l'option -e posix pour sélectionner uniquement les pages POSIX du manuel)

Ce cours suppose la maîtrise du langage C. Reportez-vous éventuellement à la page de l'unité PDC, Pratique du C.

Références

Des petits liens, en vrac :

Annales

Samuel Hym
dernière modification : 5 septembre 2017

Plan du cours

Points essentiels abordés dans le cours et pages de manuel correspondantes.

Introduction

  • Définition d’un système d’exploitation et de ses missions : gérer, abstraire, sécuriser
  • POSIX : normalisation de l’interface des appels systèmes et des commandes de base
  • « Tout est fichier »

Pages de manuel : creat(2), open(2) et chmod(2).

Système de fichiers (1)

  • Missions du système de fichiers ; il en existe de très nombreux types suivant les applications
  • Chemin dans l’arborescence : la racine, les chemins absolus et les chemins relatifs ; Filesystem Hierarchy Standard
  • I-nœud : données associées, différents types ; notamment les liens symboliques
  • Quelques utilisations des liens symboliques

Pages de manuel : stat(2) et donc lstat(2), hier(7).

Système de fichiers (2)

  • Montage de systèmes de fichiers dans une arborescence et différents types de systèmes de fichiers
  • Schéma général d’une commande parcourant un répertoire, exemple avec un petit ls
  • Utilisation de lstat pour détecter les liens symboliques, et readlink pour trouver sa cible
  • Prise en compte de l’umask à la création de fichiers et répertoires

Pages de manuel : opendir(3), readdir(3), closedir(3), lstat(2), readlink(2), mkdir(2), umask(2), unlink(2), snprintf(3).

Système de fichiers (3)

  • Schéma général d’une commande lisant ou écrivant un fichier ordinaire, exemple avec un petit cp
  • Descripteur de fichier, position courante dans un fichier ouvert
  • Entrée standard, sortie standard et sortie d’erreur standard
  • Différence entre write(STDOUT_FILENO, ...) et fprintf(stdout,...), attention aux mélanges ; fonction fflush pour forcer les écritures.

Pages de manuel : open(2), read(2), write(2), close(2), lseek(2), mount(2), path_resolution(7), fprintf(3), fflush(3).

Processus (1)

  • Description des processus et leurs nombreuses propriétés (PID, état, propriétaire, répertoire courant, temps de calcul, etc.)
  • Démonstration du shell comme gestionnaire de tâches
  • Lien de parenté entre les processus
  • Création de processus fils avec fork, attente de leur terminaison et récupération de leur résultat avec wait

Pages de manuel : fork(2), wait(2), bash(1) (pour la commande ulimit), exit(3).

Processus (2)

  • Démonstration de gdb qui permet de visualiser l’état complet d’un processus en cours d’exécution (état des variables locales de toutes les fonctions, des variables globales, etc.)
  • Illustration de quelques éléments qui sont ou ne sont pas partagés entre processus père et fils : les variables ne sont pas partagées mais les fichiers ouverts (et leur position) le sont
  • Illustration des états des processus quand le père se termine avant le fils, quand le fils se termine avant le père ; seul un octet peut être retourné à son père par un processus fils via exit(3)
  • Recouvrement d’un processus avec du code lu d’un fichier exécutable : appel execve(2) et ses variantes, notamment execlp(3)

Pages de manuel : fork(2), exit(3), wait(2), execve(2), execl(3).

Processus (3)

  • Nouveaux exemples d’utilisation des fonctions exec, notamment en faisant une petite fonction system
  • Duplication de descripteur de fichiers, par exemple pour rediriger la sortie standard
  • Principe des signaux : permettre (au système ou à un autre processus) de déclencher un traitement dans un processus donné
  • Enregistrement d’un traitement de signal, lancement d’un signal
  • Différents signaux existants, notamment : SIGINT, SIGTSTP, SIGQUIT, SIGSEGV, SIGKILL, SIGSTOP, SIGCONT

Pages de manuel : dup2(2), system(3), sigaction(2), kill(2), sigemptyset(3), pause(2), sigsuspend(2), raise(3), signal(7).

Tubes

  • Principe des tubes anonymes : un canal de communication entre processus, de taille bornée, non-seek-able
  • Illustration de leur utilisation pour synchroniser les processus, en réutilisant les appels système read(2) et write(2) ; nécessité de fermer les descripteurs qui ne vont plus être utilisés pour que cette synchronisation puisse fonctionner
  • Retour sur la gestion des signaux, notamment pour SIGPIPE utilisé dans la synchronisation sur les tubes ; exemples supplémentaires sur le traitement des signaux, en particulier SIGSEGV, SIGKILL et SIGSTOP
  • Retour sur les redirections avec dup2(2) et schéma global des redirections sur un tube dans un shell

Pages de manuel : pipe(7), pipe(2) et retour sur les appels systèmes read(2), write(2), dup2(2), sigaction(2).

Synchronisation d’activités concurrentes

  • Partage de mémoire entre processus (mmap(2)) et problème des accès concurrents à une variable partagée
  • Principe des sémaphores : un compteur (de jetons) et deux opérations (prendre un jeton ou bloquer en en attendant un ; rendre un jeton et débloquer éventuellement un autre processus)
  • Schémas classiques d’utilisation des sémaphores :
    • 1 jeton ; toute manipulation de données partagées protégée en prenant le jeton au début et en le rendant à la fin
    • exemple du producteur-consommateur, où les sémaphores comptent les ressources disponibles
  • Problème des interblocages (deadlock) : exemple des philosophes
  • Synchronisation avec les traitants de signaux en utilisant des masques
  • Synchronisation via le système de fichiers, en utilisant flock(2)

Pages de manuel : mmap(2), sem_post(3), sem_wait(3), sem_init(3), sigprocmask(2), flock(2).

Processus légers (threads)

  • Principe des threads : usages, correspondances et différences entre processus et threads
  • Création d’un thread, terminaison, attente de terminaison ou détachement
  • Schéma standard pour déclencher une fonction quelconque dans un thread
  • Synchronisation entre threads par sémaphores ou mutex : principe des mutex (récursifs ou non)
  • Traitement d’un signal dans un processus multi-thread

Pages de manuel : pthread_create(3), pthread_self(3), pthread_join(3), pthread_detach(3), pthread_exit(3), pthread_mutex_lock(3), pthread_mutex_unlock(3), pthread_sigmask(3).

Prochainement

Pages de manuel : mkfifo(3), pthread_cond_wait(3), pthread_cond_signal(3), socketpair(2).

Samuel Hym
dernière modification : 12 septembre 2017