Em termos de RDDpersistência, quais são as diferenças entre cache()e persist()na centelha?

Com cache(), você usa apenas o nível de armazenamento padrão:

• MEMORY_ONLYpara RDD
• MEMORY_AND_DISKpara conjunto de dados

Com persist(), você pode especificar qual nível de armazenamento deseja para RDD e Dataset .

Dos documentos oficiais:

• Você pode marcar um RDDpara ser persistente usando os métodos persist() ou cache() nele.
• cada persistente RDDpode ser armazenado usando umstorage level
• O cachemétodo () é uma abreviação para usar o nível de armazenamento padrão, que é StorageLevel.MEMORY_ONLY(armazenar objetos desserializados na memória).

Use persist()se você deseja atribuir um nível de armazenamento diferente de:

• MEMORY_ONLYpara o RDD
• ou MEMORY_AND_DISKpara o conjunto de dados

Link interessante para a documentação oficial: qual nível de armazenamento escolher

A diferença entre cachee persistoperações é puramente sintática. cache é sinônimo de persistir ou persistirem ( MEMORY_ONLY), ou seja, cacheé apenas persistcom o nível de armazenamento padrãoMEMORY_ONLY

/ ** * Persista este RDD com o nível de armazenamento padrão ( MEMORY_ONLY). * /
def persist (): this.type = persist (StorageLevel.MEMORY_ONLY)

/ ** * Persista este RDD com o nível de armazenamento padrão ( MEMORY_ONLY). * /
def cache (): this.type = persist ()

veja mais detalhes aqui ...

Armazenamento em cache ou persistência são técnicas de otimização para cálculos Spark (iterativos e interativos). Eles ajudam a salvar resultados parciais intermediários para que possam ser reutilizados em estágios subsequentes. Esses resultados intermediários, como RDDs, são mantidos na memória (padrão) ou em armazenamento mais sólido, como disco e / ou replicados. RDDs podem ser armazenados em cache usando a cacheoperação Eles também podem ser persistidos usando a persistoperação.

persist, cache

Essas funções podem ser usadas para ajustar o nível de armazenamento de a RDD. Ao liberar memória, o Spark utilizará o identificador de nível de armazenamento para decidir quais partições devem ser mantidas. O parâmetro menos variantes persist() e cache() são apenas abreviações para persist(StorageLevel.MEMORY_ONLY).

Aviso : Depois que o nível de armazenamento é alterado, ele não pode ser alterado novamente!

Aviso -Cache criteriosamente ... consulte ( (Por que) precisamos chamar cache ou persistir em um RDD )

Só porque você pode armazenar RDDem cache uma memória não significa que você deve fazê-lo cegamente. Dependendo de quantas vezes o conjunto de dados é acessado e a quantidade de trabalho envolvida, a recomputação pode ser mais rápida que o preço pago pelo aumento da pressão da memória.

Não é preciso dizer que, se você ler um conjunto de dados apenas quando não houver motivo para armazená-lo em cache, ele realmente tornará seu trabalho mais lento. O tamanho dos conjuntos de dados em cache pode ser visto no Spark Shell.

Listando variantes ...

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

* Veja abaixo o exemplo: *

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: Devido à diferença muito pequena e puramente sintática entre armazenamento em cache e persistência de RDDs, os dois termos são frequentemente usados ​​de forma intercambiável.

Veja mais visualmente aqui ....

Persista na memória e no disco:

Cache

O armazenamento em cache pode melhorar o desempenho do seu aplicativo, em grande medida.

Não há diferença. 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()

O Spark fornece 5 tipos de nível de armazenamento

• MEMORY_ONLY
• MEMORY_ONLY_SER
• MEMORY_AND_DISK
• MEMORY_AND_DISK_SER
• DISK_ONLY

cache()vai usar MEMORY_ONLY. Se você quiser usar outra coisa, use persist(StorageLevel.<*type*>).

Por padrão persist(), os dados serão armazenados no heap da JVM como objetos não serializados.

Cache () e persist (), ambos os métodos são usados ​​para melhorar o desempenho da computação spark. Esses métodos ajudam a salvar resultados intermediários para que possam ser reutilizados em estágios subsequentes.

A única diferença entre cache () e persist () é que, usando a técnica Cache, podemos salvar resultados intermediários na memória apenas quando necessário, enquanto em Persist () podemos salvar os resultados intermediários em 5 níveis de armazenamento (MEMORY_ONLY, MEMORY_AND_DISK, MEMORY_ONLY_SER, MEMORY_AND_DISK_SER, DISK_ONLY).