| Previous | Contents | Index |
The OpenVMS user name under which the QTI runs must have OpenVMS SYSPRV and SYSLCK privileges. Define this user name with the ACMSGEN parameter QTI_USERNAME. The user name must be authorized in the UDU authorization file as an agent.
The OpenVMS user name under which the QTI runs requires the minimum quotas shown in Table A-4.
| Minimum Value | ||
|---|---|---|
| Parameter | VAX | Alpha |
| ASTLM | 40 | 250 |
| BIOLM | 40 | 150 |
| BYTLM | 32768 | 64000 |
| DIOLM | 40 | 150 |
| ENQLM | 200 | 2000 |
| FILLM | 100 | 100 |
| PGFLQUOTA | 32768 | 50000 |
| TQELM | --- | --- |
| WSDEFAULT | --- | --- |
| WSEXTENT | --- | --- |
| WSQUOTA | --- | --- |
WSEXTENT is usually higher than WSQUOTA to make the most of the OpenVMS
dynamic working set size adjustment algorithms. To set reasonable
figures, monitor the live system to determine the page fault rate of
the QTI process.
A.2.4.1 How ACMSPARAM.COM Calculates Values for the QTI
This section shows the formulas for how ACMSPARAM.COM calculates parameter values for the QTI. If the calculated values are below the minimum values shown in Table A-4, then ACMSPARAM.COM assigns the minimum values.
Use these formulas for information or fine-tuning purposes only. Compaq recommends that you use the ACMSPARAM.COM procedure, which is discussed in detail in Chapter 10, to perform these calculations to determine the QTI quota values.
Refer to Table 10-3 for descriptions of the variables shown in these calculations.
WSDEFAULT = 512 + (20*QTI_TASK_THDS) ! Working set WSEXTENT = 4096 + (50*QTI_TASK_THDS) ! sizes for WSQUOTA = 1024 + (50*QTI_TASK_THDS) ! QTI user name |
WSDEFAULT = 2000 + (20*QTI_TASK_THDS) ! Working set WSEXTENT = 16384 + (50*QTI_TASK_THDS) ! sizes for WSQUOTA = 4000 + (50*QTI_TASK_THDS) ! QTI user name |
ASTLM = 24 + ! base
(QTI_TASK_THDS * 2) + ! one AST for each thread
(2 * QTI_SUBMITTERS) + ! session receives and messages
(3 * QTI_QUEUES) ! RMS overhead
|
BIOLM = 18 + ! base
QTI_TASK_THDS ! MSS DECnet i/o
|
BYTLM = 8192 + ! base
(2 * REMOTE_APPL_CNT * ! 2 MSS buffers for each link
MSS_MAXBUF) +
(2048 * QTI_QUEUES) + ! RMS overhead
(1024 * QTI_TASK_THDS)
|
DIOLM = 18 + ! base
QTI_TASK_THDS ! disk i/o
|
ENQLM = 69 + ! base
(15 * QTI_TASK_THDS) + ! RMS
(QTI_QUEUES * 4) ! ASTs and locking
|
FILLM = 20 + ! base
REMOTE_APPL_CNT + ! DECnet links
QTI_QUEUES ! 1 for each queue file
|
PGFLQUOTA =
8192 + ! base
MSS_PROCESS_POOL + ! MSS pool
(5831 + ! buffer for each operator request
(QTI_TASK_THDS *
(16272 + QTI_MAX_WSP_SIZE)) + ! buffer for each task thread
(QTI_QUEUES * 792) + ! buffer for each task queue
(QTI_SUBMITTERS *
(MSS_MAXBUF + 2064)) + ! buffer for each submitter
512) / 512
Include 10% for expansion
PGFLQUOTA = PGFLQUOTA + (PGFLQUOTA/10)
|
TQELM = 20 + ! base
(QTI_TASK_THDS * 2) ! one timer for each thread
|
The OpenVMS user name under which the EXC runs must have OpenVMS SETPRV and SYSPRV privileges. Define this user name with the ADU application definition clause APPLICATION USERNAME.
The OpenVMS user name under which the EXC runs requires the minimum quotas shown in Table A-5.
| Minimum Value | ||
|---|---|---|
| Parameter | VAX | Alpha |
| ASTLM | 40 | 250 |
| BIOLM | 40 | 150 |
| BYTLM | 32768 | 64000 |
| DIOLM | 40 | 150 |
| ENQLM | 200 | 2000 |
| FILLM | 100 | 100 |
| PGFLQUOTA | 32768 | 50000 |
| TQELM | --- | --- |
| WSDEFAULT | --- | --- |
| WSEXTENT | --- | --- |
| WSQUOTA | --- | --- |
WSEXTENT is usually higher than WSQUOTA to make the most of the OpenVMS dynamic working set size adjustment algorithms. To set reasonable figures, monitor the live system to determine the page fault rate of the EXC process.
The EXC user name requires access to
application databases (.ADB files), task group databases (.TDB files),
message files, and request libraries.
A.2.5.1 How ACMEXCPAR.COM Calculates Values for the EXC
This section shows the formulas for how ACMEXCPAR.COM calculates parameter values for the CP. If the calculated values are below the minimum values shown in Table A-5, then ACMEXCPAR.COM assigns the minimum values.
Use these formulas for information or fine-tuning purposes only. Compaq recommends that you use the ACMEXCPAR.COM procedure, which is described in Chapter 10, to perform these calculations to determine the EXC quota values.
Refer to Table 10-3 for descriptions of the variables shown in these calculations.
WSDEFAULT 256 + (20 * EXC_TK_INSTANCE_CNT) ! Working set quotas WSEXTENT 4096 + (50 * EXC_TK_INSTANCE_CNT) ! for the WSQUOTA 1024 + (20 * EXC_TK_INSTANCE_CNT) ! EXC user name |
WSDEFAULT 2000 + (20 * EXC_TK_INSTANCE_CNT) ! Working set quotas WSEXTENT 16384 + (50 * EXC_TK_INSTANCE_CNT) ! for the WSQUOTA 4000 + (20 * EXC_TK_INSTANCE_CNT) ! EXC user name |
ASTLM = 24 + ! base
(5 * EXC_TK_INSTANCE_CNT) + ! terminal i/o + DECnet sends
EXC_SP_CNT + ! max SP's for this appl
EXC_SERVER_CNT + ! num of servers defined for appl
(2 * AGENT_CNT) ! MSS receives from agents
|
BIOLM = 10 + ! base
EXC_TK_INSTANCE_CNT + ! TDMS i/o and MSS network sends
(2 * REMOTE_AGENT_CNT) ! DECnet receives
|
BYTLM = 8192 + ! base
(1000 * LOCAL_TDMS_TASK_CNT) + ! TDMS i/o
(((2 * REMOTE_AGENT_CNT) + ! MSS DECnet link receives
REMOTE_TK_INSTANCE_CNT)
* MSS_MAXBUF) + ! MSS DECnet link sends
(MAXPROCESSCNT * 84) ! SP termination notification
|
DIOLM = 20 + ! base
EXC_TK_INSTANCE_CNT ! rlb i/o
|
ENQLM = 20 + ! base
((EXC_RLB_CNT + EXC_MSG_CNT +
FORM_CNT +
EXC_TDB_CNT) * 4) ! rlb, tdb and msg file opens & I/O
|
FILLM = 20 + ! base
EXC_RLB_CNT + ! rlbs
FORM_CNT + ! DECforms forms
EXC_MSG_CNT + ! message files
EXC_TDB_CNT + ! tdbs
(2 * REMOTE_AGENT_CNT) ! DECnet channels
|
PGFLQUOTA = 7500 + ! base
(20 * EXC_TK_INSTANCE_CNT) + ! EXC's task context
((TWS_POOLSIZE + TWSC_POOLSIZE)
* EXC_TDB_CNT) + ! WKSP pools
(WS_POOLSIZE + WSC_POOLSIZE) + ! group/user wksp pools
MSS_PROCESS_POOL + ! MSS process pool
EXC_RLB_BLKS + ! rlb caching
(LOCAL_TDMS_TASK_CNT * 100) + ! Local TDMS tasks
EXC_ADB_BLKS + ! Size of ADB
EXC_TDB_BLKS ! Size of TDBs
|
TQELM = 1 + ! base
(2 * EXC_SERVER_CNT) + ! server management
EXC_TK_INSTANCE_CNT + ! ast for each task instance for i/o
EXC_SP_CNT ! server process communications
|
This section shows how to derive the minimum quotas required for the server processes. By increasing the base default value assigned to the AUTHORIZE quota by the amounts shown in Figure A-1, you can determine the minimum server process quota.
In Figure A-1, the number represented by BASE is the default value assigned to the AUTHORIZE quota. This number represents the base quota requirement for the processing being done in the server (not for the server process itself). The BASE amount varies for each ACMS system. Generally, the default BASE quota assigned for the process is sufficient. The number after BASE + indicates the minimum amount that should be added to bring the quota value up to the minimum required by the ACMS server process.
The only privilege ACMS requires server processes to have is TMPMBX. The quotas required by an ACMS server process are dependent on the type of processing the server performs.
Figure A-1 Minimum Quotas for Server Processes
ASTLM BASE + 2 ! for procedure servers
BASE + 4 ! for DCL servers
BIOLM BASE + 2 !for procedure servers
BASE + 4 !for DCL servers
BYTLM BASE + 2000
DIOLM BASE + 2
FILLM BASE + 10
PGFLQUOTA BASE + MSS_PROCESS_POOL + 200
|
Check the DBMS and Rdb installation guides if your server code accesses
these products. Additional resources required for using these products,
such as ENQLM, are explained in the appropriate installation guides.
A.3 Calculating Quotas for Using the ADU Utility
Users who plan to use the ADU must set quotas equal to or greater than the minimum values shown in Figure A-2. Be sure to refer to documentation for related products, such as the CDD dictionary, for further quota limits that may be required.
Figure A-2 Minimum Quotas for Using ADU
ENQLM 100
FILLM 25 + (the number of files specified with the /OBJECT
qualifier to the BUILD GROUP command)
+ (the number of files specified with the
/USERLIBRARY qualifier to the BUILD GROUP
command)
+ 2 ! if STARTLET.OLB and IMAGELIB are
! searched when resolving
! global symbols
PRCLM 1
|
Determining the values for the working set (WSDEFAULT, WSEXTENT, WSQUOTA) and the PGFLQUOTA involves experimentation and modification over time. Some factors to consider when setting these values include:
ADU typically requires higher quotas than those set by default for the
working set and the PGFLQUOTA.
A.4 Calculating Quotas for Using the ACMS Task Debugger
Users who plan to run tasks under the task debugger must set quotas equal to or greater than those listed in Figure A-3. The only privilege ACMS requires server processes to have is TMPMBX.
Figure A-3 Minimum Quotas for Using the Task Debugger
ASTLM 10
BYTLM 50000
ENQLM 100
FILLM 96
PRCLM 1 + maximum number of servers that can
be started by the task debugger
TQELM 10
|
Users might need a BYTLM value greater than 50,000 if they start the task debugger with the /WORKSPACE_DEBUG qualifier and start more than one server during a task debugging session. Also, the subprocess quota should be greater than 1 to allow the task debugger to start subprocesses.
See Compaq ACMS for OpenVMS Writing Server Procedures for complete information on the ACMSDEBUG Utility and
the associated ACMS/DEBUG commands.
A.5 Calculating Values for Certain ACMSGEN Parameters
ACMS provides values for ACMSGEN parameters as defaults or through ACMSPARAM.COM. These values normally suffice; however, for several ACMSGEN parameters you may want to calculate values independently to more accurately reflect your ACMS system. In such cases, include the new value as a variable in ACMVARINI.DAT that corresponds to the ACMSGEN parameter. Then run ACMSPARAM.COM. The command procedure uses the new variable value to generate a new ACMSGEN parameter.
The following sections describe the calculations for the ACMSGEN
parameters whose values you may want to change from the values supplied
by default or by ACMSPARAM.COM.
A.5.1 Calculating the Value of MAX_LOGINS
MAX_LOGINS limits the number of users who can sign in to ACMS.
To increase the effective value for the ACMSGEN parameter MAX_LOGINS, you may also have to change the value of the parameters MAX_TTS_CP or CP_SLOTS. A user can sign in only if ACMS can assign the user's terminal to a Command Process (CP). The total number of terminals all your Command Processes can handle is the product of:
The number of users who can sign in can never be greater than the product of the MAX_TTS_CP value and the CP_SLOTS value. Once the value you set for the MAX_LOGINS parameter reaches the product of the MAX_TTS_CP and CP_SLOTS parameters, merely increasing the value of the MAX_LOGINS parameter has no effect. To increase the number of users who can sign in, you must also increase the value of the MAX_TTS_CP or the CP_SLOTS parameter.
The ACMSGEN parameter MAX_LOGINS is only checked for task submitters signing in through the TSC. Any other sign-ins (from user-written agents, detached tasks, and the QTI) are not counted against the MAX_LOGINS value.
If you have a large number of users who sign in through user-written agents, detached tasks, and the QTI, you may want to fine-tune the working set size of the ACC. ACMSPARAM.COM uses the following minimum values for ACC's working set quotas:
| Minimum Value | ||
|---|---|---|
| Parameter | VAX | Alpha |
| WSDEFAULT | 256 | 2000 |
| WSEXTENT | 4096 | 16384 |
| WSQUOTA | 1024 | 4000 |
The WSDEFAULT and WSEXTENT quotas may be low for the ACC user name if
there are many sign-ins/sign-outs. WSEXTENT is usually higher than
WSQUOTA to make the most of the OpenVMS dynamic working set size
adjustment algorithms. To set reasonable figures, monitor the live
system to determine the page fault rate of the ACC process and set the
working set quotas appropriately.
A.5.2 Calculating the Value of MSS_MAXOBJ
The ACMSGEN message switch parameter MSS_MAXOBJ is the number of message switch objects that can be created on a system at one time. The ACMSPARAM.COM calculation of MSS_MAXOBJ follows:
MSS_MAXOBJ = 15 + (CP_PROC_CNT * (4 + TERMINALS_PER_CP))
+ (2 * OPR_ENTER_RETURN_CNT)
+ (6 * APPL_CNT)
+ (3 * TOTAL_SP_CNT)
+ QTI_SUBMITTERS
+ ((AGENT_CNT * 3) + AGENT_SUB_CNT)
+ (2 * OPERATOR_CNT)
+ (5 * DEBUGGER_CNT)
MSS_MAXOBJ = MSS_MAXOBJ + (.10 * MSS_MAXOBJ)
|
The ACMSGEN message switch parameter MSS_MAXBUF is the size of a buffer that the ACMS message switch uses to handle message traffic. If this buffer is not large enough to hold a message, the message is sent in blocks.
ACMSPARAM.COM calculates MSS_MAXBUF based on the largest message passed in an exchange step in your application so that you never incur the cost of message blocking. The ACMSPARAM.COM calculation of MSS_MAXBUF follows:
MSS_MAXBUF = 280
+ LARGEST_MESSAGE
+ (17 * LARGEST_MESSAGE_NUM_WKSP)
MSS_MAXBUF = MSS_MAXBUF + MSS_MAXBUF/10
|
This formula is based on a DECforms request and is also the one used in the ACMSPARAM.COM file. If you wish to determine more accurately the value of the MSS_MAXBUF parameter, use the following formula:
MAX_MAXBUF = 216
+ RECORD_REQUEST_NAMES
+ ( NUM_WSPS * 17 )
+ SUM_WSPS_LEN
MSS_MAXBUF = MSS_MAXBUF + MSS_MAXBUF/10
|
In this formula 216 is the message overhead for DECforms request ( use 144 as the message overhead for TDMS request). RECORD_REQUEST_NAMES is the length in bytes of the record ID or request name round to next higher longword. NUM_WSPS is the number of workspaces. Round the product to next higher longword. SUM_WSPS_LEN is the sum of lengths of workspaces, each rounded to next higher longword.
For example, you have an exchange step like this:
EXCHANGE
SEND EMPLOYEE_RECORD
SENDING EMPLOYEE_MAIN_DATA, EMPLOYEE_SUB_DATA;
|
In this example, EMPLOYEE_MAIN_DATA is 400 bytes long and EMPLOYEE_SUB_DATA is 35 bytes long. The values to use are:
216 !Message overhead for DECforms request = 216
+ 16 ! Length of "employee_record" = 15 = 16 rounded
+ 36 ! 2 workspaces * 17 = 34 = 36 rounded
+400 ! Length of employee_main_data workspace = 400
+ 36 ! Length of employee_sub_data workspace = 35 = 36 rounded
-----
704 ! message length, in bytes
+ 70 ! 10% expansion
_____
774 ! total message length, in bytes
|
The minimum size of MSS_MAXBUF is 512.
There may be circumstances for which you are willing to incur message blocking. In such cases, you may not want to have ACMSPARAM.COM calculate the MSS_MAXBUF parameter. Instead, calculate MSS_MAXBUF as described in the following example, add the values as a variable in ACMVARINI.DAT, and then run ACMSPARAM.COM.
For example, the exchange step with the maximum total message size may be much larger than any other exchange step and may be in a task that is selected infrequently. In this case you still want to choose a MSS_MAXBUF size that is not wasteful. Choose a value that satisfies the following constraints:
When a message requires multiple blocks to send, an additional 28 bytes of message overhead is incurred to send blocks other than the first block. If the data cannot be sent in one message, ACMS uses the following formula to calculate how many data segments are needed:
(Message_length - MSS_MAXBUF)
TOTAL_DATA_SEGMENTS = 1 + -----------------------------
(MSS_MAXBUF - 28)
|
This formula may not result in message blocks of approximately equal size. To divide a message into approximately equal blocks, you must decide on how many data segments you want to use, and then calculate MSS_MAXBUF so that ACMS correctly calculates the desired value of TOTAL_DATA_SEGMENTS. To do this, apply the message length and segment numbers to the following formula to determine the value of MSS_MAXBUF:
(Message_length - 28)
MSS_MAXBUF = --------------------- + 28
TOTAL_DATA_SEGMENTS
|
For example, if the total number of bytes for the entire message is 20000 and you want to use 4 data segments to send it, the calculation is:
20000 - 28
MSS_MAXBUF = ---------- + 28
4
MSS_MAXBUF = 5021
|
| Previous | Next | Contents | Index |