Location via proxy:   [ UP ]  
[Report a bug]   [Manage cookies]                
Scribd Logo
Importer

Bienvenue sur Scribd !

  • 262 vues

    OS

    Transféré par

    M4kn4sh

    Droits d'auteur :

    Attribution Non-Commercial (BY-NC)
    Téléchargez comme PDF, TXT ou lisez en ligne sur Scribd

    OS

    Transféré par

    M4kn4sh
    262 vues6 pages

    Copyright

    © Attribution Non-Commercial (BY-NC)

    Formats disponibles

    PDF, TXT ou lisez en ligne sur Scribd

    Avez-vous trouvé ce document utile ?

    Ce contenu est-il inapproprié ?

    Droits d'auteur :

    Attribution Non-Commercial (BY-NC)
    Téléchargez comme PDF, TXT ou lisez en ligne sur Scribd
    Télécharger au format pdf ou txt
    262 vues6 pages

    OS

    Transféré par

    M4kn4sh

    Droits d'auteur :

    Attribution Non-Commercial (BY-NC)
    Téléchargez comme PDF, TXT ou lisez en ligne sur Scribd
    Télécharger au format pdf ou txt
    sur 6

    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

    Vous aimerez peut-être aussi