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 => RDD3az 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!!