רבים חושבים שעם כפולי הליבות נגיע לעידן שבו המיחשוב המקבילי "יורד לעם" נוכל לשחק על מכונה עם עוצמה של שרת מרובה מעבדים - חלומו של כל ביצועיסט... אבל אז אתה מתעורר מהחלום ובדיוק באמצע הקורס בעיבוד מקבילי אתה מבין שמעבד מרובה ליבות זה לא עיבוד מקבילי... זה סה"כ יישום מעשי לקונספט של הייפרט'רדינג, פשוט במקום מעבד וורטואלי תהיה שם ליבה פיזית. "אבל... מה ההבדל ??" בהגדרה עיבוד מקבילי יכול לקרות רק כאשר יש מעבדים נפרדים עם זכרון (RAM) נפרד המסוגלים לתקשר אחד עם השני, או מעבדים עם זכרונות שיכולים לתקשר ... עדיין.. מה ההבדל ?
ההבדל הוא שבזמן שמעבד 0 (יש 2 מעבדים אז אחד הוא 0 והשני הוא 1) כותב/קורא לזכרון מעבד1 ממתין, התושבת לא מאפשרת גישה במקביל ובצדק... הם משתמשים בזכרון משותף ולא ניתן להפריד את הזכרון חלק אחד למעבד0 וחלק אחר הוא למעבד1.
אז מה קיבלנו ? שיפור קל במחיר גבוה, סיסמאות ומילים יפות במקום ביצועים...
בשונה דרך אגב מהשינוי ל64 ביט שבעבורו ניתן לקמפל בעזרת קומפיילר תומך גם תוכנות שתוכננו ל32 ביט וכך לנצל את הייתרונות שלו מבלי לשנות את הקוד, תכנות שיינצל את ייתרונות המעבד כפול הליבות יידרוש שינויים ותכנון מחדש של קוד ישן או כתיבה של קוד חדש במיוחד בשביל זה.
לסיכום: לדעתי אין מה להתלהב יותר מדיי מהמעבר לכפולי ליבות, אולי אם וכאשר יעברו למצב בו 2 המעבדים יוכלו לתקשר במקביל עם הזכרון אז זה ייקרא עיבוד מקבילי, עד אז לא התקדמנו יותר מדי...

ה Dual-Core זה לא "חיקוי של ריבוי מעבדים" - זה ריבוי מעבדים לכל דבר ועניין (SMP). ולא צריך לכתוב "תוכנות מיוחדות" בשביל זה. מערכת ההפעלה (או כך לפחות אמור להיות), יודעת לקחת את הפרוססים השונים שממתינים לביצוע במעבד (Waiting Queue), וברגע שהמעבד מסיים לטפל בפרוסס מסויים (אם בגלל שהפרוסס לא דורש יותר CPU ואם בגלל שה Scheduler של הקרנל מפסיק אותו), הקרנל שולח את הפרוסס הבא לטיפול במעבד. ברגע שיש שני מעבדים, או מעבד Dual Core, שני המעבדים יכולים לעבד מידע בו זמנית ואז ה Scheduler מעביר 2 פרוססים ממצב Waiting למצב Running - נכון שהם לא יכולים לגשת לאותו תא בזיכרון בו זמנית (במצב קריאה גם? לא יודע, לא חקרתי עד כדי כך) - אבל למה שהם ינסו לעשות את זה? הם מעבדים תוכנות שונות. אז אם מעבד אחד שלך עסוק מאוד בקאזה שמוריד 20 קבצים של 700 מגה - והמעבד השני שלך עסוק בלקודד סרט וידאו, המחשב שלך ימשיך לרוץ חלק, לעומת מחשב עם מעבד בודד שיקרטע בצורה כזאת שאתה תעזוב את המחשב...

נמאס לכם לזכור סיסמאות? לחצו כאן!

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

לגבי השאלה הטכנית לגבי קריאה: לא ידוע לי על "תקן" בנושא, וזה תלוי אך ורק
ביצרן המערכת.

לגבי ה-64ביט: אין שום צורך בקימפול מחדש אם מדברים על השיפור בביצועים
שהציגה AMD ב-AMD64 שלה. אם אנחנו מדברים על שיפור שמושג ע"י הידור
מחדש - הוא לא יהיה קיים עבור תוכנות 32ביט. (מלבד המקרה המיוחד שבו
משתמשים במשתני 64 ביט שלא קיימים במערכת, ולכן יש אמולציה כבדה
שלהם וכו')

לפעול מול הזכרון באופן עצמאי אחת מהשניה?

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

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

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

ששני המעבדים לא יכולים לכתוב ל-BUS בו"ז.
אבל אני מניח שה- cache מסדר את העניין בד"כ.

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

לא יכולה לפעול מול הזכרון באופן עצמאי אצל
כפולי הליבות של AMD?

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

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

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

לגבי מבחנים:
יש ב- ANANDTECH מיבחני ביצועים (ונידמה לי שגם ב- TOMSHARDWARE כבר יש אם כי באיחור).

1) http://www.anandtech.com/cpuchipset...doc.aspx?i=2388


2) http://www.anandtech.com/cpuchipset...doc.aspx?i=2389

כפי שניתן לראות ההנחה שלי היתה שברוב המקרים זה מסתדר מול ה- cache,
ואני שמח לראות שאתה מאשר את זה.

תודה על הקישורים,נחכה גם למבחנים על ה-AMD הכפולים

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

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

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

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

ת'רד ב' מכניס לאוגר מסויים את הערך 1, ואז מבצע XCHG עם ביט הגישה. כעת הוא בודק
את ערך האוגר: אם באוגר רשום 0, זה אומר שלפני ה-XCHG היה 0 בביט הגישה, ומותר
לגשת לאותה כתובת(ועכשיו כבר כתוב שם 1 בגלל ה-XCHG); אם רשום באוגר 1, זה אומר
שלפני ה-XCHG היה בביט הגישה 1 - ואסור לפעול עם הכתובת, אבל ביט הגישה לא השתנה,
היה 1 ונשאר 1. בעזרת XCHG הבדיקה האם בביט רשום 0, וכתיבת 1 לתוכו לא מתבצעות
בנפרד, ולא יכולה להתרחש פסיקה "באמצע הפקודה".

עד כאן הכל טוב - אבל מה יקרה כשיהיו לנו שני מעבדים ושני ת'רדים שיתבצעו בנפרד עליהם?
כאן הטריק של XCHG כבר לא פועל - כי שני המעבדים יכולים לבצע XCHG בו-זמנית.


איך פותרים את הבעיה הזו במערכת מרובת מעבדים?

בכ"א, כבר ביררתי את התשובה: משתמשים ב-prefix שנועל את הבאס למשך ביצוע
הפקודה, כך שרק אחד המעבדים יעשה XCHG בזמן מסויים(ה-prefix נקרא LOCK)

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

חשוב להבין את ההבדל בין היישום של אינטל ל AMD.

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

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

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

HT זה רק הכאילו לעומת הדבר האמיתי.

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

לגבי הטעויות - מיהרתי ולא היה לי זמן לערוך, מצטער.

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