distributed compact trie hashing
DESCRIPTION
Distributed Compact Trie Hashing. Proposé par D.E ZEGOUR. Trie hashing. Le hachage digital est l'une des méthodes les plus rapides pour l'accès au fichiers monoclé, ordonnés et dynamiques. - PowerPoint PPT PresentationTRANSCRIPT
Distributed Compact Trie Hashing
Proposé par D.E ZEGOUR
Trie hashing
Le hachage digital est l'une des méthodes les plus rapides pour l'accès au fichiers monoclé, ordonnés et dynamiques.
La technique utilise une fonction de hachage variable représentée par un arbre digital qui pousse et se rétracte en fonction des insertions et suppressions.
Caractéristiques principales : l'arbre réside en mémoire pendant l'exploitation du fichier. 6 Octets / case Un accès au plus pour retrouver un article
Compact trie hashing
Plusieurs manières de représenter la fonction d'accès en mémoire. Objectifs : doubler les fichiers adressés pour le même espace mémoire utilisé par la représentation standard.L'idée : représenter les liens de manière implicite au détriment d'algorithmes de maintenance légèrement plus long que ceux de la représentation standard.Consommation : 3 octets par case du fichier.
Ce qui permet d'adresser des millions d'articles avec un espace mémoire dérisoire. Pour un environnement distribué cette option est sans doute plus intéressante notamment pour le transfert des parties de l'arbre d'un site à un autre.
Distributed compact trie hashing
Nous proposons une distribution de CTH relativement aux propriétés des Sdds, c'est à dire en respectant les contraintes suivantes :
Distribution des cases du fichier sur les serveurs( à raison d'un serveur par case)
Pas de site maître
Aucun dialogue entre les clients.
Plan à suivre
Compact trie hashing
Distribution de la méthode sur plusieurs sites.
Algorithmes informels de recherche et insertion
Illustration de la méthode
Algorithmes (Recherche et insertion)
Simulation à prévoir
Trie hashingExemple : Arbre de Litwin
O,0
I, 0 T, 0
_, 1 412
35
O, 0 T, 0
1 -3 5
I,I, 0 _, 1
-1-1 4 2
-2
0 1 2 3
3
Compact trie hashingExemple : Nouvel arbre
_
|TOI
5
2 1 43
5 T |12O3_ 4I
Compact trie hashingPrincipe
L'arbre contient toutes les séquences de division ordonnées sans la duplication des digits commun.
Tous les premiers digits des séquences de division sont placés de manière ordonnée de gauche à droite dans le niveau 1 de l'arbre.
Pour chaque nœud du niveau 1 tous les seconds digits sont placés au niveau 2 de manière ordonnée de gauche à droite. et ainsi de suite.
Les cases sont au niveau des feuilles.
La concaténation des digits sur une branche de l'arbre représente la clé maximale de la case figurant dans la feuille correspondante.
Compact trie hashingPrincipe
La représentation correspond ainsi au préordre ( n T1 T2 ) sur ce nouvel arbre.
Dans cette représentation : l'arbre digital est une suite de nœuds internes et externes.
Un nœud interne est un digit.
Un nœud externe est un pointeur vers une case du fichier.
Compact trie hashingExpansion de l’arbre
Soit m la case à éclater.
Former la séquence ordonnée des clés de cette case augmentée de la clé qui a provoqué la collision.
Soit C' la clé du milieu et C'' la dernière.
Déterminer la plus petite séquence Seq de digits dans C' qui permet de distinguer C' de C''. Soit C'1C'2.....C'K cette séquence.
Soit I les premiers digits de cette séquence qui existent déjà dans l'arbre.
Compact trie hashingExpansion de l’arbre
Expansion de l'arbre : Soit Ind_d : l'indice (dans l’arbre) du digit en fond de pile (premier digit de la clé maximale Cm de la case surchargée.)
Ind_m : l'indice de la case surchargée Si I <> 0
Si Cm préfixe de SeqInd_d := Ind_m
Sinon Ind_d := l'indice du premier digit de Seq différent
dans CmFsi
Fsi
Compact trie hashingExpansion de l’arbre
Cas k- I = 1
insérer à la position Ind_d
C'k m d1 d2 .....M
Cas k- I > 1
Insérer à la position Ind_d
C'i+1 C'i+2 .....C'k m M Nil2 Nil3 .....d1d2....Nil1
Dans le premier cas deux nœuds sont rajoutés, dans le second cas 2( K - I) nœuds.
M étant la prochaine case à allouer au fichier.
Compact trie hashingRecherche
L'algorithme de recherche parcourt la forme linéaire de l'arbre et utilise une pile.
Arbre[ I ] désigne la case recherchée.
I désigne l'indice de la case dans l'arbre
( P ) désigne le contenu de la pile en commençant par le fond si la pile n'est pas vide, ‘:' sinon.
( P ) désigne la clé maximale de la case trouvée.
Compact trie hashingRecherche
Init( P ) ; I := 1; Trouv := FauxTq Non Trouv :
Si Interne(Arbre[ I ])Empiler(P, ( Arbre[ I ], I ) )I := I + 1
Sinon Si C <= ( P ) Trouv := Vrai Sinon Depiler(P, (V, J) ) I := I + 1 Fsi Fsi Ftq
Compact trie hashingMécanisme de construction
Insertion de la séquence
a ce dx ef h x y kx fe hx hy yya yyb yyc
Capacité : B = 4
Au départ l'arbre est |0
‘||…’ désigne la clé maximale.
Compact trie hashingMécanisme de construction
1. a ce dx ef sont insérées dans la case 0.
L'arbre : | 0
0
acedxef
h
Compact trie hashingMécanisme de construction
2. Insertion de h
L'arbre : d 0 | 1
0
acedx
efh
1
Collision sur case 0
Clé maximale =‘||…’
Séquence de division = ‘d’
K = 1 ; I = 0
Compact trie hashingMécanisme de construction
3. Insertion de x y
L'arbre : d 0 | 1
0
acedx
efhxy
1
kx
Compact trie hashingMécanisme de construction
4. Insertion de kx
L'arbre : d 0 k 1 | 2
0
acedx
efhkx
1
xy
2
Collision sur case 1
Clé maximale =‘||…’
Séquence de division = ‘k’
K = 1 ; I = 0
Compact trie hashingMécanisme de construction
5. Insertion de fe
L'arbre : d 0 k 1 | 2
0
acedx
effehkx
1
xy
2
hx
Compact trie hashingMécanisme de construction
6. Insertion de hx
L'arbre : d 0 h 1 k 3 | 2
0
acedx
effehhx
1
xy
2
kx
3
Collision sur case 1
Clé maximale = ‘k|…’
Séquence de division = ‘h’
K = 1 ; I = 0
by
Compact trie hashingMécanisme de construction
7. Insertion de hy
L'arbre : d 0 h _ 1 4 k 3 | 2
0
acedx
effeh
1
xy
2
kx
3
hxhy
4
Collision sur case 1
Clé maximale =‘h|…’
Séquence de division = ‘h_’
K = 2 ; I = 1
Compact trie hashingMécanisme de construction
8. Insertion de yya yyb
L'arbre : d 0 h _ 1 4 k 3 | 2
0
acedx
effeh
1
xyyyayyb
2
kx
3
hxhy
4
yyc
Compact trie hashingMécanisme de construction
9. Insertion de yyc
L'arbre : d 0 h _ 1 4 k 3 y y a 2 5 Nil | Nil
0
acedx
effeh
1
xyyya
2
kx
3
hxhy
4
yybyyc
5
Collision sur case 2
Clé maximale =‘||…’
Séquence de division = ‘yya’
K = 3 ; I = 0
Compact trie hashingSuppression
Le processus de fusion est déclenché quand la taille de la case devient inférieure à B/2 lors d'une suppression.
La fusion aura lieu alors si la somme des clés contenues dans cette case et celles contenues dans la case sœur est <= B.
L'arbre est alors réduit d'un nœud interne et d'un nœud externe.
Le processus peut continuer en cascade.
Compact trie hashingSuppression
Soit ind_m l'indice dans l'arbre de la case (soit M) contenant la clé à supprimer. On peut avoir les cas suivants :
... d M M1.....
....d M1 M ....
....d M d1 M1 ....
....d1 M1 d M ....
C'est à dire respectivement :Interne(Ind_m - 1) et Externe(Ind_m + 1)Externe(Ind_m - 1) et Interne(Ind_m - 2)Interne(ind_m - 1) et Interne(Ind_m + 1) et Externe(Ind_m + 2) avec Ind_m + 2 <= NbrnoeudInterne(Ind_m - 1) et Interne(Ind_m - 3) et Externe( Ind_m - 2)
Compact trie hashingSuppression
Nil est considéré comme un nœud externe. Nbrnoeud est l'indice du dernier nœud dans l'arbre.
Ca se réduit respectivement comme suit :
... M .... ou ... M1 ... si M devient Nil
... M1 .... ou ... M ... si M1 est Nil
... d1 M1....
... d M ....
Compact trie hashingRecherche séquentielle
Les cases sont ordonnées de la gauche vers la droite. Dans l'exemple : 0 1 4 3 2 5.
Pour I :=1, Nbrnoeud
Si Externe ( I ) Et Non Nil
Imprimer la case Arbre[ I ]
Fsi
Fpour
Compact trie hashingPerformances
Algorithmes en mémoire : Recherche : N/2 en moyenne Insertion : N/2 décalages en moyenne Encombrement : 3 octets / case en moyenne.
algorithmes sur disque : ( même performance que TH)1 accès au plus pour retrouver un article
Distributed Compact trie hashingConcepts
Au niveau de chaque client il y a un arbre digital partiel à partir duquel toute opération sur le fichier est entamée.
Tout client peut rentrer en scène à tout moment avec un
arbre vide ( | 0 )
Pendant la phase de recherche, commune à toutes les opérations, émanant d'un client l'arbre est mis à jour progressivement jusqu'à l'obtention de l'arbre réel.(son mûrissement) . ( Processus décrit plus loin )
Distributed Compact trie hashingConcepts
Au niveau de chaque serveur il y a un arbre digital partiel une case contenant les articles du fichier un intervalle [Min, Sup]
L'arbre digital au niveau du serveur est créé ou étendu à chaque division d'un serveur. Il garde ainsi la trace de tous les éclatements sur ce serveur.
A toute case est associé un intervalle contenant toutes les clés possibles pouvant être contenues dans cette case. Cet intervalle est nécessaire lors de la phase de recherche puisqu'il en constitue le critère d'arrêt.
Distributed Compact trie hashingConcepts
Quand une case éclate , il y aextension de l’arbre du serveur extension de l'arbre du client . Initialisation d’un nouveau serveur
( Le processus d'éclatement est donné plus loin )
Les intervalles des deux serveurs sont aussi mis à jour.
Les arbres digitaux sont représentés en forme séquentielle préordre sur le graphe G‘.
Distributed Compact trie hashingConcepts
Initialisation du systèmeInitialiser le serveur 0 avecCase :Intervalle : >Petite <=Grande
Arbre : | 0
Nous supposons que toutes les clés sont strictement supérieures à une clé (_____) et inférieures ou égales à une clé (|||||||).Petite = '______'Grande = '|||||||||'
Les arbres au niveau des clients sont initialisés | 0.
Distributed Compact trie hashingConcepts
L'expansion du fichier se fait à travers les collisions. A chaque collision il y a distribution du fichier (du serveur éclaté) sur un serveur logique.
Le nombre de serveurs est conceptuellement infini.
Le serveur peut être déterminé de manière statique ou dynamique. On peut avoir plusieurs serveurs logiques pour le même serveur physique.
Distributed Compact trie hashing
Transformation (Client, Clé) Serveur(i) Appliquer CTH sur l'arbre du client. soit I le serveur sélectionné. (ii) Cas I = NilEnvoi d’un message à tous les serveurs : “Où suis-je?”Si un tel serveur existe ( soit m ) substituer m à Nil dans l’arbre du client. I := m;Stop(iii) Cas I <> NilAller au serveur I . Si clé dans l'intervalle de I : Arrêt avec succès(iv) Si arbre vide au niveau de I, ou I = précédent serveur c'est une impasse. Envoyer un message à tous les serveurs pour déterminer le nouveau serveur I et Arrêt (iv) Si arbre non vide déterminer la partie de l'arbre dans le serveur à copier dans le client. La recopier puis, reprendre à partir de (i)
Distributed Compact trie hashing
Transformation (Client, Clé) Serveur
Cas m = Nil
A tout Nil rencontrée est associé‚ un intervalle (Min, Max).
Quand on rencontre Nil dans l'arbre du client ( original ou modifié) on envoie un message à tous les serveurs pour
savoir si Nil a été remplacé ou non (avec l'intervalle).
s'il a été remplacé, on remplace Nil par ce serveur
Distributed Compact trie hashing
Transformation (Client, Clé) ServeurCas où I = précédent serveur
Supposons qu'un client avec l'arbre c 0 e t 3 5 | 2 recherche la cle 'h' et supposons que le serveur 2 contient l'arbre w 2 | 7 avec l'intervalle >s, <=w.
Le module de recherche sélectionne le serveur 2. Comme 'h' n'est pas dans l'intervalle de ce serveur, il y a remplacement dans l'arbre du client, ce qui donne
C 0 e t 3 5 w 2 | 7.
La ré application de CTH sur 'h' nous redonne 2 et le processus de recherche rentre dans une boucle infinie.
Distributed Compact trie hashing
Transformation (Client, Clé) Serveur
Détermination de la partie de l'arbre
1. Retrouver la séquence dans le client (Sc) de la position Ind_d jusqu'au prochain noeud interne. Cette séquence est rangée dans une liste (Pliste1) de manière découpée.
2. Rechercher dans le serveur toutes les séquences inférieures ou égales à Sc. Ces séquences sont rangées dans une liste (Pliste2) de manière découpé.
4. Lancer le module de résolution qui modifie la séquence du client en fonction des séquences déterminées dans le serveur
5.Mise en forme des séquences trouvées
Distributed Compact trie hashing
Transformation (Client, Clé) Serveur
Exemple :On veut par exemple rechercher une clé 'th' à partir d'un client possédant l'arbre f 0 h 6 l 3 t 2 w 1 | 4
CTH nous renvoi la valeur 2,
Au serveur 2 on à l'arbre o 2 | 9
Si 'th' n'appartient pas à l'intervalle du serveur 2, on applique l'algorithme de résolution qui détermine la partie de l'arbre à copier dans le client.
Distributed Compact trie hashing
Transformation (Client, Clé) Serveur
1. Séquence dans le client c'est Pliste1 = (t| , 2)
2. Séquence dans le serveur c'est Pliste2 = (o|, 2)
3. Comme 't' n'existe pas dans Pliste2, on récupère la case suivante, c'est à dire 9.
4. Résolution donne la liste (o|, 2) --> (t|, 9)
5. Mise en forme de la résolution : o 2 t 9
t 2 est remplacée par o 2 t 9. L' arbre du client devient :
f 0 h 6 l 3 o 2 t 9 w 1 | 4
Distributed Compact trie hashing
Transformation (Client, Clé) Serveur
Un autre exemple:
Au niveau du client :Sc = m i i 0 l 5 n 2 1 3Pliste1 = (mii, 0) (mil, 5) (min, 2) (mi, 1) (m, 3)Au niveau du serveura 6 d e 7 8Pliste2 = (a, 6) (de, 7) (d, 8)Résolution(a, 6) (de, 7) (d, 8) (mii, 0) (mil, 5) (min, 2) (mi, 1) (m, 3)Mise en forme : a 6 d e 7 8 m i i 0 l 5 n 2 1 3
Distributed Compact trie hashing
Recherche/Insertion : description informelle
Toute recherche commence par une phase de transformation (Client x) ---> m, Min, Impasse
Cas m = Nil
A tout Nil rencontrée est associé‚ un intervalle (Min, Max). Quand on rencontre Nil dans l'arbre du client ( original ou
modifié) on envoie un message à tous les serveurs pour savoir si Nil a été remplacé ou non (avec l'intervalle).
s'il a été remplacé, on remplace Nil par ce serveur et on insère la clé dans ce serveur et on continue, c'est a dire collision possible...
s'il n'a pas été remplacé on crée un nouveau serveur puis on initialise ce serveur avec les valeurs adéquates. Arrêt.
Distributed Compact trie hashing
Recherche/Insertion : description informelle
Cas m <> Nil ( ou m = nil et a été remplacé )
(i)Si x n'est pas dans la case et case non pleine insérer tout simplement x dans la case et l'algorithme se termine. (ii) Si x n'est pas dans la case et celle-ci est pleine il y a collision. Si on est passé par une impasse, on éclate uniquement l'arbre du serveur. ( Plus tard elle le sera au niveau du client.) Si on n'est pas passé par une impasse, on éclate les arbres du client et du serveur
Distributed Compact trie hashing
Illustration du mécanisme de distribution du fichier
Prenons capacité d'une case = 4Et insérons la séquence suivante des 25 clés par les clients correspondants : (1 js), (1 hw), (3 c), (2 gwmr), (3 g), (2 km), (4 zur), (1 ewg),(3 lewhv), (2 nrq), (3 mf), (4 pem), (4 rl), (2 bqyg), (3 v), (1 j),(2 qcm), (4 czxav), (2 lhgd), (3 z), (1 lrz), (3 kiyfg), (4 pbtpr),(3 hpqtp), (4 h)
Au départ chaque client a l'arbre | 0 On donne d'abord les 10 premières avec plus de détails, ensuite l'état final au niveau des clients et des serveurs.
Distributed Compact trie hashing
Illustration du mécanisme de distribution du fichier
Ishwgwmrc
gwmr
0
|0
[ ,|]
Client1 : | 0 Client2 : | 0 Client3 : | 0
Is hw c
Distributed Compact trie hashing
Illustration du mécanisme de distribution du fichier
ggwmrc
0
g0|1
[ ,g|]
Client1 : | 0 Client2 : | 0 Client3 : g 0 | 1
g
Ishw
1
|1
[g|,||]
Modification de l'arbre du client 3
Modification de l'arbre dans le serveur
éclaté 0
Distributed Compact trie hashing
Illustration du mécanisme de distribution du fichier
ggwmrc
0
g0|1
[ ,g|]
Client1 : | 0 Client2 : g 0 | 1 Client3 : g 0 | 1
km
Ishwkm
1
|1
[g|,||]
Application de CTH sur le client 2 Remplacer dans l'arbre du client la case 0
par la partie manquante se trouvant dans le serveur0 Application de CTH sur le nouvel arbre du client 2
Clé insérée dans le serveur 1
Distributed Compact trie hashing
Illustration du mécanisme de distribution du fichier
ggwmrc
0
g0|1
[ ,g|]
Client1 : | 0 Client2 : g 0 | 1 Client3 : g 0 | 1
zur
Ishwkmzur
1
|1
[g|,||]
Client4 : g 0 | 1
Application de CTH sur le client 4 Remplacer dans l'arbre du client la case 0
par la partie manquante se trouvant dans le serveur0 Application de CTH sur le nouvel arbre du client 4
Clé insérée dans le serveur 1
Distributed Compact trie hashing
Illustration du mécanisme de distribution du fichier
ggwmrcewg
0
g0|1
[ ,g|]
Client1 : | 0 Client2 : g 0 | 1 Client3 : g 0 | 1
ewg
Ishwkmzur
1
|1
[g|,||]
Client4 : g 0 | 1
Application de CTH sur le client 1
Clé insérée dans le serveur 0
Distributed Compact trie hashing
Illustration du mécanisme de distribution du fichier
ggwmrcewg
0
g0|1
[ ,g|]
Client1 : | 0 Client2 : g 0 | 1 Client3 : g0k1|2
lewhv
Ishwkm
1
k1|2
[g|,k|]
Client4 : g 0 | 1
lewhvzur
2
|2
[k|,||]
Application de TH sur le client 3
Collision
Modification de l'arbre du client 3
Modification de l'arbre dans le serveur éclaté
Distributed Compact trie hashing
Illustration du mécanisme de distribution du fichier
ggwmrcewg
0
g0|1
[ ,g|]
Client1 : | 0 Client2 : g0k1|2 Client3 : g0k1|2
nrg
Ishwkm
1
k1|2
[g|,k|]
Client4 : g 0 | 1
Lewhvzurnrg
2
|2
[k|,||]
Application de CTH sur le client 2 Remplacer dans l'arbre du client la case 1
par la partie manquante se trouvant dans le serveur1 Application de CTH sur le nouvel arbre du client 2
Clé insérée dans le serveur 2
Distributed Compact trie hashing
Illustration du mécanisme de distribution du fichier
lewhrIhgdlrz
pbtprPemgcm
rl
ggwmr
jis
kiyfgkm
mfnrq
vzzur
hhpgtphw
bgvgcczxayewg
0 1 2 3 4 5 6 7 8
|8|7|6|5|4r3|5l2n6|3h1j8k7|2
e0g4|1
[h|,j|][l|,n|] [j|,k|][ ,e|] [g|,h|] [k|,l|] [n|,r|] [e|,g|] [r|,||]
Client1 : e 0 g 4 k 1 l 2 | 6
Client2 : e 0 g 4 k 1 n 2 r 3 | 5
Client3 : g 0 j 1 k 7 n 2 r 3 | 5
Client4: g 0 h 1 k 8 n 2 | 3
Distributed Compact trie hashing
Algorithme de Transformation (client x) ---> i
I := CTH(Client)[X] ; Si I = Nil
Envoi d’un message à tous les serveurs : “Où suis-je?”Si un tel serveur existe ( soit m ) substituer m à Nil dans l’arbre du
client. Poser I := mSinon
Precedent_serveur := -1 Impasse, Stop := Faux; Aller au serveur I
Tq X Non dans int( I ) Et Non Impasse Et not Stop Si ( Arbre( I ) Vide) Ou ( I = Precedent_serveur)
Impasse := Vrai Envoi d'un message parallèle à tous les serveur --> I
Distributed Compact trie hashing
Algorithme de Transformation (client x) ---> i
Suite de l’algorithme :Sinon
Déterminer la partie de l'arbre dans le serveur à copier dans le client, et la recopier
Precedent_serveur := I I := CTH(Client)[ X ] Si I <> Nil Aller au serveur I
SinonEnvoi d’un message à tous les serveurs : “Où
suis-je?”Si un tel serveur existe ( soit m ) substituer m à
Nil dans l’arbre du client.. Poser I := mFsi
Fsi FtqFsi
Distributed Compact trie hashing
Algorithme de Transformation (client x) ---> i
Résultat de l'algorithme de transformation :
soit I vaut Nil
soit Impasse= Faux, auquel cas I est l'adresse du serveur
soit Impasse= Vrai et I <> Nil, auquel cas il y a eu remplacement dans le client et Ind_m, Ind_d, I, sont les paramètres dans le nouveau arbre.
Distributed Compact trie hashing
Recherche/InsertionMin est la clé maximale de la case précédente. Impasse est vrai si l'algorithme de transformation détecte une impasse.
Appliquer le module de transformation m, Min, Impasse
Si m = Nil
Créer un nouveau serveur ( M )
Remplacer Nil par M dans l'arbre du client
Initialiser la case avec la clé
Int( M ) [ Min, clé maximale associée à Nil]
Arbre( M ] |M
Sinon
Distributed Compact trie hashing
Recherche/Insertion
Suite de l’algorithme :
Si Clé existe dans le serveur m : Arrêt
Si Cle n'existe pas et place suffisante : insérer Clé et Arrêt
Si Cle n'existe pas et pas de place : collision
Si Impasse
Éclater l'arbre du serveur
Sinon
Éclater l'arbre du client
Éclater l'arbre du serveur
Fsi
Distributed Compact trie hashing
Recherche/Insertion
Processus d'éclatement :
Former la séquence et déterminer la séquence de division Seq
Éclater Case(i) en 2 selon Seq
l'ancien serveur I contient les clés <= Seq
le nouveau serveur, soit J, contient le reste
Int( I ) >Inf(int( I )) , <=Seq
Int( J ) >Seq , <=Sup(int( J ))
Modifier l'arbre par l'ajout des nœuds
Distributed Compact trie hashing
Recherche/Insertion
Expansion du serveur :
En entrée
Cle, Seq, K, C', M ( envoyé par le client)
Re appliquer CTH sur l'arbre du serveur clé maximale Cm
A partir de Cm et Seq on détermine le nombre I de digits qui existent déjà dans l'arbre du serveur.
Étendre l'arbre du serveur en utilisant les autres paramètres
( C', K et M).
Distributed Compact trie hashing
Répartition des tachesIl s'agit de déterminer ce qui doit être fait par le client et par le serveur et quelles sont les informations échangées.
Au niveau d'un client Algorithme de transformation (Client clé) --> serveur
Algorithme CTH .Expansion de l'arbre du client
Au niveau du serveurAlgorithme CTHExpansion de l'arbre du serveurÉclatement du serveur . Partage des clés avec un nouveau serveur . Recherche à l'intérieure d'une case . Insertion à l'intérieure d'une case . Formation de la séquence
Distributed Compact trie hashing
Performances Une recherche sur n est lente.
Une recherche tends vers un accès (message).
Courbes : - Nombre de messages en fonction d'insertion.
SimulationOn prend n clients.Répéter générer un client aléatoire parmi n insérer m clés aléatoires Examiner le nombre de messages moyen pour une recherche pour une insertion