FPGA: गिनें या गिनें?

Question

मैं एक FPGA (पैपिलियो डेवलपमेंट बोर्ड, जिसमें xilinx संयमी 3e है, vhdh का उपयोग करके) का उपयोग करना सीख रहा हूं।

मुझे एक आवक पल्स को एक (हार्ड कोडित) संख्या से विभाजित करने की आवश्यकता है।

मैं 3 विकल्प देख सकता हूं - मोटे तौर पर, स्यूडोकोड के रूप में (उदाहरण के रूप में 10 गिनती का उपयोग करके):

1. 10 की तुलना में 1 से इनपुट बढ़ती बढ़त पर, 0 के लिए प्रारंभिक; यदि वे समान हैं, तो 0 पर रीसेट करें और आउटपुट पल्स को ट्रिगर करें
2. 10 से प्रारंभिक, इनपुट बढ़ती बढ़त पर 1 से कम, 0 की तुलना में; यदि वे समान हैं, तो 10 पर रीसेट करें और आउटपुट पल्स को ट्रिगर करें
3. 9 पर प्रारंभ करें, लेकिन सुनिश्चित करें कि कम से कम 1 अग्रणी "0" बिट है, जो मेरा आउटपुट बिट है। इनपुट राइजिंग एज घटने से 1. आउटपुट बिट के बढ़ते किनारे पर, रीसेट करें।

कर्तव्य चक्र महत्वहीन है।

क्या इनमें से एक दूसरों की तुलना में बेहतर है? वहाँ एक बेहतर तरीका है कि मैं के बारे में सोचा नहीं है?

क्या कोई "मानक" तरीका है जो कंपाइलर को अनुकूलन का सबसे अच्छा मौका देगा?

Comments

यह केवल तीन विकल्प हैं :-) ... लेकिन गंभीरता से, यह वास्तव में एक FPGA में इतना सब मायने नहीं रखता है। व्यक्तिगत तर्क तत्व पर्याप्त रूप से सामान्य होते हैं कि यह लगभग समान संसाधनों को लेता है और आपको वही प्रदर्शन देता है जो भी आप इसे करते हैं। यह निर्णय नीचे आता है कि क्या यह डिजाइन में कहीं और उपयोगी है ताकि संख्याओं की गिनती ऊपर या नीचे हो या कुछ अन्य पैटर्न हो।

— डेव ट्वीड

4 वां विकल्प: 10-बिट सर्कुलर शिफ्ट रजिस्टर "1000000000" के साथ लोड किया गया और बढ़ते किनारे पर स्थानांतरित कर दिया गया। शिफ्ट रजिस्टर के एक बिट का उपयोग करें जो आप कर रहे हैं उसके लिए सक्षम करें।

— लिंकन

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

— बेनामी

Answer 1

इस स्तर पर अनुकूलन आपके दिल को तोड़ देगा। आपके द्वारा उपयोग किए जा रहे FPGA की तकनीक, FPGA के अन्य कारकों के कारण परिणाम बदल सकता है, लेकिन यह भी कि आपके नियंत्रण से बाहर के कारकों के कारण, जिसमें फ़िटर का यादृच्छिक नंबर बीज भी शामिल है।

ऐसा कहने के बाद, मेरा मानना ​​है कि विकल्प 3 सबसे अच्छा होगा। विकल्प 1 और 2 में एक तुलनित्र / OR गेट है जो काउंटरों के बीच जा रहा है ताकि यह संकेत दे सके कि लक्ष्य संख्या तक पहुँच गया है। विकल्प 2 1 से थोड़ा तेज हो सकता है, क्योंकि यह सभी सीधे हो सकता है या किसी भी इनवर्टर के बिना एक साथ हो सकता है, लेकिन फिर से आप छोटे प्रौद्योगिकी मतभेदों में भाग लेते हैं जहां यह AND या XOR के लिए तेज़ हो सकता है।

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

काउंटरों के बारे में एक मजेदार तथ्य यह है कि वे एक लॉजिक ब्लॉक के भीतर एक डिवाइस विशिष्ट आकार में समूहीकृत होते हैं, और यदि आप इस अतिरिक्त बिट को उस समूह से बाहर धकेलते हैं तो आपको समय से अधिक बदलाव की उम्मीद है।

Comments

+1, बारिंग गति, जो कि प्रौद्योगिकी की सीमाओं को धक्का देती है, को समय रिपोर्ट को अपने समय के अनुकूलन का मार्गदर्शन करने देना चाहिए। एक स्पार्टन 3e, या उस मामले के लिए किसी भी FPGA पर सैकड़ों पिकोसेकंड का पीछा करना, बिना कारण के आमतौर पर समय की बर्बादी है।

— jalalipop

Answer 2

एक अन्य विकल्प यह होगा कि काउंटर को 6 (= 2 ⁴ - 10) से शुरू करें, गिनें और फिर रीसेट करें जब कैरी आउटपुट सक्रिय हो जाए (यानी, एफएफ सभी हैं)।

इसका लाभ यह है कि इसके लिए अतिरिक्त एफएफ की आवश्यकता नहीं होती है, और कई एफजीपीए ने काउंटर या योजक सर्किट में इस तरह के कैरी ऑपरेशन को तेज करने के लिए सहायक तर्क को समर्पित किया है।

Answer 3

निर्भर करता है। उदाहरण के लिए: 0 → 1 और 1 → 0 के लिए फ्लिप-फ्लॉप प्रचार देरी अलग हो सकती है, और इसलिए काउंटर का संक्रमण 000 → 001 और 001 → 000 के लिए थोड़ा भिन्न हो सकता है। यह उच्च या निम्न हो सकता है, जो कि FPGA में प्रयुक्त cmos तकनीक पर निर्भर करता है। इसलिए आपको संश्लेषित करना होगा और यह पता लगाना होगा कि किसका प्रदर्शन बेहतर है।

Answer 4

संकलक लेखक के दृष्टिकोण से: यदि आप उपयोग करते हैं integer, तो आंतरिक प्रतिनिधित्व अपरिभाषित है, और संकलक सबसे कुशल कार्यान्वयन चुनने के लिए स्वतंत्र है।

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

$N-1$

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