web-dev-qa-db-fra.com

Writable et WritableComparable dans Hadoop?

Quelqu'un pourrait-il m'expliquer:

Qu'est-ce que l'interface Writable et Writable Comparable dans Hadoop?

Quelle est la différence entre ces deux?

Veuillez expliquer avec un exemple.

Merci d'avance,

hadoopmapreduce
17
vipin chourasia

Inscriptible dans une interface dans Hadoop et les types dans Hadoop doivent implémenter cette interface. Hadoop fournit ces wrappers inscriptibles pour presque tous les types primitifs Java et certains autres types, mais parfois nous devons transmettre des objets personnalisés et ces objets personnalisés doivent implémenter l'interface accessible en écriture de Hadoop. Hadoop MapReduce utilise des implémentations de Writables pour interagir avec les mappeurs et les réducteurs fournis par l'utilisateur.

Pour implémenter l'interface accessible en écriture, nous avons besoin de deux méthodes:

public interface Writable {
void readFields(DataInput in);
void write(DataOutput out);
}

Pourquoi utiliser les écritures Hadoop?

Comme nous le savons déjà, les données doivent être transmises entre différents nœuds dans un environnement informatique distribué. Cela nécessite la sérialisation et la désérialisation des données pour convertir les données au format structuré en flux d'octets et vice-versa. Hadoop utilise donc un protocole de sérialisation simple et efficace pour sérialiser les données entre la carte et réduire la phase et celles-ci sont appelées écriture (s). Certains des exemples d'écritures déjà mentionnés précédemment sont IntWritable, LongWritable, BooleanWritable et FloatWritable.

Voir: https://developer.yahoo.com/hadoop/tutorial/module5.html par exemple

L'interface WritableComparable n'est qu'une sous-interface des interfaces Writable et Java.lang.Comparable. Pour implémenter un WritableComparable, nous devons avoir la méthode compareTo en dehors des méthodes readFields et write, comme indiqué ci-dessous:

public interface WritableComparable extends Writable, Comparable
{
    void readFields(DataInput in);
    void write(DataOutput out);
    int compareTo(WritableComparable o)
}

La comparaison des types est cruciale pour MapReduce, où il y a une phase de tri pendant laquelle les clés sont comparées les unes aux autres.

L'implémentation d'un comparateur pour WritableComparables comme l'interface org.Apache.hadoop.io.RawComparator contribuera certainement à accélérer vos travaux de cartographie/réduction (MR). Comme vous vous en souvenez peut-être, un travail MR est composé de la réception et de l'envoi de paires clé-valeur. Le processus ressemble à ceci.

(K1,V1) –> Map –> (K2,V2)
(K2,List[V2]) –> Reduce –> (K3,V3)

Les paires clé-valeur (K2, V2) sont appelées les paires clé-valeur intermédiaires. Ils sont passés du mappeur au réducteur. Avant que ces paires de valeurs-clés intermédiaires n'atteignent le réducteur, une étape de mélange et de tri est effectuée.

Le shuffle est l'affectation des clés intermédiaires (K2) aux réducteurs et le tri est le tri de ces clés. Dans ce blog, en implémentant le RawComparator pour comparer les clés intermédiaires, cet effort supplémentaire améliorera considérablement le tri. Le tri est amélioré car le RawComparator comparera les clés par octet. Si nous n'utilisions pas RawComparator, les clés intermédiaires devraient être complètement désérialisées pour effectuer une comparaison.

Remarque (en bref):

1) WritableComparables peut être comparé les uns aux autres, généralement via des comparateurs. Tout type qui doit être utilisé comme clé dans le framework Hadoop Map-Reduce doit implémenter cette interface.

2) Tout type qui doit être utilisé comme valeur dans le cadre Hadoop Map-Reduce doit implémenter l'interface accessible en écriture.

23
Kuntal-G

En bref, le type utilisé comme clé dans Hadoop doit être un WritableComparable, tandis que le type utilisé uniquement comme la valeur pourrait être juste un Writable.

http://hadoop.Apache.org/docs/current/api/org/Apache/hadoop/io/WritableComparable.html

@InterfaceAudience.Public
@InterfaceStability.Stable
public interface WritableComparable<T>
extends Writable, Comparable<T>

Un Writable qui est également comparable.

WritableComparables peut être comparé les uns aux autres, généralement via des comparateurs. Tout type qui doit être utilisé comme clé dans le framework Hadoop Map-Reduce doit implémenter cette interface.

http://hadoop.Apache.org/docs/current/api/org/Apache/hadoop/io/Writable.html

@InterfaceAudience.Public
@InterfaceStability.Stable
public interface Writable

Un objet sérialisable qui implémente un protocole de sérialisation simple et efficace, basé sur DataInput et DataOutput.

Tout type de clé ou de valeur dans le framework Hadoop Map-Reduce implémente cette interface.

4
songyuanyao

Writable est une interface dont vous avez besoin pour implémenter une classe de définition personnalisée utilisée dans hadoop map-Reduce. Deux fonctions doivent être implémentées/remplacées:

         write() and readFields();

Cependant, WritableComparable est une autre sous-interface de Writable et Comparable, trois fonctions doivent être implémentées/remplacées:

         write() and readFields()     |    compareTo()

Comme nous devons implémenter compareTo (),

donc la classe implémente WritableComparable, peut être utilisée à la fois comme clé ou valeur dans hadoop map-Reduce .

Cependant, la classe implémente Writable, ne peut être utilisée que comme valeur dans hadoop map-Reduce.

Vous pouvez trouver un exemple de ces deux interfaces sur le site officiel: https://hadoop.Apache.org/docs/current/api/org/Apache/hadoop/io/WritableComparable.html

https://hadoop.Apache.org/docs/current/api/org/Apache/hadoop/io/Writable.html

0
Zhihui Shao