स्पार्क क्लस्टर पर "लोकैलिटी लेवल" का क्या अर्थ है

Question

शीर्षक "लोकैलिटी लेवल" और 5 स्टेटस डेटा स्थानीय -> प्रक्रिया स्थानीय -> नोड लोकल -> रैक लोकल -> कोई भी ?

Answer 1

इलाके स्तर के रूप में तक मुझे पता है इंगित करता है डेटा तक पहुँच के प्रकार का प्रदर्शन किया गया है। जब कोई नोड अपना पूरा काम खत्म कर देता है और उसका सीपीयू निष्क्रिय हो जाता है, तो स्पार्क अन्य लंबित कार्य शुरू करने का निर्णय ले सकता है जिसके लिए अन्य स्थानों से डेटा प्राप्त करने की आवश्यकता होती है। तो आदर्श रूप से, आपके सभी कार्यों को स्थानीय प्रक्रिया की जानी चाहिए क्योंकि यह निम्न डेटा पहुंच विलंबता से जुड़ा हुआ है।

आप का उपयोग अन्य इलाके के स्तर में जाने से पहले प्रतीक्षा समय कॉन्फ़िगर कर सकते हैं:

spark.locality.wait 

अधिक मापदंडों के बारे में जानकारी करने के लिए विभिन्न स्तरों Spark Configuration docs

में पाया जा सकता सम्मान के साथ PROCESS_LOCAL, NODE_LOCAL, RACK_LOCAL, या कोई भी मुझे लगता है कि विधियां findTask और ढूंढें स्पेक्ट्रमेटिव टास्कorg.apache.spark.scheduler.TaskSetManager हो डब्ल्यू स्पार्क अपने इलाके के स्तर के आधार पर कार्यों का चयन करता है। यह पहले PROCESS_LOCAL कार्यों की जांच करेगा जो एक ही निष्पादक प्रक्रिया में लॉन्च होने जा रहे हैं। यदि नहीं, तो यह NODE_LOCAL कार्यों की जांच करेगा जो एक ही नोड में अन्य निष्पादकों में हो सकते हैं या इसे एचडीएफएस, कैश आदि जैसे सिस्टम से पुनर्प्राप्त करने की आवश्यकता है। RACK_LOCAL का अर्थ है कि डेटा किसी अन्य नोड में है और इसलिए इसे पहले स्थानांतरित करने की आवश्यकता है निष्पादन। और आखिरकार, कोई भी मौजूदा लंबित कार्य में चलने वाले लंबित कार्य को लेने के लिए है।

/** 
    * Dequeue a pending task for a given node and return its index and locality level. 
    * Only search for tasks matching the given locality constraint. 
    */ 
    private def findTask(execId: String, host: String, locality: TaskLocality.Value) 
    : Option[(Int, TaskLocality.Value)] = 
    { 
    for (index <- findTaskFromList(execId, getPendingTasksForExecutor(execId))) { 
     return Some((index, TaskLocality.PROCESS_LOCAL)) 
    } 

    if (TaskLocality.isAllowed(locality, TaskLocality.NODE_LOCAL)) { 
     for (index <- findTaskFromList(execId, getPendingTasksForHost(host))) { 
     return Some((index, TaskLocality.NODE_LOCAL)) 
     } 
    } 

    if (TaskLocality.isAllowed(locality, TaskLocality.RACK_LOCAL)) { 
     for { 
     rack <- sched.getRackForHost(host) 
     index <- findTaskFromList(execId, getPendingTasksForRack(rack)) 
     } { 
     return Some((index, TaskLocality.RACK_LOCAL)) 
     } 
    } 

    // Look for no-pref tasks after rack-local tasks since they can run anywhere. 
    for (index <- findTaskFromList(execId, pendingTasksWithNoPrefs)) { 
     return Some((index, TaskLocality.PROCESS_LOCAL)) 
    } 

    if (TaskLocality.isAllowed(locality, TaskLocality.ANY)) { 
     for (index <- findTaskFromList(execId, allPendingTasks)) { 
     return Some((index, TaskLocality.ANY)) 
     } 
    } 

    // Finally, if all else has failed, find a speculative task 
    findSpeculativeTask(execId, host, locality) 
    }