In termini di RDDpersistenza, quali sono le differenze tra cache()e persist()in spark?

Con cache(), si utilizza solo il livello di archiviazione predefinito:

• MEMORY_ONLYper RDD
• MEMORY_AND_DISKper set di dati

Con persist(), è possibile specificare il livello di archiviazione desiderato per RDD e Dataset .

Dai documenti ufficiali:

• Puoi contrassegnare RDDcome persistente usando i metodi persist() o cache() su di esso.
• ogni persistente RDDpuò essere memorizzato usando un diversostorage level
• Il cachemetodo () è una scorciatoia per utilizzare il livello di archiviazione predefinito, ovvero StorageLevel.MEMORY_ONLY(memorizzare oggetti deserializzati in memoria).

Utilizzare persist()se si desidera assegnare un livello di archiviazione diverso da:

• MEMORY_ONLYal RDD
• o MEMORY_AND_DISKper set di dati

Link interessante per la documentazione ufficiale: quale livello di archiviazione scegliere

La differenza tra cachee le persistoperazioni è puramente sintattica. cache è sinonimo di persist o persist ( MEMORY_ONLY), ovvero cacheè semplicemente persistcon il livello di archiviazione predefinitoMEMORY_ONLY

/ ** * Persiste questo RDD con il livello di archiviazione predefinito ( MEMORY_ONLY). * /
def persist (): this.type = persist (StorageLevel.MEMORY_ONLY)

/ ** * Persiste questo RDD con il livello di archiviazione predefinito ( MEMORY_ONLY). * /
def cache (): this.type = persist ()

vedi maggiori dettagli qui ...

La memorizzazione nella cache o la persistenza sono tecniche di ottimizzazione per i calcoli Spark (iterativi e interattivi). Aiutano a salvare risultati parziali intermedi in modo che possano essere riutilizzati nelle fasi successive. Questi risultati intermedi man mano RDDche vengono conservati vengono quindi conservati in memoria (impostazione predefinita) o in memoria più solida come disco e / o replicata. RDDs può essere memorizzato nella cache utilizzando l' cacheoperazione. Possono anche essere persistenti usando l' persistoperazione.

persist, cache

Queste funzioni possono essere utilizzate per regolare il livello di archiviazione di a RDD. Quando si libera la memoria, Spark utilizzerà l'identificatore del livello di archiviazione per decidere quali partizioni devono essere mantenute. Il parametro meno varianti persist() e cache() sono solo abbreviazioni per persist(StorageLevel.MEMORY_ONLY).

Avvertenza : una volta modificato il livello di archiviazione, non è più possibile modificarlo!

Avviso -Cache con giudizio ... vedi ( (Perché) dobbiamo chiamare la cache o persistere su un RDD )

Solo perché puoi memorizzare RDDnella cache un in memoria non significa che dovresti farlo alla cieca. A seconda di quante volte si accede al set di dati e alla quantità di lavoro necessaria per farlo, il calcolo può essere più veloce del prezzo pagato dall'aumento della pressione della memoria.

Va da sé che se leggi un set di dati solo una volta che non ha senso memorizzarlo nella cache, il tuo lavoro sarà più lento. Le dimensioni dei set di dati memorizzati nella cache sono visibili da Spark Shell.

Elenco varianti ...

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

* Vedi l'esempio seguente: *

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)

Nota: a causa della differenza molto piccola e puramente sintattica tra la memorizzazione nella cache e la persistenza di RDDs, i due termini sono spesso usati in modo intercambiabile.

Vedi di più visivamente qui ....

Persistere in memoria e disco:

nascondiglio

La memorizzazione nella cache può migliorare notevolmente le prestazioni dell'applicazione.

Non c'è differenza. Da 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 fornisce 5 tipi di livello di archiviazione

• MEMORY_ONLY
• MEMORY_ONLY_SER
• MEMORY_AND_DISK
• MEMORY_AND_DISK_SER
• DISK_ONLY

cache()utilizzerà MEMORY_ONLY. Se vuoi usare qualcos'altro, usa persist(StorageLevel.<*type*>).

Per impostazione predefinita persist(), i dati verranno archiviati nell'heap JVM come oggetti non serializzati.

Cache () e persist () entrambi i metodi vengono utilizzati per migliorare le prestazioni del calcolo delle scintille. Questi metodi aiutano a salvare i risultati intermedi in modo che possano essere riutilizzati nelle fasi successive.

L'unica differenza tra cache () e persist () è che, usando la tecnica Cache, possiamo salvare i risultati intermedi in memoria solo quando necessario, mentre in Persist () possiamo salvare i risultati intermedi in 5 livelli di archiviazione (MEMORY_ONLY, MEMORY_AND_DISK, MEMORY_ONLY_SER, MEMORY_AND_DISK_SER, DISK_ONLY).