Voir la source de Hachage cohérent

{{sources|date=octobre 2015}}

Le '''hachage cohérent''' est un type particulier de [[hachage]]. Lorsque la [[table de hachage]] change de taille et que le hachage cohérent est employé, seulement <math>K/n</math> clés ont besoin d’être redistribuées en moyenne, où <math>K</math> est le nombre de [[clé (structure de données)|clés]] et <math>n</math> est le nombre d'éléments dans la table de hachage. En comparaison, dans une table de hachage classique, un changement dans le nombre d'éléments de la table a pour conséquence la réorganisation de l'ensemble ou presque des clés.

== Historique ==

À l'origine conçue par Karger et coll. au ''[[Massachusetts Institute of Technology]]'', afin d’être utilisée dans un système de [[mémoire cache|cache]] distribué, cette notion est apparue dans d'autres domaines. Une publication dans un article de 1997 introduit le terme hachage cohérent comme un moyen de répartir les requêtes sur un ensemble de [[serveurs web]] en constante évolution. Chaque emplacement est représenté par un nœud d'un système réparti. L'ajout (arrivée), ou la suppression (départ/défaut) d'un des nœuds ne requiert la répartition que de <math>K/n</math> objets lorsque le ratio emplacements/nœuds change<ref name="KargerEtAl1997">{{lien conférence|url=http://portal.acm.org/citation.cfm?id=258660
 |doi=10.1145/258533.258660
 |auteur=Karger, D.; Lehman, E.; [[F. Thomson Leighton|Leighton, T.]]; Panigrahy, R.; Levine, M.; [[Daniel M. Lewin|Lewin, D.]]
 |conférence=Proceedings of the Twenty-ninth Annual ACM [[Symposium on Theory of Computing]]
 |pages=654–663
 |périodique=ACM Press New York, NY, USA
 |titre=Consistent Hashing and Random Trees: Distributed Caching Protocols for Relieving Hot Spots on the World Wide Web|date=1997}}</ref>.

Le hachage cohérent a aussi été utilisé pour réduire l'impact de défaillances partielles d'un système dans de grandes [[applications Web]], permettant la mise au point d'un système de cache robuste sans engendrer d'indisponibilité générale dans le cas d'une défaillance isolée.  

Le concept de hachage cohérent peut être appliqué à la conception des [[tables de hachage distribuées]] (DHTs). Les DHTs utilisent le hachage cohérent pour fragmenter un espace de clés sur un ensemble de nœuds, et fournissent également une surcouche réseau qui connecte des nœuds tel que chaque nœud responsable d'une clé peut être localisé de manière efficace.

Le {{lien|trad=Rendezvous hashing|fr=hachage Rendezvous}}, conçu dans la même période que le hachage cohérent, poursuit le même but en utilisant un [[algorithme]] très différent appelé ''Highest Random Weight'' (''HWR'').

== Besoin sous-jacent ==

Lorsque l'on fait fonctionner des ensembles de machines de cache, certaines limitations apparaissent. Une méthode courante pour équilibrer la charge sur <math>n</math> machines de cache est de mettre l'objet <math>o</math> dans la machine numéro <math>\mbox{hash}(o) \mod n</math>. Cela ne fonctionnera pas si une machine de cache est ajoutée ou enlevée, car la valeur de <math>n</math> change et tous ses objets vont être hachés vers un nouvel emplacement. Cela peut être désastreux en matière de performances, car les machines fournissant le contenu sont bombardées de requêtes provenant des machines de cache. Le besoin d'un hachage cohérent se fait donc ressentir (afin d’éviter d'inonder de requêtes les [[serveur informatique|serveurs]]).

Le hachage cohérent place les objets sur la même machine de cache autant que possible. Lorsqu'une machine de cache est ajoutée, elle récupère la part d'objets lui revenant des autres machines de cache et, lorsqu'elle est enlevée, ses objets sont répartis entre les machines restantes.

L’idée derrière l'algorithme de hachage cohérent est d'associer chaque machine de cache à un ou plusieurs intervalles où les frontières des intervalles sont déterminées en calculant le hache de chaque identifiant de cache. La fonction de hachage utilisée pour définir les intervalles n'a pas besoin d’être la même que la fonction utilisée pour hacher les valeurs mises en cache, seul le degré (espace) des deux fonctions doit être identique. Si le cache est supprimé, son intervalle est repris par un cache adjacent. Tous les autres caches restent inchangés.

== Technique == 

Le hachage cohérent est basé sur le principe suivant : on projette chaque objet sur un point d'un cercle (on peut aussi le faire en utilisant les angles à la place des points). On projette également chaque machine disponible (ou ensemble de stockage) sur plusieurs points répartis de manière aléatoire sur ce même cercle.

Pour trouver où un objet se trouve, le système doit trouver l'emplacement de la clé de cet objet sur le cercle, puis naviguer sur le cercle (dans le sens des aiguilles d'une montre) jusqu’à ce qu'il rencontre une machine (ou ensemble de stockage), ou la première machine disponible ayant un angle supérieur. Le résultat est que chaque seau (cache ou sous-ensemble de cache) contient toutes les ressources localisées entre son emplacement et le seau derrière lui.

Si un seau devient indisponible (par exemple parce que la machine sur lequel il réside ne répond plus), alors les angles sur lequel il se trouve sont effacés. Les requêtes des ressources qui auraient en temps normal abouti à ce point sont redirigées vers le point supérieur le plus proche. Comme chaque seau est associé à un nombre aléatoirement réparti de points, les ressources contenues dans ce seau vont maintenant être ré-affectées à d'autres seaux. Les objets contenus dans le seau perdu doivent être redistribués vers les seaux restants, mais les valeurs des autres seaux persistent et n'ont pas besoin d’être changées de place.

Un processus similaire se déroule lors de l'ajout d'un seau. En ajoutant un point correspondant à un nouveau seau, on déplace toutes ressources entre ce seau et celui d'un angle plus petit et adjacent vers le nouveau seau. Ces ressources ne sont à présent plus associées au précédent seau, et chaque valeur précédemment stockée ne sera plus trouvée à cet endroit en utilisant la méthode de sélection.

La portion de clés associée à chaque seau peut être modifiée en altérant l'angle de ce seau.

== Clés [[fonction monotone|monotones]] ==

S'il est connu que les valeurs de clés vont toujours croître de manière [[fonction monotone|monotone]], alors une approche alternative au hachage cohérent est possible.

== Propriétés ==

David Karger et al. listent plusieurs propriétés du hachage cohérent qui le rend très utile dans les systèmes distribués de cache sur Internet<ref name="KargerEtAl1997"/> :
* étalement ;
* charge ;
* douceur ;
* équilibre ;
* monotonie.

== Exemples d'utilisation ==

Certains systèmes connus utilisent le hachage cohérent :
* ''[[OpenStack]]'s Object Storage Service Swift''<ref>{{lien web |titre=Welcome to Swift’s documentation!<!-- Vérifiez ce titre --> |url=http://docs.openstack.org/developer/swift/ring.html |site=openstack.org |consulté le=27-04-2023}}.</ref> ;
* ''Partitioning component of Amazon's storage system Dynamo''<ref name="Amazon2007">{{article
 | auteur = DeCandia, G.; Hastorun, D.; Jampani, M.; Kakulapati, G.; Lakshman, A.; Pilchin, A.; Sivasubramanian, S.; Vosshall, P.; Vogels, W.
 | journal = Proceedings of the 21st ACM Symposium on Operating Systems Principles
 | année = 2007
 | titre =Dynamo: Amazon's Highly Available Key-Value Store
}}</ref>{{,}}<ref name="Dynamo: Amazon’s Highly Available Key-value Store">http://www.allthingsdistributed.com/files/amazon-dynamo-sosp2007.pdf</ref> ;
* ''Data partitioning in [[Apache Cassandra]]''<ref name="Lakshman2010b">{{article
 | auteur = Lakshman, Avinash; Malik, Prashant
 | journal = ACM SIGOPS Operating Systems Review
 | année = 2010
 | titre = Cassandra: a decentralized structured storage system
}}</ref> ;
* ''Data Partitioning in Voldemort''<ref>{{lien web|titre=Design -- Voldemort|url=http://www.project-voldemort.com/voldemort/design.html|site=project-voldemort.com|consulté le=9 février 2015|archiveurl=https://web.archive.org/web/20150209164650/http://www.project-voldemort.com/voldemort/design.html|archivedate=9 février 2015|extrait=Consistent hashing is a technique that avoids these problems, and we use it to compute the location of each key on the cluster.}}.</ref> ;
* ''Akka's consistent hashing router''<ref name="akka-routing">[http://doc.akka.io/docs/akka/snapshot/scala/routing.html Akka Routing]</ref> ;
* ''[[Riak]], a distributed key-value database''<ref name="riak-consistent-hashing">{{lien web|langue=en|url=http://docs.basho.com/riak/latest/theory/concepts/|titre=Riak Concepts|consulté le=13 décembre 2015|archive-url=https://web.archive.org/web/20151222093835/http://docs.basho.com/riak/latest/theory/concepts/|archive-date=22 décembre 2015|brisé le=23 juillet 2018}}.</ref> ;
* ''[[GlusterFS]], a network-attached storage file system''<ref name="GlusterFS Algorithms: Distribution">http://www.gluster.org/2012/03/glusterfs-algorithms-distribution/</ref> ;
* ''Skylable, an open-source distributed object-storage system''<ref name="skylable-architecture">{{lien web|url=http://wiki.skylable.com/wiki/Sxarchitecture#Data_distribution|titre=Skylable architecture}}.</ref>.

== Notes et références ==
{{Traduction/Référence|en|Consistent hashing|651527867|type=note}}
{{Références}}

== Voir aussi ==
=== Liens externes ===
* [http://www.tomkleinpeter.com/2008/03/17/programmers-toolbox-part-3-consistent-hashing/ Understanding Consistent hashing]
==== Implémentation dans divers langages ====
* [http://www.martinbroadhurst.com/Consistent-Hash-Ring.html C++]
* [http://code.google.com/p/consistent-hash/ C#]
* [https://github.com/basho/riak_core/blob/master/src/chash.erl Erlang]
* [https://github.com/stathat/consistent Go]
* [https://github.com/pda/flexihash  PHP]
* [http://amix.dk/blog/post/19367 Python]
* [https://github.com/afirel/consistent_hashr Ruby]
* [https://metacpan.org/pod/Set::ConsistentHash Perl]

{{Palette|Générateur de nombres pseudo-aléatoires|Fonctions de hachage cryptographiques}}

{{Portail|cryptologie|informatique théorique}}

[[Catégorie:Hachage]]