ນີ້ແມ່ນຄໍາສັ່ງ basl2cB ທີ່ສາມາດດໍາເນີນການໄດ້ໃນ OnWorks ຜູ້ໃຫ້ບໍລິການໂຮດຕິ້ງຟຣີໂດຍໃຊ້ຫນຶ່ງໃນຫຼາຍບ່ອນເຮັດວຽກອອນໄລນ໌ຂອງພວກເຮົາເຊັ່ນ Ubuntu Online, Fedora Online, Windows online emulator ຫຼື MAC OS online emulator
ໂຄງການ:
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 compiler ທີ່ຜະລິດລະຫັດລະດັບປານກາງທີ່ສາມາດປ້ອນເຂົ້າໄປໃນ a
compiler C ປົກກະຕິ, ແລະເຊື່ອມຕໍ່ກັບຫ້ອງສະຫມຸດ PBS ເພື່ອຜະລິດຕາຕະລາງປະຕິບັດໄດ້.
Basl2c ໃຊ້ເປັນການປ້ອນຂໍ້ມູນ a baslFile, ເຊິ່ງເປັນໂຄງການທີ່ຂຽນໄວ້ໃນ Batch Scheduling
ພາສາ, ປະກອບມີລະຫັດການກໍານົດເວລາຕົ້ນຕໍ. Basl2c ຈາກນັ້ນປ່ຽນໂຄງສ້າງ BASL
ໃນໄຟລ໌ເຂົ້າໄປໃນຄໍາຖະແຫຼງ C, ແລະມັນຍັງຕິດລະຫັດເພີ່ມເຕີມເພື່ອຜະລິດ PBS
ລະຫັດແຫຼ່ງຕາຕະລາງ. ໂດຍຄ່າເລີ່ມຕົ້ນ, ລະຫັດ C ທີ່ໄດ້ຮັບຜົນໄດ້ຖືກຂຽນໄວ້ໃນໄຟລ໌
pbs_sche.c.
ຊື່ເສັ້ນທາງເຕັມໄປຫາໄຟລ໌ C ທີ່ໄດ້ຮັບຜົນແມ່ນສິ່ງທີ່ຈໍາເປັນຕ້ອງໄດ້ລະບຸໄວ້ໃນ SCHD_CODE
ຕົວແປໃນ local.mk ກ່ອນທີ່ຈະລວບລວມຕາຕະລາງ BASL ເພື່ອຜະລິດ pbs_sche
ປະຕິບັດໄດ້.
OPTIONS
-d ພິມຂໍ້ຄວາມແກ້ໄຂເພີ່ມເຕີມເພື່ອ lexer (ເບິ່ງ -l ທາງເລືອກ), parser (ເບິ່ງ -p
ທາງເລືອກ), ຕາຕະລາງສັນຍາລັກ (ເບິ່ງ -y ທາງເລືອກ), ການວິເຄາະ semantic (ເບິ່ງ -s ທາງເລືອກ), ແລະລະຫັດ
generator (ເບິ່ງ -g ທາງເລືອກ).
-l lexerDebugFile
lexerDebugFile ແມ່ນຊື່ຂອງໄຟລ໌ທີ່ຈະຂຽນໃສ່ຂໍ້ຄວາມແກ້ບັນຫາທີ່ສ້າງຂຶ້ນ
ໃນຂະນະທີ່ສະແກນຫາ tokens.
-p parserDebugFile
parserDebugFile ແມ່ນຊື່ຂອງໄຟລ໌ທີ່ຈະຂຽນໃສ່ຂໍ້ຄວາມແກ້ບັນຫາທີ່ສ້າງຂຶ້ນ
ໃນຂະນະທີ່ການວາງ tokens ເຂົ້າກັນໃນວິທີການນໍາໃຊ້ໄດ້.
-y symtabDebugFile
symtabDebugFile ແມ່ນຊື່ຂອງໄຟລ໌ທີ່ຈະຂຽນເຂົ້າໄປໃນຂໍ້ຄວາມແກ້ບັນຫາທີ່ກ່ຽວຂ້ອງກັບ
ຕາຕະລາງສັນຍາລັກ.
-s semanticDebugFile
semanticDebugFile ແມ່ນຊື່ຂອງໄຟລ໌ທີ່ຈະຂຽນເຂົ້າໃນຂໍ້ຄວາມແກ້ບັນຫາ
ສ້າງຂຶ້ນໃນຂະນະທີ່ກວດສອບເພື່ອໃຫ້ແນ່ໃຈວ່າຕົວແປແລະຕົວປະຕິບັດການຖືກນໍາໃຊ້ໃນ a
ວິທີການທີ່ສອດຄ່ອງ.
-g codegenDebugFile
codegenDebugFile ແມ່ນຊື່ຂອງໄຟລ໌ທີ່ຈະຂຽນໃສ່ຂໍ້ຄວາມແກ້ບັນຫາທີ່ສ້າງຂຶ້ນ
ໃນຂະນະທີ່ການແປງຖະແຫຼງການ BASL ເປັນຖະແຫຼງການ C.
-c cFile
cFile ແມ່ນຊື່ຂອງໄຟລ໌ທີ່ລະຫັດ C ທີ່ຜະລິດໄດ້ຖືກຂຽນເຂົ້າໄປໃນ.
HAND STRUCTURE
ໂຄງສ້າງພື້ນຖານຂອງລະຫັດຕາຕະລາງທີ່ຂຽນໃນ BASL ແມ່ນດັ່ງຕໍ່ໄປນີ້:
ສູນ or ເພີ່ມເຕີມ FUNCTIONS ຄໍານິຍາມ
ສູນ or ເພີ່ມເຕີມ ທົ່ວໂລກ ຄວາມເປັນໄປໄດ້ ຄຳ ອະທິບາຍ
ສູນ or ເພີ່ມເຕີມ ການມອບຫມາຍ ບົດລາຍງານ (ເຖິງ ເລີ່ມຕົ້ນ ທົ່ວໂລກ ຕົວແປ)
sche_main()
{
ຫນຶ່ງ or ເພີ່ມເຕີມ ຄວາມເປັນໄປໄດ້ ຄຳ ອະທິບາຍ
ສູນ or ເພີ່ມເຕີມ ຖະແຫຼງການ
}
ຍົກຕົວຢ່າງ,
% cat sched.basl
Int ລວມ(Int a, Int b)
{
Int s;
s = a + b;
ກັບຄືນ;
}
Int ໂລກ;
sche_main()
{
Int c;
a = 3;
b = 4;
c = sum(a, b);
ພິມ(c);
ໂລກ = 5;
ພິມ(ໂລກ);
}
sche_main() ແມ່ນຟັງຊັນທີ່ຖືກເອີ້ນຢູ່ໃນທຸກໆການກໍານົດເວລາ iteration.
FUNCTIONS
ເພື່ອກໍານົດຟັງຊັນທີ່ສາມາດຖືກເອີ້ນໃນຫນ້າທີ່ຕໍ່ໄປ, syntax ແມ່ນ:
ປະເພດກັບຄືນ function-name ( DATATYPE1 IDENTIFIER1,
DATATYPE2 IDENTIFIER2, ... )
{
ຫນຶ່ງ or ເພີ່ມເຕີມ ຄວາມເປັນໄປໄດ້ ຄຳ ອະທິບາຍ
ສູນ or ເພີ່ມເຕີມ ຖະແຫຼງການ
}
ຍົກຕົວຢ່າງ,
void printStuff(ວັນອາທິດ ດາວໂຫຼດ DateTime t, string str,
ເລືອກຂະຫນາດ ເຊລ, CNode cn)
{
ພິມ(dow);
ພິມ(t);
ພິມ(str);
ພິມ(sz);
ພິມ(cn);
}
ຟັງຊັນທີ່ຖືກຕ້ອງ ປະເພດກັບຄືນ ຄື: Void, Int, Float, Dayofweek, DateTime, String, Size,
ເຊີຟເວີ, Que, ວຽກ, CNode, ກໍານົດເຄື່ອງແມ່ຂ່າຍ, ກໍານົດ Que, ກໍານົດວຽກ, ກໍານົດ CNode.
ປະເພດຂໍ້ມູນທີ່ຖືກຕ້ອງ ( DATATYPE1, DATATYPE2, ... ) ສໍາລັບຕົວກໍານົດພາລາມິເຕີແມ່ນ: int,
Float, Dayofweek, DateTime, String, Size, Server, Que, Job, CNode, Set Server, Set Que,
ຕັ້ງຄ່າວຽກ, ຕັ້ງ CNode, 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
Server, Fun Que, Fun Job, Fun CNode, Fun Set Server, Fun Set Que, Fun Set Job, Fun Set
CNode. ປະເພດຂໍ້ມູນເຫຼົ່ານີ້ຈະຖືກປຶກສາຫາລືໃນຫົວຂໍ້ຕໍ່ໄປ.
ຟັງຊັນຖືກເອີ້ນໂດຍຊື່ແລະຂໍ້ໂຕ້ແຍ້ງຂອງພວກມັນຄືກັບໃນ:
ສິ່ງພິມ( ຈັນ, (5|1|1997@14:32:00), "ຕາຕະລາງ ເລີ່ມຕົ້ນ",
30gb, node );
basl2c ຕົວຈິງແລ້ວຈະເພີ່ມຄໍານໍາຫນ້າ "basl_" ໃສ່ຊື່ຟັງຊັນທີ່ກໍານົດເວລາໃຫ້
writer ເພື່ອຫຼຸດຜ່ອນໂອກາດຂອງການ collision ຊື່, ເຊິ່ງສາມາດສົ່ງຜົນໃນເວລາທີ່ລະຫັດ C ຜົນໄດ້ຮັບ
ເຊື່ອມຕໍ່ກັບຫ້ອງສະຫມຸດ PBS, BASL. ຕົວຢ່າງ, ຖ້າທ່ານເບິ່ງລະຫັດ C ທີ່ຜະລິດສໍາລັບ
ສິ່ງພິມ, ເຈົ້າຈະເຫັນ,
basl_printStuff( MON, (5|1|1997@14:32:00),
"sched ເລີ່ມຕົ້ນ", 30gb, node );
ເຊັ່ນດຽວກັບ C, ການເອີ້ນຟັງຊັນທັງໝົດຈະຕ້ອງໄດ້ກຳນົດໄວ້ກ່ອນໜ້ານີ້. ຜູ້ລວບລວມຂໍ້ມູນ BASL ຈະ
ກວດເບິ່ງໃຫ້ແນ່ໃຈວ່າການໂຕ້ຖຽງໃນການໂທຟັງຊັນກົງກັນແທ້ (ໃນຂໍ້ກໍານົດຂອງ
types) ກັບພາລາມິເຕີໃນນິຍາມຟັງຊັນ.
ສອງປະເພດຂອງຟັງຊັນທີ່ມີຢູ່ໃນ BASL: ຫນ້າທີ່ກໍານົດໂດຍຜູ້ໃຊ້ແລະຫນ້າທີ່ກໍານົດໄວ້ລ່ວງຫນ້າ.
ຫນ້າທີ່ກໍານົດໂດຍຜູ້ໃຊ້ແມ່ນຜູ້ທີ່ນັກຂຽນກໍານົດເວລາໃຫ້ຄໍານິຍາມສໍາລັບ,
ໃນຂະນະທີ່ຫນ້າທີ່ກໍານົດໄວ້ລ່ວງຫນ້າແມ່ນຜູ້ທີ່ສາມາດເອີ້ນໄດ້ທັນທີໂດຍບໍ່ມີການຈໍາເປັນຕ້ອງໄດ້
ການກໍານົດມັນ. ສໍາລັບບັນຊີລາຍຊື່ຂອງຫນ້າທີ່ກໍານົດໄວ້ລ່ວງຫນ້າ, ເບິ່ງພາກກ່ຽວກັບ ກຳນົດໄວ້ລ່ວງໜ້າ FUNCTIONS .
ຄວາມເປັນໄປໄດ້ ຄຳ ອະທິບາຍ
ເຊັ່ນດຽວກັນກັບໃນ C, ຕົວແປທັງຫມົດໃນລະຫັດ BASL ຕ້ອງໄດ້ຮັບການປະກາດຢ່າງຈະແຈ້ງກ່ອນທີ່ຈະນໍາໃຊ້. ເຫຼົ່ານັ້ນ
ຕົວແປທີ່ປະກາດຢູ່ນອກຟັງຊັນໃດນຶ່ງແມ່ນເອີ້ນວ່າຕົວແປທົ່ວໂລກ, ໃນຂະນະທີ່
ຕົວແປທີ່ຖືກປະກາດຢູ່ໃນຮ່າງກາຍຂອງຫນ້າທີ່ເອີ້ນວ່າຕົວແປທ້ອງຖິ່ນ. ທົ່ວໂລກ
ຕົວແປແມ່ນສາມາດໃຊ້ໄດ້ທຸກບ່ອນພາຍໃນລະຫັດ BASL, ໃນຂະນະທີ່ຕົວແປທ້ອງຖິ່ນສາມາດອ່ານໄດ້
ພຽງແຕ່ຢູ່ໃນຫນ້າທີ່ທີ່ເຂົາເຈົ້າໄດ້ຖືກປະກາດ.
syntax ຂອງການປະກາດຕົວແປແມ່ນ:
DATATYPE ຕົວລະບຸຕົວຕົນ ;
ບ່ອນທີ່ DATATYPE ສາມາດເປັນ: Int, Float, Dayofweek, DateTime, String, Size, Server, Que, Job,
CNode, ຕັ້ງເຊີບເວີ, ຕັ້ງ Que, ກໍານົດວຽກ, ຕັ້ງ CNode, Range Int, Range Float, Range Dayofweek,
Range DateTime, ຂະໜາດຊ່ວງ.
ຂໍ້ມູນ TYPE
void ໃຊ້ສໍາລັບຟັງຊັນທີ່ບໍ່ສົ່ງຄືນຄ່າ.
Int ລົງລາຍເຊັນ, ຕົວເລກທັງໝົດໃຫ້ຢູ່ໃນຖານ 10.
ຕົວຢ່າງຄົງທີ່:
5, +1, -3, ຄວາມສຳເລັດ (=1), FAIL (=0), TRUE (=1), FALSE (=0)
float ຕົວເລກທີ່ແທ້ຈິງທີ່ຖືກສະແດງເປັນສອງເທົ່າໃນລະຫັດ C ທີ່ແປແລ້ວ.
ຕົວຢ່າງຄົງທີ່: 4.3, +1.2, -2.6
ມື້ຂອງອາທິດ
ຄ່າຄົງທີ່: SUN, MON, TUE, WED, THU, FRI, SAT, ພາຍໃນເປັນຕົວແທນເປັນ
integer value constant with SUN=0, MON=1, ແລະອື່ນໆ.
DateTime
ລະບຸໃນຮູບແບບໜຶ່ງໃນ 3 ຮູບແບບ:
[1] (m|d|y) ບ່ອນທີ່ 1 <= m <= 12, 1 <= d <= 31, 0 <= y, ex. (4|4|1997);
[2] (hh:mm:ss) where 0 <= hh <= 23, 0 <= mm <= 59, 0 <= ss <= 61, ex.
(12:01:00);
[3] (m|d|y@hh:mm:ss), ex. (4|4|1997@12:01:00)
ໃນລະຫວ່າງການສົມທຽບວັນທີ / ເວລາ, "ປັດຈຸບັນ" ທີ່ໃຊ້ເວລາແມ່ນການທົດແທນຖ້າຫາກວ່າເວລາ
ສ່ວນແມ່ນບໍ່ໄດ້ໃຫ້ (ຮູບແບບ [1]); ວັນທີ "ດຽວນີ້" ຖືກປ່ຽນແທນຖ້າ
ສ່ວນວັນທີບໍ່ໄດ້ຖືກມອບໃຫ້ (ຮູບແບບ [2]). ນອກຈາກນີ້, ສ່ວນຫນຶ່ງປີເຕັມຕ້ອງ
ໄດ້ຮັບການມອບໃຫ້ (ie 1997 ແທນທີ່ຈະເປັນ 97) ໃນວັນທີເພື່ອຫຼີກເວັ້ນການບໍ່ແນ່ນອນ.
string ສະຕຣິງຖືກຫຸ້ມຢູ່ໃນວົງຢືມ (") ແລະມັນສາມາດມີສິ່ງໃດແດ່ຍົກເວັ້ນອັນອື່ນ
quote, ແຖວໃຫມ່, ແລະວົງເລັບຊ້າຍແລະຂວາ.
ຕົວຢ່າງຄົງທີ່: "a ຕົວຢ່າງ string", NULLSTR
ເລືອກຂະຫນາດ ຮູບແບບ: ບ່ອນທີ່ suffix ແມ່ນຕົວຄູນຂອງແບບຟອມ:
:
ວີຜົນປະໂຫຍດ ຫນ່ວຍບໍລິການ (ໄບຕ໌ 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.
bytes ໃນເຄື່ອງ 32-bit).
ໃນເວລາທີ່ດໍາເນີນການກ່ຽວກັບ 2 ຂະຫນາດ operands ທີ່ມີ suffixes ທີ່ແຕກຕ່າງກັນ, suffix ຂອງ
"ຕ່ໍາ" ຂອງທັງສອງຈະເປັນ suffix ຜົນໄດ້ຮັບ. ຍົກຕົວຢ່າງ,
10mb + 10gb = 10250mb
ຕົວຢ່າງຄົງທີ່: -1b, 2w, 1kb, 2mw, +3gb, 4tw, 6Pb
ລະດັບ Int
ຮູບແບບ: (ຄ່າ Int ຕໍ່າ, ຄ່າ Int ສູງ)
ບ່ອນທີ່ຄ່າ Int ຕໍ່າ <= ຄ່າ Int ສູງ. ຕົວຢ່າງຄົງທີ່: (1,3)
ລະດັບ float
ຮູບແບບ: (ຄ່າ Float ຕໍ່າ, ຄ່າ Float ສູງ)
ບ່ອນທີ່ມີຄ່າຕໍ່າ <= ຄ່າສູງ. ຕົວຢ່າງຄົງທີ່: (2.3, 4.6)
ລະດັບ ມື້ຂອງອາທິດ
ຮູບແບບ: (ມື້ກ່ອນໜ້າ, ມື້ຕໍ່ມາ)
ບ່ອນທີ່ມື້ກ່ອນຫນ້າ <= ມື້ຕໍ່ມາ. ຕົວຢ່າງຄົງທີ່: (WED, FRI)
ລະດັບ DateTime
ຮູບແບບ: (ວັນທີ/ເວລາກ່ອນໜ້າ, ວັນທີ/ເວລາຕໍ່ມາ)
ບ່ອນທີ່ວັນທີ/ເວລາກ່ອນໜ້າ <= ຕໍ່ມາວັນທີ/ເວລາ.
ຫມາຍເຫດ: ຖ້າຫາກວ່າໄລຍະທີ່ມີພຽງແຕ່ສ່ວນທີ່ໃຊ້ເວລາ, ແລະເວລາກ່ອນຫນ້ານັ້ນ "ປະກົດວ່າ" ກັບ
be > ເວລາຕໍ່ມາຄືກັບ "((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)
Server ແຜນທີ່ໂດຍກົງກັບວັດຖຸເຊີບເວີ PBS. ກ Server ຈັດການຫນຶ່ງຫຼືຫຼາຍກວ່ານັ້ນ ວ່າ ວັດຖຸ.
ຕົວຢ່າງຄົງທີ່: NOSERVER
CNode ສໍາລັບ node ຄອມພິວເຕີປະກອບດ້ວຍຮູບພາບ OS ດຽວ, ຫນ່ວຍຄວາມຈໍາທີ່ໃຊ້ຮ່ວມກັນ, ແລະຊຸດ
ຂອງ CPU. CNode ແລ່ນ 1 PBS MOM.
ຕົວຢ່າງຄົງທີ່: NOCNODE
ວ່າ ແຜນທີ່ໂດຍກົງໄປຫາວັດຖຸແຖວ PBS. ກ ວ່າ object spools ໜຶ່ງ ຫຼືຫຼາຍກວ່ານັ້ນ ວຽກເຮັດງານທໍາ
ວັດຖຸ.
ຕົວຢ່າງຄົງທີ່: NOQUE
ວຽກເຮັດງານທໍາ ແຜນທີ່ໂດຍກົງກັບວັດຖຸວຽກ PBS. ກ ວຽກເຮັດງານທໍາ ວັດຖຸມີຄຸນລັກສະນະບາງຢ່າງ ແລະ
ຄວາມຕ້ອງການຊັບພະຍາກອນ.
ຕົວຢ່າງຄົງທີ່: NOJOB
ທີ່ກໍານົດໄວ້ Server
ບັນຊີລາຍຊື່ຂອງວັດຖຸຂອງເຄື່ອງແມ່ຂ່າຍ.
ຕົວຢ່າງຄົງທີ່: EMPTYSETSERVER
ທີ່ກໍານົດໄວ້ CNode
ບັນຊີລາຍຊື່ຂອງວັດຖຸ CNode.
ຕົວຢ່າງຄົງທີ່: EMPTYSETCNODE
ທີ່ກໍານົດໄວ້ ວ່າ ບັນຊີລາຍຊື່ຂອງວັດຖຸ Que.
ຕົວຢ່າງຄົງທີ່: EMPTYSETQUE
ທີ່ກໍານົດໄວ້ ວຽກເຮັດງານທໍາ ບັນຊີລາຍຊື່ຂອງວັດຖຸວຽກເຮັດງານທໍາ.
ຕົວຢ່າງຄົງທີ່: EMPTYSETJOB
BASL-ກໍານົດ ຄົງທີ່
ເຫຼົ່ານີ້ແມ່ນຄ່າຄົງທີ່ທີ່ບໍ່ສາມາດໃຊ້ສໍາລັບການຕັ້ງຊື່ຕົວລະບຸ (ເບິ່ງຫົວຂໍ້ຕໍ່ໄປ). ເຫຼົ່ານີ້
ຢູ່ໃນຕົວພິມໃຫຍ່ສະເໝີ.
ຂໍ້ມູນ TYPE BASL-ກໍານົດ ໝັ້ນ ຄົງ
=================== =============================================
ມື້ຂອງອາທິດ ແດດ, ຈັນ, ອັງຄານ, ພຸດ, Thu, ສຸກ, SAT
Int ຄວາມສໍາເລັດ, ລົ້ມເຫລວ, ຜິດ, ຄວາມຈິງ, SyncRUN, ASYNCRUN,
ລົບລ້າງ, RERUN, ຖື, ປ່ອຍ, ສັນຍາລັກ,
MODIFYATTR, ແກ້ໄຂ, SERVER_ACTIVE,
SERVER_IDLE, SERVER_SCHED, SERVER_TERM,
SERVER_TERMDELAY, QTYPE_E, QTYPE_R,
SCHED_DISABLED, SCHED_ENABLED, ການຂົນສົ່ງ,
ຄິວ, ຖື, ລໍຖ້າ, ແລ່ນ, ອອກໄປ,
CNODE_OFLINE, 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
Server ໂນເຊີເວີ
ທີ່ກໍານົດໄວ້ Server EMPTYSETSERVER
CNode ໂນກໂນດ
ທີ່ກໍານົດໄວ້ CNode EMPTYSETCNODE
ວ່າ NOQUE
ທີ່ກໍານົດໄວ້ ວ່າ EMPTYSETQUE
ວຽກເຮັດງານທໍາ NOJOB
ທີ່ກໍານົດໄວ້ ວຽກເຮັດງານທໍາ EMPTYSETJOB
string NULLSTR
ຕົວລະບຸຕົວຕົນ
ຕົວລະບຸ (ໃຊ້ສໍາລັບຊື່ຕົວແປ ແລະຊື່ຟັງຊັນ) ຢູ່ໃນຮູບແບບຕົວອັກສອນ ແລະຕົວເລກ, ມີ
ຕົວອັກສອນພິເສດ (_) ອະນຸຍາດໃຫ້. ໃນປັດຈຸບັນ, BASL ສາມາດຈັດການກັບຕົວລະບຸເທົ່ານັ້ນ
ທີ່ມີຄວາມຍາວເຖິງ 80 ຕົວອັກສອນ. ນອກຈາກນີ້, ທ່ານບໍ່ສາມາດໃຊ້ຊື່ຄົງທີ່ທີ່ກໍານົດ BASL ສໍາລັບ
ການຕັ້ງຊື່ຕົວລະບຸ.
ຖະແຫຼງການ
In BASL(2), ທ່ານສາມາດມີຄໍາຖະແຫຼງການດຽວທີ່ສິ້ນສຸດໂດຍເຄິ່ງຈໍ້າສອງເມັດ, ຫຼືກຸ່ມຂອງ
ຖະແຫຼງການ (ເອີ້ນວ່າຄຳຖະແຫຼງປະສົມ ຫຼື ບລ໋ອກ) ຈຳກັດໂດຍ '{' ແລະ '}'. ທີ່ແຕກຕ່າງກັນ
ປະເພດຂອງຄໍາຖະແຫຼງທີ່ສາມາດປາກົດຢູ່ໃນລະຫັດ BASL ແມ່ນ:
1. ຄໍາຖະແຫຼງການສະແດງອອກ
ຄໍາຖະແຫຼງການສະແດງອອກແມ່ນຮູບແບບໃດກໍ່ຕາມ:
ຕົວຢ່າງ ;
ບ່ອນທີ່ ຕົວຢ່າງ ສາມາດເປັນ:
a) ການສະແດງອອກທາງເລກເລກ
lexpr + rexpr (ເພີ່ມ)
lexpr - rexpr (ລົບ)
lexpr * rexpr (ຄູນ)
lexpr / rexpr (ແບ່ງ)
lexpr % rexpr (ໂມດູລ or ສ່ວນທີ່ເຫຼືອ)
ໝາຍເຫດ: ການເພີ່ມ, ການຫັກລົບ, ການຄູນ, ການຫານ, ແລະສ່ວນທີ່ເຫຼືອ
ຈະຖືກອະນຸຍາດໃຫ້ພຽງແຕ່ສໍາລັບປະເພດທີ່ເຫມາະສົມແລະຖ້າຊ້າຍແລະຂວາ
ການສະແດງອອກແມ່ນປະເພດທີ່ສອດຄ່ອງກັນ. ຕາຕະລາງຂ້າງລຸ່ມນີ້ສະແດງໃຫ້ເຫັນເຖິງສິ່ງທີ່
ປະເພດແມ່ນສອດຄ່ອງໃນບັນດາຕົວປະຕິບັດການຕ່າງໆ:
ສໍາລັບ +:
lexpr rexpr
============ ============
Int or float Int or float
ເລືອກຂະຫນາດ ເລືອກຂະຫນາດ
string string
ສໍາລັບ -, *, /:
lexpr rexpr
============ ============
Int or float Int or float
ເລືອກຂະຫນາດ ເລືອກຂະຫນາດ
ສໍາລັບ %:
lexpr rexpr
============ ============
Int or float Int or float
ນີ້ແມ່ນຕົວຢ່າງການສະແດງອອກຕົວເລກຕົວເລກ:
Int i1;
Int i2;
float f1;
float f2;
ເລືອກຂະຫນາດ sz1;
ເລືອກຂະຫນາດ sz2;
string str1;
string str2;
i1 + i2;
f1 - i2;
SZ1 * SZ2 * 2b
SZ1 / 1024b
p1 = "basl";
p2 = " ເຢັນ";
// ໄດ້ ດັ່ງຕໍ່ໄປນີ້ is a string ກົງກັນຂ້າມ
// ປະຕິບັດງານ ຜົນໄດ້ຮັບ in ໄດ້ ຊ່ອຍແນ່:
// "ບາສລ ເຢັນ"
p1 + str2;
i1 % 10
b) ການສະແດງອອກ Unary
+ expr // ໃນທາງບວກ - ຄູນ by 1 an
// ການສະແດງອອກ ທີ່ is
// of int, ເລື່ອນ, or
// ເລືອກຂະຫນາດ ປະເພດ
-ຕົວຢ່າງ // ກະທົບທາງລົບ - ຄູນ by -1 an
// ການສະແດງອອກ ທີ່ is
// of int, ເລື່ອນ, or
// ເລືອກຂະຫນາດ ປະເພດ
! expr // ບໍ່ - ປ່ຽນແປງ a ບໍ່ແມ່ນສູນ ຕົວຢ່າງ
// ມູນຄ່າ ເຂົ້າໄປໃນ 0, ແລະ a
// ສູນ ຕົວຢ່າງ ມູນຄ່າ ເຂົ້າໄປໃນ 1
// ບ່ອນທີ່ ຕົວຢ່າງ ປະເພດ ຕ້ອງ be
// of ປະເພດ Int or float
ບາງຕົວຢ່າງການສະແດງອອກ unary:
Int i;
+ 3
-(i + ປີ 4);
!i;
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 ຕ້ອງມີປະເພດທີ່ສອດຄ່ອງກັນຕາມທີ່ສະແດງ
ໃນຕາຕະລາງຕໍ່ໄປນີ້:
terminal-expr rterminal-expr
============== ==============
Int or float Int or float
ມື້ຂອງອາທິດ ມື້ຂອງອາທິດ
DateTime DateTime
string string
ເລືອກຂະຫນາດ ເລືອກຂະຫນາດ
Server Server
ວ່າ ວ່າ
ວຽກເຮັດງານທໍາ ວຽກເຮັດງານທໍາ
CNode CNode
ທີ່ກໍານົດໄວ້ Server ທີ່ກໍານົດໄວ້ Server
ທີ່ກໍານົດໄວ້ ວ່າ ທີ່ກໍານົດໄວ້ ວ່າ
ທີ່ກໍານົດໄວ້ ວຽກເຮັດງານທໍາ ທີ່ກໍານົດໄວ້ ວຽກເຮັດງານທໍາ
ທີ່ກໍານົດໄວ້ CNode ທີ່ກໍານົດໄວ້ CNode
ສໍາລັບການ ແລະ, OR ຜູ້ປະກອບການ, ໄດ້ lexpr, rexpr ປະເພດທີ່ສອດຄ່ອງແມ່ນ Int ຫຼື
ລອຍ.
ບາງຕົວຢ່າງຢ່າງມີເຫດຜົນ:
i1 EQ i2;
i1 NEQ f2;
dow1 LE dow2;
d1 LT d2;
p1 GT str2;
SZ1 GE sz2;
d) ການສະແດງອອກຫຼັງການດໍາເນີນການ
ເຫຼົ່ານີ້ແມ່ນການສະແດງອອກທີ່ເປັນພຽງແຕ່ທາງລັດໄປຫາການມອບຫມາຍ
ຖະແຫຼງການ.
IDENTIFIER++; // identifier=ຕົວລະບຸ+1
IDENTIFIER--; // identifier=ຕົວລະບຸ-1
ຕົວລະບຸຕົວຕົນ ຕ້ອງເປັນປະເພດ Int ຫຼື Float.
ຕົວຢ່າງ:
Int i;
float f;
i ++;
f--;
e) ຟັງຊັນໂທ
function-name ( arg1 ,arg2 ... , argN )
ບ່ອນທີ່ arg1, ..., argN ສາມາດຄົງທີ່ ຫຼືຕົວແປໄດ້. ທ່ານບໍ່ສາມາດມີ
ຟັງຊັນອື່ນໂທຫາເປັນການໂຕ້ຖຽງ.
ຕົວຢ່າງ:
void pr(Int a) {
ພິມ(a);
}
pr(5)
ມີຫນ້າທີ່ກໍານົດໄວ້ລ່ວງຫນ້າທີ່ແນ່ນອນທີ່ນັກຂຽນຕາຕະລາງສາມາດເຮັດໄດ້
ໂທອັດຕະໂນມັດໃນລະຫັດ BASL ຂອງລາວໂດຍບໍ່ຈໍາເປັນຕ້ອງກໍານົດມັນ.
ຫນ້າທີ່ເຫຼົ່ານີ້ຖືກເອີ້ນວ່າຫນ້າທີ່ຊ່ວຍ (ຫຼືຜູ້ຊ່ວຍ
functions) ແລະເຂົາເຈົ້າໄດ້ຖືກປຶກສາຫາລືພາຍໃຕ້ ກຳນົດໄວ້ລ່ວງໜ້າ FUNCTIONS ຫົວຂໍ້.
f) ຄົງທີ່
ບາງສຳນວນຄົງທີ່ທີ່ຖືກຕ້ອງແມ່ນໃຫ້ຢູ່ໃນຕໍ່ໄປນີ້:
5;
+ 1.2
Sun;
ມອນ;
TUE;
ພຸດ;
THU;
FRI;
SAT;
(4|4|1997);
(12:01:00);
(4|4|1997@12:01:00);
"ມະຫັດສະຈັນ";
-1b;
SYNCRUN;
ASYNCRUN;
ລົບ;
RERUN;
ຖື;
ປ່ອຍ;
ສັນຍານ;
MODIFYATTR;
MODIFYRES;
(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));
(23gb, 50gb);
NOSERVER;
NOCNODE;
NOQUE;
NOJOB;
EMPTYSETSERVER;
EMPTYSETCNODE;
EMPTYSETQUE;
EMPTYSETJOB;
NULLSTR;
ຄວາມສໍາເລັດ;
FAIL;
SERVER_ACTIVE;
SERVER_IDLE;
SERVER_SCHED;
SERVER_TERM;
SERVER_TERMDELAY;
QTYPE_E;
QTYPE_R;
SCHED_DISABLED;
SCHED_ENABLED;
ຜິດ;
ຄວາມຈິງ;
ການຂົນສົ່ງ;
ຄິວ;
HELD;
ລໍຖ້າ;
ແລ່ນ;
ອອກ;
CNODE_OFLINE;
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) ຕົວລະບຸ
ຕົວຢ່າງ:
int i;
i;
2. ຖະແຫຼງການມອບໝາຍ
ຕົວລະບຸຕົວຕົນ = ຕົວຢ່າງ ;
ຕົວລະບຸຕົວຕົນ ແລະ ຕົວຢ່າງ ຕ້ອງມີປະເພດທີ່ສອດຄ່ອງກັນ
ສະແດງຢູ່ໃນຕາຕະລາງຕໍ່ໄປນີ້:
ຕົວລະບຸ ຕົວຢ່າງ
=============== ===============
Int int, float
float int, float
ມື້ຂອງອາທິດ ມື້ຂອງອາທິດ
DateTime DateTime
string string
ເລືອກຂະຫນາດ ເລືອກຂະຫນາດ
ວ່າ ວ່າ
ວຽກເຮັດງານທໍາ ວຽກເຮັດງານທໍາ
CNode CNode
Server Server
ມື້ຂອງອາທິດ ມື້ຂອງອາທິດ
DateTime DateTime
ທີ່ກໍານົດໄວ້ Server ທີ່ກໍານົດໄວ້ Server
ທີ່ກໍານົດໄວ້ ວ່າ ທີ່ກໍານົດໄວ້ ວ່າ
ທີ່ກໍານົດໄວ້ ວຽກເຮັດງານທໍາ ທີ່ກໍານົດໄວ້ ວຽກເຮັດງານທໍາ
ທີ່ກໍານົດໄວ້ CNode ທີ່ກໍານົດໄວ້ CNode
ລະດັບ Int ລະດັບ Int
ລະດັບ float ລະດັບ float
ລະດັບ ມື້ຂອງອາທິດ ລະດັບ ມື້ຂອງອາທິດ
ລະດັບ DateTime ລະດັບ DateTime
ລະດັບ ເລືອກຂະຫນາດ ລະດັບ ເລືອກຂະຫນາດ
3. ຖ້າ ... ອື່ນ ຄໍາຖະແຫຼງທີ່
ຮູບແບບຂອງຄໍາຖະແຫຼງການ if ແມ່ນຄ້າຍຄືກັນກັບໃນ C ດ້ວຍການກໍານົດຂອບເຂດ
"{" ແລະ "}" ມີຢູ່ສະເໝີ:
ຖ້າ( ຕົວຢ່າງ ) {
ສູນ or ເພີ່ມເຕີມ (ຄວາມຈິງ) ຖະແຫຼງການ
}
ຖ້າ( ຕົວຢ່າງ ) {
ສູນ or ເພີ່ມເຕີມ (ຄວາມຈິງ) ຖະແຫຼງການ
} ອື່ນ {
ສູນ or ເພີ່ມເຕີມ (ຜິດ) ຖະແຫຼງການ
}
ໄດ້ ຕົວຢ່າງ 's ປະເພດຈະຕ້ອງເປັນ Int ຫຼື Float, ແລະຫຼັງຈາກການປະເມີນຜົນຖ້າມັນ
ຄ່າບໍ່ແມ່ນສູນ, ຫຼັງຈາກນັ້ນການຖະແຫຼງທີ່ແທ້ຈິງຈະຖືກປະຕິບັດ. ສຸດທີສອງ
ແບບຟອມ, ຖ້າ ຕົວຢ່າງ ປະເມີນເປັນສູນ, ຫຼັງຈາກນັ້ນການຖະແຫຼງທີ່ບໍ່ຖືກຕ້ອງຈະຖືກປະຕິບັດ.
ບາງຕົວຢ່າງ if ຖະແຫຼງການແມ່ນໃຫ້ຢູ່ຂ້າງລຸ່ມນີ້:
if (2 * x )
{
y = y + 3;
ພິມ(y);
}
if (2 * x ) {
y = y + 3;
} ອື່ນ {
ຖ້າ( 3 * x ) {
y = 4;
} ອື່ນ {
y = 5;
}
}
4. ສໍາລັບການ loop ຄໍາຖະແຫຼງທີ່
ຮູບແບບຂອງຄໍາຖະແຫຼງການມີດັ່ງນີ້:
ສໍາລັບ( ເລີ່ມຕົ້ນ; ທົດສອບ ການປະຕິບັດ ) {
ສູນ or ເພີ່ມເຕີມ ຖະແຫຼງການ
}
ຄືກັນກັບໃນ C, ສໍາລັບການ ທໍາອິດປະຕິບັດ ການເລີ່ມຕົ້ນ , ຫຼັງຈາກນັ້ນ, ການປະເມີນຜົນ ການທົດສອບ ສະພາບ
ເພື່ອເບິ່ງວ່າມັນຈະສົ່ງຄ່າທີ່ບໍ່ແມ່ນສູນ. ຖ້າຫາກວ່າມັນເຮັດ, ໄດ້ ສໍາລັບການ ຖະແຫຼງການແມ່ນ
ປະຕິບັດ. ຫຼັງຈາກ ສໍາລັບການ ຖະແຫຼງການໄດ້ຖືກປະຕິບັດ, ຫຼັງຈາກນັ້ນ ການປະຕິບັດ ຖືກປະເມີນຜົນ,
ແລະຫຼັງຈາກນັ້ນມັນກວດເບິ່ງ ການທົດສອບ ສະພາບການອີກເທື່ອຫນຶ່ງໃນລັກສະນະດຽວກັນກັບທີ່ຜ່ານມາ.
ການເລີ່ມຕົ້ນ ແລະ ການປະຕິບັດ ສາມາດເປັນການສະແດງອອກການມອບຫມາຍທີ່ງ່າຍດາຍຫຼືຫຼັງການປະຕິບັດການ
ການສະແດງອອກ. ການທົດສອບ ແມ່ນການສະແດງອອກຢ່າງມີເຫດຜົນ/ຄວາມສຳພັນ. ບາງຕົວຢ່າງສໍາລັບ
ຖະແຫຼງການແມ່ນໃຫ້ຢູ່ໃນຕໍ່ໄປນີ້:
ສໍາລັບການ (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 loop ຄໍາຖະແຫຼງທີ່
ຄໍາຖະແຫຼງການນີ້ຕົ້ນຕໍແມ່ນໃຊ້ສໍາລັບການສືບຕໍ່ດຶງຂໍ້ມູນແຕ່ລະອົງປະກອບຂອງ
a Set data type: Set Server, Set CNode, Set Job, Set Que. syntax ແມ່ນ:
foreach ( IDENTIFIER1 in IDENTIFIER2 ) {
ສູນ or ເພີ່ມເຕີມ ຖະແຫຼງການ
}
ບ່ອນທີ່ການຈັບຄູ່ປະເພດຕໍ່ໄປນີ້ສໍາລັບຕົວລະບຸແມ່ນອະນຸຍາດໃຫ້:
IDENTIFIER1 IDENTIFIER2
=========== ===========
Server ທີ່ກໍານົດໄວ້ Server
ວ່າ ທີ່ກໍານົດໄວ້ ວ່າ
ວຽກເຮັດງານທໍາ ທີ່ກໍານົດໄວ້ ວຽກເຮັດງານທໍາ
CNode ທີ່ກໍານົດໄວ້ CNode
ຕົວຢ່າງ:
Server s;
ວ່າ q;
ວຽກເຮັດງານທໍາ j;
CNode c;
ທີ່ກໍານົດໄວ້ Server ss;
ທີ່ກໍານົດໄວ້ ວ່າ sq;
ທີ່ກໍານົດໄວ້ ວຽກເຮັດງານທໍາ sj ;
ທີ່ກໍານົດໄວ້ CNode sc;
foreach(s in ss){
ພິມ
}
foreach(ກ in sq){
ພິມ(q);
}
foreach(j in sj){
ພິມ(j);
}
foreach(ຄ in sc){
ພິມ(c);
}
6. ໃນຂະນະທີ່ loop ຄໍາຖະແຫຼງທີ່
syntax ຂອງ while loop ແມ່ນ:
ໃນຂະນະທີ່ ( ຕົວຢ່າງ ) {
ສູນ or ເພີ່ມເຕີມ ຖະແຫຼງການ
}
ບ່ອນທີ່ ຕົວຢ່າງ ຕ້ອງເປັນປະເພດ Int ຫຼື Float. ຖ້າ ຕົວຢ່າງ ບໍ່ແມ່ນສູນ, ຈາກນັ້ນສູນ
ຫຼືຫຼາຍກວ່າ ຖະແຫຼງການ ຖືກປະຕິບັດແລະ ຕົວຢ່າງ ໄດ້ຖືກປະເມີນຄືນໃຫມ່.
ຕົວຢ່າງ:
Int i;
i = 3;
ໃນຂະນະທີ່ (i) {
ຖ້າ( i EQ 0 ) {
ພິມ("ແຕກ on i = 1");
ທໍາລາຍ;
}
i--;
}
7. ສະຫຼັບ ຄໍາຖະແຫຼງທີ່
ຄໍາຖະແຫຼງການສະຫຼັບແມ່ນການຕັດສິນໃຈຫຼາຍວິທີທີ່ຈະທົດສອບບໍ່ວ່າຈະເປັນ
ຄ່າຂອງຕົວລະບຸກົງກັບໜຶ່ງໃນຈຳນວນຂອງຄ່າ, ແລະສາຂາເປັນ a
ກຸ່ມຂອງຖະແຫຼງການຕາມຄວາມເຫມາະສົມ.
syntax ສໍາລັບຄໍາສັ່ງສະຫຼັບແມ່ນ:
ປ່ຽນ ( ຕົວລະບຸຕົວຕົນ ) {
ກໍລະນີ ຄົງທີ່-expr :
{
ສູນ or ເພີ່ມເຕີມ ຖະແຫຼງການ
}
ກໍລະນີ ຄົງທີ່-expr :
{
ສູນ or ເພີ່ມເຕີມ ຖະແຫຼງການ
}
...
ກໍລະນີ in constant-rangeOrSet-expr :
{
ສູນ or ເພີ່ມເຕີມ ຖະແຫຼງການ
}
ກໍລະນີ in IDENTIFIER-rangeOrSettype :
{
ສູນ or ເພີ່ມເຕີມ ຖະແຫຼງການ
}
Default :
{
ສູນ or ເພີ່ມເຕີມ ຖະແຫຼງການ
}
}
ບ່ອນທີ່ ຄົງທີ່-expr ເປັນ ຕົວຢ່າງ ປະເພດ Int, Float, Dayofweek, DateTime,
ຂະໜາດ, 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, ຫຼື Range Size.
ຕົວລະບຸຕົວຕົນ ບໍ່ສາມາດເປັນປະເພດ Void. ຕົວລະບຸຕົວຕົນ 's ປະເພດຕ້ອງສອດຄ່ອງ
ກັບ ຄົງທີ່-expr ຂອງ, constant-rangeOrSet-expr ຂອງ, ແລະ ຕົວລະບຸຕົວຕົນ-
rangeOrSettype 's ພິມດັ່ງທີ່ສະແດງຢູ່ໃນຕາຕະລາງຕໍ່ໄປນີ້:
ຕົວລະບຸຕົວຕົນ constant-range-expr, IDENTIFIER-rangetype
=========== =========================================
Server ທີ່ກໍານົດໄວ້ Server
ວ່າ ທີ່ກໍານົດໄວ້ ວ່າ
ວຽກເຮັດງານທໍາ ທີ່ກໍານົດໄວ້ ວຽກເຮັດງານທໍາ
CNode ທີ່ກໍານົດໄວ້ CNode
Int ລະດັບ Int
float ລະດັບ float
ມື້ຂອງອາທິດ ລະດັບ ມື້ຂອງອາທິດ
DateTime ລະດັບ DateTime
ເລືອກຂະຫນາດ ລະດັບ ເລືອກຂະຫນາດ
ຖ້າການສະແດງອອກຂອງກໍລະນີກົງກັບ ຕົວລະບຸຕົວຕົນ 's ຄ່າ, ຫຼັງຈາກນັ້ນ, ທີ່ສອດຄ້ອງກັນ
ຕັນຂອງຄໍາຖະແຫຼງທີ່ໄດ້ຖືກປະຕິບັດ. ບໍ່ເຫມືອນກັບໃນ C, ການປະຕິບັດບໍ່ໄດ້ຫຼຸດລົງ
ໂດຍຜ່ານການຖະແຫຼງການກໍລະນີຕໍ່ໄປ. ເຫດຜົນສໍາລັບການນີ້ແມ່ນວ່າ basl2c ຈະ
ແປນີ້ ສະຫຼັບ ຖະແຫຼງການໃນການກໍ່ສ້າງ if-elseif-else. ກໍລະນີ
labeled default ຈະຖືກປະຕິບັດຖ້າຫາກວ່າບໍ່ມີກໍລະນີອື່ນໆທີ່ພໍໃຈ. ໄດ້
Default ເປັນທາງເລືອກ; ຖ້າມັນບໍ່ມີ, ແລະຖ້າບໍ່ມີກໍລະນີໃດກົງກັນ, ບໍ່ແມ່ນ
ການປະຕິບັດເກີດຂຶ້ນ.
ຕົວຢ່າງ:
ມື້ຂອງອາທິດ dow;
ສະຫຼັບ(dow)
{
ກໍລະນີ ຂ້ອຍ:
{
ພິມ("ກໍລະນີ ມອນ");
}
ກໍລະນີ ອັງຄານ:
{
ພິມ("ກໍລະນີ TUE");
}
ກໍລະນີ ພຸດ:
{
ພິມ("ກໍລະນີ WED");
}
ກໍລະນີ ການລວບລວມ:
{
ພິມ("ກໍລະນີ THU");
}
ກໍລະນີ ຟຣີ:
{
ພິມ("ກໍລະນີ FRI");
}
ກໍລະນີ ບ່ອນນັ່ງ:
{
ພິມ("ກໍລະນີ SAT");
}
ກໍລະນີ ຕາເວັນ:
{
ພິມ("ກໍລະນີ Sun");
}
default:
{
ພິມ("ກໍລະນີ defaulted");
}
}
Int a;
ລະດັບ Int ri ;
ri = (10, ປີ 12);
ສະຫຼັບ(a)
{
ກໍລະນີ in (1,5):
{
ພິມ("ກໍລະນີ 1,5");
}
ກໍລະນີ in (6,9):
{
ພິມ("ກໍລະນີ 6,9");
}
ກໍລະນີ in ri:
{
ພິມ("ກໍລະນີ ri");
}
}
8. ພິມ ຄໍາຖະແຫຼງທີ່
ຖະແຫຼງການການພິມແມ່ນສາມາດພິມເພື່ອ stdout ມູນຄ່າຂອງໃດໆ ຕົວລະບຸ
or ຄົງທີ່ ປະເພດ Int, Float, Dayofweek, DateTime, String, Size, Que, Job,
CNode, Server, Range Int, Range Float, Range Dayofweek, Range DateTime,
ຂອບເຂດຂະຫນາດ.
syntax ແມ່ນດັ່ງຕໍ່ໄປນີ້:
ພິມ ( ຕົວລະບຸຕົວຕົນ );
ພິມ ( ຄົງທີ່ );
ຕົວຢ່າງ:
DateTime dt ;
CNode cn;
dt = (4|4|1997@12:13:36);
cn = AllNodesLocalHostGet();
ພິມ(dt);
ພິມ(cn);
ສໍາລັບຊຸດປະເພດ, ໃຊ້ foreach ເພື່ອຜ່ານແຕ່ລະອົງປະກອບແລະພິມໃນ:
Server s;
ທີ່ກໍານົດໄວ້ Server ss;
ss = AllServersGet();
foreach(s in ss) {
ພິມ
}
9. ສືບຕໍ່ຖະແຫຼງການ
ດໍາເນີນການຕໍ່ ;
ໄດ້ ດໍາເນີນການຕໍ່ ຖະແຫຼງການຕ້ອງໄດ້ຮັບການຮຽກຮ້ອງພາຍໃນ ສຳ ລັບ, foreach, ແລະ
ໃນຂະນະທີ່ ວົງ. ມັນເຮັດໃຫ້ການ iteration ຕໍ່ໄປຂອງ loop enclosing ເລີ່ມຕົ້ນ.
10. break statement
ພັກຜ່ອນ ;
ໄດ້ ພັກຜ່ອນ ຖະແຫຼງການຕ້ອງໄດ້ຮັບການຮຽກຮ້ອງພາຍໃນ ສຳ ລັບ, foreach, ແລະ ໃນຂະນະທີ່
ວົງ. ມັນສະຫນອງການອອກຕົ້ນຈາກ loop enclosing.
11. ຖະແຫຼງການກັບຄືນ
ກັບຄືນ(IDENTIFIER) ;
ກັບຄືນ(ຄົງທີ່) ;
ກັບຄືນ() ;
ຄໍາຖະແຫຼງການກັບຄືນສະຫນອງມູນຄ່າ (ຖ້າມີ) ທີ່ຈະສົ່ງຄືນໂດຍ a
ຫນ້າທີ່. ປະເພດທີ່ສົ່ງຄືນໂດຍ ຕົວລະບຸຕົວຕົນ ແລະ ຄົງທີ່ ຕ້ອງກົງກັບ
ປະເພດຂອງການກັບຄືນຂອງຫນ້າທີ່ເອີ້ນ. ຄົງທີ່ ປະເພດທີ່ອະນຸຍາດແມ່ນສິ່ງໃດກໍ່ຕາມຍົກເວັ້ນ
ກໍານົດແລະໄລຍະປະເພດ. ຮູບແບບສຸດທ້າຍ, ກັບຄືນ() ປົກກະຕິແລ້ວແມ່ນເອີ້ນວ່າພາຍໃນ a
ຟັງຊັນທີ່ບໍ່ສົ່ງຄືນຄ່າໃດໆ (ເຊັ່ນ: sche_main() ).
12. ອອກຖະແຫຼງການ
ອອກ(ຄົງທີ່);
ບ່ອນທີ່ ຄົງທີ່ ແມ່ນປະເພດ Int. ການໂທນີ້ຈະຢຸດການກຳນົດເວລາ.
13. ຖະແຫຼງການ
ເຫຼົ່ານີ້ແມ່ນຄໍາຖະແຫຼງທີ່ນໍາຫນ້າໂດຍ "//" ແລະພວກມັນຖືກລະເລີຍໂດຍ BASL
ນັກຂຽນ.
// ນີ້ ອອນໄລນ໌ is ບໍ່ສົນໃຈ
Int i; // string ດັ່ງຕໍ່ໄປນີ້ ໄດ້ ຖາງ is ບໍ່ສົນໃຈ
ຜູ້ ດຳ ເນີນການ PRECEDENCE ແລະ ສະມາຄົມ
ຕາຕະລາງຕໍ່ໄປນີ້ສະແດງໃຫ້ເຫັນລະດັບຄວາມສຳຄັນຂອງຕົວປະຕິບັດການຕ່າງໆ ແລະ ສະມາຄົມທີ່ກຳນົດໄວ້
ໃນພາສາ BASL. ຜູ້ປະກອບການຖືກລະບຸໄວ້ໃນລໍາດັບຂອງການຫຼຸດລົງກ່ອນຫນ້າ. ໄດ້
ສູງກວ່າຕົວປະຕິບັດການ, ມັນຈະຖືກປະຕິບັດກ່ອນໜ້ານັ້ນ. ຄໍາສັ່ງທີ່
ຜູ້ປະຕິບັດການໃນລະດັບດຽວກັນໄດ້ຖືກປະຕິບັດແມ່ນຂຶ້ນກັບການເຊື່ອມໂຍງ: ຊ້າຍຫມາຍຄວາມວ່າ
ຕົວປະຕິບັດການແມ່ນເຫັນໄດ້ຈາກຊ້າຍໄປຂວາ, ໃນຂະນະທີ່ຂວາຫມາຍຄວາມວ່າພວກເຂົາຖືກເບິ່ງຈາກຂວາຫາຊ້າຍ.
Operator ສະມາຄົມ
======================================= =============
! ++ -- + (unary ບວກ) - (unary ລົບ) ສິດ
* / % ໄວ້
+ - ໄວ້
LT LE GT GE ໄວ້
EQ NEQ ໄວ້
ແລະ ໄວ້
OR ໄວ້
= ສິດ
ກຳນົດໄວ້ລ່ວງໜ້າ FUNCTIONS
In BASL(2), ເຖິງ Server ແຜນທີ່ປະເພດຂໍ້ມູນໂດຍກົງກັບວັດຖຸເຊີບເວີ batch. ເຊັ່ນດຽວກັນ, CNode
ແມ່ນເພື່ອແມ່ / remom, ວຽກເຮັດງານທໍາ ແມ່ນເພື່ອ batch ວຽກ, ແລະ ວ່າ ແມ່ນເພື່ອ batch ແຖວ. ຢ່າງໃດກໍຕາມ, ບໍ່ແມ່ນທັງຫມົດ
ຄຸນລັກສະນະຂອງວັດຖຸ PBS ສາມາດເຂົ້າເຖິງໄດ້ຈາກ BASL. ພຽງແຕ່ຊຸດຍ່ອຍຂອງຄຸນສົມບັດ,
ສິ່ງທີ່ເບິ່ງຄືວ່າຈະເຮັດໃຫ້ຄວາມຮູ້ສຶກໃນສະພາບຂອງການກໍານົດເວລາ, ແມ່ນມີຢູ່, ແລະ
ຄຸນຄ່າຂອງຄຸນສົມບັດເຫຼົ່ານີ້ສາມາດໄດ້ຮັບການເຂົ້າເຖິງໂດຍການເອີ້ນຫນ້າທີ່ທີ່ກໍານົດໄວ້ລ່ວງຫນ້າດັ່ງຕໍ່ໄປນີ້,
ເອີ້ນກັນວ່າ ໜ້າທີ່ຊ່ວຍເຫຼືອ/ຜູ້ຊ່ວຍ.
(1) ຫນ້າທີ່ທີ່ກ່ຽວຂ້ອງກັບເຄື່ອງແມ່ຂ່າຍ
ທີ່ກໍານົດໄວ້ Server AllServersGet(void)
ສົ່ງຄືນລາຍຊື່ເຊີບເວີທີ່ລະບຸໄວ້ໃນໄຟລ໌ການຕັ້ງຄ່າສຳລັບ
ທີ່ນັກຂຽນຕາຕະລາງຕ້ອງການໃຫ້ລະບົບກວດສອບແຕ່ລະໄລຍະ
ສະຖານະ, ຄິວ ແລະຂໍ້ມູນວຽກ. ເບິ່ງ pbs__sched__basl(8 ບ) ສໍາລັບ
ການສົນທະນາກ່ຽວກັບຮູບແບບຂອງໄຟລ໌ການຕັ້ງຄ່າ.
ຂໍ້ຄວນລະວັງ: ຟັງຊັນນີ້ຕ້ອງຖືກເອີ້ນຈາກພາຍໃນ sche_main() so
ວ່າໃນທຸກໆ iteration ການກໍານົດເວລາ, ຫຼາຍທີ່ສຸດເຖິງວັນທີ ທີ່ກໍານົດໄວ້ Server
ໂຄງສ້າງຖືກສົ່ງຄືນ.
Server AllServersLocalHostGet(void)
ສົ່ງຄືນວັດຖຸເຊີບເວີທີ່ເປັນຕົວແທນຂອງໂຮດທ້ອງຖິ່ນ. ຄ່າທີ່ບໍ່ໄດ້ຕັ້ງ:
ໂນເຊີເວີ. ນີ້ແມ່ນຫນ້າທີ່ງ່າຍດາຍທີ່ຈະໂທຫາສະພາບແວດລ້ອມທີ່ບໍ່ແມ່ນກຸ່ມ
ບ່ອນທີ່ມີເຄື່ອງແມ່ຂ່າຍຂອງເຄື່ອງແມ່ຂ່າຍດຽວເທົ່ານັ້ນ.
ຂໍ້ຄວນລະວັງ: ຟັງຊັນນີ້ຕ້ອງຖືກເອີ້ນຈາກພາຍໃນ sche_main() (ຫຼືຈາກ
ພາຍໃນຫນ້າທີ່ເອີ້ນວ່າໂດຍ sched_main) ດັ່ງນັ້ນໃນທຸກໆການກໍານົດເວລາ
ຊ້ຳບໍ່ໜຳ, ເປັນທີ່ສຸດ Server ໂຄງສ້າງຖືກສົ່ງຄືນ.
string ServerInetAddrGet(ເຊີບເວີ s)
ສົ່ງຄືນຊື່ຂອງເຊີບເວີ s. ຄ່າທີ່ບໍ່ໄດ້ຕັ້ງ: NULLSTR
string ServerDefQueGet(ເຊີບເວີ s)
ສົ່ງຄ່າ default_queue attribute ຂອງເຊີບເວີ s. ຄ່າທີ່ບໍ່ໄດ້ຕັ້ງ: NULLSTR
Int ServerStateGet(ເຊີບເວີ s)
ສົ່ງຄືນຄຸນລັກສະນະ server_state ຂອງ Server s.
ຄ່າຕອບແທນ:
SERVER_ACTIVE, SERVER_IDLE, SERVER_SCHED, SERVER_TERM,
SERVER_TERMDELAY, -1 (ຄ່າບໍ່ໄດ້ຕັ້ງ)
Int ServerMaxRunJobsGet(ເຊີບເວີ s)
ສົ່ງຄ່າ max_running attribute ຂອງເຊີບເວີ s. ຄ່າທີ່ບໍ່ໄດ້ຕັ້ງ: 0
Int ServerMaxRunJobsPerUserGet(ເຊີບເວີ s)
ສົ່ງຄືນຄຸນສົມບັດ max_user_run ຂອງເຊີບເວີ s. ຄ່າທີ່ບໍ່ໄດ້ຕັ້ງ: 0
Int ServerMaxRunJobsPerGroupGet(ເຊີບເວີ s)
ສົ່ງຄືນຄຸນສົມບັດ max_group_run ຂອງເຊີບເວີ s. ຄ່າທີ່ບໍ່ໄດ້ຕັ້ງ: 0
ທີ່ກໍານົດໄວ້ ວ່າ ServerQueuesGet(ເຊີບເວີ s)
ສົ່ງຄືນລາຍຊື່ຄິວທີ່ຄຸ້ມຄອງໂດຍເຊີບເວີ s.
ທີ່ກໍານົດໄວ້ ວຽກເຮັດງານທໍາ ServerJobsGet(ເຊີບເວີ s)
ສົ່ງຄືນລາຍຊື່ວຽກທີ່ຄຸ້ມຄອງໂດຍ Server s. ສໍາລັບການໄດ້ຮັບຊຸດຍ່ອຍນີ້
ບັນຊີລາຍຊື່, ເບິ່ງ QueJobsGet().
Int ServerIntResAvailGet(ເຊີບເວີ s, string ຊື່)
ສົ່ງຄ່າໃຫ້ກັບຊັບພະຍາກອນທີ່ລະບຸໄວ້ໃນ ຊື່ ທີ່ສາມາດໃຊ້ໄດ້ກັບວຽກ
ດໍາເນີນການໂດຍເຄື່ອງແມ່ຂ່າຍນີ້ (ເຄື່ອງແມ່ຂ່າຍ resources_available.name ຄຸນລັກສະນະ). ໂທຫານີ້
ຟັງຊັນສໍາລັບຊັບພະຍາກອນທີ່ມີຄ່າທີ່ເປັນປະເພດ 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 ຂ).
ຕົວຢ່າງ:
Int cpuAvail;
// ການກັບຄືນມາ ໄດ້ # of CPU ປະຈຸບັນ ມີ in
// ໄດ້ ເຄື່ອງແມ່ຂ່າຍ
cpuAvail = ServerIntResAvailGet(ເຊີບເວີ, "ncpus");
ເລືອກຂະຫນາດ ServerSizeResAvailGet(ເຊີບເວີ s, string ຊື່)
ສົ່ງຄ່າໃຫ້ກັບຊັບພະຍາກອນທີ່ລະບຸໄວ້ໃນ ຊື່ ທີ່ສາມາດໃຊ້ໄດ້ກັບວຽກ
ດໍາເນີນການໂດຍເຄື່ອງແມ່ຂ່າຍນີ້ (ເຄື່ອງແມ່ຂ່າຍ resources_available.name ຄຸນລັກສະນະ). ໂທຫານີ້
ຟັງຊັນສໍາລັບຊັບພະຍາກອນທີ່ມີຄ່າທີ່ເປັນປະເພດຂະຫນາດ. ຊັບພະຍາກອນຕົວຢ່າງ
ຊື່ຄື: ໄຟລ໌, mem, pmem, workset, 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(ເຊີບເວີ, "ເມັມ");
string ServerStringResAvailGet(ເຊີບເວີ s, string ຊື່)
ສົ່ງຄ່າໃຫ້ກັບຊັບພະຍາກອນທີ່ລະບຸໄວ້ໃນ ຊື່ ທີ່ສາມາດໃຊ້ໄດ້ກັບວຽກ
ດໍາເນີນການໂດຍເຄື່ອງແມ່ຂ່າຍນີ້ (ເຄື່ອງແມ່ຂ່າຍ resources_available.name ຄຸນລັກສະນະ). ໂທຫານີ້
ຟັງຊັນສໍາລັບຊັບພະຍາກອນທີ່ມີຄ່າທີ່ເປັນປະເພດ String. ຕົວຢ່າງ
ຊື່ຊັບພະຍາກອນແມ່ນ: nodes, arch, neednodes. ສໍາລັບຄໍາອະທິບາຍເຫຼົ່ານີ້
ຊື່ຊັບພະຍາກອນ, ເບິ່ງ 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 ຂ).
ຕົວຢ່າງ:
string ປະເພດ;
// ການກັບຄືນມາ ໄດ້ ຖາປັດຕະຍະ (ຫຼື os ປະເພດ) of
// ໄດ້ ເຄື່ອງແມ່ຂ່າຍ
ປະເພດ = ServerStringResAvailGet(ເຊີບເວີ, "ໂຄ້ງ");
Int ServerIntResAssignGet(ເຊີບເວີ s, string ຊື່)
ສົ່ງຄ່າໃຫ້ກັບຊັບພະຍາກອນທີ່ລະບຸໄວ້ໃນ ຊື່ ທີ່ຖືກຈັດສັນໃຫ້
ແລ່ນວຽກ (ເຊີບເວີ resources_assigned.name ຄຸນລັກສະນະ). ໂທຫານີ້
ຟັງຊັນສໍາລັບຊັບພະຍາກອນທີ່ມີຄ່າທີ່ເປັນປະເພດ 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 ຂ).
ຕົວຢ່າງ:
Int cpuAssn;
// ການກັບຄືນມາ ໄດ້ # of CPU ປະຈຸບັນ ມອບ ໝາຍ in
// ໄດ້ ເຄື່ອງແມ່ຂ່າຍ
cpuAssn = ServerIntResAssignGet(ເຊີບເວີ, "ncpus");
ເລືອກຂະຫນາດ ServerSizeResAssignGet(ເຊີບເວີ s, string ຊື່)
ສົ່ງຄ່າໃຫ້ກັບຊັບພະຍາກອນທີ່ລະບຸໄວ້ໃນ ຊື່ ທີ່ຖືກຈັດສັນໃຫ້
ແລ່ນວຽກ (ເຊີບເວີ resources_assigned.name ຄຸນລັກສະນະ). ໂທຫານີ້
ຟັງຊັນສໍາລັບຊັບພະຍາກອນທີ່ມີຄ່າທີ່ເປັນປະເພດຂະຫນາດ. ຊັບພະຍາກອນຕົວຢ່າງ
ຊື່ຄື: ໄຟລ໌, mem, pmem, workset, 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");
string ServerStringResAssignGet(ເຊີບເວີ s, string ຊື່)
ສົ່ງຄ່າໃຫ້ກັບຊັບພະຍາກອນທີ່ລະບຸໄວ້ໃນ ຊື່ ທີ່ຖືກຈັດສັນໃຫ້
ແລ່ນວຽກ (ເຊີບເວີ resources_assigned.name ຄຸນລັກສະນະ). ໂທຫານີ້
ຟັງຊັນສໍາລັບຊັບພະຍາກອນທີ່ມີຄ່າທີ່ເປັນປະເພດ String. ຕົວຢ່າງ
ຊື່ຊັບພະຍາກອນແມ່ນ: nodes, arch, neednodes. ສໍາລັບຄໍາອະທິບາຍເຫຼົ່ານີ້
ຊື່ຊັບພະຍາກອນ, ເບິ່ງ 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)
ສົ່ງຄືນຊຸດຂອງ nodes ທີ່ຄຸ້ມຄອງໂດຍເຊີບເວີ s. ຄ່າທີ່ບໍ່ໄດ້ຕັ້ງ: EMPTYSETCNODE.
ຫມາຍເຫດ: ໂດຍປົກກະຕິທ່ານສາມາດໂທຫາຫນ້າທີ່ດັ່ງຕໍ່ໄປນີ້ສໍາລັບຂໍ້ສົ່ງກັບຄືນ
ໂດຍການໂທນີ້: CNodeStateGet(), CNodePropertiesGet(), ແລະ CNodeTypeGet().
Int ServerNodesQuery(ເຊີບເວີ s, string spec)
ອອກຄໍາຮ້ອງສະຫມັກກັບເຄື່ອງແມ່ຂ່າຍທີ່ກໍານົດໄວ້ເພື່ອສອບຖາມການມີຂອງ
ຊັບພະຍາກອນທີ່ລະບຸໄວ້ໃນ ສະເປັກ. ໃນປັດຈຸບັນ, ຊັບພະຍາກອນພຽງແຕ່
ຂໍ້ກໍານົດທີ່ອະນຸຍາດແມ່ນຫນຶ່ງທີ່ກ່ຽວຂ້ອງກັບ "nodes" ແລະມັນສາມາດເປັນຂອງ
format "nodes", "nodes=", ຫຼື "nodes= ". ຜົນການຄົ້ນຫາສາມາດເປັນ
ເຂົ້າເຖິງໂດຍການເອີ້ນຟັງຊັນຕໍ່ໄປນີ້: ServerNodesNumAvailGet(),
ServerNodesNumAllocGet(), ServerNodesNumRsvdGet(),
ServerNodesNumDownGet().
ຫມາຍເຫດ: ນີ້ແມ່ນ wrapper ກັບ pbs_rescquery(3B) ການທໍາງານຂອງເຄື່ອງແມ່ຂ່າຍ.
ຄ່າຕອບແທນ:
ຄວາມສຳເລັດ, ລົ້ມເຫລວ
Int ServerNodesNumAvailGet(ເຊີບເວີ s)
ສົ່ງຄືນຈຳນວນຂອງ nodes ທີ່ມີໃຫ້ກັບຜູ້ບໍລິຫານໂດຍທີ່ລະບຸໄວ້
ເຊີບເວີ, ຫຼືສະທ້ອນໃຫ້ເຫັນໂດຍການສອບຖາມຫຼ້າສຸດທີ່ລະບຸໄວ້ໂດຍ
ServerNodesQuery(). ຖ້າຄ່າກັບຄືນແມ່ນສູນ, ນີ້ຫມາຍຄວາມວ່າ
ຈໍານວນຂອງຂໍ້ຄວາມຈໍາເປັນໃນປັດຈຸບັນເພື່ອຕອບສະຫນອງສະເພາະຂອງ
ServerNodesQuery() ບໍ່ສາມາດໃຊ້ໄດ້ໃນຂະນະນີ້. ການຮ້ອງຂໍອາດຈະພໍໃຈ
ໃນເວລາຕໍ່ມາ. ຖ້າຜົນໄດ້ຮັບແມ່ນທາງລົບ, ບໍ່ມີການປະສົມປະສານທີ່ຮູ້ຈັກ
nodes ສາມາດຕອບສະຫນອງສະເພາະ.
Int ServerNodesNumAllocGet(ເຊີບເວີ s)
ສົ່ງຄືນຈຳນວນຂອງ nodes ທີ່ຖືກຈັດສັນໃຫ້ກັບຜູ້ທີ່ຄຸ້ມຄອງໂດຍທີ່ລະບຸໄວ້
ເຊີບເວີ, ຫຼືສະທ້ອນໃຫ້ເຫັນໂດຍການສອບຖາມຫຼ້າສຸດທີ່ລະບຸໄວ້ໂດຍ
ServerNodesQuery().
Int ServerNodesNumRsvdGet(ເຊີບເວີ s)
ສົ່ງຄືນຈຳນວນຂອງໂນດທີ່ສະຫງວນໄວ້ໃຫ້ກັບຜູ້ທີ່ຄຸ້ມຄອງໂດຍທີ່ລະບຸໄວ້
ເຊີບເວີ, ຫຼືສະທ້ອນໃຫ້ເຫັນໂດຍການສອບຖາມຫຼ້າສຸດທີ່ລະບຸໄວ້ໂດຍ
ServerNodesQuery().
Int ServerNodesNumDownGet(ເຊີບເວີ s)
ສົ່ງຄືນຈຳນວນຂອງ nodes ລົງສຳລັບທີ່ຈັດການໂດຍທີ່ລະບຸໄວ້
ເຊີບເວີ, ຫຼືສະທ້ອນໃຫ້ເຫັນໂດຍການສອບຖາມຫຼ້າສຸດທີ່ລະບຸໄວ້ໂດຍ
ServerNodesQuery().
Int ServerNodesReserve(ເຊີບເວີ s, ສາຍ spec, int resId)
ອອກຄໍາຮ້ອງຂໍໃຫ້ເຄື່ອງແມ່ຂ່າຍທີ່ລະບຸໄວ້ເພື່ອສະຫງວນຊັບພະຍາກອນ
ລະບຸໄວ້ໃນ ສະເປັກ. ຄ່າຂອງ 0 ສໍາລັບ resId ຫມາຍຄວາມວ່ານີ້ແມ່ນສໍາລັບການເຮັດ
ການຈອງໃຫມ່. ຖ້າບໍ່ດັ່ງນັ້ນ, ຕົວເລກຈະເປັນຕົວແທນທີ່ມີຢູ່ແລ້ວ
(ບາງສ່ວນ) ການຈອງ. ຊັບພະຍາກອນທີ່ສະຫງວນໄວ້ໃນປັດຈຸບັນສໍາລັບການນີ້ resId ຈະ
ຖືກປ່ອຍອອກມາແລະການຈອງເຕັມຈະຖືກພະຍາຍາມອີກເທື່ອຫນຶ່ງ. ຢູ່ທີ່
ປະຈຸບັນ, ຊັບພະຍາກອນອັນດຽວທີ່ອາດຈະຖືກກໍານົດແມ່ນ
"ຂໍ້". ມັນຄວນຈະຖືກກໍານົດເປັນ nodes=ສະເພາະ ບ່ອນທີ່
specification ແມ່ນສິ່ງທີ່ຜູ້ໃຊ້ລະບຸໄວ້ໃນລາຍການ argument ທາງເລືອກ -l
ສໍາລັບ nodes, ເບິ່ງ qsub (1B).
ຫມາຍເຫດ: ນີ້ແມ່ນ wrapper ກັບ pbs_rescreserve(3B) ການທໍາງານຂອງເຄື່ອງແມ່ຂ່າຍ.
ຄ່າຕອບແທນ:
ຕົວເລກອ້າງອີງເຖິງຜູ້ປະສົບຜົນສໍາເລັດ ຫຼືບາງສ່ວນ
ການຈອງ, ຫຼື FAIL
Int ServerNodesRelease(ເຊີບເວີ s, Int resId)
ນີ້ປ່ອຍ ຫຼືປົດປ່ອຍຊັບພະຍາກອນທີ່ສະຫງວນໄວ້ດ້ວຍໝາຍເລກອ້າງອີງ
ລະບຸໄວ້ໃນ resId.
ຫມາຍເຫດ: ນີ້ແມ່ນ wrapper ກັບ pbs_rescrelease(3B) ການທໍາງານຂອງເຄື່ອງແມ່ຂ່າຍ.
ຄ່າຕອບແທນ:
ຄວາມສຳເລັດ ຫຼື ລົ້ມເຫລວ
(2) ຫນ້າທີ່ກ່ຽວຂ້ອງກັບ Que:
string QueNameGet( ວ່າ que )
ຕອບຊື່ຂອງ Que que. ຄ່າທີ່ບໍ່ໄດ້ຕັ້ງ: NULLSTR
Int QueTypeGet( ວ່າ que )
ສົ່ງຄືນຄຸນສົມບັດ queue_type ຂອງ Que que.
ຄ່າກັບຄືນ: QTYPE_E (Execution), QTYPE_R (Routing), -1 (ບໍ່ໄດ້ຕັ້ງ
ມູນຄ່າ)
Int QueNumJobsGet( ວ່າ que )
ສົ່ງຄືນຈໍານວນວຽກທີ່ອາໄສຢູ່ໃນ Que que. ຄ່າທີ່ບໍ່ໄດ້ຕັ້ງ: 0
Int QueMaxRunJobsGet( ວ່າ que )
ສົ່ງຄືນຄຸນສົມບັດ max_running ຂອງ Que que. ຄ່າທີ່ບໍ່ໄດ້ຕັ້ງ: 0
Int QueMaxRunJobsPerUserGet( ວ່າ que )
ສົ່ງຄືນຄຸນສົມບັດ max_user_run ຂອງ Que que. ຄ່າທີ່ບໍ່ໄດ້ຕັ້ງ: 0
Int QueMaxRunJobsPerGroupGet( ວ່າ que )
ຕອບຄຸນລັກສະນະ max_group_run ຂອງ Que que. ຄ່າທີ່ບໍ່ໄດ້ຕັ້ງ: 0
Int QuePriorityGet( ວ່າ que )
ສົ່ງຄືນຄຸນສົມບັດບູລິມະສິດຂອງ Que que. ຄ່າທີ່ບໍ່ໄດ້ຕັ້ງ: 0
Int QueStateGet( ວ່າ que )
Returns start attribute of Que que - the job execution selection
ສະຖານະຂອງ que: SCHED_DISABLED, SCHED_ENABLED. ຄ່າທີ່ບໍ່ໄດ້ຕັ້ງ:
SCHED_DISABLED
ທີ່ກໍານົດໄວ້ ວຽກເຮັດງານທໍາ QueJobsGet( ວ່າ que )
ສົ່ງຄືນລາຍຊື່ວຽກທີ່ອາໄສຢູ່ໃນ que.
Int QueIntResAvailGet(Que q, string ຊື່)
ສົ່ງຄ່າໃຫ້ກັບຊັບພະຍາກອນທີ່ລະບຸໄວ້ໃນ ຊື່ ທີ່ມີໃຫ້
ວຽກທີ່ເຮັດວຽກຈາກ q ນີ້ (Que resources_available.name ຄຸນລັກສະນະ).
ເອີ້ນຟັງຊັນນີ້ສໍາລັບຊັບພະຍາກອນທີ່ມີຄ່າທີ່ເປັນປະເພດ 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(Que q, string ຊື່)
ສົ່ງຄ່າໃຫ້ກັບຊັບພະຍາກອນທີ່ລະບຸໄວ້ໃນ ຊື່ ທີ່ມີໃຫ້
ວຽກທີ່ເຮັດວຽກຈາກ q ນີ້ (Que resources_available.name ຄຸນລັກສະນະ).
ເອີ້ນຟັງຊັນນີ້ສຳລັບຊັບພະຍາກອນທີ່ມີຄ່າທີ່ເປັນປະເພດຂະໜາດ.
ຊື່ຊັບພະຍາກອນຕົວຢ່າງ: ໄຟລ໌, mem, pmem, workset, 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 ຂ).
string QueStringResAvailGet(Que q, string ຊື່)
ສົ່ງຄ່າໃຫ້ກັບຊັບພະຍາກອນທີ່ລະບຸໄວ້ໃນ ຊື່ ທີ່ມີໃຫ້
ວຽກທີ່ເຮັດວຽກຈາກ q ນີ້ (Que resources_available.name ຄຸນລັກສະນະ).
ເອີ້ນຟັງຊັນນີ້ສໍາລັບຊັບພະຍາກອນທີ່ມີຄ່າທີ່ເປັນປະເພດ String.
ຊື່ຊັບພະຍາກອນຕົວຢ່າງ: nodes, arch, neednodes. ສໍາລັບຄໍາອະທິບາຍ
ຂອງຊື່ຊັບພະຍາກອນເຫຼົ່ານີ້, ເບິ່ງ 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, string ຊື່)
ສົ່ງຄ່າໃຫ້ກັບຊັບພະຍາກອນທີ່ລະບຸໄວ້ໃນ ຊື່ ທີ່ຖືກຈັດສັນໃຫ້
ວຽກທີ່ແລ່ນຈາກແຖວນີ້ (Que resources_assigned.name ຄຸນລັກສະນະ).
ເອີ້ນຟັງຊັນນີ້ສໍາລັບຊັບພະຍາກອນທີ່ມີຄ່າທີ່ເປັນປະເພດ 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(Que q, string ຊື່)
ສົ່ງຄ່າໃຫ້ກັບຊັບພະຍາກອນທີ່ລະບຸໄວ້ໃນ ຊື່ ທີ່ຖືກຈັດສັນໃຫ້
ວຽກທີ່ເຮັດວຽກຈາກ q ນີ້ (Que resources_assigned.name ຄຸນລັກສະນະ).
ເອີ້ນຟັງຊັນນີ້ສຳລັບຊັບພະຍາກອນທີ່ມີຄ່າທີ່ເປັນປະເພດຂະໜາດ.
ຊື່ຊັບພະຍາກອນຕົວຢ່າງ: ໄຟລ໌, mem, pmem, workset, 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 ຂ).
string QueStringResAssignGet(Que q, string ຊື່)
ສົ່ງຄ່າໃຫ້ກັບຊັບພະຍາກອນທີ່ລະບຸໄວ້ໃນ ຊື່ ທີ່ຖືກຈັດສັນໃຫ້
ວຽກທີ່ເຮັດວຽກຈາກ q ນີ້ (Que resources_assigned.name ຄຸນລັກສະນະ).
ເອີ້ນຟັງຊັນນີ້ສໍາລັບຊັບພະຍາກອນທີ່ມີຄ່າທີ່ເປັນປະເພດ String.
ຊື່ຊັບພະຍາກອນຕົວຢ່າງ: nodes, arch, neednodes. ສໍາລັບຄໍາອະທິບາຍ
ຂອງຊື່ຊັບພະຍາກອນເຫຼົ່ານີ້, ເບິ່ງ 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) ໜ້າທີ່ທີ່ກ່ຽວຂ້ອງກັບວຽກງານ
string JobIdGet( ວຽກເຮັດງານທໍາ ວຽກເຮັດງານທໍາ )
ສົ່ງຄືນຕົວລະບຸວຽກຂອງວຽກວຽກ. ຄ່າທີ່ບໍ່ໄດ້ຕັ້ງ: NULLSTR
string JobNameGet( ວຽກເຮັດງານທໍາ ວຽກເຮັດງານທໍາ )
ສົ່ງຄືນຄຸນລັກສະນະ Job_Name ຂອງວຽກວຽກ. ຄ່າທີ່ບໍ່ໄດ້ຕັ້ງ: NULLSTR
string JobOwnerNameGet( ວຽກເຮັດງານທໍາ ວຽກເຮັດງານທໍາ )
ສົ່ງຄືນຄຸນລັກສະນະ Job_Owner ຂອງວຽກວຽກ. ຄ່າທີ່ບໍ່ໄດ້ຕັ້ງ: NULLSTR
string JobEffectiveUserNameGet( ວຽກເຮັດງານທໍາ ວຽກ)
ສົ່ງຄືນຄຸນລັກສະນະ euser ຂອງວຽກ Job.
string JobEffectiveGroupNameGet(ວຽກ ວຽກ)
ສົ່ງຄືນຄຸນລັກສະນະກຸ່ມຂອງວຽກວຽກ. ຄ່າທີ່ບໍ່ໄດ້ຕັ້ງ: NULLSTR
Int JobStateGet ( ວຽກເຮັດງານທໍາ ວຽກເຮັດງານທໍາ )
ສົ່ງຄືນຄຸນລັກສະນະ job_state ຂອງວຽກວຽກ.
ຄ່າຕອບແທນ:
ການຂົນສົ່ງ, ຄິວ, ຖື, ລໍຖ້າ, ແລ່ນ, ອອກ, -1 (ບໍ່ໄດ້ຕັ້ງ
ມູນຄ່າ)
Int JobPriorityGet( ວຽກເຮັດງານທໍາ ວຽກເຮັດງານທໍາ )
ສົ່ງຄືນຄຸນສົມບັດບູລິມະສິດຂອງວຽກວຽກ. ຄ່າທີ່ບໍ່ໄດ້ຕັ້ງ: 0
Int JobRerunFlagGet( ວຽກເຮັດງານທໍາ ວຽກເຮັດງານທໍາ )
ສົ່ງຄືນຄຸນລັກສະນະ Rerunable ຂອງວຽກວຽກ.
ຄ່າກັບຄືນ: FALSE, TRUE, -1 (ຄ່າທີ່ບໍ່ໄດ້ຕັ້ງ)
Int JobInteractiveFlagGet( ວຽກເຮັດງານທໍາ ວຽກເຮັດງານທໍາ )
ສົ່ງຄືນຄຸນສົມບັດແບບໂຕ້ຕອບຂອງວຽກວຽກ.
ຄ່າກັບຄືນ: FALSE, TRUE. ຄ່າທີ່ບໍ່ໄດ້ຕັ້ງ: FALSE
DateTime JobDateTimeCreatedGet(ວຽກ ວຽກ)
ຕອບຄຸນລັກສະນະ ctime ຂອງວຽກ Job. ຄ່າທີ່ບໍ່ໄດ້ຕັ້ງ:
(0|0|0@-1:-1:-1)
string JobEmailAddrGet( ວຽກເຮັດງານທໍາ ວຽກເຮັດງານທໍາ )
ສົ່ງຄືນຄຸນສົມບັດ Mail_Users ຂອງວຽກ Job. ຄ່າທີ່ບໍ່ໄດ້ຕັ້ງ: NULLSTR
string JobStageinFilesGet( ວຽກເຮັດງານທໍາ ວຽກເຮັດງານທໍາ )
ສົ່ງຄືນຄຸນສົມບັດ stagein ຂອງວຽກ Job. ຄ່າທີ່ບໍ່ໄດ້ຕັ້ງ: NULLSTR
string JobStageoutFilesGet( ວຽກເຮັດງານທໍາ ວຽກເຮັດງານທໍາ )
ສົ່ງຄືນຄຸນສົມບັດ stageout ຂອງວຽກວຽກ. ຄ່າທີ່ບໍ່ໄດ້ຕັ້ງ: NULLSTR
Int JobIntResReqGet(ວຽກ ວຽກ, string ຊື່)
ສົ່ງຄ່າໃຫ້ກັບຊັບພະຍາກອນທີ່ລະບຸໄວ້ໃນ ຊື່ ຕາມທີ່ຕ້ອງການໂດຍ
ວຽກ (ວຽກ Resource_List.name ຄຸນລັກສະນະ). ໂທຫາຫນ້າທີ່ນີ້ສໍາລັບ
ຊັບພະຍາກອນທີ່ມີຄ່າທີ່ເປັນປະເພດ 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 ຂ).
ຕົວຢ່າງ:
Int cputReq;
// ກັບຄືນມາ ໄດ້ ຂໍ້ມູນ ຄວາມຕ້ອງການ of ໄດ້ ວຽກເຮັດງານທໍາ
cputReq = JobIntResReqGet(ວຽກ, "cput");
ເລືອກຂະຫນາດ JobSizeResReqGet(ວຽກ ວຽກ, string ຊື່)
ສົ່ງຄ່າໃຫ້ກັບຊັບພະຍາກອນທີ່ລະບຸໄວ້ໃນ ຊື່ ຕາມທີ່ຕ້ອງການໂດຍ
ວຽກ (ວຽກ Resource_List.name ຄຸນລັກສະນະ). ໂທຫາຫນ້າທີ່ນີ້ສໍາລັບ
ຊັບພະຍາກອນທີ່ມີຄ່າທີ່ເປັນປະເພດຂະຫນາດ. ຕົວຢ່າງຊື່ຊັບພະຍາກອນ
ແມ່ນ: file, mem, pmem, workset, 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(ວຽກ, "ເມັມ");
string JobStringResReqGet(ວຽກ ວຽກ, string ຊື່)
ສົ່ງຄ່າໃຫ້ກັບຊັບພະຍາກອນທີ່ລະບຸໄວ້ໃນ ຊື່ ຕາມທີ່ຕ້ອງການໂດຍ
ວຽກ (ວຽກ Resource_List.name ຄຸນລັກສະນະ). ໂທຫາຫນ້າທີ່ນີ້ສໍາລັບ
ຊັບພະຍາກອນທີ່ມີຄ່າທີ່ເປັນປະເພດ String. ຕົວຢ່າງຊື່ຊັບພະຍາກອນ
ແມ່ນ: nodes, arch, neednodes. ສໍາລັບລາຍລະອຽດຂອງຊັບພະຍາກອນເຫຼົ່ານີ້
ຊື່, ເບິ່ງ 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 ຂ).
ຕົວຢ່າງ:
string nodes;
// ກັບຄືນມາ ໄດ້ nodes ຄວາມຕ້ອງການ ຄຸນສົມບັດ of
// ໄດ້ ວຽກເຮັດງານທໍາ
nodes = JobStringResReqGet(ວຽກ, "ຂໍ້");
Int JobIntResUseGet(ວຽກ ວຽກ, string ຊື່)
ສົ່ງຄ່າໃຫ້ກັບຊັບພະຍາກອນທີ່ລະບຸໄວ້ໃນ ຊື່ ໃຊ້ໃນວຽກ (ໂຢບ
resources_used.name ຄຸນລັກສະນະ). ໂທຫາຫນ້າທີ່ນີ້ສໍາລັບຊັບພະຍາກອນທີ່ມີ
ຄ່າທີ່ເປັນປະເພດ 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 ຂ).
ຕົວຢ່າງ:
Int walltUse;
// ກັບຄືນມາ ໄດ້ ຈໍານວນເງິນ of ຝາ ໃຫມ່ by
// ໄດ້ ວຽກເຮັດງານທໍາ
wallt ໃຊ້ = JobIntResUseGet(ວຽກ, "walltime");
ເລືອກຂະຫນາດ JobSizeResUseGet(ວຽກ ວຽກ, string ຊື່)
ສົ່ງຄ່າໃຫ້ກັບຊັບພະຍາກອນທີ່ລະບຸໄວ້ໃນ ຊື່ ໃຊ້ໃນວຽກ (ໂຢບ
resources_used.name ຄຸນລັກສະນະ). ໂທຫາຫນ້າທີ່ນີ້ສໍາລັບຊັບພະຍາກອນທີ່ມີ
ຄ່າທີ່ເປັນປະເພດຂະໜາດ. ຊື່ຊັບພະຍາກອນຕົວຢ່າງ: ໄຟລ໌, mem,
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;
// ກັບຄືນມາ ໄດ້ ຈໍານວນເງິນ of srfs_fast ໃຫມ່ by
// ໄດ້ ວຽກເຮັດງານທໍາ
srfs ໃຊ້ = JobSizeResUseGet(ວຽກ, "srfs_fast");
string JobStringResUseGet(ວຽກ ວຽກ, string ຊື່)
ສົ່ງຄ່າໃຫ້ກັບຊັບພະຍາກອນທີ່ລະບຸໄວ້ໃນ ຊື່ ໃຊ້ໃນວຽກ (ໂຢບ
resources_used.name ຄຸນລັກສະນະ). ໂທຫາຫນ້າທີ່ນີ້ສໍາລັບຊັບພະຍາກອນທີ່ມີ
ຄ່າທີ່ເປັນປະເພດ String. ຊື່ຊັບພະຍາກອນຕົວຢ່າງ: nodes,
arch, neednodes. ສໍາລັບລາຍລະອຽດຂອງຊື່ຊັບພະຍາກອນເຫຼົ່ານີ້, ເບິ່ງ
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)
ສົ່ງຄືນລາຍຊື່ຂອງ nodes ທີ່ຖືກຈັດການໂດຍເຊີບເວີທີ່ເຮັດວຽກຢູ່ໃນ
ເຈົ້າພາບທ້ອງຖິ່ນ. ອັນນີ້ຍັງສາມາດລວມເຖິງຂໍ້ທີ່ລະບຸໄວ້
ໃນໄຟລ໌ການຕັ້ງຄ່າຕົວກໍານົດເວລາທີ່ຜູ້ຂຽນກໍານົດເວລາ
ຕ້ອງການໃຫ້ລະບົບກວດສອບຂໍ້ມູນເປັນໄລຍະໆເຊັ່ນ: ລັດ,
ຊັບສິນ, ແລະອື່ນໆ. ເບິ່ງ pbs_sched_basl(8 ບ) ສໍາລັບການສົນທະນາຂອງ
ຮູບແບບໄຟລ໌ການຕັ້ງຄ່າ.
ຂໍ້ຄວນລະວັງ: ຟັງຊັນນີ້ຕ້ອງຖືກເອີ້ນຈາກພາຍໃນ sche_main() so
ວ່າໃນທຸກໆ iteration ການກໍານົດເວລາ, ຫຼາຍທີ່ສຸດເຖິງວັນທີ ທີ່ກໍານົດໄວ້ CNode
ໂຄງສ້າງຖືກສົ່ງຄືນ. ຢ່າໂທຫານີ້ຈາກຄໍາຖະແຫຼງການມອບຫມາຍ
ມີຈຸດປະສົງເພື່ອເລີ່ມຕົ້ນຕົວປ່ຽນແປງທົ່ວໂລກ, ເປັນຄໍາຖະແຫຼງການພຽງແຕ່
ຖືກເອີ້ນຄັ້ງດຽວ.
CNode AllNodesLocalHostGet(void)
ສົ່ງຄືນວັດຖຸ CNode ທີ່ເປັນຕົວແທນຂອງໂຮດທ້ອງຖິ່ນ. ນີ້ແມ່ນ
ຟັງຊັນງ່າຍໆເພື່ອໂທຫາລະບົບທີ່ບໍ່ແມ່ນກຸ່ມທີ່ມີພຽງແຕ່ 1 CNode
ມີຢູ່. ຄ່າທີ່ບໍ່ໄດ້ຕັ້ງ: NOCNODE
ຂໍ້ຄວນລະວັງ: ຟັງຊັນນີ້ຕ້ອງຖືກເອີ້ນຈາກພາຍໃນ sche_main() (ຫຼື
ຈາກພາຍໃນຫນ້າທີ່ເອີ້ນວ່າໂດຍ sched_main) ດັ່ງນັ້ນທຸກໆ
ການຈັດຕາຕະລາງ iteration, ຫຼາຍທີ່ສຸດເຖິງວັນທີ CNode ໂຄງສ້າງແມ່ນ
ກັບຄືນ. ຢ່າໂທຫານີ້ຈາກຄໍາຖະແຫຼງການມອບຫມາຍທີ່ມີຈຸດປະສົງ
ເລີ່ມຕົ້ນຕົວແປທົ່ວໂລກ, ຍ້ອນວ່າຄໍາຖະແຫຼງທີ່ຈະຖືກເອີ້ນເທົ່ານັ້ນ
ຄັ້ງຫນຶ່ງ.
string CNodeNameGet(CNode node)
ສົ່ງຄືນຊື່ທີ່ບໍ່ຊໍ້າກັນ (ຢ່າງເປັນທາງການ) ຂອງ node (ເຊັ່ນ ResMom hostname
ໃນ 1 ຕົວແບບແມ່ / node). ອັນນີ້ສົ່ງຄືນສະຕຣິງດຽວກັນກັບທີ່ເຄີຍເປັນ
ລະບຸໄວ້ໃນໄຟລ໌ການຕັ້ງຄ່າ. ຄ່າທີ່ບໍ່ໄດ້ຕັ້ງ: NULLSTR
string CNodeOsGet(CNode node)
ຕອບສະຖາປັດຕະຍະກໍາ os ຂອງ node (ie "irix5", "sp2"). ບໍ່ໄດ້ຕັ້ງ
ຄ່າ: NULLSTR
Int CNodeStateGet( CNode node )
ສົ່ງຄືນສະຖານະຂອງໂນດ.
ຄ່າຕອບແທນ:
CNODE_OFFLINE, CNODE_DOWN, CNODE_FREE, CNODE_RESERVE,
CNODE_INUSE_EXCLUSIVE, CNODE_INUSE_SHARED, CNODE_UNKNOWN
Int CNodeTypeGet( CNode node )
ຕອບປະເພດຂອງ node.
ຄ່າຕອບແທນ:
CNODE_TIMESHARED, CNODE_CLUSTER, CNODE_UNKNOWN
string CNodePropertiesGet(CNode node)
ສົ່ງຄືນລາຍຊື່ທີ່ຂັ້ນດ້ວຍເຄື່ອງໝາຍຈຸດຂອງຊື່ອື່ນທີ່ node ຮູ້ຈັກໂດຍ
(ຄຸນສົມບັດ, ຊື່ເຄືອຂ່າຍອື່ນ). ຍົກຕົວຢ່າງ,
"babbage.OpenPBS.org" ບາງທີຊື່ຂອງ node, ແຕ່ມັນຍັງສາມາດເປັນທີ່ຮູ້ຈັກ
ຜ່ານ "babbage1, babbage2". ຄ່າທີ່ບໍ່ໄດ້ຕັ້ງ: NULLSTR
string CNodeVendorGet(CNode node)
ສົ່ງຄືນຊື່ຂອງຜູ້ຂາຍສຳລັບຮາດແວຂອງເຄື່ອງຈັກ (ເຊັ່ນ
"sgi", "ibm"). ຄ່າທີ່ບໍ່ໄດ້ຕັ້ງ: NULLSTR
Int CNodeNumCpusGet(CNode node)
ສົ່ງຄືນຈຳນວນຂອງໂປເຊດເຊີທີ່ຕິດກັບ node. ຄ່າທີ່ບໍ່ໄດ້ຕັ້ງ:
-1
ເລືອກຂະຫນາດ CNodeMemTotalGet( CNode node, string ປະເພດ )
ສົ່ງຄືນຄວາມຊົງຈຳທັງໝົດຂອງ ປະເພດ ສໍາລັບ node. ປະເພດ ແມ່ນ arbitrary
string ທີ່ນັກຂຽນກຳນົດເວລາກຳນົດໄວ້ໃນຕົວກຳນົດເວລາ
ໄຟລ໌ການຕັ້ງຄ່າ. ຄ່າທີ່ບໍ່ໄດ້ຕັ້ງ: -1b
ຕົວຢ່າງ:
// ໄດ້ຮັບ ຈໍານວນທັງຫມົດ ທາງດ້ານຮ່າງກາຍ ຫນ່ວຍຄວາມຈໍາ
CNodeMemTotalGet(node, "ຈິງ")
// ໄດ້ຮັບ ຈໍານວນທັງຫມົດ virtual ຫນ່ວຍຄວາມຈໍາ
CNodeMemTotalGet(node, "virtual")
ເລືອກຂະຫນາດ CNodeMemAvailGet( CNode node, string ປະເພດ )
ສົ່ງຄືນຄວາມຊົງຈຳທີ່ມີໃຫ້ ປະເພດ ສໍາລັບ node. ປະເພດ ແມ່ນ arbitrary
string ທີ່ນັກຂຽນກຳນົດເວລາກຳນົດໄວ້ໃນຕົວກຳນົດເວລາ
ໄຟລ໌ການຕັ້ງຄ່າ. ຄ່າທີ່ບໍ່ໄດ້ຕັ້ງ: -1b
ດັ່ງນັ້ນການໂທຕົວຢ່າງຈະເປັນ:
// ໄດ້ຮັບ ມີ ທາງດ້ານຮ່າງກາຍ ຫນ່ວຍຄວາມຈໍາ
CNodeMemAvailGet(node, "ຈິງ")
// ໄດ້ຮັບ ມີ virtual ຫນ່ວຍຄວາມຈໍາ
CNodeMemAvailGet(node, "virtual")
Int CNodeIdletimeGet( CNode node )
ຕອບຈໍານວນວິນາທີທີ່ບໍ່ມີການກົດແປ້ນພິມ ຫຼືການເຄື່ອນໄຫວຂອງເມົາສ໌
ເກີດຂຶ້ນຢູ່ໃນ terminal ໃດທີ່ເຊື່ອມຕໍ່ກັບ node ໄດ້. ຄ່າທີ່ບໍ່ໄດ້ຕັ້ງ: -1
float CNodeLoadAveGet( CNode node )
ຕອບຄ່າສະເລ່ຍການໂຫຼດຂອງໂນດສຳລັບ CPU ທັງໝົດ. ຄ່າທີ່ບໍ່ໄດ້ຕັ້ງ: -1.0
Int CNodeCpuPercentIdleGet( CNode node )
ສົ່ງຄືນເປີເຊັນຂອງເວລາຫວ່າງທີ່ໂປເຊດເຊີທັງໝົດຂອງ node
ມີປະສົບການ.
Int CNodeCpuPercentSysGet( CNode node )
ສົ່ງຄືນເປີເຊັນຂອງເວລາທີ່ໂປເຊດເຊີທັງໝົດຂອງ node ມີ
ໃຊ້ເວລາແລ່ນລະຫັດ kernel.
Int CNodeCpuPercentUserGet( CNode node )
ສົ່ງຄືນເປີເຊັນຂອງເວລາທີ່ໂປເຊດເຊີທັງໝົດຂອງ node ມີ
ໃຊ້ເວລາແລ່ນລະຫັດຜູ້ໃຊ້.
Int CNodeCpuPercentGuestGet( CNode node )
ສົ່ງຄືນເປີເຊັນຂອງເວລາທີ່ໂປເຊດເຊີທັງໝົດຂອງ node ມີ
ໃຊ້ເວລາແລ່ນລະບົບປະຕິບັດການແຂກ.
Int CNodeNetworkBwGet( CNode node, string ປະເພດ )
ສົ່ງຄືນແບນວິດຂອງເຄືອຂ່າຍຂອງ node ຂອງ ປະເພດ ໃນ bytes/ວິນາທີ.
ປະເພດ ຖືກກໍານົດໂດຍນັກຂຽນຕາຕະລາງໃນຕົວກໍານົດເວລາ
ໄຟລ໌ການຕັ້ງຄ່າ. ຄ່າທີ່ບໍ່ໄດ້ຕັ້ງ: -1
ບາງຕົວຢ່າງການໂທແມ່ນ:
CNodeNetworkBwGet( node, "ຮິບປິ" );
CNodeNetworkBwGet( node, "fddi" );
ເລືອກຂະຫນາດ CNodeDiskSpaceTotalGet(CNode node, string ຊື່)
ສົ່ງຄືນພື້ນທີ່ທັງໝົດຂອງ node ໃນ disk ທີ່ລະບຸໂດຍ ຊື່ ບ່ອນທີ່ ຊື່
ແມ່ນຊື່ອຸປະກອນທີ່ກໍານົດໂດຍຕົນເອງໂດຍຜູ້ຂຽນກໍານົດເວລາໃນ
ໄຟລ໌ການຕັ້ງຄ່າຕົວກໍານົດເວລາ. ຄ່າທີ່ບໍ່ໄດ້ຕັ້ງ: -1b
ຕົວຢ່າງ:
CNodeDiskSpaceTotalGet( node, "/scratch2" );
ເລືອກຂະຫນາດ CNodeDiskSpaceAvailGet(CNode node, string ຊື່)
ສົ່ງຄືນພື້ນທີ່ຫວ່າງຂອງໂນດໃນແຜ່ນທີ່ລະບຸໂດຍ ຊື່ ບ່ອນທີ່
ຊື່ ຖືກກໍານົດໂດຍ arbitrarily ໂດຍ writer writer ໃນຕາຕະລາງ
ໄຟລ໌ການຕັ້ງຄ່າ. ຄ່າທີ່ບໍ່ໄດ້ຕັ້ງ: -1b
ຕົວຢ່າງ:
CNodeDiskSpaceAvailGet( node, "/scratch1" );
ເລືອກຂະຫນາດ CNodeDiskSpaceReservedGet(CNode node, string ຊື່)
ສົ່ງຄືນພື້ນທີ່ສະຫງວນຂອງໂນດໃນດິສກ໌ (ໂຄຕ້າຜູ້ໃຊ້ບໍ?) ລະບຸໂດຍ
ຊື່ ບ່ອນທີ່ ຊື່ ຖືກກໍານົດໂດຍ arbitrarily ໂດຍນັກຂຽນຕາຕະລາງໃນ
ໄຟລ໌ການຕັ້ງຄ່າຕົວກໍານົດເວລາ. ຄ່າທີ່ບໍ່ໄດ້ຕັ້ງ: -1b
ຕົວຢ່າງ:
CNodeDiskSpaceReservedGet( node, "/scratch1" );
Int CNodeDiskInBwGet( CNode node, string ຊື່ )
ສົ່ງຄືນແບນວິດການຂຽນ (ໄບຕ໌/ວິນາທີ) ຂອງດິສກ໌ຂອງໂນດທີ່ລະບຸໄວ້
by ຊື່ . ຄ່າທີ່ບໍ່ໄດ້ຕັ້ງ: -1
ຕົວຢ່າງ:
CNodeDiskInBwGet( node, "/ໄວ" );
Int CNodeDiskOutBwGet( CNode node, string ຊື່ )
ກັບຄືນການອ່ານແບນວິດ (bytes/sec) ຂອງດິສກ໌ຂອງ node ທີ່ລະບຸໂດຍ
ຊື່ . ຄ່າທີ່ບໍ່ໄດ້ຕັ້ງ: -1
ຕົວຢ່າງ:
CNodeDiskOutBwGet( node, "/ໃຫຍ່" );
ເລືອກຂະຫນາດ CNodeSwapSpaceTotalGet( CNode node, string ຊື່ )
ສົ່ງຄືນພື້ນທີ່ທັງໝົດຂອງ node ໃນ swap ທີ່ລະບຸໂດຍ ຊື່ ບ່ອນທີ່ ຊື່
ຖືກກໍານົດໂດຍ arbitrarily ໂດຍ writer writer ໃນຕາຕະລາງ
ໄຟລ໌ການຕັ້ງຄ່າ. ຄ່າທີ່ບໍ່ໄດ້ຕັ້ງ: -1b
ຕົວຢ່າງ:
CNodeSwapSpaceTotalGet( node, "ປະຖົມ" );
ເລືອກຂະຫນາດ CNodeSwapSpaceAvailGet( CNode node, string ຊື່ )
ສົ່ງຄືນພື້ນທີ່ຫວ່າງຂອງ node ໃນ swap ທີ່ລະບຸໂດຍ ຊື່ ບ່ອນທີ່ ຊື່
ແມ່ນຊື່ອຸປະກອນທີ່ກໍານົດໂດຍຕົນເອງໂດຍຜູ້ຂຽນກໍານົດເວລາໃນ
ໄຟລ໌ການຕັ້ງຄ່າຕົວກໍານົດເວລາ. ຄ່າທີ່ບໍ່ໄດ້ຕັ້ງ: -1b
ຕົວຢ່າງ:
CNodeSwapSpaceAvailGet( node, "ຮອງ" );
Int CNodeSwapInBwGet( CNode node, string ຊື່ )
ສົ່ງຄືນອັດຕາ swap ຂອງອຸປະກອນ swap ຂອງ node ທີ່ລະບຸໂດຍ ຊື່
ຕົວຢ່າງ:
CNodeSwapInBwGet(node, "ຮອງ");
Int CNodeSwapOutBwGet( CNode node, string ຊື່ )
ສົ່ງຄືນອັດຕາ swapout ຂອງອຸປະກອນ swap ຂອງ node ທີ່ລະບຸໂດຍ
ຊື່ ຄ່າທີ່ບໍ່ໄດ້ຕັ້ງ: -1
ຕົວຢ່າງ:
CNodeSwapOutBwGet(node, "ປະຖົມ");
ເລືອກຂະຫນາດ CNodeTapeSpaceTotalGet( CNode node, string ຊື່ )
ສົ່ງຄືນພື້ນທີ່ທັງໝົດຂອງ node ໃນເທບທີ່ລະບຸໂດຍ ຊື່ ບ່ອນທີ່ ຊື່
ຖືກກໍານົດໂດຍ arbitrarily ໂດຍ writer writer ໃນຕາຕະລາງ
ໄຟລ໌ການຕັ້ງຄ່າ. ຄ່າທີ່ບໍ່ໄດ້ຕັ້ງ: -1b
ຕົວຢ່າງ:
CNodeTapeSpaceTotalGet(node, "4mm");
ເລືອກຂະຫນາດ CNodeTapeSpaceAvailGet( CNode node, string ຊື່ )
ສົ່ງຄືນພື້ນທີ່ຫວ່າງຂອງໂນດໃນເທບທີ່ລະບຸໂດຍ ຊື່ ບ່ອນທີ່
ຊື່ ຖືກກໍານົດໂດຍ arbitrarily ໂດຍ writer writer ໃນຕາຕະລາງ
ໄຟລ໌ການຕັ້ງຄ່າ. ຄ່າທີ່ບໍ່ໄດ້ຕັ້ງ: -1b
ຕົວຢ່າງ:
CNodeTapeSpaceAvailGet(node, "8mm");
Int CNodeTapeInBwGet( CNode node, string ຊື່ )
ສົ່ງຄືນແບນວິດການຂຽນ (ໄບຕ໌/ວິນາທີ) ຂອງເທບຂອງໂນດທີ່ລະບຸໄວ້
by ຊື່ . ຄ່າທີ່ບໍ່ໄດ້ຕັ້ງ: -1
ຕົວຢ່າງ:
CNodeTapeInBwGet( node, "4 ມມ" );
Int CNodeTapeOutBwGet( CNode node, string ຊື່ )
ສົ່ງຄືນແບນວິດທີ່ອ່ານ (ໄບຕ໌/ວິນາທີ) ຂອງເທບຂອງໂນດທີ່ລະບຸໄວ້
by ຊື່ . ຄ່າທີ່ບໍ່ໄດ້ຕັ້ງ: -1
ຕົວຢ່າງ:
CNodeTapeOutBwGet( node, "8 ມມ" );
ເລືອກຂະຫນາດ CNodeSrfsSpaceTotalGet( CNode node, string ຊື່ )
ສົ່ງຄືນພື້ນທີ່ທັງໝົດຂອງ node ໃນອຸປະກອນ srfs ທີ່ລະບຸໂດຍ ຊື່
ບ່ອນທີ່ ຊື່ ຖືກກໍານົດໂດຍ arbitrarily ໂດຍນັກຂຽນຕາຕະລາງໃນ
ໄຟລ໌ການຕັ້ງຄ່າຕົວກໍານົດເວລາ. ຄ່າທີ່ບໍ່ໄດ້ຕັ້ງ: -1b
ຕົວຢ່າງ:
CNodeSrfsSpaceTotalGet(node, "/ໄວ");
ເລືອກຂະຫນາດ CNodeSrfsSpaceAvailGet( CNode node, string ຊື່ )
ສົ່ງຄືນພື້ນທີ່ຫວ່າງຂອງ node ໃນອຸປະກອນ srfs ທີ່ລະບຸໂດຍ ຊື່
ບ່ອນທີ່ ຊື່ ຖືກກໍານົດໂດຍ arbitrarily ໂດຍນັກຂຽນຕາຕະລາງໃນບາງ
ໄຟລ໌ການຕັ້ງຄ່າ. ຄ່າທີ່ບໍ່ໄດ້ຕັ້ງ: -1b
ຕົວຢ່າງ:
CNodeSrfsSpaceAvailGet( node, "/ໃຫຍ່" );
ເລືອກຂະຫນາດ CNodeSrfsSpaceReservedGet(CNode node, string ຊື່)
ສົ່ງຄືນຈຳນວນທັງໝົດຂອງ node ຂອງພື້ນທີ່ສະຫງວນໃນອຸປະກອນ srfs
ລະບຸໂດຍ ຊື່ ບ່ອນທີ່ ຊື່ ຖືກກໍານົດໂດຍຜູ້ກໍານົດເວລາ
writer ໃນໄຟລ໌ການຕັ້ງຄ່າຕາຕະລາງ. ຄ່າທີ່ບໍ່ໄດ້ຕັ້ງ: -1b
ຕົວຢ່າງ:
CNodeSrfsSpaceReservedGet( node, "/ໄວ" );
Int CNodeSrfsInBwGet( CNode node, string ຊື່ )
ສົ່ງຄືນແບນວິດການຂຽນ (bytes/sec) ຂອງອຸປະກອນ srfs ຂອງ node
ລະບຸໂດຍ ຊື່ . ຄ່າທີ່ບໍ່ໄດ້ຕັ້ງ: -1
ຕົວຢ່າງ:
CNodeSrfsInBwGet( node, "/fast" );
Int CNodeSrfsOutBwGet( CNode node, string ຊື່ )
ສົ່ງຄືນແບນວິດທີ່ອ່ານ (bytes/sec) ຂອງອຸປະກອນ srfs ຂອງ node
ລະບຸໂດຍ ຊື່ . ຄ່າທີ່ບໍ່ໄດ້ຕັ້ງ: -1
ຕົວຢ່າງ:
CNodeSrfsOutBwGet( node, "/big" );
(5) ຫນ້າທີ່ອື່ນໆ
DateTime datetimeGet()
ໄດ້ຮັບວັນທີ / ເວລາປະຈຸບັນ.
Int datetimeToSec(DateTime dt)
ສົ່ງຄືນ # ຂອງວິນາທີນັບຕັ້ງແຕ່ຍຸກ (ເວລາເລີ່ມຕົ້ນຂອງ UNIX -
00:00:00, 1 ມັງກອນ 1970) ສໍາລັບວັນທີ/ເວລາທີ່ໃຫ້ ດທ.
Int ວຽກເຮັດງານທຳ( ວຽກເຮັດງານທໍາ ວຽກ, Int ການປະຕິບັດ, string ຕົວກໍານົດການ )
ປະຕິບັດ ການປະຕິບັດ on ວຽກເຮັດງານທໍາ ມີ ຕົວກໍານົດການ ລະບຸໄວ້ຂຶ້ນກັບ
ການປະຕິບັດ. ການປະຕິບັດ ສາມາດເປັນ: SYNCRUN, ASYNCRUN, DELETE, RERUN, ຖື,
ປ່ອຍ, ສັນຍານ, MODIFYATTR, MODIFYRES ບ່ອນທີ່:
ການປະຕິບັດ ລາຍລະອຽດ
=============== ==========================
SyncRUN ແລ່ນ ໄດ້ ວຽກເຮັດງານທໍາ synchronously,
ຊຶ່ງຫມາຍຄວາມວ່າ ໄດ້ ໂທ to
ວຽກເຮັດ() ຈະ ພຽງແຕ່
ການກັບຄືນມາ ໃນເວລາທີ່ ໄດ້ ວຽກເຮັດງານທໍາ ມີ
ເລີ່ມຕົ້ນ ການເຮັດວຽກ or ໃນເວລາທີ່
an ຄວາມຜິດພາດ ມີ ໄດ້
ພົບ.
Param ມູນຄ່າ:
ຊື່ of ເຈົ້າພາບ to ແລ່ນ
ວຽກເຮັດງານທໍາ ພາຍໃຕ້.
ASYNCRUN ແລ່ນ ໄດ້ ວຽກເຮັດງານທໍາ asynchronously,
ຊຶ່ງຫມາຍຄວາມວ່າ ໄດ້ ໂທ to
ວຽກເຮັດ() ຈະ ການກັບຄືນມາ
ທັນທີ as ທັນທີ as
ໄດ້ ແລ່ນ ຮ້ອງຂໍ is
validated by ໄດ້ PBS ເຊີບເວີ,
ແລະ ບໍ່ ຈໍາເປັນ ໃນເວລາທີ່
ໄດ້ ວຽກເຮັດງານທໍາ ມີ ເລີ່ມຕົ້ນ
ການປະຫານຊີວິດ.
Param ມູນຄ່າ:
ຊື່ of ເຈົ້າພາບ to ແລ່ນ
ວຽກເຮັດງານທໍາ ພາຍໃຕ້.
DELETE ລຶບ ໄດ້ ວຽກງານ.
Param ມູນຄ່າ:
"deldelay=<# of ວິນາທີ>"
- ຊັກຊ້າ # of ວິນາທີ
ລະຫວ່າງ ໄດ້ ການສົ່ງ
of ໄລຍະເປົ້າໝາຍ ແລະ SIGKILL
to ໄດ້ ວຽກເຮັດງານທໍາ ກ່ອນທີ່ຈະ
ໄດ້ຮັບ ລຶບແລ້ວ.
RERUN ກັບຄືນມາ ໄດ້ ການເຮັດວຽກ ວຽກ,
ທີ່ ກ່ຽວຂ້ອງ ສິ້ນສຸດ
ໄດ້ ກອງປະຊຸມ ຜູ້ນໍາ of ໄດ້
ວຽກເຮັດງານທໍາ ແລະ ກັບຄືນ ໄດ້ ວຽກເຮັດງານທໍາ
to ໄດ້ ຄິວ ລັດ.
ຊະນິດ ສະຖານທີ່ ຫນຶ່ງ or ເພີ່ມເຕີມ ຖື
on ໄດ້ ວຽກງານ.
Param ມູນຄ່າ:
"u", "o", "s", "uo", "os",
"uos"
- ປະເພດ of ຖື to ສະຖານທີ່
on ວຽກ: u(ser), o(ອື່ນໆ),
s(ລະບົບ).
ການປ່ອຍ ເອົາອອກ or ປ່ອຍອອກມາ
ຖື ຖືກຈັດໃສ່ on ວຽກ.
Param ມູນຄ່າ:
"u", "o", "s", "uo", "os",
"uos"
- ປະເພດ of ຖື to ເອົາ
ຈາກ ວຽກ: u(ser), o(ອື່ນໆ),
s(ລະບົບ).
ລາຍເຊັນ ສົ່ງ a signal to ໄດ້
ການປະຕິບັດ ວຽກງານ.
Param ມູນຄ່າ:
"HUP", "SIGHUP",...
MODIFYATTR ດັດແປງ ໄດ້ ລະບຸ
ຄຸນລັກສະນະ of ໄດ້ ວຽກເຮັດງານທໍາ to
ໄດ້ ໄດ້ຮັບ ມູນຄ່າ, ໃນເວລາທີ່
ໄດ້ attrib_name is
!= "ລາຍການຊັບພະຍາກອນ" or
"resources_used".
Param ມູນຄ່າ:
"attrib_name=value"
ແກ້ໄຂ ດັດແປງ ໄດ້ ວຽກ
ລາຍຊື່ຊັບພະຍາກອນ
ຄຸນລັກສະນະ ໄດ້ຮັບ ໄດ້
res_name ແລະ ໄດ້
res_value:
Resource_List.res_name=
res_value
Param ມູນຄ່າ:
"res_name=res_val"
ຕົວກໍານົດການ ມູນຄ່າແມ່ນຂຶ້ນກັບການປະຕິບັດ. ລະບຸ NULLSTR ຖ້າບໍ່ມີຄ່າ
ຕົວກໍານົດການນີ້ແມ່ນຕ້ອງການ.
ມູນຄ່າກັບຄືນ: ຄວາມສຳເລັດ ຫຼື FAIL.
ໝາຍເຫດ: ບໍ່ຮູ້ຈັກໃດໆ ການປະຕິບັດ ຖືກລະເລີຍ.
ຕົວຢ່າງ:
// ແລ່ນ ວຽກເຮັດງານທໍາ j synchronously
JobAction(j, SyncRUN, NULLSTR);
// ແລ່ນ ວຽກເຮັດງານທໍາ j asynchronously on ເຈົ້າພາບ "db"
JobAction(j, ASYNCRUN, "db");
// ລຶບ ວຽກເຮັດງານທໍາ j
JobAction(j, ລົບລ້າງ, NULLSTR);
// ລຶບ ວຽກເຮັດງານທໍາ j ກັບ a ຊັກຊ້າ of 5 ແຫ້ງ
// ລະຫວ່າງ ໄດ້ ການສົ່ງ of ໄລຍະເປົ້າໝາຍ ແລະ
// SIGKILL
JobAction(j, ລົບລ້າງ, "deldelay=5");
// ແລ່ນຄືນ ວຽກເຮັດງານທໍາ j
JobAction(j, RERUN, NULLSTR);
// ສະຖານທີ່ a u(ser) ຖື on ວຽກເຮັດງານທໍາ j
JobAction(j, ຖື, "u");
// ສະຖານທີ່ an o(ອື່ນໆ) ຖື on ວຽກເຮັດງານທໍາ j
JobAction(j, ຖື, "o");
// ສະຖານທີ່ a s(ລະບົບ) ຖື on ວຽກເຮັດງານທໍາ j
JobAction(j, ຖື, "s");
// ສະຖານທີ່ a Default ຖື (ຫຼື) on ວຽກເຮັດງານທໍາ j
JobAction(j, ຖື, NULLSTR);
// ປ່ອຍ u(ser) ຖື ຈາກ ວຽກເຮັດງານທໍາ j
JobAction(j, ປ່ອຍ, "u");
// ປ່ອຍ o(ອື່ນໆ) ຖື ຈາກ ວຽກເຮັດງານທໍາ j
JobAction(j, ປ່ອຍ, "o");
// ປ່ອຍ s(ລະບົບ) ຖື ຈາກ ວຽກເຮັດງານທໍາ j
JobAction(j, ປ່ອຍ, "s");
// ປ່ອຍ Default ຖື (ຫຼື) ຈາກ ວຽກເຮັດງານທໍາ j
JobAction(j, ປ່ອຍ, NULLSTR);
// ສົ່ງ ຕິດຕາມ signal to ວຽກເຮັດງານທໍາ j
JobAction(j, ສັນຍາລັກ, "SIGHUP");
// ການປັບປຸງ ໄດ້ ຄວາມຄິດເຫັນ ຄຸນລັກສະນະ of ວຽກເຮັດງານທໍາ
// j to "a ຂໍ້ຄວາມ".
// ໄດ້ ຕົວກໍານົດການ ຮູບແບບ ແມ່ນ: attribute_name=new_value
// ປຶກສາຫາລື PBS ເອກະສານ ສໍາລັບການ a ບັນຊີລາຍຊື່ of ວຽກເຮັດງານທໍາ
// ຄຸນລັກສະນະ ຊື່ ທີ່ ສາມາດເຮັດໄດ້ be ລະບຸ.
JobAction(j, MODIFYATTR, "comment=a ຂໍ້ຄວາມ");
// ການປັບປຸງ ໄດ້ Resource_List.cput ຄຸນລັກສະນະ of ວຽກເຮັດງານທໍາ
// j to 3600 ວິນາທີ.
// ໄດ້ ຕົວກໍານົດການ ຮູບແບບ ແມ່ນ: resource_name=new_value
// ເບິ່ງ pbs_resources* ຜູ້ຊາຍ Page ສໍາລັບການ a ບັນຊີລາຍຊື່ of
// resource_names ທີ່ ສາມາດເຮັດໄດ້ be ລະບຸ.
JobAction(j, ແກ້ໄຂ, "cput=3600");
QueJobFind(Que que, ມ່ວນ Int func, int cpr, int ມູນຄ່າ);
QueJobFind(Que que, ມ່ວນ string func, int cpr, ສາຍ ມູນຄ່າ);
QueJobFind(Que que, ມ່ວນ DateTime func, int cpr,DateTime ມູນຄ່າ);
QueJobFind(Que que, ມ່ວນ ເລືອກຂະຫນາດ func, int cpr, ຂະຫນາດ ມູນຄ່າ);
ບ່ອນທີ່ cpr ແມ່ນໜຶ່ງໃນ: OP_EQ, OP_NEQ, OP_LE, OP_LT, OP_GE, OP_GT. ມ່ວນ
ແມ່ນຫນ້າທີ່ທີ່ມີການໂຕ້ຖຽງເທົ່ານັ້ນທີ່ເປັນປະເພດວຽກ. ວຽກເຮັດງານທໍາ ແມ່ນການກັບຄືນ
ປະເພດ
ລາຍລະອຽດ: ນຳໃຊ້ ມ່ວນ ກັບທຸກໆວຽກໃນ que , ແລະກັບຄືນທໍາອິດ
ວຽກທີ່ພໍໃຈກັບການປຽບທຽບຢ່າງມີເຫດຜົນ: Func(ວຽກ) cpr ມູນຄ່າ
ຕົວຢ່າງ:
ເລືອກຂະຫນາດ JobVirtualMemAvailGet(ວຽກ ວຽກ)
{
ເລືອກຂະຫນາດ sz ;
sz = JobSizeResReqGet(ວຽກ, "ເມັມ");
ກັບຄືນ(sz);
}
Int JobWallTimeReqGet(ວຽກ ວຽກ)
{
Int wallt;
ຝາ = JobIntResReqGet(ວຽກ, "walltime");
ກັບຄືນ(wallt);
}
Int JobCpuTimeUsedGet(ວຽກ ວຽກ)
{
Int ຄອມພິວເຕີ;
ຂໍ້ມູນ = JobIntResUseGet(ວຽກ, "cput");
return(cput);
}
ວ່າ findQueByName(ຊຸດ ວ່າ ຄິວ, string qname)
{
ວ່າ q;
foreach(ກ in ຄິວ) {
ຖ້າ( QueNameGet(q) EQ qname ) {
ກັບຄືນ(q);
}
}
ກັບຄືນ(NOQUE);
}
sche_main()
{
Server s;
ວ່າ que;
ທີ່ກໍານົດໄວ້ ວ່າ sq;
// ໄດ້ຮັບ ທ້ອງຖິ່ນ ເຄື່ອງແມ່ຂ່າຍ
s = AllServersLocalHostGet();
// ໄດ້ຮັບ ໄດ້ ແຖວ of ໄດ້ Server s
sq = ServerQueuesGet(s);
// ໄດ້ຮັບ ໄດ້ ຄິວ ຊື່ວ່າ "ໄວ" ຈາກ ໄດ້
// ທ້ອງຖິ່ນ ເຄື່ອງແມ່ຂ່າຍ
que = findQueByName( sq, "ໄວ" );
// ຄົ້ນຫາ ໄດ້ 1st ວຽກເຮັດງານທໍາ ທີ່ ຝາ ຄວາມຕ້ອງການ
// is == 300s:
QueJobFind(que, JobWallTimeReqGet, OP_EQ, ປີ 300);
// ຄົ້ນຫາ ໄດ້ 1st ວຽກເຮັດງານທໍາ ທີ່ ອີເມວ ທີ່ຢູ່ to
// ແຈ້ງ ກ່ຽວກັບ ວຽກເຮັດງານທໍາ ກິດຈະກໍາ != "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 ວຽກເຮັດງານທໍາ ທີ່ cpu ທີ່ໃຊ້ເວລາ ໃຫມ່ < 1600s:
QueJobFind(que, JobCpuTimeUsedGet, OP_LT, ປີ 1600);
// ຄົ້ນຫາ ໄດ້ 1st ວຽກເຮັດງານທໍາ ທີ່ virtual ຫນ່ວຍຄວາມຈໍາ
// ຄວາມຕ້ອງການ <= 300mb:
QueJobFind(que, JobVirtualMemAvailGet, OP_LE,
300mb);
}
ວຽກເຮັດງານທໍາ QueJobFind( ວ່າ ວ່າ, ສະຫນຸກສະຫນານ Int ມ່ວນ, Int cpr)
ວຽກເຮັດງານທໍາ QueJobFind( ວ່າ ວ່າ, ສະຫນຸກສະຫນານ string ມ່ວນ, Int cpr)
ວຽກເຮັດງານທໍາ QueJobFind( ວ່າ ວ່າ, ສະຫນຸກສະຫນານ DateTime ມ່ວນ, Int cpr)
ວຽກເຮັດງານທໍາ QueJobFind( ວ່າ ວ່າ, ສະຫນຸກສະຫນານ ເລືອກຂະຫນາດ ມ່ວນ, Int cpr)
ບ່ອນທີ່ cpr ສາມາດເປັນຫນຶ່ງໃນຕໍ່ໄປນີ້: OP_MAX, OP_MIN, ມ່ວນ ເປັນ
ຟັງຊັນທີ່ມີການໂຕ້ຖຽງເທົ່ານັ້ນທີ່ເປັນປະເພດວຽກ.
ລາຍລະອຽດ: ສົ່ງຄືນວຽກດ້ວຍຄ່າສູງສຸດ ຫຼື ຕ່ຳສຸດທີ່ພົບ
Func(ວຽກ) ຍ້ອນວ່າມັນຖືກນໍາໃຊ້ກັບທຸກໆວຽກໃນ que .
ຕົວຢ່າງ:
Int JobCpuTimeReqGet(ວຽກ ວຽກ)
{
Int ຄອມພິວເຕີ;
ຂໍ້ມູນ = JobIntResReqGet(ວຽກ, "cput");
return(cput);
}
sche_main()
{
ວ່າ que;
ວຽກເຮັດງານທໍາ ວຽກ;
// ຄົ້ນຫາ ໄດ້ ວຽກເຮັດງານທໍາ ກັບ ໄດ້ ທີ່ສູງທີ່ສຸດ cpu ທີ່ໃຊ້ເວລາ
// ຄວາມຕ້ອງການ:
ວຽກເຮັດງານທໍາ = QueJobFind(que, JobCpuTimeReqGet, OP_MAX);
// ຄົ້ນຫາ ໄດ້ ວຽກເຮັດງານທໍາ ກັບ ໄດ້ ຕໍາ່ສຸດທີ່ cpu ທີ່ໃຊ້ເວລາ
// ຄວາມຕ້ອງການ:
ວຽກເຮັດງານທໍາ = QueJobFind(que, JobCpuTimeReqGet, OP_MIN);
}
ວ່າ QueFilter(Que que, ມ່ວນ Int func, int cpr, int ມູນຄ່າ)
ວ່າ QueFilter(Que que, ມ່ວນ string func, int cpr, ສາຍ ມູນຄ່າ)
ວ່າ QueFilter(Que que, ມ່ວນ DateTime func, int cpr, ວັນທີ ມູນຄ່າ)
ວ່າ QueFilter(Que que, ມ່ວນ ເລືອກຂະຫນາດ func, int cpr, ຂະຫນາດ ມູນຄ່າ)
ບ່ອນທີ່ cpr ສາມາດເປັນຫນຶ່ງໃນຕໍ່ໄປນີ້: OP_EQ, OP_NEQ, OP_LE, OP_LT,
OP_GE, OP_GT, ມ່ວນ ແມ່ນຫນ້າທີ່ທີ່ມີການໂຕ້ຖຽງເທົ່ານັ້ນທີ່ເປັນປະເພດວຽກ.
ລາຍລະອຽດ: ນຳໃຊ້ ມ່ວນ ກັບທຸກໆວຽກໃນ que , ແລະກັບຄືນ que ໃຫມ່
ມີວຽກທັງໝົດທີ່ຕອບສະໜອງເງື່ອນໄຂການປຽບທຽບ:
Func(ວຽກ) cpr ມູນຄ່າ
ຕົວຢ່າງ:
Int JobWallTimeReqGet(ວຽກ ວຽກ)
{
Int wallt;
ຝາ = JobIntResReqGet(ວຽກ, "walltime");
ກັບຄືນ(wallt);
}
sche_main()
{
ວ່າ que;
ວ່າ newq;
// ຜົນຕອບແທນ a ໃຫມ່ que ບັນຈຸມີ ທັງຫມົດ ວຽກເຮັດງານທໍາ in "que"
// ກັບ a ຝາ ຄວາມຕ້ອງການ == 300s:
newq = QueFilter(que, JobWallTimeReqGet, OP_EQ, ປີ 300);
// ຜົນຕອບແທນ a ໃຫມ່ que ບັນຈຸມີ ທັງຫມົດ ວຽກເຮັດງານທໍາ in "que"
// ກັບ an ອີເມວ ທີ່ຢູ່ != "bayucan":
newq = QueFilter(que, JobEmailAddrGet, OP_NEQ, "bayucan");
// ຜົນຕອບແທນ a ໃຫມ່ que ບັນຈຸມີ ທັງຫມົດ ວຽກເຮັດງານທໍາ in "que"
// ສ້າງ ຫຼັງຈາກ or on 3 / 3 / 1997:
newq = QueFilter(que, JobDateTimeCreatedGet, OP_GE,
(3|3|1997));
// ຜົນຕອບແທນ a ໃຫມ່ que ບັນຈຸມີ ທັງຫມົດ ວຽກເຮັດງານທໍາ in "que"
// ສ້າງ ຫຼັງຈາກ 3:3:44:
newq = QueFilter(que, JobDateTimeCreatedGet, OP_GT,
(3:3:44) );
// ຜົນຕອບແທນ a ໃຫມ່ que ບັນຈຸມີ ທັງຫມົດ ວຽກເຮັດງານທໍາ in "que"
// ສ້າງ ຫຼັງຈາກ 3:3:44 on 3 / 3 / 1997:
newq = QueFilter(que, JobDateTimeCreatedGet, OP_GT,
(3|3|1997@3:3:44));
// ຫມາຍເຫດ: ໄດ້ ຕົ້ນສະບັບ "que" is ບໍ່ ແກ້ໄຂ
// ຢ່າງໃດກໍ່ຕາມ.
}
Int ຄັດ (ຊຸດ ວຽກເຮັດງານທໍາ s, ສະຫນຸກສະຫນານ Int key, Int order)
Int ຄັດ (ຊຸດ ວຽກເຮັດງານທໍາ s, ສະຫນຸກສະຫນານ string key, Int order)
Int ຄັດ (ຊຸດ ວຽກເຮັດງານທໍາ s, ສະຫນຸກສະຫນານ float key, Int order)
Int ຄັດ (ຊຸດ ວຽກເຮັດງານທໍາ s, ສະຫນຸກສະຫນານ DateTime key, Int order)
Int ຄັດ (ຊຸດ ວຽກເຮັດງານທໍາ s, ສະຫນຸກສະຫນານ ເລືອກຂະຫນາດ key, Int order)
ບ່ອນທີ່ s ຊຸດວຽກເພື່ອຈັດຮຽງ. ທີ່ສໍາຄັນ ແມ່ນລະດັບທີ່ສໍາຄັນທີ່ເປັນ
ຟັງຊັນທີ່ມີການໂຕ້ຖຽງດຽວຂອງປະເພດວຽກ, ຄໍາສັ່ງ ແມ່ນການຄັດເລືອກ
ຄໍາສັ່ງ: ASC, DESC.
ລາຍລະອຽດ: ຈັດລຽງລໍາດັບອົງປະກອບຂອງ s , ໃນ ASCending ຫຼື
DESCending ຄໍາສັ່ງຂອງມູນຄ່າທີ່ຖືກສົ່ງຄືນໂດຍ ທີ່ສໍາຄັນ ຫນ້າທີ່, ເປັນ
ນຳໃຊ້ກັບສະມາຊິກທຸກຊຸດຂອງວຽກ. ໄດ້ s ວັດຖຸຖືກດັດແກ້
ດ້ວຍການໂທນີ້. ນີ້ຈະສົ່ງຄືນຄວາມສຳເລັດ ຫຼື FAIL ຂຶ້ນກັບຜົນຂອງ
ການຈັດລຽງ.
ຕົວຢ່າງ:
ເລືອກຂະຫນາດ JobMemReqGet(ວຽກ ວຽກ)
{
ເລືອກຂະຫນາດ mem;
mem = JobSizeResReqGet(ວຽກ, "ເມັມ");
ການກັບຄືນມາ(mem);
}
sche_main()
{
Server ແມ່ບົດ;
ທີ່ກໍານົດໄວ້ ວຽກເຮັດງານທໍາ ວຽກ;
Int ສັ່ງ;
// ໄດ້ຮັບ ທ້ອງຖິ່ນ ເຄື່ອງແມ່ຂ່າຍ
ຕົ້ນສະບັບ = AllServersLocalHostGet();
ວຽກເຮັດງານທໍາ = ServerJobsGet(ແມ່ບົດ);
ຄັດ (ວຽກ, JobPriorityGet, ASC);
ຄັດ (ວຽກ, JobIdGet, DESC);
ຄໍາສັ່ງ = ASC;
ຄັດ (ວຽກ, JobDateTimeCreatedGet, ຄໍາສັ່ງ);
ຄໍາສັ່ງ = DESC;
ຄັດ (ວຽກ, JobMemReqGet, ຄໍາສັ່ງ);
}
Int ຄັດ (ຊຸດ ວ່າ s, ສະຫນຸກສະຫນານ Int key, Int order)
Int ຄັດ (ຊຸດ ວ່າ s, ສະຫນຸກສະຫນານ string key, Int order)
Int ຄັດ (ຊຸດ ວ່າ s, ສະຫນຸກສະຫນານ float key, Int order)
Int ຄັດ (ຊຸດ ວ່າ s, ສະຫນຸກສະຫນານ DateTime key, Int order)
Int ຄັດ (ຊຸດ ວ່າ s, ສະຫນຸກສະຫນານ ເລືອກຂະຫນາດ key, Int order)
ບ່ອນທີ່ s ຊຸດຂອງແຖວເພື່ອຈັດຮຽງ. ທີ່ສໍາຄັນ ແມ່ນລະດັບທີ່ສໍາຄັນທີ່ເປັນ
ຟັງຊັນທີ່ມີພຽງແຕ່ການໂຕ້ຖຽງຂອງປະເພດ Que, ຄໍາສັ່ງ ແມ່ນການຄັດເລືອກ
ຄໍາສັ່ງ: ASC, DESC.
ລາຍລະອຽດ: ຈັດລຽງລໍາດັບອົງປະກອບຂອງ s , ໃນ ASCending ຫຼື
DESCending ຄໍາສັ່ງຂອງມູນຄ່າທີ່ຖືກສົ່ງຄືນໂດຍ ທີ່ສໍາຄັນ ຫນ້າທີ່, ເປັນ
ນຳໃຊ້ກັບສະມາຊິກທຸກຊຸດຂອງແຖວ. ໄດ້ s ວັດຖຸແມ່ນ
ແກ້ໄຂດ້ວຍການໂທນີ້. ອັນນີ້ໃຫ້ຜົນຕອບແທນ SUCCESS ຫຼື FAIL ຂຶ້ນກັບ
ຜົນໄດ້ຮັບຂອງການຈັດລຽງ.
ຕົວຢ່າງ:
ເລືອກຂະຫນາດ QueMemAvailGet(Que ກວ່າ)
{
ເລືອກຂະຫນາດ mem;
mem = QueSizeResAvailGet(que, "ເມັມ");
ການກັບຄືນມາ(mem);
}
sche_main()
{
Server ແມ່ບົດ;
ທີ່ກໍານົດໄວ້ ວ່າ ques;
Int ສັ່ງ;
// ໄດ້ຮັບ ທ້ອງຖິ່ນ ເຄື່ອງແມ່ຂ່າຍ
ຕົ້ນສະບັບ = AllServersLocalHostGet();
ແມ່ນຫຍັງ = ServerQueuesGet(ແມ່ບົດ);
ຄັດ (ques, QuePriorityGet, ASC);
ຄັດ (ques, QueNameGet, ASC);
ຄໍາສັ່ງ = DESC;
ຄັດ (ques, QueMemAvailGet, ຄໍາສັ່ງ);
}
Int ຄັດ (ຊຸດ Server s, ສະຫນຸກສະຫນານ Int key, Int order)
Int ຄັດ (ຊຸດ Server s, ສະຫນຸກສະຫນານ string key, Int order)
Int ຄັດ (ຊຸດ Server s, ສະຫນຸກສະຫນານ float key, Int order)
Int ຄັດ (ຊຸດ Server s, ສະຫນຸກສະຫນານ DateTime key, Int order)
Int ຄັດ (ຊຸດ Server s, ສະຫນຸກສະຫນານ ເລືອກຂະຫນາດ key, Int order)
ບ່ອນທີ່ s ຊຸດຂອງເຄື່ອງແມ່ຂ່າຍເພື່ອຈັດຮຽງ. ທີ່ສໍາຄັນ ແມ່ນລະດັບທີ່ສໍາຄັນແມ່ນ
ຟັງຊັນທີ່ argument ສະເພາະແມ່ນປະເພດເຊີບເວີ, ຄໍາສັ່ງ ເປັນ
ການຈັດລຽງລຳດັບ: ASC, DESC.
ລາຍລະອຽດ: ຈັດລຽງລໍາດັບອົງປະກອບຂອງ s , ໃນ ASCending ຫຼື
DESCending ຄໍາສັ່ງຂອງມູນຄ່າທີ່ຖືກສົ່ງຄືນໂດຍ ທີ່ສໍາຄັນ ຫນ້າທີ່, ເປັນ
ນຳໃຊ້ກັບສະມາຊິກທຸກຊຸດຂອງເຊີບເວີ. ໄດ້ s ວັດຖຸແມ່ນ
ແກ້ໄຂດ້ວຍການໂທນີ້. ອັນນີ້ໃຫ້ຜົນຕອບແທນ SUCCESS ຫຼື FAIL ຂຶ້ນກັບ
ຜົນໄດ້ຮັບຂອງການຈັດລຽງ.
ຕົວຢ່າງ:
ເລືອກຂະຫນາດ ServerMemAvailGet(ເຊີບເວີ ຮັບໃຊ້)
{
ເລືອກຂະຫນາດ mem;
mem = ServerSizeResAvailGet(ໃຫ້ບໍລິການ, "ເມັມ");
ການກັບຄືນມາ(mem);
}
sche_main()
{
ທີ່ກໍານົດໄວ້ Server ເຊີບເວີ;
Int ສັ່ງ;
Int ret;
ເຊີບເວີ = AllServersGet();
ການປະຕິເສດ = ຈັດຮຽງ(ເຊີບເວີ, ServerMaxRunJobsGet, ASC);
ຈັດຮຽງ(ເຊີບເວີ, ServerInetAddrGet, ASC);
ຄໍາສັ່ງ = DESC;
ຈັດຮຽງ(ເຊີບເວີ, ServerMemAvailGet, ຄໍາສັ່ງ);
}
Int ຄັດ (ຊຸດ CNode s, ສະຫນຸກສະຫນານ Int key, Int order)
Int ຄັດ (ຊຸດ CNode s, ສະຫນຸກສະຫນານ string key, Int order)
Int ຄັດ (ຊຸດ CNode s, ສະຫນຸກສະຫນານ float key, Int order)
Int ຄັດ (ຊຸດ CNode s, ສະຫນຸກສະຫນານ DateTime key, Int order)
Int ຄັດ (ຊຸດ CNode s, ສະຫນຸກສະຫນານ ເລືອກຂະຫນາດ key, Int order)
ບ່ອນທີ່ s ຊຸດຂອງ nodes ເພື່ອຈັດຮຽງ. ທີ່ສໍາຄັນ ແມ່ນລະດັບທີ່ສໍາຄັນທີ່ເປັນ
ຟັງຊັນທີ່ມີພຽງແຕ່ການໂຕ້ຖຽງຂອງປະເພດ CNode, ຄໍາສັ່ງ ແມ່ນການຄັດເລືອກ
ຄໍາສັ່ງ: ASC, DESC.
ລາຍລະອຽດ: ຈັດລຽງລໍາດັບອົງປະກອບຂອງ s , ໃນ ASCending ຫຼື
DESCending ຄໍາສັ່ງຂອງມູນຄ່າທີ່ຖືກສົ່ງຄືນໂດຍ ທີ່ສໍາຄັນ ຫນ້າທີ່, ເປັນ
ນຳໃຊ້ກັບທຸກໆສະມາຊິກຂອງຊຸດຂອງ nodes. ໄດ້ s ວັດຖຸແມ່ນ
ແກ້ໄຂດ້ວຍການໂທນີ້. ອັນນີ້ໃຫ້ຜົນຕອບແທນ SUCCESS ຫຼື FAIL ຂຶ້ນກັບ
ຜົນໄດ້ຮັບຂອງການຈັດລຽງ.
ຕົວຢ່າງ:
ເລືອກຂະຫນາດ CNodeMyMemAvailGet(CNode cn)
{
ເລືອກຂະຫນາດ mem;
mem = CNodeMemAvailGet(cn, "virtual");
ການກັບຄືນມາ(mem);
}
sche_main()
{
ທີ່ກໍານົດໄວ້ CNode scnode;
Int ສັ່ງ;
ສະໂນດ = AllNodesGet();
ຄັດ (scnode, CNodeIdletimeGet, ASC);
ຄັດ (scnode, CNodeNameGet, ASC);
ຄໍາສັ່ງ = DESC;
ຄັດ (scnode, CNodeMyMemAvailGet, ຄໍາສັ່ງ);
}
CNode..Get() FUNCTIONS
ຄ່າກັບຄືນຂອງຟັງຊັນ CNode..Get() ທີ່ສົນທະນາໃນພາກກ່ອນໜ້າແມ່ນ
ໄດ້ຮັບໂດຍການສົ່ງຄໍາຖາມຊັບພະຍາກອນໄປຫາ MOM ຂອງ CNode ໃນທຸກໆການກໍານົດເວລາຊ້ໍາກັນ.
ຍົກຕົວຢ່າງ, CNodeLoadAveGet(node) ຈະສົ່ງຄືນຄ່າທີ່ໄດ້ຮັບຈາກບາງອັນ
resource> query (ນີ້ອາດຈະເປັນ string "loadave") ທີ່ຖືກສົ່ງໄປຫາ MOM ຂອງ node. ໄດ້
" -> CNode..Get()" ການສ້າງແຜນທີ່ພາຍໃນ, ແຕ່ພວກເຂົາສາມາດເປັນ
ສາມາດເພີ່ມແຜນທີ່ທີ່ດັດແກ້ ຫຼືເພີ່ມເຕີມໄດ້ຜ່ານໄຟລ໌ການຕັ້ງຄ່າຕົວກໍານົດເວລາ. ການຕັ້ງຄ່າ
ເອກະສານໄດ້ຖືກປຶກສາຫາລືໃນ pbs_sched_basl(8 ຂ).
ແຜນທີ່ທີ່ໄດ້ສ້າງຕັ້ງຂຶ້ນແລ້ວແມ່ນໄດ້ຮັບໃຫ້ຢູ່ໃນດັ່ງຕໍ່ໄປນີ້:
ສໍາລັບສະຖາປັດຕະຍະກໍາທັງຫມົດ:
CNode..Get() ຈິງ ໂທ ເຈົ້າພາບ ຊັບພະຍາກອນ
======================== =============
CNodeOsGet(node) ໂຄ້ງ
CNodeLoadAveGet(node) loadave
CNodeIdletimeGet(node) ເວລາຫວ່າງ
ໃຊ້ basl2cB ອອນໄລນ໌ໂດຍໃຊ້ບໍລິການ onworks.net
