Projet système PC : 2013 - Laura BOULLE, Nathalie MIBORD et Charlotte TROTTA

De Ensiwiki
Aller à : navigation, rechercher
L'OS Angel'OS
LOS.png
Projet Système d'Exploitation 2013

Développeurs Laura BOULLE
Nathalie MIBORD
Charlotte TROTTA

Présentation Générale

Objectifs

L'objectif principal du projet est de mettre en oeuvre des concepts associés aux systèmes d'exploitation : synchronisation, concurrence, partage de tâche, etc.

Ces différents sujets ont, entre autres, été abordés lors du cours de système d'exploitation suivi en 2ème année à l'ENSIMAG.

En 2ème année apprentissage, le projet est centré sur la réalisation d'un OS pour PC.


Pour réaliser le projet, une spécification initiale est fournie aux étudiants et peut être complétée lors de l'ajout d'extensions à l'OS.

Contraintes

Le projet doit être réalisé dans un délai précis. Les étudiants divisés en trinôme ont pu implémenter le système d'exploitation sur une période de deux semaines et demi (du 12 au 28 juin 2013).

L'équipe

L'équipe est composée de trois développeurs:

Gestion de projet

La gestion de projet est une phase importante lors de toute réalisation informatique.

La mise en place d'un planning était importante pour la réalisation du système d'exploitation.

Nous avons choisi de travailler toutes les trois, en collaboration, sur une même machine. Ceci nous semblait judicieux, afin d'augmenter notre efficacité et notre communication. Travailler ensemble sur les mêmes tâches nous permettait d'échanger sur les fonctionnalités à implémenter et facilitait la compréhension de chacune sur la totalité du projet.

Planning

Les plannings prévisionnel et effectif ont été réalisé grâce à l'outil Gantt Project.

La mise à jour régulière du planning, nous a permis de visualiser notre avancement, de prévoir les retards plus facilement et d'avoir un plan global des fonctionnalités à développer.

Planning prévisionnel

GannttProjetSysteme.png

Lors du planning prévisionnel, nous pensions que chaque sous-étape du développement pouvait être réalisée en un jour. L'ordonnancement nous paraissant plus conséquent, nous avions choisi d'y consacrer deux jours.

Des jours en fin de projet avait été réservés pour implémenter des extensions dans le système d'exploitation.

Notre choix de travailler en collaboration sur la même machine, nous a forcé à planifier la plus part des taches séquentiellement.

Planning effectif

GannttProjetSystemeReel.png

Le planning a été relativement bien tenu sur la première partie du projet. En effet, la réalisation des premières tâches était assez rapide et fixait les bases du projet.

Comme prévu l'ordonnancement fut plus compliqué que les autres étapes du projet. Cela nous a donc retardé dans le planning.

L'autre retard conséquent fut celui rencontré lors de l'implémentation du mode utilisateur. Le développement du passage utilisateur/noyau nous a pris plus de temps que prévu.

Ces différents retard nous ont amené à supprimer la réalisation d'extension. Malgré cette suppression, le planning prévisionnel de mi-projet, nous indiquait que la deadline ne serait pas tenu si nous continuions de réaliser les étapes séquentiellement.

Nous avons donc choisi de paralléliser les tâches sur la fin de projet afin de tenir la date limite de rendu.

Gestion des versions

Nous avons utilisé le gestionnaire de version Git lors de ce projet.

Ce gestionnaire de version décentralisé, nous a permis d'échanger nos fichiers de manière performante.

En effet, Git nous donne la possibilité de créer une arborescence complète facilitant les développements et les fusions de fonctionnalités développées par différentes personnes. Cependant, malgré un manque de connaissance sur l'outil nous avons dû faire face à quelques problèmes de fusion (voir Apports et Problèmes rencontrés)

Réalisation du système

Gestion de l'affichage de l'écran

Cette phase consiste à découvrir l'environnement sur lequel tout le projet est basé. Lors de cette étape, nous avons implanté différentes fonctions permettant d'afficher des caractères à l'écran et de gérer le curseur.

Les principales fonctions de cette étape sont :

- ecrit_car(int lig, int col, char c), écrit un caractère à l'écran à la ligne lig et la colonne col

- place_curseur(int lig, int col), place le curseur à la ligne lig et à la colonne col

- efface_ecran()

- traitre_car(char c), gère les caractères standarts ainsi que les caractères spécifiques (retour chariot, tabulation ... )

- console_putbytes(const char *s, int len), écrit une chaine de caractères à l'écran

Cette phase a été réalisée à partir de la pratique système n°1 : 4MMPS_Ecran

Ordonnancement

Changement de contexte entre deux processus au niveau noyau

Lors de cette phase, nous avons gérer les interruptions et horloges pour dans un premier temps, afficher une horloge en haut de la console; puis dans un second temps, permettre de changer le processus qui s'exécute.

Un traitant d'interruption a été developpé pour gérer le temps.

Durant cette étape, nous avons également abordé le problème du changement de contexte. C'est une notion très importante puisque c'est l'élément principal pour que l'ordonnanceur fonctionne correctement.

Cette phase a été réalisée à partir des pratiques systèmes 4MMPS_PIT, 4MMPS_Yield.

Pour que l'ordonnanceur fonctionne correctement, les fonctions suivantes ont été implémentées :

- start : crée un processus dans l'état activable.

- exit : termine le processus actif (ie. soi-même).

- kill : met fin à un processus.

- waitpid : attend la terminaison d'un processus fils et récupère sa valeur de retour.

- getprio : lit la priorité d'un processus.

- chprio : modifie la priorité d'un processus.

- getpid : récupére l'identifiant du processus actif.

Les sémaphores

Gestion des sémaphores et de l'endormissement des processus (wait_clock)

Lors de cette phase, nous avons mis en place les outils de synchronisation de processus.

Les fonctions développées pour mettre en place la synchronisation sont :

- screate : pour créer un sémaphore ;

- sdelete : pour détruire un sémaphore ;

- signal et signaln : pour l'opération V sur un sémaphore ;

- wait pour l'opération P ;

- try_wait : pour l'opération P sans blocage ;

- scount : pour obtenir la valeur courante du sémaphore ;

- sreset: pour réinitialiser un sémaphore.

Pour la gestion de l'endormissement des processus, nous avons utilisé l'interruption horloge créées précédemment et implémenté de nouvelles fonctions :

- clock_settings : renvoie la fréquence du quartz et le nombre d'oscillations entre chaque interruption.

- current_clock : renvoie le nombre d'interruptions déjà passées depuis le démarrage du système.

- wait_clock : endort le processus jusqu'à ce que l'interruption dont le numéro (depuis le démarrage du noyau) passé en paramètre soit arrivée.

Mode utilisateur

Un système d'exploitation est caractérisé entre autre par ses différents niveau de protection. On peut tout d'abord trouvé le niveau noyau (kernel), où tous les traitements/fonctionnalités peuvent être réalisé. Ce niveau ne doit pas être accessible pour les utilisateurs. En effet, ces derniers ont des droits totalement différents.

Pour la protection du système les utilisateurs ne peuvent pas directement réaliser des appels systèmes. Pour gérer ces différents niveaux de protection, chaque processus lancé doit disposer d'une pile utilisateur et d'une pile noyau. Ces deux piles ne sont pas enregistrées aux mêmes endroits de la mémoire et doivent être gérées différemment par le système.

Cette étape de projet consistait donc à réaliser les changements de passages entre les niveaux utilisateur et noyau.


La spécification de cette fonctionnalité se trouve principalement dans la Phase 5 de conduite du projet ainsi que dans Projet_système_:_Aspects_techniques.

Interpréteur de commandes et Entrées/Sorties

Implantation d'un interpréteur de commandes : Shell.

Les commandes pouvant être interprétées sont :

- ps : affiche tous les processus du système. Il affiche le pid, le nom et l'état du processus.

- sinfo : affiche tous les sémaphores actifs du système. Il affiche l'id du sémaphore, son count, la liste des processus qui sont bloqués sur lui.

- exit : sortie du noyau, il tue les processus actifs.

- echo : fait passer l'affichage en mode echo on ou echo off.

- clear : efface l'écran de la console. L'en-tête de la console est conservé.

- autotest : lance tous les tests du fichier ensitest les uns après les autres.

- test : exécute un test choisi par l'utilisateur parmi les tests disponibles.

Tests

Des tests de non-régression ont été réalisés lors de la première partie du projet. Ces derniers permettaient de vérifier que les fonctionnalités précédemment développées, étaient toujours présentes, au fur et à mesure de l'implémentation. Ces tests, ainsi que des tests unitaires, nous ont aidé lors de la partie développement du noyau.

Une fois le passage au niveau utilisateur réalisé, les tests fournis avec la spécification, nous ont assisté dans l'écriture des nouvelles fonctionnalités. Ils ont pu mettre au clair des parties de la spécification mal comprises.

Principaux apports et problèmes rencontrés

Problèmes

Les principaux problèmes que nous avons rencontrés concernaient l'utilisation du gestionnaire de version Git, ainsi que la syntaxe du langage C et de l'assembleur.

Lors de certains développements, les algorithmes pensés pour répondre à la fonctionnalité correspondaient totalement aux spécifications mais les spécificités du langage C nous faisaient perdre du temps sur l'implémentation.

Il est aussi arrivé durant le projet, que nous ayons mal compris une partie de la spécification. Ces erreurs de compréhension, nous ont aussi coûté du temps, sous forme de redéveloppement de fonctionnalités.

Apports

Les difficultés rencontrées nous ont aidé à mettre à jour nos connaissances ainsi que de mettre en pratique la théorie vu dans les cours de système d'exploitation.

Grâce à la réalisation de ce système d'exploitation, nous avions pris concience de toutes les données et fonctionnalités apparaissant des les OS, outils aujourd'hui courant.