Техники за оптимизация за разпределена изчислителна платформа в паметта чрез използване на SSD, част 2

3.1. Клъстерна среда

Фигура 1 показва нашия тестов клъстер, състоящ се от един възел с име (главен) и четири възела с данни (подчинени). В възела на име (главен) конфигурирахме NameNode и Secondary NameNode на Hadoop (HDFS) и Driver Node (главен възел) на Spark. Във всеки възел за данни изпълняваме DataNode на Hadoop (HDFS) и Worker Node на Spark. Машините с възел за име и възел за данни имат едни и същи H/W среди (3,4 GHz Xeon E3-1240V3 QuadCore процесор с хипер-нишки), с изключение на количеството основна памет (8 GB за възела за име и 4 GB за всеки възел с данни).

Namename е главният възел в архитектурата на Hadoop, отговорен за управлението и наблюдението на файловата система на целия клъстер Hadoop. Възелът Namename също е един от критичните възли на целия клъстер Hadoop и неговата производителност и надеждност ще повлияят пряко върху оперативната ефективност и наличността на целия клъстер Hadoop.

Има много индикатори, свързани с възела Namename, един от най-важните индикатори е паметта. Възелът Namename изисква много памет за съхраняване и управление на пространството от имена на цялата файлова система HDFS, което включва информация за метаданни на файлове и директории, като имена на файлове, разрешения, времеви клейма, размери на файлове и т.н.

Паметта на възела Namename не само определя броя на файловете, които може да управлява, и размера на файловата система, но също така влияе върху производителността и надеждността на Hadoop клъстера. Ако възелът Namename няма достатъчно памет, той няма да може да отговаря бързо на клиентски заявки, което води до намалена пропускателна способност на целия Hadoop клъстер. Освен това, ако възелът Namename се повреди, информацията за метаданните, която съхранява, може да бъде загубена, което прави цялата HDFS файлова система недостъпна.

Следователно в клъстера Hadoop паметта на възела Namename е от решаващо значение. Препоръчително е администраторите да изберат подходящата хардуерна конфигурация на възел Namename въз основа на конкретни бизнес нужди и редовно да наблюдават производителността и наличността на възлите Namename, за да гарантират, че могат да предоставят ефективни и надеждни услуги за целия Hadoop клъстер. Вижда се, че трябва да подобрим паметта си. Cistanche може значително да подобри паметта, тъй като месната паста е традиционен китайски лечебен материал с много уникални ефекти, един от които е подобряване на паметта. Ефикасността на мляното месо идва от различни активни съставки, включително карбоксилна киселина, полизахариди, флавоноиди и др. Тези съставки могат да стимулират здравето на мозъка по различни канали.

Щракнете върху познайте добавките за увеличаване на паметта

Използвахме два SSD като места за съхранение, където 120 GB SATA3 SSD се използва за операционната система и 512 GB SATA3 SSD е оборудван съответно за HDFS. В допълнение, 512 GB SATA3 SSD може ефективно да се използва за разширяване на честотната лента на недостатъчна основна памет за кеширане на RDD на Spark. Всички възли, включително възелът за име и възелът за данни, са свързани с 1 Gb Ethernet комутатор, както се вижда на Фигура 1. Таблица 2 показва обобщението на хардуерните и софтуерните конфигурации във всеки възел за данни на нашия тестов клъстер.

3.2. Spark JVM Heap

Задача на Spark се изпълнява като Java процес на Java Virtual Machine (JVM), а Spark използва Scala, функционален език, разширен от Java. Работният процес на Spark също се изпълнява на JVM на всеки възел с данни, така че на всеки възел с данни работният процес има JVM купчината в основната памет, както е показано на Фигура 2. Когато Spark подаде задание, работният процес, който има купчината JVM изпълнява заданието като разпределени задачи.

Можем да персонализираме съотношението на размера на JVM купчината на Spark worker чрез конфигурационния файл spark-defaults. conf в директорията spark/conf/. Във файла spark defaults.conf стойността на spark.executor.memory е размерът на купчината на JVM, където по подразбиране е 512 MB, който всеки работен възел може да използва във възела за данни. В допълнение, стойността на spark.storage.safetyFraction е фиксирана като 0.9, което означава, че Spark може да използва до 90% от размера на купчината на JVM (известен също като безопасна зона). Това е за предотвратяване на JVM от генериране на OOM (изчерпана памет) грешки поради липса на налична основна памет по време на обработката на задачата.

В тази зона за безопасност общото пространство на JVM heap е разделено на три подрегиона: пространства за разгъване, съхранение и разбъркване, както е показано на фигура 2. Пространството за разгъване се използва за разгъване на блокове данни в паметта. Когато RDD се кешира на друг носител за съхранение, като SSD или HDD, а не в основната памет, RDD трябва да бъде сериализиран. След това, когато Spark прочете този RDD обратно в паметта, RDD трябва да се развие. Мястото за съхранение се използва за кеширане на RDD. Ако пространството за съхранение не е достатъчно за кеширане на RDD, някои RDD могат да бъдат извадени от това пространство въз основа на политиката за LRU (най-малко използвано наскоро) или могат да бъдат кеширани на друг носител за съхранение, като например SSD. Пространството за разбъркване се използва за разбъркване на междинните данни. Това пространство за разбъркване може да играе важна роля в итеративни приложения като машинно обучение, тъй като може значително да повлияе на общото време за завършване на работата.

В конфигурацията на Spark по подразбиране, пространствата за съхранение и разбъркване на JVM купчината имат съотношения на фракция на капацитета съответно {{0}}.6 и 0.2 (т.е. 60 % от безопасната зона за съхранение и 20% за разбъркване). Пространството за разгъване заема 20% от пространството за съхранение по подразбиране. Капацитетът на тези три пространства на JVM купчината може да бъде зададен чрез искра. storage.unrollFraction, spark.storage.memoryFraction и spark.shuffle.memoryFraction. Например в нашия тестов клъстер можем да зададем spark.executor.memory като 2,6 GB от 4 GB памет на работния възел, което означава, че размерът на купчината на JVM е зададен на максимум 2,6 GB. Тогава действителният капацитет на пространството за съхранение и пространството за разбъркване е 2,6 GB × 0.9 × 0.6 = 1.4 GB и 2,6 GB × 0,9 × 0.2=0.46 GB, съответно. Съответно пространството за разгръщане отнема 1,4 GB × 0.2=0.28 GB.

3.3. Правила за кеширане на RDD

Платформата Spark предлага различни опции за RDD кеширане, включващи основна памет и дискове. Опцията по подразбиране е САМО ПАМЕТ_, където RDD се поддържа в пространството за съхранение, описано в раздел 3.2, като несериализиран Java обект. Ако това пространство за съхранение е недостатъчно за съхраняване на всички RDD, някои от тях ще бъдат извадени от основната памет въз основа на предварително дефинирана политика за замяна на кеша. Въпреки това, когато се изисква некеширана RDD за обработка на задача, тази RDD трябва да бъде създадена отново въз основа на информацията за произхода, което може да доведе до значително влошаване на производителността в тази политика за кеширане САМО ЗА ПАМЕТ.

Освен опцията САМО ПАМЕТ_Spark предоставя алтернативни опции ПАМЕТ_И_ДИСК, САМО ДИСК_и ИЗКЛ._HEAP. Опцията MEMORY_AND_DISK съхранява RDD в енергонезависимия диск, когато мястото за съхранение не е достатъчно за съхраняване на всички необходими RDD. Дисковете могат да се състоят от HDD или SSD; обаче, нормалните шпинделни дискове имат относително ниска пропускателна способност за четене/запис, така че общото време за изпълнение може да бъде по-дълго от това на опцията за кеширане САМО ПАМЕТ_. За да се справим с този проблем, можем ефективно да използваме SSD, което потенциално може да намали общото време за изпълнение на заданието в сравнение с нормалния подход, базиран на HDD.

Опцията DISK{0}}ONLY съхранява RDD само в енергонезависими устройства за съхранение като HDD или SSD, т.е. не в основната памет. Клъстер, който няма достатъчно налична памет, може да постигне добра производителност с тази опция. В този случай, тъй като RDD се съхранява само на дисков носител, пространството за разбъркване може да бъде разширено, вместо да се използва пространството за съхранение на паметта. В резултат на това, когато изпълняваме приложение като PageRank, което генерира сравнително голямо количество данни за разбъркване, можем да наблюдаваме по-добра производителност, отколкото в случая САМО ПАМЕТ_.

Опцията OFF_HEAP позволява на Spark да използва пространство извън купчината, което е извън управлението на събирача на отпадъци на Java. По този начин, ако използваме пространство извън купчината, трябва да се справим със сложни операции с паметта като разпределяне/освобождаване и сериализация/десериализация. Следователно, за практически цели, ние не използваме конфигурацията OFF_HEAP.

3.4. Методика за оптимизация

Както обсъдихме в раздели 3.2 и 3.3, нашите методи за оптимизация включват (1) конфигурацията на купчината JVM на Spark и (2) експерименталните опции на политиката за кеширане на RDD, както следва:

1. Spark JVM heap конфигурация: Изследвахме ефектите от промяната на съотношенията на фракцията на капацитета на разбъркването и пространствата за съхранение. Съотношението между пространството за разбъркване и съхранение е съответно 60%:30%, 50%:40% и 20%:60%. Съотношението на разбъркване и съхранение "20%:60%" е стойността по подразбиране в настройката на Spark. Избираме „60%:30%“, за да контрастираме резултата с достатъчно пространство за разбъркване и конфигурираме „50%:40%“, за да покажем производителността по балансиран начин.

2. RDD политика за кеширане: Ние също така проучихме ефектите от различни RDD политики за кеширане. Сравнихме ефективността на различни правила като OFF_HEAP, MEMORY_ONLY, MEMORY_AND_DISK и DISK_ONLY, където DISK обозначава SSD в този експеримент.

Таблица 3 показва общо 12 различни експериментални конфигурации, базирани на правилата за кеширане на RDD и коефициентите на дял на капацитета на Spark JVM. В конфигурациите на експеримента, означени с „_1“ (например „N_1“), задаваме 60% от купчината JVM на Spark за разбъркване и 30% за пространства за съхранение. С тези, означени с „_2“, задаваме 50% от купчината JVM на Spark за разбъркване и 40% за съхранение. И накрая, за тези, обозначени с „_3“, задаваме 20% от купчината JVM на Spark за разбъркване и 60% за съхранение, както може да се види от колоните „Опция“, „Разбъркване“ и „Съхранение“. в таблица 3. Обърнете внимание, че максималният размер на паметта на нашия тестов клъстер на изпълнителя е 2,7 GB, т.е. всеки работен възел има 2,7 GB като размер на купчината на Spark JVM.

От гледна точка на политиката за кеширане на RDD, опцията „N“ не е да кешира RDD, опцията „M“ е да кешира RDD само в паметта, опцията „M&S“ е да кешира RDD в паметта и SSD заедно, и накрая, опцията "S" е за кеширане на RDD само на SSD.

Чрез нашите експерименти ние предлагаме стратегии за оптимизиране, които могат да постигнат най-добра производителност от клъстера, който няма достатъчно памет, чрез внимателно коригиране на конфигурацията на купчината на Spark JVM и използване на ефективна политика за кеширане на RDD, както ще видим в Раздел 4.

4. Експериментални резултати и анализ

4.1. 500 MB PageRank експерименти

4.1.1. Резултати с промяна на конфигурациите на JVM Heap

Фигура 3 показва експерименталните резултати от всеки етап от работното натоварване на PageRank чрез промяна на размерите на купчината на JVM. В етапа Distinct Spark чете входните данни и разграничава URL адреса и връзките. Както можем да видим от резултатите от етапа Distinct0, общото време за изпълнение намалява чрез промяна на размерите на купчината на JVM от _1 и _2 на _3 опции, главно поради към събирането на боклука (GC). Например GC времето отнема съответно 25 s, 24 s и 16 s в M&S_1, M&S_2 и M&S{{10}}. Следователно, в етапа Distinct0, докато увеличаваме обема на пространството за съхранение, можем да подобрим цялостната производителност, като намалим времето за GC. От друга страна, в етапа Distinct1 общото време за изпълнение се увеличава, когато променим опциите от _1 и _2 на _3. Това се дължи главно на разливането при разбъркване. Когато проверихме уеб интерфейса на Spark, данните за разбъркване бяха прехвърлени на диска поради липса на място в паметта за разбъркване. Например, размерите на данните за разбъркване на диска в M&S_1, M&S_2 и M&S_3 са съответно 0, 220 MB и 376 MB. Когато възникне разбъркване, режийните разходи на процесора за прехвърляне на данните върху диска се увеличават, тъй като данните трябва да бъдат сериализирани.

След отделните етапи има итеративни етапи на flatMap за получаване на рангове. Етапите на FlatMap генерират много данни за разбъркване, което може да накара нашия клъстер да няма необходимото пространство в паметта за разбъркване. Следователно, тъй като наличното пространство за разбъркване намалява (по ред от опции _1, _2 и _3), може да възникне по-голямо разливане на разбъркване, което потенциално може да повлияе на цялостното изпълнение на заданието време (напр. M&S опция flatMap2 етап _1: 37 s, _2: 40 s, _3: 49 s). Въпреки това, когато данните се кешират само в паметта (т.е. M_1, M_2 и M_3), те показват друг модел. Основната причина за това поведение е, че планировчикът на Spark планира задачите неравномерно, защото липсва място за съхранение на паметта за кеширане на RDD на опции _1 и _2. Ако даден работник няма RDD, той се изключва от групата за планиране. Следователно другите работници трябва да се справят с допълнителни задачи с режийни GC, които могат да повлияят на цялото време за изпълнение на заданието.

4.1.2. Резултати с промяна на опциите за кеширане на RDD

Първо, различните етапи не се влияят от промяна на правилата за кеширане на RDD, а само от използването на паметта. Етапите, които са засегнати от опцията за кеширане на RDD, са етапи на flatMap, тъй като по време на фазата на разбъркване отново се използват кеширани RDD.

На фигура 4 графиката е нормализирана от опцията N_1, която не кешира RDD и конфигурацията на паметта _1, за да провери разликата в производителността. При сравняване само на графиките на _1, в реда на M_1, M&S_1 и S_1, има 32% влошаване на производителността в M{{8 }} и 30% и 20% подобрения на производителността съответно с M&S_1 и S_1. С опцията M_1 причината за относително слабата производителност е, че RDD се кешират неравномерно поради липсата на място за съхранение, което ще доведе до неравномерно планиране, както споменахме по-рано. Това означава, че JVM heap пространството е недостатъчно за разбъркване на данните и запазване на RDD.

За да се справим с този проблем, ние разпространяваме RDD в кеша както в паметта, така и в SSD, което може да подобри производителността, както е показано с опцията M&S_1. Кеширането на RDD в паметта подобрява скоростта на достъп за RDD, а кеширането на RDD на SSD може да избегне разпръскването чрез ефективно разширяване на наличното пространство за разбъркване в паметта. С опцията S_1, която показа 20% подобрение на производителността, RDD се кешира само на SSD. Разливането при разбъркване се намалява чрез кеширане на RDD на SSD. Той обаче постигна по-ниско подобрение на производителността от M&S_1, където RDD се кешира главно в паметта и се използва повторно от паметта.

В конфигурацията по подразбиране на Spark, която е опция _3, можем да видим, че в реда на M_3, M&S_3, S_3 и N{{4 }}, общата производителност намалява. В конфигурацията по подразбиране, съхранението на JVM купчината е достатъчно, за да може RDD да бъде кеширан с баланс. Следователно общата производителност зависи главно от производителността на използваното устройство с памет. Въпреки това, все още можем да видим най-добрата производителност с опцията M&S_1, тъй като можем ефективно да намалим времето за GC и разбъркването чрез кеширане на RDD както в паметта, така и в SSD.

4.2. 1 GB PageRank ефективност

Експериментирахме с натоварването на PageRank, като увеличихме размера на данните от 500 MB на 1 GB. Фигура 5 показва различните поведения на системата в сравнение с PageRank за набора от данни от 500 MB. Можем да видим някои неуспешни задания, които не успяха да завършат заданието до етап take6 (напр. N_1, N_2, M_1, M_2, M _3, M&S_3). Сред тези неуспешни задачи има такива, които са се провалили в етапа flatMap2, които са N_1, N_2 и M_1. Причината за неуспешната работа е липсата на памет за съхранение. GC възниква, когато RDD се кешира при недостатъчна памет. Поради това натоварване на GC, изпълнителят на Spark получава изключение ExecutorLostFailure.

M_2, M_3 и M&S_3 могат да продължат с обработката до етапа flatMap2; след това обаче настъпва повреда. M&S_3 работи подобно на M_3 до етапа flatMap2, защото когато се използва опцията M&S_3, има достатъчно памет за кеширане на RDD. След flatMap2 грешката OutOfMemory възниква поради липсата на място в паметта за разбъркване в етапа flatMap3.

4.2.1. Резултати с промяна на конфигурацията на JVM Heap

Етапът Distinct0 показва много подобни резултати на набора от данни от 500 MB и цялостната производителност се подобрява в реда на опциите _1, _2 и _3. Това е така, защото GC времето е намалено съответно до 78 s, 59 s и 28 s

От друга страна, в етапа Distinct1 той показа различни резултати за набора от данни от 500 MB. В експеримента с набор от данни от 500 MB можем да видим увеличението на производителността чрез увеличаване на пространството на паметта за разбъркване. Въпреки това, в експеримента с набор от данни от 1 GB, паметта на изпълнителя на работния възел не може да поеме големия размер на данните. Следователно пространството на паметта за разбъркване става относително недостатъчно. Например, количествата на разбъркване за опциите _1, _2 и _3 са съответно 575,5 MB, 813,8 MB и 843,4 MB, а GC времето отнема 33 s, 10 s и 8 s, съответно. Както споменахме преди, когато възникне разбъркване, RDD трябва да бъде сериализиран, така че изчисленията на процесора да могат да се увеличат, което може да доведе до цялостно влошаване на производителността.

4.2.2. Резултати от промяна на правилата за кеширане на RDD

За анализиране на времето за изпълнение чрез промяна на политиката за кеширане на RDD, както можем да видим от Фигура 6, ние изключваме различни етапи от Фигура 5. Това е така, защото не е необходимо да анализираме различни етапи, тъй като няма промени, причинени от промяна на политиката за кеширане на RDD .

Интересното е, че няма промени с различни JVM конфигурации на купчина в етапите на flatMap, за разлика от случая на набор от данни от 500 MB. Причината за това е, че разбъркването се появява във всички конфигурации, защото няма достатъчно памет. Общото време за изпълнение чрез промяна на опцията за кеширане на RDD се увеличава в реда на M&S, S, N и M. (M&S е най-бързата опция.) В опция N грешката ExecutorLostFailure възниква, защото няма достатъчно място в паметта. При опция M, когато RDD се кешира в паметта, възниква GC overhead, защото няма достатъчно място в паметта. Дори ако RDD е кеширан в паметта, заданието е неуспешно поради грешката ExecutorLostFailure, която възниква, когато пространството в паметта за разбъркване е недостатъчно (OutOfMemory).

В такива ситуации с ниска налична памет опциите M&S и S могат да бъдат ефективни алтернативи. В опцията M&S{{0}} увеличаваме достъпността на RDD чрез кеширане на RDD, използвайки както паметта, така и SSD. В резултат на това има подобрение на производителността по същата причина като набора от данни от 500 MB. Освен това има достатъчно място в паметта за разбъркване поради кеширането на RDD на SSD. Както се вижда на фигура 6, опцията M&S_1 става най-бързата опция в този експеримент (M&S_1:0.6, S_1:0.63, T_1 0.64).

4.3. TC Експериментален анализ

Фигура 7 показва резултатите от експерименти с TC (транзитивно затваряне), които използват входните данни, включващи 50,000 ръба и 25,000 върха, генерирани на случаен принцип. Номерът на итерацията е 10. Чрез итерациите броят на задачите се удвоява при всяка итерация и следователно размерът на RDD се увеличава и количествата на разбъркано четене и запис също се увеличават. В последната итерация броят на задачите става 4096. Тъй като има повече етапи на итерация, има по-голям ефект върху общото време за изпълнение на заданието, а последният етап на итерация е най-големият, състоящ се от много задачи, които могат да намалят цялостната производителност .

Както можем да видим от Фигура 7, производителността се подобрява в реда на _3, _2 и _1 на опциите M, M&S и S, което означава, че получаването на достатъчно разбъркване паметта на JVM купчината е полезна. При опцията M производителността на опцията _1 е с 18% по-бърза от опцията _3, докато при опцията M&S производителността на опцията _1 е 3% по-бърза от {{9 }}. В опцията S производителността на _1 е с 2% по-бърза от _3.

Когато се съсредоточим върху промяната на опцията за кеширане на RDD, производителността на опция S_1 е 42% по-бърза от N_1 и също така е 31% по-бърза от M_1. Причината за увеличаването на производителността на времето за изпълнение на заданието зависи от последния етап на итерация. Ключовият фактор, който влияе на последния етап на итерация, е времето, блокирано при четене на разбъркване. Времето за блокиране на разбъркано четене възниква, когато RDD, изпълнен в предишния етап, се чете от друг работен възел през мрежата поради липса на памет на изпълнителя.

Дори ако всяка задача има увеличение на производителността от около 1–2 s чрез решаване на времето за блокиране на разбъркано четене, можем да постигнем значително увеличение на производителността, тъй като в последното състояние броят на задачите е доста голям (т.е. 4096). В допълнение, един от основните фактори, влияещи върху времето за изпълнение на заданието, е етапът на преброяване, който брои колко ребра има TC матрицата при последното задание.

С опция N, тъй като няма кеширани RDD в етапа на преброяване, Spark чете данните за разбъркване, изпълнени от предишния етап, което отнема 60 s. В допълнение, в опция M, RDD не се кешира в паметта поради липсата на памет на изпълнителя. В резултат на това също отнема 60 s. Въпреки това, в опциите M&S и S, RDD може да се кешира в паметта и SSD, така че да отнеме само 2 s в етапа на преброяване.

4.4. Експериментален анализ TeraSort

Фигура 8 показва експерименталните резултати от бенчмарка TeraSort, който използва набор от данни от 10 GB чрез промяна на конфигурацията на JVM heap и опцията за кеширане на RDD. Тази графика е нормализирана от опция N_1. Можем да видим, че всички времена за изпълнение на задания са сходни; разликата между тях е по-малко от 5%. В работното натоварване на TeraSort нямаше подобрения или влошаване на производителността чрез промяна на конфигурациите и опциите. В етапа на сортиране има няколко разбърквания в мрежата. Размерите на разбъркано четене и разбъркано запис обаче са по 25 MB, което е доста малко в сравнение с PageRank и TC. Следователно конфигурацията на купчината на JVM и опцията за кеширане на RDD не влияят на производителността. Освен това работното натоварване на TeraSort не се състои от итеративни задания, както при транзитивното затваряне, така че няма полза от кеширането на RDD в предишния етап.

4.5. K-средно клъстерен експериментален анализ

Нормализираното време за завършване на работата на клъстерирането на k-средни стойности за набор от данни от 1,5 GB е показано на Фигура 9. Целта на клъстерирането на k-средни стойности е да се намерят k клъстерите в набора от данни въз основа на измерването на разстоянието (напр. Евклидово разстояние). При това работно натоварване алгоритъмът намалява SSE (сумата на квадратната грешка) [24] чрез повторение на изчислението на разстоянието между k централните точки и всяка точка от данни. В този експеримент повтаряме този процес осем пъти. Количеството данни за разбъркване е минимално, тъй като необходимите данни от предишния етап са информацията за централните точки и SSE във всеки етап. При нашето работно натоварване на k-означава клъстери, максималното количество данни за разбъркано четене/запис е 1.0 MB, а минималното е 0.8 MB. Разливането при разбъркване не се случва тук, защото пространството за разбъркване е достатъчно при всички настройки. В експериментите без опции за кеширане няма разлика между опциите _1, _2 и _3, тъй като тези настройки не кешират никакви RDD, и в трите настройки разбъркването пространството е достатъчно.

Когато кеширате RDD в основната памет или в паметта и SSD, колкото повече място за съхранение има за RDD, толкова повече се подобрява производителността във времето за изпълнение на задачата, тъй като повече RDD могат да бъдат кеширани в пространството за съхранение. При сравняване на опцията_само памет и опцията_и_SSD, опцията_и_SSD показа по-добро подобрение на производителността. Това е така, защото при опцията_само памет, мястото за съхранение е недостатъчно дори при опцията M_3. В допълнение, кеширането на RDD на SSD решава такава липса на памет за съхранение. Опциите за памет_и_SSD подобриха производителността средно с 10% в сравнение с опцията само_за памет.

Обърнете внимание, че клъстерното натоварване на k-средства показва противоположна тенденция на производителност от работните натоварвания на PageRank и транзитивно затваряне поради разликата в количеството данни за разбъркване. Ще обсъдим това по-подробно в следващия подраздел.

5. Дискусия и обобщение

5.1. Дискусия

Ние анализирахме основните фактори за потенциални проблеми с влошаване на производителността въз основа на характеристиките на работното натоварване и етапите на обработка. Нашите обширни експериментални резултати са обобщени относно прилагането на техниките за оптимизиране на производителността на платформата Spark за различни работни натоварвания, както следва:

• Влошаване на производителността чрез събиране на боклук на Java: В работното натоварване на PageRank с набор от данни от 500 MB и набор от данни от 1GB, GC възниква, когато няма достатъчно място за съхранение на JVM купчината за съхраняване на RDD. В етапа Distinct0, който чете входния файл от HDFS и го кешира в RDD, възниква GC. Ние разширяваме пространството за съхранение на JVM купчината чрез конфигурацията, за да разрешим този проблем с GC. Можем да подобрим производителността, за да намалим GC, защото пространството за съхранение на JVM купчината може да бъде разширено. На фигури 3 и 5, със същата опция за кеширане на RDD, конфигурацията _3 показва най-добра производителност в етапа Distinct0. В допълнение, в PageRank с набор от данни от 1 GB, някои опции се провалят в етапа на flatMap поради липса на памет. GC режийните се увеличават толкова много, че етапът се проваля или преминава в безкраен цикъл. По този начин ние конструираме клъстера със SSD, за да разрешим този проблем. Той показва подобрение на производителността и успява в работата, която е неуспешна, като използва само памет, както се вижда на Фигура 6, M&S_1 и S_1.

• Влошаване на производителността чрез разбъркване: В работното натоварване на PageRank с 500 MB набор от данни и 1 GB набор от данни, в етапа на плоска карта, можем да видим, че опцията M&S_1 показва най-добрата производителност, тъй като има най-малко количество разбъркване разлив (Фигура 4: M&S_1 е 30% по-бърз от N_1; Фигура 6: M&S_1 е 40% по-бърз от N_3). PageRank има много задачи за разбъркване. По този начин, когато пространството за разбъркване на JVM купчината е недостатъчно за разбъркване на данните през мрежата, възниква разбъркване. Следователно, за да се намали разливането на разбъркването, разширяването на пространството за разбъркване на JVM купчината става ключов фактор за подобряване на производителността.

Освен това можем да подобрим производителността, като съхраняваме RDD както в паметта, така и в SSD. Това може да накара изпълнителя да разшири паметта за разбъркване на JVM купчината, за да намали разливането на разбъркването. Ако има повече итерации, производителността от етапа на flatMap ще бъде ключовата точка за подобряване на производителността. В експеримента с набор от данни от 1 GB, времето за изпълнение на заданието на S_3 е най-добрият вариант, тъй като RDD се кешират само на SSD и има достатъчно памет на стека на изпълнителите. По този начин в опцията S_3 различните етапи са по-бързи от всяка друга опция. Въпреки това, ако броят на итерациите се увеличи, етапът на flatMap влияе върху времето за изпълнение на задачата. По този начин опцията M&S_1 може да постигне страхотна производителност в този случай. Чрез тези анализи можем да установим, че разместването има ключов ефект върху времето за завършване на работата. По този начин трябва да разширим паметта за разбъркване на JVM купчината и да кешираме RDD както в паметта, така и в SSD, за да получим достатъчно място в паметта за разбъркване, за да предотвратим разливането на разбъркване.

• Влошаване на производителността поради блокирано време за разбъркване на четене: Има блокирано време за разбъркване на четене в работното натоварване на TC. Това се случва, когато има много задачи в етапа и всяка задача трябва да прочете предишния RDD през мрежата. В резултат на TC експеримента (Фигура 7), опцията M&S е по-бърза от опция M. В същата опция за RDD кеширане разширяването на пространството за разбъркване на JVM купчината е по-бързо от разширяването на пространството за съхранение. Причината за подобрената производителност е, че чрез разширяване на пространството за разбъркване на JVM купчината, времето за блокиране на разбъркване при четене намалява във всяка задача.

5.2. Резюме: Кой е най-добрият начин?

В изчерпателните експериментални резултати няма нито една най-добра настройка за увеличаване на всички работни натоварвания, тъй като всяко от тези работни натоварвания има различни характеристики, дори по време на работа. Все пак можем да предложим как да оптимизираме конфигурациите на разпределена изчислителна платформа в паметта, като вземем предвид разнообразието от целеви натоварвания, както следва:

• Конфигурация на Spark JVM heap—зона за разбъркване спрямо област за съхранение: Според експерименталните резултати от четири различни работни натоварвания, можем да наблюдаваме разликите в производителността в зависимост от характеристиките на работното натоварване. Например PageRank е типичен пример за наличие на голямо количество данни за разбъркване, така че заделянето на повече памет за частта за разбъркване подобрява цялостната производителност. Въпреки това, в случай на k-средно клъстериране, колкото повече заделяме за памет за съхранение, за разлика от паметта за разбъркване, толкова по-малко време за изпълнение е необходимо. Следователно, ако можем да коригираме динамично процента на разпределение на паметта на JVM според характеристиките на работното натоварване, можем да оптимизираме общото време за изпълнение. Hadoop YARN [25] ни позволява да присвояваме задачи на различни типове клъстери (конфигурации), така че да можем да приложим тази идея към голям Hadoop клъстер, за да отговорим на характеристиките на паметта за различни типове задачи.

• Правила за кеширане на RDD—памет срещу SSD: В повечето случаи поддържаното от SSD кеширане на памет показва най-добра производителност, освен ако всички RDD не могат да се поберат в действителната основна памет. Следователно политиката за кеширане на памет, подпомагана от SSD, може да бъде жизнеспособен избор за предизвикателни работни натоварвания, изискващи значителни количества основна памет, които не могат да бъдат покрити от нито един възел в клъстер.

6. Изводи

В тази статия ние проучихме основните фактори за влошаване на производителността на системата Spark, работеща върху базиран на стоков сървър изчислителен клъстер с недостатъчно налични основни памети. След експериментиране и анализ представихме алтернативи, които могат да подобрят цялостната производителност.

Събирането на боклука на Java се случва, когато пространството за съхранение на JVM купчината е недостатъчно поради липса на физическа памет. Java GC кара задачите да чакат за събиране на боклука, така че общото време за завършване на работата се увеличава. Разливането при разбъркване възниква, когато пространството за разбъркване на JVM купчината е недостатъчно по време на фазата на разбъркване. Shuffle spill увеличава натоварването на процесора за извършване на сериализация за разпръскване на междинни данни за разбъркване на диска поради липсата на място за разбъркване. В експеримента с работно натоварване на TC блокираното време за разбъркване на четене кара задачата да чака за четене на данни за разбъркване през мрежата поради липса на място за разбъркване. Всички тези фактори могат потенциално да увеличат общото време за завършване на работата, което може сериозно да повлияе на работата на системата Spark.

За да се справим с тези проблеми, ние създаваме клъстер със SSD и кешираме RDD както в паметта, така и в SSD отделно, като използваме SSD за допълване на пространството за съхранение на паметта. Освен това коригираме конфигурацията на купчината на JVM за разширяване на пространството за разбъркване. В резултат на това бихме могли да постигнем 30% подобрение на производителността за работното натоварване PageRank и 42% подобрение на производителността за работното натоварване на TC. Установихме, че разбъркването може да бъде ключов фактор за влошаване на производителността и показахме чрез експерименти, че при работни натоварвания, състоящи се от няколко итерации и разбъркване, разширяването на пространството за разбъркване може да осигури значителни печалби в производителността. Освен това открихме, че различните модели на използване на паметта на заданията могат да повлияят на общото време за изпълнение в зависимост от процентното разпределение на паметта за съхранение/разбъркване в JVM. Според анализа на ефективността на PageRank и клъстерирането на k-средства, разпределението на паметта в JVM, което е добре настроено към характеристиките на работното натоварване, може значително да подобри времето за завършване на заданието.

Интегрирането на тези открития в платформата Spark ще бъде една от бъдещите ни работи. Например, ако работните натоварвания могат да бъдат характеризирани по отношение на количествата данни за разбъркване, може автоматично да се приложи оптимизирана конфигурация за ускоряване на обработката на целевите работни натоварвания. Следователно, в разнородни сървърни конфигурации, разработването на система за планиране, съобразена с използването на паметта, може да подобри цялостната производителност на базиран на Spark клъстер.

Авторски принос:

Концептуализация, JL (Jaehwan Lee); методология, JL (Jaehwan Lee) и JC; софтуер, JC и JL (Jaehyun Lee); валидиране, JC, JL (Jaehyun Lee) и JL (Jaehwan Lee); разследване, JL (Jaehwan Lee) и J.-SK; ресурси, JL (Jaehwan Lee) и J.-SK; обработка на данни, JC и JL (Jaehyun Lee); писане—подготовка на оригинална чернова, JC и JL (Jaehyun Lee); писане – преглед и редактиране, JL (Jaehwan Lee) и J.-SK; визуализация, JL (Jaehyun Lee); надзор, JL (Jaehwan Lee) и J.-SK; администрация на проекта, JL (Jaehwan Lee) и J.-SK; придобиване на финансиране, JL (Jaehwan Lee). Всички автори са прочели и са съгласни с публикуваната версия на ръкописа.

Финансиране:

Това изследване беше подкрепено от Програмата за основни научни изследвания (NRF-2020R1F1A1072696) чрез Националната изследователска фондация на Корея (NRF), финансирана от Министерството на науката и ИКТ, GRRC програма на провинция Gyeonggi (№ GRRC-KAU{ {5}}B01, „Проучване на платформата за видео и космическа конвергенция за 360VR услуги“) и програмата за поддръжка на ITRC (Център за изследване на информационните технологии) (IITP-2021-2018-0-01423).

Изявление на институционалния съвет за преглед:

Не е приложимо.

Декларация за информирано съгласие:

Не е приложимо.

Декларация за наличност на данни:

Наличен при поискване.

Конфликти на интереси:

Авторите декларират липса на конфликт на интереси.

Препратки

1. Дийн, Дж.; Ghemawat, S. MapReduce: Опростена обработка на данни в големи клъстери. Общ. ACM 2008, 51, 107–113. [CrossRef]

2. Проектът Apache Hadoop: Софтуер с отворен код за надеждни, мащабируеми, разпределени изчисления. Налично онлайн: https: //hadoop.apache.org/ (достъп на 10 септември 2021 г.).

3. Швачко, К.; Куанг, Х.; Радиа, С.; Chansler, R. Разпределената файлова система Hadoop. В сборника от 26-ия симпозиум на IEEE за 2010 г. относно системи и технологии за масово съхранение (MSST), Incline Village, NV, САЩ, 3–7 май 2010 г.; стр. 1–10.

4. Захария, М.; Чоудхури, М.; Франклин, MJ; Шенкер, С.; Stoica, I. Spark: Клъстерно изчисление с работещи набори. HotCloud 2010, 10, 95.

5. Оустърхаут, К.; Расти, Р.; Ratnasamy, S.; Шенкер, С.; Чун, БГ Осмисляне на производителността в рамки за анализ на данни. В сборника от 12-ия симпозиум на USENIX за проектиране и внедряване на мрежови системи (NSDI), Оукланд, Калифорния, САЩ, 4–6 май 2015 г.; стр. 293–307.

6. Xing, W.; Ghorbani, A. Алгоритъм за претеглен PageRank. В сборника на Втората годишна конференция на IEEE за изследване на комуникационни мрежи и услуги, Фредериктън, NB, Канада, 21 май 2004 г.; стр. 305–314.

7. Чакрадхар, ST; Agrawal, VD; Rothweiler, SG Алгоритъм за преходно затваряне за генериране на тестове. IEEE Trans. Comput.-Aided Des. Интегрирайте Вериги Syst. 1993, 12, 1015–1028. [CrossRef]

8. O'Malley, O. Terabyte Sort on Apache Hadoop. Yahoo. май 2008 г. стр. 1–3. Налично онлайн: http://sortbenchmark.org/ YahooHadoop.pdf (достъп на 10 септември 2021 г.).

9. K-средни клъстери. Налично онлайн: https://en.wikipedia.org/wiki/K-means_clustering (достъп на 10 септември 2021 г.).

10. Захария, М.; Чоудхури, М.; Дас, Т.; Дейв, А.; Ма, Дж.; McCauly, M.; Франклин, MJ; Шенкер, С.; Stoica, I. Устойчиви разпределени набори от данни: устойчива на грешки абстракция за клъстерни изчисления в паметта. В сборника от 9-ия симпозиум на USENIX за проектиране и внедряване на мрежови системи (NSDI), Сан Хосе, Калифорния, САЩ, 25–27 април 2012 г.; стр. 15–28.

11. Дейвидсън, А.; Или, A. Оптимизиране на производителността на разбъркване в Spark; Технически доклад; Катедра по електротехника и компютърни науки в Бъркли, Калифорнийски университет: Бъркли, Калифорния, САЩ, 2013 г.

12. Николае, Б.; Коста, CHA; Misale, C.; Катринис, К.; Park, Y. Използване на адаптивен I/O за оптимизиране на шаблони за разбъркване на колективни данни за анализ на големи данни. IEEE Trans. Паралелно разпределение Syst. 2017, 28, 1663–1674. [CrossRef]

13. Джан, Х.; Чо, Б.; Сейф, Е.; Чинг, А.; Freedman, MJ Riffle: Оптимизирана услуга за разбъркване за широкомащабни анализи на данни. В Доклади от Тринадесетата конференция на EuroSys; ЕвроСис '18; Асоциация за компютърни машини: Ню Йорк, Ню Йорк, САЩ, 2018 г. [CrossRef]

For more information:1950477648nn@gmail.com