In most cases, Alpha and I64 systems present to users, and
accept from users, units of memory in a 512-byte quantity called
a pagelet. Thus, one pagelet is the same
size as one VAX page. Also, on an Alpha or I64 8KB computer, 16
pagelets equal 1 Alpha or I64 page. The following conversion table
shows the relationship between pages, pagelets, and bytes:
Quotas control the way in which a process shares its allotment
of a resource with the subprocesses it creates. In addition to restricting
the number of processes that a single user or account has at any
given time, the system uses four types of quotas for sharing resources.
Resource Type Limits describes these quotas.
Table 9 Descriptions of SYSTEM and DEFAULT Accounts
|
Account |
Description |
AST Queue Limit (ASTlm)
|
Limits the sum of the
following amounts: - The number of asynchronous
system trap (AST) requests that a user's process can have outstanding
at one time

- The number of scheduled wakeup requests that a user's
process can have outstanding at one time
This
limit affects all system services that accept an AST address as
an argument, and the Schedule Wakeup ($SCHDWK) system service.
If
the deferred write option (DFW) is enabled, the number of ASTs used
per file is equal to 1, plus the number of record streams, plus
the multibuffer count. Otherwise, the number is 1 plus the number
of record streams. Note that PQL_MASTLMoverrides the account's value
for ASTlm if PQL_MASTLM is larger than ASTlm.
|
Buffered I/O
Count Limit (BIOlm)
|
Limits the number
of outstanding buffered I/O operations permitted for a user's process.
In
a buffered I/O operation, the data transfer takes place from an
intermediate buffer in the system pool, not from a process-specified
buffer. Buffered operations for a user process include terminal
I/O, file system and network I/O, card reader input, and unspooled
printer output. During a buffered I/O operation, the pages containing
the process-specified buffer need not be locked in memory. Note
that PQL_MBIOLM overridesoverrides the account's value for BIOlm
if PQL_MBIOLM is larger than BIOlm.
|
Buffered I/O
Byte Count Limit (Bytlm)
|
Limits
the amount of buffer space that a user's process can use.
This
buffer space is used for buffered I/O operations and for the creation
of temporary mailboxes. It also limits the number of mapping windows
the user can create as segmented (or cathedral) windows. Cathedral
windows are primarily useful for reducing the overhead
required to read large files. Note that PQL_MBYTLM overrides the
account's value for Bytlm if PQL_MBYTLM is larger than Bytlm.
|
CPU Time Limit (CPU)
|
Limits the amount of
CPU time that a user's process can use per session.
The
time must be specified in abbreviated delta format hh:mm:ss.cc.
CPU
is a deductible limit with a suggested typical value of 0 (no limit)
but the value applies only to this instance or to other instances
of the user's processes. CPU is not cumulative across separate sessions
or batch jobs. Note that PQL_MCPULM overrides the account's value
for CPU if PQL_MCPULM is larger than CPU.
|
Direct I/O
Count Limit (DIOlm)
|
Limits the number
of outstanding direct I/O operations permitted to a user's process.
In
a direct I/O operation, the data transfer takes place directly from
a process-specified buffer. Direct I/O operations for a user process
typically include disk and tape I/O. The pages containing this buffer
are locked in memory by the operating system during the direct I/O
operation.
DIOlm is a nondeductible limit. Note that
PQL_MDIOLM overrides the account's value for DIOlm if PQL_MDIOLM
is larger than DIOlm.
|
Enqueue Quota (Enqlm)
|
Limits the number
of locks a process (and its subprocesses) can own. OpenVMS Record
Management Services (RMS) uses the Lock Management facility to synchronize
shared file access, global buffers, and record locks. Because RMS removes
one lock for every shared file, local buffer, global buffer section,
and outstanding record lock, users who expect to perform large amounts
of RMS file sharing should have Enqlm set to a large value.
If
your process performs extensive RMS file sharing without sufficient
enqueue quota, you could receive the SS$_EXENQLM error message.
Furthermore, if your system performs extensive RMS file sharing
and the value of the LOCKIDTBL system parameter is too low, you
could receive the SS$_NOLOCKID error message. Note that whenever
you increase the value of LOCKIDTBL, you might have to increase
the value of the RESHASHTBL system parameter. (See the HP OpenVMS System Management Utilities Reference Manual.)
For
shared files, the value of Enqlm should represent the number of
files open as shared multiplied by the number of locks per process
per file.
- If you use the default
multibuffer counts, estimate the number of locks as 4 for indexed
sequential files and 3 for relative files.

- If you use a value other than the default value
for the multibuffer counts, estimate the number of locks per process
per file as 1 per file, plus the multibuffer count for that file,
plus the number of records locked, which is usually one.
Prior
to OpenVMS Version 7.1, the limit for Enqlm was 32767. Setting Enqlm
to this former maximum value automatically scales Enqlm internally
to the architectural maximum value. Thus, in effect, the process
has an unlimited enqueue quota but does not need the privilege to
ignore quotas.
Use the DCL command SHOW RMS_DEFAULT
to display the default multibuffer counts.
Enqlm is
a pooled limit. Note that PQL_MENQLM overrides the account's value
for Enqlm if PQL_MENQLM is larger than Enqlm.
|
Expiration
Date and Time (EXPIRATION)
|
Qualifier that specifies
the expiration date and time of the account. The /NOEXPIRATION qualifier
removes the expiration date on the account or resets the expiration
time for expired accounts. The /EXPIRATION qualifier does not affect
the expiration of passwords.
|
Open File Limit (Fillm)
|
Limits the number of
files that a user's process can have open at one time. This limit
includes the number of network logical links that can be active
at the same time.
Fillm is a pooled limit. Note that
each open file also requires at least 96 bytes of Bytlm. Note that
PQL_MFILLM overrides the account's value for Fillm if PQL_MFILLM
is larger than Fillm.
|
Job Table Quota (JTquota)
|
Specifies
the initial byte quota with which the jobwide logical name table
is to be created.
JTquota is a pooled quota. Note that
PQL_MJTQUOTA overrides the account's value for JTquota if PQL_MJTQUOTA
is larger than JTquota.
|
Maximum Account Jobs
Limit (Maxacctjobs)
|
Specifies the maximum
number of batch, interactive, and detached processes that might
be active at one time for all users of a single account.
Maxacctjobs
is a systemwide limit.
|
Maximum Detached Processes
Limit (Maxdetach)
|
Specifies the
maximum number of detached processes with the cited user name that
can be active at one time. MAXDETACH can also be used to control
the number of virtual terminals a user can have. To prevent the
user from creating detached processes, specify the keyword NONE.
By default, a user has a value of 0, which represents an unlimited
number.
Maxdetach is a systemwide limit.
|
Maximum Process Jobs
Limit (Maxjobs)
|
Specifies the
maximum number of interactive, batch, and detached processes that can
be active at one time for the cited user name.
Maxjobs
is a systemwide limit.
|
Page File Limit (Pgflquo)
|
Limits the number of
pages that the user's process can use in the system page file. The
page file provides temporary disk storage for pages forced out of
memory by a memory management operation. Pgflquo limits the total
virtual address space that can be created using the Create Virtual
Address Space ($CRETVA) or Expand Program/Control Region ($EXPREG)
system services.
Pgflquo is a pooled limit. Note that
PQL_MPGFLQUOTA overrides the account's value for Pgflquo if PQL_MPGFLQUOTA
is larger than Pgflquo.
|
Subprocess
Creation Limit (Prclm)
|
Limits the
number of subprocesses a user's process can create.
The
process created when a user logs in to the system can in turn create subprocesses.
These subprocesses are all accountable to the user and share the resources
allotted to the initial process.
Prclm is a pooled limit.
|
Timer Queue
Entry Limit (TQElm)
|
Limits either
of the following amounts: - The number
of entries that a user's process can have in the timer queue

- The number of temporary common event flag clusters
that a user's process can have
This
limit does not govern the creation of permanent event flag clusters.
Timer
queue entries are used in time-dependent scheduling; common event
flags are used in synchronizing activities among groups of cooperating
processes.
TQElm is a pooled limit. Note that PQL_MTQELM
overrides the account's value for TQElm if PQL_MTQELM is larger
than TQElm.
|
Default Working
Set Size (WSdef)
|
Sets the initial
working set size limit for a user's process.
WSdef is
a nondeductible limit. If the value specified exceeds the value
of WSquo, the lesser value is used.
|
Working Set
Extent (WSextent)
|
Specifies the maximum size
to which a user's physical memory usage can grow, independent of
the system load. This enlargement of the physical memory for a user
is accomplished by the Adjust Working Set Limit ($ADJWSL) system
service, and is normally done for the user by the operating system
in response to heavy page faulting by the user.
WSextent
is a nondeductible quota. This value should always be greater than
or equal to WSquo. The value is controlled by the system parameter
WSMAX. Note that PQL_MWSEXTENT overrides the account's value for
WSextent if PQL_MWSEXTENT is larger than WSextent.
|
Working Set Quota (WSquo)
|
Specifies the working
set quota. This is the maximum amount of physical memory a user
process can lock into its working set. It also represents the maximum
amount of swap space that the system reserves for this process and
the maximum amount of physical memory that the system allows the
process to consume if the systemwide memory demand is significant.
This parameter guarantees the user that the number of physical pages
specified will be available. The maximum value of WSquo is 64K pages.
WSquo
is a nondeductible quota. This value should be greater than or equal
to WSdef. The value is capped by the system parameter WSMAX. Note
that PQL_MWSQUOTA overrides the account's value for WSquo if PQL_MWQUOTA
is larger than WSquo.
|