ערכי X ו-Z ב-Verilog: הסבר על אותות לא ידועים ועכבה גבוהה

לוגיקה של שני מצבים מול ארבעה מצבים

בתוכנה, ביט הוא 0 או 1. ב-Verilog, ביט יכול לקבל אחד מ_ארבעה_ ערכים:

• 0: ה-wire מוזן לנמוך.
• 1: ה-wire מוזן לגבוה.
• x: הערך של ה-wire לא ידוע. הסימולטור לא יכול לדעת.
• z: ה-wire נמצא בעכבה גבוהה. שום דבר לא מזין אותו.

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

איך x מופיע

הריצו את זה והסתכלו על הפלט:

module unknown_demo;
    reg [3:0] a;
    reg [3:0] b;
    wire [3:0] c;

    // `a` is never assigned.
    assign c = a + b;

    initial begin
        b = 4'd5;
        #1 $display("a=%b b=%b c=%b", a, b, c);
        $finish;
    end
endmodule

a מוצהר אבל אף פעם לא נכתב, ולכן הוא נשאר x. החישוב x + 5 מפיק x: כל חשבון עם ערך לא ידוע מפיק ערך לא ידוע. בפלט תראו x במקום כל ביט, כלומר aaaa שלם של x-ים.

מקורות נפוצים של x בתכנונים שלכם:

• reg שמוצהר אבל אף פעם לא עובר reset (רוב קוד ה-Verilog שמיועד לסינתזה משתמש ב-reset מפורש כדי לאפס אותם).
• פקודת case בלי default, שמקבלת ערך כניסה שאף מקרה לא התאים לו.
• wire שאיבד את מקור ההזנה היחיד שלו אחרי refactor.
• שרשרת if/else שבה ענף אחד לא מבצע השמה לאות שהענף האחר כן מבצע (נוצר latch עם x אם לא מכוסה).
• קריאה מעבר לסוף של וקטור או מערך.

התפשטות X: קצת x הורס הכול

הדבר האכזרי ב-x הוא שהוא מתפשט. ביט x אחד באופרנד הופך את כל התוצאה ל-x:

module x_propagation;
    initial begin
        $display("0       & 1'bx = %b", 1'b0 & 1'bx);   // 0 - the AND identity wins
        $display("1       & 1'bx = %b", 1'b1 & 1'bx);   // x
        $display("1       | 1'bx = %b", 1'b1 | 1'bx);   // 1 - the OR identity wins
        $display("0       | 1'bx = %b", 1'b0 | 1'bx);   // x
        $display("0       + 1'bx = %b", 1'b0 + 1'bx);   // x - arithmetic always taints
        $display("4'hF    & 4'bxx10 = %b", 4'hF & 4'bxx10);
        $finish;
    end
endmodule

שימו לב ש-0 & x הוא 0 (AND עם 0 הוא תמיד 0) ו-1 | x הוא 1 (OR עם 1 הוא תמיד 1). הסימולטור פסימי ברמת הביט, אבל עדיין מכבד זהויות. פעולות חשבון והשוואה לא נדיבות כל כך.

זו הסיבה שרגיסטר אחד שלא אותחל יכול לגרום ל-bus פלט שלם להפוך ל-xxxx. עקבו אחורה מכל x ותמצאו את המקור.

איך z מופיע

z הוא הערך של wire שאף אחד לא מזין:

module z_demo;
    wire [3:0] floating;   // declared, no driver
    reg  enable;
    wire data_out;
    reg  data;

    // A tri-state output: drives `data` when `enable` is high, releases when low.
    assign data_out = enable ? data : 1'bz;

    initial begin
        $display("floating = %b", floating);   // zzzz

        enable = 1; data = 1; #1 $display("driven:  data_out = %b", data_out);
        enable = 0;            #1 $display("released:data_out = %b", data_out);
        $finish;
    end
endmodule

שתי תבניות בקטע הזה:

• floating רק מוצהר ואף פעם לא מוזן. ערך ברירת המחדל שלו הוא z.
• data_out הוא tri-state מכוון. כש-enable נמוך, היציאה משתחררת במפורש ל-z. כך מזין של bus "מרפה" כדי שמזין אחר יוכל להשתלט.

בלוגיקה פנימית, z כמעט תמיד שגוי. בפין דו-כיווני או ב-bus משותף, z הוא בדיוק מה שצריך.

השוואה עם == מול ===

אופרטור השוויון הרגיל == מחזיר x כשלאחד האופרנדים יש ביט x או z:

module compare_demo;
    initial begin
        $display("1'b1 == 1'b1 = %b", 1'b1 == 1'b1);     // 1
        $display("1'b1 == 1'bx = %b", 1'b1 == 1'bx);     // x  - not useful
        $display("1'bx == 1'bx = %b", 1'bx == 1'bx);     // x  - also not useful

        $display("1'b1 === 1'b1 = %b", 1'b1 === 1'b1);   // 1
        $display("1'b1 === 1'bx = %b", 1'b1 === 1'bx);   // 0
        $display("1'bx === 1'bx = %b", 1'bx === 1'bx);   // 1

        $display("$isunknown(1'bx) = %b", $isunknown(1'bx));   // 1
        $finish;
    end
endmodule

=== (ובן זוגו !==) מבצע השוואה קפדנית ביט אחר ביט, כולל x ו-z. השתמשו בו בכל פעם שצריך לבדוק ב-testbench אם ערך הוא x/z או לא. === לא ניתן לסינתזה, אבל בתוך בלוק initial ב-testbench זה לא משנה.

פונקציית המערכת $isunknown(expr) היא הדרך הנקייה ביותר לשאול "האם יש בביטוי הזה ביטים של x או z?": היא מחזירה 1 אם כן ו-0 אם לא.

שימוש ב-x כ-don't-care מכוון

תבנית שנויה במחלוקת אבל לגיטימית: 'x במקרה ה-default של מכונת מצבים אומר לכלי הסינתזה "המצב הזה לא ניתן להשגה, תבצע אופטימיזציה בחופשיות":

case (state)
    IDLE:    next_state = go ? RUNNING : IDLE;
    RUNNING: next_state = done ? IDLE : RUNNING;
    default: next_state = 'x;   // unreachable
endcase

כלי הסינתזה יכול להשתמש ב-x כדי למזג מצבים ולהקטין את מספר השערים. בסימולציה, אם ההיגיון שלכם היה שגוי וה-default כן מושג, תראו x מתפשט מ-next_state והבאג הופך לגלוי מיד.

השתמשו בזה רק אחרי שחשבתם היטב אם ה-default באמת לא ניתן להשגה. אם לא, הגדירו את ה-default למצב בטוח.

מתכון נפוץ לדיבאג

אתם בוהים בצורת גל מלאה ב-x. המתכון:

1. מצאו את ה-x המוקדם ביותר. לכו אחורה בזמן בצורת הגל. האות הראשון שהפך ל-x הוא הקרוב ביותר למקור.
2. מצאו את מקור ההזנה שלו. פתחו את קוד המקור. מה מבצע השמה לאות הזה? assign? בלוק always?
3. בדקו את הכניסות של מקור ההזנה. אם בצד הימני של מקור ההזנה יש x, ההתפשטות עושה בדיוק את מה שהיא אמורה לעשות: הבאג נמצא במעלה הזרם.
4. אם למקור ההזנה יש כניסות נקיות אבל הוא מפיק x, מקור ההזנה לא שלם. case בלי default, if בלי else, רגיסטר בלי reset.

רוב הבאגים של סערת x מסתכמים באחד מאלה: reset חסר, default חסר, או תת-מודול שלא מחובר.

מה הלאה

עכשיו יש לכם את כל התמונה של טיפוסי הנתונים: wire/reg, וקטורים, פרמטרים, ליטרלים מספריים ומודל הלוגיקה בעל ארבעת המצבים. הפרק הבא מתחיל להשתמש בכל זה כדי לבנות ביטויים: אופרטורים מכל הסוגים, כולל האופרטורים ברמת הביט שלא היה להם היגיון בתוכנה.