Spark cache vs diffusion
Il semble que la méthode de diffusion crée une copie distribuée de RDD dans mon cluster. D'un autre côté, l'exécution de la méthode cache () charge simplement les données en mémoire.
Mais je ne comprends pas comment le RDD mis en cache est distribué dans le cluster.
Pourriez-vous s'il vous plaît me dire dans quels cas dois-je utiliser les méthodes rdd.cache() et rdd.broadcast()?
Pourriez-vous me dire dans quels cas dois-je utiliser les méthodes rdd.cache () et rdd.broadcast ()?
Les RDD sont divisés en partitions. Ces partitions elles-mêmes agissent comme un sous-ensemble immuable de l'ensemble du RDD. Lorsque Spark exécute chaque étape du graphique, chaque partition est envoyée à un travailleur qui opère sur le sous-ensemble des données. À son tour, chaque travailleur peut cache les données si le RDD doit être réitéré.
Les variables de diffusion sont utilisées pour envoyer un état immuable ne fois à chaque travailleur. Vous les utilisez lorsque vous souhaitez une copie locale d'une variable.
Ces deux opérations sont assez différentes l'une de l'autre et chacune représente une solution à un problème différent.
cache () ou persiste () permet à un ensemble de données d'être utilisé à travers les opérations.
Lorsque vous persistez un RDD, chaque nœud en stocke toutes les partitions qu'il calcule en mémoire et les réutilise dans d'autres actions de cet ensemble de données (ou ensembles de données dérivés de il). Cela permet aux actions futures d'être beaucoup plus rapides (souvent de plus de 10 fois). La mise en cache est un outil clé pour les algorithmes itératifs et une utilisation interactive rapide.
Chaque RDD persistant peut être stocké à l'aide d'un niveau de stockage différent, ce qui vous permet, par exemple, de conserver le jeu de données sur le disque, de le conserver dans memory mais tel que sérialisé Java = objets (pour économiser de l'espace), répliquez-le sur les nœuds, ou stockez-le hors tas
variables de diffusion permet au programmeur de garder une variable en lecture seule en cache sur chaque machine plutôt que d'en expédier une copie avec des tâches. Ils peuvent être utilisés, par exemple, pour donner à chaque nœud une copie d'un grand ensemble de données d'entrée de manière efficace. Spark tente également de distribuer des variables de diffusion en utilisant des algorithmes de diffusion efficaces pour réduire les coûts de communication.
Vous pouvez trouver plus de détails sur cette page documentation .
Messages utiles:
Pourriez-vous me dire dans quels cas dois-je utiliser les méthodes rdd.cache () et rdd.broadcast ()?
Prenons un exemple - supposons que vous ayez une donnée de salaire d'employé contenant le service et le salaire de chaque employé. Supposons maintenant que la tâche consiste à trouver la fraction du salaire départemental moyen pour chaque employé. (Si pour l'employé e1 son département est d1, nous devons trouver e1.salaire/moyenne (tous les salaires en d1)).
Maintenant, une façon de le faire est - vous lisez d'abord les données dans un rdd - disons rdd1. Et puis faites deux choses l'une après l'autre * -
Tout d'abord, calculez la moyenne salariale par département en utilisant le rdd1 *. Vous obtiendrez finalement le résultat des salaires moyens du département - essentiellement un objet de carte contenant deptId vs average - sur le pilote.
Deuxièmement, vous devrez utiliser ce résultat pour diviser le salaire de chaque employé par le salaire moyen de son service respectif. N'oubliez pas que sur chaque travailleur, il peut y avoir des employés de n'importe quel département, vous devrez donc avoir accès au résultat salarial moyen du département pour chaque travailleur. Comment faire ça? Eh bien, vous pouvez simplement envoyer la carte de salaire moyen que vous avez obtenue sur le conducteur à chaque travailleur dans une diffusion et elle peut ensuite être utilisée pour calculer les fractions de salaire pour chaque "ligne" dans le rdd1.
Qu'en est-il de la mise en cache d'un RDD? Rappelez-vous que depuis le rdd1 initial, il y a deux branches de calcul - une pour calculer la moyenne du département et une autre pour appliquer ces moyennes à chaque employé du rdd. Maintenant, si vous ne mettez pas en cache le rdd1, alors pour la deuxième tâche ci-dessus, vous devrez peut-être revenir sur le disque pour le lire et le recalculer car spark peut avoir supprimé ce rdd de la mémoire par le fois que vous atteignez ce point. Mais comme nous savons que nous utiliserons le même rdd, nous pouvons demander à Spark de le garder en mémoire la première fois. Ensuite, la prochaine fois, nous aurons besoin d'appliquer des transformations dessus, nous l'avons déjà en mémoire.
* Nous pouvons utiliser le partitionnement basé sur les départements afin que vous puissiez éviter la diffusion mais à des fins d'illustration, disons que nous ne le faisons pas.
Cas d'utilisation
Vous mettez en cache ou diffusez un objet lorsque vous souhaitez l'utiliser plusieurs fois.
Vous ne pouvez mettre en cache qu'un RDD ou un dérivé de RDD, tandis que vous pouvez diffuser tout type d'objet, y compris les RDD.
Nous utilisons cache () lorsque nous avons affaire à un RDD/DataFrame/DataSet et nous voulons utiliser le jeu de données plusieurs fois sans le recalculer à chaque fois.
Nous diffusion un objet lorsque
- nous avons affaire à un RDD/DataFrame/DataSet qui est relativement petit, et sa diffusion offre des avantages en termes de performances par rapport à la mise en cache (par exemple, si nous utilisons l'ensemble de données dans une jointure)
- nous avons affaire à un vieil objet Scala/Java et il sera utilisé à plusieurs étapes d'un travail.