מונו - מקוון בענן

תָכְנִית:

שֵׁם

מונו - מחולל הקוד המקורי ECMA-CLI של Mono (בדיוק בזמן ומראש)

תַקצִיר

מונו [אפשרויות] פילה [טיעונים...]

mono-sgen [אפשרויות] פילה [טיעונים...]

תיאור

מונו הוא יישום זמן ריצה של תשתית השפה המשותפת של ECMA. זה יכול להיות
משמש להפעלת יישומי ECMA ו-.NET.

זמן הריצה מכיל מחולל קוד מקורי שהופך את Common Intermediate
שפה לתוך קוד מקורי.

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

זמן הריצה טוען את המצוין פילה ואופציונלי עובר את טיעונים אליו. ה פילה
הוא מכלול ECMA. בדרך כלל יש להם סיומת .exe או .dll.

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

השמיים מונו הפקודה משתמשת באספן האשפה השמרני של Boehm בזמן שה- mono-sgen הפקודה
משתמש באספן זבל נע ודור.

פוריות

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

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

ראה את התיאור עבור MONO_IOMAP בסעיף משתני סביבה לפרטים נוספים.

זמן זמן אפשרויות

האפשרויות הבאות זמינות:

--aot, --aot[=אפשרויות]
אפשרות זו משמשת להידור מראש של קוד ה-CIL במכלול שצוין ל-native
קוד. הקוד שנוצר מאוחסן בקובץ עם הסיומת .so. הקובץ הזה
ייקלט אוטומטית על ידי זמן הריצה בעת ביצוע ההרכבה.
הידור מראש הוא שימושי ביותר אם אתה משתמש בו בשילוב עם
-O=all,-shared דגל המאפשר את כל האופטימיזציות במחולל הקוד
לְהֵעָשׂוֹת. חלק מהאופטימיזציות הללו אינן מעשיות עבור Just-in-Time
קומפילציה מכיוון שהם עשויים לצרוך זמן רב. בניגוד ל-.NET Framework,
הידור מראש לא ייצור קוד עצמאי של דומיין: הוא יוצר
אותו קוד שהמהדר Just-in-Time היה מייצר. מאז רוב
אפליקציות משתמשות בדומיין בודד, זה בסדר. אם אתה רוצה לייעל את
קוד שנוצר לשימוש ביישומים מרובי דומיינים, שקול להשתמש ב-O=shared
דֶגֶל. זה מרכיב מראש את השיטות, אך עדיין נדרשת ההרכבה המקורית
לביצוע שכן זה מכיל את המטא נתונים ומידע חריג שאינו
זמין בקובץ שנוצר. בעת הידור מקדים של קוד, ייתכן שתרצה לבצע קומפילציה
עם כל האופטימיזציות (-O=all). קוד הידור מראש הוא קוד בלתי תלוי במיקום.
קומפילציה מוקדמת היא רק מנגנון לצמצום זמן האתחול, להגדיל את שיתוף הקוד
על פני מספר תהליכי מונו והימנע מהפעלת תוכנית הידור בדיוק בזמן
עלויות. ההרכבה המקורית עדיין חייבת להיות קיימת, שכן המטא נתונים כלולים
שם. בדרך כלל לא ניתן להעביר קוד AOT ממחשב אחד לאחר (CPU-
אופטימיזציות ספציפיות שמזוהות בזמן ריצה) אז אל תנסה לזוז
המכלולים שנוצרו מראש או ארוז עבורם את המכלולים שנוצרו מראש
פְּרִיסָה. כמה אפשרויות זמינות כפרמטר ל- --aot שורת הפקודה
אוֹפְּצִיָה. האפשרויות מופרדות בפסיקים, וניתן לציין יותר מאחת:

autoreg
מהדר AOT יפלוט מאתחל ספרייה (ELF בלבד) באופן אוטומטי
רשום את מודול ה-aot עם זמן הריצה. זה שימושי רק ב
מצב סטטי

באופן רגיל
מורה למהדר AOT להוציא קוד assembly במקום אובייקט
קובץ.

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

הפעלה ישירה
כאשר אפשרות זו מצוינת, שיטות P/Invoke מופעלות ישירות במקום
של מעבר פעולת חיפוש סמל מערכת ההפעלה.

llvm-path=
כנ"ל לכלי llvm 'opt' ו-'llc'.

mtriple=
השתמש בטריפל היעד בסגנון GNU כדי לקבוע יצירת קוד כלשהי
אפשרויות, כלומר --mtriple=armv7-linux-gnueabi יפיק קוד שמכוון
ARMv7. זה נתמך כרגע רק על ידי ARM backend. במצב LLVM,
הטריפל הזה מועבר למהדר LLVM LLC.

לוקח-טרמפולינות=[מספר]
בעת קומפילציה במצב aot מלא, יש ליצור מראש את טרמפולינות IMT
תמונת AOT. אתה יכול להוסיף טרמפולינות שיטה נוספת עם זה
טַעֲנָה. ברירת המחדל היא 128.

nodebug
מורה למהדר AOT לא להוציא מידע על ניפוי באגים.

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

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

nrgctx-trampolines=[מספר]
בעת קומפילציה במצב aot מלא, טרמפולינות השיתוף הגנריות חייבות להיות
נוצר מראש בתמונת AOT. ניתן להוסיף טרמפולינות בשיטה נוספת עם
הטיעון הזה. ברירת המחדל היא 1024.

ntrampolines=[מספר]
בעת קומפילציה במצב aot מלא, יש ליצור מראש את טרמפולינות השיטה
בתמונת AOT. אתה יכול להוסיף טרמפולינות שיטה נוספת עם זה
טַעֲנָה. ברירת המחדל היא 1024.

outfile=[שם קובץ]
מורה למהדר AOT לשמור את הפלט בקובץ שצוין.

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

readonly-value=namespace.typename.fieldname=type/value
עוקף את הערך של שדה סטטי לקריאה בלבד. בדרך כלל, במהלך JIT
הידור, הבנאי הסטטי מופעל בשקיקה, ולכן הערך של סטטי
השדה Readonly ידוע בזמן הקומפילציה והמהדר יכול לבצע מספר
של אופטימיזציות המבוססות עליו. במהלך AOT, במקום זאת, הבנאי הסטטי
לא ניתן להפעיל, אז ניתן להשתמש באפשרות זו כדי להגדיר את הערך של שדה כזה
ולאפשר את אותה סט של אופטימיזציות. הסוג יכול להיות כל אחד מ-i1, i2, i4 for
מספרים שלמים של הגדלים המתאימים (בבתים). שימו לב שחתום/לא חתום
המספרים לא חשובים כאן, רק גודל האחסון. אפשרות זו יכולה להיות
צוין מספר פעמים וזה לא מונע את הבנאי הסטטי עבור
הסוג שמגדיר את השדה לביצוע עם הכללים הרגילים בזמן ריצה
(ולכן אולי מחשב ערך שונה עבור השדה).

לשמור-טמפ', לשמור-טמפ'
מורה למהדר AOT לשמור קבצים זמניים.

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

סטטי צור קובץ ELF אובייקט (.o) או קובץ .s אשר ניתן לקישור סטטי
לקובץ הפעלה בעת הטמעת זמן הריצה המונו. כאשר אפשרות זו היא
בשימוש, יש לרשום את קובץ האובייקט עם זמן הריצה המוטבע באמצעות
הפונקציה mono_aot_register_module אשר לוקחת כארגומנט שלה את
mono_aot_module_ _info סמל גלובלי מקובץ האובייקט:

חלל חיצוני *mono_aot_module_hello_info;

mono_aot_register_module (mono_aot_module_hello_info);

סטטיסטיקות הדפס נתונים סטטיסטיים שונים שנאספו במהלך הידור AOT.

threads=[מספר]
זוהי אפשרות ניסיונית עבור מהדר AOT להשתמש במספר שרשורים
בעת הרכבת השיטות.

tool-prefix=
מנחה לשם הכלים המופעלים על ידי מהדר AOT, כלומר
'כמו'/'לד'. לדוגמה, --tool=prefix=arm-linux-gnueabi- ייצור את ה-AOT
הפעלת מהדר

כתיבה-סמלים
מורה למהדר AOT לפלוט מידע על סמל ניפוי באגים.

למידע נוסף על AOT, ראה: http://www.mono-project.com/docs/advanced/aot/

--attach=[אפשרויות]
כרגע האפשרות היחידה הנתמכת על ידי ארגומנט שורת פקודה זה היא להשבית אשר
משבית את פונקציונליות החיבור.

--config שם הקובץ
טען את קובץ התצורה שצוין במקום ברירת המחדל. ברירת המחדל
הקבצים הם /etc/mono/config ו ~/.mono/config או הקובץ המצוין ב-
משתנה סביבה MONO_CONFIG, אם מוגדר. ראה את מונו-תצורה(5) דף אדם עבור
פרטים על הפורמט של קובץ זה.

--debugger-agent=[אפשרויות]
זה מורה לזמן הריצה של מונו להתחיל סוכן ניפוי באגים בתוך זמן הריצה של מונו
וחיבורו לממשק משתמש לקוח ישלוט בתהליך המונו. זֶה
אפשרות משמשת בדרך כלל על ידי IDEs, כמו MonoDevelop IDE.

התצורה מוגדרת באמצעות אחת מהאפשרויות הבאות:

address=host:port
השתמש באפשרות זו כדי לציין את כתובת ה-IP שבה נמצא לקוח ניפוי הבאגים שלך
האזנה ל.

loglevel=LEVEL
מציין את רמת יומן האבחון עבור

logfile=שם קובץ
משמש כדי לציין את הקובץ שבו יישמר היומן, הוא כברירת מחדל
פלט סטנדרטי.

שרת=[y/n]
ברירת המחדל היא לא, עם אפשרות ברירת המחדל Mono יתחבר באופן פעיל ל-
מארח/יציאה מוגדרים עם ה- כתובת אוֹפְּצִיָה. אם תגדיר את זה ל'y', זה
מורה לזמן הריצה של מונו להתחיל באגים במצב שרת, שבו מונו
ממתין באופן פעיל לנקודת הקצה של ניפוי הבאגים להתחבר לתהליך המונו.
מונו ידפיס את כתובת ה-IP ואת היציאה שבה הוא מאזין.

setpgid=[y/n]
אם מוגדר ככן, מונו יתקשר setpgid(0, 0) on אתחול, if זֶה פונקציה is
זמין on מה היא מערכת. זֶה is מועיל ל הבטחתי זֶה אותות נתן
ל a תהליך זֶה is מבצע מה היא ניפוי באגים יש לו לֹא מופץ ל מה היא
ניפוי באגים, לְמָשָׁל מתי Ctrl-C שולח סיגינט ל מה היא Sdb כלי.

suspend=[y/n]
ברירת המחדל היא כן, עם אפשרות ברירת המחדל Mono ישהה ​​את ה-vm בעת ההפעלה
עד שהוא יתחבר בהצלחה לקצה קצה באגים. אם תגדיר את זה ל
'n', בשילוב עם שרת=י, הוא מורה לזמן הריצה של מונו לפעול כ
רגיל, תוך כדי שמירה של מטא-נתונים במטמון כדי לשלוח אל ממשק הבאגים
חיבור..

transport=שם_תחבורה
זה משמש כדי לציין את התחבורה שאליה ישתמש מאפר הבאגים
לתקשר. זה חייב להיות מצוין וכרגע זה דורש כך
'dt_socket'.

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

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

--gc=בוהם, --gc=sgen
בוחר את מנוע אוסף האשפה עבור מונו לשימוש, Boehm או SGen. כַּיוֹם
זה רק מבטיח שאתה מפעיל או את מונו or mono-sgen פקודות.
ניתן להגדיר דגל זה ב- MONO_ENV_OPTIONS משתנה סביבה כדי לאלץ את כולם
הילד שלך מעבד להשתמש בסוג מסוים של GC עם זמן הריצה של מונו.

- עזרה, -h
מציג הוראות שימוש.

--llvm אם זמן הריצה של מונו הידור עם תמיכת LLVM (לא זמין בכלל
תצורות), מונו ישתמש במנוע האופטימיזציה ויצירת הקוד של LLVM כדי
קומפילציה של JIT או AOT. למידע נוסף, התייעצו: http://www.mono-
project.com/docs/advanced/mono-llvm/

--nolvm
כאשר משתמשים במונו שהורכב עם תמיכת LLVM, הוא מאלץ את מונו לעשות זאת
חזרה למנוע ה-JIT שלו ולא להשתמש ב-LLVM backend.

--optimize=מצב, -O=מצב
MODE היא רשימה מופרדת בפסיקים של אופטימיזציות. הם גם מאפשרים אופטימיזציות ל
ניתן לכבות על ידי הקדמת שם האופטימיזציה עם סימן מינוס. בכללי,
מונו כוונן להשתמש בערכת ברירת המחדל של דגלים, לפני השימוש בדגלים אלה עבור א
הגדרת הפריסה, אולי כדאי למדוד בפועל את היתרונות של השימוש בהם.
דגלי האופטימיזציה הבאים מיושמים במנוע הליבה:
abcrem מערך קשור בודקת הסרה
הכל הפעל את כל האופטימיזציות
aot שימוש בקוד הידור Ahead Of Time
אופטימיזציות של סניפים
cfold קיפול מתמיד
cmov מהלכים מותנים [תלות בארכי]
deadce חיסול קוד מת
consprop התפשטות מתמדת
copyprop הפצת העתקה
fcmov Fast x86 FP משווה [תלות בארכיה]
float32 בצע אריתמטיקה של 32 סיביות באמצעות פעולות של 32 סיביות
gshared אפשר שיתוף קוד גנרי.
קריאות בשיטה מוטבעת
intrins יישומי שיטה פנימית
הקצאת reg גלובלית סריקה לינארית
אופטימיזציות של נהלי עלה עלה
אופטימיזציות הקשורות ללולאה
חור הצצה חור הצצה לאחר מעבר
precomp הידור מקדים של כל השיטות לפני ביצוע Main
תזמון הוראות
קוד Emit משותף לכל דומיין
הוראות sse2 SSE2 על x86 [תלות בארכיה]
tailc רקורסיית זנב וקריאות זנב
לדוגמה, כדי לאפשר את כל האופטימיזציה מלבד ביטול קוד מת והטבעה,
אתה יכול להשתמש:
-O=all,-deadce,-inline
הדגלים המסומנים עם [תלות בארכיה] מציינים שהאפשרות הנתונה אם
בשילוב עם הידור לפני הזמן (--aot flag) ייצור מראש
קוד קומפילציה שיהיה תלוי במעבד הנוכחי וייתכן שלא יועבר אליו בבטחה
מחשב אחר.

האופטימיזציות הבאות נתמכות

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

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

--זמן ריצה=גרסה
מונו תומך בגרסאות זמן ריצה שונות. הגרסה שבה נעשה שימוש תלויה בתוכנית
המופעל או בקובץ התצורה שלו (ששמו program.exe.config). זֶה
ניתן להשתמש באפשרות כדי לעקוף זיהוי אוטומטי כזה, על ידי כפיית זמן ריצה שונה
גרסה לשימוש. שים לב שיש להשתמש בזה רק כדי לבחור תואם מאוחר יותר
גרסת זמן ריצה מזו שלפיה התוכנית הידור. שימוש טיפוסי הוא
להפעלת תוכנית 1.1 בגרסת 2.0:
mono --runtime=v2.0.50727 program.exe

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

שימוש באבטחה ללא פרמטרים שווה ערך לקריאתה עם ה-"cas"
פָּרָמֶטֶר.

המצבים הבאים נתמכים:

core-clr
מאפשר את מערכת האבטחה core-clr, המשמשת בדרך כלל עבור
יישומי אור ירח/אור כסף. זה מספק אבטחה הרבה יותר פשוטה
מערכת מאשר CAS, ראה http://www.mono-project.com/docs/web/moonlight/ ל
פרטים נוספים וקישורים לתיאורים של מערכת חדשה זו.

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

לאימות
מפעיל את המאמת החדש ומבצע אימות מלא של הווית הקוד
יצא לפועל. זה רק מאפשר להפעיל קוד בר אימות. קוד לא בטוח הוא
אסור אבל P/Invoke כן. מצב זה לא אמור לאפשר קוד מנוהל
מונו התרסקות. האימות אינו קפדני כמו תקן ECMA 335 לפי הסדר
כדי להישאר תואם עם זמן הריצה של MS.

מערכת האבטחה פועלת לפי קוד המשתמש: קוד הכלול ב-mscorlib או ב-global
מטמון assembly תמיד מהימן.

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

--אמת-הכל
מאמת את mscorlib ו-assemblies במטמון ה-assembly הגלובלי עבור IL חוקי, והכל
קוד משתמש לאימות IL.

זה שונה מ --בִּטָחוֹןניתן לאימות או תקף בכך שהאפשרויות הללו
בדוק רק את קוד המשתמש ודלג על mscorlib ומכלולים הממוקמים בגלובל
מטמון הרכבה.

-V, --גִרְסָה
מדפיס מידע על גרסת JIT (תצורת מערכת, מספר גרסה וסניף
שמות אם קיימים).

התפתחות אפשרויות

האפשרויות הבאות משמשות לסיוע בעת פיתוח יישום JITed.

--לנפות, --debug=OPTIONS
מפעיל את מצב ניפוי הבאגים בזמן הריצה. אם הידור אסיפה עם
מידע על ניפוי באגים, הוא יפיק מידע על מספר שורה עבור עקבות מחסנית.

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

האפשרויות הבאות נתמכות:

גבס מייצר שגיאה מפורטת בעת זריקת InvalidCastException. זֶה
יש להפעיל את האפשרות מכיוון שהדבר יוצר קוד רב יותר בביצוע
הזמן.

mdb-אופטימיזציות
השבת כמה אופטימיזציות של JIT שבדרך כלל מושבתות רק בזמן הפעלה
בתוך מאתר הבאגים. זה יכול להיות מועיל אם אתה רוצה לצרף ל-
הפעלת תהליך עם mdb.

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

--profile[=profiler[:profiler_args]]
מפעיל את הפרופיל. למידע נוסף על יישומי פרופיל וקוד
כיסוי ראה את הסעיפים "פרופילים" ו"כיסוי קוד" להלן.

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

--trace[=ביטוי]
מציג את שמות השיטה כשהם מופעלים. כברירת מחדל, כל השיטות נמצאות במעקב. ה
ניתן להתאים אישית את trace כדי לכלול או לא לכלול שיטות, מחלקות או הרכבות. א
ביטוי עקבות הוא רשימה מופרדת בפסיקים של יעדים, כל יעד יכול לקבל קידומת
עם סימן מינוס כדי לכבות מטרה מסוימת. המילים 'תוכנית', 'הכל' ו
ל'נכים' יש משמעות מיוחדת. `תוכנית' מתייחס להווית התוכנית הראשית
מבוצע, ו'הכל' פירושו כל קריאות השיטה. האפשרות 'מושבת' משמשת
הפעלה עם מעקב מושבת. ניתן להפעיל אותו בנקודת זמן מאוחרת יותר ב-
תוכנית על ידי שליחת האות SIGUSR2 לזמן הריצה. הרכבות מוגדרות על ידי
השם שלהם, למשל, כדי להתחקות אחר כל הקריאות במכלול המערכת, השתמש ב:

mono --trace=System app.exe

השיעורים מצוינים עם הקידומת T:. לדוגמה, כדי לעקוב אחר כל השיחות ל-
מחלקה System.String, השתמש ב:

mono --trace=T:System.String app.exe

ולשיטות בודדות יש התייחסות עם הקידומת M: והשיטה הסטנדרטית
סִמוּן:

mono --trace=M:System.Console:WriteLine app.exe

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

mono --trace=E:System.Exception app.exe

כפי שצוין בעבר, ניתן לציין כללים שונים בבת אחת:

mono --trace=T:System.String,T:System.Random app.exe

אתה יכול לא לכלול חלקים, הדוגמה הבאה עוקבת אחר קריאות ל-System.String למעט
שיטת System.String:Concat.

mono --trace=T:System.String,-M:System.String:Concat

אתה יכול לעקוב אחר מעברים מנוהלים לבלתי מנוהלים באמצעות מוקד המעטפת:

mono --trace=wrapper app.exe

לבסוף, ניתן לציין מרחבי שמות באמצעות הקידומת N::

mono --trace=N:System.Xml

--no-x86-stack-align
אל תיישר מסגרות מחסניות בארכיטקטורת x86. כברירת מחדל, מונו מיישר מחסנית
מסגרות ל-16 בתים ב-x86, כך שמשתנים מקומיים של נקודה צפה ומשתני SIMD
מיושרים כראוי. אפשרות זו מכבה את היישור, שבדרך כלל חוסכת אחת
הוראה לכל שיחה, אך עשויה לגרום לנקודה צפה נמוכה משמעותית ו
ביצועי SIMD.

--jitmap
צור מפת שיטת JIT בקובץ /tmp/perf-PID.map. לאחר מכן נעשה שימוש בקובץ זה, עבור
לדוגמה, על ידי כלי ה-perf שנכלל בליבת לינוקס עדכנית. כל שורה בקובץ
יש ל:

שם השיטה HEXADDR HEXSIZE

כרגע אפשרות זו נתמכת רק בלינוקס.

JIT שומר אפשרויות

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

--לשבור שיטה
הוספת נקודת עצירה לפני השיטה ששמה הוא `שיטה'
(namespace.class:methodname). השתמש ב-'Main' כשם השיטה כדי להוסיף עליה נקודת עצירה
השיטה העיקרית של האפליקציה. אתה יכול להשתמש בו גם עם תרופות גנריות, למשל
"System.Collections.Generic.Queue`1:Peek"

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

--לְלַקֵט שם
זה מהדר שיטה (namespace.name:methodname), זו משמשת לבדיקת ה
ביצועי מהדר או לבחון את הפלט של מחולל הקוד.

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

--graph=TYPE שיטה
זה יוצר קובץ postscript עם גרף עם הפרטים על המצוין
שיטה (namespace.name:methodname). זה דורש 'נקודה' ו-ghostview להיות
מותקן (הוא מצפה ש-Ghostview ייקרא "gv"). הגרפים הבאים הם
זמין:
cfg Control Flow Graph (CFG)
dtree Dominator Tree
קוד CFG המציג קוד
ssa CFG מציג קוד לאחר תרגום SSA
optcode CFG המציג קוד לאחר אופטימיזציות IR
גרפים מסוימים יהיו זמינים רק אם אופטימיזציות מסוימות מופעלות.

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

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

--wapi=hps|semdel
בצע תחזוקה של הנתונים המשותפים בתהליך. semdel תמחק את הגלובלי
סֵמָפוֹר. hps תפרט את נקודות האחיזה שבהן נעשה שימוש כעת.

-v, --מִלוּלִי
מגביר את רמת הדיבור, בכל פעם שהיא מופיעה ברשימה, מגביר את הדיבור
לכלול מידע נוסף (כולל, למשל, פירוק של
נוצר קוד מקורי, מידע על בורר קוד וכו').

לְצַרֵף תמיכה

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

עם תמיכה זו ניתן לטעון מכלולים שיש להם נקודת כניסה (הם
נוצר עם -target:exe או -target:winexe) לטעינה וביצוע בתהליך מונו.

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

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

פרופילינג

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

--profile[=profiler[:profiler_args]]

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

אם פרופיל לא צוין, נעשה שימוש ברירת המחדל של הפרופיל. ה profiler_args הוא
מחרוזת אפשרויות ספציפית ל-profiler עבור ה-profiler עצמו. ברירת המחדל של הפרופיל מקבל
האפשרויות הבאות 'להקצות' לפרופיל צריכת זיכרון על ידי האפליקציה; 'זמן ל
פרופיל הזמן המושקע בכל שגרה; 'jit' כדי לאסוף את הזמן המושקע בשיטות הידור של JIT
ו-'stat' כדי לבצע פרופיל סטטיסטי לדוגמה. אם לא ניתנות אפשרויות,
ברירת המחדל היא 'aloc,time,jit'.

כברירת מחדל, נתוני הפרופיל מודפסים ל-stdout: כדי לשנות זאת, השתמש ב-'file=filename'
אפשרות לפלט את הנתונים לשם הקובץ. לדוגמה:

mono --profile program.exe

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

mono --profile=default:stat,alloc,file=prof.out program.exe

יעשה פרופיל סטטיסטי לדוגמה ופרופיל הקצאות ב-program.exe. הפרופיל
נתונים מוכנסים לפרופ.אוט. שימו לב שלפרופיל הסטטיסטי יש תקורה נמוכה מאוד ו
צריך להיות הפרופיל המועדף לשימוש (לצורך פלט טוב יותר השתמש בנתיב המלא אל המונו
בינארי בעת הפעלתו וודא שהתקנת את כלי השירות addr2line שמגיע ממנו
חבילת binutils).

LOG מאפיין

זהו הפרופיל המתקדם ביותר.

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

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

מידע נוסף על אופן השימוש בפרופיל היומן זמין ב- דוח mprof(1)
.

המותאם אישית פרופילרים

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

כדי להשתמש בפרופיל צד שלישי, עליך להעביר את שם הפרופיל למונו, כך:

mono --profile=custom program.exe

בדוגמה לעיל Mono יטען את הפרופיל המוגדר על ידי המשתמש מהספרייה המשותפת
`mono-profiler-custom.so'. מודול פרופילי זה חייב להיות בספריית המקשר הדינמי שלך
נתיב.

רשימה של פרופילים אחרים של צד שלישי זמינה מאתר האינטרנט של מונו (www.mono-
project.com/docs/advanced/performance-tips/)

פרופילים מותאמים אישית נכתבים כספריות משותפות. הספרייה המשותפת חייבת להיקרא `מונו-
profiler-NAME.so' כאשר 'NAME' הוא השם של הפרופיל שלך.

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

CODE סיקור

מונו נשלח עם מודול כיסוי קוד. מודול זה מופעל באמצעות המונו
--profile=cov אפשרות. הפורמט הוא: --profile=cov[:שם-הרכבה[/namespace]] מִבְחָן-
suite.exe

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

mono --profile=cov:demo demo.exe

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

אתה יכול להגביל עוד יותר את פלט כיסוי הקוד על ידי ציון מרחב שמות:

mono --profile=cov:demo/My.Utilities demo.exe

מה שיבצע רק כיסוי קוד בהרכבה ובמרחב השמות הנתון.

פלט אופייני נראה כך:

לא מכוסה: Class:.ctor ()
לא מכוסה: Class:A ()
לא מכוסה: Driver:.ctor ()
לא מכוסה: דרייבר:שיטה ()
כיסוי חלקי: נהג:ראשי ()
היסט 0x000a

הקיזוזים המוצגים הם קיזוז IL.

כלי כיסוי חזק יותר זמין במודול `monocov'. ראה את monocov(1)
דף איש לפרטים.

פיתרון איידס

כדי לנפות באגים ביישומים מנוהלים, אתה יכול להשתמש ב- mdb command, מנפה באגים של שורת הפקודה.

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

kill -QUIT pid

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

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

השמיים --debug=casts ניתן להשתמש באפשרות כדי לקבל מידע מפורט יותר עבור Cast Invalid
פעולות, הוא יספק מידע על הסוגים המעורבים.

אתה יכול להשתמש במשתני הסביבה MONO_LOG_LEVEL ו-MONO_LOG_MASK כדי לקבל מילים
פלט ניפוי באגים לגבי ביצוע היישום שלך בתוך Mono.

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

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

השתמש MONO_LOG_MASK משתנה סביבה כדי להגביל את היקף ההודעות שאתה מקבל: אם
מוגדר, מסכת היומן משתנה לערך שנקבע. ערכים אפשריים הם "asm" (הרכבה
loader), "סוג", "dll" (מטעין ספרייה מקורית), "gc" (אספן אשפה), "cfg" (config
טוען קבצים), "aot" (מהדר מראש), "אבטחה" (למשל תמיכת Moonlight CoreCLR) ו-"הכל".
ערך ברירת המחדל הוא "הכל". שינוי ערך המסכה מאפשר לך להציג רק הודעות
עבור רכיב מסוים. אתה יכול להשתמש במספר מסכות על ידי הפרדת פסיק ביניהן. לדוגמה
כדי לראות הודעות קבצי תצורה והודעות מטעין הרכבה, הגדר את המסכה שלך ל-"asm,cfg".

להלן שימוש נפוץ למעקב אחר בעיות עם P/Invoke:

$ MONO_LOG_LEVEL="debug" MONO_LOG_MASK="dll" mono glue.exe

פיתרון עִם LLDB

אם אתה משתמש ב-LLDB, אתה יכול להשתמש ב- mono.py סקריפט להדפסת נתונים פנימיים
מבנים איתו. כדי להשתמש בזה, הוסף את זה לשלך $HOME/.lldbinit קובץ:
ייבוא ​​סקריפט פקודה $PREFIX/lib/mono/lldb/mono.py

כאשר $PREFIX הוא ערך הקידומת שבו השתמשת כשהגדרת את Mono (בדרך כלל / usr).

ברגע שזה נעשה, אז אתה יכול לבדוק כמה מבני נתונים של Mono Runtime, למשל:
(lldb) שיטת p

(MonoMethod *) $0 = 0x05026ac0 [mscorlib]System.OutOfMemoryException:.ctor()

סדרה

כברירת מחדל, מנוע ה-XML של Mono ישתמש בגישה מבוססת השתקפות
סדרה שעשוי להיות איטי עבור עיבוד מתמשך (יישומי שירות אינטרנט). ה
מנוע הסדרות יקבע מתי מחלקה חייבת להשתמש ב-Serializer מכוון ביד על בסיס
כמה פרמטרים ובמידת הצורך זה יפיק סדרה C# מותאמת לסוגים שלך
בזמן ריצה. סריאליזר מותאם אישית זה נטען באופן דינמי לתוך שלך
יישום.

אתה יכול לשלוט בזה עם משתנה הסביבה MONO_XMLSERIALIZER_THS.

הערכים האפשריים הם `לא' כדי לבטל את השימוש בסריאלייזר מותאם אישית של C#, או
מספר שלם שהוא המספר המינימלי של שימושים לפני זמן הריצה ייצור מותאם אישית
serializer (0 יפיק סדרה מותאמת אישית בגישה הראשונה, 50 יפיק א
סדרה בשימוש ה-50). מונו יחזור לסדרה מפורשת אם
יצירת סדרה נכשל איכשהו. ניתן להשבית התנהגות זו על ידי הגדרת האפשרות
'לא נפילה' (לדוגמה: MONO_XMLSERIALIZER_THS=0,nofallback).

הסביבה וריאציות

GC_DONT_GC
מכבה את איסוף האשפה במונו. זה אמור לשמש רק לניפוי באגים
למטרות

LVM_COUNT
כאשר מונו מורכב עם תמיכת LLVM, זה מורה לזמן הריצה להפסיק להשתמש
LLVM לאחר שמספר השיטות שצוין יעברו JITed. זהו כלי המשמש ב
אבחון כדי לסייע בבידוד בעיות ב-backend של יצירת הקוד. לדוגמה
LLVM_COUNT=10 ירכיב רק 10 שיטות עם LLVM ואז יעבור ל-Mono
מנוע JIT. LLVM_COUNT=0 ישבית את מנוע LLVM לחלוטין.

MONO_AOT_CACHE
אם הוגדר, משתנה זה ינחה את Mono לבצע קומפוזיציה מבעוד מועד על הרכבות חדשות
לדרוש ולאחסן את התוצאה במטמון ~/.mono/aot-cache.

MONO_ASPNET_INHIBIT_SETTINGSMAP
מונו מכיל תכונה המאפשרת לשנות הגדרות בקבצי .config
נשלח עם Mono על ידי שימוש במפות קטעי תצורה. הממפים והמיפויים
הכללים מוגדרים בקובץ $prefix/etc/mono/2.0/settings.map, ולחלופין, ב
קובץ settings.map שנמצא בספרייה ברמה העליונה של יישום ASP.NET שלך.
שני הקבצים נקראים על ידי System.Web בעת הפעלת היישום, אם הם נמצאים ב-
מיקומים מעל. אם אינך רוצה שהמיפוי יתבצע תוכל להגדיר זאת
משתנה בסביבה שלך לפני הפעלת היישום ולא תהיה שום פעולה
נלקח.

MONO_ASPNET_WEBCONFIG_CACHESIZE
ל-Mono יש מטמון של אובייקטי ConfigSection להאצת WebConfigurationManager
שאילתות. גודל ברירת המחדל שלו הוא 100 פריטים, וכאשר יש צורך בפריטים נוספים, שמור במטמון
פינויים מתחילים לקרות. אם פינויים הם תכופים מדי זה עלול לכפות
תקורה מיותרת, שניתן להימנע ממנה על ידי שימוש במשתנה סביבה זה
הגדר גודל מטמון גבוה יותר (או כדי להפחית את דרישות הזיכרון על ידי הקטנתו).

MONO_CAIRO_DEBUG_DISPOSE
אם מוגדר, גורם ל-Mono.Cairo לאסוף עקבות מחסנית כאשר אובייקטים מוקצים, אז
שהאזהרות הסופיות/סילוק כוללות מידע על זה של המופע
מָקוֹר.

MONO_CFG_DIR
אם מוגדר, משתנה זה עוקף את ספריית ברירת המחדל של תצורת המערכת
($PREFIX/etc). הוא משמש לאיתור קובץ machine.config.

MONO_COM
מגדיר את הסגנון של COM interop. אם הערך של משתנה זה הוא "MS" Mono ישתמש
מחרוזת שגרות מרהסלינג מה-liboleaut32 עבור הספרייה מסוג BSTR, כל
ערכים אחרים ישתמשו במחרוזת BSTR המובנית במונו.

MONO_CONFIG
אם מוגדר, משתנה זה עוקף את קובץ תצורת ברירת המחדל של זמן הריצה
($PREFIX/etc/mono/config). אפשרויות שורת הפקודה --config עוקפות את
משתנה הסביבה.

MONO_CPU_ARCH
לעקוף את מנגנון זיהוי המעבד האוטומטי. כרגע בשימוש רק על הזרוע. ה
פורמט הערך הוא כדלקמן:

"armvV [אגודל[2]]"

כאשר V הוא הארכיטקטורה מספר 4, 5, 6, 7 והאפשרויות יכולות להיות כרגע
"אגודל" או "אגודל2". דוגמא:

MONO_CPU_ARCH="armv4 thumb" מונו ...

MONO_ARM_FORCE_SOFT_FLOAT
כאשר מונו בנוי עם נפילת ציפה רכה ב-ARM והמשתנה הזה מוגדר ל
"1", מונו תמיד יפלוט קוד צף רך, גם אם מזוהה יחידת VFP.

MONO_DISABLE_AIO
אם מוגדר, אומר ל-mono NOT לנסות להשתמש בשירותי קלט/פלט אסינכרוני מקוריים. בתוך זה
במקרה, נעשה שימוש ביישום ברירת מחדל של בחירה/סקר. כרגע רק epoll() הוא
נתמך.

MONO_DISABLE_MANAGED_COLLATION
אם משתנה סביבה זה הוא 'כן', זמן הריצה משתמש באיסוף לא מנוהל (אשר
למעשה אין אוסף רגיש לתרבות). זה משבית באופן פנימי את הניהול
פונקציונליות איסוף המופעלת באמצעות החברים של System.Globalization.CompareInfo
מעמד. איסוף מופעל כברירת מחדל.

MONO_DISABLE_SHM
Unix בלבד: אם מוגדר, משבית את קובצי הזיכרון המשותפים המשמשים עבור נקודות אחיזה צולבות תהליכים:
לתהליך יש רק ידיות פרטיות. זה אומר שידיות תהליך וחוט הם
לא זמין לתהליכים אחרים, ושמות mutexes, names events and names
סמפורים אינם נראים בין תהליכים. ניתן להפעיל זאת גם על ידי
ברירת מחדל על ידי העברת האפשרות "--disable-shared-handles" להגדרה. זה
ברירת מחדל מ-mono 2.8 ואילך.

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

MONO_DNS
כאשר מוגדר, מאפשר שימוש בפותר DNS מנוהל במלואו במקום הרגיל
פונקציות libc. פותר זה מבצע ביצועים טובים בהרבה כאשר מופעלות מספר שאילתות
מַקְבִּיל.

שים לב כי /etc/nsswitch.conf יתעלם.

MONO_EGD_SOCKET
עבור פלטפורמות שאין להן דרך אחרת להשיג בתים אקראיים זה יכול
להיות מוגדר לשם של שקע מערכת קבצים שעליו נמצא דמון egd או prngd
הַקשָׁבָה.

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

MONO_ENV_OPTIONS
משתנה סביבה זה מאפשר לך להעביר ארגומנטים של שורת הפקודה ל-Mono
תהליך דרך הסביבה. זה שימושי למשל כדי לאלץ את כל שלך
מונו מעבד להשתמש ב-LLVM או SGEN ללא צורך בשינוי סקריפטים להפעלה.

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

MONO_EVENTLOG_TYPE
מגדיר את סוג ספק יומן האירועים לשימוש (עבור System.Diagnostics.EventLog).
ערכים אפשריים הם:

מקומי[:נתיב]
ממשיך יומני אירועים וכניסות למערכת הקבצים המקומית. הספרייה ב
אשר כדי להתמיד ניתן לציין את יומני האירועים, מקורות האירועים והערכים
כחלק מהערך. אם הנתיב אינו מוגדר במפורש, הוא כברירת מחדל
"/var/lib/mono/eventlog" ב-unix ו-"%APPDATA%no\ventlog" ב-Windows.

win32 אתה משתמש מה היא יליד win32 API ל לכתוב אירועים ו רושמים אירוע יומני ו אירוע
מקורות ברישום. זה זמין רק ב-Windows. ב-Unix, ה
הרשאת ספרייה עבור יומן אירועים בודדים וספריות מקור אירועים
מוגדר ל-777 (עם +t bit) המאפשר לכולם לקרוא ולכתוב יומן אירועים
ערכים תוך מתן אפשרות למחיקת ערכים על ידי המשתמש/ים בלבד
יצר אותם.

ריק משליך בשקט כל אירועים.

ברירת המחדל היא "null" ב-Unix (וגרסאות של Windows לפני NT), ו-"win32" פועלת
Windows NT (ומעלה).

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

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

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

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

גודל חדר ילדים=גודל
קובע את גודל חדר הילדים. הגודל מצוין בבתים וחייב להיות a
כוח של שניים. הסיומות 'k', 'm' ו-'g' יכולות לשמש כדי לציין קילו-,
מגה-וג'יגה-בייט, בהתאמה. המשתלה היא הדור הראשון (של
שתיים). פעוטון גדול יותר יזרז בדרך כלל את התוכנית, אך ברור שכך
להשתמש יותר בזיכרון. גודל חדר הילדים המוגדר כברירת מחדל 4 MB.

עיקרי=אספן מציין באיזה אספן מרכזי להשתמש.
האפשרויות הן 'marksweep' עבור אספן Mark&Sweep, ו-'marksweep-conc'
עבור Mark&Sweep במקביל. אספן Mark&Sweep שאינו במקביל הוא
ברירת המחדל.

soft-heap-limit=גודל
ברגע שגודל הערימה גדל מהגודל הזה, התעלם מהברירת המחדל העיקרית
מדד טריגר אוסף אומר ולאפשר רק ארבעה גדלים של חדר ילדים
צמיחת ערימה בין האוספים הגדולים.

פינוי-סף=סף
קובע את סף הפינוי באחוזים. אפשרות זו זמינה רק ב-
האספנים הגדולים של Mark&Sweep. הערך חייב להיות מספר שלם בטווח
0 עד 100. ברירת המחדל היא 66. אם שלב הסריקה של האוסף נמצא
שהתפוסה של סוג בלוק ערימה מסוים פחותה מזה
אחוז, הוא יבצע אוסף העתקה עבור סוג הבלוק הזה בקטע הבא
אוסף גדול, ובכך החזיר את התפוסה לקרוב ל-100 אחוז. א
ערך של 0 מכבה את הפינוי.

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

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

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

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

default-allowance-ratio=יחס
מציין את קצבת ההקצאה המוגדרת כברירת מחדל כאשר גם הגודל המחושב
קָטָן. קצבת ההקצאה היא כמה זיכרון שהאספן הניח להיות
מקודם לפני שהפעיל אוסף גדול. זה יחס של חדר הילדים
גודל. ערכים חוקיים הם בין 1.0 ל-10.0. ברירת המחדל היא 4.0. קטן יותר
ערכים מובילים לערמות קטנות יותר ולאוספים מרכזיים תכופים יותר. כְּמוֹ כֵן,
ערכים גדולים יותר יאפשרו לערימה לגדול מהר יותר, אך ישתמשו יותר בזיכרון כאשר היא
מגיע לגודל יציב. אפשרות זו היא ניסיוני, ולכן היא עלולה להיעלם
בגרסאות מאוחרות יותר של מונו.

קטין=אספן קטן
מציין באיזה אספן קטן להשתמש. האפשרויות הן 'פשוטות' מה שמקדם
כל החפצים מהמשתלה ישירות לדור הישן ו'מפוצל'
מה שמאפשר לחפץ להישאר זמן רב יותר בחדר הילדים לפני קידום.

alloc-ratio=יחס
מציין את היחס בין הזיכרון מחדר הילדים לשימוש במרחב ההקצאה.
זה יכול לשמש רק עם האספן הקטן המפוצל. ערכים חוקיים הם
מספרים שלמים בין 1 ל-100. ברירת המחדל היא 60.

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

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

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

מספר מגדיר את רמת ניפוי הבאגים למספר שצוין.

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

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

איסוף-לפני-מקצה

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

mod-union-consistency-check
בודק ש-mod-union cardtable עקבי לפני כל גימור
הפסקת איסוף גדולה. בדיקה זו חלה רק על רב-סרן במקביל
אספנים.

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

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

בדיקות xdomain
מבצע בדיקה כדי לוודא שלא נותרו אזכורים לפרק
AppDomain.

ברור-ב-tlab-creation
מנקה את חדר הילדים בהדרגה כאשר ההקצאה המקומית של השרשור מאחזת
(TLAB) נוצרים. הגדרת ברירת המחדל מנקה את כל חדר הילדים ב-GC
הזמן.

debug-clear-at-tlab-creation
מנקה את חדר הילדים בהדרגה כאשר ההקצאה המקומית של השרשור מאחזת
(TLAB) נוצרים, אבל בזמן GC ממלאים אותו ב-byte `0xff`, אשר
אמור לגרום לקריסה מהירה יותר אם `clear-at-tlab-creation` לא
לעבוד כמו שצריך.

clear-at-gc
זה מנקה את חדר הילדים בזמן GC במקום לעשות את זה כאשר השרשור מקומי
נוצר מאגר הקצאה (TLAB). ברירת המחדל היא לפנות את חדר הילדים ב
זמן יצירת TLAB.

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

disable-major
אל תעשה אוספים גדולים.

שמרני-מחסנית-סימן
מאלץ את ה-GC לסרוק את המחסנית באופן שמרני, גם אם יש סריקה מדויקת
זמין.

ללא מקצה מנוהל
משבית את המקצה המנוהל.

check-scan-starts
אם מוגדר, מבצע בדיקת סבירות ב-scan_starts לפני ואחרי כל אחד
אוסף

verify-nursery-at-minor-gc
אם מוגדר, מבצע הליכת חפצים מלאה בחדר הילדים בתחילת כל אחד
אוסף קטן.

מזבלה-משתלה-at-minor-gc
אם מוגדר, משליך את תכולת חדר הילדים בתחילת כל קטין
אוסף. נדרש להגדיר את verify-nursery-at-minor-gc.

ערימה-dump=פילה
משליך את תוכן הערימה לקובץ שצוין. כדי לדמיין את
מידע, השתמש בכלי mono-heapviz.

בינארי-פרוטוקול=פילה
מוציא את פלט ניפוי הבאגים לקובץ שצוין. כדי שזה יעבוד, מונו
צריך להיות קומפילד עם ההגדרה BINARY_PROTOCOL ב-sgen-gc.c. אתה יכול
לאחר מכן השתמש בפקודה זו כדי לחקור את הפלט
sgen-grep-binprot 0x1234 0x5678 < קובץ

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

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

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

MONO_GAC_PREFIX
מספק קידומת שבה זמן הריצה משתמש כדי לחפש מטמוני אסיפה גלובליים. מדריכים
מופרדים על ידי מפריד נתיב הפלטפורמה (נקודתיים ב-unix). MONO_GAC_PREFIX
צריך להצביע על הספרייה העליונה של התקנה עם קידומת. או למדריך
מסופק בפקודה gacutil /gacdir. דוגמא:
/home/username/.mono:/usr/local/mono/

MONO_IOMAP
מאפשר תמיכה כלשהי בשכתוב שמות קבצים כדי לסייע ליישומים שנכתבו בצורה גרועה
נתיבי Windows בקוד קשיח. הגדר לרשימה מופרדת בנקודתיים של "כונן" לפס כונן
אותיות, או "אותיות" כדי לבצע התאמת קבצים לא תלוית רישיות בכל ספרייה ב-a
נָתִיב. "הכל" מאפשר את כל שיטות השכתוב. (הלוכסים האחוריים תמיד ממופים ל
נטוי אם משתנה זה מוגדר לאפשרות חוקית).
לדוגמה, זה יעבוד מהמעטפת:

MONO_IOMAP=כונן:מארז
ייצא MONO_IOMAP

אם אתה משתמש ב-mod_mono כדי לארח את יישומי האינטרנט שלך, אתה יכול להשתמש ב- מונוIOMAP
הוראה במקום זאת, כך:

מונוIOMAP את כל

לִרְאוֹת mod_mono(8) לפרטים נוספים.

בנוסף. מונו כולל מודול פרופיל המאפשר לעקוב אחר מה
התאמות לנתיבי קבצים שקוד IOMAP צריך לעשות. קוד המעקב מדווח על
מיקום מנוהל (מעקב מחסנית מלאה) שממנו בוצעה השיחה עם IOMAP והלאה
process exit, המיקומים שבהם נוצרו כל מחרוזות IOMAP-ed במנוהלים
קוד. הדוח האחרון הוא משוער בלבד מכיוון שלא תמיד ניתן לעשות זאת
להעריך את המיקום בפועל שבו נוצרה המחרוזת. הקוד משתמש פשוט
היוריסטיקה - הוא מנתח עקבות מחסנית המובילה חזרה למיקום הקצאת המחרוזת
ומתעלם מכל הקוד המנוהל שחי במכלולים המותקנים גם ב-GAC
כמו בספריות הכיתה הנשלחות עם Mono (מכיוון שהן משוערות ללא
בעיות של רגישות רישיות). לאחר מכן הוא מדווח על המיקום הראשון בקוד המשתמש -
ברוב המקרים זה יהיה המקום שאליו מוקצה המחרוזת או קרוב מאוד אליו
המיקום. קוד הדיווח מיושם כמודול פרופיל מותאם אישית (ראה
סעיף "פרופילים") וניתן לטעון אותו בצורה הבאה:

mono --profile=iomap yourapplication.exe

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

MONO_LLVM
כאשר Mono משתמש בקצה האחורי של יצירת קוד LLVM אתה יכול להשתמש בסביבה זו
משתנה כדי להעביר אפשרויות יצירת קוד למהדר LLVM.

MONO_MANAGED_WATCHER
אם מוגדר ל"מושבת", System.IO.FileSystemWatcher ישתמש בצופה קבצים
יישום שמתעלם בשקט מכל בקשות הצפייה. אם מוגדר לאחד
ערך אחר, System.IO.FileSystemWatcher ישתמש ברירת המחדל המנוהלת
יישום (איטי). אם לא מוגדר, מונו ינסה להשתמש ב-inotify, FAM, Gamin, kevent
תחת מערכות Unix וקריאות API מקוריות ב-Windows, נופלים חזרה למנוהל
יישום על טעות.

MONO_MESSAGING_PROVIDER
מונו תומך במודל תוסף ליישום שלו של System.Messaging מה שהופך אותו
אפשר לתמוך במגוון יישומי הודעות (למשל AMQP, ActiveMQ).
כדי לציין באיזה מימוש הודעות יש להשתמש במשתנה evironement
צריך להגדיר את שם המחלקה המלא עבור הספק. למשל להשתמש ב- RabbitMQ
יישום AMQP מבוסס המשתנה צריך להיות מוגדר ל:

Mono.Messaging.RabbitMQ.RabbitMQMessagingProvider,Mono.Messaging.RabbitMQ

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

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

MONO_PATH
מספק נתיב חיפוש לזמן הריצה שבו לחפש ספרייה
קבצים. זהו כלי נוח לאיתור באגים ביישומים, אבל
לא אמור לשמש יישומים פרוסים מכיוון שהוא שובר את המכלול
מעמיס בדרכים עדינות.
ספריות מופרדות על ידי מפריד נתיב הפלטפורמה (נקודתיים ב-unix). דוגמא:
/home/username/lib:/usr/local/mono/lib
נתיבים יחסיים נפתרים על סמך הספרייה הנוכחית בזמן ההשקה.
פתרונות חלופיים ל-MONO_PATH כוללים: התקנת ספריות לתוך
מטמון האסיפה העולמית (ראה גאקוטיל(1)) או בעל התלויים
ספריות זו לצד זו עם קובץ ההפעלה הראשי.
לתיאור מלא של שיטות עבודה מומלצות ליישום
פריסה, ראה
http://www.mono-project.com/docs/getting-started/application-deployment/

MONO_RTC
תמיכת RTC נסיונית בפרופיל הסטטיסטי: אם יש למשתמש
ההרשאה, נאספים נתונים סטטיסטיים מדויקים יותר. ה-MONO_RTC
הערך חייב להיות מוגבל למה שה-Linux rtc מאפשר: כוח של שתיים
מ-64 עד 8192 הרץ. כדי לאפשר תדרים גבוהים יותר כמו 4096 הרץ, הפעל כשורש:

echo 4096 > /proc/sys/dev/rtc/max-user-freq

לדוגמה:

MONO_RTC=4096 mono --profiler=default:stat program.exe

MONO_SHARED_DIR
אם הגדר את הספרייה שבה מאוחסן מצב הידית ".wapi". זה
ספרייה שבה שכבת Windows I/O Emulation מאחסנת את נתוני המצב המשותפים שלה
(קבצים, אירועים, מוטקסים, צינורות). כברירת מחדל, Mono יאחסן את ספריית ".wapi".
בספריית הבית של המשתמשים.

MONO_SHARED_HOSTNAME
משתמש בערך המחרוזת של משתנה זה כתחליף לשם המארח when
יצירת שמות קבצים בספריית ".wapi". זה עוזר אם שם המארח שלך
סביר להניח שהמכונה תשתנה כאשר יישום מונו פועל או אם יש לך א
ספריית wapi משותפת בין מספר מחשבים שונים. מונו משתמש בדרך כלל ב-
שם מארח כדי ליצור את הקבצים המשמשים לשיתוף מצב על פני מונו מרובים
תהליכים. זה נעשה כדי לתמוך בספריות ביתיות שעשויות להיות משותפות דרך
רשת.

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

MONO_THEME
שם ערכת הנושא שישמש את Windows.Forms. נושאים זמינים היום כוללים
"clearlooks", "נחמד" ו-"win32". ברירת המחדל היא "win32".

MONO_TLS_SESSION_CACHE_TIMEOUT
הזמן, בשניות, שבו מטמון ההפעלה של SSL/TLS ישמור על הכניסה שלו כדי להימנע ממנו
משא ומתן חדש בין הלקוח לשרת. משא ומתן הם מאוד CPU
אינטנסיבי, כך שערך מותאם אישית ספציפי לאפליקציה עשוי להיות שימושי עבור קטנים
מערכות מוטמעות. ברירת המחדל היא 180 שניות.

MONO_THREADS_PER_CPU
המספר המינימלי של שרשורים במאגר השרשור הכללי יהיה
MONO_THREADS_PER_CPU * מספר מעבדים. ערך ברירת המחדל עבור משתנה זה הוא 1.

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

MONO_X509_REVOCATION_MODE
מגדיר את מצב הביטול המשמש בעת אימות שרשרת אישור X509 (https,
ftps, smtps...). ברירת המחדל היא 'nocheck', אשר לא מבצעת בדיקת ביטול ב
את כל. הערכים האפשריים האחרים הם 'לא מקוון', המבצע בדיקת CRL (לא
מיושם עדיין) ו-'online' שמשתמש ב-OCSP ו-CRL כדי לאמת את הביטול
סטטוס (עדיין לא מיושם).

הסביבה וריאציות עבור פיתרון

MONO_ASPNET_NODELETE
אם מוגדר לערך כלשהו, ​​קבצי מקור זמניים שנוצרו על ידי שיעורי תמיכה של ASP.NET
לא יוסר. הם יישמרו בספרייה הזמנית של המשתמש.

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

הפסקה-לא מאומת
אם משתנה זה מוגדר, כאשר ה-Mono VM נתקל בבעיית אימות,
במקום לזרוק חריג הוא יפרץ ל-debugger. זה
שימושי בעת איתור באגים בבעיות אימות

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

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

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

dyn-runtime-invoke
מורה לזמן הריצה לנסות להשתמש במעטפת גנרית להפעלת זמן ריצה במקום זאת
של יצירת מעטפת הפעלה אחת.

gdb שווה ערך להגדרת ה MONO_XDEBUG משתנה, זה פולט סמלים לתוך a
ספרייה משותפת שכן הקוד הוא JITed שניתן לטעון ל-GDB כדי לבדוק
סמלים.

gen-seq-points
יוצר אוטומטית נקודות רצף שבהן ערימת ה-IL ריקה. אלה
הם מקומות שבהם מאתר הבאגים יכול להגדיר נקודת שבירה.

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

ידית-סימן
לוכד את אות ההפסקה (Control-C) ומציג מעקב מחסנית כאשר
לחוץ. שימושי כדי לגלות היכן התוכנית מופעלת בזמן נתון
נְקוּדָה. זה מציג רק את עקבות הערימה של חוט בודד.

init-stacks
מורה לזמן הריצה לאתחל את המחסנית עם כמה ערכים ידועים (0x2a
ב-x86-64) בתחילתה של שיטה לסייע באיתור באגים במנוע JIT.

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

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

אין-gdb-backtrace
אפשרות זו תשבית את ה-GDB לאחור הנפלט על ידי זמן הריצה לאחר א
SIGSEGV או SIGABRT בקוד לא מנוהל.

suspend-on-sigsegv
אפשרות זו תשה את התוכנית כאשר יתקבל SIGSEGV מקורי.
זה שימושי עבור ניפוי באגים קריסות שאינן מתרחשות תחת gdb, שכן a
תהליך חי מכיל יותר מידע מאשר קובץ ליבה.

check-pinvoke-callconv
אפשרות זו גורמת לזמן הריצה לבדוק אי-התאמה של מוסכמות שיחות
בעת שימוש ב-pinvoke, כלומר ערבוב cdecl/stdcall. זה עובד רק על חלונות. אם
מזוהה אי התאמה, ExecutionEngineException נזרק.

MONO_LOG_LEVEL
רמת הרישום, ערכים אפשריים הם 'שגיאה', 'קריטית', 'אזהרה', 'הודעה',
'מידע' ו-'debug'. עיין בסעיף ניפוי באגים לפרטים נוספים.

MONO_LOG_MASK
שולט בדומיין של זמן הריצה המונו שעליו רישום הרישום יחול. אם מוגדר, ה
מסיכת יומן משתנה לערך שנקבע. ערכים אפשריים הם "asm" (מטעין הרכבה),
"סוג", "dll" (מטעין ספריות מקורי), "gc" (אספן אשפה), "cfg" (קובץ תצורה
מטעין), "aot" (מהדר מראש), "אבטחה" (למשל תמיכת Moonlight CoreCLR) ו
"את כל". ערך ברירת המחדל הוא "הכל". שינוי ערך המסכה מאפשר לך להציג
רק הודעות עבור רכיב מסוים. אתה יכול להשתמש במספר מסכות על ידי פסיק
מפריד ביניהם. למשל לראות הודעות קבצי תצורה ומטען assembly
הודעות מגדירות את המסכה שלך ל-"asm,cfg".

MONO_TRACE
משמש למעקב אחר זמן ריצה של קריאות לשיטה. הפורמט של המעקב המופרד בפסיק
האפשרויות הן:

[-]M:שם השיטה
[-]N:space name
[-]T:שם הכיתה
[-]את כל
[-]תכנית
מושבת פלט מעקב כבוי עם ההתחלה.

אתה יכול להפעיל/לכבות פלט עקבות שליחת אות SIGUSR2 לתוכנית.

MONO_TRACE_LISTENER
אם מוגדר, מפעיל את System.Diagnostics.DefaultTraceListener, אשר ידפיס את
פלט של מחלקות System.Diagnostics Trace and Debug. ניתן להגדיר אותו ל-a
שם הקובץ, ואל Console.Out או Console.Error כדי להציג פלט לפלט סטנדרטי
או שגיאת תקן, בהתאמה. אם הוא מוגדר ל-Console.Out או Console.Error לך
יכול להוסיף קידומת אופציונלית שתשמש בעת כתיבת הודעות כמו זה:
Console.Error:MyProgramName. עיין ב-System.Diagnostics.DefaultTraceListener
תיעוד למידע נוסף.

MONO_WCF_TRACE
זה מקל על פונקציונליות האבחון של WCF על ידי הפלט פשוט של כל הודעות היומן
מנוע WCF ל-"stdout", "stderr" או כל קובץ המועבר למשתנה סביבה זה.
פורמט היומן זהה לפלט האבחון הרגיל.

MONO_XEXCEPTIONS
זה משליך חריג כאשר נתקלת בשגיאה X11; כברירת מחדל הודעה היא
מוצג אך הביצוע ממשיך

MONO_XMLSERIALIZER_DEBUG
הגדר ערך זה ל-1 כדי למנוע מהסדרה להסיר את הקבצים הזמניים
שנוצרו להסדרה מהירה; זה עשוי להיות שימושי בעת איתור באגים.

MONO_XSYNC
זה משמש ביישום System.Windows.Forms כאשר הוא פועל עם ה-X11
אחורי. זה משמש לאיתור באגים ב-Windows.Forms מכיוון שהוא מאלץ את כל
פקודות נשלחות לשרת X11 שיבוצעו באופן סינכרוני. מצב ברירת המחדל של
הפעולה היא אסינכרונית מה שמקשה על בידוד השורש של מסוימות
בעיות.

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

את כל ניתן לשתף את כל הקוד שנוצר.

אוספים
רק לשיעורים ב-System.Collections.Generic הקוד שלהם משותף
(זהו ערך ברירת המחדל).

corlib רק קוד ב-corlib ישותף לקוד שלו.

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

MONO_XDEBUG
כאשר ה- MONO_XDEBUG env var מוגדר, נפלט מידע ניפוי באגים עבור קוד JITted
לתוך ספרייה משותפת, ניתנת לטעינה לתוך gdb. זה מאפשר, למשל, לראות מנוהלים
שמות מסגרת ב-gdb עקבות לאחור.

MONO_VERBOSE_METHOD
מאפשר את מידת המלל המקסימלית של JIT עבור השיטה שצוינה. זה מאוד מועיל
לאבחן בעיות קומפילציה של שיטה ספציפית.

MONO_VERBOSE_HWCAP
אם מוגדר, הופך את פלט JIT למידע על תכונות מעבד שזוהו (כגון SSE,
CMOV, FCMOV וכו') ל-stdout.

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

VALGRIND

אם אתה רוצה להשתמש ב-Valgrind, תמצא את הקובץ `mono.supp' שימושי, הוא מכיל את
דיכויים עבור ה-GC אשר מפעילים אזהרות שגויות. השתמש בזה כך:
valgrind --suppressions=mono.supp מונו ...

DTRACE

בפלטפורמות מסוימות, Mono יכול לחשוף קבוצה של בדיקות DTrace (הידוע גם בשם user-land
מוגדר סטטי, USDT Probes).

הם מוגדרים בקובץ `mono.d'.

ves-init-begin, ves-init-end
התחלה וסיום של אתחול זמן ריצה.

שיטה-הידור-התחל, שיטה-קומפילציה-סוף
התחלה וסיום של קומפילציה של השיטה. ארגומנטי הבדיקה הם שם מחלקה, שיטה
שם וחתימה, ובמקרה של הצלחה או כישלון של שיטה-קומפילציה
הַהדָרָה.

gc-begin, gc-end
התחלה וסיום של איסוף זבל.

כדי לאמת את זמינות הבדיקות, הפעל:
dtrace -P mono'$target' -l -c מונו

הרשאות

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

בתור root, הפעל את הפקודה הזו:
# setcap cap_net_raw=+ep /usr/bin/mono

השתמש במונו מקוון באמצעות שירותי onworks.net