थ्रेडेड कोड: Difference between revisions

From Vigyanwiki
(Created page with "{{Short description|Program whose source code consists entirely of calls to functions}} {{confuse|Multi-threaded programming|Jump threading}} कंप्यूटर वि...")
 
No edit summary
Line 1: Line 1:
{{Short description|Program whose source code consists entirely of calls to functions}}
{{Short description|Program whose source code consists entirely of calls to functions}}
{{confuse|Multi-threaded programming|Jump threading}}
''मल्टी-थ्रेडेड प्रोग्रामिंग या जंप थ्रेडिंग से भ्रमित न हों।''
[[कंप्यूटर विज्ञान]] में, थ्रेडेड कोड एक प्रोग्रामिंग तकनीक है जहां स्रोत कोड का एक रूप होता है जो अनिवार्य रूप से पूरी तरह से [[सबरूटीन]]्स को कॉल करता है। यह अक्सर [[संकलक]]्स में प्रयोग किया जाता है, जो उस रूप में कोड उत्पन्न कर सकता है या स्वयं उस रूप में कार्यान्वित किया जा सकता है। कोड को [[दुभाषिया (कंप्यूटिंग)]] द्वारा संसाधित किया जा सकता है या यह केवल [[मशीन कोड]] कॉल निर्देशों का अनुक्रम हो सकता है।


थ्रेडेड कोड में वैकल्पिक पीढ़ी तकनीकों और वैकल्पिक कॉलिंग सम्मेलनों द्वारा उत्पन्न कोड की तुलना में बेहतर [[कोड घनत्व]] होता है। [[कैश (कंप्यूटिंग)]] आर्किटेक्चर में, यह [[निष्पादन (कंप्यूटिंग)]] थोड़ा धीमा हो सकता है।{{citation needed|date=February 2012}} हालाँकि, एक प्रोग्राम जो एक [[कंप्यूटर प्रोसेसर]] के CPU कैश में फिट होने के लिए काफी छोटा है, एक बड़े प्रोग्राम की तुलना में तेजी से चल सकता है जो कई [[कैश मिस]] से ग्रस्त है।<ref name="tuwien1">{{cite web|url=http://www.complang.tuwien.ac.at/forth/threading/ |title=Speed of various interpreter dispatch techniques V2}}</ref> [[धागा स्विच]]िंग पर छोटे प्रोग्राम भी तेज़ हो सकते हैं, जब अन्य प्रोग्राम कैश भर चुके हों।
[[कंप्यूटर विज्ञान]] में, थ्रेडेड कोड एक प्रोग्रामिंग तकनीक है जहां स्रोत कोड का एक रूप होता है जो अनिवार्य रूप से पूरी तरह से [[सबरूटीन]]्स को कॉल करता है। यह प्रायः [[संकलक]]्स में प्रयोग किया जाता है, जो उस रूप में कोड उत्पन्न कर सकता है या स्वयं उस रूप में कार्यान्वित किया जा सकता है। कोड को [[दुभाषिया (कंप्यूटिंग)]] द्वारा संसाधित किया जा सकता है या यह केवल [[मशीन कोड]] कॉल निर्देशों का अनुक्रम हो सकता है।
 
थ्रेडेड कोड में वैकल्पिक पीढ़ी तकनीकों और वैकल्पिक कॉलिंग सम्मेलनों द्वारा उत्पन्न कोड की तुलना में बेहतर [[कोड घनत्व]] होता है। [[कैश (कंप्यूटिंग)]] आर्किटेक्चर में, यह [[निष्पादन (कंप्यूटिंग)]] थोड़ा धीमा हो सकता है।{{citation needed|date=February 2012}} हालाँकि, एक प्रोग्राम जो एक [[कंप्यूटर प्रोसेसर]] के सेंट्रल प्रोसेसिंग यूनिट कैश में फिट होने के लिए काफी छोटा है, एक बड़े प्रोग्राम की तुलना में तेजी से चल सकता है जो कई [[कैश मिस]] से ग्रस्त है।<ref name="tuwien1">{{cite web|url=http://www.complang.tuwien.ac.at/forth/threading/ |title=Speed of various interpreter dispatch techniques V2}}</ref> [[धागा स्विच]]िंग पर छोटे प्रोग्राम भी तेज़ हो सकते हैं, जब अन्य प्रोग्राम कैश भर चुके हों।
 
थ्रेडेड कोड को [[प्रोग्रामिंग भाषा]] के कई कंपाइलरों में इसके उपयोग के लिए जाना जाता है, जैसे [[फोर्थ (प्रोग्रामिंग भाषा)]], [[बुनियादी]] के कई कार्यान्वयन, [[COBOL|सामान्य व्यवसाय उन्मुखी भाषा]] के कुछ कार्यान्वयन, B के प्रारम्भिक संस्करण (प्रोग्रामिंग लैंग्वेज),<ref>Dennis M. Ritchie, [https://www.bell-labs.com/usr/dmr/www/chist.html "The Development of the C Language"], 1993. Quote: "The B compiler on the PDP-7 did not generate machine instructions, but instead 'threaded code' ..."</ref> और छोटे [[मिनी कंप्यूटर]] और [[शौकिया रेडियो उपग्रह]]ों के लिए अन्य भाषाएं।{{citation needed|date=February 2016}}


थ्रेडेड कोड को [[प्रोग्रामिंग भाषा]] के कई कंपाइलरों में इसके उपयोग के लिए जाना जाता है, जैसे [[फोर्थ (प्रोग्रामिंग भाषा)]], [[बुनियादी]] के कई कार्यान्वयन, [[COBOL]] के कुछ कार्यान्वयन, B के शुरुआती संस्करण (प्रोग्रामिंग लैंग्वेज),<ref>Dennis M. Ritchie, [https://www.bell-labs.com/usr/dmr/www/chist.html "The Development of the C Language"], 1993. Quote: "The B compiler on the PDP-7 did not generate machine instructions, but instead 'threaded code' ..."</ref> और छोटे [[मिनी कंप्यूटर]] और [[शौकिया रेडियो उपग्रह]]ों के लिए अन्य भाषाएं।{{citation needed|date=February 2016}}




== इतिहास ==
== इतिहास ==
{{Original research section|date=February 2020}}
{{Original research section|date=February 2020}}
कंप्यूटर प्रोग्राम बनाने का सामान्य तरीका मशीन कोड में स्रोत कोड (कुछ [[प्रतीकात्मक भाषा (प्रोग्रामिंग)]] में लिखा गया) का अनुवाद करने के लिए एक कंपाइलर का उपयोग करना है। परिणामी [[निष्पादन]] योग्य आमतौर पर तेज़ होता है लेकिन, क्योंकि यह [[कंप्यूटर हार्डवेयर]] प्लेटफ़ॉर्म के लिए विशिष्ट है, यह पोर्टेबल नहीं है। एक [[आभासी मशीन]] के लिए निर्देश सेट उत्पन्न करने और प्रत्येक हार्डवेयर प्लेटफॉर्म पर दुभाषिया (कंप्यूटिंग) का उपयोग करने के लिए एक अलग दृष्टिकोण है। दुभाषिया वर्चुअल मशीन वातावरण को तुरंत चालू करता है और निर्देशों को निष्पादित करता है। इस प्रकार, केवल दुभाषिया को संकलित किया जाना चाहिए।
कंप्यूटर प्रोग्राम बनाने का सामान्य तरीका मशीन कोड में स्रोत कोड (कुछ [[प्रतीकात्मक भाषा (प्रोग्रामिंग)]] में लिखा गया) का अनुवाद करने के लिए एक कंपाइलर का उपयोग करना है। परिणामी [[निष्पादन]] योग्य सामान्य रूप से तेज़ होता है लेकिन, क्योंकि यह [[कंप्यूटर हार्डवेयर]] प्लेटफ़ॉर्म के लिए विशिष्ट है, यह पोर्टेबल नहीं है। एक [[आभासी मशीन]] के लिए निर्देश सेट उत्पन्न करने और प्रत्येक हार्डवेयर प्लेटफॉर्म पर दुभाषिया (कंप्यूटिंग) का उपयोग करने के लिए एक अलग दृष्टिकोण है। दुभाषिया वर्चुअल मशीन वातावरण को तुरंत चालू करता है और निर्देशों को निष्पादित करता है। इस प्रकार, केवल दुभाषिया को संकलित किया जाना चाहिए।


शुरुआती कंप्यूटरों में अपेक्षाकृत कम मेमोरी होती थी। उदाहरण के लिए, अधिकांश [[दिनांक जनरल नोवा]], [[IBM 1130]], और कई पहले [[माइक्रो]] कंप्यूटरों में केवल 4 kB RAM स्थापित थी। नतीजतन, उपलब्ध मेमोरी में फिट होने के लिए प्रोग्राम के आकार को कम करने के तरीके खोजने की कोशिश में बहुत समय व्यतीत हुआ।
प्रारम्भिक कंप्यूटरों में अपेक्षाकृत कम मेमोरी होती थी। उदाहरण के लिए, अधिकांश [[दिनांक जनरल नोवा]], [[IBM 1130]], और कई पहले [[माइक्रो]] कंप्यूटरों में केवल 4 kB RAM स्थापित थी। नतीजतन, उपलब्ध मेमोरी में फिट होने के लिए प्रोग्राम के आकार को कम करने के तरीके खोजने की कोशिश में बहुत समय व्यतीत हुआ।


एक समाधान एक दुभाषिया का उपयोग करना है जो एक समय में प्रतीकात्मक भाषा को थोड़ा पढ़ता है, और कार्यों को करने के लिए कार्यों को बुलाता है। चूंकि स्रोत कोड आमतौर पर परिणामी मशीन कोड की तुलना में अधिक कोड घनत्व होता है, यह समग्र मेमोरी उपयोग को कम कर सकता है। यही कारण था कि [[Microsoft BASIC]] एक दुभाषिया है:{{efn|[[Dartmouth BASIC]], upon which [[Microsoft BASIC]] is ultimately based, was a compiler that ran on mainframe machines.}} इसके अपने कोड को [[Altair 8800]] जैसी मशीनों की 4 kB मेमोरी को उपयोगकर्ता के स्रोत कोड के साथ साझा करना था। एक कंपाइलर सोर्स लैंग्वेज से मशीन कोड में ट्रांसलेट होता है, इसलिए कंपाइलर, सोर्स और आउटपुट सभी एक ही समय में मेमोरी में होने चाहिए। एक दुभाषिया में, कोई आउटपुट नहीं होता है।
एक समाधान एक दुभाषिया का उपयोग करना है जो एक समय में प्रतीकात्मक भाषा को थोड़ा पढ़ता है, और कार्यों को करने के लिए कार्यों को बुलाता है। चूंकि स्रोत कोड सामान्य रूप से परिणामी मशीन कोड की तुलना में अधिक कोड घनत्व होता है, यह समग्र मेमोरी उपयोग को कम कर सकता है। यही कारण था कि [[Microsoft BASIC|Microsoft सामान्य संयुक्त प्रोग्रामिंग भाषा]] एक दुभाषिया है:{{efn|[[Dartmouth BASIC]], upon which [[Microsoft BASIC]] is ultimately based, was a compiler that ran on mainframe machines.}} इसके अपने कोड को [[Altair 8800]] जैसी मशीनों की 4 kB मेमोरी को उपयोगकर्ता के स्रोत कोड के साथ साझा करना था। एक कंपाइलर सोर्स लैंग्वेज से मशीन कोड में ट्रांसलेट होता है, इसलिए कंपाइलर, सोर्स और आउटपुट सभी एक ही समय में मेमोरी में होने चाहिए। एक दुभाषिया में, कोई आउटपुट नहीं होता है।


थ्रेडेड कोड संकलित कोड के लिए एक स्वरूपण शैली है जो स्मृति उपयोग को कम करता है। कार्यक्रम में प्रत्येक घटना पर एक ऑपरेशन के हर चरण को लिखने के बजाय, जैसा कि उदाहरण के लिए [[मैक्रो कोडांतरक]] में आम था, संकलक कोड के प्रत्येक सामान्य बिट को सबरूटीन में लिखता है। इस प्रकार, प्रत्येक बिट स्मृति में केवल एक ही स्थान पर मौजूद है (देखें स्वयं को दोहराएं नहीं)। इन कार्यक्रमों में शीर्ष-स्तरीय एप्लिकेशन में सबरूटीन कॉल के अलावा और कुछ नहीं हो सकता है। इन सबरूटीन्स में से कई, बदले में, निचले स्तर के सबरूटीन कॉल्स के अलावा और कुछ नहीं होते हैं।
थ्रेडेड कोड संकलित कोड के लिए एक स्वरूपण शैली है जो स्मृति उपयोग को कम करता है। कार्यक्रम में प्रत्येक घटना पर एक ऑपरेशन के हर चरण को लिखने के बजाय, जैसा कि उदाहरण के लिए [[मैक्रो कोडांतरक]] में आम था, संकलक कोड के प्रत्येक सामान्य बिट को सबरूटीन में लिखता है। इस प्रकार, प्रत्येक बिट स्मृति में केवल एक ही स्थान पर सम्मिलित है (देखें स्वयं को दोहराएं नहीं)। इन कार्यक्रमों में शीर्ष-स्तरीय एप्लिकेशन में सबरूटीन कॉल के अलावा और कुछ नहीं हो सकता है। इन सबरूटीन्स में से कई, बदले में, निचले स्तर के सबरूटीन कॉल्स के अलावा और कुछ नहीं होते हैं।


मेनफ्रेम और कुछ शुरुआती माइक्रोप्रोसेसरों जैसे [[आरसीए 1802]] को सबरूटीन कॉल करने के लिए कई निर्देशों की आवश्यकता होती है। शीर्ष-स्तरीय एप्लिकेशन में और कई सबरूटीन्स में, उस क्रम को लगातार दोहराया जाता है, जिसमें केवल सबरूटीन एड्रेस एक कॉल से दूसरे कॉल में बदलता रहता है। इसका मतलब यह है कि कई फ़ंक्शन कॉल वाले प्रोग्राम में काफी मात्रा में बार-बार कोड भी हो सकता है।
मेनफ्रेम और कुछ प्रारम्भिक माइक्रोप्रोसेसरों जैसे [[आरसीए 1802]] को सबरूटीन कॉल करने के लिए कई निर्देशों की आवश्यकता होती है। शीर्ष-स्तरीय एप्लिकेशन में और कई सबरूटीन्स में, उस क्रम को लगातार दोहराया जाता है, जिसमें केवल सबरूटीन एड्रेस एक कॉल से दूसरे कॉल में बदलता रहता है। इसका मतलब यह है कि कई फ़ंक्शन कॉल वाले प्रोग्राम में काफी मात्रा में बार-बार कोड भी हो सकता है।


इसे संबोधित करने के लिए, थ्रेडेड कोड सिस्टम ने एक ऑपरेटर में फ़ंक्शन कॉल का प्रतिनिधित्व करने के लिए छद्म कोड का इस्तेमाल किया। रन टाइम पर, एक छोटा दुभाषिया शीर्ष-स्तरीय कोड को स्कैन करेगा, स्मृति में उपनेमका का पता निकालेगा, और इसे कॉल करेगा। अन्य प्रणालियों में, इसी मूल अवधारणा को [[शाखा तालिका]], [[प्रेषण तालिका]], या वर्चुअल विधि तालिका के रूप में कार्यान्वित किया जाता है, जिनमें से सभी में सबरूटीन पतों की एक तालिका होती है।
इसे संबोधित करने के लिए, थ्रेडेड कोड सिस्टम ने एक ऑपरेटर में फ़ंक्शन कॉल का प्रतिनिधित्व करने के लिए छद्म कोड का इस्तेमाल किया। रन टाइम पर, एक छोटा दुभाषिया शीर्ष-स्तरीय कोड को स्कैन करेगा, स्मृति में उपनेमका का पता निकालेगा, और इसे कॉल करेगा। अन्य प्रणालियों में, इसी मूल अवधारणा को [[शाखा तालिका]], [[प्रेषण तालिका]], या वर्चुअल विधि तालिका के रूप में कार्यान्वित किया जाता है, जिनमें से सभी में सबरूटीन पतों की एक तालिका होती है।


1970 के दशक के दौरान, हार्डवेयर डिजाइनरों ने सबरूटीन कॉल को तेज और सरल बनाने के लिए काफी प्रयास किया। बेहतर डिजाइनों पर, सबरूटीन को कॉल करने के लिए केवल एक ही निर्देश खर्च किया जाता है, इसलिए छद्म निर्देश का उपयोग कोई जगह नहीं बचाता है।{{Citation needed|date=March 2020|reason=storing only the address of the subroutine actually does save room compared to storing a call instruction, which necessarily must contain something in addition to the address of the subroutine.}} इसके अतिरिक्त, इन कॉलों का प्रदर्शन अतिरिक्त ओवरहेड से लगभग मुक्त है। आज, हालांकि लगभग सभी प्रोग्रामिंग भाषाएं सबरूटीन्स में कोड को अलग करने पर ध्यान केंद्रित करती हैं, वे ऐसा कोड स्पष्टता और रखरखाव के लिए करते हैं, स्थान बचाने के लिए नहीं।
1970 के दशक के समय, हार्डवेयर डिजाइनरों ने सबरूटीन कॉल को तेज और सरल बनाने के लिए काफी प्रयास किया। बेहतर डिजाइनों पर, सबरूटीन को कॉल करने के लिए केवल एक ही निर्देश खर्च किया जाता है, इसलिए छद्म निर्देश का उपयोग कोई जगह नहीं बचाता है।{{Citation needed|date=March 2020|reason=storing only the address of the subroutine actually does save room compared to storing a call instruction, which necessarily must contain something in addition to the address of the subroutine.}} इसके अतिरिक्त, इन कॉलों का प्रदर्शन अतिरिक्त ओवरहेड से लगभग मुक्त है। आज, हालांकि लगभग सभी प्रोग्रामिंग भाषाएं सबरूटीन्स में कोड को अलग करने पर ध्यान केंद्रित करती हैं, वे ऐसा कोड स्पष्टता और रखरखाव के लिए करते हैं, स्थान बचाने के लिए नहीं।


थ्रेडेड कोड सिस्टम फ़ंक्शन कॉल की उस सूची को बदलकर कमरे को बचाते हैं, जहां निष्पादन टोकन की सूची के साथ केवल सबरूटीन पता एक कॉल से दूसरे कॉल में बदलता है, जो अनिवार्य रूप से कॉल ऑपकोड (ओं) के साथ फ़ंक्शन कॉल होते हैं, पीछे छोड़ देते हैं केवल पतों की एक सूची।<ref>
थ्रेडेड कोड सिस्टम फ़ंक्शन कॉल की उस सूची को बदलकर कमरे को बचाते हैं, जहां निष्पादन टोकन की सूची के साथ केवल सबरूटीन पता एक कॉल से दूसरे कॉल में बदलता है, जो अनिवार्य रूप से कॉल ऑपकोड (ओं) के साथ फ़ंक्शन कॉल होते हैं, पीछे छोड़ देते हैं केवल पतों की एक सूची।<ref>
Line 47: Line 49:
p. 212
p. 212
</ref>
</ref>
इन वर्षों में, प्रोग्रामर ने उस दुभाषिया या छोटे चयनकर्ता पर कई बदलाव किए हैं। पतों की सूची में विशेष पता एक इंडेक्स, [[सामान्य प्रयोजन रजिस्टर]] या [[सूचक (कंप्यूटर प्रोग्रामिंग)]] का उपयोग करके निकाला जा सकता है। पते प्रत्यक्ष या अप्रत्यक्ष, सन्निहित या गैर-सन्निहित (पॉइंटर्स द्वारा जुड़े हुए), सापेक्ष या निरपेक्ष, संकलन समय पर हल या गतिशील रूप से निर्मित हो सकते हैं। सभी परिस्थितियों के लिए कोई भी भिन्नता सर्वोत्तम नहीं है।
इन वर्षों में, प्रोग्रामर ने उस दुभाषिया या छोटे चयनकर्ता पर कई बदलाव किए हैं। पतों की सूची में विशेष पता एक इंडेक्स, [[सामान्य प्रयोजन रजिस्टर]] या [[सूचक (कंप्यूटर प्रोग्रामिंग)]] का उपयोग करके निकाला जा सकता है। एड्रैस प्रत्यक्ष या अप्रत्यक्ष, सन्निहित या गैर-सन्निहित (पॉइंटर्स द्वारा जुड़े हुए), सापेक्ष या निरपेक्ष, संकलन समय पर हल या गतिशील रूप से निर्मित हो सकते हैं। सभी परिस्थितियों के लिए कोई भी भिन्नता सर्वोत्तम नहीं है।


== विकास ==
== विकास ==
जगह बचाने के लिए, प्रोग्रामर्स ने सबरूटीन कॉल्स की सूचियों को सबरूटीन पतों की सरल सूचियों में निचोड़ा, और बदले में प्रत्येक सबरूटीन को कॉल करने के लिए एक छोटे लूप का उपयोग किया। उदाहरण के लिए, निम्नलिखित स्यूडोकोड दो संख्याओं A और B को जोड़ने के लिए इस तकनीक का उपयोग करता है। उदाहरण में, सूची को थ्रेड लेबल किया गया है और एक चर ip (निर्देश सूचक) सूची के भीतर हमारे स्थान को ट्रैक करता है। एक अन्य चर एसपी (स्टैक पॉइंटर) में मेमोरी में कहीं और पता होता है जो अस्थायी रूप से मान रखने के लिए उपलब्ध होता है।
जगह बचाने के लिए, प्रोग्रामर्स ने सबरूटीन कॉल्स की सूचियों को सबरूटीन पतों की सरल सूचियों में निचोड़ा, और बदले में प्रत्येक सबरूटीन को कॉल करने के लिए एक छोटे लूप का उपयोग किया। उदाहरण के लिए, निम्नलिखित स्यूडोकोड दो संख्याओं A और B को जोड़ने के लिए इस तकनीक का उपयोग करता है। उदाहरण में, सूची को थ्रेड लेबल किया गया है और एक चर ip (निर्देश सूचक) सूची के भीतर हमारे स्थान को ट्रैक करता है। एक अन्य चर एसपी (स्टैक पॉइंटर) में मेमोरी में कहीं और पता होता है जो अस्थायी रूप से मान रखने के लिए उपलब्ध होता है।
 
start:
<वाक्यविन्यास प्रकाश लैंग = सी>
  ip = &thread // points to the address '&pushA', not the textual label 'thread'
शुरू करना:
top:
  ip = &thread // '&pushA' पते की ओर इशारा करता है, पाठ्य लेबल 'धागा' नहीं
  jump *ip++ // follow ip to address in thread, follow that address to subroutine, advance ip
ऊपर:
thread:
  जंप *आईपी++ // थ्रेड में पता करने के लिए आईपी का पालन करें, सबरूटीन के लिए उस पते का पालन करें, अग्रिम आईपी
  &pushA
धागा:
  &pushB
  &pushA
  &add
  &pushB
  ...
  &जोड़ना
pushA:
  ...
  *sp++ = A // follow sp to available memory, store A there, advance sp to next
पुशा:
  jump top
  *sp++ = A // उपलब्ध मेमोरी के लिए sp का अनुसरण करें, वहां A को स्टोर करें, आगे sp को आगे बढ़ाएं
pushB:
  ऊपर कूदो
  *sp++ = B
पुशबी:
  jump top
  *एसपी++ = बी
add:
  ऊपर कूदो
  addend1 = *--sp // Pop the top value off the stack
जोड़ना:
  addend2 = *--sp // Pop second value off the stack
  addend1 = *--sp // स्टैक से शीर्ष मान पॉप करें
  *sp++ = addend1 + addend2 // Add the two values together and store the result on the top of the stack
  addend2 = *--sp // स्टैक से दूसरा मान पॉप करें
  jump top
  *sp++ = addend1 + addend2 // दोनों मानों को एक साथ जोड़ें और परिणाम को स्टैक के शीर्ष पर संग्रहीत करें
कॉलिंग लूप at <code>top</code> इतना सरल है कि इसे प्रत्येक उपनेमका के अंत में इनलाइन दोहराया जा सकता है। नियंत्रण अब एक बार कूदता है, एक उपनेमका के अंत से दूसरे की प्रारंभ तक, दो बार कूदने के बजाय <code>top</code>. उदाहरण के लिए:
  ऊपर कूदो
start:
</वाक्यविन्यास हाइलाइट>
  ip = &thread // ip points to &pushA (which points to the first instruction of pushA)
 
  jump *ip++ // send control to first instruction of pushA and advance ip to &pushB
<!--In this case, decoding the [[bytecode]]s is performed once, during program compilation or program load, so it is not repeated each time an instruction is executed. This can save much time and space when decode and dispatch overhead is large compared to the execution cost.
thread:
 
  &pushA
Note, however, addresses in <code>thread</code> for <code>&pushA</code>, <code>&pushB</code>, etc., are two or more bytes, compared to (typically) one byte, for the decode and dispatch interpreter described above. In general, instructions for a decode and dispatch interpreter may be any size. For example, a decode and dispatch interpreter to simulate an Intel Pentium decodes instructions that range from 1 to 16 bytes. However, bytecoded systems typically choose 1-byte codes for the most-common operations. Thus, the thread often has a higher space cost than bytecodes. In most uses, the reduction in decode cost outweighs the increase in space cost.
  &pushB
 
  &add
Note also that while bytecodes are nominally machine-independent, the format and value of the pointers in threads generally depend on the target machine which is executing the interpreter. Thus, an interpreter might load a portable bytecode program, decode the bytecodes to generate platform-dependent threaded code, then execute threaded code without further reference to the bytecodes.-->
  ...
कॉलिंग लूप at <code>top</code> इतना सरल है कि इसे प्रत्येक उपनेमका के अंत में इनलाइन दोहराया जा सकता है। नियंत्रण अब एक बार कूदता है, एक उपनेमका के अंत से दूसरे की शुरुआत तक, दो बार कूदने के बजाय <code>top</code>. उदाहरण के लिए:
pushA:
 
  *sp++ = A // follow sp to available memory, store A there, advance sp to next
<वाक्यविन्यास प्रकाश लैंग = सी>
  jump *ip++ // send control where ip says to (i.e. to pushB) and advance ip
शुरू करना:
pushB:
  ip = &thread // ip &pushA को इंगित करता है (जो pushA के पहले निर्देश को इंगित करता है)
  *sp++ = B
  jump *ip++ // pushA के पहले निर्देश पर नियंत्रण भेजें और ip को &pushB पर आगे बढ़ाएं
  jump *ip++
धागा:
add:
  &pushA
  addend1 = *--sp // Pop the top value off the stack
  &pushB
  addend2 = *--sp // Pop second value off the stack
  &जोड़ना
  *sp++ = addend1 + addend2 // Add the two values together and store the result on top of the stack
  ...
  jump *ip++
पुशा:
  *sp++ = A // उपलब्ध मेमोरी के लिए sp का अनुसरण करें, वहां A को स्टोर करें, आगे sp को आगे बढ़ाएं
  कूद * आईपी ++ // नियंत्रण भेजें जहां आईपी कहता है (यानी पुशबी के लिए) और अग्रिम आईपी
पुशबी:
  *एसपी++ = बी
  कूदो * आईपी ++
जोड़ना:
  addend1 = *--sp // स्टैक से शीर्ष मान पॉप करें
  addend2 = *--sp // स्टैक से दूसरा मान पॉप करें
  *sp++ = addend1 + addend2 // दोनों मानों को एक साथ जोड़ें और परिणाम को स्टैक के शीर्ष पर संग्रहीत करें
  कूदो * आईपी ++
</वाक्यविन्यास हाइलाइट>
 
इसे डायरेक्ट थ्रेडेड कोड (डीटीसी) कहा जाता है। हालांकि तकनीक पुरानी है, थ्रेडेड कोड शब्द का पहला व्यापक रूप से परिचालित उपयोग संभवतः जेम्स आर. बेल का 1973 का लेख थ्रेडेड कोड है।<ref>{{cite journal|last=Bell|first=James R.|title=Threaded code|journal=Communications of the ACM|year=1973|volume=16|issue=6|pages=370–372|doi=10.1145/362248.362270}}</ref>
इसे डायरेक्ट थ्रेडेड कोड (डीटीसी) कहा जाता है। हालांकि तकनीक पुरानी है, थ्रेडेड कोड शब्द का पहला व्यापक रूप से परिचालित उपयोग संभवतः जेम्स आर. बेल का 1973 का लेख थ्रेडेड कोड है।<ref>{{cite journal|last=Bell|first=James R.|title=Threaded code|journal=Communications of the ACM|year=1973|volume=16|issue=6|pages=370–372|doi=10.1145/362248.362270}}</ref>
1970 में, चार्ल्स एच. मूर ने अपनी फोर्थ वर्चुअल मशीन के लिए एक अधिक कॉम्पैक्ट व्यवस्था, अप्रत्यक्ष थ्रेडेड कोड (ITC) का आविष्कार किया। मूर इस व्यवस्था पर इसलिए पहुंचे क्योंकि डेटा जनरल नोवा मिनीकंप्यूटर के प्रत्येक पते में एक [[अप्रत्यक्ष बिट]] था, जिसने आईटीसी को आसान और तेज़ बना दिया। बाद में, उन्होंने कहा कि उन्हें यह इतना सुविधाजनक लगा कि उन्होंने बाद के सभी फोर्थ डिजाइनों में इसका प्रचार किया।<ref>Moore, Charles H., published remarks in Byte Magazine's Forth Issue</ref>
1970 में, चार्ल्स एच. मूर ने अपनी फोर्थ वर्चुअल मशीन के लिए एक अधिक कॉम्पैक्ट व्यवस्था, अप्रत्यक्ष थ्रेडेड कोड (ITC) का आविष्कार किया। मूर इस व्यवस्था पर इसलिए पहुंचे क्योंकि डेटा जनरल नोवा मिनीकंप्यूटर के प्रत्येक एड्रैस में एक [[अप्रत्यक्ष बिट]] था, जिसने आईटीसी को आसान और तेज़ बना दिया। बाद में, उन्होंने कहा कि उन्हें यह इतना सुविधाजनक लगा कि उन्होंने बाद के सभी फोर्थ डिजाइनों में इसका प्रचार किया।<ref>Moore, Charles H., published remarks in Byte Magazine's Forth Issue</ref>
आज, कुछ फोर्थ कंपाइलर्स प्रत्यक्ष-थ्रेडेड कोड उत्पन्न करते हैं जबकि अन्य अप्रत्यक्ष-थ्रेडेड कोड उत्पन्न करते हैं। निष्पादक किसी भी तरह से कार्य करते हैं।
आज, कुछ फोर्थ कंपाइलर्स प्रत्यक्ष-थ्रेडेड कोड उत्पन्न करते हैं जबकि अन्य अप्रत्यक्ष-थ्रेडेड कोड उत्पन्न करते हैं। निष्पादक किसी भी तरह से कार्य करते हैं।


Line 112: Line 101:


=== डायरेक्ट थ्रेडिंग ===
=== डायरेक्ट थ्रेडिंग ===
थ्रेड में पते मशीनी भाषा के पते होते हैं। यह फॉर्म सरल है, लेकिन इसमें ओवरहेड्स हो सकते हैं क्योंकि थ्रेड में केवल मशीन के पते होते हैं, इसलिए आगे के सभी मापदंडों को अप्रत्यक्ष रूप से मेमोरी से लोड किया जाना चाहिए। कुछ फोर्थ सिस्टम डायरेक्ट-थ्रेडेड कोड उत्पन्न करते हैं। कई मशीनों पर डायरेक्ट-थ्रेडिंग सबरूटीन थ्रेडिंग की तुलना में तेज़ होती है (नीचे संदर्भ देखें)।
थ्रेड में एड्रैस मशीनी भाषा के एड्रैस होते हैं। यह फॉर्म सरल है, लेकिन इसमें ओवरहेड्स हो सकते हैं क्योंकि थ्रेड में केवल मशीन के एड्रैस होते हैं, इसलिए आगे के सभी मापदंडों को अप्रत्यक्ष रूप से मेमोरी से लोड किया जाना चाहिए। कुछ फोर्थ सिस्टम डायरेक्ट-थ्रेडेड कोड उत्पन्न करते हैं। कई मशीनों पर डायरेक्ट-थ्रेडिंग सबरूटीन थ्रेडिंग की तुलना में तेज़ होती है (नीचे संदर्भ देखें)।
 
[[स्टैक मशीन]] का एक उदाहरण अनुक्रम पुश ए, पुश बी, एड को निष्पादित कर सकता है। इसका अनुवाद निम्नलिखित थ्रेड और रूटीन में किया जा सकता है, जहाँ <code>ip</code> लेबल किए गए पते पर प्रारंभ किया गया है <code>thread</code> (यानी, पता जहां <code>&pushA</code> रखा है)।
 
<वाक्यविन्यास प्रकाश लैंग = सी>
#define पुश(x) (*sp++ = (x))
#define POP() (*--sp)
शुरू करना:
  ip = &thread // ip &pushA को इंगित करता है (जो pushA के पहले निर्देश को इंगित करता है)
  jump *ip++ // pushA के पहले निर्देश पर नियंत्रण भेजें और ip को &pushB पर आगे बढ़ाएं
धागा:
  &pushA
  &pushB
  &जोड़ना
  ...
पुशा:
  पुश (ए)
  कूद * आईपी ++ // नियंत्रण भेजें जहां आईपी कहता है (यानी पुशबी के लिए) और अग्रिम आईपी
पुशबी:
  पुश (बी)
  कूदो * आईपी ++
जोड़ना:
  परिणाम = पीओपी () + पीओपी ()
  पुश (परिणाम)
  कूदो * आईपी ++
</वाक्यविन्यास हाइलाइट>


वैकल्पिक रूप से, ऑपरेंड को थ्रेड में शामिल किया जा सकता है। यह उपरोक्त आवश्यक कुछ संकेतों को हटा सकता है, लेकिन धागे को बड़ा बनाता है:
[[स्टैक मशीन]] का एक उदाहरण अनुक्रम पुश ए, पुश बी, एड को निष्पादित कर सकता है। इसका अनुवाद निम्नलिखित थ्रेड और रूटीन में किया जा सकता है, जहाँ <code>ip</code> लेबल किए गए एड्रैस पर प्रारंभ किया गया है <code>thread</code> (यानी, पता जहां <code>&pushA</code> रखा है)।
 
#define PUSH(x) (*sp++ = (x))
<वाक्यविन्यास प्रकाश लैंग = सी>
#define POP() (*--sp)
#define पुश(x) (*sp++ = (x))
start:
#define POP() (*--sp)
  ip = &thread  // ip points to &pushA (which points to the first instruction of pushA)
शुरू करना:
  jump *ip++  // send control to first instruction of pushA and advance ip to &pushB
  आईपी ​​\u003d और धागा
thread:
  कूदो * आईपी ++
  &pushA
धागा:
  &pushB
  &धकेलना
  &add
  &ए // पता जहां ए संग्रहीत है, शाब्दिक ए नहीं
  ...
  &धकेलना
pushA:
  &बी
  PUSH(A)
  &जोड़ना
  jump *ip++ // send control where ip says to (i.e. to pushB) and advance ip
  ...
pushB:
धकेलना:
  PUSH(B)
  variable_address = *ip++ // आईपी को पिछले ऑपरेंड पते पर ले जाना चाहिए, क्योंकि यह एक सबरूटीन पता नहीं है
  jump *ip++
  PUSH(*variable_address) // वेरिएबल से वैल्यू पढ़ें और स्टैक पर पुश करें
add:
  कूदो * आईपी ++
  result = POP() + POP()
जोड़ना:
  PUSH(result)
  परिणाम = पीओपी () + पीओपी ()
  jump *ip++
  पुश (परिणाम)
वैकल्पिक रूप से, ऑपरेंड को थ्रेड में सम्मिलित किया जा सकता है। यह उपरोक्त आवश्यक कुछ संकेतों को हटा सकता है, लेकिन धागे को बड़ा बनाता है:
  कूदो * आईपी ++
#define PUSH(x) (*sp++ = (x))
</वाक्यविन्यास हाइलाइट>
#define POP() (*--sp)
start:
  ip = &thread
  jump *ip++
thread:
  &push
  &A  // address where A is stored, not literal A
  &push
  &B