תגובות | עיבוד מקבלי

Ofir Levy

חובשי יגבר

לפני 3 חודשים

חשמל ומחשבים
עיבוד מקבלי

0

Ofir Levy

חובשי יא מלך אוהב אותך

לפני 4 חודשים

חשמל ומחשבים
עיבוד מקבלי

0

Omer Pilosof

זה לא המסלול הכי קצר של שני הצמתים הכי מרוחקים

לפני שנה

חשמל ומחשבים
עיבוד מקבלי

0

Elad Hubashi

היא שייכת ל HTC וזה שאלה חרא שלו

לפני שנה

חשמל ומחשבים
עיבוד מקבלי

0

Elad Hubashi

למה הדבר הזה נקרא Flase Share?

לפני שנה

חשמל ומחשבים
עיבוד מקבלי

0

Elad Hubashi

צריך שהשאלה תיהיה ברורה יותר.. "איך אפשר למקבל אותה עם Cilk?"

לפני שנה

חשמל ומחשבים
עיבוד מקבלי

0

אייל יקיר

לא ספריה מקבילית אלה ספריה רגילה !

לפני שנה

חשמל ומחשבים
עיבוד מקבלי

0

אייל יקיר

כמה זמן לוקח להוריד את המידע לפס הנתונים cost = latency + n/bw

לפני שנה

חשמל ומחשבים
עיבוד מקבלי

0

אייל יקיר

א. פקודה ראשונה למעלה – Bcast ב. פקודה שנייה מלמעלה – Scatter ג. פקודה שלישית למעלה – Gather ד. פקודה רביעית למעלה – AllGather ה. פקודה ראשונה מלמטה – AlltoAll )מבצע transpose

לפני שנה

חשמל ומחשבים
עיבוד מקבלי

0

אייל יקיר

תשובה היא 11 7 1.57

לפני שנה

חשמל ומחשבים
עיבוד מקבלי

0

אייל יקיר

3.66 חוק אמדהל – תכנית סיריאלית א' רצה במשך 8 שניות ותכנית סיריאלית ב' רצה 6 שניות. החלק הסיריאלי של א' )שאינו ניתן למקבול( הוא 10% והחלק הסריאלי של ב' הוא 5% . את א' ממקבלים עם 6 תהליכים וב' ממקבלים עם 8 תהליכים י. זמן ריצה הממוקבלת של א' הוא: תשובה: ??=?∙??+(1−?)∙???=0.1∙8+0.9∙86=2??? יא. גורם ההאצה של ב' הוא : תשובה: ???????=????=??(?−1)+1=80.05(8−1)+1=5.926 יב . חשב את היחס בין גורמי ההאצה של א' לב' בגבול שמספר המעבדים שואף לאינסוף תשובה: אנחנו יודעים שעבור מספר מעבדים ששואף לאינסוף, גורם ההאצה הוא 1? , לכן: ??(?→∞)??(?→∞)=????=0.050.1=0.5 3.67 3.67 N מחשבים, כמה צעדי זמן נדרשים בכדי

לפני שנה

חשמל ומחשבים
עיבוד מקבלי

0

אייל יקיר

1 פי חלקי 2 2 – ליצור עץ שמן, להוסיף עוד קווים בין השורש לילדים:

לפני שנה

חשמל ומחשבים
עיבוד מקבלי

0

אייל יקיר

תשובה היא 2np / 3n+3 2/3

לפני שנה

חשמל ומחשבים
עיבוד מקבלי

0

אייל יקיר

SPMD – Single Program, Multiple Data תוכנית אחת (אוסף כמה פקודות), כל מעבד מבצע קטע קוד אחר, כמה מקורות נתונים. בכל רגע נתון, כל אחד מהמעבדים יכול להיות בחלק אחר של הקוד של התוכנית

לפני שנה

חשמל ומחשבים
עיבוד מקבלי

0

אייל יקיר

Scatter – 1 gather – 2 bcast – 3 allgather – 4 reduce – 5 alltoall – 6 Scan – 7

לפני שנה

חשמל ומחשבים
עיבוד מקבלי

0

אייל יקיר

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

לפני שנה

חשמל ומחשבים
עיבוד מקבלי

0

אייל יקיר

3.68 חוק אמדהל. א' רץ במשך 10000 שניות על מעבד יחיד ו - 25 שניות על מערכת מקבילית עם 1000 מעבדים. ב' רץ 1000 שניות על מעבד יחיד ו- 5 שניות על מערכת עם 1000 מעבדים א. גורם ההאצה בשביל א' – תשובה: ????????=????=1000025=400 ב. גורם האצה בשביל ב' – תשובה: ????????=????=10005=200 ג. יעילות המיקבול בשביל א' הוא: תשובה: ??=?????=100001000∙25=0.4 ד. יעילות המיקבול בשביל ב' הוא: תשובה: ??=?????=10001000∙5=0.2 ה. החלק היחסי הסיריאלי של א' הוא: תשובה: ???????=??(?−1)+1→?(?−1)+1=???→?(?−1)=???−1 →?=???(?−1)−1?−1 ??=1000400(1000−1)−11000−1=0.0015 ו. החלק היחסי הסיריאלי של ב' הוא: תשובה: ??=1000200(1000−1)−11000−1=0.004 ז. מספר המעבדים ישאף לאינסוף אז גורם ההאצה של א' : תשובה: ???=1??=666.67 ח. מספר המעבדים ישאף לאינסוף אז גורם ההאצה של ב' : תשובה: ???=1??=250 ט. העבודה / עלות ) word/cost ( בשביל א' הוא : תשובה: ?=?∙??=1000∙25=25000 י. התקורה ) overhead ( עבור א' : תשובה: ??ℎ=1?−1=10.4−1=1.5

לפני שנה

חשמל ומחשבים
עיבוד מקבלי

0

אייל יקיר

טכניקה זו משפרת את ה-scheduling במובן של clock cycles. זוהי טכניקה שפורשת קוד של כמה איטרציות כדי שיוכלו לרוץ בו-זמנית. כמות האיטרציות שנפרשת נקבעת על ידי factor unroll loop. היתרון הוא מקביליות של פקודות והחסרון הוא bloat code, פוגע ביעילות של ה- cache instruction כי כעת יש יותר פקודות מכונה בתוכנית

לפני שנה

חשמל ומחשבים
עיבוד מקבלי

0

אייל יקיר

4 צעדים, הנוסחא זה מספר המימדים (כאן יש 4 מימדים) d d p=2^d

לפני שנה

חשמל ומחשבים
עיבוד מקבלי

0

אייל יקיר

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

לפני שנה

חשמל ומחשבים
עיבוד מקבלי

0

אייל יקיר

מה מסומן בירוק – מספר המשאבים שקונדור יכול להשתמש בהם מה מסומן בכחול – מספר משאבים שלא בשימוש מה מסומן באדום – מספר משאבים שבשימוש של המשתמש

לפני שנה

חשמל ומחשבים
עיבוד מקבלי

0

אייל יקיר

להוסיף cilk_spawn על השורה של האיקס ו cilk_sync אחרי השורה של הY.

לפני שנה

חשמל ומחשבים
עיבוד מקבלי

0

אייל יקיר

התשובה היא 1.01 18.85 1.2 37.68

לפני שנה

חשמל ומחשבים
עיבוד מקבלי

0

אייל יקיר

תשובה: Xeon Phi , ראינו בכיתה שיש לו יכולת לבצע וקטוריזציה פנימית עם 512 ביט – 8 מספרים בדיוק כפו ל

לפני שנה

חשמל ומחשבים
עיבוד מקבלי

0

אייל יקיר

תקשורת שדורשת הסכמה בין 2 צדדי ההתקשרות. מוגדרות בדרך כלל להיות תקשורת חוסמת

לפני שנה

חשמל ומחשבים
עיבוד מקבלי

0

אייל יקיר

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

לפני שנה

חשמל ומחשבים
עיבוד מקבלי

0

אייל יקיר

קובץ שמכיל את שמות המכשירים עליהם נריץ את התוכנית, אם לא מציינים אותו התוכנית תרוץ במחשב הלוקלי

לפני שנה

חשמל ומחשבים
עיבוד מקבלי

0

אייל יקיר

תשובה היא 1/6 9 2

לפני שנה

חשמל ומחשבים
עיבוד מקבלי

0

אייל יקיר

תשובה יא 80 מיקרו

לפני שנה

חשמל ומחשבים
עיבוד מקבלי

0

אייל יקיר

מספר הקשרים (לינקים) שצריך לחתוך כדי לחלק את המערכת לשני חלקים שווים

לפני שנה

חשמל ומחשבים
עיבוד מקבלי

0

אייל יקיר

התשובה היא 9.17

לפני שנה

חשמל ומחשבים
עיבוד מקבלי

0

אייל יקיר

מקבל משתנה rank ואת Communicator( Comm) ומכניס למשתנה rank את מספר התהליכים שמשתתפים בחישוב. משתנה Communicator מייצג קבוצה של תהליכים והאופי בו הם מחוברים. MPI_Bcast(buf,count,datatype,root,comm) 3.13.2 שולח הודעה אחידה מהתהליך הראשי לכל שאר התהליכים בקבוצה (כולל עצמו). הודעה אחידה נמצאת בקלט buf, מועבר ממשתנה root אל שאר המעבדים ב-Comm. סוג המשתנה ששולחים או מקבלים הוא מסוג datatype וכמות המידע היא במשתנה count MPI_IRecv(buf,count,datatype,source,tag,comm,request) פקודת לא חוסמת של קבלה של הודעה. מזהה אזור בזיכרון שישמש כבאפר, התהליך ממשיך מיד מבלי לחכות שההודעה תתקבל ותועתק ל-Count .buf – כמות המידע, datatype סוג המידע שמתקבל, source – המקור ממנו מקבלים את המידע, id – tag להודעה, משמש כדי להבדיל בין הודעות שונות שנשלחות, request – מיועד לפעולות wait/test. MPI_Allgather(sendbuf,sendcount,sendtype,recvbuf,recvcount,recvtype,comm) פקודת העברת נתונים, אוספת תוצאות מכל המעבדים ואת התוצאה שולחת לכל המעבדים בקבוצה. Sendbuf – הבאפר של המעבד הראשי. Sendcount – כמות המידע. Sendtype – סוג הטיפוס של המידע שנשלח. Recvbuf – הבאפר של המקבלים. Recvcount - כמות המידע של המקבלים. Recvtype – סוג טיפוס של המידע למקבלים. Comm – מקשר MPI_Reduce(sendbuf,recvbuf,count,datatype,op,root,comm) פקודת חישוב קולקטיבית, אוספת ערכים מכל המעבדים למעבד "ראשי" שמוגדר בroot בתוספת פקודה שמבצעים על הערכים שנאספו (כמו חיבור, חיסור, פעולות לוגיות וכו') Sendbuf – הבאפר של השולח, recvbuf – באפר המקבל, count – מספר הערכים, datatype – סוג הטיפוס של המידע, opcode – op, סוג הפקודה, root – המקור, מי שאוסף את המידע, comm – מקשר MPI_Scatter(sendbuf, sendcnt, sendtype, recvbuf, recvcnt, recvtype, root, comm) פקודה השולחת הודעות נבדלות אחת מהשנייה ממקור מסוים לכל שאר התהליכים בקבוצה, מבצעת סוג של פיצול המידע לשאר המעבדים, MPI_AlltoAll(sendbuf, sendcnt, sendtype, recvbuf, recvcnt, recvtype, comm) כל תהליך בקבוצה מבצע שליחה של נתונים שונים לתהליכים שונים. הפקודה מבצעת transpose על המטריצה שמורכבת מהווקטורים שבתוך כלל התהליכים MPI_Init(&argc,&argv) מאתחלת את סביבת עבודת ה-MPI, חייבת להיות בכל תוכנית MPI בהתחלה לפני ביצוע פונקציית MPI אחרת כלשהי, מופיעה פעם אחת. Argc – פוינטר למספר הארגומנטים, argv – פוינטר לווקטור הארגומנט

לפני שנה

חשמל ומחשבים
עיבוד מקבלי

0

אייל יקיר

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

לפני שנה

חשמל ומחשבים
עיבוד מקבלי

0

אייל יקיר

3.74 שאלה על GFLOPS למדנו בכיתה על מדד להערכת ביצועי מערכת מחשב. מדד זה סופר את כמות הפעולות הנומריות המבוצעות בשנייה אחת. לדוגמה 10GFLOPS פירושו 10 מיליארד פעולות נמוריות בנקודה צפה בשנייה ?????=???????? ????? ?????????? ??? ?????? הסבירו את הבעייתיות ביחידת מדידה זו אשר לא תמיד משקפת את כוח החישוב : תשובה: המדידה מתייחסת רק למעבד אבל צריך לקחת בחשבון גם את זמני התקשורת איזה כלל )מודל( למדנו בכיתה שתומך במסקנה זו? תשובה: חוק אמדהל )או roofline model ) תנו דוגמה לסוג של חישוב אשר משקף בקירוב טוב את המדד של יחידות ה- GFLOPS כביטוי לעוצמת החישוב של המערכת: תשובה: כפל מטריצות צפופו ת תנו דוגמה לסוג של חישוב אשר אינו משקף בקירוב טוב את המדד של יחידות ה- GFLOPS כביטוי לעוצמת החישוב של המערכת : תשובה: stream

לפני שנה

חשמל ומחשבים
עיבוד מקבלי

0

אייל יקיר

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

לפני שנה

חשמל ומחשבים
עיבוד מקבלי

1

אייל יקיר

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

לפני שנה

חשמל ומחשבים
עיבוד מקבלי

0

אייל יקיר

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

לפני שנה

חשמל ומחשבים
עיבוד מקבלי

0

אייל יקיר

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

לפני שנה

חשמל ומחשבים
עיבוד מקבלי

0

אייל יקיר

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

לפני שנה

חשמל ומחשבים
עיבוד מקבלי

0

אייל יקיר

single instrucation multiple data . multiple instrucation multiple data. multiple instrucation single data. single instrucation single data.

לפני שנה

חשמל ומחשבים
עיבוד מקבלי

0

אייל יקיר

הקוד תקין אבל לא אופטימלי, יש false sharing. כל thread מנסה לעדכן ערכים שונים של sum_local אבל הערכים האלו נמצאו באותו בלוק .atomicבמקום ב reductionכדי לתקן אפשר להשתמש ב .cache .Reduction(+:sum)

לפני שנה

חשמל ומחשבים
עיבוד מקבלי

0

אייל יקיר

כן, כל מעבד ידפיס את הrank שלו וידפיס שה-root שלו הוא 3, מפני שכל המעבדים נכנסים ללולאת while ומבצעים bcast 4 פעמים של root כלומר root יקודם ל-3 (מתחיל ממינוס 1)

לפני שנה

חשמל ומחשבים
עיבוד מקבלי

0

אייל יקיר

כל מעבד ידפיס הודעת hello world from #rank כאשר rank יהיה הrank בהתאם למעבד שמדפיס. היא מבצעת זאת בכך שמעבד 0 שולח את ההודעה (יש בעיה הטיפוס הוא לא int אלא אמור להיות MPI_CHAR, לא יודע אם זה בעיה בשחזור של הקוד). אז מעבד 0 שולח את ההודעה לכל המעבדים האחרים שיש בקומינקטור בעזרת לולאת פור. ואז שאר המעבדים יכנסו לפקודת הrecv ויקבלו את ההודעה. גודל הבאפר גדול מההודעה עצמה לכן זה עדיין יעבוד אבל יש פה בזבוז זיכרון. הtag בשניהם זהה (שליחה וקבלה) לכן אין פה בעיה. איך ניתן לפשט? – לבצע פקודת bcast ממעבד 0 שישלח את ההודעה לכולם במקום להשתמש בsend, recv.

לפני שנה

חשמל ומחשבים
עיבוד מקבלי

0

אייל יקיר

כן הקוד תקין, (נניח שיש שני תהליכונים) נשים לב עבור העדכון של e יש לנו שני תהליכונים שרצים עליו, אז תהליכון ראשון רץ על עדכון c והשני על עדכון d. יש לנו nowait אז נגיד השני סיים לפני הראשון אז הוא עושה את e ואין לו את כל c עדיין אז זה לא נורא כי אחרי שהתהליך הראשון יסיים את c הוא יעשה את e (כשיש לנו את d) ואז יעדכן כמו שצריך לערכים הנכונים. ניתן להאיץ את הקוד מפני שהריצות לא תלויות אז אפשר לחלק כל לולאה "עד N" מעבדים. אפשר להוסיף barrier בסוף הsections כדי שהעדכון של e יתבצע על ידי תהליך יחיד

לפני שנה

חשמל ומחשבים
עיבוד מקבלי

0

אייל יקיר

א. בתנאי שמריצים 4 מעבדים, התוכנית תשלח כל וקטור שורה במטריצה למעבד באינדקס המתאים, כלומר את השורה 0 למעבד 0, שורה 1 למעבד 1, שורה 2 למעבד, שורה למעבד 3 ב. לא, כפי שראינו הSCATTER מחלק בצורה עקבית, ההדפסה אולי תהיה בסדר לא עקבי אבל כל מעבד מקבל לפי הסדר של המטריצה, והפלט יהיה כפי שרשום למעלה.

לפני שנה

חשמל ומחשבים
עיבוד מקבלי

0

אייל יקיר

התוכנית מבצעת transpose למטריצה A ושומרת את השחלוף באותה מטריצה A. התוכנית תקינה כי אין 2 תהליכונים שכותבים לאותו מקום. Temp מאותחל בתוך הלולאה המקבילית לכן הוא הוא נוצר בכל מעבד בנפרד כלומר הוא משתנה פרטי, וj הוא משתנה פרטי כברירת מחדל כמשתנה איטרציה, לכן אין בעיה בתוכנית. ב- race condition הכוונה למצב בו תוצאת התוכנית תלויה בסדר בו פעלו ה-threads. נשים לב שכאן לא משנה הסדר שבהם יפעלו כי כל threads יבצע שחלוף לאיבר לפי האינדקס הפרטי שלו ואין חשיבות לסדר, כל תהליכון יהיה במקום אחר בזיכרון

לפני שנה

חשמל ומחשבים
עיבוד מקבלי

0

אייל יקיר

הקוד תקין, הקוד מבצע פעולת transpose על מטריצה A ושומר תוצאה במטריצה B i מבצע חילוק של k ב-N, מכיוון ש-i הוא int אז התוצאה תחזיר את המנה של החלוקה (כלומר 0 עבור k מ-1 עד N, 1 עבור k מ-N עד 2N, 2 עבור 2N עד 3N וכו'), כלומר i רץ על השורה, j מבצע מודולו של החלוקה ובעצם לוקח את השארית ויהווה את העמודה שרצים עליה. i,j הם משתנים פרטיים עבור כל thread, שהם האינדקסים של המטריצות. וככה מבצעים את הtranspose על A ושומרים את התוצאה במטריצה B ככה שכל thread יבצע את החישוב לפי האינדקס הפרטי שלו.

לפני שנה

חשמל ומחשבים
עיבוד מקבלי

0

אייל יקיר

הקוד לא תקין מפני שהמשתנה j הוא לא private ואז לכל התהליכונים בפור שרץ עם i יהיה את אותו j שישתנה לכולם מתהליכונים אחרים אבל, אם j הוגדר בתוך הfor אז הוא פרייבט בברית מחדל ואז אין בעיה, צריך להתייחס איך שרוצים רק לכתוב (אפשר לכתוב את שני האפשרויות כדי שיבין שמבינים מה קורה) מטרת הקוד היא לבצע transpose על מטריצה A ולשמור את התוצאה במטריצה B.

לפני שנה

חשמל ומחשבים
עיבוד מקבלי

0

אייל יקיר

סוג של מכפלה פנימית (בלי השורש) בין ווקטור x לווקטור y. התוצאה היא סקלר. i משתנה פרטי עבור כל thread. המשתנים n,x,y משתנים משותפים לכולם ז"א כל הthreads יחזיקו באותו משתנה ורק משתנה i יהיה פרטי עבור כל אחד (כדי למנוע התנגשויות כזו או אחרת). נריץ בלולאת for עם reduction את המכפלה כאשר כל thread יבצע מכפלה עם ה-i הפרטי שלו ובעזרת reduction מבצעים סכום של כל הפעולות שהthreads ביצעו למשתנה יחיד עבור

לפני שנה

חשמל ומחשבים
עיבוד מקבלי

0

אייל יקיר

קודם כל tag בפקודות Send/Recv משמשות כדי להבדיל בין הודעות שונות שנשלחות, אם לא נגדיר tag אז recv יקבל כל send שישלח לאותו תהליך. בקוד הנ"ל, נותנים מספר רנדומלי לtag לכן ה-recv לא יקבל את מה שמעבד 0 ישלח כי יהיה לו tag שונה מאשר ה-tag שבפקודת הsend של מעבד 0 (אנחנו רוצים שיהיה אותו tag) ולכן ההודעה לא תגיע ואז מפני שrecv היא פקודה חוסמת התוכנית תתקע. דרך לתקן – לתת לשני הפקודות את אותו tag, למשל להגדיר: 3 = msgtag

לפני שנה

חשמל ומחשבים
עיבוד מקבלי

0