Table of Contents

Understanding Basic Tasking Concepts

Documentation Updates

What’s New

About This Guide

Tasking Concepts

Programs and Processes

Task Attributes

Interactive Tasking

Programmatic Tasking

Process Termination

Internal and External Processes

Program Structure

Advantages of Tasking

Simplifying System Operations

Increasing Programmer Productivity

Improving Application Performance

Limitations of Tasking

Understanding Interprocess Relationships

Inclusion

Flow of Control

Synchronous Processes

Asynchronous Processes

Coroutines

Dependency

Communications Effects

Flow of Control Effects-Synchronization

Flow of Control Effects-Critical Blocks

Process Families

Familial Relationships

Jobs and Tasks

Special Types of Jobs

Accessing Task Variables

Setting Resource Limits

Tasking from Interactive Sources

CANDE

CANDE Tasking Capabilities

Initiating Dependent Processes from CANDE

Initiating Compilations from CANDE

Initiating Utilities from CANDE

Submitting WFL Jobs from CANDE

Monitoring and Controlling Processes in CANDE

Access to Task Attributes in CANDE

Saving CANDE Commands for Later Use

CANDE Programming Considerations

Receiving Parameters from CANDE

Access to Ancestral Processes in CANDE

Communicating with CANDE Terminals

MARC

MARC Tasking Capabilities

Initiating Dependent Processes from MARC

Initiating Compilations from MARC

Initiating Utilities from MARC

Submitting WFL Jobs from MARC

Monitoring Processes Initiated from MARC

Monitoring Other Processes in MARC

Communicating with Interactive Processes in MARC

Access to Task Attributes in MARC

MARC Programming Considerations

Receiving Parameters from MARC

Access to Ancestral Processes in MARC

Communicating with MARC Terminals

Operations Center

Operations Center Tasking Capabilities

Submitting WFL Jobs from Operations Center

Initiating Processes from Operations Center

Initiating Compilations from Operations Center

Monitoring and Controlling Processes from Operations Center

Access to Task Attributes from Operations Center

Operations Center Programming Considerations

Receiving Parameters from Operations Center

Access to Ancestral Processes in the Operations Center

Communicating with Operations Center

ODT

ODT Tasking Capabilities

Submitting WFL Jobs from an ODT

Initiating Processes from an ODT

Initiating Compilations from an ODT

Initiating Utilities from an ODT

Monitoring and Controlling Processes at an ODT

Access to Task Attributes from an ODT

ODT Programming Considerations

Receiving Parameters from an ODT

Access to Ancestral Processes in the ODT Environment

Communicating with an ODT

Tasking Command Equivalents

Communicating with an Operator

Displaying Information to Operators

Accepting Information from Operators

Accepting Input from HI Commands

Accepting Input from AX Commands

Accepting Input from SW Commands

Tasking from Programming Languages

Work Flow Language (WFL)

Submitting WFL Input

Selecting the Queue for a Job

Specifying a Start Time

Structuring the WFL Job

Initiating Dependent Processes from WFL

Initiating Compilations from WFL

Initiating Utilities from WFL

Initiating Interactive Processes from WFL

Submitting Other WFL Jobs

Access to Task Attributes in WFL

Using File Equations in WFL

Responding to Error Conditions in WFL

Communicating with Other Processes in WFL

Controlling a Task from a Job

Restarting WFL Jobs

WFL Example

ALGOL

Structuring an ALGOL Program

Initiating Processes from ALGOL

Initiating Compilations from ALGOL

Initiating Utilities from ALGOL

Initiating Interactive Processes from ALGOL

Submitting WFL Jobs from ALGOL

Access to Task Attributes in ALGOL

Communicating with Other Processes from ALGOL

Restarting ALGOL Processes

DCALGOL Features

ALGOL Examples

COBOL

Structuring a COBOL Program

Initiating Processes from COBOL

Using Coroutines in COBOL

Entering Individual COBOL Procedures

Resolving Ambiguous CALL Statements in COBOL85

Initiating Compilations from COBOL

Initiating Utilities from COBOL

Initiating Interactive Processes from COBOL

Submitting WFL Jobs from COBOL

Access to Task Attributes in COBOL

Invoking COBOL Programs

Communicating with Other Processes from COBOL

Terminating Processes from COBOL Programs

COBOL Examples

Other Languages

Establishing Process Identity and Privileges

Process Identity

Mix Number, Session Number, Stack Number, and MPID Attribute

Usercode, Access Code, Charge Code, and Group Code

Name

Object Code File

Originating Source

Process Security Classes

Nonprivileged Status

Privileged Status

Granulated Privileges

Nonusercoded Status

ODT Status

SYSADMIN Status

SYSTEMUSER Status

Security Administrator Status

Compiler Status

Message Control System Status

Tasking Status

Process Identity and Process Initiation

Temporarily Assuming an Identity

Real, Saved, and Effective Process Identities

Using SETUSERCODE and SETGROUPCODE

Understanding Real and Saved Identities

Toggling between Identities

Monitoring and Controlling Process Status

Understanding Process Status

STATUS Task Attribute

WFL Task State Expression

Mix Display Commands

Y (Status Interrogate) Stack States

Monitoring Changes in Process Status

Controlling Process Status

Terminating a Process

Thawing a Library

Suspending and Resuming Processes

Preparing a Task Variable for Reuse

Preventing Process Scheduling

Preventing Process Suspension

Checking File Residence

Using AUTORESTORE for Disk Files

Identifying Tape Files

Using UNITNO and OMITTEDEOF for Unlabeled Tape Files

Using the AUTORM Option

Using the ORGUNIT Value for ODT Files

Using Conditional ACCEPT Statements

Controlling Processor Usage

Controlling Process Priority and Processor Rate

Limiting Processor Usage

Understanding Processor Usage Accounting

Understanding Accounting for Processor Resource Time

Controlling Process Memory Usage

Understanding Process Memory Usage

Main Memory and Virtual Memory

Process Components

Presence-Bit Operations

Controlling Code Segment Dictionary Sharing

Controlling Process Scheduling

Preventing Stack Stretches

Protecting against Stack Overflow

Restricting Save Memory Usage

Restricting Total Memory Usage

Controlling Process I/O Usage

Establishing the Default Usercode for Disk Files

Modifying File Attributes

Controlling Disk File Usage

Specifying Family Substitution

Preventing File Duplications

Automatically Restoring Missing Disk Files

Limiting Disk Usage

Specifying a Current Directory

Controlling Printing

Default Handling of Printer Output

Storing Printer Backup Files Temporarily

Titling of Printer Backup Files

Submitting Print Requests

Selecting Print Requests

Programmatic Control over Printing

Other Print-Related Task Attributes

Controlling Message Tanking

Suppressing Unwanted System Messages

Localization

Limiting I/O Usage

Determining Process History

Understanding Termination Messages

Using Log Information

Specifying the Information to Be Logged

Controlling Job Summary Printing

Saving the Job Summary File

Analyzing the System Log

Programmatically Interrogating Process History

Determining the Type of Termination

Determining Whether a Compilation Was Successful

Responding to Task Failures

Determining Where a Fault Occurred

Protecting a Process from Abnormal Terminations

Preventing All Abnormal Terminations

Protection against Most Conditions

Protection against All Conditions

Including Multiple Statements

Determining the Cause of the Error

Using TRY as an Expression

Providing Alternate Sets of Error Handling Code

Optimizing Performance

Triggering Program Dumps

Protecting a Process from Faults

Retrying a Failed Task

Protecting a Process from Operator DS (Discontinue) Commands

Protecting Procedures from DS and ST Commands

Performing Cleanup during an Abnormal Termination

Interactions between Error Recovery Statements

Multiple TRY Statements

TRY Statements and Library Delinkage

TRY Statements and ON Statements

TRY Statements, EPILOG Procedures, and EXCEPTION Procedures

Controlling Program Dumps

Using Program Statements to Control Program Dumps

Using Operator Commands to Control Program Dumps

Controlling the Program Dump Destination

Using the Task File

Analyzing a Program Dump from a Running Process

Determining Whether a Dump is In Progress

Causing Symbolic Dumps for RPG Processes

Effect of Resource Limits on Program Dumps

Understanding Internal and External Causes

Restarting Jobs and Tasks

Designing WFL Jobs for Automatic Restarts

Preventing Job Side Effects

Preventing Task Side Effects

Understanding Job Restart Failure

Understanding Disk Resource Control Effects

Manually Restarting WFL Jobs

Checkpoint Facility

Programmatically Invoked Checkpoints

Storing Information with a Checkpoint

Planning for File Recovery

Planning for Library Recovery

Invoking the Checkpoint

Creating Output Disk Files with a Checkpoint

Restrictions on the Use of Checkpoints

Determining Eligibility for Checkpoints

Determining Whether the Checkpoint Succeeded

Operator-Invoked Checkpoints

Programmatically Preventing Operator Checkpoints

Displaying the Checkpoint Status

Invoking a Checkpoint Interactively

Canceling a Checkpoint Interactively

Operator Actions after the Checkpoint

Restarting a Checkpointed Task

Restarting Checkpointed Tasks Automatically

Initiating a Restart Explicitly

Using the CHECKPOINTARRAY Procedure

Tasking Across Multihost Networks

Submitting Remote WFL Jobs

Running a Local WFL Job on a Remote Host

Submitting a WFL Job Stored on a Remote Host

Meeting Remote Job Queue Requirements

Initiating Non-WFL Remote Processes

Specifying the Remote Host

Limitations on a Non-WFL Remote Process

Host Availability

Initiating Processes from a Remote Session

Interrogating the Remote Ancestry of a Process

Preventing User Identity Problems

Usercode Identity

Accesscode and Charge Validation

Family and Group Code Identity

Logging of Remote Processes

System Log Entries

Job Summaries for Remote Processes

Resource Limits for Remote Processes

Interacting with Remote Processes

Viewing Remote Process Messages

Local Operator Control of Remote Processes

MARC Control of Remote Processes

CANDE Control of Remote Processes

Visibility of Remote Processes to Remote Operators

TASKING/MESSAGE/HANDLER and TASKING/STATE/CONTROLLER

Using Host Services-Supported Task Attributes

Understanding Interprocess Communication

Methods of Sharing Objects

Methods of Synchronizing Access

Using Task Attributes

Using Global Objects

Communication through Global Objects in WFL

Communication through Global Objects in ALGOL

Using Events and Interlocks

Using Events

Declaring Events

Accessing the Available State

Procuring an Event Unconditionally

Procuring an Event Conditionally

Liberating an Event

Partially Liberating an Event

Testing the Availability of an Event

Determining the Ownership of an Event

Accessing the Happened State

Causing an Event

Implicitly Causing an Event

Causing and Resetting an Event

Partially Causing an Event

Resetting an Event

Waiting on an Event

Waiting on Time

Waiting on and Resetting an Event

Waiting on Multiple Events

Waiting for POSIX Signals

Testing the Happened State

Duration of the Happened State

Using Implicitly Declared Events

Using Interrupts

Declaring Interrupts

Attaching or Detaching an Interrupt

Enabling or Disabling an Interrupt

Using General Disable and Enable Statements

Waiting for Interrupts

Efficiency Considerations

Buzz Loops

Preventing Excessive Interrupt Overhead

Preventing Starvation Problems

Discontinued Processes and Events

Using EPILOG and EXCEPTION Procedures

Using Timed Wait Statements

Using Conditional Procure Statements

Determining Whether to Liberate an Event

Example of Event Usage

Using Interlocks

Declaring Interlocks and Interlock Arrays

Locking an Interlock

Unlocking Interlocks

Interrogating the Interlock Status

Discontinued Processes and Interlocks

Replacing Readlocks with Interlocks

Using Parameters

Determining the Scope of Parameters

Parameter Passing Modes

Call-by-Value Parameters

Call-by-Name Parameters

Call-by-Reference Parameters

Read-Only Parameters

Specifying the Passing Mode

Using Tasking Parameters

Matching Each Parameter Type

Resolving Passing Mode Conflicts

Passing Arrays

Matching Dimensions and Elements

Matching Unbounded Arrays

Matching Pascal Arrays

Passing COBOL74 Arrays to Bound Procedures

Using Libraries

Introducing Libraries

Creating Server Library Programs

Exporting Objects

Freezing the Library

Controlling Server Library Sharing

Initiating Internal Server Library Processes

Using Server Library Objects

Local Objects in Server Libraries

Global Objects in Server Libraries

Exported Data in Server Libraries

Restrictions on OWN Objects in Server Libraries

Restrictions on COBOL74 Libraries

Monitoring Server Library Linkage

Thawing and Resuming Server Libraries

Creating Client Programs

Importing Procedures to Client Programs

Importing Data to Client Programs

Specifying Client Libraries

Linking to Server Libraries

Implicitly Linking to Server Libraries

Explicitly Linking to Server Libraries

Directly Linking to Server Libraries

Matching Client and Server Library Objects

Initiating Server Library Processes

Implicitly Initiating a Server Library

Explicitly Initiating a Server Library

Monitoring Client Process Linkage

Delinking from Server Libraries

Creating Connection Library Programs

Declaring a Connection Library

Establishing Connections

Explicitly Linking Connection Libraries

Implicitly Linking Connection Libraries

Directly Linking Connection Libraries

Controlling Connection Library Sharing

Approving a Connection

Monitoring Connection State

Matching Connection Library Objects

Initiating Connection Libraries

Unreadying a Connection Library

Delinking Connection Libraries

Using PROLOG and EPILOG Procedures

Using Connection Library Objects

Global Objects in Connection Libraries

Connection Objects in Connection Libraries

Local Objects in Connection Libraries

Exported and Imported Data in Connection Libraries

Predeclared Objects: THIS and THISCL

Passing Connections as Parameters

Restrictions on OWN Objects in Connection Libraries

Other Library Linkage Methods

Linking a Client Library to a Connection Library

Linking a Connection Library to a Server Library

Linking to a Connection Library in a Server Library Program

Linking Using PROCESS VIA

Directly Linking Client, Server, and Connection Libraries

Using Library Attributes

APPROVAL

AUTOLINK

CHANGE

CLUSAGE

CONNECTIONS

DELINKEVENT

FUNCTIONNAME

INTERFACENAME

INTNAME

LIBACCESS

LIBERROR

LIBPARAMETER

SINGLE

STATE

TITLE

Methods of Providing Objects

Direct Provision

Indirect Provision

Dynamic Provision

Circular Provision

Understanding Circular Linkage and Circular Provision

Restrictions on Circular Linkage and Circular Provision

Matching the Object Name

Type Matching

Matching Procedure Types

Matching Parameter Types

ALGOL Parameter Types

C Parameter Types

COBOL74 Parameter Types

COBOL85 Parameter Types

FORTRAN77 Parameter Types

NEWP Parameter Types

Pascal Parameter Types

Using the ANYTYPE Parameter

Matching Array Lower Bounds

Matching Parameter-Passing Mode

Matching Data Types

Determining Which Clients Are Linked to a Library

Understanding Library Process Structure

Process Stacks

Using Isolated Procedures in Libraries

Library Task Attributes

Error Handling

Design Strategies for Linking Libraries

Technical Architectures

Client Strategies

Server Strategies

Middleware Strategies

Factors Affecting System Performance

Delinkage Overuse

Hazards of Circular Connections

Security Considerations for Libraries

Privileges of the Importing Process

Support Library Attributes

Nonresumable Libraries

Restricting Access to a Library Code File

Using Linkage Classes

Library Debugging

Server Library Examples

ALGOL Library: OBJECT/FILEMANAGER/LIB

ALGOL Client Program #1

ALGOL Library: OBJECT/SAMPLE/LIBRARY

ALGOL Library: OBJECT/SAMPLE/DYNAMICLIB

ALGOL Client Program #2

ALGOL Circular Client Programs

ALGOL Incorrect Circular Libraries

C Library and ALGOL Client Program

C Client Program Passing Array to ALGOL Library

C Client Program Passing File to ALGOL Library

COBOL74 Library: OBJECT/SAMPLE4

COBOL74 Library: OBJECT/SAMPLE5

COBOL74 Client Program

COBOL85 Libraries and Client Program

FORTRAN77 Library and Client Program

Pascal Library

Connection Library Example

Using Shared Files

Sharing Communications Files

Using Port Files

Sharing Other Kinds of Files

Using Shared Logical Files

Specifying the File Location

Synchronizing Access with Shared Logical Files

Establishing Access Rights

Understanding I/O Accounting

Understanding File Attribute Access

File Sharing Examples

Accessing Disk Files Through Separate Logical Files

Entering a File in the Directory

Matching Physical Files

Synchronizing Access with Separate Logical Files

Using Core-to-Core (CRCR) and Storage Queue (STOQ)

Using CRCR

How CRCR Processes Interlock

Using CRCR Through Library Calls

Using CRCR Through COBOL85 Statements

Using STOQ

Creating and Using STOQs

Using STOQ Through Library Calls

Using STOQ Through COBOL85 Statements

Waiting On CRCR or STOQ Events

CRCR and STOQ Events in ALGOL

CRCR and STOQ Events in COBOL85

Handling the CRCR or STOQ Result

Result Handling in ALGOL

Result Handling in COBOL74

Operations Interfaces to CRCR and STOQ

Clearing a STOQ

Polling a STOQ

Displaying Status of CRCR or STOQ Operations