ในกระทู้ความคิดเห็นเกี่ยวกับคำตอบสำหรับคำถามนี้: เอาต์พุตผิดใน VHDL เอนทิตีมันถูกระบุไว้:

"ด้วยจำนวนเต็มคุณไม่สามารถควบคุมหรือเข้าถึงการเป็นตัวแทนตรรกะภายในใน FPGA ในขณะที่ SLV ช่วยให้คุณสามารถใช้เทคนิคเช่นการใช้โซ่ได้อย่างมีประสิทธิภาพ"

ดังนั้นในสถานการณ์ใดบ้างที่คุณพบว่า neater to code โดยใช้เวกเตอร์ของการแสดงบิตมากกว่าการใช้จำนวนเต็มเพื่อเข้าถึงการเป็นตัวแทนภายใน และคุณได้ประโยชน์อะไรจากการวัด (ในแง่ของพื้นที่ชิปความถี่สัญญาณนาฬิกาความล่าช้าหรืออย่างอื่น)

ฉันเขียนรหัสที่ผู้โพสต์อีกสองคนแนะนำไว้ทั้งในvectorและintegerรูปแบบโดยระมัดระวังว่าทั้งสองเวอร์ชันทำงานในลักษณะที่คล้ายกันมากที่สุด

ฉันเปรียบเทียบผลลัพธ์ในการจำลองแล้วสังเคราะห์โดยใช้ Synplify Pro การกำหนดเป้าหมาย Xilinx Spartan 6 ตัวอย่างโค้ดด้านล่างถูกวางจากรหัสการทำงานดังนั้นคุณควรจะสามารถใช้พวกเขากับเครื่องสังเคราะห์ที่คุณชื่นชอบและดูว่ามันทำงานเหมือนเดิมหรือไม่

Downcounters

ประการแรกเครื่องมือนับถอยหลังตามที่ David Kessner แนะนำ:

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 พร้อมกับtop := 16#7fff_fffe#สร้าง66 LUTสำหรับvectorรุ่นและ64 LUTสำหรับ integerรุ่น ทั้งสองเวอร์ชันใช้ประโยชน์จากสายโซ่ ทั้งความเร็วสัญญาณนาฬิการายงานเกินกว่า280MHz 280MHzซินธิไซเซอร์นั้นค่อนข้างมีความสามารถในการสร้างการใช้ประโยชน์จากห่วงโซ่การพกพา - ฉันตรวจสอบด้วยสายตาด้วยเครื่องดู RTL ว่ามีการผลิตตรรกะที่คล้ายกันทั้งคู่ เห็นได้ชัดว่า up-counter กับ comparator จะใหญ่กว่า แต่นั่นจะเหมือนกันกับทั้งจำนวนเต็มและเวกเตอร์อีกครั้ง

หารด้วย 2 ** n เคาน์เตอร์

แนะนำโดย 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 คาดการณ์ไว้) จะผลิต LUT พิเศษ 3 ชิ้นซึ่งเป็นส่วนหนึ่งของเครื่องมือเปรียบเทียบ แต่ผมก็มองโลกในแง่ดีเกี่ยวกับเครื่องสังเคราะห์แม้ว่ามันจะทำงานกับโค้ด

การใช้งานอื่น ๆ

เวกเตอร์เป็นผู้ชนะที่ชัดเจนเมื่อคุณต้องการให้เลขคณิตล้อมรอบ (ตัวนับสามารถทำได้แม้แต่บรรทัดเดียว):

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

VS

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

แม้ว่าอย่างน้อยก็ชัดเจนจากรหัสนั้นที่ผู้เขียนตั้งใจล้อมรอบ

สิ่งที่ฉันไม่ได้ใช้ในรหัสจริง แต่ได้ไตร่ตรอง:

คุณสมบัติ "การห่อตามธรรมชาติ" ยังสามารถใช้สำหรับ "การคำนวณผ่านทางล้น" เมื่อคุณรู้ว่าผลลัพธ์ของห่วงโซ่ของการบวก / การลบและการคูณถูกผูกไว้คุณไม่จำเป็นต้องเก็บบิตสูงของการคำนวณระดับกลางไว้เป็น (ในส่วนเสริม 2 s) มันจะออกมา "ในการล้าง" ตามเวลาที่คุณได้รับผลลัพธ์ ฉันบอกว่าบทความนี้มีข้อพิสูจน์เรื่องนี้ แต่มันดูค่อนข้างหนาแน่นสำหรับฉันที่จะทำการประเมินอย่างรวดเร็ว! ทฤษฎีการเพิ่มและล้นของคอมพิวเตอร์ - HL Garner

การใช้งานintegerในสถานการณ์นี้จะทำให้เกิดข้อผิดพลาดในการจำลองเมื่อมีการห่อหุ้มแม้ว่าเราจะรู้ว่าพวกเขาจะแกะในตอนท้าย

และดังที่ฟิลิปป์ชี้ให้เห็นเมื่อคุณต้องการตัวเลขที่มากกว่า 2 ** 31 คุณไม่มีทางเลือกนอกจากใช้เวกเตอร์

เมื่อเขียน VHDL ฉันขอแนะนำให้ใช้ std_logic_vector (slv) แทนจำนวนเต็ม (int) สำหรับSIGNALSสัญญาณ(ในทางกลับกันการใช้ int สำหรับ generics ค่าคงที่บางค่าและตัวแปรบางอย่างอาจมีประโยชน์อย่างมาก) เพียงแค่ใส่ถ้าคุณประกาศสัญญาณประเภท int หรือต้องระบุช่วงสำหรับจำนวนเต็มคุณอาจกำลังทำ บางสิ่งผิดปกติ.

ปัญหาของ int คือโปรแกรมเมอร์ VHDL ไม่รู้ว่าการแทนค่าตรรกะภายในของ int นั้นคืออะไรดังนั้นเราจึงไม่สามารถใช้ประโยชน์จากมันได้ ตัวอย่างเช่นถ้าฉันกำหนด int ของช่วง 1 ถึง 10 ฉันไม่รู้ว่าคอมไพเลอร์เข้ารหัสค่าเหล่านั้นอย่างไร หวังว่ามันจะถูกเข้ารหัสเป็น 4 บิต แต่เราไม่รู้อะไรมากไปกว่านั้น หากคุณสามารถสอบสวนสัญญาณภายใน FPGA มันอาจถูกเข้ารหัสเป็น "0001" ถึง "1010" หรือเข้ารหัสเป็น "0000" ถึง "1001" อาจเป็นไปได้ว่ามันถูกเข้ารหัสด้วยวิธีที่ไม่สมเหตุสมผลกับมนุษย์เรา

แต่เราควรใช้ slv แทน int เพราะจากนั้นเราสามารถควบคุมการเข้ารหัสและเข้าถึงโดยตรงไปยังแต่ละบิต การเข้าถึงโดยตรงเป็นสิ่งสำคัญอย่างที่คุณจะเห็นในภายหลัง

เราสามารถใช้ int เพื่อ slv เมื่อใดก็ตามที่เราต้องการเข้าถึงบิตแต่ละอัน แต่มันก็ยุ่งเหยิงเร็วมาก นั่นเหมือนกับการได้รับสิ่งที่เลวร้ายที่สุดของทั้งสองโลกแทนที่จะเป็นสิ่งที่ดีที่สุดของทั้งสองโลก โค้ดของคุณจะยากสำหรับคอมไพเลอร์ในการปรับให้เหมาะสมและแทบเป็นไปไม่ได้ที่คุณจะอ่าน ฉันไม่แนะนำสิ่งนี้

ดังที่ฉันพูดด้วย slv คุณสามารถควบคุมการเข้ารหัสบิตและเข้าถึงบิตโดยตรง แล้วคุณจะทำอย่างไรกับสิ่งนี้ ฉันจะแสดงตัวอย่างให้คุณดู สมมติว่าคุณต้องส่งสัญญาณพัลส์หนึ่งครั้งทุก ๆ 4,294,000,000 นาฬิกา นี่คือวิธีที่คุณจะทำกับ int:

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;

และรหัสเดียวกันโดยใช้ slv:

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;

รหัสนี้ส่วนใหญ่เหมือนกันระหว่าง int และ slv อย่างน้อยก็ในแง่ของขนาดและความเร็วของตรรกะที่เกิดขึ้น แน่นอนว่าคนหนึ่งกำลังนับและอีกคนกำลังนับถอยหลัง แต่นั่นไม่สำคัญสำหรับตัวอย่างนี้

ความแตกต่างอยู่ใน "บรรทัดสำคัญ"

จากตัวอย่าง int สิ่งนี้จะส่งผลให้ตัวเปรียบเทียบแบบ 32- อินพุต ด้วย 4-LUT LUT ที่ Xilinx Spartan-3 ใช้นี่จะต้องใช้ 11 LUTs และตรรกะ 3 ระดับ คอมไพเลอร์บางตัวอาจแปลงสิ่งนี้ให้เป็นการลบซึ่งจะใช้โซ่หิ้วและขยายที่เทียบเท่ากับ 32 LUT แต่อาจวิ่งได้เร็วกว่าตรรกะ 3 ระดับ

จากตัวอย่าง slv ไม่มีการเปรียบเทียบแบบ 32 บิตดังนั้นจึงเป็น "ศูนย์ LUT's, ระดับศูนย์ตรรกะ" โทษเพียงอย่างเดียวคือที่เคาน์เตอร์ของเราเป็นหนึ่งบิตพิเศษ เนื่องจากช่วงเวลาเพิ่มเติมสำหรับตัวนับบิตพิเศษนี้ทั้งหมดอยู่ในโซ่หิ้วพกพาจึงมีการหน่วงเวลาเพิ่มเติมเกือบเป็นศูนย์

แน่นอนว่านี่เป็นตัวอย่างที่ดีมากเนื่องจากคนส่วนใหญ่จะไม่ใช้ตัวนับ 32 บิตในลักษณะนี้ มันใช้กับเคาน์เตอร์ขนาดเล็ก แต่ความแตกต่างจะลดลงอย่างมากแม้ว่าจะยังคงสำคัญ

นี่เป็นเพียงตัวอย่างหนึ่งของวิธีการใช้ slv over int เพื่อให้ได้เวลาที่เร็วขึ้น มีวิธีอื่น ๆ อีกมากมายที่จะใช้ประโยชน์จาก slv - ใช้เวลาจินตนาการเพียงอย่างเดียว

อัปเดต: เพิ่มรายการเพื่อระบุความคิดเห็นของ Martin Thompson เกี่ยวกับการใช้ int กับ "if (count-1) <0"

(หมายเหตุ: ฉันถือว่าคุณหมายถึง "ถ้านับ <0" เนื่องจากจะทำให้มันเทียบเท่ากับรุ่น slv ของฉันและลบความจำเป็นในการลบพิเศษนั้น)

ภายใต้สถานการณ์บางอย่างสิ่งนี้อาจสร้างการใช้งานตรรกะที่ตั้งใจ แต่ไม่รับประกันว่าจะทำงานตลอดเวลา มันจะขึ้นอยู่กับรหัสของคุณและคอมไพเลอร์ของคุณเข้ารหัสค่า int

ขึ้นอยู่กับคอมไพเลอร์ของคุณและวิธีที่คุณระบุช่วงของ int เป็นไปได้โดยสิ้นเชิงว่าค่า int ของศูนย์ไม่ได้เข้ารหัสเป็นบิตเวกเตอร์ของ "0000 ... 0000" เมื่อมันทำให้เป็นตรรกะ FPGA เพื่อให้รูปแบบของคุณทำงานต้องเข้ารหัสเป็น "0000 ... 0000"

ตัวอย่างเช่นสมมติว่าคุณกำหนด int ให้มีช่วง -5 ถึง +5 คุณคาดหวังว่าค่า 0 จะถูกเข้ารหัสเป็น 4 บิตเช่น "0000" และ +5 เป็น "0101" และ -5 เป็น "1011" นี่เป็นรูปแบบการเข้ารหัสแบบเติมเต็มทั่วไป

แต่อย่าคิดว่าคอมไพเลอร์จะใช้ twos-complement แม้ว่าผิดปกติการเติมเต็มอาจส่งผลให้ตรรกะ "ดีกว่า" หรือคอมไพเลอร์สามารถใช้การเข้ารหัสแบบ "biased" โดยที่ -5 ถูกเข้ารหัสเป็น "0000", 0 เป็น "0101" และ +5 เป็น "1010"

หากการเข้ารหัสของ int นั้น "ถูกต้อง" ผู้แปลจะมีแนวโน้มที่จะสรุปว่าจะทำอย่างไรกับบิตนำพา แต่ถ้ามันไม่ถูกต้องแล้วตรรกะที่เกิดขึ้นจะน่ากลัว

อาจเป็นไปได้ว่าการใช้ int ด้วยวิธีนี้อาจส่งผลให้เกิดขนาดและความเร็วของตรรกะที่สมเหตุสมผล แต่ไม่สามารถรับประกันได้ การสลับไปใช้คอมไพเลอร์อื่น (เช่น XST เป็นเรื่องย่อ) หรือไปที่สถาปัตยกรรม FPGA อื่นอาจทำให้เกิดสิ่งผิดปกติขึ้น

Unsigned / Signed vs. slv เป็นอีกการถกเถียงกัน คุณสามารถขอบคุณคณะกรรมการรัฐบาลสหรัฐฯที่ให้ทางเลือกมากมายแก่เราใน VHDL :) ฉันใช้ slv เพราะนั่นเป็นมาตรฐานสำหรับการเชื่อมต่อระหว่างโมดูลและคอร์ นอกเหนือจากนั้นและกรณีอื่น ๆ ในแบบจำลองฉันไม่คิดว่ามีประโยชน์มากในการใช้ slv ผ่านการลงชื่อ / ไม่ได้ลงชื่อ ฉันก็ไม่แน่ใจเหมือนกันว่าสัญญาณที่รองรับสัญญาณระบุตรี

คำแนะนำของฉันคือลองทั้งสองอย่างจากนั้นดูที่การสังเคราะห์แผนที่และรายงานสถานที่และเส้นทาง รายงานเหล่านี้จะบอกให้คุณทราบถึงจำนวน LUT แต่ละวิธีที่ใช้ไปอย่างแน่นอนพวกเขาจะบอกคุณถึงความเร็วสูงสุดที่ตรรกะสามารถทำงานได้

ฉันเห็นด้วยกับ David Kessner ว่าคุณอยู่ในความเมตตาของห่วงโซ่เครื่องมือของคุณและไม่มีคำตอบที่ "ถูกต้อง" การสังเคราะห์คือมนต์ดำและวิธีที่ดีที่สุดที่จะรู้ว่าสิ่งที่เกิดขึ้นคือการอ่านรายงานที่ผลิตออกมาอย่างรอบคอบและละเอียดถี่ถ้วน เครื่องมือ Xilinx ช่วยให้คุณสามารถมองเห็นภายใน FPGA ลงไปถึงวิธีการตั้งโปรแกรม LUT แต่ละวิธีการเชื่อมต่อของโซ่หิ้ววิธีที่สวิทช์ผ้าเชื่อมต่อกับ LUT ทั้งหมด ฯลฯ

สำหรับตัวอย่างที่น่าทึ่งอีกอย่างของแนวทางของ Mr. Kessner ให้จินตนาการว่าคุณต้องการมีความถี่สัญญาณนาฬิกาหลาย ๆ ค่าที่ 1/2, 1/4, 1/8, 1/16 เป็นต้นคุณสามารถใช้จำนวนเต็มที่นับทุกรอบอย่างต่อเนื่อง จากนั้นมีตัวเปรียบเทียบหลายตัวเทียบกับค่าจำนวนเต็มนั้นโดยเอาต์พุตเปรียบเทียบแต่ละตัวจะสร้างส่วนนาฬิกาที่แตกต่างกัน ขึ้นอยู่กับจำนวนของเครื่องมือเปรียบเทียบ fanout อาจมีขนาดใหญ่เกินสมควรและเริ่มใช้ LUT พิเศษเพื่อการบัฟเฟอร์ วิธี SLV จะใช้บิตของแต่ละเวกเตอร์เป็นเอาต์พุต

เหตุผลหนึ่งที่เห็นได้ชัดคือการลงนามและไม่ได้ลงนามอนุญาตให้มีค่ามากกว่าจำนวนเต็ม 32 บิต นั่นเป็นข้อบกพร่องในการออกแบบภาษา VHDL ซึ่งไม่จำเป็น VHDL เวอร์ชันใหม่สามารถแก้ไขได้โดยต้องการค่าจำนวนเต็มเพื่อรองรับขนาดโดยพลการ (คล้ายกับ BigInt ของ Java)

นอกจากนั้นฉันสนใจที่จะฟังเกี่ยวกับการวัดประสิทธิภาพที่แตกต่างกันสำหรับจำนวนเต็มเมื่อเทียบกับเวกเตอร์

BTW ม.ค. Decaluwe เราเขียนเรียงความที่ดีเกี่ยวกับเรื่องนี้: Ints เหล่านี้สร้างขึ้นเพื่อ Countin '