स्पार्क java.lang.OutOfMemoryError: जावा हीप स्पेस

228

मेरा क्लस्टर: 1 मास्टर, 11 दास, प्रत्येक नोड में 6 जीबी मेमोरी है।

मेरी सेटिंग्स:

spark.executor.memory=4g, Dspark.akka.frameSize=512

यहाँ समस्या है:

सबसे पहले , मैंने एचडीएफएस से आरडीडी के लिए कुछ डेटा (2.19 जीबी) पढ़ा:

val imageBundleRDD = sc.newAPIHadoopFile(...)

दूसरा , इस RDD पर कुछ करें:

val res = imageBundleRDD.map(data => {
                               val desPoints = threeDReconstruction(data._2, bg)
                                 (data._1, desPoints)
                             })

अंतिम , एचडीएफएस के लिए आउटपुट:

res.saveAsNewAPIHadoopFile(...)

जब मैं अपना कार्यक्रम चलाता हूं तो यह पता चलता है:

.....
14/01/15 21:42:27 INFO cluster.ClusterTaskSetManager: Starting task 1.0:24 as TID 33 on executor 9: Salve7.Hadoop (NODE_LOCAL)
14/01/15 21:42:27 INFO cluster.ClusterTaskSetManager: Serialized task 1.0:24 as 30618515 bytes in 210 ms
14/01/15 21:42:27 INFO cluster.ClusterTaskSetManager: Starting task 1.0:36 as TID 34 on executor 2: Salve11.Hadoop (NODE_LOCAL)
14/01/15 21:42:28 INFO cluster.ClusterTaskSetManager: Serialized task 1.0:36 as 30618515 bytes in 449 ms
14/01/15 21:42:28 INFO cluster.ClusterTaskSetManager: Starting task 1.0:32 as TID 35 on executor 7: Salve4.Hadoop (NODE_LOCAL)
Uncaught error from thread [spark-akka.actor.default-dispatcher-3] shutting down JVM since 'akka.jvm-exit-on-fatal-error' is enabled for ActorSystem[spark]
java.lang.OutOfMemoryError: Java heap space

बहुत सारे कार्य हैं?

पुनश्च : हर चीज ठीक है जब इनपुट डेटा लगभग 225 एमबी है।

इस समस्या का समाधान किस प्रकार से किया जा सकता है?

out-of-memory apache-spark

— hequn8128
स्रोत

स्पार्क कैसे चलाते हैं? क्या यह कंसोल से है? या आप कौन सी स्क्रिप्ट का उपयोग करते हैं?

— समाधि

मैं अपने एप्लिकेशन को संकलित करने और चलाने के लिए sbt का उपयोग करता हूं। sbt पैकेज तब sbt रन। मैंने एक महीने पहले हडूप पर एक ही कार्यक्रम लागू किया था, और मैं आउटऑफ़मेरीऑयर की एक ही समस्या से मिला था, लेकिन हडूप में इसे Xxx200m से Xmx400m के लिए mapred.child.java.opts के मान को बढ़ाकर आसानी से हल किया जा सकता है। क्या स्पार्क के पास इसके कार्य के लिए कोई jvm सेटिंग है? मुझे आश्चर्य है कि अगर spark.executor.memory हडूप में mapred.child.java.opts की तरह ही अर्थ रखता है। मेरे कार्यक्रम में स्पार्क.एक्ससीजर.मोरियो पहले से ही हडूप में एक्सएमएक्स 400 मीटर की तुलना में 4 जी ज्यादा बड़ा हो गया है। शुक्रिया ~

— hequn8128

क्या आपके द्वारा बताए गए केवल तीन कदम हैं? डेटा द्वारा उत्पन्न डेटा का आकार क्या है (data._1, desPoints) - यह मेमोरी एस्प में फिट होना चाहिए अगर यह डेटा फिर दूसरे चरण में बदल दिया जाता है

— Arnon Rotem-Gal-Oz

1

ड्राइवर के लिए मेमोरी कॉन्फ़िगरेशन क्या है? जाँच करें कि किस सर्वर से मेमोरी एरर निकलता है। क्या यह चालक या निष्पादनकर्ताओं में से एक है।

— RanP

यहां देखें सभी कॉन्फ़िगरेशन गुण: spark.apache.org/docs/2.1.0/configuration.html

— Naramsim

363

मेरे कुछ सुझाव हैं:

यदि आपके नोड्स को स्पार्क के लिए 6 जी अधिकतम करने के लिए कॉन्फ़िगर किया गया है (और अन्य प्रक्रियाओं के लिए थोड़ा छोड़ रहे हैं), तो 4 जी के बजाय 6 जी का उपयोग करें spark.executor.memory=6g। सुनिश्चित करें कि आप UI की जाँच करके यथासंभव अधिक मेमोरी का उपयोग कर रहे हैं (यह कहेगा कि आप कितना मेम उपयोग कर रहे हैं)
अधिक विभाजन का उपयोग करने का प्रयास करें, आपके पास 2 - 4 प्रति सीपीयू होना चाहिए। IME विभाजन की संख्या बढ़ाना अक्सर किसी कार्यक्रम को और अधिक स्थिर बनाने का सबसे आसान तरीका होता है (और अक्सर तेज़ होता है)। भारी मात्रा में डेटा के लिए आपको 4 प्रति सीपीयू से अधिक की आवश्यकता हो सकती है, मुझे कुछ मामलों में 8000 विभाजन का उपयोग करना होगा!
कैशिंग , का उपयोग कर के लिए आरक्षित स्मृति का अंश घटाएं spark.storage.memoryFraction। यदि आप अपने कोड में उपयोग नहीं करते हैं cache()या नहीं करते हैं persist, तो यह 0. हो सकता है। यह डिफ़ॉल्ट 0.6 है, जिसका अर्थ है कि आपको अपने ढेर के लिए केवल 0.4 * 4 जी मेमोरी मिलती है। IME मेम फ़्राक को कम करने से अक्सर OOMs चला जाता है। अद्यतन: स्पार्क 1.6 से स्पष्ट रूप से हमें अब इन मूल्यों के साथ खेलने की आवश्यकता नहीं होगी, स्पार्क उन्हें स्वचालित रूप से निर्धारित करेगा।
उपरोक्त के समान लेकिन स्मृति अंश में फेरबदल । यदि आपकी नौकरी को बहुत अधिक फेरबदल की आवश्यकता नहीं है, तो इसे कम मूल्य पर सेट करें (इससे आपके फेरबदल डिस्क में फैल सकते हैं जो गति पर विनाशकारी प्रभाव डाल सकते हैं)। कभी-कभी जब यह एक फेरबदल ऑपरेशन होता है, तो आपको इसके विपरीत करने की आवश्यकता होती है यानी इसे 0.8 की तरह कुछ बड़े पर सेट करें, या सुनिश्चित करें कि आप अपने फेरबदल को डिस्क पर फैलाने की अनुमति दें (यह 1.0.0 के बाद से डिफ़ॉल्ट है)।
स्मृति लीक के लिए बाहर देखो , ये अक्सर गलती से उन वस्तुओं पर बंद होने के कारण होते हैं जिनकी आपको अपने लैम्ब्डा में ज़रूरत नहीं है। निदान करने का तरीका लॉग्स में "एक्सएक्सएक्स बाइट्स के रूप में क्रमबद्ध कार्य" के लिए बाहर देखना है, अगर एक्सएक्सएक्स कुछ k या एमबी से अधिक बड़ा है, तो आपके पास मेमोरी लीक हो सकती है। Https://stackoverflow.com/a/25270600/1586965 देखें
ऊपर से संबंधित; यदि आपको वास्तव में बड़ी वस्तुओं की आवश्यकता है, तो प्रसारण चर का उपयोग करें ।
यदि आप बड़े RDD की कैशिंग कर रहे हैं और RDD http://spark.apache.org/docs/latest/tuning.html#serialized-rdd-storage पर क्रमिक रूप से विचार करने के लिए कुछ एक्सेस समय का त्याग कर सकते हैं । या यहां तक कि उन्हें डिस्क पर कैशिंग (जो कभी-कभी एसएसडी का उपयोग करते हुए उतना बुरा नहीं होता है)।
( उन्नत ) संबंधित, ऊपर से बचने Stringऔर भारी घोंसले वाली संरचनाओं (जैसे Mapऔर नेस्टेड केस क्लास) से। यदि संभव हो तो केवल आदिम प्रकारों का उपयोग करने की कोशिश करें और सभी गैर-प्राथमिकताओं को विशेष रूप से अनुक्रमित करें यदि आप बहुत सारे डुप्लिकेट की अपेक्षा करते हैं। WrappedArrayजब भी संभव हो, नेस्टेड संरचनाओं का चयन करें । या यहां तक कि अपने खुद के क्रमांकन को रोल करें - आपके पास सबसे अधिक जानकारी होगी कि कैसे अपने डेटा को बाइट्स में कुशलतापूर्वक वापस लाने के लिए, इसका उपयोग करें !
( बिट हैसी ) फिर से कैशिंग करते समय, Datasetअपनी संरचना को कैश करने के लिए विचार करें क्योंकि यह अधिक कुशल क्रमांकन का उपयोग करेगा। पिछले बुलेट बिंदु की तुलना में इसे हैक माना जाना चाहिए। अपने डोमेन ज्ञान को अपने एल्गो / क्रमांकन में बनाना 100x या 1000x द्वारा मेमोरी / कैश-स्पेस को कम कर सकता है, जबकि सभी में Datasetसंभवतः 2x - 5x मेमोरी और डिस्क पर 10x संपीड़ित (लकड़ी की छत) है।

http://spark.apache.org/docs/1.2.1/configuration.html

संपादित करें: (इसलिए मैं खुद को आसान बना सकता हूं) निम्नलिखित इस समस्या का संकेत है:

java.lang.OutOfMemoryError : GC overhead limit exceeded

— samthebest
स्रोत

आपके सुझावों के लिए धन्यवाद ~ अगर मैंने स्पार्क .executor.memory = 6g सेट किया है, तो स्पार्क की समस्या होगी: "यह सुनिश्चित करने के लिए अपने क्लस्टर UI की जांच करें कि श्रमिक पंजीकृत हैं और पर्याप्त मेमोरी है"। स्पार्क.स्टोरेज .emoryFraction को 0.1 पर सेट करने से समस्या हल नहीं हो सकती है। शायद समस्या मेरे कोड में है। धन्यवाद!

— Hequn8128

2

@samthebest यह एक शानदार जवाब है। मैं वास्तव में मेमोरी लीक खोजने के लिए लॉगिंग मदद की सराहना करता हूं।

— मायल्स बेकर

1

Hi @samthebest आपने 8000 विभाजन कैसे निर्दिष्ट किए? चूँकि मैं स्पार्क एसक्यूएल का उपयोग कर रहा हूँ इसलिए मैं केवल स्पार्क.sql.shuffle.partitions का उपयोग करके विभाजन को निर्दिष्ट कर सकता हूं, डिफ़ॉल्ट मान 200 है मुझे इसे अधिक से सेट करना चाहिए मैंने इसे 1000 पर सेट करने की कोशिश की लेकिन ओओएम प्राप्त करने में मदद नहीं की क्या आप जानते हैं कि इष्टतम क्या होना चाहिए विभाजन मूल्य I के पास संसाधित करने के लिए 1 टीबी तिरछा डेटा है और इसमें हाइव क्वेरीज़ द्वारा समूह शामिल है। कृपया मार्गदर्शन करें।

— उमेश के।

2

हाय @ user449355 कृपया आप एक नया प्रश्न पूछ सकते हैं? लंबे समय तक एक टिप्पणी धागा शुरू करने के डर के लिए :) यदि आपके पास समस्याएं हैं, तो संभवतः अन्य लोग हैं, और एक प्रश्न सभी के लिए ढूंढना आसान बना देगा।

— samthebest

1

अपने पहले बिंदु पर, @samthebest, आपको सभी मेमोरी का उपयोग नहीं करना चाहिए spark.executor.memoryक्योंकि आपको निश्चित रूप से आई / ओ हेडहेड के लिए कुछ मात्रा में मेमोरी की आवश्यकता है। यदि आप इसका उपयोग करते हैं, तो यह आपके कार्यक्रम को धीमा कर देगा। इसका अपवाद यूनिक्स हो सकता है, जिस स्थिति में आपके पास स्वैप स्थान है।

— हुनले

58

इस है कि अक्सर चर्चा नहीं करने के लिए एक उपयोग के मामले को जोड़ने के लिए, मैं जब एक प्रस्तुत करने के लिए एक समाधान मुद्रा जाएगा Sparkके माध्यम से आवेदन spark-submitमें स्थानीय मोड।

गेसबुक मास्टेरिंग अपाचे स्पार्क के अनुसार जेसेक लस्कॉस्की :

आप स्पार्क को स्थानीय मोड में चला सकते हैं। इस गैर-वितरित एकल-जेवीएम परिनियोजन मोड में, स्पार्क सभी निष्पादन घटकों - चालक, निष्पादक, बैकएंड और मास्टर - को एक ही JVM में रखता है। यह एकमात्र ऐसी विधा है, जिसमें ड्राइवर का इस्तेमाल निष्पादन के लिए किया जाता है।

इस प्रकार, यदि आप के OOMसाथ त्रुटियों का सामना कर रहे हैं, तो heapयह driver-memoryबजाय समायोजित करने के लिए पर्याप्त है executor-memory।

यहाँ एक उदाहरण है:

spark-1.6.1/bin/spark-submit
  --class "MyClass"
  --driver-memory 12g
  --master local[*] 
  target/scala-2.10/simple-project_2.10-1.0.jar

— ब्रायन
स्रोत

स्टैंड-अलोन मोड में ड्राइवर मेमोरी के लिए हमें कितना प्रतिशत विचार करना चाहिए।

— यशवंत कंबाला

@ ब्रायन, स्थानीय मोड में, क्या ड्राइवर मेमोरी को इनपुट डेटा के आकार से बड़ा होना चाहिए? क्या इनपुट डेटासेट के लिए विभाजन की संख्या निर्दिष्ट करना संभव है, इसलिए स्पार्क नौकरी उपलब्ध रैम की तुलना में बहुत बड़े डेटासेट से निपट सकती है?

— fuyi

19

आपको ऑफ़एच मेमोरी मेमोरी सेटिंग्स को कॉन्फ़िगर करना चाहिए जैसा कि नीचे दिखाया गया है:

val spark = SparkSession
     .builder()
     .master("local[*]")
     .config("spark.executor.memory", "70g")
     .config("spark.driver.memory", "50g")
     .config("spark.memory.offHeap.enabled",true)
     .config("spark.memory.offHeap.size","16g")   
     .appName("sampleCodeForReference")
     .getOrCreate()

अपनी मशीनों रैम की उपलब्धता के अनुसार ड्राइवर की मेमोरी और एक्ज़ीक्यूटर मेमोरी दें। यदि आप अभी भी आउटऑफ़मेरी समस्या का सामना कर रहे हैं, तो आप ऑफ हाइप का आकार बढ़ा सकते हैं ।

— pavan.vn101
स्रोत

जोड़ा गया बंद की स्थापना में मदद की

— kennut

2

ड्राइवर मेमोरी को आपके कोड में सेट करने से काम नहीं चलेगा, इसके लिए स्पार्क डॉक्यूमेंटेशन पढ़ें: स्पार्क प्रॉपर्टीज़ को मुख्य रूप से दो प्रकारों में विभाजित किया जा सकता है: एक, "स्पार्क.driver.memory", "स्पार्क.एक्सप्लॉरर.इनस्टेंस" जैसे, परिनियोजन से संबंधित है, क्रम में SparkConf के माध्यम से प्रोग्राम सेट करते समय इस तरह की संपत्तियां प्रभावित नहीं हो सकती हैं, या व्यवहार इस बात पर निर्भर करता है कि आप किस क्लस्टर मैनेजर और तैनाती मोड को चुनते हैं, इसलिए इसे कॉन्फ़िगरेशन फ़ाइल या स्पार्क-सबमिट कमांड लाइन विकल्पों के माध्यम से सेट करने का सुझाव दिया जाएगा।

— अब्दुलहफ्थ सारतवी

1

सबसे अच्छा जवाब! मेरी समस्या यह थी कि स्पार्क को मास्टर नोड में स्थापित नहीं किया गया था, मैंने एचडीएफसी से कनेक्ट करने के लिए पाइस्पार्क का इस्तेमाल किया और वही त्रुटि मिली। configहल करके समस्या का समाधान किया।

— मिखाइल_सम

मैंने सिर्फ ढेर आकार के मुद्दे को ठीक करने के लिए स्पार्क-सबमिट कमांड का उपयोग करके कॉन्फ़िगरेशन को जोड़ा। धन्यवाद।

— प्रीतम साधुखान

16

आपको ड्राइवर मेमोरी को बढ़ाना चाहिए। मेरे $ SPARK_HOME / conf फ़ोल्डर में आपको फ़ाइल को ढूंढना चाहिए spark-defaults.conf, संपादित करें और spark.driver.memory 4000mअपने मास्टर पर स्मृति के आधार पर सेट करें , मुझे लगता है। यह वही है जो मेरे लिए मुद्दा तय करता है और सब कुछ सुचारू रूप से चलता है

— blueskin
स्रोत

कितने प्रतिशत मेम आवंटित किए जाने हैं, अकेले खड़े हैं

— यशवंत कंबाला

14

स्टार्ट अप स्क्रिप्ट पर एक नज़र डालें, एक जावा हीप आकार वहाँ सेट है, ऐसा लगता है कि आप स्पार्क कार्यकर्ता को चलाने से पहले इसे सेट नहीं कर रहे हैं।

# Set SPARK_MEM if it isn't already set since we also use it for this process
SPARK_MEM=${SPARK_MEM:-512m}
export SPARK_MEM

# Set JAVA_OPTS to be able to load native libraries and to set heap size
JAVA_OPTS="$OUR_JAVA_OPTS"
JAVA_OPTS="$JAVA_OPTS -Djava.library.path=$SPARK_LIBRARY_PATH"
JAVA_OPTS="$JAVA_OPTS -Xms$SPARK_MEM -Xmx$SPARK_MEM"

आप स्क्रिप्ट को यहां तैनात करने के लिए दस्तावेज पा सकते हैं ।

— Tombart
स्रोत

धन्यवाद ~ मैं बाद में कोशिश करूंगा। स्पार्क यूआई से, यह पता चलता है कि प्रत्येक निष्पादक की मेमोरी 4096 है। इसलिए सेटिंग को सक्षम किया गया है, है ना?

— Hequn8128

जब मैं इसी तरह के मुद्दे ( stackoverflow.com/questions/34762432/… ) का सामना कर रहा हूं, तो अपना उत्तर देखें । आपके द्वारा दिए गए लिंक को देखकर ऐसा लगता है कि Xms / Xmx सेट करना अब नहीं है, क्या आप बता सकते हैं कि क्यों?

— सेफ़ी

इससे जुड़ी स्क्रिप्ट की सामग्री start up scriptsदुर्भाग्य से बदल गई है। 2019-12-19 तक ऐसा कोई विकल्प मौजूद नहीं है

— डेविड ग्रूमेस

7

मुझे इस समस्या का सामना करना पड़ा, हम गतिशील संसाधन आवंटन का उपयोग करते हैं और मुझे लगा कि यह मेरे क्लस्टर संसाधनों का उपयोग करने के लिए सबसे उपयुक्त होगा।

लेकिन सच्चाई यह है कि, डायनेमिक रिसोर्स एलोकेशन ड्राइवर मेमोरी को सेट नहीं करता है और इसे इसकी डिफ़ॉल्ट वैल्यू पर रखता है जो कि 1g है।

मैंने इसे एक ऐसे नंबर पर सेट किया है, जो मेरे ड्राइवर की मेमोरी के अनुकूल है। 32gb के लिए मैंने इसे 18gb पर सेट किया है

आप इसे स्पार्क सबमिट कमांड का उपयोग करके सेट कर सकते हैं:

spark-submit --conf spark.driver.memory=18gb ....cont

बहुत महत्वपूर्ण नोट, इस संपत्ति को ध्यान में नहीं रखा जाएगा यदि आप इसे स्पार्क प्रलेखन के अनुसार, कोड से सेट करते हैं:

स्पार्क गुणों को मुख्य रूप से दो प्रकारों में विभाजित किया जा सकता है: एक से संबंधित है, जैसे "स्पार्क.driver.memory", "स्पार्क ।executor.instances", इस प्रकार की संपत्तियां प्रभावित नहीं हो सकती हैं, जब क्रमिक रूप से स्पार्ककॉन्फ़ के माध्यम से प्रोग्राम सेट करना, या व्यवहार इस बात पर निर्भर करता है कि आप किस क्लस्टर मैनेजर और तैनाती मोड को चुनते हैं, इसलिए इसे कॉन्फ़िगरेशन फ़ाइल या स्पार्क-सबमिट कमांड लाइन विकल्पों के माध्यम से सेट करने का सुझाव दिया जाएगा; एक और मुख्य रूप से स्पार्क रनटाइम नियंत्रण से संबंधित है, जैसे "स्पार्क.टैस्क.मैक्स फ़ेल", इस तरह के गुणों को किसी भी तरह से सेट किया जा सकता है।

— अब्दुलहाफत सारतवी
स्रोत

2

आपको

— merenptah

5

मोटे तौर पर, स्पेक एक्सेक्यूटर जेवीएम मेमोरी को दो भागों में विभाजित किया जा सकता है। स्पार्क मेमोरी और यूजर मेमोरी। यह संपत्ति द्वारा नियंत्रित किया जाता है spark.memory.fraction- मान 0 और 1 के बीच होता है। चिंगारी अनुप्रयोगों में छवियों के साथ काम करने या स्मृति गहन प्रसंस्करण करने पर, घटने पर विचार करें spark.memory.fraction। यह आपके एप्लिकेशन कार्य के लिए अधिक मेमोरी उपलब्ध कराएगा। स्पार्क फैल सकता है, इसलिए यह अभी भी कम मेमोरी शेयर के साथ काम करेगा।

समस्या का दूसरा भाग कार्य का विभाजन है। यदि संभव हो, तो अपने डेटा को छोटे विखंडू में विभाजित करें। छोटे डेटा को संभवतः कम मेमोरी की आवश्यकता होती है। लेकिन अगर यह संभव नहीं है, तो आप स्मृति के लिए बलिदान कर रहे हैं। आमतौर पर एक एकल निष्पादक कई कोर चला रहा होगा। सभी समवर्ती कार्यों की स्मृति आवश्यकताओं को संभालने के लिए निष्पादकों की कुल मेमोरी पर्याप्त होनी चाहिए। यदि निष्पादक मेमोरी बढ़ाना एक विकल्प नहीं है, तो आप प्रति निष्पादन कोर को कम कर सकते हैं ताकि प्रत्येक कार्य के साथ काम करने के लिए अधिक मेमोरी प्राप्त हो। 1 कोर निष्पादकों के साथ परीक्षण करें जो आपके पास सबसे बड़ी संभव स्मृति है और तब तक कोर को बढ़ाते रहें जब तक आपको सबसे अच्छी कोर गिनती न मिल जाए।

— रोहित कार्लुपिया
स्रोत

5

क्या आपने अपने मास्टर जीसी लॉग को डंप किया? इसलिए मैं इसी तरह के मुद्दे से मिला और मैंने पाया कि SPARK_DRIVER_MEMORY ने केवल Xmx हीप को सेट किया है। प्रारंभिक ढेर का आकार 1G रहता है और ढेर का आकार कभी भी Xmx ढेर तक नहीं होता है।

पासिंग "--conf" स्पार्क .river.extraJavaOptions = -Xms20g "मेरे मुद्दे को हल करता है।

ps aux | grep जावा और आपको निम्नलिखित लॉग दिखाई देगा: =

24501 30.7 1.7 41782944 2318184 pts / 0 Sl + 18:49 0:33 / usr / java / latest / bin / java -cp / opt / spark / conf /: / opt / spark / jars / * -Xmx30g -Xms20g

— यूंझाओ यांग
स्रोत

3

मेमोरी हीप साइज (कम से कम स्पार्क-1.0.0 में) सेट करने का स्थान कन्फ्यूजन / स्पार्क-एनवी में है। प्रासंगिक चर हैं SPARK_EXECUTOR_MEMORYऔर SPARK_DRIVER_MEMORY। अधिक डॉक्स तैनाती गाइड में हैं

इसके अलावा, सभी दास नोड्स के लिए कॉन्फ़िगरेशन फ़ाइल की प्रतिलिपि बनाना न भूलें।

— अम्नोन
स्रोत

4

तुम्हें कैसे पता है जो एक के बीच समायोजित करने के लिए करते हैं SPARK_EXECUTOR_MEMORYऔर SPARK_DRIVER_MEMORY?

— हुनले

13

यानी किस त्रुटि के कारण आप इसे बढ़ा सकते हैं SPARK_EXECUTOR_MEMORY, और कौन सी त्रुटि आपको बढ़ाने के लिए कहेगी SPARK_DRIVER_MEMORY?

— हुनले

2

उपर्युक्त त्रुटि के लिए मेरे पास कुछ शर्करा है।

● एक निष्पादक के रूप में सौंपी गई निष्पादक मेमोरी की जाँच करें, जो असाइन किया गया है उससे अधिक मेमोरी की आवश्यकता वाले विभाजनों से निपटना पड़ सकता है।

● यह देखने की कोशिश करें कि क्या अधिक फेरबदल के रूप में रहते हैं क्योंकि फेरबदल महंगे ऑपरेशन हैं क्योंकि उनमें डिस्क I / O, डेटा क्रमांकन और नेटवर्क I / O शामिल हैं

● ब्रॉडकास्ट जॉइन का उपयोग करें

● GroupByKeys के उपयोग से बचें और ReduceByKey के साथ बदलने का प्रयास करें

● जहाँ भी फेरबदल होता है, वहाँ विशाल जावा वस्तुओं के उपयोग से बचें

— अनमशा श्रीवेनी
स्रोत

किसी और की क्वेरी को हाईजैक करने के लिए क्षमा करें, लेकिन ग्रुपबाय पर कम-से-कम उपयोग कैसे करें?

— सोमिल असीजा

1

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

केवल एक या कुछ निष्पादक हैं। निष्पादकों की संख्या में वृद्धि करें ताकि उन्हें विभिन्न दासों को आवंटित किया जा सके। यदि आप यार्न का उपयोग कर रहे हैं तो सुन्न-निष्पादक विन्यास को बदलने की आवश्यकता है या यदि आप स्पार्क स्टैंडअलोन का उपयोग कर रहे हैं, तो प्रति निष्पादन सुन्न कोर को ट्यून करने की आवश्यकता है और अधिकतम अधिकतम कोर स्पार्क। स्टैंडअलोन संख्या निष्पादक में = अधिकतम कोर / कोर प्रति निष्पादक।
विभाजन की संख्या बहुत कम है या शायद केवल एक ही है। इसलिए अगर यह कम है भले ही हमारे पास मल्टी-कोर, मल्टी एक्ज़ीक्यूटर्स हों, लेकिन यह बहुत मदद नहीं करेगा क्योंकि समानांतर विभाजन की संख्या पर निर्भर है। तो छवि को बढ़ाकर विभाजन को बढ़ाएं ।DD.repartition (11)

— श्रीधर
स्रोत

0

इन सटीक कॉन्फ़िगरेशन सेट करने से समस्या को हल करने में मदद मिली।

spark-submit --conf spark.yarn.maxAppAttempts=2 --executor-memory 10g --num-executors 50 --driver-memory 12g

— स्वप्निल शशांक
स्रोत