1. No category

‫‪R‬‬
‫‪R‬‬
‫‪R‬‬
‫הטכניון‬
‫מכון טכנולוגי לישראל‬
‫מרכז מחקר למערכות ‪VLSI‬‬
‫הפקולטות להנדסת חשמל ומדעי המחשב‬
‫‪R‬‬
‫‪R‬‬
‫‪R‬‬
‫‪R‬‬
‫המעבדה ל – ‪VLSI‬‬
‫‪R‬‬
‫‪R‬‬
‫‪R‬‬
‫מעבדה ‪3 ,2‬‬
‫‪R‬‬
‫‪R‬‬
‫ניסוי בארכיטקטורות וסינתזה של‬
‫מעגלי ‪VLSI‬‬
‫‪R‬‬
‫‪R‬‬
‫‪R‬‬
‫‪R‬‬
‫‪R‬‬
‫מהדורה חדשה ‪ -‬הערות נא לשלוח ל‪goel@ee-‬‬
‫‪R‬‬
‫כל הערה תתקבל בברכה!‬
‫עדכון אחרון ‪13:04 07/10/2015 -‬‬
‫‪R‬‬
‫‪R‬‬
‫‪UTH‬‬
‫‪http://www.ee.technion.ac.il/vlsi/‬‬
‫‪HTU‬‬
‫מסמך זה כתוב בלשון זכר ע"מ להקל על הכתיבה אך מתייחס לנשים ולגברים כאחד‪ .‬עמכם הסליחה‪.‬‬
‫‪1‬‬
‫‪R‬‬
‫הטכניון ‪ -‬מכון טכנולוגי לישראל‬
‫‪R‬‬
‫הפקולטה להנדסת חשמל‬
‫‪R‬‬
‫‪R‬‬
‫מעבדות ההוראה‬
‫‪R‬‬
‫‪R‬‬
‫‪R‬‬
‫הנחיות בטיחות לסטודנטים במעבדות לאלקטרוניקה‬
‫‪R‬‬
‫‪R‬‬
‫כללי‪:‬‬
‫תמצית הנחיות בטיחות מובאת לידיעת הסטודנטים כאמצעי למניעת תאונות בעת‬
‫‪R‬‬
‫ביצוע ניסויים ופעילות במעבדות לאלקטרוניקה של הפקולטה להנדסת חשמל‪.‬‬
‫‪R‬‬
‫מטרתן להפנות תשומת לב לסיכונים הכרוכים בפעילויות המעבדה‪ ,‬כדי למנוע סבל‬
‫לאדם ונזק לציוד‪.‬‬
‫‪R‬‬
‫אנא קיראו הנחיות אלו בעיון ופעלו בהתאם להן‪.‬‬
‫מסגרת הבטיחות במעבדה ‪:‬‬
‫‪RR‬‬
‫‪UR‬‬
‫‪‬‬
‫‪‬‬
‫‪R‬‬
‫‪R‬‬
‫אין לקיים ניסויים במעבדה ללא קבלת ציון עובר בקורס הבטיחות‪.‬‬
‫‪R‬‬
‫לפני התחלת הניסויים יש להתייצב בפני מדריך הניסוי לקבלת הנחיות בטיחות‬
‫ותדריך ראשוני‪.‬‬
‫‪‬‬
‫‪‬‬
‫‪R‬‬
‫‪R‬‬
‫‪RU‬‬
‫‪R‬‬
‫אין לקיים ניסויים במעבדה ללא השגחת מדריך‪.‬‬
‫‪R‬‬
‫מדריך הניסוי אחראי להסדרים בתחום פעילותכם במעבדה; הטו אוזן קשבת‬
‫להוראותיו ונהגו על פיהן‪.‬‬
‫‪R‬‬
‫‪UR‬‬
‫עשו ואל תעשו ‪:‬‬
‫‪RR‬‬
‫‪‬‬
‫‪R‬‬
‫‪RU‬‬
‫יש לידע את המדריך על מצב מסוכן וליקויים במעבדה או בסביבתה הקרובה‪.‬‬
‫‪R‬‬
‫‪‬‬
‫‪R‬‬
‫לא תיעשה במזיד ובלי סיבה סבירה פעולה העלולה לסכן את הנוכחים‬
‫במעבדה‪.‬‬
‫‪R‬‬
‫‪‬‬
‫‪R‬‬
‫אסור להשתמש לרעה בכל אמצעי או התקן שסופק או הותקן במעבדה‪.‬‬
‫‪2‬‬
‫‪R‬‬
‫‪‬‬
‫‪R‬‬
‫היאבקות‪ ,‬קטטה והשתטות אסורים‪ .‬מעשי קונדס מעוררים לפעמים צחוק‬
‫אך הם עלולים לגרום לתאונה‪.‬‬
‫‪‬‬
‫‪R‬‬
‫‪R‬‬
‫אין להשתמש בתוך המעבדה בסמים או במשקאות אלכוהוליים‪ ,‬או להיות‬
‫תחת השפעתם‪.‬‬
‫‪R‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪R‬‬
‫‪R‬‬
‫‪R‬‬
‫אין לעשן במעבדה ואין להכניס דברי מאכל או משקה‪.‬‬
‫יש לכבות מכשירי טלפון ניידים לפני הכניסה למעבדה‪.‬‬
‫בסיום הפעולות יש להשאיר את השולחן נקי ומסודר‪.‬‬
‫‪R‬‬
‫‪R‬‬
‫‪R‬‬
‫בטיחות חשמל‪:‬‬
‫‪R‬‬
‫‪‬‬
‫‪R‬‬
‫מדריך הניסוי עבר הכשרה בבטיחות חשמל והינו בעל תעודת חשמלאי בדרגה‬
‫הנדרשת‪ .‬היעזרו בו ובגורמים מקצועיים אחרים במעבדה‪ ,‬בעת חירום‪.‬‬
‫‪‬‬
‫‪R‬‬
‫בשולחנות המעבדה מותקנים בתי תקע ("שקעים") אשר ציוד המעבדה מוזן‬
‫מהם‪ .‬אין להפעיל ציוד המוזן מבית תקע פגום‪.‬‬
‫‪‬‬
‫‪R‬‬
‫‪‬‬
‫‪R‬‬
‫אין להשתמש בציוד המוזן דרך פתילים ("כבלים גמישים") אשר הבידוד שלהם‬
‫פגום או אשר התקע שלהם אינו מחוזק כראוי‪.‬‬
‫‪R‬‬
‫‪R‬‬
‫‪R‬‬
‫אסור לתקן או לפרק ציוד חשמלי כולל החלפת נתיכים המותקנים בתוך‬
‫הציוד; יש להשאיר זאת לטפול הגורם המוסמך‪.‬‬
‫‪R‬‬
‫‪‬‬
‫‪R‬‬
‫אין לגעת בלוח החשמל המרכזי‪ ,‬אלא בעת חירום וזאת לצורך ניתוק המפסק‬
‫הראשי‪.‬‬
‫‪R‬‬
‫‪UR‬‬
‫בטיחות אש‪ ,‬החייאה ועזרה ראשונה‪:‬‬
‫‪‬‬
‫‪R‬‬
‫‪R‬‬
‫מדריך הניסוי עבר הכשרה בבטיחות אש‪ ,‬החייאה ועזרה ראשונה‪ .‬העזרו בו‬
‫ובגורמים מקצועיים אחרים במעבדה‪ ,‬בעת חירום‪.‬‬
‫‪‬‬
‫‪R‬‬
‫‪R‬‬
‫במעבדה ממוקם מטף כיבוי אש ותיק עזרה ראשונה‪ ,‬זהו את מקומו‪.‬‬
‫‪R‬‬
‫‪3‬‬
‫‪‬‬
‫‪R‬‬
‫אין להפעיל את המטפים ואין להשתמש בציוד העזרה הראשונה‪ ,‬אלא בעת‬
‫חירום ובמידה והמדריך וגורמים מקצועיים אחרים במעבדה אינם יכולים‬
‫לפעול‪.‬‬
‫‪UR‬‬
‫‪R‬‬
‫יציאות חירום ‪:‬‬
‫‪RR‬‬
‫‪‬‬
‫‪R‬‬
‫‪RU‬‬
‫במעבדה ישנה פתח יציאה אחת והיא משמשת כפתח היציאה גם בשעת חירום‪.‬‬
‫‪R‬‬
‫‪‬‬
‫‪UR‬‬
‫‪R‬‬
‫בארוע חירום הדורש פינוי‪ ,‬כגון שריפה‪ ,‬יש להתפנות מיד מהמעבדה‪.‬‬
‫דיווח בעת אירוע חירום ‪:‬‬
‫‪RR‬‬
‫‪‬‬
‫‪‬‬
‫‪R‬‬
‫‪R‬‬
‫‪R‬‬
‫‪RU‬‬
‫יש לדווח מידית למדריך ולצוות המעבדה‪.‬‬
‫‪R‬‬
‫המדריך או איש מצוות המעבדה ידווחו מיידית לקצין הביטחון בטלפון; ‪,2740‬‬
‫‪ ,2222‬נייד; ‪ .050-544575‬במידה ואין הם יכולים לעשות כך‪ ,‬ידווח אחד‬
‫הסטודנטים לקצין הביטחון‪.‬‬
‫‪R‬‬
‫‪‬‬
‫‪R‬‬
‫לפי הוראת קצין הביטחון‪ ,‬או כאשר אין יכולת לדווח לקצין הביטחון‪ ,‬יש‬
‫לדווח‪ ,‬לפי הצורך; משטרה ‪ ,7-100‬מגן דוד אדום ‪ ,7-101‬מכבי אש ‪7-102‬‬
‫וגורמי בטיחות ו‪/‬או ביטחון אחרים‪ .‬בנוסף לכך יש לדווח ליחידת סגן המנמ"פ‬
‫לעניני בטיחות; ‪.2146/7 ,3033‬‬
‫‪‬‬
‫‪‬‬
‫‪R‬‬
‫‪R‬‬
‫‪R‬‬
‫בהמשך‪ ,‬יש לדווח לאחראי משק ותחזוקה; ‪.052-419917 , 4776‬‬
‫‪R‬‬
‫לסיום‪ ,‬יש לדווח לאחראי האקדמי; ‪ , 4661‬לעוזר למנהל; ‪ ,4678‬לאחראי‬
‫ההנדסי; ‪ 4668,4671‬ולאחראי האדמיניסטרטיבי; ‪.3276‬‬
‫‪4‬‬
‫תוכן עניינים‬
‫כללי‪2 ................................................................................................................. :‬‬
‫פרק ‪ - 1‬הקדמה ‪6 .....................................................................................................‬‬
‫פרק ‪ - 2‬מבוא ‪7 .......................................................................................................‬‬
‫‪ 2.1‬הקדמה ‪ -‬שפת ‪7 ..................................................................................... VHDL‬‬
‫‪ 2.2‬מושגים בארכיטקטורות‪ ,‬סינתזה ותזמון ‪11 ..............................................................‬‬
‫‪ 2.2.1‬ארכיטקטורות‪11 ......................................................................................................‬‬
‫א‪ .‬מימוש מקבילי ‪12 .........................................................................................................‬‬
‫ב‪ .‬מימוש טורי ‪12 ..............................................................................................................‬‬
‫ג‪ .‬מימוש מצונר – ‪12 ......................................................................................... :pipeline‬‬
‫‪ 2.2.2‬סינתזה ‪14 ................................................................................................................‬‬
‫‪ 2.2.3‬תזמון ודרישות תזמון ‪15 ...........................................................................................‬‬
‫‪ 2.2.4‬שיפור הבדיקתיות של תכנון ‪16 ................................. Design For Testability (DFT) :‬‬
‫‪ 2.3‬כלי סינתזה – ‪17 ........................................................................... Design Vision‬‬
‫‪ 2.3.1‬ספרית ה‪18 ........................................................................................ DesignWare -‬‬
‫‪ 2.4‬רקע בסיסי למערכת ההפעלה ‪19 .................................................................. Linux‬‬
‫הדפסות ‪Error! Bookmark not defined........................................................................‬‬
‫הנחיות כלליות‪22 .................................................................................................. :‬‬
‫פרק ‪ – 3‬דוחות הכנה ‪22 ............................................................................................‬‬
‫הכנה ניסוי מספר ‪23 ..............................................................................................1‬‬
‫‪ .1‬ארכיטקטורות של מסכמים ‪23 ........................................................................................‬‬
‫‪ .2‬אופטימיזציה של התזמון ‪23 ...........................................................................................‬‬
‫‪ .3‬השוואה בין ארכיטקטורה מקבילית ומצונרת ‪23 ...............................................................‬‬
‫הכנה ניסוי מספר ‪23 ..............................................................................................2‬‬
‫‪ .1‬אנליזה של ‪ setup time‬ו‪23 ........................................................................... hold time -‬‬
‫‪ .2‬בעיית ה‪23 ................................................................................................. False Path -‬‬
‫‪ .3‬שימוש ב‪ multicycle path/operator -‬ב‪23 ............................................................ ALU -‬‬
‫‪ .4‬שיפור הבדיקתיות ‪23 ................................................... Design For Testability (DFT) :‬‬
‫פרק ‪ – 4‬ביצוע הניסויים ‪23 .......................................................................................‬‬
‫ביצוע ניסוי מס' ‪23 ................................................................................................ 1‬‬
‫‪ .1‬ארכיטקטורות של מסכמים ‪23 ........................................................................................‬‬
‫‪ .2‬אופטימיזציה של התזמון ‪23 ...........................................................................................‬‬
‫‪ .3‬השוואה בין ארכיטקטורה מקבילית ומצונרת ‪23 ...............................................................‬‬
‫ביצוע ניסוי מס' ‪23 ................................................................................................ 2‬‬
‫‪ .1‬אנליזה של ‪ setup time‬ו‪23 ........................................................................... hold time -‬‬
‫‪ .2‬בעיית ה‪23 ................................................................................................. False Path -‬‬
‫‪ .3‬שימוש ב‪ multicycle path/operator -‬ב‪23 ............................................................ ALU -‬‬
‫‪ .4‬שיפור הבדיקתיות ‪23 ................................................... Design For Testability (DFT) :‬‬
‫‪5‬‬
‫פרק ‪ - 1‬הקדמה‬
‫חוברת זו מהווה תדריך והכנה לניסוי בארכיטקטורות וסינתזה של מעגלי ‪ VLSI‬במעבדה ל‪-‬‬
‫‪ .VLSI‬הניסוי מתבצע על גבי תחנות ‪ Linux‬ותוכנת ‪ Synopsys‬לתכנון מעגלי ‪.VHDL‬‬
‫מטרת הניסוי‪:‬‬
‫‪ .1‬הכרה בסיסית של כלי סינתזה ועזרים נלווים‪.‬‬
‫‪ .2‬הכרה בסיסית של מבנים מסוימים בשפת ‪.VHDL‬‬
‫‪ .3‬לימוד תכנון של ארכיטקטורות מקביליות‪ ,‬טוריות ומצונרות‪.‬‬
‫‪ .4‬התנסות בסינתזה עם ה‪ Design Compiler -‬של חברת ‪ Synopsys‬ושימוש ביכולות המתקדמות‬
‫שלי הכלי‪.‬‬
‫מבנה הניסוי‪:‬‬
‫הניסוי מורכב מ‪ 2 -‬פגישות‪ .‬כל פגישה אורכה ארבע שעות‪ .‬לפני כל ניסוי יש להכין דו"ח מכין‬
‫ולהגישו למנחה עם תחילת הניסוי‪.‬‬
‫חלק א' ‪:‬‬
‫‪ .1‬לימוד ארכיטקטורות שונות למסכמים בינריים והשוואת ביצועים של הארכיטקטורות‬
‫השונות‪.‬‬
‫‪ .2‬אופטימיזציה של התזמון בשיטות שונות ב‪.design_vision -‬‬
‫‪ .3‬סינתזה וחקירה של ארכיטקטורות שונות של יחידת מכפל ‪ +‬מסכם‪.‬‬
‫חלק ב' ‪:‬‬
‫‪.1‬‬
‫‪.2‬‬
‫‪.3‬‬
‫‪.4‬‬
‫אנליזה של ‪ setup time‬ו‪( hold time -‬עם ‪ (min/max delay‬כולל פתרון הבעיות‪.‬‬
‫הבנת בעיית ה‪ false path -‬בבדיקות תזמון‪.‬‬
‫לימוד נושא ה‪ multi-cycle path -‬בעזרת מימוש של ‪.ALU‬‬
‫הבנת בעיית הבדיקתיות של מעגל ויישום שיטות לשפרה‪.‬‬
‫דרישות הניסוי‪:‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫קריאת חוברת הניסוי בעיון רב (אפילו יותר מפעם אחת)‪.‬‬
‫הגשת דו"ח הכנה לניסוי לפי שאלות מפרק דו"ח הכנה‪.‬‬
‫בוחן הכנה לניסוי‪.‬‬
‫ביצוע הניסוי על תחנת עבודה‪.‬‬
‫הגשת דו"ח סיכום שבועיים לאחר ביצוע חלק ב' של הניסוי‪.‬‬
‫דרישות דו"ח סיכום‪:‬‬
‫הגשת‪:‬‬
‫‪ ‬דו"ח מכין לשני חלקי הניסוי‪.‬‬
‫‪ ‬דו"ח סופי לשני החלקים עם תשובות לכל השאלות שנשאלות במהלך הניסוי‪.‬‬
‫"הסטודנט מתבקש למלא את טופס המשוב האלקטרוני הנמצא בקישור‬
‫"‪ ," / http://www2.ee.technion.ac.il/Labs/EELabs‬הטופס ממולא באופן אנונימי‪ .‬אנו‬
‫זקוקים לתגובותיכם על מנת לתקן ולשפר כמו גם לשבח" ‪.‬‬
‫‪T‬‬
‫‪HTTU‬‬
‫‪UTHT‬‬
‫‪T‬‬
‫‪6‬‬
‫פרק ‪ - 2‬מבוא‬
‫תהליך תכנון טיפוסי של מעגל ‪ VLSI‬מורכב מהשלבים הבאים ‪:‬‬
‫‪.1‬‬
‫‪.2‬‬
‫‪.3‬‬
‫‪.4‬‬
‫‪.5‬‬
‫הגדרת המערכת ותכנון הארכיטקטורה‬
‫מימוש המערכת בשפה עלית כגון ‪ VHDL‬או ‪.verilog‬‬
‫סימולציות‬
‫סינתזה‬
‫בנית ה‪Layout -‬‬
‫מטרת הניסוי היא הכרה והפעלה של כלי סינתזה בסיסים ומתקדמים על מנת לקבל את המעגל‬
‫היעיל ביותר‪ .‬למרות שברור כי חובה לסמלץ כל תכנון שנכתב לפני שלב הסינתזה‪ ,‬לא נבצע זאת‬
‫במסגרת הניסוי מחוסר זמן‪ ,‬כאמור הדגש של הניסוי הוא סינתזה‪ .‬בנוסף לכך‪ ,‬כל המעגלים‬
‫המופיעים במהלך הניסוי יהיו כאלה שניתן לוודא את נכונותם פשוט ע"י הסתכלות‪.‬‬
‫‪ 2.1‬הקדמה ‪ -‬שפת ‪VHDL‬‬
‫‪ VHDL‬היא שפה לתיאור חומרה ‪ , 1‬המהווה תקן רשמי בתעשייה )‪ .(IEEE 1076‬בעזרת ‪VHDL‬‬
‫אפשר לתכנן לתאר ולבצע סימולציה על מערכות מורכבות‪ .‬ניתן לתאר מערכת בכל רמת הפשטה‬
‫רצויה מרמת הטרנזיסטור עד לרמת המערכת‪ .‬במגבלות מסוימות ניתן להפוך תיאור ‪ VHDL‬של‬
‫מערכת למעגל חשמלי באמצעות כלי סינתזה‪.‬‬
‫בעת כתיבת קוד ‪ ,VHDL‬חשוב לבחון את דרכי המימוש האפשריות בחומרה‪ ,‬על מנת לוודא שהקוד‬
‫שנכתב הגיוני‪ .‬לפני שמתחלים לכתוב ב‪ VHDL -‬מומלץ להכין דיאגרמת בלוקים מפורטת של‬
‫התכנון עם הגדרה מדויקת של כל הכניסות והיציאות של כל בלוק‪ .‬בנוסף לכך‪ ,‬רצוי לצייר סכמה‬
‫של כל בלוק‪ .‬אין צורך להעמיק מדי בפירוט התכנון‪ ,‬יש להגיע עד לרמת פירוט של מונים‪ ,‬רגיסטרים‪,‬‬
‫יחידות אריתמטיות‪ ,‬מכונות מצבים וכדומה‪ .‬עבור כל מכונת מצבים יש להכין דיאגרמת מצבים‬
‫מפורטת‪.‬‬
‫‪PF‬‬
‫‪FP‬‬
‫המרכיבים הבסיסיים של השפה‬
‫לשפה מילות מפתח המתחלקות למספר קבוצות‪ :‬מילות מפתח פונקציונאליות בדומה למילות‬
‫המפתח בשפה פונקציונאלית (‪ ;)...,IF ,BEGIN ,FOR‬מילות מפתח תיאוריות‪ ,‬המתארות מרכיבים‬
‫ותכונות של מערכות (כגון‪ ;)ARCHITECTURE ,PROCESS :‬אופרטורים מסוגים שונים;‬
‫וספריה תקנית של סוגי נתונים ופונקציות‪ .‬השפה חופשית מרישיּות (‪ ,)Case-Insensitive‬אולם‬
‫מדיניות המעבדה היא לרשום את מילות המפתח השונות באותיות גדולות‪ ,‬ואילו את השמות‬
‫הניתנים על‪-‬ידי התוכניתן באותיות קטנות‪ .‬מניסיוננו‪ ,‬זה מקל על האבחנה בין מילות המפתח לשאר‬
‫המזהים‪.‬‬
‫מילות המפתח‪:‬‬
‫יישות (‪ :)ENTITY‬היא אבן הבניין הבסיסית בתכן כל מערכת‪ .‬רמת התכן העליונה מכונה‬
‫‪ ,top-level entity‬ובתכנון היררכי היא תכיל ישויות נוספות המתארות רמות נמוכות יותר‪ .‬ישות‬
‫‪ VHDL‬מקבילה ל‪ Symbol-‬בתיאור סכמטי‪ .‬לכל ישות מוגדר מנשק מול שאר חלקי המערכת‪,‬‬
‫המאופיין בכניסות ויציאות‪ ,‬או באופן כללי יותר "פתחים" (‪ .)PORTs‬ניתן להגדיר את הפתחים כ‪-‬‬
‫‪ OUT ,IN‬או ‪.INOUT‬‬
‫ארכיטקטורה (‪ :)ARCHITECTURE‬מתארת את התנהגותה של יישות‪ ,‬כלומר‪ ,‬כיצד משפיעים‬
‫הנתונים המתקבלים בכניסות והמצב הנוכחי של המערכת‪ ,‬על המצב העתידי והנתונים המועברים‬
‫‪ 1‬השם ‪ VHDL‬מהווה ראשי תיבות של ‪ . VHSIC Hardware Description Language‬השם ‪ VHSIC‬מהווה‬
‫ראשי תיבות של ‪ . Very High Scale Integrated Circuit‬במקום ‪ VHSIC‬אפשר גם ‪ , VLSI‬כלומר ‪Very‬‬
‫‪.Large Scale Integration‬‬
‫‪PTR‬‬
‫‪TP‬‬
‫‪R‬‬
‫‪R‬‬
‫‪R‬‬
‫‪R‬‬
‫‪R‬‬
‫‪R‬‬
‫‪R‬‬
‫‪7‬‬
‫‪R‬‬
‫‪R‬‬
‫‪R‬‬
‫‪R‬‬
‫‪R‬‬
‫‪R‬‬
‫‪R‬‬
‫ביציאות‪ .‬ליישות בודדת ניתן להגדיר מספר ארכיטקטורות (למשל‪ :‬ארכיטקטורה מבנית‪ ,‬המגדירה‬
‫את היישות כהרכבה של מספר ישויות בסיסיות יותר או ארכיטקטורה התנהגותית‪ ,‬המתארת את‬
‫הקשר הלוגי בין כניסות‪ ,‬יציאות‪ ,‬משתנים ואותות‪ .‬ארכיטקטורת ‪ VHDL‬מקבילה לסכמה בתיאור‬
‫הסכמטי‪.‬‬
‫תהליך (‪ :)PROCESS‬יחידת ביצוע בסיסית בשפה‪ ,‬המאפשרת תיאור תפקודי של פעילות רכיב או‬
‫מערכת‪ ,‬באופן סדרתי‪-‬אלגוריתמי‪ .‬כל פעולות הסימולציה מחולקות לתהליך אחד או יותר‪.‬‬
‫רכיב (‪ :)COMPONENT‬אבן בניין‪ ,‬המאפשרת תיאור מבני של פעילות התקן מורכב יותר‪ .‬רכיב‬
‫מגדיר מנשק בין ההתקן הנבנה‪ ,‬לבין ישות בה מעוניינים להשתמש עבורו‪.‬‬
‫תצורה (‪ :)CONFIGURATION‬מגדירה באיזו ארכיטקטורה להשתמש במקרה מסוים‪ ,‬מבין‬
‫הקיימות עבור ישות נתונה‪ .‬חובה להגדיר תצורות מתאימות לכל הישויות המשתתפות‪ ,‬לפני ביצוע‬
‫סימולציה‪.‬‬
‫ערכה (‪ :)PACKAGE‬מגדירה בצורה מרוכזת‪ ,‬אוסף של סוגי נתונים (‪ )Data Types‬ופונקציות‬
‫פרטיות‪ ,‬לצורך שימוש ביתר חלקי המערכת המתוכננת‪ .‬קיימות גם ערכות תקניות בהן ניתן‬
‫להשתמש‪ ,‬לדוגמא‪:‬‬
‫;‪Library IEEE‬‬
‫;‪USE IEEE.std_logic_1164.ALL‬‬
‫שתי ההצהרות שלעיל מאפשרות למערכת המתוכננת להשתמש בערכה המכונה ‪,std_logic_1164‬‬
‫הנמצאת בספריה ‪ .IEEE‬ערכה זו כוללת בין היתר‪ ,‬את הגדרת סוג הנתונים ‪ ,STD_LOGIC‬וכל‬
‫הפונקציות המטפלות בו‪ .‬בהמשך מופיעה דוגמא לדרך הגדרת ערכה‪.‬‬
‫סוגי נתונים (‪)Data Types‬‬
‫השפה כוללת סוגי נתונים רבים‪ .‬במסגרת הניסוי נשתמש במספר מצומצם של סוגים‪:‬‬
‫‪ :INTEGER‬מספר שלם שערכו בתחום ‪( ±2147483647‬סימטרי סביב אפס)‪.‬‬
‫‪ :STD_LOGIC‬סוג נתונים שיכול לקבל ‪ 9‬ערכים שונים‪ ,‬ביניהם‪:‬‬
‫'‪ :'0‬אפס לוגי‪.‬‬
‫'‪ :'1‬אחד לוגי‪.‬‬
‫'‪ :'X‬לא ידוע‪.‬‬
‫'‪ :'U‬לא מאותחל‪.‬‬
‫'‪ :'Z‬עכבה גבוהה (‪ High Impedance‬או ‪.)HIGHZ‬‬
‫'‪ :'-‬חסר משמעות (‪.)Don't Care‬‬
‫‪ :STD_LOGIC_VECTOR‬וקטור של ‪ .STD_LOGIC‬דוגמאות לשימוש בסוג זה‪:‬‬
‫)‪vec : STD_LOGIC_VECTOR(7 downto 0‬‬
‫)‪vec2 : STD_LOGIC_VECTOR(0 to 15‬‬
‫אופרטורים ‪:‬‬
‫מוגדרים בשפה אוסף של אופרטורים תקניים‪ .‬חלק מהאופרטורים משמשים לשימושים שונים‬
‫בהתאם להקשר‪ .‬להלן הנפוצים שביניהם‪:‬‬
‫‪NOT XOR NOR NAND‬‬
‫‪OR AND‬‬
‫אופרטורים לוגיים ‪:‬‬
‫=>‬
‫>‬
‫=<‬
‫<‬
‫=‪/‬‬
‫=‬
‫אופרטורי יחס ‪:‬‬
‫‪/‬‬
‫*‬
‫‬‫‪+‬‬
‫אופרטורים אריתמטיים‪:‬‬
‫אופרטור שירשור ‪& :‬‬
‫=‪( :‬למשתנה ‪( <= )Variable -‬לאות ‪ Signal -‬או פתח ‪)Port -‬‬
‫אופרטורי השמה‪:‬‬
‫>=‬
‫אופרטור הפעלה‪:‬‬
‫‪8‬‬
‫הערות תיעוד (‪:)Comments‬‬
‫הערות תיעוד פנימי בקבצי שפת ‪ VHDL‬רושמים אחרי זוג מקפים (‪ .)--‬כל מה שמופיע אחרי שני‬
‫המקפים ועד סוף השורה נחשב כתיעוד ואינו נבדק על‪-‬ידי המהדר‪ .‬סיום השורה מסיים המחרוזת‬
‫שאינה נבדקת‪ ,‬ואין צורך בסימנים מיוחדים נוספים‪ .‬שיטה זו זהה לשיטת התיעוד הפנימי של ‪C++‬‬
‫(שם התווים הפותחים הם ‪.)//‬‬
‫תיאור לוגי התנהגותי‬
‫נתאר כאן דוגמא של מימוש לוגי התנהגותי‪.‬‬
‫דוגמא א ‪ :‬הגדרת ישות המייצגת ‪)Reset-Set Flip-Flop( RSFF‬‬
‫בהגדרת הישות של רכיב מופיעים שם הרכיב‪ ,‬הכניסות והיציאות שלו כדלקמן‪:‬‬
‫‪ENTITY rsff IS‬‬
‫;‪PORT (set, reset: IN STD_LOGIC‬‬
‫;)‪q, qb: INOUT STD_LOGIC‬‬
‫;‪END rsff‬‬
‫הגדרת הארכיטקטורה של ה‪ RSFF -‬בתיאור התנהגותי‪:‬‬
‫‪ARCHITECTURE arc_rsff OF rsff IS‬‬
‫‪BEGIN‬‬
‫;)‪q<= NOT (qb AND set‬‬
‫;)‪qb<= NOT (q AND reset‬‬
‫;‪END arc_rsff‬‬
‫ארכיטקטורה התנהגותית זו מממשת ‪ ,RSFF‬על‪-‬ידי הגדרת ערכי היציאות שלו‪ ,‬בהתאם לערכי‬
‫הכניסות‪ .‬ארכיטקטורה ממומשת בעזרת משפטי השמה מקביליים ואין חשיבות לסדר ההשמות‪.‬‬
‫השמות אלו מופעלות כאשר אחד מהאותות בצד ימין של ההשמה משתנה‪ ,‬ללא קשר לסדר כלשהו‪.‬‬
‫למשל‪ ,‬אם ‪ q = 1‬והערך ‪ reset‬הופך מ‪ '0'-‬ל‪ ,'1'-‬אזי ‪ qb‬מקבל ערך '‪ ,'0‬בהתאם להשמה השנייה‪.‬‬
‫כעת‪ ,‬עשויה להיכנס לפעולה ההשמה הראשונה‪.‬‬
‫כאן ראינו דוגמא של משפטים מקביליים (‪ .)Concurrent Statements‬כל ההשמות המופיעות‬
‫בבלוק הארכיטקטורה (בין ה‪ BEGIN-‬ל‪ )END-‬מתבצעות במקביל‪.‬‬
‫הגדרת הארכיטקטורה של ה‪ RSFF -‬בתיאור מבני‪:‬‬
‫‪ARCHITECTURE arc2_rsff OF rsff IS‬‬
‫‪COMPONENT nand2‬‬
‫;‪PORT (a,b :IN STD_LOGIC‬‬
‫;)‪c :OUT STD_LOGIC‬‬
‫;‪END COMPONENT‬‬
‫‪BEGIN‬‬
‫‪U1: nand2‬‬
‫;)‪PORT MAP (set, qb, q‬‬
‫‪U2: nand2‬‬
‫;)‪PORT MAP (reset, q, qb‬‬
‫;‪END arc2_rsff‬‬
‫ארכיטקטורה מבנית זו מממשת ‪ RSFF‬בעזרת שערי ‪ .nand2‬ההנחה היא ששערים אלו הוגדרו‬
‫מראש כישויות בעלות ארכיטקטורה ותצורה מתאימה‪ .‬כאן‪ ,‬הבלוק ‪ COMPONENT‬מגדיר את‬
‫המנשק לשערי ‪ ,nand2‬ואילו בבלוק הראשי מציבים את הרכיבים השונים השותפים במבנה ‪,rsff‬‬
‫‪9‬‬
‫בארכיטקטורה זו‪ .‬הרכיבים מוגדרים על‪-‬ידי מיפוי ה‪ Ports -‬השונים של ‪ ,rsff‬ל‪ Ports -‬המתאימים‬
‫בכל אחד מרכיבי ‪ nand2‬השותפים במבנה‪ .‬חשוב לציין שמותר לערבב תיאור מקבילי ותיאור מבני‪.‬‬
‫הוספת רגיסטרים ‪:‬‬
‫הוספת רגיסטרים לתכנון תתבצע ע"י הצבה של היחידה ‪ reg16‬רגיסטר בעל ‪ 16‬סיביות (או ‪reg32‬‬
‫בהתאם לצורך)‪ .‬ניתן לשלב אותה בתכנון בעזרת משפט מהסוג ‪:‬‬
‫‪U1: reg16‬‬
‫;)‪PORT MAP (reg_in, clk, reg_out‬‬
‫ה‪ component -‬של הרגיסטר מוגדר ע"י‪:‬‬
‫‪COMPONENT reg16‬‬
‫( ‪PORT‬‬
‫;)‪din : IN STD_LOGIC_VECTOR(15 downto 0‬‬
‫;‪clk : IN STD_LOGIC‬‬
‫;))‪dout : OUT STD_LOGIC_VECTOR (15 downto 0‬‬
‫;‪END COMPONENT‬‬
‫מימוש ‪: multiplexor‬‬
‫ניתן לממש ‪ multiplexor‬בקלות בעזרת משפט מקבילי מהסוג ‪:‬‬
‫;‪tmp_a <= tmp_b when sel = '0' else tmp_c‬‬
‫המשפט מגדיר ש‪ tmp_a -‬יקבל את הערך ‪ tmp_b‬כאשר ‪ .sel=0‬אם ‪ ,sel=1‬אזי ‪ tmp_a‬יקבל‬
‫‪.tmp_c‬‬
‫‪Processes‬‬
‫מאוד נפוץ להשתמש במשפטי ‪ process‬בתיאור ההתנהגות הלוגית‪ .‬ה ‪ process -‬מתואר על‪-‬ידי‬
‫משפטיים סדרתיים )‪ (Sequential Statement‬המתבצעים זה אחר זה לפי סדרם‪ ,‬באופן זהה‬
‫רעיונית לדרך ביצוען של תוכניות אלגוריתמיות בשפות נוהליות )‪ .(Procedural Languages‬משפט‬
‫‪ process‬מכיל משפטיים סדרתיים‪ ,‬כגון‪ FOR ,IF ,CASE :‬ו‪ .LOOP -‬לא נשתמש בתיאור בעזרת‬
‫‪ process‬במהלך ניסוי זה‪.‬‬
‫בשפת ‪ VHDL‬ניתן להגדיר משתנים (‪ ,)Variables‬אותות (‪ )Signals‬ופתחים (‪ .)Ports‬הגדרות‬
‫המשתנים מופיעות בתוך בלוק ‪ ;process‬ורק ה‪ process -‬שבו מוגדר המשתנה‪ ,‬מכיר אותו‪ .‬משפטי‬
‫השמה של משתנים (מהצורה ‪ )num := 1‬מתבצעים מיד‪ .‬לא נשתמש במשתנים במהלך ניסוי זה‪.‬‬
‫משתנים אותות ופתחים‬
‫אותות ב‪ VHDL -‬שקולים לרוב לחוטים בסכמה‪ .‬כאשר רוצים לחבר שני רכיבים בהתקן נעזרים‬
‫ב ' בהמשך)‪ .‬הגדרת האותות מופיעה אחרי כותרת הבלוק‬
‫באותות (ראה דוגמא‬
‫"‪ ,"ARCHITECTURE‬והם מוּכרים בארכיטקטורה כולה‪ .‬כל משפטי השמה של אותות (מהצורה‬
‫’‪ )sig <= ’1‬מתבצעים בו זמנית כאשר התהליך עוצר‪.‬‬
‫התנהגות הפתחים דומה מאוד להתנהגות אותות‪ ,‬כלומר ערכם מתעדכן בסוף התהליך‪ ,‬ונשאר קבוע‬
‫לאורך ביצועו; ההשמה מבוצעת בעזרת אותו אופרטור; וההשמה האחרונה היא הקובעת‪ .‬אולם‪,‬‬
‫פתחים מוגדרים גם ככניסה (‪ ,)IN‬יציאה (‪ )OUT‬או שילוב (‪ .)INOUT‬פתח המוגדר ככניסה‪ ,‬ניתן‬
‫רק לקרוא ממנו‪ ,‬ולא לכתוב לתוכו; בדומה‪ ,‬ליציאה ניתן רק לכתוב‪ ,‬ולא ניתן לקרוא ממנה‪.‬‬
‫‪X‬‬
‫‪X‬‬
‫דוגמא ב ‪ :‬חיבור שני מהפכים בעזרת אותות‬
‫להבהרה‪ buf_in :‬ו‪ buf_out -‬הן כניסות המעגל (מוגדרות בהגדרת הישות של ‪inv_in_out .)buf‬‬
‫הוא אות המחבר בין הרכיבים ‪ U1‬ו‪ U2-‬של ‪( .buf‬לא מובא כאן תיאור ה – ‪.)entity‬‬
‫‪ARCHITECTURE arc_buf OF buf IS‬‬
‫‪10‬‬
‫;‪inv_in_out : STD_LOGIC‬‬
‫‪SIGNAL‬‬
‫‪COMPONENT inv‬‬
‫;‪PORT (inv_in :IN STD_LOGIC‬‬
‫;)‪inv_out :OUT STD_LOGIC‬‬
‫;‪END COMPONENT‬‬
‫‪BEGIN‬‬
‫‪U1: inv‬‬
‫;)‪PORT MAP (buf_in, inv_in_out‬‬
‫‪U2: inv‬‬
‫;)‪PORT MAP (inv_in_out, buf_out‬‬
‫;‪END arc_buf‬‬
‫יחידות סינכרוניות‬
‫במסגרת תהליך‪ ,‬ניתן לבנות יחידות סינכרוניות כגון ‪ Flip-Flop‬בעזרת משפט מהסוג ‪:‬‬
‫‪IF clock'EVENT AND clock = 1 THEN‬‬
‫משמעות המשפט הוא ‪ :‬אם השעון השתנה וכעת הוא שווה ל‪( '1' -‬כלומר הייתה עליית שעון)‪ .‬משפט‬
‫זה יכול להופיע רק במשפט ‪ process‬ולכן השימוש ביחידות סינכרוניות בניסוי זה יעשה הצבה של‬
‫רגיסטרים מוכנים שמסופקים במהלך הניסוי‪.‬‬
‫ספריות דרושות בסביבת ‪Synopsys‬‬
‫כדי שהכלים יוכלו למצו א את כל היחידות הדרושות יש לציין באיזה ספריות להשתמש‪ .‬זה נעשה‬
‫ע"י הוספת השורות הבאות בתחילת קובץ ה‪: VHDL -‬‬
‫;‪library IEEE,DWARE,DW01,DW02,DW03‬‬
‫;‪use IEEE.std_logic_1164.all‬‬
‫;‪use ieee.std_logic_arith.all‬‬
‫;‪use DW01.DW01_components.all‬‬
‫;‪use DW02.DW02_components.all‬‬
‫;‪use DW03.DW03_components.all‬‬
‫‪ 2.2‬מושגים בארכיטקטורות‪ ,‬סינתזה ותזמון‬
‫‪ 2.2.1‬ארכיטקטורות‬
‫נניח שברצוננו לחשב )‪ .(a+b) – (c+d‬קימות אפשרויות שונות לבניית חומרה שמסוגלת לבצע את‬
‫החישוב‪ .‬להלן תיאור קצר של מספר מימושים אפשריים ‪:‬‬
‫‪11‬‬
‫א‪ .‬מימוש מקבילי‬
‫‪+/-‬‬
‫‪+/-‬‬
‫‪TC‬‬
‫‪B‬‬
‫‪B‬‬
‫‪+/-‬‬
‫‪reg‬‬
‫איור מס' ‪ : 1‬מימוש מקבילי‬
‫החישוב מבוצע מההתחלה עד הסוף ברציפות‪ .‬המסלול בעל ההשהיה ) ‪ (T C‬הארוכה ביותר בין כ"א‬
‫מהכניסות לכ"א מהיציאות נקרא המסלול הקריטי‪.‬‬
‫‪B‬‬
‫‪B‬‬
‫ב‪ .‬מימוש טורי‬
‫‪+/-‬‬
‫‪reg‬‬
‫איור מס' ‪ : 2‬מימוש טורי‬
‫במימוש זה‪ ,‬ראשית מחשבים את ‪ a+b‬ושומרים את הסכום ברגיסטר אחד‪ .‬לאחר מכן מחסירים‬
‫‪ c‬ושומרים את הסכום באותו רגיסטר‪ ,‬ולבסוף מוסיפים לתוצאה את ‪ .d‬על מנת לבצע את החישוב‪,‬‬
‫יש צורך בשלושה מחזורי שעון‪ .‬סביר מאד שזמן המחזור (שנקבע ע"י המסלול הקריטי) קטן‬
‫מזמן המחזור של החישוב המקבילי‪ .‬במימוש זה‪ ,‬כל פעולות הסיכום וחיסור מבוצעות ע"י אותה‬
‫יחידה‪.‬‬
‫‪ - resource sharing‬שיתוף בלוקים פנויים בשלבים שונים של החישוב‪.‬‬
‫ג‪ .‬מימוש מצונר – ‪:pipeline‬‬
‫ארכיטקטורה שבה פעולת החישוב מחולקת לשלבים‪ .‬תוצאת הביניים נשמרת ברגיסטר‪ .‬כל שלב‬
‫מתחיל לבצע את החישוב על נתונים חדשים ברגע שסיים לטפל בנתונים של החישוב הקודם‪.‬‬
‫‪12‬‬
‫‪+/-‬‬
‫‪+/-‬‬
‫‪reg‬‬
‫‪reg‬‬
‫‪+/-‬‬
‫‪reg‬‬
‫איור מס' ‪ : 3‬מימוש מקבילי‬
‫במחזור הראשון‪ ,‬מחושבים את )‪ (a+b‬ואת )‪ (c+d‬ושומרים את התוצאה ברגיסטרים‪ .‬במחזור‬
‫השני מבצעים את פעולת החיסור‪ .‬בזמן הזה‪ ,‬המסכמים פנויים ולכן ניתן להזין אותם במידע חדש‪.‬‬
‫‪ – latency‬מספר המחזורים הדרוש על מנת לקבל את התוצאה המלאה הראשונה‪.‬‬
‫במימוש זה‪ ,‬דרושים שני מחזורים לקבלת התוצאה הראשונה‪ ,‬כלומר ה‪ ,2 = latency -‬אבל לאחר‬
‫מכן ניתן לקבל תוצאה חדשה בכל מחזור‪.‬‬
‫‪ - balanced pipeline‬צינור שבו ההשהיה של כל השלבים שווה פחות או יותר‪.‬‬
‫מסכמים מסוג ‪parallel prefix -‬‬
‫הסבר זה מובא כרקע לסעיף הראשון של הניסוי‪ .‬קיימת משפחה של מסכמים המכונה ‪parallel‬‬
‫‪ .prefix adders‬מעגל מסוג ‪ parallel prefix‬הוא מעגל אשר ‪:‬‬
‫‬‫‬‫‪-‬‬
‫מקבל כקלט סדרה בעלת ‪ n‬כניסות ‪ x1,x2,….xn :‬ומוציא כפלט סדרה בעלת ‪ n‬יציאות ‪:‬‬
‫))‪f(x1), f(x2,x1), f(x3,x2,x1),……f(xn,xn-1,…x1‬‬
‫‪ f‬היא פונקציה אסוציאטיבית (במקרה זה – חיבור)‬
‫הפלט ה‪ n -‬תלוי בכניסות ‪ 1‬עד ‪ .n‬מותר שתהיה יותר מסדרה אחת של כניסות או יציאות‪.‬‬
‫במסכם מסוג ‪ carry-lookahead‬מחשבים את ‪ pi‬ואת ‪ gi‬של כל דרגה על מנת להאיץ את החישוב‬
‫(במקרה הזה הקלט הוא לא רק ‪ xi‬אלא גם ‪:)yi‬‬
‫‪gi = xiyi‬‬
‫‪pi = xi + yi‬‬
‫‪ci+1 = gi + pici‬‬
‫נגדיר ‪:‬‬
‫‪Pi = pi.Pi-1‬‬
‫‪Gi = gi + pi.Gi-1‬‬
‫כאשר ‪:‬‬
‫‪G0 = x0y0‬‬
‫‪P0 = x0 + y0‬‬
‫כעת ניתן לרשום ‪:‬‬
‫‪ci+1 = Gi + Pic0‬‬
‫חשוב לשים לב ש‪:‬‬
‫‪13‬‬
‫‪Pi:0 = Pi:m.Pm-1:0‬‬
‫‪Gi = Gi:m + Pi:m.Gm-1:0‬‬
‫כאשר ‪ Pi:m‬ו‪ Gi:m -‬מסמנים חישוב הפונקציות ‪ Gi‬ו‪ Pi -‬מסיבית ה‪ m -‬עד לסיבית ה‪.i -‬‬
‫תכונה זאת מאפשרת חישוב מקבילי של הפונקציות שניתנות למימוש במגוון רחב של‬
‫ארכיטקטורות‪ .‬דוגמא אחת היא המימוש לפי ‪ Sklansky‬המופיע באיור מס' ‪:4‬‬
‫איור מס' ‪ :4‬מסכם ‪Sklansky‬‬
‫התרשים מציג את הסדר לחישוב הפונקציות ‪ Gi‬ו‪ Pi -‬שבעזרתם ניתן לחשב את ה‪ .ci+1 -‬יתרון‬
‫המימוש הוא העומק המינימלי של העץ אבל החיסרון הוא ה‪ fanout -‬הגבוה של המספר צמתים‪.‬‬
‫מתמקדים רק ב – ‪ carry‬כי חישוב זה מהווה את המסלול הקריטי‪.‬‬
‫‪ 2.2.2‬סינתזה‬
‫זהו התהליך שבו מתורגם מעגל המתואר בשפה כגון ‪ VHDL‬למימושו באמצעות שערים לוגיים‪.‬‬
‫כלי סינתזה מקבל כקלט תיאור ‪ VHDL‬של התכנון‪ ,‬ספרית התאים שעומדת לרשותו ואילוצי‬
‫המשתמש‪ .‬הפלט הוא מימוש המעגל באמצעות תאי הספרייה‪ .‬להלן איור של תהליך הסינתזה ‪:‬‬
‫‪Technology‬‬
‫‪Library‬‬
‫‪VHDL‬‬
‫‪Description‬‬
‫‪Gate Level‬‬
‫‪Netlist‬‬
‫‪Synthesis‬‬
‫‪Constraints‬‬
‫איור מס' ‪ : 5‬מערכת סינתזה‬
‫‪14‬‬
‫במהלך הניסוי הזה אנו משתמשים בספריות של חברת ‪ Tower Semiconductors‬בטכנולוגית‬
‫‪.CMOS 0.18u‬‬
‫‪ 2.2.3‬תזמון ודרישות תזמון‬
‫בסעיף זה‪ ,‬מופיע הסבר על מושגים שונים בנושא התזמון ובהמשך יובא הסבר על הפקודות‬
‫הרלוונטיות בכלי הסינתזה‪.‬‬
‫כלי שמנתח מעגל מבחינת התזמון שלו נקרא ‪ .(TV) timing verifier‬בבדיקה טיפוסית של מעגל‬
‫סינכרוני‪ ,‬יש לבדוק את כל המסלולים הבאים ‪:‬‬
‫א‪ .‬מסלולים בין הכניסות של המעגל לכניסות של רגיסטרים שבמעגל‪.‬‬
‫ב‪ .‬מסלולים מיציאות של רגיסטרים שבמעגל ליציאות המעגל‪.‬‬
‫ג‪ .‬מסלולים מיציאות של רגיסטרים שבמעגל אל הכניסות של רגיסטרים אחרים במעגל‪.‬‬
‫‪ critical path‬המסלול בעל ההשהיה הארוכה ביותר‪.‬‬
‫איור מס' ‪6‬‬
‫‪Slack‬‬
‫אם במהלך העבודה עם ‪ TV‬מגדירים שעון בעל מחזור ‪ T‬למערכת‪ ,‬הכלי יבדוק האם המעגל יכול‬
‫לעבוד בקצב זה‪ ,‬כלומר האם ההשהיה של המסלול הקריטי ‪ T c‬קצר ממחזור השעון ? אם הוא קצר‬
‫יותר אז אומרים שלמסלול הקריטי‪ slack ,‬חיובי אחרת ה‪ slack -‬שלילי!!‪.‬‬
‫‪B‬‬
‫‪B‬‬
‫‪Slack = T - T c‬‬
‫ברור שתמיד צריך להגיע למצב שבו ה‪ slack -‬יהיה חיובי‪ .‬כמובן שתיאור פשטני זה מזניח נתונים‬
‫חשובים כגון ‪ setuptime‬ו‪( holdtime -‬ראה המשך)‪.‬‬
‫‪B‬‬
‫‪Max delay requirement‬‬
‫‪Longest_path_delay + Tclock_to_q < Tcycle - Tsetup + Tskew‬‬
‫קיום דרישה זאת מבטיח שהמידע מגיע לפני שהשעון עלה‪.‬‬
‫‪Min delay requirement‬‬
‫‪Shortest_path_delay + Tclock_to_q > Thold + Tskew‬‬
‫קיום דרישה זאת מבטיח שהמידע לא מגיע מהר מידי‪ .‬אסור שיקרה מצב שבו המידע בכניסה של‬
‫ה‪ FF -‬השני משתנה לפני שהשעון מגיע ובכך ננעל המידע החדש ולא הישן כפי שהיה צריך‪ .‬קיימים‬
‫שני פתרונות לבעיה זאת ‪:‬‬
‫‪ .1‬להוסיף השהייה מסלול הנתונים‬
‫‪ .2‬לעקב את השעון שמגיע ל‪ FF -‬הראשון‬
‫‪False paths‬‬
‫במעגל הבא ברור שלא יתכן שמידע יעבור דרך ‪ delay1‬ו‪ delay3 -‬או דרך ‪ delay2‬ו‪.delay4 -‬‬
‫מסלולים אלה הם ‪ .false paths‬במקרים מסוימים כלי הסינתזה מזהה שקיימים מסלולים לוגיים‬
‫לא אפשריים ומסלק אותם בשלב האופטימיזציה‪.‬‬
‫‪15‬‬
‫איור מס' ‪False Path : 7‬‬
‫אם נשנה את המעגל הנ"ל כך שאותות הבקרה של הבוררים ‪ X‬ו‪ Y -‬יהיו כניסות למערכת בלתי‬
‫תלויות (ללא מהפך ביניהם) אזי כל המסלולים הלוגיים אפשריים‪ .‬יתכן מצב שבו המשתמש יודע‬
‫מראש ש‪ X -‬ו‪ Y -‬לעולם לא יקבלו את הערכים ‪ 0=X‬ו‪ 0=Y -‬ביחד‪ .‬במקרה זה כלי הסינתזה לא‬
‫יסלק אף מסלול מצד אחד‪ ,‬אבל עדיין קיימים ‪ false paths‬מצד שני (בגלל האילוצים על ערכי‬
‫הכניסות)‪ .‬הפתרון הוא לדווח לכלי התזמון על כל ה‪ false paths -‬הידועים‪.‬‬
‫‪Multicycle Path‬‬
‫בדרך כלל‪ ,‬כל החישובים במעגל מתבצעים במחזור שעון אחד ‪ .T c‬נניח שקיים מעגל בו כל‬
‫המסלולים בעלי השהיה קטנה מ‪ T c -‬חוץ ממספר מסלולים העוברים דרך יחידה איטית בהם‬
‫ההשהיה גדולה מ‪ T c -‬אבל קטנה מ‪ . 2T c -‬פתרון אחד הוא להגדיל את מחזור השעון של כל המעגל‬
‫ל‪ 2T c -‬למשל‪ .‬ישנם מקרים שבהם התוצאה של היחידה האיטית אינה נחוצה כל מחזור אלא כל‬
‫שני מחזורים או יותר‪ .‬במקרים אלה ניתן להמשיך לעבוד במחזור שעון ‪ T c‬ולהשתמש בתוצאה‬
‫של היחידה האיטית (כלומר‪ ,‬לנעול אותה ברגיסטר) כל שני מחזורים‪.‬‬
‫‪B‬‬
‫‪B‬‬
‫‪B‬‬
‫‪B‬‬
‫‪B‬‬
‫‪B‬‬
‫‪B‬‬
‫‪B‬‬
‫‪B‬‬
‫‪B‬‬
‫‪B‬‬
‫‪B‬‬
‫‪ 2.2.4‬שיפור הבדיקתיות של תכנון ‪Design For Testability (DFT) :‬‬
‫לאחר יצור נדרש לבדוק את השבב בצורה מקיפה‪ .‬באחת הבדיקות מנסים לוודא שאף צומת אינו‬
‫מקוצר להספקה או אדמה בטעות‪ .‬על מנת לבצע בדיקה זאת‪ ,‬יש לספק לשבב כניסות שיגרמו לכל‬
‫אחד מהצמתים לשנות מצב וגם שאפשר יהיה להבחין בשינוי ביציאות השבב‪ .‬פעולה זאת קשה‬
‫ביותר עבור שבבים גדולים בעיקר עבור צמתים הנמצאים עמוק בתכנון‪.‬‬
‫הדרך המקובלת לפתרון הבעיה היא הוספת חומרה לתכנון שמטרתה היא לשפר את הבדיקתיות‬
‫שלו‪ Internal Scan .‬היא אחת הטכניקות הנפוצות ל‪ .DFT -‬בשיטה זאת‪ ,‬מחליפים כל ה‪FF -‬‬
‫בתכנון ב‪ Scan FF -‬כפי שמתואר באיור מס' ‪ .8‬בעבודה רגילה ה‪ Scan FF -‬מקבל את הכניסה‬
‫הרגילה וב‪ test mode -‬הוא מקבל כניסה מה‪ .scan_in: port-‬פורט זה מחובר ליציאה של ‪Scan‬‬
‫‪ FF‬אחר‪ .‬בצורה זאת ב‪ test mode -‬ניתן לצור ‪ shift register‬ארוך )‪ (Scan Chain‬המורכב מכל ה‪-‬‬
‫‪ FF‬שבתכנון‪ .‬ע"י הפעלה נכונה של המעגל‪ ,‬ניתן להכניס ל‪ FF -‬כל ערך רצוי ע"י רצף של פעולות‬
‫הזזה‪ .‬אחרי הכנסת ערך רצוי לכל ה‪ FF -‬מפעילים את השבב במוד רגיל של עבודה במשך מחזור‬
‫אחד שבסיומו ננעלות התוצאות באותם ה‪ .Scan FF -‬כעת ניתן להוציא את התוצאות החוצה ע"י‬
‫סידרה נוספת של פעולות הזזה‪ .‬ברור ששינוים אלה מגדילים את שטח המעגל ויכולים לפגוע‬
‫בביצועים‪ ,‬אבל הם חיוניים לשיפור הבדיקתיות‪.‬‬
‫ניתן לבצע הוספת ה‪ scan chain -‬בשלב הסינתזה בתצורות שונות באופן אוטומטי‪.‬‬
‫איור מס' ‪Scan FlipFlop :8‬‬
‫‪16‬‬
‫‪ 2.3‬כלי סינתזה – ‪Design Vision‬‬
‫ה‪( (dc) design compiler -‬או ‪ design vision‬בגרסתו הגרפית) הוא כלי הסינתזה של חברת‬
‫‪ .Synopsys‬הכלי מקבל כקלט תיאור ‪( VHDL‬או ‪ )Verilog‬ויוצר כפלט מעגל ברמת השערים‬
‫המממש את ה‪ .VHDL -‬הכלי מופעל באמצעות הפקודה ‪ design_vision‬שגורם לפתיחה של חלון‬
‫גרפי המאפשר הרצת פקודות מתוך תפריטים‪.‬‬
‫כל פקודה שנריץ בעזרת הממשק הגרפי תופיע גם בחלון ה‪ terminal -‬ממנו הרצנו את הכלי‪.‬‬
‫נוכל להריץ גם פקודות על ידי כתיבתם בחלון ה‪.terminal-‬‬
‫נוכל גם לרשום את כל הפקודות בקובץ אחד (כל פקודה בשורה נפרדת) ולהריץ את כל הקובץ בבת‬
‫אחת על ידי ‪file->execute script...‬‬
‫ניתן לקבל את קובץ כל הפקודות שהרצנו ע"י ‪file->save info->design setup‬‬
‫תהליך של סינתזה מתחלק ל‪ 3 -‬שלבים‪:‬‬
‫‪:syntax‬‬
‫לשגיאות‬
‫ובדיקתם‬
‫‪vhdl/verilog‬‬
‫ה‪-‬‬
‫קבצי‬
‫‪ )1‬קריאת‬
‫לחץ על ‪.file->read‬‬
‫‪ )2‬אופטימיזציה ומיפוי לשערי ספרייה (סינתזה תלויית טכנולוגייה) ‪:‬‬
‫לפני התחלת שלב זה יש להגדיר את אילוצי התכנון (אופציונאלי – ראה בהמשך) ע"י‬
‫האפשרויות השונות שבתפריט ה‪ attributes -‬או ע"י קריאת קובץ אילוצים בעזרת‬
‫‪ .file->execute script )3‬בדוק שבחלון הקטן למעלה מופיע שם היחידה העליונה‪ .‬לחץ על‬
‫‪ .design->compile‬בחלון שנפתח ניתן לבחור את כמות העבודה שהכלי ישקיע בכל שלב‬
‫ע"י שינוי הבחירה באפשרויות ה‪ .effort -‬בסיום יש ללחוץ ‪ .OK‬ניתן לראות את הסכמה‬
‫של המעגל המסונתז ע"י בחירת השם (בחלון הקטן למעלה) ולחיצה על ה‪ icon -‬של שער‬
‫ה‪.and -‬‬
‫‪U‬‬
‫‪U‬‬
‫‪U‬‬
‫‪U‬‬
‫אילוצים שניתן להגדיר לכלי ‪:‬‬
‫‪-‬‬
‫‪U‬‬
‫‪ :create_clock‬פקודה להגדרת שעון‪ ,‬דוגמא ‪:‬‬
‫‪create_clock -name "CLK" -period 50 -waveform {0 25} clock‬‬
‫מגדירה אות שעון על ההדק ‪ CLK‬בעל מחזור ‪ ,50ns‬המתחיל ב‪ 0 -‬ועולה ל‪ 1 -‬בזמן ‪ .25ns‬בדר"כ‬
‫נבצע את הפקודה באמצעות התפריט‪ .‬אם שעון מוגדר‪ DC ,‬ינסה לסנתז מעגל העומד בתדר השעון‪.‬‬
‫ניתן להגדיר שעון גם בעזרת התפריט ע"י בחירת הדק השעון ולחיצה על‬
‫‪ .attributes->specify clock‬למציאת הדק השעון יש ללחוץ על הרכיב הרצוי ולשנות את הבחירה‬
‫)‪ cells (hierarchal‬ל ‪. pins/ports‬‬
‫ ‪ : set_max_delay‬קובע אילוץ של השהיה המרבית בין צמתים שונים במעגל‪ .‬דוגמא ‪:‬‬‫]*[‪set_max_delay 10 –to D‬‬
‫ה‪ dc -‬ינסה לבנות מעגל כך שההשהיה בין כל צומת במעגל לצמתים ששמם מתאים ל‪D[*] -‬‬
‫לא תעלה על ‪ .10ns‬אין ודאות שה‪ -dc‬יצליח לבנות מעגל כזה‪.‬‬
‫ ‪ : set_max_area‬קובע אילוץ לגבי השטח הכולל של המעגל‪.‬‬‫ ‪ : set_input_delay‬מאפשר למשתמש להגדיר מתי (ביחס לעליית השעון) אותות הכניסה‬‫מוכנים‪.‬‬
‫ ‪ : set_output_delay‬מאפשר למשתמש להגדיר מתי (ביחס לעליית השעון) אותות היציאה‬‫צריכים להיות מוכנים‪.‬‬
‫ ‪ : set_dont_touch block_name‬מורה לכלי לא לסנתז בלוק מסוים‪.‬‬‫ ‪ : balance_registers‬מאזן את ההשהיות בכל דרגות הצינור‪ .‬האיזון מתקבל ע"י הזזה‬‫אוטומטית של לוגיקה קומבינטורית משלבים עמוסים של ה‪ pipe -‬לשלבים פחות עמוסים תוך‬
‫כדי שמירה על הנכונות הלוגית‪.‬‬
‫‪17‬‬
‫קבלת נתונים על הביצועים של המעגל ‪:‬‬
‫ שטח ‪ :‬ע"י ‪design->report area‬‬‫ צריכת הספק ‪ :‬ע"י ‪design->report power‬‬‫ תזמון ‪ :‬ע"י ‪timing->report timing‬‬‫‪U‬‬
‫שמירת התוצאות ‪:‬‬
‫לחץ על ‪ file->save‬ובחר את הפורמט הרצוי ‪:‬‬
‫ ‪ - ddc‬פורמט אותו ‪ design vision‬קורא‬‫ ‪ – db‬הפורמט הישן של ‪synopsys‬‬‫‪U‬‬
‫‪Multicycle Path‬‬
‫ עבור מקרים של ‪ Multicycle Path‬חשוב לציין לכלי שקיימים מסלולים בהם החישוב דורש‬‫יותר ממחזור אחד‪ ,‬אחרת הם ידווחו כמסלולים בעיתיים‪ .‬ניתן לעשות זאת בעזרת הפקודה‪:‬‬
‫[*]‪set_multicycle_path 2 -end -to U1/din‬‬
‫‪False Paths‬‬
‫ אם קיימים ‪ false paths‬ידועים בתכנון‪ ,‬חשוב לספק את המידע לכלי‪ .‬ניתן לעשות זאת בעזרת‬‫פקודה מסוג ‪:‬‬
‫[*]‪set_false_path -from a[*] -through tmp_a[*] -to z‬‬
‫‪-‬‬
‫‬‫‪-‬‬
‫הפקודה ‪ set_false_path‬פעולת רק על מסלולים שעליהם מוגדרים אילוצי זמן‪ .‬לדוגמא אם‬
‫רק נגדיר שעון אזי יוגדר אילוץ זמן רק על מסלולים בין הרגיסטרים‪ .‬במקרה זה אין אילוץ זמן‬
‫על המסלולים בין הכניסות לרגיסטרים ועל המסלולים בין הרגיסטרים ליציאות‪ ,‬ולכן אם קיים‬
‫מסלול קריטי מבין מסלולים אלה הכלי ידווח עליו אפילו אם הוא מוגדר כ‪ .false path -‬כדי‬
‫למנוע את הבעיה הזאת נגדיר על המסלולים שתחילתם בכניסות המעגל ומסלולים שסופם‬
‫ביציאות המעגל בעזרת פקודות מהסוג ‪:‬‬
‫‪set_input_delay 0 -clock clk a‬‬
‫‪set_output_delay 0 -clock clk z‬‬
‫הפקודה הראשונה מגדירה שההשהיה של הכניסות ‪ a‬יחסית לשעון ‪ clk‬הוא ‪ ,0‬כלומר הכניסה‬
‫מופיעה בתחילת מחזור השעון‪.‬‬
‫הפקודה השנייה מגדירה שהשהיה של יציאות ‪ z‬יחסית לשעון ‪ clk‬הוא ‪ ,0‬כלומר היציאה תהיה‬
‫מוכנה לתחילת מחזור השעון‪.‬‬
‫‪ 2.3.1‬ספרית ה‪DesignWare -‬‬
‫כאמור ה‪ design compiler -‬הוא כלי הסינתזה של חברת ‪DesignWare (DW) .Synopsys‬‬
‫מאפשר למשתמש לשלב בתהליך הסינתזה מימושים מיוחדים עבור אופרטורים שונים ( למשל‬
‫שימוש ב‪ carry lookahead -‬עבור פעולת סיכום מסוימת)‪ .‬ניתן להשתמש ב‪ DW -‬במספר שיטות‪:‬‬
‫א‪inference .‬‬
‫בדרך זאת קוראים לפונקציה שברצוננו להשתמש כגון כפל כפי שמופיע בדוגמא הבאה‪:‬‬
‫;‪library IEEE,DWARE,DW01,DW02‬‬
‫;‪use IEEE.std_logic_1164.all‬‬
‫;‪use IEEE.std_logic_arith.all‬‬
‫;‪use IEEE.std_logic_unsigned.all‬‬
‫;‪use DW02.DW02_components.all‬‬
‫‪entity mult is‬‬
‫( ‪port‬‬
‫‪a, b‬‬
‫;)‪: in std_logic_vector(15 downto 0‬‬
‫‪18‬‬
CLK : in std_logic;
product : out std_logic_vector(31 downto 0));
end mult;
architecture arc_mult of mult is
begin
product <= a * b ;
end arc_mult;
Instantiation .‫ב‬
‫ דוגמא‬.DW -‫בשיטה זאת משתמשים בתיאור מבני של ארכיטקטורה ופשוט מציבים בלוקים של ה‬
:
library IEEE,DWARE,DW01;
use IEEE.std_logic_1164.all;
use IEEE.std_logic_arith.all;
use IEEE.std_logic_unsigned.all;
use DW02.DW02_components.all;
entity adder32 is
port (
a, b : in std_logic_vector(31 downto 0);
cin : in std_logic;
sum : out std_logic_vector(31 downto 0);
cout : out std_logic);
end adder32;
architecture arc_adder32 of adder32 is
begin
U1 : DW01_add
generic map ( width => 32 )
port map (a , b , cin , sum , cout ) ;
end arc_adder32;
.‫ בקוד הנ"ל מאפשר למשתמש לקבוע את רוחב המסכם‬generic map -‫ משפט ה‬: ‫הערה‬
set_implementation .‫ג‬
‫ בעזרת הפקודה‬dv -‫משתמשים בדרך זאת מתוך כלי הסינתזה כלומר מתוך ה‬
:‫ לדוגמא‬,set_implementation
set_implementation type U1
.‫ מציין עבור איזה יחידה בסכמה‬U1 -‫ למשל עבור מסכם) ו‬cla ( ‫ מציין את סוג המעגל הדרוש‬- type
Linux ‫ רקע בסיסי למערכת ההפעלה‬2.4
.)carry lookahead - cla(
].‫ יכולים לפסוח על חלק זה‬Linux ‫[סטודנטים בעלי ניסיון במערכת ההפעלה‬
19
‫מנשק המשתמש של ‪Linux‬‬
‫במעבדה מחשבי ‪ PC‬עליהם מותקנת מערכת ההפעלה ‪ .RedHat Linux‬זו מערכת בעלת ממשק גרפי‬
‫המאפשר ביצוע של מרבית הפעולות הנדרשות הן מתוך שורת פקודה כמקובל ב‪ Linux-‬והן דרך‬
‫תפריטים וצלמיות (‪ )Icons‬כמקובל במערכות מסוג זה‪.‬‬
‫עם הכניסה למערכת‪ ,‬מופיע על המסך שולחן עבודה (‪ )Desktop‬ובתחתיתו לוח הפעלה‪ .‬לוח ההפעלה‬
‫מאפשר הפעלת תוכניות נפוצות רבות‪ ,‬מעבר בין ‪ 4‬שולחנות עבודה שונים‪ ,‬קבלת מידע בסיסי על‬
‫מצב המערכת ועוד‪ .‬אולם‪ ,‬במעבדה זו כמעט אין צורך בו‪ .‬זאת‪ ,‬כיוון שאת כל הפעולות הבסיסיות‬
‫הנדרשות לנו‪ ,‬ניתן להפעיל מתפריט מהיר (‪ ,)Workspace Menu‬הנפתח בלחיצת עכבר ימני על‬
‫שטח ריק בשולחן העבודה‪ .‬כדי להשלים ההכרות עם שולחן העבודה‪ ,‬נוסיף כי על משטח זה נפתחים‬
‫חלונות כבכל מערכת חלונאית‪ ,‬ומיזעורם (‪ )Minimize‬מביא להצגתם כצלמיות בעמודה המתחילה‬
‫בפינה השמאלית העליונה של המסך‪.‬‬
‫מערכת הקבצים‬
‫להלן מספר פקודות בסיסיות לניהול מערכת הקבצים ב‪ ,Unix-‬דרך שורת פקודה‬
‫(פעולות דומות ניתן לבצע גם ממנהל הקבצים ‪:)File Manager -‬‬
‫‪U‬‬
‫פירוש‬
‫‪U‬‬
‫‪U‬‬
‫שם הספריה הנוכחית‬
‫פקודה‬
‫‪U‬‬
‫‪pwd‬‬
‫שינוי הספריה הנוכחית‬
‫]שם ספריה[ ‪cd‬‬
‫מעבר לספרית האב של ההנוכחית‬
‫‪cd ..‬‬
‫העתקת קובץ‬
‫]קובץ יעד[ ]קובץ מקור[ ‪cp‬‬
‫העתקת קובץ לספרית בת של הנוכחית‬
‫]שם ספריה[ ]שם קובץ[ ‪cp‬‬
‫העתקת קובץ לספרית האב‬
‫‪] ..‬שם קובץ[ ‪cp‬‬
‫העברת קובץ לספרית בת של הנוכחית‬
‫]שם ספריה[ ]שם קובץ[ ‪mv‬‬
‫שינוי שם קובץ‬
‫]שם חדש[ ]שם ישן[ ‪mv‬‬
‫העברת קובץ לספרית האב‬
‫‪] ..‬שם קובץ[ ‪mv‬‬
‫מחיקת קובץ‬
‫]שם קובץ[ ‪rm‬‬
‫יצירת ספרית בת לספריה הנוכחית‬
‫]שם ספריה[ ‪mkdir‬‬
‫מחיקת ספרית בת של הנוכחית‬
‫]שם ספריה[ ‪rmdir‬‬
‫רשימת שמות הקבצים הגלויים בספריה הנוכחית‬
‫רשימת פרטי כל הקבצים בספריה הנוכחית‬
‫‪ls‬‬
‫‪ls -la‬‬
‫כפי שניתן לראות‪ ,‬שם ספרית האב של הנוכחית הוא תמיד "‪( "..‬נקודה‪-‬‬
‫נקודה)‪.‬‬
‫כשברצוננו להתייחס לספריה אחות (הנמצאת תחת אותו אב)‪ ,‬ניתן לרשום‪:‬‬
‫‪20‬‬
‫]שם ספריה[‪../‬‬
‫עורכי טקסט‬
‫במהלך הניסויים נדרש להשתמש בעורך טקסט )‪ ,(Text Editor‬כדי ליצור הקבצים‪ .‬קיימים מספר‬
‫עורכים שונים במערכת‪ ,‬כגון‪ xemacs ,textedit ,nedit ,vim ,vi :‬ועוד‪ .‬ניתן להשתמש בכל עורך‬
‫לפי שיקול המשתתפים בניסוי‪ .‬העורכים ‪ nedit ,xemacs‬ו‪" vim-‬מכירים" שפת ‪.VHDL‬‬
‫למי שאינו מכיר היטב עורכי טקסט ב‪ Unix-‬ורגיל דווקא לסביבת חלונות‪ ,‬מומלץ על ‪,Text Editor‬‬
‫המופעל מתוך תת‪-‬התפריט ‪ Applications‬של התפריט המהיר‪ .‬עורך זה עובד באופן דומה מאוד ל‪-‬‬
‫‪ Notepad‬של חלונות‪.‬‬
‫עורך חלונאי דומה‪ ,‬אך חזק מעט יותר הוא ‪ ,NEdit‬המופעל בעזרת הפקודה (בשורת פקודה)‪:‬‬
‫‪nedit filename.vhd‬‬
‫עורך זה גם מראה בהדגשה את המלים השמורות של השפה‪.‬‬
‫עורך חלונאי נוסף‪ ,‬חזק ומורכב יותר‪ ,‬הוא ‪ xemacs‬מופעל בעזרת הפקודה‪:‬‬
‫‪xemacs filename.vhd‬‬
‫עורך זה מסוגל להשלים את הקטעים הנפוצים בקוד ‪ ,VHDL‬על‪-‬ידי לחיצה על ‪.TAB‬‬
‫ברוב עורכי הטקסט והחלונות בהם נעשה שימוש‪ ,‬ניתן להדפיס בדומה למערכת חלונות‪ ,‬בעזרת‬
‫‪ ,File → Print‬ולחיצה על <‪ >Enter‬ללא שום שינויים או תוספות‪.‬‬
‫כמו‪-‬כן‪ ,‬ניתן להדפיס קובץ המוכר על‪-‬ידי המדפסת (טקסט או ‪ )PostScript‬בעזרת הפקודה‪:‬‬
‫‪lpr -Pbp filename‬‬
‫‪21‬‬
‫פרק ‪ – 3‬דוחות הכנה‬
‫הנחיות כלליות‪:‬‬
‫במהלך שאלות ההכנה תתבקשו לרשום קוד ‪ VHDL‬עבור מעגלים שונים‪ .‬ברור שקיימים מימושים‬
‫שונים ומשונים עבור כל מעגל‪ .‬בניסוי זה אתם נדרשים לממש את כל המעגלים בעזרת ‪:‬‬
‫ משפטי השמה פשוטים (אין להשתמש במשפטי ‪)process‬‬‫ משפטי השמה הכוללים "‪( "when‬אם יש צורך ב‪)multiplexor -‬‬‫ הצבה של רגיסטרים (‪ 16‬או ‪ 32‬סיביות)‪ .‬אין צורך לממש את הרגיסטרים בעצמם‪ ,‬הם יסופקו‬‫לכם במהלך הניסוי‪.‬‬
‫ משפטי ‪ instantiation‬או ‪ reference‬עבור אופרטורים של ‪.Designware‬‬‫לפני רישום הקוד עליך לצייר סכמה פשוטה של מעגל‪ .‬רשום שם (מסוג ‪ ) ... tmp_b ,tmp_a‬על כל‬
‫כניסה ויציאה של כל יחידת חישוב (מסכם‪ ,‬מכפל‪ )... ,‬או לרגיסטר‪ .‬יש להגדיר שם זה כסיגנל בקוד‪.‬‬
‫המימוש יכלול אוסף של משפטי השמה לסיגנלים אלה ו‪/‬או חיבור הסיגנלים מהפתחים (‪ )Ports‬של‬
‫הרגיסטרים‪.‬‬
‫דוגמא ‪:‬‬
‫;‪library IEEE‬‬
‫;‪use IEEE.std_logic_1164.all‬‬
‫;‪use IEEE.std_logic_unsigned.all‬‬
‫‪entity example is‬‬
‫( ‪port‬‬
‫;)‪a, b : in std_logic_vector(7 downto 0‬‬
‫;)‪c : in std_logic_vector(15 downto 0‬‬
‫;‪clk : in std_logic‬‬
‫;))‪z : out std_logic_vector(15 downto 0‬‬
‫;‪end example‬‬
‫‪architecture example_arc of example is‬‬
‫‪component reg16 is‬‬
‫( ‪port‬‬
‫;)‪din : in std_logic_vector(15 downto 0‬‬
‫;‪clk : in std_logic‬‬
‫;))‪dout : out std_logic_vector(15 downto 0‬‬
‫;‪end component‬‬
‫;)‪signal tmp_a, tmp_b, tmp_c,: std_logic_vector(15 down to 0‬‬
‫‪begin‬‬
‫; ‪tmp_a <= a * b‬‬
‫‪U1 : reg16‬‬
‫; )‪port map(tmp_a,clk, z‬‬
‫;‪end example_arc‬‬
‫המעגל שבדוגמא מחשב ב‪ tmp_a -‬את מכפלת הכניסות ‪ a‬ו‪ tmp_a .b -‬נכנס לרגיסטר עם עלית‬
‫השעון‪ .‬יציאת הרגיסטר מחובר ליציאת המעגל ‪ .z‬כאמור‪ ,‬אין צורך לממש את הרגיסטרים‪ .‬הם‬
‫ניתנים לסטודנט במהלך הניסוי‪.‬‬
‫‪22‬‬
‫הפגישה הראשונה תתמקד בלימוד בסיסי של כלי הסינתזה ‪ design_vision‬וספרית ה‪-‬‬
‫‪ ,DesignWare‬כיצד מבצעים סינתזה וכיצד מורים לכלי לנצל מימושים יעילים שקיימים בספריות‪.‬‬
‫בנוסף נכיר את האמצעים שהכלי מספק לשיפור הביצועים בהתאם לדרישות המתכנן‪.‬‬
‫בפגישה השנייה נכיר יכולות נוספות לכלי הסינתזה‪ .‬כיצד ניתן לתקן בעיות תזמון באופן‬
‫אוטומטית‪ ,‬כיצד הכלי יכול לשפר את הבדיקתיות של המעגל‪ ,‬וכיצד הוא מנצל ידע על המעגל על‬
‫נמת לשפר את הביצועים ועוד‪.‬‬
‫בסעיפים השונים נממש מעגלים בעלי ארכיטקטורות שונות ובכך נכיר את היתרונות והחסרונות‬
‫של ארכיטקטורות סדרתיות‪ ,‬מקביליות ומצונרות‪.‬‬
‫הכנה ניסוי מספר ‪1‬‬
‫‪ .1‬ארכיטקטורות של מסכמים‬
‫קיימות דרכים רבות למימוש מסכמים‪ .‬לרוב ניתן לומר מימוש מהיר צורך הרבה שטח ולהיפך‪.‬‬
‫בסעיף זה נלמד את השיטות שונות ליצור מסכם בעזרת כלי הסינתזה והספריות ונשווה בין שישה‬
‫מימושים שונים‪.‬‬
‫לקבלת רקע מסוים בנושא זה‪ ,‬הינך מתבקש להכין סרטוטים של מספר מימושים‪( .‬ניתן למצוא‬
‫חומר רב על המימושים המבוקשים באינטרנט)‪.‬‬
‫א‪ .‬שרטט סכמה המממשת מסכם בעל ‪ 4‬סיביות בשיטת ‪.ripple carry‬‬
‫ב‪ .‬שרטט סכמה המממשת מסכם בעל ‪ 4‬סיביות בשיטת ‪ .carry lookahead‬מהם היתרונות‬
‫והחסרונות של מימוש זה לעומת המימוש הקודם‪.‬‬
‫ג‪ .‬שרטט סכמה המממשת מסכם בעל ‪ 4‬סיביות בשיטת ‪.carry select‬‬
‫ד‪ .‬צייר מימוש של מסכם בעל ‪ 8‬סיביות מסוג ‪ .Brent-Kung Adder :‬מה היתרונות והחסרונות‬
‫של מסכם זה לעומת המסכם של ‪?Slansky -‬‬
‫ה‪ .‬רשום מימוש ב‪ VHDL -‬של יחידה המקבלת כניסה )‪ (a‬מילה בת ‪ 64‬סיביות המהוות ‪ 8‬מילים‬
‫בנות ‪ 8‬סיביות כ"א‪ .‬על הרכיב לסכם את ‪ 8‬המילים ולהוציא את הסכום כפלט )‪ (z‬בעל ‪8‬‬
‫סיביות‪ .‬השתמש בשיטת ה‪ .inference -‬קרא ל‪ entity -‬בשם ‪.adder64‬‬
‫שים לב ‪:‬‬
‫ ניתן לחלק את הכניסה לבתים בעלי ‪ 8‬סיביות באמצעות משפטים מסוג ‪:‬‬‫; )‪tmp_a <= a(15 downto 8‬‬
‫‪ .2‬אופטימיזציה של התזמון‬
‫המטרה בסעיף זה היא להכיר דרכים שונות לשיפור תדר העבודה של המעגל‪ .‬לשם כך נשתמש‬
‫במעגל המסוגל לחשב את כ"א מהפעולות ‪:‬‬
‫(‪cos(cosx) , )cos x)**2 , (x+1)**2 , cos (x+1‬‬
‫)‪Cos(x‬‬
‫‪x*x‬‬
‫‪z‬‬
‫‪a‬‬
‫‪x+1‬‬
‫)‪Cos(x‬‬
‫‪sela‬‬
‫‪selb‬‬
‫איור מס' ‪ :9‬מעגל למימוש הפונקציות של סעיף ‪2‬‬
‫‪23‬‬
‫עליך לרשום מימוש ב‪ VHDL -‬של הסכמה באיור מס ‪ 9‬לפי ההנחיות שהוסברו לעיל‪.‬‬
‫ בתחילת הקובץ יש להוסיף הפניות לספריות בעזרת המשפטים ‪:‬‬‫;‪library IEEE,DW02‬‬
‫;‪use IEEE.std_logic_1164.all‬‬
‫;‪use IEEE.std_logic_arith.all‬‬
‫;‪use IEEE.std_logic_unsigned.all‬‬
‫;‪use DW02.DW02_components.all‬‬
‫ עליך להניח ש‪ sela -‬ו‪ selb -‬הן כניסות למעגל ואין צורך לצור אותן במימוש עצמו‪.‬‬‫ ממש את פעולת ה‪ cos -‬בשיטת ה‪ inference -‬עם משפט מסוג ‪:‬‬‫)‪tmp_a <= DWF_cos(a, 8‬‬
‫ כאשר ‪ 8‬מציין את רוחב היציאה‪.‬‬‫ שים לב שהיציאה של יחידת ה‪ cos -‬הראשונה ויחידת ה‪ x+1 -‬היא בעלת ‪ 8‬סיביות והיציאה של‬‫יחידת ה‪ cos -‬השנייה ויחידת ה‪ x*x -‬היא בעלת ‪ 16‬סיביות‪.‬‬
‫ כניסת המעגל ‪ a‬היא מסוג )‪ signed(7 downto 0‬ולא ‪ .std_logic_vector‬יציאת המעגל ‪ z‬היא‬‫מסוג )‪ ,signed(15 downto 0‬כלומר ממשק המעגל יראה כך‪:‬‬
‫‪entity cos_unit is‬‬
‫(‪port‬‬
‫;)‪a : in signed(7 downto 0‬‬
‫;‪sela, selb : in std_logic‬‬
‫)‪z : out signed(15 downto 0‬‬
‫;)‬
‫;‪end cos_unit‬‬
‫כאשר ‪ cos_unit‬יכול להיות שם כלשהו‪.‬‬
‫‪ .3‬השוואה בין ארכיטקטורה מקבילית ומצונרת‬
‫המטרה כאן היא להשוות בין ארכיטקטורות שונות ולהכיר דרכים שונות למימוש מעגל מצונר‬
‫בעזרת כלי הסינתזה‪.‬‬
‫א‪ .‬רשום בצורה מפורטת כיצד מבצעים את החישוב ‪.1101 * 1011 :‬‬
‫ב‪ .‬צייר מעגל המבצע את פעולת הכפל של סעיף א' באופן מקבילי‪ .‬השתמש בשערים פשוטים‪,‬‬
‫מסכמים ורגיסטרים‪.‬‬
‫ג‪ .‬צייר מעגל המבצע את פעולת הכפל של סעיף א' באופן סדרתי‪ .‬השתמש בשערים פשוטים‪,‬‬
‫מסכמים ורגיסטרים‪( .‬אין צורך לצייר את הבקר של המעגל)‪.‬‬
‫ד‪ .‬רשום (בקובץ בשם ‪ )macpa.vhd‬מימוש מקבילי (בשיטת ה‪ (inference -‬ב‪ VHDL -‬המממש‬
‫את הפעולה )‪ (a*b+c‬כאשר ‪ a‬ו‪ b -‬הן כניסות בעלות ‪ 16‬סיביות כ"א‪ c ,‬כניסה בעלת ‪ 32‬סיביות‬
‫ו‪ z -‬יציאה בעלת ‪ 32‬סיביות‪.‬‬
‫ה‪ .‬רשום (בקובץ בשם ‪ )macpi.vhd‬מימוש נוסף לפעולה )‪ .(a*b+c‬הפעם יש לממש את המכפל‬
‫כמכפל מצונר בעל שתי דרגות‪ .‬יש לממש את המכפל בשיטת ה‪ .instantiation -‬דוגמא למימוש‬
‫מכפל מצונר (‪ 4‬דרגות) בשיטת ה‪:instantiation -‬‬
‫‪U1 : DW02_mult_4_stage‬‬
‫)‪generic map (A_width=>16, B_width=>16‬‬
‫;)‪port map(A=>a, B=>b, tc=>tc, clk => clk, product => temp‬‬
‫הערות‪:‬‬
‫ בתחילת הקובץ יש להוסיף הפניות לספריות כמו בסעיף הקודם‪.‬‬‫ עליך להוסיף אות שעון ‪ clk‬ו‪ tc -‬לרשימת הכניסות‪( .‬כניסות המכפל הן ‪ A,B, clk, tc :‬יציאת‬‫הרכיב היא ‪ tc .)PRODUCT‬קובע האם המכפל עובד עם ‪.2’s-Complement‬‬
‫ ניתן להניח שהאות ‪ c‬מגיע למסכם בזמן הנכון ואין צורך ברגיסטר שישמור את ערכו עד‬‫שמשתמשים בו‪.‬‬
‫ מהם היתרונות והחסרונות של מימוש זה לעומת המכפל מהסעיף הקודם ?‬‫ו‪ .‬למימוש של סעיף ד' הוסף ‪ 3‬רגיסטרים (ברוחב היציאה כלומר ‪ 32‬סיביות) שדרכם תעבור‬
‫התוצאה אל היציאה‪ .‬שים לב שיש צורך להוסיף אות שעון למעגל כולו‪.‬‬
‫‪24‬‬
‫הכנה ניסוי מספר ‪2‬‬
‫‪ .1‬אנליזה של ‪ setup time‬ו‪hold time -‬‬
‫סעיף זה יעסוק בהעמקת הבנה בנושא ‪ setup time‬ו‪ .hold time -‬חשוב להבין שזמני השהיה של‬
‫שערים נעים בין ערך מינימלי לערך ומקסימלי‪ .‬חיוני לבצע את האנליזה עם ההשהיות הנכונות (ולא‬
‫רק עם זמני ה‪ .)typical -‬נתון המעגל הבא ‪:‬‬
‫‪Min = 5ns‬‬
‫‪Max = 7ns‬‬
‫‪Data‬‬
‫‪CLK‬‬
‫‪Setup = 2ns‬‬
‫‪Hold = 1ns‬‬
‫‪Min = 1ns‬‬
‫‪Max = 2ns‬‬
‫איור מס' ‪ : 10‬מעגל סינכרוני טיפוסי‬
‫המעגל מכיל שני ‪ FlipFlops‬ולוגיקה קומבינטורית ביניהם‪ .‬עבור סעיף זה‪ ,‬נזניח את ההשהיות‬
‫הפנימיות של ה‪ FlipFlops -‬וההשהיות של החוטים‪.‬‬
‫א‪ .‬הסבר מה זה ‪ setup time‬ומה זה ‪? hold time‬‬
‫ב‪ .‬מהו מחזור השעון המינימלי שעדיין מאפשר למעגל לעבוד בצורה תקינה ? הסבר‪.‬‬
‫ג‪ .‬מהו הפתרון פשוט למעגל שאינו מקיים את דרישת ה‪? setup time -‬‬
‫ד‪ .‬האם המעגל מקיים את דרישת ה‪ “hold” -‬של ה‪ ? FlipFlop -‬הסבר‪.‬‬
‫ה‪ .‬מהו הפתרון למסלול שאינו מקיים את דרישת ה‪? hold time -‬‬
‫‪ .2‬בעיית ה‪False Path -‬‬
‫המטרה בסעיף זה היא להכיר את בעיית ה‪ .false path -‬בסעיף זה נשתמש במעגל המסוגל לחשב‬
‫את כ"א מהפעולות ‪)cos x)**2 , (x+1)**2 , cos (x+1( :‬‬
‫כלומר מעגל המממש אותן הפונקציות כמו המעגל של סעיף ‪ 2‬של החלק הראשון (איור מס' ‪ )9‬פרט‬
‫לפונקציה של )‪ .cos(cosx‬נשתמש באותו מימוש – ‪.VHDL‬‬
‫ מהו לדעתך המסלול הקריטי של המעגל ? הסבר‪.‬‬‫‪ .3‬שימוש ב‪ multicycle path/operator -‬ב‪ALU -‬‬
‫בסעיף זה‪ ,‬נלמד את נושא ה‪ multicycle path/operator -‬בעזרת יחידת חישוב אריתמטית )‪.(ALU‬‬
‫ברכיב זה‪ ,‬קיימת דרישה שכל הפעולות חוץ פעולת הכפל תתבצענה בקצב של ‪ 500MHz‬כלומר‪ ,‬זמן‬
‫מחזור של ‪ .2ns‬מערכים שההשהיה המינימלית של המכפל יהיה כ‪ 4ns -‬ולכן דרושים שני מחזורי‬
‫שעון לביצוע פעולה זאת‪ .‬נשתמש ביחידת ‪ ALU‬המתוארת להלן‪:‬‬
‫כניסות ‪:‬‬
‫‪ A‬ו‪ 32 :B -‬סיביות ‪ -‬האופרנדים של הפעולה‬
‫‪ 3 : opcode‬סיביות ‪ -‬הגדרה של סוג הפעולה‬
‫יציאות ‪:‬‬
‫‪ 32 : C1‬סיביות – הסיביות ה‪ lsb -‬של התוצאה‬
‫‪ 32 : C2‬סיביות – הסיביות ה‪ msb -‬של התוצאה‬
‫הערה ‪ :‬תוצאת הכפל היא בעלת ‪ 64‬סיביות‪ .‬כל יתר התוצאות הן בעלות ‪ 32‬סיביות‪.‬‬
‫‪25‬‬
: ‫תיאור פונקציונלי‬
opcode
000
001
010
011
100
101
110
111
C1
LSB(A*B)
A+B
A-B
not A
A and B
A xor B
ShiftL(A)
ShiftR(A)
C2
MSB(A*B)
-
ALU -‫להלן סכמת בלוקים של ה‬
*
A
B
A
B
+
not
-
an
d
shl
xor
shr
product(31 downto 0)
product(63 downto 32)
opcode
C2
C1
C2
C1
ALU -‫ סכמת בלוקים של ה‬: 11 '‫איור מס‬
26
‫הערה ‪ :‬הבלוקים ‪ C1,B,A‬ו‪ C2 -‬הם רגיסטרים בעלי ‪ 32‬סיביות‪ .‬נתאר שני פתרונות אפשריים‬
‫למימוש ‪ ALU‬העומד בדרישות הנ"ל‪:‬‬
‫ מימוש המכפל כ‪ multicycle operator -‬כלומר כיחידה שמקצים לה שני מחזורי שעון‪.‬‬‫ מימוש המכפל בעל שתי דרגות צינור‬‫בסעיף זה הנך נדרש לרשום שני מימושים של ה‪ ALU -‬על מנת שנוכל להשוואות בין שני הפתרונות‪.‬‬
‫א‪ .‬ראשית‪ ,‬רשום קוד ‪ VHDL‬המממש את ה‪ ALU -‬הנ"ל בהתאם להנחיות הבאות‪ .‬עליך לשלב‬
‫במימוש את ארבעת הרגיסטרים בשיטה ה‪( instantiation -‬המימוש עצמו של הרגיסטרים‬
‫יינתן במהלך הניסוי)‪ .‬עליך לממש את ה‪ multiplexor -‬בעזרת משפט מהסוג ‪:‬‬
‫‪muxout <= x + y WHEN opcode="000" ELSE‬‬
‫‪x - y WHEN opcode="001" ELSE…..‬‬
‫‪..‬‬
‫)‪'0' & A(31 downto 1) WHEN opcode="110"; (ShiftR‬‬
‫פעולות הזזה מתבצעות על האופרנד ‪.A‬‬
‫‪ muxout‬הוא שם הסיגנל ביציאת ה‪.multiplexor -‬‬
‫יש לממש את המכפל בצורה מקבילית פשוט ע"י שימוש באופרטור "*" ‪.‬‬
‫את פעולת הזזה ניתן לממש עם אופרטור השרשור "&"‪ ,‬לדוגמא ‪x(7 downto 1) & ‘0’ :‬‬
‫הערה ‪ :‬בתחילת הקובץ יש להוסיף הפניות לספריות כמו בסעיפים הקודמים‪.‬‬
‫ב‪ .‬רשום מימוש נוסף ב‪ VHDL -‬עבור ה‪ ALU -‬דומה למימוש הקודם אבל הפעם עליך לממש‬
‫את המכפל כמכפל מצונר בעל שתי דרגות צינור (ראה את סעיף ‪ 3‬של החלק הראשון של‬
‫הניסוי)‪.‬‬
‫‪ .4‬שיפור הבדיקתיות ‪Design For Testability (DFT) :‬‬
‫המטרה בסעיף זה היא להכיר את היכולת של הכלי לשפר באופן אוטומטי את הבדיקתיות של‬
‫התכנון‪.‬‬
‫רשום מימוש (בשיטת ה‪ (inference -‬ב‪ VHDL -‬המממש את הפעולה )‪ (a*b+c‬כאשר ‪ a‬ו‪ b -‬הן‬
‫כניסות בעלות ‪ 8‬סיביות כ"א‪ c ,‬כניסה בעלת ‪ 16‬סיביות ו‪ z -‬יציאה בעלת ‪ 16‬סיביות‪ .‬עליך לקלוט‬
‫את תוצאת הכפל של ‪ a‬ו‪ b -‬ברגיסטר‪ .‬כמו כן עליך לקלוט גם את תוצאת הסיכום גם ברגיסטר לפני‬
‫הוצאתה דרך ‪.z‬‬
‫הערה ‪ :‬בתחילת הקובץ יש להוסיף הפניות לספריות כמו בסעיפים הקודמים‪.‬‬
‫‪27‬‬
‫פרק ‪ – 4‬ביצוע הניסויים‬
‫הערות ‪:‬‬
‫‬‫‬‫‬‫‪-‬‬
‫כתיבת דוח הניסוי תתבצע במהלך הניסוי באופן ממוחשב בעזרת תבנית שברשותכם‪ .‬כל‬
‫הגרפים והסכמות ישולבו בדו"ח זה ללא הצורך בהדפסות‪.‬‬
‫לעריכת הדו"ח רשום ‪:‬‬
‫‪- oowrite name1_name2.odt‬‬
‫כשאר ‪ name1‬ו‪ name2 -‬הם שמות הסטודנטים‪ .‬שים לב ש‪ name1_name2.odt -‬אינו קובץ‬
‫ריק אלה תבנית עליה מתבסס הדו"ח‪.‬‬
‫עריכת הדוח הממוחשב תעשה ע"י מעבד תמלילים של ‪ .Open Office‬יתכן ויפתח חלון‬
‫ההערה הבא‪:‬‬
‫ לחץ על ‪ Yes‬בכדי להמשיך‪ .‬בדוק שנפתח קובץ לפי שמות הסטודנטים שלכם‪.‬‬‫צירוף תמונות‪/‬סכמות לדו"ח ‪:‬‬
‫ ראשית יש צורך לצור קובץ ‪.jpg‬‬‫ הפעל את תוכנת ‪ xv‬בחלון ‪ .terminal‬יפתח החלון השמאלי‪ .‬כאשר הסמן נמצא מעל‬‫חלון זה לחץ על הכפתור הימני של העכבר‪ .‬יפתח החלון הימני‪ .‬לחץ על "‪ ."Grab‬לחץ על‬
‫"‪ "Grab‬גם בחלון שנפתח‪ .‬כעת הזמן לסמן את התמונה שברצונך לשמור‪.‬‬
‫ הכפתור השמאלי של העכבר מאפשר לך לבחור חלון שלם‪.‬‬‫ הכפתור האמצעי מאפשר לך לסמן איזור של המסך שברצונך לשמור כתמונה‪.‬‬‫ אחרי שבחרת את התמונה לחץ על ‪ save‬בחלון הימני‪ ,‬בחר בפורמט ‪ jpg‬והכנס שם‬‫לתמונה עם סיומת ‪. .jpg‬‬
‫הכנס את הסכמה לדו"ח ב‪ openoffice -‬עם ‪.Insert->Picture->From File‬‬
‫שינוי שפה יעשה ע"י ‪ Alt+Shift‬ושינוי כיוון כתיבה ע"י ‪.Ctrl+Shift‬‬
‫‪28‬‬
‫ביצוע ניסוי מס' ‪1‬‬
‫‪ .1‬ארכיטקטורות של מסכמים‬
‫מטרת סעיף זה היא ללמוד כיצד ניתן לצור ארכיטקטורות שונות של מסכמים בעזרת כלי הסינתזה‬
‫ולהשוואות ביניהם‪.‬‬
‫א‪ .‬מימוש פשוט‬
‫ רשום את מימוש המסכם שהכנת בקבצים בשם ‪.adder64.vhd‬‬‫ הפעל את ה‪ design vision -‬בעזרת הפקודה ‪.dv‬‬‫ קרא את הקובץ ‪ adder64.vhd‬בעזרת הפקודה ‪ ,File->Read‬בחר את הקובץ ולחץ על ‪Open‬‬‫בחלון שנפתח‪.‬‬
‫ בחלון ה‪ Logical Hierarchy -‬בחר ביחידת ה‪.adder64-‬‬‫ בצע ‪ Design->Compile Design‬ולחץ על ‪.O.K.‬‬‫ כעת בחלון ה‪ Logical Hierarchy -‬יופיעו מספר יחידות‪ ,‬יש לבחור את היחידה העליונה‬‫וללחוץ על ה‪ icon-‬של שער ה‪ and -‬למעלה‪ .‬בסכמה המתקבלת מופיעים ‪.8bit adders 7‬‬
‫ בחר באחד מהם וללחוץ על ↓ ‪.‬‬‫ ‪ :Q11‬באיזו ארכיטקטורה ממומש המסכם?‬‫ ‪ :Q12‬צרף את הסכמה לדו"ח‪.‬‬‫ חזור לרמת העליונה בעזרת ↑‪.‬‬‫ להערכת הביצועים בחר את ה‪ adder64 -‬ולחץ על ‪ ,Timing -> Report Timing Path‬בחלון‬‫שנפתח לחץ על ‪. OK‬‬
‫ כדי לקבל הערכה של השטח וההספק לחץ על ‪Design-Report Area‬‬‫ו‪.Design-Report Power -‬‬
‫ רשום את שטח המעגל‪ ,‬צריכת ההספק והשהיית המסלול הקריטי בטבלה בסעיף הבא‪.‬‬‫ נציג כעת את המסלול הקריטי על הסכמה‪ .‬פתח ‪Timing->Timing Analysis Driver‬‬‫ בחלון ‪ select paths‬לחץ על ‪ .OK‬בחלון ‪ TimingAnalysisDriver‬יופיעו כל המסלולים‪.‬‬‫בחר בעליון‪.‬‬
‫ב‪ .‬כעת נבחן עוד מספר ארכיטקטורות אפשריות המסופקות ע"י ה‪ .DW -‬ראשית מלא את‬
‫הנתונים מהסעיף הקודם בטבלה הבאה‪:‬‬
‫‪Power‬‬
‫‪Area‬‬
‫‪Arch/Constraint Critical Path‬‬
‫‪ripple‬‬
‫‪adder64‬‬
‫‪1‬‬
‫‪cla‬‬
‫‪adder64‬‬
‫‪2‬‬
‫‪pparch‬‬
‫‪adder64‬‬
‫‪3‬‬
‫‪max_delay=2‬‬
‫‪adder64‬‬
‫‪4‬‬
‫‪default‬‬
‫‪sum‬‬
‫‪5‬‬
‫‪max_delay=2‬‬
‫‪sum‬‬
‫‪6‬‬
‫מימוש ‪Carry Lookahead :2‬‬
‫כאמור‪ ,‬ה‪ designware -‬מאפשר למשתמש לשלב בתהליך הסינתזה מימושים מיוחדים עבור‬
‫אופרטורים שונים (למשל שימוש ב‪ carry lookahead -‬עבור פעולת סיכום מסוימת)‪.‬‬
‫חזור לרמה העליונה של הסכמה של ה‪ .adder64 -‬בחר ביחידה אחת‪ .‬בחלון ה‪Logical Hierarchy -‬‬
‫יבחר ה‪ ,instance_name -‬לדוגמא ‪. add_1_root_add_48 :‬‬
‫בחלון הפקודות רשום ‪:‬‬
‫*‪set_implementation cla add‬‬
‫‪29‬‬
‫ הכלי מחזיר "‪ "1‬אם הפקודה נקלטת בהצלחה‪ .‬הקפד על אותיות גדולות‪/‬קטנות עבור השמות!‪.‬‬‫ פעולה זאת מאלצת את ה‪ dv -‬לממש את כל המסכים בארכיטקטורת ‪ add*( cla‬מציין את כל‬‫המסכמים ששמם מתחיל ב‪ – add-‬זה פשוט חוסך כתיבה)‪.‬‬
‫ בצע ‪ Design->Compile Design‬ולחץ על ‪.O.K.‬‬‫ פתח את הסכמה‪ .‬בחר אחת היחידות המתקבלות ולחץ על ↓‪ ,‬ולחץ על ה‪ icon -‬של שער ה‪-‬‬‫‪ .and‬כעת תופיע הסכמה של ה‪ adder64 -‬הנבחר‪ .‬שים לב לשינוי במימוש‪.‬‬
‫ סכם בטבלה את הביצועים (השהיה‪ ,‬שטח והספק) כפי שעשית עבור התכנון הקודם‪.‬‬‫מימוש ‪Parallel Prefix Architecture :3‬‬
‫חזור על הסעיף הקודם אבל הפעם עם ‪:‬‬
‫*‪set_implementation pparch add‬‬
‫ סכם בטבלה את הביצועים של המימוש‪.‬‬‫ הערה ‪ :‬קיימים מימושים שונים של ‪ ,pparch‬הכלי בוחר את המימוש הטוב ביותר‪ ,‬בהתאם‬‫לאילוצים‪ ,‬עובר המעגל הזה‪.‬‬
‫מימוש ‪:4‬‬
‫ברצוננו לבנות את המסכם המהיר ביותר‪ .‬כיצד ניתן לעשות זאת עם הפקודה ‪?set_max_delay‬‬
‫ רשום אילוץ ‪ set_max_delay‬מתאים בחלון הפקודות של ה‪ .dv -‬הראה את הפקודה למנחה‬‫(רשום את הפקודה גם הדו"ח)‪.‬‬
‫ סנתז את המסכם מצא את ההשהיה שלו‪ ,‬שטח והספק‪.‬‬‫ סכם בטבלה את הביצועים כפי שעשית עבור התכנון הקודם‪.‬‬‫שאלות‪:‬‬
‫‪ :Q13‬האם למימושים עם ‪ )2( cla‬וה‪ )3( pparch -‬היתרונות והחסרונות לעומת ה‪ )1( ripple-‬כפי‬
‫שציפית? הסבר‪.‬‬
‫‪ :Q14‬מה הוא מחיר השיפור במהירות שהתקבל במימוש ‪?4‬‬
‫האם ניתן למצוא מימוש טוב יותר ? ננסה לחפש ב‪.designware -‬‬
‫ פתח את ה‪ manual -‬עם הפקודה ‪.sold :‬‬‫ בחר ‪Designware Building Block IP‬‬‫ עבור לעמוד ‪ 7‬ולחץ על ‪ DW02_sum‬לקבלת התיאור של רכיב זה‪.‬‬‫ סגור את ה‪manual -‬‬‫‪ DW02_sum‬הוא רכיב המקבל וקטור ככניסה ופרמטר המציין כמה מילים הוקטור מייצג‪ .‬הרכיב‬
‫מבצע חיבור של מילים אלה‪ sum.vhd .‬מממש רכיב מסוג זה עבור כניסה בעלת ‪ 64‬סיביות המהווה‬
‫‪ 8‬מילים בעלות ‪ 8‬סיביות כ"א‪.‬‬
‫מימוש ‪:5‬‬
‫ הפעל את ה‪ design vision -‬בעזרת הפקודה ‪.dv‬‬‫ קרא את הקובץ ‪ sum.vhd‬בעזרת הפקודה ‪ ,File->Read‬לחץ על ‪ OK‬בחלון שנפתח‬‫ בצע ‪ Design->Compile Design‬ולחץ על ‪.O.K.‬‬‫ סכם בטבלה את הביצועים (השהיה‪ ,‬שטח והספק) כפי שעשית עבור התכנון הקודם‪.‬‬‫מימוש ‪:6‬‬
‫ בחלון ‪ command window‬רשום את האילוץ ‪ set_max_delay –to z 2 :‬ואז ‪ .compile‬כאשר‬‫‪ z‬הוא שם היציאה‪.‬‬
‫ סכם בטבלה את הביצועים (השהיה‪ ,‬שטח והספק) כפי שעשית עבור התכנון הקודם‪.‬‬‫שאלות ‪:‬‬
‫‪ :Q15‬למה לדעתך רכיב זה הצליח לתת מימושים הרבה יותר יעילים (כלומר גם מהירים יותר וגם‬
‫בעלי שטח קטן יותר) ?‬
‫‪30‬‬
‫‪ .2‬אופטימיזציה של התזמון‬
‫בסעיף זה נכיר מספר דרכים שונות לשיפור התזמון של מעגל‪ .‬בתרגיל זה נשתמש במעגל המחשב‬
‫את הפעולות ‪:‬‬
‫(‪cos(cosx) , )cos x)**2 , (x+1)**2 , cos (x+1‬‬
‫ רשום את המימוש שהכנת בבית בקובץ בשם ‪.cos.vhd‬‬‫דרכים שונות לשיפור התזמון בכלי ‪ design_vision‬שנפעיל במהלך הניסוי‪:‬‬
‫‪.1‬‬
‫‪.2‬‬
‫‪.3‬‬
‫‪.4‬‬
‫‪.5‬‬
‫שבירת ההיררכיה לשיפור האופטימיזציה ‪ :‬אם "שוברים" את המבנה הלוגי‪ ,‬ניתן לעתים‬
‫קרובות לבצע אופטימיזציה טובה יותר‬
‫‪ – Compile Ultra‬כלי סינתזה עם יכולת אופטימיזציה טובה יותר‬
‫‪ – set_max_delay‬מגדיר את ההשהיה המרבית שהמשתמש דורש עבור מסלול מסוים‪.‬‬
‫‪ – set_max_capacitance‬מגביל את הקיבול המירבי של כל הצמיתים שבמעגל‬
‫‪ - set_max_fanout‬מגביל את ה‪ fanout -‬המירבי של כל שער שבמעגל‬
‫ הפעל את ה‪ design vision -‬בעזרת הפקודה ‪.dv‬‬‫ קרא את הקובץ ‪ cos.vhd‬בעזרת הפקודה ‪ ,File->Read‬לחץ על ‪ OK‬בחלון שנפתח‪.‬‬‫ על מנת לקבל מימוש מהיר הגדר אילוץ זמן ‪:‬‬‫‪- set_max_delay –to z_* 2‬‬
‫ כאשר *_‪ z‬הן היציאות ו‪ 2 -‬מציין ‪ .2ns‬אילוץ הדוק זה גורם לכלי לבצע אופטימיזציה של זמן‬‫על חשבון שטח‪.‬‬
‫ בצע סינתזה של המעגל ע"י בחירת ‪.Design->Compile design‬‬‫ בעזרת ‪ Timing -> Report Timing Path‬מצא את ההשהיה של המסלול הקריטי‪.‬‬‫ בעזרת ‪ Design->Report Area‬מצא את השטח של הלוגיקה הקומבינטורית‪.‬‬‫‪ :Q21‬האם המעגל עומד בתזמון שהוגדר ? הסבר‪ .‬רשום את התזמון והשטח בטבלה‪.‬‬
‫ בצע סינתזה של המעגל מחדש עם ‪ Design->Compile design‬אבל הפעם הפעל את האופציה‬‫‪.Ungroup‬‬
‫‪ :Q22‬מצא ורשום בטבלה את התזמון והשטח של המימוש שהתקבל‪ .‬האם יש שיפור בתזמון ?‬
‫הסבר‪.‬‬
‫ בצע סינתזה של המעגל מחדש אבל הפעם עם ‪Design->Compile Ultra‬‬‫‪ :Q23‬מצא ורשום בטבלה את התזמון והשטח של המימוש שהתקבל‪ .‬האם יש שיפור בתזמון ?‬
‫ הפקודה ‪ set_max_capacitance‬מנסה להגביל את הקיבול המקסימלי של הצמתים של‬‫המעגל‪ .‬לדוגמא‪ ,‬הפקודה הבאה מגבילה את הקיבול בכל צומת של היחידה ‪ design‬ל‪:0.05pf -‬‬
‫‪- set_max_capacitance 0.05 design‬‬
‫ זכור להשתמש בשם היחידה שלך במקום ‪.design‬‬‫ על מנת לראות את ההיסטוגרמה של הקיבולים במעגל ‪,‬לחץ על ‪timing->net capacitance‬‬‫ולחץ על ‪ OK‬בחלון שנפתח‪.‬‬
‫ הפקודה ‪ set_max_fanout‬מנסה להגביל את מספר השערים שיכולים להיות מחוברים‬‫ליציאה מסוימת‪ .‬לדוגמא‪ ,‬על מנת להגביל את ה‪ fanout -‬של הכניסות *‪ a‬ל‪ ,10-‬ניתן לרשום ‪:‬‬
‫*‪- set_max_fanout 10 a‬‬
‫ בעזרת ‪ Design->Report Nets‬ניתן לראות את ה‪ fanout -‬של כל הצמתים‪.‬‬‫‪ :Q24‬בעזרת ‪ set_max_capacitance‬נסה לקבל מעגל מהיר יותר‪ .‬עליך להריץ שתי סינתזות עם‬
‫‪ .Design->Compile Ultra‬עבור כל ריצה‪ ,‬קבע ערך מירבי לקיבול שונה‪ .‬העזר בהיסטוגרמה של‬
‫הקיבולים על מנת לבחור ערך הגיוני‪ .‬האם הצלחת לשפר את התזמון ? מצא ורשום בטבלה את‬
‫התזמון והשטח של המימוש שהתקבל‪ .‬רשום עבור איזה קיבול התקבלו תוצאות אלה‪ .‬בדוק את‬
‫ההיסטוגרמה של הקיבולים‪ .‬האם הכלי מקיים את האילוץ של קיבול מיריבי ?‬
‫‪31‬‬
‫‪ :Q25‬בעזרת ‪ set_max_fanout‬נסה לקבל מעגל מהיר יותר‪ .‬עליך להריץ שתי סינתזות עם‬
‫‪ .Design->Compile Ultra‬עבור כל ריצה‪ ,‬קבע ערך שונה ל‪ .fanout -‬העזר ‪Design->Report‬‬
‫‪ Cells‬על מנת לבחור ערך הגיוני ל‪ .fanout -‬האם הצלחת לשפר את התזמון ? מצא ורשום בטבלה‬
‫את התזמון והשטח של המימוש שהתקבל‪ .‬רשום עבור איזה ‪ fanout‬התקבלו תוצאות אלה‪.‬‬
‫‪Delay‬‬
‫‪Area‬‬
‫‪DC‬‬
‫‪DC+ UngroupAll‬‬
‫‪Compile Ultra‬‬
‫‪set_max_cap‬‬
‫= ‪Cap‬‬
‫‪set_max_fanout‬‬
‫= ‪Fanout‬‬
‫‪ :Q26‬אילו מסקנות ניתן להעסיק מהריצות הנ"ל ?‬
‫‪ .3‬השוואה בין ארכיטקטורה מקבילית ומצונרת‬
‫בסעיף זה‪ ,‬נשווה בין מימושים שונים ונכיר שיטות שונות למימוש מעגל מצונר‪ .‬נדרש לממש מעגל‬
‫לחישוב )‪ (a*b+c‬בעל ‪ throughput‬מכסימלי‪ .‬ראשית נממש את המעגל כמעגל צירופי‬
‫בארכיטקטורה מקבילית‪ .‬לאחר מכן נממש את המעגל בעזרת מכפל מצונר ולבסוף נלמד כיצד ניתן‬
‫לממש את המעגל כולו בארכיטקטורת ‪( pipeline‬ולא רק את המכפל)‪ .‬הדרישה העיקרית בסעיף‬
‫זה היא להגיע למחזור שעון מינימלי‪.‬‬
‫א‪ .‬מימוש מקבילי ‪:‬‬
‫ רשום בקובץ ‪ macpa.vhd‬את המימוש של הפעולה )‪ (a*b+c‬המקבילי שהכנת בשיטת ה‪-‬‬‫‪.inference‬‬
‫ הפעל את ה‪ design vision -‬בעזרת הפקודה ‪.dv‬‬‫ קרא את הקובץ ‪ macpa.vhd‬בעזרת הפקודה ‪ ,File->Read‬לחץ על ‪ OK‬בחלון שנפתח‪.‬‬‫ בחלון הפקודות רשום ‪:‬‬‫‪- set_max_delay –to z 1‬‬
‫ אילוץ זה יגרום לכלי לצור את המימוש המהיר ביותר‪.‬‬‫ בצע סינתזה של המעגל ע"י בחירת ‪.Design->Compile design‬‬‫‪ :Q31‬בעזרת ‪ Timing -> Report Timing Path‬מצא את ההשהיה של המסלול הקריטי ורשום‬
‫את הנתון בטבלה‪.‬‬
‫ סגור את ה‪ dv -‬עם ‪.File->Close‬‬‫ב‪ .‬מימוש עם מכפל מצונר ‪:‬‬
‫ בקובץ ‪ macpi.vhd‬רשום את המימוש של הפעולה )‪ (a*b+c‬עם מכפל מצונר (בעל ‪ 2‬דרגות‬‫צינור) שהכנת‪ .‬זכור להשתמש בשיטת ה‪ instantiation -‬עבור המכפל‪ .‬פתח את ה‪.dv -‬‬
‫ קרא את הקובץ ‪ macpi.vhd‬בעזרת הפקודה ‪ ,File->Read‬לחץ על ‪ OK‬בחלון שנפתח‪.‬‬‫ בצע סינתזה של המעגל ע"י בחירת ‪.Design->Compile design‬‬‫ נבחר כעת מימוש מהיר יותר עבור המסכם ועבור המכפל‪.‬‬‫ נוסיף מספר אילוצי תזמון לקבלת מימוש מהיר‪ .‬בחלון הפקודות רשום ‪:‬‬‫‪- set_max_delay 1 –to z‬‬
‫‪- set_max_delay 1 –to */PRODUCT‬‬
‫ כאשר ‪ z‬מהווה את יציאת המסכם ו‪ – */PRODUCT -‬יציאת המכפל‪.‬‬‫ סנתז את המעגל שוב עם ‪.Design->Compile design‬‬‫‪ :Q32‬בעזרת ‪ Timing -> Report Timing Path‬מצא את ההשהיה של המסלול הקריטי ורשום‬
‫את הנתון בטבלה‪.‬‬
‫ שים לב שניתן לשנות את מספר דרגות הצינור של המכפל מ‪ 2-‬ל‪ 6-‬בקובץ ‪.macpi.vhd‬‬‫‪32‬‬
‫ג‪ .‬מימוש אוטומטי של ‪ pipeline‬עם רגיסטרים מוגדרים מראש‬
‫ העתק את הקובץ ‪ macpa.vhd‬לקובץ בשם ‪ macpi2.vhd‬בעזרת הפקודה ‪:‬‬‫‪- cp macpa.vhd macpi2.vhd‬‬
‫ והוסף שלושת הרגיסטרים לפני היציאה כפי שהכנת (הוסף גם סיגנלי ‪ tmp‬לפי הצורך‪ ,‬וגם‬‫כניסת ‪ .)clk‬צייר סכמה פשוטה של המעגל‪.‬‬
‫ הפעל את ה‪ dv -‬וקרא את הקובץ ‪ reg32.vhd‬בעזרת הפקודה ‪ ,File->Read‬לחץ על ‪ OK‬בחלון‬‫שנפתח‪.‬‬
‫ הערה ‪ :‬בכל פעם שתכנון מסוים משתמש ב‪ reg16 -‬או ב‪ reg32 -‬הנכם נדרשים לקרוא את‬‫הקובץ עם הגדרת הרגיסטר בנוסף לקובץ עם התכנון‪ .‬למעשה לאחר שהרגיסטר נקרא פעם‬
‫אחת‪ ,‬אין צורך לקרוא אותו שוב בסעיפים בהמשך כי הרגיסטר כבר קומפל וכלי מסוגל לזהות‬
‫אותו בספרית ה‪.)WORK -‬‬
‫ קרא את הקובץ – ‪ macpi2.vhd‬בעזרת ‪.File->Read‬‬‫ בחלון הפקודות רשום ‪:‬‬‫‪- source macpi2.con‬‬
‫ קובץ זה מגדיר לכלי להתייחס גם למסלולים מכל הכניסות ואל כל היציאות בזמן חישוב‬‫התזמון‪ ,‬וגם מגדיר את השעון כפי שמופיע בשורה הבאה ‪:‬‬
‫}‪- create_clock -name "clk" -period 1 -waveform { 0 0.5 } {clk‬‬
‫ בצע סינתזה של המעגל ע"י בחירת ‪.Design->Compile design‬‬‫‪ :Q33‬בעזרת ‪ Timing -> Report Timing Path‬מצא את ההשהיה של המסלול הקריטי‪ .‬הסבר !!‬
‫ בחלון ה‪ CW -‬הכנס את הפקודה ‪.balance_registers‬‬‫‪( Q33‬המשך) ‪ :‬מצא את ההשהיה של המסלול הקריטי‪ .‬הסבר !!‬
‫ סגור את ה‪ dv -‬עם ‪.File->Close‬‬‫‪Critical Path‬‬
‫‪Arch‬‬
‫‪Parallel‬‬
‫‪1‬‬
‫‪DWF_mult_2_s‬‬
‫‪2‬‬
‫‪balance_reg‬‬
‫‪3a‬‬
‫‪balance_reg‬‬
‫‪3b‬‬
‫‪ :EX1‬תרגיל‪:‬‬
‫בעזרת אחת השיטות הנ"ל (כולל גם ‪ , )Compile Ultra‬ממש מעגל לחישוב )‪ (a*b+c‬בעל תדר‬
‫שעון של ‪ .1ns‬עליך לקרוא למדריך‪ ,‬להסביר לו את השיטה שבחרת ולהציג לו את ההשהיה של‬
‫המסלול הקריטי‪ .‬עליך גם לרשום את ההסברים והתוצאות בדו"ח‪.‬‬
‫סיום חלק ראשון !‬
‫‪33‬‬
‫ביצוע ניסוי מס' ‪2‬‬
‫‪ .1‬אנליזה של ‪ setup time‬ו‪hold time -‬‬
‫כאמור בהכנה‪ ,‬חשוב לשים לב שלשערים השונים יש זמני השהיה מינימליים ומקסימליים‪ .‬חיוני‬
‫לבצע את האנליזה עם ההשהיות הנכונות (ולא רק עם זמני ה‪ .)typical -‬בסעיף זה נשווה בין זמני‬
‫ה‪ typical -‬ולבין זמני ‪ max-min‬ולאחר מכן נכיר דרך אוטומטית לתיקון בעיות ‪ .hold‬עבור סעיף‬
‫זה נשתמש במימוש ‪ cos.vhd‬שהכרנו בחלק הראשון אבל נוסיף לתכנון שני רגיסטרים כפי שמופיע‬
‫באיור מס' ‪:12‬‬
‫)‪Cos(x‬‬
‫‪x*x‬‬
‫‪z‬‬
‫‪a‬‬
‫‪x+1‬‬
‫)‪Cos(x‬‬
‫‪sela‬‬
‫‪selb‬‬
‫‪clk‬‬
‫איור מס' ‪ :12‬מעגל לאנליזה של ‪ setup time‬ו‪hold time -‬‬
‫ מימוש לתכנון הנ"ל מופיע בקובץ בשם ‪cos2.vhd‬‬‫ הפעל את ה‪ design vision -‬בעזרת הפקודה ‪.dv‬‬‫ קרא את הקבצים ‪ reg8s.vhd‬ואת ‪ cos2.vhd‬בעזרת הפקודה ‪.File->Read‬‬‫ בחלון הפקודות רשום ‪:‬‬‫‪- source cos2.con‬‬
‫ קובץ זה מכיל את הפקודות‪:‬‬‫}‪- create_clock -name "CLK" -period 20 -waveform {0 10‬‬
‫ בצע סינתזה של המעגל ע"י בחירת ‪.Design->Compile Design‬‬‫ בעזרת ‪ . Timing -> Report Timing Path‬מצא את ה‪ slack -‬עבור אנליזת ה‪( setup -‬שים לב‬‫שה‪ Delay Type -‬הוא ‪.)max‬‬
‫ בעזרת ‪) Timing -> Report Timing Path‬אבל הפעם בשדה ‪ Delay Type‬בחר ב‪ min -‬במקום‬‫‪ (max‬מצא את ה‪ slack -‬עבור אנליזת ה‪.hold -‬‬
‫‪ :Q11‬רשום את ה‪ slack -‬עבור שני המקרים בטבלה בסוף הסעיף‪.‬‬
‫ שים לב שהאנליזות הנ"ל בוצעו עבור השהיות מסוג ‪ typical‬בשני המקרים‪.‬‬‫כעת נחזור על שתי הבדיקות ונשתמש ב‪ max delay -‬עבור אנליזת ‪ setup‬וב‪ min delay -‬עבור‬
‫אנליזת ‪ .hold‬כדי לעשות זאת‪ ,‬יש לבצע את הפקודות הבאות ‪:‬‬
‫‪- set_min_lib tsl18fs120_max.db -min_version tsl18fs120_min.db‬‬
‫‪set_operating_conditions -max tsl18fs120_max -max_library tsl18fs120_max -min‬‬
‫(הכל בשורה אחת) ‪tsl18fs120_min -min_library tsl18fs120_min‬‬
‫‪-‬‬
‫ניתן לעשות זאת בדרך פשוטה על הרצת הקובץ ‪ minmax.tcl‬באופן הבא ‪:‬‬
‫‪- source minmax.tcl‬‬
‫ בעזרת ‪ . Timing -> Report Timing Path‬מצא את ה‪ slack -‬עבור אנליזת ה‪.setup -‬‬‫ בעזרת ‪) Timing -> Report Timing Path‬אבל הפעם בשדה ‪ Delay Type‬בחר ב‪ min -‬במקום‬‫‪ (max‬מצא את ה‪ slack -‬עבור אנליזת ה‪.hold -‬‬
‫‪ :Q12‬רשום את ה‪ slack -‬עבור שני המקרים בטבלה בסוף הסעיף‪.‬‬
‫א‪ .‬רשום בכמה אחוזים השתנו הזמנים לעומת זמני ה‪? typical -‬‬
‫‪34‬‬
‫ב‪ .‬האם יש בעיה של ‪ ?(hold time) min delay‬הסבר את התשובה למדריך ורשום אותה‬
‫בדו"ח‪.‬‬
‫קובץ בשם ‪ cos2_syn.v‬מכיל אותו תכנון אבל הפעם הוא כולל את ההשהיה של השעון שנגרמת‬
‫ע"י החיווט‪ .‬נחזור על כל בדיקות התזמון עם המעגל הזה‪.‬‬
‫ לאיפוס הכלי רשום ‪:‬‬‫‪- remove_design -designs‬‬
‫ קרא את הקובץ ‪ cos2_syn.vhd‬בעזרת הפקודה ‪ ,File->Read‬לחץ על ‪ OK‬בחלון שנפתח‪.‬‬‫ הפעם‪ ,‬אין לצורך לבצע ‪.Design->Compile design‬‬‫ בצע ‪:‬‬‫‪- current_design cos2‬‬
‫‪- source cos2.con‬‬
‫]* ‪- set_propagated_clock [get_clock‬‬
‫פקודה זאת גורמת לכלי לחשב את ה‪ skew -‬על קווי השעון הנגרם מההשהיה עליהם‪ .‬נגדיר גם את‬
‫הספריות הנכונות ‪:‬‬
‫‪- source minmax.tcl‬‬
‫ בעזרת ‪ . Timing -> Report Timing Path‬מצא את ה‪ slack -‬עבור אנליזת ה‪.setup -‬‬‫ בעזרת ‪) Timing -> Report Timing Path‬אבל הפעם בשדה ‪ Delay Type‬בחר ב‪ min -‬במקום‬‫‪ (max‬מצא את ה‪ slack -‬עבור אנליזת ה‪.hold -‬‬
‫‪ :Q13‬רשום בטבלה את ה‪ slack -‬עבור שני המקרים בסוף הסעיף הקודם‪.‬‬
‫‪ :Q14‬הוסף סכמת של המימוש לדו"ח‪ .‬לחיצה על ה‪ icon -‬של שער ה‪ and -‬בחלון ‪design_vision‬‬
‫תיצור סכמה‪.‬‬
‫‪ :Q15‬האם יש בעיה של ‪ ? min delay‬הסבר‪.‬‬
‫‪ :Q16‬כיצד ניתן לתקן את בעיית ה‪ ? min delay -‬הסבר למדריך פתרונות אפשריים‪.‬‬
‫‪ :Q17‬לאחר התייעצות עם המדריך בצע את התיקון‪ .‬רשום מה עשית בדו"ח‪.‬‬
‫‪ :Q18‬הוסף סכמת של המימוש לאחר התיקון לדו"ח‪ .‬מה ההבדל לעומת הסכמה הקודמת ?‬
‫‪ :Q19‬חזור על הבדיקה ‪ .hold‬האם הבעיה נפתרה ?‬
‫‪Hold slack‬‬
‫‪Setup slack‬‬
‫)‪cos2(typ‬‬
‫)‪cos2(min/max‬‬
‫)‪cos2_syn(min/max‬‬
‫‪After fix hold‬‬
‫‪ .2‬בעיית ה‪False Path -‬‬
‫המטרה בסעיף זה היא להכיר את בעיית ה‪ .false path -‬כזכור‪ ,‬בחלק הראשון הכנת מעגל בקובץ‬
‫בשם ‪ cos.vhd‬המחשב את הפעולות ‪:‬‬
‫(‪cos(cosx) , )cos x)**2 , (x+1)**2 , cos (x+1‬‬
‫נשתמש במימוש זה במהלך תרגיל זה‪ .‬נניח כעת שאנו מעוניינים רק בפעולות ‪:‬‬
‫(‪)cos x)**2 , (x+1)**2 , cos(x+1‬‬
‫כלומר‪ ,‬קיימים מסלולים לוגיים במעגל שאינם רלוונטיים ואינם מופעלים וחשוב ליידע לכלי על‬
‫קיום כל המסלולים מסוג זה‪.‬‬
‫ הפעל את ה‪ design vision -‬בעזרת הפקודה ‪.dv‬‬‫ קרא את הקובץ ‪ cos.vhd‬בעזרת הפקודה ‪ ,File->Read‬לחץ על ‪ OK‬בחלון שנפתח‪.‬‬‫ בצע סינתזה של המעגל ע"י בחירת ‪.Design->Compile design‬‬‫‪ :Q21‬בעזרת ‪ Timing -> Report Timing Path‬מצא את ההשהיה של המסלול הקריטי‪.‬‬
‫ בדוק את המסלול קריטי של המימוש‪ .‬האם הוא עבור דרך שתי יחידות ה‪? cos -‬‬‫‪35‬‬
‫ נציג כעת את המסלול הקריטי על הסכמה‪ .‬פתח ‪Timing->Timing Analysis Driver‬‬‫ בחלון ‪ select paths‬לחץ על ‪ .OK‬בחלון ‪ TimingAnalysisDriver‬יופיעו כל המסלולים‪ .‬בחר‬‫בעליון‪.‬‬
‫‪ :Q22‬האם זה באמת המסלול הקריטי של התכנון ? הסבר‪.‬‬
‫ בחלון הפקודות רשום הפקודה )‪ (set_false_path‬המציינת לכלי שהמסלול שעובר דרך שתי‬‫יחידת ה‪ cos -‬מסלול אמיתי‪ .‬העזר ב‪ man set_false_path -‬כדי לראות את המבנה המדויק‬
‫של הפקודה‪ .‬הכלי מחזיר "‪ "1‬אם הפקודה נקלטת בהצלחה‪ .‬הקפד על אותיות גדולות‪/‬קטנות‬
‫עבור השמות!)‬
‫‪ :Q23‬מצא שוב את המסלול הקריטי‪ .‬האם זה שונה מהסעיף הקודם ? איזו הודעה מתקבלת‬
‫מהכלי ? הסבר‪.‬‬
‫ בחלון הפקודות רשום ‪:‬‬‫‪- source cos.con‬‬
‫ קובץ זה מכיל את הפקודות‪:‬‬‫*_‪- set_max_delay 10 -to z‬‬
‫ כלומר אילוצים על ההשהיה המרבית עד ליציאה‪.‬‬‫‪ :Q24‬למה לדעתך אנו מספקים אילוצים אלה לכלי ?‬
‫‪ :Q25‬מצא שוב את המסלול הקריטי‪ .‬האם זה שונה מהסעיף הקודם ?‬
‫ עליך להראות את הפקודה שרשמת ואת ולהסביר את התוצאות למדריך!‬‫ סגור את ה‪ dv -‬עם ‪.File->Close‬‬‫‪ .3‬שימוש ב‪ multicycle path/operator -‬ב‪ALU -‬‬
‫המטרה של סעיף זה היא להכיר את הנושא של ‪multicycle path/operator‬‬
‫‪Power‬‬
‫‪Area‬‬
‫‪Slack‬‬
‫‪Arch‬‬
‫‪Parallel‬‬
‫‪1‬‬
‫‪Parallel + MCO (no‬‬
‫)‪recompile‬‬
‫‪2‬‬
‫‪Parallel + MCO (with‬‬
‫)‪recompile‬‬
‫‪3‬‬
‫‪Using a 2 stage‬‬
‫‪pipelined mult‬‬
‫‪4‬‬
‫‪multicycle operator =MCO‬‬
‫א‪ .‬מימוש מקבילי עבור המכפל‬
‫ רשום את המימוש שהכנת עבור ה‪ ALU-‬בקובץ בשם ‪ .alu.vhd‬העזר בקובץ הקיים ספרית‬‫העבודה‪.‬‬
‫ הפעל את ה‪ design vision -‬בעזרת הפקודה ‪.dv‬‬‫ קרא את הקובץ ‪ alu.vhd‬בעזרת הפקודה ‪ ,File->Read‬לחץ על ‪ OK‬בחלון שנפתח‪.‬‬‫ נגדיר שעון בעל מחזור של ‪ 2ns‬בעזרת את הפקודה ‪:‬‬‫} ‪create_clock -name "clk" -period 2 -waveform { 0 1 } { clk‬‬
‫ בצע סינתזה של המעגל ע"י בחירת ‪.Design->Compile Design‬‬‫‪ : Q31‬מצא את ה‪ slack -‬של המסלול הקריטי‪ ,‬צריכת ההספק והשטח של המימוש‪ .‬שים לב שהכלי‬
‫מדווח על המסלול דרך המכפל כמסלול הקריטי ‪ .‬רשום את הנתונים בטבלה‪.‬‬
‫‪36‬‬
‫ב‪ .‬מימוש מקבילי עבור המכפל ושימוש ב‪multicycle path -‬‬
‫נדגים בסעיף זה שימוש ב‪.multicycle operator -‬‬
‫ כעת נודיע לכלי שהמכפל רשאי לבצע את חישוב בשני מחזורים שעון‪ .‬נעשה זאת בעזרת‬‫הפקודות ‪:‬‬
‫*_‪set_multicycle_path 2 –through mul*/product‬‬
‫ בסכמה של המעגל‪ ,‬ניתן לראות שקיים מכפל בשם *_‪ .mult‬הפקודה הנ"ל מגדירה את כל‬‫המסלולים שעוברים דרך יציאת ‪ product‬של המכפל כמסלולי ‪ multicycle‬המתבצעים בשני‬
‫מחזורי שעון‪.‬‬
‫‪ :Q32‬בדוק שוב את המסלול הקריטי ? האם גם הפעם המסלול הקריטי עובר דרך מכפל? הסבר‪.‬‬
‫רשום בטבלה מהו שטח המעגל‪ ,‬צריכת ההספק שלו וה‪ slack -‬של המסלול הקריטי?‬
‫נבצע שוב סינתזה של המעגל ע"י בחירת ‪ Design->Compile Design‬על מנת לבדוק האם הכלי‬
‫מסוגל לשפר את המימוש‪.‬‬
‫‪ :Q33‬רשום בטבלה מהו שטח המעגל‪ ,‬צריכת ההספק שלו וה‪ slack -‬של המסלול הקריטי?‬
‫‪ :Q34‬הסבר מדוע לדעתך המעגל עומד בדרישות התזמון אחרי ‪ Design->Compile Design‬ולא‬
‫עמד בדרישות התזמון לפני כן‪.‬‬
‫ג‪ .‬מימוש מצונר עבור המכפל‬
‫דרך נוספת לפתור את בעיית התזמון עבור המקרה הזה היא לבצע את החישוב ב‪.pipeline -‬‬
‫המטרה היא להשוואת את הפתרון הזה עם הקודם מחינת תוספת השטח הדרושה‪.‬‬
‫ רשום את המימוש שהכנת עבור ה‪ ALU-‬בקובץ בשם ‪ .alu2.vhd‬העזר בקובץ הקיים ספרית‬‫העבודה‪.‬‬
‫ הפעל את ה‪ design vision -‬בעזרת הפקודה ‪.dv‬‬‫ קרא את הקובץ ‪ alu2.vhd‬בעזרת הפקודה ‪ ,File->Read‬לחץ על ‪ OK‬בחלון שנפתח‪.‬‬‫ נגדיר שעון בעל מחזור של ‪ 2ns‬בעזרת את הפקודה ‪:‬‬‫} ‪create_clock -name "clk" -period 2 -waveform { 0 1 } { clk‬‬
‫ בצע סינתזה של המעגל ע"י בחירת ‪.Design->Compile Design‬‬‫ מצא את ה‪ slack -‬של המסלול הקריטי‪ ,‬צריכת ההספק והשטח של המימוש‪ .‬רשום את הנתונים‬‫בטבלה‪.‬‬
‫‪ :Q35‬האם המסלול הקריטי עובר דרך המכפל ? הסבר‪.‬‬
‫‪ :Q36‬איזו ארכיטקטורה היא הטובה ביותר ? הסבר‪.‬‬
‫‪ .4‬שיפור הבדיקתיות ‪Design For Testability (DFT) :‬‬
‫המטרה בסעיף זה היא להכיר את היכולת של הכלי לשפר באופן אוטומטי את הבדיקתיות של‬
‫התכנון‪.‬‬
‫ בקובץ ‪ dft.vhd‬רשום את המימוש של המעגל שמחשב )‪ (a*b+c‬עם רגיסטרים שהכנת‪.‬‬‫ הפעל את ה‪ design vision -‬בעזרת הפקודה ‪.dv‬‬‫ קרא את הקובץ ‪ reg16.vhd‬בעזרת הפקודה ‪ ,File->Read‬לחץ על ‪ OK‬בחלון שנפתח‪.‬‬‫ קרא את הקובץ ‪ dft.vhd‬בעזרת הפקודה ‪ ,File->Read‬לחץ על ‪ OK‬בחלון שנפתח‪.‬‬‫}‪create_clock –name “clk” –period 2 –waveform {0 1} {clk‬‬
‫ בצע סינתזה של המעגל ע"י בחירת ‪.Design->Compile Design‬‬‫‪ :Q41‬רשום בטבלה מהו שטח המעגל‪ ,‬צריכת ההספק והשהיית המסלול הקריטי?‬
‫ בחר באחד הרגיסטרים‪ .‬כדי לראות את הסכמה יש ללחוץ על ↓‪.‬‬‫‪ :Q42‬צרף לדו"ח את הסכמה של הרגיסטר‪.‬‬
‫‪37‬‬
‫‪-‬‬
‫‬‫‪-‬‬
‫חזור לרמה העליונה של הסכמה‪.‬‬
‫בחלון הפקודות רשום ‪:‬‬
‫‬‫‪-‬‬
‫ב‪ dft.src -‬רשומות שתי פקודות עם הגדרות עבור ה‪.scan insertion -‬‬
‫בחלון הפקודות רשום ‪:‬‬
‫‪source dft.src‬‬
‫‪insert_dft‬‬
‫‪ :Q43‬רשום בטבלה מהו שטח המעגל‪ ,‬צריכת ההספק והשהיית המסלול הקריטי?‬
‫‪Power‬‬
‫‪Max‬‬
‫‪Delay‬‬
‫‪-‬‬
‫‪-‬‬
‫‪Area‬‬
‫‪Before DFT‬‬
‫‪After DFT‬‬
‫‪ :Q44‬רשום כיצד ‪ insert_dft‬השפיע על ערכים אלה‪.‬‬
‫‪ :Q45‬רשום את כל השינויים שהוכנסו למעגל כתוצאה של הפקודה ‪.insert_dft‬‬
‫‪ :Q46‬צרף לדו"ח את הסכמה של הרגיסטרים החדשים שהפעולה יצרה‪.‬‬
‫ סגור את ה‪ dv -‬עם ‪.File->Close‬‬‫ הפעל את ה‪ design vision -‬מחדש בעזרת הפקודה ‪.dv‬‬‫ קרא את הקובץ ‪ reg16.vhd‬בעזרת הפקודה ‪ ,File->Read‬לחץ על ‪ OK‬בחלון שנפתח‪.‬‬‫ קרא את הקובץ ‪ dft.vhd‬בעזרת הפקודה ‪ ,File->Read‬לחץ על ‪ OK‬בחלון שנפתח‪.‬‬‫ בצע סינתזה של המעגל ע"י בחירת ‪.Design->Compile design‬‬‫ אם ברצוננו לשנות את שיטת הפעולה של הפקודה ‪ insert_dft‬יש להשתמש בפקודה‬‫‪ set_scan_configuration‬לפני ביצוע ‪.insert_dft‬‬
‫ ניתן לקבל הסבר מפורט על ‪ set_scan_configuration‬על ידי רישום ‪:‬‬‫‪- man set_scan_configuration‬‬
‫בחלון הפקודות‪.‬‬
‫ הרץ שוב ‪:‬‬‫‪- source dft.src‬‬
‫‪ :Q47‬בעזרת ההסבר רשום פקודה שיגרום ל‪ insert_dft -‬להכניס ‪scan_chains 3‬‬
‫‪- insert_dft‬‬
‫‪ :Q48‬צרף לדו"ח את הסכמה של הרמה העליונה של התכנון ואת הסכמה של הרגיסטר המציג את‬
‫‪ 3‬ה‪.scan_chains -‬‬
‫בצע את הפקודה ‪:‬‬
‫‪- write_scan_def -output scandef‬‬
‫פקודה זאת יוצרת קובץ בשם ‪ scandef‬המכיל את כל הנתונים של ה‪ .scan chains -‬פתח את‬
‫הקובץ ובחן את התוכנו‪.‬‬
‫‪ :Q49‬רשום את שמות הכניסה והיציאה של כל ‪.scan chain‬‬
‫‪ -‬סגור את ה‪ dv -‬עם ‪.File->Close‬‬
‫סיום חלק שני !‬
‫‪38‬‬