जब यह इंटीग्रेटर बनाम इंटेगर का उपयोग करने के लिए neater है?

Question

इस प्रश्न के उत्तर पर टिप्पणी थ्रेड में: VHDL इकाई में गलत आउटपुट यह कहा गया था:

"पूर्णांक के साथ आपके पास FPGA में आंतरिक तर्क प्रतिनिधित्व पर नियंत्रण या पहुंच नहीं है, जबकि SLV आपको कैरी चेन का कुशलतापूर्वक उपयोग करने जैसी तरकीबें देता है"

तो, आपने किन परिस्थितियों में आंतरिक प्रतिनिधित्व का उपयोग करने के लिए पूर्णांक s का उपयोग करने की तुलना में बिट्स प्रतिनिधित्व के वेक्टर का उपयोग करते हुए इसे कोडित किया है ? और आपने किन लाभों को मापा (चिप क्षेत्र, घड़ी की आवृत्ति, देरी, या अन्यथा के संदर्भ में)।

Comments

मुझे लगता है कि यह मापने के लिए कुछ कठिन है, क्योंकि जाहिर है कि यह केवल निम्न-स्तरीय कार्यान्वयन पर नियंत्रण का मामला है।

— clabacchio

Answer 1

मैंने दोनों vectorऔर integerफॉर्म में दो अन्य पोस्टरों द्वारा सुझाए गए कोड को लिखा है , दोनों संस्करणों को यथासंभव समान रूप से संचालित करने का ख्याल रखते हुए।

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

---

Downcounters

सबसे पहले, डेविड केसर द्वारा सुझाए गए डाउनकाउंटर:

library ieee;
use ieee.std_logic_1164.all;
use ieee.numeric_std.all;

entity downcounter is
    generic (top : integer);
    port (clk, reset, enable : in  std_logic; 
         tick   : out std_logic);
end entity downcounter;

वेक्टर वास्तुकला:

architecture vec of downcounter is
begin
    count: process (clk) is
        variable c : unsigned(32 downto 0);  -- don't inadvertently not allocate enough bits here... eg if "integer" becomes 64 bits wide
    begin  -- process count
        if rising_edge(clk) then  
            tick <= '0';
            if reset = '1' then
                c := to_unsigned(top-1, c'length);
            elsif enable = '1' then
                if c(c'high) = '1' then
                    tick <= '1';
                    c := to_unsigned(top-1, c'length);
                else
                    c := c - 1;
                end if;
            end if;
        end if;
    end process count;
end architecture vec;

पूर्ण वास्तुकला

architecture int of downcounter is
begin
    count: process (clk) is
        variable c : integer;
    begin  -- process count
        if rising_edge(clk) then  
            tick <= '0';
            if reset = '1' then
                c := top-1;
            elsif enable = '1' then
                if c < 0 then
                    tick <= '1';
                    c := top-1;
                else
                    c := c - 1;
                end if;
            end if;
        end if;
    end process count;
end architecture int;

परिणाम

कोड-वार, पूर्णांक मेरे लिए बेहतर लगता है क्योंकि यह to_unsigned()कॉल से बचता है । अन्यथा, चुनने के लिए ज्यादा नहीं।

इसे Synplify Pro के माध्यम से चलाने से संस्करण के लिए 66 LUT और संस्करण के लिए 64 LUT काtop := 16#7fff_fffe# उत्पादन होता है । दोनों संस्करण कैरी-चेन का बहुत उपयोग करते हैं। दोनों ने 280MHz से अधिक की घड़ी की गति की रिपोर्ट की । सिंथेसाइज़र कैरी चेन के अच्छे उपयोग को स्थापित करने में काफी सक्षम है - मैंने आरटीएल दर्शक के साथ नेत्रहीन रूप से सत्यापित किया कि दोनों के साथ समान तर्क उत्पन्न होता है। स्पष्ट रूप से तुलनित्र के साथ एक अप-काउंटर बड़ा होगा, लेकिन फिर से पूर्णांक और वैक्टर दोनों के साथ समान होगा।vectorinteger

---

2 ** एन काउंटरों द्वारा विभाजित

Ajs410 द्वारा सुझाया गया:

library ieee;
use ieee.std_logic_1164.all;
use ieee.numeric_std.all;
entity clkdiv is
    port (clk, reset : in     std_logic;
        clk_2, clk_4, clk_8, clk_16  : buffer std_logic);
end entity clkdiv;

वेक्टर वास्तुकला

architecture vec of clkdiv is

begin  -- architecture a1

    process (clk) is
        variable count : unsigned(4 downto 0);
    begin  -- process
        if rising_edge(clk) then  
            if reset = '1' then
                count  := (others => '0');
            else
                count := count + 1;
            end if;
        end if;
        clk_2 <= count(0);
        clk_4 <= count(1);
        clk_8 <= count(2);
        clk_16 <= count(3);
    end process;

end architecture vec;

पूर्ण वास्तुकला

आपको केवल उपयोग करने से बचने के लिए कुछ हुप्स के माध्यम से कूदना होगा to_unsignedऔर फिर बिट्स को चुनना होगा जो स्पष्ट रूप से ऊपर जैसा प्रभाव पैदा करेगा:

architecture int of clkdiv is
begin
    process (clk) is
        variable count : integer := 0;
    begin  -- process
        if rising_edge(clk) then  
            if reset = '1' then
                count  := 0;
                clk_2  <= '0';
                clk_4  <= '0';
                clk_8  <= '0';
                clk_16 <= '0';
            else
                if count < 15 then
                    count := count + 1;
                else
                    count := 0;
                end if;
                clk_2 <= not clk_2;
                for c4 in 0 to 7 loop
                    if count = 2*c4+1 then
                        clk_4 <= not clk_4;
                    end if;
                end loop; 
                for c8 in 0 to 3 loop
                    if count = 4*c8+1 then
                        clk_8 <= not clk_8;
                    end if;
                end loop; 
                for c16 in 0 to 1 loop
                    if count = 8*c16+1 then
                        clk_16 <= not clk_16;
                    end if;
                end loop; 
            end if;
        end if;
    end process;
end architecture int;

परिणाम

कोड-वार, इस मामले में, vectorसंस्करण स्पष्ट रूप से बेहतर है!

संश्लेषण परिणामों के संदर्भ में, इस छोटे से उदाहरण के लिए, पूर्णांक संस्करण (जैसा कि ajs410 की भविष्यवाणी की गई है) तुलना करने वालों के हिस्से के रूप में 3 अतिरिक्त LUTs का उत्पादन करता है, मैं सिंथेसाइज़र के बारे में बहुत आशावादी था, हालांकि यह कोड के एक भयानक रूप से obfuscated टुकड़े के साथ काम कर रहा है!

---

अन्य उपयोग

जब आप रैप-अराउंड के लिए अंकगणित चाहते हैं तो वैक्टर एक स्पष्ट जीत होती है (काउंटरों को एकल पंक्ति के रूप में भी किया जा सकता है):

vec <= vec + 1 when rising_edge(clk);

बनाम

if int < int'high then 
   int := int + 1;
else
   int := 0;
end if;

हालांकि कम से कम यह उस कोड से स्पष्ट है कि लेखक ने एक लपेटने का इरादा किया था।

---

कुछ मैंने वास्तविक-कोड में उपयोग नहीं किया है, लेकिन विचार किया है:

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

integerइस स्थिति में s का उपयोग करने से जब वे लिपटे हैं तो सिमुलेशन त्रुटियों का कारण होगा, भले ही हम जानते हैं कि वे अंत में खोलेंगे।

---

और जैसा कि फिलिप ने बताया, जब आपको 2 ** 31 से बड़ी संख्या की आवश्यकता होती है, तो आपके पास वैक्टर का उपयोग करने के अलावा कोई विकल्प नहीं होता है।

Comments

दूसरे कोड ब्लॉक में आपके पास variable c : unsigned(32 downto 0);... cएक 33 बिट चर नहीं है?

— clabacchio

@clabacchio: हां, जो रैप-अराउंड देखने के लिए 'कैरी-बिट' तक पहुंच की अनुमति देता है।

— मार्टिन थॉम्पसन

Answer 2

जब VHDL लेखन, मैं अत्यधिक के लिए पूर्णांक (पूर्णांक) के बजाय std_logic_vector (SLV) उपयोग करने की अनुशंसा सिग्नल । (दूसरी ओर, जेनेरिक, कुछ स्थिरांक, और कुछ चर के लिए int का उपयोग करना अत्यधिक उपयोगी हो सकता है।) सीधे शब्दों में कहें, यदि आप टाइप इंट का संकेत देते हैं, या पूर्णांक के लिए एक सीमा निर्दिष्ट करना है तो आप शायद कर रहे हैं। कुछ गलत।

Int के साथ समस्या यह है कि VHDL प्रोग्रामर को यह पता नहीं है कि int का आंतरिक तर्क प्रतिनिधित्व क्या है, और इसलिए हम इसका लाभ नहीं उठा सकते हैं। उदाहरण के लिए, यदि मैं 1 से 10 के अंतर को परिभाषित करता हूं तो मुझे पता नहीं है कि कंपाइलर उन मानों को कैसे एनकोड करता है। उम्मीद है कि इसे 4 बिट्स के रूप में एन्कोड किया जाएगा, लेकिन हम इससे आगे नहीं जानते हैं। यदि आप FPGA के अंदर संकेतों की जांच कर सकते हैं तो इसे "0001" से "1010" के रूप में एन्कोड किया जा सकता है, या "0000" के रूप में "1001" में एन्कोड किया जा सकता है। यह भी संभव है कि यह एक तरह से एनकोडेड हो जो कि हम इंसानों के लिए बिलकुल समझ में न आए।

इसके बजाय हमें int के बजाय बस slv का उपयोग करना चाहिए, क्योंकि तब हमारे पास एन्कोडिंग पर नियंत्रण होता है और व्यक्तिगत बिट्स तक भी सीधी पहुंच होती है। प्रत्यक्ष पहुंच महत्वपूर्ण है, जैसा कि आप बाद में देखेंगे।

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

इसलिए, जैसा कि मैंने कहा, एसएलवी के साथ आपको बिट एनकोडिंग पर नियंत्रण और बिट्स तक सीधी पहुंच है। तो आप इससे क्या कर सकते हैं? मैं आपको कुछ उदाहरण दिखाता हूँ। मान लीजिए कि आपको हर 4,294,000,000 घड़ियों को एक बार एक पल्स आउटपुट करने की आवश्यकता है। यहां बताया गया है कि आप इंट के साथ ऐसा कैसे करेंगे:

signal count :integer range 0 to 4293999999;  -- a 32 bit integer

process (clk)
begin
  if rising_edge(clk) then
    if count = 4293999999 then  -- The important line!
      count <= 0;
      pulse <= '1';
    else
      count <= count + 1;
      pulse <= '0';
    end if;
  end if;
end process;

और एसएलवी का उपयोग कर एक ही कोड:

use ieee.numeric_std.all;
signal count :std_logic_vector (32 downto 0);  -- a 33 bit integer, one extra bit!

process (clk)
begin
  if rising_edge(clk) then
    if count(count'high)='1' then   -- The important line!
      count <= std_logic_vector(4293999999-1,count'length);
      pulse <= '1';
    else
      count <= count - 1;
      pulse <= '0';
    end if;
  end if;
end process;

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

अंतर "महत्वपूर्ण पंक्ति" में है।

अंतर उदाहरण के साथ, यह एक 32-इनपुट तुलनित्र में परिणाम करने वाला है। 4-इनपुट LUT के साथ कि Xilinx संयमी -3 का उपयोग करता है, इसके लिए 11 LUTs और तर्क के 3 स्तरों की आवश्यकता होती है। कुछ संकलक इसे एक घटाव में परिवर्तित कर सकते हैं जो कैरी चेन का उपयोग करेगा और 32 LUT के बराबर होगा लेकिन तर्क के 3 स्तरों से अधिक तेज़ हो सकता है।

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

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

यह केवल एक ही उदाहरण है कि तेजी से समय प्राप्त करने के लिए एसएलवी का उपयोग कैसे करें। Slv का उपयोग करने के कई अन्य तरीके हैं - यह केवल कुछ कल्पना लेता है।

अपडेट: मार्टिन थॉमप्सन की टिप्पणियों को संबोधित करने के लिए सामान जोड़ा गया, "अगर (गिनती -1) <0"

(ध्यान दें: मेरा मानना ​​है कि "यदि आप गणना करें तो <0", क्योंकि यह मेरे एसएलवी संस्करण के बराबर होगा और उस अतिरिक्त घटाव की आवश्यकता को दूर करेगा।)

कुछ परिस्थितियों में यह इच्छित तर्क कार्यान्वयन उत्पन्न कर सकता है लेकिन यह सभी समय काम करने की गारंटी नहीं है। यह आपके कोड पर निर्भर करेगा और आपका कंपाइलर इंट वैल्यू को कैसे एन्कोड करता है।

आपके कंपाइलर पर निर्भर करता है, और आप अपने इंट की सीमा को कैसे निर्दिष्ट करते हैं, यह पूरी तरह से संभव है कि शून्य का एक इंटेंस एफपीजीए लॉजिक में "0000 ... 0000" के बिट वेक्टर को एनकोड नहीं करता है। काम करने के लिए आपकी भिन्नता के लिए, इसे "0000 ... 0000" को एन्कोड करना होगा।

उदाहरण के लिए, मान लें कि आप -5 से +5 तक की सीमा को परिभाषित करते हैं। आप "0000", और +5 को "0101" और -5 को "1011" के रूप में एन्कोड करने के लिए 0 के मान की अपेक्षा कर रहे हैं। यह विशिष्ट टॉक्सो-पूरक एन्कोडिंग योजना है।

लेकिन यह मत समझिए कि कंपाइलर ट्वायस-सप्लीमेंट का उपयोग करने वाला है। हालांकि असामान्य, लोगों के पूरक "बेहतर" तर्क हो सकते हैं। या, संकलक "पक्षपातपूर्ण" एन्कोडिंग का एक प्रकार का उपयोग कर सकता है जहां -5 को "0000", 0 को "0101", और +5 को "1010" के रूप में एन्कोड किया गया है।

यदि इंट की एन्कोडिंग "सही" है, तो संकलक को अनुमान होगा कि कैरी बिट के साथ क्या करना है। लेकिन अगर यह गलत है तो परिणामी तर्क भयानक होगा।

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

निरस्त / हस्ताक्षरित बनाम स्लेव अभी तक एक और बहस है। आप हमें VHDL में इतने सारे विकल्प देने के लिए अमेरिकी सरकार की समिति का धन्यवाद कर सकते हैं। :) मैं एसएलवी का उपयोग करता हूं क्योंकि यह मॉड्यूल और कोर के बीच अंतर करने के लिए मानक है। इसके अलावा, और सिमुलेशन में कुछ अन्य मामलों में, मुझे नहीं लगता कि हस्ताक्षरित / अहस्ताक्षरित से अधिक एसएलवी का उपयोग करने का एक बड़ा लाभ है। मुझे यकीन नहीं है कि यदि हस्ताक्षरित / अहस्ताक्षरित समर्थन त्रिकोणीय संकेतों के साथ है।

Comments

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

— फिलिप

फिलिप की तरह, मुझे यकीन नहीं है कि यह एक वैध तुलना है। यदि पूर्णांक उदाहरण नीचे गिना जाता है और उपयोग किया जाता है, तो if (count-1) < 0मुझे लगता है कि सिंथेसाइज़र कैरी आउट बिट का अनुमान लगाएगा और आपके स्लेटी उदाहरण के समान सर्किट का उत्पादन करेगा। इसके अलावा, क्या हमें unsignedइन दिनों प्रकार का उपयोग नहीं करना चाहिए :)

— मार्टिन थॉम्पसन

@DavidKessner आपने निश्चित रूप से एक THOROUGH प्रदान किया है और अच्छी तरह से जवाब दिया है, आपको मेरा +1 मिल गया है। मुझे हालांकि पूछना है ... आप पूरे डिजाइन के अनुकूलन के बारे में चिंतित क्यों हैं? क्या यह बेहतर होगा कि कोड के क्षेत्रों पर अपने प्रयासों को केंद्रित करने की आवश्यकता है या संगतता के लिए इंटरफ़ेस बिंदुओं (इकाई बंदरगाहों) के लिए एसएलवी पर ध्यान केंद्रित करना चाहिए? मुझे पता है कि मेरे अधिकांश डिज़ाइनों में मुझे विशेष रूप से ध्यान नहीं है कि LUT का उपयोग कम से कम किया जाता है, जब तक कि यह समय पूरा करता है और भाग फिट बैठता है। अगर मेरे पास विशेष रूप से तंग बाधाएं हैं, तो मैं निश्चित रूप से इष्टतम डिजाइन के बारे में अधिक जागरूक हूं, लेकिन सामान्य नियम के रूप में नहीं।

— २१:२०

इस उत्तर पर अप-वोटों की संख्या से मैं थोड़ा आश्चर्यचकित हूं। @ bit_vector @ निश्चित रूप से मॉडलिंग और माइक्रो-आर्किटेक्चर को अनुकूलित करने के लिए सही अमूर्त स्तर है, लेकिन एक सामान्य सिफारिश फिर से संकेतों और पोर्ट के लिए "उच्च-स्तर" जैसे "उच्च-स्तरीय" प्रकारों को अजीब लगती है। मैंने इन सुविधाओं को प्रदान करने वाले मूल्य को जानने के लिए अमूर्तता की कमी के कारण पर्याप्त जटिल और अपठनीय कोड देखा है, और अगर मुझे उन्हें पीछे छोड़ना पड़े तो बहुत दुख होगा।

— ट्रेंडडाउन

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

— trondd

Answer 3

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

मैं डेविड केसनर से सहमत हूं कि आप अपने टूलचेन की दया पर हैं, और कोई "सही" जवाब नहीं है। संश्लेषण काला जादू है और यह जानने का सबसे अच्छा तरीका है कि जो कुछ हुआ है उसे ध्यान से और अच्छी तरह से पढ़ें। Xilinx उपकरण यहां तक ​​कि आपको FPGA के अंदर देखने की अनुमति देता है, प्रत्येक LUT को प्रोग्राम करने के तरीके के ठीक नीचे, कैरी चेन कैसे जुड़ी है, स्विच फैब्रिक सभी LUTs को कैसे जोड़ता है, आदि।

श्री केसर के दृष्टिकोण के एक और नाटकीय उदाहरण के लिए, कल्पना करें कि आप 1/2, 1/4, 1/8, 1/16 आदि पर कई घड़ी आवृत्तियाँ चाहते हैं, आप एक पूर्णांक का उपयोग कर सकते हैं जो लगातार हर चक्र को गिनता है, और फिर उस पूर्णांक मान के खिलाफ कई तुलनित्र हैं, जिसके साथ प्रत्येक तुलनित्र आउटपुट एक अलग घड़ी विभाजन बनाता है। तुलना करने वालों की संख्या के आधार पर, प्रशंसक अनुचित रूप से बड़े हो सकते हैं और बफरिंग के लिए अतिरिक्त LUT का सेवन शुरू कर सकते हैं। एसएलवी दृष्टिकोण बस वेक्टर के प्रत्येक व्यक्तिगत बिट को आउटपुट के रूप में ले जाएगा।

Answer 4

एक स्पष्ट कारण यह है कि हस्ताक्षरित और अहस्ताक्षरित 32 बिट पूर्णांक की तुलना में बड़े मूल्यों की अनुमति देते हैं। यह वीएचडीएल भाषा डिजाइन में एक दोष है, जो जरूरी नहीं है। VHDL का एक नया संस्करण ठीक कर सकता है, जिससे पूर्णांक मानों को मनमाने आकार (जावा के बिगआईंट के समान) का समर्थन करने की आवश्यकता होती है।

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

BTW, Jan Decaluwe ने इस पर एक अच्छा निबंध लिखा: ये स्याही काउंटिन के लिए बनाई गई है '

Comments

धन्यवाद फिलिप (हालांकि यह "आंतरिक प्रतिनिधित्व तक पहुंच के माध्यम से बेहतर नहीं है" आवेदन, जो कि मैं वास्तव में उसके बाद क्या कर रहा हूं ...)

— मार्टिन थॉम्पसन

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

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

— फिलिप

@Philippe नहीं, मेरा मतलब था कि यदि आप संश्लेषण परिणामों के बारे में बिल्कुल भी परवाह करते हैं तो यह एक निर्णय कॉल है। ऐसा नहीं है कि संश्लेषण परिणाम स्वयं एक निर्णय कॉल है।

@DavidKessner ठीक है। मैंने गलत समझा।

— फिलिप