זוהי הפקודה basl2cB שניתן להריץ בספק האירוח החינמי של OnWorks באמצעות אחת מתחנות העבודה המקוונות המרובות שלנו, כגון Ubuntu Online, Fedora Online, אמולטור מקוון של Windows או אמולטור מקוון של MAC OS
תָכְנִית:
שֵׁם
basl2c - ממירה קוד BASL (Batch Scheduling Language) לקוד מתזמן C.
תַקצִיר
basl2c [-d] [-l lexerDebugFile] [-p parserDebugFile] [-y symtabDebugFile] [-s
semanticDebugFile] [-g codegenDebugFile] [-c cFile] baslFile
תיאור
basl2c הוא מהדר BASL ל-C שמייצר קוד ביניים שניתן להזין לתוך a
מהדר C רגיל, ומקושר עם ספריות PBS כדי לייצר את קובץ ההפעלה של מתזמן.
Basl2c לוקח כקלט א baslFile, שהיא תוכנית שנכתבה בתזמון BAtch
שפה, המכילה את קוד התזמון הראשי. לאחר מכן Basl2c ממיר את מבני BASL
בקובץ לתוך הצהרות C, והוא גם מצרף קוד נוסף כדי לייצר את ה-PBS
קוד המקור של מתזמן. כברירת מחדל, קוד ה-C המתקבל נכתב בקובץ
pbs_sched.c.
שם הנתיב המלא לקובץ C שנוצר הוא מה שצריך לציין ב- SCHD_CODE
משתנה ב-local.mk לפני הידור של מתזמן BASL כדי לייצר את pbs_sched
הפעלה.
אפשרויות
-d מדפיס הודעות איתור באגים נוספות ל-lexer (ראה אפשרות -l), מנתח (ראה -p
אפשרות), טבלת סמלים (ראה אפשרות -y), מנתח סמנטי (ראה אפשרות -s) וקוד
מחולל (ראה אפשרות -g).
-l lexerDebugFile
lexerDebugFile הוא שם של קובץ לכתוב בהודעות איתור באגים שנוצרו
תוך כדי סריקה לאסימונים.
-p parserDebugFile
parserDebugFile הוא שם של קובץ לכתוב בהודעות איתור באגים שנוצרו
תוך חיבור אסימונים בצורה שמישה.
-y symtabDebugFile
symtabDebugFile הוא שם של קובץ לכתוב בהודעות איתור באגים הקשורות אליה
טבלת הסמלים.
-s semanticDebugFile
semanticDebugFile הוא שם של קובץ לכתוב בהודעות איתור באגים
נוצר תוך כדי בדיקה כדי לוודא שמשתנים ואופרטורים נמצאים בשימוש ב-a
דרך עקבית.
-g codegenDebugFile
codegenDebugFile הוא שם של קובץ לכתוב בהודעות איתור באגים שנוצרו
תוך המרת הצהרות BASL להצהרות C.
-c cFile
cFile הוא שם הקובץ שבו נכתב קוד C שנוצר.
רָאשִׁי מבנה
המבנה הבסיסי של קוד מתזמן הכתוב ב-BASL הוא כדלקמן:
אפס or יותר פונקציות הגדרות
אפס or יותר גלוֹבָּלִי מִשְׁתַנֶה הצהרות
אפס or יותר משימה הצהרות (ל לאתחל גלוֹבָּלִי משתנים)
sched_main()
{
אחד or יותר מִשְׁתַנֶה הצהרות
אפס or יותר הצהרות
}
לדוגמה,
% חתול sched.basl
Int sum(Int a, Int b)
{
Int s;
s = a + b;
החזרות);
}
Int גלוב;
sched_main()
{
Int c;
a = 3;
b = 4;
c = סכום(א, ב);
print(c);
גוש = 5;
print(glob);
}
sched_main() היא הפונקציה שנקראת בכל איטרציה של תזמון.
פונקציות
כדי להגדיר פונקציה שניתן לקרוא לה בפונקציות עוקבות, התחביר הוא:
ReturnType שם פונקציה ( DATATYPE1 IDENTIFIER1,
DATATYPE2 IDENTIFIER2, ... )
{
אחד or יותר מִשְׁתַנֶה הצהרות
אפס or יותר הצהרות
}
לדוגמה,
חלל ריק printStuff(Dayofweek דאו, תאריך שעה t, מחרוזת str,
מידה sz, CNode cn)
{
print(דאו);
print(t);
print(str);
print(sz);
print(cn);
}
פונקציה חוקית ReturnType הם: Void, Int, Float, Dayofweek, DateTime, String, Size,
Server, Que, Job, CNode, Set Server, Set Que, Set Job, Set CNode.
סוגי נתונים חוקיים ( DATATYPE1, DATATYPE2, ... ) עבור מזהי הפרמטרים הם: Int,
Float, Dayofweek, DateTime, String, Size, Server, Que, Job, CNode, Set Server, Set Que,
הגדר עבודה, הגדר CNNode, Range Int, Range Float, Range Dayofweek, Range DateTime, Range Size,
Fun Int, Fun Float, Fun Void, Fun Dayofweek, Fun DateTime, Fun String, Fun Size, Fun
שרת, Fun Que, Fun Job, Fun CNode, Fun Set Server, Fun Set Que, Fun Set Job, Fun Set
CNode. סוגי נתונים אלה יידונו בנושא הבא.
פונקציות מופעלות על ידי שמן והטיעונים שלהן כמו ב:
printStuff( יום שני, (5|1|1997@14:32:00), "לוח זמנים מתחיל",
30 ג'יגה-בייט, צומת );
basl2c למעשה יוסיף קידומת "basl_" לשם הפונקציה שניתן על ידי המתזמן
סופר כדי למזער את הסיכוי להתנגשות שמות, שעלולה להיגרם כאשר קוד C המתקבל הוא
מקושר לספריות PBS, BASL. לדוגמה, אם אתה מסתכל על קוד C שנוצר עבור
printStuff, אתה תראה,
basl_printStuff( MON, (5|1|1997@14:32:00),
"תזמון מתחיל", 30gb, node );
כמו ב-C, כל קריאות הפונקציה חייבות להיות מוגדרות קודם לכן. מהדר BASL יעשה זאת
בדוק כדי לוודא שהארגומנטים בקריאת הפונקציה תואמים בדיוק (במונחים של
types) עם הפרמטרים בהגדרת הפונקציה.
שני סוגים של פונקציות קיימים ב-BASL: פונקציות מוגדרות על ידי משתמש ופונקציות מוגדרות מראש.
פונקציות מוגדרות על ידי משתמש הן אלו שכותב המתזמן סיפק הגדרה עבורן,
בעוד שפונקציות מוגדרות מראש הן כאלו שניתן לקרוא אותן מיד ללא צורך בהן
מגדיר את זה. לרשימה של פונקציות מוגדרות מראש, ראה סעיף בנושא מוגדר מראש פונקציות .
מִשְׁתַנֶה הצהרות
כמו ב-C, יש להצהיר במפורש על כל המשתנים בקוד BASL לפני השימוש. הָהֵן
משתנים המוצהרים מחוץ לכל פונקציה מכונים משתנים גלובליים, while
משתנים המוצהרים בתוך גוף פונקציה נקראים משתנים מקומיים. גלוֹבָּלִי
משתנים ניתנים לשימוש בכל מקום בקוד BASL, בעוד שמשתנים מקומיים ניתנים לקריאה
רק במסגרת הפונקציה שממנה הם הוכרזו.
התחביר של הצהרת משתנה הוא:
סוג מידע מזהה ;
איפה סוג מידע יכול להיות: Int, Float, Dayofweek, DateTime, String, Size, Server, Que, Job,
CNode, Set Server, Set Que, Set Job, Set CNode, Range Int, Range Float, Range Dayofweek,
טווח תאריך זמן, גודל טווח.
נתונים סוג
חלל ריק משמש לפונקציות שאינן מחזירות ערך.
Int חתום, מספרים שלמים ניתנים בבסיס 10.
קבועים לדוגמא:
5, +1, -3, SUCCESS (=1), FAIL (=0), TRUE (=1), FALSE (=0)
לָצוּף מספרים ממשיים המיוצגים ככפולים בקוד C המתורגם.
קבועים לדוגמא: 4.3, +1.2, -2.6
יום בשבוע
ערכים קבועים: יום ראשון, שני, שלישי, ד', ה', שישי, שבת, מיוצג פנימי כ
קבועים בעלי ערך מספר שלם עם SUN=0, MON=1 וכן הלאה.
תאריך שעה
ציין באחד מ-3 פורמטים:
[1] (m|d|y) כאשר 1 <= m <= 12, 1 <= d <= 31, 0 <= y, למשל. (4|4|1997);
[2] (hh:mm:ss) כאשר 0 <= hh <= 23, 0 <= מ"מ <= 59, 0 <= ss <= 61, למשל.
(12:01:00);
[3] (m|d|y@hh:mm:ss), ex. (4|4|1997@12:01:00)
במהלך השוואת תאריכים/שעות, הזמן "עכשיו" מוחלף אם השעה
חלק לא ניתן (פורמט [1]); התאריך "עכשיו" מוחלף אם
חלק תאריך לא ניתן (פורמט [2]). כמו כן, חלק השנה המלא חייב
להינתן (כלומר 1997 במקום 97) בתאריכים כדי למנוע אי בהירות.
מחרוזת מחרוזת מוקפת במירכאות ("") והיא יכולה להכיל כל דבר מלבד אחר
ציטוט, שורה חדשה וסוגריים ימני ושמאלי.
קבועים לדוגמה: "מחרוזת דוגמה", NULLSTR
מידה פוּרמָט: כאשר הסיומת היא מכפיל של הצורה:
:
מכפיל יחידה (בתים or מילים)
=================== =====================
k,m,g,t,p,K,M,G,T,P b,B,w,W
כאשר k=K=1024, m=M=1,048,576, g=G=1,073,741,824, t=T=1,099,511,627,776,
p=P=1,125,899,906,842,624, b=B=1, וגודל המילה w=W מוגדר באופן מקומי (כלומר 4
בתים במכונת 32 סיביות).
כאשר פועלים על 2 אופרנדים בגודל שהם בעלי סיומות שונות, הסיומת של
ה"נמוך" מבין השניים יהיה הסיומת שנוצרת. לדוגמה,
10MB + 10GB = 10250mb
קבועים לדוגמה: -1b, 2w, 1kb, 2mw, +3gb, 4tw, 6Pb
טווח Int
פורמט: (ערך Int נמוך, ערך Int גבוה)
כאשר ערך Int נמוך <= ערך Int גבוה. קבוע מדגם: (1,3)
טווח לָצוּף
פורמט: (ערך צף נמוך, ערך צף גבוה)
כאשר ערך נמוך <= ערך גבוה. קבוע מדגם: (2.3, 4.6)
טווח יום בשבוע
פורמט: (יום מוקדם יותר, יום מאוחר יותר)
שבו מוקדם יותר היום <= היום מאוחר יותר. קבוע מדגם: (ד', ו')
טווח תאריך שעה
פורמט: (תאריך/שעה מוקדמים יותר, תאריך/שעה מאוחרים יותר)
כאשר תאריך/שעה מוקדם יותר <= תאריך/שעה מאוחרים יותר.
הערה: אם הטווח מכיל רק חלקי זמן, וזמן מוקדם יותר "מופיע" ל
להיות > זמן מאוחר יותר כמו ב"((18:0:0), (6:0:0))", ולאחר מכן במהלך התאריך/שעה
בהשוואות, הזמן ה"מאוחר יותר" יותאם ביום אחד כך שיהיה
נראה כמו: "( ( @18:0:0), ( @6:0:0) )"
קבועים לדוגמא:
((4|4|1997), (4|10|1997)), ((12:01:00), (12:30:00)), ((4|4|1997@12:01:00),
(4|10|1997@12:30:00))
טווח מידה
פורמט: (גודל נמוך, גודל גבוה)
כאשר מידה נמוכה <= מידה גבוהה. קבועים לדוגמא: (23gb, 50gb)
שרת מפות ישירות לאובייקט שרת PBS. א שרת מנהל אחד או יותר כי חפצים.
קבוע לדוגמא: NOSERVER
CNode עבור צומת חישובי המורכב מתמונת מערכת הפעלה אחת, זיכרון משותף וקבוצה
של מעבד. CNode מפעיל 1 PBS MOM.
קבוע מדגם: NOCNODE
כי מפות ישירות לאובייקט התור PBS. א כי אובייקט סליל אחד או יותר עבודה
חפצים.
קבוע מדגם: NOQUE
עבודה מפות ישירות לאובייקט העבודה של PBS. א עבודה אובייקט נושא כמה תכונות ו
דרישות משאבים.
קבוע מדגם: NOJOB
לקבוע שרת
רשימה של אובייקטי שרת.
קבוע לדוגמא: EMPTYSETSERVER
לקבוע CNode
רשימה של אובייקטי CNode.
קבוע לדוגמא: EMPTYSETCNODE
לקבוע כי רשימה של אובייקטים Que.
קבוע לדוגמא: EMPTYSETQUE
לקבוע עבודה רשימה של אובייקטי עבודה.
קבוע לדוגמא: EMPTYSETJOB
בסל-מוגדר קבועים
אלו הם קבועים שלא ניתן להשתמש בהם למתן שם למזהה (ראה את הנושא הבא). אלה
תמיד באותיות רישיות.
נתונים סוג בסל-מוגדר קָבוּעַ
=================== =============================================
יום בשבוע שמש, יום שני, יום שלישי, היינו עושים, ה', יום שישי, SAT
Int הַצלָחָה, לְהִכָּשֵׁל, FALSE, נָכוֹן, SYNCRUN, ASYNCRUN,
לִמְחוֹק, הפעלה חוזרת, לְהַחזִיק, לְשַׁחְרֵר, אוֹת,
MODIFYATTR, שינויים, SERVER_ACTIVE,
SERVER_IDLE, SERVER_SCHED, SERVER_TERM,
SERVER_TERMDELAY, QTYPE_E, QTYPE_R,
SCHED_DISABLED, SCHED_ENABLED, מַעֲבָר,
בתור, מוּחזָק, הַמתָנָה, רץ, יוצא,
CNODE_OFFLINE, CNODE_DOWN, CNODE_FREE,
CNODE_RESERVE, CNODE_INUSE_EXCLUSIVE,
CNODE_INUSE_SHARED, CNODE_TIMESHARED,
CNODE_CLUSTER, CNODE_UNKNOWN, OP_EQ, OP_NEQ,
OP_LE, OP_LT, OP_GE, OP_GT, OP_MAX, OP_MIN,
ASC DESC
שרת NOSERVER
לקבוע שרת EMPTYSETSERVER
CNode NOCNODE
לקבוע CNode EMPTYSETCNODE
כי NOQUE
לקבוע כי EMPTYSETQUE
עבודה אין עבודה
לקבוע עבודה ריקון עבודה
מחרוזת NULLSTR
מזהה
המזהים (המשמשים עבור שמות משתנים ושמות פונקציות) הם בפורמט אלפאנומרי, עם
תו הקו התחתון המיוחד (_) מותר. נכון לעכשיו, BASL יכול לטפל רק במזהים
עם אורך של עד 80 תווים. כמו כן, אינך יכול להשתמש בשמות הקבועים המוגדרים BASL עבור
מתן שם של מזהה.
הצהרות
In BASL(2), אתה יכול לקבל הצהרה בודדת שתסתיים על ידי נקודה-פסיק, או קבוצה של
הצהרות (הנקראות משפט מורכב או בלוק) המופרדות ב-'{' ו-'}'. השונה
סוגי הצהרות שיכולים להופיע בקוד BASL הם:
1. הצהרת ביטוי
הצהרות ביטוי הן כל צורה שהיא:
ביטוי ;
איפה ביטוי יכול להיות:
א) ביטויים אריתמטיים
lexpr + rexpr (לְהוֹסִיף)
lexpr - rexpr (להחסיר)
lexpr * rexpr (לְהַכפִּיל)
lexpr / rexpr (לחלק)
lexpr % rexpr (מודול or היתרה)
הערה: חיבור, חיסור, הכפל, חלוקה והשארה
יתאפשר רק לסוגים מתאימים ואם שמאל וימין
הביטויים הם מסוגים עקביים. הטבלה למטה ממחישה מה
הסוגים עקביים בין האופרטורים השונים:
עבור +:
lexpr rexpr
============ ============
Int or לָצוּף Int or לָצוּף
מידה מידה
מחרוזת מחרוזת
ל -, *, /:
lexpr rexpr
============ ============
Int or לָצוּף Int or לָצוּף
מידה מידה
ל %:
lexpr rexpr
============ ============
Int or לָצוּף Int or לָצוּף
להלן כמה משפטי ביטויים אריתמטיים לדוגמה:
Int i1;
Int i2;
לָצוּף f1;
לָצוּף f2;
מידה sz1;
מידה sz2;
מחרוזת str1;
מחרוזת str2;
i1 + i2;
f1 - i2;
szXNXX * szXNXX * 2b;
szXNXX / 1024b;
עמ' 1 = "באסל";
עמ' 2 = " מגניב";
// מה היא הבא is a מחרוזת שרשור
// מבצע וכתוצאה מכך in מה היא חוּט:
// "באזל מגניב"
עמ' 1 + str2;
i1 % 10;
b) ביטויים לא נראים
+ ביטוי // חיובי - מכפיל by 1 an
// ביטוי זֶה is
// of בינוני לָצוּף, or
// מידה סוג
-ביטוי // שלילי - מכפיל by -1 an
// ביטוי זֶה is
// of בינוני לָצוּף, or
// מידה סוג
! ביטוי // לֹא - המתגייר a לא אפס ביטוי
// ערך אל תוך 0, ו a
// אפס ביטוי ערך אל תוך 1
// איפה ביטוי סוג צריך be
// of סוג Int or לָצוּף
כמה ביטויים אונריים לדוגמה:
Int i;
+ 3;
-(אני + 4);
!אני;
c) ביטויים לוגיים
lexpr EQ rexpr
lexpr NEQ rexpr
lexpr LT rexpr
lexpr LE rexpr
lexpr GT rexpr
lexpr GE rexpr
lexpr ו rexpr
lexpr OR rexpr
lexpr ו rexpr חייב להיות סוגים העקבים הדדית כפי שמוצג
בטבלה הבאה:
lterminal-expr rterminal-expr
============== ==============
Int or לָצוּף Int or לָצוּף
יום בשבוע יום בשבוע
תאריך שעה תאריך שעה
מחרוזת מחרוזת
מידה מידה
שרת שרת
כי כי
עבודה עבודה
CNode CNode
לקבוע שרת לקבוע שרת
לקבוע כי לקבוע כי
לקבוע עבודה לקבוע עבודה
לקבוע CNode לקבוע CNode
בעד ו, OR מפעילים, ה lexpr, rexpr סוגים עקביים הם Int או
לָצוּף.
כמה ביטויים לוגיים לדוגמה:
i1 EQ i2;
i1 NEQ f2;
דאו1 LE דאו2;
d1 LT d2;
עמ' 1 GT str2;
szXNXX GE sz2;
d) ביטויים לאחר מפעיל
אלו הם ביטויים שהם רק קיצור דרך להקצאה
הצהרות.
IDENTIFIER++; // מזהה=מזהה+1
מזהה--; // מזהה=מזהה-1
מזהה חייב להיות מסוג Int או Float.
דוגמא:
Int i;
לָצוּף f;
i ++;
f--;
e) שיחת פונקציה
שם פונקציה ( arg1 ,arg2 ... , argN )
איפה arg1, ..., argN יכול להיות כל קבוע או משתנה. אתה לא יכול לקבל
קריאה נוספת לפונקציה כארגומנט.
דוגמא:
חלל ריק הדפס a) {
print(a);
}
pr(5);
ישנן פונקציות מסוימות מוגדרות מראש שכותב מתזמן יכול
התקשר אוטומטית לקוד ה-BASL שלו ללא צורך בהגדרתו.
פונקציות אלה מכונות פונקציות סיוע (או עוזר
פונקציות) והן נדונות תחת מוגדר מראש פונקציות נושא.
ו) קבועים
כמה ביטויים קבועים חוקיים ניתנים בקטע הבא:
5;
+ 1.2;
שמש;
יום שני;
TUE;
היינו עושים;
ה';
FRI;
ישב;
(4|4|1997);
(12:01:00);
(4|4|1997@12:01:00);
"נִפלָא";
-1b;
SYNCRUN;
ASYNCRUN;
לִמְחוֹק;
RERUN;
לְהַחזִיק;
לְשַׁחְרֵר;
אוֹת;
MODIFYATTR;
MODIFYRES;
(1, 3);
(2.3, 4.6);
(רביעי, ו');
((4|4|1997), (4|10|1997));
((12:01:00), (12:30:00));
((4|4|1997@12:01:00), (4|10|1997@12:30:00));
(23gb, 50gb);
NOSERVER;
NOCNODE;
NOQUE;
אין עבודה;
EMPTYSETSERVER;
EMPTYSETCNODE;
EMPTYSETQUE;
EMPTYSETJOB;
NULLSTR;
הַצלָחָה;
לְהִכָּשֵׁל;
SERVER_ACTIVE;
SERVER_IDLE;
SERVER_SCHED;
SERVER_TERM;
SERVER_TERMDELAY;
QTYPE_E;
QTYPE_R;
SCHED_DISABLED;
SCHED_ENABLED;
שֶׁקֶר;
אמת
מַעֲבָר;
בתור;
מוּחזָק;
הַמתָנָה;
רץ;
יציאה;
CNODE_OFFLINE;
CNODE_DOWN;
CNODE_FREE;
CNODE_RESERVE;
CNODE_INUSE_EXCLUSIVE;
CNODE_INUSE_SHARED;
CNODE_TIMESHARED;
CNODE_CLUSTER;
CNODE_UNKNOWN;
OP_EQ;
OP_NEQ;
OP_LE;
OP_LT;
OP_GE;
OP_GT;
OP_MAX;
OP_MIN;
ז) מזהה
דוגמא:
Int i;
i;
2. הצהרת משימה
מזהה = ביטוי ;
מזהה ו ביטוי חייב להיות סוגים העקביים הדדית כמו
מודגם בטבלה הבאה:
מזהה ביטוי
=============== ===============
Int בינוני לָצוּף
לָצוּף בינוני לָצוּף
יום בשבוע יום בשבוע
תאריך שעה תאריך שעה
מחרוזת מחרוזת
מידה מידה
כי כי
עבודה עבודה
CNode CNode
שרת שרת
יום בשבוע יום בשבוע
תאריך שעה תאריך שעה
לקבוע שרת לקבוע שרת
לקבוע כי לקבוע כי
לקבוע עבודה לקבוע עבודה
לקבוע CNode לקבוע CNode
טווח Int טווח Int
טווח לָצוּף טווח לָצוּף
טווח יום בשבוע טווח יום בשבוע
טווח תאריך שעה טווח תאריך שעה
טווח מידה טווח מידה
3. אחרת הצהרה
הפורמט של משפט if דומה לזה שב-C עם התוחם
"{" ו-"}" תמיד נוכחים:
אם ביטוי ) {
אפס or יותר (אמיתי) הצהרות
}
אם ביטוי ) {
אפס or יותר (אמיתי) הצהרות
} אחר {
אפס or יותר (שֶׁקֶר) הצהרות
}
אל האני ביטוי 's הסוג חייב להיות Int או Float, ולאחר הערכה אם זה
הערך אינו אפס, ואז ההצהרות האמיתיות מבוצעות. בשני
טופס, אם ה ביטוי מוערך לאפס, ואז ההצהרות השגויות מבוצעות.
מדגם כלשהו if להלן ההצהרות:
if (2 * x )
{
y = y + 3;
print(y);
}
if (2 * x ) {
y = y + 3;
} אחר {
אם 3 * x ) {
y = 4;
} אחר {
y = 5;
}
}
4. ל לולאה הצהרה
הפורמט של הצהרת for הוא כדלקמן:
עבור ( הַתחָלָה; הבדיקה; פעולה ) {
אפס or יותר הצהרות
}
בדיוק כמו ב-C, ל תחילה מבצע התחלה , לאחר מכן מעריך את מבחן מצב
כדי לראות אם הוא מחזיר ערך שאינו אפס. אם כן, ה ל הצהרות הן
יצא לפועל. לאחר ל הצהרות מבוצעות, אם כך פעולה מוערך,
ואז זה בודק את מבחן מצב שוב באותו אופן כמו קודם.
התחלה ו פעולה יכול להיות ביטוי פשוט של הקצאה או פוסט אופרטור
ביטוי. מבחן הוא ביטוי לוגי/יחסי. דוגמא כלשהי עבור
ההצהרות ניתנות בדברים הבאים:
ל (i = 0; i LT 3 ; i = i + 1)
{
print(i);
}
ל (i = 0; i LT 2 * x; i++)
{
if (x GT 3)
{
y = 99;
} אחר
{
x = 73;
}
}
5. foreach לולאה הצהרה
הצהרה זו משמשת בעיקר לאחזור ברציפות של כל רכיב של
a קבע סוג נתונים: הגדר שרת, הגדר CNode, הגדר עבודה, הגדר קו. התחביר הוא:
foreach ( מזהה 1 in מזהה 2 ) {
אפס or יותר הצהרות
}
כאשר ההתאמה הבאה של סוגים עבור המזהים מותרת:
מזהה 1 מזהה 2
=========== ===========
שרת לקבוע שרת
כי לקבוע כי
עבודה לקבוע עבודה
CNode לקבוע CNode
דוגמא:
שרת s;
כי q;
עבודה j;
CNode c;
לקבוע שרת ss;
לקבוע כי מ"ר;
לקבוע עבודה sj;
לקבוע CNode sc;
חזית (ים in ss){
הדפס(ים);
}
foreach(q in sq){
print(q);
}
foreach(j in sj){
print(j);
}
foreach (ג in sc){
print(c);
}
6. בזמן לולאה הצהרה
התחביר של לולאת while הוא:
בזמן ( ביטוי ) {
אפס or יותר הצהרות
}
איפה ביטוי חייב להיות מסוג Int או Float. אם ביטוי אינו אפס, ואז האפס
או יותר הצהרות מוצאים להורג ו ביטוי מוערך מחדש.
דוגמא:
Int i;
i = 3;
בזמן שאני) {
אם i EQ 0 ) {
print("break on i = 1");
לשבור;
}
i--;
}
7. להחליף הצהרה
הצהרת הבורר היא החלטה רב-כיוונית הבודקת אם א
הערך של המזהה תואם לאחד ממספר ערכים, ומסתעף ל-a
קבוצת הצהרות בהתאם.
התחביר עבור הצהרת switch הוא:
מתג ( מזהה ) {
מקרה קבוע-exp :
{
אפס or יותר הצהרות
}
מקרה קבוע-exp :
{
אפס or יותר הצהרות
}
...
מקרה in constant-rangeOrSet-expr :
{
אפס or יותר הצהרות
}
מקרה in IDENTIFIER-rangeOrSettype :
{
אפס or יותר הצהרות
}
ברירת מחדל :
{
אפס or יותר הצהרות
}
}
איפה קבוע-exp הוא ביטוי מסוג Int, Float, Dayofweek, DateTime,
Size, String, Server, Que, Job או CNode. constant-rangeOrSet-expr ו
IDENTIFIER-rangeOrSettype יכול להיות מסוג Set Server, Set CNode, Set Que, Set
עבודה, Range Int, Range Float, Range Dayofweek, Range DateTime או גודל טווח.
מזהה לא יכול להיות מסוג Void. מזהה 's הסוג חייב להיות עקבי
עם קבוע-exp של, constant-rangeOrSet-expr של, ו מזהה-
rangeOrSettype 's הקלד כפי שמוצג בטבלה הבאה:
מזהה טווח קבוע-expr, IDENTIFIER-טווח סוג
=========== =========================================
שרת לקבוע שרת
כי לקבוע כי
עבודה לקבוע עבודה
CNode לקבוע CNode
Int טווח Int
לָצוּף טווח לָצוּף
יום בשבוע טווח יום בשבוע
תאריך שעה טווח תאריך שעה
מידה טווח מידה
אם ביטוי מקרה תואם את מזהה 's ערך, ואז המתאים
בלוק של הצהרות מתבצע. שלא כמו ב-C, הביצוע לא נופל
לעבור להצהרת המקרה הבאה. הסיבה לכך היא basl2c יצטרך
תתרגם את זה להחליף הצהרה למבנה if-elseif-else. המקרה
ברירת מחדל שכותרתה מופעלת אם אף אחד מהמקרים האחרים לא מתקיים. ה
ברירת מחדל הוא אופציונלי; אם זה לא קיים, ואם אף אחד מהמקרים לא תואם, לא
מתרחשת פעולה.
דוגמא:
יום בשבוע דאו;
מתג (דאו)
{
מקרה שֶׁלִי:
{
print("case MON");
}
מקרה יום שלישי:
{
print("case TUE");
}
מקרה היינו עושים:
{
print("case היינו עושים");
}
מקרה אוסף:
{
print("case THU");
}
מקרה חינם:
{
print("case FRI");
}
מקרה ישב:
{
print("case ישב");
}
מקרה שמש:
{
print("case שמש");
}
ברירת מחדל:
{
print("case ברירת מחדל");
}
}
Int a;
טווח Int רי;
ri = (10, 12);
מתג (א)
{
מקרה in (1,5):
{
print("case 1,5");
}
מקרה in (6,9):
{
print("case 6,9");
}
מקרה in רי:
{
print("case רי");
}
}
8. הדפסה הצהרה
הצהרת הדפסה מסוגלת להדפיס כדי לעמוד על הערך של כל אחד מזהה
or קבוע מסוג Int, Float, Dayofweek, DateTime, String, Size, Que, Job,
CNode, Server, Range Int, Range Float, Range Dayofweek, Range DateTime,
גודל טווח.
התחביר הוא כדלקמן:
הדפסה ( מזהה );
הדפסה ( קבוע );
דוגמא:
תאריך שעה dt;
CNode cn;
dt = (4|4|1997@12:13:36);
cn = AllNodesLocalHostGet();
print(dt);
print(cn);
עבור סוגי סט, השתמש foreach לעבור על כל אלמנט ולהדפיס כמו ב:
שרת s;
לקבוע שרת ss;
ss = AllServersGet();
חזית (ים in ss) {
הדפס(ים);
}
9. המשך בהצהרה
להמשיך ;
אל האני להמשיך הצהרה חייבת להיות מופעלת בתוך a ל, לכל אחד, ו
בזמן לוּלָאָה. זה גורם לאיטרציה הבאה של הלולאה המקיפה להתחיל.
10. הצהרת הפסקה
לשבור ;
אל האני לשבור הצהרה חייבת להיות מופעלת בתוך a ל, לכל אחד, ו בזמן
לוּלָאָה. הוא מספק יציאה מוקדמת מהלולאה הסוגרת.
11. הצהרת החזרה
return(IDENTIFIER) ;
החזר (קבוע) ;
לַחֲזוֹר() ;
הצהרת ההחזרה מספקת את הערך (אם יש) שיוחזר על ידי א
פוּנקצִיָה. הסוג שהוחזר על ידי מזהה ו קבוע חייב להתאים את
קורא לסוג ההחזרה של הפונקציה. קבוע הסוגים המותרים הם הכל מלבד
סוגי סט וטווחים. הפורמט האחרון, לַחֲזוֹר() נקרא בדרך כלל בתוך a
פונקציה שלא מחזירה שום ערך (כמו sched_main() ).
12. הצהרת יציאה
יציאה (קבוע);
איפה קבוע הוא מסוג Int. קריאה לזה תגרום לביטול המתזמן.
13. הערה
אלו הן הצהרות עם קידומת "//" וה-BASL מתעלם מהן
מהדר.
// זֶה קו is התעלם
Int i; // מחרוזת הבא מה היא חתכים is התעלם
מַפעִיל עֲדִיפוּת ו אסוציאטיביות
הטבלה הבאה מציגה את רמות קדימות האופרטור והאסוציאטיביות השונות שהוגדרו
בשפת BASL. המפעילים רשומים בסדר העדיפויות יורד. ה
קדימות אופרטור גבוהה יותר, ככל שהוא מבוצע מוקדם יותר. הסדר שבו ה
אופרטורים באותה רמה מבוצעים תלוי באסוציאטיביות: שמאל פירושו
אופרטורים נראים משמאל לימין, בעוד ימין פירושו שהם נראים מימין לשמאל.
מַפעִיל אסוציאטיביות
======================================= =============
! ++ -- + (לא אחד ועוד) - (לא אחד מִינוּס) תקין
* / % עזבו
+ - עזבו
LT LE GT GE עזבו
EQ NEQ עזבו
ו עזבו
OR עזבו
= תקין
מוגדר מראש פונקציות
In BASL(2), ל שרת סוג נתונים ממפה ישירות לאובייקט שרת אצווה. באופן דומה, CNode
זה לאמא/רמוסום, עבודה הוא עבודה אצווה, ו כי זה לתור אצווה. עם זאת, לא כולם
ניתן לגשת לתכונות לאובייקטי PBS מ-BASL. רק תת-קבוצה של תכונות,
אלה שנראו הגיוניים בהקשר של מתזמן, זמינים ו
ניתן לגשת לערכים של תכונות אלו על ידי קריאה לפונקציות המוגדרות מראש הבאות,
ידוע גם כפונקציות סיוע/עזר.
(1) פונקציות הקשורות לשרת
לקבוע שרת AllServersGet(void)
מחזירה את רשימת השרתים שצוינו בקובץ התצורה עבור
מה שכותב המתזמן רוצה שהמערכת תבדוק מעת לעת
סטטוס, תורים ומידע על משרות. לִרְאוֹת pbs__sched__basl(8 ב) עבור
דיון על הפורמט של קובץ התצורה.
זהירות: יש לקרוא לפונקציה זו מבפנים sched_main() so
שבכל איטרציה של תזמון, הכי עדכני לקבוע שרת
המבנה מוחזר.
שרת AllServersLocalHostGet(void)
מחזירה את אובייקט השרת המייצג את המארח המקומי. ערך לא מוגדר:
NOSERVER. זוהי פונקציה פשוטה לקריאה עבור סביבות שאינן אשכולות
שבו קיים רק מארח שרת אחד.
זהירות: יש לקרוא לפונקציה זו מבפנים sched_main() (או מ
בתוך פונקציה שנקראת על ידי sched_main) כך שבכל תזמון
איטרציה, המעודכנת ביותר שרת המבנה מוחזר.
מחרוזת ServerInetAddrGet(שרת s)
מחזירה שם עבור שרתים. ערך לא מוגדר: NULLSTR
מחרוזת ServerDefQueGet(שרת s)
מחזירה את תכונת default_queue של שרתים. ערך לא מוגדר: NULLSTR
Int ServerStateGet(שרת s)
מחזיר את תכונת server_state של Server s.
ערך החזרה:
SERVER_ACTIVE, SERVER_IDLE, SERVER_SCHED, SERVER_TERM,
SERVER_TERMDELAY, -1 (ערך לא מוגדר)
Int ServerMaxRunJobsGet(שרת s)
מחזיר את תכונת max_running של s Server. ערך לא מוגדר: 0
Int ServerMaxRunJobsPerUserGet(Server s)
מחזיר את תכונת max_user_run של שרתים. ערך לא מוגדר: 0
Int ServerMaxRunJobsPerGroupGet(Server s)
מחזיר את תכונת max_group_run של שרתים. ערך לא מוגדר: 0
לקבוע כי ServerQueuesGet(שרת s)
מחזירה רשימה של תורים המנוהלים על ידי שרתים.
לקבוע עבודה ServerJobsGet(שרת s)
מחזיר רשימה של משרות המנוהלות על ידי Server s. להשגת תת-קבוצה של זה
רשימה, ראה QueJobsGet().
Int ServerIntResAvailGet(שרת s, מחרוזת שֵׁם)
מחזירה את הערך למשאב שצוין ב שם זה זמין לעבודות
מופעל על ידי שרת זה (שרת resources_available.name תְכוּנָה). תקרא לזה
פונקציה עבור משאבים עם ערכים מסוג Int. משאב לדוגמא
השמות הם: cput, pcput, walltime, mppt, pmppt, nice, procs, mppe, ncpus,
pncpus, nodect, srfs_assist, mta,..., mth. לתיאור של אלה
שמות משאבים, ראה pbs_resources_irix5(7B), pbs_resources_sp2(7B),
pbs_resources_sunos4(7B), pbs_resources_unicos8(7B),
pbs_server_attributes(7B), pbs_resources_irix6(7B),
pbs_resources_linux(7 ב).
דוגמא:
Int cpuAvail;
// לַחֲזוֹר מה היא # of מעבד כַּיוֹם זמין in
// מה היא שרת
cpuAvail = ServerIntResAvailGet(שרת, "ncpus");
מידה ServerSizeResAvailGet(שרת s, מחרוזת שֵׁם)
מחזירה את הערך למשאב שצוין ב שם זה זמין לעבודות
מופעל על ידי שרת זה (שרת resources_available.name תְכוּנָה). תקרא לזה
פונקציה עבור משאבים עם ערכים מסוג Size. משאב לדוגמא
השמות הם: file, mem, pmem, workingset, pf, ppf, srfs_tmp, srfs_wrk,
srfs_big, srfs_fast, sds, psds. לתיאור של משאבים אלה
שמות, ראה pbs_resources_irix5(7B), pbs_resources_sp2(7B),
pbs_resources_sunos4(7B), pbs_resources_unicos8(7B),
pbs_server_attributes(7B), pbs_resources_irix6(7B),
pbs_resources_linux(7 ב).
דוגמא:
מידה memAvail;
// לַחֲזוֹר מה היא כמות of זמין זיכרון in
// מה היא שרת
memAvail = ServerSizeResAvailGet(שרת, "מ");
מחרוזת ServerStringResAvailGet(שרת s, מחרוזת שֵׁם)
מחזירה את הערך למשאב שצוין ב שם זה זמין לעבודות
מופעל על ידי שרת זה (שרת resources_available.name תְכוּנָה). תקרא לזה
פונקציה עבור משאבים עם ערכים שהם מסוג String. לִטעוֹם
שמות המשאבים הם: צמתים, קשת, צמתים. לתיאור של אלה
שמות משאבים, ראה pbs_resources_irix5(7B), pbs_resources_sp2(7B),
pbs_resources_sunos4(7B), pbs_resources_unicos8(7B),
pbs_server_attributes(7B), pbs_resources_irix6(7B),
pbs_resources_linux(7 ב).
דוגמא:
מחרוזת סוג;
// לַחֲזוֹר מה היא ארכיטקטורה (אוֹ os סוּג) of
// מה היא שרת
סוג = ServerStringResAvailGet(שרת, "קֶשֶׁת");
Int ServerIntResAssignGet(שרת s, מחרוזת שֵׁם)
מחזירה את הערך למשאב שצוין ב שם שמוקצה ל
הפעלת עבודות (שרת resources_assigned.name תְכוּנָה). תקרא לזה
פונקציה עבור משאבים עם ערכים מסוג Int. משאב לדוגמא
השמות הם: cput, pcput, walltime, mppt, pmppt, nice, procs, mppe, ncpus,
pncpus, nodect, srfs_assist, mta,..., mth. לתיאור של אלה
שמות משאבים, ראה pbs_resources_irix5(7B), pbs_resources_sp2(7B),
pbs_resources_sunos4(7B), pbs_resources_unicos8(7B),
pbs_server_attributes(7B), pbs_resources_irix6(7B),
pbs_resources_linux(7 ב).
דוגמא:
Int cpuAssn;
// לַחֲזוֹר מה היא # of מעבד כַּיוֹם שהוקצה in
// מה היא שרת
cpuAssn = ServerIntResAssignGet(שרת, "ncpus");
מידה ServerSizeResAssignGet(שרת s, מחרוזת שֵׁם)
מחזירה את הערך למשאב שצוין ב שם שמוקצה ל
הפעלת עבודות (שרת resources_assigned.name תְכוּנָה). תקרא לזה
פונקציה עבור משאבים עם ערכים מסוג Size. משאב לדוגמא
השמות הם: file, mem, pmem, workingset, pf, ppf, srfs_tmp, srfs_wrk,
srfs_big, srfs_fast, sds, psds. לתיאור של משאבים אלה
שמות, ראה pbs_resources_irix5(7B), pbs_resources_sp2(7B),
pbs_resources_sunos4(7B), pbs_resources_unicos8(7B),
pbs_server_attributes(7B), pbs_resources_irix6(7B),
pbs_resources_linux(7 ב).
דוגמא:
מידה sdsAssn;
// לַחֲזוֹר מה היא כמות of Sds שטח כַּיוֹם שהוקצה
// in מה היא שרת
sdsAssn = ServerSizeResAssignGet(שרת, "sds");
מחרוזת ServerStringResAssignGet(Server s, מחרוזת שֵׁם)
מחזירה את הערך למשאב שצוין ב שם שמוקצה ל
הפעלת עבודות (שרת resources_assigned.name תְכוּנָה). תקרא לזה
פונקציה עבור משאבים עם ערכים שהם מסוג String. לִטעוֹם
שמות המשאבים הם: צמתים, קשת, צמתים. לתיאור של אלה
שמות משאבים, ראה pbs_resources_irix5(7B), pbs_resources_sp2(7B),
pbs_resources_sunos4(7B), pbs_resources_unicos8(7B),
pbs_server_attributes(7B), pbs_resources_irix6(7B),
pbs_resources_linux(7 ב).
לקבוע CNode ServerNodesGet(שרת s)
מחזירה את קבוצת הצמתים המנוהלת על ידי s שרתים. ערך לא מוגדר: EMPTYSETCNODE.
הערה: בדרך כלל ניתן לקרוא לפונקציות הבאות עבור הצמתים המוחזרים
על ידי קריאה זו: CNodeStateGet(), CNodePropertiesGet() ו-CNodeTypeGet().
Int ServerNodesQuery(Server s, מחרוזת מפרט)
מוציא בקשה לשרת שצוין כדי לשאול את זמינותו של
משאבים המפורטים ב מפרט נכון לעכשיו, המשאב היחיד
המפרט המותר הוא כזה הכולל "צמתים" והוא יכול להיות של
פורמט "nodes", "nodes=" או "nodes= ". תוצאות השאילתה יכולות להיות
גישה אליו על ידי קריאה לפונקציות הבאות: ServerNodesNumAvailGet(),
ServerNodesNumAllocGet(), ServerNodesNumRsvdGet(),
ServerNodesNumDownGet().
הערה: זוהי עטיפה ל pbs_rescquery(3B) פונקציית שרת.
ערך החזרה:
הצלחה, נכשל
Int ServerNodesNumAvailGet(שרת s)
מחזירה את מספר הצמתים הזמינים עבור אלו המנוהלים על ידי המצוין
שרת, או כפי שמשתקף מהשאילתה העדכנית ביותר שצוינה על ידי
ServerNodesQuery(). אם ערך ההחזר הוא אפס, זה אומר ש
מספר מסוים של צמתים הדרוש כעת כדי לספק את המפרט של
ServerNodesQuery() אינם זמינים כעת. הבקשה אולי נענתה
במועד מאוחר יותר. אם התוצאה שלילית, אין שילוב של ידוע
צמתים יכולים לעמוד במפרט.
Int ServerNodesNumAllocGet(שרת s)
מחזירה את מספר הצמתים שהוקצו לאלו המנוהלים על ידי המצוין
שרת, או כפי שמשתקף מהשאילתה העדכנית ביותר שצוינה על ידי
ServerNodesQuery().
Int ServerNodesNumRsvdGet(שרת s)
מחזירה את מספר הצמתים השמורים לאלו המנוהלים על ידי המצוין
שרת, או כפי שמשתקף מהשאילתה העדכנית ביותר שצוינה על ידי
ServerNodesQuery().
Int ServerNodesNumDownGet(שרת s)
מחזירה את מספר הצמתים למטה עבור אלו המנוהלים על ידי המצוין
שרת, או כפי שמשתקף מהשאילתה העדכנית ביותר שצוינה על ידי
ServerNodesQuery().
Int ServerNodesReserve(שרת s, מחרוזת spec, Int resId)
מוציא בקשה לשרת שצוין לשמור את המשאבים
צוין ב מפרט ערך של 0 עבור resId אומר שזה בשביל לעשות א
הזמנה חדשה. אחרת, המספר ייצג קיים
הסתייגות (חלקית). משאבים שמורים כרגע לכך resId יצטרך
ישוחרר וההזמנה המלאה תבוצע שוב. ב
בזמן הנוכחי המשאבים היחידים שניתן לציין הם
"צמתים". יש לציין זאת כ צמתים=מפרט איפה
מפרט הוא מה שמשתמש מציין ברשימת הארגומנטים -l option
לצמתים, ראה qsub (1B).
הערה: זוהי עטיפה ל pbs_rescreserve(3B) פונקציית שרת.
ערך החזרה:
מספר סימוכין למצליח או מוצלח חלקית
הזמנה, או נכשל
Int ServerNodesRelease(Server s, Int resId)
זה משחרר או משחרר משאבים השמורים עם מספר האסמכתה
צוין ב resId.
הערה: זוהי עטיפה ל pbs_recrelease(3B) פונקציית שרת.
ערך החזרה:
הצלחה, או נכשל
(2) פונקציות הקשורות ל-Que:
מחרוזת QueNameGet( כי כי )
מחזיר את השם של Que que. ערך לא מוגדר: NULLSTR
Int QueTypeGet( כי כי )
מחזירה את התכונה queue_type של Que que.
ערך החזרה: QTYPE_E (ביצוע), QTYPE_R (ניתוב), -1 (לא מוגדר
ערך)
Int QueNumJobsGet( כי כי )
מחזירה מספר משרות המתגוררות ב-Que que. ערך לא מוגדר: 0
Int QueMaxRunJobsGet( כי כי )
מחזיר את התכונה max_running של Que que. ערך לא מוגדר: 0
Int QueMaxRunJobsPerUserGet( כי כי )
מחזיר את התכונה max_user_run של Que que. ערך לא מוגדר: 0
Int QueMaxRunJobsPerGroupGet( כי כי )
מחזיר את התכונה max_group_run של Que que. ערך לא מוגדר: 0
Int QuePriorityGet( כי כי )
מחזיר את תכונת העדיפות של Que que. ערך לא מוגדר: 0
Int QueStateGet( כי כי )
תכונת החזרה התחילה של Que que - בחירת ביצוע העבודה
מצב ה-que: SCHED_DISABLED, SCHED_ENABLED. ערך לא מוגדר:
SCHED_DISABLED
לקבוע עבודה QueJobsGet( כי כי )
מחזירה את רשימת המשרות המתגוררות כעת ב-que.
Int QueIntResAvailGet(Que q, מחרוזת שֵׁם)
מחזירה את הערך למשאב שצוין ב שם שעומד לרשות
משרות הפועלות מהש' הזה (Que resources_available.name תְכוּנָה).
קרא לפונקציה זו עבור משאבים עם ערכים מסוג Int.
שמות משאבים לדוגמה הם: cput, pcput, walltime, mppt, pmppt, nice,
procs, mppe, ncpus, pncpus, nodect, srfs_assist, mta,..., mth. למשך
תיאור של שמות משאבים אלה, ראה pbs_resources_irix5(7B),
pbs_resources_sp2(7B), pbs_resources_sunos4(7B),
pbs_resources_unicos8(7B), pbs_server_attributes(7B),
pbs_resources_irix6(7B), pbs_resources_linux(7 ב).
מידה QueSizeResAvailGet(Que q, מחרוזת שֵׁם)
מחזירה את הערך למשאב שצוין ב שם שעומד לרשות
משרות הפועלות מהש' הזה (Que resources_available.name תְכוּנָה).
קרא לפונקציה זו עבור משאבים עם ערכים מסוג Size.
שמות משאבים לדוגמה הם: file, mem, pmem, workingset, pf, ppf,
srfs_tmp, srfs_wrk, srfs_big, srfs_fast, sds, psds. לתיאור
של שמות משאבים אלה, ראה pbs_resources_irix5(7B),
pbs_resources_sp2(7B), pbs_resources_sunos4(7B),
pbs_resources_unicos8(7B), pbs_server_attributes(7B),
pbs_resources_irix6(7B), pbs_resources_linux(7 ב).
מחרוזת QueStringResAvailGet(Que q, מחרוזת שֵׁם)
מחזירה את הערך למשאב שצוין ב שם שעומד לרשות
משרות הפועלות מהש' הזה (Que resources_available.name תְכוּנָה).
קרא לפונקציה זו עבור משאבים עם ערכים מסוג String.
שמות משאבים לדוגמה הם: צמתים, קשת, צמתים. לתיאור
של שמות משאבים אלה, ראה pbs_resources_irix5(7B),
pbs_resources_sp2(7B), pbs_resources_sunos4(7B),
pbs_resources_unicos8(7B), pbs_server_attributes(7B),
pbs_resources_irix6(7B), pbs_resources_linux(7 ב).
Int QueIntResAssignGet(Que q, מחרוזת שֵׁם)
מחזירה את הערך למשאב שצוין ב שם שמוקצה ל
משימות הפועלות מהתור הזה (Que resources_assigned.name תְכוּנָה).
קרא לפונקציה זו עבור משאבים עם ערכים מסוג Int.
שמות משאבים לדוגמה הם: cput, pcput, walltime, mppt, pmppt, nice,
procs, mppe, ncpus, pncpus, nodect, srfs_assist, mta,..., mth. למשך
תיאור של שמות משאבים אלה, ראה pbs_resources_irix5(7B),
pbs_resources_sp2(7B), pbs_resources_sunos4(7B),
pbs_resources_unicos8(7B), pbs_server_attributes(7B),
pbs_resources_irix6(7B), pbs_resources_linux(7 ב).
מידה QueSizeResAssignGet(Que q, מחרוזת שֵׁם)
מחזירה את הערך למשאב שצוין ב שם שמוקצה ל
משרות הפועלות מהש' הזה (Que resources_assigned.name תְכוּנָה).
קרא לפונקציה זו עבור משאבים עם ערכים מסוג Size.
שמות משאבים לדוגמה הם: file, mem, pmem, workingset, pf, ppf,
srfs_tmp, srfs_wrk, srfs_big, srfs_fast, sds, psds. לתיאור
של שמות משאבים אלה, ראה pbs_resources_irix5(7B),
pbs_resources_sp2(7B), pbs_resources_sunos4(7B),
pbs_resources_unicos8(7B), pbs_server_attributes(7B),
pbs_resources_irix6(7B), pbs_resources_linux(7 ב).
מחרוזת QueStringResAssignGet(Que q, מחרוזת שֵׁם)
מחזירה את הערך למשאב שצוין ב שם שמוקצה ל
משרות הפועלות מהש' הזה (Que resources_assigned.name תְכוּנָה).
קרא לפונקציה זו עבור משאבים עם ערכים מסוג String.
שמות משאבים לדוגמה הם: צמתים, קשת, צמתים. לתיאור
של שמות משאבים אלה, ראה pbs_resources_irix5(7B),
pbs_resources_sp2(7B), pbs_resources_sunos4(7B),
pbs_resources_unicos8(7B), pbs_server_attributes(7B),
pbs_resources_irix6(7B), pbs_resources_linux(7 ב).
(3) פונקציות הקשורות לתפקיד
מחרוזת JobIdGet( עבודה עבודה )
מחזיר את מזהה העבודה של משימת העבודה. ערך לא מוגדר: NULLSTR
מחרוזת שם עבודה קבל( עבודה עבודה )
מחזיר את התכונה Job_Name של משימת העבודה. ערך לא מוגדר: NULLSTR
מחרוזת JobOwnerNameGet( עבודה עבודה )
מחזיר את התכונה Job_Owner של משימת העבודה. ערך לא מוגדר: NULLSTR
מחרוזת JobEffectiveUserNameGet( עבודה עבודה)
מחזירה תכונה euser של משימת עבודה.
מחרוזת JobEffectiveGroupNameGet(Job עבודה)
מחזיר את תכונת egroup של משימת עבודה. ערך לא מוגדר: NULLSTR
Int JobStateGet ( עבודה עבודה )
מחזירה את תכונת העבודה_מצב של משימת העבודה.
ערך החזרה:
מעבר, תור, מוחזק, ממתין, רץ, יציאה, -1 (לא מוגדר
ערך)
Int JobPriorityGet( עבודה עבודה )
מחזירה את תכונת העדיפות של משימת העבודה. ערך לא מוגדר: 0
Int JobRerunFlagGet( עבודה עבודה )
מחזירה תכונה ניתנת להרצה של משימת עבודה.
ערך החזרה: FALSE, TRUE, -1 (ערך לא מוגדר)
Int JobInteractiveFlagGet( עבודה עבודה )
מחזירה תכונה אינטראקטיבית של משימת עבודה.
ערך החזרה: FALSE, TRUE. ערך לא מוגדר: FALSE
תאריך שעה JobDateTimeCreatedGet(Job עבודה)
מחזירה את תכונת ctime של Job job. ערך לא מוגדר:
(0|0|0@-1:-1:-1)
מחרוזת JobEmailAddrGet( עבודה עבודה )
מחזירה את התכונה Mail_Users של משימת העבודה. ערך לא מוגדר: NULLSTR
מחרוזת JobStageinFilesGet( עבודה עבודה )
מחזירה את תכונת stagein של Job Job. ערך לא מוגדר: NULLSTR
מחרוזת JobStageoutFilesGet( עבודה עבודה )
מחזיר את תכונת השלב של משימת העבודה. ערך לא מוגדר: NULLSTR
Int JobIntResReqGet(Job עבודה, מחרוזת שֵׁם)
מחזירה את הערך למשאב שצוין ב שם כנדרש על ידי
עבודה (עבודה Resource_List.name תְכוּנָה). קרא לפונקציה זו עבור
משאבים עם ערכים מסוג Int. שמות משאבים לדוגמה
הם: cput, pcput, walltime, mppt, pmppt, nice, procs, mppe, ncpus,
pncpus, nodect, srfs_assist, mta,..., mth. לתיאור של אלה
שמות משאבים, ראה pbs_resources_irix5(7B), pbs_resources_sp2(7B),
pbs_resources_sunos4(7B), pbs_resources_unicos8(7B),
pbs_server_attributes(7B), pbs_resources_irix6(7B),
pbs_resources_linux(7 ב).
דוגמא:
Int cputReq;
// החזרות מה היא cput דרישה of מה היא עבודה
cputReq = JobIntResReqGet(job, "cput");
מידה JobSizeResReqGet(Job עבודה, מחרוזת שֵׁם)
מחזירה את הערך למשאב שצוין ב שם כנדרש על ידי
עבודה (עבודה Resource_List.name תְכוּנָה). קרא לפונקציה זו עבור
משאבים עם ערכים מסוג גודל. שמות משאבים לדוגמה
הם: file, mem, pmem, workingset, pf, ppf, srfs_tmp, srfs_wrk,
srfs_big, srfs_fast, sds, psds. לתיאור של משאבים אלה
שמות, ראה pbs_resources_irix5(7B), pbs_resources_sp2(7B),
pbs_resources_sunos4(7B), pbs_resources_unicos8(7B),
pbs_server_attributes(7B), pbs_resources_irix6(7B),
pbs_resources_linux(7 ב).
דוגמא:
מידה memReq;
// החזרות מה היא זיכרון דרישה of מה היא עבודה
memReq = JobSizeResReqGet(job, "מ");
מחרוזת JobStringResReqGet(Job עבודה, מחרוזת שֵׁם)
מחזירה את הערך למשאב שצוין ב שם כנדרש על ידי
עבודה (עבודה Resource_List.name תְכוּנָה). קרא לפונקציה זו עבור
משאבים עם ערכים מסוג String. שמות משאבים לדוגמה
הם: צמתים, קשת, צמתים. לתיאור של משאבים אלה
שמות, ראה pbs_resources_irix5(7B), pbs_resources_sp2(7B),
pbs_resources_sunos4(7B), pbs_resources_unicos8(7B),
pbs_server_attributes(7B), pbs_resources_irix6(7B),
pbs_resources_linux(7 ב).
דוגמא:
מחרוזת צמתים;
// החזרות מה היא צמתים דרישה רכוש of
// מה היא עבודה
צמתים = JobStringResReqGet(job, "צמתים");
Int JobIntResUseGet(Job עבודה, מחרוזת שֵׁם)
מחזירה את הערך למשאב שצוין ב שם המשמשת את העבודה (איוב
resources_used.name תְכוּנָה). קרא לפונקציה זו עבור משאבים עם
ערכים מסוג Int. שמות משאבים לדוגמה הם: cput, pcput,
walltime, mppt, pmppt, nice, procs, mppe, ncpus, pncpus, nodect,
srfs_assist, mta,..., mth. לתיאור של שמות משאבים אלה,
לִרְאוֹת pbs_resources_irix5(7B), pbs_resources_sp2(7B),
pbs_resources_sunos4(7B), pbs_resources_unicos8(7B),
pbs_server_attributes(7B), pbs_resources_irix6(7B),
pbs_resources_linux(7 ב).
דוגמא:
Int walltUse;
// החזרות מה היא כמות of זמן קיר מְשׁוּמָשׁ by
// מה היא עבודה
walltUse = JobIntResUseGet(job, "walltime");
מידה JobSizeResUseGet(Job עבודה, מחרוזת שֵׁם)
מחזירה את הערך למשאב שצוין ב שם המשמשת את העבודה (איוב
resources_used.name תְכוּנָה). קרא לפונקציה זו עבור משאבים עם
ערכים שהם מסוג גודל. שמות משאבים לדוגמה הם: קובץ, mem,
pmem, workingset, pf, ppf, srfs_tmp, srfs_wrk, srfs_big, srfs_fast,
sds, psds. לתיאור של שמות משאבים אלה, ראה
pbs_resources_irix5(7B), pbs_resources_sp2(7B),
pbs_resources_sunos4(7B), pbs_resources_unicos8(7B),
pbs_server_attributes(7B), pbs_resources_irix6(7B),
pbs_resources_linux(7 ב).
דוגמא:
מידה srfsUse;
// החזרות מה היא כמות of srfs_מהיר מְשׁוּמָשׁ by
// מה היא עבודה
srfsUse = JobSizeResUseGet(job, "srfs_fast");
מחרוזת JobStringResUseGet(Job עבודה, מחרוזת שֵׁם)
מחזירה את הערך למשאב שצוין ב שם המשמשת את העבודה (איוב
resources_used.name תְכוּנָה). קרא לפונקציה זו עבור משאבים עם
ערכים שהם מסוג String. שמות משאבים לדוגמה הם: צמתים,
קשת, צמתים. לתיאור של שמות משאבים אלה, ראה
pbs_resources_irix5(7B), pbs_resources_sp2(7B),
pbs_resources_sunos4(7B), pbs_resources_unicos8(7B),
pbs_server_attributes(7B), pbs_resources_irix6(7B),
pbs_resources_linux(7 ב).
(4) פונקציות הקשורות ל-CNode
לקבוע CNode AllNodesGet(void)
מחזירה רשימה של צמתים המנוהלים על ידי השרת הפועל ב-
מארח מקומי. זה יכול לכלול גם את אותם צמתים שצוינו
בקובץ התצורה של המתזמן שעבורו כותב המתזמן
רוצה שהמערכת תבדוק מעת לעת מידע כמו מצב,
רכוש וכן הלאה. לִרְאוֹת pbs_sched_basl(8 ב) לדיון ב
פורמט קובץ תצורה.
זהירות: יש לקרוא לפונקציה זו מבפנים sched_main() so
שבכל איטרציה של תזמון, הכי עדכני לקבוע CNode
המבנה מוחזר. אל תקרא לזה מתוך הצהרת משימה
נועד לאתחל משתנה גלובלי, כפי שההצהרה תעשה זאת בלבד
להיקרא פעם אחת.
CNode AllNodesLocalHostGet(void)
מחזירה את האובייקט CNode המייצג את המארח המקומי. זה
פונקציה פשוטה לקריאה עבור מערכות לא מקובצות שבהן רק 1 CNode
קיים. ערך לא מוגדר: NOCNODE
זהירות: יש לקרוא לפונקציה זו מבפנים sched_main() (אוֹ
מתוך פונקציות שנקראות על ידי sched_main) כך שבכל
איטרציה בתזמון, המעודכנת ביותר CNode מבנה הוא
חזר. אל תקרא לזה מתוך הצהרת משימה שנועדה
אתחול משתנה גלובלי, כפי שהמשפט ייקרא רק
פַּעַם.
מחרוזת CNodeNameGet(CNode צוֹמֶת)
מחזירה את השם הייחודי (הרשמי) של הצומת (כלומר שם מארח ResMom
במודל של אמא/צומת אחת). זה מחזיר את אותה מחרוזת שהייתה
שצוין בקובץ התצורה. ערך לא מוגדר: NULLSTR
מחרוזת CNodeOsGet(CNode צוֹמֶת)
מחזירה את ארכיטקטורת מערכת ההפעלה של הצומת (כלומר "irix5", "sp2"). לא מוגדר
ערך: NULLSTR
Int CNodeStateGet( CNode צומת )
מחזירה את מצב הצומת.
ערך החזרה:
CNODE_OFFLINE, CNODE_DOWN, CNODE_FREE, CNODE_RESERVE,
CNODE_INUSE_EXCLUSIVE, CNODE_INUSE_SHARED, CNODE_UNKNOWN
Int CNodeTypeGet( CNode צומת )
מחזירה את סוג הצומת.
ערך החזרה:
CNODE_TIMESHARED, CNODE_CLUSTER, CNODE_UNKNOWN
מחרוזת CNodePropertiesGet(CNode צוֹמֶת)
מחזירה את הרשימה המופרדת בפסיקים של שמות אחרים שהצומת מוכר לפיהם
(מאפיינים, שם רשת אחר). לדוגמה,
"babbage.OpenPBS.org" אולי שם הצומת, אבל אפשר גם לדעת אותו
דרך "babbage1, babage2". ערך לא מוגדר: NULLSTR
מחרוזת CNodeVendorGet(CNode צוֹמֶת)
מחזירה את שם הספק עבור החומרה של המכונה (כלומר
"sgi", "ibm"). ערך לא מוגדר: NULLSTR
Int CNodeNumCpusGet(CNode צוֹמֶת)
מחזירה את מספר המעבדים המחוברים לצומת. ערך לא מוגדר:
-1
מידה CNodeMemTotalGet( CNode צוֹמֶת, מחרוזת סוג )
מחזירה זיכרון כולל של סוג עבור הצומת. סוג הוא שרירותי
מחרוזת שכותב המתזמן מגדיר בלוח הזמנים
קובץ תצורה. ערך לא מוגדר: -1b
דוגמא:
// לקבל סה"כ גופני זיכרון
CNodeMemTotalGet(צומת, "אמיתי")
// לקבל סה"כ וירטואלי זיכרון
CNodeMemTotalGet(צומת, "וירטואלי")
מידה CNodeMemAvailGet( CNode צוֹמֶת, מחרוזת סוג )
מחזיר זיכרון זמין של סוג עבור הצומת. סוג הוא שרירותי
מחרוזת שכותב המתזמן מגדיר בלוח הזמנים
קובץ תצורה. ערך לא מוגדר: -1b
אז שיחות לדוגמה יהיו:
// לקבל זמין גופני זיכרון
CNodeMemAvailGet(צומת, "אמיתי")
// לקבל זמין וירטואלי זיכרון
CNodeMemAvailGet(צומת, "וירטואלי")
Int CNodeIdletimeGet( CNode צומת )
מחזירה מספר שניות שבהן אין הקשה או תנועת עכבר
התרחש בכל טרמינל המחובר לצומת. ערך לא מוגדר: -1
לָצוּף CNodeLoadAveGet( CNode צומת )
מחזירה את ממוצע העומס של הצומת עבור כל המעבדים. ערך לא מוגדר: -1.0
Int CNodeCpuPercentIdleGet( CNode צומת )
מחזירה את אחוז זמן הסרק של כל המעבדים של הצומת
חוו.
Int CNodeCpuPercentSysGet( CNode צומת )
מחזירה את אחוז הזמן שיש לכל המעבדים של הצומת
בילה בהפעלת קוד ליבה.
Int CNodeCpuPercentUserGet( CNode צומת )
מחזירה את אחוז הזמן שיש לכל המעבדים של הצומת
בילה בהפעלת קוד משתמש.
Int CNodeCpuPercentGuestGet( CNode צומת )
מחזירה את אחוז הזמן שיש לכל המעבדים של הצומת
בילה בהפעלת מערכת הפעלה אורחת.
Int CNodeNetworkBwGet( CNode צוֹמֶת, מחרוזת סוג )
מחזירה את רוחב הפס של רשת הצומת של סוג בבתים/שנייה.
סוג מוגדר על ידי כותב המתזמן בלוח הזמנים
קובץ תצורה. ערך לא מוגדר: -1
כמה שיחות לדוגמה הן:
CNodeNetworkBwGet( צוֹמֶת, "היפי" );
CNodeNetworkBwGet( צוֹמֶת, "fddi" );
מידה CNodeDiskSpaceTotalGet(CNode צוֹמֶת, מחרוזת שֵׁם)
מחזירה את השטח הכולל של הצומת בדיסק המזוהה על ידי שם איפה שם
הוא שם המכשיר שהוגדר באופן שרירותי על ידי כותב המתזמן ב-
קובץ התצורה של מתזמן. ערך לא מוגדר: -1b
דוגמא:
CNodeDiskSpaceTotalGet( צוֹמֶת, "/ scratch2" );
מידה CNodeDiskSpaceAvailGet(CNode צוֹמֶת, מחרוזת שֵׁם)
מחזירה את השטח הפנוי של הצומת בדיסק המזוהה על ידי שם איפה
שם מוגדר באופן שרירותי על ידי כותב המתזמן במתזמן
קובץ תצורה. ערך לא מוגדר: -1b
דוגמא:
CNodeDiskSpaceAvailGet( צוֹמֶת, "/ scratch1" );
מידה CNodeDiskSpaceReservedGet(CNode צוֹמֶת, מחרוזת שֵׁם)
מחזירה את השטח השמור של הצומת בדיסק (מכסת משתמשים?) מזוהה על ידי
שם איפה שם מוגדר באופן שרירותי על ידי כותב המתזמן ב-
קובץ התצורה של מתזמן. ערך לא מוגדר: -1b
דוגמא:
CNodeDiskSpaceReservedGet( צוֹמֶת, "/ scratch1" );
Int CNodeDiskInBwGet( CNode צוֹמֶת, מחרוזת שם )
מחזירה את רוחב הפס הכתיבה (בתים/שנייה) של הדיסק של הצומת שזוהה
by שם . ערך לא מוגדר: -1
דוגמא:
CNodeDiskInBwGet( צוֹמֶת, "/מָהִיר" );
Int CNodeDiskOutBwGet( CNode צוֹמֶת, מחרוזת שם )
מחזירה את רוחב הפס הקריאה (בתים/שנייה) של הדיסק של הצומת שזוהה על ידי
שם . ערך לא מוגדר: -1
דוגמא:
CNodeDiskOutBwGet( צוֹמֶת, "/גָדוֹל" );
מידה CNodeSwapSpaceTotalGet( CNode צוֹמֶת, מחרוזת שם )
מחזירה את השטח הכולל של הצומת בהחלפה מזוהה על ידי שם איפה שם
מוגדר באופן שרירותי על ידי כותב המתזמן במתזמן
קובץ תצורה. ערך לא מוגדר: -1b
דוגמא:
CNodeSwapSpaceTotalGet( צוֹמֶת, "יְסוֹדִי" );
מידה CNodeSwapSpaceAvailGet( CNode צוֹמֶת, מחרוזת שם )
מחזיר את השטח הפנוי של הצומת בהחלפה מזוהה על ידי שם איפה שם
הוא שם המכשיר שהוגדר באופן שרירותי על ידי כותב המתזמן ב-
קובץ התצורה של מתזמן. ערך לא מוגדר: -1b
דוגמא:
CNodeSwapSpaceAvailGet( צוֹמֶת, "מִשׁנִי" );
Int CNodeSwapInBwGet( CNode צוֹמֶת, מחרוזת שם )
מחזירה את שיעור ההחלפה של התקן ההחלפה של הצומת המזוהה על ידי שם.
דוגמא:
CNodeSwapInBwGet(node, "מִשׁנִי");
Int CNodeSwapOutBwGet( CNode צוֹמֶת, מחרוזת שם )
מחזירה את קצב ההחלפה של התקן ההחלפה של הצומת המזוהה על ידי
שם. ערך לא מוגדר: -1
דוגמא:
CNodeSwapOutBwGet(node, "יְסוֹדִי");
מידה CNodeTapeSpaceTotalGet( CNode צוֹמֶת, מחרוזת שם )
מחזירה את השטח הכולל של הצומת בקלטת שזוהה על ידי שם איפה שם
מוגדר באופן שרירותי על ידי כותב המתזמן במתזמן
קובץ תצורה. ערך לא מוגדר: -1b
דוגמא:
CNodeTapeSpaceTotalGet(צומת, "4 מ"מ");
מידה CNodeTapeSpaceAvailGet( CNode צוֹמֶת, מחרוזת שם )
מחזירה את השטח הפנוי של הצומת בקלטת שזוהה על ידי שם איפה
שם מוגדר באופן שרירותי על ידי כותב המתזמן במתזמן
קובץ תצורה. ערך לא מוגדר: -1b
דוגמא:
CNodeTapeSpaceAvailGet(node, "8mm");
Int CNodeTapeInBwGet( CNode צוֹמֶת, מחרוזת שם )
מחזירה את רוחב הפס הכתיבה (בתים/שנייה) של הקלטת שזוהתה של הצומת
by שם . ערך לא מוגדר: -1
דוגמא:
CNodeTapeInBwGet( צוֹמֶת, "4 מ"מ" );
Int CNodeTapeOutBwGet( CNode צוֹמֶת, מחרוזת שם )
מחזירה את רוחב הפס הקריאה (בתים/שנייה) של סרט הצומת שזוהה
by שם . ערך לא מוגדר: -1
דוגמא:
CNodeTapeOutBwGet( צוֹמֶת, "8 מ"מ" );
מידה CNodeSrfsSpaceTotalGet( CNode צוֹמֶת, מחרוזת שם )
מחזירה את השטח הכולל של הצומת במכשיר srfs המזוהה על ידי שם
איפה שם מוגדר באופן שרירותי על ידי כותב המתזמן ב-
קובץ התצורה של מתזמן. ערך לא מוגדר: -1b
דוגמא:
CNodeSrfsSpaceTotalGet(node, "/מָהִיר");
מידה CNodeSrfsSpaceAvailGet( CNode צוֹמֶת, מחרוזת שם )
מחזירה את השטח הפנוי של הצומת במכשיר srfs המזוהה על ידי שם
איפה שם מוגדר באופן שרירותי על ידי כותב המתזמן בחלק
קובץ תצורה. ערך לא מוגדר: -1b
דוגמא:
CNodeSrfsSpaceAvailGet( צוֹמֶת, "/גָדוֹל" );
מידה CNodeSrfsSpaceReservedGet(CNode צוֹמֶת, מחרוזת שֵׁם)
מחזירה את הכמות הכוללת של השטח השמור של הצומת במכשיר srfs
מזוהה על ידי שם איפה שם מוגדר באופן שרירותי על ידי המתזמן
כותב בקובץ התצורה של המתזמן. ערך לא מוגדר: -1b
דוגמא:
CNodeSrfsSpaceReservedGet( צוֹמֶת, "/מָהִיר" );
Int CNodeSrfsInBwGet( CNode צוֹמֶת, מחרוזת שם )
מחזירה את רוחב הפס הכתיבה (בתים/שנייה) של התקן srfs של הצומת
מזוהה על ידי שם . ערך לא מוגדר: -1
דוגמא:
CNodeSrfsInBwGet( node, "/fast" );
Int CNodeSrfsOutBwGet( CNode צוֹמֶת, מחרוזת שם )
מחזירה את רוחב הפס הקריאה (בתים/שנייה) של התקן srfs של הצומת
מזוהה על ידי שם . ערך לא מוגדר: -1
דוגמא:
CNodeSrfsOutBwGet( node, "/big" );
(5) פונקציות שונות
תאריך שעה datetimeGet()
מקבל את התאריך/שעה הנוכחיים.
Int datetimeToSecs(DateTime dt)
מחזירה את # השניות מאז התקופה (תחילת זמן UNIX -
00:00:00, 1 בינואר 1970) עבור התאריך/שעה הנתונים dt.
Int JobAction( עבודה עבודה, Int פעולה, מחרוזת להפסיק )
מבצע פעולה on עבודה עם להפסיק מצוין בהתאם ל
פעולה. פעולה יכול להיות: SYNCRUN, ASYNCRUN, DELETE, RERUN, HOLD,
RELEASE, SIGNAL, MODIFYATTR, MODIFYRES כאשר:
פעולה תיאור
=============== ==========================
SYNCRUN פועל מה היא עבודה באופן סינכרוני,
משמעות מה היא שיחה ל
JobAction() יצטרך רק
לַחֲזוֹר מתי מה היא עבודה יש ל
החל ריצה or מתי
an שגיאה יש ל היה
נתקל ב.
פארם ערך:
שם of מארח(ים) ל לָרוּץ
עבודה תחת.
ASYNCRUN פועל מה היא עבודה באופן אסינכרוני,
משמעות מה היא שיחה ל
JobAction() יצטרך לַחֲזוֹר
מיד as בקרוב as
מה היא לָרוּץ לבקש is
תוקף by מה היא PBS שרת,
ו לֹא בהכרח מתי
מה היא עבודה יש ל החל
ביצוע.
פארם ערך:
שם of מארח(ים) ל לָרוּץ
עבודה תחת.
למחוק מוחק מה היא עבודה.
פארם ערך:
"deldelay=<# of שניות>"
- עיכוב # of שניות
בֵּין מה היא שליחה
of טווח יעד ו סיגיל
ל מה היא עבודה לפני
מקבל נמחק.
הפעלה חוזרת שידורים חוזרים מה היא ריצה עבודה,
אשר כרוך סיום
מה היא מושב מנהיג of מה היא
עבודה ו חוזר מה היא עבודה
ל מה היא בתור מדינה.
להחזיק מקומות אחד or יותר מחזיק
on מה היא עבודה.
פארם ערך:
"את", "או", "ש", "אוו", "os",
"uos"
- סוג of מחזיק ל מקום
on עבודה: מִשׁתַמֵשׁ), אַחֵר),
מערכת).
שחרור מסיר or משחרר
מחזיק מוצב on מקומות תעסוקה.
פארם ערך:
"את", "או", "ש", "אוו", "os",
"uos"
- סוג of מחזיק ל להסיר
החל מ- עבודה: מִשׁתַמֵשׁ), אַחֵר),
מערכת).
אוֹת שולח a אוֹת ל מה היא
מבצע עבודה.
פארם ערך:
"האפ", "נרשמה",...
MODIFYATTR משנה מה היא מפורט
תכונה of מה היא עבודה ל
מה היא נתן ערך מתי
מה היא attrib_name is
!= "רשימת_משאבים" or
"משאבים_בשימוש".
פארם ערך:
"attrib_name=value"
שנה משנה מה היא מקומות תעסוקה
משאבים_רשימת
תכונה נתן מה היא
res_name ו מה היא
res_value:
Resource_List.res_name=
res_value
פארם ערך:
"res_name=res_val"
להפסיק הערך תלוי בפעולה. ציין NULLSTR אם אין ערך עבור
פרמטר זה רצוי.
ערך החזרה: SUCCESS או FAIL.
הערה: כל לא מזוהה פעולה מתעלמים.
דוגמא:
// לָרוּץ עבודה j באופן סינכרוני
JobAction(j, SYNCRUN, NULLSTR);
// לָרוּץ עבודה j באופן אסינכרוני on המארח "db"
JobAction(j, ASYNCRUN, "db");
// להסיר עבודה j
JobAction(j, לִמְחוֹק, NULLSTR);
// להסיר עבודה j עם a עיכוב of 5 שניות
// בֵּין מה היא שליחה of טווח יעד ו
// סיגיל
JobAction(j, לִמְחוֹק, "deldelay=5");
// שידור חוזר עבודה j
JobAction(j, הפעלה חוזרת, NULLSTR);
// מקום a מִשׁתַמֵשׁ) להחזיק on עבודה j
JobAction(j, לְהַחזִיק, "u");
// מקום an אַחֵר) להחזיק on עבודה j
JobAction(j, לְהַחזִיק, "o");
// מקום a מערכת) להחזיק on עבודה j
JobAction(j, לְהַחזִיק, "s");
// מקום a ברירת מחדל להחזיק (אוֹ) on עבודה j
JobAction(j, לְהַחזִיק, NULLSTR);
// לשחרר מִשׁתַמֵשׁ) להחזיק החל מ- עבודה j
JobAction(j, לְשַׁחְרֵר, "u");
// לשחרר אַחֵר) להחזיק החל מ- עבודה j
JobAction(j, לְשַׁחְרֵר, "o");
// לשחרר מערכת) להחזיק החל מ- עבודה j
JobAction(j, לְשַׁחְרֵר, "s");
// לשחרר ברירת מחדל להחזיק (אוֹ) החל מ- עבודה j
JobAction(j, לְשַׁחְרֵר, NULLSTR);
// לשלוח הרשמה אוֹת ל עבודה j
JobAction(j, אוֹת, "SIGHUP");
// עדכון מה היא הערה תכונה of עבודה
// j ל "a הוֹדָעָה".
// אל האני להפסיק פוּרמָט היא: attribute_name=new_value
// התייעץ PBS תיעוד ל a רשימה of עבודה
// תכונה שמות זֶה יכול be נָקוּב.
JobAction(j, MODIFYATTR, "תגובה=א הוֹדָעָה");
// עדכון מה היא Resource_List.cput תכונה of עבודה
// j ל 3600 שניות.
// אל האני להפסיק פוּרמָט היא: resource_name=new_value
// לִרְאוֹת pbs_resources* איש עמוד ל a רשימה of
// שמות_משאבים זֶה יכול be נָקוּב.
JobAction(j, שינויים, "cput=3600");
QueJobFind(Que מה, כיף Int func, Int cpr, Int ערך);
QueJobFind(Que מה, כיף מחרוזת func, Int cpr, מחרוזת ערך);
QueJobFind(Que מה, כיף תאריך שעה func, Int cpr,DateTime ערך);
QueJobFind(Que מה, כיף מידה func, Int cpr, גודל ערך);
איפה החייאה הוא אחד מ: OP_EQ, OP_NEQ, OP_LE, OP_LT, OP_GE, OP_GT. func
היא פונקציה שהארגומנט היחיד שלה הוא מסוג Job. עבודה היא התמורה
הקלד.
תיאור: חל func לכל עבודה ב כי , ולהחזיר את הראשון
עבודה שעונה על ההשוואה הלוגית: func(עבודה) החייאה ערך
דוגמא:
מידה JobVirtualMemAvailGet(Job עבודה)
{
מידה sz;
sz = JobSizeResReqGet(job, "מ");
return(sz);
}
Int JobWallTimeReqGet(Job עבודה)
{
Int קיר;
קיר = JobIntResReqGet(job, "walltime");
return(wallt);
}
Int JobCpuTimeUsedGet(Job עבודה)
{
Int cput;
cput = JobIntResUseGet(job, "cput");
return(cput);
}
כי findQueByName(Set כי תורים, מחרוזת qname)
{
כי q;
foreach(q in תורים) {
אם QueNameGet(q) EQ qname ) {
return(q);
}
}
return(NOQUE);
}
sched_main()
{
שרת s;
כי que;
לקבוע כי מ"ר;
// לקבל מקומי שרת
s = AllServersLocalHostGet();
// לקבל מה היא פרָאק of מה היא שרת s
sq = ServerQueuesGet(s);
// לקבל מה היא תור בשם "מָהִיר" החל מ- מה היא
// מקומי שרת
כי = findQueByName( מ"ר, "מָהִיר" );
// מה היא 1st עבודה של מי זמן קיר דרישה
// is == 300s:
QueJobFind(que, JobWallTimeReqGet, OP_EQ, 300);
// מה היא 1st עבודה של מי אמייל כתובת ל
// תודיע על עבודה פעילות != "bayucan":
QueJobFind(que, JobEmailAddrGet, OP_NEQ,
"bayucan");
// מה היא 1st עבודה זֶה היה נוצר לאחר
// or on 3 / 3 / 1997:
QueJobFind(que, JobDateTimeCreatedGet, OP_GE,
(3|3|1997));
// מה היא 1st עבודה זֶה היה נוצר לאחר
// 3: 3: 44:
QueJobFind(que, JobDateTimeCreatedGet, OP_GT,
(3:3:44));
// מה היא 1st עבודה זֶה היה נוצר לאחר
// 3:3:44 on 3 / 3 / 1997:
QueJobFind(que, JobDateTimeCreatedGet, OP_GT,
(3|3|1997@3:3:44));
// מה היא 1st עבודה של מי מעבד זמן מְשׁוּמָשׁ < 1600s:
QueJobFind(que, JobCpuTimeUsedGet, OP_LT, 1600);
// מה היא 1st עבודה של מי וירטואלי זיכרון
// דרישה <= 300MB:
QueJobFind(que, JobVirtualMemAvailGet, OP_LE,
300MB);
}
עבודה QueJobFind( כי כי, כיף Int func, Int החייאה)
עבודה QueJobFind( כי כי, כיף מחרוזת func, Int החייאה)
עבודה QueJobFind( כי כי, כיף תאריך שעה func, Int החייאה)
עבודה QueJobFind( כי כי, כיף מידה func, Int החייאה)
איפה החייאה יכול להיות אחד מהבאים: OP_MAX, OP_MIN, func הוא
פונקציה שהארגומנט היחיד שלה הוא מסוג Job.
תיאור: מחזירה את העבודה עם הערך המקסימלי או המינימלי שנמצא עבור
func(עבודה) כפי שהוא מיושם על כל עבודה ב כי .
דוגמא:
Int JobCpuTimeReqGet(Job עבודה)
{
Int cput;
cput = JobIntResReqGet(job, "cput");
return(cput);
}
sched_main()
{
כי que;
עבודה עבודה;
// מה היא עבודה עם מה היא הגבוה ביותר מעבד זמן
// דְרִישָׁה:
עבודה = QueJobFind(que, JobCpuTimeReqGet, OP_MAX);
// מה היא עבודה עם מה היא מינימום מעבד זמן
// דְרִישָׁה:
עבודה = QueJobFind(que, JobCpuTimeReqGet, OP_MIN);
}
כי QueFilter(Que מה, כיף Int func, Int cpr, Int ערך)
כי QueFilter(Que מה, כיף מחרוזת func, Int cpr, מחרוזת ערך)
כי QueFilter(Que מה, כיף תאריך שעה func, Int cpr, תאריך ערך)
כי QueFilter(Que מה, כיף מידה func, Int cpr, גודל ערך)
איפה החייאה יכול להיות אחד מהבאים: OP_EQ, OP_NEQ, OP_LE, OP_LT,
OP_GE, OP_GT, func היא פונקציה שהארגומנט היחיד שלה הוא מסוג Job.
תיאור: חל func לכל עבודה ב כי , ומחזיר que חדש
המכיל את כל המשרות העומדות בתנאי ההשוואה:
func(עבודה) החייאה ערך
דוגמא:
Int JobWallTimeReqGet(Job עבודה)
{
Int קיר;
קיר = JobIntResReqGet(job, "walltime");
return(wallt);
}
sched_main()
{
כי que;
כי newq;
// החזרים a חדש כי מכיל את כל משרות in "מאשר"
// עם a זמן קיר דרישה == 300s:
newq = QueFilter(que, JobWallTimeReqGet, OP_EQ, 300);
// החזרים a חדש כי מכיל את כל משרות in "מאשר"
// עם an אמייל כתובת != "bayucan":
newq = QueFilter(que, JobEmailAddrGet, OP_NEQ, "bayucan");
// החזרים a חדש כי מכיל את כל משרות in "מאשר"
// נוצר לאחר or on 3 / 3 / 1997:
newq = QueFilter(que, JobDateTimeCreatedGet, OP_GE,
(3|3|1997));
// החזרים a חדש כי מכיל את כל משרות in "מאשר"
// נוצר לאחר 3: 3: 44:
newq = QueFilter(que, JobDateTimeCreatedGet, OP_GT,
(3:3:44));
// החזרים a חדש כי מכיל את כל משרות in "מאשר"
// נוצר לאחר 3:3:44 on 3 / 3 / 1997:
newq = QueFilter(que, JobDateTimeCreatedGet, OP_GT,
(3|3|1997@3:3:44));
// הערה: אל האני מְקוֹרִי "מאשר" is לֹא שונים
// כָּלשֶׁהוּ.
}
Int מיין (קבע עבודה s, כיף Int מַפְתֵחַ, Int סדר)
Int מיין (קבע עבודה s, כיף מחרוזת מַפְתֵחַ, Int סדר)
Int מיין (קבע עבודה s, כיף לָצוּף מַפְתֵחַ, Int סדר)
Int מיין (קבע עבודה s, כיף תאריך שעה מַפְתֵחַ, Int סדר)
Int מיין (קבע עבודה s, כיף מידה מַפְתֵחַ, Int סדר)
איפה s מכלול המשרות למיון. מפתח הוא מפתח המיון שהוא א
פונקציה שהארגומנט היחיד שלה הוא מסוג Job, להזמין הוא המיון
סדר: ASC, DESC.
תיאור: ממיין את האלמנטים של s , ב-ASCending או
סדר יורד של ערכים שהוחזרו על ידי ה מפתח מתפקד כ
חל על כל חבר במערך המשרות. ה s האובייקט משתנה
עם השיחה הזו. זה מחזיר SUCCESS או FAIL בהתאם לתוצאה של
המיון.
דוגמאות:
מידה JobMemReqGet(Job עבודה)
{
מידה מ;
מ = JobSizeResReqGet(job, "מ");
לַחֲזוֹר(מ);
}
sched_main()
{
שרת לִשְׁלוֹט;
לקבוע עבודה מקומות תעסוקה;
Int להזמין;
// לקבל מקומי שרת
אב = AllServersLocalHostGet();
משרות = ServerJobsGet(לִשְׁלוֹט);
מיין (עבודות, JobPriorityGet, ASC);
מיין (עבודות, JobIdGet, DESC);
להזמין = ASC;
מיין (עבודות, JobDateTimeCreatedGet, להזמין);
להזמין = DESC;
מיין (עבודות, JobMemReqGet, להזמין);
}
Int מיין (קבע כי s, כיף Int מַפְתֵחַ, Int סדר)
Int מיין (קבע כי s, כיף מחרוזת מַפְתֵחַ, Int סדר)
Int מיין (קבע כי s, כיף לָצוּף מַפְתֵחַ, Int סדר)
Int מיין (קבע כי s, כיף תאריך שעה מַפְתֵחַ, Int סדר)
Int מיין (קבע כי s, כיף מידה מַפְתֵחַ, Int סדר)
איפה s קבוצת התורים למיון. מפתח הוא מפתח המיון שהוא א
פונקציה שהארגומנט היחיד שלה הוא מסוג Que, להזמין הוא המיון
סדר: ASC, DESC.
תיאור: ממיין את האלמנטים של s , ב-ASCending או
סדר יורד של ערכים שהוחזרו על ידי ה מפתח מתפקד כ
מוחל על כל חבר בקבוצת התורים. ה s אובייקט הוא
שונה עם השיחה הזו. זה מחזיר SUCCESS או FAIL בהתאם
תוצאה מהסוג.
דוגמאות:
מידה QueMemAvailGet(Que מה)
{
מידה מ;
מ = QueSizeResAvailGet(que, "מ");
לַחֲזוֹר(מ);
}
sched_main()
{
שרת לִשְׁלוֹט;
לקבוע כי שאלות;
Int להזמין;
// לקבל מקומי שרת
אב = AllServersLocalHostGet();
שאלות = ServerQueuesGet(לִשְׁלוֹט);
מיין (שאלות, QuePriorityGet, ASC);
מיין (שאלות, QueNameGet, ASC);
להזמין = DESC;
מיין (שאלות, QueMemAvailGet, להזמין);
}
Int מיין (קבע שרת s, כיף Int מַפְתֵחַ, Int סדר)
Int מיין (קבע שרת s, כיף מחרוזת מַפְתֵחַ, Int סדר)
Int מיין (קבע שרת s, כיף לָצוּף מַפְתֵחַ, Int סדר)
Int מיין (קבע שרת s, כיף תאריך שעה מַפְתֵחַ, Int סדר)
Int מיין (קבע שרת s, כיף מידה מַפְתֵחַ, Int סדר)
איפה s ערכת השרתים למיון. מפתח הוא מפתח המיון שהוא
פונקציה שהארגומנט היחיד שלה הוא מסוג Server, להזמין האם ה
סדר מיון: ASC, DESC.
תיאור: ממיין את האלמנטים של s , ב-ASCending או
סדר יורד של ערכים שהוחזרו על ידי ה מפתח מתפקד כ
מיושם על כל חבר בקבוצת השרתים. ה s אובייקט הוא
שונה עם השיחה הזו. זה מחזיר SUCCESS או FAIL בהתאם
תוצאה מהסוג.
דוגמאות:
מידה ServerMemAvailGet(שרת שרת)
{
מידה מ;
מ = ServerSizeResAvailGet(serv, "מ");
לַחֲזוֹר(מ);
}
sched_main()
{
לקבוע שרת sserver;
Int להזמין;
Int לְהַשְׁרוֹת;
שרת = AllServersGet();
ret = מיון(שרת, ServerMaxRunJobsGet, ASC);
מיון(שרת, ServerInetAddrGet, ASC);
להזמין = DESC;
מיון(שרת, ServerMemAvailGet, להזמין);
}
Int מיין (קבע CNode s, כיף Int מַפְתֵחַ, Int סדר)
Int מיין (קבע CNode s, כיף מחרוזת מַפְתֵחַ, Int סדר)
Int מיין (קבע CNode s, כיף לָצוּף מַפְתֵחַ, Int סדר)
Int מיין (קבע CNode s, כיף תאריך שעה מַפְתֵחַ, Int סדר)
Int מיין (קבע CNode s, כיף מידה מַפְתֵחַ, Int סדר)
איפה s קבוצת הצמתים למיון. מפתח הוא מפתח המיון שהוא א
פונקציה שהארגומנט היחיד שלה הוא מסוג CNode, להזמין הוא המיון
סדר: ASC, DESC.
תיאור: ממיין את האלמנטים של s , ב-ASCending או
סדר יורד של ערכים שהוחזרו על ידי ה מפתח מתפקד כ
מוחל על כל חבר בקבוצת הצמתים. ה s אובייקט הוא
שונה עם השיחה הזו. זה מחזיר SUCCESS או FAIL בהתאם
תוצאה מהסוג.
דוגמאות:
מידה CNodeMyMemAvailGet(CNode cn)
{
מידה מ;
מ = CNodeMemAvailGet(cn, "וירטואלי");
לַחֲזוֹר(מ);
}
sched_main()
{
לקבוע CNode scnode;
Int להזמין;
scnode = AllNodesGet();
מיון(סקנוד, CNodeIdletimeGet, ASC);
מיון(סקנוד, CNodeNameGet, ASC);
להזמין = DESC;
מיון(סקנוד, CNodeMyMemAvailGet, להזמין);
}
CNode..Get() פונקציות
ערכי ההחזרה של הפונקציות CNode..Get() שנדונו בסעיף הקודם הם
מתקבל על ידי שליחת שאילתות משאבים ל-MOM של ה-CNod בכל איטרציה של תזמון.
לדוגמה, CNodeLoadAveGet(צומת) יחזיר את הערך שהתקבל מכמה
resource> query (זו יכולה להיות המחרוזת "loadave") כפי שנשלחה ל-MOM של הצומת. ה
" -> מיפוי CNode..Get()" נוצרים באופן פנימי, אבל הם יכולים להיות
ניתן להוסיף מיפויים ששונו או יותר באמצעות קובץ התצורה של מתזמן. התצורה
הקובץ נדון ב pbs_sched_basl(8 ב).
מיפויים שכבר הוקמו ניתנים בחלק הבא:
לכל הארכיטקטורות:
CNode..Get() ממשי שיחה המארח משאב
======================== =============
CNodeOsGet(צומת) קשת
CNodeLoadAveGet(צומת) עומס
CNodeIdletimeGet(צומת) זמן מת
השתמש ב-basl2cB באינטרנט באמצעות שירותי onworks.net
