There is a set of EGL programs that should perform well
running in segmented mode in the CICS® environment.
An additional benefit is that these programs are easier to maintain,
test, and enhance than a single EGL program that contains all the
same functions.
The diagram below shows the relationship between four EGL programs
that perform three tasks. The only purpose of the menu program is
to access the other three programs. When the user selects the desired
task, the menu program transfers control to the corresponding program
by using a transfer to program statement.
The menu program passes a small working storage record to further
define the request. The transferred-to program prompts the user for
required data, performs the task as often as needed and uses the transfer
to program statement to return to the menu program.
Figure 1. Hierarchical structure using a transfer to program
statement
Using a
transfer to program statement
solves the following segmented mode restrictions:
- A called program cannot run in segmented mode unless all programs
in the chain are segmented.
- Called programs do not release the caller's resources because
program control returns to the calling program.
- The amount of data rolled in/out during a segmented converse is
much smaller. Only the program currently in control has its data areas
saved.
In the IMS/VS environment, a
transfer to program statement
does not release the storage for the original program. In the example,
the menu program is the original program. If you are developing programs
that run in both IMS™ and CICS environments, you can use
either a
transfer to program or a
transfer
to transaction statement. If you are developing programs
that run in IMS only, use a
transfer
to transaction statement for the following reasons:
- To free resources for the transferred-from programs
- To cause a commit point and release forUpdate locks
- To permit each program to have its own DB2® plan and a different PSB
- To permit each program to have different performance tuning information
in the IMS system definition
Use a
transfer to program statement
in the IMS environment if you
do not want a commit point to occur or if you need both programs to
use the same DB2 plan and PSB.
Dynamically changing between segmented
and nonsegmented mode
Note: This technique is only supported
in VisualAge® Generator
compatibility mode. It should not be used for new programs.
When
you specify the
segmented property for a
program, you set the default mode for how a
converse statement
is handled at runtime. The
segmented property
initializes the value of the
converseVar.segmentedMode system
variable in the following way:
- 0
- indicates that the program is nonsegmented
- 1
- indicates that the program is segmented
You can change the
converseVar.segmentedMode system
variable to dynamically control segmentation at runtime. By setting
converseVar.segmentedMode to
0 or 1, you can override the default value for the next
converse statement.
Before each
converse statement, EGL checks
the value of
converseVar.segmentedMode and
processes the
converse statement in the
following way:
- If converseVar.segmentedMode is set
to 1, EGL treats the converse statement
as a segmented converse.
- If converseVar.segmentedMode is set
to 0, EGL treats the converse statement
as a nonsegmented converse.
When the converse statement
completes successfully, EGL resets converseVar.segmentedMode to
the default value based on the segmented property
for the program.
The
converseVar.segmentedMode system
variable enables you to switch in and out of segmented mode for reasons
of performance, function, and target system differences. To control
segmentation, use either of the following statements prior to a
converse statement:
converseVar.segmentedMode = 1; // force the next converse to be segmented
converseVar.segmentedMode = 0; // force the next converse to be nonsegmented
Remember
that converseVar.segmentedMode is reset
to its generated default after every converse.
Therefore, you should only set converseVar.segmentedMode if
you want to alter the behavior of a specific converse from
the default processing.
Note: EGL ignores the use of converseVar.segmentedMode system
variable in the IMS/VS environment. All programs containing converse statements
must run in segmented mode in the IMS/VS environment.