En termes de RDDpersistance, quelles sont les différences entre cache()et persist()en étincelle?

Avec cache(), vous utilisez uniquement le niveau de stockage par défaut:

• MEMORY_ONLYpour RDD
• MEMORY_AND_DISKpour Dataset

Avec persist(), vous pouvez spécifier le niveau de stockage que vous souhaitez pour RDD et Dataset .

De la documentation officielle:

• Vous pouvez marquer un RDDcomme persistant à l'aide des méthodes persist() ou cache().
• chaque persistant RDDpeut être stocké en utilisant un autrestorage level
• La cacheméthode () est un raccourci pour utiliser le niveau de stockage par défaut, qui est StorageLevel.MEMORY_ONLY(stocker les objets désérialisés en mémoire).

À utiliser persist()si vous souhaitez attribuer un niveau de stockage autre que:

• MEMORY_ONLYau RDD
• ou MEMORY_AND_DISKpour Dataset

Lien intéressant pour la documentation officielle: quel niveau de stockage choisir

La différence entre les opérations cacheet persistest purement syntaxique. cache est un synonyme de persist ou persist ( MEMORY_ONLY), c'est cache-à- dire qu'il est simplement persistavec le niveau de stockage par défautMEMORY_ONLY

/ ** * Conservez ce RDD avec le niveau de stockage par défaut ( MEMORY_ONLY). * /
def persist (): this.type = persist (StorageLevel.MEMORY_ONLY)

/ ** * Conservez ce RDD avec le niveau de stockage par défaut ( MEMORY_ONLY). * /
def cache (): this.type = persist ()

voir plus de détails ici ...

La mise en cache ou la persistance sont des techniques d'optimisation pour les calculs (itératifs et interactifs) de Spark. Ils aident à sauvegarder les résultats partiels intermédiaires afin qu'ils puissent être réutilisés dans les étapes suivantes. Ces résultats intermédiaires comme RDDs sont ainsi conservés en mémoire (par défaut) ou en stockage plus solide comme le disque et / ou répliqués. RDDles s peuvent être mis en cache à l'aide de l' cacheopération. Ils peuvent également être persistés en utilisant l' persistopération.

persist, cache

Ces fonctions peuvent être utilisées pour ajuster le niveau de stockage d'un RDD. Lors de la libération de mémoire, Spark utilisera l'identificateur de niveau de stockage pour décider quelles partitions doivent être conservées. Les variantes sans paramètre persist() et cache() ne sont que des abréviations pour persist(StorageLevel.MEMORY_ONLY).

Attention : Une fois le niveau de stockage modifié, il ne peut plus être modifié!

Avertissement -Cachez judicieusement ... voir ( (Pourquoi) devons-nous appeler le cache ou persister sur un RDD )

Ce RDDn'est pas parce que vous pouvez mettre en cache un en mémoire que vous devez le faire aveuglément. Selon le nombre d'accès au jeu de données et la quantité de travail nécessaire, le recalcul peut être plus rapide que le prix payé par l'augmentation de la pression de la mémoire.

Il va sans dire que si vous ne lisez un ensemble de données qu'une fois qu'il est inutile de le mettre en cache, cela rendra votre travail plus lent. La taille des jeux de données mis en cache peut être vue depuis le Spark Shell.

Liste des variantes ...

def cache(): RDD[T]
 def persist(): RDD[T]
 def persist(newLevel: StorageLevel): RDD[T]

* Voir l'exemple ci-dessous: *

val c = sc.parallelize(List("Gnu", "Cat", "Rat", "Dog", "Gnu", "Rat"), 2)
     c.getStorageLevel
     res0: org.apache.spark.storage.StorageLevel = StorageLevel(false, false, false, false, 1)
     c.cache
     c.getStorageLevel
     res2: org.apache.spark.storage.StorageLevel = StorageLevel(false, true, false, true, 1)

Remarque: En raison de la très petite différence purement syntaxique entre la mise en cache et la persistance de RDDs, les deux termes sont souvent utilisés de manière interchangeable.

Voir plus visuellement ici ....

Persister dans la mémoire et le disque:

Cache

La mise en cache peut améliorer considérablement les performances de votre application.

Il n'y a pas de différence. De RDD.scala.

/** Persist this RDD with the default storage level (`MEMORY_ONLY`). */
def persist(): this.type = persist(StorageLevel.MEMORY_ONLY)

/** Persist this RDD with the default storage level (`MEMORY_ONLY`). */
def cache(): this.type = persist()

Spark propose 5 types de niveaux de stockage

• MEMORY_ONLY
• MEMORY_ONLY_SER
• MEMORY_AND_DISK
• MEMORY_AND_DISK_SER
• DISK_ONLY

cache()va utiliser MEMORY_ONLY. Si vous voulez utiliser autre chose, utilisez persist(StorageLevel.<*type*>).

Par défaut persist(), les données seront stockées dans le tas JVM en tant qu'objets non sérialisés.

Cache () et persist (), les deux méthodes sont utilisées pour améliorer les performances du calcul d'étincelle. Ces méthodes aident à enregistrer les résultats intermédiaires afin qu'ils puissent être réutilisés dans les étapes suivantes.

La seule différence entre cache () et persist () est qu'en utilisant la technique Cache, nous pouvons enregistrer les résultats intermédiaires en mémoire uniquement lorsque cela est nécessaire tandis que dans Persist () nous pouvons enregistrer les résultats intermédiaires dans 5 niveaux de stockage (MEMORY_ONLY, MEMORY_AND_DISK, MEMORY_ONLY_SER, MEMORY_AND_DISK_SER, DISK_ONLY).