מעבד 64 ביט אופטימלי יכול לגשת ל 2 בחזקת 64 בתים (byte - 8bit).

תחלק את זה ב-1024 כדי לקבל את זה בקילו-ביט ותחלק שוב פעם ב1024 כדי לקבל את זה במגה ביט

ועוד פעם ב 1024 כדי לקבל את זה בגיגה בייט וזה עדיין מספר אסטרונומי לחלוטים (17 מיליארד גיגה-בייט... ועודף)

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

דבר ראשון החישוב הוא 2 בחזקת 64 באקספוננט מינוס 9, ולא כמו שאתה אמרתה שצריך לחלק ב-1024, צריך לחלק ב-1000.

דבר שני זה, מה ה-2 בחישוב מיצג?

http://hwzone.co.il/community/index.php?topic=156368.10

http://www.tapuz.co.il/tapuzforum/main/Viewmsg.asp?forum=99&msgid=47080264

http://www.nrg.co.il/online/10/ART1/003/571.html

ההסברים לא בתפוז ולא במעריב טובים.

בעיקר הזו של תפוז שפשוט מטעה לחלוטין.

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

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

דבר ראשון החישוב הוא 2 בחזקת 64 באקספוננט מינוס שש, ולא כמו שאתה אמרתה שצריך לחלק ב-1024, צריך לחלק ב-1000.

דבר שני זה, מה ה-2 בחישוב מיצג?

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

המספר 2 הוא בגלל הבסיס הבינארי (בסיס 2 - שימוש במספרים 0 ו-1)

הכתובות בזכרון רשומות מ-0 והאלה.

מעבד 2 ביט (עובד עם מספרים של 2 ספרות בינאריות) למשל יכול לפנות לפנות ל 4 בתים בזכרון:

שכתובתם:

00

01

10

11

(0,1,2,3 בתרגום לבסיס 10 - הבסיס שאנחנו משתמשים בו ביום יום.)

זה בעצם קומבנציה של 2 בחזקת 2.

מעבד של שלוש ביט יכול לפנות לשמונה בתים בזכרון

שכתובתם:

000

001

010

011

100

101

110

111

0,1,2,3,4,5,6,7 - בבסיס 10.

כדי לקבל את מספר הכתובות הפעם העלו 2 בחזקת 3. וכך האלה.

מעבד 32 ביט יכול לפנות ל2 בחזקת 32 בתים בזכרון...

מרחב הכתובות שמעבד 32 ביט יכול לפנות איליו הוא:

מ-

0000,0000,0000,0000,0000,0000,0000,0000

ועד-

1111,1111,1111,1111,1111,1111,1111,1111

(הפסיקים הם בשבילי)

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

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

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

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

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

אני ינסה להסביר באופן יותר ברור.

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

לכן הקוד יותר "שמן" וגם דורש יותר רוחב פס גדול יותר לקריאה מהזכרון (יותר מקום ב RAM וגם בזכרון המטמון של המעבד - וזה משמעותי)

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

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

שבהידור תוכניות 32 ביט ל-64 ביט צפיפות התוכנה יורדת בכ-10% בממוצע (כמובן שיש פה הרבה מרחב בין תוכנה לתוכנה... מחקר של IBM על מגוון ישומים).

בכל מקרה אם כתבת תוכנה ב-64 ביט היא לא תפעל על מעבד 32 ביט.

אפשר כמובן לכתוב את התוכנה ב-32 ביט. ובמקרה שאתה צריך לעשות חישובי 64 ביט זה יעלה לך בביצועים.

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

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

הסיביות העליונות - ולכתוב אותם גם לזכרון... ולזכור שאתה משתמש בשני תאי זכרון כדי לשמור מספר 64 ביט.

למשל אם היית רוצה להוסיף שני מספרים בעלי 4 ספרות - אבל היית יכול לחשב רק מספרים בעלי 2 ספרות

היית למשל לוקח את המספר 1234 והמספר 6384 ומחשב אותו כך:

34

+

84

=

118

את ה - 1 בהתחלה היית צריך לשמור בתא אחר בזכרון ואז להוסיף אותו לחיבור שני המספרים העליונים

ולזכור את התוצאה 18

ואז שני המספרים העליונים:

1 (המספר שגררנו)

+

12

+

63

----

75

ואז קיבלנו את המספר

7518

כמו שאתה רואה - לחלק חישוב לשניים לוקח הרבה פעולות.

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

שאפשר לעשות איתם פעולות בx86 (הכפלו את כמות וגודל הרגיסטרים ב x86-64)

בקיצור איטי בצורה ניכרת.

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

הדבר היחיד שעולה לי מהראש זה הצפנה למשל... שם יש מפתחות של 64,128 ואף 256 ומעלה ביטים.

ופה בהחלט יש שיפור אדיר בין מעבד 64 ל-32 ביט.

ולזכור שאתה משתמש בשני תאי זכרון כדי לשמור מספר 64 ביט.

רגע... לא אמרנו שבייט אחד (התא הבסיסי של הזיכרון) הוא עשוי מ-8 ביטים?

וככה אם אני רוצה לשמור מספר של 64 ביט אז אני צריך 8 תאים?

וגם אפשר לעיל את העובדה, אם אתה לוקח את שתי מספרי 32 ביט אז אתה יכול לעשות חישוב של 64 ביט וככה לחסור במחזורי שעון, זה אפשרי?

אתה צודק... טעות שלי. (רואים זה לא כ"כ קשה להודות בטעות...)

התא הבסיסי בזכרון הוא לא בגודל 64 ביט

מה שנכון לומר הוא שהמשתנה הבסיסי הוא בגודל 64 ביט.

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

עדיין לכל byte בזכרון - שזה באמת 8bit - יש כתובות משלו.

אתה יכול לחשב שני מספרים 32 ביט ביחד

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

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

הפעולה שם חיבור מספר היא שוות ערך למחזור שעון בודד.

לכן אם תצטרך ל]עמייםאת פעולות ההעברה לרגיסטר על כל 2 מספרי 32 ביט שתרצה לחבר זה יהרוג את הביצועים.

אנחנו עוד לא עברנו ל-64 ביט, אז אתה רוצה שנעבור ל-128 ביט?

אני מאמין שהמעבר ל-128 ביט יתרחש איפה שהוא באיזור השנים 2022-2024....

רוב היתרון שיש ל-64 ביט מעל ל-32 ביט זה בעקבות התמיכה העצומה שיש לו בזכרון.

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

בטח ה-128 ביט יתמוך ב-36 טרה בייט....

בקיצור, אף אחד לבנתיים לא חושב לעבור ל-128 ביט, ואתה יכול להירגע.

אתה כמעט ולא צריך את זה בתכונות היום היום ...

ואני מאמין שיקח המון זמן עד שנגיע ל128bit

זה יקרה שננצל את כל הכמות זיכרון של 64 ביט כמו שהסביר http://hwzone.co.il/community/index.php?topic=187223.msg1624257#msg1624257

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