डेटा निर्भरता

कंप्यूटर विज्ञान में डेटा निर्भरता एक ऐसी स्थिति है जिसमें एक कार्यक्रम वक्तव्य (निर्देश) पिछले स्टेटमेंट के डेटा को संदर्भित करता है। संकलक सिद्धांत में, कथनों (या निर्देशों) के बीच डेटा निर्भरता की खोज करने के लिए उपयोग की जाने वाली तकनीक को निर्भरता विश्लेषण कहा जाता है।

निर्भरताएँ तीन प्रकार की होती हैं: डेटा, नाम और नियंत्रण।

डेटा निर्भरताएँ

अनुमान कथन $S_{1}$ और $S_{2}$, $S_{2}$ पर निर्भर करता है $S_{1}$ अगर:

$\left[I(S_{1})\cap O(S_{2})\right]\cup \left[O(S_{1})\cap I(S_{2})\right]\cup \left[O(S_{1})\cap O(S_{2})\right]\neq \varnothing$

कहाँ:

• $I(S_{i})$ द्वारा पढ़े गए स्मृति स्थानों का समूह है $S_{i}$,
• $O(S_{j})$ द्वारा लिखित स्मृति स्थानों का समूह है $S_{j}$, और
• से एक व्यवहार्य रन-टाइम निष्पादन पथ है $S_{1}$ को $S_{2}$.

इस स्थिति को बर्नस्टीन स्थिति कहा जाता है, जिसका नाम ए जे बर्नस्टीन ने रखा है।

तीन मामले मौजूद हैं:

• विरोधी निर्भरता: $I(S_{1})\cap O(S_{2})\neq \varnothing$, $S_{1}\rightarrow S_{2}$ और $S_{1}$ पहले कुछ पढ़ता है $S_{2}$ इसे अधिलेखित कर देता है
• प्रवाह (डेटा) निर्भरता: $O(S_{1})\cap I(S_{2})\neq \varnothing$, $S_{1}\rightarrow S_{2}$ और $S_{1}$ कुछ पढ़ने से पहले लिखता है $S_{2}$
• आउटपुट निर्भरता: $O(S_{1})\cap O(S_{2})\neq \varnothing$, $S_{1}\rightarrow S_{2}$ और दोनों एक ही मेमोरी लोकेशन लिखते हैं।

प्रवाह निर्भरता (सच्ची निर्भरता)

प्रवाह निर्भरता, जिसे डेटा निर्भरता या सच्ची निर्भरता या रीड-आफ्टर-राइट (RAW) के रूप में भी जाना जाता है, तब होती है जब कोई निर्देश पिछले निर्देश के परिणाम पर निर्भर करता है।

1. ए = 3
2. बी = ए
3. सी = बी

निर्देश 3 वास्तव में निर्देश 2 पर निर्भर है, क्योंकि C का अंतिम मान निर्देश अद्यतन करने वाले B पर निर्भर करता है। निर्देश 2 वास्तव में निर्देश 1 पर निर्भर है, क्योंकि B का अंतिम मान निर्देश अद्यतन करने वाले A पर निर्भर करता है। चूँकि निर्देश 3 वास्तव में निर्भर है निर्देश 2 पर और निर्देश 2 वास्तव में निर्देश 1 पर निर्भर है, निर्देश 3 भी वास्तव में निर्देश 1 पर निर्भर है। निर्देश स्तर समानता इसलिए इस उदाहरण में एक विकल्प नहीं है।

विरोधी निर्भरता

एक एंटी-डिपेंडेंसी, जिसे राइट-आफ्टर-रीड (WAR) के रूप में भी जाना जाता है, तब होता है जब किसी निर्देश को एक मान की आवश्यकता होती है जिसे बाद में अपडेट किया जाता है। निम्नलिखित उदाहरण में, निर्देश 2 एंटी-निर्देश 3 पर निर्भर करता है - इन निर्देशों का क्रम बदला नहीं जा सकता है, न ही उन्हें समानांतर में निष्पादित किया जा सकता है (संभवतः निर्देश क्रम बदल रहा है), क्योंकि यह ए के अंतिम मूल्य को प्रभावित करेगा।

1. बी = 3
2. ए = बी + 1
3. बी = 7

उदाहरण :

 एमयूएल आर3,आर1,आर2
 R2,R5,R6 जोड़ें

स्पष्ट है कि इन दोनों निर्देशों के बीच परस्पर-निर्भरता है। सबसे पहले हम R2 पढ़ते हैं फिर दूसरे निर्देश में हम एक नया लिख ​​रहे होते हैं इसके लिए मूल्य.

एंटी-डिपेंडेंसी नाम निर्भरता का एक उदाहरण है। अर्थात्, वेरिएबल्स का नाम बदलने से निर्भरता दूर हो सकती है, जैसा कि अगले उदाहरण में है:

1. बी = 3
एन. बी2 = बी
2. ए = बी2 + 1
3. बी = 7

एक नए निर्देश, निर्देश एन में एक नए चर, बी2 को बी की एक प्रति के रूप में घोषित किया गया है। 2 और 3 के बीच की