एक बार फिर FPGA परियोजना के स्रोत कोड में देरी या एक FPGA डेवलपर की नौकरी के लिए साक्षात्कार के लिए एक सरल प्रश्न

कुछ समय पहले, पेशेवर FPGA डेवलपर्स की कंपनी में एक चर्चा के दौरान, एक साक्षात्कार पारित करने के बारे में चर्चा हुई। वहां क्या सवाल पूछे जाते हैं, और क्या पूछे जा सकते हैं। मैंने दो प्रश्न सुझाए:

1. देरी का उपयोग किए बिना एक तुल्यकालिक कोड का एक उदाहरण दें, जो मॉडलिंग करते समय और वास्तविक उपकरणों में काम करते समय अलग-अलग परिणाम देगा
2. इस कोड को देरी से ठीक करें।

इस सवाल के बाद एक जीवंत चर्चा हुई, जिसके परिणामस्वरूप मैंने इस मुद्दे पर अधिक विस्तार से विचार करने का निर्णय लिया।

मैंने पहले ही इस मुद्दे पर पिछले लेख में थोड़ा सा छुआ था। अब और विस्तार से। यहाँ एक उदाहरण पाठ है:

library IEEE; use IEEE.STD_LOGIC_1164.all; entity delta_delay is end delta_delay; architecture delta_delay of delta_delay is signal clk1 : std_logic:='0'; signal clk2 : std_logic; alias clk3 : std_logic is clk1; --    clk1 signal a : std_logic; signal b : std_logic; signal c : std_logic; signal d : std_logic; begin ---    --- clk1 <= not clk1 after 5 ns; pr_a: process begin a <= '0' after 1 ns; wait until rising_edge( clk1 ); wait until rising_edge( clk1 ); a <= '1' after 1 ns; wait until rising_edge( clk1 ); wait until rising_edge( clk1 ); wait until rising_edge( clk1 ); wait until rising_edge( clk1 ); end process; ---   -    --- clk2 <= clk1; --    ,        ---  1 -     --- b <= a when rising_edge( clk1 ); c <= b when rising_edge( clk1 ); d <= b when rising_edge( clk2 ); ---  2 -     --- -- --clk2 <= clk1; --b <= a after 1 ns when rising_edge( clk1 ); --c <= b after 1 ns when rising_edge( clk1 ); --d <= b after 1 ns when rising_edge( clk2 ); ---  3 -          alias --- --b <= a when rising_edge( clk1 ); --c <= b when rising_edge( clk1 ); --d <= b when rising_edge( clk3 ); end delta_delay; 

सादगी के लिए, सभी कोड एक घटक में रखे जाते हैं।

सिग्नल clk1 और टेस्ट एक्सपोजर सिग्नल हैं। clk1 100 मेगाहर्ट्ज की एक घड़ी आवृत्ति है, सिग्नल 0 पर दो घड़ी चक्र रखता है और 1 पर चार घड़ी चक्र होता है। संकेत 1, cl1 के बढ़ते किनारे के सापेक्ष 1 nc की देरी से उत्पन्न होता है। समस्या का वर्णन करने के लिए ये दो संकेत पर्याप्त हैं।

विभिन्न संश्लेषित कोड विकल्प को अनियोजित और मॉडलिंग किया जा सकता है।
पहले विकल्प पर विचार करें, यह बिना देरी के और घड़ी की आवृत्ति के पुनर्मूल्यांकन का उपयोग करके एक संश्लेषित कोड है।

यहां विकल्प 1 के लिए सिमुलेशन परिणाम दिए गए हैं:



आरेख नेत्रहीन यह दर्शाता है कि घड़ी संकेत clk1 और clk2 संयोग करती है, लेकिन वास्तव में clk1 देरी देरी के मूल्य से clk1 के सापेक्ष है। सिग्नल c लैग्स सिग्नल b को एक घड़ी चक्र द्वारा। यह सही है। लेकिन सिग्नल d को संकेत c के साथ मेल खाना चाहिए, लेकिन ऐसा नहीं होता है। यह पहले काम करता है।

आइए याद रखें कि देरी देरी क्या है। यह एक मौलिक अवधारणा है, यह ईवेंट सिमुलेटरों के काम पर आधारित है, जिसका उपयोग हम लॉजिक सर्किट के मॉडलिंग करते समय करते हैं।

सिम्युलेटर में मॉडल समय की अवधारणा है। सिस्टम में सभी घटनाएं इस मॉडल समय से जुड़ी हुई हैं। आइए घड़ी की आवृत्ति के गठन को देखें:

 clk1 <= not clk1 after 5 ns; 

मान लीजिए अब हम केवल clk1 मॉडलिंग कर रहे हैं, कोई अन्य संकेत नहीं हैं।
समय के प्रारंभिक क्षण में, clk1 0 है, यह तब सेट किया जाता है जब सिग्नल घोषित किया जाता है। सिम्युलेटर सिग्नल को पलटने की आवश्यकता देखता है। वर्तमान कीवर्ड वर्तमान मॉडल समय के सापेक्ष 5 ns में एक नया मान असाइन करने के निर्देश देता है। सिम्युलेटर इसे देखता है और नोट करता है कि उस समय 5 एनएस का मूल्य clk1 होगा 1. जबकि यह एक मॉडल भविष्य है, वैसे यह अभी भी बदल सकता है। अगला, सिम्युलेटर शेष संकेतों को स्कैन करता है। सिम्युलेटर यह देखेगा कि मॉडल समय में किसी दिए गए क्षण के लिए, सब कुछ किया जाता है और वह अगले क्षण की गणना कर सकता है। सवाल उठता है - अगले पल क्या है? सिद्धांत रूप में, विभिन्न विकल्प संभव हैं। उदाहरण के लिए, सिमुलिंक में एक निश्चित पिच मोड है। इस मामले में, मॉडल का समय कुछ राशि से बढ़ेगा और गणना जारी रहेगी।

डिजिटल सर्किट सिमुलेशन सिस्टम अलग तरीके से करते हैं। वे अगली घटना पर चलते हैं, जिसे उन्होंने भविष्य में अपने मॉडल समय की धुरी पर रखा है। इस मामले में, यह 5 ns होगा। सिम्युलेटर यह देखेगा कि clk1 बदल गया है और इसके लिए एक नए मूल्य की गणना करेगा, यह 0 होगा जो समय अक्ष पर 5 ns की देरी के साथ भी रखा जाएगा। यानी यह 10 ns होगा। और इसलिए यह प्रक्रिया तब तक जारी रहेगी जब तक कि निर्दिष्ट सिमुलेशन समय समाप्त नहीं हो जाता।

अब संकेत ए और बी जोड़ते हैं।

सिग्नल को प्रक्रिया में सौंपा गया है। सिग्नल बी के लिए , जब उपयोग किया जाता है तो सशर्त निर्माण; आरोह_गेज ( clk1 ) फ़ंक्शन parses clk1 है और सामने निश्चित होने पर वापस लौटता है , अर्थात। पिछला मान 0 है और वर्तमान मान 1 है।

मॉडल समय 5 एनएस, clk1 बदल जाएगा। यह 1 के बराबर हो जाएगा और 10 एनएस के क्षण के लिए इसे 0. पर सेट करने के लिए एक घटना बनाई जाएगी। जबकि हम अभी भी 5 ns के क्षण में हैं और हम गणना जारी रखते हैं। सिम्युलेटर लाइन में जाता है

 b<=a when rising_edge(clk1); 

चूंकि एक फ़ंक्शन है जो clk1 पर निर्भर करता है , सिम्युलेटर फ़ंक्शन के मूल्य की गणना करेगा, यह देखें कि यह सही है और असाइन करेगा

 b<=a; 

यहां सबसे दिलचस्प हिस्सा शुरू होता है - जब बी के मूल्य को बदलना आवश्यक होता है। इस समय, इस समय इसे बदलना आवश्यक प्रतीत होगा। लेकिन हमारे पास समानांतर प्रक्रियाएं हैं। शायद हमें अभी भी अन्य संकेतों की गणना करने के लिए बी के मूल्य की आवश्यकता है। और यहाँ देरी देरी की अवधारणा आती है। यह न्यूनतम मूल्य है जिसके द्वारा मॉडल समय बदलता है। इस मान में समय का आयाम भी नहीं होता है। यह सिर्फ एक डेल्टा है। लेकिन उनमें से कई हो सकते हैं। और इतना कि सिम्युलेटर गलती से बंद हो जाता है या जमा देता है।
तो, b का एक नया मान 5 ns + 1 (1 पहला डेल्टा विलंब) है। सिम्युलेटर यह देखेगा कि पहले से ही 5 ns के लिए गणना करने के लिए पहले से ही कुछ नहीं है और अगले क्षण तक जाएगा, और यह 5 ns + 1 होगा; इस समय, राइजिंग_गेज (ckl1) काम नहीं करता है। और बी का मान 1 पर सेट किया जाएगा। उसके बाद, सिम्युलेटर पल 10 एनसी पर जाएगा।

अब चलो संकेतों को सी , डी जोड़ते हैं और देखते हैं कि वे अलग क्यों हैं।
मॉडल समय 25 ns की देरी को ध्यान में रखते हुए डेल्टा के समय पर विचार करना सबसे अच्छा है

डेल्टा	clk1	clk2	पुनः (clk1)	पुनः (clk2)	ख	ग	घ
0	1	0	सच	झूठा	0	0	0
1	1	1	झूठा	सच	1	0	0
2	1	0	झूठा	झूठा	1	0	1

नोट: पुनः

तालिका से पता चलता है कि जिस समय राइजिंग_डेज ( clk2 ) फ़ंक्शन चालू होता है, b का मान पहले से ही 1. होता है और इसलिए, इसे सिग्नल d को सौंपा जाएगा।

सामान्य ज्ञान के आधार पर, यह वह व्यवहार नहीं है जिसकी हमें कोड से उम्मीद थी। आखिरकार, हमने बस clk2 को संकेत clk1 को पुनः असाइन किया और उम्मीद की कि संकेत c और d समान होंगे। लेकिन सिम्युलेटर के तर्क के बाद, ऐसा नहीं है। यह एक PRINCIPAL फीचर है। यह सुविधा, निश्चित रूप से, FPGA परियोजनाओं के डेवलपर्स के लिए जानी जानी चाहिए और इसलिए यह एक साक्षात्कार के लिए एक अच्छा और आवश्यक प्रश्न है।

संश्लेषण के दौरान क्या होगा? लेकिन सिंथेसाइज़र सामान्य ज्ञान का पालन करेगा, यह संकेतों को clk2 और clk1 को एक संकेत बना देगा और इसलिए c और d भी समान होंगे। और कुछ सिंथेसाइज़र सेटिंग्स के साथ, उन्हें एक सिग्नल में भी जोड़ा जाएगा।

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

 clk2 <= clk1 

अब दूसरा प्रश्न देरी के साथ इस कोड को ठीक करने का है।
यह विकल्प 2 है। इसे अनियोजित और मॉडलिंग किया जा सकता है।
यहाँ परिणाम है।



परिणाम सही है। क्या हुआ था? चलो 25 - 36 एनएस के अंतराल के लिए फिर से एक तालिका बनाते हैं

समय	डेल्टा	clk1	clk2	पुनः (clk1)	पुनः (clk2)	ख	ग	घ
25	0	1	0	सच	झूठा	0	0	0
25	1	1	1	झूठा	सच	0	0	0
26	0	1	1	झूठा	झूठा	1	0	0
35	0	1	0	सच	झूठा	1	0	0
35	1	1	1	झूठा	सच	1	0	0
36	0	1	1	झूठा	झूठा	1	1	1

यह देखा जा सकता है कि मोर्चों clk1 , clk2 के क्षणों में b का मान नहीं बदलता है। 1 एनएस की देरी से एज रिस्पांस ज़ोन से परे सिग्नल में बदलाव होता है। यह कोड वास्तविकता के करीब हो रहा है। एक वास्तविक सर्किट में, ट्रिगर को ट्रिगर करने और सिग्नल को प्रचारित करने के लिए कुछ समय होता है। यह समय घड़ी की आवृत्ति की अवधि से कम होना चाहिए, वास्तव में, यह वही है जो अनुरेखक करता है, और यही समय विश्लेषण की जांच करता है।

त्रुटि का कारण सामान्य असाइनमेंट द्वारा घड़ी संकेत का पुनर्मूल्यांकन है जिस पर एक डेल्टा विलंब दिखाई देता है। हालाँकि, VHDL भाषा में एक अन्य निर्माण है। यह आपको सिग्नल के लिए एक अलग नाम प्राप्त करने की अनुमति देता है। यहाँ घोषणा है:

 alias clk3 : std_logic is clk1; 

उदाहरण पाठ में, आप विकल्प 3 को अनसुना कर सकते हैं - यह सही ढंग से काम करेगा।

यह उदाहरण VHDL में लिखा गया है। शायद यह समस्या केवल इस भाषा की है? लेकिन यहां वेरिलॉग में एक ही विकल्प हैं।

• विकल्प 1 - कोई देरी नहीं। यह ठीक से काम नहीं करता है।
• विकल्प 2 - देरी के साथ। यह सही ढंग से काम करता है।
• विकल्प 3 - तार के माध्यम से पुनर्मूल्यांकन। यह सही ढंग से काम करता है।

वेरिलॉग में रेज और तार की अवधारणा है। इस मामले में, तार के माध्यम से घड़ी संकेत का पुनर्मूल्यांकन अधिक प्राकृतिक दिखता है। यह VHDL में एक उपनाम असाइनमेंट के अनुरूप है। यह कुछ हद तक समस्या के तनाव से छुटकारा दिलाता है, लेकिन आपको अभी भी यह जानने की जरूरत है।
वेरिलॉग में ब्लॉकिंग और नॉन-ब्लॉकिंग असाइनमेंट की अवधारणा भी है। सिग्नल असाइनमेंट b और c को दूसरे तरीके से लिखा जा सकता है:

 always @(posedge clk1) begin c = b; b = a; end 

और आप यह कर सकते हैं:

 always @(posedge clk1) begin b = a; c = b; end 

लाइनों के क्रम के आधार पर, परिणाम अलग होगा।

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

सैंपल फाइलें यहां उपलब्ध हैं।