orterun - מקוון בענן

תָכְנִית:

שֵׁם

orterun, mpirun, mpiexec - ביצוע עבודות סדרתיות ומקבילות ב-Open MPI. אושרון, שממרון
- ביצוע עבודות סדרתיות ומקבילות ב- Open SHMEM.

הערה: מפירון, mpiexec, ו orterun כולן מילים נרדפות זו לזו אושרון,
שממרון במקרה שבו מותקן Open SHMEM. שימוש בכל אחד מהשמות ייצור אותו דבר
התנהגות.

תַקצִיר

מודל ריבוי נתונים של תהליך יחיד (SPMD):

מפירון [ אפשרויות ] [ ]

מודל מספר רב של הוראות (MIMD):

מפירון [אפשרויות_גלובליות]
[local_options1] [ ] :
[local_options2] [ ] :
... :
[ local_optionsN ] [ ]

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

% /usr/local/bin/mpirun ...

שווה

% mpirun --תחילית / usr / local

מָהִיר סיכום

אם אתה פשוט מחפש כיצד להפעיל יישום MPI, סביר להניח שתרצה להשתמש ב-a
שורת הפקודה של הטופס הבא:

% mpirun [ -np X ] [ --hostfile ]

זה יפעיל X עותקים של בסביבת זמן הריצה הנוכחית שלך (אם פועל תחת
מנהל משאבים נתמך, Open MPI's מפירון בדרך כלל ישתמש אוטומטית ב-
מתנע תהליכי מנהל משאבים מקביל, בניגוד למשל, רש or ssh,
הדורשים שימוש בקובץ מארח, או שיהיו כברירת מחדל להריץ את כל העותקים של X ב-
localhost), תזמון (כברירת מחדל) בצורה סיבובית לפי חריץ מעבד. ראה את שאר
עמוד זה לפרטים נוספים.

שימו לב ש-mpirun קושר תהליכים אוטומטית מתחילת סדרת v1.8.
שני דפוסי מחייב משמשים בהיעדר הנחיות נוספות:

לאגד ל הליבה: כאשר מספר התהליכים הוא <= 2

לאגד ל שֶׁקַע: כאשר מספר התהליכים הוא > 2

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

אפשרויות

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

קובץ ההפעלה של התוכנית. זה מזוהה כטיעון הראשון שאינו מוכר
למפירון.

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

-h, - עזרה
הצג עזרה עבור פקודה זו

-q, --שֶׁקֶט
דחק הודעות אינפורמטיביות מ-orterun במהלך הפעלת היישום.

-v, --מִלוּלִי
היו מילוליים

-V, --גִרְסָה
מספר גרסה להדפסה. אם לא יינתנו טיעונים אחרים, זה גם יגרום
orterun כדי לצאת.

-תצוגה-מפה, --תצוגה-מפה
הצג טבלה המציגה את המיקום הממוף של כל תהליך לפני ההשקה.

-תצוגה-לפתח-מפה, --display-devel-map
הצג טבלה מפורטת יותר המציגה את המיקום הממוף של כל תהליך קודם לכן
להשיק (בדרך כלל מעניין מפתחים).

-תצוגה-הקצאה, --תצוגה-הקצאה
הצג את הקצאת המשאב שזוהתה.

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

-H, -מנחה, --מנחה
רשימת מארחים שעליהם להפעיל תהליכים.

-hostfile, --hostfile
ספק קובץ מארח לשימוש.

-קובץ מכונה, --קובץ מכונה
מילה נרדפת ל -hostfile.

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

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

-c, -n, --נ, -נ.פ. <#>
הפעל כל כך הרבה עותקים של התוכנית על הצמתים הנתונים. אפשרות זו מעידה על כך
הקובץ שצוין הוא תוכנית הפעלה ולא הקשר יישום. אם לא
מסופק ערך עבור מספר העותקים לביצוע (כלומר, לא ה-"-np" ולא
המילים הנרדפות שלו מסופקות בשורת הפקודה), Open MPI יבוצע אוטומטית
עותק של התוכנית בכל משבצת תהליך (ראה להלן לתיאור של "תהליך
חריץ"). עם זאת, ניתן להשתמש בתכונה זו רק בדגם SPMD והיא תחזור
שגיאה (ללא תחילת ביצוע של היישום) אחרת.

-מפה לפי ppr:N:
הפעל N כפול מספר האובייקטים מהסוג שצוין בכל צומת.

-npersocket, --npersocket <#persocket>
בכל צומת, הפעל כל כך הרבה תהליכים כפול מספר שקעי המעבד
הצומת. ה -npersocket אפשרות גם מפעילה את -כריכה לשקע אוֹפְּצִיָה.
(הוצא משימוש לטובת --map-by ppr:n:socket)

-npernode, --npernode <#pernode>
בכל צומת, הפעל כל כך הרבה תהליכים. (הוצא משימוש לטובת --map-by
ppr:n:node)

-פרנודה, --פרנודה
בכל צומת, הפעל תהליך אחד -- שווה ערך ל -npernode 1. (הוצא משימוש ב
לטובת --map-by ppr:1:node)

למיפוי תהליכים:

--מפה לפי
מפה לאובייקט שצוין, ברירת המחדל היא שקע. אפשרויות נתמכות כוללות חריץ,
hwthread, core, L1cache, L2cache, L3cache, socket, numa, board, node, sequential,
מרחק, ו-ppr. כל אובייקט יכול לכלול משנה על ידי הוספת : וכל אחד
שילוב של PE=n (קשור n רכיבי עיבוד לכל פרוק), SPAN (איזון עומסים
התהליכים על פני ההקצאה), OVERSUBSCRIBE (אפשר יותר תהליכים בצומת
מאשר רכיבי עיבוד), ו-NOOVERSUBSCRIBE. זה כולל PPR, שבו
הדפוס יסתיים על ידי נקודתיים אחר כדי להפריד בינו לבין המשתנים.

-bycore, --bycore
מפה תהליכים לפי ליבה (הוצא משימוש לטובת --map-by core)

-bysocket, --bysocket
מפה תהליכים לפי שקע (הוצא משימוש לטובת --map-by socket)

- לא מקומי, --לא מקומי
אל תפעיל עותקים כלשהם של היישום שהושק באותו צומת כמו של orterun
רץ. אפשרות זו תעקוף את רישום המארח המקומי איתו --מנחה או כל אחר
מנגנון ציון מארח.

-לא מנוי, --nooversubscribe
אל תירשם יותר מדי צמתים; שגיאה (מבלי להתחיל תהליכים כלשהם) אם ה
מספר התהליכים המבוקש יגרום למנוי יתר. אפשרות זו באופן מרומז
מגדיר את "max_slots" שווה לערך "slots" עבור כל צומת.

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

כדי להזמין את דרגות התהליכים ב-MPI_COMM_WORLD:

--דירוג לפי
דירוג ב-round robin לפי האובייקט שצוין, ברירת המחדל היא חריץ.
האפשרויות הנתמכות כוללות חריץ, hwthread, core, L1cache, L2cache, L3cache, socket,
numa, לוח וצומת.

לכריכת תהליך:

--קשור ל
קשירה תהליכים לאובייקט שצוין, ברירת המחדל היא הליבה. אפשרויות נתמכות כוללות
חריץ, hwthread, core, l1cache, l2cache, l3cache, socket, numa, board, וללא.

-Cpus-per-proc, --cpus-per-proc <#perproc>
קשר כל תהליך למספר המעבדים שצוין. (הוצא משימוש לטובת --map-
על ידי :PE=n)

-Cpus-per-rank, --Cpus-per-rank <#perrank>
כינוי עבור -Cpus-per-proc. (הוצא משימוש לטובת --map-by :PE=n)

-קשור לליבה, --bind-to-core
קישור תהליכים לליבות (הוצא משימוש לטובת --bind-to core)

-כריכה לשקע, --כריכה לשקע
איגד תהליכים לשקעי מעבד (הוצא משימוש לטובת --bind-to socket)

-ללא קשר, --bind-to-none
אין לאגד תהליכים (הוצא משימוש לטובת --bind-to none)

-כריכות דוח, -- כריכות דוח
דווח על כריכות לתהליכים שהושקו.

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

עבור קבצי דירוג:

-rf, --rankfile
ספק קובץ rankfile.

כדי לנהל קלט/פלט סטנדרטי:

-שם קובץ פלט, --שם קובץ פלט
הפנה מחדש את ה-stdout, stderr וה-stddiag של כל התהליכים לתהליך ייחודי
גרסה של שם הקובץ שצוין. כל ספריות בשם הקובץ יהיו
נוצר אוטומטית. כל קובץ פלט יכלול filename.id, כאשר ה-
המזהה יהיה דירוג התהליכים ב-MPI_COMM_WORLD, מלא משמאל עם אפסים עבור
סדר נכון ברשימות.

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

-תג-פלט, --תג-פלט
תייג כל שורת פלט ל-stdout, stderr ו-stddiag עם [עבודה,
MCW_rank] מציין את עבודת התהליך ואת דירוג MPI_COMM_WORLD של
תהליך שיצר את הפלט, והערוץ שיצר אותו.

-חותמת-זמן-פלט, ---outstamp-output
חותמת כל שורת פלט ל-stdout, stderr ו-stddiag.

-xml, --xml
ספק את כל הפלט ל-stdout, stderr ו-stddiag בפורמט xml.

-xterm, --xterm
הצג את הפלט מהתהליכים שזוהו לפי דירוג ה-MPI_COMM_WORLD שלהם
חלונות xterm נפרדים. הדרגות מצוינות כרשימה מופרדת בפסיקים של
טווחים, עם -1 המציין הכל. יווצר חלון נפרד לכל אחד מהם
תהליך מוגדר. הערה: xterm בדרך כלל יסיים את החלון עם סיום
של התהליך המתנהל בתוכו. עם זאת, על ידי הוספת "!" לסוף הרשימה
בדרגות שצוינו, יסופקו האפשרויות המתאימות כדי להבטיח שה-xterm יישמר
החלון נפתח לאחר התהליך מסתיים, ובכך מאפשר לך לראות את התהליך'
תְפוּקָה. כל חלון xterm יצטרך להיסגר ידנית. הערה: In
בסביבות מסוימות, xterm עשוי לדרוש שקובץ ההפעלה יהיה בנתיב המשתמש, או
יצויין במונחים מוחלטים או יחסיים. לפיכך, ייתכן שיהיה צורך לציין א
קובץ הפעלה מקומי בתור "./foo" במקום רק "foo". אם xterm לא מצליח למצוא את
קובץ הפעלה, mpirun ייתקע, אבל עדיין יגיב נכון ל-ctrl-c. אם זה
קורה, אנא בדוק שקובץ ההפעלה מצוין כהלכה ונסה
שוב.

כדי לנהל קבצים וסביבת זמן ריצה:

-נָתִיב, --נָתִיב
שישמשו בעת ניסיון לאתר את קובצי ההפעלה המבוקשים. זֶה
משמש לפני השימוש בהגדרת PATH המקומית.

-קידומת
ספריית קידומת שתשמש להגדרת ה נתיב ו LD_LIBRARY_PATH על
צומת מרוחק לפני הפעלת MPI פתוח או תהליך היעד. ראה את "השלט
הסעיף "ביצוע", להלן.

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

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

--preload-files-dest-dir
ספריית היעד שתשמש לטעינה מראש של קבצים, אם היא שונה מהנוכחית
ספריית עבודה. כברירת מחדל, הנתיבים המוחלטים והיחסיים שמסופקים על ידי
נעשה שימוש ב-preload-files.

--tmpdir
הגדר את השורש עבור עץ ספריות ההפעלה עבור mpirun בלבד.

-wd
מילה נרדפת ל -wdir.

-wdir
שנה לספרייה לפני הפעלת התוכנית של המשתמש. ראה את "נוכחי
קטע Working Directory" להערות על נתיבים יחסיים. הערה: אם -wdir אוֹפְּצִיָה
מופיע הן בשורת הפקודה והן בהקשר של יישום, ההקשר יופיע
עדיפות על שורת הפקודה. לפיכך, אם הנתיב ל-wdir הרצוי הוא
שונה בצמתים האחוריים, אז יש לציין אותו כנתיב מוחלט
נכון לצומת הקצה האחורי.

-x
ייצא את משתני הסביבה שצוינו לצמתים המרוחקים לפני ביצוע ה-
תכנית. ניתן לציין רק משתנה סביבה אחד לכל -x אוֹפְּצִיָה. קיים
ניתן לציין משתני סביבה או לציין שמות משתנים חדשים עם
ערכים מתאימים. לדוגמה:
% mpirun -x DISPLAY -x OFILE=/tmp/out ...

המנתח עבור ה -x אפשרות לא מאוד מתוחכמת; זה אפילו לא מבין
ערכים מובאים. מומלץ למשתמשים להגדיר משתנים בסביבה, ולאחר מכן להשתמש
-x לייצא (לא להגדיר) אותם.

הגדרת פרמטרים של MCA:

-gmca, --gmca
העבר פרמטרים גלובליים של MCA החלים על כל ההקשרים. האם ה
שם פרמטר; הוא ערך הפרמטר.

-mca, --mca
שלח ארגומנטים למודולי MCA שונים. עיין בסעיף "MCA", להלן.

לניפוי באגים:

-לנפות, --לנפות
הפעל את מאתר הבאגים ברמת המשתמש המצוין על ידי orte_base_user_debugger MCA
פָּרָמֶטֶר.

-מנפה, --מנפה
רצף של ניפוי באגים לחיפוש מתי --לנפות משמש (כלומר מילה נרדפת ל
orte_base_user_debugger פרמטר MCA).

-טֵלֶוִיזִיָה, --טֵלֶוִיזִיָה
הפעל תהליכים תחת מאתר הבאגים של TotalView. תאימות לאחור הוצאה משימוש
דֶגֶל. מילה נרדפת ל --לנפות.

יש גם אפשרויות אחרות:

--לאפשר-לרוץ-כשורש
להתיר מפירון להפעלה כאשר הוא מופעל על ידי משתמש השורש (מפירון ברירת המחדל להפסקה
כאשר הושק כמשתמש השורש).

-הופל, -- הופסק <#>
הגדר את המספר המרבי של תהליכים שהופסקו לתצוגה.

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

-סה, --cartofile
ספק קובץ קרטוגרפיה.

--הטרו
מציין שמסופקים מספר app_contexts שהם שילוב של 32/64 סיביות
בינאריות.

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

-ompi-שרת, --ompi-שרת <uri or קובץ>
ציין את ה-URI של שרת MPI הפתוח (או ה-mpirun שישמש כשרת),
שם הקובץ (מצוין בתור file:filename) שמכיל את המידע הזה, או את
PID (מצוין בתור pid:#) של ה-mpirun שיש להשתמש בו
השרת. שרת MPI פתוח משמש לתמיכה בנתונים מרובי יישומים
החלפה באמצעות הפונקציות MPI-2 MPI_Publish_name ו-MPI_Lookup_name.

-דוח-pid, --report-pid
הדפס את ה-PID של mpirun במהלך ההפעלה. הערוץ חייב להיות '-' לאינדי
ציינו שה-Pid ייצא ל-stdout, '+' כדי לציין שה-Pid הוא
להיות outp ut ל stderr, או שם קובץ שאליו יש לכתוב את ה-PID.

-דווח-uri, --report-uri
הדפס את ה-URI של mpirun במהלך ההפעלה. הערוץ חייב להיות '-' לאינדי
ציינו שה-URI ייצא ל-stdout, '+' כדי לציין שה-URI הוא
להיות יוצא ל-stderr, או שם קובץ שאליו יש לכתוב את ה-URI.

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

-זמן המתנה לשרת, --זמן המתנה לשרת
משך הזמן המקסימלי (בשניות) mpirun צריך לחכות לשרת ompi
הַתחָלָה. ברירת המחדל היא 10 שניות.

האפשרויות הבאות שימושיות למפתחים; הם בדרך כלל לא שימושיים לרוב
משתמשי ORTE ו/או MPI:

-d, --debug-devel
אפשר איתור באגים של OmpiRTE (שכבת זמן הריצה ב-Open MPI). זה לא
שימושי בדרך כלל עבור רוב המשתמשים.

--debug-demons
אפשר איתור באגים של כל דמוני OmpiRTE המשמשים את היישום הזה.

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

-השקה-סוכן, ---launch-agent
שם קובץ ההפעלה שיש להשתמש בו כדי להתחיל תהליכים בצמתים מרוחקים.
ברירת המחדל היא "אורט". ניתן להשתמש באפשרות זו כדי לבדוק מושגי דמון חדשים, או כדי
להעביר אפשרויות חזרה לדמונים מבלי ש-mpirun עצמה תראה אותן. ל
לדוגמה, ציון סוכן השקה של orted -mca odls_base_verbose 5 מאפשר את
המפתח יבקש מהאורטד לפלט ניפוי באגים ללא עומס מ-mpirun עצמו.

--לא תחילית
השבת את אופן הפעולה האוטומטי --prefix

ייתכן שיופיעו אפשרויות אחרות עם מפירון - עזרה.

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

תיאור

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

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

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

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

מפרט מארח צמתים
ניתן לזהות צמתים מארח ב- מפירון שורת הפקודה עם ה -מנחה אפשרות או ב-a
קובץ מארח.

לדוגמה,

mpirun -H aa,aa,bb ./a.out
משיק שני תהליכים בצומת aa ואחד ב-bb.

לחלופין, שקול את קובץ המארח

% cat myhostfile
aa חריצים=2
bb slots=2
חריצי cc=2

כאן, אנו מפרטים גם את שמות המארח (aa, bb ו-cc) אבל גם כמה "חריצים" יש עבור
כל אחד. חריצים מציינים כמה תהליכים יכולים לבצע בצומת. לטובה
ביצועים, ניתן לבחור את מספר המשבצות להיות מספר הליבות בצומת או
מספר שקעי המעבד. אם קובץ המארח אינו מספק מידע על משבצות, א
ההנחה היא ברירת המחדל של 1. כאשר פועל תחת מנהלי משאבים (למשל, SLURM, Torque,
וכו'), Open MPI ישיג גם את שמות המארחים וגם את מספר המשבצות ישירות מה-
מנהל משאבים.

mpirun -hostfile myhostfile ./a.out
ישיק שני תהליכים בכל אחד משלושת הצמתים.

mpirun -hostfile myhostfile -host aa ./a.out
ישיק שני תהליכים, שניהם בצומת aa.

mpirun -hostfile myhostfile -host dd ./a.out
לא ימצא מארחים לרוץ עליהם ויבטל עם שגיאה. כלומר, המארח שצוין dd
אינו נמצא בקובץ המארח שצוין.

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

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

mpirun -H aa,bb -npersocket 2 ./a.out
משיק תהליכים 0-3 בצומת aa ותהליך 4-7 בצומת bb, כאשר aa ו-bb שניהם
צמתים עם שקעים כפולים. ה -npersocket אפשרות גם מפעילה את -כריכה לשקע אוֹפְּצִיָה,
אשר נדון בחלק מאוחר יותר.

mpirun -H aa,bb -npernode 2 ./a.out
משיק תהליכים 0-1 בצומת aa ותהליכים 2-3 בצומת bb.

mpirun -H aa,bb -npernode 1 ./a.out
משיק תהליך אחד לכל צומת מארח.

mpirun -H aa,bb -pernode ./a.out
הוא זהה -npernode 1.

חלופה נוספת היא לציין את מספר התהליכים עם -נ.פ. אוֹפְּצִיָה. לשקול
כעת קובץ המארח

% cat myhostfile
aa חריצים=4
bb slots=4
חריצי cc=4

עכשיו,

mpirun -hostfile myhostfile -np 6 ./a.out
ישיק תהליכים 0-3 בצומת aa ותהליכים 4-5 בצומת bb. השאר
משבצות בקובץ המארח לא ישמשו מאז -נ.פ. האפשרות ציינה שרק 6
יש להפעיל תהליכים.

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

שקול את אותו קובץ מארח כמו לעיל, שוב עם -נ.פ. 6:

node aa node bb node cc

mpirun 0 1 2 3 4 5

mpirun --map-by node 0 3 1 4 2 5

mpirun -nolocal 0 1 2 3 4 5

השמיים --מפה לפי צומת אפשרות איזון עומס התהליכים על פני הצמתים הזמינים,
מספור כל תהליך באופן עגול.

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

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

mpirun -hostfile myhostfile -np 14 ./a.out
ישיק תהליכים 0-3 בצומת aa, 4-7 ב-bb ו-8-11 ב-cc. לאחר מכן הוא יוסיף את
שני תהליכים שנותרו לאיזה צמתים שהיא תבחר.

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

mpirun -hostfile myhostfile -np 14 -nooversubscribe ./a.out
יפיק שגיאה מאז -לא מנוי מונע מנוי יתר.

ניתן לציין מגבלות על מנוי יתר גם בקובץ המארח עצמו:
% cat myhostfile
aa slots=4 max_slots=4
bb max_slots=4
חריצי cc=4

השמיים max_slots השדה מציין מגבלה כזו. כשזה קורה, ה חריצי ברירת המחדל של הערך היא
לְהַגבִּיל. עַכשָׁיו:

mpirun -hostfile myhostfile -np 14 ./a.out
גורם ל-12 התהליכים הראשונים להיות מופעלים כמו קודם, אבל השניים הנותרים
תהליכים ייכפו על צומת cc. שני הצמתים האחרים מוגנים על ידי
hostfile נגד מנוי יתר על ידי עבודה זו.

משתמש ב --nooversubscribe אפשרות יכולה להיות מועילה מכיוון ש-Open MPI כרגע לא מקבל
ערכי "max_slots" ממנהל המשאבים.

כמובן, -נ.פ. יכול לשמש גם עם -H or -מנחה אוֹפְּצִיָה. לדוגמה,

mpirun -H aa,bb -np 8 ./a.out
משיקה 8 תהליכים. מכיוון שציינו רק שני מארחים, אחרי השניים הראשונים
תהליכים ממופים, אחד ל-aa ואחד ל-bb, שאר התהליכים נרשמים יתר על המידה
המארחים שצוינו.

והנה דוגמה של MIMD:

mpirun -H aa -np 1 שם מארח: -H bb,cc -np 2 זמן פעילות
יפעיל את תהליך 0 המארח בצומת aa ותהליכים 1 ו-2 פועלים כל אחד
זמן פעולה תקין בצמתים bb ו-cc, בהתאמה.

מיפוי, דירוג, ו כריכה: Oh שֶׁלִי!
Open MPI משתמש בהליך תלת-שלבי להקצאת מיקומי תהליכים ודרגות:

מיפוי מקצה מיקום ברירת מחדל לכל תהליך

הדירוג מקצה ערך דירוג MPI_COMM_WORLD לכל תהליך

כריכה מגביל כל תהליך לפעול על מעבדים ספציפיים

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

הערה: המיקום שהוקצה לתהליך אינו תלוי במקום שבו הוא ייקשר - ה
ההקצאה משמשת אך ורק כקלט לאלגוריתם הקישור.

ניתן להגדיר את המיפוי של תהליכי תהליך לצמתים לא רק עם מדיניות כללית
אבל גם, במידת הצורך, באמצעות מיפויים שרירותיים שלא ניתן לתאר על ידי פשוט
מְדִינִיוּת. אפשר להשתמש ב"מפה רציף", שקורא את קובץ המארח שורה אחר שורה,
הקצאת תהליכים לצמתים בכל סדר שקובץ המארח מציין. להשתמש ב -mca rmaps
seq אוֹפְּצִיָה. לדוגמה, שימוש באותו קובץ מארח כמו קודם:

mpirun -hostfile myhostfile -mca rmaps seq ./a.out

ישיק שלושה תהליכים, אחד בכל אחד מהצמתים aa, bb ו-cc, בהתאמה. החריץ
הספירה לא משנה; תהליך אחד מופעל בכל שורה בכל צומת שרשום ב-
קו.

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

השלב השני מתמקד ב הדירוג של התהליך בתוך MPI_COMM_WORLD של המשרה.
Open MPI מפריד בין זה לבין הליך המיפוי כדי לאפשר גמישות רבה יותר ב-
מיקום יחסי של תהליכי MPI. זה מומחש בצורה הטובה ביותר על ידי התחשבות בדברים הבאים
שני מקרים שבהם השתמשנו באפשרות —map-by ppr:2:socket:

צומת aa צומת bb

דירוג לפי ליבה 0 1 ! 2 3 4 5 ! 6 7

דירוג לפי שקע 0 2 ! 1 3 4 6 ! 5 7

דירוג לפי שקע: span 0 4 ! 1 5 2 6 ! 3 7

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

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

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

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

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

לבסוף, -- כריכות דוח ניתן להשתמש כדי לדווח על כריכות.

כדוגמה, שקול צומת עם שני שקעי מעבד, שכל אחד מהם כולל ארבע ליבות. אָנוּ
לָרוּץ מפירון עם -נ.פ. 4 -- כריכות דוח והאפשרויות הנוספות הבאות:

% mpirun ... --map-by core --bind-to core
[...] ... מחייב ילד [...,0] למעבד 0001
[...] ... מחייב ילד [...,1] למעבד 0002
[...] ... מחייב ילד [...,2] למעבד 0004
[...] ... מחייב ילד [...,3] למעבד 0008

% mpirun ... --map-by socket --bind-to socket
[...] ... מחייב ילד [...,0] לשקע 0 cpus 000f
[...] ... מחייב ילד [...,1] לשקע 1 מעבד 00f0
[...] ... מחייב ילד [...,2] לשקע 0 cpus 000f
[...] ... מחייב ילד [...,3] לשקע 1 מעבד 00f0

% mpirun ... --map-by core:PE=2 --bind-to core
[...] ... מחייב ילד [...,0] למעבד 0003
[...] ... מחייב ילד [...,1] למעבד 000c
[...] ... מחייב ילד [...,2] למעבד 0030
[...] ... מחייב ילד [...,3] למעבד 00c0

% mpirun ... --bind-to none

כאן, -- כריכות דוח מציג את הכריכה של כל תהליך כמסכה. במקרה הראשון,
התהליכים נקשרים לליבות עוקבות כפי שמצוין על ידי המסכות 0001, 0002, 0004, ו
0008. במקרה השני, תהליכים נקשרים לכל הליבות בשקעים עוקבים כמצוין
לפי המסכות 000f ו-00f0. התהליכים עוברים דרך שקעי המעבד בסיבוב עגול
רובין אופנה כמה פעמים שצריך. במקרה השלישי, המסכות מראות לנו ש-2
ליבות נקשרו לכל תהליך. במקרה הרביעי, הכריכה כבויה ולא
מדווחים על כריכות.

התמיכה של Open MPI בקשירת תהליכים תלויה במערכת ההפעלה הבסיסית.
לכן, ייתכן שאפשרויות מסוימות של קשירת תהליכים לא יהיו זמינות בכל מערכת.

ניתן להגדיר כריכת תהליך גם עם פרמטרים של MCA. השימוש בהם פחות נוח מאשר
זה של מפירון אפשרויות. מצד שני, ניתן להגדיר פרמטרים של MCA לא רק על
מפירון שורת הפקודה, אך לחילופין בקובץ מערכת או משתמש mca-params.conf או as
משתני סביבה, כמתואר בסעיף MCA להלן. כמה דוגמאות כוללות:

אפשרות mpirun ערך מפתח פרמטר MCA

--map-by core ליבת rmaps_base_mapping_policy
--map-by socket rmaps_base_mapping_policy socket
--דירוג לפי ליבה ליבת rmaps_base_ranking_policy
--bind-to core ליבת hwloc_base_binding_policy
--bind-to socket hwloc_base_binding_policy socket
--bind-to none hwloc_base_binding_policy none

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

דַרגָה = חריץ=

לדוגמה:

$ cat myrankfile
דרגה 0=aa משבצת=1:0-2
דרגה 1=bb משבצת=0:0,1
דרגה 2=חריץ cc=1-2
$ mpirun -H aa,bb,cc,dd -rf myrankfile ./a.out

אומר ש

דרגה 0 פועלת על צומת aa, קשורה לשקע לוגי 1, ליבות 0-2.
דרגה 1 פועלת על צומת bb, קשורה לשקע לוגי 0, הליבות 0 ו-1.
דרגה 2 פועלת על צומת cc, קשורה לליבות לוגיות 1 ו-2.

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

$ cat myphysicalrankfile
דרגה 0=aa משבצת=1
דרגה 1=bb משבצת=8
דרגה 2=חריץ cc=6

משמעות הדבר היא

דירוג 0 יפעל בצומת aa, קשור לליבה המכילה PU 1 פיזי
דירוג 1 יפעל על צומת bb, קשור לליבה המכילה PU 8 פיזי
דרגה 2 תפעל על צומת cc, קשור לליבה המכילה PU 6 פיזי

קבצי דירוג מתייחסים כאל הגיוני כברירת מחדל, והפרמטר MCA
יש להגדיר את rmaps_rank_file_physical ל-1 כדי לציין ש-rankfile אמור להיות
נחשב כ גופני.

שמות המארחים המפורטים לעיל הם "אבסולוטיים", כלומר שמות מארחים ניתנים לפתרון בפועל
נָקוּב. עם זאת, ניתן לציין גם שמות מארחים כ"יחסיים", כלומר שכן
שצוין ביחס לרשימה שצוינה חיצונית של שמות מארח (למשל, על ידי mpirun's
--ארגומנט מארח, קובץ מארח או מתזמן עבודה).

המפרט ה"יחסי" הוא בצורת "+n ", כאשר X הוא מספר שלם המציין את
שם מארח X-בקבוצה של כל שמות המארחים הזמינים, באינדקס מ-0. לדוגמה:

$ cat myrankfile
rank 0=+n0 slot=1:0-2
דרגה 1=+n1 משבצת=0:0,1
דרגה 2=+n2 משבצת=1-2
$ mpirun -H aa,bb,cc,dd -rf myrankfile ./a.out

החל מ-Open MPI v1.7, כל מיקומי חריצי שקע/ליבה יצוינו כ הגיוני
אינדקסים (סדרת Open MPI v1.6 בשימוש גופני אינדקסים). ניתן להשתמש בכלים כגון
"lstopo" של HWLOC כדי למצוא את האינדקסים הלוגיים של שקע וליבות.

בקשה הקשר or ניתן לבצע תכנית?
כדי להבחין בין שתי הצורות השונות, מפירון מחפש בשורת הפקודה עבור --אפליקציה אוֹפְּצִיָה.
אם הוא מצוין, ההנחה היא שהקובץ ששמו בשורת הפקודה הוא an
הקשר יישום. אם זה לא צוין, ההנחה היא שהקובץ הוא קובץ הפעלה
תכנית.

איתור קבצים
אם לא צוין נתיב יחסי או מוחלט עבור קובץ, Open MPI יחפש תחילה
קבצים על ידי חיפוש בספריות שצוינו על ידי --נָתִיב אוֹפְּצִיָה. אם אין --נָתִיב
מוגדר או אם הקובץ לא נמצא ב- --נָתִיב מיקום, ואז Open MPI יחפש
משתנה הסביבה PATH של המשתמש כפי שהוגדר בצמת/ים המקור.

אם צוינה ספרייה יחסית, עליה להיות יחסית לספריית העבודה הראשונית
נקבע לפי המתנע הספציפי שבו נעשה שימוש. לדוגמה בעת שימוש ב-rsh או ssh starters,
הספרייה הראשונית היא $HOME כברירת מחדל. מתחילים אחרים עשויים להגדיר את הספרייה הראשונית ל
ספריית העבודה הנוכחית מהפעלת מפירון.

נוֹכְחִי עבודה מַדרִיך
השמיים -wdir אפשרות mpirun (והמילה הנרדפת שלה, -wd) מאפשר למשתמש לשנות למצב שרירותי
ספרייה לפני הפעלת התוכנית. ניתן להשתמש בו גם בקובצי הקשר של יישומים
כדי לציין ספריות עבודה על צמתים ספציפיים ו/או עבור יישומים ספציפיים.

אם -wdir האפשרות מופיעה הן בקובץ ההקשר והן בשורת הפקודה, ההקשר
ספריית הקבצים תעקוף את ערך שורת הפקודה.

אם -wdir האפשרות מוגדרת, Open MPI ינסה לשנות לצוין
ספרייה בכל הצמתים המרוחקים. אם זה נכשל, מפירון יפיל.

אם -wdir האפשרות היא לֹא שצוין, Open MPI ישלח את שם הספרייה לאן מפירון
הופעל לכל אחד מהצמתים המרוחקים. הצמתים המרוחקים ינסו לשנות לזה
מַדרִיך. אם הם אינם מסוגלים (למשל, אם הספרייה לא קיימת בצומת זה), אז
Open MPI ישתמש בספריית ברירת המחדל שנקבעה על ידי המתנע.

כל שינוי ספריות מתרחש לפני הפעלת התוכנית של המשתמש; זה לא מחכה עד
MPI_INIT נקרא.

תֶקֶן I / O
Open MPI מפנה את הקלט הסטנדרטי של UNIX ל-/dev/null בכל התהליכים מלבד
MPI_COMM_WORLD תהליך דירוג 0. תהליך MPI_COMM_WORLD דירוג 0 יורש קלט סטנדרטי
החל מ- מפירון. הערה: הצומת שהפעיל מפירון לא צריך להיות זהה לצומת שבו
תהליך MPI_COMM_WORLD דירוג 0 נמצא. Open MPI מטפל בהפניה מחדש של מפירון's
קלט סטנדרטי לתהליך דרגה 0.

Open MPI מפנה את הפלט והשגיאה הסטנדרטיים של UNIX מצמתים מרוחקים לצומת שהפעיל
מפירון ומדפיס אותו על הפלט/שגיאה הסטנדרטית של מפירון. תהליכים מקומיים יורשים את
פלט סטנדרטי/שגיאה של מפירון ולהעביר אליו ישירות.

כך ניתן להפנות מחדש קלט/פלט סטנדרטי עבור יישומי MPI פתוחים על ידי שימוש ב-
נוהל הפניית מעטפת טיפוסי מופעל מפירון.

% mpirun -np 2 my_app < ​​my_input > my_output

שימו לב שבדוגמה זו רק תהליך MPI_COMM_WORLD דרגה 0 יקבל את הזרם
החל מ- שלי_הקלט על stdin. הסטדין בכל הצמתים האחרים יהיה קשור ל-/dev/null.
עם זאת, ה-stdout מכל הצמתים ייאסף לתוך שלי_פלט קובץ.

לאותת רביה
כאשר orterun יקבל SIGTERM ו-SIGINT, הוא ינסה להרוג את כל העבודה על ידי
שליחת כל התהליכים בעבודה SIGTERM, ממתינה מספר קטן של שניות, אז
שליחת כל התהליכים בתפקיד SIGKILL.

אותות SIGUSR1 ו-SIGUSR2 המתקבלים על ידי orterun מופצים לכל התהליכים ב-
עבודה.

אפשר להפעיל העברה של SIGSTOP ו-SIGCONT לתוכנית שמבוצעת על ידי mpirun by
הגדרת פרמטר MCA orte_forward_job_control ל-1. אות SIGTSTOP ל-mpirun
ואז לגרום לאות SIGSTOP להישלח לכל התוכניות שהופעלו על ידי mpirun ו
כמו כן אות SIGCONT ל-mpirun יגרום לשליחת SIGCONT.

אותות אחרים אינם מופצים כעת על ידי orterun.

התַהֲלִיך סיום / לאותת טיפול
במהלך הרצה של יישום MPI, אם תהליך כלשהו מת בצורה לא תקינה (או יציאה
לפני הפעלת MPI_FINALIZE, או מת כתוצאה מאות), מפירון ידפיס
הודעת שגיאה והרוג את שאר יישום MPI.

כנראה שמטפלי אותות משתמשים צריכים להימנע מלנסות לנקות את מצב MPI (Open MPI הוא
כרגע לא מאובטח לאותות אסינכרון; לִרְאוֹת MPI_Init_thread(3) לפרטים על
MPI_THREAD_MULTIPLE ובטיחות חוטים). לדוגמה, אם מתרחשת תקלת פילוח ב
MPI_SEND (אולי בגלל שמאגר רע הועבר פנימה) ומטפל איתות משתמש הוא
מופעל, אם מטפל משתמש זה מנסה להפעיל MPI_FINALIZE, דברים רעים עלולים לקרות
מכיוון ש-Open MPI כבר היה "ב" MPI כאשר התרחשה השגיאה. מאז מפירון ישים לב
שהתהליך מת עקב אות, זה כנראה לא הכרחי (והבטוח ביותר) עבור
משתמש לנקות רק מצב שאינו MPI.

התַהֲלִיך סביבה
תהליכים באפליקציית MPI יורשים את הסביבה שלהם מהדמון Open RTE
הצומת עליו הם פועלים. הסביבה בדרך כלל עוברת בירושה מה
המעטפת של המשתמש. בצמתים מרוחקים, הסביבה המדויקת נקבעת על ידי מודול MCA האתחול
בשימוש. ה רש מודול הפעלה, למשל, משתמש בשניהם רש/ssh כדי להפעיל את Open RTE
daemon בצמתים מרוחקים, ובדרך כלל מבצע אחד או יותר מקבצי הגדרת המעטפת של המשתמש
לפני הפעלת הדמון Open RTE. בעת הפעלת יישומים מקושרים דינמית אשר
דורשים את LD_LIBRARY_PATH יש להגדיר משתנה סביבה, יש להקפיד על כך
שהוא מוגדר כהלכה בעת אתחול Open MPI.

עיין בסעיף "ביצוע מרחוק" לפרטים נוספים.

מרוחק הוצאה לפועל
MPI פתוח דורש שה נתיב משתנה סביבה יוגדר כדי למצוא קובצי הפעלה מרחוק
צמתים (בדרך כלל זה נחוץ רק ב רש- או sshסביבות מבוססות --
סביבות אצווה/מתוזמנות בדרך כלל מעתיקות את הסביבה הנוכחית לביצוע של
משרות מרוחקות, אז אם יש לסביבה הנוכחית נתיב ו / או LD_LIBRARY_PATH מוגדר כמו שצריך,
גם הצמתים המרוחקים יגדירו אותו כראוי). אם Open MPI הוידור עם משותף
תמיכה בספרייה, ייתכן שיהיה צורך גם ב- LD_LIBRARY_PATH משתנה הסביבה
מוגדר גם בצמתים מרוחקים (במיוחד כדי למצוא את הספריות המשותפות הנדרשות להפעלת משתמש
יישומי MPI).

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

השמיים -קידומת option לוקח ארגומנט בודד: ספריית הבסיס בצומת המרוחק איפה
Open MPI מותקן. Open MPI ישתמש בספרייה זו כדי להגדיר את השלט נתיב ו
LD_LIBRARY_PATH לפני הפעלת כל Open MPI או יישומי משתמש. זה מאפשר ריצה
פתח משרות MPI מבלי להגדיר מראש את נתיב ו LD_LIBRARY_PATH בשלט הרחוק
צמתים.

Open MPI מוסיף את שם הבסיס של ה-"bindir" של הצומת הנוכחי (הספרייה שבה
קובצי הפעלה מותקנים) לקידומת ומשתמש בה כדי להגדיר את נתיב בצומת המרוחק.
באופן דומה, Open MPI מוסיף את שם הבסיס של ה-"libdir" של הצומת הנוכחי (הספרייה שבה
הספריות של Open MPI מותקנות) לקידומת ומשתמשת בה כדי להגדיר את LD_LIBRARY_PATH
בצומת המרוחק. לדוגמה:

מאגר מקומי: /local/node/directory/bin

libdir מקומי: /local/node/directory/lib64

אם נעשה שימוש בשורת הפקודה הבאה:

% mpirun --prefix /remote/node/directory

MPI פתוח יוסיף את "/remote/node/directory/bin" ל- נתיב ו
"/remote/node/directory/lib64" ל-D_LIBRARY_PATH בצומת המרוחק לפני ניסיון
לבצע כל דבר.

השמיים -קידומת האפשרות אינה מספיקה אם נתיבי ההתקנה בצומת המרוחק הם
שונה מהצומת המקומי (למשל, אם "/ lib"משמש בצומת המקומי, אבל"/lib64"זה
בשימוש בצומת המרוחק), או אם נתיבי ההתקנה הם משהו אחר מאשר a
ספריית משנה תחת קידומת נפוצה.

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

% /usr/local/bin/mpirun ...

שווה

% mpirun --תחילית / usr / local

מיוצא סביבה משתנים
כל משתני הסביבה שנקראים בצורת OMPI_* ייוצאו אוטומטית
לתהליכים חדשים בצמתים המקומיים והמרוחקים. פרמטרים סביבתיים יכולים להיות גם
הגדר/הועבר לתהליכים החדשים באמצעות פרמטר MCA mca_base_env_list. ה -x
אפשרות ל מפירון הוצא משימוש, אבל התחביר של פראם MCA עוקב אחר זה הקודם
דוגמא. בעוד שהתחביר של ה -x Option ו-MCA ​​param מאפשרים הגדרה של חדש
משתנים, שים לב שהמנתח עבור אפשרויות אלה אינו מתוחכם במיוחד -
הוא אפילו לא מבין ערכים מובאים. מומלץ למשתמשים להגדיר משתנים ב-
סביבה והשתמש באפשרות לייצא אותם; לא להגדיר אותם.

הגדרת MCA פרמטרים
השמיים -mca מתג מאפשר העברת פרמטרים ל-MCA שונים (רכיב מודולרי
אדריכלות) מודולים. למודולי MCA יש השפעה ישירה על תוכניות MPI מכיוון שהם מאפשרים
פרמטרים ניתנים לכוונון שיש להגדיר בזמן ריצה (כגון לאיזה מנהל התקן תקשורת BTL יש לבצע
להשתמש, אילו פרמטרים להעביר לאותו BTL וכו').

השמיים -mca switch לוקח שני ארגומנטים: ו . ה טיעון באופן כללי
מציין איזה מודול MCA יקבל את הערך. לדוגמה, ה נעשה שימוש ב-"btl".
כדי לבחור באיזה BTL ישמש להעברת הודעות MPI. ה הטיעון הוא ה
ערך שעובר. לדוגמה:

mpirun -mca btl tcp,self -np 1 foo
אומר ל-Open MPI להשתמש ב-"tcp" ו-"self" BTLs, ולהריץ עותק בודד של "foo" an
צומת שהוקצה.

mpirun -mca btl self -np 1 foo
אומר ל-Open MPI להשתמש ב-BTL "עצמי", ולהריץ עותק בודד של "foo" מוקצה
צוֹמֶת.

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

שים לב כי -mca switch הוא פשוט קיצור דרך להגדרת משתני סביבה. ה
ניתן להשיג אותה השפעה על ידי הגדרת משתני סביבה מתאימים לפני כן
ריצה מפירון. צורת משתני הסביבה ש-Open MPI מגדירה היא:

OMPI_MCA_ =

כך, -mca מתג עוקף כל משתני סביבה שהוגדרו בעבר. ה -mca
ההגדרות עוקפות באופן דומה את פרמטרי MCA שהוגדרו ב-$OPAL_PREFIX/etc/openmpi-mca-
קובץ params.conf או $HOME/.openmpi/mca-params.conf.

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

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

ריצה as שורש
צוות Open MPI ממליץ בחום שלא לבצע מפירון בתור משתמש השורש. MPI
יש להפעיל יישומים כמשתמשים רגילים (שאינם שורשיים).

משקף את העצה הזו, mpirun יסרב לפעול כ-root כברירת מחדל. כדי לעקוף את זה
ברירת מחדל, אתה יכול להוסיף את --לאפשר-לרוץ-כשורש אפשרות מפירון שורת הפקודה.

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

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

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

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

· אם אופציית הקו cmd --report-child-jobs-separately מוגדרת, נחזיר -רק- את
מצב יציאה מהעבודה העיקרית. כל סטטוס יציאה שאינו אפס במשרות משניות יהיה
דווח אך ורק בהצהרה מודפסת מסכם.

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

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

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

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

דוגמאות

הקפד גם לראות את הדוגמאות לאורך הסעיפים לעיל.

mpirun -np 4 -mca btl ib,tcp,self prog1
הפעל 4 עותקים של prog1 באמצעות ה-"ib", "tcp" ו-"self" BTL's עבור הובלת MPI
הודעות.

mpirun -np 4 -mca btl tcp,sm,self
--mca btl_tcp_if_include eth0 prog1
הפעל 4 עותקים של prog1 באמצעות ה-BTLs "tcp", "sm" ו-"self" להובלת MPI
הודעות, כאשר TCP משתמש רק בממשק eth0 לתקשורת. שים לב ש-BTLs אחרים
יש פרמטרים דומים של if_include MCA.

לַחֲזוֹר ערך

מפירון מחזירה 0 אם כל התהליכים התחילו על ידי מפירון צא לאחר התקשרות ל-MPI_FINALIZE. א
ערך שאינו אפס מוחזר אם אירעה שגיאה פנימית ב-mpirun, או אחת או יותר
יצאו מתהליכים לפני הקריאה ל-MPI_FINALIZE. אם אירעה שגיאה פנימית ב-mpirun,
קוד השגיאה המתאים מוחזר. במקרה שאחד או יותר תהליכים יוצאים
לפני קריאת MPI_FINALIZE, ערך ההחזרה של דירוג MPI_COMM_WORLD של התהליך
זֶה מפירון ההודעות הראשונות מתו לפני ההתקשרות ל-MPI_FINALIZE יוחזרו. ציין זאת,
באופן כללי, זה יהיה התהליך הראשון שמת אך לא מובטח שזה יהיה כך.

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