გიოლეკვა

წინა პოსტში Google-ის ფაილური სისტემა ავღწერე თუ როგორ ახერხებს Google დიდი ზომის მონაცემების შენახვას DFS-ის (Distributed File System) გამოყენებით. ცხადია ამ მონაცემებს ანალიზის ჩატარება სჭირდება, რაც თავისხმრივ გარკვეულ პრობლემებთან არის დაკავშირებული. განვიხილოთ მონაცემების დამუშავების პრიმიტიული ვარიანტი და ვეცადოთ მის გაუმჯობესებას, რაც მიგვიყვნას MapReduce-ამდე:

მარტივი ვარიანტი:

• ვხსნით ფაილს
• ნაბიჯ-ნაბიჯ ვკითხულობთ მონაცემებს
• ვაანალიზებთ თითოეულ წაკითხულ მონაცემს
• შედეგს ვწერთ გამომავალ ფაილში

ეს მიდგომა იწვევს რამოდენიმე პრობლემას:

• საკმაოდ ნელი პროცესია უზარმაზარი ზომის (ტერაბაიტები) ინფორმაციის ერთ ნაკადის გამოყენებით დამუშავება.
• იმის გამო რომ ინფორმაციას ამუშავებს მხოლოდ ერთ სერვერზე გაშვებული ერთი აპლიკაცია, სერვერის გადატვირთვის/გაფუჭების ან აპლიკაციაში მომხდარი შეცდომის გამო შეიძლება მთელი ინფორმაცია დავკარგოთ, რაც იმას ნიშნავს რომ მონაცემების ანალიზი უნდა დავიწყოთ თავიდან.
• იმის გამო რომ ფაილის ზომა საკმაოდ დიდია და განაწილებულია მთელს ქსელში, უნდა მოხდეს მისი წამოღება სხვადასხვა სერვერებიდან. რაც საკმაოდ ნელია და შეიძლება ქსელის გადატვირთვაც გამოიწვიოს.

პირველი პრობლემა შეიძლება გადაიჭრას იმით, რომ ერთი ნაკადის მაგივრად გამოვიყენოთ მრავალ ნაკადური მიდგომა და პარალელურად ვაწარმოოთ სამუშაო. თუმცა ეს თავის მხრივ საკმაოდ ბევრ პრობლემასთან და თავის ტკივილთან არის დაკავშირებული. საჭიროა ნაკადების კონტროლი და რომელიმეს შეცდომით დასრულების შემთხვევაში ის სამუშაო რომელიც მას უნდა შეესრულებინა სხვა ახალ ნაკადს უნდა გავაკეთებინოთ. საბოლოოდ კი ყველა ნაკადიდან დაბრუნებული შედეგი უნდა შევკრიბოთ, დალაგებული სახე მივცეთ და სადმე შევინახოთ. ამ ყველაფრის ჩვენით კეთება კი საკმაოდ რთულია, საჭიროა მისი ავტომატიზირება.

რათმქუნდა თუ პირველ პრობლემას წარმატებით გადავჭრით აპლიკაციის მუშაობის დრო შემცირდება, თუმცა მონაცემების ზომის გათვალისწინებით ეს გაუმჯობესება შეუმჩნეველი იქნება.

პირველი პრობლემის გადაჭრით მივედით იმ დასკვნამდე, რომ საჭიროა რამოდენიმე ერთმანეთისგან დამოუკიდებელი პროცესი რომლებიც დაამუშავებენ მითითებულ ინფორმაციას. წარმოვიდგინოთ რომ ეს პროცესები გაშვებული გვაქვს არა ერთ სერვერზე არამედ განაწილებული გვაქვს რამოდენიმე სერვერზე ერთდროულად. სერვერების რაოდენობის ზრდასთან ერთად პროპორციულად მცირდება ინფორმაციის დამუშავებისთვის საჭირო დრო. ამასთანავე თუ რომელიმე სერვერი/პროცესი გაითიშა ის არ ეხება სხვებს, რაც იმას ნიშნავს რომ უკვე დამუშავებული ინფორმაცია მთლიანად არ გვეკარგება, იკარგება მისი მხოლოდ მცირე ნაწილი რომლის დამუშავებაც რათქმაუნდა სხვა პროცესს უნდა დავავალოთ და თან ეს ყველაფერი ავტომატურად უნდა მოხდეს.

ამ მიდგომით გადავჭერით მეორე პრობლემაც, თუმცა გადაუჭრელი გვრჩება ქსელში ინფორმაციის გაცვლასთან დაკავშირებული პრობლემა. აქამდე ჩვენ ინფორმაცია მოგვქონდა აპლიკაციასთან ქსელის გამოყენებით, გაცილებით სწრაფი იქნება რომ აპლიკაცია გადავიტანოთ იმ სერვერებზე სადაც ინფორმაცია ინახება და იქვე მოვახდინოთ მისი დამუშავება. ამ შემთხვევაში ქსელში უზარმაზარი რაოდენობით ინფორმაციის გაცვლას ავირიდებთ თავიდან.

MapReduce აკეთებს ამ ყველაფრის ავტომატიზირებას, ის სრულდება ორ ფაზად. ჩვენ მოგვეთხოვება დავწეროთ ორი Map და Reduce ფუნქცია, რომლებიც შესაბამისად პირველ და მეორე ფაზებში იღებენ მონაწილეობას:

• Map: გადაეცემა ორი პარამეტრი: გასაღები და მნიშვნელობა (key/value), ხოლო უნდა დააბრუნოს მასივი ახალი გასაღები/მნიშვნელობა წყვილებისა.
• Reduce: მასაც გადაეცემა ორი პარამეტრი: გასაღები და მასივი რომელიც შეიცავს მითითებულ გასაღებთან დაკავშირებულ ყველა მნიშვნელობას, რომლებიც წინა ფაზაში დააბრუნეს map ფუნქციებმა. მან უნდა დააბრუნოს მხოლოდ ერთი მნიშვნელობა რომელიც ასოცირდება მის გასაღებთან.

ამ ორი ფუნქციისთვის მიწოდება, საბოლოოდ reduce ფუნქციებიდან დაბრუნებული შედეგების key-ის მიხედვით სორტირება და ფაილში ჩაწერა ავტომატურად ხდება.

კიდევ ერთხელ ჩამოვთვლის MapReduce-ის ეფექტურობის მიზეზებს:

• აპლიკაციის გადატანა ინფორმაციასთან და არა პირიქით
• გაუთვალისწინებელი შემთხვევების დროს გამოწვეული შეცდომების ავტომატურად აღმოფხვრა
• სამუშაოს გადანაწილება ათობით ათას კომპიუტერზე, რაც წარმოუდგენელ წარმადობას გვაძლევს
• და რათქმაუნდა ამ ყველაფრის ავტომატიზირება

განვიხილოთ ასეთი ამოცანა, დავითვალოთ თითოეული სიტყვა თუ რამდენჯერ გვხვდება ფაილში: ფსევდო კოდი

map(key, line):
for each word in line:
emit(word, 1)
reduce(key, intermediateValues):
count = 0
for each value in intermediateValues:
count += value
emit(key, value)

სამწუხაროდ მე პირადად არ მქონია ასეთ სისტემასთან შეხება და უფრო დეტალურად აღწერა მიჭირს, თუმცა ზოგადი წარმოდეგნა შეგექმნებოდათ MapReduce-ის შესახებ . დაწვრილებით შეგიძლიათ წაიკითხოთ Google-ის გამოქვეყნებულ სტატიაში: Google MapReduce

P.S. შთაბიჭდილება მრჩება რომ საკმაოდ ცოტა ინფორმაცია მოგაწოდეთ , კომენტარებში გაამდიდრეთ საინტერესო მასალებით მეც უფრო მეტს გავიგებ.