Projet système PC : 2012 – Jose RAMIREZ-ENCINAS et Anthony BUCQUET

De Ensiwiki
Aller à : navigation, rechercher

Présentation

PrometheOs
PrometheOs.jpeg

Le projet système

La fin de la deuxième année à l'Ensimag est marquée par la réalisation d'un projet de spécialité qui dure 1 mois. Ce projet se réalise en groupes d'au moins deux personnes et le sujet correspond a un choix fait par les élèves. Dans notre cas, on a choisi de suivre le projet système qui a pour objectif de concevoir un système d'exploitation. Après avoir suivi pendant l’année scolaire, les matières de systèmes d exploitation et programmation concurrente, ainsi que celui de conception de systèmes d'exploitation , il y avait pour nous un grand intérêt de pouvoir appliquer de manière pratique ces connaissances acquises.

L'équipe

Notre équipe est composée de deux étudiants :

José Ramirez
Bucquet Anthony

Le groupe est encadré par : Damien Dejean

Réalisation

Présentation du cahier de charges

Le temps étant un facteur limitant pour un projet de ce type, un cahier de charge minimal nous a été fournie. Ce cahier charge était séparé en plusieurs étapes qui , pour la plupart, dépendaient les unes des autres. Voici les grandes parties du projet :

  1. La création du noyau de système d'exploitation
    • La gestion de l’écran
    • La gestion des processus
    • La gestion de l'horloge
    • La gestion des mécanismes de synchronisation
  2. L’implémentation de la partie utilisateur dans le système d'exploitation
    • Modification de la structure des processus
    • Création des appels systèmes
  3. La création d'une Console:
    • La gestion du clavier
    • La réalisation d'un interpréteur de commandes : shell .

Pour finir le projet, une étape supplémentaire de réalisation d'extensions était disponible. Nous avons choisi d’implémenter dans une premier temps une petite extension, la gestion de l'ACPI, et après une extension plus développée, l’implémentation de la mémoire virtuelle.

Implémentation de la partie Noyau du système

La gestion de l’écran

Lors du début du projet, on possède un noyau du système très primitif (donné par les enseignants) . Ainsi la première étape consiste à la gestion de l'écran et de l'affichage des caractères. En effet, puisqu'on commence avec un noyau très primitif, il ne contient pas de driver pour pouvoir gérer l'affichage. On réalise ceci en écrivant directement à des adresses en mémoires mappées à des entrées de l’écran.

La gestion de l'horloge

L’étape suivante consiste à gérer l'horloge du système, cela se fait par des interruptions d'un composant interne au système , le interrupt timer. Cette horloge possède une fréquence de 100hz . Cette horloge servira, dans la partie suivante, comme appelant à l'ordonnanceur des processus.

La gestion des processus

Une fois cette étape implémente il reste à gérer l’implémentation des processus dans notre noyau. Des primitives telles que la bonne initialisation, le démarrage, un système de priorités sont quelques fonctionnalités demandées dans les spécifications .

La gestion des mécanismes de synchronisation=

Après avoir testé le bon fonctionnement de ces processus, on implémente des primitives de synchronisation telles que les sémaphores, et l'attente d'un processus à la terminaison d'un processus fils, qui permettent la synchronisation des différents processus.

Implémentation du Mode User

Cette étape a été la plus longue et la plus complexe de tout le projet. En effet , il faut créer un nouveau mode dans le système, celui de l'utilisateur. Le but est de séparer un kernel qui possède tous les droits sur le matériel et un utilisateur qui ne peut interéagir avec ce matériel qu'à partir d'appels systèmes faits à ce kernel. Ainsi il faut réussir à changer constamment de mode. Cela pose quelques difficultés au niveau des protections des différents niveaux du processeur. Une fois cette grosse étape finie, les processus ne peuvent plus utiliser les fonctions du kernel (ils ne les voient même pas), ils ont pour communiquer une liste d'appels systèmes définies dans les spécifications.

Implémentation de la console

La gestion du clavier

Pour effectuer l’interpréteur de commande, il faut évidement gérer clavier, on gère cela à l'aide des interruptions clavier, qui nous permettent de récupérer le code ASCII (nombre) associé a chaque touche pour pouvoir après faire le traitement correspondant à la pression ou à l'état particulier de certaines touches.

Le shell

Shell PrometheOs
Shell prometheOS.jpeg

Une fois cela réalisé, il reste que l’implémentation du shell. Ce processus est chargé de faire un appel système en attente d'une entre du clavier ( une ligne ) pour pouvoir interpréter la chaîne de caractères qui lui est envoyée et exécuter la commande correspondante si elle existe. Voici, un tableau de commandes disponibles dans notre shell :

Implémentation des extensions

La gestion d'ACPI

Cette extension permet de gérer la consommation électrique de l'ordinateur. Nous avons utilisé l'interface ACPI pour pouvoir éteindre le système lorsque l'utilisateur tape "exit" dans le shell.

L'implémentation de la mémoire virtuelle

Les mécanismes de la mémoire virtuelle permettent de gérer efficacement la mémoire RAM du système. Dans notre cas, nous avons réussi à implémenter une mémoire virtuelle fonctionnelle pour les piles et tas des processus utilisateurs, ce qui constitue déjà une majeur partie de la gestion totale de cette mémoire RAM. Le reste de la mémoire physique est mappée en mémoire virtuelle aux mêmes adresses.

Tetris

Tetris prometheOs.jpeg

A titre d'exemple des capacités de PrometheOS, nous avons réalisé sur celui-ci un jeu Tetris utilisable à partir d'une commande shell.