הבנת פעילות אריתמטית ב VHDL

VHDL (VHSIC Hardware Description Language) מספק תמיכה חזקה בביצוע פעולות ⁇ , מה שהופך אותו אבן הפינה לתכנון מערכות דיגיטליות כגון מעבדים, מעבדי אותות דיגיטליים (DSPs), ויחידות בקרה. אריתמטיות בלוקים כמו תוספות, תת-טררקטורים, ומשכפלים הם אבני בניין בסיסיות, ויודעים כיצד ליישם אותם ביעילות הוא קריטי עבור הן סימולציה והן סינתזה.

(ב) לפני ש[דרוש מקור] ל[[המאה ה-20]], [[1924]]]], [[1924]]]]]], [[1924]]]]]], [[1924]]]]]]]]]]]]]]]], [[1924]]]]]]]]]]]]]]]]]], [[1924]]]]]]]]]]]]]], [[1924]]]]]]]]]]]]]]]]]], [[1924]]]]]]]]]]]]]] ו[[1924]], [[1924]], [[1924]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]] [[1924]]]]]]]]]]]]]] [[1924]]]] [[1924]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]] [[1924]] [[1924]]]]]]]]]]]]]]]]]]]]]]]]]], [[[[1924]]]]]]]]]], [[[[1924]]]]]] [[[[[[1966]]]]]] [[[[1966]]]]]] [[[[1924]]]]]]]] [[[[1924]]]]]] [[[[[[1924]]]] [[[[[[[[1924]]]]]] [[[[[[[[[[1924

כל דוגמאות הקוד במאמר זה נכתבות באמצעות FLT:0 [01-2008FLT:1 תואמים VHDL והמטרה Xilinx או Intel (אלטרה) FPGA מכשירים, אבל המושגים חלים על כל זרם עיצוב דיגיטלי.

תוספות ב VHDL

תוספת היא הפעולה הבסיסית ביותר של VHDL, אתה יכול ליישם תוספים ברמות שונות של מופשט: התנהגות (באמצעות FLT:0 +03FLT:1 מפעיל), זרימת נתונים (באמצעות הקצאת אות נוכחית), או מבני (הדגשת רכיבים נמוכים יותר) עבור עיצובים מעשיים ביותר, מודלים התנהגותיים עם FLT:2numic stalrateddigtrated מספק את האיזון הטוב ביותר של יעילות לקרוא.

ריפפל-קארי Adder

שרשרת מדרגות קרועה מלאה יחד, שבו ה-Common-out של כל פיסת מזון מזין את ה-Common-in של החלק העליון הבא.הדוגמה הבאה מציגה סולם של 4 סיביות ללא חתימה באמצעות תהליך התנהגותי:

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;

entity adder4bit is
 Port (
 A : in unsigned(3 downto 0);
 B : in unsigned(3 downto 0);
 Sum : out unsigned(3 downto 0);
 Cout : out std_logic
 );
end adder4bit;

architecture Behavioral of adder4bit is
begin
 process(A, B)
 variable temp_sum : unsigned(4 downto 0);
 begin
 temp_sum := ('0' & A) + ('0' & B);
 Sum <= temp_sum(3 downto 0);
 Cout <= temp_sum(4);
 end process;
end Behavioral;

נקודות מפתח:

  • ה[[18]] ו[[1924]]]]]] [[1924]]]], [[1924]]]]]], [[1924]]]]]], [[1924]]]]]], [[1924]]]]]]]]
  • (ב) שימוש ב-[[1924]] ב[[1924]], [[1924]]]], [[1924]]]], [[1924]]]]]], [[1924]]]]]]]]]], [[1924]]]]]]]], [[1924]]]]]]]], [[1924]]]]]]]]]]]]]], [[1924]]]]]]]]]]
  • רשימת הרגישות של התהליך כוללת את כל אותות הקלט, הבטחת עדכוני התפוקה באופן מיידי על כל שינוי (התנהגות בינלאומית).

צ'יף צ'אט (CLA)

(ב) , (ב) , ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ 

entity adder16bit is
 Port (
 A : in unsigned(15 downto 0);
 B : in unsigned(15 downto 0);
 Sum : out unsigned(15 downto 0);
 CO : out std_logic
 );
end adder16bit;

architecture Behavioral of adder16bit is
 signal temp : unsigned(16 downto 0);
begin
 temp <= ('0' & A) + ('0' & B);
 Sum <= temp(15 downto 0);
 CO <= temp(16);
end Behavioral;

תגית: Overflow Detection

כאשר משתמשים במספרים של EF:0 (המספרים של ההרחבה) מופיעים כאשר הסימן של התוצאה אינו תואם את הסימן הצפוי בהתבסס על הקלטים. Detecting Overflow הוא חיוני במעבד אלוס.

entity signed_adder is
 Port (
 A : in signed(7 downto 0);
 B : in signed(7 downto 0);
 Sum : out signed(7 downto 0);
 Overflow: out std_logic
 );
end signed_adder;

architecture Behavioral of signed_adder is
 signal extended_sum : signed(8 downto 0);
begin
 extended_sum <= (A(7) & A) + (B(7) & B); -- sign extend
 Sum <= extended_sum(7 downto 0);
 Overflow <= extended_sum(8) XOR extended_sum(7); -- sign mismatch
end Behavioral;

רקטורים בVHDL

ניתן ליישם את השימוש הישיר של ה-FLT:0rea-FLT:1 מפעיל או על ידי הוספת השלים של השניים של תת-החל למשכן, בעוד שמודל התנהגותי הוא פשוט, הבנת ה-Low propagation ו-טיפול בתוצאות שליליות הוא חיוני.

המונחים: Behavioral Subtractor

הסובטור הפשוט ביותר משתמש במפעיל ה-FLT:0 (FLT:0)-FreaLT:1 עם סוגים לא חתומה או חתומה.עבור תת-החתרה ללא חתימה, התוצאה עלולה להיות שלילית אם B > A; במקרים כאלה, עלינו לזהות את הנפילה (בור) הדוגמה הבאה מחזירה את ההבדל ואת דגל הלווה:

entity subtractor4bit is
 Port (
 A : in unsigned(3 downto 0);
 B : in unsigned(3 downto 0);
 Diff : out unsigned(3 downto 0);
 Borrow : out std_logic
 );
end subtractor4bit;

architecture Behavioral of subtractor4bit is
 signal temp_diff : signed(4 downto 0);
begin
 process(A, B)
 begin
 temp_diff <= signed('0' & A) - signed('0' & B);
 if temp_diff(4) = '1' then
 Borrow <= '1';
 else
 Borrow <= '0';
 end if;
 Diff <= unsigned(temp_diff(3 downto 0));
 end process;
end Behavioral;

הערה: המרה לדרגה:0 (ה) החתומה על חישוב הביניים; הדבר מאפשר טיפול הולם בהבדלים שליליים.המעט המשמעותי ביותר (זמן דאף (4)) פועל כדגל הלווה.

המונחים: two's Complement

לחלופין, אתה יכול ליישם תת-קרקעית על ידי הוספת השלים של B. טכניקה זו נפוצה כאשר שימוש חוזר בסולם קיים באלו.השלמה של השניים של B נקבעת כ- FLT:0(לא B) + 1IRFLT:1 כאן הוא הרעיון:

signal B_comp : unsigned(3 downto 0);
signal sum_with_borrow : unsigned(4 downto 0);

B_comp <= (not B) + 1; -- two's complement
sum_with_borrow <= ('0' & A) + ('0' & B_comp);
Diff <= sum_with_borrow(3 downto 0);
Borrow <= not sum_with_borrow(4); -- borrow asserted if carry out is 0

שתי השיטות הן ידידותיות לסנתזה; בחרו את זו שמתאימה להעדפות האדריכליות של העיצוב שלכם.

השוואה ופיצול

סובטרטורים משמשים לעתים קרובות ליישום של מחוקקים. על ידי בחינת הלווה או סימן של ההבדל, אתה יכול לקבוע אם A > B, A < B, או A=B ללא מכנה ייעודי. לדוגמה, לאחר תת-טראומה, אם התוצאה היא אפס (כל bits 0), הקלטים שווים.

« « VOHDL

Multiplication הוא יותר משאבים-intensive מאשר תוספת או תת-קרקעית.VHDL תומך ב-FLT:0reas*FLT:1 מפעיל עבור סוגים לא חתומה וחתומה, אשר מפרה מכפיל משולב.עם זאת, עבור רוחבי ביט גדולים יותר, מכפילים משולבים יכולים לצרוך לוגיקה משמעותית ויש להם עיכובים מצטברים ארוכים.

המונחים: Multiplier

1 (ב) 4bit מכפיל באמצעות מפעילת ה-FLT:0) *FcioLT:1 הוא טריוויאלי:

entity multiplier4bit is
 Port (
 A : in unsigned(3 downto 0);
 B : in unsigned(3 downto 0);
 Product : out unsigned(7 downto 0)
 );
end multiplier4bit;

architecture Behavioral of multiplier4bit is
begin
 Product <= A * B;
end Behavioral;

זה מפר מכפיל משולב, אשר ב FPGA הוא בדרך כלל מיושם באמצעות פרוסות DSP ייעודי (כמו Xilinx DSP48 בלוקים) או לוגיקה מבוססת LUT. עבור רוחב עד 18 ביטים, רוב כלי FPGA יכולים למפות את הכפלה יחיד DSP. עבור מכפילים רחב יותר, כלי הסינתזה עשוי לשלב DSPs מרובים או להשתמש לוגיקה רכות.

כפליים (Shift-and-Add)

עבור עיצובים מאומנים באזור או כאשר עיכוב משולב אינו מתקבל על הדעת, מכפיל רצף כי הוא מתרוצץ על ביטים ניתן להשתמש. אלגוריתם השינוי הקלאסי-השינוי-העברה מכפיל שני מספרים N-bit על מחזורי שעון N. להלן הוא דוגמה פשוטה (4-bit מכפיל, ללא חתימה, עם אותות שליטה המוקצבים לבהירות):

entity sequential_multiplier is
 Port (
 clk : in std_logic;
 reset : in std_logic;
 start : in std_logic;
 A : in unsigned(3 downto 0);
 B : in unsigned(3 downto 0);
 done : out std_logic;
 Product : out unsigned(7 downto 0)
 );
end sequential_multiplier;

architecture Behavioral of sequential_multiplier is
 signal multiplicand : unsigned(7 downto 0);
 signal multiplier : unsigned(3 downto 0);
 signal product_reg : unsigned(7 downto 0);
 signal count : integer range 0 to 4;
 signal busy : std_logic;
begin
 process(clk)
 begin
 if rising_edge(clk) then
 if reset = '1' then
 count <= 0;
 busy <= '0';
 product_reg <= (others => '0');
 done <= '0';
 elsif start = '1' and busy = '0' then
 multiplicand <= "0000" & A; -- left-aligned 4-bit multiplicand
 multiplier <= B;
 product_reg <= (others => '0');
 count <= 0;
 busy <= '1';
 done <= '0';
 elsif busy = '1' then
 if multiplier(0) = '1' then
 product_reg <= product_reg + multiplicand;
 end if;
 multiplicand <= multiplicand(6 downto 0) & '0'; -- shift left
 multiplier <= '0' & multiplier(3 downto 1); -- shift right
 count <= count + 1;
 if count = 3 then
 busy <= '0';
 done <= '1';
 end if;
 end if;
 end if;
 end process;
 Product <= product_reg;
end Behavioral;

עיצוב זה משתמש תוספת אחת לביט למחזור השעון (4 מחזורים לקלטות 4 סיביות) הוא חוסך שטח אך מקריב קורבנות באמצעות חתיעה וכבדות.

המונחים: Multiplier

עבור יישומים בעלי ביצועים גבוהים, מכפיל צינורות מתרשם בין שלבים של ריבוי שילוב.רבים FPGA synthesis יכול באופן אוטומטי צינורות מכפיל כאשר אתה מוסיף רישומים צינורות.לדוגמה, באמצעות AFLT:0for...SourceFLT:1 או שלב ידני:

-- Pipelined unsigned 4x4 multiplier (2-stage pipeline)
architecture Pipelined of multiplier4bit is
 signal stage1_prod : unsigned(7 downto 0);
 signal stage1_A, stage1_B : unsigned(3 downto 0);
 signal stage2_prod : unsigned(7 downto 0);
begin
 process(clk)
 begin
 if rising_edge(clk) then
 stage1_A <= A;
 stage1_B <= B;
 stage1_prod <= stage1_A * stage1_B; -- first stage
 stage2_prod <= stage1_prod; -- second stage
 Product <= stage2_prod;
 end if;
 end process;
end Pipelined;

גישה פשוטה זו שתי שלבים מכפילת את לוח (תוצאה אחת לשעון לאחר השקיפות הראשונית) תוך הוספת רק שכבה אחת נוספת של רישום.שלבים נוספים ניתן להוסיף לתאריות שעון גבוהות יותר.

שימוש ב-DSP Slices

(ה-FPGAs מכיל פרוסות DSP קשיחות מוגדרות עבור ריבוי הכפל והצטברות. ב-VHDL, באמצעות שימוש ב- VHDL:0* *03FLT:1 מפעיל לעתים קרובות מפר את המכשולים האלה באופן אוטומטי כדי להבטיח DSP הקצוץ, לעקוב אחר הנחיות הספק: לשמור אופרות בתוך רוחב הפרוסה (למשל, 18x18xxxx, 1825), למנוע מפעילי יחסי גדול על התוצאה, שימוש רוחב 748 ו-F1 המתאים, אך גם כן, אך ניתן להשתמש ב-Flin-iFate.

(ב) ויקרא יא"ד: ויקרא י"ד)

אופטימיזציה טכניקות וסינתזה

כאשר יישום פעולות קידוד ב-VHDL, מספר גורמים משפיעים על איכות התוצאות:

  • (ב) ויקרא: ויקרא י"א): "ה' (ב) ויקרא כ': "וַיָּעָשֶׂה לָעֹאמַר לְךָ עַמֶּה דָּבְתָּבְתָּעָתִיתִי" (במדבר כ"ד, כ"ד).
  • (ב) ויקרא י"ד): "ה' (ב) ויקרא י"ד): "וַיָּבְהִיאֶת הוּא הוּא עַמְתָּבְהִיתִיא הוּא הוּא הוּא הוּא הוּא הוּא הוּא הוּא הוּא הוּא הוּא הוּא הוּא הוּא הוּא הוּא הוּא הוּא הוּא הוּא הוּא הוּא הוּא הוּא הוּא הוּא הוּא הוּא הוּא הוּא הוּא הוּא הוּא הוּא הוּא הוּא הוּא הוּא הוּא הוּא הוּא הוּא הוּא הוּא הוּא הוּא הוּא הוּא הוּא הוּא הוּא הוּא הוּא הוּא הוּא הוּא הוּא הוּא הוּא הוּא הוּא הוּא הוּא הוּא הוּא הוּא הוּא הוּא הוּא הוּא הוּא הוּא הוּא הוּא הוּא הוּא הוּא הוּא הוּא הוּא הוּא הוּא הוּא הוּא הוּא הוּא הוּא הוּא הוּא הוּא הוּא הוּא הוּא הוּא הוּא הוּא הוּא הוּא הוּא הוּא הוּא הוּא
  • (FLT:0) Resource Sharing:FLT:1 אם פעולות מרובות משתמשות באותו סולם או מכפיל, לשקול מחדש חומרה באמצעות רכיב משותף או בלוק ספאם יחיד עם קלטות מרובות.
  • (ב) ,0) ,Pipelining:FLT:1 הכנס נרשם כדי לענות על מגבלות התזמון.
  • (ב) [15] ,ב"ה' (ב"ב)"ה' (ב"ב)"ב"ה, "ה'" (ב"ב)"ב"ה, "ה')"ה', "ה'"ה'" (ב"ב)"ה', "ה'"ה'"ה'" (ב"ב"ב)"ב"ב"ב"ב"ב, כ"ב"ב"ב"ב"ב"ב"ב"ב"ב"ב"ב"ב"ב"ב"ב"ב"ב"ב"ב"ב"ב"ב"ב"ב"ב"ב"ב"ב"ב"ב"ב"ב"ב"ב"ב"ב"ב"ב"ב"ב"ב"ב"ב"ב"ב"ב"ב"ב"ב"ב"ב"ב"ב"ב"ב"ב"ב"ב"ב"ב"ב"ב"ב"ב"ב"ב"ב"ב"ב"ב"ב"ב"ב"ב"ב"ב"ב"ב"ב"ב
  • (FLT:0) שרשראות הקררי:FLT:1 עבור תוספות רחבות, שרשרת לשאת הוא משאב ייעודי ב FPGAs.להבטיח כלי הסינתזה שלך אינו שובר את השרשרת באמצעות אותות ביניים לא מתאימים.

שילוב פעולות: דוגמה

כדי להמחיש כיצד מוסיפים, תת-טרקטורים, והכפליים משתלבים בעיצוב גדול יותר, לשקול יחידת לוגיקה פשוטה אריתמטית (ALU) שיכולה להוסיף, תת-קרקעית, או להכפיל שני ערכי 8 סיביות המבוססים על אות בחירה:

entity alu is
 Port (
 A, B : in signed(7 downto 0);
 op : in std_logic_vector(1 downto 0); -- "00": add, "01": sub, "10": mul
 result : out signed(15 downto 0)
 );
end alu;

architecture Behavioral of alu is
begin
 process(A, B, op)
 begin
 case op is
 when "00" => result <= resize(A + B, 16); -- sign extend
 when "01" => result <= resize(A - B, 16);
 when "10" => result <= A * B;
 when others => result <= (others => '0');
 end case;
 end process;
end Behavioral;

זה ALU reuses אותו תוצאה להירשם ומשלב את שלושת הפעולות. בסנתזה, כל פעולה מיושמת כבלוק נפרד, עם הפלט שנבחר על ידי מספרxer. בהתאם למכשיר היעד, ההכפלה עשויה להיות הדרך הקריטית.

שימוש ב- IP Cores for Complex Arithmetic

עבור פעולות מתקדמות (למשל, נקודת צף, שורש מרובע, מודולו), או כאשר ביצועים מקסימליים נדרשים, מומלץ להשתמש הליבה IP המסופקים על ידי הספק.אלה הם אופטימיזציה מאוד ומודלים סימולציהאומת. ב VHDL, אתה מידידית הליבה IP כמרכיב, מיפוי אותות שלך ליבות משותף כוללים:

  • (FLT:0)Xilinx Floating-Point OperatorveFLT:1) עבור תוספת /sub / multiply / diide בפורמט IEEE 754.
  • [[1924]]]]]] [[1924]]]]]]]]]] [[1924]]]]]]
  • (ב) ,0) ,Lattice DividerárLT 1 עבור חלוקה קבועה.

שימוש בליבת IP מצמצם את הסיכון ולעתים קרובות מביא ביצועים טובים יותר מאשר המקבילות מקובעות יד.פר לתיעוד המוכר עבור תבניות הרגעה.

(ב) FPGA IP Cores Guide of ReveFLT 1

בדיקות ואימות

סימבול הוא קריטי עבור עיצובים של ⁇ .לכתוב בדיקות כי מקרים של פינת פעילות גופנית: על גדות, אפס, ערכים מקסימליים וסימנים מעורבים (עבור סוגים חתומות) עבור מכפילים, לבדוק את כל השילובים של הקלט הקטן ביותר כדי לאמת את האלגוריתם. השתמש ב- FLT:0assertFLT 1 כדי לבדוק תוצאות צפויות.

signal A, B : unsigned(3 downto 0);
signal Sum : unsigned(3 downto 0);
signal Cout : std_logic;
...
A <= "1100"; B <= "0011"; wait for 10 ns;
assert (Sum = "1111" and Cout = '0')
 report "Adder failed for 12 + 3" severity error;

עבור עיצובים גדולים יותר, לשקול שימוש במריצים אקראיים ומודלים זהב בשפות תסריט (Python, Tcl) כדי ליצור וקטורים מבחן.

(ב) ,0) שיטות מבחן (SynthWorks)

מסקנה

יישום פעולות קידוד ב VHDL הוא תערובת של הבנה דיגיטלית סיבולת, שימוש רב-מדעי של סוגי נתונים ומפעילים, ומודעות להתנהגות כלי סינתזה. אדרנים ו subtractors הם פשוט בעת שימוש ב-FLT:0numeric stdexdFLT:1, בעוד מכפילים דורשים שיקול זהיר של ביצועים ואזור.

לקריאה נוספת, להתייעץ עם מדריך הפניה שפה של IEEE VHDL ותיעוד ספציפי של הספק על ההפרעה.

(ב) ויקרא י"ד: ויקרא י"ד ויקרא י"ד ויקרא י"ד ).