משתמש:Yishaybg/אופן מעינה
אופני מעינה (באנגלית: Addressing mode) הם היבט של ארכיטקטורת ערכת ההוראות ברוב יחידות העיבוד המרכזיות (CPU). אופני המעינה השונים, המוגדרים בארכיטקטורת סט פקודות נתונה, מגדירים כיצד הוראות שפת המכונה בארכיטקטורה זו מתייחסות אל כל אחד מהאופרנדים בפקודה נתונה. אופן המעינה מציין כיצד לחשב את כתובת הזיכרון בפועל של אופרנד באמצעות שימוש במידע שבאוגרים, בקבועים הכלולים בהוראת מכונה או במקום אחר.
בתכנות מחשבים, אופני מעינה חשובים בעיקר עבור מתכנתים בשפות סף וכותבי מהדרים. סט פקודות אורתוגונלי הוא סט פקודות שבו כל הוראה יכולה להשתמש בכל אופן מעינה.
סייגים[עריכת קוד מקור | עריכה]
בדרך כלל אין שמות מקובלים לאופני מעינה השונים; ארכיטקטים של מחשבים ויצרני מחשבים שונים עשויים לתת שמות שונים לאותו אופן מעינה, או אותם שמות לאופני מעינה שונים. יתרה מזאת, אופן מעינה אשר בארכיטקטורה נתונה פועל כאופן מעינה יחיד עשוי לייצג פונקציונליות שבארכיטקטורה אחרת דורשת שני אופני מעינה או יותר. לדוגמה, בכמה ארכיטקטורות של מחשבי עם סט פקודות מורכב (CISC), כגון VAX של דיגיטל, יש התייחסות לאוגרים ולקבועים מיידיים כאל אופן מעינה נוסף של אותה הוראה. מחשבים אחרים, כגון IBM System/360 וממשיכיו, ורוב תכנוני המחשבים עם סט פקודות מצומצם (RISC), מקודדים מידע זה בתוך ההוראה עצמה. לפיכך, למחשבים האחרונים יש הוראות נפרדות עבור העתקת אוגר אחד למשנהו, העתקת קבוע מפורש לתוך אוגר, והעתקת תוכן של מיקום זיכרון לתוך אוגר, בעוד של-VAX יש רק הוראת "MOV" אחת.
המונח "אופן מעינה" נתון בעצמו לפרשנויות שונות: יש שמגדירים אותו כ"אופן חישוב כתובת זיכרון" ויש שמגדירים אותו כ"אופן גישה לאופרנד". לפי ההגדרה הראשונה, הוראות שאינן קוראות מהזיכרון או כותבות לזיכרון (כגון "הוסף קבוע לאוגר") לא נחשבות בעלות "אופן מעינה". ההגדרה השנייה מאפשרת למחשבים כגון VAX המשתמשים בסיביות בסיביות בהוראה כדי להגדיר אם האופרנד נמצא באוגר או שהוא ערך קבוע. רק ההגדרה הראשונה רלוונטית עבור הוראות כגון "טעינת כתובת בפועל", אשר טוענת את הכתובת עצמה במקום את הנתון בכתובת זו.
אופני המעינה המפורטים להלן מחולקים למעינות עבור קוד (הוראות) ומעינות עבור נתונים. רוב ארכיטקטורות המחשב שומרות על הבחנה זו, אבל ישנן ארכיטקטורות המאפשרות להשתמש בכל אופני מעינה כמעט בכל הקשר.
ההוראות המוצגות להלן מייצגות אך ורק על מנת להמחיש את אופני המעינה, ואינן משקפות בהכרח את התחביר המשמש מחשב מסוים.
לחלק מהמחשבים, כמו IBM 709 ו־RCA 3301,[1] אין שדה אופן מעינה יחיד אלא שדות נפרדים עבור מעינה עקיפה ושימוש באינדקס.
מספר אופני המעינה[עריכת קוד מקור | עריכה]
ארכיטקטורות המחשב משתנות מאוד באשר למספר אופני המעינה שהם מספקים בחומרה. ישנם כמה יתרונות לביטול אופני מעינה מורכבים ושימוש רק באופן מעינה יחיד או בכמה פשוטים יותר, אף על פי שזה דורש כמה הוראות נוספות, ואולי אף אוגר נוסף.[2][3] זה הוכיח[4][5][6] הרבה יותר קל לתכנן מעבדי צינורות אם אופני המעינה היחידים הזמינים הם פשוטים.
לרוב ארכיטקטורות RISC יש רק כחמישה אופני מעינה פשוטים, בעוד שלמחשבי ארכיטקטורות CISC כגון VAX של דיגיטל יש יותר מתריסר אופני מעינה, חלקם מסובכים למדי. לארכיטקטורת IBM System/360 היו רק שלושה אופני מעינה; עוד כמה נוספו עבור System/390.
כאשר יש רק כמה אופני מעינה, אופן המעינה המסוים הנדרש מקודד בדרך כלל בתוך קוד ההוראות (למשל IBM System/360 וממשיכים, רוב RISC). אך כאשר ישנם אופני מעינה רבים, שדה ספציפי מופרש לעיתים קרובות בצד בהוראה לציון אופן המעינה. ה-DEC VAX אפשר אופרנדים מרובים של זיכרון עבור כמעט כל ההוראות, ולכן שמר את הסיביות הראשונות של כל מפרט אופרנד כדי לציין את אופן המעינה עבור האופרנד המסוים הזה. שמירה על סיביות מפרט אופן המעינה נפרדות מביטים של פעולת ה-opcode מייצרת ערכת הוראות אורתוגונלית.
אפילו במחשב עם אופני מעינה רבים, מדידות של תוכניות בפועל[7] מצביעות על כך שאופני המעינה הפשוטים המפורטים להלן מהווים כ-90% או יותר מכל אופני המעינה בשימוש. מכיוון שרוב המדידות הללו מבוססות על קוד שנוצר משפות ברמה גבוהה על ידי מהדרים, הדבר משקף במידה מסוימת את המגבלות של המהדרים בשימוש.[8][7][9]
יישום מעשי חשוב[עריכת קוד מקור | עריכה]
כמה ארכיטקטורות של סט פקודות, כגון אינטל x86 ו-IBM/360 וממשיכיה, כוללות הוראת כתובת בפועל לטעינת נתונים.[10][11] הוראה זו מחשבת את כתובת האופרנד בפועל וטוענת אותה לתוך אוגר, מבלי לגשת לזיכרון שאליו הוא מתייחס. דבר זה יכול להיות שימושי בעת העברת הכתובת של ערך מתוך מערך לתת-שגרה. זו עשויה להיות גם דרך חכמה לבצע יותר חישובים מהרגיל בהוראה אחת; לדוגמה, שימוש בהוראה כזו עם אופן המעינה "בסיס+אינדקס+היסט" (מפורט להלן) מאפשר להוסיף שני אוגרים וקבוע יחד בהוראה אחת ולאחסן את התוצאה באוגר שלישי.
אופני מעינה פשוטים עבור קוד[עריכת קוד מקור | עריכה]
כמה אופני מעינה פשוטים לקוד מוצגים להלן. המינוחים עשוים להשתנות בהתאם לפלטפורמה.
מוחלט או ישיר[עריכת קוד מקור | עריכה]
+----+------------------------------+ |jump| address | +----+------------------------------+
(כתובת מונה התוכנית בפועל = כתובת)
הכתובת בפועל עבור כתובת פקודה ישירה היא פרמטר הכתובת עצמו, ללא שינויים כלשהם.
מעינה יחסית למונה התוכנית[עריכת קוד מקור | עריכה]
+----+------------------------------+ |jump| offset | jump relative +----+------------------------------+
(כתובת מונה התוכנית בפועל = כתובת ההוראה הבאה + היסט. ההיסט עשוי להיות שלילי)
הכתובת בפועל עבור כתובת פקודה יחסית למונה התוכנית היא פרמטר ההיסט המתווסף לכתובת ההוראה הבאה. היסט הוא בדרך כלל מספר שיכול להיות חיובי או שלילי ("מספר מסומן") כדי לאפשר התייחסות לקוד שמופיע אחרי ההוראה וגם לפניה.[12]
דבר זה שימושי במיוחד בקפיצות, מכיוון שקפיצות טיפוסיות קופצות להוראות סמוכות (בשפה עילית, ברוב הפקודות המותנות (if) ולולאות ה־while הקפיצות הן קצרות למדי). מדידות של בפועל תוכניות מצביעות על כך שהיסט של 8 או 10 סיביות גדול מספיק לכ-90% מהקפיצות המותנות (בערך ±128 או ±512 בתים).[13]
יתרון נוסף של המעינה היחסית למונה התוכנית הוא שהקוד יכול להיות בלתי תלוי במיקום, כלומר ניתן לטעון אותו בכל מקום בזיכרון ללא צורך לשנות בו כתובות כלשהן.
גרסאות מסוימות של אופן מעינה זה עשויות להיות מותנות ביחס לשני אוגרים ("קפוץ אם reg1=reg2"), לאוגר אחד ("קפוץ אלא אם כן reg1=0") או ללא אוגרים בכלל, תוך התייחסות הרומזת לאיזושהי סיבית שהוגדרה קודם לכן באוגר הדגלים. ראו גם ביצוע מותנה להלן.
אוגר עקיף[עריכת קוד מקור | עריכה]
+-------+-----+ |jumpVia| reg | +-------+-----+
(כתובת מונה התוכנית בפועל = תוכן האוגר 'reg')
הכתובת בפועל להוראת אוגר עקיפה היא הכתובת באוגר שצוין. לדוגמה, (A7) כדי לגשת לתוכן של אוגר הכתובת A7.
ההשפעה היא העברת השליטה להוראה שכתובתה נמצאת באוגר שצוין.
למחשבי RISC רבים, כמו גם למחשב ה־CISC IBM System/360 ולבאים אחריו, יש הוראות קריאה לתת-שגרתיות ששומרות את כתובת החזרה באוגר כתובת - אופן המעינה העקיפה של האוגר משמש כדי לחזור לתוכנית הראשית מאותה תת-שגרה.
אופני מעינה סדרתיים[עריכת קוד מקור | עריכה]
ביצוע סדרתי[עריכת קוד מקור | עריכה]
+------+ | nop | execute the following instruction +------+
(כתובת מונה התוכנית בפועל = כתובת ההוראה הבאה)
לאחר ביצוע הוראה סדרתית, המעבד מבצע מיד את ההוראה הבאה.
ביצוע סדרתי אינו נחשב כאופן מעינה במחשבים מסוימים.
רוב ההוראות ברוב ארכיטקטורות המעבד הן הוראות סדרתיות. מכיוון שרוב ההוראות הן הוראות סדרתיות, מתכנני CPU לעיתים קרובות מוסיפים תכונות שמקריבות בכוונה את ביצועי ההוראות האחרות - כמו הוראות הסתעפות - על מנת לגרום להוראות הסדרתיות הללו לרוץ מהר יותר.
הסתעפויות מותנות טוענות למונה התוכנית אחת מ-2 תוצאות אפשריות, בהתאם לקיום התנאי - רוב ארכיטקטורות ה-CPU משתמשות באופן מעינה מסוים עבור הסתעפות שקרתה, וביצוע סדרתי עבור הסתעפות שלא התרחשה.
תכונות רבות במעבדים מודרניים - כגון אחזור מוקדם של הוראות והצנרה מורכבת יותר, ביצוע שלא לפי הסדר וכו' - שומרות על האשליה שכל הוראה מסתיימת לפני שההוראה הבאה מתחילה, ושהתוצאות הסופיות אן אותן תוצאות, אף על פי שזה לא בדיוק מה שקורה בתוך החומרה.
כל "בלוק בסיסי" של הוראות סדרתיות כאלה מציג את מקומיות הייחוס גם בזמן וגם במרחב.
מעבדים שאינם משתמשים בביצוע סדרתי[עריכת קוד מקור | עריכה]
מעבדים שאינם משתמשים בביצוע סדרתי עם מונה תוכנית הם נדירים ביותר. בחלק ממעבדים כאלה, כל הוראה תמיד מציינת את כתובת ההוראה הבאה. למעבדים כאלה יש מצביע הוראה שמחזיק את הכתובת שצוינה; מצביע זה הוא אינו מונה תוכנית משום שאין מנגנון מובנה להגדלתו. מעבדים כאלה כוללים כמה מחשבי זיכרון תופים (Drum memory) כמו IBM 650, מכונת SECD, ליברסקופ LGP-30 ו-RTX 32P.[14]
ארכיטקטורות מחשוב אחרות הולכות הרבה יותר רחוק, ומנסות לעקוף את צוואר בקבוק פון־נוימן באמצעות מגוון חלופות למונה התוכניות.
ביצוע מותנה[עריכת קוד מקור | עריכה]
בחלק מארכיטקטורות המחשב יש הוראות מותנות (כגון ב־ARM, אבל כבר לא עבור כל ההוראות במצב 64 סיביות) או הוראות טעינת נתונים מותנות (כגון ב־x86) אשר במקרים מסוימים יכולות לייתר הסתעפויות מותנות ולמנוע ריקון פתאומי של צינור ההוראות (flushing). הוראה כגון 'השווה' (compare) קובעת את ערכם של חלק מהדגלים באוגר הדגלים על פי תוצאת ההשוואה, והוראות עוקבות כוללות בדיקה של הדגלים האלה כדי לראות אם הם מקיימים את התנאי או לא.
דילוג[עריכת קוד מקור | עריכה]
+------+-----+-----+ |skipEQ| reg1| reg2| skip the next instruction if reg1=reg2 +------+-----+-----+
(כתובת מונה התוכנית בפועל = כתובת ההוראה הבאה + 1)
מעינת דילוג עשויה להיחשב כסוג מיוחד של מעינה יחסית למונה התוכנית עם היסט קבוע של "+1". כמו מעינה יחסית למונה התוכנית, גם לאופן המעינה הזה יש, במעבדים מסוימים, גרסאות שמתייחסות לאוגר אחד בלבד ("דלג אם reg1=0") או שלא מתייחסות לאוגרים בכלל אלא באופן מרומז לאיזשהו ביט שערכו נקבע קודם לכן באוגר הדגלים. במעבדים אחרים יש גרסה שבוחרת סיביות מסוימת בבייט ספציפי לבדיקה ("דלג אם סיביות 7 של reg12 היא 0").
בניגוד לכל ההסתעפויות המותנות האחרות, הוראת דילוג לעולם אינה צריכה "לשטוף" את צינור ההוראות, אם כי ייתכן שהיא תצטרך לגרום להתעלמות מההוראה הבאה.
אופני מעינה פשוטים עבור נתונים[עריכת קוד מקור | עריכה]
כמה אופני מעינה פשוטים לנתונים מוצגים להלן. המינוחים עשוים להשתנות בהתאם לפלטפורמה.
אוגר (או אוגר ישיר)[עריכת קוד מקור | עריכה]
+------+-----+-----+-----+ | mul | reg1| reg2| reg3| reg1 := reg2 * reg3; +------+-----+-----+-----+
ל"אופן מעינה" זה אין כתובת בפועל והוא אינו נחשב כאופן מעינה במחשבים מסוימים.
בדוגמה זו, כל האופרנדים נמצאים באוגרים, והתוצאה נכתבת לאוגר.
בסיס בתוספת היסט, ווריאציות[עריכת קוד מקור | עריכה]
זה מכונה לפעמים 'בסיס בתוספת היסט'
+------+-----+-----+----------------+ | load | reg | base| offset | reg := RAM[base + offset] +------+-----+-----+----------------+
(כתובת בפועל = היסט + תוכן אוגר הבסיס שצוין)
ההיסט הוא בדרך כלל ערך חיובי או שלילי של 16 סיביות (אם כי ב־80386 הוא הורחב ל-32 סיביות).
אם ההיסט הוא אפס, המעינה הופכת למקרה פרטי של מעינת אוגר עקיף; הכתובת בפועל היא פשוט הערך שבאוגר הבסיס.
במחשבי RISC רבים, ערכו של אוגר 0 הוא תמיד אפס ולא ניתן לשנותו. אם משתמשים באוגר 0 כאוגר הבסיס, המעינה הופכת למקרה פרטי של מעינה ישירה. עם זאת, ניתן לגשת בדרך זו רק לחלק קטן מהזיכרון (64 קילובייט, אם ההיסט הוא של 16 סיביות).
היסט של 16 סיביות עשוי להיראות קטן מאוד ביחס לגודל זיכרונות המחשב בימינו (ולכן ב־80386 הוא הורחב ל-32 סיביות). דבר זה יכול להיות גרוע יותר: למחשב המרכזי של IBM System/360 יש רק היסט חיובי של 12 סיביות. עם זאת, עיקרון מקומיות הייחוס חל: לאורך זמן קצר, רוב פריטי הנתונים שתוכנית רוצה לגשת אליהם קרובים למדי זה לזה.
אופן מעינה זה קשור בקשר הדוק לאופן המעינה הישיר הממופתח (indexed).
דוגמה 1: בתוך תת-שגרה מתכנת יתעניין בעיקר בפרמטרים ובמשתנים המקומיים שלעיתים רחוקות יעלו על מרחק של 64 קילו־בייט. עבורם מספיק אוגר בסיס אחד (מצביע המסגרת). אם שגרה זו היא שיטת מחלקה (class method) בשפה מונחית עצמים, אז קיים צורך באוגר בסיס שני שמצביע על התכונות של האובייקט הנוכחי (this או self בשפות עיליות מסוימות).
דוגמה 2: אם אוגר הבסיס מכיל את הכתובת של טיפוס נתונים מורכב (רשומה או מבנה), ניתן להשתמש בהיסט לבחירת שדה של אותו הטיפוס (גודלם של רוב הרשומות והמבנים הוא פחות מ-32 קילו־בייט).
מיידי / מפורש[עריכת קוד מקור | עריכה]
+------+-----+-----+----------------+ | add | reg1| reg2| constant | reg1 := reg2 + constant; +------+-----+-----+----------------+
ל"אופן מעינה" זה אין כתובת בפועל, והוא אינו נחשב כאופן מעינה במחשבים מסוימים.
הקבוע עשוי להיות בעל סימן או חיובי בלבד. לדוגמה, move.l #$FEEDABBA, D0 כדי להעביר את הערך ההקסדצימלי המיידי "FEEDABBA" לתוך האוגר D0.
במקום להשתמש באופרנד מהזיכרון, הערך של האופרנד נמצא בתוך ההוראה עצמה. במחשב VAX של חברת DEC, האופרנד המפורש יכול להיות באורך של 6, 8, 16 או 32 סיביות.
אנדרו טננבאום הראה ש-98% מכל הקבועים בתוכנית יתאימו ל-13 סיביות (ראוRISC).
מרמז[עריכת קוד מקור | עריכה]
+-----------------+ | clear carry bit | +-----------------+
+-------------------+ | clear Accumulator | +-------------------+
אופן מעינה מרמז, הנקרא גם אופן מעינה משתמע, אינו מציין במפורש כתובת בפועל למקור או ליעד (ולפעמים לא מציין עבור שניהם).
המקור (אם בכלל) או כתובת היעד בפועל (ולפעמים שניהם) משתמעים מתוך קוד הפעולה.
מעינה מרמזת הייתה נפוצה למדי במחשבים ישנים (עד אמצע שנות ה-70). למחשבים כאלה היה בדרך כלל רק אוגר בודד שבו ניתן לבצע פעולות אריתמטיות - הצובר. מכונות צובר כאלה מתייחסות באופן מרומז לאותו צובר כמעט בכל הוראה. לדוגמה, את הפעולה < a := b + c; > ניתן לעשות באמצעות הרצף < load b; הוסף c; אחסן את a; > -- היעד (הצובר) מרומז בכל הוראת "טעינה" ו"הוספה"; המקור (הצובר) מרומז בכל הוראת "אחסן".
למחשבים מאוחרים יותר, היו בדרך כלל יותר מאוגר רב תכליתי יחיד או מיקום RAM יחיד שיכולים להיות המקור או היעד או שניהם עבור פעולות אריתמטיות - ולכן מחשבים מאוחרים יותר צריכים אופני מעינה אחרים כדי לציין את המקור והיעד של האריתמטיקה.
מתוך סט הפקודות של ה־x86, חלק מהפקודות משתמשות באוגרים מרומזים עבור אחד מהאופרנדים או התוצאות (כגון בכפל, חלוקה וספירת קפיצות מותנית).
למחשבים רבים (כגון x86 ו-AVR) יש אוגר אחד למטרות מיוחדות הנקרא מצביע המחסנית, אשר מוגדל או מופחת באופן מרומז בעת דחיפה או שליפה של נתונים מהמחסנית, והכתובת בפועל של המקור או היעד היא (במרומז) הכתובת המאוחסנת במצביע מחסנית.
למחשבים רבים של 32 סיביות (כגון 68000, ARM, או PowerPC) יש יותר מאוגר יחיד שיכול לשמש כמצביע מחסנית, ולכן משתמשים באופן המעינה "הגדלה אוטומטית של אוגר עקיף" כדי לציין באילו מהאוגרים יש להשתמש כאשר דוחפים או שולפים נתונים ממחסנית.
כמה ארכיטקטורות מחשבים נוכחיות (למשל IBM/390 ופנטיום) מכילות כמה הוראות עם אופרנדים מרומזים על מנת לשמור על תאימות לאחור עם מעבדים קודמים.
במחשבים רבים, הוראות שהופכות את סיבית מצב המשתמש/מערכת, סיבית אִפשור פסיקות וכו' מציינות באופן מרומז את האוגר המיוחד שבו נשמרות סיביות אלו.
כמה מעבדים תוכננו כאשר כל אופרנד תמיד מצוין באופן מרומז בכל הוראה שהיא -- מעבדי אפס אופרנדים.
אופני מעינה אחרים עבור קוד או נתונים[עריכת קוד מקור | עריכה]
מוחלט/ישיר[עריכת קוד מקור | עריכה]
+------+------+-----+ | לטעון | 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, בשילוב עם מונה התוכניות, מספקים את מצבי הפנייה המוחלטים והיחסי למחשב.
ראו גם[עריכת קוד מקור | עריכה]
קישורים חיצוניים[עריכת קוד מקור | עריכה]
הערות שוליים[עריכת קוד מקור | עריכה]
- ^ System Reference Manual - RCA 3301 REALCOM EDP (PDF). RCA. בספטמבר 1967. 94-16-000-1. נבדק ב-21 בדצמבר 2023.
{{cite book}}: (עזרה) - ^ 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.
- ^ 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. ..
- ^ Dr. Jon Squire. "Lecture 19, Pipelining Data Forwarding". CS411 Selected Lecture Notes.
- ^ "High Performance Computing, Notes of Class 11 (Sept. 15 and 20, 2000) - Pipelining". אורכב מ-המקור ב-2013-12-27. נבדק ב-2014-02-08.
- ^ John Paul Shen, Mikko H. Lipasti (2004). Modern Processor Design. McGraw-Hill Professional. ISBN 9780070570641.
- ^ 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.
- ^ 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
- ^ 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.
- ^ IBM System/360 Principles of Operation (PDF). IBM. בספטמבר 1968. p. 135. A22-6821-7. נבדק ב-12 ביולי 2019.
{{cite book}}: (עזרה) - ^ z/Architecture Principles of Operation (PDF). IBM. בספטמבר 2017. pp. 7–266. SA22-7832-11. נבדק ב-12 ביולי 2019.
{{cite book}}: (עזרה) - ^ Max Maxfield. "Building a 4-Bit Computer: Assembly Language and Assembler". Section "Addressing modes". 2019.
- ^ Kong, Shing; Patterson, David (1995). "Instruction set design". Slide 27.
- ^ Koopman, Philip (1989). "Architecture of the RTX 32P". Stack Computers.
[[קטגוריה:ארכיטקטורת מחשב]]