לדלג לתוכן

משתמש:Yishaybg/אופן מעינה

מתוך ויקיפדיה, האנציקלופדיה החופשית

Addressing mode

אופני מעינה או אופני מיעוןאנגלית: Addressing modes) הם היבט של ארכיטקטורת ערכת ההוראות ברוב יחידות העיבוד המרכזיות (CPU). אופני המעינה השונים, המוגדרים בארכיטקטורת סט פקודות נתונה, מגדירים כיצד הוראות שפת המכונה בארכיטקטורה זו מתייחסות אל כל אחד מהאופרנדים בפקודה נתונה – האם האופרנד מייצג נתון מספרי, כתובת או מספר אוגר וכדומה. אופן המעינה מציין כיצד לחשב את כתובת הזיכרון בפועל (memory effective address) של אופרנד באמצעות שימוש במידע שבאוגרים, בקבועים הכלולים בהוראת המכונה או במקום אחר.

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

בדרך כלל אין שמות אחידים לאופני המעינה השונים; ארכיטקטים של מחשבים ויצרני מחשבים שונים עשויים לתת שמות שונים לאותו אופן מעינה, או שם אחד לאופני מעינה שונים. יתרה מזאת, אופן מעינה שבארכיטקטורה נתונה פועל כאופן מעינה יחיד עשוי לייצג פונקציונליות שבארכיטקטורה אחרת דורשת שני אופני מעינה או יותר. לדוגמה, בכמה ארכיטקטורות מחשבים בעלות סט פקודות מורכב (CISC), כגון VAX של חברת דיגיטל, התייחסות לאוגרים והתייחסות לקבועים מיידיים (כלומר קבועים הנמצאים בפקודה עצמה) נחשבות כשני אופני מעינה של אותה הוראה. במחשבים אחרים, כגון IBM System/360 ובממשיכיו, וברוב המחשבים עם סט פקודות מצומצם (RISC), מידע זה מקודד בתוך ההוראה עצמה. כלומר, למחשבים האחרונים יש הוראות נפרדות עבור העתקת אוגר אחד למשנהו, עבור העתקת קבוע מפורש לתוך אוגר ועבור העתקת נתון מזיכרון לתוך אוגר, בעוד של-VAX יש רק הוראת "MOV" אחת בעלת כמה אופני מעינה.

המונח "אופן מעינה" עצמו נתון לפרשנויות שונות: יש שמגדירים אותו כ"אופן חישוב כתובת זיכרון" ויש שמגדירים אותו כ"אופן גישה לאופרנד". לפי ההגדרה הראשונה, הוראות שאינן קוראות מהזיכרון או כותבות לזיכרון (כגון הוראה להוספת קבוע לאוגר) לא נחשבות בעלות "אופן מעינה". ההגדרה השנייה מאפשרת למחשבים כגון VAX, המשתמשים בסיביות מצב אופרנד (operand mode bits) בהוראה, להגדיר אם האופרנד נמצא באוגר או שהוא ערך קבוע. עם זאת, רק ההגדרה הראשונה רלוונטית עבור הוראות כגון "טען כתובת בפועל", הוראה שמוֹרה למחשב לטעון את הכתובת עצמה במקום את הנתון שבכתובת זו.

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

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

לחלק מהמחשבים, כמו IBM 709 ו־RCA 3301,[1] אין שדה אופן מעינה יחיד אלא שדות נפרדים עבור מעינה עקיפה ועבור שימוש באינדקס.

מספר אופני המעינה

[עריכת קוד מקור | עריכה]

מספר אופני המעינה משתנה מאוד בין ארכיטקטורות מחשבים שונות. ישנם כמה יתרונות בביטול אופני מעינה מורכבים ובשימוש באופן מעינה יחיד בלבד או בכמה פשוטים, אף על פי שדבר זה דורש כמה הוראות נוספות, ואולי אף אוגר נוסף.[2][3] הוכח[4][5][6] שקל הרבה יותר לתכנן מעבדים העובדים בשיטת צינור עיבוד נתונים אם אופני המעינה הם פשוטים.

לרוב ארכיטקטורות ה־RISC יש כ־5 אופני מעינה פשוטים, בעוד שלמחשבי ארכיטקטורות CISC, כגון VAX של דיגיטל, יש יותר מתריסר אופני מעינה, חלקם מורכבים למדי. לארכיטקטורת IBM System/360 היו רק 3 אופני מעינה; עוד כמה נוספו עבור System/390.

כאשר יש מספר מועט של אופני מעינה, אופן המעינה המסוים הנדרש מקודד בדרך כלל בתוך קוד ההוראות (למשל ב־IBM System/360 וממשיכיו, ורוב ה־RISC), כלומר יש הוראה נפרדת עבור אופן מעינה שאינו מובנה. כאשר ישנם אופני מעינה רבים, לעיתים קרובות יש שדה ספציפי בהוראה שמציין את אופן המעינה. ה-DEC VAX אִפשר כמעט לכל ההוראות לעבוד עם אופרנדים מרובים של זיכרון (כלומר שהוראה בודדת עשויה לגשת או לשנות נתונים המאוחסנים במספר מיקומי זיכרון), ולכן הוא שמר את הסיביות הראשונות בכל שדה אופרנד בהוראה כדי לציין את אופן המעינה עבור האופרנד המסוים הזה. תכנון זה אִפשר פעולות מגוונות על מיקומי זיכרון שונים בתוך הוראה יחידה, והגביר את גמישות הארכיטקטורה ואת יעילותה.

אפילו במחשבים בעלי אופני מעינה רבים, מדידות של תוכניות בפועל[7] מצביעות על כך שאופני המעינה הפשוטים המפורטים להלן מהווים כ-90% או יותר מכלל אופני המעינה שבשימוש. מכיוון שרוב המדידות הללו מבוססות על קוד שנוצר משפות עיליות על ידי מהדרים, הדבר משקף במידה מסוימת את מגבלות המהדרים שבשימוש.[8][7][9]

יישום מעשי חשוב

[עריכת קוד מקור | עריכה]

כמה ארכיטקטורות סט פקודות, כגון אינטל x86 ו-IBM/360 וממשיכיה, כוללות הוראת כתובת בפועל (effective address) לטעינת נתונים.[10][11] הוראה זו מחשבת את כתובת האופרנד בפועל וטוענת אותה לתוך אוגר, מבלי לגשת לכתובת זיכרון שאליו היא מתייחסת. דבר זה יכול להיות שימושי בעת העברת הכתובת של ערך מתוך מערך לתת-שגרה. זו עשויה להיות גם דרך חכמה לבצע יותר חישובים בהוראה יחידה. לדוגמה, שימוש בהוראה כזו עם אופן המעינה "בסיס + אינדקס + היסט" (מפורט להלן) מאפשר לבצע פעולת חיבור של שני אוגרים וקבוע בהוראה אחת ולאחסן את התוצאה באוגר שלישי.

אופני מעינה פשוטים עבור קוד

[עריכת קוד מקור | עריכה]

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

מוחלטת או ישירה

[עריכת קוד מקור | עריכה]
+----+------------------------------+
|jump| address |
+----+------------------------------+

במעינה מוחלטת או ישירה (Absolute or direct), הכתובת בפועל עבור כתובת פקודה ישירה היא פרמטר הכתובת עצמו, ללא שינויים כלשהם.

מעינה יחסית

[עריכת קוד מקור | עריכה]
+----+------------------------------+
|jump| offset | jump relative
+----+------------------------------+

במעינה יחסית (PC-relative), הכתובת בפועל עבור כתובת פקודה יחסית היא כתובת ההוראה הבאה בתופסת פרמטר ההיסט. היסט הוא מספר, חיובי או שלילי ("מספר מסומן"), המאפשר להתייחס לקוד שמופיע אחרי ההוראה או לפניה.[12]

דבר זה שימושי במיוחד בקפיצות, מכיוון שקפיצות טיפוסיות קופצות להוראות סמוכות (בשפה עילית, ברוב הפקודות המותנות (if) ובלולאות ה־while הקפיצות הן קצרות למדי). מדידות בפועל תוכניות מצביעות על כך שהיסט של 8 או 10 סיביות (בערך ±128 או ±512 בתים) מספיק לכ־90% מהקפיצות המותנות.[13]

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

גרסאות מסוימות של אופן מעינה זה עשויות להיות מותנות בתוכן של שני אוגרים ("קפוץ אם reg1=reg2"), בתוכן אוגר יחיד ("קפוץ אלא אם כן reg1=0") או ללא אוגרים בכלל, תוך התייחסות הרומזת לאיזושהי סיבית שהוצבה קודם לכן באוגר הדגלים. ראו גם ביצוע מותנה להלן.

מעינת אוגר עקיפה

[עריכת קוד מקור | עריכה]
+-------+-----+
|jumpVia| reg |
+-------+-----+
(כתובת מונה התוכנית בפועל = תוכן האוגר 'reg')

במעינת אוגר עקיפה (Register indirect), הכתובת בפועל היא תוכן האוגר שצוין בפקודה. לדוגמה, בפקודה jump (A7) המעבד ניגש לאוגר הכתובת A7, וקופץ לכתובת הנמצאת בו.

למחשבי RISC רבים, כמו גם למחשב ה־CISC‏ IBM System/360 ולבאים אחריו, יש הוראות קריאה לתת-שגרות ששומרות את כתובת החזרה באוגר כתובת – מעינת אוגר עקיפה משמשת לחזרה לתוכנית הראשית מאותה תת-שגרה.

אופני מעינה פשוטים עבור נתונים

[עריכת קוד מקור | עריכה]

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

מעינת אוגר ישירה

[עריכת קוד מקור | עריכה]
+------+-----+-----+-----+
| mul  | reg1| reg2| reg3| reg1 := reg2 * reg3;
+------+-----+-----+-----+

למעינת אוגר ישירה (register direct; נקראת גם מעינת אוגר) אין כתובת בפועל, ובמחשבים מסוימים היא אינה נחשבת לאופן מעינה.

בדוגמה זו, כל האופרנדים נמצאים באוגרים, והתוצאה נכתבת לאוגר.

מיידית או מפורשת

[עריכת קוד מקור | עריכה]
+------+-----+-----+----------------+
| add  | reg1| reg2| constant | reg1 := reg2 + constant;
+------+-----+-----+----------------+

למעינה מיידית או מפורשת (Immediate or literal) אין כתובת בפועל, ובמחשבים מסוימים היא אינה נחשבת לאופן מעינה.

הקבוע עשוי להיות חיובי בלבד או בעל סימן. לדוגמה, move.l #$FEEDABBA, D0 כדי להעביר את הערך ההקסדצימלי המיידי "FEEDABBA" לתוך האוגר D0.

במקום להשתמש באופרנד מהזיכרון, הערך של האופרנד נמצא בתוך ההוראה עצמה. במחשב VAX של חברת DEC, האופרנד המפורש יכול להיות באורך של 6, 8, 16 או 32 סיביות.

אנדרו טננבאום הראה ש-98% מכל הקבועים בתוכנית יתאימו ל-13 סיביות (ראוRISC).

בסיס עם היסט

[עריכת קוד מקור | עריכה]
+------+-----+-----+----------------+
| load | reg | base| offset | reg := RAM[base + offset]
+------+-----+-----+----------------+
(כתובת בפועל = היסט + תוכן אוגר הבסיס שצוין)

במעינת בסיס עם היסט (Base plus offset), ההיסט הוא ערך חיובי או שלילי של 16 סיביות (בערך ±32 קילו־בייט אם כי ב־80386 הוא הורחב ל-32 סיביות – בערך ±2 גיגה־בייט).

אם ההיסט הוא אפס, המעינה הופכת למקרה פרטי של מעינת אוגר עקיפה משום שהכתובת בפועל היא פשוט הערך שבאוגר הבסיס.

במחשבי RISC רבים, ערכו של אוגר 0 הוא תמיד אפס ולא ניתן לשנותו. אם משתמשים באוגר 0 כאוגר הבסיס, הכתובת בפועל היא ההיסט והמעינה הופכת למקרה פרטי של מעינה ישירה. עם זאת, ניתן לגשת בדרך זו רק לחלק קטן מהזיכרון (64 קילובייט, אם ההיסט הוא של 16 סיביות).

היסט של 16 סיביות עשוי להיראות קטן מאוד ביחס לגודל זיכרונות המחשב בימינו (ולכן ב־80386 הוא הורחב ל-32 סיביות), אך המצב יכול להיות גרוע יותר: למחשבי המיינפריים של IBM System/360 יש היסט חיובי בלבד של 12 סיביות. עם זאת, עקרון המקומיות חל: לאורך זמן קצר, רוב פריטי הנתונים שתוכנית רוצה לגשת אליהם קרובים למדי זה לזה.

לדוגמה, בתוך תת-שגרה, מתכנת יתעניין בעיקר בפרמטרים ובמשתנים המקומיים, שרק לעיתים רחוקות יהיו במרחקים העולים על 64 קילו־בייט. עבורם מספיק אוגר בסיס אחד – מצביע המסגרת. אם שגרה זו היא שיטת מחלקה (class method) בשפה מונחית עצמים, אז קיים צורך באוגר בסיס נוסף שמצביע על תכונות האובייקט הנוכחי (this או self בשפות עיליות מסוימות).

דוגמה נוספת, אם אוגר הבסיס מכיל את הכתובת של טיפוס נתונים מורכב (רשומה או מבנה), ניתן להשתמש בהיסט לבחירת שדה באותו הטיפוס (גודלם של רוב הרשומות והמבנים הוא פחות מ־32 קילו־בייט).

אופן מעינה זה קשור בקשר הדוק למעינה ישירה ממופתחת (indexed absolute addressing).

+-----------------+
| clear carry bit |
+-----------------+
+-------------------+
| clear Accumulator |
+-------------------+

במעינה מרמזת או משתמעת (Implicit), הכתובת בפועל למקור או ליעד (ולפעמים עבור שניהם) אינה מצוינת במפורש.

המקור (אם בכלל יש מקור) או כתובת היעד בפועל (ולפעמים שניהם) משתמעים מתוך קוד הפעולה.

מעינה מרמזת הייתה נפוצה למדי במחשבים ישנים (עד אמצע שנות ה-70). למחשבים כאלה היה בדרך כלל רק אוגר בודד שבו ניתן לבצע פעולות אריתמטיות – הצובר. מכונות צובר כאלה מתייחסות באופן מרומז לאותו צובר כמעט בכל הוראה. לדוגמה, את הפעולה a := b + c; ניתן לעשות באמצעות הרצף load b; add c; store a; – היעד (הצובר) מרומז בכל הוראת טעינה (load) וחיבור (add); המקור (גם הצובר) מרומז בכל הוראת אחסון (store).

למחשבים מאוחרים יותר, היו בדרך כלל יותר מאוגר רב תכליתי יחיד או מיקום RAM יחיד שיכולים להיות המקור או היעד או שניהם עבור פעולות אריתמטיות, ולכן מחשבים מאוחרים יותר צריכים אופני מעינה אחרים כדי לציין את המקור ואת היעד של האריתמטיקה.

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

למחשבים רבים (כגון x86 ו-AVR) יש אוגר אחד למטרות מיוחדות הנקרא מצביע המחסנית (stack pointer), אשר מוגדל או מופחת באופן מרומז בעת דחיפה (push) או שליפה (pop) של נתונים מהמחסנית, והכתובת בפועל של המקור או של היעד היא (באופן מרומז) הכתובת המאוחסנת במצביע מחסנית.

למחשבי 32 סיביות רבים (כגון 68000, ARM או PowerPC) יש יותר מאוגר יחיד שיכול לשמש כמצביע מחסנית, ולכן משתמשים באופן המעינה "מעינת אוגר מוגדל אוטומטית עקיפה" (register autoincrement indirect) כדי לציין באיזה אוגר יש להשתמש כאשר דוחפים או שולפים נתונים ממחסנית.

כמה ארכיטקטורות מחשבים נוכחיות (כמו IBM/390 ופנטיום) מכילות כמה הוראות עם אופרנדים מרומזים על מנת לשמור על תאימות לאחור עם מעבדים קודמים. במחשבים רבים, הוראות שהופכות את סיבית מצב המשתמש/מערכת, סיבית אִפשור פסיקות (interrupt-enable) וכו' רומזות לאוגר המיוחד שבו נשמרות סיביות אלו.

כמה מעבדים תוכננו באופן כזה כך שכל אופרנד תמיד מצוין באופן מרומז בלבד בכל הוראה שהיא. מעבדים אלו נקראים מעבדים ללא מען (zero-operand CPUs).

אופני מעינה סדרתיים

[עריכת קוד מקור | עריכה]

ביצוע סדרתי

[עריכת קוד מקור | עריכה]
+------+
| nop  | execute the following instruction
+------+
(כתובת מונה התוכנית בפועל = כתובת ההוראה הבאה)

הוראה סדרתית (sequential instruction) היא הוראה שאחרי ביצועה המעבד מבצע מיד את ההוראה הבאה שבזיכרון. במחשבים מסוימים, ביצוע סדרתי של הוראות אינו נחשב לאופן מעינה. רוב ההוראות ברוב הארכיטקטורות הן הוראות סדרתיות, ולכן מתכנני מעבדים מוסיפים לעיתים קרובות תכונות שמקריבות בכוונה את ביצועי ההוראות האחרות – כמו הוראות הסתעפות (קפיצות וקריאות לתת-שגרות) – על מנת לגרום להוראות הסדרתיות לרוץ מהר יותר.

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

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

כל "בלוק בסיסי" של הוראות סדרתיות כאלה מציג את עקרון המקומיות גם בזמן וגם במרחב.

מעבדים שאינם משתמשים בביצוע סדרתי

[עריכת קוד מקור | עריכה]

מעבדים שאינם מבצעים הוראות באופן סדרתי באמצעות מונה תוכנית הם נדירים ביותר. בחלק ממעבדים אלו, בכל הוראה תמיד מצוינת כתובת ההוראה הבאה. למעבדים כאלה יש מצביע הוראה שמצביע על הכתובת שצוינה; מצביע זה איננו מונה תוכנית משום שאין מנגנון מובנה להגדלתו. מעבדים כאלה כוללים כמה מחשבי זיכרון תופים (Drum memory) כמו IBM 650, מכונת SECD, ליברסקופ LGP-30 ו־RTX 32P.[14]

ארכיטקטורות מחשוב אחרות הולכות הרבה יותר רחוק, ומנסות לעקוף את צוואר בקבוק פון־נוימן באמצעות מגוון חלופות למונה התוכניות.

ביצוע מותנה

[עריכת קוד מקור | עריכה]

בחלק מארכיטקטורות המחשב יש הוראות מותנות (כגון ב־ARM) או הוראות טעינת נתונים מותנות (כגון ב־x86), כלומר הוראות שמתבצעות אם תנאי מסוים מתקיים. במקרים מסוימים הוראות כאלו יכולות לייתר הסתעפויות מותנות ולמנוע ריקון פתאומי (flushing) של צינור ההוראות. הוראה כגון 'השווה' (compare) קובעת את ערכם של חלק מהדגלים באוגר הדגלים על פי תוצאת ההשוואה, והוראות מותנות עוקבות כוללות בדיקה של הדגלים האלה כדי לראות אם הם מקיימים את התנאי או לא.

+------+-----+-----+
|skipEQ| reg1| reg2| skip the next instruction if reg1=reg2
+------+-----+-----+
(כתובת מונה התוכנית בפועל = כתובת ההוראה הבאה + 1)

מעינת דילוג עשויה להיחשב כסוג מיוחד של מעינה יחסית עם היסט קבוע של 1+. כמו למעינה יחסית, גם למעינה זו יש, במעבדים מסוימים, גרסאות שמותנות בערכו של אוגר אחד בלבד (skip if reg1=0) או שלא מותנות באוגרים בכלל אלא מותנות באופן מרומז באיזשהו ביט באוגר הדגלים שערכו נקבע קודם לכן. במעבדים אחרים יש גרסה שבוחרת סיבית מסוימת בבייט מסוים ובודקת את ערכו ("דלג אם סיביות 7 של reg12 היא 0").

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

אופני מעינה אחרים עבור קוד או נתונים

[עריכת קוד מקור | עריכה]

מוחלט או ישיר

[עריכת קוד מקור | עריכה]
+------+------+-----+
| לטעון | reg1 | בסיס|
+------+------+-----+
(כתובת בפועל = תוכן אוגר הבסיס)

אופן מעינה זה דורש מקום בהוראה עבור כתובת גדולה למדי. הוא קיים לעיתים קרובות במעבדי CISC שיש להם הוראות באורך משתנה, כגון x86.

לחלק ממעבדי RISC יש הוראה מיוחדת של Load Upper Literal הטוענת קבוע של 16 או 20 סיביות אל החצי העליון של אוגר כלשהו. כך האוגר יכול לשמש כאוגר בסיס באופן מעינה בסיס בתוספת היסט, המספק את 16 או 12 הסיביות הנמוכות (LSB). השילוב של שני אופני מעינה אלה מאפשר כתובת מלאה של 32 סיביות.

מוחלט ממופתח

[עריכת קוד מקור | עריכה]
+------+-----+-----+-----+----------------+
| לטעון | reg | בסיס|אינדקס| קיזוז |
+------+-----+-----+-----+----------------+
(כתובת בפועל = היסט + תוכן של אוגר בסיס שצוין + תוכן של אוגר אינדקס שצוין)

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

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

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

דוגמה 2: מתכנת יכול להגדיר מספר מערכים גדולים כמשתנים גלובליים או כמשתני מחלקה. התחלת המערך מאוחסנת בכתובת המפורשת (שאולי שונתה בזמן טעינת התוכנית על ידי מטען זחיח (Relocating loader)) של ההוראה שמפנה אליו. ההיסט - האלמנט מהמערך שבו רוצים להשתמש באיטרציה זו של הלולאה - מאוחסן באוגר האינדקס. לעיתים קרובות ההוראות בלולאה משתמשות מחדש באותו אוגר עבור מונה הלולאה וההיסטים של מספר מערכים.

בסיס פלוס אינדקס פלוס קיזוז

[עריכת קוד מקור | עריכה]
+------+-----+-----+-----+
| לטעון | reg | בסיס|אינדקס|
+------+-----+-----+-----+
(כתובת בפועל = תוכן של אוגר בסיס שצוין + תוכן מוקטן של אוגר אינדקס שצוין)

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

בסיס בתוספת אינדקס

[עריכת קוד מקור | עריכה]
+------+-----+-------+
| לטעון | reg | בסיס |
+------+-----+-------+
(כתובת בפועל = תוכן אוגר הבסיס)

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

+------+-----+-----+
| לטעון | reg | בסיס|
+------+-----+-----+
(כתובת בפועל = תוכן חדש של אוגר הבסיס)

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

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

הרשמה עקיפה

[עריכת קוד מקור | עריכה]
+-----+-----+-------------------------------------------- --+
| טען | reg | כתובת |
+-----+-----+-------------------------------------------- --+
(כתובת בפועל = כתובת כפי שצוינה בהוראות)

לכמה מחשבים יש את זה כאופן מעינה מובחן. מחשבים רבים פשוט משתמשים בבסיס פלוס היסט עם ערך היסט של 0. לדוגמה, (A7)

אוגר הגדלה אוטומטית בעקיפין

[עריכת קוד מקור | עריכה]
+------+-----+-----+------------------------------------- --+
| טען | reg |index| כתובת |
+------+-----+-----+------------------------------------- --+
(כתובת בפועל = כתובת + תוכן אוגר אינדקס שצוין)

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

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

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

  • Motorola 68000 (הכתובת מיוצגת ב-24 סיביות). יכול להיות אחד או שני אופרנדים של אוגר בעל הגדלה אוטומטית. ה־68010+ פתר את הבעיה על ידי שמירת המצב הפנימי של המעבד בשגיאות אפיק או כתובת.
  • DEC VAX. יכול לכלול עד 6 אופרנדים של רישום אוטומטי. כל גישה לאופרנד עלולה לגרום לשתי תקלות עמוד (אם אופרנדים עברו על גבול עמוד). ההוראה עצמה יכולה להיות באורך של יותר מ-50 בתים ועשויה לעבור גם גבול עמוד!

אוגר ירידה אוטומטית בעקיפין

[עריכת קוד מקור | עריכה]
+------+-----+-----+-----+
| לטעון | reg | בסיס|אינדקס|
+------+-----+-----+-----+
(כתובת בפועל = תוכן של אוגר בסיס שצוין + תוכן של אוגר אינדקס שצוין)

לפני קביעת הכתובת בפועל, הערך באוגר הבסיס מופחת לפי גודל פריט הנתונים שאליו יש לגשת.

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

ראה את הדיון על תופעות הלוואי תחת מצב ההתייחסות להגדלה אוטומטית.

זיכרון עקיף או נדחה

[עריכת קוד מקור | עריכה]

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

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

לחלק ממחשבי המיני המוקדמים (DEC PDP-8, Data General Nova, למשל) היו רק כמה אוגרים ורק טווח כתובת ישיר מוגבל (8 סיביות). מכאן שהשימוש בכתובת עקיפה בזיכרון היה כמעט הדרך היחידה להתייחס לכל כמות משמעותית של זיכרון.

מחצית משמונת מצבי הכתובת של DEC PDP-11 נדחים. אוגר דחוי @Rn זהה לאוגר עקיף כפי שהוגדר לעיל. מצבי הפחתה מוקדמת @-(Rn), לאחר ההגדלה דחתה @(Rn)+, ומצבי @nn(Rn) דחוי אינדקס מצביעים על כתובות בזיכרון שנקראות כדי למצוא את הכתובת של הפרמטר. המצבים הנדחים של ה-PDP-11, בשילוב עם מונה התוכניות, מספקים את מצבי הפנייה המוחלטים והיחסי למחשב.

קישורים חיצוניים

[עריכת קוד מקור | עריכה]

הערות שוליים

[עריכת קוד מקור | עריכה]
  1. ^ System Reference Manual - RCA 3301 REALCOM EDP (PDF). RCA. בספטמבר 1967. 94-16-000-1. נבדק ב-21 בדצמבר 2023. {{cite book}}: (עזרה)
  2. ^ F. Chow; S. Correll; M. Himelstein; E. Killian; L. Weber (1987). "How many addressing modes are enough?". ACM Sigarch Computer Architecture News. 15 (5): 117–121. doi:10.1145/36177.36193.
  3. ^ John L. Hennessy; Mark A. Horowitz (1986). "An Overview of the MIPS-X-MP Project" (PDF). ... MIPS-X uses a single addressing mode: base register plus offset. This simple addressing mode allows the computation of the effective address to begin very early. ..
  4. ^ Dr. Jon Squire. "Lecture 19, Pipelining Data Forwarding". CS411 Selected Lecture Notes.
  5. ^ "High Performance Computing, Notes of Class 11 (Sept. 15 and 20, 2000) - Pipelining". אורכב מ-המקור ב-2013-12-27. נבדק ב-2014-02-08.
  6. ^ John Paul Shen, Mikko H. Lipasti (2004). Modern Processor Design. McGraw-Hill Professional. ISBN 9780070570641.
  7. ^ 1 2 John L. Hennessy; David A. Patterson (2002-05-29). Computer Architecture: A Quantitative Approach. Elsevier. p. 104. ISBN 9780080502526. The C54x has 17 data addressing modes, not counting register access, but the four found in MIPS account for 70% of the modes. Autoincrement and autodecrement, found in some RISC architectures, account for another 25% of the usage. This data was collected form a measurement of static instructions for the C-callable library of 54 DSP routines coded in assembly language.
  8. ^ Dr. Sofiène Tahar. "Instruction Set Principles: Addressing Mode Usage (Summary)" (PDF). אורכב מ-המקור (PDF) ב-2011-09-30. 3 programs measured on machine with all address modes (VAX). .. 75% displacement and immediate
  9. ^ Ali-Reza Adl-Tabatabai; Geoff Langdale; Steven Lucco; Robert Wahbe (1995). "Efficient and Language-Independent Mobile Programs". Proceedings of the ACM SIGPLAN 1996 conference on Programming language design and implementation - PLDI '96. pp. 127–136. doi:10.1145/231379.231402. ISBN 0897917952. 79% of all instructions executed could be replaced by RISC instructions or synthesized into RISC instructions using only basic block instruction combination.
  10. ^ IBM System/360 Principles of Operation (PDF). IBM. בספטמבר 1968. p. 135. A22-6821-7. נבדק ב-12 ביולי 2019. {{cite book}}: (עזרה)
  11. ^ z/Architecture Principles of Operation (PDF). IBM. בספטמבר 2017. pp. 7–266. SA22-7832-11. נבדק ב-12 ביולי 2019. {{cite book}}: (עזרה)
  12. ^ Max Maxfield. "Building a 4-Bit Computer: Assembly Language and Assembler". Section "Addressing modes". 2019.
  13. ^ Kong, Shing; Patterson, David (1995). "Instruction set design". Slide 27.
  14. ^ Koopman, Philip (1989). "Architecture of the RTX 32P". Stack Computers.

[[קטגוריה:ארכיטקטורת מחשב]]