Inzicht in persistentie in Apache Spark

Leestijd: 4 minuten

in deze blog zullen we proberen om het concept van persistentie in Apache Spark te begrijpen in een zeer leken term met scenario-gebaseerde voorbeelden.
opmerking: de scenario ‘ s zijn alleen bedoeld voor een eenvoudig begrip.

Vonkarchitectuur

opmerking: cachegeheugen kan worden gedeeld tussen uitvoerders.

wat betekent het met persisting / caching van een RDD?

Spark RDD persistence is een optimalisatietechniek die het resultaat van RDD-evaluatie in het cachegeheugen opslaat. Hiermee slaan we het tussenresultaat op zodat we het indien nodig verder kunnen gebruiken. Het vermindert de berekening overhead.

wanneer we een RDD aanhouden, slaat elk knooppunt de partities op die het berekent in het geheugen en hergebruikt ze in andere acties op die RDD (of RDD afgeleid van het). Hierdoor kunnen toekomstige acties veel sneller verlopen (vaak met meer dan 10x). Caching is een belangrijk hulpmiddel voor iteratieve algoritmen en snel interactief gebruik.

u kunt een RDD markeren om te worden voortgezet met behulp van de persist() of cache() methoden erop. De eerste keer dat het wordt berekend in een actie, zal het worden bewaard in het cachegeheugen op de knooppunten. Spark ‘ s cache is fout-tolerant-als een partitie van een RDD verloren gaat, zal het automatisch worden berekend met behulp van de transformaties die oorspronkelijk gemaakt.

stel dat ik deze transformatie heb–

RDD3 => RDD2 => RDD1 => Text FileRDD4 => RDD3RDD5 => RDD3

RDD3 wordt gemaakt van RDD2 en RDD2 wordt gemaakt van RDD1. Elke keer als we een transformatie doen op RDD3, dan moeten RDD2 en RDD1 opnieuw en opnieuw worden berekend.

RDD4.collect()RDD5.collect()

hier moet de volledige transformatieketen tweemaal worden berekend.

maar we kunnen deze RDD3 in het cachegeheugen van het Werkknooppunt houden, zodat elke keer dat we het gebruiken, RDD2 en RDD1 niet opnieuw hoeven te worden berekend.

RDD3.cache()RDD4.collect()//The first action which involves RDD3 will store it in cache memoryRDD5.collect()

om rdd5 te berekenen zal Spark RDD3 uit het cachegeheugen lezen en het resultaat genereren. Daarom zullen RDD2 en RDD1 niet worden berekend voor RDD5

opmerking: rdd.cache () is hetzelfde als rdd.persist ()

Persistentieniveaus

opslaglocatie

– MEMORY_ONLY (standaard) – hetzelfde als cache
rdd.persist(StorageLevel.GEHEUGEN_ONLY) of rdd.persist ()

– MEMORY_AND_DISK – slaat partities op schijf op die niet in het geheugen passen (dit wordt ook morsen genoemd)
rdd.persist(StorageLevel.MEMORY_AND_DISK)

– DISK_ONLY-slaat alle partities op op de schijf
rdd.persist(StorageLevel.DISK_ONLY)

– MEMORY_ONLY (standaard) – Dit is de eenvoudigste en meest aanbevolen om te gebruiken. Het slaat alle partities van RDD in het cachegeheugen op.

– DISK_ONLY-stel dat ik een RDD heb (genaamd RDD1) en de berekening van die RDD is erg ingewikkeld (tijdrovend, gemaakt na het toepassen van een ML algoritme) en de RDD is enorm groot en het beschikbare cachegeheugen in het Werkknooppunt is minder, dus we kunnen de RDD niet opslaan in het cachegeheugen. In dit geval kunnen we de RDD op schijf opslaan.

u vraagt zich misschien af wat het nut is van het opslaan op schijf?

als we de RDD op schijf opslaan, zal I/O optreden, wat tijdrovend is. Maar we moeten ervoor zorgen dat of de I/O lang duurt of de herberekening van de RDD langer duurt. Als we nu kunnen ontdekken dat I/O minder tijd in beslag neemt dan de herberekening van de RDD, dan is het in dat geval beter om de RDD op de schijf op te slaan.

dus, wanneer RDD1 de volgende keer nodig is in de volgende transformatie, dan zal Spark een I/O-bewerking uitvoeren en deze naar het geheugen van de uitvoerder brengen.

RDD1.persist(StorageLevel.DISK_ONLY)

– MEMORY_AND_DISK-laten we zeggen dat ik 3 RDDs (Geen zijn gecached) in het geheugen van de uitvoerder en er is geen Beschikbaar geheugen over. Ondertussen komt er een andere RDD (zeg RDD4) binnen. Spark zal dus de minst recent gebruikte (LRU) RDD uit het geheugen van de uitvoerder verwijderen en ruimte maken voor de nieuwe RDD om in te komen (in dit geval RDD4).

laten we nu aannemen dat er 3 RDD ‘ s in het geheugen zijn opgeslagen en wanneer RDD4 arriveert, zal LRU geen RDD uit het cachegeheugen van het Werkknooppunt verwijderen. En er kunnen problemen zijn.

maar als we memory_and_disk persistence level gebruiken met RDD4 dan zal RDD4 opgeslagen worden op de schijf, als het niet genoeg ruimte in het cachegeheugen vindt.

RDD4.persist(StorageLevel.MEMORY_AND_DISK)

ook als er een enorme RDD in het geheugen is opgeslagen en er niet genoeg cachegeheugen is, worden de resterende partities die niet in het cachegeheugen kunnen passen naar de schijf gemorst als we MEMORY_AND_DISK gebruiken.

ook hier is de uitdaging I / O-operaties.

opmerking: de gegevens die op de schijf aanwezig zijn, worden opgeslagen op de tmp-locatie.

geheugenformaat

serialisatie-we kunnen ervoor kiezen om de gegevens die zijn opgeslagen in het cachegeheugen te serialiseren.

MEMORY_ONLY_SER en MEMORY_AND_DISK_SER

het aanhouden van de RDD in een seriële (binaire) vorm helpt om de grootte van de RDD te verkleinen, waardoor er ruimte wordt gemaakt voor meer RDD om in het cachegeheugen te blijven staan. Deze twee geheugenformaten zijn ruimte-efficiënt.

maar het probleem is dat ze minder tijdefficiënt zijn omdat we de kosten van de tijd moeten dragen die nodig zijn om de gegevens te deserialiseren.

het is dus de keuze van een ontwikkelaar of performance van belang is of de opslag van belang is. Zeker, de performance impact zou niet veel zijn, maar het zou een minuut een.

Partitiereplicatie

slaat de partitie op twee nodes op.

DISK_ONLY_2
MEMORY_AND_DISK_2
MEMORY_ONLY_2
MEMORY_AND_DISK_SER_2
MEMORY_ONLY_SER_2

deze opties slaan een gerepliceerde kopie van de RDD ook op in het cachegeheugen van een andere Werknode.

gerepliceerde gegevens op de schijf zullen worden gebruikt om de partitie opnieuw te maken, d.w.z. het helpt om de RDD te berekenen als het andere werkknooppunt naar beneden gaat.

de RDD

niet persisteren– stoppen met persisteren en verwijderen van geheugen of schijf
– het persistentieniveau
van een RDD wijzigen.unpersist ()

dus, dit is hoe we kunnen werken met ons cachegeheugen in Apache Spark.

dit komt allemaal uit deze blog, Ik hoop dat je ervan genoten hebt en dat het je geholpen heeft!! Blijf in contact voor meer toekomstige blogs. Dank je!!

Geef een antwoord

Het e-mailadres wordt niet gepubliceerd.