LIMITS - set activity limits and starting sizes.
Syntax:
$ LIMITS cpu_time,prog_mem,load_mem,lines,io_time,
pat_mem,syo_mem
Examples:
$ LIMITS 4,20K,,5K
$ LIMITS 4
$ LIMITS 4,100k,-2k Give GELOAD more table space
$ LIMITS 3,,,,,6k Extra PAT space
Where:
- cpu_time
- This specifies the limit on the CPU time that can be used for this
activity.
The value is in hundredths of an hour (36 second units).
If not specified a default is chosen based on the type
of activity definer.
The maximum value is 9999, which is just short of 100 hours.
- prog_mem
- For single segment programs, this specifies the starting
memory allocation for the program.
The value is expressed in words, but will be rounded up to the
next page (1024 words) boundary.
The suffix "k" can be used to express the size in pages.
I.e. "8k" has the same meaning as "8192".
As with cpu_time, the default is chosen based on the activity type.
This field is ignored for multi-segment programs.
- load_mem
- This field only has meaning for $EXECUTE activities,
and controls how much extra memory is added to 'prog_mem'
for GELOAD's code and tables.
As with 'prog_mem' the value is rounded up to the next page.
If the field is not specified a value of zero is assumed.
Before GELOAD is loaded, the initial memory size is set to
'prog_mem+(8k-load_mem)'.
GELOAD is then loaded into the low part of the segment
and it begins linking the program into the remainder of the segment.
If this is a load-and-go $EXECUTE,
then when GELOAD has finished,
it will do a GEMREL to release the lower '8k-load_mem'
and pass control to the program.
Thus a positive value for 'load_mem' will allow GELOAD and its tables
to overlap uninitialized lower parts of the program memory.
This can save memory with high loaded programs since the lower
addresses will be used for the initial core hole and/or blank common.
A negative value for 'load_mem' is used when the default table
space is not large enough, and more memory needs to be set aside
for GELOAD's symbol table.
Since the default space for GELOAD and its tables is 8k,
positive values large than 8k are not meaningful,
and may be reduced to 8k.
- lines
- This specifies the maximum number of records that can be written to
SYSOUT.
The value is not rounded up, but the "k" suffix may be used to
express the value in units of 1024 records.
A prefix of "p" may be specified for security,
and indicates that the output may not be reprinted.
(REPRO requests from the console or JOUT will not be honoured.)
The field must not exceed 6 characters including any "p" prefix
or "k" suffix characters.
If not specified a default is chosen based on the type of activity.
- io_time
- This specifies the total I/O channel time than can be used by the
activity.
As with 'cpu_time', the units are hundredths of an hour.
The default is not to limit I/O time.
- pat_mem
- Specifies the amount of memory in words to allocate to the PAT segment.
The value can range from 1k to 16k.
If not specified a value is computed based on the file control
cards for the activity ($FILE, $PRMFL, $TAPE etc.).
This may not be sufficient if the program dynamically attaches
a large number of files with different file codes.
- syo_mem
- Specifies the number of words for the sysout buffer/collection
segment.
The value must be between 1k and 8k.
The default is to compute a value based on the sysout record
limit field ('lines').
The computed value never exceeds 4k, so for some jobs there
may be a performance improvement from increasing the size.
Description:
$LIMITS modifies the standard activity limits and memory allocations.
If a program exceeds the CPU time or sysout record limit,
it is aborted and the limits is extended some to allow dump and
wrpaup processing.
There is a site option to offer the operator a chance to extend the
limit instead of aborting the activity.
If the site selected the option, and the operator elects to continue
the job, the CPU time will be extended in 5 minute increments,
and the sysout limit will be extended in 10k increments.
The memory size ('prog_mem' and 'load_mem') for single segment programs
is just a starting value.
The true limit is the hardware limit of 256k in a segment,
and the program may grow the ISR to that size.
The 'pat_mem' and 'syo_mem' fields fix the size of these segments for
the whole job step and the program cannot dynamically grow them.
Setting the sysout collection area too small may result in some performance
degradation.
Setting the PAT segment too small will cause dynamic file attach calls
to fail.
Job limits
Normally, a $LIMITS card is placed after the activity definer,
and specifies the limits for just that activity.
A $LIMITS card place before the first activity card will set
total CPU time, sysout record and I/O time limits for the whole job.
Each activity will be started with the minimum of the limits from
its own $LIMITS and the limit remaining for the whole job.
(I.e. that portion of the limit not used by previous activities.)
Copyright © 2000, Thinkage Ltd.