Préface

C’est mes reponses pour le cours Info-524: Système d’exploitation

Questions

Question 2

Vous inclure un fichier “reponses.txt” à votre archive qui contiendra :

le numéro en base 10 du message “PM_CHANGE_NAME”
votre réponse à la remarque ci dessus.

Ox900 = 2304, donc le numéro en base 10 du message “PM_CHANGE_NAME” est 2316.

La commande “ps” signaler un aperçu des processus en cours, mais selon le premier exercise, on a vu que c’est possible de changer le nom du processus dynamiquement par le appel système “changer_nom”. Donc on utilise “top” au lieu de “ps” pour afficher les processus dynamiquement.

Question 3

Cherchez la valeur de “NR_SCHED_QUEUES”.

Dans le fichier "config.h" en 78eme ligne, NR_SCHED_QUEUES = 16.

Quelle est la priorité par défaut d’un processus noyau (“TASK_Q”) ?

Un processus noyau "TASK_Q" a une priorité de 0, ça veut dire que il a la priorité maximale.

Quelle est la priorité par défaut d’un processus utilisateur (“USER_Q”) ?

    USER_Q = (MIN_SUER_Q - MAX_USER_Q) / 2 + MAX_USER_Q
Sachant que:
    MIN_USER_Q = NR_SCHED_QUEUES - 1
         = 15
    MAX_USER_Q = 0
Donc:
    USER_Q = (15 - 0) / 2 + 0
           = 7

Question 4

Vérifiez dans le code des fonctions “do_noquantum()” et “balance_queues()” que c’est bien ce qu’il se passe et donnez les lignes pertinentes dans votre fichier reponses.txt.

"do_noquantum()":

Parmi les lignes 42 et 45, il obtient rmp et vérifie la priorité du rmp. Si la priorité est inférieur à MIN_USER_Q(15), il va augmenter la priorité par 1, c'est à dire que la priorité est baissée par 1.

"balance_queues()":

Parmi les lignes 246 et 256, pour chaque processus, si un rmp n'a pas la priorité maximale, il va diminuer la priorité par 1, c'est à dire que la priorité est augumentée par 1.

Question 5

Décrivez une situation théorique dans laquelle une famine peut apparaitre avec cet algorithme d'ordonnancement. (Pas besoin de programmer quoi que ce soit...)

Supposant que un processus avec un priorité faible se retrouve bloqué avant que son quantum de temps ne soit écoulé, même si sa priorité ne change pas, mais il est simplement remis en fin de file. De même, les fois suivante quand le processus execute, il s'est bloqué encore, donc il est remis en fin encore une fois. Donc la famine de le processus apparaît.

Code

Veuillez consulter le projet sous Github: MinixOrdonnancement

Architecture d’appels

/usr/src/servers/sched/schedule.c : do_superman()

PUBLIC int do_superman(message *m_ptr)
{
    int proc_nb;
    int rv;
    struct schedproc *rmp;
    unsigned old_p, old_s;

    /* Get pid */
    int endpoint = m_ptr->m1_i1;

    /* Convert pid */
    if (sched_isokendpt(endpoint, \&proc_nb) != OK) {
        printf("SCHED: WARNING: superman() get an invalid endpoint\n");
        return EBADEPT;
    }

    /* Get correspond processus */
    rmp = \&schedproc[proc_nb];

    /* Store old values, in case we need to roll back the changes */
    old_p = rmp->priority;
    /*printf("log: Old priority before superman: %d\n", old_p);*/
    old_s = rmp->superman;

    /* Update the proc priority and reschedule the process */
    if (old_p != 0 \&\& old_s != 1) {
        rmp->priority = 0;
        rmp->superman = 1;
    }

    if ((rv = schedule_process(rmp)) != OK) {
        rmp->priority = old_p;
        rmp->superman = old_s;
    }

    /*printf("log: New priority after superman: %d\n", rmp->priority);*/

    return rv;
}

/usr/src/servers/sched/schedule.c : do_kryptonite()

PUBLIC int do_kryptonite(message *m_ptr)
{
    int proc_nb;
    int rv;
    struct schedproc *rmp;
    unsigned old_p, old_s;

    /* Get pid */
    int endpoint = m_ptr->m1_i1;

    /* Convert pid */
    if (sched_isokendpt(endpoint, \&proc_nb) != OK) {
        printf("SCHED: WARNING: superman() get an invalid endpoint");
        return EBADEPT;
    }

    /* Get correspond processus */
    rmp = \&schedproc[proc_nb];

    /* Store old values, in case we need to roll back the changes */
    old_p = rmp->priority;
    old_s = rmp->superman;
     /*printf("log: Old priority before superman: %d\n", old_p);*/

    /* Update the proc priority and reschedule the process */
    if (old_p == 0 \&\& old_s == 1) {
        rmp->priority = 0;
        rmp->superman = 0;
    }

    if ((rv = schedule_process(rmp)) != OK) {
        rmp->priority = old_p;
        rmp->superman = old_s;
    }

    /*printf("log: New priority after superman: %d\n", rmp->priority);*/

    return rv;
}

Vous pouvez trouvez tout les code sous Github: MinixOrdonnancement

Minix Appels Systèmes et Ordonnancement 2