LoadLeveler Job Command File Keywords
account_no = < string >
Supports centralized accounting. Allows you to
specify an account number to be associated with a
job. This account number is used when you use the
llacctmrg command to collect data on one or more
jobs. < string > consists of a combination of
numbers and letters.
account_no = beans42
arguments = < argument_list >
List of arguments to supply to the job when it
begins. Separate the arguments with one or more
blanks.
checkpoint = < yes|no >
If you specify "checkpoint = yes", LoadLeveler
checkpoints the program at regular intervals. In
this case the program must be linked with the
LoadLeveler libraries. Otherwise the program is
rejected when LoadLeveler tries to start it.
If you specify "checkpoint = no", LoadLeveler does
not checkpoint the file. The default is
"checkpoint = no".
class < name >
The name of the class associated with the job. If
you do not specify a class, the default job class
is assigned.
comment
Use this keyword to describe characteristics or
distinguishing features of the job
core_limit = {[hardlimit][,softlimit]}
This value specifies the maximum size of a core
file. Express the value as described in
data_limit. The usage examples are similar. The
interpretation of soft and hard limit is the same
as was described in cpu_limit.
cpu_limit = {[hardlimit][,softlimit]}
Specifies the maximum amount of CPU time that a
submitted job can use. The action taken when the
softlimit is exceeded is operating system
dependent. Generally, your job receives a signal
when the softlimit is exceeded and is killed when
the hardlimit is exceeded. Express either the
hardlimit or the softlimit as:
{{hours:}minutes:}seconds{.fraction}
If you specify a fraction, it is rounded to
seconds. Alternatively, the value may be either
of the following strings:
rlim_infinity - indicates the largest positive
number
unlimited - same as rlim_infinity
copy - indicates to use the limit currently active
when the job is submitted.
Some examples are:
cpu_limit = 12:56:21
sets a hardlimit to 12 hrs 56 min and 21 sec
cpu_limit = ,56:21
sets a softlimit to 56 min and 21 sec
cpu_limit = 1:03,21
sets a hardlimit to 63 sec and a softlimit to 21
sec
cpu_limit = unlimited
sets a hardlimit to 2,147,483,647 secs
(0x'7fffffff')
cpu_limit = ,copy
sets a softlimit to the softlimit on the
submitting machine.
Hard Limits:
You can provide the hard limit in the command
file. The administrator can specify a hard limit
upper bound in the class stanza of the LoadL_admin
file. If the hard limit is defined in both the
command file and in the LoadL_admin file, and if
the hard limit from the command file is less than
or equal to the hard limit in the LoadL_admin
file, use the hard limit from the command file.
If that value exceeds the hard limit that exists
on the machine that is running the job, the hard
limit on the machine is raised to the value
supplied in the command file. Otherwise, if the
hard limit is greater than the hard limit from the
LoadL_admin file, this is an error.
If the hard limit is defined in the command file
but not in the LoadL_admin, and if the hard limit
from the command file is less than the hard limit
on the machine that runs the job, use the hard
limit from the command file. Otherwise, lower the
hard limit from the command file to equal the hard
limit on the machine.
If the hard limit is not defined in the command
file but is defined in the LoadL_admin file, use
the hard limit found in the LoadL_admin file. If
it exceeds the hard limit on the machine that is
running the job, raise the hard limit on the
machine to the value supplied in the LoadL_admin
file. Otherwise, use the hard limit that exists
on the machine that runs the job.
Soft Limits:
The soft limits are provided by you in the command
file. Only hard limits appear in the LoadL_admin
file.
If you provide both a soft and a hard limit, the
soft limit must be less than or equal to the hard
limit. If you only provide a soft limit, if the
soft limit exceeds the hard limit from the
LoadL_admin file, you receive a warning and the
job is submitted. In this case, the soft limit is
lowered to equal the hard limit defined in the
LoadL_admin file.
If a hard limit exists in the LoadL_admin file and
if your soft limit exceeds the hard limit on the
machine that runs your job, the soft limit is
lowered to equal the hard limit on the machine.
If you do not provide a soft limit, the soft limit
on the machine that runs your job is used.
data_limit = {[hardlimit][,softlimit]}
This value specifies the maximum size of the data
segment that is used by the submitted job,
expressed as:
integer{.fraction}{units}
where integer and fraction represent strings of up
to eight digits. The units may be:
b - bytes
w - words
kb - kilobytes (2**10 bytes)
kw - kilowords (2**10 words)
mb - megabytes (2**20 bytes)
mw - megawords (2**20 words)
gb - gigabytes (2**30 bytes)
If you do not specify units, bytes are assumed.
The interpretation of soft and hard limits are the
same as described in cpu_limit.
EXAMPLES
data_limit = ,125621
125,621 bytes soft limit
data_limit = 5621kb
5,755,904 bytes hard limit
data_limit = 2mb
2,097,152 bytes hard limit
data_limit = 2.5mw,2mb
10,485,760 bytes hard limit, 2mb soft limit
data_limit = unlimited
2,147,483,647 bytes (0x'7fffffff') hard limit
data_limit = ,copy
The data soft limit on the submitting machine
dependecy = < expression >
Specifies the dependencies between job steps, where the
syntax for the expression is as follows:
step_name operator value
where step_name must be a previously defined job
step and operator can be one of the following:
== equal to
!= not equal to
<= less than or equal to
>= greater than or equal to
< less than
> greater than
&& and
|| or
For example:
dependency = (step1 == 0) && (step2 > 0)
environment = < parameter_list >
Specifies your initial environment variables when
your job starts. Separate environment
specifications with semicolons. An environment
specification may be one of:
COPY_ALL - All the environment variables from your
shell at the time the submit was issued should be
copied.
$var - The environment variable "var" is copied
into the environment of your job when started.
!var - Do not copy the environment variable "var".
This is used in conjunction with COPY_ALL
var=value - The environment variable "var" is set
to "value" and copied into the environment of your
job when started.
Warning: environment strings have a maximum length
restriction of 4096 bytes (or less depending upon
the arguments specified with the arguments
keyword, if any). If your environment exceeds
this maximum, a warning message is issued, and the
copied environment is truncated.
error = < filename >
Specifies the name of the file to use as standard error
(stderr) when your job step runs. If you only specify
this keyword in the first job step, its value is inherited
to the other job steps. If not specified, the file /dev/null
is used.
For example:
error = $(jobid).$(stepid)
executable = < name >
The name of the executable file for this job
cluster. This may appear 0 or 1 times in each job
command file. If it is omitted, the file itself
is used as the executable.
When the job command file itself is the
executable, then it must be marked as executable
(chmod +x).
file_limit = {[hardlimit][,softlimit]}
This value specifies the maximum size of a file
that is created. Express the value as described
in data_limit. The usage examples are similar. The
interpretation of soft and hard limit is the same
as was described in cpu_limit.
group = < group name >
Specifies the LoadLeveler group. If not specified, this
defaults to the default group.
For example:
group = my_group_name
hold = < user|system|usersys >
This keyword specifies whether to place the job in
a hold state when you submit it.
user - The job is placed in user hold.
system - The job is placed in system hold.
usersys - The job is placed in both user hold and
system hold.
Use the llhold command to release the job. The
user may release his job from user hold but only a
system administrator may release a job from system
hold.
image_size = < size >
This specifies the maximum size, in kilobytes,
that the virtual image of the job is expected to
grow. LoadLeveler executes your job only on
machines which have enough resources to support
executing and checkpointing your job. If you do
not specify the image size of your job in the
command file, LoadLeveler assumes its size. If
you underestimate the image size of your job, it
may crash due to inability to acquire more address
space. If you overestimate the image size,
LoadLeveler may have difficulty finding machines
which have the required resources.
initialdir = directory
Specifies the pathname of the directory to be the
initial working directory during execution of your
job. If it doesn't start with "/" then the current
directory is prepended to the directory specified.
The default is the current working directory.
input = < pathname >
Specifies the name of the file to use as standard input
(stdin) when your job step runs. If not specified, the file
/dev/null is used. If you only specify this keyword in the
first job step, its value is inherited to the other job
steps.
For example:
input = input.$(process)
job_cpu_limit = < {{hours:}minutes:}seconds{.fraction} >
Specifies the maximum CPU time to be used by all processes
of a job step. For example, if a job step forks to produce
multiple processes, the sum total of CPU consumed by all of
the processes is added and controlled by this limit.
If you specify a fraction, it is rounded to seconds.
job_name = < string >
Specifies the name of the job. This keyword must be specified
in the first job step. If it is specified in other job steps
in the job command file, it is ignored. You can name the
job using any combination of letters and/or numbers.
For example:
job_name = my_first_job
job_type = < string >
Specifies the type of job step to process. If you only
specify this keyword in the first job step, its value
is inherited to the other job steps. Valid entries are:
pvm3 - PVM jobs. This is not for PVMe jobs
parallel - For other parallel jobs (MPL, PVMe)
serial - For serial jobs
If not specified, the job will be serial.
For example:
job_type = pvm3
notification = < when >
Owners of LoadLeveler jobs are notified by mail
when certain events occur. If < when > is set to
Always mail is sent whenever the job begins, ends,
or if it incurs error conditions.
Error mail is sent only if the job fails.
Start mail is sent only when the job begins.
Never mail is not sent.
Complete mail is sent when the job ends. This is
the default.
notify_user = username
username is the mail address where mail is sent
based on the notification keyword. The format is
whatever is acceptable to the mailer. For
example:
notify_user = maint@ykt.watson.ibm.com
The default is to send mail to the job owner (the
submitter) at the submitting host.
output = < pathname >
Specifies the name of the file to use as standard output
(stdout) when your job step runs. If not specified, the file
/dev/null is used. If you only specify this keyword in the
first job step, its value is inherited to the other job
steps.
For example:
output = output.$(process)
parallel_path = < directory >
Used for PVM. Tells the PVM process where to look for the
executables when the parallel job spawns tasks.
For example:
parallel_path = /u/tadj/cmds/pvm/$pvm_arch
preferences = < boolean_expression >
This is a list of characteristics desired but not
necessary in a machine running this job. Specify
it in the same way as requirements. Machines
satisfying these preferences are supplied if
available, but otherwise any machine meeting the
requirements is used.
queue
This keyword creates the next job in the cluster.
One copy of the job is placed in the job queue.
Other keywords are used to change values
established earlier. For example:
If desired, you can issue new input output error
and arguments between queue keywords.
At least one queue keyword is required in a
LoadLeveler command file.
requirements = < boolean_expression >
This is a list of requirements which a remote
machine must meet to execute any jobs in the
cluster. The supported requirements are:
"Memory", "Arch", "OpSys", "Feature", "Machine" or
"Disk".
"Memory", is the amount of physical memory
required on the remote workstation expressed in
megabytes.
"Disk", is the amount of disk space required on
the remote workstation expressed in megabytes.
"Machine", is the host name that this job must run
on. If there are no dots found in the name then
the domain of the submitting machine is added.
"Feature" is a string that identifies a feature
that exists on a particular machine.
"Arch" is the machine architechture.
"OpSys" is the operating system. The platforms
supported by the this version of LoadLeveler are:
Arch Opsys Description
R6000 AIX32 IBM R6000 (AIX3.2)
SPARC SUNOS41 SPARCstation (SunOS 4.1)
If you do not specify "Arch" and "OpSys"
requirements in the command file, defaults which
match the submitting machine are supplied. The
job must have been compiled and linked on a
machine which matches the "Arch" and "OpSys"
requirements.
The requirements keyword is a boolean expression
using C-like operators. For example:
requirements = (Memory >= 16 && (Arch == "R6000"
|| Arch == "SPARC") && Feature == "SQL")
This requests that the job run on an IBM RISC
System/6000 or on a Sun SPARCstation that has the
SQL program product and at least 16 megabytes of
memory.
restart = < yes | no >
Specifies whether this job be restarted if it is stopped
for some reason. You cannot code "restart = no" and
"checkpoint = yes".
rss_limit = {[hardlimit][,softlimit]}
This value specifies the maximum resident set
size. Express the value as described in
data_limit. The usage examples are similar. The
interpretation of soft and hard limit is the same
as was described in cpu_limit.
shell = name
Specifies the name of the shell to use for this
job. The default is the shell defined in the
owner's password file. If a shell definition is
not found in the password file, /bin/sh is the
default.
stack_limit = {[hardlimit][,softlimit]}
This value specifies the maximum size of a the
stack. Express the value as described in
data_limit. The usage examples are similar. The
interpretation of soft and hard limit is the same
as was described in cpu_limit.
startdate = < date > < time >
Date and time your job should start. Your job
will not start before this date and/or time. If
you do not specify this, the current date and time
are assumed.
specify < date > as (MM/DD/YY).
specify < time > as (HH:MM(:SS)).
stepname = < string >
Specifies the name of the job step. You can name the job step
using any combination of letters, numbers, underscores (_)
and periods (.). You cannot, however, name it T or F, or use
a number in the first position of the step name. If you don't
specify step names, by default, the first job step is named
the character string "0", the second is named the character
string "1", and so on.
For example:
step_name = step_3
user_priority = < prio >
Sets the initial priority of your job. It orders
jobs you submitted with respect to other jobs
submitted by you, not with respect to jobs
submitted by other users. The priority of a job
ranges from 0 to 100. Jobs with higher priorities
run before jobs with lower priorities. The
default priority is 50.
wall_clock_limit = {[hardlimit][,softlimit]}
Sets the elapsed time for which a job can run. In
computing the elapsed time for a job, LoadLeveler
considers the start time to be the time the starter
process is executed. The action taken when the
softlimit is exceeded is operating system
dependent. Generally, your job receives a signal
when the softlimit is exceeded and is killed when
the hardlimit is exceeded. Express either the
hardlimit or the softlimit as:
{{hours:}minutes:}seconds{.fraction}
If you specify a fraction, it is rounded to
seconds.
COPYRIGHT INFORMATION
* (C) COPYRIGHT International Business Machines Corp. 1992
* All Rights Reserved
* Licensed Materials - Property of IBM
*
* US Government Users Restricted Rights - Use, duplication
* or disclosure restricted by GSA ADP Schedule Contract with
* IBM Corp.