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