Risposte:
Con cache()
, si utilizza solo il livello di archiviazione predefinito:
MEMORY_ONLY
per RDDMEMORY_AND_DISK
per set di datiCon persist()
, è possibile specificare il livello di archiviazione desiderato per RDD e Dataset .
Dai documenti ufficiali:
- Puoi contrassegnare
RDD
come persistente usando i metodipersist
() ocache
() su di esso.- ogni persistente
RDD
può essere memorizzato usando un diversostorage level
- Il
cache
metodo () è una scorciatoia per utilizzare il livello di archiviazione predefinito, ovveroStorageLevel.MEMORY_ONLY
(memorizzare oggetti deserializzati in memoria).
Utilizzare persist()
se si desidera assegnare un livello di archiviazione diverso da:
MEMORY_ONLY
al RDDMEMORY_AND_DISK
per set di datiLink interessante per la documentazione ufficiale: quale livello di archiviazione scegliere
MEMORY_AND_DISK
è il valore predefinito solo per i set di dati. MEMORY_ONLY
è ancora il valore predefinito per RDD
La differenza tra
cache
e lepersist
operazioni è puramente sintattica. cache è sinonimo di persist o persist (MEMORY_ONLY
), ovverocache
è semplicementepersist
con 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 RDD
che vengono conservati vengono quindi conservati in memoria (impostazione predefinita) o in memoria più solida come disco e / o replicata.
RDD
s può essere memorizzato nella cache utilizzando l' cache
operazione. Possono anche essere persistenti usando l' persist
operazione.
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 variantipersist
() ecache
() sono solo abbreviazioni perpersist(StorageLevel.MEMORY_ONLY).
Avvertenza : una volta modificato il livello di archiviazione, non è più possibile modificarlo!
Solo perché puoi memorizzare RDD
nella 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 RDD
s, i due termini sono spesso usati in modo intercambiabile.
Vedi di più visivamente qui ....
Persistere in memoria e disco:
La memorizzazione nella cache può migliorare notevolmente le prestazioni dell'applicazione.
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).
cache()
ora utilizza MEMORY_AND_DISK