गुणन, वर्गमूल निष्कर्षण, आयात प्रतिस्थापन और कंपनी मिलेंडर के मुद्दे पर

"एन्ट्रॉपी, एर्गोडिक स्रोत, एक बहुआयामी संदेश स्थान, बिट्स, पॉलीसमी, मार्कोव प्रक्रिया - ये सभी शब्द बहुत प्रभावशाली लगते हैं, जिस भी क्रम में उन्हें रखा जाता है। यदि आप उन्हें सही क्रम में व्यवस्थित करते हैं, तो वे एक निश्चित सैद्धांतिक सामग्री प्राप्त करते हैं। और एक वास्तविक विशेषज्ञ कभी-कभी उनकी मदद से रोजमर्रा की व्यावहारिक समस्याओं का हल पा सकता है। "

जॉन पीरएस "आई नो नो ईविल"

यह पोस्ट सीमित संसाधनों के साथ एमके पर गणितीय कार्यों के सूक्ष्म अनुकूलन के साथ-साथ एम्बेडेड सॉफ्टवेयर के विकास के विभिन्न पहलुओं के व्यक्तिपरक आकलन के बारे में चर्चा से भरा है।

जिन लोगों ने यह चेतावनी नहीं दी थी, मैं बिल्ली के नीचे पूछता हूं।

इससे पहले कि हम एक पूर्णांक से एक वर्गमूल निकालने की प्रक्रिया का वर्णन करने के लिए आगे बढ़ें, ऑपरेशन को स्क्वायर में उलटा कर दें और, तदनुसार, गुणा करें, बाद के बारे में बात करें।

मान लीजिए कि हमारे पास एक 8-बिट संख्या को 8-बिट से गुणा करने का अवसर है, 16-बिट परिणाम (8 * 8 = 16) प्राप्त कर रहा है, हम इस ऑपरेशन के आधार पर ऑपरेशन 16 * 16 = 32 का कार्यान्वयन कैसे प्राप्त कर सकते हैं। स्पष्ट तरीका 16 का प्रतिनिधित्व दो 8 के योग के रूप में करना है, फिर हम प्राप्त करते हैं

(16)*(16)=(1(8)*256+2(8))*1(8)*256+2(8)) =1*1*256*256+1*2*256+2*1*256+2*2

यदि परिणामी अभिव्यक्ति में हम गुणा को 256 से बाईं ओर 8 अंकों से बदलते हैं, तो हमें पूरी तरह से काम करने वाला एल्गोरिदम मिलता है। आइए कार्यान्वयन पर खर्च किए गए समय का अनुमान लगाएं - हमें 4 * 8 = 16 के 4 गुणा और 4 बाइट संख्या 32 + 32 = 32 के 4 परिवर्धन की आवश्यकता है। एमके प्रकार एवीआर के लिए, हमें 4 * 2 + 4 * 4 = 24 चक्र मिलते हैं, लेकिन यह "माथे" समाधान के लिए है। आइए परिणाम को बेहतर बनाने का प्रयास करें। तथ्य यह है कि हमें 4 नहीं, बल्कि 3 अतिरिक्त और एक असाइनमेंट की आवश्यकता है, स्थिति को कुछ हद तक सरल करता है, क्योंकि परिणाम की प्रारंभिक शून्यिंग की आवश्यकता नहीं है, लेकिन हमने अभी भी इसे ध्यान में नहीं रखा है, हालांकि यह आवश्यक था और कुल समय 24/4 = 28 चक्र होना चाहिए। लेकिन, अगर हम पहले तीन शब्दों में एक पारी की उपस्थिति को ध्यान में रखते हैं (क्रमशः, हमारे पास है कि निम्न (दो कम बाइट) शून्य है और परिणाम में इसे जोड़ने का कोई मतलब नहीं है), तो हमें 4 बाइट्स नहीं जोड़ना होगा, लेकिन तीन और दो, जो कम हो जाएंगे 1 * 2 + 2 = 4 उपायों के लिए निष्पादन का समय और 20 उपाय प्राप्त करें। इसके अलावा, हम इस तथ्य पर ध्यान दे सकते हैं कि पहली और अंतिम शर्तें बिल्कुल भी प्रतिच्छेद नहीं करती हैं, जो हमें परिणाम की उच्चतम छमाही के शून्यकरण को पहले कार्यकाल के असाइनमेंट के साथ बदलने की अनुमति देती है और निष्पादन समय को अन्य 2 घड़ी चक्रों से घटाकर 18 कर देती है। आगे, आर्किटेक्चर सुविधाओं का उपयोग करके, अर्थात् रजिस्टर ट्रांसफर कमांड की उपस्थिति। जोड़े, दो और उपायों को बचाने और अंतिम परिणाम - मूल 28 के बजाय 16 उपाय - एक तिपहिया, लेकिन अच्छा।

इसी तरह के अनुकूलन के तरीके ऑपरेशन 32 * 32 = 32 के लिए काम करते हैं, जिसके लिए आप निष्पादन समय को अपेक्षित 4 * 4 * (2 + 4) + 4 = 100 घड़ी चक्र से (3 + 5 + 4 + 3) + (5 + 3) कम कर सकते हैं +3) + (4 + 3) + 3 = 36 उपाय, जो बिल्कुल भी बुरा नहीं है। खैर, गुणन के लिए विभिन्न विकल्पों के विचार के अंत में, हम ध्यान दें कि 16 * 16 = 16 3 + 3 + 3 = 9 चक्र में प्राप्त किया जा सकता है। ध्यान दें कि ये सभी विचार केवल इस धारणा के तहत मान्य हैं कि 2 उपायों के लिए एक ऑपरेशन 8 * 8 = 16 है, और यदि यह लक्ष्य एमके पर नहीं है, तो ऑपरेशन के अन्य सभी संस्करणों का निष्पादन समय निश्चित रूप से तेज नहीं होगा।

हमें गुणा (8 * 8 = 8 2, 8 * 8 = 16 9, 16 * 16 = 16 16, 16 * 16 = 32 36) करने के लिए आवश्यक समय को संक्षेप में प्रस्तुत करना चाहिए और अब मूल समस्या पर विचार करें।

हमें वर्गाकार पूर्णांक रूट को 32 बिट संख्या H से निकालने की आवश्यकता है, अर्थात, सबसे बड़ी 16 बिट संख्या n को ज्ञात करें जैसे कि n * n <= H. हम सभी माध्यमिक विद्यालय के पाठ्यक्रम में वर्गमूल (n = (N / n '+ n) / 2) के लिए क्रमिक सन्निकटन की विधि जानते हैं, लेकिन इसका उपयोग करते समय हमें पूर्णांकों को विभाजित करना होगा, जो एक बहुत ही समय लेने वाला ऑपरेशन है।

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

• प्रारंभिक मूल्य -> ​​एन = 0; b = 0x8000;
• प्रदर्शन 16 बार -> अगर (((एन + बी) * (एन + बी)> = एच) एन = एन + बी; बी = बी >> 1;

आप तुरंत इस विकल्प 16 (परिणाम के बिट्स की संख्या) पर खर्च किए गए समय का अनुमान लगा सकते हैं * (2 (चक्र का संगठन) +2 (जोड़) + X (गुणन) +5 (तुलना और समाधान) +2 (परिणाम का संशोधन) / 2 (औसत) हाफ टाइम) +2 (बिट शिफ्ट)) = 16 * (12 + X)। आप पूछते हैं कि संख्या 16 के बजाय सूत्र X में क्यों है, और यह पता चलता है कि एक घात का हमें इंतजार है, क्योंकि हम सी में लिख रहे हैं, और कोडांतरक में नहीं। तथ्य यह है कि मानक पुस्तकालय में बिट गहराई में परिवर्तन के साथ कोई गुणन ऑपरेशन नहीं होता है और हम 16 * 16 = 32 लागू नहीं कर सकते हैं, लेकिन 32 * 32 = 32 का उपयोग करने के लिए मजबूर किया जाता है, जो X = 16 के बजाय X = 36 की ओर जाता है और अंतिम आंकड़ा 16 * है। 32-बिट संख्या के वर्गमूल के पूर्णांक मान को निकालने के लिए 48 = 768 घड़ी चक्र।

बेशक, यह न्यूटन विधि की तुलना में बहुत बेहतर है, लेकिन थोड़ा बहुत, आइए देखें कि क्या किया जा सकता है।
तो, यह स्पष्ट है कि अधिकांश समय अगले गुणा परिणाम की गणना पर खर्च किया जाता है। बेशक, आप इसे असेंबलर में फिर से लिख सकते हैं और 16 * (12 + 16) = 448 टिक्स प्राप्त करते हुए, गुणन के कम खर्चीले संस्करण का उपयोग कर सकते हैं, लेकिन हम इसे अंतिम उपाय के रूप में छोड़ देंगे। प्रक्रिया को अधिक ध्यान से देखें और देखें कि हम किसी यादृच्छिक संख्या के गुणन की गणना स्वयं नहीं करते हैं, बल्कि पिछले मूल्य के गुणन में कुछ वृद्धि के साथ करते हैं, और पिछले मूल्य का वर्ग ज्ञात होता है। इसलिए, हम सूत्र (n + b) * (n + b) = n * n + 2 * n * b + b * b के आधार पर अंतर योजना का सहारा ले सकते हैं। पहली नज़र में, यह एक मज़ाक की तरह दिखता है - एक गुणन के बजाय, हमें चार टुकड़े और यहां तक ​​कि लंबी (32-बिट) संख्याओं के दो अतिरिक्त करने की आवश्यकता है। लेकिन यह समझना शुरू करें: हमारे पास पहले से ही n * n, b * b है जो खाते में ले रहा है b = b '/ 2 प्राप्त करना आसान है, जैसे b' * b '/ 4, और इसी तरह 2 * n * b = 2 * n * b '/ 2।

निम्नलिखित गणना योजना उभरती है:

1. प्रारंभिक मान -> एनएन = 0; n = 0; b = 0x8000; बी बी = बी * बी;
2. 16 बार दोहराएं -> अगर (nn + n + bb> = H) {n = n + b; nn = nn + bb + n}; bb >> 2; बी> 1;

हम अनुमान लगाते हैं कि कार्यान्वयन लागत 16 * (2 (चक्र का संगठन) +12 (असाइनमेंट और दो परिवर्धन) +5 (तुलना और समाधान) + (2 (जोड़) +8 (दो जोड़)) / 2 (औसत आधा समय) +8 (2 से दाईं ओर शिफ्ट) +2 (दाईं ओर शिफ्ट) = 16 * 34 = 544 घड़ी चक्र। 32 * 32 के गलत गुणा से बेहतर, लेकिन हमारे पास अभी भी भंडार है।

वे क्या हैं - चलो सबसे महंगे ऑपरेशन पर ध्यान दें - कुल 17 घड़ी चक्रों को जोड़ना और उनकी तुलना करना और एल्गोरिथम के मुख्य लूप को फिर से बनाना:
2. 16 बार दोहराएं -> टी = एच-बी बी-एन; if (T> = 0) {H = T; n = n + b);}; bb >> 2; बी> 1;
फिर चक्र का निष्पादन समय 16 * (2 (चक्र का संगठन) +12 (नए अंतर की गणना) +1 (तुलना और समाधान) + ((4 (असाइनमेंट) +2 (जोड़)) / 2 (औसत आधा समय) +8 होगा +2) = 16 * 28 = 448 चक्र, यदि आप वास्तुकला की ख़ासियतों को ध्यान में रखते हैं, तो आप एक और 2 + 2 = 4 * 16 = 64 चक्र बचा सकते हैं और 400 से कम चक्रों के भीतर रख सकते हैं।

हम थोड़ा बेहतर परिणाम प्राप्त करते हैं, जैसे कि सही गुणा 16 * 16 = 32 का उपयोग करते हुए, लेकिन कोडांतरक के बिना, "शुद्ध सी में"। हालांकि, एक महत्वपूर्ण माइनस है - यदि सब कुछ गुणन के साथ संस्करण में सहज है, तो टिप्पणियों के बिना एक अंतर योजना के साथ संस्करण काले जादू के एक सत्र की छाप देता है, आपको चुनना चाहिए। ध्यान दें कि हमने मध्यवर्ती चर के लिए अतिरिक्त मेमोरी के लिए उपायों की संख्या का आदान-प्रदान किया, जो आमतौर पर होता है।

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

ऐसा लगता था कि यह बेहतर काम नहीं करेगा, लेकिन, यह पता चला है, एल्गोरिथ्म के प्रदर्शन को बढ़ाने के लिए अभी भी भंडार हैं। आइए त्वरण की एक और क्लासिक विधि का उपयोग करने का प्रयास करें - विभाजित करें और जीतें। क्या होगा यदि आप पहले तर्क के पुराने आधे हिस्से से वर्गमूल निकालते हैं, और फिर इसे परिष्कृत करते हैं? सबसे पहले, हम दिखाते हैं कि यह मौलिक रूप से संभव है। वास्तव में, हम तर्क को H = H '<< 16 + H' के रूप में प्रस्तुत करते हैं और परिणाम n = n '<< 8 + n' के रूप में होता है। चूंकि n '' <256, तो इसका वर्ग स्पष्ट रूप से संख्या n = n '<< 8 + 256 = (n' + 1) << 8 के वर्ग से कम होगा। यह निम्नानुसार है कि परिणाम का उच्चतम भाग तर्क के उच्चतम भाग के वर्गमूल से अधिक नहीं है।

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

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

लेकिन यह सब नहीं है। चूँकि हम पहले ही अलगाव और प्रभुत्व के मार्ग पर चल चुके हैं, तो फिर आगे क्यों नहीं बढ़े - बिट्स से रूट को कदम से निकालें, सबसे पुराने (हमारे मामले में छोटे लोगों के साथ शुरू होने के साथ शुरू होता है)। एल्गोरिदम योजना समान है - हम वर्तमान परिणाम में बिट्स के अगले हिस्से को जोड़ते हैं और परिणाम में अगले बिट को जोड़ने की कोशिश करते हैं, अगर हम रूट वैल्यू से परे चले गए हैं। ख़ासियत यह है कि हम केवल तर्क के उच्च बिट्स की जांच कर सकते हैं, जब तक कि हम कम बिट्स तक नहीं पहुंचते।

लागू करते समय, हम एक और तरकीब का उपयोग करते हैं - अपने घटाए गए अंकों को दाईं ओर ले जाने के बजाय, हम अपने विघटित तर्क को बाईं ओर ले जाएंगे, अर्थ नहीं बदलता है, और गति बढ़ जाती है। यह दो कारकों के कारण बढ़ता है - 1) यह हमारे लिए केवल 16 बिट संख्याओं को घटाने के लिए पर्याप्त है (एक ख़ासियत है, और इसे ध्यान में रखा जाना चाहिए, लेकिन हम एक मामले के अध्ययन, विचार पर विचार कर रहे हैं) और 2) हमें अगले बिट के वर्ग को स्थानांतरित करने की आवश्यकता नहीं है, क्योंकि यह हमेशा रहेगा। एक के बराबर। लेकिन आपको इस दुनिया में हर चीज के लिए भुगतान करना होगा और हमारे पास बाईं ओर विस्तारित अंतर (6 बाइट्स) और प्रति घड़ी 2 बिट्स की शिफ्ट होगी। हम छद्म कोड को देखते हैं

1. प्रारंभिक मूल्य -> ​​एन = 0; एच 1 = 0;
2. 16 बार दोहराएं -> (एच 1, एच) << 2; टी = एच 1-एन -1; if (T> 0) {H1 = T; n = n + 2}; n << 1;

और निष्पादन समय का मूल्यांकन करें, 16 * (12 (विस्तारित शिफ्ट) +4 (अंतर की गणना) +1 (समाधान) +2 (असाइनमेंट) +1 (वृद्धि) +2 (शिफ्ट) = 16 * 22 = 352 उपाय, शायद परिणाम एकदम सही है। इस विकल्प को लागू करते समय, छोटे नुकसान होते हैं, मैं इसे फिर से जिज्ञासु पाठक (अच्छी तरह से, उसे काम मिलता है) पर छोड़ देता हूं।

खैर, उस खंड के निष्कर्ष में जिसने मुझे यह पोस्ट लिखने के लिए प्रेरित किया। एंटोन चिज़ोव द्वारा लिखित एक पूरी तरह से अद्भुत मैकूपीपी पुस्तकालय है, जिसमें, लेखकशिप के लोकी वर्ग के आधार पर, एंड्रीस्कु असामान्य रूप से सुरुचिपूर्ण है (ठीक है, जहां तक ​​लालित्य को C ++ टेम्पलेट्स पर लागू किया जा सकता है), पिन के साथ काम करें <a « github.com/KonstantinChizhov/ Mcucpp »मेरे पास उल्लिखित लेखक (दोनों के लिए) और हाल ही में, परिस्थितियों के संबंध में बहुत सम्मान है, जिसकी मैं बाद में चर्चा करूंगा, मैंने इस पुस्तकालय के स्रोतों को देखा और एक बार फिर प्रशंसा की।

हालाँकि, अन्य फाइलों के बीच मैंने template_utils.h को देखा, जिसमें कुछ सहायक दिनचर्याएँ लागू की गईं, और उनमें से एक 32-बिट संख्या का पूर्णांक रूट था। यह तथ्य कि यह गुणन के साथ सबसे सरल अनुक्रमिक सन्निकटन एल्गोरिथ्म का उपयोग करता है डरावना नहीं है, क्योंकि यह एल्गोरिथ्म गति में इतना अधिक नहीं खोता है, लेकिन समझ में यह आगे बहुत सारे अंक देता है और फिर भी जीतता है। लेकिन मैं वास्तव में इस तथ्य की तरह नहीं था कि इसे कुछ हद तक गलत तरीके से (प्रदर्शन के मामले में) लागू किया गया था, क्योंकि "बच्चे इसे देख सकते हैं।" अशुद्धि में 32 बिट्स के साथ चयनित संख्या का प्रतिनिधित्व करना शामिल है, क्योंकि हम दृढ़ता से जानते हैं कि 32 बिट संख्या की जड़ 16 बिट्स से आगे नहीं जाएगी, इसलिए हमें शून्य बाइट्स को स्थानांतरित करने की आवश्यकता क्यों है। और यह वास्तव में ऐसा मामला है जब कंपाइलर खुद कभी ऑप्टिमाइज़ेशन करने का अनुमान नहीं लगाएगा और उसे मदद करनी चाहिए।

स्पष्ट कार्य रूपांतरण

 static inline uint32_t sqrt(uint32_t value) { uint16_t result = 0; uint16_t add = 0x8000; for (uint8_t i = 16; i !=0; ++i) { uint32_t rootGuess = result | add; uint32_t guess = rootGuess * rootGuess; if (value >= guess) { result = rootGuess; } add >>= 1; } return result; } 

हमें एक बिट शिफ्ट पर 2 चक्र बचाने की अनुमति देता है और प्रत्येक चक्र पर अगला कारक बनाने पर 2 चक्र, और निर्दिष्ट रूप में चक्र का आयोजन एक और 4 चक्र है (मुझे पता है कि कंपाइलर हमारे लिए यह अनुकूलन कर सकता है, लेकिन स्पष्ट रूप से मदद क्यों नहीं करता है ), जो विशुद्ध रूप से कॉस्मेटिक कोड परिवर्तनों के लिए काफी अच्छा है जो कम से कम इसकी व्यापकता को प्रभावित नहीं करते हैं।

बाद में ध्यान दें - एक टिप्पणी ने मुझे लगता है कि यह अधिक सही होगा

  for (uint_fast8_t i= ...) 

मदद के लिए धन्यवाद ओलेग।

केक पर चेरी नीचे स्थित साइन नंबर से पूरे वर्गमूल निकालने का कार्य है, जो दावा करता है कि 65-1 = 65635 = -1। दूसरी ओर, क्यों नहीं, किसी भी अन्य परिणाम से भी बदतर क्या है, हमारे पास कोई अपवाद नहीं है। एमके में कारण, और एक नकारात्मक संख्या का पूरा वर्गमूल मौजूद नहीं है।

खैर, इस बारे में निष्कर्ष कि मैं एंटोन चिझोव की लाइब्रेरी में क्यों गया। मुझे MAX (MultiAgent Coherent System) नाम के तहत MK के लिए घरेलू RTOS के बारे में हाल ही में एक पोस्ट द्वारा संकेत दिया गया था - इसके रचनाकारों द्वारा विज्ञापित पद के लिए एपिग्राफ देखें और Milander द्वारा निर्मित MK में पोर्ट किए गए। नोट - यह पोस्ट किसी भी तरह से प्रचार सामग्री नहीं है और यह जल्द ही पाठकों के लिए स्पष्ट हो जाएगा। पूर्वोक्त mcucpp से, OS लेखकों ने रिंग बफर के कार्यान्वयन का उपयोग किया था (बिना एंटोन लाइब्रेरी के फायदे को ध्यान में रखते हुए, मुझे कहना होगा कि इसका यह हिस्सा एक संदर्भ नहीं है, और यह अभी भी एक नरम सूत्रीकरण है, जिसके बारे में मैंने एक और पोस्ट में लिखा था कि मैं बिल्कुल भी नहीं जीता था)। चूंकि मैं मिलेंडर की उत्पादन सुविधाओं के साथ मिलकर काम करता हूं, इसलिए सामग्री ने मुझे दिलचस्पी दी और मैंने डेवलपर्स वेबसाइट के लिंक का अनुसरण किया।

यारोस्लावना का अगला रोना शुरू होता है।

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

शुरू करने के लिए, आधे साल का विवरण लगभग मात्रा (115 से 55 पृष्ठों से) में आधा हो गया है, और यदि "प्रोग्राम विवरण" से तीसरे उत्पादों को लॉन्च करने की प्रक्रिया का वर्णन करने वाले स्क्रीनशॉट के साथ गायब होने का स्वागत है, तो इन सामग्रियों की उपस्थिति नहीं है (जिसके निर्माण के लिए मैंने एक दस्तावेज जैसे "ऑपरेटर की मार्गदर्शिका" में बहुत महत्वपूर्ण, लेकिन अभी भी समय और पैसा नहीं खर्च किया है, मैं व्यक्तिगत रूप से हैरान हूं। इसके अलावा, दस्तावेज़ के पहले ही वाक्य में, हम सच्चाई से एक स्पष्ट विचलन देखते हैं, क्योंकि RTOS का उद्देश्य किसी भी तरह से "कार्यक्रम बनाना" नहीं है, किसी कारण से लेखक ने दस्तावेज़ के पिछले संस्करण में खुद को इस तरह के बयान की अनुमति नहीं दी है, विपणन सेवा का प्रभाव महसूस होता है। यह यह भी बताता है कि यदि वर्णन रूट निर्देशिका के / डॉक्स फ़ोल्डर में हुआ करता था, और यह तार्किक था, अब यह / टूलकिन / मैक / डॉक्स में छिपा हुआ है, ठीक है, जैसा कि उन्होंने मेरी युवावस्था में कहा था, "हर कोई अपने तरीके से पागल है," हम आगे बढ़ते हैं।

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

यही है, घोषित ओएस, जिसमें से हाइलाइट की गई विशेषता एक मल्टी-कंट्रोलर सिस्टम के भीतर बातचीत का संगठन है, में इस इंटरैक्शन को व्यवस्थित करने के मूल साधन नहीं हैं। नीचे की पंक्ति में हमारे पास क्या है - और हमारे पास कार्य प्रबंधन है, वास्तव में एक शेड्यूलर, न्यूनतम समय सेवा और कार्यों को सिंक्रनाइज़ करने का साधन है, और यह सब अजीब है, कम से कम कहने के लिए। ठीक है, हम आगे भी देखेंगे, ऐसे घटकों के एक सेट में भी दिलचस्प समाधान संभव है, विशेष रूप से यह देखते हुए कि एक साइट पर (निर्माता की कंपनी नहीं) मैंने संदर्भ द्वारा इस ओएस के स्रोत कोड की "परीक्षा" देखी। इस दस्तावेज़ में कहा गया है कि सॉफ़्टवेयर उत्पाद तृतीय-पक्ष (आयात) घटकों का उपयोग नहीं करता है और मूल है, यह सुनिश्चित करने के लिए आवश्यक होगा।

पहला अवलोकन यह है कि यदि आप किसी विशेष Cortex-M0 आर्किटेक्चर (1986 BE1T) को पोर्ट करने के लिए सोर्स कोड पैकेज में शामिल ऑरिजनल ARM फाइल का उपयोग करते हैं, तो यह थर्ड-पार्टी (इम्पोर्टेड) ​​टेक्स्ट फ्रैगमेंट का उपयोग करने के समान है - मुझे व्यक्तिगत रूप से लगता है कि यह उपयोग है, लेकिन मैं शायद सब कुछ नहीं जानता। और दूसरी बात, शेडयूलर और संबंधित कार्य प्रबंधन घटकों का स्रोत कोड वास्तव में मूल है और इसमें कोई एनालॉग नहीं है (कम से कम मुझे कोई भी पता नहीं है), लेकिन यह उस तरह की मौलिकता है जब मुझे फिल्म "द इविल स्पिरिट ऑफ यंबुया" से पुराने जादूगर के वाक्यांश को याद करते हैं। महान शिकारी: "कान काट दिया, पकाया और खाया - क्या आपने अनुमान लगाया होगा?"

मैं समझाने की कोशिश करूंगा - सामान्य रूप से ओएस के डिजाइन में और विशेष रूप से आरटीओएस में, जटिल मुद्दों में से एक सिस्टम में सभी प्रक्रियाओं तक एक साझा संसाधन - प्रोसेसर रनटाइम तक पहुंच सुनिश्चित करने का मुद्दा है। , ( ) , . ( , , MPU), .

, , , , . (1) , , FREE-RTOS 20 , ( , , ).

, , 60 ( ). , . ( ) , (, ) ,

1. (n)
2. — , 20*(3*4)=240 . , , , .

, , ( , , ) . , ( , ). mcucpp ( — ), .

— - , .

(, , ) - — . ( , , ), , ( 2013) 1 , 2019 .

, :

1. ( , ) ( , , , , ),
2. ( ),
3. () 2,
4. HAL, CMSIS (- ),
5. ,
6. ,
7. (3rd part), ,
8. ,
9. ,
10. , (, , ..) « »,
11. , , ( , , MIT , « »), , (?).

, , , 5 ( , , 10, IDE). , , .

, , , .

, , () .