basl2cB - En ligne dans le cloud

PROGRAMME:

Nom

basl2c - convertit un code BASL (BAtch Scheduling Language) en code de planificateur C.

SYNOPSIS

basl2c [-d] [-l lexerDebugFile] [-p parserDebugFile] [-y symtabDebugFile] [-s
semanticDebugFile] [-g codegenDebugFile] [-c cFile] baslFile

DESCRIPTION

basl2c est le compilateur BASL vers C qui produit un code intermédiaire pouvant être introduit dans un
compilateur C standard et lié aux bibliothèques PBS pour produire l'exécutable du planificateur.
Basl2c prend en entrée un baslFichier, qui est un programme écrit en BAtch Scheduling
Langue, contenant le code de planification principal. Basl2c convertit ensuite les constructions BASL
dans le fichier en instructions C, et il joint également du code supplémentaire pour produire le PBS
code source du planificateur. Par défaut, le code C résultant est écrit dans le fichier
pbs_sched.c.

Le chemin d'accès complet au fichier C résultant doit être spécifié dans le fichier SCHD_CODE
variable dans local.mk avant de compiler le planificateur BASL pour produire le pbs_sched
exécutable

OPTIONS

-d Imprime des messages de débogage supplémentaires sur le lexer (voir l'option -l), l'analyseur (voir -p
option), table de symboles (voir option -y), analyseur sémantique (voir option -s) et code
générateur (voir l'option -g).

-l lexerDebugFichier
lexerDebugFichier est le nom d'un fichier à écrire dans les messages de débogage générés
lors de la recherche de jetons.

-p analyseurDebugFichier
parserDebugFile est le nom d'un fichier à écrire dans les messages de débogage générés
tout en rassemblant les jetons de manière utilisable.

-y symtabDebugFichier
symtabDebugFichier est le nom d'un fichier à écrire dans les messages de débogage liés à
la table des symboles.

-s sémantiqueDebugFile
sémantiqueDebugFile est le nom d'un fichier à écrire dans les messages de débogage
généré lors de la vérification pour s'assurer que les variables et les opérateurs sont utilisés dans un
manière cohérente.

-g codegenDebugFichier
codegenDebugFile est le nom d'un fichier à écrire dans les messages de débogage générés
lors de la conversion des instructions BASL en instructions C.

-c Fichierc
cFichier est le nom d'un fichier dans lequel le code C généré est écrit.

PRINCIPAL STRUCTURE

La structure de base d'un code de planificateur écrit en BASL est la suivante :
zéro or PLUS FONCTIONS définitions
zéro or PLUS de défis VARIABLE DÉCLARATIONS
zéro or PLUS affectation déclarations (à initialiser de défis variables)
sched_main()
{
UN or PLUS VARIABLE DÉCLARATIONS

zéro or PLUS ÉTATS
}

Par exemple,
% cat sched.basl
Int somme(Int a, Int b)
{
Int s;
s = a + b;
Retour);
}
Int globe;
sched_main()
{
Int c;

a = 3;
b = 4;
c = somme(a, b);
imprimer(c);
glob = 5;
imprimer(glob);
}

sched_main() est la fonction qui est appelée à chaque itération de planification.

FONCTIONS

Pour définir une fonction pouvant être appelée dans les fonctions suivantes, la syntaxe est la suivante :

Type de retour nom-fonction ( TYPE DE DONNÉES1 IDENTIFIANT1,
TYPE DE DONNÉES2 IDENTIFIANT2, )
{
UN or PLUS VARIABLE DÉCLARATIONS

zéro or PLUS ÉTATS
}

Par exemple,
vide printStuff(Jourdelasemaine dow, DateTime t, Chaîne str,
Taille sz, CNode cn)
{
print(dow);
imprimer(t);
imprimer(chaîne);
imprimer(taille);
imprimer(cn);
}

Fonction valide Type de retour sont : Void, Int, Float, Dayofweek, DateTime, String, Size,
Serveur, Que, Travail, CNode, Définir le serveur, Définir la file d'attente, Définir le travail, Définir le CNode.

Types de données valides ( TYPE DE DONNÉES1, TYPE DE DONNÉES2, ) pour les identifiants de paramètres sont : Int,
Flottant, Jour de la semaine, DateHeure, Chaîne, Taille, Serveur, Que, Travail, CNode, Définir le serveur, Définir la file d'attente,
Définir le travail, définir le nœud CN, la plage Int, la plage flottante, la plage Dayofweek, la plage DateHeure, la taille de la plage,
Fun Int, Fun Float, Fun Void, Fun Dayofweek, Fun DateTime, Fun String, Fun Size, Fun
Serveur, Fun Que, Fun Job, Fun CNode, Fun Set Server, Fun Set Que, Fun Set Job, Fun Set
CNode. Ces types de données seront abordés dans la rubrique suivante.

Les fonctions sont invoquées par leur nom et leurs arguments comme dans :

printStuff( LUN, (5|1|1997@14:32:00), "schedulé commence",
30 Go, nœud );

basl2c ajoutera en fait un préfixe "basl_" au nom de la fonction donné par le planificateur
écrivain pour minimiser les risques de collision de noms, qui peuvent survenir lorsque le code C résultant est
lié aux bibliothèques PBS, BASL. Par exemple, si vous regardez le code C généré pour
imprimerStuff, tu verrais,

basl_printStuff( MON, (5|1|1997@14:32:00),
"le planning commence", 30 Go, nœud );

Comme en C, tous les appels de fonction doivent avoir été préalablement définis. Le compilateur BASL va
vérifiez que les arguments de l'appel de fonction correspondent exactement (en termes de
types) avec les paramètres dans la définition de la fonction.

Deux types de fonctions existent en BASL : les fonctions définies par l'utilisateur et les fonctions prédéfinies.
Les fonctions définies par l'utilisateur sont celles pour lesquelles le rédacteur du planificateur a fourni une définition,
tandis que les fonctions prédéfinies sont celles qui peuvent être immédiatement appelées sans avoir besoin de
le définir. Pour une liste des fonctions prédéfinies, voir la section sur PRÉDÉFINI FONCTIONS .

VARIABLE DÉCLARATIONS

Comme en C, toutes les variables d'un code BASL doivent être explicitement déclarées avant utilisation. Ceux
les variables déclarées en dehors de toute fonction sont appelées variables globales, tandis que
les variables déclarées dans le corps d'une fonction sont appelées variables locales. Mondial
les variables sont utilisables n'importe où dans le code BASL, tandis que les variables locales sont lisibles
uniquement dans la fonction à partir de laquelle ils ont été déclarés.

La syntaxe d'une déclaration de variable est :

TYPE DE DONNÉES IDENTIFICATEUR ;

De TYPE DE DONNÉES peut être : Int, Float, Dayofweek, DateTime, String, Size, Server, Que, Job,
CNode, Définir le serveur, Définir la file d'attente, Définir le travail, Définir CNode, Range Int, Range Float, Range Dayofweek,
Plage DateHeure, Taille de la plage.

DONNEES TYPE

vide utilisé pour les fonctions qui ne renvoient pas de valeur.

Int signé, nombres entiers donnés en base 10.

Exemples de constantes :
5, +1, -3, SUCCÈS (=1), ÉCHEC (=0), VRAI (=1), FAUX (=0)

flotteur nombres réels qui sont représentés sous forme de doubles dans le code C traduit.
Constantes d'échantillon : 4.3, +1.2, -2.6

Jour de la semaine
valeurs constantes : SUN, MON, TUE, WED, THU, FRI, SAT, représentées en interne par
constantes à valeur entière avec SUN=0, MON=1, et ainsi de suite.

DateTime
à préciser dans l'un des 3 formats :

[1] (m|d|y) où 1 <= m <= 12, 1 <= d <= 31, 0 <= y, ex. (4|4|1997) ;

[2] (hh:mm:ss) où 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)
Lors de la comparaison dates/heures, l'heure « actuelle » est remplacée si l'heure
la partie n'est pas donnée (format [1]) ; la date «maintenant» est remplacée si le
la partie date n’est pas donnée (format [2]). De plus, la partie année complète doit
être donné (c'est-à-dire 1997 au lieu de 97) en dates pour éviter toute ambiguïté.

Chaîne Une chaîne est entourée de guillemets ("") et peut contenir n'importe quoi sauf un autre
citation, une nouvelle ligne et des parenthèses gauche et droite.
Exemples de constantes : "un exemple de chaîne", NULLSTR

Taille format: où le suffixe est un multiplicateur de la forme :
:

multiplicateur unité (octets or mots)
=================== =====================
k, m, g, t, p, K, M, G, T, P b,B,w,W

où k=K=1024, m=M=1,048,576 1,073,741,824 1,099,511,627,776, g=G=XNUMX XNUMX XNUMX XNUMX, t=T=XNUMX XNUMX XNUMX XNUMX XNUMX,
p=P=1,125,899,906,842,624 1 4 XNUMX XNUMX XNUMX, b=B=XNUMX, et la taille des mots w=W est définie localement (c'est-à-dire XNUMX
octets dans une machine 32 bits).

Lorsque vous opérez sur 2 opérandes de taille ayant des suffixes différents, le suffixe de
le « inférieur » des deux sera le suffixe résultant. Par exemple,
10 Mo + 10 Go = 10250 XNUMX Mo
Exemples de constantes : -1b, 2w, 1kb, 2mw, +3gb, 4tw, 6Pb

Catégorie Int

format : (valeur Int faible, valeur Int élevée)
où valeur Int faible <= valeur Int élevée. Constante d'échantillon : (1,3)

Catégorie flotteur

format : (valeur Float faible, valeur Float élevée)
où valeur faible <= valeur élevée. Constante d'échantillon : (2.3, 4.6)

Catégorie Jour de la semaine

format : (plus tôt, plus tard)
où le jour le plus tôt <= le jour le plus tard. Constante d'échantillon : (MER, VEN)

Catégorie DateTime

format : (date/heure antérieure, date/heure ultérieure)
où date/heure antérieure <= date/heure ultérieure.
REMARQUE : si la plage contient uniquement des portions de temps et que l'heure antérieure "apparaît"
être > plus tard comme dans "((18:0:0), (6:0:0))", puis pendant la date/heure
comparaisons, l'heure "plus tard" sera ajustée d'un jour afin qu'elle soit
ressembler: "( ( @18:0:0), ( @6:0:0) )"

Exemples de constantes :
((4|4|1997), (4|10|1997)), ((12:01:00), (12:30:00)), ((4|4|1997@12:01:00),
(4|10|1997@12:30:00))

Catégorie Taille

format : (taille basse, taille haute)
où taille basse <= taille haute. Exemples de constantes : (23 Go, 50 Go)

Server Mappe directement à l’objet serveur PBS. UN Server gère un ou plusieurs Que objets.
Constante d'échantillon : NOSERVER

CNode pour un nœud de calcul constitué d'une seule image du système d'exploitation, d'une mémoire partagée et d'un ensemble
de processeurs. CNode exécute 1 PBS MOM.
Constante d'échantillon : NOCNODE

Que Mappe directement à l’objet de file d’attente PBS. UN Que l'objet met en file d'attente un ou plusieurs Emploi
objets.
Constante d’échantillon : NOQUE

Emploi Mappé directement sur l'objet de travail PBS. UN Emploi l'objet porte certains attributs et
besoins en ressources.
Constante d'échantillon : NOJOB

Ensemble Server
liste des objets Serveur.
Exemple de constante : EMPTYSETSERVER

Ensemble CNode
liste des objets CNode.
Constante d'exemple : EMPTYSETCNODE

Ensemble Que liste des objets Que.
Constante d'échantillon : EMPTYSETQUE

Ensemble Emploi liste des objets Job.
Exemple de constante : EMPTYSETJOB

DÉFINI BASL CONSTANTES

Ce sont des constantes qui ne peuvent pas être utilisées pour nommer un identifiant (voir rubrique suivante). Ces
sont toujours en majuscules.

DONNEES TYPE DÉFINI BASL CONSTANTE
=================== =============================================
Jour de la semaine SOLEIL, LUN, MAR, ÉPOUSER, JEU, VEN, SAM

Int SUCCÈS, ÉCHOUER, FAUX VRAI SYNCHRONISATION, ASYNCRUN,
EFFACER, REDIFFUSION, PRISE, LIBÉRATION, SIGNAL,
MODIFIERATTR, MODIFIER, SERVEUR_ACTIVE,
SERVER_IDLE, SERVEUR_SCHED, SERVEUR_TERM,
SERVER_TERMDELAY, QTYPE_E, QTYPE_R,
SCHED_DISABLED, SCHED_ENABLED, TRANSIT,
EN QUEUE, DÉTENU, EN ATTENDANT, EN COURS D'EXÉCUTION, SORTIE,
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

Server AUCUN SERVEUR
Ensemble Server SERVEUR VIDESET

CNode NOCNODE
Ensemble CNode EMPTYSETCNODE

Que NOQUE
Ensemble Que VIDESETQUE

Emploi PAS DE TRAVAIL
Ensemble Emploi VIDESETJOB

Chaîne STRNULLE

IDENTIFICATEUR

Les identifiants (utilisés pour les noms de variables et les noms de fonctions) sont au format alphanumérique, avec
le caractère de soulignement spécial (_) autorisé. Actuellement, BASL ne peut gérer que les identifiants
avec une longueur allant jusqu'à 80 caractères. De plus, vous ne pouvez pas utiliser les noms de constantes définis par BASL pour
nommer un identifiant.

ÉTATS

In BASL(2), vous pouvez avoir une seule instruction terminée par un point-virgule ou un groupe de
instructions (appelées instruction composée ou bloc) délimitées par '{' et '}'. Le différent
Les types d'instructions qui peuvent apparaître dans un code BASL sont :

1. déclaration d'expression
Les instructions d'expression ont la forme suivante :

expr ;

De expr peut être:

a) Expressions arithmétiques

lexpr + expression (ajouter)
lexpr - expression (soustraire)
lexpr * expression (multiplier)
lexpr / expression (diviser)
lexpr % expression (module or reste)

REMARQUE : Addition, soustraction, multiplication, division et reste
ne sera autorisé que pour les types appropriés et si la gauche et la droite
les expressions sont de types cohérents. Le tableau ci-dessous illustre ce que
les types sont cohérents entre les différents opérateurs :

Pour + :

lexpr expression
============ ============
Int or flotteur Int or flotteur
Taille Taille
Chaîne Chaîne

Pour -, *, /:

lexpr expression
============ ============
Int or flotteur Int or flotteur
Taille Taille

Pour %:

lexpr expression
============ ============
Int or flotteur Int or flotteur

Voici quelques exemples d’expressions arithmétiques :
Int je1;
Int je2;
flotteur f1 ;
flotteur f2 ;
Taille taille1 ;
Taille taille2 ;
Chaîne str1 ;
Chaîne str2 ;

i1 + je2;
f1 - je2;
sz1 * sz2 * 2b;
sz1 / 1024b;

str1 = "Bâle" ;
str2 = " cool";

// le Abonnement is a un magnifique enchaînement
// opération résultant in le chaîne:
// "basl frais"
str1 + str2 ;

i1 % 10;

b) Expressions unaires

+expression // positif - multiplie by 1 an
// expression qui is
// of Int, Flotter, or
// Taille type

-expr // négatif - multiplie by -1 an
// expression qui is
// of Int, Flotter, or
// Taille type

!expr // ne sauraient - convertis a non nul expr
// Plus-value développement 0, ainsi que a
// zéro expr Plus-value développement 1
// De expr type must be
// of type Int or flotteur

Quelques exemples d'expressions unaires :
Int i;

+ 3;
-(je + 4);
!je;

c) Expressions logiques

lexpr EQ expression
lexpr NEQ expression
lexpr LT expression
lexpr LE expression
lexpr GT expression
lexpr GE expression
lexpr ET expression
lexpr OR expression

lexpr ainsi que expression doit avoir des types mutuellement cohérents, comme indiqué
dans le tableau suivant:

lterminal-expr expression-rterminal
============== ==============
Int or flotteur Int or flotteur
Jour de la semaine Jour de la semaine
DateTime DateTime
Chaîne Chaîne
Taille Taille
Server Server
Que Que
Emploi Emploi
CNode CNode
Ensemble Server Ensemble Server
Ensemble Que Ensemble Que
Ensemble Emploi Ensemble Emploi
Ensemble CNode Ensemble CNode

Pour ET, OR opérateurs, les lexpr, expression les types cohérents sont Int ou
Flotter.

Quelques exemples d'expressions logiques :

i1 EQ je2;
i1 NEQ f2 ;
dow1 LE dow2 ;
d1 LT d2;
str1 GT str2 ;
sz1 GE taille2 ;

d) Expressions post-opérateur
Ce sont des expressions qui ne sont que des raccourcis vers l'affectation
Déclarations.

IDENTIFIANT++; // identifiant=identifiant+1
IDENTIFIANT-- ; // identifiant=identifiant-1

IDENTIFICATEUR doit être de type Int ou Float.

Mise en situation :
Int i;
flotteur f;

i ++;
F--;

e) Appel de fonction

nom-fonction ( argument1 ,arg2 , argN )

De argument1, ..., argN peut être n’importe quelle constante ou variable. Tu ne peux pas avoir
un autre appel de fonction comme argument.
Mise en situation :
vide imprimer a) {
imprimer(a);
}

pr(5);

Il existe certaines fonctions prédéfinies qu'un planificateur peut
appelle automatiquement son code BASL sans avoir besoin de le définir.
Ces fonctions sont appelées fonctions d'assistance (ou fonctions d'assistance).
fonctions) et ils sont discutés sous PRÉDÉFINI FONCTIONS sujet.

f) Constantes
Certaines expressions constantes valides sont données dans ce qui suit :
5;
+ 1.2;
SOLEIL;
LUN;
MAR;
ÉPOUSER;
JEU;
VEN;
ASSIS;
(4|4|1997) ;
(12:01:00) ;
(4|4|1997@12:01:00);
"merveilleux";
-1b ;
SYNCHRONISATION ;
ASYNCRUN ;
SUPPRIMER;
REDIFFUSION;
PRISE;
LIBÉRER;
SIGNAL;
MODIFIERATTR ;
MODIFIER;
(1, 3);
(2.3, 4.6);
(MER, VEN);
((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 Go, 50 Go) ;
NOSERVEUR ;
NOCNODE ;
NOQUE;
PAS DE TRAVAIL;
SERVEUR EMPTYSET ;
EMPTYSETCNODE ;
VIDESETQUE ;
VIDESETJOB ;
STRNULLE ;
SUCCÈS;
ÉCHOUER;
SERVEUR_ACTIVE ;
SERVEUR_IDLE ;
SERVEUR_SCHED ;
SERVEUR_TERM ;
SERVER_TERMDELAY ;
QTYPE_E ;
QTYPE_R ;
SCHED_DISABLED ;
SCHED_ENABLED ;
FAUX;
VRAI
TRANSIT;
EN QUEUE ;
DÉTENU;
EN ATTENDANT;
EN COURS D'EXÉCUTION;
SORTIE ;
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) Identifiant

Mise en situation :
Int je;

i;

2. Déclaration de cession

IDENTIFICATEUR = expr ;

IDENTIFICATEUR ainsi que expr doit avoir des types mutuellement cohérents comme
illustré dans le tableau suivant :

identifiant expr
=============== ===============
Int Int, flotteur
flotteur Int, flotteur
Jour de la semaine Jour de la semaine
DateTime DateTime
Chaîne Chaîne
Taille Taille
Que Que
Emploi Emploi
CNode CNode
Server Server
Jour de la semaine Jour de la semaine
DateTime DateTime
Ensemble Server Ensemble Server
Ensemble Que Ensemble Que
Ensemble Emploi Ensemble Emploi
Ensemble CNode Ensemble CNode
Catégorie Int Catégorie Int
Catégorie flotteur Catégorie flotteur
Catégorie Jour de la semaine Catégorie Jour de la semaine
Catégorie DateTime Catégorie DateTime
Catégorie Taille Catégorie Taille

3. sinon déclaration
Le format d'une instruction if est similaire à celui du C avec la délimitation
"{" et "}" toujours présents :

si ( expr ) {
zéro or PLUS (Vrai) ÉTATS
}

si ( expr ) {
zéro or PLUS (Vrai) ÉTATS
} d'autre {
zéro or PLUS (faux) ÉTATS
}

La expr 's le type doit être soit Int, soit Float, et après évaluation s'il est
la valeur est différente de zéro, alors les vraies instructions sont exécutées. Au deuxième
formulaire, si le expr est évalué à zéro, puis les fausses déclarations sont exécutées.

Un échantillon if les déclarations sont données ci-dessous :

if (2 * x )
{
y = y + 3;
imprimer(y);
}

if (2 * x ) {
y = y + 3;
} d'autre {
si ( 3 * x ) {
y = 4;
} d'autre {
y = 5;
}
}

4. en boucle déclaration
Le format d'une instruction for est le suivant :

pour ( début; tester; action ) {
zéro or PLUS ÉTATS
}

Comme en C, en exécute d'abord Commencer , puis évalue le tester condition
pour voir s'il renvoie une valeur non nulle. Si c'est le cas, le en les déclarations sont
réalisé. Après le en les instructions sont exécutées, puis action est évalué,
puis il vérifie le tester conditionner à nouveau de la même manière que précédemment.
Commencer ainsi que action peut être une simple expression d'affectation ou un post-opérateur
expression. tester est une expression logique/relationnelle. Quelques échantillons pour
les déclarations sont données comme suit :

en (i = 0; i LT 3 ; i = i + 1)
{
imprimer(je);
}

en (i = 0; i LT 2 * x; je++)
{
if (x GT 3)
{
y = 99;
} d'autre
{
x = 73;
}
}

5. foreach boucle déclaration
Cette instruction est principalement utilisée pour récupérer successivement chaque élément de
a Définir le type de données : Définir le serveur, Définir le CNode, Définir le travail, Définir la file d'attente. La syntaxe est :

foreach ( IDENTIFIANT1 in IDENTIFIANT2 ) {
zéro or PLUS ÉTATS
}

où les paires de types suivantes pour les identifiants sont autorisées :

IDENTIFIANT1 IDENTIFIANT2
=========== ===========
Server Ensemble Server
Que Ensemble Que
Emploi Ensemble Emploi
CNode Ensemble CNode

Mise en situation :
Server s;
Que q;
Emploi j;
CNode c;

Ensemble Server SS;
Ensemble Que carré;
Ensemble Emploi sj;
Ensemble CNode sc;

pour chaque(s) in ss){
impression(s);
}
pour chaque (q in carré){
imprimer(q);
}
pour chaque (j in js){
imprimer(j);
}
pour chaque (c in sc){
imprimer(c);
}

6. tout en boucle déclaration
La syntaxe d'une boucle while est la suivante :

tout en ( expr ) {
zéro or PLUS ÉTATS
}

De expr doit être de type Int ou Float. Si expr est non nul, alors le zéro
ou plus ÉTATS sont exécutés et expr est réévalué.

Mise en situation :
Int i;
i = 3;
alors que je) {
si ( i EQ 0 ) {
print("pause on i = 1");
break;
}
je--;
}

7. interrupteur déclaration
L'instruction switch est une décision à plusieurs voies qui teste si un
la valeur de l'identifiant correspond à l'une d'un certain nombre de valeurs et se branche vers un
groupe d’instructions en conséquence.
La syntaxe d'une instruction switch est la suivante :

commutateur ( IDENTIFICATEUR ) {
maisons expression constante :
{
zéro or PLUS ÉTATS
}
maisons expression constante :
{
zéro or PLUS ÉTATS
}

maisons in plage-constanteOuEnsemble-expr :
{
zéro or PLUS ÉTATS
}
maisons in IDENTIFIER-rangeOrSettype :
{
zéro or PLUS ÉTATS
}
défaut :
{
zéro or PLUS ÉTATS
}
}

De expression constante est un expr de type Int, Float, Dayofweek, DateTime,
Taille, Chaîne, Serveur, Que, Travail ou CNode. plage-constanteOuEnsemble-expr ainsi que
IDENTIFIER-rangeOrSettype peut être de type Set Server, Set CNode, Set Que, Set
Travail, Range Int, Range Float, Range Dayofweek, Range DateTime ou Range Size.

IDENTIFICATEUR ne peut pas être de type Void. IDENTIFICATEUR 's le type doit être cohérent
avec expression constante « S, plage-constanteOuEnsemble-expr « S, ainsi que IDENTIFIANT-
plageOuEnsembletype 's tapez comme illustré dans le tableau suivant :
IDENTIFICATEUR expression à plage constante, IDENTIFIER-rangetype
=========== =========================================
Server Ensemble Server
Que Ensemble Que
Emploi Ensemble Emploi
CNode Ensemble CNode
Int Catégorie Int
flotteur Catégorie flotteur
Jour de la semaine Catégorie Jour de la semaine
DateTime Catégorie DateTime
Taille Catégorie Taille

Si une expression de cas correspond à la IDENTIFICATEUR 's valeur, alors la valeur correspondante
un bloc d'instructions est exécuté. Contrairement à C, l'exécution ne tombe PAS
jusqu'à l'énoncé de cas suivant. La raison en est que basl2c sera
traduis cela interrupteur déclaration dans la construction if-elseif-else. L'affaire
La valeur par défaut étiquetée est exécutée si aucun des autres cas n'est satisfait. Le
défaut est facultatif ; si ce n'est pas là, et si aucun des cas ne correspond, non
l’action a lieu.

Mise en situation :
Jour de la semaine dow;

interrupteur (bas)
{
maisons MON:
{
print("cas LUN");
}
maisons MAR:
{
print("cas MAR");
}
maisons ÉPOUSER:
{
print("cas ÉPOUSER");
}
maisons JEU:
{
print("cas JEU");
}
maisons VEN:
{
print("cas VEN");
}
maisons SAM:
{
print("cas ASSIS");
}
maisons SOLEIL:
{
print("cas SOLEIL");
}
par défaut:
{
print("cas par défaut");
}
}

Int a;
Catégorie Int ri;
ri = (10, 12);
interrupteur(a)
{
maisons in (1,5):
{
print("cas 1,5");
}
maisons in (6,9):
{
print("cas 6,9");
}
maisons in ri :
{
print("cas ri");
}
}

8. impression déclaration
L'instruction d'impression est capable d'imprimer sur sortie standard la valeur de n'importe quel identifiant
or constant de type Int, Float, Dayofweek, DateTime, String, Size, Que, Job,
CNode, serveur, Range Int, Range Float, Range Dayofweek, Range DateTime,
Taille de la plage.
La syntaxe est la suivante:

impression ( IDENTIFICATEUR );
impression ( constant );

Mise en situation :
DateTime dt;
CNode CN ;

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

imprimer(dt);
imprimer(cn);

Pour les types d'ensemble, utilisez foreach pour parcourir chaque élément et imprimer comme dans :

Server s;
Ensemble Server SS;

ss = AllServersGet();

pour chaque(s) in ss) {
impression(s);
}

9. Continuer la déclaration

continuer ;

La continuer la déclaration doit avoir été invoquée dans un pour, pour chaque, ainsi que
tout en boucle. Cela provoque le début de l’itération suivante de la boucle englobante.

10. déclaration de rupture

pause ;

La pause la déclaration doit avoir été invoquée dans un pour, pour chaque, ainsi que tout en
boucle. Il permet une sortie anticipée de la boucle englobante.

11. déclaration de retour

retour(IDENTIFIANT) ;
retour (constant) ;
revenir() ;

L'instruction return fournit la valeur (le cas échéant) qui doit être renvoyée par un
fonction. Le type renvoyé par IDENTIFICATEUR ainsi que constant doit correspondre au
type de retour de la fonction appelante. constant les types autorisés sont tout sauf
Types d’ensemble et de plage. Le dernier format, revenir() est généralement appelé dans un
fonction qui ne renvoie aucune valeur (comme sched_main() ).

12. déclaration de sortie

sortie (constante);

De constant est de type Int. L’appel de ceci mettra fin au planificateur.

13. Déclaration de commentaires
Ce sont des instructions préfixées par "//" et elles sont ignorées par le BASL
compilateur.

// this en ligne is ignoré
Int i; // un magnifique Abonnement le slash is ignoré

OPÉRATEUR PRIORITÉ ET ASSOCIATIVITÉ

Le tableau suivant présente les différents niveaux de priorité des opérateurs et l'associativité définis
en langage BASL. Les opérateurs sont classés par ordre de priorité décroissante. Le
plus la priorité d'un opérateur est élevée, plus il est exécuté tôt. L'ordre dans lequel le
les opérateurs du même niveau sont exécutés en fonction de l'associativité : gauche signifie le
les opérateurs sont vus de gauche à droite, tandis que droite signifie qu'ils sont vus de droite à gauche.

Opérateur Associativité
======================================= =============
! ++ -- + (unaire plus) - (unaire moins) bon
* / % à gauche
+ - à gauche
LT LE GT GE à gauche
EQ NEQ à gauche
ET à gauche
OR à gauche
= bon

PRÉDÉFINI FONCTIONS

In BASL(2), un Server Le type de données est directement mappé à un objet de serveur batch. De la même manière, CNode
c'est à maman/resmom, Emploi est un travail par lots, et Que est de mettre en file d'attente par lots. Cependant, tous ne
les attributs des objets PBS sont accessibles depuis BASL. Seulement un sous-ensemble d'attributs,
ceux qui semblaient avoir du sens dans le contexte d'un ordonnanceur, sont mis à disposition, et
les valeurs de ces attributs sont accessibles en appelant les fonctions prédéfinies suivantes,
également connues sous le nom de fonctions d'assistance/d'assistance.

(1) Fonctions liées au serveur

Ensemble Server AllServersGet (vide)
Renvoie la liste des serveurs spécifiés dans le fichier de configuration pour
que le planificateur souhaite que le système vérifie périodiquement
statut, files d'attente et informations sur les tâches. Voir pbs__sched__basl(8B) pour
discussion sur le format du fichier de configuration.
ATTENTION : Cette fonction doit être appelée de l'intérieur sched_main() so
qu'à chaque itération de planification, le plus à jour Ensemble Server
la structure est renvoyée.

Server AllServersLocalHostGet (vide)
Renvoie l'objet Server qui représente l'hôte local. valeur non définie :
NOSERVEUR. Il s'agit d'une fonction simple à appeler pour des environnements non-cluster
où un seul hôte de serveur existe.
ATTENTION : Cette fonction doit être appelée de l'intérieur sched_main() (ou de
dans la fonction appelée par sched_main) afin qu'à chaque planification
itération, la plus à jour Server la structure est renvoyée.

Chaîne ServeurInetAddrGet(Serveur s)
Renvoie le nom des Server s. valeur non définie : NULLSTR

Chaîne ServeurDefQueGet(Serveur s)
Renvoie l'attribut default_queue des Server s. valeur non définie : NULLSTR

Int ServerStateGet(Serveur s)
Renvoie l'attribut server_state des Server s.

Valeur de retour:
SERVER_ACTIVE, SERVER_IDLE, SERVER_SCHED, SERVER_TERM,
SERVER_TERMDELAY, -1 (valeur non définie)

Int ServerMaxRunJobsGet(Serveur s)
Renvoie l'attribut max_running des Server s. valeur non définie : 0

Int ServerMaxRunJobsPerUserGet(Serveur s)
Renvoie l'attribut max_user_run des Server s. valeur non définie : 0

Int ServerMaxRunJobsPerGroupGet(Serveur s)
Renvoie l'attribut max_group_run des Server s. valeur non définie : 0

Ensemble Que ServerQueuesGet(Serveur s)
Renvoie la liste des files d'attente gérées par Server s.

Ensemble Emploi ServerJobsGet(Serveur s)
Renvoie la liste des tâches gérées par Server s. Pour obtenir un sous-ensemble de ceci
liste, voir QueJobsGet().

Int ServerIntResAvailGet(Serveur s, Chaîne prénom)
Renvoie la valeur à la ressource spécifiée dans prénom qui est disponible pour les emplois
exécuté par ce serveur (Serveur ressources_disponibles.nom attribut). Appelle ça
fonction pour les ressources avec des valeurs de type Int. Exemple de ressource
les noms sont : cput, pcput, walltime, mppt, pmppt, nice, procs, mppe, npcus,
pncpus, nodect, srfs_assist, mta,..., mois. Pour une description de ceux-ci
noms de ressources, voir 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(7B).

Mise en situation :
Int cpuDisponible ;
// retourner le # of cpus actuellement, en ce moment disponibles in
// le serveur
CPUDisponible = ServerIntResAvailGet(serveur, "ncpus");

Taille ServerSizeResAvailGet(Serveur s, Chaîne prénom)
Renvoie la valeur à la ressource spécifiée dans prénom qui est disponible pour les emplois
exécuté par ce serveur (Serveur ressources_disponibles.nom attribut). Appelle ça
fonction pour les ressources avec des valeurs de type Size. Exemple de ressource
les noms sont : file, mem, pmem, workingset, pf, ppf, srfs_tmp, srfs_wrk,
srfs_big, srfs_fast, sds, psds. Pour une description de ces ressources
noms, voir 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(7B).

Mise en situation :
Taille memDisponible ;
// retourner le montant of disponibles Mémoire in
// le serveur
mémoireDisponible = ServerSizeResAvailGet(serveur, "mémoire");

Chaîne ServerStringResAvailGet(Serveur s, Chaîne prénom)
Renvoie la valeur à la ressource spécifiée dans prénom qui est disponible pour les emplois
exécuté par ce serveur (Serveur ressources_disponibles.nom attribut). Appelle ça
fonction pour les ressources avec des valeurs de type String. Échantillon
les noms des ressources sont : nodes, arch, neednodes. Pour une description de ceux-ci
noms de ressources, voir 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(7B).

Mise en situation :
Chaîne taper;
// retourner le architecture (ou os Type d') of
// le serveur
type = ServerStringResAvailGet(serveur, "cambre");

Int ServerIntResAssignGet(Serveur s, Chaîne prénom)
Renvoie la valeur à la ressource spécifiée dans prénom qui est attribué à
travaux en cours d'exécution (serveur ressources_assigned.name attribut). Appelle ça
fonction pour les ressources avec des valeurs de type Int. Exemple de ressource
les noms sont : cput, pcput, walltime, mppt, pmppt, nice, procs, mppe, npcus,
pncpus, nodect, srfs_assist, mta,..., mois. Pour une description de ceux-ci
noms de ressources, voir 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(7B).

Mise en situation :
Int cpuAssn;
// retourner le # of cpus actuellement, en ce moment attribué in
// le serveur
cpuAssn = ServerIntResAssignGet(serveur, "ncpus");

Taille ServerSizeResAssignGet(Serveur s, Chaîne prénom)
Renvoie la valeur à la ressource spécifiée dans prénom qui est attribué à
travaux en cours d'exécution (serveur ressources_assigned.name attribut). Appelle ça
fonction pour les ressources avec des valeurs de type Size. Exemple de ressource
les noms sont : file, mem, pmem, workingset, pf, ppf, srfs_tmp, srfs_wrk,
srfs_big, srfs_fast, sds, psds. Pour une description de ces ressources
noms, voir 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(7B).

Mise en situation :
Taille sdsAssn ;
// retourner le montant of sds espace actuellement, en ce moment attribué
// in le serveur
sdsAssn = ServerSizeResAssignGet(serveur, "sds");

Chaîne ServerStringResAssignGet(Serveur s, Chaîne prénom)
Renvoie la valeur à la ressource spécifiée dans prénom qui est attribué à
travaux en cours d'exécution (serveur ressources_assigned.name attribut). Appelle ça
fonction pour les ressources avec des valeurs de type String. Échantillon
les noms des ressources sont : nodes, arch, neednodes. Pour une description de ceux-ci
noms de ressources, voir 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(7B).

Ensemble CNode ServerNodesGet(Serveur s)
Renvoie l'ensemble des nœuds gérés par les serveurs. valeur non définie : EMPTYSETCNODE.
REMARQUE : Vous pouvez généralement appeler les fonctions suivantes pour les nœuds renvoyés
par cet appel : CNodeStateGet(), CNodePropertiesGet() et CNodeTypeGet().

Int ServerNodesQuery(Serveur s, Chaîne spec)
Émet une requête au serveur spécifié pour interroger la disponibilité de
ressources spécifiées dans spec. À l'heure actuelle, la seule ressource
la spécification autorisée est celle qui implique des « nœuds » et elle peut être du type
formater "nodes", "nodes=" ou "nodes= ". Les résultats de la requête peuvent être
accessible en appelant les fonctions suivantes : ServerNodesNumAvailGet(),
ServerNodesNumAllocGet(), ServerNodesNumRsvdGet(),
ServerNodesNumDownGet().
REMARQUE : Il s'agit d'un emballage pour le pbs_rescquery(3B) fonction serveur.

Valeur de retour:
SUCCÈS, ÉCHEC

Int ServerNodesNumAvailGet(Serveur s)
Renvoie le nombre de nœuds disponibles pour ceux gérés par le spécifié
serveur, ou comme reflété par la requête la plus récente spécifiée par
ServerNodesQuery(). Si la valeur de retour est zéro, cela signifie que
un certain nombre de nœuds actuellement nécessaires pour satisfaire la spécification de
ServerNodesQuery() sont actuellement indisponibles. La demande peut être satisfaite
à un moment ultérieur. Si le résultat est négatif, aucune combinaison de facteurs connus
les nœuds peuvent satisfaire à la spécification.

Int ServerNodesNumAllocGet(Serveur s)
Renvoie le nombre de nœuds alloués pour ceux gérés par le spécifié
serveur, ou comme reflété par la requête la plus récente spécifiée par
ServerNodesQuery().

Int ServerNodesNumRsvdGet(Serveur s)
Renvoie le nombre de nœuds réservés à ceux gérés par le spécifié
serveur, ou comme reflété par la requête la plus récente spécifiée par
ServerNodesQuery().

Int ServerNodesNumDownGet(Serveur s)
Renvoie le nombre de nœuds en panne pour ceux gérés par le spécifié
serveur, ou comme reflété par la requête la plus récente spécifiée par
ServerNodesQuery().

Int ServerNodesReserve(Serveur s,Chaîne spécification, Int résId)
Émet une demande au serveur spécifié pour réserver les ressources
spécifié dans spec. Une valeur de 0 pour résId signifie que c'est pour faire un
nouvelle réservation. Sinon, le numéro représentera un existant
réservation (partielle). Ressources actuellement réservées à cet effet résId sera
sera libéré et la réservation complète sera à nouveau tentée. Au
à l'heure actuelle, les seules ressources qui peuvent être spécifiées sont
"nœuds". Il convient de préciser comme nœuds = spécification De
la spécification est ce qu'un utilisateur spécifie dans la liste d'arguments de l'option -l
pour les nœuds, voir qsub (1B).
REMARQUE : Il s'agit d'un emballage pour le pbs_rescreserve(3B) fonction serveur.

Valeur de retour:
un numéro de référence à un projet réussi ou partiellement réussi
réservation, ou ÉCHEC

Int ServerNodesRelease(Serveur s, Int résId)
Cela libère ou libère les ressources réservées avec le numéro de référence
spécifié dans résId.
REMARQUE : Il s'agit d'un emballage pour le pbs_rescrelease(3B) fonction serveur.

Valeur de retour:
SUCCÈS ou ÉCHEC

(2) Fonctions liées à Que :

Chaîne QueNameGet( Que Quoi )
Renvoie le nom de Que que. valeur non définie : NULLSTR

Int QueTypeGet( Que Quoi )
Renvoie l'attribut queue_type de Que que.
Valeur de retour : QTYPE_E (Exécution), QTYPE_R (Routage), -1 (non défini
valeur)

Int QueNumJobsGet( Que Quoi )
Renvoie le nombre d'emplois résidant dans Que que. valeur non définie : 0

Int QueMaxRunJobsGet( Que Quoi )
Renvoie l'attribut max_running de Que que. valeur non définie : 0

Int QueMaxRunJobsPerUserGet( Que Quoi )
Renvoie l'attribut max_user_run de Que que. valeur non définie : 0

Int QueMaxRunJobsPerGroupGet( Que Quoi )
Renvoie l'attribut max_group_run de Que que. valeur non définie : 0

Int QuePriorityGet( Que Quoi )
Renvoie l'attribut Priorité de Que que. valeur non définie : 0

Int QueStateGet( Que Quoi )
Renvoie l'attribut démarré de Que que - la sélection d'exécution du travail
état de la que : SCHED_DISABLED, SCHED_ENABLED. valeur non définie :
SCHED_DISABLED

Ensemble Emploi QueJobsGet( Que Quoi )
Renvoie la liste des emplois résidant actuellement dans que.

Int QueIntResAvailGet(Que q, Chaîne prénom)
Renvoie la valeur à la ressource spécifiée dans prénom qui est disponible pour
travaux exécutés à partir de ce q (Que ressources_disponibles.nom attribut).
Appelez cette fonction pour les ressources avec des valeurs de type Int.
Des exemples de noms de ressources sont : cput, pcput, walltime, mppt, pmppt, nice,
procs, mppe, ncpus, pncpus, nodect, srfs_assist, mta,..., mth. Pour un
description de ces noms de ressources, voir 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(7B).

Taille QueSizeResAvailGet(Que q, Chaîne prénom)
Renvoie la valeur à la ressource spécifiée dans prénom qui est disponible pour
travaux exécutés à partir de ce q (Que ressources_disponibles.nom attribut).
Appelez cette fonction pour les ressources dont les valeurs sont de type Size.
Des exemples de noms de ressources sont : file, mem, pmem, workingset, pf, ppf,
srfs_tmp, srfs_wrk, srfs_big, srfs_fast, sds, psds. Pour un descriptif
de ces noms de ressources, voir 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(7B).

Chaîne QueStringResAvailGet(Que q, Chaîne prénom)
Renvoie la valeur à la ressource spécifiée dans prénom qui est disponible pour
travaux exécutés à partir de ce q (Que ressources_disponibles.nom attribut).
Appelez cette fonction pour les ressources dont les valeurs sont de type String.
Des exemples de noms de ressources sont : nodes, arch, neednodes. Pour un descriptif
de ces noms de ressources, voir 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(7B).

Int QueIntResAssignGet(Que q, Chaîne prénom)
Renvoie la valeur à la ressource spécifiée dans prénom qui est attribué à
travaux exécutés à partir de cette file d'attente (Que ressources_assigned.name attribut).
Appelez cette fonction pour les ressources avec des valeurs de type Int.
Des exemples de noms de ressources sont : cput, pcput, walltime, mppt, pmppt, nice,
procs, mppe, ncpus, pncpus, nodect, srfs_assist, mta,..., mth. Pour un
description de ces noms de ressources, voir 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(7B).

Taille QueSizeResAssignGet(Que q, Chaîne prénom)
Renvoie la valeur à la ressource spécifiée dans prénom qui est attribué à
travaux exécutés à partir de ce q (Que ressources_assigned.name attribut).
Appelez cette fonction pour les ressources dont les valeurs sont de type Size.
Des exemples de noms de ressources sont : file, mem, pmem, workingset, pf, ppf,
srfs_tmp, srfs_wrk, srfs_big, srfs_fast, sds, psds. Pour un descriptif
de ces noms de ressources, voir 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(7B).

Chaîne QueStringResAssignGet(Que q, Chaîne prénom)
Renvoie la valeur à la ressource spécifiée dans prénom qui est attribué à
travaux exécutés à partir de ce q (Que ressources_assigned.name attribut).
Appelez cette fonction pour les ressources dont les valeurs sont de type String.
Des exemples de noms de ressources sont : nodes, arch, neednodes. Pour un descriptif
de ces noms de ressources, voir 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(7B).

(3) Fonctions liées à l'emploi

Chaîne JobIdGet( Emploi JOB )
Renvoie l'identifiant du travail. valeur non définie : NULLSTR

Chaîne NomTravailObtenir( Emploi JOB )
Renvoie l'attribut Job_Name du travail. valeur non définie : NULLSTR

Chaîne NomPropriétaireJobObtenir( Emploi JOB )
Renvoie l'attribut Job_Owner du travail Job. valeur non définie : NULLSTR

Chaîne JobEffectiveUserNameGet( Emploi emploi)
Renvoie l'attribut euser du travail Job.

Chaîne JobEffectiveGroupNameGet(Job emploi)
Renvoie l'attribut egroup du travail. valeur non définie : NULLSTR

Int JobStateGet ( Emploi JOB )
Renvoie l'attribut job_state du travail Job.

Valeur de retour:
TRANSIT, EN QUEUE, EN ATTENTE, EN ATTENTE, EN COURS, EN SORTIE, -1 (non défini
valeur)

Int JobPriorityGet( Emploi JOB )
Renvoie l'attribut Priorité du travail. valeur non définie : 0

Int JobRerunFlagGet( Emploi JOB )
Renvoie l'attribut réexécutable du travail.
Valeur de retour : FALSE, TRUE, -1 (valeur non définie)

Int JobInteractiveFlagGet( Emploi JOB )
Renvoie l'attribut interactif du travail Job.
Valeur de retour : FAUX, VRAI. valeur non définie : FAUX

DateTime JobDateTimeCreatedGet(Job emploi)
Renvoie l'attribut ctime du travail Job. valeur non définie :
(0|0|0@-1:-1:-1)

Chaîne JobEmailAddrGet( Emploi JOB )
Renvoie l'attribut Mail_Users du travail. valeur non définie : NULLSTR

Chaîne JobStageinFilesGet( Emploi JOB )
Renvoie l'attribut stagein du travail Job. valeur non définie : NULLSTR

Chaîne JobStageoutFilesGet( Emploi JOB )
Renvoie l'attribut stageout du travail. valeur non définie : NULLSTR

Int JobIntResReqGet(Travail emploi, Chaîne prénom)
Renvoie la valeur à la ressource spécifiée dans prénom comme l'exige le
travail (Travail Resource_List.name attribut). Appelez cette fonction pour
ressources avec des valeurs de type Int. Exemples de noms de ressources
sont : cput, pcput, walltime, mppt, pmppt, nice, procs, mppe, npcus,
pncpus, nodect, srfs_assist, mta,..., mois. Pour une description de ceux-ci
noms de ressources, voir 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(7B).

Mise en situation :
Int cputReq;
// Retours le cput exigence of le JOB
cputReq = JobIntResReqGet(travail, "cput");

Taille JobSizeResReqGet(Travail emploi, Chaîne prénom)
Renvoie la valeur à la ressource spécifiée dans prénom comme l'exige le
travail (Travail Resource_List.name attribut). Appelez cette fonction pour
ressources avec des valeurs de type Taille. Exemples de noms de ressources
sont : fichier, mem, pmem, workingset, pf, ppf, srfs_tmp, srfs_wrk,
srfs_big, srfs_fast, sds, psds. Pour une description de ces ressources
noms, voir 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(7B).

Mise en situation :
Taille memReq;
// Retours le Mémoire exigence of le JOB
memReq = JobSizeResReqGet(travail, "mémoire");

Chaîne JobStringResReqGet(Travail emploi, Chaîne prénom)
Renvoie la valeur à la ressource spécifiée dans prénom comme l'exige le
travail (Travail Resource_List.name attribut). Appelez cette fonction pour
ressources avec des valeurs de type String. Exemples de noms de ressources
sont : nœuds, arc, nœuds nécessaires. Pour une description de ces ressources
noms, voir 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(7B).

Mise en situation :
Chaîne nœuds ;
// Retours le nœuds exigence propriété of
// le JOB
nœuds = JobStringResReqGet(travail, "nœuds");

Int JobIntResUseGet(Job emploi, Chaîne prénom)
Renvoie la valeur à la ressource spécifiée dans prénom utilisé par le travail (Job
ressources_utilisées.nom attribut). Appelez cette fonction pour les ressources avec
valeurs qui sont de type Int. Des exemples de noms de ressources sont : cput, pcput,
walltime, mppt, pmppt, nice, procs, mppe, ncpus, pncpus, nodect,
srfs_assist, mta,..., mois. Pour une description de ces noms de ressources,
sur le lien 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(7B).

Mise en situation :
Int walltUtilisation ;
// Retours le montant of temps mural d'utiliser by
// le JOB
walltUtilisation = JobIntResUseGet(travail, "temps mural");

Taille JobSizeResUseGet(Job emploi, Chaîne prénom)
Renvoie la valeur à la ressource spécifiée dans prénom utilisé par le travail (Job
ressources_utilisées.nom attribut). Appelez cette fonction pour les ressources avec
valeurs qui sont de type Taille. Des exemples de noms de ressources sont : file, mem,
pmem, ensemble de travail, pf, ppf, srfs_tmp, srfs_wrk, srfs_big, srfs_fast,
sds, psds. Pour une description de ces noms de ressources, voir
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(7B).

Mise en situation :
Taille srfsUtilisation ;
// Retours le montant of srfs_fast d'utiliser by
// le JOB
srfsUtilisation = JobSizeResUseGet(travail, "srfs_fast");

Chaîne JobStringResUseGet(Job emploi, Chaîne prénom)
Renvoie la valeur à la ressource spécifiée dans prénom utilisé par le travail (Job
ressources_utilisées.nom attribut). Appelez cette fonction pour les ressources avec
valeurs de type String. Des exemples de noms de ressources sont : nœuds,
arc, nœuds nécessaires. Pour une description de ces noms de ressources, voir
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(7B).

(4) Fonctions liées à CNode

Ensemble CNode AllNodesGet (vide)
Renvoie la liste des nœuds gérés par le serveur exécuté sur le
hôte local. Cela pourrait également inclure les nœuds spécifiés
dans le fichier de configuration du planificateur pour lequel le rédacteur du planificateur
souhaite que le système vérifie périodiquement des informations telles que l'état,
propriété, et ainsi de suite. Voir pbs_sched_basl(8B) pour une discussion sur
format du fichier de configuration.
ATTENTION : Cette fonction doit être appelée de l'intérieur sched_main() so
qu'à chaque itération de planification, le plus à jour Ensemble CNode
la structure est renvoyée. N'appelez pas cela à partir d'une instruction d'affectation
destiné à initialiser une variable globale, car l'instruction ne fera que
être appelé une fois.

CNode AllNodesLocalHostGet (vide)
Renvoie l'objet CNode qui représente l'hôte local. C'est un
fonction simple pour appeler des systèmes non clusterisés où seulement 1 CNode
existe. valeur non définie : NOCNODE
ATTENTION : Cette fonction doit être appelée de l'intérieur sched_main() (ou
depuis les fonctions appelées par sched_main) afin qu'à chaque
itération de planification, la plus à jour CNode la structure est
revenu. N'appelez pas ceci à partir d'une instruction d'affectation destinée à
initialiser une variable globale, car l'instruction ne sera appelée que
une fois que.

Chaîne CNodeNameGet(CNode nœud)
Renvoie le nom unique (officiel) du nœud (c'est-à-dire le nom d'hôte ResMom
dans un modèle 1 mère/nœud). Cela renvoie la même chaîne qui était
spécifié dans le fichier de configuration. valeur non définie : NULLSTR

Chaîne CNodeOsGet(CNode nœud)
Renvoie l'architecture du système d'exploitation du nœud (c'est-à-dire "irix5", "sp2"). désarmé
valeur : NULLSTR

Int CNodeStateGet( CNode nœud )
Renvoie l'état du nœud.

Valeur de retour:
CNODE_OFFLINE, CNODE_DOWN, CNODE_FREE, CNODE_RESERVE,
CNODE_INUSE_EXCLUSIVE, CNODE_INUSE_SHARED, CNODE_UNKNOWN

Int CNodeTypeGet( CNode nœud )
Renvoie le type du nœud.

Valeur de retour:
CNODE_TIMESHARED, CNODE_CLUSTER, CNODE_UNKNOWN

Chaîne CNodePropertiesGet(CNode nœud)
Renvoie la liste séparée par des virgules des autres noms sous lesquels le nœud est connu
(propriétés, autre nom de réseau). Par exemple,
"babbage.OpenPBS.org" peut-être le nom du nœud, mais il pourrait aussi être connu
via "babbage1, babbage2". valeur non définie : NULLSTR

Chaîne CNodeVendorGet(CNode nœud)
Renvoie le nom du fournisseur du matériel de la machine (c'est-à-dire
"sgi", "ibm"). valeur non définie : NULLSTR

Int CNodeNumCpusGet(CNode nœud)
Renvoie le nombre de processeurs connectés au nœud. valeur non définie :
-1

Taille CNodeMemTotalGet( CNode nœud, Chaîne type )
Renvoie la mémoire totale de type pour le nœud. type est un arbitraire
chaîne que le rédacteur du planificateur définit dans le planificateur
fichier de configuration. valeur non définie : -1b
Mise en situation :
// obtenez la totalité de votre cycle de coaching doit être payée avant votre dernière session. Physique Mémoire
CNodeMemTotalGet(nœud, "réel")
// obtenez la totalité de votre cycle de coaching doit être payée avant votre dernière session. virtuel Mémoire
CNodeMemTotalGet(nœud, "virtuel")

Taille CNodeMemAvailGet( CNode nœud, Chaîne type )
Renvoie la mémoire disponible de type pour le nœud. type est un arbitraire
chaîne que le rédacteur du planificateur définit dans le planificateur
fichier de configuration. valeur non définie : -1b
Ainsi, des exemples d'appels seront :
// obtenez disponibles Physique Mémoire
CNodeMemAvailGet(nœud, "réel")
// obtenez disponibles virtuel Mémoire
CNodeMemAvailGet(nœud, "virtuel")

Int CNodeIdletimeGet( CNode nœud )
Renvoie le nombre de secondes pendant lesquelles aucune frappe ou mouvement de la souris n'a eu lieu.
a eu lieu sur n’importe quel terminal connecté au nœud. valeur non définie : -1

flotteur CNodeLoadAveGet( CNode nœud )
Renvoie la charge moyenne du nœud pour tous les processeurs. valeur non définie : -1.0

Int CNodeCpuPercentIdleGet( CNode nœud )
Renvoie le pourcentage de temps d'inactivité de tous les processeurs du nœud
ont connu.

Int CNodeCpuPercentSysGet( CNode nœud )
Renvoie le pourcentage de temps dont disposent tous les processeurs du nœud
passé à exécuter le code du noyau.

Int CNodeCpuPercentUserGet( CNode nœud )
Renvoie le pourcentage de temps dont disposent tous les processeurs du nœud
passé à exécuter du code utilisateur.

Int CNodeCpuPercentGuestGet( CNode nœud )
Renvoie le pourcentage de temps dont disposent tous les processeurs du nœud
passé à exécuter un système d’exploitation invité.

Int CNodeNetworkBwGet( CNode nœud, Chaîne type )
Renvoie la bande passante du réseau de type en octets/seconde.
type est défini par le rédacteur du planificateur dans le planificateur
fichier de configuration. valeur non définie : -1
Voici quelques exemples d'appels :
CNodeNetworkBwGet( nœud, "hippi" );
CNodeNetworkBwGet( nœud, "fddi" );

Taille CNodeDiskSpaceTotalGet(CNode nœud, Chaîne prénom)
Renvoie l'espace total du nœud sur le disque identifié par prénom De prénom
est le nom du périphérique défini arbitrairement par le planificateur dans le
fichier de configuration du planificateur. valeur non définie : -1b
Mise en situation :
CNodeDiskSpaceTotalGet( nœud, "/scratch2" );

Taille CNodeDiskSpaceAvailGet(CNode nœud, Chaîne prénom)
Renvoie l'espace disponible du nœud sur le disque identifié par prénom De
prénom est arbitrairement défini par le rédacteur du planificateur dans le planificateur
fichier de configuration. valeur non définie : -1b
Mise en situation :
CNodeDiskSpaceAvailGet( nœud, "/scratch1" );

Taille CNodeDiskSpaceReservedGet(CNode nœud, Chaîne prénom)
Renvoie l'espace réservé du nœud sur le disque (quota utilisateur ?) identifié par
prénom De prénom est arbitrairement défini par le planificateur dans le
fichier de configuration du planificateur. valeur non définie : -1b
Mise en situation :
CNodeDiskSpaceReservedGet( nœud, "/scratch1" );

Int CNodeDiskInBwGet( CNode nœud, Chaîne prénom )
Renvoie la bande passante d'écriture (octets/s) du disque du nœud identifié
by prénom . valeur non définie : -1
Mise en situation :
CNodeDiskInBwGet( nœud, "/rapide" );

Int CNodeDiskOutBwGet( CNode nœud, Chaîne prénom )
Renvoie la bande passante de lecture (octets/s) du disque du nœud identifié par
prénom . valeur non définie : -1
Mise en situation :
CNodeDiskOutBwGet( nœud, "/grand" );

Taille CNodeSwapSpaceTotalGet( CNode nœud, Chaîne prénom )
Renvoie l'espace total du nœud lors du swap identifié par prénom De prénom
est arbitrairement défini par le rédacteur du planificateur dans le planificateur
fichier de configuration. valeur non définie : -1b
Mise en situation :
CNodeSwapSpaceTotalGet( nœud, "primaire" );

Taille CNodeSwapSpaceAvailGet( CNode nœud, Chaîne prénom )
Renvoie l'espace disponible du nœud lors du swap identifié par prénom De prénom
est le nom du périphérique défini arbitrairement par le planificateur dans le
fichier de configuration du planificateur. valeur non définie : -1b
Mise en situation :
CNodeSwapSpaceAvailGet( nœud, "secondaire" );

Int CNodeSwapInBwGet( CNode nœud, Chaîne prénom )
Renvoie le taux de swapin du périphérique de swap du nœud identifié par nom.
Mise en situation :
CNodeSwapInBwGet(nœud, "secondaire");

Int CNodeSwapOutBwGet( CNode nœud, Chaîne prénom )
Renvoie le taux de swapout du périphérique de swap du nœud identifié par
nom. valeur non définie : -1
Mise en situation :
CNodeSwapOutBwGet(nœud, "primaire");

Taille CNodeTapeSpaceTotalGet( CNode nœud, Chaîne prénom )
Renvoie l'espace total du nœud sur la bande identifié par prénom De prénom
est arbitrairement défini par le rédacteur du planificateur dans le planificateur
fichier de configuration. valeur non définie : -1b
Mise en situation :
CNodeTapeSpaceTotalGet(nœud, "4mm");

Taille CNodeTapeSpaceAvailGet( CNode nœud, Chaîne prénom )
Renvoie l'espace disponible du nœud sur la bande identifié par prénom De
prénom est arbitrairement défini par le rédacteur du planificateur dans le planificateur
fichier de configuration. valeur non définie : -1b
Mise en situation :
CNodeTapeSpaceAvailGet(nœud, "8mm");

Int CNodeTapeInBwGet( CNode nœud, Chaîne prénom )
Renvoie la bande passante d'écriture (octets/s) de la bande du nœud identifié
by prénom . valeur non définie : -1
Mise en situation :
CNodeTapeInBwGet( nœud, "4mm" );

Int CNodeTapeOutBwGet( CNode nœud, Chaîne prénom )
Renvoie la bande passante de lecture (octets/s) de la bande du nœud identifié
by prénom . valeur non définie : -1
Mise en situation :
CNodeTapeOutBwGet( nœud, "8mm" );

Taille CNodeSrfsSpaceTotalGet( CNode nœud, Chaîne prénom )
Renvoie l'espace total du nœud sur le périphérique srfs identifié par prénom
De prénom est arbitrairement défini par le planificateur dans le
fichier de configuration du planificateur. valeur non définie : -1b
Mise en situation :
CNodeSrfsSpaceTotalGet(nœud, "/rapide");

Taille CNodeSrfsSpaceAvailGet( CNode nœud, Chaîne prénom )
Renvoie l'espace disponible du nœud sur le périphérique srfs identifié par prénom
De prénom est arbitrairement défini par le planificateur dans certains
fichier de configuration. valeur non définie : -1b
Mise en situation :
CNodeSrfsSpaceAvailGet( nœud, "/grand" );

Taille CNodeSrfsSpaceReservedGet(CNode nœud, Chaîne prénom)
Renvoie la quantité totale d'espace réservé du nœud sur le périphérique srfs
identifié par prénom De prénom est arbitrairement défini par le planificateur
écrivain dans le fichier de configuration du planificateur. valeur non définie : -1b
Mise en situation :
CNodeSrfsSpaceReservedGet( nœud, "/rapide" );

Int CNodeSrfsInBwGet( CNode nœud, Chaîne prénom )
Renvoie la bande passante d'écriture (octets/s) du périphérique srfs du nœud
identifié par prénom . valeur non définie : -1
Mise en situation :
CNodeSrfsInBwGet(nœud, "/fast" );

Int CNodeSrfsOutBwGet( CNode nœud, Chaîne prénom )
Renvoie la bande passante de lecture (octets/s) du périphérique srfs du nœud
identifié par prénom . valeur non définie : -1
Mise en situation :
CNodeSrfsOutBwGet(nœud, "/big" );

(5) Fonctions diverses

DateTime dateheureObtenir()
obtient la date/heure actuelle.

Int dateheureVersSecs(DateHeure dt)
renvoie le nombre de secondes depuis l'époque (début de l'heure UNIX -
00:00:00, 1er janvier 1970) pour la date/heure donnée dt.

Int ActionTravail( Emploi emploi, Int action, Chaîne arrêter )
Effectue action on JOB avec une arrêter précisé en fonction de
l'action. action peut être : SYNCRUN, ASYNCRUN, DELETE, RERUN, HOLD,
LIBÉRATION, SIGNAL, MODIFYATTR, MODIFYRES où :
Action Description
=============== ==========================
SYNCHRONISATION fonctionne le JOB de manière synchrone,
sens le Appelez-nous à
ActionTravail() sera uniquement
retourner quand le JOB a
j'ai commencé pour le running or quand
an erreur a était
rencontré.
Param valeur:
prénom of hôte(s) à courir
JOB sous.

ASYNCRUN fonctionne le JOB de manière asynchrone,
sens le Appelez-nous à
ActionTravail() sera retourner
immédiatement as Bientôt as
le courir nécessaire is
validé by le PBS serveur,
ainsi que ne sauraient nécessairement quand
le JOB a j'ai commencé
exécution.
Param valeur:
prénom of hôte(s) à courir
JOB sous.

EFFACER suppressions le d'emplois.
Param valeur:
"deldelay=<# of secondes>"
- retarder # of secondes
jusqu'à XNUMX fois le envoi
of SIGTERME ainsi que SIGTUER
à le JOB before
obtention supprimée.

REDIFFUSION relance le pour le running emploi,
qui implique se terminant
le Session leader of le
JOB ainsi que retour le JOB
à le en file d'attente Etat.

ATTENTE endroits UN or PLUS détient
on le d'emplois.
Param valeur:
"tu", "o", "s", "oui", "os",
"uos"
- type of détient à endroit
on emploi: utilisateur), autre),
système).

PRESSE supprime or de presse
détient mis on emplois.
Param valeur:
"tu", "o", "s", "oui", "os",
"uos"
- type of détient à supprimez
de emploi: utilisateur), autre),
système).

SIGNAL envoie a signal à le
exécution d'emplois.
Param valeur:
"HUP", "SOUPIR",...

MODIFIERATTR modifie le spécifié
attribuer of le JOB à
le donné valeur, quand
le nom_attribut is
!= "Liste_ressources" or
"ressources_utilisées".
Param valeur:
"attrib_name=valeur"

MODIFIER modifie le emplois
Liste_ressources
attribuer donné le
nom_res ainsi que le
res_value :
Resource_List.res_name=
res_value
Param valeur:
"res_name=res_val"
arrêter la valeur dépend de l’action. Spécifiez NULLSTR si aucune valeur pour
ce paramètre est souhaité.
Valeur de retour : SUCCÈS ou ÉCHEC.
REMARQUE : Tout action est ignoré.
Mise en situation :
// courir Emploi j de manière synchrone
JobAction(j, SYNCHRONISATION, NULLSTR);

// courir Emploi j de manière asynchrone on hôte "db"
JobAction(j, ASYNCRUN, "base de données");

// effacer Emploi j
JobAction(j, EFFACER, NULLSTR);

// effacer Emploi j avec a retarder of 5 secondes
// jusqu'à XNUMX fois le envoi of SIGTERME ainsi que
// SIGTUER
JobAction(j, EFFACER, "deldélai=5");

// rediffusion Emploi j
JobAction(j, REDIFFUSION, NULLSTR);

// endroit a utilisateur) appuyez en continu on Emploi j
JobAction(j, PRISE, "tu");

// endroit an autre) appuyez en continu on Emploi j
JobAction(j, PRISE, "o");

// endroit a système) appuyez en continu on Emploi j
JobAction(j, PRISE, "s");

// endroit a défaut appuyez en continu (U) on Emploi j
JobAction(j, PRISE, NULLSTR);

// libérer utilisateur) appuyez en continu de Emploi j
JobAction(j, LIBÉRATION, "tu");

// libérer autre) appuyez en continu de Emploi j
JobAction(j, LIBÉRATION, "o");

// libérer système) appuyez en continu de Emploi j
JobAction(j, LIBÉRATION, "s");

// libérer défaut appuyez en continu (U) de Emploi j
JobAction(j, LIBÉRATION, NULLSTR);

// envoyer VUE D'ENSEMBLE signal à Emploi j
JobAction(j, SIGNAL, "SOUPIR");

// Mise à jour le commentaire attribuer of Emploi
// j à "a un message".
// La arrêter le format est: nom_attribut=nouvelle_valeur
// Consultation PBS Documentation en a liste of JOB
// attribuer noms qui vous be spécifié.
JobAction(j, MODIFIERATTR, "commentaire=un message");
// Mise à jour le Resource_List.cput attribuer of Emploi
// j à 3600 secondes.
// La arrêter le format est: nom_ressource=nouvelle_valeur
// See pbs_resources* man page en a liste of
// noms_ressources qui vous be spécifié.
JobAction(j, MODIFIER, "cput=3600");

QueJobFind(Que que,Amusant Int fonction,Int cpr,Int valeur);

QueJobFind(Que que,Amusant Chaîne fonction,Int cpr, chaîne valeur);

QueJobFind(Que que,Amusant DateTime fonction,Int cpr, DateHeure valeur);

QueJobFind(Que que,Amusant Taille fonction,Int cpr, taille valeur);

De cpr est l'un des suivants : OP_EQ, OP_NEQ, OP_LE, OP_LT, OP_GE, OP_GT. fonction
est une fonction dont le SEUL argument est de type Job. Emploi c'est le retour
type.

Description : S'applique fonction à chaque emploi dans Quoi , et renvoie le premier
travail qui satisfait à la comparaison logique : fonction (travail) cpr Plus-value

Mise en situation :

Taille JobVirtualMemAvailGet(Travail emploi)
{
Taille sz;

sz = JobSizeResReqGet(travail, "mémoire");
retour(sz);
}
Int JobWallTimeReqGet(Travail emploi)
{
Int mur;

mur = JobIntResReqGet(travail, "temps mural");
revenir(mur);
}

Int JobCpuTimeUsedGet(Travail emploi)
{
Int processeur ;

cput = JobIntResUseGet(travail, "cput");
return(cput);
}

Que findQueByName(Ensemble Que les files d'attente, Chaîne nomq)
{
Que q;

pour chaque (q in files d'attente) {
si ( QueNameGet(q) EQ qnom ) {
retour(q);
}
}
return(NOQUE);
}
sched_main()
{
Server s;
Que que;
Ensemble Que carré;

// obtenez locales serveur
s = AllServersLocalHostGet();

// obtenez le files d'attente of le Server s
sq = ServerQueuesGet(s);

// obtenez le file nommé "vite" de le
// locales serveur
Quoi = findQueByName( m², "vite" );

// Trouvez le 1 JOB dont temps mural exigence
// is == 300s:
QueJobFind(que, JobWallTimeReqGet, OP_EQ, 300);

// Trouvez le 1 JOB dont email propos à
// notifier à propos JOB activité != "bayucan":
QueJobFind(que, JobEmailAddrObtenir, OP_NEQ,
"bayucan");

// Trouvez le 1 JOB qui était créée après
// or on 3 / 3 / 1997:
QueJobFind(que, JobDateTimeCreatedGet, OP_GE,
(3|3|1997));

// Trouvez le 1 JOB qui était créée après
// 3:3:44 :
QueJobFind(que, JobDateTimeCreatedGet, OP_GT,
(3:3:44));

// Trouvez le 1 JOB qui était créée après
// 3:3:44 on 3 / 3 / 1997:
QueJobFind(que, JobDateTimeCreatedGet, OP_GT,
(3|3|1997@3:3:44));

// Trouvez le 1 JOB dont cpu fiable d'utiliser < 1600s:
QueJobFind(que, JobCpuTimeUsedGet, OP_LT, 1600);

// Trouvez le 1 JOB dont virtuel Mémoire
// exigence <= 300 Mo :
QueJobFind(que, JobVirtualMemAvailGet, OP_LE,
300 Mo);
}

Emploi QueJobFind( Que que amusement Int fonction, Int RCP)

Emploi QueJobFind( Que que amusement Chaîne fonction, Int RCP)

Emploi QueJobFind( Que que amusement DateTime fonction, Int RCP)

Emploi QueJobFind( Que que amusement Taille fonction, Int RCP)

De cpr peut être l'un des éléments suivants : OP_MAX, OP_MIN, fonction est une
fonction dont le seul argument est de type Job.

Description : Renvoie le Job avec la valeur max ou min trouvée pour
fonction (travail) car il est appliqué à chaque emploi dans Quoi .

Mise en situation :
Int JobCpuTimeReqGet(Travail emploi)
{
Int processeur ;

cput = JobIntResReqGet(travail, "cput");
return(cput);
}
sched_main()
{
Que que;
Emploi travail;

// Trouvez le Emploi avec le le plus élevé cpu fiable
// exigence:
JOB = QueJobFind(que, JobCpuTimeReqGet, OP_MAX);

// Trouvez le Emploi avec le minimum cpu fiable
// exigence:
JOB = QueJobFind(que, JobCpuTimeReqGet, OP_MIN);
}

Que QueFilter(Que que,Amusant Int fonction,Int cpr,Int valeur)

Que QueFilter(Que que,Amusant Chaîne fonction,Int cpr, chaîne valeur)

Que QueFilter(Que que,Amusant DateTime fonction,Int cpr, date valeur)

Que QueFilter(Que que,Amusant Taille fonction,Int cpr, taille valeur)

De cpr peut être l'un des éléments suivants : OP_EQ, OP_NEQ, OP_LE, OP_LT,
OP_GE, OP_GT, fonction est une fonction dont le seul argument est de type Job.

Description : S'applique fonction à chaque emploi dans Quoi , et renvoie un nouveau que
contenant tous les travaux qui satisfont à la condition de comparaison :
fonction (travail) cpr Plus-value

Mise en situation :
Int JobWallTimeReqGet(Travail emploi)
{
Int mur;

mur = JobIntResReqGet(travail, "temps mural");
revenir(mur);
}
sched_main()
{
Que que;
Que nouveauq ;

// Retours a neufs Quoi comprenant TOUTE emplois in "que"
// avec a temps mural exigence == 300s:
nouveauq = QueFilter(que, JobWallTimeReqGet, OP_EQ, 300);

// Retours a neufs Quoi comprenant TOUTE emplois in "que"
// avec an email propos != "bayucan":
nouveauq = QueFilter(que, JobEmailAddrObtenir, OP_NEQ, "bayucan");

// Retours a neufs Quoi comprenant TOUTE emplois in "que"
// créée après or on 3 / 3 / 1997:
nouveauq = QueFilter(que, JobDateTimeCreatedGet, OP_GE,
(3|3|1997));

// Retours a neufs Quoi comprenant TOUTE emplois in "que"
// créée après 3:3:44 :
nouveauq = QueFilter(que, JobDateTimeCreatedGet, OP_GT,
(3:3:44));

// Retours a neufs Quoi comprenant TOUTE emplois in "que"
// créée après 3:3:44 on 3 / 3 / 1997:
nouveauq = QueFilter(que, JobDateTimeCreatedGet, OP_GT,
(3|3|1997@3:3:44));

// REMARQUE: La original "que" is ne sauraient modifié
// quel qu'ils soient.
}

Int Trier(Définir Emploi s, amusement Int clé, Int ordre)

Int Trier(Définir Emploi s, amusement Chaîne clé, Int ordre)

Int Trier(Définir Emploi s, amusement flotteur clé, Int ordre)

Int Trier(Définir Emploi s, amusement DateTime clé, Int ordre)

Int Trier(Définir Emploi s, amusement Taille clé, Int ordre)

De s l'ensemble des tâches à trier. key est la clé de tri qui est un
fonction dont le seul argument est de type Job, de commander c'est le tri
ordre : ASC, DESC.

Description : trie les éléments de s , en ASCending ou
Ordre DESCENDANT des valeurs renvoyées par le key fonctionne comme
appliqué à chaque membre de l’ensemble d’emplois. Le s l'objet est modifié
avec cet appel. Cela renvoie SUCCESS ou FAIL en fonction du résultat de
le genre.

Exemples :
Taille JobMemReqGet(Travail emploi)
{
Taille mem;

Membre = JobSizeResReqGet(travail, "mémoire");
retourner(mémoire);
}

sched_main()
{
Server maître;

Ensemble Emploi emplois;

Int ordre;

// obtenez locales serveur
maître = AllServersLocalHostGet();

emplois = ServeurJobsObtenir(maître);
Trier(emplois, JobPriorityObtenir, ASC);
Trier(emplois, JobIdGet, DESC);
de commander = ASC ;
Trier(emplois, JobDateTimeCreatedGet, commande);
de commander = DESC;
Trier(emplois, JobMemReqGet, commande);
}

Int Trier(Définir Que s, amusement Int clé, Int ordre)

Int Trier(Définir Que s, amusement Chaîne clé, Int ordre)

Int Trier(Définir Que s, amusement flotteur clé, Int ordre)

Int Trier(Définir Que s, amusement DateTime clé, Int ordre)

Int Trier(Définir Que s, amusement Taille clé, Int ordre)

De s l'ensemble des files d'attente à trier. key est la clé de tri qui est un
fonction dont le seul argument est de type Que, de commander c'est le tri
ordre : ASC, DESC.

Description : trie les éléments de s , en ASCending ou
Ordre DESCENDANT des valeurs renvoyées par le key fonctionne comme
appliqué à chaque membre de l’ensemble de files d’attente. Le s l'objet est
modifié avec cet appel. Cela renvoie SUCCÈS ou ÉCHEC selon
résultat du genre.

Exemples :
Taille QueMemAvailGet(Que que)
{
Taille mem;

Membre = QueSizeResAvailGet(que, "mémoire");
retourner(mémoire);
}

sched_main()
{
Server maître;

Ensemble Que ques;
Int ordre;

// obtenez locales serveur
maître = AllServersLocalHostGet();

ques = ServerQueuesGet(maître);
Trier(ques, QuePriorityGet, ASC);
Trier(ques, QueNameGet, ASC);
de commander = DESC;
Trier(ques, QueMemAvailGet, commande);
}

Int Trier(Définir Server s, amusement Int clé, Int ordre)

Int Trier(Définir Server s, amusement Chaîne clé, Int ordre)

Int Trier(Définir Server s, amusement flotteur clé, Int ordre)

Int Trier(Définir Server s, amusement DateTime clé, Int ordre)

Int Trier(Définir Server s, amusement Taille clé, Int ordre)

De s l'ensemble des serveurs à trier. key est la clé de tri qui est
une fonction dont le seul argument est de type Serveur, de commander est
ordre de tri : ASC, DESC.

Description : trie les éléments de s , en ASCending ou
Ordre DESCENDANT des valeurs renvoyées par le key fonctionne comme
appliqué à chaque membre de l’ensemble des serveurs. Le s l'objet est
modifié avec cet appel. Cela renvoie SUCCÈS ou ÉCHEC selon
résultat du genre.

Exemples :
Taille ServerMemAvailGet(Serveur servir)
{
Taille mem;

Membre = ServerSizeResAvailGet(serv, "mémoire");
retourner(mémoire);
}

sched_main()
{
Ensemble Server serveur ;

Int ordre;

Int ret;

serveur = AllServersGet();

ret = Trier(serveur, ServeurMaxRunJobsGet, ASC);
Trier(serveur, ServeurInetAddrGet, ASC);

de commander = DESC;
Trier(serveur, ServeurMemAvailGet, commande);
}

Int Trier(Définir CNode s, amusement Int clé, Int ordre)

Int Trier(Définir CNode s, amusement Chaîne clé, Int ordre)

Int Trier(Définir CNode s, amusement flotteur clé, Int ordre)

Int Trier(Définir CNode s, amusement DateTime clé, Int ordre)

Int Trier(Définir CNode s, amusement Taille clé, Int ordre)

De s l'ensemble des nœuds à trier. key est la clé de tri qui est un
fonction dont le seul argument est de type CNode, de commander c'est le tri
ordre : ASC, DESC.

Description : trie les éléments de s , en ASCending ou
Ordre DESCENDANT des valeurs renvoyées par le key fonctionne comme
appliqué à chaque membre de l’ensemble de nœuds. Le s l'objet est
modifié avec cet appel. Cela renvoie SUCCÈS ou ÉCHEC selon
résultat du genre.

Exemples :
Taille CNodeMyMemAvailGet(CNode cn)
{
Taille mem;

Membre = CNodeMemAvailGet(cn, "virtuel");
retourner(mémoire);
}

sched_main()
{
Ensemble CNode scnode;

Int ordre;

scnode = AllNodesGet();

Trier(scnode, CNodeIdletimeGet, ASC);
Trier(scnode, CNodeNameGet, ASC);
de commander = DESC;
Trier(scnode, CNodeMyMemAvailGet, commande);
}

CNode..Obtenir() FONCTIONS

Les valeurs de retour des fonctions CNode..Get() abordées dans la section précédente sont
obtenu en envoyant des requêtes de ressources au MOM du CNode à chaque itération de planification.
Par exemple, CNodeLoadAveGet (nœud) renverra la valeur obtenue à partir de certains
ressource> requête (cela pourrait être la chaîne "loadave") telle qu'envoyée au MOM du nœud. Le
" -> Les mappages CNode..Get()" sont établis en interne, mais ils peuvent être
modifiés ou plusieurs mappages peuvent être ajoutés via le fichier de configuration du planificateur. La configuration
le dossier est discuté dans pbs_sched_basl(8B).
Les mappages déjà établis sont donnés comme suit :

Pour toutes les architectures :

CNode..Obtenir() présenter Appelez-nous hôte ressource
======================== =============
CNodeOsGet (nœud) arche
CNodeLoadAveGet (nœud) chargement
CNodeIdletimeGet(nœud) temps d'inactivité

Utilisez basl2cB en ligne en utilisant les services onworks.net