Enterprise IT Consultant Views on Technologies and Trends

Jan 3 2011   2:24AM GMT

Static / Dynamic Linking in IBM COBOL

Sasirekha R Profile: Sasirekha R

Static / Dynamic Linking in IBM COBOL

Using linking, we can have one program call another program that is not contained in the source code of the calling program. Depending on the linkage options,  the object module of the calling program is linked with the object module of the called program “before or during” execution – referred to as static or dynamic linking.

Appropriately choosing the linkage as static / dynamic depending on the application requirement (and not a single technique for the entire application) can result in benefits related to performance, memory usage and maintenance.

 Static CALL

 In the static CALL statement, the COBOL program and all called programs are part of the same load module (self-contained). When control is transferred, the called program already resides in storage, and a branch to it takes place. Subsequent executions of the CALL statement make the called program available in its last-used state, unless the called program has the INITIAL attribute.

A static call occurs:

1. When the CALL literal statement is used in a program that is compiled using the NODYNAM and NODLL compiler options.. With these options, all calls of the CALL literal format are handled as static calls.

Because a statically called program is link-edited into the same load module as the calling program, a static call is faster than a dynamic call (though the load modules are larger).

The key disadvantage is that to change the behavior of the called program, relinking is necessary. As statically called programs cannot be deleted (using CANCEL), static calls might take more main storage. Also if more than one calling program accesses the called program, duplicate copies of the programs have to be loaded into memory.

 

Dynamic CALL

In the dynamic CALL statement, the called COBOL subprogram is not link-edited with the main program, but is instead link-edited into a separate load module, and, at run time, is loaded only when it is required (that is, when called).

When a dynamic CALL statement calls a subprogram that is not resident in storage, the subprogram is loaded from secondary storage into the region or partition containing the main program and a branch to the subprogram is performed. The first dynamic call to a subprogram within a run unit obtains a fresh copy of the subprogram. Subsequent calls to the same subprogram (by either the original caller or any other subprogram within the same run unit) result in a branch to the same copy of the subprogram in its last-used state, provided the subprogram does not possess the INITIAL attribute.

When a CANCEL statement is issued for a subprogram, the storage occupied by the subprogram is freed, and a subsequent call to the subprogram functions as though it were the first call. A subprogram can also be cancelled from a program other than the original caller.

A Dynamic Call occurs:

1. When the CALL literal statement is used in a program that is compiled using the DYNAM and the NODLL compiler options (or)

2. when the CALL identifier statement is used in a program. CALL identifier is always dynamic, even if the NODYNAM compiler option is used.

The program name in the PROGRAM-ID paragraph must be identical to the corresponding load module name or load module alias of the load module that contains it.

Typically, dynamic CALL statement is used in the following circumstances:

  • For ease of maintenance. Applications do not have to be link-edited again when dynamically called subprograms are changed.
  • The subprograms called are used infrequently or are very large. If the subprograms are called on only a few conditions, dynamic calls can bring in the subprogram only when needed. If the subprograms are very large or there are many of them, using static calls might require too much main storage. Less total storage might be required to call and cancel one, then call and cancel another, than to statically call both.

The key points to be noted are:

  • CALL identifier is always dynamic
  • With NODYNAM compiler option, all calls of the CALL literal format are handled as static calls.
  • When a static CALL statement and a dynamic CALL statement to the same subprogram are issued within one program, a second copy of the subprogram is loaded into storage. 

1  Comment on this Post

 
There was an error processing your information. Please try again later.
Thanks. We'll let you know when a new response is added.
Send me notifications when other members comment.

REGISTER or login:

Forgot Password?
By submitting you agree to receive email from TechTarget and its partners. If you reside outside of the United States, you consent to having your personal data transferred to and processed in the United States. Privacy
  • Sasirekha R
    [...] With DYNAM option, all subprograms invoked through the CALL literal statement will be loaded dynamically at run time. NODYNAM is the default. DYNAM allows sharing of common subprograms, provides control of using the virtual storage (that can be freed using CANCEL statement), but with a performance penalty as the call must go through a library routine, whereas with the NODYNAM option, the call goes directly to the subprogram. Detailed information is available at http://itknowledgeexchange.techtarget.com/enterprise-IT-tech-trends/static-dynamic-linking-in-ibm-co.... [...]
    0 pointsBadges:
    report

Forgot Password

No problem! Submit your e-mail address below. We'll send you an e-mail containing your password.

Your password has been sent to: