כיום רוב התוכנות משתמשות בליבה אחת

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

אז איך נוכל להריץ שתי תוכנות בו זמנית ?

אולי עדיף שלא יתכנתו תוכנות שמשתמשות בשתי הליבות ?

תודה לעונים יהודה.

כבר עושים את זה...

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

נכון מאד מחזק.

^^

את..?

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

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

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

אם תריץ 2 תוכנות שהן Multithreaded וטוחנות את המעבד על כפול ליבה, הם פשוט יתנהגו כ-Single threaded

יהודה,

הענין הוא כזה. כל ישום/תוכנה יכול להיות בנוי מתהליך (process) אחד או יותר. כל תהליך הוא רכיב תוכנה עצמאי פחות או יותר שמתחיל בנקודה מסוימת ואמור לתת איזשהו תוצר.

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

על הרצת התהליכים אחראית מערכת ההפעלה שצריכה לנהל את המשאבים ובכלל זה איזה מעבד/ליבה יריץ איזה תהליך ומתי.

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

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

כאשר יש יותר מליבה/מעבד אחד וזה כרגע לא משנה אם 2 או יותר, מערכת ההפעלה יכולה לחלק את התהליכים בין כל הליבות. כלומר באופן פשטני לצורך ההסבר התהליך הראשון יעבוד על הליבה הראשונה והשני על השניה וכך הלאה. זה מביא באופן תיאורטי להקלה מידית של 50% על כל ליבה. מערכת ההפעלה תשאף לאזן את העומס בין שתי הליבות כך שכל תהליך חדש יופנה לליבה הפחות עמוסה וכך ישמר האיזון. אם נניח שהעומס על המעבד במצב מנוחה הוא 5% על כל ליבה וכעת מעונינים להריץ תוכנת קידוד לדוגמה אבל עם תהליך יחיד. התוכנה תרוץ על הליבה הראשונה ותעלה אותה ל 90%. הליבה השניה לא יכולה לעזור כרגע כי יש רק תהליך בודד ולכן תמשיך לעבוד בעומס של 5%. וכעת רוצים להריץ תוכנה נוספת נאמר משחק - שוב בעל תהליך יחיד. המשחק ירוץ באופן טבעי על הליבה הפחות עמוסה ויעלה את הניצולת שלה בכמה שיעלה בעוד הקידוד הכבד עובד על הליבה האחרת ולא מפריע לו.

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

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

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

תהליך (Process) ו-Thread זה ממש לא אותו דבר

תהליך בודד יכול להכיל כמה Threads

כן, זה תלוי מאיזה עולם מושגים באים.

בכל מקרה אפשר מבחינתי להחליף process ב thread.

העיקר שהרעיון הכללי עבר.

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

אני ממשיל תוכנה לגדר עמודים.

כמו הגדר הזו :

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

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

אתה יכול לקחת פועל אחד, שצובע 10 עמודים בשעה, כלומר 6 דקות לעמוד. את הפועל צריך לתדרך במשך דקה אחת, אחר-כך הוא יצבע את 10 העמודים. סה"כ ייקח לו 1 שעה ו-1 דקה לסיים את העבודה.

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

אם תיקח 10 פועלים, שכל אחד יצבע עמוד אחד, תצטרך לתדרך אותם במשך 10 דקות, ועוד 6 דקות שכל אחד יצבע עמוד אחד, סה"כ ביצעת את העבודה ב-16 דקות. ממש מהר (אבל לא פי 10 יותר מהר מהמקרה הראשון - למה?).

מה יקרה אם תיקח 20 פועלים ?

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

התוכנה שהיא צביעת גדר, מחולקת ל-10 תהליכים, כל תהליך הוא צביעת עמוד אחד. הליבות הן הפועלים. השאלה היא כמה פועלים יש לך שפנויים לעבודה ?

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

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

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

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

פשש הסבר תותח הבאת לו אחי

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

והנה הסבר נחמד על processes, threads ו handles לפני שאני אשכח:

http://www.informit.com/articles/article.asp?p=362660&seqNum=1&rl=1

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

הסבר נחמד