“Mecanismos de controlo de scheduling no JES2“

O z/OS fornece controlos nativos de scheduling dentro do JES2 que muitas vezes passam despercebidos porque muitas instalações dependem de schedulers empresariais como IBM Work Scheduler, BMC Control-M ou Broadcom AutoSys Workload Automation. Esses schedulers externos são importantes, mas continua a ser útil perceber o que o JES2 consegue fazer por si próprio para jobs individuais no job stream.

Este artigo é deliberadamente prático. Foca-se na instrução SCHEDULE para jobs individuais e mostra como:

• Manter um job em espera até um instante futuro com HOLDUNTL
• Criar uma dependência simples entre jobs com AFTER
• Evitar arranques falsos num sequenciamento dinâmico com DELAY=YES

1. Objetivos do laboratório

No fim deste laboratório deverá ser capaz de:

• Explicar o que faz a instrução JES2 SCHEDULE
• Atrasar um job até um instante futuro com HOLDUNTL
• Construir uma sequência simples pai-dependente com AFTER
• Compreender porque é que DELAY=YES importa no sequenciamento dinâmico
• Reconhecer os limites práticos do scheduling nativo JES2

2. Ambiente necessário

Para este laboratório, use:

• z/OS 2.2 ou posterior
• JES2
• acesso TSO/ISPF com permissão para submeter e monitorizar jobs batch
• acesso SDSF, ou qualquer ferramenta equivalente que lhe permita observar jobs submetidos

Nota importante:

• A IBM documenta a instrução SCHEDULE como uma capacidade exclusiva de JES2
• A instrução JES2 SCHEDULE foi introduzida no z/OS 2.2, por isso z/OS 3.1 não é o nível mínimo exigido para os exemplos deste artigo

3. O que o scheduling nativo JES2 pode fazer

A instrução SCHEDULE permite especificar atributos de scheduling para um job.

Para este artigo, as cláusulas mais úteis são:

O ponto principal a reter é que estes controlos afetam apenas a elegibilidade de um job para execução e não substituem um scheduler empresarial completo, mas são úteis para sequenciamento nativo simples.

4. Limitações importantes que é necessário entender

Tenha em conta estes pontos:

• A instrução SCHEDULE é suportada por JES2, não por JES3
• Tem de aparecer depois da instrução JOB e antes da primeira EXEC ou IF
• Só é permitida uma instrução SCHEDULE num job
• O sequenciamento dinâmico com BEFORE / AFTER / DELAY=YES é mais leve e mais limitado do que a utilização de um scheduler completo

Esse último ponto é importante. O sequenciamento dinâmico nativo é útil para relações pequenas, mas não é a mesma coisa que um scheduler de produção completo com calendários, lógica de restart e gestão de dependências mais rica.

5. Laboratório 1: atrasar um job até um instante futuro

Este primeiro job mostra a capacidade útil mais simples: não deixar que um job submetido execute imediatamente.

Crie um membro como SCHHOLD1:

//SCHHOLD1 JOB ,'SCHEDULE LAB',CLASS=A,MSGCLASS=X,NOTIFY=&SYSUID
//         SCHEDULE HOLDUNTL='+00:02'
//STEP1    EXEC PGM=IDCAMS
//SYSPRINT DD  SYSOUT=*
//SYSIN    DD  *
  SET MAXCC=0
/*

Submeta o job.

O que observar:

• O job entra imediatamente no JES2
• Poderá vê-lo na Input Queue. Não se torna elegível para execução logo de seguida
• Ao fim de cerca de dois minutos, é libertado e termina normalmente

Porque isto importa:

• Pode submeter trabalho antecipadamente
• O JES2 impede que o job seja selecionado até à janela temporal pedida

Nota prática:

• '+00:02' é um intervalo temporal relativo
• Para scheduling real mais longo, a IBM documenta também formas absolutas de data e hora para HOLDUNTL

6. O que HOLDUNTL é e o que não é

HOLDUNTL é útil quando se quer atrasar a elegibilidade para execução, mas continua a ser muito simples e limitado quando comparado com um scheduler completo.

É bom para:

• Adiamentos curtos
• Libertação controlada de jobs
• Dar tempo a um conjunto relacionado de jobs para entrar no sistema antes de a lógica de dependência ser avaliada

Não substitui:

• Calendários empresariais
• Regras de feriados
• Previsão complexa de workloads
• Cadeias de dependências espalhadas por muitas aplicações e datas de negócio

7. Laboratório 2: uma sequência simples pai-dependente

Agora vamos construir uma pequena sequência de dois jobs:

• JOBA cria um data set de teste
• JOBB verifica que o data set existe
• JOBB não deve executar antes de JOBA terminar

Crie um único membro de input stream como SCHSEQ1 com ambos os jobs:

//JOBA     JOB ,'SCHEDULE LAB',CLASS=A,MSGCLASS=X,NOTIFY=&SYSUID
//         SCHEDULE HOLDUNTL='+00:02'
//STEP1    EXEC PGM=IEFBR14
//PARENTDD DD  DSN=&SYSUID..SCHEDLAB.PARENT,
//             DISP=(NEW,CATLG,DELETE),
//             SPACE=(TRK,(1,1)),
//             DCB=(RECFM=FB,LRECL=80,BLKSIZE=0)
//* 
//JOBB     JOB ,'SCHEDULE LAB',CLASS=A,MSGCLASS=X,NOTIFY=&SYSUID
//         SCHEDULE AFTER=JOBA,DELAY=YES
//STEP1    EXEC PGM=IDCAMS
//SYSPRINT DD  SYSOUT=*
//SYSIN    DD  *
  SET MAXCC=0
/*

Submeta o membro uma vez para que ambos os jobs entrem no JES2 quase ao mesmo tempo.

O que observar:

• JOBA e JOBB entram ambos no sistema
• JOBA fica atrasado por HOLDUNTL
• JOBB mantém-se inelegível até JOBA terminar
• depois de JOBA terminar, JOBB executa

Isto torna a demonstração mais limpa porque a dependência passa a ser conduzida por AFTER=JOBA, enquanto a retenção temporal é aplicada apenas ao job pai.

Resultado funcional esperado:

• JOBA termina com CC 0000
• JOBB termina com CC 0000

8. Porque é que DELAY=YES importa

Este é um dos detalhes mais importantes no sequenciamento nativo JES2.

O AFTER= por si só pode produzir um falso positivo se o job pai não existir nesse momento. Nesse caso, o JES2 pode interpretar o pai como “já executou e foi removido”, tornando o job dependente elegível.

DELAY=YES altera esse significado:

• Com DELAY=YES, um job pai em falta é tratado como ainda não submetido

É por isso que o laboratório anterior usa:

SCHEDULE AFTER=JOBA,DELAY=YES

A combinação é deliberada:

• AFTER=JOBA exprime a dependência
• DELAY=YES evita uma libertação falsa

Nesta versão, HOLDUNTL é aplicado apenas a JOBA. Isso mantém o job pai atrasado, ao mesmo tempo que mostra que JOBB espera por causa de AFTER=JOBA. Se ambos os jobs ficassem retidos até à mesma hora, o exemplo deixaria de isolar o efeito de AFTER.

9. Um modelo mental útil para o sequenciamento nativo

Pense no modelo nativo JES2 desta forma:

Isto é suficiente para sequenciamento nativo simples, mas continua a ser intencionalmente leve.

10. Quando isto é uma boa escolha

Estas capacidades são uma boa escolha quando:

• Precisa de uma pequena dependência local sem um scheduler externo
• Quer preparar um pequeno conjunto de jobs para libertação posterior
• Precisa de uma solução prática exclusiva de JES2 para um fluxo batch reduzido
• Quer prototipar lógica de sequenciamento antes de a mover para uma framework de scheduling mais abrangente

11. Quando deve usar algo mais forte

O scheduling nativo JES2 não é a melhor resposta quando precisa de:

• Calendários de negócio
• Cadeias longas de dependências entre muitas aplicações
• Lógica robusta de restart e recovery
• Políticas de balanceamento de workload em grandes streams de produção
• Auditoria central e governação de workload

O sequenciamento dinâmico com BEFORE / AFTER / DELAY=YES é menos robusto e normalmente menos eficiente do que JOBGROUP.

Por isso, a mensagem prática é:

• Use scheduling nativo JES2 para sequenciamento pequeno, local e tático
• Use construções de scheduler mais ricas quando o workload é maior ou crítico para o negócio

12. Cleanup

Se quiser remover o data set criado por JOBA, submeta:

//SCHCLN1  JOB ,'SCHEDULE LAB',CLASS=A,MSGCLASS=X,NOTIFY=&SYSUID
//STEP1    EXEC PGM=IDCAMS
//SYSPRINT DD  SYSOUT=*
//SYSIN    DD  *
  DELETE '&SYSUID..SCHEDLAB.PARENT'
  IF LASTCC = 8 THEN SET MAXCC = 0
/*

Resumo

As capacidades nativas de scheduling JES2 são simples, mas úteis.

Os dois padrões mais práticos são:

//JOB1 JOB ...
//     SCHEDULE HOLDUNTL='+00:02'

e:

//JOBB JOB ...
//     SCHEDULE AFTER=JOBA,DELAY=YES

O primeiro atrasa um job para um momento posterior. O segundo cria uma dependência leve e reduz o risco de execução prematura por falso positivo.

Usados com cuidado, estes controlos dão-lhe uma camada prática de scheduling nativo para jobs individuais dentro do JES2 sem envolver um scheduler externo.

Documentação IBM útil

• Instrução SCHEDULE
• Instruções de controlo de execução JES2
• Sequenciamento dinâmico de jobs com BEFORE, AFTER e DELAY=YES
• Parâmetro AFTER
• Parâmetro BEFORE
• Parâmetro TYPRUN
• Controlo de input de jobs através da retenção na entrada