Your Browser is not longer supported

Please use Google Chrome, Mozilla Firefox or Microsoft Edge to view the page correctly
Loading...

{{viewport.spaceProperty.prod}}

MAX - define UTM application parameters

  • The MAX control statement allows you to define the maximum values, timers, process values and system parameters of a UTM application. For instance, these include:
  • the name of the application

  • the base name or the base directory for UTM files

  • single or dual-file operation of the KDCFILE

  • size of a UTM page (block size of UTM storages and buffers)

  • the maximum number of

    • processes

    • key codes

    • GSSBs

    • LSSBs

    • UTM pages in the buffer for user log records, etc.

  • threshold values for monitoring the size of SYSLOG file generations if the SYSLOG is created as an FGG (SYSLOG-SIZE operand)

  • the default language environment of the UTM application (LOCALE operand)

  • whether or not SM2 can be used for performance monitoring in the application

The parameters of the MAX control statement can be split into several MAX statements. If the same operand is inadvertently entered in several MAX statements, the first value entered for this operand is taken as valid.

Mandatory operands:

APPLINAME=, KDCFILE= and TASKS=.

Additional mandatory operands on Unix, Linux and Windows systems:

SEMKEY= or SEMARRAY= (semaphore keys), IPCSHMKEY=, KAASHMKEY= and CACHESHMKEY=.

In OSI TP applications additionally: XAPTPSHMKEY= and OSISHMKEY=.

The mandatory operands need to be defined once.

Note on UTM cluster applications on Unix, Linux and Windows systems:

If you modify one of the operands APPLINAME, APPLIMODE, GSSBS, LSSBS, KB or NB then you must regenerate both the initial KDCFILE and the UTM cluster files by specifying GEN=(CLUSTER,KDCFILE) in the OPTION statement.

For clarity, all operands of the MAX statement are listed in a table following the operand descriptions.

 

Operands valid for all operating systems

MAX

  [ APPLIMODE={ SECURE | FAST } ]
  ,APPLINAME=appliname
[ ,ASYNTASKS={ atask_number | (atask_number,service_number) } ]
[ ,BLKSIZE={ 2K | 4K | 8K } ]
[ ,CACHESIZE=( number,paging,{ NORES | RES }1  { ,PS | DS }1  ) ]
[ ,CLRCH={ c | C'c'| X'xx' } ]
[ ,CONN-USERS=number ] (mandatory on Unix, Linux and Windows systems)
[ ,CONRTIME=time ]
[ ,DATA-COMPRESSION={ STD | YES | NO } ]
[ ,DEAD-LETTER-Q-ALARM=number ]
[ ,DESTADM=destination ]
[ ,DPUTLIMIT1=( day,hour,minute,second ) ]
[ ,DPUTLIMIT2=( day,hour,minute,second ) ]
[ ,GSSBS=number ]
[ ,HOSTNAME=name ]
[ ,KB=length ]
  ,KDCFILE=( filebase [, { SINGLE | DOUBLE } ] )
[ ,KEYVALUE=number ]
[ ,LEADING-SPACES={ NO | YES } ]
[ ,LPUTBUF=number ]
[ ,LPUTLTH=length ]
[ ,LSSBS=number ]
[ ,MOVE-BUNDLE-MSGS={ YES | NO } ]
[ ,NB=length ]
[ ,NRCONV=number ]
[ ,OSI-SCRATCH-AREA=value ]

[ ,PGPOOL=( number,warnlevel1,warnlevel2 ) ]
[ ,PGPOOLFS=number ] 
[ ,PGWTTIME=time ]
[ ,PRIVILEGED-LTERM = <lterm-name> ]
[ ,QTIME = (qtime1,qtime2)]
[ ,RECBUF=( number,length ) ]
[ ,RECBUFFS=number ]
[ ,REDELIVERY=(number1, number2) ]
[ ,RESWAIT={ time1 | ( time1, time2 ) } ]
[ ,SM2={ NO | OFF | ON } ]
[ ,SPAB=length ]
[ ,STATISTICS-MSG={ NONE | FULL-HOUR } ]
[ ,SYSLOG-SIZE=size ]
[ ,SYSTEM-TASKS={ *STD | number } ]
  ,TASKS=number
[ ,TASKS-IN-PGWT=number ]
[ ,TERMWAIT=time ]
[ ,TRACEREC=number ]
[ ,TRMSGLTH=length ]
[ ,USLOG={ SINGLE | DOUBLE } ]

further operands for BS2000 systems

[ ,BRETRYNR=number ]
[ ,CARDLTH=length]
[ ,CATID=( catalog_A,catalog_B ) ]
[ ,LOCALE=( [ lang_id ][,[ terr_id ][ ,ccsname ] ] ) ]
[ ,LOGACKWAIT=time ]
[ ,MP-WAIT=number ]
[ ,PRINCIPAL-LTH=length ]
[ ,REQNR=number ]
[ ,SAT={ ON | OFF } ]
[ ,VGMSIZE=number ]

further operands for Unix, Linux and Windows systems

  ,CACHESHMKEY=number  
  ,IPCSHMKEY=number
[ ,IPCTRACE=number ]
  ,KAASHMKEY=number
  ,OSISHMKEY=number        
only mandatory if you generate OSI TP partners
  ,{ SEMARRAY=( number,number1 ) | SEMKEY=( number,...) }
  ,XAPTPSHMKEY=number       
only mandatory if you generate OSI TP partners

1NORES | RES and PS | DS only permitted on BS2000 systems. The long form PROGRAM-SPACE or DATA-SPACE can also be specified instead of PS or DS.

APPLIMODE= This specifies whether the application is a UTM-S or UTM-F application.

    SECURE

The application is generated as a UTM-S application.

With UTM-S, openUTM logs all user data so that this data is retained after the application is terminated or following a system crash. In the event of errors, UTM-S guarantees the integrity and consistency of the application data. If a UTM-S application is terminated abnormally, an automatic restart is automatically performed. For this purpose, this variant of openUTM logs all modifications at the end of transactions.

Default: SECURE

    FAST

The application is generated as a UTM-F application.

UTM-F offers enhanced performance by eliminating the disk input/output operations performed by UTM-S when logging user and transaction data. With a standalone UTM-F application, openUTM only logs user passwords and changes to the configuration which were made by means of dynamic administration. These modifications are thus retained for the next application run. However, UTM-F applications do not log changes to the user data. They are therefore suitable only for installations in which performance is the most important criterion and the restart facility is not required. This applies in the case of pure information systems, or if all logging functions can be provided by the database system used.

In UTM cluster applications, user data that is valid globally in the cluster is also saved for UTM-F.

APPLINAME= 

appliname

Name of the UTM application up to eight characters in length.  appliname defines a transport system access point via which connections to the UTM application can be established.

This is a mandatory operand.

If several application names are required, for example, for distributed processing based on the LU6.1 protocol, these can be assigned to the application using the BCAMAPPL statement. With APPLINAME= you define the primary application name.

appliname must be unique within the local system and must not begin with the character ’$’.

BS2000 systems:

This name is subject to the name conventions for BCAM applications. The transport system access point defined with appliname supports the transport protocol NEA.

appliname must not begin with a number or with ’$’ as this is prohibited by BCAM and the application cannot be started otherwise. Please note that KDCDEF cannot intercept numbers.

Unix, Linux and Windows systems:

appliname must be specified when establishing a connection from the terminal (dialog terminal process).

If connections are to be established with partner applications using the application name defined with APPLINAME=, you must also issue an appropriate BCAMAPPL statement (see "BCAMAPPL - define additional application names").

ASYNTASKS=

(atask_number,service_number)

Maximum number of resources that may be reserved to process asynchronous jobs.

    atask_number

Maximum number of processes (BS2000 tasks or work processes on Unix, Linux and Windows systems) of the application which can simultaneously handle jobs with asynchronous transaction codes. This operand allows you to prevent long-running asynchronous processes from affecting dialog operation.

If ASYNTASKS=0, asynchronous TAC classes cannot be generated.

Default: 1
Minimum value: 0
Maximum value: TASKS -1

    service_number

Maximum number of asynchronous services that may be open at the same time.

You should set service_number to be larger than atask_number when one of the two following cases can arise:

  • Process switch while processing an asynchronous service:If an asynchronous service consists of several program units and if the transaction code of a follow-up program (follow-up TAC after PEND PA/PR or PEND SP) is located in a different TAC lass than the calling program unit or the priority control is generated for TAC classes (TAC-PRIORITIES statement), then a process switch can occur during processing. The asynchronous service is inactive at first and does not allocate a UTM process, although it remains open.

  • Dialogs initiated by synchronous services with LU6.1 or OSI TP partner applications: If a dialog is initiated with a partner application within an asynchronous service (with APRO DM) and it must wait for a response from the partner (via PEND KP or PEND RE), then the asynchronous service remains open until the response arrives (or until a timeout), but it does not allocate a UTM process.

If these cases arise in the application and the value of service_number is too small, then the asynchronous processing may be temporarily blocked because service_number of inactive services already exist. New asynchronous services cannot be started although no UTM processes are processing asynchronous services at this time.

Default: atask_number
Minimum value: atask_number
Maximum value: 32767

BLKSIZE=

Size of a UTM page

Please note that, depending on the BLKSIZE specification, each user storage area occupies at least 2K, 4K or 8K in the page pool.

You can only specify BLKSIZE=4K or 8K for UTM cluster applications.

Default

  • standalone UTM applications: 2K

  • UTM cluster applications that run on 32-bit systems: 4K

  • UTM cluster applications that run on 64-bit systems: 8K

Possible values: 2K, 4K, 8K

On BS2000 systems you must specify BLKSIZE=4K or 8K
  • if the KDCFILE and the USLOG file are created on NK4 disks, or

  • if the KDCFILE is to be used as a Hiperfile (high-performance file).

BRETRYNR=

number

This operand is only supported on BS2000 systems.

Number of attempts made by openUTM to transfer a message to the transport system (BCAM) if BCAM cannot accept the message immediately. If this number is exceeded, the connection to the dialog partner is shut down.

BRETRYNR is irrelevant for asynchronous messages output to a dialog partner with PTYPE=APPLI (PTERM statement). If such a message from the transport system is rejected due to a temporary bottleneck, then openUTM releases the process, but does not clear down the connection. After waiting for three seconds, openUTM makes up to three attempts to transfer the message to BCAM. If after the third attempt BCAM still cannot accept the message, then openUTM waits for 3 more seconds before it makes another three attempts to send the message to BCAM. If still unsuccessful, it waits another 3 seconds before making another three attempts, and so on.

Default: 10
Minimum value: 1
Maximum value: 32767 (theoretical value)

CACHESHMKEY=

number  

This operand is only supported on Unix, Linux and Windows systems.

Authorization key for the shared memory segment containing the global buffer for file access. Keys are global parameters under the Unix, Linux and Windows systems. You cannot specify more than one key. You must enter a decimal number for number.

This is a mandatory operand.

CACHESIZE=

(number,paging,NORES or RES, PS or DS)

(NORES, RES, PS, DS only on BS2000 systems PROGRAM-SPACE or DATA-SPACE can also be specified instead of PS or DS)

This specifies the size and properties of the cache memory (further information can be found in the openUTM manual “Concepts und Functions”). The values entered here affect the performance of your UTM application.

    number

Number of UTM pages in the cache. The size of each UTM page is defined in the BLKSIZE= operand. The cache is used for accessing the page pool, i.e. all input and output operations involving LSSBs, GSSBs, TLSs, LPUT messages, FPUT messages, MPUT messages to clients, and some types of UTM administrative data. Data is not written to the KDCFILE until the cache becomes full or the transaction is terminated.

KDCDEF rounds up this number to a multiple of 32.

Default value:
1024 (corresponds to 2, 4 or 8 MB, depending on the value of BLKSIZE=)
Minimum value:
32 (corresponds to 64, 128 or 256 KB, depending on the value of BLKSIZE=)
Maximum value:
Depends on the hardware and operating system, but not larger than 16777184.

If the cache on BS2000 systems is located in the program space (PS), the cache is created in a common memory pool whose size is always a multiple of 1 MB. The BS2000 system automatically rounds the value specified in CACHESIZE. CACHESIZE should be requested in multiples of 1 MB so that address space is not wasted.

    paging

Percentage of cache pages to be written to the KDCFILE in a single batch in the event of a bottleneck, thereby freeing space in the cache. This must correspond to at least eight pages. The value specified here can be modified using the administration command KDCAPPL CACHE=%_utm_pages.

Default value: 70(%)
Minimum value: 0, i.e. eight pages are swapped out
Maximum value: 100 (%)

    NORES

This operand value is only supported on BS2000 systems.

The cache is created as non-resident.

Default: NORES

    RES

This operand value is only supported on BS2000 systems.

The cache is created as resident.

A resident cache can enhance the performance of the UTM application. RES may not be specified together with DATA-SPACE.

Resident cache offers enhanced performance in productive mode, as the cache paging algorithm is designed specifically for use with this type of cache.

The number of resident pages used in the creation of a resident cache cannot be checked using the COREBIAS operand of the BS2000 command BIAS.

    PS or PROGRAM-SPACE

This operand value is only supported on BS2000 systems.

The UTM cache is created in the program space.

Default: PS

    DS or DATA-SPACE

This operand value is only supported on BS2000 systems.

The UTM cache is created in one or more data spaces.

If the generated UTM cache is larger than 2GBt, UTM will distribute the cache over more than one data space as a data space may be at most 2GB in size.

The option of creating the UTM cache in a data space should be chosen only if a very large UTM cache is required and the address space (program space) is not sufficient for this.

Use of a data space for the ITM cache always entails a slight loss of performance as a result of the way in which a program can access data in a data space. For applications which require a large UTM cache, these performance disadvantages are, however, counterbalanced by the advantages which a large cache brings through the reduction of file IOs.

Above all for UTM applications it can be advantageous to create a very large UTM cache in a data space. In the case of UTM-F, cache buffers are written to file only in the event of a cache bottleneck. If the UTM cache is generated large enough all file IOs to this page pool may be omitted for such applications.

The maximum size of a UTM cache in data spaces is 8 GB. In other words:

  • when BLKSIZE is 2K, the maximum value for number is 4,194,304,

  • when BLKSIZE is 4K, the maximum value for number is 2,097,152,

  • when BLKSIZE is 8K, the maximum value for number is 1,048,576.

DATA-SPACE may not be specified together with RES.

CARDLTH=

length

This operand is only supported on BS2000 systems.

Length of the ID card information in bytes. If the ID card reader is used for sign-on, openUTM stores the ID card information in the length resulting from the maximum of the length specified here and the value generated for MAX PRINCIPAL-LTH. If the information on the ID card is longer, it is truncated and stored in this length.

The KDCS call INFO (KCOM=CD) enables a program to read this information.

CARDLTH must be big enough to ensure that the following applies for all USER statements with
USER ..., CARD = (pos, string):
pos + length (string) -1 <= CARDLTH.

Default: 0
Maximum value: 255

When a value > 255 is specified, 255 is assumed.
No warning message is output.

CATID=

(catalog_A,catalog_B)

This operand is only supported on BS2000 systems.

Catalog IDs to which your KDCFILE is assigned.

If you work with CATIDs, enter the base name without the CATID in KDCFILE=filebase (see "MAX - define UTM application parameters").

In the case of single-file operation of the KDCFILE, specify the CATID to which the KDCFILE is to be assigned in catalog_A. In this case, catalog_B is not specified.

In the case of dual-file operation of the KDCFILE (see "The KDCFILE"), you can assign files with the suffix A to CATID catalog_A and files with the suffix B to catalog_B. If you only specify a value for catalog_A, both files are assigned to this CATID.

CLRCH=

Character with which the KB program area and the standard primary working area are overwritten at the end of a dialog step. Possible entries are:

c
C’c’
X’xx’

Where c is an alphanumeric character and x a hexadecimal character.

Default:
The communication area and standard primary working area are not overwritten.

CONN-USERS=

number

This operand is used to control the load on the application. It defines the maximum number of users that can work simultaneously with the application. In the case of an application for which user IDs have not been generated, CONN-USERS= can be used to define the maximum number of clients that can sign simultaneously on to the application via LTERM partners.

  • CONN-USERS < number of users/clientsThis prevents all users/clients from working simultaneously with the application.

  • CONN-USERS=0The number of simultaneously active users/clients is unrestricted.

  • CONN-USERS > number of users/clientsThe application load is not controlled. CONN-USERS= is ignored.

User IDs and clients generated with administration authorization can sign on to the UTM application, even if the maximum number of simultaneously active user IDs has already been reached.

Default value on BS2000 systems: 0 (i.e. no restriction)
Minimum value: 0
Maximum value: 500000

CONN-USERS is a mandatory operand on Unix, Linux and Windows systems. Please note that number cannot be set to a higher value that the number of concurrent user licenses obtained.

CONRTIME= 

time

(connection request time) Time in minutes after which openUTM retries to establish a connection after failing to establish a connection generated to be established automatically.
If CONRTIME > 0 then, following a disconnection, openUTM first attempts to reestablish the connection immediately and then at the intervals specified in CONRTIME. This applies to the following partners:

  • TS applications (PTYPE=APPLI or PTYPE=SOCKET) which openUTM generates with automatic connection setup (PTERM ...,CONNECT=YES,) provided that the connection was not terminated by an administration command or due to the IDLETIME timer running down (see the PTERM statement on "PTERM - define the properties of a client/printer and assign an LTERM partner") .

  • OSI TP or LU6.1 partner applications which were generated with automatic connection setup, provided that the connection was not terminated by an administration command or because of the expiry of an IDLETIME timer.

  • OSI TP partner to which the asynchronous messages were sent and with which no connection existed at the creation time of the messages.

  • On BS2000 systems
    • Printers to which openUTM establishes a connection as soon as the number of print jobs for this printer exceeds the generated threshold value (LTERM ...,PLEV>0). On disconnection, the number of print jobs must be greater than or equal to the threshold value if openUTM is to attempt to re-establish the connection. If CONRTIME!=0, openUTM also attempts to re-establish the connection if this was previously explicitly disconnected using an administration command.

    • Printers to which openUTM automatically establishes a connection (PTERM ...,CONNECT=YES), provided that the connection was not terminated by an administration command.

    • Message distributor (MUX) to which openUTM automatically establishes a connection on start-up, provided that the connection was not terminated by an administration command.

If a connection to this partner is not established when the application is started or the administration command KDCPTERM or KDCLPAP is issued, openUTM attempts to reestablish the connection at intervals specified in CONRTIME=.

If CONRTIME=0, openUTM does not make any attempt to set up the connection. Exception: A wait time of 10 minutes is set for asynchronous messages to OSI TP partners.

Default: 10 min.
Maximum value: 32767 min.

DATA-COMPRESSION=

This parameter enables data compression to be permitted or not permitted.
If data compression is permitted and enabled, for data of the secondary storages and long-term storages (GSSB, LSSB, TLS and ULS) and the communication area-program area UTM performs data compression in order to reduce the space required for these areas by at least one UTM page. For UTM-S applications in particular this can have a positive effect on the performance because as a result execution in UTM and the file IOs to the page pool are optimized.
UTM attempts to compress the user data only if this enables at least one UTM page to be saved, i.e. only for data spaces which are written with a length of more than one UTM page.

    YES

Data compression is permitted and enabled. Data compression can be disabled using administration facilities, e.g. by means of KDCAPPL.

    NO

Data compression is not permitted and is disabled. This setting cannot be modified using administration facilities.

    STD

Data compression is permitted and enabled for UTM-S applications (APPLIMODE=S).
Data compression is permitted but disabled for UTM-F applications (APPLIMODE=F).

This default setting can be modified using administration facilities.

Default: STD

The average value for UTM pages saved per data compression can be queried using the administration functions, e.g. using the KDCINF STAT command (see openUTM manual “Administering Applications”) or using WinAdmin or WebAdmin.

DEAD-LETTER-Q-ALARM

Controls monitoring the number of messages in the dead letter queue.

The K134 message is output each time the threshold is reached. for this message the destination MSGTAC can be defined in order to automate handling of the dead letter queue.

Default: 0, monitoring is disabled.
Maximum value: 65535

DESTADM=

destination

Destination to which openUTM sends the results of administration calls processed asynchronously. For destination, you can specify:

  • an LTERM partner Exception: UPIC-LTERM partners are not permitted!

  • the TAC of an asynchronous program

  • the TAC queue (type=Q).

Default: Blanks, i.e. no destination; the results are thus lost.

DPUTLIMIT1=

(day,hour,minute,second)

Defines the latest possible execution time of a job. Can be specified in relative or absolute time:

time of execution < time of DPUT call + DPUTLIMIT1

The following applies for time specifications in DPUTLIMIT1:

    day

Maximum value: 364
Minimum value: 0

    hour

Maximum value: 23
Minimum value: 0

    minute

Maximum value: 59
Minimum value: 0

    second

Maximum value: 59
Minimum value: 0

Default value: DPUTLIMIT1 (360, 0, 0, 0) = 360 days
Default value: DPUTLIMIT2 (1, 0, 0, 0) = 1 day
Minimum value: (0, 0, 0, 0)
Maximum value: (364, 23, 59, 59)

The following must apply for the DPUTLIMIT1 and DPUTLIMIT2 operands:

DPUTLIMIT1 + DPUTLIMIT2 <= (364, 23, 59, 59) < 365 days

i.e. if you enter (364, 23, 59, 59) for DPUTLIMIT1, you must specify DPUTLIMIT2=(0, 0, 0, 0).

DPUTLIMIT2= 

(day,hour,minute,second)

The time specification for the DPUT call does not contain a number for the year. Furthermore, the desired execution time may already have passed if the DPUT call was delayed.

For this reason, you must decide whether the execution time of a job with an absolute time specification should be attributed to the past, current, or next year.

Since DPUTLIMIT1 + DPUTLIMIT2 must be < 1 year, only one of these three alternatives will be in the permissible open time period (call time - DPUTLIMIT2, call time + DPUTLIMIT1):

  • If the only alternative allowed is before the call time, then the DPUT is handled as an FPUT and executed as soon as possible.

  • If the only alternative allowed is after the call time, then the DPUT is saved and only converted to an FPUT and executed at the alternative time.

  • If none of the three alternatives are in the permissible time period, then the DPUT is rejected.

DPUTLIMIT2 therefore allows you to backdate the specified execution time into the past for time-driven jobs with absolute time specifications. You cannot backdate jobs with relative time specifications.

DPUTLIMIT1 restricts the predating of jobs with absolute or relative time specifications into the future only.

Example 1

DPUTLIMIT1 = (300,0,0,0)
DPUTLIMIT2 = (010,0,0,0)

The DPUT call time is (005,0,0,0). The current and last years are not leap years.

  • DPUTs with relative time (000,0,0,0) to (299,23,59,59) are accepted.

  • DPUTs with absolute times (001,0,0,0) to (005,0,0,0) and (360,0,0,1) to (365,23,59,59) are handled as FPUT.

  • DPUTs with absolute time (005,0,0,1) to (304,23,59,59) are handled as DPUT.

DPUTs with absolute time (305,0,0,0) to (360,0,0,1) are rejected.

-|---------------|------------- ... --------------|-----------|
360              5                               305         360
 FFFFFFFFFFFFFFFFFDDDDDDDDDDDDD ... DDDDDDDDDDDDDDD

Example 2

  • DPUTLIMIT1 and DPUTLIMIT2 are defined exactly as in Example 1 , but the DPUT call time is (360,0,0,0).
  • DPUTs with relative time (000,0,0,0) to (299,23,59,59) are accepted.

  • DPUTs with absolute time (350,0,0,1) to (360,0,0,0) are handled as FPUT.

  • DPUTs with absolute time (001,0,0,0) to (294,23,59,59) and (360,0,0,1) to (365,23,59,59) are handled as DPUT.

  • DPUTs with absolute time (295,0,0,0) to (350,0,0,0) are rejected.

 -|---------------|-------------- ... -----------|-------------|
 350             360                            295           350
  FFFFFFFFFFFFFFFFFDDDDDDDDDDDDDD ... DDDDDDDDDDDD

The default values are listed under the description of the DPUTLIMIT1 operand.

GSSBS=

number

Maximum number of GSSBs (global secondary storage areas) that can exist simultaneously in the application.

Default: 32
Minimum value: 0
Maximum value: 30000

HOSTNAME=

name

BS2000 systems:

Name of the virtual host on which the UTM application runs (from the point of view of BCAM). This virtual host must also be generated in BCAM. The name can be up to 8 characters in length. Default value: 8 blanks, i.e the applications runs under the real host.

Unix, Linux and Windows systems:

Can only be specified in standalone applications.

In UTM cluster applications, you can specify a virtual host name in the VIRTUAL-HOST parameter of the CLUSTER-NODE statement.

Name of the host that is specified as the sending address when a connection is established from the UTM application end. HOSTNAME= is required in cluster systems that use the “relocatable” IP address as the sending address and not the stationary IP address.
The name can be up to 64 characters in length.

Default: Blanks, the default processor name of the transport system is used as the sending address.

IPCSHMKEY= 

number

This operand is only supported on Unix, Linux and Windows systems.

Authorization key for the shared memory segment, which is used for communication between work processes on one side and the dialog terminal or printer processes and the timer process (external processes of an application) on the other side. Keys are global parameters under the Unix, Linux and Windows systems. You cannot specify more than one key. You must enter a decimal number for number.

This is a mandatory operand.

IPCTRACE= 

number

This operand is only supported on Unix, Linux and Windows systems.

In test mode (startup with TESTMODE=ON, see openUTM manual “Using UTM Applications on Unix, Linux and Windows Systems”), openUTM writes entries in the trace area of the IPC (shared memory segments for interprocess communication). These entries contain internal information which is required for diagnostic purposes. Each entry occupies 32 bytes. IPCTRACE defines the number of entries in the trace area. If this number is exceeded, openUTM overwrites the existing entries, beginning with the oldest entry.

Default: 1060
Minimum value: 1
Maximum value: 32500

KDCDEF automatically resets values < 1 or > 32500 to the minimum or maximum value without outputting a UTM message.

KAASHMKEY=

number

This operand is only supported on Unix, Linux and Windows systems.

Authorization key for the shared memory segment containing the global data. Keys are global parameters under the Unix, Linux and Windows systems. You cannot specify more than one key. You must enter a decimal number for number.

This is a mandatory operand.

KB=

length

Length of the communication area (KB) in bytes, excluding the KB header and KB return area.

Default: 512
Minimum value: 0
Maximum value: 32767

KDCFILE=


    filebase

Base name of the KDCFILE, the user log file, and the system log file SYSLOG. The name entered here must also be specified in the start parameter FILEBASE=filebase when starting the application program (see openUTM manual “Using UTM Applications”).

This is a mandatory operand.

BS2000 systems:
If you use the CATID= parameter to assign catalog IDs to your KDCFILE, the base name must be specified without a CATID. (see section "BS2000 systems:" (The KDCFILE) for the format and length of the name).

Unix, Linux and Windows systems:
filebase is the name of the directory containing the KDCFILE and all application files. This directory must be created before the KDCDEF run.
filebase can be fully or partially qualified and can be a maximum of 29 characters in length for standalone applications, irrespective of whether the name is fully or partially qualified.
filebase can be a maximum of 27 characters in length for UTM cluster applications.

        SINGLE

Single-file operation is activated for the KDCFILE.

If the KDCFILE is split (see section "Splitting the KDCFILE"), all KDCFILE files are subject to single-file operation.

Default: SINGLE

       DOUBLE

For security reasons, dual-file operation is activated for the KDCFILE.

If the KDCFILE is split (see section "Splitting the KDCFILE"), all KDCFILE files are subject to dual-file operation.

In UTM cluster applications, only SINGLE may be specified.

KEYVALUE= 

number

Value of the highest key code of the application, and thus the value of the corresponding highest lock code that can be assigned to a transaction code or a terminal for data access control. The operand KEYVALUE=number can also be used to define the maximum number of key codes per key set. openUTM uses this information to optimize the key set tables. You can define up to 4000 key and lock codes. Only numerical lock codes can be defined.

Default: 32
Minimum value: 1
Maximum value: 4000

Exceptions:

  • Maximum value (32-bit Unix, Linux and Windows systems): 1976 for MAX ...,BLKSIZE=2K

  • Maximum value (64-bit Unix, Linux and Windows systems): 3900 for MAX ...,BLKSIZE=4K

If you enter a value < 1, KDCDEF automatically sets KEYVALUE=1 without outputting a UTM message.

LEADING-SPACES=

Specifies how the leading spaces in a messages from a terminal or from a  TS application (PTERM ... PTYPE=APPLI or SOCKET) are to be handled.

    YES

When calling a program unit, leading blanks in messages are passed on to the program unit. The same applies for messages sent to a client with PTYPE=APPLI. A blank acting as a separator between TAC and message is removed if the TAC name < 8 characters.

    NO

Leading blanks are suppressed.

Default: NO

LOCALE= 

(lang_id,terr_id,ccsname)


This operand is only supported on BS2000 systems.

Default language environment of the UTM application (see also section"UTM messages").

The locale generated here is assigned to all user IDs and clients that sign on via LTERM partners or LTERM pools as the default language environment. This default setting applies unless another locale is explicitly defined for these objects in the corresponding USER, LTERM, or TPOOL statements.

The message module whose language and territorial identifiers match the specifications in the MESSAGE ...LOCALE= and MAX ...,LOCALE= statements becomes the application message module. openUTM sends messages to the message destinations SYSOUT, SYSLST, and CONSOLE from this application message module. The specifications in the application message module also determine the destination of a particular message.

    lang_id

Freely selectable language identifier for the UTM application up to two characters in length.

Default: Blanks

    terr_id

Freely selectable territorial identifier up to two characters in length.

Default: Blanks

    ccsname

(coded character set name)
Name of an extended character set (CCS name) up to eight characters in length. The specified CCS name must belong to one of the EBCDIC character sets defined under the BS2000 system (see also the XHCS User Guide). During generation, openUTM cannot check whether this condition is fulfilled. KDCDEF will thus accept CCS names to which no character set is assigned.

Default: Blanks, i.e. 7-bit mode

LOGACKWAIT=

time

The maximum length of time in seconds that openUTM is to wait for an acknowledgment from an output device. This acknowledgment is

  • for a printer, the logical print acknowledgment from the printer,

  • for an RSO printer, the acknowledgment from RSO,

  • for an FPUT call to another application, the transport acknowledgment.

If confirmation does not arrive within this period, e.g. because the printer has run out of paper, openUTM shuts down the logical connection to the device.

Default: 600
Minimum value: 10
Maximum value: 32767

LPUTBUF=

number

Size of the LPUT buffer in UTM pages. The LPUT buffer of the KDCFILE is used to temporarily store LPUT data. This data is not copied to the user log file until the value specified in number is exceeded. The user log file USLOG is open only during this copy process.

Default: 1
Minimum value: 1
Maximum value: 1000
KDCDEF automatically resets values > 1000 to 1000 without outputting a UTM message.

CAUTION!
This operand must be set > 1 if the application contains LPUT calls. Otherwise, the copy process will be started too often. This involves opening and closing the user log files.
The value entered in LPUTBUF must be selected such that the buffer can accommodate the longest LPUT record. The following must apply:

LPUTBUF * UTM page size >= LPUTLTH + length of KB header (84 bytes)

LPUTLTH=

length

Maximum length of the user data in LPUT records in bytes (excluding the KB header).

The maximum length of an LPUT record in the user log file is calculated as follows (see also the openUTM manual „Programming Applications with KDCS”, user log file):

length + 84 bytes for the KB header + 12 bytes for length fields.

Default: 1948
Minimum value: 0
Maximum value (BS2000 systems): 32652, irrespective of the storage medium for the user log file
Maximum value (Unix, Linux and Windows systems): 32668

BS2000 systems:
openUTM uses length to determine the block size of the user log file. To do this, openUTM calculates the next largest value of (length + 100 bytes) that is a multiple of 2 kbytes. openUTM uses this multiple as the block length for the user log file. The 100 bytes comprise of 84 bytes for the KB header + 12 bytes for the record length fields + 4 bytes for the block length fields.

If the user log file USLOG is created on a non-key disk (NK2, NK4), then you must select the value of length such that:

length + 100 byte + 16 bytes block-specific internal DVS administration information

is a multiple of 2 Kbytes (on NK2 disks) or 4 Kbytes (on NK4 disks). This allows you to optimally utilize disk space.

The 16 byte block-specific internal DVS administration information are therefore not available for use as user data. You will find more information on this subject in the BS2000 manual "Introductory Guide to DMS".

LSSBS=

number

Maximum number of LSSBs (local secondary storage areas) that can be created in a service.

Default: 8
Minimum value: 0
Maximum value: 1600

MOVE-BUNDLE-MSGS=

This parameter can be used for an application to allow automatic moving of waiting asynchronous messages from a slave LTERM, slave LPAP or slave OSI-LPAP without a connection to the partner application.

    YES

When the waiting time defined in MAX CONRTIME has elapsed, or after 10
minutes (if CONRTIME=0), UTM automatically moves FPUT messages to
a slave in the bundle with a connection established. It is possible that FPUTs
from a transaction will be sent using different slaves from a bundle.

    NO

Asynchronous messages to a slave are never sent via another slave.

Default: NO

MP-WAIT=

number 

This operand is only supported on BS2000 systems.

Maximum number of seconds for which openUTM waits for a process to sign on to a common memory pool.

Default value: 180
Minimum value: 1
Maximum value: 32000

CAUTION!
The default value of 180 seconds should only be changed in exceptional circumstances, e.g. if a process terminates with K078 ENQAR and a user dump with the return code KDCSST01.

NB=

length

Maximum length of a working area for

  • logical inputs and outputs to and from terminals and transport system applications of the APPLI type

  • asynchronous output messages to printers and transport system applications of the SOCKET type

This should be equal to the length of the largest KDCS message area of the program units in bytes.

Default: 2048
Minimum value: 2048
Maximum value (BS2000 systems): 32700
Maximum value (Unix, Linux and Windows systems): 32676

NRCONV=

number

(number of conversations)
Maximum number of services that can be simultaneously stacked by the user. NRCONV=0 means that services cannot be stacked.

The following limits are valid:

Number of user IDs + maximum number of services that can be placed on the stack (number of services =number * number of user IDs) <= 500000

If the limit value of 500000 is exceeded (by the values specified for NRCONV in the RESERVE statement, see "RESERVE - reserve table locations for UTM objects", and by the number of USER statements, see "USER - define a user ID"), then openUTM automatically creates fewer entries for stacking services. In this case, not all users will be able to place number services on the stack.

Default: 0
Minimum value: 0
Maximum value: 15

OSISHMKEY=

number

This operand is only supported on Unix, Linux and Windows systems.

Authorization key for the shared memory segment, which is used by OSS for communication based on OSI TP. You must enter a decimal number for number.
This is a mandatory operand if the application communicates on the basis of OSI TP.

OSI-SCRATCH-AREA=

value

Size in KB of an internal UTM working area for dynamic data storage when using the OSI TP protocol.

Default: 256
Minimum value: 128
Maximum value: 32767

On BS2000 systems this working area is automatically extended during runtime, if required.

On Unix, Linux and Windows systems the size of the internal working area must not be modified during runtime. It is recommended that you select the default value. However, if this proves to be insufficient during operation, increase the value of OSI-SCRATCH-AREA and repeat the generation procedure.

PGPOOL=

(number,warnlevel1,warnlevel2)

Size of the page pool in UTM pages and the warning levels for utilization of the page pool.

    number

Number of UTM pages to be used for the page pool in the KDCFILE (see "Page pool"). The size of each UTM page is defined in the BLKSIZE= operand.

Default: 100
Minimum value: 20
Maximum value: 16777215 - (2 * number of PGPOOLFS)

If you enter a value less than 20, KDCDEF automatically sets PGPOOL=20 without outputting a UTM message.

On Unix, Linux and Windows systems the value of PGPOOL is always an even number. If you enter an uneven number, openUTM subtracts 1 from your entry.

    warnlevel1

Numeric value (percentage) indicating the page pool utilization level at which the first warning (UTM message K041) is output.

Default: 80
Minimum value: 1
Maximum value: 99

    warnlevel2 

Numeric value (percentage) indicating the page pool utilization level at which the second warning is to be output. If warnlevel2 is exceeded, all asynchronous jobs are rejected. In this case, the user receives a K message, and a corresponding return code is sent to a program unit.

Default: 95
Minimum value: warnlevel1 + 1
Maximum value: 100

PGPOOLFS=

number

Number of files between which the page pool is to be split. If PGPOOLFS = 0, the page pool is located in the main file (on BS2000 systems in the file filebase.KDCA, on Unix, Linux and Windows systems in the file KDCA in the filebase file directory). In the case of dual-file operation (MAX ...,KDCFILE=(...,DOUBLE)), the value specified in number does not include the two file copies.
The file names are defined by KDCDEF.

Default: 0, i.e. the page pool is located in the main file

Maximum value (BS2000 systems): 99 (and PGPOOL=number / 2)
Maximum value (Unix, Linux and Windows systems): 10

Minimum value: The minimum value depends on the number of UTM pages, the UTM page size and the maximum file size permitted on the relevant system.

  • On BS2000 systems, an individual UTM file must not be larger than 32 Gbytes in size.
    For BS2000 systems, this results in the following minimum value depending on the size of a UTM page:
    4 if BLKSIZE = 8K and PGPOOL number >= 4194304
    2 if BLKSIZE = 4K and PGPOOL number >= 8388608
    0: other, for meaning, see above.

  • On Unix, Linux and Windows systems in 32-bit mode files up to 2 Gbyte in size are supported.

  • On Unix, Linux and Windows systems in 64-bit mode, openUTM can also use larger files as defined by the limits of the operating system and file system.

PGWTTIME=

time

Maximum number of seconds for which a program unit can wait for messages to arrive after a blocking call (e.g. PGWT call). During this period, a process of the UTM application is exclusively reserved for this program unit.

Default: corresponds to time in TERMWAIT=time
Minimum value: 60
Maximum value: 32767

PRINCIPAL-LTH=

length

This operand is only supported on BS2000 systems.

Maximum length of a Kerberos principal in bytes. This parameter is only of significance if at least one user is generated with USER ..., PRINCIPAL= or at least one LTERM or TPOOL is generated with KERBEROS-DIALOG=YES. The length of the value specified with USER ... PRINCIPAL= must not be larger than the value generated with MAX PRINCIPAL-LTH=.

When a Kerberos dialog is performed with a client, openUTM saves the Kerberos information in the length resulting from the maximum of this length and the length generated for MAX CARDLTH. If the Kerberos information is longer, it is truncated to this length and stored.
The KDCS call INFO (KCOM=CD) allows the program unit run to read this information if no user signs on to the same client with an ID card after the Kerberos dialog. In this event, the Kerberos information is overwritten by the ID card information.

Default: 0
Minimum value: 0
Maximum value: 100

PRIVILEGED-LTERM=


 

lterm-name

Identifies an LTERM as a privileged connection. Jobs sent to the UTM application via this LTERM are prioritized for processing by UTM in situations in which the UTM application is subject to a high load.

To permit rapid responsiveness even in high-load situations, additional processes (referred to as UTM system processes) are started for a UTM application. The UTM system processes only handle selected jobs. These are primarily internal jobs or jobs issued by an administrator who is signed on at the UTM application via the privileged LTERM. See also operand MAX SYSTEM-TASKS on "MAX - define UTM application parameters".

If optimum use is to be made of this functionality, the PRIVILEGED-LTERM should always be explicitly generated. Only then is it possible for all the mechanisms that allow this LTERM to be privileged in high-load situations to take effect. More specifically, the following approach is recommended:

  • The administrator's workstation should be generated via a PTERM- and an LTERM statement.

  • The administrator's LTERM should be declared as a PRIVILEGED-LTERM.

If a connection is established via this LTERM then the following applies:

  • If a sign-on service is started for this connection then this sign-on service is also processed by the UTM system processes.

  • If an administrator signs on via this connection then program unit runs for this connection are also handled by the UTM system processes.

  • If a normal user signs on via this connection then this connection is handled exclusively using "normal" processes until the user signs off.

The LTERM must be generated as a dialog LTERM in an LTERM statement.

If no PRIVILEGED-LTERM is generated then it is dynamically determined as follows:

  • After the start of the application, the first LTERM to which an administrator signs on becomes the privileged LTERM.

  • If this administrator then signs off again then the next LTERM to become the privileged LTERM is that at which an administrator signs on or at which an administrator who is already signed on starts a program unit.

QTIME=

(qtime1, qtime2)

Specifies the maximum permitted length of time that a service is to wait for the arrival of a message in a message queue. QTIME= refers to user specific (USER queues), permanent (TAC queues) and temporary message queues.

It is possible to define individual maximum values for wait times in dialog or asynchronous services.
If a greater wait time value is specified in a program unit run than is generated in QTIME=, openUTM resets the wait time to the generated value.

    qtime1

Maximum length of wait time for dialog services

    qtime2

Maximum length of wait time for asynchronous services

Both times are specified in seconds.

Default: 32767 (seconds)
Maximum value: 32767 (seconds)
Minimum value: 0 (seconds)

RECBUF=

(number,length)

Size of the transaction-oriented restart area. This area contains the data required for a restart following a transaction or system error. Further information on the restart area can be found on section "Restart area".

    number

Number of UTM pages per process to be used in the KDCFILE to store data for a restart following a system error. The size of each UTM page is defined in the BLKSIZE= operand. If this area is large, the application load is reduced but the restart process following a system error is slower. If this area is small, the application load is increased but the restart process following a system error is faster.

Default: 100 (per process)
Minimum value: 5 (per process)
Maximum value: 32767 (per process)

    length

Size in bytes of the buffer available to each application process for temporarily storing restart data. This data is required for a restart following a transaction or system error.

Default: 8192
Minimum value: 1024
Maximum value: 16777212 (16 MB)

RECBUFFS=

number

Number of files between which the restart area is to be split. If RECBUFFS=0, the restart area is located in the main file of KDCFILE. In the case of dual-file operation (MAX ..., KDCFILE=(...,DOUBLE)), the value specified in number does not include the two file copies. The file names are defined by KDCDEF.

number must not be greater than the maximum number of processes defined in TASKS=. If this requirement is not fulfilled, the default value is used.

Default: 0
Maximum value (BS2000 systems): 99, or value of the TASKS parameter
Maximum value (Unix, Linux and Windows systems):
10, or value of the TASKS parameter

REDELIVERY=

(number1, number2)

Maximum number of redeliveries of an asynchronous message after the service or transaction was rolled back. number1 and number2 apply for different message destinations.

    number1

Maximum number of redeliveries of messages to an asynchronous TAC. Delivery is always repeated after an asynchronous service was terminated abnormally with PEND ER/FR or system PEND ER without at least one transaction having been completed successfully. Restart of an asynchronous service after PEND RS within the first transaction is not regarded as a redelivery.
When redelivery is made, the program unit assigned to the TAC is restarted. With the FGET call, the number of redeliveries is output in the KB return area.

    number2

Maximum number of redeliveries of messages to a service controlled queue. Delivery is always repeated if the message was processed and the transaction was then rolled back.

With the DGET call, the number of redeliveries is output in the KB return area.

Default: (0, 255)
Minimum value for number1 and number2: 0
Maximum value for number1 and number2: 255 (i.e. the number is unlimited)

A value of 0 means that the message is deleted or saved to the dead letter queue after rollback, depending on the value in TAC ...,DEAD-LETTER-Q.

If the value is set to 255, a message is redelivered any number of times. Note that this can result in an endless loop if, for example, a program unit is rolled back because of a programming error. Additionally the message cannot be saved to the dead letter queue in case of an endless loop.

REQNR=

number

This operand is only supported on BS2000 systems.

Maximum number of PAM read/write jobs that can be issued in parallel at the same time for a file in a UTM process. This value can be used to control the parallel processing of input/output operations within certain limits.

Default: 20
Minimum value: 1
Maximum value: 100
KDCDEF replaces an invalid value with the maximum value without outputting a message.

RESWAIT=

(time1,time2)

(resource wait)
The times specified for time1 and time2 can be modified during runtime using the administration command KDCAPPL.

    time1

Maximum number of seconds for which a program unit can wait for a resource locked by another transaction: GSSBs, TLSs, ULSs, and on BS2000 systems possibly LTERM partners if ANNOAMSG=N.
If the resource does not become available within this time, the program unit receives an appropriate return code.
If the transaction currently occupying the resource is waiting for an input message following a PEND KP or PGWT KP program call, the program unit receives an appropriate return code immediately without having to wait for the period specified in time1. If a PEND KP or PGWT KP call is issued in a blocking transaction, all pending program units are informed of this by means of a return code.

RESWAIT=0: The application program does not wait for the resource to become available. If the resource is locked by another transaction, the requesting program unit immediately receives an appropriate return code.

Default: 120
Minimum value: 0
Maximum value: 32767

On BS2000 systems the real waiting time depends on the precision with which the bourse waiting time was set in the operating system.

    time2

Maximum number of seconds for which you can wait for a resource locked by another process. If time2 is exceeded, the application is terminated abnormally.

time2 should not be set too low, since certain activities in the UTM application must be performed and completed by a process before the same activities can be initiated in another process.

Example

When sending a message, a process locks the terminal to which the message is directed. If another process wishes to access an input message of the same terminal, it must wait for the terminal to become available again.

In particular, the value entered for time2 must be at least equal to the longest processing time (real time) required in the following cases:

  • In the case of a communication partner generated with PTERM ...,PTYPE=APPLI, the resources are locked for the entire duration of a processing step. This includes the time required to process the event exit VORGANG at the start and/or end of a conversation.

  • At the end of a conversation, the resources remain locked as long as the event exit VORGANG is running.

Default: 300
Minimum value: 300
Maximum value: 32767

If the value 0 is specified for time2, KDCDEF uses the default value 300 without outputting a UTM message. If you specify a value between 0 and 300, however, KDCDEF issues an appropriate UTM message.

SAT=

(security audit trail)

This operand is only supported on BS2000 systems.

Minimum event logging with SAT. Further information about "SAT logging" can be found in the openUTM manual “Using UTM Applications on BS2000 Systems”.

    ON

SAT logging is switched on.

Minimum logging with SAT is switched on for the following events:

  • signing a process on to and off from the UTM application

  • switching the memory protection key

  • exchanging programs

  • executing a UTM SAT administration command.

Minimum logging can be extended and controlled by means of preselection.
This is generated using the SATSEL statement and the SATSEL= operand in the USER and TAC statements. The administration command KDCMSAT can be used to modify the preselection values defined during generation.

    OFF

SAT logging is switched off
The logging procedure only covers attempts to access the SAT administration TAC KDCMSAT (apart from KDCMSAT HELP). All other events are ignored. SAT logging can be switched on and off using the SAT administration TAC KDCMSAT (see the openUTM manual “Using UTM Applications on BS2000 Systems”).

Default: OFF

SEMARRAY= 

(number,number1)

This operand is only supported on Unix, Linux and Windows systems.

Range of semaphore keys for global semaphores (process synchronization). Semaphore keys are global parameters under the Unix, Linux and Windows systems. With SEMARRAY, you enter an initial value number and an upper limit number. openUTM then reserves these keys, incrementing them by 1 starting with the initial value. For further information, please contact your system administrator.

This is a mandatory operand if SEMKEY= is not specified.

The SEMARRAY= and SEMKEY= parameters are mutually exclusive. Compared to SEMKEY=, SEMARRAY= offers the advantage of allowing openUTM to reserve more than ten semaphore keys. To calculate the number of semaphore keys required for a UTM application, please refer to the description of the global system resources in the openUTM manual “Using UTM Applications on Unix, Linux and Windows Systems”.

    number

Initial value (numeric value)

    number1

Number of keys to be reserved

Minimum value: 1
Maximum value: 1000

SEMKEY= 

(number,...)

This operand is only supported on Unix, Linux and Windows systems.
Semaphore keys (semaphore key) for global semaphores (process synchronization).
Semaphore keys are global parameters under the Unix, Linux and Windows systems. You can define up to 10 semaphore keys in a list. All semaphore keys (number,...) are specified in the form of a decimal number. For further information, please contact your system administrator.

This is a mandatory operand if SEMARRAY is not specified.

The SEMARRAY= and SEMKEY= parameters are mutually exclusive. Compared to SEMKEY=, SEMARRAY= offers the advantage of allowing openUTM to reserve more than ten semaphore keys. To calculate the number of semaphore keys required for a UTM application, please refer to the description of the global system resources in the openUTM manual “Using UTM Applications on Unix, Linux and Windows Systems”.

SM2=

This defines whether the UTM application is to supply data to SM2 or openSM2 for performance monitoring.

    NO

Performance monitoring with openSM2 is generally prohibited for the UTM application, i.e. the UTM application cannot supply data to openSM2, nor can this be explicitly activated by the UTM administrator.

    OFF

The UTM application can supply data to openSM2, but this must be explicitly activated by the administrator using KDCAPPL SM2=ON. The supply of data can be deactivated again at any time using the administration command KDCAPPL SM2=OFF.

Default value: OFF

    ON

The UTM application can supply data to openSM2. This is activated automatically when starting the UTM application. It can be deactivated again at any time by the UTM application administrator using the administration command KDCAPPL SM2=OFF.

SPAB=

length

Maximum length of the standard primary working area in bytes

Default: 512
Minimum value: 0
Maximum value: 32767

STATISTICS-MSG=

Specifies whether or not openUTM is to produce statistics message K081 hourly.

    FULL-HOUR

Statistics message K081 is produced every hour and written in the SYSLOG. At the same time, openUTM resets the following application specific statistical values to 0:

  • number of messages received (term_input_msgs)
  • number of messages sent/output (term_output_msgs)
  • number of requests to write records in the user log file USLOG (logfile_writes)
  • percentage of requests from buffers in the cache that led to wait times (cache_wait_buffer)

    NONE

Statistics message K081 is not produced and the statistical values listed above are not automatically reset to 0.
You should choose NONE if you want to reset the statistical values listed above via the administration when needed (see the openUTM manual “Administering Applications”, KC_MODIFY_OBJECT).

Default: FULL-HOUR

SYSLOG-SIZE=

size

Automatic size monitoring of the system log file SYSLOG by openUTM.

  • size !=0
    This can only be specified if the system log file SYSLOG is created as a file generation group (FGG). If SYSLOG is a normal file and a value other than 0 is entered for size, openUTM aborts the application startup with the start error 58. If SYSLOG is created as an FGG, you can use SYSLOG-SIZE to activate the automatic size monitoring of the SYSLOG by openUTM. In this case, size defines the file generation size at which openUTM switches to the next file generation.
  • size=0
    If the value 0 is specified for size (default), openUTM does not monitor the size of the SYSLOG file. Instead, it outputs all UTM messages directed to SYSLOG to the same file generation until openUTM switches to another file generation by means of administration (KDCSLOG command), or until size monitoring is activated.
  • size>=100
    Values >= 100 are interpreted by openUTM as follows: the size of each individual SYSLOG file generation must not exceed the value (size * size of a UTM page). The size of each UTM page is defined in BLKSIZE. When the size of the SYSLOG file exceeds this threshold value, openUTM automatically switches to the next SYSLOG file generation.
  • size<100
    openUTM automatically resets values between 1 and 99 to 100. In this case, a UTM message is output for information purposes.
  • size<0
    Values < 0 are rejected by KDCDEF.

The administrator can modify the generated threshold value, and activate or deactivate size monitoring as desired during operation (e.g. with the KDCSLOG command).

Default: 0 (no size monitoring)
Minimum value: 100
Maximum value: (231 - 1)

SYSTEM-TASKS

Controls the number of UTM system processes.
Under load, in the case of UTM applications all processes can be utilized by program unit runs, and they are then not available for processing other jobs.

To ensure that an application continues to be responsive and, for example, can also process internal jobs to terminate transactions, communication between the nodes of a UTM cluster application or an administrator's jobs in these situations, UTM starts further processes, known as UTM system processes, in addition to the processes generated and started by the user.

Generally no program unit runs are executed by the UTM system processes, and they are only used for internal jobs in bottleneck situations. Consequently the additional UTM system processes only place a slight load on the host.
The UTM system processes are started independently by UTM and in addition to the processes started by the user.
See also the MAX operand PRIVILEGED-LTERM in section "MAX - define UTM application parameters".

    *STD

*STD means that UTM starts (up to) three additional processes for the application; these are then used as UTM system processes. Depending on the number of tasks started for the application, the second, fourth, and seventh processes of an application become UTM system processes.

*STD is the default value.

    number

Maximum number of UTM system processes which are to be started in addition for the application.

The value 0 means that no UTM system process will be started.

Minimum value: 0
Maximum value: 10

Values greater than 10 are ignored and rounded down to 10.

The table below shows how many UTM system processes are started additionally for the generated value SYSTEM-TASKS=*STD in accordance with the start parameter TASKS:

Start parameter
TASKS=

Number of additionally started
UTM system processes

Total started processes

1

0

1

2

1

3

3

2

5

4

2

6

5

3

8

n > 5

3

n + 3

If more than three UTM system processes are generated, depending on the value of SYSTEM-TASKS and the number of started processes, the 11th, 21st, 31st, 41st, 51st, 61st, and 71st processes also become UTM system processes.

TASKS=

number

Maximum number of processes that can be used simultaneously for the application.

This is a mandatory operand.

Minimum value: 2
Maximum value: 240

KDCDEF automatically resets values < 2 to 2 without outputting a UTM message.

The current number of processes is defined when starting the application. You can specify TASKS=1 during startup. The administrator can dynamically modify the number of processes during runtime (e.g. with the administration command KDCAPPL). The number of processes specified during startup or set by the administrator must not exceed the value generated here.

TASKS-IN-PGWT=

number 

Maximum number of processes of the UTM application in which program units with blocking calls, e.g. the KDCS call PGWT, may run simultaneously. The value of TASKS-IN-PGWT must be less than that of the TASKS= operand.

If TASKS-IN-PGWT=0, it is not possible to generate a TAC class or a transaction code (TAC) for which blocking calls are permitted (see TAC/TACCLASS ...,PGWT=). In this case, PGWT=NO must be specified in all TACCLASS and TAC statement (see also the TAC statement in section"TAC - define the properties of transaction codes and TAC queues" and the TACCLASS statement in section "TACCLASS - define the number of processes for a TAC class" for more information).

Default value: 0
Minimum value: 0
Maximum value: number in TASKS -1

TERMWAIT=

time

(terminal wait)
Maximum time in seconds that may elapse in a multi-step transaction (i.e. after PEND KP) between dialog output to the partner and the subsequent dialog response from the partner. This value applies for all dialogs in which the partner assumes the client role (terminals, UPIC clients, OSI TP, LU6.1 and LU6.2 job submitters). For terminal clients, for example, time is the time the user has to think after PEND KP. In the event of a timeout, the transaction is rolled back and the resources reserved by the transaction are released. The connection to the partner is shut down.

Default: 600
Maximum value: 32767
Minimum value: 60

TRACEREC= 

number

Maximum number of entries in the process-specific trace areas handled by openUTM. This value applies to the trace area

  • of the main routine KDCROOT (UTM Diagarea)
  • of the UTM system code (KTA trace)
  • of the XAPTP module (XAP trace) for OSI TP applications

openUTM writes trace information to these areas for diagnostic purposes.

Length of the entries:

  • Entry in UTM Diagarea: 138 bytes (on 32-bit systems) or 256 bytes (on 64-bit systems)
  • KTA and XAP trace entry: 64 bytes (on 32-bit systems) or 112 bytes (on 64-bit systems

Default: 32500
Minimum value: 1
Maximum value: 32500 (depending on the available resources)

KDCDEF automatically resets values < 1 to the default value and values > 32500 to the maximum value without outputting a UTM message.

TRMSGLTH=

length

This defines the maximum value for the following:

  • The length of physical output messages sent to a terminal, printer or transport system application (PTYPE=APPLI) or received by a terminal or transport system application with PTYPE=APPLI. When the message length is calculated, all characters to be transmitted, including control characters etc., must be included.
  • The length of asynchronous output messages to transport system applications of the SOCKET type.
  • The length of the message section of the input message received from an UPIC client that uses TCP/IP via the socket interface. During the calculation of the length, it is necessary to take account of all the characters that are to be transferred, including protocol elements.

Default: 32700 bytes

Maximum value: 32700 bytes
A value < 32700 is replaced with the maximum value by KDCDEF with no message. Values < 32700 are only supported for compatibility reasons.

If you use RSO printers, the size of the RSO buffer (REMOTE-BUFFER- SIZE in the SPOOL parameter file) must be greater than or equal to 32700. See also section "Defining the RSO buffer size" (Entries for RSO and SPOOL) for more information.

USLOG=

This defines single- or dual-file operation for the user log file USLOG.

    SINGLE

Single-file operation is activated for the user log file.

Default: SINGLE

    DOUBLE

For security reasons, dual-file operation is activated for the user log file.
Further information on the user log file can be found in openUTM manual “Using UTM Applications”.

VGMSIZE=

number

This operand is only supported on BS2000 systems.

This parameter is used to generate a buffer area with the specified size for the service memory of an SQL database system. It also restricts the user’s share of the page pool. VGMSIZE= is specified in KB.

If the service memory area to be logged when the PEND call is issued is greater than number, the service is terminated with PEND ER.

Default value: 32KB
Minimum value: 32KB
Maximum value: 256KB

XAPTPSHMKEY=

number

This operand is only supported on Unix, Linux and Windows systems.

Authorization key for the XAPTP shared memory segment

Shared memory keys are global system parameters.

XAPTPSHMKEY is a mandatory operand if the application is to communicate via the OSI TP protocol.

 

The table below provides an overview of the purpose and default values of the individual operands of the MAX statement:

Operand

Purpose

Mandatory

Default value

Operands valid for all operating systems

APPLIMODE=

Choice of UTM variant: UTM-S or UTM-F


SECURE

APPLINAME=

Name of the UTM application

X

-

ASYNTASKS=

Asynchronous processing (number of processes for asynchronous processing and asynchronous services open at the same time)


1, 1

BLKSIZE=

Size of a UTM page


2K (in UTM cluster
applications: 4K or 8K)

CACHESIZE=

Tuning feature (size and properties of the cache)


Depending on the system:
BS2000 systems:
(1024,70%, NORES, PS)
Unix, Linux and
Windows systems (1024,70%)

CLRCH=

Character for overwriting the communication area and standard primary working area


None 

CONN-USERS=

Restriction on the number of users or clients active simultaneously


Depending on the system:
BS2000 systems:
No restriction
Unix, Linux and
Windows systems:
Mandatory operand 

CONRTIME=

Automatic connection setup for printers (waiting time for reconnection)


10 minutes 

DATA-COMPRESSION

Controlling data compression


STD 

DEAD-LETTER-Q-ALARM=

Monitors the number of messages received in the dead letter queue


0, i.e. no monitoring

DESTADM=

Asynchronous administration


None

DPUTLIMIT1=

Time-driven jobs (upper limit)


360 days

DPUTLIMIT2=

Time-driven jobs (lower limit)


1 day

GSSBS=

GSSB storage areas (maximum number)


32

HOSTNAME=

Virtual host name for the UTM application


8 blanks

KB=

Maximum length of the communication area


512

KDCFILE=

Assigning a KDCFILE

X

-

KEYVALUE=

Data access control using the lock/key code concept (number of the highest key code)


32

LEADING-SPACES=

Pass leading blanks in messages from terminals or from TS applications
(PTYPE=APPLI/SOCKET) to the program unit


NO

LPUTBUF=

Logging of user data with LPUT (number of PAM pages in the page pool)


1

LPUTLTH=

Logging of user data with LPUT (maximum LPUT message length)


1948 bytes

LSSBS=

LSSB storage areas (maximum number)


8

MOVE-BUNDLE-MSGS=NO

Automatic moving of waiting asynchronous messages of a slave LTERM, a slave LPAP, or a slave OSI-LPAP


NO

NB=

Maximum length of the KDCS message area


2048

NRCONV=

Maximum number of stacked services


OSI-SCRATCH-AREA=

Size in KB of an internal UTM working area


256

PGPOOL=

Size of the page pool and warning levels


100 UTM pages, 80%, 95% 

PGPOOLFS=

Tuning feature: splitting the page pool


Page pool in KDCFILE

PGWTTIME=

Maximum time for the KDCS call PGWT


TERMWAIT=time 

PRIVILEGED-LTERM=

Define the privileged LTERM


-

QTIME

Maximum permitted wait time for messages from service controlled queues


32767 seconds

RECBUF=

Tuning feature:
size of the restart area in KDCFILE or process-oriented system memory


5 PAM pages per process,
512 bytes

RECBUFFS=

Tuning feature:
splitting the restart area


in KDCFILE

REDELIVERY=

Maximum number of redeliveries of an asynchronous message


0 for UTM-controlled queues,
255 for servicecontrolled queues

RESWAIT=

Waiting time for a resource (e.g. GSSB, TLS) locked by another transaction (time1) or process (time2)


120 seconds, 300 seconds

SPAB=

Maximum SPAB length


512

SM2=

Permitting, activating, and deactivating the supply of UTM data to SM2


OFF

STATISTICS-MSG=

Statistics message K081 is produced and the counter is automatically reset to 0


FULL-HOUR

SYSLOG-SIZE=

Automatic size monitoring of the SYSLOG file by openUTM


 0

SYSTEM-TASKS

Number of UTM system processes


*STD 

TASKS=

Number of UTM processes

X

 -

TASKS-IN-PGWT=

Number of processes for PGWT jobs


TERMWAIT=

Maximum waiting time for dialog input within a transaction


600 seconds

TRACEREC=

Space reserved for diagnostic information (number of entries)


32500

TRMSGLTH= 

Maximum message length


32700 bytes

USLOG= 

Single- or dual-file operation of the user log file


SINGLE

VGMSIZE=

Generate the buffer area with the specified size


32 KB 

BS2000-specific operands 

BRETRYNR=

Communication with BCAM (number of retries when sending messages)


10

CARDLTH=

ID card reader for KDCSIGN check


 0

CATID=

Catalog IDs for the KDCFILE


Default CATID

LOCALE=

Default language environment


Blanks

LOGACKWAIT=

Support for output devices (waiting time for confirmation)


600 seconds

MP-WAIT=

Maximum waiting time per process for connection to the common memory pool


180 seconds

PRINCIPAL-LTH=

Maximum length of a Kerberos principal in bytes


32

REQNR=

Tuning feature: PAM I/O jobs (maximum number of parallel jobs)


20

SAT=

Minimum logging of events with SAT


OFF

VGMSIZE=

Size of the buffer area for the service memory of an SQL database system


32KB 

Unix, Linux and Windows system-specific operands

CACHESHMKEY=

Authorization key for a shared memory segment (global buffer for file access)

X

-

IPCSHMKEY=

Authorization key for a shared memory segment (communication between UTM processes)

X

-

IPCTRACE=

Number of UTM entries in the IPC trace area


1060

KAASHMKEY=

Authorization key for a shared memory segment (global data)

X

-

OSISHMKEY=

Authorization key for an OSS shared memory segment

with
OSI TP

-

SEMARRAY=

Range of semaphore keys for global semaphores (alternative to SEMKEY)

X

-

SEMKEY=

Semaphore keys for global semaphores (alternative to SEMARRAY)

X

-

XAPTPSHMKEY=

Authorization key for the XAPTP shared memory segment

with
OSI TP

-