Les états du processus

Département d’Informatique
Master Big Data Analytics & Smart Systems
Realisé par :
Encadré par :
Salma Largo
Pr.Meknassi
Khalid El masry
Année universitaire 2016/2017
Table des matières
Les états d’un processus _____________________________________________ 2
Définition : Processus ..................................................................................... 2
Les états du processus ................................................................................... 2
Le bloc de contrôle du processus (PCB) ...................................................... 4
Algorithme de Tri rapide _____________________________________________ 4
Le tri rapide ...................................................................................................... 4
Introduction ................................................................................................... 4
Description ..................................................................................................... 5
Explications .................................................................................................... 6
Jeu d'essai ......................................................................................................... 7
Complément : recherche dichotomique ....................................................... 9
Recherche dichotomique ............................................................................. 9
Loi de Morre _____________________________________________________ 10
Historique de loi de morre ........................................................................... 10
Loi de Moore et générations successives................................................. 10
Environnement de travail ____________________________________________ 12
Références ______________________________________________________ 12
Annexe _________________________________________________________ 12
LARGO & ELMASRY
Page 2
1) Les états d’un processus :
Définition : Processus
 Un processus est un programme en cours d'exécution auquel est associé un
environnement processeur (CO, PSW, RSP, registres généraux) et un environnement
mémoire appelés contexte du processus.
 Un processus est l'instance dynamique d'un programme et incarne le fil d'exécution de
celui-ci dans un espace d'adressage protégé (objets propres : ensemble des instructions
et données accessibles)
 Un programme réentrant est un programme pour lequel il peut exister plusieurs
processus en même temps
Les états du processus
Lors de son exécution, un processus est caractérisé par un état :
 lorsque le processus obtient le processeur et s'exécute, il est dans l'état élu. L'état élu
est l'état d'exécution du processus.
 lors de cette exécution, le processus peut demander à accéder à une ressource
(réalisation d'une entrée/sortie, accès à une variable protégée) qui n'est pas
immédiatement disponible : le processus ne peut pas poursuivre son exécution tant qu'il
n'a pas obtenu la ressource (par exemple, le processus doit attendre la fin de
l'entrée/sortie qui lui délivre les données sur lesquelles il réalise les calculs suivants
dans son code) : le processus quitte alors le processeur et passe dans l'état bloqué.
L'état bloqué est l'état d'attente d'une ressource autre que le processeur.
 lorsque le processus a enfin obtenu la ressource qu'il attendait, celui-ci peut
potentiellement reprendre son exécution. Cependant, nous nous sommes placés dans le
cadre de systèmes multiprogrammés, c'est-à-dire qu'il y a plusieurs programmes en
mémoire centrale et donc plusieurs processus. Lorsque le processus est passé dans
l'état bloqué, le processeur a été alloué à un autre processus. Le processeur n'est donc
pas forcément libre. Le processus passe alors dans l'état prêt.
L'état Prêt est l'état d'attente du processeur.
 Le passage de l'état prêt vers l'état élu constitue l'opération d'élection. Le passage de
l'état élu vers l'état bloqué est l'opération de blocage. Le passage de l'état bloqué vers
l'état prêt est l'opération de déblocage.
LARGO & ELMASRY
Page 3
Un processus est toujours crée dans l'état prêt. Un processus se termine toujours à partir de
l'état élu (sauf anomalie).
Figure 1 : le système multiprocessus / états des processus
2) Le bloc de contrôle du processus (PCB)
Le bloc de contrôle d'un processus (PCB) contient les informations suivantes :
 un identificateur unique du processus (un entier) : le PID
 l'état courant du processus (élu, prêt, bloqué)
 le contexte processeur du processus : la valeur du CO, la valeur des autres registres du
processeur
 le contexte mémoire : ce sont des informations mémoire qui permettent de trouver le
code et lesdonnées du processus en mémoire centrale
 des informations diverses de comptabilisation pour les statistiques sur les
performances système
 des informations liées à l’ordonnancement du processus. Le PCB permet la sauvegarde
et la restauration du contexte mémoire et du contexte processeur lors des opérations
de commutations de contexte.
LARGO & ELMASRY
Page 4
Figure 2 : bloc de contrôle de de processus
3) Algorithme de Tri rapide
Le tri rapide

Introduction
Le tri rapide est fondé sur une approche "diviser pour régner". Le tri rapide nous fait introduire
les notions de récurrence et de récursivité. Une méthode sera dite récursive si dans le corps
de cette méthode elle s'appelle elle-même. En mathématique, vous avez déjà dû manipuler des
suites qui étaient définies de manières récursives. Vous aviez Un qui était fonction de Un-1 et
on vous donnez la valeur de U0. Ici c'est pareil. Considérons le calcul de la factorielle :
factorielle(n) = n * factorielle(n-1) et factorielle(0) = 1. Nous avons vu dans le cours une
méthode qui calculer la factorielle de manière itérative. Voici l'algorithme d'une fonction qui
calcule la factorielle de manière itérative
Entier Factorielle(Entier n)
{
si (n == 0)
{
retourne (1);
}
sinon
{
retourne (n*Factorielle(n-1));
}
LARGO & ELMASRY
Page 5
On voit dans cet exemple que pour calculer la valeur de la factorielle pour n, on la calcule
d'abord pour n-1, et ainsi de suite. On s'arrête grâce à la condition initiale, à savoir que
Factorielle(0) vaut 1. Nous allons voir que le tri rapide est un algorithme récursif.

Description
Comme énoncé dans la section précédente le tri rapide est fondé sur une approche "diviser
pour régner" que l'on peut décomposer en 3 étapes. On considère que nous avons un tableau
Tab de taille n. On notera un "sous-tableau" de Tab, Tab[p…r], p étant l'indice du début du
sous-tableau et r l'indice de la fin du sous tableau. On remarquera qu'un sous-tableau est un
tableau et que Tab[0…n-1] est le sous-tableau représentant le tableau Tab en entier.
Diviser : le sous-tableau Tab[p…r] est partitionné( i.e. réarrangé) en 2 sous-tableaux non
vides Tab[p..q] et Tab[q+1..r] de telle sorte que chaque élément du tableau Tab[p..q] soit
inférieur ou égal à chaque élément de A[q+1…r]. L’indice q est calculé pendant la procédure de
partitionnement.
Régner : Les 2 sous-tableaux A[p..q] et A[q+1..r] sont triés par des appels récursifs à la
méthoide principale de tri-rapide.
Combiner : le tri rapide effectue "le tri sur place" (cf. la section 2.2 sur le tri par insertion).
Cela implique qu'il n'y a aucun travail supplémentaire pour les fusionner : le sous-tableau
Tab[p..r] tout entier est maintenant trié.
Le tri rapide va comporter 2 méthodes triRapide(Tableau tab, Entier p, Entier r) et
partitionner(Tableau tab, Entier p, Entier r), qui renvoie un entier. L'entier renvoyé par
partitionner est l'indice que l'on recherche dans l'étape "Diviser". L'appel initial sur le
tableau tab sera triRapide(tab, 0, tab.length). Voici les algorithmes des 2 méthodes.

Explications
Partitionner place les éléments plus petits que eltPivot dans la région inférieure du tableau et
les éléments plus grands que x dans la région supérieure. Il faut remarquer que les indices i
et j n'indicent jamais le tableau tabp…r] hors des limites même si cela ne semble pas évident
au premier abord. Il faut également noter que si on utilisait comme élément pivot tab[r] au
lieu de tab[p] et s'il s'avérait que tab[r] soit le plus grand élément du sous-tableau tab[p…r],
alors partitionner retournerait à triRapide la valeur q = r et triRapide bouclerait à "l'infini".
Dans partitionner on commence par choisir un eltPivot = tab[p] comme pivot autour duquel on
va effectuer le découpage (virtuel) du tableau tab[p…r]. Dans la suite on construit 2 "régions"
tab[p…i] et tab[j…r], respectivement à partir du début et de la fin du tableau tab[p…r], de
telle sorte que chaque élément de A[p…i] soit inférieur ou égal à x et chaque élément de
A[j…r] est supérieur ou égal à x. Initialement, i = p-1 et j = r+1, les 2 "régions" sont donc
vides.
LARGO & ELMASRY
Page 6
Dans le corps de la boucle "tant que (Vrai)" l'indice j est décrémenté et l'indice i est
incrémenté jusqu'à ce que tab[i] ≥ eltPivot ≥ tab[j]. Pour la clarté du raisonnement on
supposera que les inégalités sont strictes (si elles ne le sont pas l'échange peut de toute
façon être quand même effectué). On échange tab[i] et tab[j], car tab[i] est trop grand pour
appartenir à la région inférieure du tableau (il est plus grand que l'élément pivot) et tab[j]
trop petit pour appartenir à la région supérieure (il est plus petit que l'élément pivot), d'où la
nécessité de l'échange.
On ne sort de la boucle "Tan que (vrai)" que si i ≥ j, moment où le tableau tout entier a été
partitionné en 2 sous-tableaux tab[p…q] et tab[q+1…r], où l'on a p ≤ q < r et de telle manière
qu'aucun élément de tab[p…q] ne soit plus grand qu'un élément de tab[q+1…r].
Jeu d'essai :
Le programme nous permet choisir entre 3 options : la génération d’un tableau de variables
aléatoires, lire un tableau de données à partir d’un fichier et quitter le programme.
On va choisir la génération d’un tableau de variables aléatoire et on saisi le nom du fichier
ou on va stocker le tableau :
LARGO & ELMASRY
Page 7
Et affiche les données du tableau :
Après on choisi la méthode du tri :
LARGO & ELMASRY
Page 8
Et voilà le tableau trié
Complément : recherche dichotomique
Il s'agit de trouver dans un tableau l'indice correspondant à une valeur donnée. Le principe de
recherche dichotomique ne s'applique que pour des tableaux triés par rapport à l'information
sur laquelle s'établit la recherche. Soit X l'élément recherché dans un tableau T dont les
bornes inférieure et supérieure sont BI et BS. On appelle milieu (BI + BS) Div 2. Principe de
recherche de l'indice X :
Si T[milieu] > X, alors l'indice de X, s'il existe, est compris entre BI et milieu-1
Si T[milieu] = X, l'indice est trouvé.
Si T[milieu] < X, alors l'indice
LARGO & ELMASRY
Page 9
Recherche dichotomique
Lorsque l'on recherche un élément dans un tableau, en s'attend à effectuer, en moyenne, des
comparaisons avec la moitié des éléments avant de trouver un élément présent dans celui-ci.
Dans l'éventualité où l'élément cherché est absent du tableau, nous devons comparer la valeur
cherchée avec la totalité des éléments du tableau avant de pouvoir conclure à l'absence de
l'élément cherché.
La recherche dichotomique, sur un tableau trié en fonction du champ sur lequel nous
recherchons une valeur, permet de diminuer le nombre moyen de comparaisons nécessaires
pour conclure à la présence ou non, d'un élément dans le tableau.
Voici une méthode qui effectue la recherche d'un entier aChercher dans un tableau t d'entiers.
Si elle la trouve, la méthode retourne l'indice dans le tableau de la valeur cherchée, sinon, elle
retourne –1.
4) Loi de Morre
Historique de loi de morre
C’est en 1965, le 19 avril pour exacte que Gordon Moore, alors directeur R&D chez Fairchild
Semiconductor et futur co-fondateur d’Intel, livre ses observations sur le taux de croissance
exponentiel des circuits. Il constate alors que depuis 1959, un doublement régulier des
composants électroniques. Il extrapole alors que cette course ne va pas s’arrêter et que la
tendance va se poursuivre dans les années suivantes avec des composants non seulement de
moins en moins chères à produire mais aussi plus performants et économes en énergie. Sans
le deviner à l’époque, il met sur pied « une miniaturisation rythmée » des circuits intégrés
(ou transistors) des processeurs.
Intel conçoit dans ses laboratoires les 4004 en 1971 tandis que 1975, l’hypothèse de Gordon
Moore se vérifie presque intégralement et depuis, après une révision de sa régularité
(passage de un à deux ans), la « loi de Moore » devient une tendance générale. Il ne s’agit pas
du loi physique, démontrée ou démontrable mais d’une tendance qui est devenue le fil
conducteur de l’ensemble de l’industrie des semi-conducteurs qui se fait un devoir d’aller
aussi vite que le rythme prédit.
Loi de Moore et générations successives
A partir de 1970, le d´développement suit le rythme exponentiel représenté figure ce déçus.
C’est ce rythme de croissance qui est appelé : ”loi de Moore”.
LARGO & ELMASRY
Page 10
Figure 3 : nombre de transistors par circuit intégré
Le produit essentiel de cette industrie est la mémoire. Il dispose d’un très grand marché
(tous les montages ont besoin de mémoire), concentre toutes les difficultés technologiques
(si l’on recherche une densité maximum) et pousse constamment à la modernisation des
usines.
En 1974, Intel introduit la DRAM de 4 Kbits. Une cellule mémoire n’est plus constituée alors
que d’un seul transistor associé `a un condensateur. La technologie est MOS canal N grille Si.
Ce sera également la technologie des microprocesseurs 8 bits. Dans cette technologie, la
dissipation n’est pas négligeable en l’absence d’horloge, alors qu’elle l’est dans le CMOS (MOS
complémentaire), mais les réalisations CMOS occupent alors trop de surface.
Ce compromis sera renversé au début des années 80, date `a partir de laquelle l’utilisation du
CMOS devient universelle pour les circuits logiques. En 1984, les m´mémoires atteignent le
cap de 1 Mbits, c’est l ère VLSI (Very Large Scale Integration).
La loi de Moore n’est pas réalisée comme une évolution continue, mais comme une succession
de paliers (ou générations). A chaque palier, les industriels se fixent comme objectif de
diviser la surface d’un transistor 2, ce qui revient à diviser la largeur des motifs gravés par
racine de 2 dans chaque dimension. Comme, en outre, et grâce `à l’amélioration du rendement
de fabrication, on arrive à doubler la surface des puces `a chaque génération, cela donne un
facteur 4 pour le nombre de transistors par puce à chaque génération (figure 5 et 6). Depuis
plus de 30 ans, les générations se sont succédées au rythme d’une tous les trois ans. Ces
dernières années, elles se sont plutôt rapprochées, au rythme d’une tous les deux ans entre
1995 et 2001 (sans toutefois augmenter la surface des puces).
LARGO & ELMASRY
Page 11
5) Environnement de travail :
6) Références :
http://www.futura-sciences.com/tech/definitions/informatique-loi-moore-2447/
https://openclassrooms.com/courses/recherche-dichotomique
https://fr.wikipedia.org/wiki/Tri_rapide
https://fr.wikipedia.org/wiki/Processus_(informatique)
7) Annexe :
fonction
genererNbrAleatoir
es
LARGO & ELMASRY
Code source en langage C
Page 12
afficheTable
tri_rapid
tri_selection
LARGO & ELMASRY
Page 13
ecrire_fichier
lire_par_indice_lign
LARGO & ELMASRY
Page 14