Este es el comando basl2cB que se puede ejecutar en el proveedor de alojamiento gratuito de OnWorks utilizando una de nuestras múltiples estaciones de trabajo en línea gratuitas, como Ubuntu Online, Fedora Online, emulador en línea de Windows o emulador en línea de MAC OS.
PROGRAMA:
NOMBRE
basl2c: convierte un código BASL (BAtch Scheduling Language) en un código de programador C.
SINOPSIS
basl2c [-d] [-l lexerDebugFile] [-p parserDebugFile] [-y symtabDebugFile] [-s
archivodepuraciónsemántica] [-g archivodepuracióncodegen] [-c archivoc] archivobasl
DESCRIPCIÓN
basl2c es el compilador de BASL a C que produce un código intermedio que se puede alimentar en un
compilador C normal y vinculado con las bibliotecas PBS para producir el ejecutable del programador.
Basl2c toma como entrada un baslArchivo, que es un programa escrito en BAtch Scheduling
Idioma, que contiene el código de programación principal. Basl2c luego convierte las construcciones BASL
en el archivo en declaraciones C, y también adjunta código adicional para producir el PBS
código fuente del programador. De forma predeterminada, el código C resultante se escribe en el archivo
pbs_sched.c.
El nombre de ruta completo al archivo C resultante es lo que debe especificarse en el SCHD_CODE
variable en local.mk antes de compilar el planificador BASL para producir el pbs_sched
ejecutable.
CAMPUS
-d Imprime mensajes de depuración adicionales al lexer (vea la opción -l), parser (vea -p
opción), tabla de símbolos (ver opción -y), analizador semántico (ver opción -s) y código
generador (ver opción -g).
-l lexerDebugFile
lexerDebugFile es el nombre de un archivo para escribir en los mensajes de depuración generados
mientras busca tokens.
-p analizadorArchivoDepuración
analizadorDebugFile es el nombre de un archivo para escribir en los mensajes de depuración generados
al juntar tokens de una manera utilizable.
-y symtabArchivoDepuración
symtabDebugFile es el nombre de un archivo para escribir en los mensajes de depuración relacionados con
la tabla de símbolos.
-s archivo de depuración semántico
archivo de depuración semántico es el nombre de un archivo para escribir en los mensajes de depuración
generado mientras se comprueba para asegurarse de que las variables y los operadores se utilizan en un
de forma coherente.
-g codegenDebugFile
codegenDebugFile es el nombre de un archivo para escribir en los mensajes de depuración generados
al convertir declaraciones BASL a declaraciones C.
-c cArchivo
cArchivo es el nombre de un archivo en el que se escribe el código C generado.
PRINCIPAL ESTRUCTURA
La estructura básica de un código de planificador escrito en BASL es la siguiente:
cero or más, Las funciones Definiciones
cero or más, global VARIABLE Declaraciones
cero or más, asignación declaraciones (a inicializar global variables)
sched_main ()
{
una or más, VARIABLE Declaraciones
cero or más, DECLARACIONES
}
Por ejemplo,
% gato programado.basl
Int. suma (Int a, Int. b)
{
Int. s;
s = a + b;
devoluciones);
}
Int. glob
sched_main ()
{
Int. c;
a = 3;
b = 4;
c = suma (a, B);
imprimir (c);
glob = 5;
imprimir (glob);
}
sched_main () es la función que se llama en cada iteración de programación.
Las funciones
Para definir una función que se puede llamar en funciones posteriores, la sintaxis es:
Tipo de retorno nombre de la función ( TIPO DE DATOS1 IDENTIFICADOR1,
TIPO DE DATOS2 IDENTIFICADOR2, ... )
{
una or más, VARIABLE Declaraciones
cero or más, DECLARACIONES
}
Por ejemplo,
Void printStuff (día de la semana abajo, DateTime t, Cordón calle,
Tamaño talla, NodoC cn)
{
imprimir (dow);
imprimir (t);
imprimir (str);
imprimir (sz);
imprimir (cn);
}
Función válida Tipo de retorno son: Void, Int, Float, Dayofweek, DateTime, String, Size,
Servidor, Cola, Trabajo, CNode, Establecer servidor, Establecer cola, Establecer trabajo, Establecer CNode.
Tipos de datos válidos ( TIPO DE DATOS1, TIPO DE DATOS2, ... ) para los identificadores de parámetro son: Int,
Flotante, Día de la semana, Fecha y hora, Cadena, Tamaño, Servidor, Que, Trabajo, CNode, Establecer servidor, Establecer que,
Establecer trabajo, Establecer CNode, Intervalo de intervalo, Intervalo de flotación, Intervalo de día de la semana, Intervalo de fecha y hora, Intervalo de tamaño,
Fun Int, Fun Float, Fun Void, Fun Dayofweek, Fun DateTime, Fun String, Fun Size, Fun
Servidor, Fun Que, Fun Job, Fun CNode, Fun Set Servidor, Fun Set Que, Fun Set Job, Fun Set
CNode. Estos tipos de datos se discutirán en el siguiente tema.
Las funciones se invocan por su nombre y sus argumentos como en:
printStuff ( LUN, (5|1|1997@14:32:00), "programado comienza ",
30 gb, nodo );
basl2c en realidad agregará un prefijo "basl_" al nombre de la función dado por el programador
escritor para minimizar la posibilidad de colisión de nombres, que puede resultar cuando el código C resultante es
vinculado con las bibliotecas PBS, BASL. Por ejemplo, si observa el código C generado para
imprimirCosas, tu verias,
basl_printStuff( MON, (5|1|1997@14:32:00),
"inicio programado", 30gb, nodo);
Como en C, todas las llamadas a funciones deben haberse definido previamente. El compilador BASL
compruebe para asegurarse de que los argumentos en la llamada a la función coincidan exactamente (en términos de
tipos) con los parámetros en la definición de función.
Existen dos tipos de funciones en BASL: funciones definidas por el usuario y funciones predefinidas.
Las funciones definidas por el usuario son aquellas para las que el escritor del planificador proporcionó una definición,
mientras que las funciones predefinidas son aquellas que se pueden llamar inmediatamente sin necesidad de
definiéndolo. Para obtener una lista de funciones predefinidas, consulte la sección sobre PREDEFINIDO Las funciones .
VARIABLE Declaraciones
Como en C, todas las variables en un código BASL deben declararse explícitamente antes de su uso. Aquellos
las variables declaradas fuera de cualquier función se denominan variables globales, mientras que
las variables que se declaran dentro del cuerpo de una función se denominan variables locales. Global
las variables se pueden usar en cualquier lugar dentro del código BASL, mientras que las variables locales se pueden leer
solo dentro de la función desde la que fueron declarados.
La sintaxis de una declaración de variable es:
TIPO DE DATOS IDENTIFICADOR ;
donde TIPO DE DATOS puede ser: Int, Float, Dayofweek, DateTime, String, Size, Server, Que, Job,
Nodo C, Establecer servidor, Establecer cola, Establecer trabajo, Establecer nodo C, Rango int, Rango flotante, Rango Día de la semana,
Rango Fecha y hora, Tamaño del rango.
DATOS TIPO
Void utilizado para funciones que no devuelven un valor.
Int. números enteros con signo en base 10.
Constantes de muestra:
5, +1, -3, ÉXITO (= 1), FALLO (= 0), VERDADERO (= 1), FALSO (= 0)
Flotador números reales que se representan como dobles en el código C traducido.
Constantes de muestra: 4.3, +1.2, -2.6
Día de la semana
valores constantes: SUN, MON, TUE, WED, THU, FRI, SAT, representados internamente como
constantes con valores enteros con SUN = 0, MON = 1, etc.
DateTime
especificar en uno de los 3 formatos:
[1] (m | d | y) donde 1 <= m <= 12, 1 <= d <= 31, 0 <= y, ej. (4 | 4 | 1997);
[2] (hh: mm: ss) donde 0 <= hh <= 23, 0 <= mm <= 59, 0 <= ss <= 61, ej.
(12:01:00);
[3] (m|d|y@hh:mm:ss), ex. (4|4|1997@12:01:00)
Durante la comparación de fechas / horas, la hora "ahora" se sustituye si la hora
no se proporciona una porción (formato [1]); la fecha "ahora" se sustituye si la
no se proporciona la parte de la fecha (formato [2]). Además, la parte del año completo debe
debe darse (es decir, 1997 en lugar de 97) en fechas para evitar ambigüedades.
Cordón Una cadena está entre comillas (") y puede contener cualquier cosa excepto otra
cita, una nueva línea y paréntesis izquierdo y derecho.
Constantes de muestra: "una cadena de muestra", NULLSTR
Tamaño formato: donde el sufijo es un multiplicador de la forma:
:
multiplicador unidad (bytes or palabras)
=================== =====================
k, m, g, t, p, K, M, G, T, P b, B, w, W
donde 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, y el tamaño de palabra w = W está definido localmente (es decir, 4
bytes en una máquina de 32 bits).
Cuando se opera en operandos de 2 tamaños que son de diferentes sufijos, el sufijo de
el "más bajo" de los dos será el sufijo resultante. Por ejemplo,
10 MB + 10 GB = 10250 MB
Constantes de muestra: -1b, 2w, 1kb, 2mw, + 3gb, 4tw, 6Pb
Gama de Colores Int.
formato: (valor Int bajo, valor Int alto)
donde valor Int bajo <= valor Int alto. Constante muestral: (1,3)
Gama de Colores Flotador
formato: (valor flotante bajo, valor flotante alto)
donde valor bajo <= valor alto. Constante muestral: (2.3, 4.6)
Gama de Colores Día de la semana
formato: (día anterior, día posterior)
donde día anterior <= día posterior. Constante de muestra: (WED, FRI)
Gama de Colores DateTime
formato: (fecha / hora anterior, fecha / hora posterior)
donde fecha / hora anterior <= fecha / hora posterior.
NOTA: si el rango contiene solo porciones de tiempo, y el tiempo anterior "aparece" para
ser> más tarde como en "((18: 0: 0), (6: 0: 0))", luego durante la fecha / hora
comparaciones, el tiempo "posterior" se ajustará en un día para que
parece: "( ( @ 18: 0: 0), ( @ 6: 0: 0)) "
Constantes de muestra:
((4|4|1997), (4|10|1997)), ((12:01:00), (12:30:00)), ((4|4|1997@12:01:00),
(4|10|1997@12:30:00))
Gama de Colores Tamaño
formato: (tamaño bajo, tamaño alto)
donde tamaño bajo <= tamaño alto. Constantes de muestra: (23 gb, 50 gb)
Servidor Se asigna directamente al objeto del servidor PBS. A Servidor gestiona uno o más Que objetos.
Constante de muestra: NOSERVER
NodoC para un nodo computacional que consta de una sola imagen de sistema operativo, una memoria compartida y un conjunto
de cpus. CNode ejecuta 1 PBS MOM.
Constante de muestra: NOCNODE
Que Se asigna directamente al objeto de cola de PBS. A Que bobinas de objetos uno o más Trabajos
objetos.
Constante de muestra: NOQUE
Trabajos Se asigna directamente al objeto de trabajo de PBS. A Trabajos El objeto lleva algunos atributos y
requerimientos de recursos.
Constante de muestra: NOJOB
Set Servidor
lista de objetos del servidor.
Constante de muestra: EMPTYSETSERVER
Set NodoC
lista de objetos CNode.
Constante de muestra: EMPTYSETCNODE
Set Que lista de objetos Que.
Constante de muestra: EMPTYSETQUE
Set Trabajos lista de objetos de trabajo.
Constante de muestra: EMPTYSETJOB
DEFINIDO POR BASL Constantes
Estas son constantes que no se pueden usar para nombrar un identificador (vea el tema siguiente). Estas
siempre están en mayúsculas.
DATOS TIPO DEFINIDO POR BASL MEJORA
=================== =============================================
Día de la semana SOL, LUN, MAR, CASARSE, JUE, VIE, Sábado
Int. ÉXITO, FALLAR, FALSO CIERTO, SINCRONIZAR, ASINCRUN,
ELIMINAR, REPETICIÓN, SOSTENER, LIBERACIÓN, SEÑAL,
MODIFICAR ATTR, MODIFICA, SERVIDOR_ACTIVO,
SERVIDOR_IDLE, SERVIDOR_HORARIO, SERVIDOR_TERMINO,
SERVIDOR_TERMDELAY, QTYPE_E, QTYPE_R,
SCHED_DISABLED, SCHED_ENABLED, TRÁNSITO,
PUESTO EN COLA, RETENIDA, ESPERANDO, CORRIENDO, SALIENDO,
CNODE_DESCONECTADO, CNODE_ABAJO, CNODE_GRATIS,
CNODE_RESERVA, CNODE_INUSE_EXCLUSIVO,
CNODE_INUSE_SHARED, CNODE_TIMESHARED,
CNODE_CLUSTER, CNODE_DESCONOCIDO, OP_EQ, OP_NEQ,
OP_LE, OP_LT, OP_GE, OP_GT, OP_MAX, OP_MIN,
ASC DESC
Servidor SIN SERVIDOR
Set Servidor SERVIDOR VACÍO
NodoC NOCNODO
Set NodoC EMPTYSETCNODE
Que NOQUE
Set Que VACÍO
Trabajos SIN TRABAJO
Set Trabajos TRABAJO VACÍO
Cordón NULLSTR
IDENTIFICADOR
Los identificadores (usados para nombres de variables y nombres de funciones) están en formato alfanumérico, con
el carácter especial de subrayado (_) permitido. Actualmente, BASL solo puede manejar identificadores
con una longitud de hasta 80 caracteres. Además, no puede utilizar los nombres de constantes definidos por BASL para
nombrar un identificador.
DECLARACIONES
In BASL(2), puede hacer que una sola declaración termine con un punto y coma, o un grupo de
declaraciones (llamadas declaración compuesta o bloque) delimitadas por '{' y '}'. Lo diferente
Los tipos de declaraciones que pueden aparecer en un código BASL son:
1. declaración de expresión
Las declaraciones de expresión son cualquier cosa de la forma:
expr ;
donde expr puede ser:
a) Expresiones aritméticas
Lexpr + reexpr (agregar)
Lexpr - reexpr (sustraer)
Lexpr * reexpr (multiplicar)
Lexpr / reexpr (dividir)
Lexpr % reexpr (módulo or recordatorio)
NOTA: Sumar, restar, multiplicar, dividir y restar
sólo se permitirá para los tipos adecuados y si la izquierda y la derecha
las expresiones son de tipos consistentes. La siguiente tabla ilustra lo que
los tipos son consistentes entre los distintos operadores:
Para +:
Lexpr reexpr
============ ============
Int. or Flotador Int. or Flotador
Tamaño Tamaño
Cordón Cordón
Para -, *, /:
Lexpr reexpr
============ ============
Int. or Flotador Int. or Flotador
Tamaño Tamaño
Para %:
Lexpr reexpr
============ ============
Int. or Flotador Int. or Flotador
A continuación, se muestran algunos ejemplos de declaraciones de expresiones aritméticas:
Int. i1;
Int. i2;
Flotador f1;
Flotador f2;
Tamaño sz1;
Tamaño sz2;
Cordón cadena1;
Cordón cadena2;
i1 + i2;
f1 - i2;
sz1 * sz2 * 2b;
sz1 / 1024b;
str1 = "basl";
str2 = " frio";
// las siguiendo is a cadena concatenación
// Inteligente resultante in las cuerda:
// "basl frio"
str1 + cadena2;
i1 % 10;
b) Expresiones unarias
+ expr // positivo - multiplica by 1 an
// expresión esa is
// of En t, Flotador, or
// Tamaño tipo
-expr // negativas - multiplica by -1 an
// expresión esa is
// of En t, Flotador, or
// Tamaño tipo
! expr // no - conversos a distinto de cero expr
// propuesta de dentro 0, y a
// cero expr propuesta de dentro 1
// donde expr tipo debe be
// of tipo Int. or Flotador
Algunas expresiones unarias de muestra:
Int. i;
+ 3;
-(I + 4);
!I;
c) Expresiones lógicas
Lexpr EQ reexpr
Lexpr NEQ reexpr
Lexpr LT reexpr
Lexpr LE reexpr
Lexpr GT reexpr
Lexpr GE reexpr
Lexpr Y reexpr
Lexpr OR reexpr
Lexpr y reexpr debe tener tipos que sean mutuamente consistentes como se muestra
en la siguiente tabla:
terminal-expr rterminal-expr
============== ==============
Int. or Flotador Int. or Flotador
Día de la semana Día de la semana
DateTime DateTime
Cordón Cordón
Tamaño Tamaño
Servidor Servidor
Que Que
Trabajos Trabajos
NodoC NodoC
Set Servidor Set Servidor
Set Que Set Que
Set Trabajos Set Trabajos
Set NodoC Set NodoC
Y, OR operadores, el lexpr, reexpr los tipos consistentes son Int o
Flotador.
Algunas expresiones lógicas de muestra:
i1 EQ i2;
i1 NEQ f2;
dow1 LE dow2;
d1 LT d2;
str1 GT cadena2;
sz1 GE sz2;
d) Expresiones posteriores al operador
Estas son expresiones que son simplemente un atajo a la asignación
Declaraciones.
IDENTIFICADOR ++; // identificador = identificador + 1
IDENTIFICADOR--; // identificador = identificador-1
IDENTIFICADOR debe ser de tipo Int o Float.
Ejemplo:
Int. i;
Flotador f;
i + +;
F--;
e) Llamada de función
nombre de la función ( arg1 , arg2 ... , argn )
donde arg1, ... argn puede ser cualquier constante o variable. No puedes tener
otra llamada a función como argumento.
Ejemplo:
Void impresión a) {
imprimir (a);
}
pr(5);
Hay ciertas funciones predefinidas que un programador puede programar.
llamar automáticamente a su código BASL sin necesidad de definirlo.
Estas funciones se conocen como funciones de asistencia (o ayuda
funciones) y se analizan en PREDEFINIDO Las funciones tema.
f) Constantes
Algunas expresiones constantes válidas se dan a continuación:
5;
+ 1.2;
SOL;
LUN;
MAR;
CASARSE;
JUE;
VIE;
SENTÉ;
(4 | 4 | 1997);
(12:01:00);
(4|4|1997@12:01:00);
"maravilloso";
-1b;
SINCRONIZAR;
ASINCRÓNEO;
ELIMINAR;
REPETICIÓN;
SOSTENER;
LIBERACIÓN;
SEÑAL;
MODIFICAR ATTR;
MODIFICA;
(1, 3);
(2.3, 4.6);
(MIÉ, VIE);
((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 gb, 50 gb);
SINSERVIDOR;
NOCNODO;
NOQUE;
SIN TRABAJO;
SERVIDORCONJUNTOVACÍO;
VACÍOSETCNODE;
VACÍO;
TRABAJO VACÍO;
NULLSTR;
ÉXITO;
FALLAR;
SERVIDOR_ACTIVO;
SERVIDOR_IDLE;
SERVIDOR_HORARIO;
SERVIDOR_TERMINO;
SERVIDOR_TERMDELAY;
QTYPE_E;
QTYPE_R;
PROGRAMA_DESHABILITADO;
PROGRAMA_HABILITADO;
FALSO;
CIERTO;
TRÁNSITO;
PUESTO EN COLA;
RETENIDA;
ESPERANDO;
CORRIENDO;
SALIR;
CNODE_DESCONECTADO;
CNODE_ABAJO;
CNODE_GRATIS;
CNODE_RESERVA;
CNODE_INUSE_EXCLUSIVO;
CNODE_INUSE_SHARED;
CNODE_TIMESHARED;
CNODE_CLUSTER;
CNODE_DESCONOCIDO;
OP_EQ;
OP_NEQ;
OP_LE;
OP_LT;
OP_GE;
OP_GT;
OP_MAX;
OP_MIN;
g) Identificador
Ejemplo:
yo;
i;
2. Declaración de cesión
IDENTIFICADOR = expr ;
IDENTIFICADOR y expr debe tener tipos que sean mutuamente consistentes como
ilustrado en la siguiente tabla:
identificador expr
================== ==================
Int. En t, Flotador
Flotador En t, Flotador
Día de la semana Día de la semana
DateTime DateTime
Cordón Cordón
Tamaño Tamaño
Que Que
Trabajos Trabajos
NodoC NodoC
Servidor Servidor
Día de la semana Día de la semana
DateTime DateTime
Set Servidor Set Servidor
Set Que Set Que
Set Trabajos Set Trabajos
Set NodoC Set NodoC
Gama de Colores Int. Gama de Colores Int.
Gama de Colores Flotador Gama de Colores Flotador
Gama de Colores Día de la semana Gama de Colores Día de la semana
Gama de Colores DateTime Gama de Colores DateTime
Gama de Colores Tamaño Gama de Colores Tamaño
3. si ... si no ambiental
El formato de una instrucción if es similar al de C con la delimitación
"{" y "}" siempre presentes:
if ( expr ) {
cero or más, (True) DECLARACIONES
}
if ( expr ) {
cero or más, (True) DECLARACIONES
} más {
cero or más, (falso) DECLARACIONES
}
El expr 's tipo debe ser Int o Float, y después de la evaluación si su
valor no es cero, entonces se ejecutan las declaraciones verdaderas. En el segundo
forma, si el expr evalúa a cero, luego se ejecutan las declaraciones falsas.
Alguna muestra if las declaraciones se dan a continuación:
if (2 * x )
{
y = y + 3;
imprimir (y);
}
if (2 * x ) {
y = y + 3;
} más {
if ( 3 * x ) {
y = 4;
} más {
y = 5;
}
}
4. para loops ambiental
El formato de una declaración for es el siguiente:
por( comienzo; prueba; DE ACTUAR! ) {
cero or más, DECLARACIONES
}
Al igual que en C, para primero se ejecuta comienzo , luego evalúa el test condición
para ver si devuelve un valor distinto de cero. Si lo hace, el para declaraciones son
ejecutado. Después de la para las declaraciones se ejecutan, entonces DE ACTUAR! es evaluado,
y luego comprueba el test condición de nuevo de la misma manera que antes.
comienzo y DE ACTUAR! puede ser una expresión de asignación simple o un posoperador
expresión. test es una expresión lógica / relacional. Alguna muestra para
Las declaraciones se dan a continuación:
para (i = 0; i LT 3 ; i = i + 1)
{
imprimir (i);
}
para (i = 0; i LT 2 * x; i ++)
{
if (x GT 3)
{
y = 99;
} más
{
x = 73;
}
}
5. foreach loops ambiental
Esta declaración se utiliza principalmente para recuperar sucesivamente cada elemento de
a Establecer tipo de datos: Establecer servidor, Establecer CNode, Establecer trabajo, Establecer cola. La sintaxis es:
foreach ( IDENTIFICADOR1 in IDENTIFICADOR2 ) {
cero or más, DECLARACIONES
}
donde se permite el siguiente emparejamiento de tipos para los identificadores:
IDENTIFICADOR1 IDENTIFICADOR2
=========== ===========
Servidor Set Servidor
Que Set Que
Trabajos Set Trabajos
NodoC Set NodoC
Ejemplo:
Servidor s;
Que q;
Trabajos j;
NodoC c;
Set Servidor ss;
Set Que cuadrado;
Set Trabajos sj;
Set NodoC Carolina del Sur;
foreach (s in ss) {
huellas dactilares);
}
foreach (q in sq) {
imprimir (q);
}
foreach (j in sj) {
imprimir (j);
}
foreach (c in Carolina del Sur){
imprimir (c);
}
6. mientras loops ambiental
La sintaxis de un bucle while es:
mientras ( expr ) {
cero or más, DECLARACIONES
}
donde expr debe ser de tipo Int o Float. Si expr es distinto de cero, entonces el cero
o más DECLARACIONES son ejecutados y expr se reevalúa.
Ejemplo:
Int. i;
i = 3;
mientras yo) {
if ( i EQ 0 ) {
imprimir ("romper on i = 1 ");
break;
}
I--;
}
7. cambiar ambiental
La sentencia de cambio es una decisión de múltiples vías que prueba si un
El valor del identificador coincide con uno de varios valores y se ramifica a un
grupo de declaraciones en consecuencia.
La sintaxis de una declaración de cambio es:
cambiar( IDENTIFICADOR ) {
case constante-expr :
{
cero or más, DECLARACIONES
}
case constante-expr :
{
cero or más, DECLARACIONES
}
...
case in rango-constanteOrSet-expr :
{
cero or más, DECLARACIONES
}
case in IDENTIFICADOR-rangeOrSettype :
{
cero or más, DECLARACIONES
}
tu préstamo estudiantil :
{
cero or más, DECLARACIONES
}
}
donde constante-expr es un expr de tipo Int, Float, Dayofweek, DateTime,
Size, String, Server, Que, Job o CNode. rango-constanteOrSet-expr y
IDENTIFICADOR-rangeOrSettype puede ser de tipo Set Server, Set CNode, Set Que, Set
Trabajo, Intervalo de intervalo, Intervalo de flotación, Intervalo de día de la semana, Intervalo de fecha y hora o Tamaño de intervalo.
IDENTIFICADOR no puede ser de tipo Vacío. IDENTIFICADOR 's el tipo debe ser consistente
constante-expr 'S, rango-constanteOrSet-expr 'S, y IDENTIFICADOR-
rangoOrSettype 's escriba como se ilustra en la siguiente tabla:
IDENTIFICADOR rango-constante-expr, IDENTIFICADOR-tipo de rango
=========== =========================================
Servidor Set Servidor
Que Set Que
Trabajos Set Trabajos
NodoC Set NodoC
Int. Gama de Colores Int.
Flotador Gama de Colores Flotador
Día de la semana Gama de Colores Día de la semana
DateTime Gama de Colores DateTime
Tamaño Gama de Colores Tamaño
Si una expresión de caso coincide con IDENTIFICADOR 's valor, entonces el correspondiente
Se ejecutan bloques de sentencias. A diferencia de C, la ejecución NO cae
hasta la siguiente declaración de caso. La razón de esto es que basl2c seguirá
traduce esto cambiar declaración en la construcción if-elseif-else. El caso
etiquetado predeterminado se ejecuta si no se cumple ninguno de los otros casos. los
tu préstamo estudiantil es opcional; si no está allí, y si ninguno de los casos coincide, no
se lleva a cabo la acción.
Ejemplo:
Día de la semana abajo;
interruptor (dow)
{
case LUNES:
{
imprimir ("caso LUN");
}
case MAR:
{
imprimir ("caso MAR");
}
case CASARSE:
{
imprimir ("caso CASARSE");
}
case JUE:
{
imprimir ("caso JUE");
}
case VIE:
{
imprimir ("caso VIE");
}
case SAT:
{
imprimir ("caso SENTÉ");
}
case SOL:
{
imprimir ("caso SOL");
}
por defecto:
{
imprimir ("caso predeterminado ");
}
}
Int. a;
Gama de Colores Int. Rhode Island;
ri = (10, 12);
cambiar (a)
{
case in (1,5):
{
imprimir ("caso 1,5 ");
}
case in (6,9):
{
imprimir ("caso 6,9 ");
}
case in Rhode Island:
{
imprimir ("caso Rhode Island");
}
}
8. Imprimir ambiental
Print declaración es capaz de imprimir para stdout el valor de cualquier identificador
or constante de tipo Int, Float, Dayofweek, DateTime, String, Size, Que, Job,
CNode, Servidor, Rango Int, Rango Flotante, Rango Día de la semana, Rango Fecha Hora,
Tamaño de rango.
La sintaxis es la siguiente:
Imprimir ( IDENTIFICADOR );
Imprimir ( constante );
Ejemplo:
DateTime dt;
NodoC cn;
dt = (4|4|1997@12:13:36);
cn = AllNodesLocalHostGet ();
imprimir (dt);
imprimir (cn);
Para los tipos de conjuntos, utilice foreach para revisar cada elemento e imprimir como en:
Servidor s;
Set Servidor ss;
ss = AllServersGet ();
foreach (s in ss) {
huellas dactilares);
}
9. Continuar declaración
continue ;
El continue declaración debe haber sido invocada dentro de un para, para cada, y
mientras círculo. Hace que comience la siguiente iteración del bucle adjunto.
10. declaración de ruptura
romper ;
El romper declaración debe haber sido invocada dentro de un para, para cada, y mientras
círculo. Proporciona una salida anticipada del circuito circundante.
11. declaración de devolución
volver (IDENTIFICADOR) ;
retorno (constante) ;
regreso() ;
La declaración de retorno proporciona el valor (si lo hay) que debe devolver un
función. El tipo devuelto por IDENTIFICADOR y constante debe coincidir con el
llamando al tipo de retorno de la función. constante los tipos permitidos son cualquier cosa excepto
Tipos de conjunto y rango. El último formato, regreso() se suele llamar dentro de un
función que no devuelve ningún valor (como sched_main () ).
12. declaración de salida
salida (constante);
donde constante es de tipo Int. Llamar a esto terminará el programador.
13. Declaración de comentarios
Estas son declaraciones con el prefijo "//" y el BASL las ignora.
compilador
// así línea is ignorado
Int. i; // cadena siguiendo las barras is ignorado
OPERADOR PRECEDENCIA Y ASOCIATIVIDAD
La siguiente tabla muestra los distintos niveles de precedencia de operadores y asociatividad definidos
en el idioma BASL. Los operadores se enumeran en orden de precedencia decreciente. los
cuanto mayor sea la precedencia de un operador, antes se ejecutará. El orden en el que
los operadores en el mismo nivel se ejecutan depende de la asociatividad: izquierda significa que
los operadores se ven de izquierda a derecha, mientras que la derecha significa que se ven de derecha a izquierda.
Operador Asociatividad
==================================== =============
! ++ -- + (unario más) - (unario menos) Derecho
* / % izquierda
+ - izquierda
LT LE GT GE izquierda
EQ NEQ izquierda
Y izquierda
OR izquierda
= Derecho
PREDEFINIDO Las funciones
In BASL(2), un Servidor el tipo de datos se asigna directamente a un objeto de servidor por lotes. Similar, NodoC
es para mamá / resmom, Trabajos es un trabajo por lotes, y Que es hacer cola por lotes. Sin embargo, no todos
Se puede acceder a los atributos de los objetos PBS desde BASL. Solo un subconjunto de atributos,
aquellos que parecían tener sentido en el contexto de un planificador, están disponibles y
Se puede acceder a los valores de estos atributos llamando a las siguientes funciones predefinidas,
también conocidas como funciones de asistencia / ayuda.
(1) Funciones relacionadas con el servidor
Set Servidor AllServersGet (anulado)
Devuelve la lista de servidores especificada en el archivo de configuración para
que el escritor del planificador desea que el sistema compruebe periódicamente
información de estado, colas y trabajos. Ver pbs__sched__basl(8 mil millones) para agendar una
discusión sobre el formato del archivo de configuración.
PRECAUCIÓN: Esta función debe llamarse desde adentro sched_main () so
que en cada iteración de programación, el más actualizado Set Servidor
se devuelve la estructura.
Servidor AllServersLocalHostGet (void)
Devuelve el objeto de servidor que representa el host local. valor no establecido:
NOSERVER. Esta es una función simple para llamar a entornos que no son de clúster.
donde solo existe un servidor.
PRECAUCIÓN: Esta función debe llamarse desde adentro sched_main () (o de
dentro de la función llamada por sched_main) de modo que en cada programación
iteración, la más actualizada Servidor se devuelve la estructura.
Cordón ServerInetAddrGet (servidor s)
Devuelve el nombre de los servidores. valor no establecido: NULLSTR
Cordón ServerDefQueGet (servidor s)
Devuelve el atributo default_queue de Server s. valor no establecido: NULLSTR
Int. ServerStateGet (servidor s)
Devuelve el atributo server_state de Server s.
Valor devuelto:
SERVIDOR_ACTIVO, SERVIDOR_IDLE, SERVIDOR_SCHED, SERVIDOR_TERM,
SERVER_TERMDELAY, -1 (valor no establecido)
Int. ServerMaxRunJobsGet (servidor s)
Devuelve el atributo max_running de Server s. valor no establecido: 0
Int. ServerMaxRunJobsPerUserGet (servidor s)
Devuelve el atributo max_user_run de Server s. valor no establecido: 0
Int. ServerMaxRunJobsPerGroupGet (servidor s)
Devuelve el atributo max_group_run de Server s. valor no establecido: 0
Set Que ServerQueuesGet (servidor s)
Devuelve la lista de colas administradas por los servidores.
Set Trabajos ServerJobsGet (servidor s)
Devuelve la lista de trabajos administrados por los servidores. Para obtener un subconjunto de este
lista, ver QueJobsGet ().
Int. ServerIntResAvailGet (servidor s, Cordón nombre)
Devuelve el valor al recurso especificado en nombre que está disponible para trabajos
ejecutado por este servidor (servidor recursos_disponibles.nombre atributo). Llama esto
función para recursos con valores que son de tipo Int. Recurso de muestra
los nombres son: cput, pcput, walltime, mppt, pmppt, nice, procs, mppe, ncpus,
pncpus, nodect, srfs_assist, mta, ..., mth. Para obtener una descripción de estos
nombres de recursos, consulte pbs_resources_irix5(7B), pbs_recursos_sp2(7B),
pbs_resources_sunos4(7B), pbs_resources_unicos8(7B),
pbs_server_atributos(7B), pbs_resources_irix6(7B),
pbs_recursos_linux(7B).
Ejemplo:
Int. cpuDisponible;
// volvemos las # of CPUs actualmente Hoy Disponibles in
// las servidor
cpuDisponible = ServerIntResAvailGet (servidor, "ncpus");
Tamaño ServerSizeResAvailGet (servidor s, Cordón nombre)
Devuelve el valor al recurso especificado en nombre que está disponible para trabajos
ejecutado por este servidor (servidor recursos_disponibles.nombre atributo). Llama esto
función para recursos con valores que son de tipo Size. Recurso de muestra
los nombres son: archivo, mem, pmem, conjunto de trabajo, pf, ppf, srfs_tmp, srfs_wrk,
srfs_big, srfs_fast, sds, psds. Para obtener una descripción de estos recursos
nombres, ver pbs_resources_irix5(7B), pbs_recursos_sp2(7B),
pbs_resources_sunos4(7B), pbs_resources_unicos8(7B),
pbs_server_atributos(7B), pbs_resources_irix6(7B),
pbs_recursos_linux(7B).
Ejemplo:
Tamaño memDisponible;
// volvemos las cantidad of Hoy Disponibles memoria in
// las servidor
disponible = ServerSizeResAvailGet (servidor, "mem");
Cordón ServerStringResAvailGet (servidor s, Cordón nombre)
Devuelve el valor al recurso especificado en nombre que está disponible para trabajos
ejecutado por este servidor (servidor recursos_disponibles.nombre atributo). Llama esto
función para recursos con valores que son de tipo String. Muestra
los nombres de los recursos son: nodos, arco, nodos de necesidad. Para obtener una descripción de estos
nombres de recursos, consulte pbs_resources_irix5(7B), pbs_recursos_sp2(7B),
pbs_resources_sunos4(7B), pbs_resources_unicos8(7B),
pbs_server_atributos(7B), pbs_resources_irix6(7B),
pbs_recursos_linux(7B).
Ejemplo:
Cordón escribe;
// volvemos las arquitectura (o os tipo) of
// las servidor
tipo = ServerStringResAvailGet (servidor, "arco");
Int. ServerIntResAssignGet (servidor s, Cordón nombre)
Devuelve el valor al recurso especificado en nombre que se asigna a
trabajos en ejecución (servidor recursos_asignados.nombre atributo). Llama esto
función para recursos con valores que son de tipo Int. Recurso de muestra
los nombres son: cput, pcput, walltime, mppt, pmppt, nice, procs, mppe, ncpus,
pncpus, nodect, srfs_assist, mta, ..., mth. Para obtener una descripción de estos
nombres de recursos, consulte pbs_resources_irix5(7B), pbs_recursos_sp2(7B),
pbs_resources_sunos4(7B), pbs_resources_unicos8(7B),
pbs_server_atributos(7B), pbs_resources_irix6(7B),
pbs_recursos_linux(7B).
Ejemplo:
Int. CPUAssn;
// volvemos las # of CPUs actualmente asigna in
// las servidor
CPUAssn = ServerIntResAssignGet (servidor, "ncpus");
Tamaño ServerSizeResAssignGet (servidor s, Cordón nombre)
Devuelve el valor al recurso especificado en nombre que se asigna a
trabajos en ejecución (servidor recursos_asignados.nombre atributo). Llama esto
función para recursos con valores que son de tipo Size. Recurso de muestra
los nombres son: archivo, mem, pmem, conjunto de trabajo, pf, ppf, srfs_tmp, srfs_wrk,
srfs_big, srfs_fast, sds, psds. Para obtener una descripción de estos recursos
nombres, ver pbs_resources_irix5(7B), pbs_recursos_sp2(7B),
pbs_resources_sunos4(7B), pbs_resources_unicos8(7B),
pbs_server_atributos(7B), pbs_resources_irix6(7B),
pbs_recursos_linux(7B).
Ejemplo:
Tamaño sdsAssn;
// volvemos las cantidad of sds espacio actualmente asigna
// in las servidor
sdsAssn = ServerSizeResAssignGet (servidor, "sds");
Cordón ServerStringResAssignGet (servidor s, Cordón nombre)
Devuelve el valor al recurso especificado en nombre que se asigna a
trabajos en ejecución (servidor recursos_asignados.nombre atributo). Llama esto
función para recursos con valores que son de tipo String. Muestra
los nombres de los recursos son: nodos, arco, nodos de necesidad. Para obtener una descripción de estos
nombres de recursos, consulte pbs_resources_irix5(7B), pbs_recursos_sp2(7B),
pbs_resources_sunos4(7B), pbs_resources_unicos8(7B),
pbs_server_atributos(7B), pbs_resources_irix6(7B),
pbs_recursos_linux(7B).
Set NodoC ServerNodesGet (servidor s)
Devuelve el conjunto de nodos gestionados por los servidores. valor no establecido: EMPTYSETCNODE.
NOTA: Por lo general, puede llamar a las siguientes funciones para los nodos devueltos
mediante esta llamada: CNodeStateGet (), CNodePropertiesGet () y CNodeTypeGet ().
Int. ServerNodesQuery (servidor s, Cordón Especificaciones)
Emite una solicitud al servidor especificado para consultar la disponibilidad de
recursos especificados en especulación. En la actualidad, el único recurso
La especificación permitida es aquella que involucra "nodos" y puede ser del tipo
formato "nodos", "nodos =" o "nodos = ". Los resultados de la consulta pueden ser
se accede llamando a las siguientes funciones: ServerNodesNumAvailGet (),
ServerNodesNumAllocGet (), ServerNodesNumRsvdGet (),
ServerNodesNumDownGet ().
NOTA: Este es un envoltorio para el pbs_rescquery(3B) función de servidor.
Valor devuelto:
ÉXITO, FALLO
Int. ServerNodesNumAvailGet (servidor s)
Devuelve el número de nodos disponibles para los gestionados por el especificado
servidor, o como se refleja en la consulta más reciente especificada por
ServerNodesQuery (). Si el valor de retorno es cero, esto significa que
cierto número de nodos que se necesitan actualmente para satisfacer la especificación de
ServerNodesQuery () no están disponibles actualmente. La solicitud puede ser satisfecha
en algún momento posterior. Si el resultado es negativo, no se conoce ninguna combinación de
los nodos pueden satisfacer la especificación.
Int. ServerNodesNumAllocGet (servidor s)
Devuelve el número de nodos asignados para los gestionados por el especificado
servidor, o como se refleja en la consulta más reciente especificada por
ServerNodesQuery ().
Int. ServerNodesNumRsvdGet (servidor s)
Devuelve el número de nodos reservados para los gestionados por el especificado
servidor, o como se refleja en la consulta más reciente especificada por
ServerNodesQuery ().
Int. ServerNodesNumDownGet (servidor s)
Devuelve el número de nodos hacia abajo para aquellos administrados por el especificado
servidor, o como se refleja en la consulta más reciente especificada por
ServerNodesQuery ().
Int. ServerNodesReserve (servidor s, cadena especificación, Int ID de residencia)
Emite una solicitud al servidor especificado para reservar los recursos
especificado en especulación. Un valor de 0 para ID de residencia significa que esto es para hacer un
nueva reserva. De lo contrario, el número representará un
reserva (parcial). Recursos actualmente reservados para esto ID de residencia seguirá
se liberará y se intentará de nuevo la reserva completa. En el
En la actualidad, los únicos recursos que pueden especificarse son
"nodos". Debe especificarse como nodos = especificación donde
la especificación es lo que un usuario especifica en la lista de argumentos de la opción -l
para los nodos, consulte qsub (1B).
NOTA: Este es un envoltorio para el pbs_reservar(3B) función de servidor.
Valor devuelto:
un número de referencia para una exitosa o parcialmente exitosa
reserva, o FAIL
Int. ServerNodesRelease (servidor s, Int. ID de residencia)
Esto libera o libera recursos reservados con el número de referencia
especificado en Resid.
NOTA: Este es un envoltorio para el pbs_rescrelease(3B) función de servidor.
Valor devuelto:
ÉXITO o FALLO
(2) Funciones relacionadas con Que:
Cordón QueNameGet ( Que que )
Devuelve el nombre de Que que. valor no establecido: NULLSTR
Int. QueTypeGet ( Que que )
Devuelve el atributo queue_type de Que cola.
Valor de retorno: QTYPE_E (ejecución), QTYPE_R (enrutamiento), -1 (no establecido
valor)
Int. QueNumJobsGet ( Que que )
Devuelve el número de trabajos que residen en Que que. valor no establecido: 0
Int. QueMaxRunJobsGet ( Que que )
Devuelve el atributo max_running de Que que. valor no establecido: 0
Int. QueMaxRunJobsPerUserGet ( Que que )
Devuelve el atributo max_user_run de Que que. valor no establecido: 0
Int. QueMaxRunJobsPerGroupGet ( Que que )
Devuelve el atributo max_group_run de Que que. valor no establecido: 0
Int. QuePriorityGet ( Que que )
Devuelve el atributo Prioridad de Que que. valor no establecido: 0
Int. QueStateGet ( Que que )
Devuelve el atributo iniciado de Que que - la selección de ejecución del trabajo
estado de la que: SCHED_DISABLED, SCHED_ENABLED. valor no establecido:
SCHED_DISABLED
Set Trabajos QueJobsGet ( Que que )
Devuelve la lista de trabajos que residen actualmente en la cola.
Int. QueIntResAvailGet (Que q, Cordón nombre)
Devuelve el valor al recurso especificado en nombre que está disponible para
trabajos que se ejecutan desde este q (Que recursos_disponibles.nombre atributo).
Llame a esta función para recursos con valores de tipo Int.
Ejemplos de nombres de recursos son: cput, pcput, walltime, mppt, pmppt, nice,
procs, mppe, ncpus, pncpus, nodect, srfs_assist, mta, ..., mth. Para
descripción de estos nombres de recursos, consulte pbs_resources_irix5(7B),
pbs_recursos_sp2(7B), pbs_resources_sunos4(7B),
pbs_resources_unicos8(7B), pbs_server_atributos(7B),
pbs_resources_irix6(7B), pbs_recursos_linux(7B).
Tamaño QueSizeResAvailGet (Que q, Cordón nombre)
Devuelve el valor al recurso especificado en nombre que está disponible para
trabajos que se ejecutan desde este q (Que recursos_disponibles.nombre atributo).
Llame a esta función para recursos con valores de tipo Size.
Ejemplos de nombres de recursos son: file, mem, pmem, workingset, pf, ppf,
srfs_tmp, srfs_wrk, srfs_big, srfs_fast, sds, psds. Para una descripción
de estos nombres de recursos, consulte pbs_resources_irix5(7B),
pbs_recursos_sp2(7B), pbs_resources_sunos4(7B),
pbs_resources_unicos8(7B), pbs_server_atributos(7B),
pbs_resources_irix6(7B), pbs_recursos_linux(7B).
Cordón QueStringResAvailGet (Que q, Cordón nombre)
Devuelve el valor al recurso especificado en nombre que está disponible para
trabajos que se ejecutan desde este q (Que recursos_disponibles.nombre atributo).
Llame a esta función para recursos con valores de tipo String.
Ejemplos de nombres de recursos son: nodos, arco, nodos de necesidad. Para una descripción
de estos nombres de recursos, consulte pbs_resources_irix5(7B),
pbs_recursos_sp2(7B), pbs_resources_sunos4(7B),
pbs_resources_unicos8(7B), pbs_server_atributos(7B),
pbs_resources_irix6(7B), pbs_recursos_linux(7B).
Int. QueIntResAssignGet (Que q, Cordón nombre)
Devuelve el valor al recurso especificado en nombre que se asigna a
trabajos que se ejecutan desde esta cola (Que recursos_asignados.nombre atributo).
Llame a esta función para recursos con valores de tipo Int.
Ejemplos de nombres de recursos son: cput, pcput, walltime, mppt, pmppt, nice,
procs, mppe, ncpus, pncpus, nodect, srfs_assist, mta, ..., mth. Para
descripción de estos nombres de recursos, consulte pbs_resources_irix5(7B),
pbs_recursos_sp2(7B), pbs_resources_sunos4(7B),
pbs_resources_unicos8(7B), pbs_server_atributos(7B),
pbs_resources_irix6(7B), pbs_recursos_linux(7B).
Tamaño QueSizeResAssignGet (Que q, Cordón nombre)
Devuelve el valor al recurso especificado en nombre que se asigna a
trabajos que se ejecutan desde este q (Que recursos_asignados.nombre atributo).
Llame a esta función para recursos con valores de tipo Size.
Ejemplos de nombres de recursos son: file, mem, pmem, workingset, pf, ppf,
srfs_tmp, srfs_wrk, srfs_big, srfs_fast, sds, psds. Para una descripción
de estos nombres de recursos, consulte pbs_resources_irix5(7B),
pbs_recursos_sp2(7B), pbs_resources_sunos4(7B),
pbs_resources_unicos8(7B), pbs_server_atributos(7B),
pbs_resources_irix6(7B), pbs_recursos_linux(7B).
Cordón QueStringResAssignGet (Que q, Cordón nombre)
Devuelve el valor al recurso especificado en nombre que se asigna a
trabajos que se ejecutan desde este q (Que recursos_asignados.nombre atributo).
Llame a esta función para recursos con valores de tipo String.
Ejemplos de nombres de recursos son: nodos, arco, nodos de necesidad. Para una descripción
de estos nombres de recursos, consulte pbs_resources_irix5(7B),
pbs_recursos_sp2(7B), pbs_resources_sunos4(7B),
pbs_resources_unicos8(7B), pbs_server_atributos(7B),
pbs_resources_irix6(7B), pbs_recursos_linux(7B).
(3) Funciones relacionadas con el trabajo
Cordón JobIdGet ( Trabajos trabajo )
Devuelve el identificador de trabajo del trabajo de trabajo. valor no establecido: NULLSTR
Cordón JobNameGet ( Trabajos trabajo )
Devuelve el atributo Job_Name del trabajo de trabajo. valor no establecido: NULLSTR
Cordón JobOwnerNameGet ( Trabajos trabajo )
Devuelve el atributo Job_Owner del trabajo Job. valor no establecido: NULLSTR
Cordón JobEffectiveUserNameGet ( Trabajos trabajo)
Devuelve el atributo euser del trabajo Job.
Cordón JobEffectiveGroupNameGet (Trabajo trabajo)
Devuelve el atributo egroup del trabajo Job. valor no establecido: NULLSTR
Int. EstadoTrabajoObtener ( Trabajos trabajo )
Devuelve el atributo job_state del trabajo Job.
Valor devuelto:
TRÁNSITO, EN COLA, DETENIDO, ESPERANDO, EN EJECUCIÓN, SALIDA, -1 (desarmado
valor)
Int. JobPriorityGet ( Trabajos trabajo )
Devuelve el atributo Prioridad del trabajo de trabajo. valor no establecido: 0
Int. JobRerunFlagGet ( Trabajos trabajo )
Devuelve el atributo Rerunable del trabajo Job.
Valor de retorno: FALSO, VERDADERO, -1 (valor no establecido)
Int. JobInteractiveFlagGet ( Trabajos trabajo )
Devuelve el atributo interactivo del trabajo de trabajo.
Valor de retorno: FALSO, VERDADERO. valor no establecido: FALSO
DateTime JobDateTimeCreatedGet (Trabajo trabajo)
Devuelve el atributo ctime de Job job. valor no establecido:
(0|0|0@-1:-1:-1)
Cordón JobEmailAddrGet ( Trabajos trabajo )
Devuelve el atributo Mail_Users del trabajo Job. valor no establecido: NULLSTR
Cordón JobStageinFilesGet ( Trabajos trabajo )
Devuelve el atributo stagein del trabajo Job. valor no establecido: NULLSTR
Cordón JobStageoutFilesGet ( Trabajos trabajo )
Devuelve el atributo stageout del trabajo Job. valor no establecido: NULLSTR
Int. JobIntResReqGet (Trabajo trabajo, Cordón nombre)
Devuelve el valor al recurso especificado en nombre como lo requiere el
trabajo (trabajo Resource_List.nombre atributo). Llame a esta función para
recursos con valores que son de tipo Int. Nombres de recursos de muestra
son: cput, pcput, walltime, mppt, pmppt, nice, procs, mppe, ncpus,
pncpus, nodect, srfs_assist, mta, ..., mth. Para obtener una descripción de estos
nombres de recursos, consulte pbs_resources_irix5(7B), pbs_recursos_sp2(7B),
pbs_resources_sunos4(7B), pbs_resources_unicos8(7B),
pbs_server_atributos(7B), pbs_resources_irix6(7B),
pbs_recursos_linux(7B).
Ejemplo:
Int. cputReq;
// devoluciones las cput requisito of las trabajo
CPUReq = JobIntResReqGet (trabajo, "cput");
Tamaño JobSizeResReqGet (Trabajo trabajo, Cordón nombre)
Devuelve el valor al recurso especificado en nombre como lo requiere el
trabajo (trabajo Resource_List.nombre atributo). Llame a esta función para
recursos con valores que son de tipo Size. Nombres de recursos de muestra
son: archivo, mem, pmem, conjunto de trabajo, pf, ppf, srfs_tmp, srfs_wrk,
srfs_big, srfs_fast, sds, psds. Para obtener una descripción de estos recursos
nombres, ver pbs_resources_irix5(7B), pbs_recursos_sp2(7B),
pbs_resources_sunos4(7B), pbs_resources_unicos8(7B),
pbs_server_atributos(7B), pbs_resources_irix6(7B),
pbs_recursos_linux(7B).
Ejemplo:
Tamaño memReq;
// devoluciones las memoria requisito of las trabajo
memReq = JobSizeResReqGet (trabajo, "mem");
Cordón JobStringResReqGet (Trabajo trabajo, Cordón nombre)
Devuelve el valor al recurso especificado en nombre como lo requiere el
trabajo (trabajo Resource_List.nombre atributo). Llame a esta función para
recursos con valores que son de tipo String. Nombres de recursos de muestra
son: nudos, arco, nudos de necesidad. Para obtener una descripción de estos recursos
nombres, ver pbs_resources_irix5(7B), pbs_recursos_sp2(7B),
pbs_resources_sunos4(7B), pbs_resources_unicos8(7B),
pbs_server_atributos(7B), pbs_resources_irix6(7B),
pbs_recursos_linux(7B).
Ejemplo:
Cordón nodos
// devoluciones las nodos requisito perfecta of
// las trabajo
nodos = JobStringResReqGet (trabajo, "nodos");
Int. JobIntResUseGet (Job trabajo, Cordón nombre)
Devuelve el valor al recurso especificado en nombre utilizado por el trabajo (trabajo
recursos_usados.nombre atributo). Llame a esta función para recursos con
valores que son de tipo Int. Ejemplos de nombres de recursos son: cput, pcput,
walltime, mppt, pmppt, agradable, procs, mppe, ncpus, pncpus, nodect,
srfs_assist, mta, ..., mth. Para obtener una descripción de estos nombres de recursos,
ver pbs_resources_irix5(7B), pbs_recursos_sp2(7B),
pbs_resources_sunos4(7B), pbs_resources_unicos8(7B),
pbs_server_atributos(7B), pbs_resources_irix6(7B),
pbs_recursos_linux(7B).
Ejemplo:
Int. uso de pared;
// devoluciones las cantidad of Walltime usado by
// las trabajo
uso de la pared = JobIntResUseGet (trabajo, "walltime");
Tamaño JobSizeResUseGet (Job trabajo, Cordón nombre)
Devuelve el valor al recurso especificado en nombre utilizado por el trabajo (trabajo
recursos_usados.nombre atributo). Llame a esta función para recursos con
valores que son de tipo Tamaño. Ejemplos de nombres de recursos son: archivo, mem,
pmem, conjunto de trabajo, pf, ppf, srfs_tmp, srfs_wrk, srfs_big, srfs_fast,
sds, psds. Para obtener una descripción de estos nombres de recursos, consulte
pbs_resources_irix5(7B), pbs_recursos_sp2(7B),
pbs_resources_sunos4(7B), pbs_resources_unicos8(7B),
pbs_server_atributos(7B), pbs_resources_irix6(7B),
pbs_recursos_linux(7B).
Ejemplo:
Tamaño srfsUso;
// devoluciones las cantidad of srfs_rápido usado by
// las trabajo
srfsUsar = JobSizeResUseGet (trabajo, "srfs_fast");
Cordón JobStringResUseGet (Job trabajo, Cordón nombre)
Devuelve el valor al recurso especificado en nombre utilizado por el trabajo (trabajo
recursos_usados.nombre atributo). Llame a esta función para recursos con
valores que son de tipo String. Ejemplos de nombres de recursos son: nodos,
arco, nudos de aguja. Para obtener una descripción de estos nombres de recursos, consulte
pbs_resources_irix5(7B), pbs_recursos_sp2(7B),
pbs_resources_sunos4(7B), pbs_resources_unicos8(7B),
pbs_server_atributos(7B), pbs_resources_irix6(7B),
pbs_recursos_linux(7B).
(4) Funciones relacionadas con CNode
Set NodoC AllNodesGet (anulado)
Devuelve la lista de nodos administrados por el servidor que se ejecuta en el
anfitrión local. Esto también podría incluir los nodos que se especificaron
en el archivo de configuración del planificador para el que el escritor del planificador
quiere que el sistema compruebe periódicamente información como el estado,
propiedad, etc. Ver pbs_sched_basl(8 mil millones) para una discusión de
formato de archivo de configuración.
PRECAUCIÓN: Esta función debe llamarse desde adentro sched_main () so
que en cada iteración de programación, el más actualizado Set NodoC
se devuelve la estructura. No llame a esto desde una declaración de asignación
destinado a inicializar una variable global, ya que la declaración solo
ser llamado una vez.
NodoC AllNodesLocalHostGet (void)
Devuelve el objeto CNode que representa el host local. Esto es un
función simple para llamar a sistemas no agrupados donde solo 1 CNode
existe. valor no establecido: NOCNODE
PRECAUCIÓN: Esta función debe llamarse desde adentro sched_main () (o
desde dentro de funciones llamadas por sched_main) de modo que en cada
programación de iteraciones, la más actualizada NodoC la estructura es
regresó. No llame a esto desde una declaración de asignación destinada a
inicializar una variable global, ya que la declaración solo se llamará
una vez.
Cordón CNodeNameGet (CNode nodo)
Devuelve el nombre único (oficial) del nodo (es decir, el nombre de host de ResMom
en un modelo de 1 mamá / nodo). Esto devuelve la misma cadena que fue
especificado en el archivo de configuración. valor no establecido: NULLSTR
Cordón CNodeOsGet (CNode nodo)
Devuelve la arquitectura del sistema operativo del nodo (es decir, "irix5", "sp2"). desarmado
valor: NULLSTR
Int. CNodeStateGet ( NodoC nodo )
Devuelve el estado del nodo.
Valor devuelto:
CNODE_OFFLINE, CNODE_DOWN, CNODE_FREE, CNODE_RESERVE,
CNODE_INUSE_EXCLUSIVO, CNODE_INUSE_SHARED, CNODE_UNKNOWN
Int. CNodeTypeGet ( NodoC nodo )
Devuelve el tipo de nodo.
Valor devuelto:
CNODE_TIMESHARED, CNODE_CLUSTER, CNODE_UNKNOWN
Cordón CNodePropertiesGet (CNode nodo)
Devuelve la lista separada por comas de otros nombres por los que se conoce el nodo
(propiedades, otro nombre de red). Por ejemplo,
"babbage.OpenPBS.org" tal vez sea el nombre del nodo, pero también podría ser conocido
a través de "babbage1, babbage2". valor no establecido: NULLSTR
Cordón CNodeVendorGet (CNode nodo)
Devuelve el nombre del proveedor del hardware de la máquina (es decir,
"sgi", "ibm"). valor no establecido: NULLSTR
Int. CNodeNumCpusGet (CNode nodo)
Devuelve el número de procesadores conectados al nodo. valor no establecido:
-1
Tamaño CNodeMemTotalGet ( NodoC nodo, Cordón tipo )
Devuelve la memoria total de tipo para el nodo. tipo es un arbitrario
cadena que el escritor del planificador define en el planificador
archivo de configuración. valor no establecido: -1b
Ejemplo:
// obtener total los libros físicos memoria
CNodeMemTotalGet (nodo, "verdadero")
// obtener total virtual memoria
CNodeMemTotalGet (nodo, "virtual")
Tamaño CNodeMemAvailGet ( NodoC nodo, Cordón tipo )
Devuelve la memoria disponible de tipo para el nodo. tipo es un arbitrario
cadena que el escritor del planificador define en el planificador
archivo de configuración. valor no establecido: -1b
Entonces las llamadas de muestra serán:
// obtener Hoy Disponibles los libros físicos memoria
CNodeMemAvailGet (nodo, "verdadero")
// obtener Hoy Disponibles virtual memoria
CNodeMemAvailGet (nodo, "virtual")
Int. CNodeIdletimeGet ( NodoC nodo )
Devuelve el número de segundos en los que no se ha pulsado ninguna tecla o movimiento del mouse.
se lleva a cabo en cualquier terminal conectado al nodo. valor no establecido: -1
Flotador CNodeLoadAveGet ( NodoC nodo )
Devuelve el promedio de carga del nodo para todos los cpus. valor no establecido: -1.0
Int. CNodeCpuPercentIdleGet ( NodoC nodo )
Devuelve el porcentaje de tiempo inactivo que todos los procesadores del nodo
ha experimentado.
Int. CNodeCpuPercentSysGet ( NodoC nodo )
Devuelve el porcentaje de tiempo que tienen todos los procesadores del nodo.
gastado ejecutando el código del kernel.
Int. CNodeCpuPercentUserGet ( NodoC nodo )
Devuelve el porcentaje de tiempo que tienen todos los procesadores del nodo.
gastado ejecutando código de usuario.
Int. CNodeCpuPercentGuestGet ( NodoC nodo )
Devuelve el porcentaje de tiempo que tienen todos los procesadores del nodo.
gastado ejecutando un sistema operativo invitado.
Int. CNodeNetworkBwGet ( NodoC nodo, Cordón tipo )
Devuelve el ancho de banda de la red del nodo de tipo en bytes / segundo.
tipo está definido por el escritor del planificador en el planificador
archivo de configuración. valor no establecido: -1
Algunas llamadas de muestra son:
CNodeNetworkBwGet ( nodo, "hippi" );
CNodeNetworkBwGet ( nodo, "fddi" );
Tamaño CNodeDiskSpaceTotalGet (CNode nodo, Cordón nombre)
Devuelve el espacio total del nodo en el disco identificado por nombre donde nombre
es el nombre del dispositivo definido arbitrariamente por el escritor del planificador en el
archivo de configuración del planificador. valor no establecido: -1b
Ejemplo:
CNodeDiskSpaceTotalGet ( nodo, "/ scratch2" );
Tamaño CNodeDiskSpaceAvailGet (CNode nodo, Cordón nombre)
Devuelve el espacio disponible del nodo en el disco identificado por nombre donde
nombre es definido arbitrariamente por el escritor del planificador en el planificador
archivo de configuración. valor no establecido: -1b
Ejemplo:
CNodeDiskSpaceAvailGet ( nodo, "/ scratch1" );
Tamaño CNodeDiskSpaceReservedGet (CNode nodo, Cordón nombre)
Devuelve el espacio reservado del nodo en el disco (¿cuota de usuario?) Identificado por
nombre donde nombre es definido arbitrariamente por el programador escritor en el
archivo de configuración del planificador. valor no establecido: -1b
Ejemplo:
CNodeDiskSpaceReservedGet ( nodo, "/ scratch1" );
Int. CNodeDiskInBwGet ( NodoC nodo, Cordón nombre )
Devuelve el ancho de banda de escritura (bytes / seg) del disco del nodo identificado
by nombre . valor no establecido: -1
Ejemplo:
CNodeDiskInBwGet ( nodo, "/rápido" );
Int. CNodeDiskOutBwGet ( NodoC nodo, Cordón nombre )
Devuelve el ancho de banda leído (bytes / seg) del disco del nodo identificado por
nombre . valor no establecido: -1
Ejemplo:
CNodeDiskOutBwGet ( nodo, "/grande" );
Tamaño CNodeSwapSpaceTotalGet ( NodoC nodo, Cordón nombre )
Devuelve el espacio total del nodo en el intercambio identificado por nombre donde nombre
es definido arbitrariamente por el escritor del planificador en el planificador
archivo de configuración. valor no establecido: -1b
Ejemplo:
CNodeSwapSpaceTotalGet ( nodo, "primario" );
Tamaño CNodeSwapSpaceAvailGet ( NodoC nodo, Cordón nombre )
Devuelve el espacio disponible del nodo en el intercambio identificado por nombre donde nombre
es el nombre del dispositivo definido arbitrariamente por el escritor del planificador en el
archivo de configuración del planificador. valor no establecido: -1b
Ejemplo:
CNodeSwapSpaceAvailGet ( nodo, "secundario" );
Int. CNodeSwapInBwGet ( NodoC nodo, Cordón nombre )
Devuelve la tasa de intercambio del dispositivo de intercambio del nodo identificado por nombre.
Ejemplo:
CNodeSwapInBwGet (nodo, "secundario");
Int. CNodeSwapOutBwGet ( NodoC nodo, Cordón nombre )
Devuelve la tasa de intercambio del dispositivo de intercambio del nodo identificado por
nombre. valor no establecido: -1
Ejemplo:
CNodeSwapOutBwGet (nodo, "primario");
Tamaño CNodeTapeSpaceTotalGet ( NodoC nodo, Cordón nombre )
Devuelve el espacio total del nodo en la cinta identificado por nombre donde nombre
es definido arbitrariamente por el escritor del planificador en el planificador
archivo de configuración. valor no establecido: -1b
Ejemplo:
CNodeTapeSpaceTotalGet (nodo, "4 mm");
Tamaño CNodeTapeSpaceAvailGet ( NodoC nodo, Cordón nombre )
Devuelve el espacio disponible del nodo en la cinta identificado por nombre donde
nombre es definido arbitrariamente por el escritor del planificador en el planificador
archivo de configuración. valor no establecido: -1b
Ejemplo:
CNodeTapeSpaceAvailGet (nodo, "8 mm");
Int. CNodeTapeInBwGet ( NodoC nodo, Cordón nombre )
Devuelve el ancho de banda de escritura (bytes / seg) de la cinta del nodo identificado
by nombre . valor no establecido: -1
Ejemplo:
CNodeTapeInBwGet ( nodo, "4 mm" );
Int. CNodeTapeOutBwGet ( NodoC nodo, Cordón nombre )
Devuelve el ancho de banda leído (bytes / seg) de la cinta del nodo identificado
by nombre . valor no establecido: -1
Ejemplo:
CNodeTapeOutBwGet ( nodo, "8 mm" );
Tamaño CNodeSrfsSpaceTotalGet ( NodoC nodo, Cordón nombre )
Devuelve el espacio total del nodo en el dispositivo srfs identificado por nombre
donde nombre es definido arbitrariamente por el programador escritor en el
archivo de configuración del planificador. valor no establecido: -1b
Ejemplo:
CNodeSrfsSpaceTotalGet (nodo, "/rápido");
Tamaño CNodeSrfsSpaceAvailGet ( NodoC nodo, Cordón nombre )
Devuelve el espacio disponible del nodo en el dispositivo srfs identificado por nombre
donde nombre es definido arbitrariamente por el escritor del planificador en algunos
archivo de configuración. valor no establecido: -1b
Ejemplo:
CNodeSrfsSpaceAvailGet ( nodo, "/grande" );
Tamaño CNodeSrfsSpaceReservedGet (CNode nodo, Cordón nombre)
Devuelve la cantidad total de espacio reservado del nodo en el dispositivo srfs
identificado por nombre donde nombre está definido arbitrariamente por el planificador
escritor en el archivo de configuración del planificador. valor no establecido: -1b
Ejemplo:
CNodeSrfsSpaceReservedGet ( nodo, "/rápido" );
Int. CNodeSrfsInBwGet ( NodoC nodo, Cordón nombre )
Devuelve el ancho de banda de escritura (bytes / seg) del dispositivo srfs del nodo
identificado por nombre . valor no establecido: -1
Ejemplo:
CNodeSrfsInBwGet (nodo, "/ rápido");
Int. CNodeSrfsOutBwGet ( NodoC nodo, Cordón nombre )
Devuelve el ancho de banda leído (bytes / seg) del dispositivo srfs del nodo
identificado por nombre . valor no establecido: -1
Ejemplo:
CNodeSrfsOutBwGet (nodo, "/ grande");
(5) Funciones misceláneas
DateTime datetimeGet ()
obtiene la fecha / hora actual.
Int. datetimeToSecs (DateTime dt)
devuelve el número de segundos desde la época (comienzo del tiempo de UNIX -
00:00:00, 1 de enero de 1970) para la fecha / hora indicadas dt.
Int. JobAction ( Trabajos trabajo, Int. acción, Cordón detener )
Realiza DE ACTUAR! on trabajo con un detener especificado dependiendo de la
acción. DE ACTUAR! puede ser: SYNCRUN, ASYNCRUN, DELETE, RERUN, HOLD,
RELEASE, SIGNAL, MODIFYATTR, MODIFYRES donde:
la columna Acción Descripción
================== ==========================
SINCRONIZAR corre las trabajo sincrónicamente,
sentido las llamar al a
JobAction () seguirá , solamente
volvemos cuando las trabajo tiene
fundó correr or cuando
an error tiene esto
encontrado.
Param valor:
nombre of Hospedadores) a corrida
trabajo debajo.
ASYNCRUN corre las trabajo asincrónicamente,
sentido las llamar al a
JobAction () seguirá volvemos
inmediatamente as pronto as
las corrida solicita is
validado by las PBS servidor,
y no necesariamente cuando
las trabajo tiene fundó
ejecución.
Param valor:
nombre of Hospedadores) a corrida
trabajo debajo.
BORRAR elimina las trabajo.
Param valor:
"deldelay = <# of segundos> "
- retrasar # of segundos
entre las enviando
of SIGNO y sigilo
a las trabajo antes
conseguir eliminada.
REPETICIÓN repeticiones las correr trabajo,
que implica terminando
las Sesión líder of las
trabajo y volver las trabajo
a las En cola estado.
SOSTENER lugares una or más, mantiene
on las trabajo.
Param valor:
"u", "o", "s", "uo", "os",
"uos"
- tipo of mantiene a place
on trabajo: usuario), otro),
sistema).
LIBERAR elimina or lanzamientos
mantiene metido on puestos de trabajo.
Param valor:
"u", "o", "s", "uo", "os",
"uos"
- tipo of mantiene a remove
en trabajo: usuario), otro),
sistema).
SEÑAL envía a señal a las
ejecución trabajo.
Param valor:
"HUP", "SIGHUP", ...
MODIFICAR ATR modifica las especificado
atributo of las trabajo a
las dado valor, cuando
las nombre_atributo is
!= "Resource_List" or
"recursos_usados".
Param valor:
"nombre_atributo = valor"
MODIFICAR modifica las trabajos
lista_de_recursos
atributo dado las
nombre_res y las
valor_res:
Resource_List.res_name =
valor_res
Param valor:
"res_name = res_val"
detener el valor depende de la acción. Especifique NULLSTR si no hay valor para
este parámetro es el deseado.
Valor de retorno: ÉXITO o FALLO.
NOTA: Cualquier no reconocido DE ACTUAR! se ignora.
Ejemplo:
// corrida Trabajos j sincrónicamente
JobAction (j, SINCRONIZAR, NULLSTR);
// corrida Trabajos j de forma asíncrona on fortaleza "db"
JobAction (j, ASINCRUN, "db");
// borrar Trabajos j
JobAction (j, ELIMINAR, NULLSTR);
// borrar Trabajos j a retrasar of 5 segundos
// entre las enviando of SIGNO y
// sigilo
JobAction (j, ELIMINAR, "demora = 5");
// repetición Trabajos j
JobAction (j, REPETICIÓN, NULLSTR);
// place a usuario) mantener on Trabajos j
JobAction (j, SOSTENER, "u");
// place an otro) mantener on Trabajos j
JobAction (j, SOSTENER, "o");
// place a sistema) mantener on Trabajos j
JobAction (j, SOSTENER, "s");
// place a tu préstamo estudiantil mantener (U) on Trabajos j
JobAction (j, SOSTENER, NULLSTR);
// , usuario) mantener en Trabajos j
JobAction (j, LIBERACIÓN, "u");
// , otro) mantener en Trabajos j
JobAction (j, LIBERACIÓN, "o");
// , sistema) mantener en Trabajos j
JobAction (j, LIBERACIÓN, "s");
// , tu préstamo estudiantil mantener (U) en Trabajos j
JobAction (j, LIBERACIÓN, NULLSTR);
// envío SUSCRÍBETE señal a Trabajos j
JobAction (j, SEÑAL, "SIGHUP");
// actualización las comentario atributo of Trabajos
// j a "a mensaje".
// El detener formato : nombre_atributo = valor_nuevo
// Consulta PBS documentación para a lista of trabajo
// atributo nombres esa podemos be especificado.
JobAction (j, MODIFICAR ATTR, "comentario = a mensaje");
// actualización las Lista_recursos.cput atributo of Trabajos
// j a 3600 segundos.
// El detener formato : resource_name = new_value
// See pbs_resources * hombre página para a lista of
// nombres de los recursos esa podemos be especificado.
JobAction (j, MODIFICA, "cput = 3600");
QueJobFind (Que que, divertido Int. func, Int rcp, Int valor);
QueJobFind (Que que, divertido Cordón func, Int cpr, cadena valor);
QueJobFind (Que que, divertido DateTime func, Int cpr, DateTime valor);
QueJobFind (Que que, divertido Tamaño func, Int cpr, tamaño valor);
donde cpr es uno de: OP_EQ, OP_NEQ, OP_LE, OP_LT, OP_GE, OP_GT. divertida
es una función cuyo ÚNICO argumento es de tipo Trabajo. Trabajos es el regreso
tipo.
Descripción: Aplica divertida a cada trabajo en que , y devuelve el primero
trabajo que satisface la comparación lógica: func (trabajo) cpr propuesta de
Ejemplo:
Tamaño JobVirtualMemAvailGet (Job trabajo)
{
Tamaño talla;
sz = JobSizeResReqGet (trabajo, "mem");
retorno (sz);
}
Int. JobWallTimeReqGet (Trabajo trabajo)
{
Int. pared;
Wallt = JobIntResReqGet (trabajo, "walltime");
retorno (wallt);
}
Int. JobCpuTimeUsedGet (Trabajo trabajo)
{
Int. CPU;
cput = JobIntResUseGet (trabajo, "cput");
retorno (cput);
}
Que findQueByName (Establecer Que colas Cordón qnombre)
{
Que q;
foreach (q in colas) {
if ( QueNameGet (q) EQ qnombre ) {
retorno (q);
}
}
volver (NOQUE);
}
sched_main ()
{
Servidor s;
Que What;
Set Que cuadrado;
// obtener local servidor
s = AllServersLocalHostGet ();
// obtener las colas of las Servidor s
sq = ServerQueuesGet (s);
// obtener las cola llamado "rápido" en las
// local servidor
que = findQueByName ( cuadrado, "rápido" );
// Encuentre las 1 trabajo cuyo Walltime requisito
// is == 300:
QueJobFind (que, JobWallTimeReqObtener, OP_EQ, 300);
// Encuentre las 1 trabajo cuyo email dirección a
// notificar Sobre Nosotros trabajo actividad != "bayucan":
QueJobFind (que, JobEmailAddrGet, OP_NEQ,
"bayucan");
// Encuentre las 1 trabajo esa fue creado después de
// or on 3 / 3 / 1997:
QueJobFind (que, JobDateTimeCreatedGet, OP_GE,
(3 | 3 | 1997));
// Encuentre las 1 trabajo esa fue creado después de
// 3: 3: 44:
QueJobFind (que, JobDateTimeCreatedGet, OP_GT,
(3: 3: 44));
// Encuentre las 1 trabajo esa fue creado después de
// 3:3:44 on 3 / 3 / 1997:
QueJobFind (que, JobDateTimeCreatedGet, OP_GT,
(3|3|1997@3:3:44));
// Encuentre las 1 trabajo cuyo cpu equipo usado < 1600:
QueJobFind (que, JobCpuTimeUsedGet, OP_LT, 1600);
// Encuentre las 1 trabajo cuyo virtual memoria
// requisito <= 300 MB:
QueJobFind (que, JobVirtualMemAvailGet, OP_LE,
300 MB);
}
Trabajos QueJobFind ( Que que Alcance Int. función, Int. RCP)
Trabajos QueJobFind ( Que que Alcance Cordón función, Int. RCP)
Trabajos QueJobFind ( Que que Alcance DateTime función, Int. RCP)
Trabajos QueJobFind ( Que que Alcance Tamaño función, Int. RCP)
donde cpr puede ser uno de los siguientes: OP_MAX, OP_MIN, divertida es un
función cuyo único argumento es de tipo Job.
Descripción: Devuelve el trabajo con el valor máximo o mínimo encontrado para
func (trabajo) como se aplica a todos los trabajos en que .
Ejemplo:
Int. JobCpuTimeReqGet (Trabajo trabajo)
{
Int. CPU;
cput = JobIntResReqGet (trabajo, "cput");
retorno (cput);
}
sched_main ()
{
Que What;
Trabajos trabajo;
// Encuentre las Trabajos las más alto cpu equipo
// requisito:
trabajo = QueJobFind (que, TrabajoCpuTimeReqGet, OP_MAX);
// Encuentre las Trabajos las mínimo cpu equipo
// requisito:
trabajo = QueJobFind (que, TrabajoCpuTimeReqGet, OP_MIN);
}
Que QueFilter (Que que, divertido Int. func, Int rcp, Int valor)
Que QueFilter (Que que, divertido Cordón func, Int cpr, cadena valor)
Que QueFilter (Que que, divertido DateTime func, Int cpr, fecha valor)
Que QueFilter (Que que, divertido Tamaño func, Int cpr, tamaño valor)
donde cpr puede ser uno de los siguientes: OP_EQ, OP_NEQ, OP_LE, OP_LT,
OP_GE, OP_GT, divertida es una función cuyo único argumento es de tipo Job.
Descripción: Aplica divertida a cada trabajo en que , y devuelve una nueva que
que contiene todos los trabajos que cumplen la condición de comparación:
func (trabajo) cpr propuesta de
Ejemplo:
Int. JobWallTimeReqGet (Trabajo trabajo)
{
Int. pared;
Wallt = JobIntResReqGet (trabajo, "walltime");
retorno (wallt);
}
sched_main ()
{
Que What;
Que nuevoq;
// Returns a nueva que que contiene todos recibas nuevas vacantes en tu correo in "que"
// a Walltime requisito == 300:
nuevoq = QueFilter (que, JobWallTimeReqObtener, OP_EQ, 300);
// Returns a nueva que que contiene todos recibas nuevas vacantes en tu correo in "que"
// an email dirección != "bayucan":
nuevoq = QueFilter (que, JobEmailAddrGet, OP_NEQ, "bayucan");
// Returns a nueva que que contiene todos recibas nuevas vacantes en tu correo in "que"
// creado después de or on 3 / 3 / 1997:
nuevoq = QueFilter (que, JobDateTimeCreatedGet, OP_GE,
(3 | 3 | 1997));
// Returns a nueva que que contiene todos recibas nuevas vacantes en tu correo in "que"
// creado después de 3: 3: 44:
nuevoq = QueFilter (que, JobDateTimeCreatedGet, OP_GT,
(3: 3: 44));
// Returns a nueva que que contiene todos recibas nuevas vacantes en tu correo in "que"
// creado después de 3:3:44 on 3 / 3 / 1997:
nuevoq = QueFilter (que, JobDateTimeCreatedGet, OP_GT,
(3|3|1997@3:3:44));
// NOTA: El reconocida por "que" is no modificado
// .
}
Int. Ordenar (Establecer Trabajos s, Alcance Int. llave, Int. orden)
Int. Ordenar (Establecer Trabajos s, Alcance Cordón llave, Int. orden)
Int. Ordenar (Establecer Trabajos s, Alcance Flotador llave, Int. orden)
Int. Ordenar (Establecer Trabajos s, Alcance DateTime llave, Int. orden)
Int. Ordenar (Establecer Trabajos s, Alcance Tamaño llave, Int. orden)
donde s el conjunto de trabajos para clasificar. clave es la clave de clasificación que es una
función cuyo único argumento es de tipo Job, solicite es la clasificación
orden: ASC, DESC.
Descripción: ordena los elementos de s , en ASCending o
DESCENDENTE Orden de valores que fueron devueltos por el clave funcionan como
aplicado a todos los miembros del conjunto de trabajos. los s el objeto es modificado
con esta llamada. Esto devuelve ÉXITO o FALLO según el resultado de
el tipo.
Ejemplos:
Tamaño JobMemReqGet (Trabajo trabajo)
{
Tamaño memoria;
Miembro = JobSizeResReqGet (trabajo, "mem");
volvemos(mem);
}
sched_main ()
{
Servidor Maestro;
Set Trabajos trabajos;
Int. pedido;
// obtener local servidor
dominar = AllServersLocalHostGet ();
recibas nuevas vacantes en tu correo = ServerJobsObtener(Maestro);
Ordenar (trabajos, TrabajoPrioridadObtener, ASC);
Ordenar (trabajos, ID de trabajo, DESC);
solicite = ASC;
Ordenar (trabajos, JobDateTimeCreatedGet, pedido);
solicite = DESC;
Ordenar (trabajos, JobMemReqObtener, pedido);
}
Int. Ordenar (Establecer Que s, Alcance Int. llave, Int. orden)
Int. Ordenar (Establecer Que s, Alcance Cordón llave, Int. orden)
Int. Ordenar (Establecer Que s, Alcance Flotador llave, Int. orden)
Int. Ordenar (Establecer Que s, Alcance DateTime llave, Int. orden)
Int. Ordenar (Establecer Que s, Alcance Tamaño llave, Int. orden)
donde s el conjunto de colas para ordenar. clave es la clave de clasificación que es una
función cuyo único argumento es de tipo Que, solicite es la clasificación
orden: ASC, DESC.
Descripción: ordena los elementos de s , en ASCending o
DESCENDENTE Orden de valores que fueron devueltos por el clave funcionan como
aplicado a todos los miembros del conjunto de colas. los s objeto es
modificado con esta llamada. Esto devuelve SUCCESS o FAIL dependiendo de
resultado del género.
Ejemplos:
Tamaño QueMemAvailGet (Que What)
{
Tamaño memoria;
Miembro = QueSizeResAvailGet (que, "mem");
volvemos(mem);
}
sched_main ()
{
Servidor Maestro;
Set Que pregunta;
Int. pedido;
// obtener local servidor
dominar = AllServersLocalHostGet ();
cuestión = ServidorColasObtener(Maestro);
Ordenar (ques, QuePrioridadObtener, ASC);
Ordenar (ques, QueNombreObtener, ASC);
solicite = DESC;
Ordenar (ques, QueMemAvailGet, pedido);
}
Int. Ordenar (Establecer Servidor s, Alcance Int. llave, Int. orden)
Int. Ordenar (Establecer Servidor s, Alcance Cordón llave, Int. orden)
Int. Ordenar (Establecer Servidor s, Alcance Flotador llave, Int. orden)
Int. Ordenar (Establecer Servidor s, Alcance DateTime llave, Int. orden)
Int. Ordenar (Establecer Servidor s, Alcance Tamaño llave, Int. orden)
donde s el conjunto de servidores para ordenar. clave es la clave de clasificación que es
una función cuyo único argumento es de tipo servidor, solicite son los
orden de clasificación: ASC, DESC.
Descripción: ordena los elementos de s , en ASCending o
DESCENDENTE Orden de valores que fueron devueltos por el clave funcionan como
aplicado a todos los miembros del conjunto de servidores. los s objeto es
modificado con esta llamada. Esto devuelve SUCCESS o FAIL dependiendo de
resultado del género.
Ejemplos:
Tamaño ServerMemAvailGet (servidor servir)
{
Tamaño memoria;
Miembro = ServerSizeResAvailGet (serv, "mem");
volvemos(mem);
}
sched_main ()
{
Set Servidor servidor;
Int. pedido;
Int. retirado;
servidor = AllServersGet ();
retirado = Ordenar (servidor, ServerMaxRunJobsGet, ASC);
Ordenar (servidor, ServidorInetAddrGet, ASC);
solicite = DESC;
Ordenar (servidor, ServidorMemAvailGet, pedido);
}
Int. Ordenar (Establecer NodoC s, Alcance Int. llave, Int. orden)
Int. Ordenar (Establecer NodoC s, Alcance Cordón llave, Int. orden)
Int. Ordenar (Establecer NodoC s, Alcance Flotador llave, Int. orden)
Int. Ordenar (Establecer NodoC s, Alcance DateTime llave, Int. orden)
Int. Ordenar (Establecer NodoC s, Alcance Tamaño llave, Int. orden)
donde s el conjunto de nodos para ordenar. clave es la clave de clasificación que es una
función cuyo único argumento es de tipo CNode, solicite es la clasificación
orden: ASC, DESC.
Descripción: ordena los elementos de s , en ASCending o
DESCENDENTE Orden de valores que fueron devueltos por el clave funcionan como
aplicado a cada miembro del conjunto de nodos. los s objeto es
modificado con esta llamada. Esto devuelve SUCCESS o FAIL dependiendo de
resultado del género.
Ejemplos:
Tamaño CNodeMyMemAvailGet (CNode cn)
{
Tamaño memoria;
Miembro = CNodeMemAvailGet (cn, "virtual");
volvemos(mem);
}
sched_main ()
{
Set NodoC scnodo;
Int. pedido;
scnodo = AllNodesGet ();
Ordenar (scnode, CNodeIdletimeGet, ASC);
Ordenar (scnode, CNodeNameObtener, ASC);
solicite = DESC;
Ordenar (scnode, CNodeMyMemAvailGet, pedido);
}
CNode..Get () Las funciones
Los valores de retorno de las funciones CNode..Get () discutidas en la sección anterior son
obtenido enviando consultas de recursos al MOM de CNode en cada iteración de programación.
Por ejemplo, CNodeLoadAveGet (nodo) devolverá el valor obtenido de algunos
recurso> consulta (podría ser la cadena "loadave") como se envió al MOM del nodo. los
" -> Las asignaciones CNode..Get () "se establecen internamente, pero se pueden
se pueden agregar más asignaciones modificadas o mediante el archivo de configuración del planificador. La configuración
el archivo se discute en pbs_sched_basl(8B).
Las asignaciones ya establecidas se dan a continuación:
Para todas las arquitecturas:
CNode..Get () real llamar al fortaleza Recurso
======================== =============
CNodeOsGet (nodo) arco
CNodeLoadAveGet (nodo) cargar
CNodeIdletimeGet (nodo) tiempo de inactividad
Use basl2cB en línea usando los servicios de onworks.net
