खोज…


टिप्पणियों

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

[वास्तव में, यह 100% सत्य नहीं है। फ़ाइल इनपुट / आउटपुट का उपयोग करके प्रक्रियाएं भी संवाद कर सकती हैं। लेकिन अगर कोई डिजाइनर फाइलों का उपयोग करके नियतत्ववाद से समझौता कर रहा था, तो यह वास्तव में गलती नहीं हो सकती है।]

इस प्रकार भाषा सुरक्षित थी। उद्देश्य को छोड़कर, गैर-नियतात्मक वीएचडीएल मॉडल डिजाइन करना लगभग असंभव था।

वीएचडीएल 1993 ने साझा चर पेश किए और गैर-नियतात्मक वीएचडीएल मॉडल डिजाइन करना बहुत आसान हो गया।

वीएचडीएल 2000 ने संरक्षित प्रकार पेश किए और जो चर साझा किए गए हैं वे बाधा संरक्षित प्रकार के होने चाहिए।

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

केवल अनुकार के लिए उच्च स्तरीय VHDL मॉडल डिजाइन करते समय संरक्षित प्रकार बहुत उपयोगी होते हैं। उनके पास ओओ भाषाओं के कई बहुत अच्छे गुण हैं। उनका बार-बार उपयोग करना कोड को अधिक पठनीय, बनाए रखने योग्य और पुन: प्रयोज्य बनाता है।

टिप्पणियाँ:

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

एक छद्म यादृच्छिक जनरेटर

सिमुलेशन वातावरण डिजाइन करते समय Peudo-random जनरेटर अक्सर उपयोगी होते हैं। निम्न VHDL पैकेज boolean , bit और bit_vector छद्म यादृच्छिक जनरेटर को डिजाइन करने के लिए संरक्षित प्रकारों का उपयोग करने का तरीका bit_vector । यह आसानी से यादृच्छिक std_ulogic_vector उत्पन्न करने के लिए बढ़ाया जा सकता है, signed , unsigned । मनमाने ढंग से सीमा के साथ यादृच्छिक पूर्णांक उत्पन्न करने के लिए इसका विस्तार करना और एक समान वितरण थोड़ा अधिक मुश्किल है लेकिन उल्लेखनीय है।

पैकेज की घोषणा

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

-- file rnd_pkg.vhd
package rnd_pkg is
    type rnd_generator is protected
        procedure init(seed: bit_vector);
        impure function get_boolean return boolean;
        impure function get_bit return bit;
        impure function get_bit_vector(size: positive) return bit_vector;
    end protected rnd_generator;
end package rnd_pkg;

पैकेज बॉडी

संरक्षित प्रकार का शरीर आंतरिक डेटा संरचनाओं (सदस्यों) और उपप्रोग्राम निकायों को परिभाषित करता है। हमारा यादृच्छिक जनरेटर चार नल के साथ 128-बिट रैखिक प्रतिक्रिया शिफ्ट रजिस्टर (LFSR) पर आधारित है। state चर LFSR की वर्तमान स्थिति को संग्रहीत करता है। एक निजी throw प्रक्रिया LFSR को शिफ्ट करने के लिए हर बार जनरेटर का उपयोग किया जाता है।

-- file rnd_pkg.vhd
package body rnd_pkg is
    type rnd_generator is protected body
        constant len: positive := 128;
        constant default_seed: bit_vector(1 to len) := X"8bf052e898d987c7c31fc71c1fc063bc";
        type tap_array is array(natural range <>) of positive range 1 to len;
        constant taps: tap_array(0 to 3) := (128, 126, 101, 99);

        variable state: bit_vector(1 to len) := default_seed;

        procedure throw(n: positive := 1) is
            variable tmp: bit;
        begin
            for i in 1 to n loop
                tmp := '1';
                for j in taps'range loop
                    tmp := tmp xnor state(taps(j));
                end loop;
                state := tmp & state(1 to len - 1);
            end loop;
        end procedure throw;

        procedure init(seed: bit_vector) is
            constant n:   natural            := seed'length;
            constant tmp: bit_vector(1 to n) := seed;
            constant m:   natural            := minimum(n, len);
        begin
            state         := (others => '0');
            state(1 to m) := tmp(1 to m);
        end procedure init;

        impure function get_boolean return boolean is
            constant res: boolean := state(len) = '1';
        begin
            throw;
            return res;
        end function get_boolean;

        impure function get_bit return bit is
            constant res: bit := state(len);
        begin
            throw;
            return res;
        end function get_bit;

        impure function get_bit_vector(size: positive) return bit_vector is
            variable res: bit_vector(1 to size);
        begin
            if size <= len then
                res := state(len + 1 - size to len);
                throw(size);
            else
                res(1 to len) := state;
                throw(len);
                res(len + 1 to size) := get_bit_vector(size - len);
            end if;
            return res;
        end function get_bit_vector;
    end protected body rnd_generator;
end package body rnd_pkg;

यादृच्छिक जनरेटर को तब OO शैली में उपयोग किया जा सकता है:

-- file rnd_sim.vhd
use std.env.all;
use std.textio.all;
use work.rnd_pkg.all;

entity rnd_sim is
end entity rnd_sim;

architecture sim of rnd_sim is
    shared variable rnd: rnd_generator;
begin
    process
        variable l: line;
    begin
        rnd.init(X"fe39_3d9f_24bb_5bdc_a7d0_2572_cbff_0117");
        for i in 1 to 10 loop
            write(l, rnd.get_boolean);
            write(l, HT);
            write(l, rnd.get_bit);
            write(l, HT);
            write(l, rnd.get_bit_vector(10));
            writeline(output, l);
        end loop;
        finish;
    end process;
end architecture sim;
$ mkdir gh_work
$ ghdl -a --std=08 --workdir=gh_work rnd_pkg.vhd rnd_sim.vhd
$ ghdl -r --std=08 --workdir=gh_work rnd_sim
TRUE    1    0001000101
FALSE   0    1111111100
TRUE    1    0010110010
TRUE    1    0010010101
FALSE   0    0111110100
FALSE   1    1101110010
TRUE    1    1011010110
TRUE    1    0010010010
TRUE    1    1101100111
TRUE    1    0011100100
simulation finished @0ms


Modified text is an extract of the original Stack Overflow Documentation
के तहत लाइसेंस प्राप्त है CC BY-SA 3.0
से संबद्ध नहीं है Stack Overflow