איך מתאימים תוכנות למעבדים מרובי ליבות?

[מישהו שלא מצליח להיכנס]

שוב נתקלתי בדבר הזה -התאמה של תכנות למעבדים מרובי ליבות (בכתבה שעוסקת במה שנכתב בבלוג של אינטל על מעבדים עם עשרות/מאות/אלפי (זה לא קצת מוגזם? :s05:) ליבות)

"מתכנתים כיום עושים מאמץ מסויים להתאים את התכנות שלהם למעבדים כפולי ליבה"

איך עושים דבר כזה?

(חשבתי על אפשרות, אבל אני לא בטוח לגביה, ולכן אני שואל^^)

[00000]

מצטרף לשאלה

[genia]

אין לי שמץ איך עושים את זה

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

[Revertigo]

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

אבל זה פנימי בתוכנה, לגבי חלוקה לליבות ממש - הייתי מהמר שהמערכת הפעלה עושה את זה

[DOGMA]

using System.Threading;

public class MyUtility
{
  public void MyTask()
  {
    Thread.BeginThreadAffinity();

//your c0de goes her3

    Thread.EndThreadAffinity();
 }

[מישהו שלא מצליח להיכנס]

using System.Threading;

public class MyUtility
{
  public void MyTask()
  {
    Thread.BeginThreadAffinity();

//your c0de goes her3

    Thread.EndThreadAffinity();
 }

באיזו שפה זו? נראה כמ C/C++/Java/C# (פשוט מזה שאני מכיר C, C++ וקצת ג'אווה, ושמעתי שC# דיי דומה, ג'אווה אני מניח שלא...)

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

[matteo]

תשובה פשוטה

multithreading

ריבוי תהליכים

זה דבר שקיים המון זמן

השימוש בו לא יעיל במעבד בעל ליבה אחת

שימוש בכמה ט'ראדים שרוצים

אני מניח שאם אתה רוצה לתכנת קוד ל1000 ליבות אתה בעצם תיצור 1000 טר'אדים בו זמנית על מנת שהשימוש יהיה בכל הליבות

הבעיה :

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

מה שכן התוצאה יוצאת מאוד איכותית

[master whilee]

אין לי שמץ איך עושים את זה

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

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

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

אבל זה פנימי בתוכנה, לגבי חלוקה לליבות ממש - הייתי מהמר שהמערכת הפעלה עושה את זה

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

דוגמה גרועה:

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

אבל אם יש לך 10 ליבות במחשב, אתה יכול לחשב בכל ליבה את הסכום של 100 מספרים מתוך הסדרה, ואז לחבר את 10 התוצאות.

ככה אתה משתמש בכל עשר המעבדים, ומאיץ כמעט פי 10 את מהירות החישוב.

[oba3k]

נתחיל בתיקון קטן -

גם על מעבד אחד - תוכנה יכולה לרוץ יותר מהר אם יהיה לה יותר מת'רד אחד.

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

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

[Holy]

בדיוק היום העברתי על זה הרצאה

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

מיקרוסופט התחילו להכנס לתחום הזה ומציעים עכשיו הרחבה ל-Visual Studio 2008

http://msdn.microsoft.com/en-us/concurrency/default.aspx

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

רק לתקן כמה טעויות, תכנות מקבילי נכון הוא לא לפתוח 1000000 תראדים כדי לנצל את המעבד. ה-Over head שתשמו על contact switch ועל יצירת התראדים גדול פי כמה מהרווח שתקבלו בביצועים. ההרחבה החדשה של מיקרוסופט מאפשרת למקבל משימות כך שידעו לנצל את כל הליבות במחשב כך שנוצר "Thread" עבור כל ליבה (זה קצת יותר מורכב מזה אבל זה הרעיון בגדול).

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

הכלים שנותן ה-parallel extensions של Parallel.for ואחרים חזק יותר משימוש ב-Thread pool. החיסרון של ה-Thread pool שצריך ליצור אובייקט (Thread) עבור כל משימה קטנה וצריך לשלם הרבה על Contact switcing. ה-Parallel.for יוצר אובייקטים (מסוג ReplicableTask) כמספר הליבות ולא כמספר המשימות.

בקיצור זה מורכב מאד

[מישהו שלא מצליח להיכנס]

בדיוק היום העברתי על זה הרצאה

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

מיקרוסופט התחילו להכנס לתחום הזה ומציעים עכשיו הרחבה ל-Visual Studio 2008

http://msdn.microsoft.com/en-us/concurrency/default.aspx

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

רק לתקן כמה טעויות, תכנות מקבילי נכון הוא לא לפתוח 1000000 תראדים כדי לנצל את המעבד. ה-Over head שתשמו על contact switch ועל יצירת התראדים גדול פי כמה מהרווח שתקבלו בביצועים. ההרחבה החדשה של מיקרוסופט מאפשרת למקבל משימות כך שידעו לנצל את כל הליבות במחשב כך שנוצר "Thread" עבור כל ליבה (זה קצת יותר מורכב מזה אבל זה הרעיון בגדול).

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

הכלים שנותן ה-parallel extensions של Parallel.for ואחרים חזק יותר משימוש ב-Thread pool. החיסרון של ה-Thread pool שצריך ליצור אובייקט (Thread) עבור כל משימה קטנה וצריך לשלם הרבה על Contact switcing. ה-Parallel.for יוצר אובייקטים (מסוג ReplicableTask) כמספר הליבות ולא כמספר המשימות.

בקיצור זה מורכב מאד

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

[Holy]

כן ברמה מסויימת

[מישהו שלא מצליח להיכנס]

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

בפורום בנושא שפות תכנות שונות, החל מפסקל, ++C וכלה ב-Java, PHP ו-HTML על כל סוגיו

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

אבל שיהיה, בכל מקרה נראה לי שסיימנו עם זה, תודה על התשובות

(לעזאזל! המחשב כבר לפחות שעה מנסה לשלוח את ההודעה הזאת! זה הנסיון הרביעי לשלוח אותה)

[שניצל]

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

השם נועד (בין השאר) כדי להבדיל בינו לבין פורום "תוכנה".

אם יש עוד שאלות בנושא, נא לפנות בהודעה פרטית לאחד המנהלים.

[Zelig]

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

לאלה שעדיין לא מבינים מה הבעיה, יש מספר בעיות שקשורות בתכנות מקבילי:

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

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

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

ויש עוד ועוד בעיות...

למי שרוצה, הנה מספר מאמרים המרכזים עצות לתכנות מקבילי: http://herbsutter.wordpress.com/2008/06/27/effective-concurrency-choose-concurrency-friendly-data-structures/

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

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