Qu'est-ce qu'un systeme d'exploitation ?

une gestion de ressources ( processeur, périphérique extérieur etc .. )

une base de développement et d'exécution de programme
d'application.

Il a pour but :

- Décharger le programmeur d'une longue tache de programmation

bas niveau et donc de se concentrer sur l'écriture du programme.
-proteger le système de fausses manipulations.
-offrire une vue simple de la machine et ses ressources.

2 points de vue pour un OS : Machine virtuelle et gestionnaire de

ressoucrces.

Les traps permet au logiciel de dérouter son exécution pour executer le

code système.

Mono-utilisateur : un seul utilisateur a un moment donné.

Monolithique : aucune structure interne. Une collection de procedure,

toutes visibles par les autres et pouvant appeller toute autre procédure
qui lui est utile.

Machine virtuelle: cette idée consiste a séparer compltement la

possibilité de partager le processeur et l'interface plus pratique pour la
programmation matériel.

Processus : taches qui modélisent l'exécution d'un programme sur un

processeur virtuel.

Système a temps partagé : Ils progressent dans le temps, mais un seul

a la fois. 3 états possible :

-Elu ( en cours d'exécution )

-Prêt ( suspendu en faveur d'un autre )
-Bloqué ( en attente d'un evenement eterne )
on peut passé du mode :

Bloqué ==> prêt

Prêt <==> Elu
Elu==> bloqué

Sémaphore: variable utilisée pour compter le nombres de réveils en

attente. L'appel systeme DOWN décrémente cette variable et UP
l'incrémente.
Dans le cas d'un systeme multi-processeur le sémaphore est protégé
par une variable verrou manipulée par TSL pour s'assurer qu'un seul
processs a la fois n'accede au sémaphore et change sa donnée.

Le moniteur est un support d'exlusion mutuels au niveau langage.

l'exclusion mutuelle assure l'exclusion d'une variable/fichier par un
programme si elle est utilisée par un autre.

Région/ section critique: Partie du processus qui a acces a la mémoire

partagé.

on ne peut jamais avoir deux processus dans la région critique.

Ordannancement des processus :

-Tourniquet : il attribue un quantum de temps par processus.

-Priorité : variable ( modifiable dynamiquement ).

-Plus court : quand on connait par avance le temps d'utilisation.

-Politique : Le temps processeur consomé par chaque utilisateur

depuis la connexion est divisée par le nombre d'utilisateur pour savoir
quel portion de processeur sera attribué a l'utilisateur. Le processus
ayant le rapport le plus faible sera prioritaire.

-A deux niveaux : Le bas niveau s'occupe des processus présent en

mémoire et le haut niveau switch de temps en temps les processus
entre la mémoire et le disque. le haut niveau se base sur le temps
écoulé depuis le dernier switch, la quantité ( en temps ) utilisée par le
processus et la taille ( les plus petits sont moins pénalisant lors du
switch ) et la priorité du processus.
 MEMOIRE

monoprogramation : 1 seul processus en mémoire a la fois qui peut

utiliser toute la mémoire si necessaire. Si la taille du programme
dépasse celle de la mémoire physique on peut utiliser des segment de
recouvrmeent ( overlay ).

Plus clairement, si le programme dépasse la taille de la mémoire

disponnible on peut utiliser une mémoire externe ( disquette ) pour
sauver les différentes parties du programme. par exemple un jeu ou un
programme mis sur plusieurs disquette que l'ont doit switcher pour
avoir la partie voulue du programme.

Multiprogrammation : Utilisé pour les calculs intensifs, permet d'utiliser

plus pleinement le CPU que la monoprogrammation.

Multiprogrammation avec partition fixe:

La mémoire est partitionner au démarage. Les taches sont placée dans

la file d'attente de la plus petite partition pouvant la contenir. ( l'espace
de trop étant perdu ).

Problème de la multiprogrammation :

-Translation d'adresse : une solution consiste a garder les positions de

touts les mots mémoires qui sont des afresses dans une table annexes
généré par l'éditeur du lien.

-Protection contre les tentatives d'accès: une solution a été de diviser

la mémoire en bloc de 2Ko et y affecter une clé de 4bits. Le PSW étant
aussi doté de clé pour chaque processus. Cette clé est un "code"
empechant l'intrusion de processus non "aggréé" ( ceci permettant un
maximum de 16 processus d'être exécuté en meme temps en
mémoire).

Dans les systemes a temps partagé la mémoire ne peut pas contenir

tous les processus des utilisateurs. Le swapping intervient alors pour
switcher les proccessus entre la mémoire et le disque.

Faire du swapping sur les partitions de taille fixe ferait du gaspillage

car la taille du processus peut etre beaucoup plus petit que la taille de
la partition donnée. Les partitions de taille variable reglent donc le
problème mais les mécanismes d'allocation mémoire et de libération
sont alors plus compliqué.

Après plusieurs ré-allocations de partitions la mémoire peut etre

fragmenté et un compactage est necessaire mais couteux. Une
solution ==> la pagination.

La taille des processus augmente avec le temps, une taille de mémoire

plus grande est donc allouée a son arrivée.

3 gestions de mémoires :

-Table de bit
-Liste chainée
-Subdivision

La table de bit: Subdivision de la mémoire en unitée d'allocation ( de

taille variable ). Chaque unitée est représentée par un bit dans une
table d'allocation.

La liste chainée: Une liste chainée de segments libre et occupés.

Chaque segments étant représenté par un bit d'état, sont adresse de
début et sa taille.
il y a 4 sorte d'allocation:

-First fit
-Best fit
-Worst fit
-Quick fit

First fit : utilise le premier segment qui correspond.

Best fit: Parcours toute la liste et attribue le meilleur segment.
Worst fit: parcours toute la liste et attribue le plus grand segments
disponnible.
Quick fit: accélération de la recherche en séparants les segments
libres des occupées et sépares les libre par taille ==> simplification des
recherche mais complication des fusions.

Subdivision: manipulation des blocs mémoires ave -c une taille égale a

une puissance de deux. Pour faire une allocation on cherche la liste
correspondant a la taille égale ou supérieur a la taille demandée.

La 3ieme génération est due a une avancée majeure ( circuit intégré ).

Les circuits intégré ont permit la standardisation des machines et
l'apparition des "familles de machines" partageant le meme langage
systeme et OS pour des configurations différentes. Il fallait donc un OS
capable de fonctionner sous toutes les configurations.
Les traveaux on peut etre stocké sur les disques dur des machines
( spool ) L'arrivée de la multiprogrammation avec apparition des
premiers mécanismes matériels de controle des acces mémoires.
Apparition de CTSS suivi de Multics.

CALCULS

le compactage: il faut retenir 200 000 000 octets compacté par

seconde.

Regarder la mémoire a compacter ex 256 soit 2^28 et la diviser par les

200 000 000 octets/s

2^28
----------------- = 1, 34... s
200 000 000

Pour trouver un numéro de page et de déplacment:

systeme a 4ko :

prendre le chiffre donné et le diviser par 4096. prendre le résultats

entier de cette division pour le numéro de page. pour trouver le
déplacement on prend le chiffre donné et on le soustrait a 4096
multiplié par résultat entier ).

systeme a 8Ko :

idem que pour le 4ko mais remplacer le 4096 par 8192.

généralement le systeme a 8Ko aura un numéro de page deux fois

plus petit que celui du 4Ko et le déplacement ne change pas.

Pour calculer le nombre d'entrée de page on fait :

2^ 32 ( pour un systeme d'adresse virtuelle de 32 bits )

--------
2^12 ( pour un systeme de page a 4Ko )

remplacer les exposant par ceux de l'éxercice a faire ;)

Comment calculter le temps processus en mémoire en l'absence

d'autre processus:
On prend le temps d'exécution et on le divise par (le temps d'utilisation
( 100% ) - le temps d'attend E/S ( en % aussi )) /100 ( soir un chiffre a
virgule )

ex 5 minutes d'execution bloqué a 65% d'E/S.

5 5
------------------= ---------= 14 minutes et 16 sec.
(100-65)/100 0.35

Le taux d'utilisation CPU pendant X temps.

1 seule tache :

1- temps d'E/S divisé par 100^1= x%

2 tache :

1-temps d'E/S divisé par 100^2= x%

Pour avoir l'adresse physique quand on a la base et le déplacement:

il suffit de les additionner.

Pour une systeme de pagination a xoctets. Il faut trouver le nombre de

page.

Adresse
----------- = ? ( prise du chiffre entier du résultats )
x

et pour le déplacement :

Adresse%x=?
|_ modulo