| Sun Mainframe Administration Tool User's Guide |    
|
| Sun Mainframe Administration Tool User's Guide |
|
| C H A P T E R 10 |
|
Resources Tab |
The Resources tab enables you to display a window for each resource type you want to monitor. The following resource types are available:
The CICS Commands pane displays a list of supported CICS commands. The entry for each command shows the number of times the command was issued by the application program(s) executing in the region. All counts are initialized to zero when the region is started.
The following datapoints are displayed on the CICS Commands pane:
|
Identifies the CICS command. See Name. |
|
|
Indicates the number of times a command has been requested by application programs. See Count. |
The Name datapoint shows a CICS command supported by Sun MTP.
To find out if a particular CICS command is executed in a region, look at the Count datapoint. If the Count datapoint shows a nonzero number, then the command has executed n times since system initiation.
The value of Count for a CICS command is the number of times a command has been requested by application programs.
Count is an integer initialized to zero at region startup and incremented for each call to a particular command by an application program.
The column of Count values show cumulative counts from all application programs executing in a region.
The Count column gives a profile of the types and counts of CICS commands issued by the programs that run in a region.
The Files window shows the datasets and alternate indexes available to the region's transactions and programs.
Click the down arrow on the Resources tab and select Files.
The table shows all the VSAM files configured for the region.
|
|
Click the dataset or alternate index name.
The detail panel is displayed under the table.
The following datapoints are displayed for each dataset:
|
Identifies the dataset. See Name |
|
|
Indicates if an alternate exists for the dataset. See Alternate Index. |
|
|
Indicates the average number of bytes in the COMMAREA for inbound function ship requests. See Average Inbound FS Size |
|
|
Indicates the average number of bytes in the COMMAREA for outbound function ship requests. See Average Outbound FS Size. |
|
|
Identifies the physical file on disk. The name in the Name datapoint is the dataset name, which is the logical file name. A single physical file may be associated with multiple dataset names. |
|
|
Identifies the environment variable specifying the directory where the file is located. |
|
|
Indicates the file status as defined in the Sun MTP internal file control block structure. See Flags. |
|
|
Indicates the total number of inbound function ship requests for this dataset. See Inbound FS. |
|
|
Indicates the total number of index read I/O requests for this dataset. See Index Reads. |
|
|
Indicates the total number of index write I/O requests for this dataset. See Index Writes. |
|
|
Indicates the total number of locks obtained against this dataset. See Locks. |
|
|
Indicates the total number of outbound function ship requests for this dataset. See Outbound FS. |
|
|
Indicates the total number of read I/O requests for this dataset. See Reads. |
|
|
Identifies the remote system hosting this file for function shipping. |
|
|
Indicates the file type. See Type. |
|
|
Indicates the total number of locks released against this dataset. See Unlocks. |
|
|
Indicates the total number of times application programs have been forced to wait for a record within this file. See Waits. |
|
|
Indicates the total number of write I/O requests for this dataset. See Writes |
The Name datapoint on the Files pane contains the name of the dataset.
The dataset name is one to eight characters long.
An application program uses the dataset name to reference a particular file. The dataset name is mapped to a system file name (Disk File Name datapoint) whose location is defined in the Environment datapoint.
The Alternate Index datapoint indicates if the dataset is an alternate index file to a primary dataset.
An alternate index accesses the same segments as the primary index because both actually reference the same data file (and its segments). An alternate index is defined in both the file table and the VSAM catalog. To create an alternate index, you must recreate the VSAM file with the Record Editor or the unikixbld utility, which automatically create alternates from the information configured in the file table and VSAM catalog.
The Average Inbound FS Size datapoint indicates the average number of bytes in the COMMAREA for inbound function ship (FS) requests for a dataset.
The Average Inbound FS Size datapoint is calculated by dividing the total number of characters received by inbound FS requests for a specific dataset by the number of requests (Inbound FS datapoint). Note that remote applications can send an FS request for a dataset defined as either local or remote to the region. In the latter case, the region issues an FS request of its own out to the remote system on behalf of the original requestor.
This datapoint provides a general idea of the volume of data transferred to and from a dataset defined on the local region due to FS requests from remote regions.
The Average Outbound FS Size datapoint indicates the average number of bytes in the COMMAREA for outbound function ship (FS) requests to a remote dataset.
The Average Outbound FS Size datapoint is calculated by dividing the total number of characters sent by outbound FS requests to a specific remote dataset by the actual number of requests (Outbound FS datapoint). Note that the administration tool only calculates Average Outbound FS Size and Outbound FS for a remote dataset.
This datapoint provides a general idea of the volume of data transferred to a particular remote dataset.
The Inbound FS datapoint indicates the number of inbound function ship (FS) requests that have occurred for a specific dataset.
The value is a positive integer count.
An application program on a remote region can issue commands against a dataset defined on the local region. This remote request is considered an FS operation. Each request, no matter from which remote region, causes the Inbound FS count to increase. The remote application can request access to either a local or remote dataset. If the requested dataset is located on a remote system, Sun MTP function ships the request out to the appropriate remote system.
This datapoint helps identify the amount of traffic coming from remote regions to the local region for a particular dataset.
The number of Index Reads represents the total number of physical reads issued to the index file since the region was started. A physical read is a read not accommodated by Sun MTP's internal buffers. This read may, however, be handled by the operating systems buffer cache and not actually require a physical disk access.
Index Reads is a numeric quantity that is set to zero at region startup and increments for each physical read to the index portion of a dataset.
This datapoint is not set for remote datasets (those with a value set for the Remote System datapoint) because the administration tool does not communicate with the remote host.
This datapoint, together with Reads, Writes, and Index Writes, provides an accurate picture of dataset activity. Multiple highly active datasets on the same physical device decreases system throughput. All four of these datapoints should be used to determine the extent of a file's activity. Note that the Writes and Index Writes entail more overhead than their read counterparts.
There are ways to optimize dataset access performance. There are two kinds of configurable cache involved with a VSAM file local to a host machine: the operating system buffer cache and the Sun MTP buffer pool. The size of the Sun MTP buffer pool is easily configured in the VCT. Change the number of shared buffers, save the VCT to disk, and restart the region to activate the change.
There are also ways to distribute dataset files across hardware devices to achieve performance gains. The simplest way is to physically place entire datasets on separate disks. If the disks have separate disk controllers, performance can be further improved.
Another method to take advantage of I/O bandwidth is to use disk striping. This file system facility automatically distributes files across multiple devices. Again, consult your operating system's system administrator's guide for details.
Sun MTP provides another method to boost performance by spanning a dataset across multiple segments, each of which can reside on a separate device. Sun MTP allows a dataset to have as many as 8 segments. This method proves to be more efficient than the other two. You can choose to combine Sun MTP segmentation with operating system striping, but the results are not predictable since the file organization becomes extremely complex.
The number of Index Writes represents the total number of physical index writes issued to the index file since the region was started. A physical write is a write not accommodated by Sun MTP's internal buffers. This write may, however, be handled by the operating systems buffer cache and not actually require a physical disk access.
Index Writes is a numeric quantity that is set to zero when a region is started and increments for each physical write to the index portion of a dataset.
This datapoint is not set for remote datasets (those with a value set in the Remote System datapoint) because the administration tool does not communicate with a remote machine.
This datapoint, together with Writes, Reads, and Index Reads, provides an accurate picture of dataset activity. Multiple highly active datasets on the same physical device decreases system throughput. All four of these datapoints should be used to determine the extent of a file's activity. Note that the Writes and Index Writes entail more overhead than their read counterparts.
There are a few ways to optimize dataset access performance. There are two kinds of configurable cache involved with a VSAM file local to a host machine: the operating system buffer cache and the Sun MTP buffer pool. The size of the Sun MTP cache is easily configured in the VCT. Change the number of shared buffers, save the VCT to disk, and restart the region to activate a change.
There are also ways to distribute dataset files across hardware devices to achieve performance gains. The simplest way is to physically place entire datasets on separate disks. If the disks have separate disk controllers, performance can be further improved.
Another method to take advantage of I/O bandwidth is to use disk striping. This file system facility automatically distributes files across multiple devices. Again, consult your system's system administrator's guide for details.
Sun MTP provides another method to boost performance by spanning a dataset across multiple segments, each of which can reside on a separate device. Sun MTP allows a dataset to have any many as eight segments. This method proves to be more efficient than the other two. You can choose to combine Sun MTP segmentation with operating system striping, but the results are not predictable since the file organization becomes extremely complex.
The Locks datapoint shows the total number of times a file required locking to process data on a particular dataset. There are two kinds of file locks: record locks and control interval (CI) locks. The Locks datapoint counts only CI locks. Because a CI can contain multiple records, or even portions of records, record locking is implicit in a CI lock. A CI lock occurs when an application program requests a record (contained inside a CI) from a file, whether for read or for write.
The value of Locks ranges from 0 to n, where n depends on how frequently application programs lock a dataset.
This datapoint helps determine how heavily a file is used. For example, if the lock count is high and the transactions that access the file tend to run slowly, it is possible that transactions are waiting on each other due to CI resource contention. This could indicate a database design problem, or an application program problem in how, or in what sequence, the data is accessed.
The number of Locks and Unlocks should always be the same when no transactions are executing. If this is not the case, an internal Sun MTP problem has occurred. The system should be shut down and restarted. If this situation repeats itself, contact your authorized Sun service provider.
The Outbound FS datapoint shows the number of outbound function ships (FS) for a specific remote dataset.
The value is an integer count.
Sun MTP sends an outbound FS request out under two conditions:
Regardless of the situation, Sun MTP increments Outbound FS each time it processes an outbound FS request for access to a remote dataset.
Use this datapoint to monitor the traffic to a remote dataset.
The number of Reads represents the total number of physical reads issued to a dataset since the region was started. A physical read is a read not accommodated by Sun MTP's internal buffers. This read may, however, be handled by the operating system buffer cache and not actually require a physical disk access.
The Reads datapoint is an integer number that starts at zero when a region starts and increments for each physical read from (for KSDS, the data portion of) a dataset. Note that this datapoint is not set for remote datasets (those with a value set for the Remote System datapoint) because the administration tool does not communicate with the remote region.
This datapoint, together with Index Reads, Writes, and Index Writes, provides an accurate picture of dataset activity. Having multiple highly active datasets on the same physical device decreases system throughput. All four of these datapoints should be used to determine the extent of a dataset's activity. Note that the Writes and Index Writes entail more overhead than their read counterparts.
There are ways to optimize dataset access performance. There are two kinds of configurable cache involved with a VSAM file local to a host machine: the operating system buffer cache and the Sun MTP buffer pool. The size of the Sun MTP cache is easily configured in the VCT. Change the number of shared buffers, save the VCT to the disk, and restart the region to activate the change.
There are also ways to distribute dataset files across hardware devices to achieve performance gains. The simplest way is to physically place entire datasets on separate disks. If the disks have separate disk controllers, performance can be further improved.
Another method to take advantage of I/O bandwidth is to use disk striping. This file system facility automatically distributes files across multiple devices. Refer to your operating system's system administrator's guide for details.
Sun MTP provides another method to boost performance by spanning a dataset across multiple segments, each of which can reside on a separate device. Sun MTP allows a dataset to have as many as 8 segments. This method proves to be more efficient than the other two. You can choose to combine Sun MTP segmentation with operating system striping, but the results are not predictable since the file organization becomes extremely complex.
The Flags datapoint shows the file status as defined in the Sun MTP internal file control block structure.
The flags are a series of bits that reflect the status of the file to Sun MTP.
This datapoint is internal to Sun MTP.
Type shows the dataset type, or database organization.
The dataset Type indicates the file organization. Each of these types of database files are managed by the VSAM access method. The available types are:
A KSDS file requires a key for access. The keys are kept in an index file. Thus, a KSDS dataset is broken into two files, data and index. Sun MTP uses the logical file name for a dataset, defined in the file table, to identify these files, with a .dta and .idx extension for the data and index files, respectively.
The ESDS and RRDS file organizations do not require an index file. Therefore, the file name defined in the file table corresponds to the actual system file name.
Verify that a dataset's type is consistent with respect to the application programs accessing a particular dataset. Build a particular type of dataset with the Sun MTP Record Editor.
The Unlocks datapoint shows the total number of times a dataset was unlocked from a previous lock.
The number of Unlocks is an integer that is initialized to zero at region startup. The value of the Unlocks datapoint increases as data activity takes place.
If Unlocks does not match Locks, then the dataset may either be locked for normal processing or possibly involved in a program logic error. An error or deadlock is evident when the two datapoints differ in value and do not change for an extended period of time.
When system performance seems to be degrading, examine the Unlocks and Locks datapoints for a system's datasets. If these values remain constant when they should both be increasing with file activity, the system is probably in deadlock. Note that these values should become identical and not change when the system is idle. If the values do not change and they are different, there may be an internal Sun MTP problem.
The Waits datapoint represents the number of times application programs have to wait for a record of a particular dataset because another application program has already obtained the record.
Sun MTP initializes the number of Waits to zero at region startup, and increments the number upon every record contention for a particular dataset.
A large number of Waits indicates that many user transactions are accessing the same data for a particular dataset. This could indicate a possible database design problem.
When application programs must wait on a resource, such as a record in a dataset, the entire application's performance degrades. If the application's performance appears to slump after reaching a certain transaction rate, analyze the Waits value to see if the number is increasing. If so, there might be a database design flaw or a bad mix of application programs might be running at the same time. They might all be trying to access the same records in the same dataset.
The number of Writes represents the total number of physical writes issued to a data file since the region was started. A physical write is a write not accommodated by Sun MTP's internal buffers. This write might, however, be handled by the operating system buffer cache and not actually require a physical disk access.
The Writes datapoint is an integer number that starts at zero when a region starts and increments for each physical write to (for KSDS, the data portion of) a dataset. This datapoint is not set for remote datasets (those with a value set for the Remote System datapoint) because the administration tool does not communicate with the remote region.
This datapoint, together with Index Writes, Reads, and Index Reads, provides an accurate picture of dataset activity. Having multiple highly active datasets on the same physical device decreases system throughput. All four of these datapoints should be used to determine the extent of a dataset's activity. Note that the Writes and Index Writes entail more overhead than their read counterparts.
There are ways to optimize dataset access performance. There are two kinds of configurable cache involved with a VSAM file local to a host machine: the operating system buffer cache and the Sun MTP buffer pool. The size of the Sun MTP cache is easily configured in the VCT. Change the number of shared buffers, save the VCT to the disk, and restart the region to activate the change.
The Groups window displays the following information about the groups defined for the region.
The Journals window displays information about the Sun MTP journals. The following datapoints are displayed on the Journals window:
|
Journal file identifier. See Identifier. |
|
|
Indicates if this journal is used for accounting. Values are true and false. See Accounting. |
|
|
Indicates the buffer size in bytes for this journal. See Buffer Size. |
|
|
Indicates whether the system cache is enabled for I/O to this journal. Values are true and false. |
|
|
Identifies the environment variable that specifies the directory where the journal is located. |
|
The Identifier datapoint is the file identifier assigned to this journal. Sun MTP can support up to 99 journals per region.
Each journal is assigned a file identifier ranging from 01 to 99.
This file identifier is referenced by transaction and user resources when they want to enable accounting at a region and designate a particular journal file.
The Accounting datapoint indicates whether this journal is used for accounting purposes.
Accounting journals are archived by Sun MTP whenever they fill up or are closed. Refer to the Sun Mainframe Transaction Processing Software Administrator's Guide for information about accounting.
The Buffer Size datapoint indicates the size, in bytes, of the buffer for this journal.
Numeric value ranging from 72 bytes to 32 KBytes.
Larger buffer sizes increase buffering and reduce the file I/O, thereby improving performance.
The Mapsets window displays information about the mapsets being used in the region.
The following datapoints are displayed on the Mapsets window:
|
Indicates the number of transactions that are currently using the mapset. |
|
|
Indicates if the mapset is disabled. See Disabled. |
|
|
Indicates if the mapset is loaded into shared memory. See Loaded |
|
|
Indicates the total number of times this mapset has been executed. See Executions. |
Indicates whether the mapset is currently disabled for use.
If the mapset is disabled, requests to use the mapset will be denied and a response code returned to the requesting program.
The Loaded datapoint indicates whether the mapset is currently loaded into the region's memory.
If this datapoint is true, the mapset has been loaded into the region's memory and is available for use by applications.
If this datapoint is false, the next time this mapset is requested by a program, it will be loaded from the disk into memory.
The Executions datapoint indicates the total number of times this mapset has been executed.
An integer value initialized to zero at region startup and incremented each time an application program requests this mapset.
This datapoint can help identify high-use mapsets.
The Programs window shows information about the programs executing in the region. It displays information about every application program specified in the region's program table.
The Programs window helps the administrator determine which application programs are high use. These are candidates for optimization.
The following datapoints are displayed on the Programs pane:
|
Identifies the program. See Name. |
|
|
Indicates the level of application programming interface (API) support. See API. |
|
|
Indicates the total number of times the program has aborted. See Aborts. |
|
|
Indicates the total processor time (CPU) used by this program. |
|
|
Indicates the current number of transactions using this program. |
|
|
Indicates the total number of times this program was invoked by a Distributed Program Link (DPL). See DPL Inbound. |
|
|
Indicates the total number of times this program issued a DPL request. See DPL Outbound. |
|
|
Indicates if the program is disabled. See Disabled. |
|
|
indicates the number of times program was executed. See Executions. |
|
|
Indicates the average size of COMMAREA for inbound DPL invocations. See Average Inbound CA Size. |
|
|
Identifies the fully qualified Java |
|
|
Identifies the programming language this program is written in. See Language. |
|
|
Indicates whether the program is loaded into shared memory. See Loaded. |
|
|
Indicates the average size of COMMAREA for outbound DPL invocations. See Average Outbound CA Size. |
|
|
Indicates if the program is preloaded. See Preload. |
|
|
Identifies the program on remote system. See Remote Program. |
|
|
Four-character identifier of the remote system where the program is to execute. See Remote System. |
|
|
Identifies the shared library associated with this program. See Shared Library. |
The Name datapoint contains the name of a system executable program.
The name can have a maximum of eight characters.
In order for Sun MTP to execute an application program, two conditions must be met. First, the program must be registered in the program table. Second, the executable must actually exist.
The API datapoint indicates which API set the application program supports.
An application program that supports the full CICS API set can execute any CICS command. An application program that supports the DPL API set can execute only the API set corresponding to the DPL API set.
Programs that are called via the EXEC CICS LINK command and reside on a remote system are considered DPL and can only execute a subset of the full CICS API. For example, a program that resides on a remote system cannot execute an EXEC CICS SEND or RECEIVE MAP command because there is no terminal associated with the program on the remote system.
The Aborts datapoint shows the number of times a program has aborted since the region was started.
The Aborts datapoint is a integer value that is initialized to zero when the region starts and is incremented each time a transaction aborts.
A program can abort for many reasons. For example:
A high number of aborts might indicate that transactions are deadlocking trying to obtain the same records in a database. The Transactions Aborted datapoint on the System Performance Overview pane represents the total number of aborts for all programs executing within the region.
The DPL Inbound datapoint shows the total number of times this program was invoked by DPL requests from a remote region. These DPL requests can originate from any other region in the network configured in the system entries portion of the terminal table.
The value of DPL Inbound is an integer value.
An application program on a remote region can issue a LINK command and specify a program that is located in a Sun MTP region. When the remote application program issues the LINK, the program name is looked up in the remote program table. If it is identified as a remote program, a DPL request is sent to the remote region, which can be a Sun MTP region.
The DPL Outbound datapoint shows the total number of times this program issued a DPL request to remote regions.
The value of DPL Outbound is an integer value.
A local application program can issue a LINK command and specify a program that resides on a remote region. When the program issues the LINK, the program name argument is looked up in the program table. If it is identified as a remote program, a DPL request is sent to the remote region.
The Disabled datapoint indicates whether the program is currently disabled for use.
If the program is disabled, requests to use it are denied, and a response code is returned to the requesting program.
The Executions datapoint indicates the total number of times the program was executed since the region was started.
The Executions datapoint is an integer value initialized to zero at region startup and incremented each time an application program executes.
The Executions value is the sum of executions due to the following request types:
This datapoint helps identify high use programs. The application programs that execute the most often should be targets for optimization to increase overall system performance.
The Average Inbound CA Size datapoint represents the average number of characters associated with each inbound DPL request for a particular program.
The value is an integer representing a character count.
The average number of characters for inbound DPL requests is calculated by dividing the total number of characters that have been received by the number of inbound requests, DPL Inbound.
This datapoint provides a general idea of the volume of data transferred from a remote region to the local region for a specific program.
The Java Class datapoint defines the fully qualified Java class name for a Java program.
The Java class name can contain up to 255 characters.
This is the name of the Java class that will be loaded by the Java virtual machine (JVM
) when Sun MTP attempts to load this program.
The Language datapoint indicates the language in which the program was written.
|
This is a Sun MTP program. The value System is used to differentiate it from user programs. |
|
|
An application data table that can be the target of an EXEC CICS LOAD request. |
The Loaded datapoint indicates whether this program is load into the region's memory.
This is an indication that Sun MTP shared memory structures exist for this program.
The Average Outbound CA Size datapoint represents the average number of characters associated with each outbound DPL request made by a particular program.
The Average Outbound CA Size datapoint is an integer value representing a character count.
The average number of characters for outbound DPL requests is calculated by dividing the total number of characters that have been sent to a remote region by the number of outbound requests, DPL Outbound.
This datapoint provides a general idea of the volume of data transferred from the local region to any remote region for a specific program.
The Preload datapoint indicates whether this program is preloaded during region startup.
This datapoint applies to shared library programs. If it is yes, the region attaches the program library during startup processing, thereby making it readily available for use.
The Remote Program datapoint corresponds to the program name of a system executable at the remote region. Remote Program contains a value only if the local and remote names are different. By default, Sun MTP assumes the local and remote program names are the same. Refer to the Sun Mainframe Transaction Processing Software Administrator's Guide for information about using remote programs.
The Remote Program name can have a maximum of eight characters. It cannot specify a mapset name.
In order for Sun MTP to execute a remote application program, the same conditions as for a local application program execution must hold true. First, the remote program must be registered in the program table. Second, the program must actually exist in the remote region.
The Remote System datapoint corresponds to the remote region where the program is deployed.
The value of Remote System is a four-character identifier.
When a program in the program table is defined as remote, Sun MTP requests the remote region to initiate the DPL request. If undefined, Sun MTP uses a default mirror transaction identifier. The mirror transaction essentially performs the duties required to execute Program (or Remote Program if different from Program) on a remote region.
The Shared Library datapoint specifies a shared object library that contains the system executable for the program identified in the Program datapoint.
A Shared Library value can have a maximum of sixteen characters. It can include a path name prefix. The .so extension associated with shared object libraries is excluded from the Shared Library value.
The shared object library is located in a directory relative to the $KIXSYS value, unless the KIXLIB environment variable is set to a valid path name.
The Terminals window shows the current status of all terminals connected to a region, as well as unconnected terminals defined in the Sun MTP terminal table. There are many types of connections: 3270, EPI, free, local, remote, TN3270, TR, and unknown.
The Terminals window can display a large number of datapoints. However, most datapoints are specific to the terminal type, and are only set if applicable.
The Terminals window displays the following datapoints:
|
Indicates the current activity count for remotely connected terminals. See Active. |
|
|
Indicates if a device is performing a transaction. See Busy. |
|
|
Identifies the terminal device name. See Device. |
|
|
Indicates if the terminal is in or out of service. See In Service. |
|
|
Identifies the logical unit name of the terminal handler. See LU Name. |
|
|
Indicates the total number of messages for TCP/IP-based terminals. See Messages. |
|
|
Shows a specific 3270 model or the TERM environment variable. See Model. |
|
|
Process ID of the process handling this terminal. See PID. |
|
|
Shows the session identifier. See Session ID. |
|
|
Indicates the current status of a terminal. See Status. |
|
|
Identifies the system where the terminal handler client process runs. See Terminal Handler Host. |
|
|
Identifies the port number used by a terminal handler client process to communicate with a region. See Terminal Handler Port. |
|
|
Identifies the type of terminal handler. See Terminal Handler Type. |
|
|
Shows the user ID of the terminal user. See User ID. |
The Active datapoint shows the polling activity for a socket-based terminal handler (TH) process that runs on behalf of a connected device. The polling activity shows if a device is alive or not. Sun MTP polls 3270 and remote connections (actually, the TH process) to see if it is still connected to the region. This datapoint is used for an entry with a type of 3270 or Remote.
This value is zero if no connection exists. It alternates between the values 1 and 2 as polling occurs.
The Active datapoint is 0 when no polling is taking place. While a terminal is connected, the region pings the TH client process to determine if the process is still alive. After the region finds out that the TH process is alive, the Active datapoint takes a value of 2. Every subsequent polling interval, the region pings the TH client. If the TH does not respond within the next polling interval, the value for Active is decremented. If after two pings with no response, Active remains at 0, the region assumes the terminal has been disconnected. If a subsequent ping receives a response, Active is set back to 2.
If no response is received from a TH client process within the polling interval two times in a row (the value of Active reaches 0), Sun MTP assumes the device is no longer connected and frees up the terminal's entry in the region's terminal table (unless the entry is preconfigured). The datapoint immediately reflects any change in connectivity.
The Busy datapoint indicates if a device is performing a transaction. This datapoint is used for all types of connected entries.
The Busy datapoint displays either true or false. A value of true means that the device is performing a transaction.
The Device datapoint displays a form of device identifier based on the type of entry. This datapoint typically shows a terminal's definition as known to the client terminal handler process to help find the exact location of the terminal.
The value of Device is dependent on the type of entry. The following table shows the kind of value to expect for a given terminal type:
The Device name helps identify the origin of a terminal table entry. This datapoint is used for all types of entries except for 3270 and free entries.
The Host datapoint identifies the name of the system on which a terminal handler client process executes. A host name is displayed for all entry types (except Free and TR), since the value can be preconfigured in the terminal table.
The Host datapoint displays the name of a host machine, up to 16 characters. If the name of a host cannot be determined, the datapoint displays Unknown.
The PID value for a terminal handler identifies a specific process running on a particular host. The Device Name for UNIX-based terminal handlers, Local and Remote, refers to a physical device name on the host.
The reason a host is not displayed for a TR type is that Sun MTP ignores the corresponding setting in the terminal table.
The In Service datapoint indicates whether a 3270-like entry's device is in or out of service. A value appears for all (active or not) entries with a Type of 3270, EPI, TN3270, or TR.
The In Service datapoint displays one of the following values:
This datapoint indicates if a device is connected. The tool can show that inactive entries are in service if they are preconfigured in the terminal table. In this case, the In Service datapoint shows the value set in the table's In Svc datapoint.
When a terminal logs in to the region, it is put into service. An XPUx device can also be put into service with the CEMT transaction. For example:
The following CEMT transaction example takes a device out of service:
The LU Name datapoint displays the logical unit name of all 3270 entries in the Terminals window, as well as active transaction route (TR) entries.
The LU Name datapoint displays an alphanumeric string that is always eight characters or less.
This datapoint is populated for all 3270 entries, active or not. This includes terminals preconfigured in the 3270 devices portion of the terminal table. For preconfigured terminals, the LU Name datapoint shows the value (of the same name) as set in the table. The Terminals window also shows the LU Name for active TR surrogate entries, since the underlying representation is essentially a 3270-type connection.
A preconfigured TR entry in the 3270 devices portion of the terminal table also sets the LU Name datapoint. However, the tool only displays the LU Name for active TR entries, since the actual value gets set upon connection. In other words, Sun MTP ignores the LU Name datapoint for preconfigured TR entries, and learns of the actual LU Name dynamically.
The Messages datapoint displays the number of socket messages used to communicate back and forth between a remote terminal handler and a transaction server.
The Messages datapoint is a cumulative, numeric value initialized to zero at region startup.
The tool computes the Messages datapoint only for remote and 3270 connections.
Sun MTP uses this number to ensure correct communication between the TH and a transaction server.
For most 3270-like entries, this datapoint shows the terminal model number and type. For other kinds of entries, the tool displays a context-dependent value for the type of terminal. The Model datapoint is only displayed for active entries.
For 3270-like entries, this datapoint shows as much of the exact model as possible, for example, 3278 or 32782e. This is the case for connections with type equal to 3270 or EPI. TR connections merely show a generic value of 3270.
For the UNIX-based terminal handler unikixl, the Model datapoint shows the value of the TERM environment variable, for example, xterms or vt100, for an X terminal or a dumb terminal, respectively. TN3270 entries show a similar value, except the value represents the type of hardware the terminal handler runs on. For example, the Model is xterm for a TN3270 client.
The meaning of the Model datapoint is based on the type of the entry:
The Model datapoint can help identify additional terminal characteristics of a particular connection. This is especially true for 3270 and EPI type terminal handlers. For the UNIX-based terminal handlers, the Model datapoint tells if the end user is using an X terminal display or a dumb terminal. However, a user might set the TERM environment variable to a dumb terminal type, such as vt100, but still run the terminal handler in an xterm.
In all cases except one, the PID value is the system process ID of the process that handles a type of terminal window entry. The Host datapoint identifies the machine where the PID process is executing. The single exception is the PID for a transaction route entry, where there is no PID available to show.
The PID datapoint is a nonzero integer, usually with a maximum of five digits. The operating system assigns the PID when a terminal handler process initiates execution.
The Terminals window shows the PID for terminal handlers that are actually connected to a region. Entries with a blank PID are either preconfigured in the terminal table or are free to be used by terminals that are auto-installed. The Terminals window displays preconfigured entries of the terminal table to make the unconnected entries visible. For such entries, most datapoints are left blank because a connection does not exist.
The Port datapoint shows the port number used by a terminal handler client process to communicate with a region. The Port is only used by socket-based clients.
The Port datapoint is an integer value.
A region communicates with a terminal handler client through an operating system socket. A socket connects two ports, usually (but not necessarily) on different machines.
You cannot control the port number for the terminal handler client, because the operating system assigns them dynamically so that port numbers do not conflict within a host.
|
Note - The value in the Port datapoint is not the port number specified for the unikixmain server or the client initiator (unikixi). |
A Session ID value is displayed for 3270, EPI, and TR entries. The Session ID datapoint is a number that identifies a particular connection between a device and some portion of the region or communication software on a machine that allows the device to communicate with a region.
The Session ID datapoint has a nonzero integer value if a session exists. Otherwise, this datapoint displays nothing.
The interpretation of the Session ID datapoint depends on the type of entry. The following kinds of entries can display a value:
Use the value to identify diagnostic entries in the trace files for a particular session.
The Status datapoint shows the current status of a terminal for any active entry.
The Status datapoint can have the following values:
|
Shows that the terminal handler process is waiting for an Enter, in conversational mode, from the terminal to execute the transaction |
|
The value for the Status datapoint is dependent upon the timing of the inquiry into the terminal's status. In other words, the Status datapoint shows the activity at the exact moment the agent obtains the status from Sun MTP. User activity constantly changes the status of a particular terminal.
The Terminal Handler Type datapoint indicates the type of connection to a region rather than an actual device type. All connections to Sun MTP represent some form of 3270 communication. Each type of connection is handled by a context-specific terminal handler process or application programmatic interface (API). Therefore, type indicates the process type used to handle a particular terminal connection.
The type can be one of the following values: 3270, EPI, free, local, remote, TN3270, TR, or unknown (if the type is truly not known by the agent). An asterisk (*) prefix might be displayed if there is something wrong with the entry. For example, all items of unknown type show the following value: *Unknown.
The user ID associated with an entry in the Terminals window could either be a user ID from the Sun MTP Sign-On Table (SNT) or a system login user ID. An entry can be for a variety of terminal handler client and server processes.
The User ID datapoint displays a user ID up to eight characters. The user ID is most often the system login user ID of the user involved in a terminal table entry. The login user ID is a value specified in the password file (usually /etc/passwd or a similar NIS map file).
There are several types of Sun MTP terminal handlers and server processes, and the User ID datapoint has a different meaning for each type of entry:
|
User ID of the system process communicating to the region by means of the EPI protocol |
|
The user ID for a 3270 terminal handler can be overridden by specifying a user ID to VTAM or XPUx when linking up to a Sun MTP region. This case and a transaction route's user ID (where the user ID comes from CICS/Sun MTP) are the only cases where the user ID is not an operating system user ID.
The TS Table window displays information about the configured Sun MTP temporary storage resources.
The TS Table window displays the following datapoints:
|
Indicates the average character count for inbound function ship requests. See FS Average Bytes Inbound. |
|
|
Indicates the average character count for outbound function ship requests. See FS Average Bytes Outbound. |
|
|
Indicates the total number of inbound function ship requests for a particular temporary storage queue. |
|
|
Indicates the total number of outbound function ship requests for a particular temporary storage queue. |
|
|
Indicates whether this temporary storage queue is recoverable. Values are true or false. |
|
|
Identifies this temporary storage queue as defined in the corresponding remote system defined by the Remote System ID. |
|
|
Identifies the remote system to which requests will be shipped. |
This datapoint represents the average number of characters per inbound function ship (FS) request for a particular Temporary Storage (TS) queue.
The value of the datapoint is an integer character count.
This datapoint is calculated by dividing the total number of characters received by inbound FS requests for a specific TS queue by the number of requests, FS Total Inbound. Note that remote applications can send an FS request for a TS queue defined as either local or remote to the Sun MTP region. For the latter case, the region issues an FS request of its own out to the remote system (for the remote queue) on behalf of the original requestor.
This datapoint provides a general idea of the volume of data transferred to and from a TS queue defined on the local Sun MTP region due to FS requests from (possibly multiple) remote Sun MTP and CICS regions.
This datapoint represents the average number of characters per outbound function ship (FS) request for a particular remote temporary storage (TS) queue.
The value of the datapoint is an integer character count.
This datapoint is calculated by dividing the total number of characters sent by outbound FS requests to a specific remote TS queue by the number of requests, FS Total Outbound.
This datapoint provides a general idea of the volume of data transferred to a particular remote TS queue.
The Temporary Storage (TS) Queues window displays information about active TS queues for a region. It displays the following datapoints:
The Extrapartition Transient Data Queue (TDQ) window displays information about extrapartition transient data (TD) queues.
It displays the following datapoints:
|
Identifies the extrapartition TD queue. See Name. |
|
|
Indicates if the queue is open for access. See Open. |
|
|
Indicates if the queue is enabled. Values are true and false. |
|
|
Identifies a system environment variable specified for this queue. See Environment. |
|
|
Identifies the file associated with this queue. See Disk File Name. |
|
|
Identifies the record format of the file See Format. |
|
|
Indicates if this is an input queue. Values are true and false. |
|
|
Identifies the length of a record to be sent to this queue. See Record Length. |
|
|
Indicates the number of inbound function ship requests for this queue. See FS Total Inbound. |
|
|
Indicates when the last record was read from this queue. See Last Read Time. |
|
|
Indicates when the last record was written to this queue. See Last Write Time. |
|
|
Indicates the average character count for inbound function ship requests. See FS Average Bytes Inbound. |
The Name datapoint is the name of a transient data (TD) queue defined in the Extrapartition Destinations portion of the Sun MTP Destination Control Table (DCT).
The Name datapoint is four characters.
Application programs use the name of a TD queue to specify a particular queue within the application code.
The Environment datapoint shows the name (not the value) of a system environment variable specified for a given TD queue in the Extrapartition Destinations section of the DCT.
By convention, the name of an environment variable is an uppercase character string of at most 14 characters. The environment variable value contains a character string that specifies a file system directory. To view the value of the Environment variable, echo the value at the system prompt where the region was started, as follows:
where variable-name is the name displayed in the Environment datapoint.
The value of the Environment variable specifies the system directory that contains the file for a queue. The actual name of the queue appears in the Disk File Name datapoint. Concatenate the value of Disk File Name to the end of the value of the Environment for the full path name of the file that contains the TD queue.
The Disk File Name datapoint contains the name of the file associated with a TD queue.
A standard system file name with a maximum of eight characters.
The Disk File Name identifies a variable-length KSDS VSAM file, with a maximum record size of 32 KBytes. Concatenate the value of Disk File Name to the end of the value of the Environment to get the full path name of the file used by the TD queue.
The Format datapoint indicates the record format of the file.
|
Line file of character data; a line feed at the end of each line |
|
|
Line file of character data, linked to kixprint shell script |
|
The FS Total Inbound datapoint shows the number of inbound FS requests for a particular TD queue.
The value of the datapoint is an integer count of requests.
The FS Total Inbound datapoint shows the number of function ship requests that the local node has received from remote nodes requesting a particular TD queue.
This datapoint gives you a general idea of the volume of data that is being transferred from multiple remote nodes to the local node for a specific TD queue.
The Record Length datapoint displays the length, in bytes, of a record to be sent to a particular extrapartition TD queue.
The value of the Record Length datapoint is an integer number of bytes in the record.
The Open datapoint indicates if a particular queue is open for access.
This datapoint displays the current state of the TD queue. The value can be set for startup through the DCT Extrapartition Destinations screen, or dynamically with the CEMT SET command.
This datapoint indicates when the last record was read from a TD queue.
The format is ddd mmm nn hh:mm:ss-GMT-hh:mm yyyy
ddd: day
mmm: month
nn: date
hh: hours
mm: minutes
ss: seconds
yyyy: year
If there has never been an entry on a TD queue, this datapoint displays blanks
Sun MTP records the exact time when an application reads from a TD queue with a READQ TD command.
This datapoint indicates when the last record was written to a particular TD queue.
The format is ddd mmm nn hh:mm:ss-GMT-hh:mm yyyy.
ddd: day
mmm: month
nn: date
hh: hours
mm: minutes
ss: seconds
yyyy: year
If there has never been an entry on a TD queue, this datapoint displays blanks.
Sun MTP records the exact time when an application writes to a TD queue with a WRITEQ TD command.
The FS Average Bytes Inbound datapoint represents the average number of characters per inbound FS request for a particular TD queue.
The value of this datapoint is an integer character count.
This datapoint is calculated by dividing the value the total number of characters received by inbound FS requests for a specific TD queue by the number of requests, FS Total Inbound. Note that remote applications can send an FS request for a TD queue defined as either local or remote to the region. For the latter case, the region issues an FS request of its own out to the remote system (for the remote queue) on behalf of the original requestor.
This datapoint provides a general idea of the volume of data transferred to and from a TD queue defined on the local Sun MTP region due to FS requests from (possibly multiple) remote regions.
The Intrapartition Transient Data Queue (TDQ) pane displays information about intrapartition queues. It displays the following datapoints:
|
Identifies the intrapartition TD queue. See Name. |
|
|
Identifies if the queue is enabled. Values are true and false. |
|
|
Identifies a system environment variable specified for this queue. See Environment. |
|
|
Identifies the file associated with this queue. See Disk File Name. |
|
|
Indicates if the queue is recoverable. Values are true and false. |
|
|
Value specified by the TERMID parameter in the EXEC CICS command. See Terminal ID. |
|
|
Indicates the number of inbound function ship requests for this queue. See FS Total Inbound. |
|
|
Identifies the transaction identifier of the transaction to execute when the number of entries in the queue reaches the Trigger Level value. See Transaction ID. |
|
|
Identifies a threshold value for the number of entries on a transient data (TD) queue. See Trigger Level. |
|
|
Indicates when the last record was read from this queue. See Last Read Time. |
|
|
Indicates when the last record was written to this queue. See Last Write Time. |
|
|
Indicates the average character count for inbound function ship requests. See FS Average Bytes Inbound. |
The Name datapoint is the name of a TD queue defined as the DestID in the Intrapartition Destinations portion of the DCT.
The Name datapoint consists of four characters.
Application programs use the name of a TD queue to specify a particular queue within the application code.
The Environment datapoint shows the name (not the value) of a system environment variable specified for a given TD queue in the Intrapartition Destinations section of the DCT.
By convention, the name of an environment variable is an uppercase character string of at most 14 characters. The environment variable value specifies a character string that specifies a file system directory. To view the value of the Environment variable, echo the value at the system prompt where the region was started, as follows:
where variable-name is the name displayed in the Environment datapoint.
The value of the Environment variable specifies the system directory that contains the file for a queue. The actual name of the queue appears in the Disk File Name datapoint. Concatenate the value of Disk File Name to the end of the value of the Environment for the full path name of the file that contains the TD queue.
The Disk File Name datapoint is the name of the file associated with a TD queue.
A standard system file name with a maximum of 14 characters.
The Disk File Name datapoint identifies a variable-length KSDS VSAM file, with a maximum record size of 32 KBytes. Concatenate the value of Disk File Name to the end of the value of Environment to get the full path name of the file used by the TD queue.
The FS Total Inbound datapoint shows the number of inbound FS requests for a particular TD queue.
The value of the datapoint is an integer count of requests.
The FS Total Inbound datapoint shows the number of function ship requests that the local node has received from remote nodes requesting a particular TD queue.
This datapoint gives you a general idea of the volume of data that is being transferred from multiple remote nodes to the local node for a specific TD queue.
This datapoint indicates the most recent time a record was read from a TD queue.
The format is ddd mmm nn hh:mm:ss-GMT-hh:mm yyyy.
ddd: day
mmm: month
nn: date
hh: hours
mm: minutes
ss: seconds
yyyy: year
If there has never been an entry on a TD queue, this datapoint displays blanks.
Sun MTP records the exact time when an application reads from a TD queue with a READQ TD command.
This datapoint indicates the most recent time a record was written to a particular TD queue.
The format is ddd mmm nn hh:mm:ss-GMT-hh:mm yyyy. If there has never been an entry on a TD queue, this datapoint displays blanks.
Sun MTP records the exact time when an application writes to a TD queue with a WRITEQ TD command.
The Terminal ID datapoint represents the value specified by the TERMID parameter in the EXEC CICS command. It is the terminal identifier that the transaction is to be executed against.
The value is any valid four-character name. If the command is to execute locally, The terminal ID must match an entry in the Sun MTP terminal table.
The Terminal ID datapoint specifies the name of a terminal where the task will run. If omitted, the task runs without a terminal. If a Terminal ID datapoint is not displayed, it indicates that the application program cannot perform I/O to a terminal.
The Transaction ID datapoint contains the transaction identifier of the transaction to execute when the number of entries in a TD queue reaches the Trigger Level value.
The Transaction ID datapoint is a one- to four-character identifier specified in the Intrapartition Destinations portion of the Sun MTP DCT.
When a TD queue reaches its trigger value, the transaction specified by Transaction ID is invoked. Therefore, in order to be executed, the Transaction ID must have an entry in the transaction table.
The Trigger Level datapoint is a threshold value for the number of entries on a TD queue. When the TD queue reaches the trigger level, a specific transaction ID is executed.
The Trigger Level datapoint is a numeric value between 0 and 99,999. The administrator defines the value for a particular TD queue in the Intrapartition Destinations portion of the DCT.
When a Trigger Level value is zero, Sun MTP never starts the transaction. When the number of entries on a TD queue reaches the Trigger Level value, Sun MTP starts the transaction specified by transaction ID. In order for Sun MTP to start the transaction, the transaction ID must have an entry in the transaction table.
The FS Average Bytes Inbound datapoint represents the average number of characters per inbound FS request for a particular transient data queue.
The value of the datapoint is an integer character count.
This datapoint is calculated by dividing the value the total number of characters received by inbound FS requests for a specific TD queue by the number of requests, FS Total Inbound. Note that remote applications can send an FS request for a TD queue defined as either local or remote to the region. For the latter case, the region issues an FS request of its own out to the remote system (for the remote queue) on behalf of the original requestor.
This datapoint provides a general idea of the volume of data transferred to and from a TD queue defined on the local Sun MTP region due to FS requests from (possibly multiple) remote regions.
The Remote Transient Data Queue (TDQ) pane displays the following information about remote transient data queues:
|
Identifies the remote TDQ. See Name. |
|
|
Indicates if the queue is enabled. Values are true and false. |
|
|
Indicates the average size of inbound function shipping requests in bytes. |
|
|
Indicates the average character count for outbound function ship requests. See FS Average Bytes Outbound. |
|
|
Indicates the total number of inbound function shipping requests. |
|
|
Indicates the number of outbound function ship requests for this queue. See FS Total Outbound |
|
|
Indicates the length of the record to be sent to the remote TDQ. See Record Length. |
|
|
Identifies the terminal name used to run the triggered transaction. |
The Name datapoint represents the name of the remote TD queue that an application program references in the WRITEQ TD, DELETEQ TD, and READQ TD commands. The application accesses Name over the Remote System ID connection.
The Name datapoint is a one- to eight-character name. The name of a TD queue is defined by the application program when it creates a queue with the first WRITEQ TD command issued for a particular remote queue.
The FS Average Bytes Outbound datapoint represents the average number of characters associated with each outbound FS request for a TD queue.
The value of the datapoint is an integer character count.
The average number of characters for outbound TD function ship requests is calculated by dividing the total number of characters that have been sent by the number of outbound TD function ship requests (FS Total Outbound).
This datapoint can give you a general idea of the volume of data that is being transferred to multiple remote nodes from the local node for the specified queue.
This datapoint shows the number of outbound FS requests for a given TD queue.
The value of the datapoint is a number representing a request count.
Sun MTP processes an outbound FS request under two circumstances. First, a local application program can issue a READQ TD or WRITEQ TD against a remote TD queue. Sun MTP ships the request to the system identified by Remote System ID for the remote queue. The other condition where this happens is by a request generated by a remote application program. Such a program's region could have the TD queue defined as residing in the Sun MTP region while the TD queue can actually reside somewhere else. In this case, Sun MTP forwards the request to the Remote System ID that it knows about. Regardless of the situation, Sun MTP increments FS Total Outbound each time it processes a FS for access to a remote TD queue.
This datapoint can give you a general idea of the volume of data transferred to remote regions from the local Sun MTP region for a specific TD queue.
The Record Length datapoint contains the length of the record to be sent to a remote TD queue.
The value is an integer number of bytes in the record.
The Record Length is specified in the TD queue definition in the Remote Destinations portion of the Sun MTP DCT.
The Remote Systems pane displays the following information about remote systems:
The Transaction window displays information about the transactions specified in the transaction table. This information can be useful in determining high-use transactions, which are candidates for optimization. In particular, the Aborts datapoint shows that how often transactions are aborting. When this happens, check the Programs window to determine which program is aborting.
The following datapoints are displayed on the Transactions window:
|
Transaction identifier. See Name. |
|
|
Indicates the total number of times this transaction aborted. See Aborts. |
|
|
Indicates if accounting is on or off for the transaction. See Accounting Option. |
|
|
Identifies the assigned accounting journal. See Acct File ID |
|
|
Indicates the average number of bytes per asynchronous processing (AP) request inbound. See AP Average Bytes In. |
|
|
Indicates the average number of bytes per AP request outbound. See AP Average Bytes Out. |
|
|
Indicates whether the transaction is a back-end DTP transaction. See APPC Enabled. |
|
|
Indicates the total processor usage. See CPU. |
|
|
Indicates the total system processor usage. See CPU System. |
|
|
Indicates the total user processor usage. See CPU User. |
|
|
Indicates if this transaction is disabled. See Disabled. |
|
|
Indicates if dump production is inhibited. See Dump Suppressed. |
|
|
Indicates the total number of times the transaction has been executed. See Executions. |
|
|
Indicates the total ISC AP requests (inbound). See ISC AP Total Requests In. |
|
|
Indicates the total ISC AP requests (outbound). See ISC AP Total Requests Out. |
|
|
Indicates whether the transaction is locally queued if the remote system in unavailable when the transaction is shipped. If true, the transaction is queued locally. If false, the transaction is not queued locally. |
|
|
Identifies the first program invoked by this transaction. See Program. |
|
|
Identifies the remote system to which requests will be shipped. |
|
|
Identifier of the transaction on the remote system. See Remote TranID. |
|
|
Indicates the screen size allowed for the transaction. See Screen Size. |
|
|
Indicates the security level of this transaction. See Security Keys. |
|
|
Indicates the number of times this transaction was started internally. See STARTs. |
|
|
Indicates the size in bytes of any transaction work area assigned to the transaction. Values range from 0 (no TWA) to a maximum of 32 KBytes. |
|
|
Identifies the transaction class to which transaction is assigned. See TX Class. |
The Name datapoint shows the transaction identifier as specified in the region's transaction table, which is used to map a transaction identifier to a program for execution.
A user or program runs an application program by requesting its transaction ID.
If a requested transaction is not defined in the transaction table, the user receives a message that the transaction ID is invalid.
The APPC Enabled datapoint indicates whether a transaction is a back-end DTP transaction.
The APPC Enabled datapoint value reflects the APPC datapoint value of an entry in the transaction table.
The Aborts datapoint shows the number of times a particular transaction has aborted since the region was started.
The Aborts datapoint is a integer value initialized to zero when the region starts and incremented each time a transaction aborts.
A transaction can abort for many reasons. For example, the application program does not handle a CICS HANDLE CONDITION properly, or a transaction server cannot recover from an application request (for example, divide by zero), or a deadlock condition occurs, or the region aborts a transaction to make space in the recovery file.
A high incidence of transaction aborts can indicate that many transactions are deadlocking trying to obtain the same records in a database. Confirm this by examining the Transactions Deadlocked datapoint on the Performance Overview window. The Transactions Aborted datapoint on the Performance Overview window represents the total number of aborts for all transactions executing within the region. When these two values increase together, you might have to review the database access protocol. Check the Programs window to identify the programs causing the aborts.
The Accounting Option datapoint indicates whether accounting is specified for the transaction.
The Accounting Option datapoint has one of the following values:
|
Accounting is controlled by the transaction accounting setting in the Monitoring Control Table (MCT) |
The value of Y for the Accounting Option datapoint does not necessarily mean that the region generates accounting records for a particular transaction. The same condition applies when the Accounting Option datapoint is D. Accounting must be specified at both the transaction and global levels in order for the region to generate accounting records for a transaction.
The Acct File ID datapoint displays the number of the journal that receives accounting records for this transaction.
An integer number between 1 and 99.
This datapoint displays a zero if accounting is not specified for the transaction.
The administrator can exert a fair degree of control over the target locations for accounting records. For example, each transaction could theoretically have its own accounting record file. The administrator can also group the accounting records of some number transactions into a single shared file.
The AP Average Bytes In datapoint shows the average number of characters associated with each inbound ISC asynchronous processing (AP) request for a particular transaction from a remote region.
The value is a character count.
The value is calculated by dividing the total number of characters that have been received from a remote region by the number of inbound requests (ISC AP Total Requests In).
This datapoint gives a general idea of the volume of data for a particular transaction that is being transferred to the local region from a remote region.
The AP Average Bytes Out datapoint shows the average number of characters associated with each outbound ISC asynchronous processing (AP) request for a particular transaction at a remote region.
The value is a character count.
The value is calculated by dividing the total number of characters that have been sent to the remote region by the number of outbound requests, (ISC AP Total Requests Out).
This datapoint gives a general idea of the volume of data for a particular transaction that is being transferred from the local region to a remote region.
The CPU datapoint shows the accumulated amount of CPU time spent executing a transaction since the region was started.
The value is displayed as the total number of seconds.
The CPU value of a transaction includes both kernel (system call) and user (application code) execution time. If a region uses a database access method instead of the VSAM method, the CPU datapoint does not reflect the execution time spent by the external database server.
If a transaction executes only a few times (small number of Executions) and the CPU datapoint indicates it executes for a longer than expected period of time, the transaction is either a candidate for optimization or the victim of a program logic error. In either case, the application program code requires attention.
The CPU (System) datapoint shows the accumulated amount of CPU time the transaction has spent executing operating system calls.
The value is displayed as the total number of seconds.
The CPU (User) datapoint shows the accumulated amount of CPU time the transaction has spent executing user (application) code.
The value is displayed as the total number of seconds.
The Disabled datapoint indicates whether the transaction is currently disabled.
A disabled transaction cannot be initiated at a Sun MTP region.
The Dump Suppressed datapoint indicates whether the transaction currently has user dumps suppressed.
When user dumps are suppressed, Sun MTP does not generate a dump file as a result of a transaction abort.
The Executions datapoint shows the number of times a transaction has executed since the region started.
An integer value initialized to zero at region startup and incremented each time the transaction executes.
The Executions value is the total number of executions of a transaction, whether the transaction was requested internally or externally. Specifically, Executions is the sum of executions due to the following request types: an external request from an end user, internal requests from another program, or an internal request due to a trigger condition for a transient data queue.
This datapoint helps identify high use transactions. The transactions that execute the most often should be targets for optimization to improve overall system performance.
This datapoint represents the number of inbound asynchronous processing (AP) requests for a given transaction received from remote regions.
An integer value initialized to zero at region startup and incremented each time the transaction executes.
There are two different ways that a remote region can initiate an AP request into the local system. First, the remote application program can issue a START command with a transaction ID that is defined as remote in the remote region's transaction table. Second, the remote application can specify the SYSID as a parameter to the START command.
This datapoint shows the number of asynchronous processing (AP) requests for a particular transaction at a remote region.
An integer value initialized to zero at region startup and incremented each time the transaction executes.
There are two different ways to initiate an AP request to a remote region. First, the application program can issue a START command with a transaction ID that is defined as remote in the transaction table. Second, the application can specify the SYSID as a parameter to the START command.
The Program datapoint contains the name of a system executable that is associated with the transaction name.
The Program datapoint can have a maximum of eight characters.
Every transaction must be associated with the application program that is to be executed on its behalf. Each transaction ID and its associated program is defined in the transaction table.
In order for a region to execute an application program, three conditions must be true. First, the transaction ID and program must be defined in the transaction table. Sun MTP requires this definition to map a request for a particular transaction ID to an actual program. Next, the program must be registered in the program table. Sun MTP refers to this definition to identify the type of file associated with the program. Finally, the file must actually exist.
The Remote TranID datapoint refers to a transaction that is located on a remote system.
The value of the Remote TranID datapoint is a one- to four-character name representing a transaction ID defined on the remote system.
When a remote transaction ID is specified for a local transaction ID, it indicates that the transaction is to be executed on a remote system and the name of the transaction is specified by the Remote TranID value.
There are two cases that can occur when a remote transaction ID is specified in the transaction table of the local system:
The STARTs datapoint displays the number of times a transaction was initiated internally, either by another transaction or application program, or from a transient data queue trigger condition.
The datapoint is an integer value initialized to zero at region startup and incremented as application usage initiates a transaction ID.
This datapoint is similar to the Executions datapoint except that this datapoint does not include the number of times a transaction was requested by an end user directly from a terminal.
Subtract the value in this datapoint from the Executions datapoint for a profile of how often end users at a terminal request a particular transaction.
The Screen Size datapoint shows the terminal screen size allowed for execution of the transaction.
The Screen Size datapoint has one of the following values:
|
Indicates that the transaction uses the default screen size (24 lines and 80 columns) |
|
|
Indicates that the transaction uses an alternate screen size |
If the Screen Size datapoint is ALT, Sun MTP allows this transaction to run on screen sizes of 27 lines and 132 columns (Model 5 3270 Terminal) or 43 lines and 80 columns (Model 4 3270 Terminal). The Screen Size values indicate the screen size that the specified transaction can support.
The Screen Size datapoint can be used to determine if a particular terminal is trying to execute a transaction that it cannot support due to its screen size limitations.
The TX Class datapoint contains the name of the transaction class assigned to the transaction.
The TX Class datapoint contains the name of a transaction class configured for the region.
If transaction classes are configured for the region, requests for this transaction will be scheduled by the associated transaction class.
The Security Keys datapoint shows the security level for a particular transaction. An end user must have this security level in order to run the transaction.
A number from 1 to 64. Each number represents a different security level.
Sun MTP compares a transaction's Security Keys value against a user's security key to determine if the user can execute the transaction or not. The administrator may assign a security level to a specific user by defining an entry for the user in the user table.
If a user is not registered in this table, the user receives a default security key of 1. This means the user can only execute transactions with a transaction security value of 1. If the user is in the user table (the system user ID matches the user ID defined in the table), the user implicitly receives the defined security key upon login or can change security levels explicitly (to one specified in the user table) with the CSSN transaction.
All Sun MTP system transactions are installed with a default security key value of 1. This enables all users to run these transactions. It is the responsibility of the Sun MTP system administrator to change the security level of the system transactions to limit their use. Refer to the Sun Mainframe Transaction Processing Software Administrator's Guide for more information about security.
The Transaction Classes window displays information about each transaction class defined in the region.
The Users pane displays user identification and password information about each user configured for the region. It displays the following datapoints:
|
Defines an identifier for this user that can be used to log in to the region by means of the CESN transaction. |
|
|
Indicates whether accounting is specified for this user. See Accounting Option. |
|
|
Indicates the date and time the existing user password expires. |
|
|
Indicates the total number of times an incorrect password was supplied at login. See Invalid Password. |
|
|
A three-character datapoint that identifies this user. This information is used by the EXEC CICS ASSIGN OPID command. |
|
|
A three-character datapoint that classifies this user. See Operator Class. |
|
|
Defines an identifier for this user that can be used to log in to the region via the CSSN transaction. |
|
|
Defines the security level for this user for resource management tasks. This information is used by the EXEC CICS ASSIGN OPERKEYS command. |
|
|
Defines the security level for this user. See Security Key. |
|
|
Indicates whether the user password is currently suspended. Values are true and false. |
The Accounting Option datapoint indicates whether accounting is specified for this user.
|
Indicates that accounting is controlled by the user accounting setting in the Monitoring Control Table (MCT) |
The value of Y for the Accounting Option datapoint does not necessarily mean that the region generates accounting records for a particular user ID. The same condition applies when the Accounting Option datapoint is D. Accounting must be specified at both the user and global levels in order for the region to generate accounting records for a user.
The Invalid Password datapoint indicates the total number of times an incorrect password was supplied when the user tried to log in to the region.
The count is reset to zero following a successful login. The value, therefore, indicates the number of unsuccessful attempts since the last unsuccessful attempt.
The Operator Class datapoint is a three-character datapoint that classifies this user. This information is used by the EXEC CICS ASSIGN OPCLASS command.
An Operator Class value of SYS enables a user to perform system administration tasks.
The Security Key datapoint indicates the security level for this user. This information is used by the EXEC CICS ASSIGN OPSECURITY command.
A hexadecimal bit mask that is used to check the user's authority when requesting a transaction.
| Sun Mainframe Administration Tool User's Guide | 817-0572-11 |
|
Copyright © 2004, Sun Microsystems, Inc. All rights reserved.
To Display the Files Window