Système distribuée

Introduction
Le système répartis ( distribuée ) est un système de ressources autonomes , indépendants et de différentes
types reliés par un réseau de communication . Il est équipé d’un logicielle ( middleware ) dédiée à la
coordination des activités de système.

le SR est classée comme un MIMD ( Multiples instructions sur des multiples données ) et c’est un système
faiblement couplée.

Ces ressources ont pour but principale de collaboration pour une tache commune .

L’utilisateur peut voir ce système répartis comme un seul system centralisé ( machine virtuelle ) . Un bon
système répartis qui semble centralisé.

Caractéristiques :

Pas de partage de mémoire et ressources distans

Pas de partage d’horloge , et plusieurs horloges non synchronisés .

Absence d’état globale , chaque site connait son état pas l’état des autres .

Ordres non définis a l’avance

Besoins et motivations :

Besoins de communication et de partage d’informations et de ressources

Besoin de système a haut disponibilité et flexible et plus performant

Besoin d’un système d’une bonne qualité-prix

Avantages :

Fiabilité ( continuité de service ) , disponibilité ( prêt à l’utilisation) , Economie , Puissance , Redondance (

diminuer possibilité de perte de donnée ) , Résistances au pannes

Défis :

hétérogénéité ( adaptation de ressources pour communiquer ) , ouverture , transparence , évolutivité (

scalabilité) , Disponibilité des ressources , sécurité , Gestion de fautes , concurrences

Du point de vue réalisation , Le système Repartis contient les memes composants qu’un système centralise (
gestion de ressources , gestion de processeurs … ) mais les problèmes a résoudre sont plus complexes .
Transparence :

C’est la propriété fondamentale de la SR , C’est le fait de cacher à l’utilisateur la répartition revient à lui
donner l’illusion qu’il utilise une seule machine performante. Il existe 8 niveaux de transparence

Transparence : accès ( accès locale = distant ), localisation , migration ( code , processus , machine … ) ,
partage ( cohérence de partage ) , faute ( pannes ) , charge ( masquer les phénomènes de surcharge ) ,
réplication ( plusieurs copies ) , échelle ( adaptabilité d’ajout ).

Système distribuée 1
 Algorithmes réparties
Ordonnancement : Définir un ordre entre les événements d’un système .

le SR doit garantir :

- sûreté ( safety ) : Verifier qu’un évènement indésirable ( interblocage , incoherence de données , violation
d’exclusion mutuelle ) n’arrivera jamais.
- Vivacité ( Liveness ) : Un évènement desirable ( message au destinataire ) , fin d’un algorithme , sortie de
section critique , liberation de ressource ) finira par arriver .

uPropriété de communication : Message émit finit toujours par arriver ( temps non borné ; finit toujours par
arriver …) , Message non modifié , FIFO
évènement : exécution des processus ,

la problématique s’agit que chaque évènement possède une horloge locale .

Causalité : le cause précède l’effet , l’émission précède la réception.

D’apres Lamport : e——> e’

e précède localement e’

Il existe un message m tels que e = émission et e’ réception

il existe e’’ tels que e précède e’’ et e’’ précède e’ ( transitivité) , e cause potentiellement e’ ( pas sûr )

Passé(e)= {e} U {f | f- - - → e }

Not ( e - - - > e’ ) = e ne peut pas influencer e’

Not ( e - - - > e’ ) et Not ( e’ - - - > e ) : e et e’ sont causalement indépendants ,

on note e || e’

Horloge de Lamport
Soit a le temps de transmission non bornée , il existe un horloge H , tels que le message émis m est
estampillés ( marqués ) , sa forme est ( m , H(m) ) avec H(m) est la date de transmission de m .

Condition de validité faible : e——> e’ ⇒ H(e)—> H(e’)

L'algorithme d'horloge de Lamport est un algorithme utilisé pour synchroniser l'horloge des nœuds dans un
système distribué. Il permet de gérer l'ordre de traitement des événements dans un système distribué en
utilisant des horloges logiques. Voici comment fonctionne l'algorithme d'horloge de Lamport :
1. Chaque nœud possède une horloge logique qui incrémente régulièrement H(i)

2. On initialise avec Hi=0

3. Incrémenter l’horloge +1 Hi=Hi+1 pour un évènement locale\

4. Lorsqu'un nœud envoie un message à un autre nœud, il envoie également sa valeur d'horloge actuelle
avec le message.(m,H(m))

5. Lorsqu'un message est reçu , Hj=max(Hj,Hi)+1

Système distribuée 2
 l’example :

Horloge-de-Lamport-Exemple-2-chronogramme-avec-ajouts-des-estampilles-1-1-1-2-1-3-1-0
Image Horloge-de-Lamport-Exemple-2-chronogramme-avec-ajouts-des-estampilles-1-1-1-2-1-3-1-0
hosted in ImgBB

https://ibb.co/yWqmBtz

L'algorithme d'horloge de Lamport permet de garantir l'ordre de traitement des événements dans un système
distribué en utilisant des horloges logiques. Cela signifie que si un nœud A envoie un message à un nœud B
avant qu'un nœud C n'envoie un message au nœud B, le nœud B traitera d'abord le message du nœud A,
même si le message du nœud C arrive avant celui du nœud A

Relation d’ordre totale :

Soit deux évènements a sur Si et b sur Sj , a→b ↔ ( H(a)<H(b) ) ou ( H(a)=H(b) avec i<j)

Horloge vectorielle
Cet algorithme est basé sur le concept de vecteur d'horloge, qui est une liste de nombres entiers qui représente
l'état de l'horloge de chaque nœud dans le réseau.

1. Chaque nœud dans le réseau possède un vecteur d'horloge, qui est initialisé à zéro au démarrage du système
Vi(0,…..,0) .
2. La taille de vecteur d’horloge est le nombres de sites (noeuds)
3. Lorsqu'un événement locale se produit sur un nœud, son compteur d'horloge est incrémenté de 1. Vi[i]= Vi[i]+1
4. Si un nœud envoie un message à un autre nœud, il inclut son propre vecteur d'horloge dans le message

5. Lorsqu'un nœud reçoit un message d'un autre nœud, il met à jour son propre vecteur d'horloge en fonction
des informations contenues dans le message :

Vi[i]= Vi[i]+1

Vi[j]= Max(Vi[j],Vm[j]) pour j=1,….,n sauf j =! i

Système distribuée 3