Förstå uthållighet i Apache Spark

Lästid: 4 minuter

i den här bloggen kommer vi att försöka förstå begreppet uthållighet i Apache Spark i en mycket lekman term med scenariobaserade exempel.
Obs: scenarierna är endast avsedda för din enkla förståelse.

Spark arkitektur

Obs: cacheminnet kan delas mellan exekutörer.

vad betyder det genom att fortsätta / cacha en RDD?

Spark RDD persistens är en optimeringsteknik som sparar resultatet av RDD-utvärdering i cacheminnet. Med detta sparar vi mellanresultatet så att vi kan använda det vidare om det behövs. Det minskar beräkningen overhead.

när vi fortsätter en RDD, lagrar varje nod partitionerna av den som den beräknar i minnet och återanvänder dem i andra åtgärder på den RDD (eller rdd härledd från den). Detta gör att framtida åtgärder kan bli mycket snabbare (ofta med mer än 10x). Caching är ett viktigt verktyg för iterativa algoritmer och snabb interaktiv användning.

du kan markera en RDD som ska kvarstå med metoderna persist() eller cache() på den. Första gången det beräknas i en åtgärd kommer det att hållas i cacheminnet på noderna. Sparks cache är feltolerant-om någon partition av en RDD går förlorad, kommer den automatiskt att beräknas om med hjälp av de transformationer som ursprungligen skapade den.

låt oss säga att jag har denna omvandling–

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

RDD3 skapas från RDD2 och RDD2 skapas från RDD1. Varje gång vi gör en omvandling på RDD3, måste RDD2 och RDD1 beräknas om och om igen.

RDD4.collect()RDD5.collect()

här måste hela transformationskedjan beräknas två gånger.

men vi kan fortsätta denna RDD3 i cacheminnet för Arbetarnoden så att RDD2 och RDD1 inte behöver beräknas om varje gång vi använder den.

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

här, för att beräkna Rdd5 Spark kommer att läsa RDD3 från cacheminnet och generera resultatet. Därför RDD2 och RDD1 kommer inte att beräknas för RDD5

Obs: rdd.cache () är samma som rdd.kvarstår()

Persistensnivåer

lagringsplats

– MEMORY_ONLY (standard) – samma som cache
rdd.kvarstår (StorageLevel.MEMORY_ONLY) eller rdd.kvarstår ()

rdd.kvarstår (StorageLevel.MEMORY_AND_DISK)

– DISK_ONLY – lagrar alla partitioner på disken
rdd.kvarstår (StorageLevel.DISK_ONLY)

du kanske undrar vad som är meningen med att lagra i Disk?

definitivt, om vi lagrar RDD I disken kommer I/O att inträffa, vilket är tidskrävande. Men vi måste se till att om I/O tar lång tid eller omberäkningen av RDD tar längre tid. Nu, om vi kan ta reda på att I/O tar mindre tid än omberäkningen av RDD, då är det bättre att lagra RDD i disken.

så, när RDD1 krävs nästa gång i den efterföljande omvandlingen, kommer Spark att göra en I/O-operation och ta den till exekutörens minne.

RDD1.kvarstår (StorageLevel.DISK_ONLY)

låt oss nu anta att 3 rdd: er är cachade i minnet och när RDD4 anländer kommer LRU inte att sparka ut någon RDD från cacheminnet för arbetaren. Och det kan finnas OOM-problem.

men om vi använder MEMORY_AND_DISK persistensnivå med RDD4 kommer RDD4 att lagras på disken om den inte hittar tillräckligt med utrymme i cacheminnet.

RDD4.kvarstår (StorageLevel.MEMORY_AND_DISK)

om en enorm RDD cachas i minnet och det inte finns tillräckligt med cacheminne spills de återstående partitionerna som inte kan passa i cacheminnet till Disk om vi använder MEMORY_AND_DISK.

återigen är utmaningen här I / O-operationer.

Obs! data som finns kvar på disken lagras på tmp-plats.

Minnesformat

serialisering – vi kan välja att serialisera data som lagras i cacheminnet.

MEMORY_ONLY_SER och MEMORY_AND_DISK_SER

att fortsätta rdd I en serialiserad (binär) form hjälper till att minska storleken på RDD, vilket gör plats för mer RDD att kvarstå i cacheminnet. Så dessa två minnesformat är rymdeffektiva.

men problemet med detta är att de är mindre tidseffektiva eftersom vi måste ådra oss kostnaden för tid som är involverad i deserialisering av data.

så det är en utvecklares val om prestanda är viktigt eller lagringsfrågor. Definitivt skulle prestandapåverkan inte vara mycket, men det skulle vara en minut en.

Partitionsreplikation

lagrar partitionen på två noder.

DISK_ONLY_2
MEMORY_AND_DISK_2
MEMORY_ONLY_2
MEMORY_AND_DISK_SER_2
MEMORY_ONLY_SER_2

dessa alternativ lagrar också en replikerad kopia av RDD i någon annan Arbetarnods cacheminne.

replikerade data på disken kommer att användas för att återskapa partitionen dvs. det hjälper till att beräkna RDD om den andra arbetaren noden går ner.

Unpersisting rdd

– för att sluta fortsätta och ta bort från minnet eller disken
– för att ändra en rdd: s persistensnivå
rdd.unpersist ()

så, så här kan vi arbeta med vårt cacheminne i Apache Spark.

det här är allt från den här bloggen, hoppas du gillade det och det hjälpte dig!! Håll kontakten för fler framtida bloggar. Tack!!

Lämna ett svar

Din e-postadress kommer inte publiceras.