💯 ✍🏼 👎🏿 रेड के लिए कोड अनुकूलन के तरीके। भाग 2: गैर-कैचीबल मेमोरी और समानांतर बस संचालन 🕞 ™️ 🧛🏽

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

श्रृंखला में पिछले लेख:

आज, हमारी संदर्भ पुस्तक एंबेडेड डिज़ाइन हैंडबुक होगी , या बल्कि, इसका खंड 7.5 होगा। Nios II प्रोसेसर ट्यूटोरियल के साथ टाइटली कपल्ड मेमोरी का उपयोग करना । खंड ही रंगीन है। आज हम प्लेटफ़ॉर्म डिज़ाइनर प्रोग्राम में Intel FPGAs के लिए प्रोसेसर सिस्टम डिज़ाइन करते हैं। ऑल्टर के दिनों में, इसे QSys कहा जाता था (इसलिए परियोजना फ़ाइल का .qsys एक्सटेंशन)। लेकिन Qssys के आने से पहले, सभी ने अपने पूर्वज, SOPC बिल्डर (जिनकी मेमोरी में .sopcinfo फ़ाइल एक्सटेंशन को छोड़ दिया गया था) का उपयोग किया। इसलिए, हालांकि दस्तावेज़ को इंटेल लोगो के साथ चिह्नित किया गया है, लेकिन इसमें मौजूद चित्र इस SOPC बिल्डर के स्क्रीनशॉट हैं। यह स्पष्ट रूप से दस साल पहले से अधिक लिखा गया था, और तब से इसमें केवल शर्तों को ठीक किया गया है। सच है, ग्रंथ काफी आधुनिक हैं, इसलिए यह दस्तावेज प्रशिक्षण मैनुअल के रूप में काफी उपयोगी है।

उपकरण तैयार करना

So. हम अपने स्पार्टन प्रोसेसर सिस्टम में मेमोरी को जोड़ना चाहते हैं, जो कभी भी कैश नहीं होता है और एक ही समय में उच्चतम संभव गति से चलता है। बेशक, यह आंतरिक FPGA मेमोरी होगी। हम कोड और डेटा दोनों के लिए मेमोरी जोड़ेंगे, लेकिन ये अलग-अलग ब्लॉक होंगे। आइए डेटा मेमोरी के साथ सबसे सरल के रूप में शुरू करें। हम सिस्टम में पहले से ज्ञात OnChip मेमोरी को जोड़ते हैं ।

ठीक है, मान लें कि इसकी मात्रा 2 किलोबाइट होगी (FPGA की आंतरिक मेमोरी के साथ मुख्य समस्या यह है कि यह छोटा है, इसलिए आपको इसे सहेजना होगा)। बाकी साधारण मेमोरी है, जिसे हम पहले ही जोड़ चुके हैं।

लेकिन हम इसे डेटा बस से नहीं, बल्कि एक विशेष बस से जोड़ेंगे। इसे प्रदर्शित करने के लिए, हम प्रोसेसर गुणों में जाते हैं, कैश और मेमोरी इंटरफेस टैब पर जाते हैं और चयन सूची में कसकर युग्मित डेटा मास्टर पोर्ट की संख्या 1 का चयन करते हैं।

यहाँ प्रोसेसर के लिए एक नया पोर्ट है:

हम हाल ही में इसमें नए जोड़े गए मेमोरी ब्लॉक को जोड़ते हैं!

एक और ट्रिक इस नई मेमोरी में एड्रेस असाइन करने की है। दस्तावेज़ में पते के डिकोडिंग की इष्टतमता के बारे में तर्क की एक लंबी रेखा है। यह बताता है कि गैर-कैश्ड मेमोरी को स्पष्ट रूप से व्यक्त एक बिट पते द्वारा अन्य सभी प्रकार की मेमोरी से अलग किया जाना चाहिए। इसलिए, दस्तावेज़ में, सभी गैर-कैशेबल मेमोरी 0x2XXXXXXX श्रेणी की है। तो मैन्युअल रूप से पता 0x2000000 दर्ज करें और इसे लॉक करें ताकि यह निम्नलिखित स्वचालित असाइनमेंट के साथ न बदले।

ठीक है, और विशुद्ध रूप से सौंदर्यशास्त्र के लिए, ब्लॉक का नाम बदलें ... चलो इसे कहते हैं, कहते हैं, नॉन-कैक्डडाटा ।

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

ध्यान दें कि दस्तावेज़ क्यों नहीं समझाता है, लेकिन यह ध्यान दिया जाता है कि दोहरे पोर्ट मेमोरी के साथ भी, केवल एक पोर्ट को बिना पढ़े मास्टर से जोड़ा जा सकता है। दूसरा सामान्य से जुड़ा होना चाहिए।

आइए 8 किलोबाइट मेमोरी जोड़ें, इसे ड्यूल-पोर्ट बनाएं, बाकी को डिफ़ॉल्ट रूप से छोड़ दें:

प्रोसेसर में नॉन-कैशेबल इंस्ट्रक्शन पोर्ट जोड़ें:

हम मेमोरी को नॉन-कैशेडकोड कहते हैं, मेमोरी को बसों से जोड़ते हैं, इसे 0x20010000 का पता देते हैं और इसे लॉक करते हैं (दोनों पोर्ट के लिए)। कुल, हमें कुछ ऐसा मिलता है:

वह सब है। हम सिस्टम को सहेजते हैं और उत्पन्न करते हैं, परियोजना को इकट्ठा करते हैं। हार्डवेयर तैयार है। हम सॉफ्टवेयर भाग को पास करते हैं।

सॉफ्टवेयर भाग में बीएसपी की तैयारी

आमतौर पर, प्रोसेसर सिस्टम को बदलने के बाद, बस जनरेट बीएसपी मेनू आइटम का चयन करें, लेकिन आज हमें बीएसपी संपादक को खोलना होगा। चूंकि हम शायद ही कभी ऐसा करते हैं, मुझे आपको याद दिलाना है कि संबंधित मेनू आइटम कहाँ स्थित है:

वहां हम लिंकर स्क्रिप्ट टैब पर जाते हैं। हम देखते हैं कि हमने ऐसे क्षेत्रों को जोड़ा है जो रैम ब्लॉकों से नाम प्राप्त करते हैं:

मैं दिखाऊंगा कि किस अनुभाग को कैसे जोड़ना है जिसमें कोड रखा जाएगा। अनुभाग अनुभाग में, जोड़ें पर क्लिक करें:

दिखाई देने वाली विंडो में, अनुभाग का नाम दें (लेख में भ्रम से बचने के लिए, मैं इसे क्षेत्र के नाम से अलग कहता हूं, अर्थात् nccode) और इसे क्षेत्र के साथ संबद्ध करता हूं (मैंने सूची से NonCachedCode चुना है:

बस यही है, बसपा को पैदा करो और संपादक को बंद करो।

एक नए मेमोरी सेक्शन में कोड डालना

मैं आपको याद दिलाता हूं कि पिछले लेख से विरासत में मिले कार्यक्रम में हमारे दो कार्य हैं: मैजिकफंक्शन 1 () और मैजिकफंक्शन 2 () । पहली बार में, दोनों ने अपने शरीर को कैश में लोड किया, जो ऑसिलोस्कोप पर दिखाई दे रहा था। इसके अलावा, पर्यावरण की स्थिति के आधार पर, उन्होंने या तो अधिकतम गति से काम किया या लगातार अपने शरीर के साथ एक दूसरे को रगड़ते हुए, SDRAM से लगातार डाउनलोड को उकसाया।

आइए पहले फ़ंक्शन को एक नए गैर-कैश्ड सेगमेंट में ले जाएं, और दूसरे स्थान पर छोड़ दें, और फिर कुछ रन बनाएं।

एक नए अनुभाग में एक फ़ंक्शन रखने के लिए, इसमें अनुभाग विशेषता जोड़ें।

मैजिकफंक्शन 1 () फ़ंक्शन को परिभाषित करने से पहले, हम इसकी घोषणा इस विशेषता के साथ करते हैं:

void MagicFunction1()__attribute__ ((section("nccode"))); void MagicFunction1() { IOWR (PIO_0_BASE,0,1); IOWR (PIO_0_BASE,0,0); ...

हम लूप के एक पुनरावृत्ति का पहला रन करते हैं (मैं थोड़ी देर के लिए ब्रेकपॉइंट लगाता हूं):

  while (1) { MagicFunction1(); MagicFunction2(); }

हम निम्न परिणाम देखते हैं:

जैसा कि आप देख सकते हैं, पहला फ़ंक्शन वास्तव में अधिकतम गति पर निष्पादित किया जाता है, दूसरा एसडीआरएएम से लोड होता है। दूसरा रन चलाएँ:

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

 volatile void FuncBetween() { Nops256 Nops256 Nops256 Nops64 Nops64 Nops64 Nops16 Nops16 }

यह सम्मिलन अब दो कार्यों की सापेक्ष स्थिति को प्रभावित नहीं करता है, क्योंकि उनमें से पहला स्मृति के पूरी तरह से अलग क्षेत्र में छोड़ दिया है।

डेटा के बारे में कुछ शब्द

इसी तरह, आप गैर-कैश किए गए डेटा का एक खंड बना सकते हैं और वहां वैश्विक चर डाल सकते हैं, उन्हें एक ही विशेषता बता सकते हैं, लेकिन अंतरिक्ष को बचाने के लिए, मैं ऐसे उदाहरण नहीं दूंगा।

हमने ऐसी मेमोरी के लिए एक क्षेत्र बनाया है, सेक्शन में मैपिंग उसी तरह से की जा सकती है जैसे कि कोड सेक्शन के लिए। यह केवल यह समझने के लिए बना हुआ है कि किसी वैरिएबल को संबंधित विशेषता कैसे सौंपी जाए। स्वचालित रूप से उत्पन्न कोड के आंत्र में पाए जाने वाले ऐसे डेटा को घोषित करने का पहला उदाहरण यहां दिया गया है:

 volatile alt_u32 alt_log_boot_on_flag \ __attribute__ ((section (".sdata"))) = ALT_LOG_BOOT_ON_FLAG_SETTING;

यह हमें क्या देता है

ठीक है, वास्तव में, स्पष्ट चीजों से: अब हम एसडीआरएएम में कोड के मुख्य भाग को रख सकते हैं, और गैर-परिवर्तनीय अनुभाग में हम उन कार्यों को लगा सकते हैं जो समय-समय पर प्रोग्राम बनाते हैं, या जिनका प्रदर्शन अधिकतम होना चाहिए, जो उन्हें धीमा नहीं करना चाहिए। कुछ अन्य फ़ंक्शन लगातार कैश से संबंधित कोड को डंप करते हैं।

टायरों पर करीब से नज़र डालें।

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

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

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

दृष्टिकोण के संबंध में "हम विकास पर ज्यादा समय नहीं देते हैं", ऐसा लगता है:
हमें तैयार मानक टायर के उपयोग को अनुकूलित करने के लिए प्रयास करने की आवश्यकता नहीं है, हम कार्य को हल करने के लिए जल्दी से उन्हें सबसे इष्टतम तरीके से बिछा सकते हैं, इस सहायक विकास को जल्दी से खत्म कर सकते हैं और जल्दी से डिबगिंग या मुख्य परियोजना के परीक्षण की प्रक्रिया सुनिश्चित कर सकते हैं।

आइए सामग्री को समेकित करने के लिए एंबेडेड पेरिफेरल्स आईपी यूजर गाइड से डीएमए ब्लॉक सहित एक उदाहरण देखें।

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

टायर को समानांतर करने के लिए, आप गैर-कैश्ड टायर का भी उपयोग कर सकते हैं, क्योंकि हमने देखा कि कई हो सकते हैं। इन बसों से जुड़े दासों पर कई प्रतिबंध लगाए गए हैं:

दास हमेशा बस में एक होता है;
दास बस विलंब तंत्र का उपयोग नहीं करता है;
लिखना विलंबता हमेशा शून्य होता है; विलंबता पढ़ें हमेशा एक होता है।

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

सामान्य तौर पर, इन मूल सिद्धांतों को जानते हुए, आप निश्चित रूप से वास्तविक कार्यों में उनका उपयोग कर सकते हैं। लेकिन, सामान्य तौर पर, आप कर सकते हैं। आप इसके बिना कर सकते हैं, अगर परिणाम पारंपरिक तरीकों से प्राप्त किया जाता है। लेकिन इसे ध्यान में रखें। कभी-कभी, इन तंत्रों के माध्यम से एक प्रणाली का अनुकूलन कार्यक्रम को ठीक करने की तुलना में सरल होता है।

निष्कर्ष

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

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

रेड के लिए कोड अनुकूलन के तरीके। भाग 2: गैर-कैचीबल मेमोरी और समानांतर बस संचालन