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

איך שלא תסתכל על זה יותר קשה לחלק דינמית ל-4 חלקים מאשר ל-2 חלקים

איך תסתכל על זה ממש לא, קראת בכלל על איך החלוקה מתבצעת?

כמו שאמרתי

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

אתה תבזבז יותר משאבי מערכת מאשר על חלוקה דינמית זהה של 2 ליבות.

כמו שאמרתי

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

אתה תבזבז יותר משאבי מערכת מאשר על חלוקה דינמית זהה של 2 ליבות.

כמו שאמרתי תקרא על איך התהליך הזה מתבצע ותחזור אלי.

אתה מתכוון למידע הרשמי של אינטל?

משהו כמו זה?

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

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

אבל בניגוד לחנייה אם ליבה אחת תקבל עומס שווה לליבה השנייה החלוקה תהיה מחדש

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

ולכן בהתחלה על ליבה אחת יהיה יותר עומס והשנייה תהיה במצב מנוחה.

התוצאה תהיה זהה בשני המופעים

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

כמובן שכל זה לא נכון במקרה וברגע שמידע מהמטמון נמחק גם ה"בעלות" עליו נמחקת והוא הופך ל-Non Allocated

שוב פעם בפשטות התהליך מתבצע לפי FIFO, אין פה יח' שמנהלת את כל העסק, אלא פשוט אוסף של חוקים לפיהם חלוקת הקאש מתבצעת.

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

אין כאן עניין של בעלות על המידע, ה L2 הוא משותף לחלוטין וכל פיסת מידע זמינה לכל מעבד.

ה Pre Fetchers טוענים מידע ל L2 כל הזמן. אם רק מעבד מספר 1 מריץ קוד, ה Pre Fetchers ימלאו את ה L2 במידע ששייך לת'רדים ש CPU1 מריץ. ברגע ש CPU2 יתחיל להריץ קוד כלשהו, ה Pre Fetchers פשוט ידרסו מידע קיים ב L2 ויטענו לתוכו מידע ששייך ל Execution של CPU2.

זה קצת מופשט אני מניח, אבל עם CPU2 יעמוד יבזבז חצי ממחזורי השעון שלו במצב IDLE, ל Pre Fetchers תהיה הרבה פחות עבודה לטעון מידע של הת'רדים שלו ל L2, ובאופן אוטומטי את ה L2 ימלא יותר מידע שקשור לת'רדים של CPU1.

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

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

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

אבל אז מה, נדרס, So What?

אז אחרי כל זה, למה באמת אינטל לא תעשה כבר קש משותף אחד לכל הליבות?

האם זה יכול להיות בגלל יותר מדי שינויים שצריך לעשות בגלל זה? לא נראה לי בכלל!

החלוקה הדינמית הזאת של ה-L2 תהיה הרבה יותר קשה עם 4 ליבות במקום 2

אם זה באמת היה ככה, אז קש אישי לכל ליבה היה יותר טוב יותר מקש משותף לשני הליבות... וזה לא ככה.

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

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

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

??? העיצוב של אינטל בריבוי ליבות גרוע, כי אין להם משהו דומה לבקר כמו בשיטה של AMD,

שם הם משתמשים במעין בקר שאחראי על קצב העברת האינפורמציה בין הליבות, הינה מאמר שממחיש את העניין:

http://anandtech.com/printarticle.aspx?i=2397

זה היה נכון לריבוי ליבות הישן, לא למבוסס יונה.