फॉर-लूप और सामान्य के लिए लागू करने के बीच व्यावहारिक अंतर क्या है? दूसरे पर एक का उपयोग करना बेहतर कब होता है?

Question

मान लीजिए कि मुझे std_logic_vector पर विभिन्न बिट्स का परीक्षण करना है। क्या एक एकल प्रक्रिया को कार्यान्वित करना बेहतर होगा, कि प्रत्येक बिट के लिए लूप्स या 'एन' प्रक्रियाओं को तत्काल उत्पन्न करने के लिए जो प्रत्येक प्रक्रिया का परीक्षण करता है?

के लिए लूप

my_process: process(clk, reset) begin 
    if rising_edge (clk) then 
    if reset = '1' then 
     --init stuff 
    else 
     for_loop: for i in 0 to n loop 
     test_array_bit(i); 
     end loop; 
    end if;  
    end if; 
end process; 

के लिए: जनरेट

for_generate: for i in 0 to n generate begin 
my_process: process(clk, reset) begin 
    if rising_edge (clk) then 
    if reset = '1' then 
     --init stuff 
    else 
     test_array_bit(i); 
    end if; 
    end if; 
end process; 
end generate; 

क्या इस मामलों के लिए FPGA और ASIC कार्यान्वयन पर प्रभाव हो सकता है? सीएडी उपकरण के साथ निपटने के लिए क्या आसान है?

संपादित करें: बस एक प्रतिक्रिया मैं एक को दे दिया पुरुष की मदद करने, मेरे सवाल का अधिक स्पष्ट बनाने के जोड़ने:

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

Answer 1

रीसेट और परीक्षण कार्यों में अपेक्षाकृत सरल तर्क मानना ​​(उदाहरण के लिए, आसन्न बिट्स के बीच कोई इंटरैक्शन नहीं) मैं दोनों को एक ही तर्क उत्पन्न करने की उम्मीद करता।

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

और उस आधार पर, मैं (मामूली) for ... loop संस्करण पसंद करते हैं क्योंकि यह कार्यक्रम तर्क स्थानीयकरण, "उत्पन्न" संस्करण यह globalises जबकि, process बॉयलरप्लेट बाहर रखने से होगा। यदि आपको loop संस्करण पढ़ने के लिए थोड़ा आसान लगता है, तो आप कुछ स्तर पर सहमत होंगे।

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

तो यह साफ शैली में लिखने जहां आप कर सकते हैं के लिए बेहतर है, लेकिन उपकरण सीमाओं और कभी कभी वास्तविक उपकरण दोष के आसपास काम करने के लिए कुछ लचीलेपन के साथ।

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

उदाहरण को संशोधित करने के लिए निर्देशक हो सकता है और यह देख सकता है कि सरलतम मामले के लिए संश्लेषण "इसे सही प्राप्त कर सकता है" (उसी हार्डवेयर का उत्पादन) कर सकता है, और जब तक आप यह नहीं पाते कि कौन सा निर्माण विफल रहता है, जटिलता को फिर से पेश करें।

यदि आप इस तरह से कुछ ठोस पता चलता है, यह (अपने खुद के सवाल का जवाब देने से) यहाँ रिपोर्टिंग के लायक है। Xilinx अपने वेबकेस सिस्टम के माध्यम से ऐसे दोषों की रिपोर्टिंग को प्रोत्साहित करने के लिए प्रयोग किया जाता है; अंत में वे भी तय किए गए थे! ऐसा लगता है कि, हालांकि, पिछले साल या दो में, उन्होंने इसे रोक दिया है।

Answer 2

पहले टुकड़ा के बराबर होगा निम्नलिखित:

my_process: process(clk, reset) begin 
    if rising_edge (clk) then 
    if reset = '1' then 
     --init stuff 
    else 
     test_array_bit(0); 
     test_array_bit(1); 
     ............ 
     test_array_bit(n); 
    end if;  
    end if; 
end process; 

दूसरा एक प्रत्येक i के लिए n+1प्रक्रियाओं उत्पन्न करते हैं, एक साथ रीसेट तर्क और सब कुछ (जो कि के रूप में एक समस्या हो सकती है के साथ तर्क विभिन्न प्रक्रियाओं से एक ही सिग्नल ड्राइव करने का प्रयास करेगा)।
सामान्य रूप से, for लूप अनुक्रमिक बयान होते हैं, जिसमें अनुक्रमिक विवरण होते हैं (यानी प्रत्येक पुनरावृत्ति को पिछले के बाद निष्पादित किया जाना अनुक्रमित किया जाता है)। for-generate लूप समवर्ती कथन होते हैं, जिसमें समवर्ती कथन होते हैं, और उदाहरण के लिए, आप घटक के कई उदाहरण बनाने के लिए इसका उपयोग कैसे कर सकते हैं।