# Compaq ACMS for OpenVMS
Managing Applications

Previous | Contents | Index

## A.2.4 User Name Setup for the QTI

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.

Table A-4 Minimum Quotas for the QTI User Name Process
| 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.

Working Set on VAX

    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

Working Set on Alpha

    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

    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

    BIOLM = 18 +                            ! base
            QTI_TASK_THDS                   ! MSS DECnet i/o

BYTLM

    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

    DIOLM = 18 +                            ! base
            QTI_TASK_THDS                   ! disk i/o

ENQLM

    ENQLM = 69 +                            ! base
            (15 * QTI_TASK_THDS) +          ! RMS
            (QTI_QUEUES * 4)                ! ASTs and locking

FILLM

    FILLM = 20 +                            ! base
            REMOTE_APPL_CNT +               ! DECnet links
            QTI_QUEUES                      ! 1 for each queue file

PGFLQUOTA

    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

    TQELM = 20 +                   ! base
            (QTI_TASK_THDS  * 2)   ! one timer for each thread

## A.2.5 User Name Setup for the EXC

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.

Table A-5 Minimum Quotas for the EXC User Name Process
| 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.

Working Set on VAX

    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

Working Set on Alpha

    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

    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

    BIOLM = 10 +                             ! base
            EXC_TK_INSTANCE_CNT +            ! TDMS i/o and MSS network sends
            (2 * REMOTE_AGENT_CNT)           ! DECnet receives

BYTLM

    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

    DIOLM = 20 +                             ! base
            EXC_TK_INSTANCE_CNT              ! rlb i/o

ENQLM

    ENQLM = 20 +                             ! base
            ((EXC_RLB_CNT + EXC_MSG_CNT +
            FORM_CNT +
            EXC_TDB_CNT) * 4)                ! rlb, tdb and msg file opens & I/O

FILLM

    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

    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

    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

## A.2.6 Calculating Quotas for ACMS Server Processes

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:

- Amount of available memory
- CPU processing power
- Complexity of ACMS task groups

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 terminals one Command Process can service, the MAX_TTS_CP value
- The maximum number of Command Processes that can run when ACMS is active, the CP_SLOTS value

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)

## A.5.3 Calculating the Value of MSS_MAXBUF

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:

- The value should be large enough to accommodate any frequently accessed exchange step.
- Allow for enough space so that the message can be divided into approximately equal blocks, so that space is not wasted.

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