mpy.mpich2 - מקוון בענן

תָכְנִית:

שֵׁם

mpy - הודעה עוברת יוריק

תַקצִיר

mpirun -np mp_size mpy [ -j pfile1.i [ -j pfile2.i [ ... ]]] [ -אני file1.i [ -אני file2.i [
... ]]]
mpirun -np mp_size mpy -קבוצה file.i

תיאור

יוריק היא שפה מפורשת כמו Basic או Lisp, אבל הרבה יותר מהירה. לִרְאוֹת יוריק (1) ל
ללמוד עוד על זה.
Mpy הוא גרסה מקבילה של יוריק מבוסס על ממשק העברת הודעות (MPI). ה
תחביר מדויק להפעלת עבודה מקבילה תלוי בסביבת ה-MPI שלך. זה יכול להיות
הכרחי כדי להפעיל דמון מיוחד לפני שמתקשרים מירון או פקודה מקבילה.

הסברים
חבילת mpy ממשק את yorick לספריית התכנות המקבילות של MPI. MPI מייצג
ממשק העברת הודעות; הרעיון הוא לחבר מקרים מרובים של יוריק זה
לתקשר בינם לבין עצמם באמצעות הודעות. Mpy יכול לבצע פשוט, מקביל מאוד
משימות כתוכנות מפורשות טהורות, או שהיא יכולה להתחיל ולנווט מורכבות באופן שרירותי
חבילות שהן בחינם לשימוש בממשק ה-API הקומפילציה של MPI. ה-API המתפרש לא נועד
להיות מעטפת MPI; במקום זאת הוא מופשט למינימום.

זוהי גרסה 2 של mpy (שוחררה ב-2010); זה לא תואם לגרסה 1 של mpy
(שוחרר באמצע שנות התשעים), כי לגרסה 1990 היו פגמי עיצוב רבים שהפכו אותה מאוד
קשה לכתוב תוכניות ללא תנאי גזע, ואי אפשר להגדיל אותן למיליונים
של מעבדים. עם זאת, אתה יכול להפעיל את רוב תוכניות mpy גרסה 1 תחת גרסה 2 על ידי ביצוע
mp_include,"mpy1.i" לפני שאתה mp_include כל קובץ המגדיר משימה מקבילה mpy1 (כלומר
לפני כל קובץ המכיל קריאה ל-mp_task.)

נוֹהָג הערות
סביבת ה-MPI לא ממש מצוינת בתקן; סביבות קיימות הן
גס מאוד, ומעדיפים מאוד עבודות אצווה לא אינטראקטיביות. מספר התהליכים הוא
תוקן לפני תחילת MPI; לכל תהליך יש דרגה, מספר מ-0 עד אחד פחות מה-
מספר תהליכים. אתה משתמש בדרגה ככתובת לשליחת הודעות, ובתהליך
קבלת ההודעה יכולה לחקור כדי לראות אילו דרגות שלחו אליה הודעות, וכמובן
לקבל את ההודעות האלה.

בעיה מרכזית בכתיבת תוכנית להעברת הודעות היא טיפול באירועים או הודעות
מגיע בהזמנה לא מתוכננת. MPI מבטיח רק שרצף הודעות נשלח על ידי
דרגה א' עד דרגה ב' תגיע לפי הסדר שנשלח. אין ערובה לגבי הסדר של
הגעה של אותם הודעות ביחס להודעות שנשלחו ל-B מדרגה שלישית C. In
במיוחד, נניח ש-A שולח הודעה ל-B, ואז A שולח הודעה ל-C (או אפילו מחליף
מספר הודעות עם C) מה שגורם לכך ש-C שולח הודעה ל-B. ההודעה מ-C
עשוי להגיע ל-B לפני ההודעה מא'. תוכנית MPI שלא מאפשרת זאת
לאפשרות יש באג שנקרא "תנאי מירוץ". תנאי הגזע עשויים להיות עדינים ביותר,
במיוחד כאשר מספר התהליכים גדול.

הממשק הבסיסי של mpy מפורש מורכב משני משתנים:
mp_size = מספר תהליכים
mp_rank = דירוג תהליך זה וארבע פונקציות:
mp_send, to, msg; // שלח הודעה לדרג "ל"
msg = mp_recv(from); // קבל הודעה מדרגה "מאת"
ranks = mp_probe(block); // שאילתות שולחים של הודעות ממתינות
mp_exec, מחרוזת; // נתח והפעל מחרוזת בכל דרגה

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

חבילת mpy משנה את האופן שבו yorick מטפל בהנחיית מנתח #include, וב-include
ודורשים פונקציות. כלומר, אם פועלת משימה מקבילה (כלומר, פונקציה התחילה
על ידי mp_exec), כל אלה הופכים לפעולות קולקטיביות. כלומר, דרגה 0 קוראת את כולו
תוכן הקובץ, ושולח את התוכן לתהליכים האחרים כהודעת MPI (כמו
mp_exec של תוכן הקובץ). כל תהליך מלבד דרגה 0 פועל רק במהלך
משימות מקבילות; מחוץ למשימה מקבילה כאשר רק דרגה 0 פועלת (וכל שאר הדרגות
מחכים ל-mp_exec הבא), ההנחיה #include וה- include and require
פונקציות חוזרות לפעולה הטורית הרגילה שלהן, ומשפיעות רק על דרגה 0.

כאשר mpy מתחיל, זה במצב מקבילי, כך שכל הקבצים yorick כולל כאשר זה
התחלות (הקבצים ב-Y_SITE/i0) כלולים כפעולות קולקטיביות. בלי זה
תכונה, כל תהליך של יוריק ינסה לפתוח ולקרוא את קבצי ההפעלה הכוללים,
עומס יתר על מערכת הקבצים לפני ש-mpy מתחילה. העברת התוכן של אלה
קבצים כהודעות MPI היא הדרך היחידה להבטיח שיש מספיק רוחב פס לכל
תהליך לקריאת התוכן של קובץ בודד.

הקובץ האחרון שנכלל באתחול הוא הקובץ שצוין באפשרות -batch, או
הקובץ custom.i. כדי למנוע בעיות עם קוד ב-custom.i שאולי לא בטוח עבורו
ביצוע מקביל, mpy אינו מחפש custom.i, אלא עבור custommp.i במקום זאת. ה
הוראות בקובץ -batch או ב-custommp.i מבוצעות במצב סדרתי בדרגה 0
רק. באופן דומה, mpy עוקף את הפונקציה process_argv הרגילה, כך ש-i ואחר
אפשרויות שורת הפקודה מעובדות רק בדרגה 0 במצב סדרתי. הכוונה בכל אלה
מקרים זה לגרום ל--batch או custommp.i או -i לכלול קבצים לפעול רק בדרגה 0, כמו
אם היית מקליד אותם שם באופן אינטראקטיבי. אתה חופשי להתקשר ל-mp_exec מכל אחד מאלה
קבצים כדי להתחיל משימות מקבילות, אבל הקובץ עצמו הוא סדרתי.

אפשרות שורת פקודה נוספת מתווספת לסט הרגיל:
mpy -j somefile.i
כולל somefile.i במצב מקביל בכל הדרגות (שוב, -i other.i כולל רק other.i
בדרגה 0 במצב סדרתי). אם יש מספר אפשרויות -j, ההקבלה כוללת happen
לפי סדר שורת הפקודה. עם זאת, אם האפשרויות -j ו-i מעורבות, כל ה-j כולל קורה
לפני כל -i כולל.

כתופעת לוואי של המורכבות של פונקציות include ב-mpy, תכונת הטעינה האוטומטית היא
נָכֶה; אם הקוד שלך באמת מפעיל כולל על ידי קריאה לפונקציה שנטענת אוטומטית, mpy
יעצור עם שגיאה. עליך לטעון במפורש את כל הפונקציות הנחוצות עבור מקבילה
משימות המשתמשות דורשות קריאות לפונקציות עצמן בתוך משימה מקבילה.

הפונקציה mp_send יכולה לשלוח כל מערך יוריק מספרי (סוגי char, short, int, long,
צף, כפול או מורכב), או ערך מחרוזת סקלרית. תהליך שליחת ההודעה
דרך MPI שומר רק על מספר האלמנטים, כך mp_recv מייצר רק ערך סקלרי או
מערך 1D של ערכים, לא משנה מה הממדיות הועברה ל-mp_send.

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

הפונקציה mp_probe מחזירה את רשימת כל השולחים של הודעות בתור (או אפס אם
התור ריק). שִׂיחָה mp_probe(0) לחזור מיד, גם אם התור ריק.
שִׂיחָה mp_probe(1) לחסום אם התור ריק, חוזר רק כאשר לפחות הודעה אחת
זמין עבור mp_recv. שִׂיחָה mp_probe(2) לחסום עד שתגיע הודעה חדשה, גם אם
כמה הודעות זמינות כרגע.

הפונקציה mp_exec משתמשת ב-fanout לוגריתמי - דרגה 0 שולחת לתהליכי F, כל אחד
ששולח ל-F יותר, וכן הלאה, עד שלכל התהליכים יש את המסר. פעם אחת תהליך
משלים את כל פעולות השליחה שלו, הוא מנתח ומבצע את תוכן ההודעה.
אלגוריתם ה-fanout מגיע ל-N תהליכים ביומן עד לבסיס F של N שלבים. תהליכי F
דרגה 0 נשלחת אל היא הדרגות 1, 2, 3, ..., F. באופן כללי, התהליך עם דרגה r שולח ל
מדרגים r*F+1, r*F+2, ..., r*F+F (כאשר אלה הם פחות מ-N-1 עבור N תהליכים). הסט הזה
נקרא "צוות" של דרגה r. דרגים עם r>0 מקבלים את ההודעה מדרג (r-1)/F,
מה שנקרא "הבוס" של ר. הקריאה mp_exec פועלת יחד עם תור mp_recv;
במילים אחרות, הודעות מדרג אחר מלבד הבוס במהלך התנפצות mp_exec יהיו
בתור לאחזור מאוחר יותר על ידי mp_recv. (ללא תכונה זו, כל משימה מקבילה אשר
אם נעשה שימוש בדפוס הודעה שונה מ-fanout לוגריתמי יהיה רגיש לגזע
תנאים.)

ה-fanout הלוגריתמי והמקבילה הפנימית שלו כל כך שימושיים עד ש-mpy מספק זוג
של פונקציות ברמה גבוהה יותר המשתמשות באותו דפוס fanout כמו mp_exec:
mp_handout, msg;
total = mp_handin(value);
כדי להשתמש ב-mp_handout, דרגה 0 מחשבת הודעה, ואז כל הדרגות מתקשרות ל-mp_handout, אשר שולחת הודעה
(פלט בכל הדרגות מלבד 0) בכל מקום באותו fanout כמו mp_exec. להשתמש
mp_handin, כל תהליך מחשב ערך, ואז קורא ל-mp_handin, שמחזיר את הסכום של
הערך שלהם וכל הצוות שלהם, כך שבדרגה 0 mp_handin מחזירה את סכום ה-
ערכים מכל תהליך.

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

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

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

לבסוף, הערה לגבי שחזור שגיאות. במקרה של שגיאה במהלך משימה מקבילה,
mpy מנסה לצאת בחן מה-mp_exec, כך שכאשר הדרגה 0 חוזרת, כל שאר הדרגות
ידועים כבלתי פעילים, מוכנים ל-mp_exec הבא. הליך זה יישאר לנצח אם בכלל
אחד התהליכים נמצא בלולאה אינסופית, או במצב שבו הוא לעולם לא יהיה
התקשר ל-mp_send, mp_recv או mp_probe, מכיוון ש-MPI אינו מספק שום אמצעי לשלוח אות
מפריע לכל התהליכים. (זו אחת הדרכים שבהן סביבת MPI
"גולמי".) תהליך דרגה 0 נשאר עם הדרגה של התהליך הראשון שדיווח על א
תקלה, בתוספת ספירה של מספר התהליכים שנפגעו מסיבה שאינה קיימת
שלח הודעה שדרגה אחרת טעתה. תהליך התקלה הראשון יכול להיכנס ל-dbug
מצב באמצעות mp_connect; השתמש ב-mp_disconnect או dbexit כדי לרדת חזרה למצב טורי בדרגה 0.

אפשרויות
-j file.i כולל את קובץ המקור של Yorick file.i כמו mpy מתחיל במצב מקבילי
בכל הדרגות. זה שווה ערך לפונקציה mp_include אחרי mpy
התחיל.

-i file.i כולל את קובץ המקור של Yorick file.i כאשר mpy מתחיל, במצב טורי.
זה שווה ערך להנחיה #include לאחר הפעלת mpy.

-קבוצה file.i כולל את קובץ המקור של Yorick file.i כאשר mpy מתחיל, במצב טורי.
קובץ ההתאמה האישית שלך custommp.i, אם קיים, הוא לֹא לקרוא, ו-mpy הוא
ממוקם במצב אצווה. השתמש בפקודת העזרה בפונקציית האצווה
(עזרה, אצווה) למידע נוסף על מצב אצווה. במצב אצווה, הכל
שגיאות הן קטלניות; בדרך כלל, mpy תעצור את הביצוע ותמתין לעוד
קלט לאחר שגיאה.

השתמש ב-mpy.mpich2 באינטרנט באמצעות שירותי onworks.net