Structures de données avancées : Range Partionning: RP*

Présentation au sujet: "Structures de données avancées : Range Partionning: RP*"— Transcription de la présentation:

1 Structures de données avancées : Range Partionning: RP*
ZEGOUR Institut National d ’Informatique

2 RP* Famille des SDDS, appelée RP* (Range Partitioning) : RP*N, RP*C et RP*S Un client RP*N envoie ses requêtes aux serveurs en utilisant uniquement des messages Multicast. Il ne comporte aucune image sur le fichier distribué. Un fichier RP*C est un fichier RP*N avec une image construite au niveau de chaque client. Cette image permet à un client RP*C d’utiliser des messages unicast lorsqu’il s’adresse à un serveur déjà référencé. Le multicast est utilisé dans le cas contraire. Un fichier RP*S ajoute à RP*C un index distribué au niveau des serveurs indexant toutes les cases. Élimine le multicast.

3 RP*N Structure et Évolution du Fichier
Un fichier RP*N évolue par éclatement de cases ( comme un B-arbre). Chaque fragment du fichier correspond à une case de données, pouvant contenir au maximum b enregistrements, et stockée en mémoire centrale sur un serveur. Un enregistrement est composé d’un champ clé et d’un ou de plusieurs champs non-clé. Les cases forment une partition sur l’ensemble des clés. Chaque case est associée à un intervalle noté (  , ], où  est appelée la clé minimale de la case et  sa clé maximale.

4 RP*N Structure et Évolution du Fichier
Un fichier RP*N est initialement constitué d’une case unique qui porte le numéro zéro (case 0), avec  =- et  =+ . Toutes les insertions initiales vont à la case 0. Elle est éclatée lorsqu’elle atteint sa capacité maximale b. L’éclatement consiste à déplacer, vers un nouveau serveur, tous les enregistrements ayant une clé appartenant à la moitié supérieure de l’intervalle de la case. Cet intervalle est d’abord divisé en deux par la clé du milieu de l’éclatement, notée cm. A l’issue de cet éclatement, aucun message de mise à jour de la structure du fichier n’est envoyé aux clients.

5 RP*N Évolution d’un fichier RP*N avec des enregistrements de clé alphanumérique et pour b =4. a to the of and of and a to the +  -  of - +  of 1

6 RP*N Évolution d’un fichier RP*N avec des enregistrements de clé alphanumérique et pour b =4. is of in and a to the that in and a to the that of is of - +  of in - +  of of in 1 1 2

7 RP*N Évolution d’un fichier RP*N avec des enregistrements de clé alphanumérique et pour b =4. for in i and a to the that of is for and a to the that of is in i 1 2 1 2 3 in - +  of of in for - +  of of in in for

8 RP*N Algorithme d’éclatement d’une case RP*N.
1. Déterminer Cm, la clé du milieu des clés de la case débordée (serveur) B et de la nouvelle clé, cela permet d’obtenir g1 et g2. 2. Allocation d’un serveur Si 3. Initialiser l’intervalle de la case du serveur Si : (Si)  Cm, (Si)  (B) 4. Copier dans Si l’ensemble des enregistrements de g2. 5. Mettre à jour la clé maximale de B : (B)  Cm 6. Supprimer les enregistrements de g2 de B

9 RP*N Accès au fichier Les clients RP*N accèdent au fichier en envoyant des requêtes d’insertion, de mise à jour, de suppression ou de recherche d’enregistrements. Ces requêtes sont réparties en plusieurs catégories : Requête simple Requête à intervalle

10 RP*N Requête simple Elle correspond à la recherche, à l’insertion, à la suppression ou à la mise à jour d’un enregistrement de clé c donnée. Dans RP*N, une requête simple est envoyée à l’aide d’un message Multicast. Elle est reçue par tous les serveurs. Chaque serveur S, d’intervalle (, ], procède comme suit : Si c (, ] alors S exécute la requête, puis envoie éventuellement une réponse au client à l’aide d’un message Unicast. Cette réponse contient le résultat de l’exécution de la requête( par exemple : l’enregistrement de clé c pour une recherche avec succès ) S ignore la requête si c  (, ].

11 RP*N Requête à intervalle
(Même principe pour les clients RP*C et RP*S) Il s’agit de la recherche de l’ensemble des enregistrements de clés c appartenant à un intervalle donné (a, b] (a <b Une telle requête est envoyée à tous les serveurs à l’aide d’un message Multicast. Elle est traitée sur chaque serveur d’intervalle (, ] tel que (, ]  (a, b]  {}. Les enregistrements sélectionnés sont ensuite envoyés au client en parallèle.

12 RP*N Terminaison d’une requête à intervalle (a, b]   (i , i]
Terminaison déterministe Chaque serveur Si d’intervalle (i, i] tel que (i, i]  (a, b]  {} envoie une réponse au client avec son intervalle (i, i] et, éventuellement, les enregistrements trouvés. Le client termine la requête avec succès, si (a, b]   (i , i]

13 RP*N Terminaison d’une requête à intervalle Terminaison probabiliste
Un serveur répond uniquement lorsqu’il trouve au moins un enregistrement ayant une clé dans l’intervalle de la requête. Le client utilise un time out t pour collecter les réponses. Ce time out est réinitialisé après la réception de chaque réponse. La requête est terminée lorsque t expire. Ce time out doit être choisi de manière à réduire la probabilité de perte de réponses. Ce choix dépend non seulement des performances du réseau mais également de la vitesse de traitement des serveurs.

14 RP*C Structure de l’image
RP*C crée une image du fichier sur chaque client pour réduire l’usage de messages Multicast. Cette image n’est qu’une collection des intervalles et des adresses des différentes cases déjà accédées. Elle ne correspond pas forcément à la structure exacte de la répartition du fichier sur les serveurs. Son rôle est de permettre à chaque client d’utiliser un message Unicast lorsqu’il envoie une requête simple à une case déjà référencée. Le Multicast est utilisé dans le cas contraire.

15 RP*C Structure de l’image
L’image se présente sous forme d’une table T de couples (A, C), où A est l’adresse d’une case et C sa clé maximale. Elle est ordonnée suivant les différentes valeurs de C. Sa structure est semblable à celle d’un nœud d’un B-arbre. L’adresse associé à une entrée quelconque i de T est notée par A(i), sa clé est notée par C(i). Une adresse inconnue est représentée par le symbole ‘*’. Initialement, c’est à dire au démarrage d’un nouveau client, T ne contient que l’élément (0, ]. Puis, elle évolue en fonctions des IAMs reçus suite aux erreurs d’adressage.

16 RP*C Accès à l’article ( cas de recherche d’un enregistrement de clé c ( valable pour les mises à jour et insertions ) Coté Client : Désignons par R(c) la requête correspondant à la recherche de la clé c. Le client recherche d’abord l’entrée i T ayant la plus petite clé telle que C(i) c. Si A(i) ‘*’ alors il envoie R(c) par Unicast au serveur d'adresse A(i). Sinon R(c) est envoyée à tous les serveurs à l’aide d’un message Multicast.

17 RP*C Accès à l’article Coté serveur : Un serveur qui reçoit R(c) vérifie d’abord si c appartient à son intervalle. Dans le cas défavorable, R(c) est ignorée si elle a été envoyée par Multicast. Sinon, il s’agit d’une erreur d’adressage. Le serveur redirige alors la requête par Multicast vers les autres serveurs. Le message redirigé contient, en plus de R(c), l’adresse du serveur et son intervalle. Dans le cas favorable, le serveur exécute R(c), puis envoie une réponse au client. Cette réponse contient éventuellement l’enregistrement de c trouvé, ainsi que l’adresse et l’intervalle du serveur.

18 RP*C Accès à l’article IAM : Toute réponse à une requête envoyée sans erreur d’adressage contient un IAM noté (  , a,  ) L ’intervalle ( ,  ] est celui du serveur ayant traité la requête a représente son adresse. Une réponse à une requête redirigée comporte deux IAMs correspondant au serveur qui a effectué la redirection et celui qui l’a traitée. Dans les deux cas, le client corrige son image à l’aide de chaque IAM, selon l’Algorithme de mise à jour de l’image.

19 RP*C Mise à jour de l’Image
( En entrée : (, a, ) ) 1. S'il n'existe pas dans T une entrée i de valeur (a, C) telle que C(i) =  et   - , alors insérer (*,  ) dans T. 2. S'il existe dans T une entrée i de valeur (a, C) telle C(i) > , alors : a) Si C(i) =+  alors Remplacer l’entrée i par (a,  ) puis insérer le couple (*, + ) dans T. b)Sinon, si C(i) <+  alors Remplacer l’entrée i par (a, ). 3. S'il existe dans T une entrée i de valeur (*,  ) alors Remplacer l’entrée i par (a, ). 4. S'il n'existe pas dans T une entrée i de valeur (a, ) alors insérer (a,  ) dans T.

20 RP*C Évolution de l’image d‘un client RP*C. I A M Table T 0 
(-, for, 0) 0 for  *  Règle 2a) 0 for  * in  *  (in, of, 2) Règle 1 0 for  * in  2 of  *  Règle 4 Table T

21 RP*C Évolution de l’image d‘un client RP*C. I A M Table T (of, , 1)
0 for  * in | 2 of | 1 Règle 3 0 for  3 in  2 of  1  Règle 3 (for, in, 3) Table T

22 RP*S Concepts RP *S ajoute à RP *C un index réparti au niveau de serveurs spécifiques appelés serveurs d’index. Un client RP*S a la même table qu’un client RP*C ( Sans ‘*’). Cet index représente une image de la structure globale de la répartition du fichier distribué. Il est transparent aux clients. Objectifs : Éliminer l’usage du Multicast pour envoyer les requêtes simples Accélérer la convergence de l’image du client pour réduire le nombre d’erreur d’adressage.

23 RP*S Structure de l’Index Réparti
L’index RP *S a une structure semblable à celle d’un fichier en arbre-B+ distribué. Les serveurs d’index correspondent aux nœuds non terminaux de l’arbre, les cases (serveurs) de données représentent les feuilles.

24 RP*S Structure de l’Index Réparti
Chaque serveur d’index peut contenir au maximum m (m >>1) couples (A, C) ordonnés ( comme dans l’image d’un client). A représente un pointeur vers le nœud de niveau inférieur, de clé maximale C. En fait, A correspond à l’adresse d’un serveur d’index ou d’une case si le nœud est une feuille. Les clés C1 et C2 de deux couples successifs (A1, C1) et (A2, C2) d’un serveur d’index définissent l'intervalle du serveur d’index ou de la case référencée par le pointeur médian A2.

25 RP*S Structure de l’Index Réparti
Chaque serveur d’index est muni d’un en-tête contenant son intervalle et un pointeur vers son nœud parent. Chaque case (serveur) de données est muni d’un en-tête contenant son intervalle et un pointeur vers le nœud feuille d’index le plus à gauche. Remarque : les B-arbres ne comportent pas de pointeurs parents. Ces pointeurs sont utilisés pour la redirection des requêtes en cas d’erreur d’adressage.

26 RP*S : Exemple à 1 niveau d’index
- +  *  0 for 3 in 2 of 1 for and a to the that of It is in i a for - a of a of in a in for 1 2 3

27 RP*S : Exemple à 2 niveaux d’index
- + * a in b c a - in c 0 for 3 in  c2 of 1 these 4 b for and a these the that of It is in i to this a for - a these of a of in a in for a  these 1 2 3 4

28 RP*S Évolution du fichier
L’algorithme d’éclatement de RP*S est une extension de celui de RP*C. Il exige une mise à jour de l’index, comme dans un arbre-B+, à chaque fois qu’une nouvelle case est créée.

29 RP*S Évolution du fichier
1. La case 0 est éclatée comme dans RP *N. Il en résulte la création du premier nœud a qui représente la racine d'un arbre-B à un niveau d’index, d’intervalle (- ,+ )et de pointeur père *. 2. Le nœud a est créé avec le triplet (0, Cm, 1). Cm : clé du milieu. 3. Tout autre éclatement entraîne l'insertion d’un nouveau couple (Cm,r) dans a, où r est l'adresse de la nouvelle case. Le pointeur père de la nouvelle case est ensuite relié à a.

30 RP*S Évolution du fichier
4.Quand le nœud a devient plein, il est divisé en 2 donnant naissance à un nœud frère b et un nouveau nœud c devenant ainsi la nouvelle racine d'un arbre-B à 2 niveaux d’index. 5. Le nœud c est créé avec l’intervalle (- ,+ ) et de pointeur père *. C’est le père des nœuds a et b. 6. Etc.

31 RP*S Accès au fichier (Algorithme de traitement d’une requête simple dans RP *S) Un client qui désire envoyer une requête simple recherche d'abord l'adresse de la case à partir de son image. Soit S le serveur possédant la case d’intervalle ( ,  ]. S exécute les opérations suivantes lorsqu’il reçoit une requête avec une clé c : 1. Si c  ( ,  ], alors S exécute la requête. 2. Sinon, S redirige la requête vers son nœud père P. 3. Si c ( p,  p] de P, P alors envoie la requête à la case contenant l'enregistrement de clé c. 4. Sinon, P redirige la requête au niveau supérieur.

32 RP*S Accès au fichier (Algorithme de traitement d’une requête simple dans RP *S) 5. Ce processus est répété jusqu'à ce qu'une feuille ou la racine soit atteinte. 6. La feuille finale renvoie un IAM au client avec la trace du chemin parcouru par la requête dans l'arbre. La structure représentant ce chemin est appelée IA-Tree.

33 RP*S Accès au fichier (Algorithme de traitement d’une requête simple dans RP *S) Remarque : Suivant l’état de son image, le client peut envoyer directement une requête à un serveur d’index au lieu d’une case (serveur de données). Cela est considéré comme une erreur d’adressage. Dans ce cas, le serveur d’index redirige la requête vers la bonne branche de l’arbre distribué, pour quelle soit acheminée vers la case correcte.

34 RP*S Requête par intervalle
Peut être envoyée à l’aide d’un message Multicast, comme dans RP *N et RP *C. Il est aussi possible d’utiliser plusieurs messages Unicast. Dans ce cas, le client (selon sa table) envoie la requête par Unicast à chaque case du fichier, d’intervalle I’, tel que : I  I’ {}, où I est l’intervalle de la requête. Chaque message contient l’intervalle qui est supposé être celui du serveur cible. A la réception de ce message, chaque serveur cible exécute l’Algorithme de traitement des requêtes par intervalle.

35 RP*S Requête par intervalle ( Algorithme de traitement d’une requête par intervalle dans RP *S ) Soient S un serveur cible, IS son intervalle et I’S l’intervalle correspondant dans l’image du client. 1. Si IS =I’S, alors S traite la requête, puis envoie une réponse au client, avec son intervalle IS au moins, et éventuellement avec les données trouvées. 2. IS  I’S, alors S traite la requête uniquement sur son intervalle, puis envoie une réponse au client, avec son intervalle IS au moins, et éventuellement avec les données trouvées. Ensuite, il redirige la requête avec le reste de l’intervalle vers son nœud parent p.

36 RP*S Requête par intervalle ( Algorithme de traitement d’une requête par intervalle dans RP *S ) 3. p redirige la requête vers les cases (serveurs de données) qui recommencent la procédure à partir de 1 Chaque case qui répond envoie en même temps son intervalle ( pour les ajustements et dans le cas d’une terminaison déterministe) Le client collecte alors les réponses pour terminer la requête comme dans RP *N.

37 RP*S Algorithme de mise à jour de l’image d’un client RP *S.
Soit T la table représentant l'image d’un client comme dans RP *C. Notons par (a, s) un élément de T où a est un pointeur et s une clé. Cet algorithme est exécuté pour chaque nœud n de l'IA-Tree et pour chaque (a, s) de n de bas en haut et niveau par niveau.

38 RP*S Algorithme de mise à jour de l’image d’un client RP *S.
Pour chaque nœud feuille n (index) de l’IA-tree et pour chaque couple (a,s)  n, modifier T uniquement dans les cas suivants : Si s T, ajouter (a, s) à T en respectant l'ordre de rangement. Sinon, si (a, s')  T avec s's, alors s'  s [Modification de la borne supérieure de l’intervalle d'une case déjà enregistrée dans l’image] Si non, si (a', s)  T avec a'  a, alors a‘  a [Modification de l'adresse d'une case déjà enregistrée dans l’image ]  Transforme les adresses de nœuds en adresses de cases.

39 RP*S Algorithme de mise à jour de l’image d’un client RP *S.
Pour chaque (a, s) d'un nœud non feuille n (index) de IA-tree , modifier T uniquement dans les cas suivants : Si s  T, alors ajouter (a, s) à T Si (a',s)  T avec a'  a et s =  (n)   , alors : Soient s' le prédécesseur de s dans n, s'' le prédécesseur de s dans T Si s''  s', alors a'  a.

40 RP*S : Conclusion Facteur de chargement : le même pour les 3 méthodes(70% pour les insertions aléatoires) En terme de messages : Rp*N meilleur que Rp*C meilleur que Rp*S En terme de convergence des images des clients Rp*S meilleur que Rp*C C’est Rp*s qui exploite l’ordre. Schéma déterministe (fonctionne sans multicast) Inconvénient : exige beaucoup de message lors des opérations de recherche, insertion, ajustement, etc…