distcc - מקוון בענן

תָכְנִית:

שֵׁם

distcc - מהדר C/C++/ObjC מבוזר עם הרחבות distcc-pump

תַקצִיר

distcc [מַהְדֵר אפשרויות]

distcc [מַהְדֵר אפשרויות]

[מַהְדֵר אפשרויות]

distcc [DISTCC אפשרויות]

תיאור

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

גרסה זו משלבת distcc רגיל וכן שיפור הנקרא pump mode or
distcc-משאבה.

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

ההידור מונע על ידי מחשב לקוח, שהוא בדרך כלל תחנת העבודה של המפתח
או מחשב נייד. לקוח distcc פועל על מחשב זה, וכך גם מייצר את המעבד המקדים (אם
לא נעשה שימוש במצב המשאבה של distcc), המקשר ושלבים אחרים של תהליך הבנייה. כל
מספר מכונות מתנדבים פועלות כשרתי קומפילציה ועוזרות ללקוח לבנות את
תוכנית, על ידי הפעלת ה distccd(1) daemon, מהדר C ו-assembler לפי הצורך.

distcc יכול לרוץ על פני שקעי TCP (ביציאה 3632 כברירת מחדל), או דרך מנהרה
פקודה כגון ssh(1). עבור חיבורי TCP על המתנדבים להפעיל את distccd(1) דמון
ישירות או מ-inetd. עבור חיבורי SSH יש להתקין distccd אבל צריך
לֹא להקשיב לחיבורים.

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

distcc מיועד לשימוש עם GNU Make's -j option, אשר מריץ כמה מהדרים
תהליכים במקביל. distcc מפזר את העבודות על פני מעבדים מקומיים ומרוחקים כאחד.
מכיוון ש- distcc מסוגל להפיץ את רוב העבודה ברחבי הרשת, גבוה יותר
ניתן להשתמש ברמת בו-זמנית מאשר עבור בנייה מקומית. ככלל אצבע, ה -j ערך
צריך להיות מוגדר בערך פי שניים מהמספר הכולל של מעבדי שרת זמינים אך בכפוף ל
מגבלות הלקוח. הגדרה זו מאפשרת שזירה מקסימלית של משימות שנחסמות
מחכה לדיסק או רשת IO. שים לב ש-distcc יכול לעבוד גם עם בקרת בנייה אחרת
כלים, כגון SCons, שבהם יש להתאים הגדרות מקבילות דומות.

אל האני -j הגדרה, במיוחד עבור ערכים גדולים של -י, חייב לקחת בחשבון את עומס המעבד
הלקוח. ייתכן שיהיה צורך באמצעים נוספים כדי לצמצם את עומס הלקוח. לדוגמה,
יש לצמצם באופן חמור את הקישור המקביל באמצעות מנעולי עזר. האפקט של
פעילות בנייה אחרת, כגון קומפילציה של Java בעת בניית קוד מעורב, צריכה להיות
נחשב. ה --localslots_cpp הפרמטר מוגדר כברירת מחדל ל-16. זה מגביל את
מספר תהליכים במקביל שעושים עיבוד מקדים במצב distcc רגיל (ללא משאבה).
לכן, גדול יותר -j ניתן להשתמש בערכים מ-16 מבלי להעמיס יתר על המידה על לקוח עם מעבד יחיד
עקב עיבוד מקדים. ערכים כה גדולים עשויים להאיץ חלקים מהבנייה שלא
כרוך בהידורי C, אך ייתכן שהם לא יהיו שימושיים ליעילות הדיסטcc במצב רגיל.

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

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

התחלה מהירה

1 עבור כל מחשב, הורד את distcc, פרק והתקן.

2 בכל אחד מהשרתים, הפעל distccd --דימון עם --להתיר אפשרויות להגביל
גישה אליו.

3 שים את שמות השרתים בסביבה שלך:
$ export DISTCC_HOSTS='localhost אדום ירוק כחול'

4 בנה!
$ make -j8 CC=distcc

התחלה מהירה עבור DISTCC-PUMP MODE

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

$ export DISTCC_HOSTS='--הזז באקראי localhost red,cpp,lzo green,cpp,lzo
כחול,cpp,lzo'

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

$ distcc-pump make -j20 CC=distcc

איך מישור (לא משאבה) DISTCC עבודות

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

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

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

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

איך DISTCC-PUMP MODE עבודות

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

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

לאחר מכן, המהדר מופעל מהנתיב בספריה הזמנית התואמת ל-
ספריית העבודה הנוכחית בלקוח. כדי למצוא ולשדר את מאות רבות של קבצים
שהם לרוב חלק מהידור בודד, מצב משאבה משתמש ב-incremental include
אלגוריתם ניתוח. שרת include היא תוכנית Python המיישמת זאת
אַלגוֹרִיתְם. הפקודה distcc-pump מפעילה את שרת include כך שלאורך כל ה-build
זה יכול לענות על שאילתות כוללות על ידי פקודות distcc.

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

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

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

הגבלות עבור משאבה MODE

שימוש במצב משאבה דורש הן מהלקוח והן מהשרתים להשתמש בגרסה 3.0 ואילך של distcc ו
distccd (בהתאמה).

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

הנחה חשובה נוספת היא שתצורת הכלול של כל המכונות חייבת להיות
זֵהֶה. לפיכך, הכותרות מתחת לנתיב מערכת ברירת המחדל חייבות להיות זהות בכל השרתים
וכל הלקוחות. אם נעשה שימוש בהתקנת מהדר סטנדרטית של GNU, אזי דרישה זו
חל על כל הספריות שקובצי הכותרות שלהן מותקנים תחת / usr / include or
/usr/local/include/. שים לב שהתקנת חבילות תוכנה מובילה לעתים קרובות לתוספת
קובצי כותרות ממוקמים בתיקיית משנה של אחד מהם.

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

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

ראה include_server(1) מדריך למידע נוסף על תסמינים וסיבות להפרות
של הנחות מצב distcc-pump.

אוֹפְּצִיָה סיכום

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

- עזרה מציג הוראות סיכום.

--גִרְסָה
מציג את גרסת לקוח distcc.

--מארחי מופעים
מציג את רשימת המארחים שבה ישתמש distcc. עיין בסעיף מפרטי מארח.

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

פלט הרשימה על ידי distcc --סריקה-כוללת יכיל ערך אחד בכל שורה. כל אחד
שורה מכילה קטגוריה ואחריה נתיב. הקטגוריה היא אחת של FILE, SYMLINK,
DIRECTORY, או SYSTEMDIR:

קובץ מציין קובץ מקור או קובץ כותרת שיישלח לשרת distcc
מנחה.

SYMLINK מציין קישור סמלי שיישלח למארח שרת distcc.

DIRECTORY מציין ספרייה שעשויה להיות נחוצה על מנת להרכיב את המקור
קוֹבֶץ. לדוגמה, ייתכן שיהיה צורך בספרייה "foo" בגלל הכללה של ה
טופס #include "foo/../bar.h". ספריות כאלה ייווצרו ב-distcc
מארח שרת.

SYSTEMDIR מציין מערכת include directory, כלומר ספרייה שנמצאת ב-
ברירת המחדל של המהדר כולל נתיב, כגון "/ usr / include"; ספריות כאלה הן
ההנחה היא להיות קיימת במארח שרת distcc, ולכן לא יישלח אל
מארח שרת distcc.

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

התקנה DISTCC

ישנן שלוש דרכים שונות לקרוא ל- distcc, כדי להתאים לנסיבות שונות:

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

ניתן להוסיף distcc לשורות פקודה מהדר, כגון "distcc cc -c hello.c"
או CC="distcc gcc". זה נוח כאשר אתה רוצה להשתמש ב-distcc רק עבור חלק
קומפילציות או לנסות את זה, אבל יכול לגרום לבעיות עם כמה קבצי makefile או
גרסאות של libtool המניחות ש-$CC אינו מכיל רווח.

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

זכור שאסור להשתמש בשתי שיטות לקריאה ל- distcc בו-זמנית. אם אתה
משתמשים בספריית מסכות, אל תשנה CC ו/או CXX, פשוט הכנס את הספרייה מוקדם
ב-PATH שלך. אם אינך משתמש בספריית מסיכות, תצטרך לשנות CC
ו/או CXX, או שנה את ה-makefile(ים) כדי לקרוא ל- distcc במפורש.

מסקר

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

לדוגמה:

# mkdir /usr/lib/distcc/bin
# cd /usr/lib/distcc/bin
# ln -s ../../../bin/distcc gcc
# ln -s ../../../bin/distcc cc
# ln -s ../../../bin/distcc g++
# ln -s ../../../bin/distcc c++

לאחר מכן, כדי להשתמש ב-distcc, משתמש רק צריך לשים את הספרייה /usr/lib/distcc/bin מוקדם יותר
ה-PATH, וקבעו רשימת מארח ב-DISTCC_HOSTS או קובץ. distcc יטפל ב
מנוחה.

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

אפשר לקבל "שגיאת רקורסיה" במצב masquerade, כלומר distcc הוא
איכשהו מוצא את עצמו שוב, לא את המהדר האמיתי. זה יכול להעיד שיש לך שניים
ספריות מסכות ב-PATH, אולי בגלל שיש שתי התקנות distcc
מיקומים שונים. זה גם יכול להצביע על כך שאתה מנסה לערבב "מסווה" ו
פעולה "מפורשת".

ניתן להימנע משגיאות רקורסיה על ידי שימוש בסקריפטים של מעטפת במקום קישורים. לדוגמה, ב
/usr/lib/distcc/bin צור קובץ cc המכיל:

#!/ Bin / sh
distcc /usr/bin/gcc "$@"

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

משתמש DISTCC עִם CCACHE

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

השיטה האמינה ביותר היא להגדיר

CCACHE_PREFIX="distcc"

זה אומר ל-ccache להפעיל את distcc בתור מעטפת סביב המהדר האמיתי. ccache עדיין משתמש
המהדר האמיתי כדי לזהות שדרוגי מהדר.

לאחר מכן ניתן להפעיל את ה-cache באמצעות ספריית masquerade or על פי הגדרה

CC="ccache gcc"

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

מצב המשאבה של distcc אינו תואם ל-cache.

HOST מפרט

"רשימת מארח" אומרת ל-distcc באילו מכונות להשתמש להידור. לפי הסדר, נראה distcc
ב $DISTCC_HOSTS משתנה סביבה, של המשתמש $DISTCC_DIR/מארחים הקובץ, ו-
קובץ מארח בכל המערכת. אם לא ניתן למצוא רשימת מארחים, distcc פולט אזהרה ומבצע קומפילציה
מקומית.

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

localhost אָדוֹם ירוק כָּחוֹל

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

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

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

ישנם שני שמות מארחים מיוחדים --localslots ו --localslots_cpp אשר מועילים עבור
התאמת עומס על המכונה המקומית. ה --localslots המארח מציין כמה משרות זה
לא ניתן להפעיל מרחוק שניתן להפעיל בו זמנית במחשב המקומי, while
--localslots_cpp שולט כמה מעבדי קדם יפעלו במקביל על המקומי
מְכוֹנָה. כוונון ערכים אלה יכול לשפר את הביצועים. קישור בפרויקטים גדולים יכול לקחת
כמויות גדולות של זיכרון. הפעלת קישורים מקבילים, שלא ניתן להפעיל מרחוק,
עלול לאלץ את המכונה להחליף, מה שמפחית את הביצועים על פני הפעלת המשימות בלבד
רצף ללא החלפה. קבלת מספר המעבדים המקבילים בדיוק כמו שצריך
מאפשר לך להשתמש בגורמים מקבילים גדולים יותר עם make, שכן למכונה המקומית יש כעת כמה
מנגנון למדידת שימוש במשאבים מקומיים.

לבסוף יש את ערך המארח

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

התחביר הוא

DISTCC_HOSTS = HOSTSPEC ...
HOSTSPEC = LOCAL_HOST | SSH_HOST | TCP_HOST | OLDSTYLE_TCP_HOST
| GLOBAL_OPTION
| ZEROCONF
LOCAL_HOST = מארח מקומי[/LIMIT]
| --localslots=
| --localslots_cpp=
SSH_HOST = [USER]@HOSTID[/LIMIT][:COMMAND][OPTIONS]
TCP_HOST = HOSTID[:PORT][/LIMIT][OPTIONS]
OLDSTYLE_TCP_HOST = HOSTID[/LIMIT][:PORT][OPTIONS]
מארח = שם מארח | IPV4 | IPV6
OPTIONS = ,OPTION[OPTIONS]
OPTION = lzo | cpp
GLOBAL_OPTION = --מזג באקראי
ZEROCONF = +zeroconf

הנה כמה דוגמאות בודדות של התחביר:

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

IPV6 כתובת IPv6 מילולית המוקפת בסוגריים מרובעים, כגון [::1]

IPV4 כתובת IPv4 מילולית, כגון 10.0.0.1

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

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

@HOSTID
התחבר למארח באמצעות SSH, במקום TCP. אפשרויות לחיבור SSH יכולות
להיות מוגדר ~ / .ssh / config

מִשׁתַמֵשׁ@ התחבר למארח באמצעות SSH כשם משתמש מוגדר.

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

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

,לזו מאפשר דחיסת LZO עבור מארח TCP או SSH זה.

,cpp מפעיל מצב distcc-pumpה עבור מארח זה. הערה: יש לעטוף את פקודת ה-build
הסקריפט distcc-pump על מנת להפעיל את שרת include.

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

+zeroconf
זֶה אוֹפְּצִיָה is רק זמין if distcc היה הידור עם אוואהי תמיכה מופעל at
להגדיר הזמן. כאשר ערך מיוחד זה קיים ברשימת המארחים, distcc יהיה
השתמש ב-Avahi Zeroconf DNS Service Discovery (DNS-SD) כדי לאתר כל distccd זמין
שרתים ברשת המקומית. זה מונע את הצורך לרשום במפורש את המארח
שמות או כתובות IP של מכונות שרת distcc. לשרתי distccd חייבים להיות
הופעל עם האפשרות "--zeroconf" ל- distccd. אזהרה חשובה היא
ביישום הנוכחי, מצב משאבה ("cpp") ודחיסה ("lzo") יהיו
לעולם לא ישמש עבור מארחים הממוקמים דרך zeroconf.

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

localhost/2 @bigman/16:/opt/bin/distccd מכונה ישנה: 4200/1
# קרטמן is מטה
מרוחק/3,לזו

הערות מותרות במפרטי המארח. הערות מתחילות בסימן חשיש/פאונד (#)
ולרוץ לסוף הקו.

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

דְחִיסָה

אל האני lzo אפשרות המארח מציינת שיש להשתמש בדחיסת LZO להעברת נתונים,
כולל מקור מעובד מראש, קוד אובייקט והודעות שגיאה. דחיסה היא בדרך כלל
חסכוני ברשתות איטיות מ-100Mbps, אך התוצאות עשויות להשתנות בהתאם לרשת,
מעבדים ועץ מקור.

הפעלת דחיסה גורמת ללקוח ולשרת distcc להשתמש יותר זמן מעבד, אבל פחות
תעבורת רשת. זמן המעבד הנוסף אינו משמעותי עבור מצב משאבה. הדחיסה
היחס הוא בדרך כלל 4:1 עבור מקור ו-2:1 עבור קוד אובייקט.

שימוש בדחיסה דורש הן מהלקוח והן מהשרת להשתמש לפחות בגרסה 2.9 של distcc.
אין צורך בתצורת שרת: השרת תמיד מגיב בתשובות דחוסות ל
בקשות דחוסות.

מצב משאבה דורש מהשרתים להפעיל את האפשרות lzo host.

לחפש שבילים

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

distcc /usr/local/bin/gcc-3.1415 -c שלום.ג

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

פסק זמן

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

לא ניתן להגדיר את פסק הזמן כרגע.

דיאגנוסטיקה

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

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

יְצִיאָה קודים

קוד היציאה של distcc הוא בדרך כלל זה של המהדר: אפס להידור מוצלח
ולא אפס אחרת.

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

אם המהדר יוצא עם אות, distcc מחזיר קוד יציאה של 128 פלוס האות
מספר.

שגיאות פנימיות distcc גורמות לקוד יציאה בין 100 ל-127. במיוחד

100 תקלה כללית בדיסק.

101 טיעונים רעים.

102 כריכה נכשלה.

103 החיבור נכשל.

104 מהדר קרס.

105 אזל הזיכרון.

106 מפרט מארח רע

107 I / O שגיאה

108 קצוץ.

שגיאת פרוטוקול 109.

110 המהדר הנתון לא נמצא במארח המרוחק. בדוק ש-$CC מוגדר
כראוי ושהוא מותקן בספריה בנתיב החיפוש עבור
distccd.

111 קריאה רקורסיבית ל- distcc.

112 נכשל בביטול ההרשאות.

113 הגישה לרשת נדחתה.

114 בשימוש בתהליך אחר.

115 אין קובץ כזה.

116 לא הוגדרו מארחים והחזרות נגרמות מושבתות.

118 פסק זמן.

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