Algorithmes distribués de base -...

1

Algorithmes distribués de base

Nabil Abdennadher

[email protected]

2

Infrastructure

3

•  Hypothèses de travail •  Généralités •  Collecte (Convergecast) •  Diffusion (Broadcast) •  Construction d’arbres de recouvrement •  Identification des noeuds d’un réseau •  Calcul du plus court chemin •  Algorithme d’élection •  Algorithmes de recherche

Plan

4

Hypothèses de travail

•  Le système distribué est représenté par un graphe où les nœuds sont les processeurs (ou devices) et les arêtes sont les liens inter-noeuds : Gp = (Np, Ep)

•  Les arêtes sont bi-directionnelles. •  La communication est basée sur la transmission de

messages (en ce qui concerne les alg. distribués qui seront vus en cours)

•  Un message est représenté par le couple (q, Msg) •  Msg doit être délivré au noeud q •  Msg : (u, msg) où u est la tâche exécutée par le noeud q et msg

est le message à délivrer à la tâche u

5

Hypothèses de travail: Routage

•  Au niveau de chaque nœud r, il existe une fonction appelée nextr(q)

•  prochain nœud à qui envoyer le message (sachant que nous sommes au niveau du nœud r) pour atteindre q

•  (r, nextr(q)) appartient à Ep.

•  Cette fonction peut être fixe ou dynamique •  Elle peut être déterministe (nextr(q) est unique) ou non •  On supposera dans ce cours que la propriété FIFO est

vérifiée •  Au niveau d’un lien •  Au niveau de l’arrivée des messages au nœud destination

6

Hypothèses de travail: Flux de contrôle

•  Cette fonction concerne le stockage des données en transit et la gestion des ressources de communication (liens, buffers)

•  Les types de flux de contrôle les plus connus •  Store and forward •  Circuit switching •  Wormhole routing

•  On supposera dans ce cours que le flux de contrôle utilisé garantit l’absence de deadlock

7

Flux de contrôle: Store and forward

•  (q, Msg) est décomposé en plusieurs packets •  Les packets contiennent les même informations de

routage que le message lui même •  Les paquets sont transmis en parallèle •  Pour garantir le « FIFO », les packets sont numérotés •  Possibilité de deadlock: taille limitée des buffers

8

Flux de contrôle: Circuit switching

•  Le chemin est réservé avant le début du transfert •  Possibilité de deadlock: un lien peut faire partie de

plusieurs chemins •  Pas efficace pour les petits messages

9

Flux de contrôle: flow control (wormhole routing)

•  Les packets sont décomposés en flit (flow-control-digit) •  Le flit leader trace le chemin qui sera suivi par les autres

flits •  Seul le flit leader contient les informations de routage •  Contrairement à la méthode store-and-forward, la

transmission des packets est pipelinée

10

!  Hypothèses de travail !  Généralités !  Collecte (Convergecast) !  Diffusion (Broadcast) !  Construction d’arbres de recouvrement !  Identification des noeuds d’un réseau !  Calcul du plus court chemin !  Algorithme d’élection !  Algorithmes de recherche

Plan

11

Objectifs

•  Etude théorique des algorithmes distribués de bases

•  Complexité : exprimée en terme de messages transmis

12

•  L’application est représentée par un graphe orienté GT= (NT, DT).

•  Pour chaque tâche t: •  Intt : les liens entrant dans t. Intt appartient à DT •  Outt : les liens sortant de t. Outt appartient à DT

•  Une tâche t est réactive (message driven) •  Elle effectue un traitement en réponse à un message reçu. •  Dans certains cas :

•  Une ou plusieurs tâches initialisent le traitement de l’application •  Une tâche peut procéder à une étape d’initialisation

Généralités

13

•  Task_t •  Faire un traitement d’intialisation •  Envoyer un message à un sous ensemble de Outt (peut

être l’ensemble vide) •  Répéter

•  A la réception d’un message sur un canal c1 (de intt) et Cond1 " •  Faire un traitement •  Envoyer un message à un sous ensemble de Outt

•  ou … •  A la réception d’un message sur un canal cn (de intt) et Condn "

•  Faire un traitement •  Envoyer un message à un sous ensemble de Outt

•  Jusqu’à (une condition de fin)

Template d’un algorithme distribué

14

•  Condition d’arrêt •  La tâche est capable de « détecter » la condition d’arrêt à partir des

messages qu’elle reçoit •  La condition d’arrêt suppose aussi que la tâche ne reçoit plus de

messages •  guard " command

•  La commande est exécutée lorsque « guard » est prêt: message reçu et condition booléenne Condi vérifiée

•  Un seul « guard » est exécuté à chaque itération •  En cas de présence de plusieurs « guard », un est sélectionné au

hasard •  En cas d’absence de « guard », la tâche ne fait rien

Remarques …

15

•  Envoi et réception de messages •  L’envoi est non bloquant •  La réception est bloquante •  Ce schéma évite les «deadlocks»

•  Les canaux (liens entre les tâches) délivrent les messages dans un ordre FIFO •  Cette condition n’est pas nécessaires pour les

algorithmes qui seront étudiés

Encore des remarques …

16


Plan

17

•  Tous les noeuds envoient une donnée locale à un même noeud destinataire

•  Au départ : •  Chaque noeud ni dispose d’une donnée locale Di

•  A la fin : •  Toutes les données Di sont reçues par un noeud destinataire nr .

Qu’est ce qu’un convergecast ?

18

Structure de données : Arbre de recouvrement

•  Le réseau est modélisé par une structure appelée arbre de recouvrement (Spanning Tree) •  AR est connu

•  Au niveau de chaque nœud : le père + les fils •  Représentation distribuée

•  Pourquoi ? •  Un arbre est plus facile à parcourir qu’un graphe

19

Exemple d’arbre de recouvrement

•  Le AR est représenté de manière distribuée :

•  Chaque noeud ni connaît : •  son père (NULL pour la racine) •  ses fils (NULL pour les feuilles)

Racine

20

Convergecast : Exemple

Liens du AR

Liens non AR

Le noeud a reçu tous les messages

Le noeud n’a pas encore reçu tous les messages

D1

nr

D2

D3

n1

n2 n3

nr

D5 D6

n1

n2 n3

n4

n5

n6

21

Convergecast : Algorithme

•  Chaque noeud feuille •  Envoie la donnée locale Di au noeud père

•  Chaque noeud non feuille ni (i ≠ r) •  A la réception des messages de tous les noeuds fils

•  Envoie l’ensemble des messages reçus au noeud père

•  noeud nr •  Reçoit les messages de la part de tous les noeuds fils

22

Convergecast : Complexité

•  n – 1 messages •  n opérations

23


Plan

24

Qu’est ce qu’un braodcast ?

•  Un (ou plusieurs) noeuds envoie une donnée D à tous les noeuds du réseau

•  Initialement : •  D se trouve sur un (ou plusieurs) noeuds :

Ensemble N0

•  A la fin : •  D se trouve sur tous les noeuds du réseau.

25

Liens du AR

Liens non AR

noeud racine

noeud non racine

D D nr

Broadcast avec arbre de recouvrement : Exemple

D nr

D

26

Broadcast avec arbre de recouvrement : Algorithme

•  Nœud racine nr •  Envoie la donnée D à tous les fils (arbre AR)

•  Noeuds ni (i ≠ r) •  A la réception de la donnée D de la part du père

•  Si ni n’est pas un nœud feuille •  Envoyer D à tous les fils de ni

27

Broadcast avec arbre de recouvrement : Complexité

•  Chaque noeud : •  Reçoit un message de son père (sauf la racine) •  Envoie un message à ses fils (arbre AR)

•  Nombre de messages : n – 1 messages •  Nombre d’opérations : n •  … mais il faut construire le AR auparavant •  Lorsque |N0| > 1, on peut utiliser plusieurs AR : Spanning

Forest.

28

Broadcast par vagues (Inondation)

noeuds possédant D

noeud ne possédant pas D

•  Chaque noeud ni gère : •  Liste des voisins directs : vi •  Un booléen atteinti

•  initialisé à faux •  mis à vrai si :

•  ni appartient à N0 •  ni reçoit D pour la 1ère fois

D

D

29

Première vague : générée par N0

30

Broadcast par vagues : Algorithme

•  atteinti = faux;

•  Si ni appartient à N0 •  atteinti = vrai •  Envoyer D à tous les voisins directs (vi)

•  A chaque réception de D (* |vi| réceptions *) •  Si atteinti =faux (* 1ère réception de D *)

•  atteinti := vrai •  Envoyer D à tous les voisins directs de ni

31

Broadcast par vagues : Complexité

•  La propagation de D se fait par vagues (waves) •  ni envoie une seul fois D à ses voisins directs •  ni reçoit D autant de fois qu’il a de voisins. •  Chaque lien du réseau transmet la donnée D

deux fois : Une fois dans chaque direction •  Complexité

•  2m messages (m : nombre de liens dans le réseau)

•  n “opérations” (n : nombre de noeuds)

32

Broadcast par vagues avec accusé de réception: Principe

33

•  L’ensemble N0 est un singleton •  Chaque nœud :

•  est adopté par le 1er nœud qui lui envoie D •  Envoie D à tous ses voisins directs, sauf son père •  Recoit D autant de fois qu’il a de voisins directs •  A la réception du dernier D, envoie D à son père

Broadcast par vagues avec accusé de réception

34

Broadcast par vagues avec accusé de réception

•  Chaque noeud ni gère : •  Une liste des voisins directs : vi

•  Un booléen atteinti initialisé à faux •  Un compteur counti initialisé à 0 •  parenti initialisé à NULL

35

Broadcast par vagues avec accusé de réception : Algorithme

•  Si ni appartient à N0 (ni est le noeud racine) •  atteinti := vrai •  Envoyer D à tous les voisins directs

(* Le reste est exécuté quelque soit le noeud *)

•  A chaque réception D de la part d’un noeud nj (*|vi| mesg*) •  counti = counti + 1; •  Si atteinti =faux

•  atteinti := vrai •  parenti := nj •  Envoyer D à tous les voisins directs de ni ≠ nj

•  Si counti = |vi| et parenti ≠ NULL •  Envoyer D à parenti

36

•  Le noeud root nr envoie |vr| messages •  Chaque noeud ni ≠ nr

•  Envoie |vi| - 1 messages •  Envoie un accusé de réception (D) à son père

•  Nombre de messages : 2m •  2m – n + 1 •  En plus de l’accusé de réception : n – 1 (nombre de

liens dans l’arbre construit) •  Nombre “d’opérations” : n

Broadcast par vagues avec accusé de réception: Complexité

37

Exécution 1

Exécution 2

Broadcast par vagues avec ou sans accusé de réception : Non déterminisme

38

Les algorithmes Broadcast en bref

•  Par vagues (ou inondation) •  Asynchrone •  2m messages •  Avantage : Les liens utilisés varient d’une exécution à l’autre

•  Par vague avec accusé de réception •  Synchrone •  2m messages •  Avantages

•  Les liens utilisés varient d’une exécution à l’autre •  Construction de l’arbre de recouvrement

•  En utilisant un arbre de recouvrement •  n – 1 messages •  Inconvénient

•  Les mêmes liens inter-nœuds sont toujours utilisés •  Non tolérance aux pannes

☺"

☺"

#"

39


Plan

40

•  Construction d’un AR en largeur d’abord (Bredth First Serach : BFS) avec racine identifiée

•  Construction d’un AR en profondeur d’abord (Depth First Search : DFS) avec racine identifiée

•  Construction d’un AR sans racine identifiée

Trois algorithmes

41

Exemple

Le noeud a reçu le message M

Le noeud n’a pas encore reçu M

P

nr

P

R

M

M

M

M

Liens du AR

Liens non AR

M : Demande d’adoption P : Salut papa R : Non ! Tu n’es pas papa

nr

M

M

P

M

M

42

•  Pour chaque noeud ni •  parent : parent du nœud ni. Initialisé à NULL •  F : Ensemble des fils de ni. Initialisé à NULL •  NF : Ensemble des Non Fils de ni. Initialisé à NULL •  v : Ensemble des voisins de ni

Structure de données

43

•  Trois types de messages : •  M : Demande d’adoption d’un fils •  P : Tu as demandé mon adoption, tu es mon papa •  R : Tu as demandé mon adoption, merci mais j’ai déjà

un papa.

Les messages

44

•  Pour le noeud racine nr •  Envoi d’un message <M> à tous les voisins •  Attente de messages <M>, ou <R> •  A la réception d’un message <M>

•  Envoyer un message <R>

•  A la réception d’un message •  Actualiser la liste des noeuds fils : F

•  A la réception d’un message <R> •  Actualiser la liste des noeuds non fils : NF

Algorithme (exécuté par nr)

45

•  Répéter •  A la première réception de M de la part de nj

•  ni envoie un message à nj •  parent = nj •  ni envoie un message <M> à tous les voisins autres que nj

•  Pour les autres messages <M> reçus •  ni envoie le message <R> à l’émetteur

•  Pour un message reçu •  Actualiser la liste des processus fils : F

•  Pour un message <R> reçu •  Actualiser la liste des processus non fils : NF

•  Jusquà (condition d’arrêt)

Algorithme (exécuté par ni , i ≠ r)

• ?

46

Test d’arrêt

•  Un noeud non racine s’arrête d’attendre des messages lorsque :

•  |NF| + |F| + 1 = nombre de voisins

pére

Nombre de messages Nombre de messages <R>

•  Le noeud racine s’arrête d’attendre des messages lorsque : #  |NF| + |F| = nombre de voisins

47

Remarques

•  L’algorithme BFS est écrit de sorte à privilégier un parcours parallèle des voisins.

•  L’AR généré est en général large avec peu de niveaux

•  Est si on désire obtenir un AR étroit avec beaucoup de niveaux ?

48

•  Construction d’un AR en largeur d’abord (Breadth First Search : BFS) avec racine identifiée

•  Construction d’un AR en profondeur d’abord (Depth First Search : DFS) avec racine identifiée

•  Construction d’un AR sans racine identifiée

Trois algorithmes

49

•  Pour chaque noeud ni •  parent : parent du nœud ni. Initialisé à NULL •  F : Ensemble des fils de ni. Initialisé à NULL •  NF : Ensemble des Non Fils de ni. Initialisé à NULL •  v : Ensemble des voisins de ni

•  NE : Ensemble des voisins de ni non encore explorés. Initialement NE = v


50

•  Pour le noeud racine nr •  parent = nr

•  Choisir un nœud nk et l’enlever de NE •  Envoi <M> à nk

Algorithme

51

•  Au niveau d’un noeud ni •  A la réception de <M> de la part de nj

•  si parent = NULL /* Premier Message M reçu */ •  parent = nj •  Enlever le nœud nj de NE •  si NE ≠ NULL

•  Choisir un nœud nk et l’enlever de NE •  Envoi <M> à nk

•  sinon /* Le Message M reçu n’est pas le premier */ •  ni envoie le message <R> à l’émetteur

•  A la réception de ou <R> de la part de nj •  si le message reçu est <R> alors ajouter nj à NF •  si le message reçu est alors ajouter nj à F •  si NEi ≠ NULL

•  Choisir un nœud nk et l’enlever de NE •  Envoyer <M> à nk

Algorithme … suite

52

Test d’arrêt

•  Le noeud racine s’arrête d’attendre des messages lorsque : •  |NF| + |F| = nombre de voisins


•  |NF| + |F| + 1 = nombre de voisins •  En plus, Si parent ≠ ni (nœud non racine) alors envoyer un

message à parent /* fin du programme */

53

!  Construction d’un AR en largeur d’abord (Breadth First Search : BFS) avec racine identifiée

!  Construction d’un AR en profondeur d’abord (Depth First Search : DFS) avec racine identifiée

!  Construction d’un AR sans racine identifiée

Trois algorithmes

54

Construction d’un AR, racine non identifiée

•  Chaque nœud ni est identifié par un identificateur idi •  Chaque nœud candidat tente de construire un AR de type DFS

en envoyant son propre id. •  Si deux arbres AR essaient de s’approprier un nœud, celui-ci est

affecté au AR ayant la plus grande racine. •  Chaque nœud gère une variable leader : le plus grand id reçu. •  Lorsqu’un nœud ni reçoit un message id de la part de nj

•  si (id > leader) •  ni change de AR et envoie id à ses voisins (≠ nj)

•  Si (id < leader) •  ni bloque le message

•  Si (id = leader) // ni et nj appartiennent au même AR ayant la racine leader

•  ni envoie un message <R> à nj

55


•  Pour chaque noeud ni •  id : identifiant du nœud ni •  parent : parent du nœud ni. Initialisé à NULL •  leader : Plus grand id reçu par ni •  F : Ensemble des fils de ni. Initialisé à NULL •  NF : Ensemble des Non Fils de ni. Initialisé à NULL •  v : Ensemble des voisins de ni

•  NE : Ensemble des voisins de ni non encore explorés. Initialement NE = v

•  terminé : booléen qui arrête l’algorithme au niveau du nœud racine. Initialisé à faux.

56

Algorithme

•  Pour tous les noeuds •  parent = NULL; •  leader = 0; •  F = NULL; •  NE = v; •  terminé = faux

•  Chaque nœud ni candidat •  parent = ni

•  leader = idi

•  Choisir un nœud nk et l’enlever de NE •  Envoi <leader> à nk

57

•  A la réception de <y> de la part de nj •  si leader < y /* Passage à un autre arbre AR */

•  leader = y; parent = nj ; NE = v - nj. •  si NE ≠ NULL /* Tous les voisins ne sont pas explorés */

•  Choisir un nœud nk , l’enlever de NE et envoyer <leader> à nk •  Sinon ni envoie un message à parent

•  sinon /* leader >= y */ •  si leader = y alors envoi du message <R> à l’émetteur nj /* ni déjà dans

l’arbre */

•  A la réception de ou <R> de la part de nj •  si le message reçu est <R> alors ajouter nj à NF •  si le message reçu est alors ajouter nj à F •  si NEi = NULL

•  si (parent ≠ ni) {envoyer à parent; terminé = vrai} fsi •  sinon

•  Choisir un nœud nk , l’enlever de NE et envoyer <leader> à nk

Algorithme … suite (au niveau de ni)

58


•  |NF| + |F| + 1 = nombre de voisins

père

Nombre de Nombre de <R>

#  Le noeud racine s’arrête lorsque terminé est à vrai

Test d’arrêt

59


Plan

60

Problématique

•  Objectif •  Disposer d’une vue du réseau au niveau de chaque

nœud •  Chaque nœud s’identifie aux autres :

•  Type, Processeur, OS, performance, ressources, etc.

•  Pourquoi ? •  Tolérance aux pannes : panne de certains nœuds du

réseau •  Gérer la qualité de service (Quality of Service)

•  Choix du meilleur nœud pour un service donné

61

Solutions

•  1ère solution •  Exécuter séquentiellement l’algorithme Broadcast avec

ACK n fois •  Chaque nœud envoie son identification aux autres

•  2ème solution •  Exécuter en parallèle l’algorithme Broadcast avec ACK:

Algorithme Test_Connectivity (TC)

62

Algorithme TC : Principe

•  Algorithme Test_Connectivity •  Exécution en parallèle de l’algorithme Broadcast avec

accusé de réception •  Génération de n arbres de recouvrement (AR)

•  Chaque nœud envoie son identificateur id à tous ses voisins

•  Les voisins propagent l’id reçu vers tous les nœuds voisins (sauf le nœud émetteur)

63

Algorithme TC

64

Algorithme TC : Structure de données

•  idi : Identifiant du nœud ni •  vi : liste des voisins directs

•  atteinti (j) •  Booléen initialisé à faux et mis à vrai lors de la première

réception de idj par le nœud ni •  counti (j) : nombre de réception du message idj par le nœud ni

•  parenti (j) : •  Initialisé à NULL. •  Pointe sur le nœud nk de vi qui a envoyé, pour la première fois, le

message idj à ni •  initi : booléen positionné à vrai si :

•  ni appartient à N0 ou •  lors de la réception du premier message par ni

65

Algorithme TC

•  ni appartient à N0 •  initi := vrai; •  atteinti (i) := vrai; •  Envoyer idi à tous les nœuds de vi

66

Algorithme TC … Suite

•  Répéter •  A la réception de idk de la part de nj

•  si non (initi) // ni envoie ses informations •  initi := vrai; atteinti (i) := vrai; •  Envoyer idi à tous les nœuds de vi

•  counti (k) := counti (k) + 1; •  si non (atteinti (k))

•  atteinti (k) := vrai •  parenti (k) := nj •  Envoyer idk à tous les voisins directs de ni ≠ nj

•  si (counti (k) = |vi|) et (parenti (k) ≠ NULL) •  Envoyer idk à parenti (k)

•  Jusqu’à (condition d’arrêt)

67

Algorithme TC : Complexité

•  n exécution de l’algorithme broadcast avec ACK •  2 n*m messages •  n2 exécutions de l’algorithme broadcast avec ACK

68


Plan

69

Calcul des plus courts chemins : Calcul_PCC

•  Quoi ? : Calcule le plus court chemin entre deux nœuds quelconque du réseau.

•  Pourquoi ? : Routage des messages. •  A la fin de l’exécution de l’algorithme, chaque nœud ni est informé :

•  de la plus petite distance qui le sépare de chaque nœud du réseau •  du plus court chemin qui relie ni à à un autre nœud nj.

•  Pour le chemin (ni, nj): ni connaît le voisin nk qui appartient au chemin. nk connaît à son tour le prochain voisin direct nh qui le relie à nj, et ainsi de suite.

•  Deux algorithmes : •  Algorithme synchrone : S_Calcul_PCC •  Algorithme asynchrone : A_Calcul_PCC

70

Algorithme Synchrone : S_Calcul_PCC

•  A l’instant t = 0 : Chaque nœud ni envoie son identificateur à tous ses voisins.

•  A l’instant t = 1 : •  Chaque nœud ni a reçu les messages de la part de ses voisins, il connaît

alors les nœuds nj tels que disti(j) = 0 ou 1. •  ni construit l’ensemble des nœuds nj tels que disti (j)= 1 et les transmets

vers ses voisins. •  A l’instant t = 2 :

•  Chaque nœud ni a reçu les messages de la part de ses voisins, il connaît alors les nœuds nj tels que disti(j) = 0, 1 ou 2.

•  ni construit l’ensemble des nœuds nj tels que disti(j)=2 et les transmets vers ses voisins.

disti (j) : la plus petite distance qui sépare le nœud ni du nœud nj

71

•  A l’instant t >= 0, chaque nœud ni envoie à ses voisins

l’ensemble des nœuds nj tels que la distance disti (j) = t.

•  Pour t = 0, cet ensemble est le singleton ni.

•  Pour t > 0, cet ensemble représente les nœuds reçus

durant les précédents t–1 instants. La distance entre ces

nœuds et ni est au plus égale à t:

•  Ces nœuds ont une distance t-1 des voisins de ni.

Algorithme Synchrone : S_Calcul_PCC

72

•  disti (j) : la plus petite distance qui sépare le nœud ni du nœud nj

•  Initialement, disti (j) = n pour i ≠ j et disti (i) = 0.

•  firsti (j) : nœud, appartenant à vi, qui est le premier nœud du chemin le plus court qui relie les nœuds ni et nj.

•  Initialement, firsti(k)= null

•  seti (t) : L’ensemble des nœuds que ni envoie à ses voisins à l’instant t.

•  Initialement, seti (0) = {ni}

•  MSGi (t) : Ensemble des nœuds reçus par le nœud ni à l’instant t-1 de la part de tous les nœuds voisins

•  MSGi (t) est l’union des messages setj (t) reçus de la part des voisins nj du nœud ni.

Structure de données (S_Calcul_PCC)

73

Algorithme : S_Calcul_PCC

•  MSGi (0) = {} ; •  Pour (tous les nœuds de N) faire envoyer seti(0) aux voisins vi finpour •  Pour t allant de 1 à n – 1 faire // longueur max d’un chemin = n -1 •  Pour (chaque réception de MSGi(t-1)) faire

•  seti(t) = {} ; •  Pour (chaque setj(t-1) appartenant à MSGi(t-1)) faire

•  Pour chaque nœud nk appartenant à setj(t-1) faire •  Si (disti (k) > t) alors

•  disti (k) = t ; •  firsti (k) = nj; •  seti(t) = seti(t)+{nk}

•  Finpour •  Envoyer seti(t) à tous les voisins de ni (ensemble vi) •  t = t + 1; •  Finpour

•  FinPour

MSGi(t-1)

setm(t-1)

• seth(t-1)

• setl(t-1)

seti(t) ni

74

Version asynchrone …

75

•  disti (j) : la plus petite distance qui sépare le nœud ni du nœud nj •  Initialement, disti (j) = n pour i ≠ j et disti (i) = 0.

•  leveli (j) = d : ni a reçu de nj les nœuds ayant une distance d de nj. •  nj appartient à vi

•  Initialement, leveli(j)= -1 •  leveli (j) peut être considéré comme l’horloge par

rapport au voisin nj •  firsti (j) : nœud, appartenant à vi : le premier nœud du

chemin le plus court qui relie les nœuds ni et nj. •  Initialement, firsti(j)= null

Structure de données (A_Calcul_PCC)

76

•  statei : statei = d signifie que ni a reçu tous les

identificateurs des nœuds qui sont à une distance d.

•  Initialement, statei = 0

•  statei peut être considérée comme l’horloge des

«horloges» leveli (j) (en ce qui concerne le nœud ni)

•  seti : Nœuds à envoyer par ni à ses voisins.

•  Initialement, seti = {ni}


77

•  Pour tous les nœuds ni •  disti (i) = 0; •  disti (j) = n pour j ≠ i •  leveli (j) = -1 pour ni appartenant à vi. •  firsti (j) = null pour i ≠ j •  statei = 0 •  initi = faux •  seti = {ni}

•  Pour les nœuds ni appartenant à No •  initi = vrai •  Envoyer seti à tous les nœuds voisins (vi)


78

Algorithme A_Calcul_PCC (exécuté par tous les ni)

•  Tant que (statei < n-1) faire •  A la réception d’un message setj de la part de nj

(appartenant à vi) •  Si (non initi) alors debut initi = vrai; envoyer seti à tous les voisins

fin fsi •  leveli (j) = leveli (j) + 1; •  Pour (tous les nœuds nk appartenant à setj) faire

•  Si (disti (k) > leveli (j) + 1) alors •  disti (k) = leveli (j) + 1 ; •  firsti (k) = nj;

•  Si (leveli (j) >= statei) pour tous les nj de l’ensemble vi) alors •  statei = statei + 1; •  seti = {nk / disti(k) = statei} •  Envoyer seti à tous les voisins de ni (ensemble vi)

79


Plan

80

Algorithmes d’élection

•  On s’intéresse aux graphes complets •  1ère solution

•  Tous les nœuds envoient leur identifiants aux autres nœuds •  A la réception des identifiants, chaque nœud peut identifier le

nœud leader •  Complexité : O(n2) pour les messages et O(1) pour le

traitement

81

Algorithme S_Elect_Leader

•  2ème solution •  Les nœuds candidats sont ceux qui désirent être leaders •  Chaque nœud envoie son identifiant (id) à un seul (20)

destinataire, puis à 2 (21) destinataires, puis à 4 (22) destinataires, etc.

•  Lors de la kéme étape, un nœud envoie son id à 2k-1

destinataires •  Pour envoyer à tous les nœuds, il faut log(n) étapes •  Complexité

•  O(n log(n)) pour les messages •  O(n) pour le traitement

82

Algorithme S_Elect_Leader

•  2ème solution … suite •  L’envoie de l’id est considéré comme une tentative de

«capture» du nœud destinataire •  Pour être élu, il faut réussir à capturer tous les nœuds du

réseau •  Un nœud ni réussit à capturer un nœud nj si idi est plus

grand que les id de tous les nœuds qui tentent de capturer nj. De plus, idi doit être supérieur à idj.

•  A l’étape k, ni ne tente de capturer des nœuds que s’il réussit à capturer tous les nœuds de l’étape k-1. Dans le cas contraire, il cesse d’être candidat.

83

•  Structure de données •  candidati

•  Initialisé à vrai pour les nœuds de No, à faux pour les autres •  triedi(j)

•  concerne les nœuds appartenant à vi. Il est à vrai pour les voisins à qui ni a déjà envoyé un message, faux sinon

•  owneri •  Propriétaire du nœud ni, initialisé à NULL

Algorithme d’élection: S_Elect_Leader

84

Algorithme S_Elect_Leader (exécuté par tous les ni)

•  Initialisation •  t = 0; // horloge ou pulsation

•  MSGi = {}; •  Pour les nœuds candidats (appartenant à No), faire

•  candidati = true •  owneri = idi •  Choisir un nœud nj de vi

•  Envoyer capture(idi) à nj

•  t = t + 1;

85

Algorithme S_Elect_leader (exécuté par tous les ni)

•  t impair: •  Recevoir MSGi //union des captures reçus •  Sélectionner nk tel que idk >= idj, nj étant les nœuds

qui ont envoyé une demande de capture à ni. •  Si owneri < idk alors

•  Si candidati alors candidati = faux; •  owneri = idk •  Envoyer ACK à nk

•  t = t + 1;

86

Algorithme S_Elect_Leader (exécuté par tous les ni)

•  t est pair: •  Recevoir MSGi //union des ACK reçus •  Si candidati alors

•  Si «le nombre de messages envoyés (captures) est supérieur (strictement) à celui des ACK reçus»

•  alors candidati = faux; •  sinon

•  Si t < 2 (log n) alors •  Sélectionner parmi les nœuds nj de vi un ensemble S

tels que leur triedi(j) = faux •  Mettre triedi(j) à vrai pour les éléments de S •  Envoyer capture(idi) aux éléments de S

•  t = t + 1;

87

Version asynchrone …

88

Algorithme asynchrone A_Elect_Leader

•  L’algorithme doit s’assurer que deux candidats ne doivent/peuvent jamais capturer un même nœud

•  Un nœud a toujours un seul et unique leader (propriétaire) •  La comparaison ne se fait pas en fonction des identifiants

id mais en fonction du niveau d’avancement «level» •  level : nombre de groupes capturés par le nœud: 1, 2, 4,

8, etc. •  leveli = E [log (ownsi + 1)] où ownsi est le nombre de nœuds

capturés par ni

89

•  Pour capturer nj, ni envoie un message: •  capture (leveli, idi )

•  A la réception de ce message, nj teste: •  (levelj, propriétairej ) < (leveli, idi ) •  Test lexicographique: si les variables levels sont identiques, on

compare les variables propriétairej et idi.

A_Elect_Leader : comment ça marche?

90


•  ni demande la capture de nj : •  ni envoie à nj un message capture (leveli, idi )

•  A la réception de ce message, nj effectue le test: •  Si (levelj, propriétairej) > (leveli, idi ) alors

•  nj envoie un message nack à ni

•  Sinon •  levelj = leveli •  Si nj est candidat

•  nj n’est plus candidat •  nj envoie un message ack à ni •  A la réception du message ack, ni devient le propriétaire de nj.

91

•  Si nj n’est pas candidat

•  p_propriétairej = ni //garder trace de la candidature de ni •  nj envoie un message check (k) à ni

•  nk est le propriétaire actuel de nj. •  Objectif: Régler le contentieux entre ni et nk.

•  A la réception du message check, ni (s’il est toujours candidat):

•  Envoie un message eliminate (leveli, idi) à nk. •  A la réception du message eliminate (leveli, idi), nk teste :

•  Si (levelk, idk ) < (leveli, idi ) •  nk envoie un message eliminated à ni

•  Sinon •  nk envoie un message nack à ni


92

•  Structure de données •  candidati

•  Initialisé à vrai pour les nœuds de No, à faux pour les autres •  triedi(j)

•  concerne les nœuds appartenant à vi. Il est à vrai pour les voisins à qui ni a déjà envoyé un message de capture, faux sinon

•  propriétairei •  Propriétaire du nœud ni, initialisé à NULL

•  leveli : log (ownsk) nk est le propriétaire de ni •  nb_capturési : nombre de nœuds capturés •  p_proriétairei: proprétaire potentiel du nœud ni •  p_capturéi: nœud en cours de capture par ni

A_Elect_Leader : Algorithme

93

A_Elect_Leader : Algorithme … suite

•  Si ni appartient à No •  candidati = vrai; •  owneri = idi •  ownsi = 0; •  leveli = 0; •  p_owneri = NULL •  p_capturéi = NULL •  On choisit un nœud nj appartenant à vi (vi contient les

autres nœuds du graphe puisque G est complet) •  triedi(j) = vrai •  Envoyer capture (leveli, idi) à nj

94

•  A la réception de capture (levelj, idj) •  Si p_owner = idj

•  owneri = idj •  Envoyer ack () à nj

•  Si (leveli, owneri) < (levelj, idj) alors •  leveli = levelj ; •  Si candidati alors

•  candidati = faux •  owneri = idj •  Envoyer ack à nj

•  Sinon •  p_owneri = idj •  Envoyer check () à nk (propriétaire actuel de ni (owneri = idk))

•  Sinon envoyer nack () à nj

95

•  A la réception de nack

•  Si candidati alors candidati = faux;

•  A la réception de check (j) •  Si candidati alors envoyer eliminate (leveli, idi) à nj;


96

•  A la réception de eliminate (levelj, idj)

•  Si non candidati alors envoyer eliminated à nj

•  sinon •  Si (leveli, owneri ) < (levelj, idj) alors

•  candidati = faux; •  Envoyer eliminated à nj

•  Sinon envoyer nack () à nj

•  A la réception eliminated •  Si candidati alors

•  Soit nj le nœud de vi tel que p_ownedi = idj. •  Send capture (leveli, idi) à nj

97

•  A la réception de ack () •  nb_capturési = nb_capturési + 1; •  leveli = E [log(ownsi )]; •  S = {nj appartiennent à vi tels que triedi(j) = faux} •  Si S ≠ {} alors

•  On choisit un nœud de S : nj •  triedi (j) = vrai •  Envoyer capture (leveli, idi) à nj


98


Plan

•  Chaque site dispose : •  d’un entrepôt contenant les fichiers partagés •  d’une liste de voisins (au sens Gnutella) •  d’un Algorithme de recherche distribué

•  Basé sur un algorithme de diffusion •  Avec une portée limitée (Time To Live : TTL)

Gnutella

•  Une requête de recherche : •  Fichier recherché, •  Durée de vie (Time To Live : TTL)

•  Une requête est envoyée vers les nœuds voisins •  A la réception d’une requête :

•  Recherche dans l’entrepôt local •  Si le fichier existe, un relpy est envoyé à l’émetteur •  Décrémentation de TTL •  Si TTL non nul, la requête est envoyée aux voisins

directs.

Principe de recherche

• Site Gnutella • Client

• Site Gnutella

• Site Gnutella • Site Gnutella

• Site Gnutella

• Site Gnutella

• Site Gnutella • 3

• 3

• 3

• 2

• 2

• 2

• 2

• 2

• 1

• Connexion Gnutella

• Fichier trouvé

• TTL • x • 1

Principe de recherche

•  Application : partage de données •  Chaque site dispose de :

•  son propre entrepôt •  Un algorithme de recherche

•  Un fichier est représenté par : •  Une clé •  Son contenu (pas toujours) •  L’adresse IP de la machine qui l’héberge (propriétaire)

FreeNet

Clé Contenu (donnée) Adresse IP (propriétaire)

xYWERaa Pointeur sur le fichier 129.187.133.141

saWQEa Pointeur sur le fichier

192.199.111.101

Entrepôt

• b

• d

• e • f

• a

• c

• Connexion Freenet

• 10 e • 67 c

• 45 f • 98 d • 45 f

• 55 b

• 55 b

• 10 e

• 50 d • 98 d

• 67 c

• 55 b

Réseau Freenet

•  A la réception d’une requête : •  Recherche du fichier (clé) dans l’entrepôt local •  Envoie au voisin qui héberge le fichier ayant la clé la

plus proche •  Un site ne traite jamais une requête plus qu’une fois.

•  Lorsqu’un site ne peut plus transmettre une requête, il la renvoie au site émetteur …

•  Le résultat est : •  transmis au client en suivant le même circuit •  stocké au niveau des sites intermédiaires

Principe de la recherche

• b

• d

• e • f

• a

• c

• Requête

• 1 • 2

• 3

• 4

• 5

• 6 • 7

• 8

• 9

• 10

• 11 • 12

• Réponse positive

• Requête • Réponse négative

• Connexion Freenet

• 10 e • 67 c

• Recherche d’un document : clé = 50

• 45 f • 98 d • 45 f

• 55 b

• 55 b

• 10 e

• 50 d • 98 d

• 67 c

• 50 d

• 50 d

• 50 d

• 55 b

Algorithme de recherche

Algorithmes distribués de base -...

Documents

Transcript of Algorithmes distribués de base -...