लिनक्स कर्नेल- task_h_load

Question

मैं समझने की कोशिश कर रहा हूं कि load_balance फ़ंक्शन के दौरान क्या होता है।
मैं संस्करण 3.14 की जांच कर रहा हूं लेकिन मैंने संस्करण 4.3 पर भी एक नज़र डाली क्योंकि मुझे बताया गया था कि तंत्र बदल गया था और इस संस्करण में थोड़ा और स्पष्ट था।

में

v3.14 कॉल v4.3 में move_tasks

से कॉल मैं क्या देखते हैं यह एक ही समारोह है, लेकिन केवल एक अलग नाम के साथ से से detach_tasks

है।

यह फ़ंक्शन env->balance पैरामीटर के अनुसार कार्यों को एक कतार से दूसरे में ले जा रहा है।
मुझे समझ में नहीं आता कि task_h_load में लोड की गणना कैसे की जाती है।

क्या कोई जानता है कि लोड सदस्य क्या प्रतिनिधित्व करता है और इसकी गणना task_h_load फ़ंक्शन में की जाती है? यदि SMP configured.Linux Completely Fair Scheduler (सीएफएस) का उपयोग करता है प्रत्येक कार्य शेड्यूल करने के लिए इतना है कि हर एक को प्राप्त प्रोसेसर समय की 'निष्पक्ष' शेयर है

Answer 1

CFS "शेड्यूलिंग इकाइयों" का पेड़ रखता है। प्रत्येक शेड्यूलिंग इकाई का अपना पेड़ हो सकता है, और इसी तरह एक पुनरावर्ती तरीके से ... (उदाहरण के लिए, यह एक विशिष्ट उपयोगकर्ता की सभी प्रक्रियाओं को एक शेड्यूलिंग इकाई में समूहित करने के लिए उपयोगी है, इस प्रकार ऐसे उपयोगकर्ता को रोकना जिसमें कई कार्य हैं उपभोक्ता कम प्रक्रियाओं के साथ उन)

task_h_load की तुलना में अधिक CPU समय से - "कार्य श्रेणीबद्ध लोड"

के बाद से एक कार्य कुछ पेड़ में नेस्ट किया जा सकता है, तो की गणना इसकी भार इतना आसान नहीं है के लिए खड़ा है। ..

static unsigned long task_h_load(struct task_struct *p){ 
    struct cfs_rq *cfs_rq = task_cfbs_rq(p); 
    update_cfs_rq_h_load(cfs_rq); 
    return div64_ul(p->se.avg.load_avg * cfs_rq->h_load, 
          cfs_rq_load_avg(cfs_rq) + 1); 
} 

शुरुआत में 0 तत्काल पेड़ सेअंक जो पी में में पाया जाता है, तो हम केवल दो नेस्टेड पेड़ तो की गणना पी का भार सरल हो गया होता था:।

task_h_load = task_load_in_its_tree * (load_of_immediate_tree/ load_of_containing_tree);

(जबकि immediate_tree पेड़ उस कार्य में शामिल है को संदर्भित करता है, और containing_tree पेड़ कि पेड़ उस कार्य में शामिल होता है को दर्शाता है।)

लेकिन यह मामला नहीं है। हमारा पेड़ एक शेड्यूलिंग इकाई के अंदर घोंसला वाला पेड़ हो सकता है, जो स्वयं ही दूसरे पेड़ में एक पत्ता है। इस समारोह ऊपर पेड़ पदानुक्रम रूट करने के लिए सभी तरह से नीचे जड़ से चला जाता है, और:

तो, पहली बात हम करते हैं कॉल करने के लिए update_cfs_rq_h_load(cfs_rq) जो cfs_rq और उसके सभी ascendants (पूर्वजों) के लिए श्रेणीबद्ध लोड फैक्टर की गणना करता है पदानुक्रम में प्रत्येक पेड़ के लिए पदानुक्रमित लोड कारक की गणना करते समय हमारे cfs_rq पर।

गणना एक समान तरीके से किया जाता है:

cfs_rq_h_load = cfs_rq_load_in_its_tree * (load_of_immediate_tree/ load_of_containing_tree)

तो, अंत में हम cfs_rq का आंशिक लोड है और हम सभी के लिए है एक ही सूत्र का उपयोग कर h_load की गणना करना है।

task_h_load = task_load_in_its_tree * (load_of_immediate_tree/ load_of_containing_tree)

Answer 2

लोड संतुलन शुरू हो जाती है .. सीएफएस red-black tree की अवधारणा का उपयोग करता है।

समयबद्धक वर्तमान समय रिकॉर्ड जब एक कार्य रन कतार में प्रवेश करती है। हालांकि प्रक्रिया प्रोसेसर समय के लिए इंतजार कर रही है, यह वर्तमान में रन कतार में प्रक्रियाओं की कुल संख्या और प्रक्रिया प्राथमिकता से प्राप्त राशि से "प्रतीक्षा" मान बढ़ता है। जब प्रोसेसर इस कार्य को चलाता है, तो यह "प्रतीक्षा" मान कम हो जाता है। यदि यह मान कुछ मूल्य से नीचे गिर जाता है तो शेड्यूलर कार्य को छूट देगा और अन्य कार्य निष्पादित करने के लिए प्रोसेसर के करीब आ जाएगा। सीएफएस हमेशा "प्रतीक्षा" मान शून्य रखकर स्थिति को आदर्श रखने की कोशिश करता है।

लिनक्स load_balance और select_task_rq_fair() में दो कार्य हैं जो भार संतुलन का कार्य करते हैं।

सरल शब्द में सीएफएस लोड बैलेंस तंत्र व्यस्त सीपीयू को कम व्यस्त या आदर्श में ऑफ़लोड करता है।

task_h_load का उपयोग कार्य के वजन की गणना करने के लिए किया जाता है।

मुझे समझ में नहीं आता कि task_h_load में लोड की गणना कैसे की जाती है। task_h_load फ़ंक्शन में इसकी गणना कैसे की जाती है?

यह वज़न कारक प्रक्रिया के अच्छे मूल्य पर निर्भर करता है।

weighting factor = weight of process with nice value 0/weight of current task; 

जहां 'weight' लगभग 1024 * (1 के बराबर है।25)^(- अच्छा)

उदाहरण के लिए: वजन अच्छा मूल्य 1 वजन के लिए 820 है अच्छा मूल्य -1

task_h_load
अधिक लोड संतुलन विधियों के लिए के लिए 1277 है और बुनियादी बातें kernel comment task_h_load उल्लेख उचित समय शेड्यूलिंग के लिए रन कतार के पदानुक्रमित भार की गणना करने के लिए update_cfs_rq_h_load का उपयोग करें और जो cfs_rq_load_avg का उपयोग रनक्यू load_avg के औसत भार का उपयोग करें।

वर्चुअल रन टाइम CPU पर एक कार्य चलाने का भारित समय है। सीएफएस हमेशा this संतुलन में लाल-काले पेड़ रखने की कोशिश करता है।

< --smaller मूल्य ----------- vruntime मूल्य -------- बड़ा मूल्य -> ​​

प्रत्येक runnable काम है vruntime पर आधारित लाल काले पेड़ को संतुलित करने में रखा गया है। यदि कार्य चलाने के लिए तैयार है (मतलब है कि कार्य किसी संसाधन के लिए इंतजार नहीं कर रहा है), यह पेड़ पर रखा जाता है। यदि कार्य कुछ संसाधनों की प्रतीक्षा कर रहा है (यानी I/O की प्रतीक्षा कर रहा हूं) तो इसे हटा दिया जाएगा। जिन कार्यों में कम प्रसंस्करण समय होता है (इसका मतलब है कि vruntime) पेड़ के बाईं तरफ हैं और अधिक प्रसंस्करण समय वाले कार्य पेड़ के दाहिने तरफ हैं।

बाएं नोड का सबसे छोटा कुंजी मान है (सीएफएस के लिए, यह उच्च प्राथमिकता वाला कार्य है)। स्व-संतुलन लाल काले पेड़ को बाएं नोड की ओर नेविगेट करने के लिए ओ (एलजीएन) ऑपरेशन की आवश्यकता होती है। शेड्यूलर rb_leftmost में इस मान को कैश करता है। इस मूल्य का पुन: प्राप्त करने के द्वारा, अनुसूचक जो निर्धारित कार्य को चलाने के लिए अगले

यह भार संतुलन गैर वास्तविक कार्य केवल for real time कार्य धक्का-पुल संचालन उपयोग किया जाता है जो स्टीवन Rostedt और ग्रेगरी हास्किंस द्वारा

एक और विकसित की है के लिए प्रयोग किया जाता है सीएफएस के बारे में बात भी मेले समूह निर्धारण .Consider में सहायक है below figure

move_task बस (असंतुलन भारित भार को ले जाने की कोशिश लोड फैक्टर की गणना के रूप में ऊपर दिखाए गए के बाद इसका मतलब है) व्यस्त से this_rq तक। यह रन कतार दोनों के भार संतुलन के बराबर करने की कोशिश करता है ताकि दोनों "निष्पक्ष" प्रोसेसर समय को छोड़ सकें।

detach_taskenv लिनक्स कर्नेल के सूचक में निर्दिष्ट माइग्रेशन के लिए कार्य को अलग करें।

detach_one_task env-> src_rq से बिल्कुल एक कार्य को हटाने का प्रयास करता है।

detach_tasks() busiest_rq से असंतुलित भारित भार को अलग करने की कोशिश करता है। और यह अलग-अलग कार्यों की संख्या देता है या अन्यथा शून्य होने में विफल रहता है।

इस पृथक कार्य को नए rq (रन कतार) में जोड़ने के लिए, attach_task, attach_one_task,attach_tasks स्थिति के अनुसार उपयोग किया जाता है।

नई चेतावनी की जांच lockdep_assert_held()detach_tasks में शुरू की है जो move_tasks

On multi-processor it is not easy to move task so easily तो में मौजूद नहीं थे सीएफएस करना डोमेन विशिष्ट लोड संतुलन के रूप में नीचे:

यह सब के लिए समझने के लिए मैं करने के लिए आप चाहते हैं निम्नलिखित संदर्भ के माध्यम से जाने

1. Per-Entity-Load-Tracking metric for load balancing

2. weight factor

3. Open-suse

4. Robert-love Chapter 3

5. CPU-scheduling

मैं विशेष रूप से अपने सवाल का जवाब देने मुझे आशा है कि आप अगर टिप्पणी करने के लिए कोई आपत्ति नहीं है इन सारे दस्तावेज़ पढ़ कुछ छूट रहा है।