A perzisztencia megértése az Apache Sparkban

olvasási idő: 4 perc

ebben a blogban megpróbáljuk megérteni az Apache Spark Perzisztencia fogalmát egy nagyon laikus kifejezéssel, forgatókönyv-alapú példákkal.
megjegyzés: a forgatókönyvek csak azt jelentette, a könnyű megértést.

Spark architektúra

Megjegyzés: A gyorsítótár memória megosztható a végrehajtók között.

mit jelent az RDD fenntartása/gyorsítótárazása?

a Spark RDD perzisztencia egy optimalizálási technika, amely az RDD kiértékelés eredményét a gyorsítótár memóriájába menti. Ezzel elmentjük a közbenső eredményt, hogy szükség esetén tovább tudjuk használni. Csökkenti a számítási költségeket.

amikor megmaradunk egy RDD-nek, minden csomópont tárolja a partíciókat, amelyeket kiszámít a memóriában, és újra felhasználja őket az adott RDD (vagy az abból származó RDD) más műveleteiben. Ez lehetővé teszi, hogy a jövőbeli műveletek sokkal gyorsabbak legyenek (gyakran több mint 10x). A gyorsítótár az iteratív algoritmusok és a gyors interaktív használat kulcsfontosságú eszköze.

a persist() vagy cache() módszerekkel jelölhet meg egy MEGMARADANDÓ RDD-t. Az első alkalommal, amikor egy műveletben kiszámítják, a csomópontok gyorsítótárában marad. A Spark gyorsítótára hibatűrő – ha az RDD bármely partíciója elveszik, akkor az automatikusan újraszámításra kerül az eredetileg létrehozott átalakítások segítségével.

tegyük fel, hogy van ez az átalakulás–

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

az RDD3 az RDD2-ből, az RDD2 pedig az RDD1-ből jön létre. Minden alkalommal, amikor átalakítást végzünk az RDD3-on, akkor az RDD2-t és az RDD1-et újra és újra kell számolni.

RDD4.collect()RDD5.collect()

itt a teljes transzformációs láncot kétszer kell kiszámítani.

de megtarthatjuk ezt az RDD3-at a Worker csomópont gyorsítótárában, így minden alkalommal, amikor használjuk, az RDD2-t és az RDD1-et nem kell újra kiszámítani.

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

itt az RDD5 kiszámításához a Spark beolvassa az RDD3-at a gyorsítótár memóriájából, és létrehozza az eredményt. Ezért az RDD2 és az RDD1 nem kerül újraszámításra RDD5

esetén Megjegyzés: rdd.cache () ugyanaz, mint rdd.persist ()

Perzisztencia szintek

tárolási hely

– MEMORY_ONLY (alapértelmezett) – ugyanaz, mint a gyorsítótár
rdd.továbbra is fennáll(StorageLevel.MEMORY_ONLY) vagy rdd.persist()

rdd.továbbra is fennáll(StorageLevel.MEMORY_AND_DISK) rdd.továbbra is fennáll(StorageLevel.DISK_ONLY)

elgondolkodhat azon, hogy mi értelme a lemezen tárolni?

határozottan, ha az RDD-t lemezre tároljuk, akkor az I / O bekövetkezik, ami időigényes. De biztosítanunk kell, hogy az I/O hosszú időt vesz igénybe, vagy az RDD újraszámítása hosszabb időt vesz igénybe. Most, ha megtudjuk, hogy az I/O kevesebb időt vesz igénybe, akkor az RDD újraszámítása, akkor ebben az esetben jobb, ha az RDD-t lemezre tárolja.

tehát, amikor rdd1-re van szükség a következő átalakítás során, akkor a Spark egy I/O műveletet hajt végre, és eljuttatja azt a végrehajtó memóriájába.

RDD1.továbbra is fennáll(StorageLevel.DISK_ONLY)

most tegyük fel, hogy 3 RDD-t tárolnak a memóriában, és amikor az RDD4 megérkezik, az LRU nem fog semmilyen RDD-t kidobni a Worker csomópont gyorsítótárából. És lehetnek OOM problémák.

de ha MEMORY_AND_DISK perzisztencia szintet használunk az RDD4-rel, akkor az RDD4 a lemezen lesz tárolva, ha nem talál elég helyet a gyorsítótár memóriájában.

RDD4.továbbra is fennáll(StorageLevel.MEMORY_AND_DISK)

Továbbá, ha egy hatalmas RDD-t tárolunk a memóriában, és nincs elég gyorsítótár, akkor a fennmaradó partíciók, amelyek nem férnek el a gyorsítótár memóriájában, a MEMORY_AND_DISK használatával a lemezre kerülnek.

itt ismét az I/O műveletek jelentik a kihívást.

megjegyzés: a lemezen tárolt adatok tmp helyen vannak tárolva.

memória formátum

Sorosítás – választhatjuk a gyorsítótárban tárolt adatok sorosítását.

MEMORY_ONLY_SER és MEMORY_AND_DISK_SER

az RDD serializált (bináris) formában való fennmaradása segít csökkenteni az RDD méretét, így több RDD marad a gyorsítótár memóriájában. Tehát ez a két memória formátum helytakarékos.

ezzel azonban az a probléma, hogy kevésbé időtakarékosak, mert az adatok deszerializálásával járó időköltséget kell viselnünk.

tehát a fejlesztő döntése, hogy a teljesítmény vagy a tárolás számít-e. Határozottan, a teljesítmény hatása nem lenne sok, de egy perc lenne.

partíció replikáció

a partíciót két csomóponton tárolja.

DISK_ONLY_2
MEMORY_AND_DISK_2
MEMORY_ONLY_2
MEMORY_AND_DISK_SER_2
MEMORY_ONLY_SER_2

ezek az Opciók az RDD replikált példányát más munkacsomag gyorsítótár-memóriájába is tárolják.

a lemezen lévő replikált adatok kerülnek felhasználásra a partíció újbóli létrehozásához. segít az RDD újraszámításában, ha a másik munkás csomópont leesik.

az RDD fennmaradásának megszüntetése

– a perzisztencia leállítása és a memóriából vagy a lemezről való eltávolítás
– az RDD perzisztencia szintjének megváltoztatása
rdd.unpersist ()

szóval, ez hogyan tudunk dolgozni a cache memória Apache Spark.

ez mind a blog, remélem tetszett, és ez segített!! Maradjon kapcsolatban további jövőbeli blogokkal. Köszönöm!!

Vélemény, hozzászólás?

Az e-mail-címet nem tesszük közzé.