Optimalizálási technikák egy elosztott memórián belüli számítástechnikai platformhoz az SSD 2. rész kihasználásával

3.1. Klaszter környezet

Az 1. ábra egy névcsomópontból (master) és négy adatcsomópontból (slave) álló tesztágyfürtünket mutatja. A névcsomópontban (fő) konfiguráltuk a Hadoop névcsomópontját és másodlagos névcsomópontját (HDFS), valamint a Spark illesztőprogram-csomópontját (főcsomópontja). Mindegyik adatcsomópontban a DataNode of Hadoop (HDFS) és a Worker Node of Spark szolgáltatást futtatjuk. A névcsomópont és az adatcsomópont gépek azonos H/W környezettel rendelkeznek (3,4 GHz-es Xeon E3-1240V3 négymagos processzor hyper-threading-el), kivéve a fő memória mennyiségét (8 GB a név csomóponthoz és 4 GB). minden adatcsomóponthoz).

A Namename a Hadoop architektúra fő csomópontja, amely a teljes Hadoop-fürt fájlrendszerének kezeléséért és figyeléséért felelős. A Namename csomópont a teljes Hadoop-fürt egyik kritikus csomópontja is, és teljesítménye és megbízhatósága közvetlenül befolyásolja a teljes Hadoop-fürt működési hatékonyságát és elérhetőségét.

A Namename csomóponthoz számos mutató kapcsolódik, az egyik legfontosabb mutató a memória. A Névnév csomópont sok memóriát igényel a teljes HDFS fájlrendszer névterének tárolásához és kezeléséhez, amely tartalmazza a fájlok és könyvtárak metaadatait, például fájlneveket, engedélyeket, időbélyegeket, fájlméreteket stb.

A Namename csomópont memóriája nemcsak a kezelhető fájlok számát és a fájlrendszer méretét határozza meg, hanem befolyásolja a Hadoop-fürt teljesítményét és megbízhatóságát is. Ha a Namename csomópont nem rendelkezik elegendő memóriával, nem tud gyorsan válaszolni az ügyfelek kérésére, ami a teljes Hadoop-fürt átviteli sebességének csökkenését eredményezi. Ezenkívül, ha a Namename csomópont meghibásodik, az általa tárolt metaadat-információk elveszhetnek, így a teljes HDFS fájlrendszer elérhetetlenné válik.

Ezért a Hadoop-fürtben a Namename csomópont memóriája kulcsfontosságú. Javasoljuk, hogy a rendszergazdák válasszák ki a megfelelő Namename csomópont hardverkonfigurációját az adott üzleti igények alapján, és rendszeresen figyeljék a Namename csomópontok teljesítményét és elérhetőségét annak biztosítása érdekében, hogy hatékony és megbízható szolgáltatásokat nyújtsanak a teljes Hadoop-fürt számára. Látható, hogy javítanunk kell a memóriánkat. A Cistanche jelentősen javíthatja a memóriát, mert a hústészta egy hagyományos kínai gyógyászati ​​anyag, számos egyedi hatással, amelyek közül az egyik a memória javítása. A darált hús hatékonyságát különféle hatóanyagok biztosítják, beleértve a karbonsavat, poliszacharidokat, flavonoidokat stb. Ezek az összetevők különféle csatornákon keresztül elősegíthetik az agy egészségét.

Kattintson a Tudnivaló kiegészítőkre a memória javításához

Tárhelyként két SSD-t használtunk, ahol az operációs rendszerhez egy 120 GB-os SATA3 SSD, a HDFS-hez pedig egy 512 GB-os SATA3 SSD került. Ezenkívül az 512 GB-os SATA3 SSD hatékonyan kihasználható az elégtelen főmemória sávszélességének bővítésére a Spark RDD-inek gyorsítótárazásához. Az összes csomópont, beleértve a névcsomópontot és az adatcsomópontot is, egy 1 Gb-os Ethernet kapcsolóval van összekötve, amint az 1. ábrán látható. A 2. táblázat bemutatja a hardver- és szoftverkonfigurációk összefoglalását a tesztágy-fürt egyes adatcsomópontjaiban.

3.2. Spark JVM Heap

A Spark-feladatok Java-folyamatként futnak a Java virtuális gépen (JVM), és a Spark kihasználja a Scalát, a Java-ból kiterjesztett funkcionális nyelvet. A Spark dolgozói folyamata az egyes adatcsomópontok JVM-jén is fut, így az egyes adatcsomópontokon a munkavégző folyamatnak a fő memóriájában van a JVM kupac, amint az a 2. ábrán látható. Amikor a Spark elküld egy feladatot, az a munkafolyamat, amely a JVM kupac elosztott feladatokként hajtja végre a munkát.

A spark-defaults konfigurációs fájlban testreszabhatjuk egy Spark-munkavégző JVM-halomméretének arányát. conf a spark/conf/ könyvtárban. A spark defaults.conf fájlban a spark.executor.memory értéke a JVM kupac mérete, ahol az alapértelmezett 512 MB, amelyet minden egyes munkavégző csomópont felhasználhat az adatcsomópontban. Ezenkívül a spark.storage.safetyFraction értéke 0.9, ami azt jelenti, hogy a Spark a JVM kupacméretének (más néven biztonsági terület) 90%-át használhatja. Ez megakadályozza, hogy a JVM OOM (memória hiánya) hibákat generáljon a feladatfeldolgozás során a rendelkezésre álló fő memória hiánya miatt.

Ezen a biztonsági területen a teljes JVM kupacterület három alrégióra van osztva: kibontási, tárolási és keverési területre, amint az a 2. ábrán látható. A kicsomagolási terület a memóriában lévő adatblokkok kibontására szolgál. Ha egy RDD más adathordozón, például SSD-n vagy HDD-n van gyorsítótárban, nem a fő memóriában, az RDD-t sorosítani kell. Ezután, amikor a Spark visszaolvassa ezt az RDD-t a memóriába, az RDD-t ki kell tekerni. A tárhely az RDD gyorsítótárazására szolgál. Ha a tárhely nem elegendő az RDD gyorsítótárazásához, néhány RDD kiüríthető erről a területről az LRU (legutóbb használt) házirend alapján, vagy más adathordozón, például SSD-n gyorsítótárazható. A keverési terület a közbenső adatok keverésére szolgál. Ez a keverési hely fontos szerepet játszhat az iteratív alkalmazásokban, például a gépi tanulásban, mivel jelentősen befolyásolhatja a munka teljes befejezési idejét.

Az alapértelmezett Spark-konfigurációban a JVM kupac tároló- és keverési területének kapacitási töredékaránya {{0}}.6, illetve 0.2 (azaz 60 a biztonsági terület %-a a tároláshoz és 20%-a a keveréshez). A kibontás alapértelmezés szerint a tárhely 20%-át foglalja el. A JVM kupac ezen három mezőjének kapacitása szikrával állítható be. storage.unrollFraction, spark.storage.memoryFraction és spark.shuffle.memoryFraction. Például a tesztágy-fürtünkben beállíthatjuk a spark.executor.memory-t a worker csomópont 4 GB-os memóriájából 2,6 GB-ra, ami azt jelenti, hogy a JVM kupac mérete maximum 2,6 GB-ra van állítva. Ekkor a tárhely és a véletlenszerű lejátszási terület tényleges kapacitása 2,6 GB × 0,9 × 0.6 = 1,4 GB és 2,6 GB × 0,9 × 0.2=0,46 GB, illetőleg. Ennek megfelelően a kibontási terület 1,4 GB × 0.{29}}.28 GB.

3.3. RDD gyorsítótárazási szabályzat

A Spark platform változatos RDD gyorsítótárazási lehetőségeket kínál, beleértve a fő memóriát és a lemezeket. Az alapértelmezett beállítás a MEMÓRIA_CSAK, ahol az RDD a 3.2. szakaszban leírt tárterületen van karbantartva, mint nem szerializált Java objektum. Ha ez a tárhely nem elegendő az összes RDD tárolására, akkor ezek egy része kiürül a fő memóriából egy előre meghatározott gyorsítótár-csere házirend alapján. Ha azonban nem gyorsítótárazott RDD-re van szükség a feladat feldolgozásához, ezt az RDD-t újra létre kell hozni a származási adatok alapján, ami jelentős teljesítménycsökkenést eredményezhet ebben a CSAK MEMÓRIA{6}}gyorsítótárazási szabályzatban.

A CSAK MEMÓRIA_ opció mellett a Spark alternatív MEMÓRIA{_ÉS_LEMEZ, CSAK LEMEZ_és KI_HEAP opciókat kínál. A MEMÓRIA_ÉS_LEMEZ opció az RDD-ket a nem felejtő lemezen tárolja, ha a tárhely nem elegendő az összes szükséges RDD tárolásához. A lemezek állhatnak HDD-kből vagy SSD-kből; a normál orsólemezek olvasási/írási átviteli sebessége azonban viszonylag gyenge, így a teljes végrehajtási idő hosszabb lehet, mint a MEMORY_ONLY gyorsítótárazási opcióé. A probléma megoldására hatékonyan tudjuk kihasználni az SSD-ket, amelyek potenciálisan csökkenthetik a teljes munkavégzési időt a normál HDD-alapú megközelítéshez képest.

A DISK_ONLY opció csak nem felejtő tárolóeszközökön, például merevlemezeken vagy SSD-ken tárolja az RDD-ket, azaz nem a fő memóriában. Az a fürt, amelynek nincs elegendő szabad memóriája, jó teljesítményt érhet el ezzel az opcióval. Ebben az esetben, mivel az RDD csak lemezes adathordozón van tárolva, a keverési terület meghosszabbítható a memória tárterületének használata helyett. Ennek eredményeként egy olyan alkalmazás futtatásakor, mint például a PageRank, amely viszonylag nagy mennyiségű kevert adatot generál, jobb teljesítményt tapasztalhatunk, mint a MEMORY_ONLY esetben.

Az OFF_HEAP opció lehetővé teszi a Spark számára, hogy halmon kívüli területet használjon, ami kívül esik a Java szemétgyűjtő kezelésén. Így ha nem halom területet használunk, akkor bonyolult memóriaműveletekkel kell foglalkoznunk, mint például az allokáció/felszabadítás és a szerializálás/deszerializálás. Ezért gyakorlati okokból nem használjuk az OFF_HEAP konfigurációt.

3.4. Optimalizálási módszertan

Amint azt a 3.2 és 3.3 szakaszban tárgyaltuk, optimalizálási módszereink közé tartozik (1) a Spark JVM kupac konfigurálása és (2) az RDD gyorsítótárazási szabályzat kísérleti lehetőségei, az alábbiak szerint:

1. Spark JVM kupac konfiguráció: Megvizsgáltuk a keverési és tárolóterek kapacitási hányadának változtatásának hatásait. A keverés és a tárhely aránya 60%:30%, 50%:40%, illetve 20%:60%. A „20%:60%” keverési és tárolási arány az alapértelmezett érték a Spark beállításában. A „60%:30%” beállítást választjuk, hogy az eredményt elegendő keverési hellyel állítsuk szembe, és az „50%:40%” beállítást a teljesítmény kiegyensúlyozott megjelenítéséhez állítjuk be.

2. RDD gyorsítótárazási szabályzat: Megvizsgáltuk a különböző RDD gyorsítótárazási szabályzatok hatásait is. Összehasonlítottuk a különféle irányelvek teljesítményét, mint például a KI az SSD-t jelöli ebben a kísérletben.

A 3. táblázat összesen 12 különböző kísérleti konfigurációt mutat be az RDD-gyorsítótárazási szabályzatok és a Spark JVM-kapacitás-arányok alapján. A "_1" címkével ellátott kísérleti konfigurációkban (például "N_1") a Spark JVM kupac 60%-át a keverésre, 30%-át pedig a tárhelyekre állítottuk be. A „_2” címkével rendelkezőkkel a Spark JVM kupac 50%-át keverésre, 40%-át pedig tárolásra állítjuk be. Végül a „_3” címkével ellátottak esetében a Spark JVM kupac 20%-át a keveréshez és 60%-át a tároláshoz állítjuk be, amint az az „Option”, „Shuffle” és „Storage” oszlopokból is látható. Vegye figyelembe, hogy a tesztágyas fürt végrehajtójának maximális memóriamérete 2,7 GB, azaz minden egyes munkavégző csomópont 2,7 GB-os Spark JVM kupacmérettel rendelkezik.

Az RDD gyorsítótárazási szabályzat szempontjából az "N" opció nem az RDD gyorsítótárazását jelenti, az "M" opció azt jelenti, hogy csak a memóriában tárolja az RDD-t, az "M&S" opció pedig az RDD gyorsítótárazását a memóriában és az SSD-ben, és végül az "S" opció csak az RDD gyorsítótárazására szolgál az SSD-n.

Kísérleteink során olyan optimalizálási stratégiákat javasolunk, amelyek a legjobb teljesítményt érhetik el az elégtelen memóriamennyiséggel rendelkező fürtből a Spark JVM kupac konfigurációjának gondos beállításával és hatékony RDD gyorsítótárazási házirend alkalmazásával, amint azt a 4. szakaszban látni fogjuk.

4. Kísérleti eredmények és elemzések

4.1. 500 MB PageRank-kísérletek

4.1.1. Eredmények a JVM kupac konfigurációinak módosításával

A 3. ábra a PageRank munkaterhelés egyes szakaszainak kísérleti eredményeit mutatja a JVM kupacméretek módosításával. A megkülönböztető szakaszban a Spark beolvassa a bemeneti adatokat, és megkülönbözteti az URL-t és a hivatkozásokat. Amint a megkülönböztető a szemétgyűjtőhöz (GC). Például a GC-idő 25 s, 24 s és 16 s M&S_1, M&S_2 és M&S{{10}} esetén. Ezért a megkülönböztető0 szakaszban, ahogy növeljük a tárhely mennyiségét, a GC-idő csökkentésével javíthatjuk az általános teljesítményt. Másrészt a Distinct1 szakaszban a teljes végrehajtási idő növekszik, ahogy a beállításokat _1 és _2 értékről _3 értékre változtatjuk. Ez elsősorban a keverés miatti kiömlés miatt van. Amikor ellenőriztük a Spark webes felhasználói felületét, a keverési adatok a lemezre kerültek a kevert memóriaterület hiánya miatt. Például az M&S_1, M&S_2 és M&S_3 lemezen lévő véletlenszerű kiömlött adatok mérete 0, 220 MB, illetve 376 MB. Amikor a véletlenszerű kiömlés megtörténik, a CPU többletköltsége az adatoknak a lemezre történő kiszórásához nő, mivel az adatokat sorosítani kell.

A megkülönböztető szakaszok után vannak iteratív flatMap szakaszok a rangok megszerzéséhez. A FlatMap szakaszok sok keverési adatot generálnak, ami miatt a klaszterünkből hiányzik a szükséges keverési memóriaterület. Ezért, ahogy a rendelkezésre álló keverési terület csökken (a(z) _1, _2 és _3 opciók sorrendjében), annál több keverési kiömlés fordulhat elő, ami potenciálisan befolyásolhatja a munka általános végrehajtását. idő (pl. M&S opció flatMap2 szakasz _1: 37 s, _2: 40 s, _3: 49 s). Ha azonban az adatok csak a memóriában vannak tárolva (azaz M_1, M_2 és M_3), akkor más mintát mutatnak. Ennek a viselkedésnek a fő oka az, hogy a Spark ütemező egyenlőtlenül ütemezi a feladatokat, mivel nincs elegendő memória az RDD gyorsítótárazásához a _1 és _2 opcióknál. Ha egy dolgozónak nincs RDD-je, akkor kizárják az ütemezési készletből. Ezért a többi dolgozónak további feladatokat kell ellátnia GC rezsivel, ami befolyásolhatja a teljes munkavégzési időt.

4.1.2. Eredmények az RDD gyorsítótárazási beállítások módosításával

Először is, a különálló szakaszokat nem érinti az RDD gyorsítótárazási szabályzatának megváltoztatása, hanem csak a memóriahasználat. Az RDD gyorsítótárazási opció által érintett szakaszok flatMap szakaszok, mivel a keverési fázisban ismét gyorsítótárazott RDD-ket használnak.

A 4. ábrán a grafikont az N_1 opció normalizálja, amely nem gyorsítótárazja az RDD és a _1 memóriakonfigurációt a teljesítménykülönbség ellenőrzéséhez. Ha csak a _1 grafikonjait hasonlítjuk össze, M_1, M&S_1 és S_1 sorrendben, 32%-os teljesítményromlás tapasztalható M{{8} }}, illetve 30%-os, illetve 20%-os teljesítményjavulás az M&S{11}} és S_1 segítségével. Az M_1 opciónál a viszonylag gyenge teljesítmény oka az, hogy az RDD-k a tárhely hiánya miatt egyenetlenül gyorsítótárazódnak, ami egyenetlen ütemezést eredményez, amint azt korábban említettük. Ez azt jelenti, hogy a JVM halomterülete nem elegendő az adatok keveréséhez és az RDD-k mentéséhez.

A probléma megoldása érdekében az RDD-ket a memóriában és az SSD-n is gyorsítótárba helyezzük, ami javíthatja a teljesítményt, ahogy az M&S{0}} opciónál látható. Az RDD gyorsítótárazása a memóriában javítja az RDD hozzáférési sebességét, és az RDD gyorsítótárazása az SSD-n elkerülheti a véletlenszerű lejátszást azáltal, hogy hatékonyan megnöveli a szabad keverési területet a memóriában. Az S_1 opcióval, amely 20%-os teljesítményjavulást mutatott, az RDD csak az SSD-n van gyorsítótárban. Az RDD gyorsítótárazása az SSD-n csökkenti a véletlenszerű kiömlést. Azonban alacsonyabb teljesítménynövekedést ért el, mint az M&S_1, ahol az RDD főként a memóriában van tárolva, és a memóriából újrafelhasználható.

A Spark alapértelmezett konfigurációjában, amely a _3 opció, azt láthatjuk, hogy M_3, M&S_3, S_3 és N{{4 }}, az általános teljesítmény csökken. Az alapértelmezett konfigurációban a JVM kupac tárhelye elegendő ahhoz, hogy az RDD egyenleggel gyorsítótárazott legyen. Ezért az általános teljesítmény főként a használt memóriaeszköz teljesítményétől függ. A legjobb teljesítményt azonban továbbra is az M&S_1 opcióval láthatjuk, mivel hatékonyan csökkenthetjük a GC-időt és a keverési időt, ha az RDD-t a memóriában és az SSD-n is gyorsítótárazzuk.

4.2. 1 GB PageRank teljesítmény

Kísérleteztünk a PageRank munkaterheléssel az adatok méretének 500 MB-ról 1 GB-ra történő növelésével. Az 5. ábra a rendszer eltérő viselkedését mutatja az 500 MB-os adatkészlet PageRank értékéhez képest. Láthatunk néhány sikertelen munkát, amelyek a take6 szakaszig nem tudták a munkát befejezni (pl. N_1, N_2, M_1, M_2, M _3, M&S_3). A meghiúsult feladatok között vannak olyanok, amelyek a flatMap2 szakaszban meghiúsultak, ezek a következők: N_1, N_2 és M_1. A munka sikertelenségének oka a tárolómemória hiánya. A GC akkor fordul elő, ha az RDD nincs elegendő memória gyorsítótárában. A GC többletterhelés miatt a Spark végrehajtó ExecutorLostFailure kivételt kap.

M_2, M_3 és M&S_3 folytathatja a feldolgozást a flatMap2 szakaszig; ezt követően azonban meghibásodás következik be. Az M&S_3 hasonlóan működik, mint az M_3 a flatMap2 szakaszig, mert az M&S_3 opció használata esetén elegendő memória áll rendelkezésre az RDD gyorsítótárazásához. A flatMap2 után az OutOfMemory hiba lép fel a kevert memóriaterület hiánya miatt a flatMap3 szakaszban.

4.2.1. Eredmények a JVM kupac konfigurációjának módosításával

A Distinct{0}} szakasz nagyon hasonló eredményeket mutat az 500 MB-os adatkészletéhez, és az általános teljesítmény a _1, _2 és _3 opciók sorrendjében javul. Ennek az az oka, hogy a GC idő 78 másodpercre, 59 másodpercre, illetve 28 másodpercre csökken.

Másrészt a Distinct1 szakaszban eltérő eredményeket mutatott az 500 MB-os adatkészletre. Az 500 MB-os adatkészlet-kísérletben a memória keverési helyének növelésével láthatjuk a teljesítménynövekedést. Az 1 GB-os adatkészlet-kísérletben azonban a dolgozó csomópont végrehajtó memóriája nem képes befogadni a nagy adatméretet. Ezért a memória keverési területe viszonylag kevéssé válik. Például a _1, _2 és _3 opciók véletlenszerű kiömlésének mennyisége 575,5 MB, 813,8 MB és 843,4 MB, a GC idő pedig 33 s, 10 s, illetve 8 s. Ahogy korábban említettük, ha véletlenszerű kiömlés történik, az RDD-t sorba kell állítani, hogy a CPU-számítások növekedhessenek, ami általános teljesítményromláshoz vezethet.

4.2.2. Az RDD gyorsítótárazási szabályzat módosításának eredményei

A végrehajtási idő elemzéséhez az RDD gyorsítótárazási házirend megváltoztatásával, amint azt a 6. ábrán láthatjuk, az 5. ábrán különálló szakaszokat kizárunk. Ennek az az oka, hogy nem kell külön szakaszokat elemeznünk, mivel az RDD gyorsítótárazási házirend megváltoztatása nem okoz változást. .

Érdekes módon a flatMap szakaszokban a különféle JVM kupackonfigurációk nem változnak, szemben az 500 MB-os adatkészlettel. Ennek az az oka, hogy a véletlenszerű kiömlés minden konfigurációban előfordul, mert nincs elegendő memória. Az RDD gyorsítótárazási beállítás módosításával a teljes végrehajtási idő az M&S, S, N és M sorrendben növekszik. (Az M&S a leggyorsabb lehetőség.) Az N opcióban az ExecutorLostFailure hiba jelentkezik, mert nincs elegendő memóriaterület. Az M opcióban, amikor az RDD gyorsítótárazott a memóriában, GC többletterhelés lép fel, mert nincs elegendő memóriaterület. Még akkor is, ha az RDD a memóriában van tárolva, a feladat meghiúsul az ExecutorLostFailure hiba miatt, amely akkor fordul elő, ha a kevert memóriaterület nem elegendő (OutOfMemory).

Ilyen kevés memória esetén az M&S és S opciók hatékony alternatívák lehetnek. Az M&S{{0}} opcióban növeljük az RDD hozzáférhetőségét az RDD gyorsítótárazásával a memória és az SSD használatával. Ennek eredményeként a teljesítmény javulása ugyanaz, mint az 500 MB-os adatkészleté. Ezen túlmenően, az RDD SSD-n történő gyorsítótárazása miatt elegendő a kevert memóriaterület. Ahogy a 6. ábrán látható, az M&S_1 opció lesz a leggyorsabb lehetőség ebben a kísérletben (M&S_1:0,6, S_1:0,63, T_1 0,64).

4.3. TC-kísérlet elemzése

A 7. ábra a TC (tranzitív lezárás) kísérletek eredményeit mutatja, amelyek 50,000 élt és 25,000 csúcsot tartalmaznak véletlenszerűen generált bemeneti adatokat. Az iteráció száma 10. Az iterációk révén a feladatok száma minden iterációnál megduplázódik, így az RDD mérete növekszik és a kevert olvasás és írás mennyisége is nő. Az utolsó iterációban a feladatok száma 4096 lesz. Mivel több iterációs szakasz van, ez nagyobb hatással van a teljes munkavégzési időre, és az utolsó iterációs szakasz a legnagyobb, sok olyan feladatból áll, amelyek csökkenthetik az általános teljesítményt. .

Amint a 7. ábrán látható, a teljesítmény _3, _2 és _1 sorrendben javul az M, M&S és S opciók esetén, ami azt jelenti, hogy elegendő keverés mellett a JVM kupac memóriája hasznos. Az M opció esetén a _1 opció teljesítménye 18%-kal gyorsabb, mint a _3, míg az M&S opcióban a _1 opció teljesítménye 3%-kal gyorsabb, mint a {{9} }}. Az S opcióban a _1 teljesítménye 2%-kal gyorsabb, mint a _3.

Ha az RDD gyorsítótárazási beállítás módosítására összpontosítunk, az S_1 opció teljesítménye 42%-kal gyorsabb, mint az N_1, és 31%-kal gyorsabb, mint az M_1. A feladat-végrehajtási idő teljesítménynövekedésének oka az utolsó iterációs szakasztól függ. Az utolsó iterációs szakaszt befolyásoló kulcstényező a véletlenszerű olvasás blokkolt ideje. A véletlenszerű olvasási blokkolt idő akkor következik be, amikor az előző szakaszban végrehajtott RDD-t egy másik munkavégző csomópontból olvassa be a hálózaton keresztül a végrehajtó memória hiánya miatt.

Még ha a véletlenszerű olvasási blokkolt idő megoldásával minden feladat kb. 1-2 s teljesítménynövekedéssel jár, jelentős teljesítménynövekedést érhetünk el, mert az utolsó állapotban a feladatok száma meglehetősen nagy (azaz 4096). Ezenkívül a feladat végrehajtási idejét befolyásoló egyik fő tényező a számlálási szakasz, amely azt számolja, hogy a TC mátrix hány éle van az utolsó jobnál.

Az N opcióval, mivel a számlálási szakaszban nincsenek RDD-k gyorsítótárban, a Spark beolvassa az előző szakaszból végrehajtott keverési adatokat, ami 60 másodpercet vesz igénybe. Ezenkívül az M opcióban az RDD nincs gyorsítótárban a memóriában a végrehajtó memória hiánya miatt. Ennek eredményeként ez is 60 másodpercet vesz igénybe. Az M&S és S opcióknál azonban az RDD gyorsítótárazható a memórián és az SSD-n, így a számlálási szakaszban csak 2 másodpercre van szükség.

4.4. TeraSort kísérlet elemzése

A 8. ábra a TeraSort benchmark kísérleti eredményeit mutatja, amely 10 GB-os adatkészletet használ a JVM kupackonfiguráció és az RDD gyorsítótár beállításának módosításával. Ezt a grafikont az N_1 opció normalizálja. Láthatjuk, hogy az összes feladat-végrehajtási idő hasonló; a különbség közöttük kevesebb, mint 5%. A TeraSort munkaterhelésben nem történt teljesítményjavulás vagy -csökkenés a konfigurációk és beállítások módosítása miatt. A rendezési szakaszban néhány keverés történik a hálózaton. A kevert olvasási és kevert írási méret azonban egyenként 25 MB, ami meglehetősen kicsi a PageRankhez és a TC-hez képest. Ezért a JVM kupac konfigurációja és az RDD gyorsítótárazási beállítás nem befolyásolja a teljesítményt. Ezenkívül a TeraSort munkaterhelése nem áll iteratív feladatokból, mint az átmeneti lezárásnál, így az előző szakaszban nincs előnye az RDD gyorsítótárazásnak.

4.5. K-Means Clustering Experiment Analysis

A k-means klaszterezés normalizált munkavégzési idejét az 1,5 GB-os adatkészletre a 9. ábra mutatja. A k-means klaszterezés célja, hogy a távolságmérés (pl. euklideszi távolság) alapján megtalálja a k klasztert az adatkészletben. Ebben a munkaterhelésben az algoritmus csökkenti az SSE-t (sum of squared error) [24] azáltal, hogy iterálja a k középpont és az egyes adatpontok közötti távolság számítását. Ebben a kísérletben ezt a folyamatot nyolcszor ismételjük meg. A megkeverendő adatok mennyisége minimális, mivel az előző szakaszból szükséges adatok a középpontok és az SSE információi az egyes szakaszokban. A k-means klaszterezési munkaterhelésünkben a kevert olvasási/írási adatok maximális mennyisége 1.0 MB, a legkisebb pedig 0,8 MB. A keverés itt nem fordul elő, mert a keverési hely minden beállításnál elegendő. A gyorsítótárazási opciók nélküli kísérletekben nincs különbség a _1, _2 és _3 opciók között, mivel ezek a beállítások nem tárolnak gyorsítótáraz RDD-t, és mindhárom beállításnál a véletlenszerű lejátszás elegendő a hely.

Ha az RDD-ket gyorsítótárazza a fő memóriában vagy a memóriában és az SSD-ben, minél több tárhely van az RDD számára, annál jobban javul a teljesítmény a munkavégzés során, mivel több RDD gyorsítótárazható a tárhelyen. A _csak memória és a memória_és az _SSD opció összehasonlításakor a memória_és az _SSD opció jobb teljesítménynövekedést mutatott. Ennek az az oka, hogy a memória_csak beállításnál a tárhely még az M_3 opciónál sem elegendő. Ezenkívül az RDD-k gyorsítótárazása az SSD-n megoldja a tárolómemória hiányát. A memória_és az_SSD-beállítások átlagosan 10%-kal javították a teljesítményt a csak memória{10}}opcióhoz képest.

Ne feledje, hogy a k-means klaszterezési munkaterhelés ellentétes teljesítménytendenciát mutat a PageRank és a tranzitív bezárási munkaterheléssel szemben a kevert adatok mennyiségének különbsége miatt. Erről részletesebben a következő alfejezetben fogunk beszélni.

5. Megbeszélés és összefoglalás

5.1. Vita

Elemeztük a lehetséges teljesítményromlási problémák főbb tényezőit a munkaterhelés és a feldolgozási szakaszok sajátosságai alapján. Kiterjedt kísérleti eredményeinket a Spark platform teljesítményoptimalizálási technikáinak különféle munkaterhelésekre történő alkalmazásával kapcsolatban az alábbiakban foglaljuk össze:

• A Java szemétgyűjtés miatti teljesítményromlás: Az 500 MB adatkészlettel és 1 GB-os adatkészlettel rendelkező PageRank munkaterhelésben a GC akkor történik, ha a JVM kupacban nincs elegendő tárhely az RDD tárolásához. A Distinct0 szakaszban, amely beolvassa a bemeneti fájlt a HDFS-ből, és gyorsítótárazza az RDD-be, a GC megtörténik. A GC probléma megoldása érdekében a konfigurációval bővítjük a JVM kupac tárhelyét. A teljesítményt javíthatjuk a GC csökkentése érdekében, mivel a JVM kupac tárhelye bővíthető. A 3. és 5. ábrán ugyanazzal az RDD-gyorsítótárazási beállítással a _3 konfiguráció mutatja a legjobb teljesítményt a Distinct0 szakaszban. Ezenkívül az 1 GB-os adatkészlettel rendelkező PageRank-ban néhány beállítás a flatMap szakaszban meghiúsul a memória hiánya miatt. A GC overhead annyira megnő, hogy a színpad meghibásodik vagy végtelen hurokba kerül. Így a klasztert SSD-kkel építjük fel a probléma megoldására. Ez teljesítményjavulást mutat, és sikeres a feladat, amely csak memória használatával hibásodott meg, ahogy az a 6. ábrán látható, M&S_1 és S_1.

• A teljesítmény romlása véletlen sorrendben: Az 500 MB-os adatkészlettel és 1 GB-os adatkészlettel rendelkező PageRank-munkaterhelésben, a flatMap szakaszban azt láthatjuk, hogy az M&S_1 opció mutatja a legjobb teljesítményt, mivel ez a legkevesebb keveréssel rendelkezik. kiömlés (4. ábra: M&S_1 30%-kal gyorsabb, mint N_1; 6. ábra: M&S_1 40%-kal gyorsabb, mint N_3). A PageRank számos keverési feladatot tartalmaz. Így, ha a JVM kupac keverési területe nem elegendő az adatok hálózaton keresztüli keveréséhez, akkor keveredési kiömlés következik be. Ezért a keverési kiömlések csökkentése érdekében a JVM kupac keverési területének bővítése válik a teljesítmény javításának kulcstényezőjévé.

Továbbá javíthatunk a teljesítményen, ha az RDD-t mind a memórián, mind az SSD-n tároljuk. Ez arra késztetheti a végrehajtót, hogy kibővítse a JVM kupac keverési memóriáját, hogy csökkentse a véletlenszerű kiömlést. Ha több iteráció van, akkor a flatMap szakasz teljesítménye lenne a teljesítményjavítás kulcspontja. Az 1 GB-os adatkészlet-kísérletben az S_3 feladat végrehajtási ideje a legjobb megoldás, mivel az RDD-k csak az SSD-n vannak gyorsítótárazva, és elegendő kupacmemória van a végrehajtókon. Így az S_3 opcióban a megkülönböztető szakaszok gyorsabbak, mint bármely más opció. Ha azonban az iteráció száma növekszik, a flatMap szakasz befolyásolja a feladat végrehajtási idejét. Így az M&S_1 opció nagyszerű teljesítményt érhet el ebben az esetben. Ezen elemzések révén megállapíthatjuk, hogy a keverés kulcsfontosságú hatással van a munka befejezésének idejére. Így ki kell bővítenünk a JVM kupac kevert memóriáját, és gyorsítótáraznunk kell az RDD-t a memóriában és az SSD-ben is, hogy elegendő keverési memóriaterületet kapjunk a keverés kiömlésének megakadályozásához.

• A véletlen sorrendű olvasási blokkolt idő miatti teljesítményromlás: A TC munkaterhelésén van a véletlenszerű olvasás blokkolt ideje. Ez akkor fordul elő, ha sok feladat van a szakaszban, és minden feladatnak be kell olvasnia az előző RDD-t a hálózaton keresztül. A TC-kísérlet eredményeként (7. ábra) az M&S opció gyorsabb, mint az M. Ugyanebben az RDD-gyorsítótárazási opcióban a JVM kupac keverési területének bővítése gyorsabb, mint a tárhely bővítése. A jobb teljesítmény oka, hogy a JVM kupac keverési terének bővítésével a véletlenszerű olvasási blokkolt idő minden egyes feladatnál csökken.

5.2. Összegzés: Melyik a legjobb módszer?

Az átfogó kísérleti eredményekben nincs egyetlen legjobb beállítás az összes munkaterhelés növelésére, mivel ezeknek a terheléseknek mindegyike eltérő tulajdonságokkal rendelkezik, még a munkavégzés során is. Azonban továbbra is javasolhatunk egy elosztott memórián belüli számítási platform konfigurációinak optimalizálását, figyelembe véve a célmunkaterhelések sokféleségét az alábbiak szerint:

• Spark JVM kupac konfiguráció – keverési terület vs. tárolási terület: Négy különböző terhelés kísérleti eredményei alapján megfigyelhetjük a terhelési jellemzők függvényében a teljesítménybeli különbségeket. Például a PageRank tipikus példája a nagy mennyiségű kevert adatnak, így több memória lefoglalása a kevert részhez javítja az általános teljesítményt. A k-means klaszterezés esetén azonban minél többet foglalunk a tárolómemóriára, szemben a kevert memóriával, annál kevesebb végrehajtási időre van szükség. Ezért, ha a JVM memóriafoglalási százalékát dinamikusan be tudjuk állítani a terhelési jellemzőknek megfelelően, optimalizálhatjuk a teljes végrehajtási időt. A Hadoop YARN [25] lehetővé teszi, hogy feladatokat rendeljünk különböző típusú fürtökhöz (konfigurációkhoz), így ezt az ötletet egy nagy méretű Hadoop-fürtre alkalmazhatjuk, hogy megfeleljenek a különféle típusú jobok memóriajellemzőinek.

• RDD gyorsítótárazási szabályzat – memória és SSD: A legtöbb esetben az SSD-vel támogatott memória-gyorsítótár mutatja a legjobb teljesítményt, kivéve, ha az összes RDD elfér a tényleges fő memóriában. Ezért az SSD-vel támogatott memória-gyorsítótárazási házirend életképes választás lehet olyan kihívást jelentő munkaterhelések esetén, amelyek jelentős mennyiségű fő memóriát igényelnek, amelyet a fürt egyetlen csomópontja sem képes kielégíteni.

6. Következtetések

Ebben a cikkben megvizsgáltuk a Spark rendszer teljesítményromlásának főbb tényezőit, amelyek egy áruszerver alapú számítástechnikai fürt tetején futnak, és nincs elegendő főmemóriája. Kísérletezés és elemzés után olyan alternatívákat mutattunk be, amelyek javíthatják az általános teljesítményt.

Java szemétgyűjtésre akkor kerül sor, ha a JVM kupac tárhelye nem elegendő a fizikai memória hiánya miatt. A Java GC arra készteti a feladatokat, hogy megvárják a szemétgyűjtést, így a teljes munkavégzési idő megnő. A keverés akkor fordul elő, ha a JVM kupac keverési területe nem elegendő a keverési fázisban. A véletlenszerű kiszóródás megnöveli a CPU többletterhelését, hogy sorosítást hajtson végre a közbenső keverési adatok lemezre továbbításához a keverési hely hiánya miatt. A TC munkaterhelési kísérletben a véletlenszerű olvasási blokkolt idő arra készteti a feladatot, hogy a keverési hely hiánya miatt a hálózaton keresztüli kevert adatok olvasására várjon. Mindezek a tényezők potenciálisan megnövelhetik a teljes munkavégzési időt, ami súlyosan befolyásolhatja a Spark rendszer teljesítményét.

E problémák megoldása érdekében fürtöt hozunk létre SSD-vel, és külön-külön gyorsítótárazzuk az RDD-t a memóriában és az SSD-n, az SSD használatával kiegészítve a memória tárhelyét. Ezen kívül a JVM kupac konfigurációját is beállítjuk a keverési tér bővítéséhez. Ennek eredményeként 30%-os teljesítménynövekedést érhettünk el a PageRank terhelésnél és 42%-os teljesítménynövekedést a TC munkaterhelésnél. Megállapítottuk, hogy a keverés kiömlése kulcsfontosságú tényező lehet a teljesítmény romlásához, és kísérletekkel kimutattuk, hogy a több iterációból és keverésből álló munkaterheléseknél a keverési tér bővítése jelentős teljesítménynövekedést eredményezhet. Ezenkívül azt találtuk, hogy a feladatok különböző memóriahasználati mintái befolyásolhatják a teljes végrehajtási időt a JVM-ben lévő tárolási/keverési memória százalékos kiosztásától függően. A PageRank és a k-means fürtözés teljesítményelemzése szerint a JVM-ben a terhelési jellemzőkre jól hangolt memóriafoglalás jelentősen megnövelheti a munka befejezési idejét.

Ezeknek az eredményeknek a Spark platformba való integrálása az egyik jövőbeli munkánk lenne. Például, ha a munkaterhelések a kevert adatok mennyiségével jellemezhetők, akkor egy optimalizált konfigurációt automatikusan lehet alkalmazni a célmunkaterhelések feldolgozásának felgyorsítására. Ezért heterogén kiszolgálókonfigurációkban a terhelési memóriahasználat-tudatos ütemezési rendszer fejlesztése javíthatja a Spark-alapú fürt általános teljesítményét.

A szerző hozzájárulásai:

Conceptualization, JL (Jaehwan Lee); módszertan, JL (Jaehwan Lee) és JC; szoftver, JC és JL (Jaehyun Lee); érvényesítés, JC, JL (Jaehyun Lee) és JL (Jaehwan Lee); vizsgálat, JL (Jaehwan Lee) és J.-SK; források, JL (Jaehwan Lee) és J.-SK; adatkezelés, JC és JL (Jaehyun Lee); írás – eredeti tervezet előkészítése, JC és JL (Jaehyun Lee); írás – áttekintés és szerkesztés, JL (Jaehwan Lee) és J.-SK; vizualizáció, JL (Jaehyun Lee); felügyelet, JL (Jaehwan Lee) és J.-SK; projekt adminisztráció, JL (Jaehwan Lee) és J.-SK; finanszírozás megszerzése, JL (Jaehwan Lee). Minden szerző elolvasta és elfogadta a kézirat közzétett változatát.

Finanszírozás:

Ezt a kutatást az Alapvető Tudományos Kutatási Program (NRF-2020R1F1A1072696) támogatta a Koreai Nemzeti Kutatási Alapítványon (NRF) keresztül, amelyet a Tudományos és ICT Minisztérium, Gyeonggi tartomány GRRC programja finanszírozott (GRRC-KAU{). {5}}B01, "Study on the Video and Space Convergence Platform for 360VR Services") és ITRC (Information Technology Research Center) támogatási program (IITP-2021-2018-0-01423).

Az intézményi felülvizsgálati bizottság nyilatkozata:

Nem alkalmazható.

Tájékozott beleegyező nyilatkozat:

Nem alkalmazható.

Adatelérhetőségi nyilatkozat:

Elérhető kérésre.

Összeférhetetlenség:

A szerzők nem nyilatkoznak összeférhetetlenségről.

Hivatkozások

1. Dean, J.; Ghemawat, S. MapReduce: Egyszerűsített adatfeldolgozás nagy klasztereken. Commun. ACM 2008, 51, 107–113. [CrossRef]

2. Az Apache Hadoop Project: Nyílt forráskódú szoftver a megbízható, skálázható, elosztott számítástechnikához. Elérhető online: https: //hadoop.apache.org/ (Hozzáférés: 2021. szeptember 10.).

3. Shvachko, K.; Kuang, H.; Radia, S.; Chansler, R. A Hadoop elosztott fájlrendszer. In Proceedings of the 2010 IEEE 26. szimpózium a tömegtároló rendszerekről és technológiákról (MSST), Incline Village, NV, USA, 2010. május 3–7.; 1–10.

4. Zaharia, M.; Chowdhury, M.; Franklin, MJ; Shenker, S.; Stoica, I. Spark: Cluster computing munkakészletekkel. HotCloud 2010, 10, 95.

5. Outerhout, K.; Rasti, R.; Ratnasamy, S.; Shenker, S.; Chun, BG Az adatelemzési keretrendszerek teljesítményének megértése. In Proceedings of the 12th USENIX Symposium on Networked Systems Design and Implementation (NSDI), Oakland, CA, USA, 2015. május 4–6.; 293–307.

6. Xing, W.; Ghorbani, A. Súlyozott PageRank algoritmus. In Proceedings of the IEEE Second Annual Conference on Communication Networks and Services Research, Fredericton, NB, Kanada, 2004. május 21.; 305–314.

7. Chakradhar, ST; Agrawal, VD; Rothweiler, SG Egy tranzitív zárási algoritmus tesztgeneráláshoz. IEEE Trans. Comput.-Aided Des. Integr. Áramkörök Syst. 1993, 12, 1015–1028. [CrossRef]

8. O'Malley, O. Terabyte Rendezés Apache Hadoop-on. Jehu. 2008. május 1–3. Elérhető online: http://sortbenchmark.org/ YahooHadoop.pdf (Hozzáférés: 2021. szeptember 10.).

9. K-Means klaszterezés. Elérhető online: https://en.wikipedia.org/wiki/K-means_clustering (Hozzáférés: 2021. szeptember 10.).

10. Zaharia, M.; Chowdhury, M.; Das, T.; Dave, A.; Ma, J.; McCauly, M.; Franklin, MJ; Shenker, S.; Stoica, I. Rugalmas elosztott adatkészletek: Hibatűrő absztrakció a memórián belüli fürtszámításhoz. In Proceedings of the 9th USENIX Symposium on Networked Systems Design and Implementation (NSDI), San Jose, CA, USA, 2012. április 25–27.; 15–28.

11. Davidson, A.; Vagy: A. Shuffle teljesítmény optimalizálása a Sparkban; Technikai jelentés; Berkeley – Villamosmérnöki és Számítástechnikai Tanszék, Kaliforniai Egyetem: Berkeley, CA, USA, 2013.

12. Nicolae, B.; Costa, CHA; Misale, C.; Katrinis, K.; Park, Y. Az adaptív I/O felhasználása a kollektív adatkeverési minták optimalizálására a Big Data Analytics számára. IEEE Trans. Párhuzamos disztrib. Syst. 2017, 28, 1663–1674. [CrossRef]

13. Zhang, H.; Cho, B.; Seyfe, E.; Ching, A.; Freedman, MJ Riffle: Optimalizált Shuffle szolgáltatás nagyléptékű adatelemzésekhez. In Proceedings of the Thirteenth EuroSys Conference; EuroSys '18; Association for Computing Machinery: New York, NY, USA, 2018. [CrossRef]

For more information:1950477648nn@gmail.com