basl2cB - ക്ലൗഡിൽ ഓൺലൈനിൽ

പട്ടിക:

NAME

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-യിലേക്ക് നൽകാം
റെഗുലർ സി കംപൈലർ, കൂടാതെ ഷെഡ്യൂളർ എക്സിക്യൂട്ടബിൾ നിർമ്മിക്കാൻ PBS ലൈബ്രറികളുമായി ലിങ്ക് ചെയ്‌തു.
Basl2c ഇൻപുട്ട് a ആയി എടുക്കുന്നു baslFile, ഇത് ബാച്ച് ഷെഡ്യൂളിംഗിൽ എഴുതിയ ഒരു പ്രോഗ്രാമാണ്
പ്രധാന ഷെഡ്യൂളിംഗ് കോഡ് അടങ്ങുന്ന ഭാഷ. Basl2c പിന്നീട് BASL നിർമ്മാണങ്ങളെ പരിവർത്തനം ചെയ്യുന്നു
ഫയലിൽ സി സ്റ്റേറ്റ്‌മെന്റുകളായി, കൂടാതെ ഇത് പിബിഎസ് നിർമ്മിക്കുന്നതിന് അധിക കോഡും അറ്റാച്ചുചെയ്യുന്നു
ഷെഡ്യൂളർ സോഴ്സ് കോഡ്. സ്ഥിരസ്ഥിതിയായി, തത്ഫലമായുണ്ടാകുന്ന സി കോഡ് ഫയലിൽ എഴുതിയിരിക്കുന്നു
pbs_sched.c.

തത്ഫലമായുണ്ടാകുന്ന C ഫയലിന്റെ പൂർണ്ണമായ പാത്ത് നെയിം ആണ് ഇതിൽ വ്യക്തമാക്കേണ്ടത് SCHD_CODE
നിർമ്മിക്കുന്നതിനായി BASL ഷെഡ്യൂളർ കംപൈൽ ചെയ്യുന്നതിന് മുമ്പ് local.mk-ൽ വേരിയബിൾ pbs_sched
എക്സിക്യൂട്ടബിൾ.

ഓപ്ഷനുകൾ

-d ലെക്സറിലേക്ക് അധിക ഡീബഗ്ഗിംഗ് സന്ദേശങ്ങൾ പ്രിന്റ് ചെയ്യുന്നു (-l ഓപ്ഷൻ കാണുക), പാഴ്സർ (കാണുക -p
ഓപ്ഷൻ), ചിഹ്ന പട്ടിക (-y ഓപ്ഷൻ കാണുക), സെമാന്റിക് അനലൈസർ (-s ഓപ്ഷൻ കാണുക), കോഡ്
ജനറേറ്റർ (-g ഓപ്ഷൻ കാണുക).

-l lexerDebugFile
lexerDebugFile സൃഷ്ടിച്ച ഡീബഗ്ഗിംഗ് സന്ദേശങ്ങളിൽ എഴുതാനുള്ള ഒരു ഫയലിന്റെ പേരാണ്
ടോക്കണുകൾക്കായി സ്കാൻ ചെയ്യുമ്പോൾ.

-p parserDebugFile
parserDebugFile സൃഷ്ടിച്ച ഡീബഗ്ഗിംഗ് സന്ദേശങ്ങളിൽ എഴുതാനുള്ള ഒരു ഫയലിന്റെ പേരാണ്
ഉപയോഗിക്കാവുന്ന രീതിയിൽ ടോക്കണുകൾ കൂട്ടിച്ചേർക്കുമ്പോൾ.

-y symtabDebugFile
symtabDebugFile എന്നതുമായി ബന്ധപ്പെട്ട ഡീബഗ്ഗിംഗ് സന്ദേശങ്ങളിൽ എഴുതാനുള്ള ഒരു ഫയലിന്റെ പേരാണ്
ചിഹ്ന പട്ടിക.

-s semanticDebugFile
semanticDebugFile ഡീബഗ്ഗിംഗ് സന്ദേശങ്ങളിൽ എഴുതാനുള്ള ഒരു ഫയലിന്റെ പേരാണ്
a-യിൽ വേരിയബിളുകളും ഓപ്പറേറ്റർമാരും ഉപയോഗിക്കുന്നുണ്ടെന്ന് ഉറപ്പുവരുത്താൻ പരിശോധിക്കുമ്പോൾ ജനറേറ്റുചെയ്‌തത്
സ്ഥിരമായ വഴി.

-g codegenDebugFile
codegenDebugFile സൃഷ്ടിച്ച ഡീബഗ്ഗിംഗ് സന്ദേശങ്ങളിൽ എഴുതാനുള്ള ഒരു ഫയലിന്റെ പേരാണ്
BASL പ്രസ്താവനകൾ C പ്രസ്താവനകളാക്കി മാറ്റുമ്പോൾ.

-സി സി ഫയൽ
cFile ജനറേറ്റ് ചെയ്ത C കോഡ് എഴുതിയ ഫയലിന്റെ പേരാണ്.

കൈ സ്ട്രക്ചർ

BASL-ൽ എഴുതിയ ഷെഡ്യൂളർ കോഡിന്റെ അടിസ്ഥാന ഘടന ഇപ്രകാരമാണ്:
പൂജ്യം or കൂടുതൽ പ്രവർത്തനങ്ങൾ നിർവചനങ്ങൾ
പൂജ്യം or കൂടുതൽ ഗ്ലോബൽ വേരിയബിൾ പ്രഖ്യാപനങ്ങൾ
പൂജ്യം or കൂടുതൽ നിയമനം പ്രസ്താവനകൾ (ലേക്ക് ആരംഭിക്കുക ഗ്ലോബൽ വേരിയബിളുകൾ)
ഷെഡ്_മെയിൻ()
{
ഒന്ന് or കൂടുതൽ വേരിയബിൾ പ്രഖ്യാപനങ്ങൾ

പൂജ്യം or കൂടുതൽ പ്രസ്താവനകൾ
}

ഉദാഹരണത്തിന്,
% പൂച്ച sched.basl
int തുക (Int a, int b)
{
int s;
s = a + b;
റിട്ടേൺ(കൾ);
}
int ഗ്ലോബ്;
ഷെഡ്_മെയിൻ()
{
int c;

a = 3;
b = 4;
c = തുക(എ, ബി);
പ്രിന്റ് (സി);
ഗ്ലോബ് = 5;
പ്രിന്റ് (ഗ്ലോബ്);
}

ഷെഡ്_മെയിൻ() ഓരോ ഷെഡ്യൂളിംഗ് ആവർത്തനത്തിലും വിളിക്കപ്പെടുന്ന പ്രവർത്തനമാണ്.

പ്രവർത്തനങ്ങൾ

തുടർന്നുള്ള ഫംഗ്ഷനുകളിൽ വിളിക്കാവുന്ന ഒരു ഫംഗ്ഷൻ നിർവചിക്കുന്നതിന്, വാക്യഘടന ഇതാണ്:

റിട്ടേൺടൈപ്പ് ഫംഗ്ഷൻ-നാമം ( DATATYPE1 ഐഡന്റിഫയർ1,
DATATYPE2 ഐഡന്റിഫയർ2, ... )
{
ഒന്ന് or കൂടുതൽ വേരിയബിൾ പ്രഖ്യാപനങ്ങൾ

പൂജ്യം or കൂടുതൽ പ്രസ്താവനകൾ
}

ഉദാഹരണത്തിന്,
അസാധുവാണ് പ്രിന്റ് സ്റ്റഫ്(Dayofweek ഡൗ, തീയതി ടൈം t, സ്ട്രിംഗ് str,
വലുപ്പം sz, സിനോഡ് cn)
{
പ്രിന്റ് (ഡൗ);
പ്രിന്റ് (ടി);
പ്രിന്റ് (str);
പ്രിന്റ് (sz);
പ്രിന്റ് (cn);
}

സാധുവായ പ്രവർത്തനം റിട്ടേൺടൈപ്പ് ഇവയാണ്: അസാധുവായ, അന്തർഭാഗം, ഫ്ലോട്ട്, ഡേഓഫ് വീക്ക്, തീയതി സമയം, സ്ട്രിംഗ്, വലുപ്പം,
സെർവർ, ക്യൂ, ജോബ്, സി നോഡ്, സെറ്റ് സെർവർ, സെറ്റ് ക്യൂ, സെറ്റ് ജോബ്, സെറ്റ് സി നോഡ്.

സാധുവായ ഡാറ്റ തരങ്ങൾ ( DATATYPE1, DATATYPE2, ... ) പാരാമീറ്റർ ഐഡന്റിഫയറുകൾക്ക് ഇവയാണ്: Int,
ഫ്ലോട്ട്, ഡേഓഫ് വീക്ക്, തീയതി സമയം, സ്ട്രിംഗ്, വലുപ്പം, സെർവർ, ക്യൂ, ജോലി, സി നോഡ്, സെറ്റ് സെർവർ, സെറ്റ് ക്യൂ,
ജോലി സജ്ജമാക്കുക, സെറ്റ് സി നോഡ്, റേഞ്ച് ഇന്റ്, റേഞ്ച് ഫ്ലോട്ട്, റേഞ്ച് ഡയോഫ് വീക്ക്, റേഞ്ച് തീയതി സമയം, റേഞ്ച് സൈസ്,
Fun Int, Fun Float, Fun Void, Fun Dayofweek, Fun DateTime, Fun String, Fun Size, Fun
സെർവർ, ഫൺ ക്യൂ, ഫൺ ജോബ്, ഫൺ സി നോഡ്, ഫൺ സെറ്റ് സെർവർ, ഫൺ സെറ്റ് ക്യൂ, ഫൺ സെറ്റ് ജോബ്, ഫൺ സെറ്റ്
സിനോഡ്. ഈ ഡാറ്റ തരങ്ങൾ അടുത്ത വിഷയത്തിൽ ചർച്ച ചെയ്യും.

ഫംഗ്‌ഷനുകൾ അവയുടെ പേരും അവയുടെ ആർഗ്യുമെന്റുകളും ഇപ്രകാരമാണ്:

പ്രിന്റ് സ്റ്റഫ്( മോൺ, (5|1|1997@14:32:00), "ഷെഡ് ചെയ്തു ആരംഭിക്കുന്നു",
30 ജിബി, നോഡ് );

basl2c ഷെഡ്യൂളർ നൽകിയ ഫംഗ്‌ഷൻ നാമത്തിലേക്ക് യഥാർത്ഥത്തിൽ ഒരു "basl_" പ്രിഫിക്‌സ് ചേർക്കും
റൈറ്റർ നെയിം കൂട്ടിയിടിയുടെ സാധ്യത കുറയ്ക്കുന്നു, തത്ഫലമായുണ്ടാകുന്ന സി കോഡ് ആയിരിക്കുമ്പോൾ ഇത് സംഭവിക്കാം
PBS, BASL ലൈബ്രറികളുമായി ബന്ധിപ്പിച്ചിരിക്കുന്നു. ഉദാഹരണത്തിന്, നിങ്ങൾ ജനറേറ്റ് ചെയ്ത സി കോഡ് നോക്കുകയാണെങ്കിൽ
പ്രിന്റ് സ്റ്റഫ്, നിങ്ങൾ കാണും,

basl_printStuff( MON, (5|1|1997@14:32:00),
"ഷെഡ് ആരംഭിക്കുന്നു", 30ജിബി, നോഡ് );

സിയിലെ പോലെ, എല്ലാ ഫംഗ്‌ഷൻ കോളുകളും മുമ്പ് നിർവ്വചിച്ചിരിക്കണം. BASL കംപൈലർ ചെയ്യും
ഫംഗ്‌ഷൻ കോളിലെ ആർഗ്യുമെന്റുകൾ കൃത്യമായി പൊരുത്തപ്പെടുന്നുണ്ടെന്ന് ഉറപ്പാക്കാൻ പരിശോധിക്കുക (ഇതിന്റെ അടിസ്ഥാനത്തിൽ
തരം) ഫംഗ്‌ഷൻ നിർവചനത്തിലെ പാരാമീറ്ററുകൾക്കൊപ്പം.

BASL-ൽ രണ്ട് തരത്തിലുള്ള ഫംഗ്‌ഷനുകൾ നിലവിലുണ്ട്: ഉപയോക്തൃ-നിർവചിച്ച ഫംഗ്‌ഷനുകളും മുൻ‌നിശ്ചയിച്ച ഫംഗ്ഷനുകളും.
ഉപയോക്തൃ-നിർവചിച്ച ഫംഗ്‌ഷനുകൾ എന്നത് ഷെഡ്യൂളർ റൈറ്റർ ഒരു നിർവചനം നൽകിയവയാണ്,
മുൻകൂട്ടി നിശ്ചയിച്ച ഫംഗ്‌ഷനുകൾ ഒരു ആവശ്യമില്ലാതെ തന്നെ ഉടൻ വിളിക്കാവുന്നവയാണ്
അത് നിർവചിക്കുന്നു. മുൻകൂട്ടി നിശ്ചയിച്ച ഫംഗ്‌ഷനുകളുടെ ഒരു ലിസ്റ്റിനായി, എന്ന വിഭാഗം കാണുക മുൻകൂട്ടി നിശ്ചയിച്ചത് പ്രവർത്തനങ്ങൾ .

വേരിയബിൾ പ്രഖ്യാപനങ്ങൾ

സിയിലേതുപോലെ, BASL കോഡിലെ എല്ലാ വേരിയബിളുകളും ഉപയോഗിക്കുന്നതിന് മുമ്പ് വ്യക്തമായി പ്രഖ്യാപിച്ചിരിക്കണം. ആ
ഏതെങ്കിലും ഫംഗ്‌ഷന് പുറത്ത് പ്രഖ്യാപിച്ചിരിക്കുന്ന വേരിയബിളുകളെ ആഗോള വേരിയബിളുകൾ എന്ന് വിളിക്കുന്നു, അതേസമയം
ഒരു ഫംഗ്ഷൻ ബോഡിക്കുള്ളിൽ പ്രഖ്യാപിക്കുന്ന വേരിയബിളുകളെ ലോക്കൽ വേരിയബിളുകൾ എന്ന് വിളിക്കുന്നു. ആഗോള
വേരിയബിളുകൾ BASL കോഡിനുള്ളിൽ എവിടെയും ഉപയോഗിക്കാവുന്നതാണ്, അതേസമയം പ്രാദേശിക വേരിയബിളുകൾ വായിക്കാൻ കഴിയും
അവ പ്രഖ്യാപിക്കപ്പെട്ട ചടങ്ങിനുള്ളിൽ മാത്രം.

ഒരു വേരിയബിൾ ഡിക്ലറേഷന്റെ വാക്യഘടന ഇതാണ്:

ഡാറ്റാറ്റിപ്പ് ഐഡന്റിഫയർ ;

എവിടെ ഡാറ്റാറ്റിപ്പ് ആകാം: Int, Float, Dayofweek, DateTime, String, Size, Server, Que, Job,
സി നോഡ്, സെറ്റ് സെർവർ, സെറ്റ് ക്യൂ, സെറ്റ് ജോബ്, സെറ്റ് സി നോഡ്, റേഞ്ച് ഇന്റർ, റേഞ്ച് ഫ്ലോട്ട്, റേഞ്ച് ഡയോഫ് വീക്ക്,
റേഞ്ച് തീയതി സമയം, റേഞ്ച് വലിപ്പം.

ഡാറ്റ തരം

അസാധുവാണ് മൂല്യം നൽകാത്ത ഫംഗ്‌ഷനുകൾക്കായി ഉപയോഗിക്കുന്നു.

int ഒപ്പിട്ടത്, അടിസ്ഥാന 10-ൽ നൽകിയിരിക്കുന്ന മുഴുവൻ സംഖ്യകളും.

സാമ്പിൾ സ്ഥിരാങ്കങ്ങൾ:
5, +1, -3, വിജയം (=1), പരാജയം (=0), ശരി (=1), തെറ്റ് (=0)

ഫ്ലോട്ട് വിവർത്തനം ചെയ്ത C കോഡിൽ ഇരട്ടകളായി പ്രതിനിധീകരിക്കുന്ന യഥാർത്ഥ സംഖ്യകൾ.
സാമ്പിൾ സ്ഥിരാങ്കങ്ങൾ: 4.3, +1.2, -2.6

ഡേഓഫ് വീക്ക്
സ്ഥിരമായ മൂല്യങ്ങൾ: SUN, MON, TUE, WED, THU, FRI, SAT, ആന്തരികമായി പ്രതിനിധീകരിക്കുന്നത്
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 <= mm <= 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)

ശ്രേണി ഡേഓഫ് വീക്ക്

ഫോർമാറ്റ്: (നേരത്തെ ദിവസം, പിന്നീടുള്ള ദിവസം)
എവിടെ നേരത്തെ ദിവസം <= പിന്നീടുള്ള ദിവസം. സാമ്പിൾ സ്ഥിരാങ്കം: (ബുധൻ, FRI)

ശ്രേണി തീയതി ടൈം

ഫോർമാറ്റ്: (നേരത്തെ തീയതി/സമയം, പിന്നീടുള്ള തീയതി/സമയം)
മുമ്പത്തെ തീയതി/സമയം <= പിന്നീടുള്ള തീയതി/സമയം.
ശ്രദ്ധിക്കുക: ശ്രേണിയിൽ സമയ ഭാഗങ്ങൾ മാത്രമേ അടങ്ങിയിട്ടുള്ളൂ എങ്കിൽ, മുമ്പത്തെ സമയം "ദൃശ്യമാകുന്നു"
"((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

സിനോഡ് ഒരൊറ്റ OS ഇമേജ്, ഒരു പങ്കിട്ട മെമ്മറി, ഒരു സെറ്റ് എന്നിവ അടങ്ങുന്ന കമ്പ്യൂട്ടേഷണൽ നോഡിനായി
cpus-ന്റെ. CNode 1 PBS MOM പ്രവർത്തിപ്പിക്കുന്നു.
സാമ്പിൾ സ്ഥിരാങ്കം: NOCNODE

അത് PBS ക്യൂ ഒബ്‌ജക്‌റ്റിലേക്ക് നേരിട്ട് മാപ്പുകൾ. എ അത് ഒബ്ജക്റ്റ് ഒന്നോ അതിലധികമോ സ്പൂളുകൾ ഇയ്യോബ്
വസ്തുക്കൾ.
സാമ്പിൾ സ്ഥിരാങ്കം: NOQUE

ഇയ്യോബ് PBS ജോബ് ഒബ്‌ജക്‌റ്റിലേക്ക് നേരിട്ട് മാപ്പുകൾ. എ ഇയ്യോബ് ഒബ്ജക്റ്റ് ചില ആട്രിബ്യൂട്ടുകൾ വഹിക്കുന്നു
വിഭവ ആവശ്യകതകൾ.
സാമ്പിൾ സ്ഥിരാങ്കം: NOJOB

ഗണം സെർവർ
സെർവർ ഒബ്ജക്റ്റുകളുടെ പട്ടിക.
സാമ്പിൾ സ്ഥിരാങ്കം: EMPTYSETSERVER

ഗണം സിനോഡ്
CNode ഒബ്‌ജക്‌റ്റുകളുടെ പട്ടിക.
സാമ്പിൾ സ്ഥിരാങ്കം: EMPTYSETCNODE

ഗണം അത് ക്യൂ ഒബ്ജക്റ്റുകളുടെ പട്ടിക.
സാമ്പിൾ സ്ഥിരാങ്കം: EMPTYSETQUE

ഗണം ഇയ്യോബ് ജോലി വസ്തുക്കളുടെ പട്ടിക.
സാമ്പിൾ സ്ഥിരാങ്കം: EMPTYSETJOB

BASL-നിർവചിക്കപ്പെട്ടത് സ്ഥിരം

ഇവ ഒരു ഐഡന്റിഫയറിന് പേരിടാൻ ഉപയോഗിക്കാനാവാത്ത സ്ഥിരാങ്കങ്ങളാണ് (അടുത്ത വിഷയം കാണുക). ഇവ
എപ്പോഴും വലിയക്ഷരത്തിലാണ്.

ഡാറ്റ തരം BASL-നിർവചിക്കപ്പെട്ടത് നിരന്തരം
===================== =========================================
ഡേഓഫ് വീക്ക് സൂര്യൻ, മോൺ, ചൊവ്വാഴ്ച, ബുധൻ, THU, FRI, SAT

int വിജയം, പരാജയപ്പെടുക, തെറ്റായ, സത്യം, സിൻക്രൺ, അസിൻക്രൺ,
ഇല്ലാതാക്കുക, വീണ്ടും, പിടിക്കുക, പ്രകാശനം, സിഗ്നൽ,
മോഡിഫൈറ്റർ, മോഡിഫയറുകൾ, 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

സെർവർ നോസർവർ
ഗണം സെർവർ EMPTYSETSERVER

സിനോഡ് നോക്നോഡ്
ഗണം സിനോഡ് EMPTYSETCNODE

അത് NOQ
ഗണം അത് എംപ്റ്റിസെറ്റ്ക്യൂ

ഇയ്യോബ് ജോലിയില്ല
ഗണം ഇയ്യോബ് EMPTYSETJOB

സ്ട്രിംഗ് NULLSTR

ഐഡന്റിഫയർ

ഐഡന്റിഫയറുകൾ (വേരിയബിൾ പേരുകൾക്കും ഫംഗ്‌ഷൻ പേരുകൾക്കും ഉപയോഗിക്കുന്നു) ആൽഫാന്യൂമെറിക് ഫോർമാറ്റിലാണ്.
അനുവദനീയമായ പ്രത്യേക അടിവര (_) പ്രതീകം. നിലവിൽ, BASL-ന് ഐഡന്റിഫയറുകൾ മാത്രമേ കൈകാര്യം ചെയ്യാനാകൂ
80 അക്ഷരങ്ങൾ വരെ നീളം. കൂടാതെ, നിങ്ങൾക്ക് BASL-നിർവചിച്ച സ്ഥിരമായ പേരുകൾ ഉപയോഗിക്കാൻ കഴിയില്ല
ഒരു ഐഡന്റിഫയർ നാമകരണം ചെയ്യുന്നു.

പ്രസ്താവനകൾ

In BASL(2), നിങ്ങൾക്ക് ഒരു അർദ്ധവിരാമം അല്ലെങ്കിൽ ഒരു കൂട്ടം ഉപയോഗിച്ച് അവസാനിപ്പിക്കുന്ന ഒരൊറ്റ പ്രസ്താവന ഉണ്ടായിരിക്കാം
പ്രസ്താവനകൾ (സംയുക്ത പ്രസ്താവന അല്ലെങ്കിൽ ബ്ലോക്ക് എന്ന് വിളിക്കുന്നു) '{', '}' എന്നിവയാൽ വേർതിരിച്ചിരിക്കുന്നു. വ്യത്യസ്തമായത്
ഒരു BASL കോഡിൽ ദൃശ്യമാകുന്ന തരത്തിലുള്ള പ്രസ്താവനകൾ ഇവയാണ്:

1. എക്സ്പ്രഷൻ പ്രസ്താവന
എക്സ്പ്രഷൻ പ്രസ്താവനകൾ ഏതെങ്കിലും തരത്തിലുള്ളതാണ്:

exr ;

എവിടെ exr ആകാം:

a) ഗണിത പദപ്രയോഗങ്ങൾ

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;
sz1 * sz2 * 2;
sz1 / 1024;

p1 = "ബാസൽ";
p2 = " തണുത്ത";

// The പിന്തുടരുന്ന is a സ്ട്രിംഗ് ഒത്തുചേരൽ
// ഓപ്പറേഷൻ ഫലമായി in The സ്ട്രിംഗ്:
// "ബാസൽ തണുത്ത"
p1 + str2;

i1 % 10;

b) ഏകീകൃത ഭാവങ്ങൾ

+expr // നല്ല - പെരുകുന്നു by 1 an
// പദപ്രയോഗം ആ is
// of ഇൻറ്റ്, ഫ്ലോട്ട്, or
// വലുപ്പം ടൈപ്പ് ചെയ്യുക

-expr // നെഗറ്റീവ് - പെരുകുന്നു by -1 an
// പദപ്രയോഗം ആ is
// of ഇൻറ്റ്, ഫ്ലോട്ട്, or
// വലുപ്പം ടൈപ്പ് ചെയ്യുക

!expr // അല്ല - പരിവർത്തനം ചെയ്യുന്നു a പൂജ്യമല്ലാത്തത് exr
// മൂല്യം കടന്നു 0, ഒപ്പം a
// പൂജ്യം exr മൂല്യം കടന്നു 1
// എവിടെ exr ടൈപ്പ് ചെയ്യുക ആവശമാകുന്നു 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 ഫ്ലോട്ട്
ഡേഓഫ് വീക്ക് ഡേഓഫ് വീക്ക്
തീയതി ടൈം തീയതി ടൈം
സ്ട്രിംഗ് സ്ട്രിംഗ്
വലുപ്പം വലുപ്പം
സെർവർ സെർവർ
അത് അത്
ഇയ്യോബ് ഇയ്യോബ്
സിനോഡ് സിനോഡ്
ഗണം സെർവർ ഗണം സെർവർ
ഗണം അത് ഗണം അത്
ഗണം ഇയ്യോബ് ഗണം ഇയ്യോബ്
ഗണം സിനോഡ് ഗണം സിനോഡ്

വേണ്ടി ഒപ്പം, OR ഓപ്പറേറ്റർമാർ, ദി lexpr, rexpr സ്ഥിരതയുള്ള തരങ്ങൾ Int അല്ലെങ്കിൽ
ഫ്ലോട്ട്.

ചില സാമ്പിൾ ലോജിക്കൽ എക്സ്പ്രഷനുകൾ:

i1 EQ i2;
i1 NEQ f2;
dow1 LE ഡൗൺ2;
d1 LT d2;
p1 GT str2;
sz1 GE sz2;

d) പോസ്റ്റ്-ഓപ്പറേറ്റർ എക്സ്പ്രഷനുകൾ
അസൈൻമെന്റിലേക്കുള്ള കുറുക്കുവഴി മാത്രമുള്ള എക്സ്പ്രഷനുകളാണിത്
പ്രസ്താവനകൾ.

ഐഡന്റിഫയർ++; // ഐഡന്റിഫയർ=ഐഡന്റിഫയർ+1
ഐഡന്റിഫയർ--; // ഐഡന്റിഫയർ=ഐഡന്റിഫയർ-1

ഐഡന്റിഫയർ Int അല്ലെങ്കിൽ Float തരം ആയിരിക്കണം.

ഉദാഹരണം:
int i;
ഫ്ലോട്ട് f;

ഞാൻ ++;
f--;

e) ഫംഗ്ഷൻ കോൾ

ഫംഗ്ഷൻ-നാമം ( arg1 ,arg2 ... , argN )

എവിടെ arg1, ..., argN ഏതെങ്കിലും സ്ഥിരമോ വേരിയബിളോ ആകാം. നിനക്ക് പറ്റില്ല
ഒരു ആർഗ്യുമെന്റായി മറ്റൊരു ഫംഗ്ഷൻ കോൾ.
ഉദാഹരണം:
അസാധുവാണ് pr(Int a) {
പ്രിന്റ് (എ);
}

pr(5);

ഒരു ഷെഡ്യൂളർ എഴുത്തുകാരന് കഴിയുന്ന ചില മുൻനിശ്ചയിച്ച ഫംഗ്ഷനുകൾ ഉണ്ട്
നിർവചിക്കാതെ തന്നെ അവന്റെ/അവളുടെ BASL കോഡിൽ സ്വയമേവ വിളിക്കുക.
ഈ ഫംഗ്‌ഷനുകളെ അസിസ്റ്റ് ഫംഗ്‌ഷനുകൾ (അല്ലെങ്കിൽ സഹായി) എന്ന് വിളിക്കുന്നു
പ്രവർത്തനങ്ങൾ) കൂടാതെ അവ ചുവടെ ചർച്ചചെയ്യുന്നു മുൻകൂട്ടി നിശ്ചയിച്ചത് പ്രവർത്തനങ്ങൾ വിഷയം.

f) സ്ഥിരാങ്കങ്ങൾ
സാധുവായ ചില സ്ഥിരമായ പദപ്രയോഗങ്ങൾ ഇനിപ്പറയുന്നവയിൽ നൽകിയിരിക്കുന്നു:
5;
+ 1.2;
സൂര്യൻ;
മോൺ;
TUE;
WED;
THU;
FRI;
SAT;
(4|4|1997);
(12:01:00);
(4|4|1997@12:01:00);
"അത്ഭുതം";
-1 ബി;
SYNCRUN;
ASYNCRUN;
ഇല്ലാതാക്കുക;
RERUN;
പിടിക്കുക;
പ്രകാശനം;
സിഗ്നൽ;
മോഡിഫൈറ്റർ;
മോഡിഫയറുകൾ;
(1, 3);
(2.3, 4.6);
(WED, FRI);
((4|4|1997), (4|10|1997));
((12:01:00), (12:30:00));
((4|4|1997@12:01:00), (4|10|1997@12:30:00));
(23 ജിബി, 50 ജിബി);
നോസർവർ;
നോക്നോഡ്;
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;

g) ഐഡന്റിഫയർ

ഉദാഹരണം:
ഇന്റ് ഐ;

i;

2. അസൈൻമെന്റ് പ്രസ്താവന

ഐഡന്റിഫയർ = exr ;

ഐഡന്റിഫയർ ഒപ്പം exr പോലെ പരസ്പരം സ്ഥിരതയുള്ള തരങ്ങൾ ഉണ്ടായിരിക്കണം
ഇനിപ്പറയുന്ന പട്ടികയിൽ ചിത്രീകരിച്ചിരിക്കുന്നു:

ഐഡന്റിഫയർ exr
================ ================
int ഇൻറ്റ്, ഫ്ലോട്ട്
ഫ്ലോട്ട് ഇൻറ്റ്, ഫ്ലോട്ട്
ഡേഓഫ് വീക്ക് ഡേഓഫ് വീക്ക്
തീയതി ടൈം തീയതി ടൈം
സ്ട്രിംഗ് സ്ട്രിംഗ്
വലുപ്പം വലുപ്പം
അത് അത്
ഇയ്യോബ് ഇയ്യോബ്
സിനോഡ് സിനോഡ്
സെർവർ സെർവർ
ഡേഓഫ് വീക്ക് ഡേഓഫ് വീക്ക്
തീയതി ടൈം തീയതി ടൈം
ഗണം സെർവർ ഗണം സെർവർ
ഗണം അത് ഗണം അത്
ഗണം ഇയ്യോബ് ഗണം ഇയ്യോബ്
ഗണം സിനോഡ് ഗണം സിനോഡ്
ശ്രേണി int ശ്രേണി int
ശ്രേണി ഫ്ലോട്ട് ശ്രേണി ഫ്ലോട്ട്
ശ്രേണി ഡേഓഫ് വീക്ക് ശ്രേണി ഡേഓഫ് വീക്ക്
ശ്രേണി തീയതി ടൈം ശ്രേണി തീയതി ടൈം
ശ്രേണി വലുപ്പം ശ്രേണി വലുപ്പം

3. എങ്കിൽ...അല്ലെങ്കിൽ പ്രസ്താവന
ഒരു if സ്റ്റേറ്റ്‌മെന്റിന്റെ ഫോർമാറ്റ് ഡീലിമിറ്റിംഗ് ഉപയോഗിച്ച് C യിൽ ഉള്ളതിന് സമാനമാണ്
"{" ഉം "}" ഉം എപ്പോഴും ഉണ്ട്:

എങ്കിൽ ( exr ) {
പൂജ്യം or കൂടുതൽ (ശരി) പ്രസ്താവനകൾ
}

എങ്കിൽ ( exr ) {
പൂജ്യം or കൂടുതൽ (ശരി) പ്രസ്താവനകൾ
} മറ്റാരെങ്കിലും {
പൂജ്യം or കൂടുതൽ (തെറ്റായ) പ്രസ്താവനകൾ
}

ദി exr 's തരം ഒന്നുകിൽ Int അല്ലെങ്കിൽ Float ആയിരിക്കണം, മൂല്യനിർണ്ണയത്തിന് ശേഷം അത് ആണെങ്കിൽ
മൂല്യം പൂജ്യമല്ല, തുടർന്ന് യഥാർത്ഥ പ്രസ്താവനകൾ നടപ്പിലാക്കുന്നു. രണ്ടാമത്തേതിൽ
ഫോം, എങ്കിൽ exr പൂജ്യമായി വിലയിരുത്തുന്നു, തുടർന്ന് തെറ്റായ പ്രസ്താവനകൾ നടപ്പിലാക്കുന്നു.

കുറച്ച് സാമ്പിൾ if പ്രസ്താവനകൾ ചുവടെ നൽകിയിരിക്കുന്നു:

if (2 * x )
{
y = y + 3;
പ്രിന്റ് (y);
}

if (2 * x ) {
y = y + 3;
} മറ്റാരെങ്കിലും {
എങ്കിൽ ( 3 * x ) {
y = 4;
} മറ്റാരെങ്കിലും {
y = 5;
}
}

4. വേണ്ടി ലൂപ്പ് പ്രസ്താവന
ഒരു പ്രസ്താവനയുടെ ഫോർമാറ്റ് ഇപ്രകാരമാണ്:

വേണ്ടി( ആരംഭിക്കുക; പരിശോധന; നടപടി ) {
പൂജ്യം or കൂടുതൽ പ്രസ്താവനകൾ
}

സിയിലെന്നപോലെ, വേണ്ടി ആദ്യം നിർവ്വഹിക്കുന്നു തുടക്കം , തുടർന്ന് വിലയിരുത്തുന്നു പരിശോധന കണ്ടീഷൻ
ഇത് പൂജ്യമല്ലാത്ത ഒരു മൂല്യം നൽകുന്നുണ്ടോ എന്നറിയാൻ. അത് ചെയ്താൽ, ദി വേണ്ടി പ്രസ്താവനകളാണ്
വധിച്ചു. ശേഷം വേണ്ടി പ്രസ്താവനകൾ നടപ്പിലാക്കുന്നു, തുടർന്ന് നടപടി വിലയിരുത്തപ്പെടുന്നു,
തുടർന്ന് അത് പരിശോധിക്കുന്നു പരിശോധന മുമ്പത്തെ അതേ രീതിയിൽ വീണ്ടും അവസ്ഥ.
തുടക്കം ഒപ്പം നടപടി ഒരു ലളിതമായ അസൈൻമെന്റ് എക്സ്പ്രഷൻ അല്ലെങ്കിൽ ഒരു പോസ്റ്റ്-ഓപ്പറേറ്റർ ആകാം
എക്സ്പ്രഷൻ. പരിശോധന ഒരു ലോജിക്കൽ/റിലേഷണൽ എക്സ്പ്രഷൻ ആണ്. ചില സാമ്പിൾ
പ്രസ്താവനകൾ ഇനിപ്പറയുന്നവയിൽ നൽകിയിരിക്കുന്നു:

വേണ്ടി (i = 0; i LT 3 ; i = i + 1)
{
പ്രിന്റ് (i);
}

വേണ്ടി (i = 0; i LT 2 * x; i++)
{
if (x GT 3)
{
y = 99;
} മറ്റാരെങ്കിലും
{
x = 73;
}
}

5. foreach ലൂപ്പ് പ്രസ്താവന
ഈ പ്രസ്താവന പ്രാഥമികമായി ഓരോ ഘടകങ്ങളുടെയും തുടർച്ചയായി വീണ്ടെടുക്കാൻ ഉപയോഗിക്കുന്നു
ഒരു സെറ്റ് ഡാറ്റ തരം: സെറ്റ് സെർവർ, സെറ്റ് സി നോഡ്, സെറ്റ് ജോബ്, സെറ്റ് ക്യൂ. വാക്യഘടന ഇതാണ്:

foreach ( ഐഡന്റിഫയർ1 in ഐഡന്റിഫയർ2 ) {
പൂജ്യം or കൂടുതൽ പ്രസ്താവനകൾ
}

ഐഡന്റിഫയറുകൾക്കായി ഇനിപ്പറയുന്ന ജോടി തരങ്ങൾ അനുവദനീയമാണ്:

ഐഡന്റിഫയർ1 ഐഡന്റിഫയർ2
============ ============
സെർവർ ഗണം സെർവർ
അത് ഗണം അത്
ഇയ്യോബ് ഗണം ഇയ്യോബ്
സിനോഡ് ഗണം സിനോഡ്

ഉദാഹരണം:
സെർവർ s;
അത് q;
ഇയ്യോബ് j;
സിനോഡ് c;

ഗണം സെർവർ എസ്എസ്;
ഗണം അത് ചതുരശ്ര അടി;
ഗണം ഇയ്യോബ് sj;
ഗണം സിനോഡ് sc;

ഫോറെച്ച്(കൾ in ss){
പ്രിന്റ്(കൾ);
}
ഫോറെച്ച്(ക്യു in ചതുരശ്ര){
പ്രിന്റ് (ക്യു);
}
ഫോറെച്ച്(ജെ in sj){
പ്രിന്റ് (ജെ);
}
ഫോറെച്ച്(സി in sc){
പ്രിന്റ് (സി);
}

6. സമയത്ത് ലൂപ്പ് പ്രസ്താവന
a while ലൂപ്പിന്റെ വാക്യഘടന ഇതാണ്:

സമയത്ത് ( exr ) {
പൂജ്യം or കൂടുതൽ പ്രസ്താവനകൾ
}

എവിടെ exr Int അല്ലെങ്കിൽ Float തരം ആയിരിക്കണം. എങ്കിൽ exr പൂജ്യമല്ല, പിന്നെ പൂജ്യം
അല്ലെങ്കിൽ കൂടുതൽ പ്രസ്താവനകൾ നടപ്പിലാക്കുകയും ചെയ്യുന്നു exr പുനർമൂല്യനിർണയം നടത്തുന്നു.

ഉദാഹരണം:
int i;
i = 3;
അതേസമയം (i) {
എങ്കിൽ ( i EQ 0 ) {
പ്രിന്റ് ("ബ്രേക്ക് on i = 1");
പൊട്ടി;
}
i--;
}

7. മാറുക പ്രസ്താവന
എന്ന് പരിശോധിക്കുന്ന ഒരു മൾട്ടി-വേ തീരുമാനമാണ് സ്വിച്ച് സ്റ്റേറ്റ്മെന്റ്
ഐഡന്റിഫയറിന്റെ മൂല്യം നിരവധി മൂല്യങ്ങളിൽ ഒന്നുമായി പൊരുത്തപ്പെടുന്നു, ശാഖകൾ a യുമായി പൊരുത്തപ്പെടുന്നു
അതനുസരിച്ച് പ്രസ്താവനകളുടെ കൂട്ടം.
ഒരു സ്വിച്ച് സ്റ്റേറ്റ്‌മെന്റിന്റെ വാക്യഘടന ഇതാണ്:

സ്വിച്ചുചെയ്യുക ( ഐഡന്റിഫയർ ) {
കേസ് സ്ഥിരം-എക്സ്പ്രർ :
{
പൂജ്യം or കൂടുതൽ പ്രസ്താവനകൾ
}
കേസ് സ്ഥിരം-എക്സ്പ്രർ :
{
പൂജ്യം or കൂടുതൽ പ്രസ്താവനകൾ
}
...
കേസ് in കോൺസ്റ്റന്റ്-റേഞ്ച്OrSet-expr :
{
പൂജ്യം or കൂടുതൽ പ്രസ്താവനകൾ
}
കേസ് in IDENTIFIER-rangeOrSettype :
{
പൂജ്യം or കൂടുതൽ പ്രസ്താവനകൾ
}
സ്ഥിരസ്ഥിതി :
{
പൂജ്യം or കൂടുതൽ പ്രസ്താവനകൾ
}
}

എവിടെ സ്ഥിരം-എക്സ്പ്രർ ഒരു ആണ് exr ഇന്റെ തരം Int, ഫ്ലോട്ട്, Dayofweek, DateTime,
വലുപ്പം, സ്ട്രിംഗ്, സെർവർ, ക്യൂ, ജോലി അല്ലെങ്കിൽ സിനോഡ്. കോൺസ്റ്റന്റ്-റേഞ്ച്OrSet-expr ഒപ്പം
IDENTIFIER-rangeOrSettype സെറ്റ് സെർവർ, സെറ്റ് സി നോഡ്, സെറ്റ് ക്യൂ, സെറ്റ് എന്നിങ്ങനെയായിരിക്കാം
ജോലി, റേഞ്ച് ഇന്റ്, റേഞ്ച് ഫ്ലോട്ട്, റേഞ്ച് ഡയോഫ് വീക്ക്, റേഞ്ച് തീയതി സമയം അല്ലെങ്കിൽ റേഞ്ച് സൈസ്.

ഐഡന്റിഫയർ ശൂന്യമായ തരത്തിലാകാൻ കഴിയില്ല. ഐഡന്റിഫയർ 's തരം സ്ഥിരതയുള്ളതായിരിക്കണം
കൂടെ സ്ഥിരം-എക്സ്പ്രർ ന്റെ, കോൺസ്റ്റന്റ്-റേഞ്ച്OrSet-expr ന്റെ, ഒപ്പം ഐഡന്റിഫയർ-
rangeOrSettype 's ഇനിപ്പറയുന്ന പട്ടികയിൽ കാണിച്ചിരിക്കുന്നതുപോലെ ടൈപ്പ് ചെയ്യുക:
ഐഡന്റിഫയർ സ്ഥിരമായ ശ്രേണി-എക്സ്പ്രർ, ഐഡന്റിഫയർ-റേഞ്ച് ടൈപ്പ്
============ =========================================
സെർവർ ഗണം സെർവർ
അത് ഗണം അത്
ഇയ്യോബ് ഗണം ഇയ്യോബ്
സിനോഡ് ഗണം സിനോഡ്
int ശ്രേണി int
ഫ്ലോട്ട് ശ്രേണി ഫ്ലോട്ട്
ഡേഓഫ് വീക്ക് ശ്രേണി ഡേഓഫ് വീക്ക്
തീയതി ടൈം ശ്രേണി തീയതി ടൈം
വലുപ്പം ശ്രേണി വലുപ്പം

ഒരു കേസ് എക്സ്പ്രഷൻ പൊരുത്തപ്പെടുന്നെങ്കിൽ ഐഡന്റിഫയർ 's മൂല്യം, തുടർന്ന് അനുബന്ധം
പ്രസ്താവനകളുടെ ബ്ലോക്ക് എക്സിക്യൂട്ട് ചെയ്യുന്നു. സിയിൽ നിന്ന് വ്യത്യസ്തമായി, എക്സിക്യൂഷൻ വീഴുന്നില്ല
അടുത്ത കേസ് പ്രസ്താവനയിലേക്ക്. അതിനുള്ള കാരണം അതാണ് basl2c ഉദ്ദേശിക്കുന്ന
ഇത് വിവർത്തനം ചെയ്യുക മാറുക if-elseif-else construct എന്നതിലേക്ക് പ്രസ്താവന. കേസ്
മറ്റ് കേസുകളൊന്നും തൃപ്തികരമല്ലെങ്കിൽ ലേബൽ ചെയ്ത ഡിഫോൾട്ട് എക്സിക്യൂട്ട് ചെയ്യപ്പെടും. ദി
സ്ഥിരസ്ഥിതി ഓപ്ഷണൽ ആണ്; അത് അവിടെ ഇല്ലെങ്കിൽ, കേസുകളൊന്നും പൊരുത്തപ്പെടുന്നില്ലെങ്കിൽ, ഇല്ല
പ്രവർത്തനം നടക്കുന്നു.

ഉദാഹരണം:
ഡേഓഫ് വീക്ക് ഡോവ്;

സ്വിച്ച് (ഡൗ)
{
കേസ് മോഡൽ:
{
പ്രിന്റ് ("കേസ് MON");
}
കേസ് ചൊവ്വ:
{
പ്രിന്റ് ("കേസ് TUE");
}
കേസ് വിവാഹം:
{
പ്രിന്റ് ("കേസ് WED");
}
കേസ് സമാഹാരം:
{
പ്രിന്റ് ("കേസ് THU");
}
കേസ് സൗ ജന്യം:
{
പ്രിന്റ് ("കേസ് FRI");
}
കേസ് സാറ്റ്:
{
പ്രിന്റ് ("കേസ് SAT");
}
കേസ് സൂര്യൻ:
{
പ്രിന്റ് ("കേസ് സൂര്യൻ");
}
സ്ഥിരസ്ഥിതി:
{
പ്രിന്റ് ("കേസ് സ്ഥിരസ്ഥിതി");
}
}

int a;
ശ്രേണി int Ri;
ri = (ക്സനുമ്ക്സ, 12);
സ്വിച്ച് (എ)
{
കേസ് in (1,5):
{
പ്രിന്റ് ("കേസ് 1,5");
}
കേസ് in (6,9):
{
പ്രിന്റ് ("കേസ് 6,9");
}
കേസ് in Ri:
{
പ്രിന്റ് ("കേസ് Ri");
}
}

8. അച്ചടിക്കുക പ്രസ്താവന
പ്രിന്റ് സ്റ്റേറ്റ്‌മെന്റിന് ഏത് മൂല്യത്തിന്റെയും മൂല്യം വ്യക്തമാക്കാൻ പ്രിന്റ് ചെയ്യാൻ കഴിയും ഐഡന്റിഫയർ
or സ്ഥിരമായ ഇന്റെ തരം Int, Float, Dayofweek, DateTime, String, Size, Que, Job,
CNode, Server, Range Int, Range Float, Range Dayofweek, Range DateTime,
പരിധി വലിപ്പം.
സിന്റാക്സ് ഇപ്രകാരമാണ്:

അച്ചടിക്കുക ( ഐഡന്റിഫയർ );
അച്ചടിക്കുക ( സ്ഥിരമായ );

ഉദാഹരണം:
തീയതി ടൈം dt;
സിനോഡ് cn;

dt = (4|4|1997@12:13:36);
cn = AllNodesLocalHostGet();

പ്രിന്റ് (dt);
പ്രിന്റ് (cn);

സെറ്റ് തരങ്ങൾക്ക്, ഉപയോഗിക്കുക foreach ഓരോ ഘടകത്തിലൂടെയും പോയി ഇതുപോലെ പ്രിന്റ് ചെയ്യാൻ:

സെർവർ s;
ഗണം സെർവർ എസ്എസ്;

ss = AllServersGet();

ഫോറെച്ച്(കൾ in ss) {
പ്രിന്റ്(കൾ);
}

9. പ്രസ്താവന തുടരുക

തുടരുക ;

ദി തുടരുക a-നുള്ളിൽ പ്രസ്താവന അഭ്യർത്ഥിച്ചിരിക്കണം വേണ്ടി, മുന്നോട്ട്, ഒപ്പം
സമയത്ത് ലൂപ്പ്. എൻക്ലോസിംഗ് ലൂപ്പിന്റെ അടുത്ത ആവർത്തനം ആരംഭിക്കുന്നതിന് ഇത് കാരണമാകുന്നു.

10. ബ്രേക്ക് സ്റ്റേറ്റ്മെന്റ്

ഇടവേള ;

ദി ഇടവേള a-നുള്ളിൽ പ്രസ്താവന അഭ്യർത്ഥിച്ചിരിക്കണം വേണ്ടി, മുന്നോട്ട്, ഒപ്പം സമയത്ത്
ലൂപ്പ്. ഇത് എൻക്ലോസിംഗ് ലൂപ്പിൽ നിന്ന് നേരത്തെയുള്ള എക്സിറ്റ് നൽകുന്നു.

11. റിട്ടേൺ സ്റ്റേറ്റ്മെന്റ്

മടക്കം (ഐഡന്റിഫയർ) ;
തിരിച്ചുവരവ് (സ്ഥിരമായ) ;
മടക്കം () ;

റിട്ടേൺ സ്റ്റേറ്റ്മെന്റ് മൂല്യം (എന്തെങ്കിലും ഉണ്ടെങ്കിൽ) നൽകുന്നു a
പ്രവർത്തനം. തിരികെ നൽകിയ തരം ഐഡന്റിഫയർ ഒപ്പം സ്ഥിരമായ പൊരുത്തപ്പെടണം
കോളിംഗ് ഫംഗ്‌ഷന്റെ റിട്ടേൺ തരം. സ്ഥിരമായ അനുവദനീയമായ തരങ്ങൾ ഒഴികെ
സെറ്റ്, റേഞ്ച് തരങ്ങൾ. അവസാന ഫോർമാറ്റ്, മടക്കം () സാധാരണയായി a ഉള്ളിൽ വിളിക്കുന്നു
ഒരു മൂല്യവും നൽകാത്ത ഫംഗ്‌ഷൻ ( പോലെ ഷെഡ്_മെയിൻ() ).

12. എക്സിറ്റ് സ്റ്റേറ്റ്മെന്റ്

എക്സിറ്റ് (സ്ഥിരമായ);

എവിടെ സ്ഥിരമായ Int എന്ന തരത്തിലുള്ളതാണ്. ഇത് വിളിക്കുന്നത് ഷെഡ്യൂളറെ അവസാനിപ്പിക്കും.

13. അഭിപ്രായ പ്രസ്താവന
ഇവ "//" പ്രിഫിക്‌സ് ചെയ്ത പ്രസ്താവനകളാണ്, അവ BASL അവഗണിക്കുന്നു
കംപൈലർ.

// ഈ വര is അവഗണിച്ചു
int i; // സ്ട്രിംഗ് പിന്തുടരുന്ന The വെട്ടുന്നു is അവഗണിച്ചു

ഓപ്പറേറ്റർ മുൻതൂക്കം ഒപ്പം അസോസിയേറ്റിവിറ്റി

താഴെപ്പറയുന്ന പട്ടിക വിവിധ ഓപ്പറേറ്റർ മുൻഗണനാ തലങ്ങളും അസോസിയേറ്റിവിറ്റിയും നിർവചിച്ചിരിക്കുന്നു
BASL ഭാഷയിൽ. മുൻ‌ഗണന കുറയുന്ന ക്രമത്തിലാണ് ഓപ്പറേറ്റർമാരെ പട്ടികപ്പെടുത്തിയിരിക്കുന്നത്. ദി
ഒരു ഓപ്പറേറ്ററുടെ മുൻഗണനയേക്കാൾ ഉയർന്നത്, അത് നേരത്തെ തന്നെ നടപ്പിലാക്കും. ക്രമം
ഒരേ തലത്തിലുള്ള ഓപ്പറേറ്റർമാർ അസോസിയേറ്റിവിറ്റിയെ ആശ്രയിച്ചിരിക്കുന്നു: ഇടത് എന്നാൽ
ഓപ്പറേറ്റർമാരെ ഇടത്തുനിന്ന് വലത്തോട്ട് കാണുന്നു, വലത് എന്നാൽ വലത്തുനിന്ന് ഇടത്തോട്ട് കാണുന്നു.

ഓപ്പറേറ്റർ അസോസിയേറ്റിവിറ്റി
======================================= ==============
! ++ -- + (ഏകമായ പ്ലസ്) - (ഏകമായ മൈനസ്) വലത്
* / % ഇടത്തെ
+ - ഇടത്തെ
LT LE GT GE ഇടത്തെ
EQ NEQ ഇടത്തെ
ഒപ്പം ഇടത്തെ
OR ഇടത്തെ
= വലത്

മുൻകൂട്ടി നിശ്ചയിച്ചത് പ്രവർത്തനങ്ങൾ

In BASL(2), ടു സെർവർ ഒരു ബാച്ച് സെർവർ ഒബ്‌ജക്‌റ്റിലേക്ക് നേരിട്ട് ഡാറ്റ തരം മാപ്പുകൾ. സമാനമായി, സിനോഡ്
അമ്മ / റെസ്മോം ആണ്, ഇയ്യോബ് ബാച്ച് ജോലിയാണ്, ഒപ്പം അത് ബാച്ച് ക്യൂ ആണ്. എന്നിരുന്നാലും, എല്ലാം അല്ല
PBS ഒബ്‌ജക്‌റ്റുകളിലേക്കുള്ള ആട്രിബ്യൂട്ടുകൾ BASL-ൽ നിന്ന് ആക്‌സസ് ചെയ്യാൻ കഴിയും. ആട്രിബ്യൂട്ടുകളുടെ ഒരു ഉപവിഭാഗം മാത്രം,
ഒരു ഷെഡ്യൂളറുടെ സന്ദർഭത്തിൽ അർത്ഥമുണ്ടെന്ന് തോന്നിയവ, ലഭ്യമാക്കിയിട്ടുണ്ട്, കൂടാതെ
ഈ ആട്രിബ്യൂട്ടുകളിലേക്കുള്ള മൂല്യങ്ങൾ ഇനിപ്പറയുന്ന മുൻനിർവചിച്ച ഫംഗ്‌ഷനുകൾ വിളിക്കുന്നതിലൂടെ ആക്‌സസ് ചെയ്യാൻ കഴിയും,
അസിസ്റ്റ്/ഹെൽപ്പർ ഫംഗ്‌ഷനുകൾ എന്നും അറിയപ്പെടുന്നു.

(1) സെർവറുമായി ബന്ധപ്പെട്ട പ്രവർത്തനങ്ങൾ

ഗണം സെർവർ AllServersGet(അസാധു)
എന്നതിനായുള്ള കോൺഫിഗറേഷൻ ഫയലിൽ വ്യക്തമാക്കിയ സെർവറുകളുടെ ലിസ്റ്റ് നൽകുന്നു
സിസ്റ്റം ഇടയ്ക്കിടെ പരിശോധിക്കണമെന്ന് ഷെഡ്യൂളർ റൈറ്റർ ആഗ്രഹിക്കുന്നു
സ്റ്റാറ്റസ്, ക്യൂകൾ, ജോലി വിവരങ്ങൾ. കാണുക pbs__sched__basl(8 ബി) ഒരു വേണ്ടി
കോൺഫിഗറേഷൻ ഫയലിന്റെ ഫോർമാറ്റിനെക്കുറിച്ചുള്ള ചർച്ച.
ജാഗ്രത: ഈ ഫംഗ്ഷൻ ഉള്ളിൽ നിന്ന് വിളിക്കണം ഷെഡ്_മെയിൻ() so
ഓരോ ഷെഡ്യൂളിംഗ് ആവർത്തനത്തിലും, ഏറ്റവും കാലികമായത് ഗണം സെർവർ
ഘടന തിരികെ ലഭിച്ചു.

സെർവർ AllServersLocalHostGet(അസാധു)
പ്രാദേശിക ഹോസ്റ്റിനെ പ്രതിനിധീകരിക്കുന്ന സെർവർ ഒബ്‌ജക്റ്റ് നൽകുന്നു. സജ്ജീകരിക്കാത്ത മൂല്യം:
നോസർവർ. നോൺ-ക്ലസ്റ്റർ പരിതസ്ഥിതികൾക്കായി വിളിക്കുന്നതിനുള്ള ഒരു ലളിതമായ പ്രവർത്തനമാണിത്
ഒരു സെർവർ ഹോസ്റ്റ് മാത്രമേ നിലനിൽക്കുന്നുള്ളൂ.
ജാഗ്രത: ഈ ഫംഗ്ഷൻ ഉള്ളിൽ നിന്ന് വിളിക്കണം ഷെഡ്_മെയിൻ() (അല്ലെങ്കിൽ നിന്ന്
sched_main വിളിക്കുന്ന പ്രവർത്തനത്തിനുള്ളിൽ) അങ്ങനെ എല്ലാ ഷെഡ്യൂളിംഗിലും
ആവർത്തനം, ഏറ്റവും കാലികമായത് സെർവർ ഘടന തിരികെ ലഭിച്ചു.

സ്ട്രിംഗ് ServerInetAddrGet(സെർവർ s)
സെർവറിന്റെ പേര് നൽകുന്നു. സജ്ജീകരിക്കാത്ത മൂല്യം: NULLSTR

സ്ട്രിംഗ് ServerDefQueGet(സെർവർ s)
സെർവർ s-ന്റെ default_queue ആട്രിബ്യൂട്ട് നൽകുന്നു. സജ്ജീകരിക്കാത്ത മൂല്യം: NULLSTR

int ServerStateGet(സെർവർ s)
സെർവറിന്റെ സെർവർ_സ്റ്റേറ്റ് ആട്രിബ്യൂട്ട് നൽകുന്നു.

റിട്ടേൺ മൂല്യം:
SERVER_ACTIVE, SERVER_IDLE, SERVER_SCHED, SERVER_TERM,
SERVER_TERMDELAY, -1 (മൂല്യം സജ്ജമാക്കിയിട്ടില്ല)

int ServerMaxRunJobsGet(സെർവർ s)
സെർവർ s-ന്റെ max_running ആട്രിബ്യൂട്ട് നൽകുന്നു. സജ്ജീകരിക്കാത്ത മൂല്യം: 0

int ServerMaxRunJobsPerUserGet(സെർവർ s)
സെർവർ s-ന്റെ max_user_run ആട്രിബ്യൂട്ട് നൽകുന്നു. സജ്ജീകരിക്കാത്ത മൂല്യം: 0

int ServerMaxRunJobsPerGroupGet(സെർവർ s)
സെർവർ s-ന്റെ max_group_run ആട്രിബ്യൂട്ട് നൽകുന്നു. സജ്ജീകരിക്കാത്ത മൂല്യം: 0

ഗണം അത് ServerQueuesGet(സെർവർ s)
സെർവർ നിയന്ത്രിക്കുന്ന ക്യൂകളുടെ ലിസ്റ്റ് നൽകുന്നു.

ഗണം ഇയ്യോബ് ServerJobsGet(സെർവർ s)
സെർവർ മാനേജ് ചെയ്യുന്ന ജോലികളുടെ ലിസ്റ്റ് നൽകുന്നു. ഇതിന്റെ ഒരു ഉപവിഭാഗം ലഭിക്കുന്നതിന്
പട്ടിക, കാണുക QueJobsGet().

int ServerIntResAvailGet(സെർവർ s, സ്ട്രിംഗ് പേര്)
നിർദ്ദിഷ്ട ഉറവിടത്തിലേക്ക് മൂല്യം നൽകുന്നു പേര് അത് ജോലികൾക്ക് ലഭ്യമാണ്
ഈ സെർവർ പ്രവർത്തിപ്പിക്കുന്നത് (സെർവർ ഉറവിടങ്ങൾ_ലഭ്യം.പേര് ആട്രിബ്യൂട്ട്). ഇതിനെ വിളിക്കൂ
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;
// മടക്കം The # of cpus നിലവിൽ ലഭ്യമായ in
// The സെർവർ
cpuAvail = ServerIntResAvailGet(സെർവർ, "ncpus");

വലുപ്പം ServerSizeResAvailGet(സെർവർ s, സ്ട്രിംഗ് പേര്)
നിർദ്ദിഷ്ട ഉറവിടത്തിലേക്ക് മൂല്യം നൽകുന്നു പേര് അത് ജോലികൾക്ക് ലഭ്യമാണ്
ഈ സെർവർ പ്രവർത്തിപ്പിക്കുന്നത് (സെർവർ ഉറവിടങ്ങൾ_ലഭ്യം.പേര് ആട്രിബ്യൂട്ട്). ഇതിനെ വിളിക്കൂ
വലിപ്പം തരത്തിലുള്ള മൂല്യങ്ങളുള്ള ഉറവിടങ്ങൾക്കായുള്ള പ്രവർത്തനം. സാമ്പിൾ റിസോഴ്സ്
പേരുകൾ ഇവയാണ്: ഫയൽ, മെം, പിഎംഎം, വർക്കിംഗ് സെറ്റ്, 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;
// മടക്കം The തുക of ലഭ്യമായ മെമ്മറി in
// The സെർവർ
memAvail = ServerSizeResAvailGet(സെർവർ, "മെം");

സ്ട്രിംഗ് ServerStringResAvailGet(സെർവർ s, സ്ട്രിംഗ് പേര്)
നിർദ്ദിഷ്ട ഉറവിടത്തിലേക്ക് മൂല്യം നൽകുന്നു പേര് അത് ജോലികൾക്ക് ലഭ്യമാണ്
ഈ സെർവർ പ്രവർത്തിപ്പിക്കുന്നത് (സെർവർ ഉറവിടങ്ങൾ_ലഭ്യം.പേര് ആട്രിബ്യൂട്ട്). ഇതിനെ വിളിക്കൂ
സ്ട്രിംഗ് തരത്തിലുള്ള മൂല്യങ്ങളുള്ള ഉറവിടങ്ങൾക്കായുള്ള പ്രവർത്തനം. സാമ്പിൾ
ഉറവിട നാമങ്ങൾ ഇവയാണ്: നോഡുകൾ, കമാനം, നീഡ്നോഡുകൾ. ഇവയുടെ വിവരണത്തിന്
ഉറവിട നാമങ്ങൾ, കാണുക 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 ബി).

ഉദാഹരണം:
സ്ട്രിംഗ് തരം;
// മടക്കം The വാസ്തുവിദ്യ (അഥവാ os തരം) of
// The സെർവർ
ടൈപ്പ് ചെയ്യുക = ServerStringResAvailGet(സെർവർ, "കമാനം");

int ServerIntResAssignGet(സെർവർ s, സ്ട്രിംഗ് പേര്)
നിർദ്ദിഷ്ട ഉറവിടത്തിലേക്ക് മൂല്യം നൽകുന്നു പേര് ഇതിനായി അനുവദിച്ചിരിക്കുന്നു
പ്രവർത്തിപ്പിക്കുന്ന ജോലികൾ (സെർവർ റിസോഴ്സ്_അസൈൻഡ്.നാമം ആട്രിബ്യൂട്ട്). ഇതിനെ വിളിക്കൂ
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;
// മടക്കം The # of cpus നിലവിൽ നിയുക്തമാക്കി in
// The സെർവർ
cpuAssn = ServerIntResAssignGet(സെർവർ, "ncpus");

വലുപ്പം ServerSizeResAssignGet(സെർവർ s, സ്ട്രിംഗ് പേര്)
നിർദ്ദിഷ്ട ഉറവിടത്തിലേക്ക് മൂല്യം നൽകുന്നു പേര് ഇതിനായി അനുവദിച്ചിരിക്കുന്നു
പ്രവർത്തിപ്പിക്കുന്ന ജോലികൾ (സെർവർ റിസോഴ്സ്_അസൈൻഡ്.നാമം ആട്രിബ്യൂട്ട്). ഇതിനെ വിളിക്കൂ
വലിപ്പം തരത്തിലുള്ള മൂല്യങ്ങളുള്ള ഉറവിടങ്ങൾക്കായുള്ള പ്രവർത്തനം. സാമ്പിൾ റിസോഴ്സ്
പേരുകൾ ഇവയാണ്: ഫയൽ, മെം, പിഎംഎം, വർക്കിംഗ് സെറ്റ്, 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;
// മടക്കം The തുക of സ്ദ്സ് ഇടം നിലവിൽ നിയുക്തമാക്കി
// in The സെർവർ
sdsAssn = ServerSizeResAssignGet(സെർവർ, "sds");

സ്ട്രിംഗ് ServerStringResAssignGet(സെർവർ s, സ്ട്രിംഗ് പേര്)
നിർദ്ദിഷ്ട ഉറവിടത്തിലേക്ക് മൂല്യം നൽകുന്നു പേര് ഇതിനായി അനുവദിച്ചിരിക്കുന്നു
പ്രവർത്തിപ്പിക്കുന്ന ജോലികൾ (സെർവർ റിസോഴ്സ്_അസൈൻഡ്.നാമം ആട്രിബ്യൂട്ട്). ഇതിനെ വിളിക്കൂ
സ്ട്രിംഗ് തരത്തിലുള്ള മൂല്യങ്ങളുള്ള ഉറവിടങ്ങൾക്കായുള്ള പ്രവർത്തനം. സാമ്പിൾ
ഉറവിട നാമങ്ങൾ ഇവയാണ്: നോഡുകൾ, കമാനം, നീഡ്നോഡുകൾ. ഇവയുടെ വിവരണത്തിന്
ഉറവിട നാമങ്ങൾ, കാണുക 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 ബി).

ഗണം സിനോഡ് ServerNodesGet(സെർവർ s)
സെർവറുകൾ നിയന്ത്രിക്കുന്ന നോഡുകളുടെ സെറ്റ് നൽകുന്നു. സജ്ജീകരിക്കാത്ത മൂല്യം: EMPTYSETCNODE.
ശ്രദ്ധിക്കുക: നിങ്ങൾക്ക് സാധാരണയായി മടങ്ങിയ നോഡുകൾക്കായി ഇനിപ്പറയുന്ന ഫംഗ്‌ഷനുകൾ വിളിക്കാം
ഈ കോളിലൂടെ: CNodeStateGet(), CNodePropertiesGet(), കൂടാതെ CNodeTypeGet().

int ServerNodesQuery(സെർവർ 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 എന്ന മൂല്യം റെസിഡൻറ് ഇത് ഒരു ചെയ്യാൻ വേണ്ടിയുള്ളതാണ് എന്നാണ് അർത്ഥമാക്കുന്നത്
പുതിയ സംവരണം. അല്ലെങ്കിൽ, നമ്പർ നിലവിലുള്ളതിനെ പ്രതിനിധീകരിക്കും
(ഭാഗിക) സംവരണം. ഇതിനായി നിലവിൽ റിസർവ് ചെയ്തിട്ടുള്ള വിഭവങ്ങൾ റെസിഡൻറ് ഉദ്ദേശിക്കുന്ന
റിലീസ് ചെയ്യപ്പെടും, മുഴുവൻ റിസർവേഷനും വീണ്ടും ശ്രമിക്കും. അവിടെ
നിലവിലെ സമയം വ്യക്തമാക്കാൻ കഴിയുന്ന ഏക വിഭവങ്ങൾ
"നോഡുകൾ". എന്ന് വ്യക്തമാക്കണം നോഡുകൾ=സ്പെസിഫിക്കേഷൻ എവിടെ
-l ഓപ്‌ഷൻ ആർഗ്യുമെന്റ് ലിസ്റ്റിൽ ഒരു ഉപയോക്താവ് വ്യക്തമാക്കുന്നത് സ്‌പെസിഫിക്കേഷൻ ആണ്
നോഡുകൾക്കായി, qsub (1B) കാണുക.
ശ്രദ്ധിക്കുക: ഇത് ഒരു റാപ്പറാണ് pbs_rescreserv(3B) സെർവർ പ്രവർത്തനം.

റിട്ടേൺ മൂല്യം:
വിജയിച്ചതോ ഭാഗികമായി വിജയിച്ചതോ ആയ ഒരു റഫറൻസ് നമ്പർ
സംവരണം, അല്ലെങ്കിൽ പരാജയം

int ServerNodesRelease(സെർവർ s, int resid)
ഇത് റഫറൻസ് നമ്പർ ഉപയോഗിച്ച് റിസർവ് ചെയ്‌തിരിക്കുന്ന ഉറവിടങ്ങൾ റിലീസ് ചെയ്യുകയോ സ്വതന്ത്രമാക്കുകയോ ചെയ്യുന്നു
ൽ വ്യക്തമാക്കിയിരിക്കുന്നു റെസിഡൻറ്.
ശ്രദ്ധിക്കുക: ഇത് ഒരു റാപ്പറാണ് pbs_rescrelease(3B) സെർവർ പ്രവർത്തനം.

റിട്ടേൺ മൂല്യം:
വിജയം, അല്ലെങ്കിൽ പരാജയം

(2) ക്യൂ-ബന്ധപ്പെട്ട പ്രവർത്തനങ്ങൾ:

സ്ട്രിംഗ് QueNameGet( അത് ബന്ധിക്കുന്നു )
ക്യൂ ക്യൂവിന്റെ പേര് നൽകുന്നു. സജ്ജീകരിക്കാത്ത മൂല്യം: NULLSTR

int QueTypeGet( അത് ബന്ധിക്കുന്നു )
Que que-ന്റെ queue_type ആട്രിബ്യൂട്ട് നൽകുന്നു.
റിട്ടേൺ മൂല്യം: QTYPE_E (എക്‌സിക്യൂഷൻ), QTYPE_R (റൂട്ടിംഗ്), -1 (സജ്ജീകരിച്ചിട്ടില്ല.
മൂല്യം)

int QueNumJobsGet( അത് ബന്ധിക്കുന്നു )
ക്യൂ ക്യൂവിൽ താമസിക്കുന്ന ജോലികളുടെ എണ്ണം നൽകുന്നു. സജ്ജീകരിക്കാത്ത മൂല്യം: 0

int QueMaxRunJobsGet( അത് ബന്ധിക്കുന്നു )
Que que-ന്റെ max_running ആട്രിബ്യൂട്ട് നൽകുന്നു. സജ്ജീകരിക്കാത്ത മൂല്യം: 0

int QueMaxRunJobsPerUserGet( അത് ബന്ധിക്കുന്നു )
Que que-ന്റെ max_user_run ആട്രിബ്യൂട്ട് നൽകുന്നു. സജ്ജീകരിക്കാത്ത മൂല്യം: 0

int QueMaxRunJobsPerGroupGet( അത് ബന്ധിക്കുന്നു )
Que que-ന്റെ max_group_run ആട്രിബ്യൂട്ട് നൽകുന്നു. സജ്ജീകരിക്കാത്ത മൂല്യം: 0

int QuePriorityGet( അത് ബന്ധിക്കുന്നു )
Que que-ന്റെ മുൻഗണനാ ആട്രിബ്യൂട്ട് നൽകുന്നു. സജ്ജീകരിക്കാത്ത മൂല്യം: 0

int QueStateGet( അത് ബന്ധിക്കുന്നു )
ക്യൂ ക്യൂവിന്റെ റിട്ടേൺസ് ആരംഭിച്ച ആട്രിബ്യൂട്ട് - ജോബ് എക്സിക്യൂഷൻ സെലക്ഷൻ
ക്യൂവിന്റെ അവസ്ഥ: SCHED_DISABLED, SCHED_ENABLED. സജ്ജീകരിക്കാത്ത മൂല്യം:
SCHED_DISABLED

ഗണം ഇയ്യോബ് QueJobsGet( അത് ബന്ധിക്കുന്നു )
നിലവിൽ ക്യൂവിൽ താമസിക്കുന്ന ജോലികളുടെ ലിസ്റ്റ് നൽകുന്നു.

int QueIntResAvailGet(ക്യൂ q, സ്ട്രിംഗ് പേര്)
നിർദ്ദിഷ്ട ഉറവിടത്തിലേക്ക് മൂല്യം നൽകുന്നു പേര് അത് ലഭ്യമാണ്
ഈ q-ൽ നിന്ന് പ്രവർത്തിക്കുന്ന ജോലികൾ (Que ഉറവിടങ്ങൾ_ലഭ്യം.പേര് ആട്രിബ്യൂട്ട്).
Int തരത്തിലുള്ള മൂല്യങ്ങളുള്ള ഉറവിടങ്ങൾക്കായി ഈ ഫംഗ്‌ഷൻ വിളിക്കുക.
സാമ്പിൾ റിസോഴ്സ് പേരുകൾ ഇവയാണ്: cput, pcput, walltime, mppt, pmppt, നൈസ്,
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(ക്യൂ q, സ്ട്രിംഗ് പേര്)
നിർദ്ദിഷ്ട ഉറവിടത്തിലേക്ക് മൂല്യം നൽകുന്നു പേര് അത് ലഭ്യമാണ്
ഈ q-ൽ നിന്ന് പ്രവർത്തിക്കുന്ന ജോലികൾ (Que ഉറവിടങ്ങൾ_ലഭ്യം.പേര് ആട്രിബ്യൂട്ട്).
വലുപ്പത്തിലുള്ള മൂല്യങ്ങളുള്ള ഉറവിടങ്ങൾക്കായി ഈ ഫംഗ്‌ഷൻ വിളിക്കുക.
സാമ്പിൾ റിസോഴ്സ് പേരുകൾ ഇവയാണ്: ഫയൽ, മെം, പിഎംഎം, വർക്കിംഗ് സെറ്റ്, പിഎഫ്, പിപിഎഫ്,
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(ക്യൂ q, സ്ട്രിംഗ് പേര്)
നിർദ്ദിഷ്ട ഉറവിടത്തിലേക്ക് മൂല്യം നൽകുന്നു പേര് അത് ലഭ്യമാണ്
ഈ q-ൽ നിന്ന് പ്രവർത്തിക്കുന്ന ജോലികൾ (Que ഉറവിടങ്ങൾ_ലഭ്യം.പേര് ആട്രിബ്യൂട്ട്).
സ്ട്രിംഗ് തരത്തിലുള്ള മൂല്യങ്ങളുള്ള ഉറവിടങ്ങൾക്കായി ഈ ഫംഗ്‌ഷൻ വിളിക്കുക.
സാമ്പിൾ റിസോഴ്സ് പേരുകൾ ഇവയാണ്: നോഡുകൾ, കമാനം, നീഡ്നോഡുകൾ. ഒരു വിവരണത്തിന്
ഈ ഉറവിട നാമങ്ങളിൽ, കാണുക 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(ക്യൂ q, സ്ട്രിംഗ് പേര്)
നിർദ്ദിഷ്ട ഉറവിടത്തിലേക്ക് മൂല്യം നൽകുന്നു പേര് ഇതിനായി അനുവദിച്ചിരിക്കുന്നു
ഈ ക്യൂവിൽ നിന്ന് പ്രവർത്തിക്കുന്ന ജോലികൾ (ക്യൂ റിസോഴ്സ്_അസൈൻഡ്.നാമം ആട്രിബ്യൂട്ട്).
Int തരത്തിലുള്ള മൂല്യങ്ങളുള്ള ഉറവിടങ്ങൾക്കായി ഈ ഫംഗ്‌ഷൻ വിളിക്കുക.
സാമ്പിൾ റിസോഴ്സ് പേരുകൾ ഇവയാണ്: cput, pcput, walltime, mppt, pmppt, നൈസ്,
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(ക്യൂ q, സ്ട്രിംഗ് പേര്)
നിർദ്ദിഷ്ട ഉറവിടത്തിലേക്ക് മൂല്യം നൽകുന്നു പേര് ഇതിനായി അനുവദിച്ചിരിക്കുന്നു
ഈ q-ൽ നിന്ന് പ്രവർത്തിക്കുന്ന ജോലികൾ (Que റിസോഴ്സ്_അസൈൻഡ്.നാമം ആട്രിബ്യൂട്ട്).
വലുപ്പത്തിലുള്ള മൂല്യങ്ങളുള്ള ഉറവിടങ്ങൾക്കായി ഈ ഫംഗ്‌ഷൻ വിളിക്കുക.
സാമ്പിൾ റിസോഴ്സ് പേരുകൾ ഇവയാണ്: ഫയൽ, മെം, പിഎംഎം, വർക്കിംഗ് സെറ്റ്, പിഎഫ്, പിപിഎഫ്,
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(ക്യൂ q, സ്ട്രിംഗ് പേര്)
നിർദ്ദിഷ്ട ഉറവിടത്തിലേക്ക് മൂല്യം നൽകുന്നു പേര് ഇതിനായി അനുവദിച്ചിരിക്കുന്നു
ഈ q-ൽ നിന്ന് പ്രവർത്തിക്കുന്ന ജോലികൾ (Que റിസോഴ്സ്_അസൈൻഡ്.നാമം ആട്രിബ്യൂട്ട്).
സ്ട്രിംഗ് തരത്തിലുള്ള മൂല്യങ്ങളുള്ള ഉറവിടങ്ങൾക്കായി ഈ ഫംഗ്‌ഷൻ വിളിക്കുക.
സാമ്പിൾ റിസോഴ്സ് പേരുകൾ ഇവയാണ്: നോഡുകൾ, കമാനം, നീഡ്നോഡുകൾ. ഒരു വിവരണത്തിന്
ഈ ഉറവിട നാമങ്ങളിൽ, കാണുക 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

സ്ട്രിംഗ് JobNameGet( ഇയ്യോബ് ജോലി )
ജോലി ജോലിയുടെ Job_Name ആട്രിബ്യൂട്ട് നൽകുന്നു. സജ്ജീകരിക്കാത്ത മൂല്യം: NULLSTR

സ്ട്രിംഗ് JobOwnerNameGet( ഇയ്യോബ് ജോലി )
ജോലി ജോലിയുടെ Job_Owner ആട്രിബ്യൂട്ട് നൽകുന്നു. സജ്ജീകരിക്കാത്ത മൂല്യം: NULLSTR

സ്ട്രിംഗ് JobEffectiveUserNameGet( ഇയ്യോബ് ജോലി)
ജോലി ജോലിയുടെ യൂസർ ആട്രിബ്യൂട്ട് നൽകുന്നു.

സ്ട്രിംഗ് JobEffectiveGroupNameGet(ജോലി ജോലി)
ജോലി ജോലിയുടെ ഈഗ്രൂപ്പ് ആട്രിബ്യൂട്ട് നൽകുന്നു. സജ്ജീകരിക്കാത്ത മൂല്യം: NULLSTR

int JobStateGet ( ഇയ്യോബ് ജോലി )
ജോലി ജോലിയുടെ job_state ആട്രിബ്യൂട്ട് നൽകുന്നു.

റിട്ടേൺ മൂല്യം:
ട്രാൻസിറ്റ്, ക്യൂഡ്, പിടിക്കുക, കാത്തിരിക്കുക, ഓടുക, പുറത്തുകടക്കുക, -1 (സജ്ജീകരിച്ചിട്ടില്ല
മൂല്യം)

int Job PriorityGet( ഇയ്യോബ് ജോലി )
ജോലി ജോലിയുടെ മുൻഗണനാ ആട്രിബ്യൂട്ട് നൽകുന്നു. സജ്ജീകരിക്കാത്ത മൂല്യം: 0

int JobRerunFlagGet( ഇയ്യോബ് ജോലി )
ജോലി ജോലിയുടെ പുനരുപയോഗിക്കാവുന്ന ആട്രിബ്യൂട്ട് നൽകുന്നു.
റിട്ടേൺ മൂല്യം: FALSE, TRUE, -1 (മൂല്യം സജ്ജീകരിക്കാത്തത്)

int JobInteractiveFlagGet( ഇയ്യോബ് ജോലി )
ജോലി ജോലിയുടെ സംവേദനാത്മക ആട്രിബ്യൂട്ട് നൽകുന്നു.
റിട്ടേൺ മൂല്യം: FALSE, TRUE. സജ്ജീകരിക്കാത്ത മൂല്യം: FALSE

തീയതി ടൈം JobDateTimeCreatedGet(ജോലി ജോലി)
ജോലി ജോലിയുടെ ctime ആട്രിബ്യൂട്ട് നൽകുന്നു. സജ്ജീകരിക്കാത്ത മൂല്യം:
(0|0|0@-1:-1:-1)

സ്ട്രിംഗ് JobEmailAddrGet( ഇയ്യോബ് ജോലി )
ജോലി ജോലിയുടെ Mail_Users ആട്രിബ്യൂട്ട് നൽകുന്നു. സജ്ജീകരിക്കാത്ത മൂല്യം: NULLSTR

സ്ട്രിംഗ് JobStageinFilesGet( ഇയ്യോബ് ജോലി )
ജോലി ജോലിയുടെ സ്റ്റേജിൻ ആട്രിബ്യൂട്ട് നൽകുന്നു. സജ്ജീകരിക്കാത്ത മൂല്യം: NULLSTR

സ്ട്രിംഗ് JobStageoutFilesGet( ഇയ്യോബ് ജോലി )
ജോലി ജോലിയുടെ സ്റ്റേജ്ഔട്ട് ആട്രിബ്യൂട്ട് നൽകുന്നു. സജ്ജീകരിക്കാത്ത മൂല്യം: NULLSTR

int JobIntResReqGet(ജോലി ജോലി, സ്ട്രിംഗ് പേര്)
നിർദ്ദിഷ്ട ഉറവിടത്തിലേക്ക് മൂല്യം നൽകുന്നു പേര് ആവശ്യപ്പെടുന്നത് പോലെ
ജോലി (ജോലി 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;
// വരുമാനം The cput ആവശ്യകത of The ജോലി
cputReq = JobIntResReqGet(ജോലി, "cput");

വലുപ്പം JobSizeResReqGet(ജോലി ജോലി, സ്ട്രിംഗ് പേര്)
നിർദ്ദിഷ്ട ഉറവിടത്തിലേക്ക് മൂല്യം നൽകുന്നു പേര് ആവശ്യപ്പെടുന്നത് പോലെ
ജോലി (ജോലി Resource_List.name ആട്രിബ്യൂട്ട്). ഇതിനായി ഈ ഫംഗ്‌ഷൻ വിളിക്കുക
വലിപ്പം തരം മൂല്യങ്ങളുള്ള ഉറവിടങ്ങൾ. സാമ്പിൾ റിസോഴ്സ് പേരുകൾ
ഇവയാണ്: ഫയൽ, മെം, pmem, വർക്കിംഗ് സെറ്റ്, 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;
// വരുമാനം The മെമ്മറി ആവശ്യകത of The ജോലി
memReq = JobSizeResReqGet(ജോലി, "മെം");

സ്ട്രിംഗ് JobStringResReqGet(ജോലി ജോലി, സ്ട്രിംഗ് പേര്)
നിർദ്ദിഷ്ട ഉറവിടത്തിലേക്ക് മൂല്യം നൽകുന്നു പേര് ആവശ്യപ്പെടുന്നത് പോലെ
ജോലി (ജോലി Resource_List.name ആട്രിബ്യൂട്ട്). ഇതിനായി ഈ ഫംഗ്‌ഷൻ വിളിക്കുക
സ്ട്രിംഗ് തരത്തിലുള്ള മൂല്യങ്ങളുള്ള ഉറവിടങ്ങൾ. സാമ്പിൾ റിസോഴ്സ് പേരുകൾ
ഇവയാണ്: നോഡുകൾ, കമാനം, നീഡ്നോഡുകൾ. ഈ വിഭവങ്ങളുടെ വിവരണത്തിനായി
പേരുകൾ, കാണുക 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 ബി).

ഉദാഹരണം:
സ്ട്രിംഗ് നോഡുകൾ;
// വരുമാനം The നോഡുകൾ ആവശ്യകത പ്രോപ്പർട്ടി of
// The ജോലി
നോഡുകൾ = JobStringResReqGet(ജോലി, "നോഡുകൾ");

int JobIntResUseGet(ജോലി ജോലി, സ്ട്രിംഗ് പേര്)
നിർദ്ദിഷ്ട ഉറവിടത്തിലേക്ക് മൂല്യം നൽകുന്നു പേര് ജോലി ഉപയോഗിച്ചു (ജോബ്
ഉറവിടങ്ങൾ_ഉപയോഗിച്ച പേര് ആട്രിബ്യൂട്ട്). ഉള്ള വിഭവങ്ങൾക്കായി ഈ ഫംഗ്‌ഷൻ വിളിക്കുക
Int തരത്തിലുള്ള മൂല്യങ്ങൾ. സാമ്പിൾ റിസോഴ്സ് പേരുകൾ ഇവയാണ്: cput, pcput,
വാൾടൈം, mppt, pmppt, നൈസ്, 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;
// വരുമാനം The തുക of വാൾടൈം ഉപയോഗിച്ച by
// The ജോലി
walltUse = JobIntResUseGet(ജോലി, "വാൾടൈം");

വലുപ്പം JobSizeResUseGet(ജോലി ജോലി, സ്ട്രിംഗ് പേര്)
നിർദ്ദിഷ്ട ഉറവിടത്തിലേക്ക് മൂല്യം നൽകുന്നു പേര് ജോലി ഉപയോഗിച്ചു (ജോബ്
ഉറവിടങ്ങൾ_ഉപയോഗിച്ച പേര് ആട്രിബ്യൂട്ട്). ഉള്ള വിഭവങ്ങൾക്കായി ഈ ഫംഗ്‌ഷൻ വിളിക്കുക
വലിപ്പം തരം മൂല്യങ്ങൾ. സാമ്പിൾ റിസോഴ്സ് പേരുകൾ ഇവയാണ്: ഫയൽ, മെം,
pmem, വർക്കിംഗ് സെറ്റ്, 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;
// വരുമാനം The തുക of srfs_fast ഉപയോഗിച്ച by
// The ജോലി
srfsUse = JobSizeResUseGet(ജോലി, "srfs_fast");

സ്ട്രിംഗ് JobStringResUseGet(ജോലി ജോലി, സ്ട്രിംഗ് പേര്)
നിർദ്ദിഷ്ട ഉറവിടത്തിലേക്ക് മൂല്യം നൽകുന്നു പേര് ജോലി ഉപയോഗിച്ചു (ജോബ്
ഉറവിടങ്ങൾ_ഉപയോഗിച്ച പേര് ആട്രിബ്യൂട്ട്). ഉള്ള വിഭവങ്ങൾക്കായി ഈ ഫംഗ്‌ഷൻ വിളിക്കുക
സ്ട്രിംഗ് തരത്തിലുള്ള മൂല്യങ്ങൾ. സാമ്പിൾ റിസോഴ്സ് പേരുകൾ ഇവയാണ്: നോഡുകൾ,
കമാനം, നീഡ്നോഡുകൾ. ഈ ഉറവിട നാമങ്ങളുടെ വിവരണത്തിന്, കാണുക
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-മായി ബന്ധപ്പെട്ട പ്രവർത്തനങ്ങൾ

ഗണം സിനോഡ് AllNodesGet(അസാധു)
എന്നതിൽ പ്രവർത്തിക്കുന്ന സെർവർ നിയന്ത്രിക്കുന്ന നോഡുകളുടെ ലിസ്റ്റ് നൽകുന്നു
പ്രാദേശിക ഹോസ്റ്റ്. ഇതിൽ വ്യക്തമാക്കിയിട്ടുള്ള നോഡുകളും ഉൾപ്പെടാം
ഷെഡ്യൂളർ റൈറ്ററിന് വേണ്ടിയുള്ള ഷെഡ്യൂളർ കോൺഫിഗറേഷൻ ഫയലിൽ
സംസ്ഥാനം പോലുള്ള വിവരങ്ങൾക്കായി സിസ്റ്റം ഇടയ്ക്കിടെ പരിശോധിക്കണമെന്ന് ആഗ്രഹിക്കുന്നു,
സ്വത്ത്, തുടങ്ങിയവ. കാണുക pbs_sched_basl(8 ബി) എന്ന ചർച്ചയ്ക്കായി
കോൺഫിഗറേഷൻ ഫയൽ ഫോർമാറ്റ്.
ജാഗ്രത: ഈ ഫംഗ്ഷൻ ഉള്ളിൽ നിന്ന് വിളിക്കണം ഷെഡ്_മെയിൻ() so
ഓരോ ഷെഡ്യൂളിംഗ് ആവർത്തനത്തിലും, ഏറ്റവും കാലികമായത് ഗണം സിനോഡ്
ഘടന തിരികെ ലഭിച്ചു. ഒരു അസൈൻമെന്റ് പ്രസ്താവനയിൽ നിന്ന് ഇതിനെ വിളിക്കരുത്
ഒരു ഗ്ലോബൽ വേരിയബിൾ ആരംഭിക്കാൻ ഉദ്ദേശിച്ചുള്ളതാണ്, പ്രസ്താവനയിൽ മാത്രം
ഒരിക്കൽ വിളിക്കും.

സിനോഡ് AllNodesLocalHostGet(അസാധു)
പ്രാദേശിക ഹോസ്റ്റിനെ പ്രതിനിധീകരിക്കുന്ന CNode ഒബ്‌ജക്റ്റ് നൽകുന്നു. ഇതൊരു
1 CNode മാത്രമുള്ള നോൺ-ക്ലസ്റ്റേർഡ് സിസ്റ്റങ്ങളെ വിളിക്കുന്നതിനുള്ള ലളിതമായ പ്രവർത്തനം
നിലവിലുണ്ട്. സജ്ജീകരിക്കാത്ത മൂല്യം: NOCNODE
ജാഗ്രത: ഈ ഫംഗ്ഷൻ ഉള്ളിൽ നിന്ന് വിളിക്കണം ഷെഡ്_മെയിൻ() (അഥവാ
sched_main വിളിക്കുന്ന ഫംഗ്‌ഷനുകൾക്കുള്ളിൽ നിന്ന്) അങ്ങനെ എല്ലാത്തിലും
ആവർത്തന ഷെഡ്യൂളിംഗ്, ഏറ്റവും കാലികമായത് സിനോഡ് ഘടനയാണ്
മടങ്ങി. ഉദ്ദേശിച്ചിട്ടുള്ള ഒരു അസൈൻമെന്റ് പ്രസ്താവനയിൽ നിന്ന് ഇതിനെ വിളിക്കരുത്
ഒരു ഗ്ലോബൽ വേരിയബിൾ ആരംഭിക്കുക, കാരണം പ്രസ്താവന വിളിക്കപ്പെടും
ഒരിക്കല്.

സ്ട്രിംഗ് CNodeNameGet(CNode നോഡ്)
നോഡിന്റെ തനതായ (ഔദ്യോഗിക) പേര് (അതായത്, ResMom ഹോസ്റ്റ്നാമം
1 അമ്മ/നോഡ് മോഡലിൽ). ഇത് അതേ സ്ട്രിംഗ് തിരികെ നൽകുന്നു
കോൺഫിഗറേഷൻ ഫയലിൽ വ്യക്തമാക്കിയിട്ടുണ്ട്. സജ്ജീകരിക്കാത്ത മൂല്യം: NULLSTR

സ്ട്രിംഗ് CNodeOsGet(CNode നോഡ്)
നോഡിന്റെ OS ആർക്കിടെക്ചർ നൽകുന്നു (അതായത് "irix5", "sp2"). സജ്ജീകരിക്കാത്തത്
മൂല്യം: NULLSTR

int CNodeStateGet( സിനോഡ് നോഡ് )
നോഡിന്റെ അവസ്ഥ നൽകുന്നു.

റിട്ടേൺ മൂല്യം:
CNODE_OFFLINE, CNODE_DOWN, CNODE_FREE, CNODE_RESERVE,
CNODE_INUSE_EXCLUSIVE, CNODE_INUSE_SHARED, CNODE_UNKNOWN

int CNodeTypeGet( സിനോഡ് നോഡ് )
നോഡിന്റെ തരം നൽകുന്നു.

റിട്ടേൺ മൂല്യം:
CNODE_TIMESHARED, CNODE_CLUSTER, CNODE_UNKNOWN

സ്ട്രിംഗ് CNodePropertiesGet(CNode നോഡ്)
നോഡ് അറിയപ്പെടുന്ന മറ്റ് പേരുകളുടെ കോമയാൽ വേർതിരിച്ച ലിസ്റ്റ് നൽകുന്നു
( പ്രോപ്പർട്ടികൾ, മറ്റ് നെറ്റ്‌വർക്കിന്റെ പേര്). ഉദാഹരണത്തിന്,
"babbage.OpenPBS.org" നോഡിന്റെ പേരായിരിക്കാം, പക്ഷേ അത് അറിയാനും കഴിയും
"babbage1, babbage2" വഴി. സജ്ജീകരിക്കാത്ത മൂല്യം: NULLSTR

സ്ട്രിംഗ് CNodeVendorGet(CNode നോഡ്)
മെഷീന്റെ ഹാർഡ്‌വെയറിനായി വെണ്ടറുടെ പേര് നൽകുന്നു (അതായത്.
"sgi", "ibm"). സജ്ജീകരിക്കാത്ത മൂല്യം: NULLSTR

int CNodeNumCpusGet(CNode നോഡ്)
നോഡിൽ ഘടിപ്പിച്ചിരിക്കുന്ന പ്രോസസ്സറുകളുടെ എണ്ണം നൽകുന്നു. സജ്ജീകരിക്കാത്ത മൂല്യം:
-1

വലുപ്പം CNodeMemTotalGet( സിനോഡ് നോഡ്, സ്ട്രിംഗ് ടൈപ്പ് ചെയ്യുക )
മൊത്തം മെമ്മറി നൽകുന്നു ടൈപ്പ് ചെയ്യുക നോഡിന്. ടൈപ്പ് ചെയ്യുക ഒരു ഏകപക്ഷീയമാണ്
ഷെഡ്യൂളർ റൈറ്റർ ഷെഡ്യൂളറിൽ നിർവചിക്കുന്ന സ്ട്രിംഗ്
കോൺഫിഗറേഷൻ ഫയൽ. സജ്ജീകരിക്കാത്ത മൂല്യം: -1 ബി
ഉദാഹരണം:
// നേടുക മൊത്തം ഭൗതികമായ മെമ്മറി
CNodeMemTotalGet(നോഡ്, "യഥാർത്ഥ")
// നേടുക മൊത്തം വെർച്വൽ മെമ്മറി
CNodeMemTotalGet(നോഡ്, "വെർച്വൽ")

വലുപ്പം CNodeMemAvailGet( സിനോഡ് നോഡ്, സ്ട്രിംഗ് ടൈപ്പ് ചെയ്യുക )
ലഭ്യമായ മെമ്മറി നൽകുന്നു ടൈപ്പ് ചെയ്യുക നോഡിന്. ടൈപ്പ് ചെയ്യുക ഒരു ഏകപക്ഷീയമാണ്
ഷെഡ്യൂളർ റൈറ്റർ ഷെഡ്യൂളറിൽ നിർവചിക്കുന്ന സ്ട്രിംഗ്
കോൺഫിഗറേഷൻ ഫയൽ. സജ്ജീകരിക്കാത്ത മൂല്യം: -1 ബി
അതിനാൽ സാമ്പിൾ കോളുകൾ ഇതായിരിക്കും:
// നേടുക ലഭ്യമായ ഭൗതികമായ മെമ്മറി
CNodeMemAvailGet(നോഡ്, "യഥാർത്ഥ")
// നേടുക ലഭ്യമായ വെർച്വൽ മെമ്മറി
CNodeMemAvailGet(നോഡ്, "വെർച്വൽ")

int CNodeIdletimeGet( സിനോഡ് നോഡ് )
കീസ്ട്രോക്കോ മൗസിന്റെയോ ചലനങ്ങളില്ലാത്ത സെക്കൻഡുകളുടെ എണ്ണം നൽകുന്നു
നോഡുമായി ബന്ധിപ്പിച്ചിട്ടുള്ള ഏതെങ്കിലും ടെർമിനലിലാണ് നടന്നത്. സജ്ജീകരിക്കാത്ത മൂല്യം: -1

ഫ്ലോട്ട് CNodeLoadAveGet( സിനോഡ് നോഡ് )
എല്ലാ cpus-നും നോഡിന്റെ ലോഡ് ശരാശരി നൽകുന്നു. സജ്ജീകരിക്കാത്ത മൂല്യം: -1.0

int CNodeCpuPercentIdleGet( സിനോഡ് നോഡ് )
നോഡിന്റെ എല്ലാ പ്രോസസ്സറുകളും നിഷ്‌ക്രിയ സമയത്തിന്റെ ശതമാനം നൽകുന്നു
അനുഭവിച്ചിട്ടുണ്ട്.

int CNodeCpuPercentSysGet( സിനോഡ് നോഡ് )
നോഡിന്റെ എല്ലാ പ്രോസസ്സറുകൾക്കും ഉള്ള സമയത്തിന്റെ ശതമാനം നൽകുന്നു
കേർണൽ കോഡ് പ്രവർത്തിപ്പിക്കാൻ ചെലവഴിച്ചു.

int CNodeCpuPercentUserGet( സിനോഡ് നോഡ് )
നോഡിന്റെ എല്ലാ പ്രോസസ്സറുകൾക്കും ഉള്ള സമയത്തിന്റെ ശതമാനം നൽകുന്നു
ഉപയോക്തൃ കോഡ് പ്രവർത്തിപ്പിക്കാൻ ചെലവഴിച്ചു.

int CNodeCpuPercentGuestGet( സിനോഡ് നോഡ് )
നോഡിന്റെ എല്ലാ പ്രോസസ്സറുകൾക്കും ഉള്ള സമയത്തിന്റെ ശതമാനം നൽകുന്നു
ഒരു ഗസ്റ്റ് ഓപ്പറേറ്റിംഗ് സിസ്റ്റം പ്രവർത്തിപ്പിക്കാൻ ചെലവഴിച്ചു.

int CNodeNetworkBwGet( സിനോഡ് നോഡ്, സ്ട്രിംഗ് ടൈപ്പ് ചെയ്യുക )
ന്റെ നോഡിന്റെ നെറ്റ്‌വർക്കിന്റെ ബാൻഡ്‌വിഡ്ത്ത് നൽകുന്നു ടൈപ്പ് ചെയ്യുക ബൈറ്റുകൾ/സെക്കൻഡിൽ.
ടൈപ്പ് ചെയ്യുക ഷെഡ്യൂളറിലെ ഷെഡ്യൂളർ റൈറ്ററാണ് നിർവചിച്ചിരിക്കുന്നത്
കോൺഫിഗറേഷൻ ഫയൽ. സജ്ജീകരിക്കാത്ത മൂല്യം: -1
ചില സാമ്പിൾ കോളുകൾ ഇവയാണ്:
CNodeNetworkBwGet( നോഡ്, "ഹിപ്പി" );
CNodeNetworkBwGet( നോഡ്, "fddi" );

വലുപ്പം CNodeDiskSpaceTotalGet(CNode നോഡ്, സ്ട്രിംഗ് പേര്)
തിരിച്ചറിഞ്ഞ ഡിസ്കിലെ നോഡിന്റെ മൊത്തം ഇടം നൽകുന്നു പേര് എവിടെ പേര്
എന്നതിലെ ഷെഡ്യൂളർ റൈറ്റർ ഏകപക്ഷീയമായി നിർവചിച്ച ഉപകരണത്തിന്റെ പേരാണ്
ഷെഡ്യൂളർ കോൺഫിഗറേഷൻ ഫയൽ. സജ്ജീകരിക്കാത്ത മൂല്യം: -1 ബി
ഉദാഹരണം:
CNodeDiskSpaceTotalGet( നോഡ്, "/സ്ക്രാച്ച്2" );

വലുപ്പം CNodeDiskSpaceAvailGet(CNode നോഡ്, സ്ട്രിംഗ് പേര്)
തിരിച്ചറിഞ്ഞ ഡിസ്കിൽ നോഡിന്റെ ലഭ്യമായ ഇടം നൽകുന്നു പേര് എവിടെ
പേര് ഷെഡ്യൂളറിലെ ഷെഡ്യൂളർ എഴുത്തുകാരൻ ഏകപക്ഷീയമായി നിർവചിച്ചിരിക്കുന്നു
കോൺഫിഗറേഷൻ ഫയൽ. സജ്ജീകരിക്കാത്ത മൂല്യം: -1 ബി
ഉദാഹരണം:
CNodeDiskSpaceAvailGet( നോഡ്, "/സ്ക്രാച്ച്1" );

വലുപ്പം CNodeDiskSpaceReservedGet(CNode നോഡ്, സ്ട്രിംഗ് പേര്)
തിരിച്ചറിഞ്ഞിട്ടുള്ള ഡിസ്കിലെ നോഡിന്റെ റിസർവ്ഡ് സ്പേസ് (ഉപയോക്തൃ ക്വാട്ട?) നൽകുന്നു
പേര് എവിടെ പേര് എന്നതിലെ ഷെഡ്യൂളർ എഴുത്തുകാരൻ ഏകപക്ഷീയമായി നിർവചിച്ചിരിക്കുന്നു
ഷെഡ്യൂളർ കോൺഫിഗറേഷൻ ഫയൽ. സജ്ജീകരിക്കാത്ത മൂല്യം: -1 ബി
ഉദാഹരണം:
CNodeDiskSpaceReservedGet( നോഡ്, "/സ്ക്രാച്ച്1" );

int CNodeDiskInBwGet( സിനോഡ് നോഡ്, സ്ട്രിംഗ് പേര് )
തിരിച്ചറിഞ്ഞ നോഡിന്റെ ഡിസ്കിന്റെ റൈറ്റ് ബാൻഡ്‌വിഡ്ത്ത് (ബൈറ്റുകൾ/സെക്കൻഡ്) നൽകുന്നു
by പേര് . സജ്ജീകരിക്കാത്ത മൂല്യം: -1
ഉദാഹരണം:
CNodeDiskInBwGet( നോഡ്, "/വേഗത" );

int CNodeDiskOutBwGet( സിനോഡ് നോഡ്, സ്ട്രിംഗ് പേര് )
തിരിച്ചറിഞ്ഞ നോഡിന്റെ ഡിസ്കിന്റെ റീഡ് ബാൻഡ്‌വിഡ്ത്ത് (ബൈറ്റുകൾ/സെക്കൻഡ്) നൽകുന്നു
പേര് . സജ്ജീകരിക്കാത്ത മൂല്യം: -1
ഉദാഹരണം:
CNodeDiskOutBwGet( നോഡ്, "/വലിയ" );

വലുപ്പം CNodeSwapSpaceTotalGet( സിനോഡ് നോഡ്, സ്ട്രിംഗ് പേര് )
തിരിച്ചറിഞ്ഞ സ്വാപ്പിൽ നോഡിന്റെ മൊത്തം ഇടം നൽകുന്നു പേര് എവിടെ പേര്
ഷെഡ്യൂളറിലെ ഷെഡ്യൂളർ എഴുത്തുകാരൻ ഏകപക്ഷീയമായി നിർവചിച്ചിരിക്കുന്നു
കോൺഫിഗറേഷൻ ഫയൽ. സജ്ജീകരിക്കാത്ത മൂല്യം: -1 ബി
ഉദാഹരണം:
CNodeSwapSpaceTotalGet( നോഡ്, "പ്രാഥമിക" );

വലുപ്പം CNodeSwapSpaceAvailGet( സിനോഡ് നോഡ്, സ്ട്രിംഗ് പേര് )
തിരിച്ചറിഞ്ഞ സ്വാപ്പിൽ നോഡിന്റെ ലഭ്യമായ ഇടം നൽകുന്നു പേര് എവിടെ പേര്
എന്നതിലെ ഷെഡ്യൂളർ റൈറ്റർ ഏകപക്ഷീയമായി നിർവചിച്ച ഉപകരണത്തിന്റെ പേരാണ്
ഷെഡ്യൂളർ കോൺഫിഗറേഷൻ ഫയൽ. സജ്ജീകരിക്കാത്ത മൂല്യം: -1 ബി
ഉദാഹരണം:
CNodeSwapSpaceAvailGet( നോഡ്, "സെക്കൻഡറി" );

int CNodeSwapInBwGet( സിനോഡ് നോഡ്, സ്ട്രിംഗ് പേര് )
തിരിച്ചറിഞ്ഞ നോഡിന്റെ സ്വാപ്പ് ഉപകരണത്തിന്റെ സ്വാപിൻ നിരക്ക് നൽകുന്നു പേര്.
ഉദാഹരണം:
CNodeSwapInBwGet(നോഡ്, "സെക്കൻഡറി");

int CNodeSwapOutBwGet( സിനോഡ് നോഡ്, സ്ട്രിംഗ് പേര് )
തിരിച്ചറിഞ്ഞ നോഡിന്റെ സ്വാപ്പ് ഉപകരണത്തിന്റെ സ്വാപ്പ്ഔട്ട് നിരക്ക് നൽകുന്നു
പേര്. സജ്ജീകരിക്കാത്ത മൂല്യം: -1
ഉദാഹരണം:
CNodeSwapOutBwGet(നോഡ്, "പ്രാഥമിക");

വലുപ്പം CNodeTapeSpaceTotalGet( സിനോഡ് നോഡ്, സ്ട്രിംഗ് പേര് )
തിരിച്ചറിഞ്ഞ ടേപ്പിലെ നോഡിന്റെ മൊത്തം ഇടം നൽകുന്നു പേര് എവിടെ പേര്
ഷെഡ്യൂളറിലെ ഷെഡ്യൂളർ എഴുത്തുകാരൻ ഏകപക്ഷീയമായി നിർവചിച്ചിരിക്കുന്നു
കോൺഫിഗറേഷൻ ഫയൽ. സജ്ജീകരിക്കാത്ത മൂല്യം: -1 ബി
ഉദാഹരണം:
CNodeTapeSpaceTotalGet(നോഡ്, "4 മിമി");

വലുപ്പം CNodeTapeSpaceAvailGet( സിനോഡ് നോഡ്, സ്ട്രിംഗ് പേര് )
തിരിച്ചറിഞ്ഞ ടേപ്പിൽ നോഡിന്റെ ലഭ്യമായ ഇടം നൽകുന്നു പേര് എവിടെ
പേര് ഷെഡ്യൂളറിലെ ഷെഡ്യൂളർ എഴുത്തുകാരൻ ഏകപക്ഷീയമായി നിർവചിച്ചിരിക്കുന്നു
കോൺഫിഗറേഷൻ ഫയൽ. സജ്ജീകരിക്കാത്ത മൂല്യം: -1 ബി
ഉദാഹരണം:
CNodeTapeSpaceAvailGet(നോഡ്, "8mm");

int CNodeTapeInBwGet( സിനോഡ് നോഡ്, സ്ട്രിംഗ് പേര് )
തിരിച്ചറിഞ്ഞ നോഡിന്റെ ടേപ്പിന്റെ റൈറ്റ് ബാൻഡ്‌വിഡ്ത്ത് (ബൈറ്റുകൾ/സെക്കൻഡ്) നൽകുന്നു
by പേര് . സജ്ജീകരിക്കാത്ത മൂല്യം: -1
ഉദാഹരണം:
CNodeTapeInBwGet( നോഡ്, "4 മിമി" );

int CNodeTapeOutBwGet( സിനോഡ് നോഡ്, സ്ട്രിംഗ് പേര് )
തിരിച്ചറിഞ്ഞ നോഡിന്റെ ടേപ്പിന്റെ റീഡ് ബാൻഡ്‌വിഡ്ത്ത് (ബൈറ്റുകൾ/സെക്കൻഡ്) നൽകുന്നു
by പേര് . സജ്ജീകരിക്കാത്ത മൂല്യം: -1
ഉദാഹരണം:
CNodeTapeOutBwGet( നോഡ്, "8 മിമി" );

വലുപ്പം CNodeSrfsSpaceTotalGet( സിനോഡ് നോഡ്, സ്ട്രിംഗ് പേര് )
തിരിച്ചറിഞ്ഞ srfs ഉപകരണത്തിലെ നോഡിന്റെ മൊത്തം ഇടം നൽകുന്നു പേര്
എവിടെ പേര് എന്നതിലെ ഷെഡ്യൂളർ എഴുത്തുകാരൻ ഏകപക്ഷീയമായി നിർവചിച്ചിരിക്കുന്നു
ഷെഡ്യൂളർ കോൺഫിഗറേഷൻ ഫയൽ. സജ്ജീകരിക്കാത്ത മൂല്യം: -1 ബി
ഉദാഹരണം:
CNodeSrfsSpaceTotalGet(നോഡ്, "/ ഫാസ്റ്റ്");

വലുപ്പം CNodeSrfsSpaceAvailGet( സിനോഡ് നോഡ്, സ്ട്രിംഗ് പേര് )
തിരിച്ചറിഞ്ഞ srfs ഉപകരണത്തിൽ നോഡിന്റെ ലഭ്യമായ ഇടം നൽകുന്നു പേര്
എവിടെ പേര് ചിലതിൽ ഷെഡ്യൂളർ എഴുത്തുകാരൻ ഏകപക്ഷീയമായി നിർവചിച്ചിരിക്കുന്നു
കോൺഫിഗറേഷൻ ഫയൽ. സജ്ജീകരിക്കാത്ത മൂല്യം: -1 ബി
ഉദാഹരണം:
CNodeSrfsSpaceAvailGet( നോഡ്, "/വലിയ" );

വലുപ്പം CNodeSrfsSpaceReservedGet(CNode നോഡ്, സ്ട്രിംഗ് പേര്)
srfs ഉപകരണത്തിൽ നോഡിന്റെ ആകെ റിസർവ് ചെയ്ത ഇടം നൽകുന്നു
വഴി തിരിച്ചറിഞ്ഞു പേര് എവിടെ പേര് ഷെഡ്യൂളർ ഏകപക്ഷീയമായി നിർവചിച്ചിരിക്കുന്നു
ഷെഡ്യൂളർ കോൺഫിഗറേഷൻ ഫയലിലെ എഴുത്തുകാരൻ. സജ്ജീകരിക്കാത്ത മൂല്യം: -1 ബി
ഉദാഹരണം:
CNodeSrfsSpaceReservedGet( നോഡ്, "/വേഗത" );

int CNodeSrfsInBwGet( സിനോഡ് നോഡ്, സ്ട്രിംഗ് പേര് )
നോഡിന്റെ srfs ഉപകരണത്തിന്റെ റൈറ്റ് ബാൻഡ്‌വിഡ്ത്ത് (ബൈറ്റുകൾ/സെക്കൻഡ്) നൽകുന്നു
വഴി തിരിച്ചറിഞ്ഞു പേര് . സജ്ജീകരിക്കാത്ത മൂല്യം: -1
ഉദാഹരണം:
CNodeSrfsInBwGet(നോഡ്, "/ഫാസ്റ്റ്" );

int CNodeSrfsOutBwGet( സിനോഡ് നോഡ്, സ്ട്രിംഗ് പേര് )
നോഡിന്റെ srfs ഉപകരണത്തിന്റെ റീഡ് ബാൻഡ്‌വിഡ്ത്ത് (ബൈറ്റുകൾ/സെക്കൻഡ്) നൽകുന്നു
വഴി തിരിച്ചറിഞ്ഞു പേര് . സജ്ജീകരിക്കാത്ത മൂല്യം: -1
ഉദാഹരണം:
CNodeSrfsOutBwGet(നോഡ്, "/ബിഗ്" );

(5) വിവിധ പ്രവർത്തനങ്ങൾ

തീയതി ടൈം തീയതിസമയം നേടുക()
നിലവിലെ തീയതി/സമയം ലഭിക്കുന്നു.

int തീയതി സമയം മുതൽ സെക്കൻഡ് വരെ (തീയതി സമയം dt)
യുഗം മുതലുള്ള # സെക്കൻഡുകൾ നൽകുന്നു (UNIX സമയത്തിന്റെ ആരംഭം -
00:00:00, ജനുവരി 1, 1970) നൽകിയിരിക്കുന്ന തീയതി/സമയം dt.

int തൊഴിൽ പ്രവർത്തനം( ഇയ്യോബ് ജോലി, int നടപടി, സ്ട്രിംഗ് പരം )
നിർവഹിക്കുന്നു നടപടി on ജോലി ഒരു കൂടെ പരം അനുസരിച്ച് വ്യക്തമാക്കിയിരിക്കുന്നു
പ്രവർത്തനം. നടപടി ആകാം: SYNCRUN, ASYNCRUN, DELETE, ReRUN, Hold,
റിലീസ്, സിഗ്നൽ, മോഡിഫൈയറ്റ്, മോഡിഫയറുകൾ ഇവിടെ:
ആക്ഷൻ വിവരണം
================ ==========================
സിൻക്രൺ റൺസ് The ജോലി സമകാലികമായി,
അർത്ഥം The വിളി ലേക്ക്
ജോലി ആക്ഷൻ() ഉദ്ദേശിക്കുന്ന മാത്രം
മടക്കം എപ്പോൾ The ജോലി ഉണ്ട്
ആരംഭിച്ചു പ്രവർത്തിക്കുന്ന or എപ്പോൾ
an പിശക് ഉണ്ട് ആകുമായിരുന്നു
നേരിട്ടു.
പരം മൂല്യം:
പേര് of ഹോസ്റ്റ്(കൾ) ലേക്ക് ഓടുക
ജോലി കീഴിൽ.

അസിൻക്രൺ റൺസ് The ജോലി അസമന്വിതമായി,
അർത്ഥം The വിളി ലേക്ക്
ജോലി ആക്ഷൻ() ഉദ്ദേശിക്കുന്ന മടക്കം
ഉടനെ as ഉടൻ as
The ഓടുക അഭ്യർത്ഥന is
സാധൂകരിച്ചു by The പിബിഎസ് സെർവർ,
ഒപ്പം അല്ല അനിവാര്യമായും എപ്പോൾ
The ജോലി ഉണ്ട് ആരംഭിച്ചു
വധശിക്ഷ.
പരം മൂല്യം:
പേര് of ഹോസ്റ്റ്(കൾ) ലേക്ക് ഓടുക
ജോലി കീഴിൽ.

ഇല്ലാതാക്കും ഇല്ലാതാക്കുന്നു The ജോലി
പരം മൂല്യം:
"deldelay=<# of സെക്കന്റ്>"
- കാലതാമസം # of നിമിഷങ്ങൾ
തമ്മിലുള്ള The അയയ്ക്കുന്നത്
of അടയാളം ഒപ്പം സിഗിൽ
ലേക്ക് The ജോലി മുമ്പ്
ലഭിക്കുന്നു ഇല്ലാതാക്കി.

വീണ്ടും വീണ്ടും പ്രവർത്തിക്കുന്നു The പ്രവർത്തിക്കുന്ന ജോലി,
ഏത് ഉൾപ്പെടുന്നു അവസാനിപ്പിക്കുന്നു
The സമ്മേളനം നേതാവ് of The
ജോലി ഒപ്പം മടങ്ങി The ജോലി
ലേക്ക് The ക്യൂവിൽ സംസ്ഥാന.

ഹോൾഡ് സ്ഥലങ്ങൾ ഒന്ന് or കൂടുതൽ താങ്ങി
on The ജോലി
പരം മൂല്യം:
"u", "o", "s", "uo", "os",
"uos"
- ടൈപ്പ് ചെയ്യുക of താങ്ങി ലേക്ക് സ്ഥലം
on ജോലി: നിങ്ങൾ (സെർ), അല്ലെങ്കിൽ (അവിടെ),
s(സിസ്റ്റം).

റിലീസ് നീക്കം or റിലീസുകൾ
താങ്ങി സ്ഥാപിച്ചു on ജോലികൾ.
പരം മൂല്യം:
"u", "o", "s", "uo", "os",
"uos"
- ടൈപ്പ് ചെയ്യുക of താങ്ങി ലേക്ക് നീക്കം
നിന്ന് ജോലി: നിങ്ങൾ (സെർ), അല്ലെങ്കിൽ (അവിടെ),
s(സിസ്റ്റം).

സിഗ്നൽ അയയ്ക്കുന്നു a സിഗ്നൽ ലേക്ക് The
നടപ്പിലാക്കുന്നു ജോലി
പരം മൂല്യം:
"HUP", "SIGHUP",...

മോഡിഫൈറ്റർ തിരുത്തപ്പെട്ടത് The വ്യക്തമാക്കിയ
ആട്രിബ്യൂട്ട് of The ജോലി ലേക്ക്
The നൽകപ്പെട്ട മൂല്യം, എപ്പോൾ
The ആട്രിബ്_നാമം is
!= "റിസോഴ്സ്_ലിസ്റ്റ്" or
"ssources_used".
പരം മൂല്യം:
"attrib_name=value"

മോഡിഫയറുകൾ തിരുത്തപ്പെട്ടത് The ജോലിയുടെ
റിസോഴ്സ്_ലിസ്റ്റ്
ആട്രിബ്യൂട്ട് നൽകപ്പെട്ട The
പേര്_നാമം ഒപ്പം The
res_value:
Resource_List.res_name=
res_value
പരം മൂല്യം:
"res_name=res_val"
പരം മൂല്യം പ്രവർത്തനത്തെ ആശ്രയിച്ചിരിക്കുന്നു. മൂല്യമില്ലെങ്കിൽ NULLSTR വ്യക്തമാക്കുക
ഈ പരാമീറ്റർ ആവശ്യമാണ്.
റിട്ടേൺ മൂല്യം: SUCCESS അല്ലെങ്കിൽ FAIL.
ശ്രദ്ധിക്കുക: തിരിച്ചറിയാത്തവ നടപടി അവഗണിക്കപ്പെടുന്നു.
ഉദാഹരണം:
// ഓടുക ഇയ്യോബ് j സമകാലികമായി
ജോബ് ആക്ഷൻ(ജെ, സിൻക്രൺ, NULLSTR);

// ഓടുക ഇയ്യോബ് j അസമന്വിതമായി on ഹോസ്റ്റ് "db"
ജോബ് ആക്ഷൻ(ജെ, അസിൻക്രൺ, "db");

// ഇല്ലാതാക്കുക ഇയ്യോബ് j
ജോബ് ആക്ഷൻ(ജെ, ഇല്ലാതാക്കുക, NULLSTR);

// ഇല്ലാതാക്കുക ഇയ്യോബ് j കൂടെ a കാലതാമസം of 5 ഉണങ്ങിയ
// തമ്മിലുള്ള The അയയ്ക്കുന്നത് of അടയാളം ഒപ്പം
// സിഗിൽ
ജോബ് ആക്ഷൻ(ജെ, ഇല്ലാതാക്കുക, "deldelay=5");

// വീണ്ടും പ്രവർത്തിപ്പിക്കുക ഇയ്യോബ് j
ജോബ് ആക്ഷൻ(ജെ, വീണ്ടും, NULLSTR);

// സ്ഥലം a നിങ്ങൾ (സെർ) പിടിക്കുക on ഇയ്യോബ് j
ജോബ് ആക്ഷൻ(ജെ, പിടിക്കുക, "u");

// സ്ഥലം an അല്ലെങ്കിൽ (അവിടെ) പിടിക്കുക on ഇയ്യോബ് j
ജോബ് ആക്ഷൻ(ജെ, പിടിക്കുക, "o");

// സ്ഥലം a s(സിസ്റ്റം) പിടിക്കുക on ഇയ്യോബ് j
ജോബ് ആക്ഷൻ(ജെ, പിടിക്കുക, "s");

// സ്ഥലം a സ്ഥിരസ്ഥിതി പിടിക്കുക (യു) on ഇയ്യോബ് j
ജോബ് ആക്ഷൻ(ജെ, പിടിക്കുക, NULLSTR);

// റിലീസ് നിങ്ങൾ (സെർ) പിടിക്കുക നിന്ന് ഇയ്യോബ് j
ജോബ് ആക്ഷൻ(ജെ, പ്രകാശനം, "u");

// റിലീസ് അല്ലെങ്കിൽ (അവിടെ) പിടിക്കുക നിന്ന് ഇയ്യോബ് j
ജോബ് ആക്ഷൻ(ജെ, പ്രകാശനം, "o");

// റിലീസ് s(സിസ്റ്റം) പിടിക്കുക നിന്ന് ഇയ്യോബ് j
ജോബ് ആക്ഷൻ(ജെ, പ്രകാശനം, "s");

// റിലീസ് സ്ഥിരസ്ഥിതി പിടിക്കുക (യു) നിന്ന് ഇയ്യോബ് j
ജോബ് ആക്ഷൻ(ജെ, പ്രകാശനം, NULLSTR);

// അയയ്ക്കുക ഫോളോ അപ്പ് സിഗ്നൽ ലേക്ക് ഇയ്യോബ് j
ജോബ് ആക്ഷൻ(ജെ, സിഗ്നൽ, "SIGHUP");

// അപ്ഡേറ്റ് The അഭിപ്രായം ആട്രിബ്യൂട്ട് of ഇയ്യോബ്
// j ലേക്ക് "a സന്ദേശം".
// ദി പരം ഫോർമാറ്റ് ഇതാണ്: attribute_name=new_value
// കൂടിയാലോചിക്കുക പിബിഎസ് ഡോക്യുമെന്റേഷൻ വേണ്ടി a പട്ടിക of ജോലി
// ആട്രിബ്യൂട്ട് പേരുകൾ ആ കഴിയും be വ്യക്തമാക്കിയ.
ജോബ് ആക്ഷൻ(ജെ, മോഡിഫൈറ്റർ, "അഭിപ്രായം=എ സന്ദേശം");
// അപ്ഡേറ്റ് The Resource_List.cput ആട്രിബ്യൂട്ട് of ഇയ്യോബ്
// j ലേക്ക് 3600 സെക്കൻഡ്.
// ദി പരം ഫോർമാറ്റ് ഇതാണ്: resource_name=new_value
// കാണുക pbs_resources* ഒന്ന് പേജ് വേണ്ടി a പട്ടിക of
// റിസോഴ്സ്_നാമങ്ങൾ ആ കഴിയും be വ്യക്തമാക്കിയ.
ജോബ് ആക്ഷൻ(ജെ, മോഡിഫയറുകൾ, "cput=3600");

QueJobFind(ക്യൂ que, രസകരം int func, Int cpr, Int മൂല്യം);

QueJobFind(ക്യൂ que, രസകരം സ്ട്രിംഗ് func, Int cpr, സ്ട്രിംഗ് മൂല്യം);

QueJobFind(ക്യൂ que, രസകരം തീയതി ടൈം func, Int cpr, തീയതി സമയം മൂല്യം);

QueJobFind(ക്യൂ que, രസകരം വലുപ്പം func, Int cpr, വലിപ്പം മൂല്യം);

എവിടെ cpr ഇവയിലൊന്നാണ്: OP_EQ, OP_NEQ, OP_LE, OP_LT, OP_GE, OP_GT. ഫങ്ക്
ഒരു ഫംഗ്‌ഷനാണ്, അതിന്റെ ഒരേയൊരു വാദഗതി ജോലി തരത്തിലുള്ളതാണ്. ഇയ്യോബ് തിരിച്ചുവരവാണ്
ടൈപ്പ് ചെയ്യുക.

വിവരണം: ബാധകമാണ് ഫങ്ക് എല്ലാ ജോലികളിലേക്കും ബന്ധിക്കുന്നു , ആദ്യത്തേത് തിരികെ നൽകുക
ലോജിക്കൽ താരതമ്യത്തെ തൃപ്തിപ്പെടുത്തുന്ന ജോലി: ഫംഗ് (ജോലി) cpr മൂല്യം

ഉദാഹരണം:

വലുപ്പം JobVirtualMemAvailGet(ജോലി ജോലി)
{
വലുപ്പം sz;

sz = JobSizeResReqGet(ജോലി, "മെം");
റിട്ടേൺ(sz);
}
int JobWallTimeReqGet(ജോലി ജോലി)
{
int വാൾട്ട്;

വാൾട്ട് = JobIntResReqGet(ജോലി, "വാൾടൈം");
മടക്കം (മതിൽ);
}

int JobCpuTimeUsedGet(ജോലി ജോലി)
{
int cput;

cput = JobIntResUseGet(ജോലി, "cput");
റിട്ടേൺ (സിപുട്ട്);
}

അത് FindQueByName(സെറ്റ് അത് ക്യൂകൾ, സ്ട്രിംഗ് പേര്)
{
അത് q;

ഫോറെച്ച്(ക്യു in ക്യൂകൾ) {
എങ്കിൽ ( QueNameGet(q) EQ qname ) {
റിട്ടേൺ (ക്യു);
}
}
മടക്കം (NOQUE);
}
ഷെഡ്_മെയിൻ()
{
സെർവർ s;
അത് ക്യൂ;
ഗണം അത് ചതുരശ്ര അടി;

// നേടുക പ്രാദേശിക സെർവർ
s = AllServersLocalHostGet();

// നേടുക The വാലിൽ of The സെർവർ s
sq = ServerQueuesGet(കൾ);

// നേടുക The വരി പേരുനൽകിയത് "വേഗത" നിന്ന് The
// പ്രാദേശിക സെർവർ
ബന്ധിക്കുന്നു = FindQueByName( ചതുരശ്ര, "വേഗത" );

// കണ്ടെത്തുക The 1st ജോലി ആരുടെ വാൾടൈം ആവശ്യകത
// is == 300- കൾ:
QueJobFind(que, JobWallTimeReqGet, OP_EQ, 300);

// കണ്ടെത്തുക The 1st ജോലി ആരുടെ ഇമെയിൽ വിലാസം ലേക്ക്
// അറിയിക്കുക കുറിച്ച് ജോലി പ്രവർത്തനം != "bayucan":
QueJobFind(que, JobEmailAddrGet, OP_NEQ,
"bayucan");

// കണ്ടെത്തുക The 1st ജോലി ആ ആയിരുന്നു സൃഷ്ടിച്ചു ശേഷം
// or on 3 / 3 / 1997:
QueJobFind(que, JobDateTimeCreatedGet, OP_GE,
(3|3|1997));

// കണ്ടെത്തുക The 1st ജോലി ആ ആയിരുന്നു സൃഷ്ടിച്ചു ശേഷം
// 3:3:44:
QueJobFind(que, JobDateTimeCreatedGet, OP_GT,
(3:3:44));

// കണ്ടെത്തുക The 1st ജോലി ആ ആയിരുന്നു സൃഷ്ടിച്ചു ശേഷം
// 3:3:44 on 3 / 3 / 1997:
QueJobFind(que, JobDateTimeCreatedGet, OP_GT,
(3|3|1997@3:3:44));

// കണ്ടെത്തുക The 1st ജോലി ആരുടെ സിപിയു കാലം ഉപയോഗിച്ച < 1600- കൾ:
QueJobFind(que, JobCpuTimeUsedGet, OP_LT, 1600);

// കണ്ടെത്തുക The 1st ജോലി ആരുടെ വെർച്വൽ മെമ്മറി
// ആവശ്യകത <= 300mb:
QueJobFind(que, JobVirtualMemAvailGet, OP_LE,
300 എംബി);
}

ഇയ്യോബ് QueJobFind( അത് അത്, തമാശ int ഫങ്ക്, int cpr)

ഇയ്യോബ് QueJobFind( അത് അത്, തമാശ സ്ട്രിംഗ് ഫങ്ക്, int cpr)

ഇയ്യോബ് QueJobFind( അത് അത്, തമാശ തീയതി ടൈം ഫങ്ക്, int cpr)

ഇയ്യോബ് QueJobFind( അത് അത്, തമാശ വലുപ്പം ഫങ്ക്, int cpr)

എവിടെ cpr ഇനിപ്പറയുന്നവയിൽ ഒന്നാകാം: OP_MAX, OP_MIN, ഫങ്ക് ഒരു ആണ്
ഫംഗ്‌ഷൻ അതിന്റെ ഒരേയൊരു വാദം ജോലി തരത്തിലുള്ളതാണ്.

വിവരണം: കണ്ടെത്തിയ പരമാവധി അല്ലെങ്കിൽ കുറഞ്ഞ മൂല്യം ഉപയോഗിച്ച് ജോലി നൽകുന്നു
ഫംഗ് (ജോലി) എല്ലാ ജോലികൾക്കും ഇത് ബാധകമാണ് ബന്ധിക്കുന്നു .

ഉദാഹരണം:
int JobCpuTimeReqGet(ജോലി ജോലി)
{
int cput;

cput = JobIntResReqGet(ജോലി, "cput");
റിട്ടേൺ (സിപുട്ട്);
}
ഷെഡ്_മെയിൻ()
{
അത് ക്യൂ;
ഇയ്യോബ് ജോലി;

// കണ്ടെത്തുക The ഇയ്യോബ് കൂടെ The ഏറ്റവും സിപിയു കാലം
// ആവശ്യം:
ജോലി = QueJobFind(que, JobCpuTimeReqGet, OP_MAX);

// കണ്ടെത്തുക The ഇയ്യോബ് കൂടെ The ഏറ്റവും കുറഞ്ഞ സിപിയു കാലം
// ആവശ്യം:
ജോലി = 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, വലിപ്പം മൂല്യം)

എവിടെ cpr ഇനിപ്പറയുന്നവയിൽ ഒന്നാകാം: OP_EQ, OP_NEQ, OP_LE, OP_LT,
OP_GE, OP_GT, ഫങ്ക് ഒരു ഫംഗ്‌ഷനാണ്, അതിന്റെ ഒരേയൊരു വാദം ജോലി തരത്തിലുള്ളതാണ്.

വിവരണം: ബാധകമാണ് ഫങ്ക് എല്ലാ ജോലികളിലേക്കും ബന്ധിക്കുന്നു , ഒരു പുതിയ ക്യൂ തിരികെ നൽകുന്നു
താരതമ്യ വ്യവസ്ഥയെ തൃപ്തിപ്പെടുത്തുന്ന എല്ലാ ജോലികളും ഉൾക്കൊള്ളുന്നു:
ഫംഗ് (ജോലി) cpr മൂല്യം

ഉദാഹരണം:
int JobWallTimeReqGet(ജോലി ജോലി)
{
int വാൾട്ട്;

വാൾട്ട് = JobIntResReqGet(ജോലി, "വാൾടൈം");
മടക്കം (മതിൽ);
}
ഷെഡ്_മെയിൻ()
{
അത് ക്യൂ;
അത് newq;

// റിട്ടേൺസ് a പുതിയ ബന്ധിക്കുന്നു അടങ്ങിയ എല്ലാം ജോലികൾ in "ക്യൂ"
// കൂടെ a വാൾടൈം ആവശ്യകത == 300- കൾ:
newq = ക്യൂഫിൽറ്റർ(ക്യൂ, JobWallTimeReqGet, OP_EQ, 300);

// റിട്ടേൺസ് a പുതിയ ബന്ധിക്കുന്നു അടങ്ങിയ എല്ലാം ജോലികൾ in "ക്യൂ"
// കൂടെ an ഇമെയിൽ വിലാസം != "bayucan":
newq = ക്യൂഫിൽറ്റർ(ക്യൂ, JobEmailAddrGet, OP_NEQ, "bayucan");

// റിട്ടേൺസ് a പുതിയ ബന്ധിക്കുന്നു അടങ്ങിയ എല്ലാം ജോലികൾ in "ക്യൂ"
// സൃഷ്ടിച്ചു ശേഷം or on 3 / 3 / 1997:
newq = ക്യൂഫിൽറ്റർ(ക്യൂ, JobDateTimeCreatedGet, OP_GE,
(3|3|1997));

// റിട്ടേൺസ് a പുതിയ ബന്ധിക്കുന്നു അടങ്ങിയ എല്ലാം ജോലികൾ in "ക്യൂ"
// സൃഷ്ടിച്ചു ശേഷം 3:3:44:
newq = ക്യൂഫിൽറ്റർ(ക്യൂ, JobDateTimeCreatedGet, OP_GT,
(3:3:44));

// റിട്ടേൺസ് a പുതിയ ബന്ധിക്കുന്നു അടങ്ങിയ എല്ലാം ജോലികൾ in "ക്യൂ"
// സൃഷ്ടിച്ചു ശേഷം 3:3:44 on 3 / 3 / 1997:
newq = ക്യൂഫിൽറ്റർ(ക്യൂ, 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 അടുക്കാനുള്ള ജോലികളുടെ കൂട്ടം. കീ സോർട്ടിംഗ് കീ ആണ് a
ജോലി തരത്തിലുള്ള ഒരേയൊരു വാദത്തിന്റെ പ്രവർത്തനം, ഓർഡർ അടുക്കൽ ആണ്
ഓർഡർ: ASC, DESC.

വിവരണം: ഘടകങ്ങൾ അടുക്കുന്നു s , ഒന്നുകിൽ ആരോഹണത്തിൽ അല്ലെങ്കിൽ
തിരിച്ച് നൽകിയ മൂല്യങ്ങളുടെ DESCending ഓർഡർ കീ ഫംഗ്ഷൻ, പോലെ
ജോലികളുടെ സെറ്റിലെ ഓരോ അംഗത്തിനും ബാധകമാണ്. ദി s ഒബ്ജക്റ്റ് പരിഷ്കരിച്ചു
ഈ കോളിനൊപ്പം. ഇത് ഫലത്തെ ആശ്രയിച്ച് വിജയം അല്ലെങ്കിൽ പരാജയം നൽകുന്നു
തരം.

ഉദാഹരണങ്ങൾ:
വലുപ്പം JobMemReqGet(ജോലി ജോലി)
{
വലുപ്പം മെം;

നിഗര് = JobSizeResReqGet(ജോലി, "മെം");
മടക്കം(മെം);
}

ഷെഡ്_മെയിൻ()
{
സെർവർ മാസ്റ്റർ;

ഗണം ഇയ്യോബ് ജോലികൾ;

int ഓർഡർ;

// നേടുക പ്രാദേശിക സെർവർ
യജമാനന് = AllServersLocalHostGet();

ജോലികൾ = ServerJobsGet(മാസ്റ്റർ);
അടുക്കുക(ജോലികൾ, ജോലി മുൻഗണന, ASC);
അടുക്കുക(ജോലികൾ, JobIdGet, DESC);
ഓർഡർ = ASC;
അടുക്കുക(ജോലികൾ, JobDateTimeCreatedGet, ഓർഡർ);
ഓർഡർ = DESC;
അടുക്കുക(ജോലികൾ, JobMemReqGet, ഓർഡർ);
}

int അടുക്കുക (സെറ്റ് അത് s, തമാശ int കീ, int ഓർഡർ)

int അടുക്കുക (സെറ്റ് അത് s, തമാശ സ്ട്രിംഗ് കീ, int ഓർഡർ)

int അടുക്കുക (സെറ്റ് അത് s, തമാശ ഫ്ലോട്ട് കീ, int ഓർഡർ)

int അടുക്കുക (സെറ്റ് അത് s, തമാശ തീയതി ടൈം കീ, int ഓർഡർ)

int അടുക്കുക (സെറ്റ് അത് s, തമാശ വലുപ്പം കീ, int ഓർഡർ)

എവിടെ s അടുക്കാനുള്ള ക്യൂകളുടെ കൂട്ടം. കീ സോർട്ടിംഗ് കീ ആണ് a
ക്യൂ ടൈപ്പിലുള്ള ഒരേയൊരു ആർഗ്യുമെന്റ് ഫംഗ്‌ഷൻ, ഓർഡർ അടുക്കൽ ആണ്
ഓർഡർ: ASC, DESC.

വിവരണം: ഘടകങ്ങൾ അടുക്കുന്നു s , ഒന്നുകിൽ ആരോഹണത്തിൽ അല്ലെങ്കിൽ
തിരിച്ച് നൽകിയ മൂല്യങ്ങളുടെ DESCending ഓർഡർ കീ ഫംഗ്ഷൻ, പോലെ
ക്യൂകളുടെ സെറ്റിലെ ഓരോ അംഗത്തിനും ബാധകമാണ്. ദി s വസ്തുവാണ്
ഈ കോൾ ഉപയോഗിച്ച് പരിഷ്ക്കരിച്ചു. ഇത് അനുസരിച്ച് വിജയം അല്ലെങ്കിൽ പരാജയം നൽകുന്നു
അത്തരത്തിലുള്ള ഫലം.

ഉദാഹരണങ്ങൾ:
വലുപ്പം QueMemAvailGet(ക്യൂ അതിലും)
{
വലുപ്പം മെം;

നിഗര് = QueSizeResAvailGet(ക്യൂ, "മെം");
മടക്കം(മെം);
}

ഷെഡ്_മെയിൻ()
{
സെർവർ മാസ്റ്റർ;

ഗണം അത് ques;
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 അടുക്കാനുള്ള സെർവറുകളുടെ കൂട്ടം. കീ സോർട്ടിംഗ് കീ ആണ്
സെർവർ തരത്തിലുള്ള ഒരേയൊരു ആർഗ്യുമെന്റ്, ഓർഡർ ആകുന്നു
സോർട്ടിംഗ് ഓർഡർ: ASC, DESC.

വിവരണം: ഘടകങ്ങൾ അടുക്കുന്നു s , ഒന്നുകിൽ ആരോഹണത്തിൽ അല്ലെങ്കിൽ
തിരിച്ച് നൽകിയ മൂല്യങ്ങളുടെ DESCending ഓർഡർ കീ ഫംഗ്ഷൻ, പോലെ
സെർവറുകളുടെ സെറ്റിലെ ഓരോ അംഗത്തിനും ബാധകമാണ്. ദി s വസ്തുവാണ്
ഈ കോൾ ഉപയോഗിച്ച് പരിഷ്ക്കരിച്ചു. ഇത് അനുസരിച്ച് വിജയം അല്ലെങ്കിൽ പരാജയം നൽകുന്നു
അത്തരത്തിലുള്ള ഫലം.

ഉദാഹരണങ്ങൾ:
വലുപ്പം ServerMemAvailGet(സെർവർ സേവിക്കുക)
{
വലുപ്പം മെം;

നിഗര് = ServerSizeResAvailGet(സേവനം, "മെം");
മടക്കം(മെം);
}

ഷെഡ്_മെയിൻ()
{
ഗണം സെർവർ സെർവർ;

int ഓർഡർ;

int റിട്ട്;

സെർവർ = AllServersGet();

നിഷേധിക്കല് = അടുക്കുക(സെർവർ, ServerMaxRunJobsGet, ASC);
അടുക്കുക(സെർവർ, ServerInetAddrGet, ASC);

ഓർഡർ = DESC;
അടുക്കുക(സെർവർ, ServerMemAvailGet, ഓർഡർ);
}

int അടുക്കുക (സെറ്റ് സിനോഡ് s, തമാശ int കീ, int ഓർഡർ)

int അടുക്കുക (സെറ്റ് സിനോഡ് s, തമാശ സ്ട്രിംഗ് കീ, int ഓർഡർ)

int അടുക്കുക (സെറ്റ് സിനോഡ് s, തമാശ ഫ്ലോട്ട് കീ, int ഓർഡർ)

int അടുക്കുക (സെറ്റ് സിനോഡ് s, തമാശ തീയതി ടൈം കീ, int ഓർഡർ)

int അടുക്കുക (സെറ്റ് സിനോഡ് s, തമാശ വലുപ്പം കീ, int ഓർഡർ)

എവിടെ s അടുക്കാനുള്ള നോഡുകളുടെ കൂട്ടം. കീ സോർട്ടിംഗ് കീ ആണ് a
CNode തരത്തിലുള്ള ആർഗ്യുമെന്റ് മാത്രമുള്ള ഫംഗ്‌ഷൻ, ഓർഡർ അടുക്കൽ ആണ്
ഓർഡർ: ASC, DESC.

വിവരണം: ഘടകങ്ങൾ അടുക്കുന്നു s , ഒന്നുകിൽ ആരോഹണത്തിൽ അല്ലെങ്കിൽ
തിരിച്ച് നൽകിയ മൂല്യങ്ങളുടെ DESCending ഓർഡർ കീ ഫംഗ്ഷൻ, പോലെ
നോഡുകളുടെ സെറ്റിലെ ഓരോ അംഗത്തിനും ബാധകമാണ്. ദി s വസ്തുവാണ്
ഈ കോൾ ഉപയോഗിച്ച് പരിഷ്ക്കരിച്ചു. ഇത് അനുസരിച്ച് വിജയം അല്ലെങ്കിൽ പരാജയം നൽകുന്നു
അത്തരത്തിലുള്ള ഫലം.

ഉദാഹരണങ്ങൾ:
വലുപ്പം CNodeMyMemAvailGet(CNode cn)
{
വലുപ്പം മെം;

നിഗര് = CNodeMemAvailGet(cn, "വെർച്വൽ");
മടക്കം(മെം);
}

ഷെഡ്_മെയിൻ()
{
ഗണം സിനോഡ് സ്നോഡ്;

int ഓർഡർ;

സ്നോഡ് = AllNodesGet();

അടുക്കുക(സ്‌നോഡ്, CNodeIdletimeGet, ASC);
അടുക്കുക(സ്‌നോഡ്, CNodeNameGet, ASC);
ഓർഡർ = DESC;
അടുക്കുക(സ്‌നോഡ്, CNodeMyMemAvailGet, ഓർഡർ);
}

CNode..Get() പ്രവർത്തനങ്ങൾ

മുൻ വിഭാഗത്തിൽ ചർച്ച ചെയ്ത CNode..Get() ഫംഗ്‌ഷനുകളുടെ റിട്ടേൺ മൂല്യങ്ങൾ ഇവയാണ്
ഓരോ ഷെഡ്യൂളിംഗ് ആവർത്തനത്തിലും CNode-ന്റെ MOM-ലേക്ക് റിസോഴ്സ് അന്വേഷണങ്ങൾ അയച്ചുകൊണ്ട് ലഭിക്കുന്നത്.
ഉദാഹരണത്തിന്, CNodeLoadAveGet(നോഡ്) ചില <ഹോസ്റ്റിൽ നിന്ന് ലഭിച്ച മൂല്യം തിരികെ നൽകും
റിസോഴ്സ്> അന്വേഷണം (ഇത് "ലോഡേവ്" എന്ന സ്ട്രിംഗ് ആകാം) നോഡിന്റെ MOM-ലേക്ക് അയച്ചത്. ദി
" -> CNode..Get()" മാപ്പിംഗുകൾ ആന്തരികമായി സ്ഥാപിക്കപ്പെട്ടതാണ്, പക്ഷേ അവ ആകാം
ഷെഡ്യൂളർ കോൺഫിഗറേഷൻ ഫയൽ വഴി പരിഷ്കരിച്ച അല്ലെങ്കിൽ കൂടുതൽ മാപ്പിംഗുകൾ ചേർക്കാവുന്നതാണ്. കോൺഫിഗറേഷൻ
ഫയൽ ചർച്ചചെയ്യുന്നു pbs_sched_basl(8 ബി).
ഇതിനകം സ്ഥാപിച്ച മാപ്പിംഗുകൾ ഇനിപ്പറയുന്നവയിൽ നൽകിയിരിക്കുന്നു:

എല്ലാ വാസ്തുവിദ്യകൾക്കും:

CNode..Get() യഥാർത്ഥ വിളി ഹോസ്റ്റ് വിഭവം
======================= ==============
CNodeOsGet(നോഡ്) കമാനം
CNodeLoadAveGet(നോഡ്) ലോഡേവ്
CNodeIdletimeGet(നോഡ്) നിഷ്ക്രിയ സമയം

onworks.net സേവനങ്ങൾ ഉപയോഗിച്ച് basl2cB ഓൺലൈനായി ഉപയോഗിക്കുക