कैसे करें-j विकल्प पास करने के लिए अधिकतम संख्या निर्धारित करने के लिए?

Question

मैं जितनी जल्दी हो सके संकलन करना चाहता हूं। जाओ पता लगाओ। और विकल्प के बाद नंबर की पसंद को स्वचालित करना चाहते हैं -j। मैं शेल स्क्रिप्ट में प्रोग्राम मान को कैसे चुन सकता हूं?

क्या nprocमेरे पास संकलन करने के लिए उपलब्ध थ्रेड्स की संख्या के बराबर आउटपुट है ?

make -j1 make -j16

Answer 1

nprocसीपीयू कोर / थ्रेड्स की संख्या उपलब्ध कराता है, उदाहरण के लिए दो तरह के एसएमटी का समर्थन करने वाले क्वाड-कोर सीपीयू पर 8।

विकल्प makeका उपयोग करके आप कितनी नौकरियों के समानांतर चल सकते हैं, यह -jकई कारकों पर निर्भर करता है:

• उपलब्ध स्मृति की मात्रा
• प्रत्येक makeकार्य द्वारा उपयोग की जाने वाली स्मृति की मात्रा
• makeI / O- या सीपीयू-बाउंड किस कार्य के लिए है

make -j$(nproc) शुरू करने के लिए एक सभ्य जगह है, लेकिन आप आमतौर पर उच्च मूल्यों का उपयोग कर सकते हैं, जब तक आप अपनी उपलब्ध स्मृति को समाप्त नहीं करते हैं और जोर देना शुरू करते हैं।

वास्तव में तेजी से निर्माण के लिए, यदि आपके पास पर्याप्त मेमोरी है, तो मैं एक का उपयोग करने की सलाह देता हूं tmpfs, इस तरह से अधिकांश नौकरियां सीपीयू-बाउंड make -j$(nproc)होंगी और यथासंभव तेजी से काम करेंगी।

Comments

और ccacheबाद में पुनर्निर्माण के लिए लेकिन यह OT है

— solsTiCe

क्या GNU समानांतर की तरह कुछ का उपयोग करना यहाँ सार्थक होगा?

— terdon

यदि मैं एक का उपयोग करता हूं tmpfs, तो क्या मैं एक निर्देशिका आकार तक सीमित रहूंगा जो हमेशा मेरे भौतिक रैम आकार से छोटा होता है?

— टैराबाइट

यह एक महान जवाब नहीं है, लेकिन सबसे तेज "जे" मूल्य को निर्धारित करने वाले प्रोग्राम के सवाल की सख्त भावना में, आप 1 से कुछ उचित ऊपरी सीमा (2x nproc ??) पर लूप j कर सकते हैं और timeकॉल में मेक को लपेट सकते हैं । परिणामों को साफ करें, बार-बार कुल्ला करें - और अंत में समय / जम्मू मानों को छांटें।

— जेफ स्कालर

@terdon No. मेक सभी निर्भरता को हल करने के बारे में है, जिसका अर्थ है कि नौकरियों को अभी भी एक निश्चित क्रम में चलाया जाना है। GNU समानांतर उस के बारे में परवाह नहीं करता है। एक साइड नोट पर, यह तय करना कि समानांतर में कौन सी नौकरियां सुरक्षित हैं और जो एक कठिन समस्या नहीं हैं। सभी कार्यक्रम बनाते हैं जो समानांतर बिल्ड की पेशकश करते हैं, जब तक कि वे कुछ हद तक उपयोग योग्य नहीं हो जाते।

— lcd047

Answer 2

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

100 छोटी सी फ़ाइलों को संकलित करना किसी एक विशाल, या इसके उलट संकलन से तेज हो सकता है। छोटे-छोटे अत्यधिक जटिल कोड का निर्माण बड़ी मात्रा में सीधे-आगे / रैखिक कोड के निर्माण की तुलना में धीमा हो सकता है।

बिल्ड मामलों के संदर्भ में भी - समर्पित सर्वरों के निर्माण के लिए अनुकूलित aj फ़ैक्टर का उपयोग करना, विशेष, नॉन-ओवरलैपिंग बिल्ड के लिए ट्यून किए गए, जब एक ही साझा किए गए सर्वर पर समानांतर में डेवलपर्स बिल्डिंग द्वारा उपयोग किया जाता है, तो बहुत अधिक परिणाम मिल सकते हैं। उन सभी की तुलना में समय यदि क्रमबद्ध है) या विभिन्न हार्डवेयर कॉन्फ़िगरेशन या वर्चुअलाइज्ड वाले सर्वरों पर।

बिल्ड स्पेसिफिकेशन की शुद्धता का पहलू भी है। बहुत ही जटिल बिल्ड में दौड़ की स्थिति हो सकती है, जो आकस्मिक दर की असफलताओं का कारण बन सकती है, जो कि जे कारक की वृद्धि या कमी के साथ अलग-अलग हो सकती है।

हम लगातार चलते रह सकते हैं। मुद्दा यह है कि आपको वास्तव में अपने निर्माण का मूल्यांकन अपने उसी संदर्भ में करना होगा जिसके लिए आप जे कारक को अनुकूलित करना चाहते हैं। @ जेफ़ स्कॉलर की टिप्पणी लागू होती है: जब तक आप अपना सर्वश्रेष्ठ फिट नहीं पाते हैं, तब तक इसे लागू करें। व्यक्तिगत रूप से मैं nproc मूल्य से शुरू करूँगा, ऊपर की ओर पहले और नीचे की ओर प्रयास करें यदि ऊपर की तरफ का प्रयास तत्काल गिरावट दिखाता है।

एक अच्छा विचार हो सकता है कि पहले अपने माप की परिवर्तनशीलता का एक विचार प्राप्त करने के लिए, समान रूप से समान संदर्भों में कई समान बनाता है - यदि बहुत अधिक है तो यह आपके संपूर्ण अनुकूलन प्रयास को खतरे में डाल सकता है (20% परिवर्तनशीलता पूरी तरह से 10% सुधार ग्रहण करेगी / गिरावट जे कारक खोज में पढ़ने)।

अंत में, यदि एक निश्चित जे फैक्टर के बजाय समर्थित और उपलब्ध हो तो IMHO ( एडेप्टिव ) जॉबस्वर का उपयोग करना बेहतर होता है - यह लगातार व्यापक संदर्भों में बेहतर निर्माण प्रदर्शन प्रदान करता है।

Comments

अच्छी तरह से अंतर्निहित निर्माण की निर्भरता के बारे में डाल दिया। क्या आप -jपैरामीटर के साथ कोई निश्चित संख्या पास करने पर टिप्पणी कर सकते हैं ? जैसेmake -j

— ताराबाई

make -jनिर्भरता के रूप में कई नौकरियों के रूप में एक कांटा बम ( superuser.com/questions/927836/… ) की अनुमति देगा ; निर्माण सबसे अच्छे रूप में क्रॉल करेगा उन्हें (चलाने की तुलना में प्रक्रियाओं के प्रबंध पर सबसे सीपीयू खर्च superuser.com/questions/934685/... ) और अत्यधिक समानांतर में बनाता है सिस्टम स्मृति / स्वैप या पीआईडी # से से बाहर चला जाएगा और निर्माण असफल हो जायेगी ।

— डैन कॉर्निलेस्कु

Answer 3

सबसे सीधे-सादे तरीके से nprocऐसा उपयोग करना है:

make -j`nproc`

आदेश nprocआपकी मशीन पर कोर की संख्या लौटाएगा। इसे टिक्स में लपेटकर, nprocकमांड पहले निष्पादित करेगा, एक नंबर लौटाएगा और उस नंबर को पास कर दिया जाएगा make।

आपके पास कुछ महत्वपूर्ण अनुभव हो सकते हैं जहां तेजी से संकलित समय में कोर-काउंट + 1 परिणाम होता है। यह I / O देरी, अन्य संसाधन देरी और संसाधन बाधाओं की अन्य उपलब्धता जैसे कारकों के साथ अधिक करना है।

ऐसा करने के लिए nproc+1, यह प्रयास करें:

make -j$((`nproc`+1))

Answer 4

यदि आप makeवर्चुअल सीपीयू के रूप में कई समानांतर श्रमिकों का उपयोग करने के लिए कमांड लिखना चाहते हैं , तो मैं उपयोग करने का सुझाव देता हूं:

nproc | xargs -I % make -j%

जिसे या तो एक स्टैंडअलोन कमांड के रूप में या RUNभीतर निर्देश के रूप में लिखा जा सकता है Dockerfile(जैसा कि डॉकर नेस्टेड कमांड का समर्थन नहीं करता है)