MULTI-FETCH

IN AND OUT
OF NATURAL

Jim Poole 1
CONTENTS

1. WHAT’S NOT COVERED

2. OVERALL

3. SYNTAX
4. HOW IT WORKS
5. NATURAL vs ADAMLF
6. UPDATING
7. HOW MUCH TO MULTI-FETCH
8. CONCERNS, ISSUES

2
WHAT’S NOT COVERED:

ADAMLF
PREFETC Exclude:
H PREFXFIL/
PREFXCMD

HISTOGRAM
L9’s

ADAMLF:
NOT USING
DIRECT PREFNREC
CALLS
PROGRAMS
3
OVERALL “?WHAT IS MULTI-FETCH ?”
RETURN MULTIPLE RECORDS ON ONE ADABAS CALL/CMD

REGULAR PROCESSING MULTI-FETCH PROCESSING

PROGRAM ADABAS PROGRAM ADABAS
READ FILE READ FILE
CQ  CQ 
::: :::
THREAD THREAD
END-READ END-READ
*COUNTER=10,000
*COUNTER=10,000 PREFNREC/MFF=100

10,000 L3’S 100 L3’S

10,000 CALLS TO ADABAS 100 CALLS TO ADABAS
10,000 CQ TO THREAD 100 CQ TO THREAD
10,000 RB’S FILLED 100 RB’S FILLED (WITH 100
10,000 CALLS RETURNED RECORDS EACH)
100 CALLS RETURNED
4
OVERALL “TWO APPROACHES TO MULTI-FETCH”

1. BATCH 2. BATCH/ONLINE NATURAL V4

READ/FIND
PROGRAM
MULTI-FETCH #MFF
:::

ADAMLF:
ADARUN PREF*=
::: ADA LINK

ADALNK NATMLF

ADAMLF 5
NOTE: PGM MLF HAS PRECEDENCE
 QU
SYNTAX: ADAMLF IC
K
JCL: //DDCARD (ALL PREFACED BY ADARUN)
PREFETCH=YES / NO
PREFSBL=130000 * MLF BUFFER SIZE/SEQUENCE
PREFTBL=n*PREFSBL * n=# MLF SEQUENCES)
PREFNREC= * MAX RECS TO MLF

* Code ICMD/IFIL pairs for cmd/fnr to MLF

* ICMD cmd’s separated by ‘/’
* IFIL fnr’s separated by ‘,’

PREFICMD=cmd/cmd/cmd …
PREFIFIL=fnr,fnr,fnr …

!! ALWAYS CODE PREFNREC= !!

6
 QU
SYNTAX: ADAMLF EXAMPLES IC
K
PREFETCH=YES,PREFSBL=130000,PREFTBL=130000
PREFNREC=20,PREFICMD=L2,PREFIFIL=241
“FNR 241, ALL L2/L5 WILL MLF UP TO 20 RECORDS PER L2/L5”

PREFETCH=YES,PREFSBL=130000,PREFTBL=390000
PREFNREC=100
PREFICMD=L2/L3/L3
PREFIFIL=22,18,16
“3 MLF SEQUENCES:
L2/L5 FOR FNR 22
L3/L6 FOR FNR 18
L3/L6 FOR FNR 16”
7
 QU
SYNTAX: NATMLF IC
K
AVAILABLE WITH NATURAL 4
READ/FIND MULTI-FETCH factor view-name . . .

FOR EXAMPLE:

1 #MFF (I4)INIT <020> /*RECS/DB ACCESS FOR MLF

: : :
RD1. READ MULTI-FETCH #MFF DA-FILE PHYSICAL

“FOR FILE DA-FILE, 20 RECORDS WILL BE RETURNED ON

EACH DATABASE CALL”

8
SYNTAX: NATMLF RULES
1. READ LOGICAL. WORKS ON BOTH ASCENDING, DESCENDING.

2. DOES NOT WORK IF DYNAMIC SEQUENCE CHANGES:

“. . . IN DYNAMIC . . . SEQUENCE . . . “

3. ONLY WORKS FOR BROWSE LOOPS (NO RECORD HOLDS),

‘NO UPDATES’.

3a. IF ‘UPDATE,DELETE’ THEN MLF TURNED OFF (no error)

4. MLF BUFFER RELEASED WITH REPOSITIONING OR LOOP-END

5. MLF BUFFER RELEASED AT END OF LOOP (RC CMD)

9
SYNTAX: NATMLF MFF REDUCED BY

A. READ/FIND (NNN) . . .
IF MFF > NNN THEN NNN USED
IF MFF < NNN THEN MFF USED (extra records may be read)

B. RECORD BUFFER LENGTH (32K). More later

C. ISNQ (*NUMBER) FOR FIND STATEMENTS. More later

10
 QU
SYNTAX: NATMLF. MULFETCH BUFFER IC
K
NTDS MULFETCH,nn
Or
GLOBALS DS=(MULFETCH,nn)

nn = 0 – 1024 KILOBYTES OF MEMORY

=0 MULTI-FETCH DISABLED
/= 0 (NATURAL 4.1) SIZE AS NEEDED
(UP TO MAX BUFFER LENGTH)

11
HOW IT WORKS. DIRECT CALLS ADABAS NUCLEUS

CB: CONTROL BLOCK CMD = L2/L5, L3/L6

L1/L4 where COP2=I or N
ILL = MAX RECS TO RETURN
COP1=M or O
FB: FORMAT BUFFER CID = NON-ZERO,NON-BLANK

RB: RECORD BUFFER DECOMPRESSED RECORDS

IB: ISN BUFFER 16 BYTE HEADERS:

4B – LENGTH OF THIS RECORD IN RB
4B – ADABAS RESPONSE CODE*
4B – ISN OF THIS RECORD
4B – FOR L9, ISNQ

*IF RSP.CODE /= 0 THEN NO RECORD STORED IN RB

NOTE: MAX BUFFER LENGTH = 32,768 (ADABAS 7)
12
NOTE: V8 ACBX USES MLF ABD vs IB FOR HEADERS
HOW IT WORKS. DIRECT CALLS,eg.
1 EMP VIEW OF EMPLOYEES
2 FIRST-NAME
2 NAME
2 MIDDLE-NAME
: : :
READ MULTI-FETCH 10 EMP BY NAME

ADABAS

CB: CMD=L3 ILL=10 COP1=M CID=X’02000101’

FB: AC,020,A,AE,020,A,AD,020,A. FBL=27

RB: REC1 REC2 REC3 . . . REC 10 RBL=10x60

=600

IB: HDR1 HDR2 HDR3 . . . HDR 10 IBL=10x16

=160 13
HOW IT WORKS. MAX #MFF, PREFNREC ADABAS V7

MAX AS DETERMINED BY IB:

IBL=32768
/ 16 = 2048

MAX AS DETERMINED BY RB:

RBL=32768 / rec.size

REC SIZE MAX FOR MLF

60 546
200 163
2000 16

14
 QU
HOW IT WORKS. ET/BT ADABAS NUCLEUS IC
K

CB: CONTROL BLOCK CMD = ET, BT

COP1 = P
ILL = COUNT OF 6b IB ENTRIES

IB: ISN BUFFER 6 BYTE ENTRIES:

2B – FILE NUMBER
4B – ISNs TO BE PUT BACK ON HOLD

NOTE: ONLY AVAILABLE FOR DIRECT CALL PROGRAMMING:

COP1=M RELEASE ONLY ISN’S IN IB
IB: 4b COUNT OF ELEMENTS
n8b ELEMENTS (4b FNR, 4b ISN) 15
 QU
HOW IT WORKS. CA-APAS IC
K
CB ISNLL = MAX MFF RECORDS REQUESTED

CA-APAS

ISN-LOWER-LIMIT ( ISNLL ) equals 0

ISNLL-REPORTED shows MFF requested

ISN-QUANTITY ( ISNQ ) shows #RECS in RB

Note: ISNQ may not equal ISNLL-REPORTED

16
CPU COSTS OF
MULTI-FETCH
PROGRAM
5 RUNS EACH: CPU
MFF = 0
MFF = 10
MFF = 25
MFF = 50
MFF = 100 MFF= 0 10 25 50 100 1000
MFF = 1000
AVERAGES
SHOWN
NO ADABAS DELAY: ADABAS
NO IO, NO OTHER USERS CPU

NO PGM DELAY.

MFF= 0 10 25 50 100 1000 17

NATURAL (NATMLF) vs ADAMLF

18
NATMLF PROCESSES “NORMAL CALLS TO ADABAS”

PROGRAM ADALNK ADABAS NUCLEUS

1ST MLF CALL ADABAS

FILLS
BUFFER
PROGRAM
READS
BUFFER
2nd MLF CALL ADABAS
FILLS SAVE ON
BUFFER PGM-TO-ADA TIME
PROGRAM CQ-THREAD TIME
READS SOME PGM TIME
BUFFER SOME ADA TIME
3rd MLF CALL ADABAS
FILLS
BUFFER
AND SO ON . . .
19
ADAMLF PROCESSES “ASYNC CALLS TO ADABAS”

PROGRAM ADAMLF ADALNK ADABAS NUCLEUS

½ PREFSBL ½

1ST MLF CALL ADABAS

FILLS
BUFFER

2nd MLF CALL PROGRAM ADABAS

READS FILLS WHILE PROGRAM
BUFFER BUFFER PROCESS BUFFER,
ADABAS FILLS
NEXT BUFFER
3rd MLF CALL ADABAS PROGRAM
FILLS READS
BUFFER BUFFER

AND SO ON . . .
20
ADAMLF PREFSBL USAGE

PREFSBL
1/2 1/2
1/4 IB IB

3/4 RB RB

IDEAL PREFSBL
FOR EXAMPLE:
PREFSBL = 130,000
PREFSBL = 64K
1/2 = 65K
1/2 = 32K
EACH IB > 32K
EACH IB = 8K
EACH RB > 32K
EACH RB = 24K
! USE PREFNREC ! 21
ADAMLF “WARM UP” NOT USED IN NATMLF

DETERMINE RBL = ( PREFSBL / 2 ) X (3/4)

MAX RECORDS RETURNED ON EACH MLF ADAMLF CALL

1ST CALL - ONE RECORD RETURNED (NO MLF)

2ND CALL - NUMBER OF RECORDS THAT CAN FIT IN 1/8 RBL

3RD CALL - NUMBER OF RECORDS THAT CAN FIT IN 1/8 RBL

4TH CALL - NUMBER OF RECORDS THAT CAN FIT IN 1/2 RBL

5TH CALL - NUMBER OF RECORDS THAT CAN FIT IN RBL

:::
5+n CALL - NUMBER OF RECORDS THAT CAN FIT IN RBL

22
ADAMLF “WARM UP” Example
PREFSBL = 65K, RBL = ( 65K / 2 ) X (3/4) = 24,573 PREFNREC = 200
CALL# IBL RBL ISNQ*
1 8,190 100 1  1 REC, NOTE RBL=100
2 8,190 3,071 30  1/8 RBL
3 8,190 3,071 30  1/8 RBL
4 8,190 12,286 122  1/2 RBL
5 8,190 24,573 200  MAX REACHED
6 8,190 24,573 200
7 8,190 24,573 200
8 8,190 24,573 200
9 8,190 24,573 200
10 8,190 24,573 200
*NOTE: CA-APAS
11 8,190 24,573 200
ISNQ = RECS
12 8,190 24,573 200 MLF’D
13 8,190 24,573 200
23
14 8,190 24,573 17  EOF
ADAMLF vs NATURAL MLF (overall)
ADAMLF NATURAL/PROGRAM MLF

1. ASYNC PROCESSING SYNC PROCESSING

2. BATCH ONLY ONLINE OR BATCH

3. NO PROGRAM CHANGES CHANGED WITHIN PROGRAM

4. PREFNREC: FOR ALL SEQs VARY FOR @ ACCESS LOOP

5. “WARMS UP” WHAT YOU CODE, YOU GET

6. CAN DO UPDATES ! NO ! UPDATING

7. CONTROL VIA //DDCARD CONTROL WITHIN PROGRAM

(PROCS, PDS MBRs, ETC.)

24
ADAMLF vs NATURAL MLF (Performance)
PERFORMANCE (PGM ELAPSED TIME) =
ADABAS RESPONSE
(CPU,IO,OVERLAP)

PATHLENGTH TO/FROM
PGM-ADABAS
* ( #RECS / MFF )

+
PGM PROCESS ADABAS
CALLS

PGM DELAY
(CPU,IO,ETC.)
* ( #RECS )

MULTI-FETCH SAVES ON:

1. PATHLENGTH
2. SOME ADABAS RESPONSE
3. SOME PGM TIME TO PROCESS CALLS
ADAMLF IMPROVES AS PGM DELAY INCREASES 25
ADAMLF vs NATURAL MLF (Performance)
IN THE LAB: NATMLF vs ADAMLF
MFF=100
800,000 RECORDS
READ PHYSICAL

MEASURE: PGM ELAPSED TIME

PGM CPU TIME
ADABAS RESPONSE TIME (DURATION)
ADABAS RELATIVE CPU TIME (CMDTIME)

SCENARIOS:
A. NO DELAY
ADABAS: NO IO, NO OTHER USERS
NATURAL: READ LOOP ONLY
B. ADABAS DELAY (IO)
C. ADABAS/PGM DELAY (LOTSA MOVE STATEMENTS)

FOR EACH SCENARIO, MULTIPLE RUNS NATMLF,ADAMLF

RESULTS 26
ADAMLF vs NATURAL MLF (Performance)A. NO DELAY
KEY: ADAMLF NATMLF
7

2.5

2
4

3
1.5

ELAPSED (NAT 12% Better)

0
1 2 3 4 5 6 7
0.5

4
CPU (3% Diff)
0
1 2 3 4 5 6 7

3.5
6

3
5

2.5

?
4

CQ-TRHD DELAY
2

1.5

2
1

1
0.5

CPU (NAT 56% Better)

0
1 2 3 4 5 6 7
DURATION (NAT 39% Better)
0
1 2 3 4 5 6 7

PROGRAM ADABAS 27
ADAMLF vs NATURAL MLF (Performance)
B. ADABAS DELAY
KEY: ADAMLF NATMLF
6

80

70

60
4

50

40

30
2

20

ELAPSED (ADA 8% Better)

10

0
1 2 3 4 5 6
CPU (ADA 5% Better ?)
0
1 2 3 4 5 6

70
4

3.5
60

50

2.5

40

30

1.5

20
1

0.5
10

CPU (NAT 54% Better)

0
1 2 3 4 5 6
DURATION (No Diff)
0
1 2 3 4 5 6

PROGRAM ADABAS 28
ADAMLF vs NATURAL MLF (Performance)
C. DELAY PGM/ADA
KEY: ADAMLF NATMLF
450 6

400

350

300
4

250

200

150
2

100

ELAPSED (ADA 22% Better)

50

0
1 2 3 4 5
CPU (2% Diff)
0
1 2 3 4 5

25 70

60

20

50

15
40

30

10

20

10

CPU (2% Diff)

0
1 2 3 4 5
DURATION (No Diff)
0
1 2 3 4 5

PROGRAM ADABAS 29
MULTI-FETCH AND UPDATING
( ADAMLF )

30
ADAMLF. UPDATES. ET
REVIEW FOR EXAMPLE:
Lx RD1. READ TEST PHYSICAL
CB COP1=‘O’ IF AM-FIELD = 'AA'
THEN AM-FIELD := 'BB'
ET ELSE AM-FIELD := 'AA'
CB COP1=‘P’ END-IF
IB = 6b fnr/isn to UPDATE (RD1.)
put back on HQ ETCNT := ETCNT + 1
IF ETCNT = ETLIMIT
END TRANSACTION
ETCNT := 0
END-IF
END-READ /*(RD1.)
END TRANSACTION

PREFNREC=100
PREFIFIL=241,PREFICMD=L2

RESULTS 31
ADAMLF. UPDATES. ET ETLIMIT = 10

CM COP1 ILL IBL

L5 O 1 16,247  1ST CALL
A1 0 0  UPDATE 1ST RECORD
L5 O 100 16,247  1ST MLF CALL, 100 RECs
L5 O 100 16,247  2nd ASYNC MLF CALL, 100 RECs
9 A1'S  9 MORE UPDATES
ET P 191 1,146  191 RECS BACK ON HOLD
10 A1'S  10 MORE UPDATES
ET P 181 1,086  181 RECS BACK ON HOLD
10 A1'S
: : :
ET P 101 606
10 A1'S
L5 O 100 16,247  3rd ASYNC MLF CALL, 100 RECs
: : :
RC S 0 0
RI 0 16,247  RECS ON HOLD AT LOOP END
RI 0 16,247
: : : 32
ADAMLF. UPDATES. ET ETLIMIT = PREFNREC = 100
(NOTE A1s NOT ON REPORT)

CM COP1 ILL IBL EVERY ET PUTS 101 RECS

L5 O 1 16,247
L5 O 100 16,247 BACK ON HOLD
L5 O 100 16,247
ET P 0 606
L5 O 100 16,247
ET P 0 606 !! CANNOT SYNC ET’S
L5 O 100 16,247 WITH
ET P 0 606 PREFNREC !!
L5 O 100 16,247
ET P 0 606
: :
RC S 0 0 EOF, NO RI’s

33
MIN ADARUN NISNHQ=2 X PREFNREC
ADAMLF. UPDATES. ET COSTS
ET EVERY 1 A1
ADABAS AVG CPU TIME / ET

ET EVERY 10 A1

ET EVERY 100 A1

1 2 3 4 5

NREC = 0 25 50 100 200

34
ADAMLF. UPDATES. ET COSTS
50

ET EVERY 1 A1, 200K ET’S

45
ADABAS SUM CPU TIME ET’s

40
ET EVERY 10 A1, 20K ET’S
35
ET EVERY 100 A1, 2K ET’S
30

25

20

15

10

0
1 2 3 4 5

NREC = 0 25 50 100 200

ET COSTS INCREASE AS PREFNREC INCREASES

35
ADAMLF. UPDATES. UPD/DELETE A1/E1
RECORD BUFFER:
CURRENT RECORD

FOR EVERY UPDATE RECORD +1

PREFSBL BUFFER SCANNED RECORD +2
TO SEE IF ISN IN RECORD +3
“YET-TO-BE-READ” RECORDS RECORD +4
RECORD +5
( NOT CURRENT RECORD ) :::

INCREASE IN PROGRAM CPU/ELAPSED TIME

NO INCREASE IN ADABAS TIMES (NEITHER CPU NOR DURATION)

? MEASURE CPU COSTS ?

TEST PROGRAM 36
 QU
ADAMLF. UPDATES. A1/E1 COSTS IC
K
DEFINE DATA LOCAL
1 #CPU-PGM-ALL (I4) INIT <0000> /* TIME IN 10 MS UNITS
1 #CPU-UPD-ALL (I4) INIT <0000> /* TIME IN 10 MS FOR UPDS
1 #CPU-UPD (I4) /* CPU TIME COUNTER
1 TEST VIEW OF SOME-FILE
: : :
END-DEFINE
ST. SETTIME VARY PREFNREC=
ASSIGN #CPU-PGM-ALL = *CPU-TIME
RD1. READ TEST PHYSICAL RESULTS
: : :
ASSIGN #CPU-UPD = *CPU-TIME /*
UPDATE (RD1.)
ASSIGN #CPU-UPD = *CPU-TIME - #CPU-UPD
ASSIGN #CPU-UPD-ALL = #CPU-UPD-ALL + #CPU-UPD
: : :
END-READ /*(RD1.)
ASSIGN #CPU-PGM-ALL = *CPU-TIME - #CPU-PGM-ALL
WRITE 'DA-TIME' *TIME *TIMD(ST.) (EM=99:99:99'.'9)
WRITE 'DA-PGM-CPU' #CPU-PGM-ALL
WRITE 'DA-UPD-CPU' #CPU-UPD-ALL 37
ADAMLF. UPDATES. A1/E1 COSTS
7

SUM PROGRAM CPU TIMEs

6

TOTAL
TOTAL

TOTAL

TOTAL
3

1 A1 A1 A1 A1

0
ET
1
ET
2
ET
3
ET
4
NREC: ----- 0 ----- ---- 100 ---- ---- 400 ---- ---- 800 ----

UPDATE COSTS INCREASE AS PREFNREC INCREASES 38

ADAMLF. UPDATES. A1/E1 VIA REREAD

FOR EVERY READ,

REREAD (L4) THEN UPDATE

NO INCREASE IN ET TIMES
NO INCREASE IN ADABAS TIMES

MAJOR INCREASE IN PROGRAM TIMES

MEASURE CPU COSTS

RESULTS 39
ADAMLF. UPDATES. A1/E1 VIA REREAD
20

SUM PROGRAM CPU TIMEs

18

16

14

12

10

8
TOTAL

TOTAL

TOTAL

TOTAL
6

A1 A1 A1 A1
0
1 2 3 4

NREC: ----- 0 ----- ---- 100 ---- ---- 400 ---- ---- 800 ----

!! DON’T REREAD RECORD AND UPDATE !! 40

ADAMLF. UPDATES. OUTSIDE OF LOOP RB:
CURRENT RECORD
FOR EXAMPLE:
1. MLF READ RECORD +1
2. UPDATE/DELETE YET-TO-BE-READ-RECORD RECORD +2
3. IF THAT RECORD IS IN PREFSBL, IT WILL RECORD +3
BE REREAD BY ADAMLF (L1/L4) :::

FNR CM MFF COUNT

FOR EXAMPLE: --- -- ---- ------
READ MLF LOGICAL 0 CL 0 1
GET isn-x/UPDATE/REC 0 ET 0 200
(isn-x not yet read ) 241 A1 0 19,980
241 L1 0 84 NOTE
241 L3 800 28
241 L4 0 19,980

!! CAN CAUSE OUT-OF-SEQUENCE FOR READ LOGICAL !! 41

SIZING MFF

42
SIZE MFF/PREFNREC. UPPER LIMIT
1. 2048 (IBL=32K/16 ADABAS V7)

2. 32K / (RECORD.SIZE) (ADABAS V7)

3. ISN-QUANTITY FOR FIND (Sx) STATEMENTS

4. RECORDS PER LOOP (*COUNTER)

43
SIZE MFF/PREFNREC. VARY VALUE IF:
1. DATABASE USE: SHARED ( ) OR DEDICATED ( )?

2. ADAMLF. PROGRAM DELAY: MUCH ( ) OR LITTLE ( )?

3. ADAMLF. ARE UPDATES BEING DONE ( )?

4. IS SEQUENCE READ PHYSICAL ( ) OR LOGICAL ( )?

44
SIZE MFF/PREFNREC.
1. (PERSONAL PHILOSOPHY):
GOAL OF 7 TO 10 IO’S PER COMMAND.
READ PHYSICAL, USE ADAREP, RECS/BLOCK X 10
READ LOGICAL, DETERMINE AVERAGE IO/CMD

2. = J / D (ROUND UP TO INTEGER)
J = ELAPSED TIME OF JOB (IDEALLY READ SEQUENCE)
D = SUM OF ADABAS DURATION FOR SEQUENCE

3. START SMALL (5,10,20, . . . )

MONITOR CPU, ELAPSED TIMES.
! DO NOT INCREASE IF ELAPSED TIME DOES NOT INCREASE !

ANALYSIS REPORT for #1, #2 45

 QU
SIZE MFF/PREFNREC. CA-APAS IC
K
MCIMLF: SUMMARIZE(SUBTOT=OFF)
MIN(TIME) ANALYSIS REPORT
for #1, #2
MAX(TIME)
COUNT (PF=N7)
SUM(TOTAL-IO) (PF=N7)
SUM(DURATION) (PF=N4.2)
SUM(ENQ-TIME) (PF=N4.2)
SUM(CMD-TIME) (PF=N4.2)
MEAN(RBL) (PF=N3.1) TO ENSURE ONLY 1
WHERE SEQUENCE IS
FILE = 241 AND CMD = 'L2‘ MEASURED
* AND CID = X'02000101'
AND NAT-PROGRAM = 'TPGM' QUALIFY SEQUENCE
* AND JOBNAME = 'THISJOB‘
PRINT TO ADHOC1 FOR EXAMPLE
INSIGHT-LINES=600; 46
SIZE MFF/PREFNREC. Eg. Method #1,#2
SUM SUM SUM SUM
MIN MAX CMD TOT DURAT ENQTIM CMD MEAN
TIME TIME COUNT IO SECS SECS TIME RBL
EXAMPLE 1:
154931 163551 1,103,425 179,865 530.76 939.96 70.14 184.0
EXAMPLE 2:
160926 161841 4,460 6,604 61.07 0.02 1.11 204.0

EXAMPLE 1 (L2 SEQ): EXAMPLE 2 (L3 SEQ):

1. IO / CMD = 180K / 1103K 1. IO / CMD = 6604 / 4460
= .16 = 1.5
10 / .16 = 60 (MFF) 10 / 1.5 = 7 (MFF)

2. ELAPSED TIME = 2780 2. ELAPSED TIME = 555

TIME / DUR = 2780 / 531 TIME / DUR = 555 / 61
= 6 (MFF) = 10 (MFF)

47
SIZE MFF/PREFNREC. AGAIN #3
3. START SMALL (5,10,20, . . . )
MONITOR CPU, ELAPSED TIMES.
! DO NOT INCREASE IF ELAPSED TIME DOES NOT INCREASE !

PERFORMANCE (PGM ELAPSED TIME) =

ADABAS RESPONSE PGM PROCESS ADABAS
(CPU,IO,OVERLAP) CALLS

PATHLENGTH TO/FROM PGM DELAY

PGM-ADABAS (CPU,IO,ETC.)

EXAMPLES 48
SIZE MFF/PREFNREC. MINIMAL PGM DELAY
60.0
MINIMAL
PATHLENGTH
PGM ELAPSED TIME

50.0

40.0

STOP

ENQTIME
30.0
PATHLENGTHDURAT
PGM.DELAY

PROGRAM TIME
ADABAS TIME
20.0

10.0

0.0
1 2 3 4 5 6
NREC: -0- - 25 - - 50 - - 100 - 200 - - 400 - 49
SIZE MFF/PREFNREC. PGM DELAY: Lotsa MOVE stmts
300
MINIMAL PATHLENGTH
PGM ELAPSED TIME

250
PATHLENGTH
PROGRAM TIME
ADABAS TIME
200

STOP

150

100

50

0
1 2 3 4 5 6 7
NREC: 0 -5- - 10 - - 20 - - 30 - - 60 - - 400
50
-
SIZE MFF/PREFNREC. PGM DELAY: Lotsa MOVE stmts
PATHLENGTH: Different
LPAR
PGM ELAPSED TIME
500

450

400

PATHLENGTH
350
PROGRAM TIME
300
ADABAS TIME

250

200
STOP

150

100

50

0
1 2 3 4 5 6 7

NREC: - 0 - -5- - 10 - - 20 - - 30 - - 60 - - 400 -

51
CONCERNS / ISSUES

52
CONCERNS. ADARUNs
ADARUN: IF TOO SMALL:
LU=65K 152

NAB= 254,255

NISNHQ= 2 X PREFNREC 47

NH= 9 sub 1

NT= performance

NC= 151

53
CONCERNS. LOOP LIMITS
EXAMPLE
RD1. READ FILE-X
:::
RD2. READ #MFF FILE-Y
THEDE = ‘A’ THRU ‘A’
LOOP
LOOP
*COUNTER(RD2.)=10 to 15

IF #MFF = 10, 0 TO 5 EXTRA RECORDS READ EACH TIME

IF #MFF = 100, 90 TO 85 EXTRA RECORDS READ EACH TIME

54
CONCERNS. LOOP EXITS

”ESCAPE . . .”

“READ view WITH REPOSITION BY . . . “

55
CONCERNS. RECORD SIZE
EXAMPLE: RECORD EXTRACTION JOB

LRECL = 10,000 (eg. PE, MU, LA, etc)

MAX #MFF = 3

USE OF COMMON VIEWS VIA PROGRAM, LDA, GDA.

EG. LDA DEFINES 2000 BYTES OF DATA

EG. PROGRAM WITH LDA USES ONLY 50 BYTES OF DATA

MAX #MFF = 16 WITH LDA

MAX #MFF = 640 WITHOUT LDA

NOTE IF VIEW SIZE CHANGES #MFF LIMIT CHANGES

56
CONCERNS. GENERALIZATIONS

AVOID:

1. COMMON PROCS
2. COMMON ADARUN PDS MEMBERS
3. USING ADAMLF PREFXFIL,PREFXCMD, EXCLUDES
4. COMMON VIEWS,LDA’S,GDA’S (LARGER RECS)

57
CONCERNS. MADIO
MADIO LIMITS THE NUMBER OF ADABAS CALLS

FOR EXAMPLE, MADIO = 5000

READ (9000) DA-FILE . . .

:::

! FAILS !

READ (9000) MULTI-FETCH 100 DA-FILE . . .

:::

! DOES NOT FAIL !

58
CONCERNS. DB PERFORMANCE

HIGH IO MULT-FETCH CALLS CAN IMPACT OTHER DB USERS.

ADAMLF (ASYNC) HIGH IO MLF CALLS CAN IMPACT OTHER USERS.

NOTE NATURAL NUCLEUS USES MLF AGAINST SYSTEM FILES:

FNAT – YES
FUSER – YES
FDIC - NOT AT THIS TIME
FSEC - NOT AT THIS TIME
? ADD ON PRODUCTS ?
? FASTPATH ?

SAMPLE PERF REPORT 59

CONCERNS. DB PERFORMANCE CA-APAS PART 1

DECLARE FETCH (A3) VALOF

IF COPT1 = 'M' RESULTIS 'YES'
ELSEIF COPT1 = 'P' RESULTIS 'YES'
ELSEIF COPT1 = 'O' RESULTIS 'YES'
ELSE RESULTIS ' '
IFEND;

60
CONCERNS. DB PERFORMANCE CA-APAS PART 2
MCIMLFS: SUMMARIZE(SUBTOT=ON GTT=NO)
COUNT
MEAN(ENQ-TIME) (PF=N2.5)
MEAN(DURATION) (PF=N2.5)
MEAN(CMD-TIME) (PF=N1.5)
MEAN(TOTAL-IO) (PF=N2.2)
MEAN(ECBS) (PF=N2.2)
MEAN(DATA-IO) (PF=N1.2) MLF
MAX(FETCH) (HD='MLF?')
BY JOBNAME
WHERE
* OMIT FUSER/FNAT FILES
FILE NE 14 AND FILE NE 19
INTERVAL 15 MINUTES
PRINT TO SYSOUTX
INSIGHT-LINES 400; 61
CONCERNS. DB PERFORMANCE CA-APAS OPTION’s

“DRILL DOWN” OPTIONS

WHERE
* JOBNAME = 'X'
* TP-TRANS-NAME = ‘NATX’
* CID = X’02000101’

BY
* BY TP-TRANS-NAME
* BY NATURAL-LOGON
* BY NAT-PROGRAM

MAX(ISNLL-REPORTED) (PF=N3) *CAUTION

SAMPLE PERF REPORT 62

CONCERNS. DB PERFORMANCE DOCTOR’D REPORT
MEAN MEAN MEAN MEAN MEAN MEAN
CMD ENQTIME DURAT CMD TOT PST DATA
JOB NAME COUNT SECS SECS TIME IO ECB IO MLF
CICS00BH 27,097 0.00002 0.00032 0.00012 0.06 5.29 0.03
CICS000A 29,512 0.00002 0.00031 0.00014 0.03 5.52 0.01
CICS000B 15,820 0.00003 0.00082 0.00048 0.16 5.36 0.32 YES
CICS000C 8,594 0.00002 0.00031 0.00015 0.03 5.29 0.01
CICS000D 9,252 0.00003 0.00035 0.00014 0.05 5.36 0.02
CICS000I 1,525 0.00071 0.00035 0.00008 0.05 5.70 0.02
JOB00001 3,516 0.01245 0.00046 0.00007 0.10 5.27 0.04
JOB00004 7,079 0.00002 0.00339 0.00020 0.83 5.46 0.62
JOB00004 8,030 0.00001 0.01434 0.00893 5.23 5.88 4.55 YES

BATCH JOB, NOTE MEAN-DATA-IO, ECB

CICS REGION, NEED TO DRILL DOWN TO TRANS, PROGRAM

63
ADABAS 2006, V8 NOTES

FOR DIRECT CALLS (NEW ACBX):

1. MULTI-FETCH BUFFER REPLACES ISN-BUFFER FOR HEADERS
2. 32K LIMIT REMOVED FROM RECORD BUFFER.
3. FOR EXAMPLE

64
DAS ENDE

65