Web Site

Computerit-solutions.com



» Computer » Large computer » Topics begins with J » Job control LANGUAGE


Page modified: Friday, June 23, 2006 20:28:50

JCL (job control LANGUAGE) is the Steuersprache for batch processings in a large computer surrounding field. Today still on systems under z/OS assigned JCL 1964 for OS/360 were developed.

The JCL has two characteristics, which are lost sight of in the process of the modernization of interactive systems increasingly: On the one hand remarks of software in can be planned in advance and be run off without any interaction in the background. On the other hand the complete decoupling of any physical conditions (like file name, printer devices etc.) from the software running off isolated and into the JCL is shifted. Thus expirations can be planned well and flexibly, which require many hours or days computer achievement. This high functionality cannot be opened by the not evenly modern however simple syntax necessarily easily. In addition full downward compatibility had to be ensured with extensions of the JCL.

Originally JCL stored on punch cards, today are JCL libraries Partitioned DATA set with record format FB (Fixed Blocked) and record length 80.

JCL is read in and interpreted by JES2 or JES3. All instructions begin with "“/"”. Comments are marked by "“//*"” and after "“/"” take place no more processing. It is possible to give standard input directly in the JCL.

The most important instructions are:

  • JOB (information about batch processing which can be required)
  • EXEC (implement a program or a procedure)
  • Dd (DATA definition, allocation file in the program for physical file)
  • PROC to define local or global procedures

These few statements are sufficient in practice for roughly 95% of the jobs. The extensive JCL Reference (about 700 sides) deals with all more special requirements.

One calls a program execution, which is started with EXEC, steps. It is possible to make execution dependent on steps on the return values of earlier steps (condition code). But there is a simple IF-THEN-ELSE logic, assistance of those to implement one blocks of instructions (steps) conditionally can. Direct back purchase to output data of a vorhergenden step are possible, in order to use this as Eingebabedaten of the following steps. Loops are sequential during job processing not possible, the execution of the steps effected always. I.e. the "“intelligence"” of a job is to the majority in the called programs. The task of the JCL exists in the reason to give to the programs a run time environment (connection to physical hardware, I/O and files)

The start of a job been made either automated time-steered by a scheduler or can be activated also by an operator directly (usually over ISPF)

Providing a new job takes place in practice usually via the fact that existing jobs are copied and adapted accordingly.

In the reason the start of all subsystems of a large computer is made by JCL. Also the registration of a user, thereafter interactively at the system works (in the TSO and/or ISPF) works with this formalism.

Examples of JCL:

//JOB1 JOB (12345), MSGCLASS=X, NOTIFY=SYSPROG1 //STEP1 EXEC PGM=IEFBR14 //DD1 DD DSN=AB.CD.EFGH, DISP= (OLD, DELETE) 

This job deletes the listed DATA set AB.CD.EFGH. The implemented program IEFBR14 is a dummy program. This is only necessary, because the JCL interpreter expects a program or a Prozeduraufruf with each step. The user "“SYSPROG1"” is informed after end of the job about the remark status. In this case return code 0 (=OK) and/or "“JCL ERROR"”, if the job were incorrectly coded or if the appropriate file does not exist and/or is not accessed by other jobs the DS straight. The allocation of the DATA set AB.CD.EFGH to the dd name DD1 is arbitrary in this case, because the DATA set of the called program is not used.

Expiration (simplifies):

  • The DATA set is allokiert (1. DISP parameter OLD => exclusive accesses) and the dd name DD1 assigned. (Quilting material location)
  • The dummy program is called.
  • The DATA set is deleted (2. DISP parameter DELETE, step after processing)
//JOB2 JOB (123456), MSGCLASS=X //STEP1 EXEC PGM=SALDO //STEPLIB DD DISP=SHR, DSN=BH.PROD.LOAD // DD DISP=SHR, DSN=BH.PROD.LOAD2 //INPUT DD DISP=SHR, DSN=BH.DETAIL.BESTAND //LISTE DD SYSOUT=* 

Here the application program BALANCE is implemented, executable load modules is in the library BH.PROD.LOAD or LOAD2. With the reading access to files DATA sets under a dd name can be concatenated. The search of the program takes place sequentially, until it is found. In BH.PROD.LOAD and in LOAD2 if a program "“BALANCE"” would be, then first was always taken. The program input in the DATA set BH.DETAIL.BESTAND and the result list is to be written in a Spoolfile (dd name LIST). The allocation of the input DATA set to the dd names "“INPUT"” and/or the output to "“LIST"” is compelling, since the program under this dd name expects the input data.

//JOB3 JOB (123456), MSGCLASS=X //STEP1 EXEC PGM=IDCAMS //DDIN DD DISP=SHR, DSN=SYSPROG.SMF.AUSWERT //DDOUT DD DISP= (NEW ONE, CATLG), DSN=SYSPROG.SMF.HISTORY (+1), // UNIT=SYSDA, SPACE= (CYL, (15,15), RLSE), DCB=*.DDIN //SYSPRINT DD SYSOUT=* //SYSIN DD * REPRODUCTION INFILE (DDIN) OUTFILE (DDOUT)/* 

Here with that system utility IDCAMS the file is copied SYSPROG.SMF.AUSWERT into a new generation of the generation DATA Group (GDG) SYSPROG.SMF.HISTORY. Minutes of this action (SYSPRINT) are written in a Spoolfile, which became tax control statement for IDCAMS (reproduction COMMAND) in the standard input SYSIN coded, which is locked with/*.

See also: Job

Other Mainframebetriebssysteme such as VSE uses likewise JCL languages mentioned, which have however completely different syntax.

Related links


Articles in category "Job control LANGUAGE"

We found here 2 articles.

J

» Job control LANGUAGE
» Job entry subsystem

Related Websites

We found here 4 related websites.

Page cached: Wednesday, July 5, 2006 14:11:04
Valid XHTML 1.0!  Valid CSS!

Navigation

Related articles


Page copy protected against web site content infringement by Copyscape