1. 1 MULTI-FETCH IN AND OUT OF NATURAL Jim Poole

2. 2 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

3. 3 WHAT’S NOT COVERED: PREFETC H HISTOGRAM L9’s ADAMLF Exclude: PREFXFIL/ PREFXCMD ADAMLF: NOT USING PREFNREC DIRECT CALLS PROGRAMS

4. 4 OVERALL “?WHAT IS MULTI-FETCH ?” RETURN MULTIPLE RECORDS ON ONE ADABAS CALL/CMD READ FILE : : : END-READ PROGRAM CQ  THREAD ADABAS READ FILE : : : END-READ PROGRAM CQ  THREAD ADABAS *COUNTER=10,000 10,000 L3’S 10,000 CALLS TO ADABAS 10,000 CQ TO THREAD 10,000 RB’S FILLED 10,000 CALLS RETURNED *COUNTER=10,000 PREFNREC/MFF=100 100 L3’S 100 CALLS TO ADABAS 100 CQ TO THREAD 100 RB’S FILLED (WITH 100 RECORDS EACH) 100 CALLS RETURNED REGULAR PROCESSINGMULTI-FETCH PROCESSING

5. 5 OVERALL “TWO APPROACHES TO MULTI-FETCH” PROGRAM ADALNK 1. BATCH2. BATCH/ONLINE NATURAL V4 READ/FIND MULTI-FETCH #MFF : : : ADA LINK ADAMLF: ADARUN PREF*= : : : ADAMLF NATMLF NOTE: PGM MLF HAS PRECEDENCE

6. 6 SYNTAX: ADAMLF QUICK 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 … JCL: //DDCARD (ALL PREFACED BY ADARUN) !! ALWAYS CODE PREFNREC= !!

7. 7 SYNTAX: ADAMLF EXAMPLES QUICK 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”

8. 8 SYNTAX: NATMLF QUICK READ/FIND MULTI-FETCH factor view-name... AVAILABLE WITH NATURAL 4 1 #MFF (I4)INIT /*RECS/DB ACCESS FOR MLF : : : RD1. READ MULTI-FETCH #MFF DA-FILE PHYSICAL FOR EXAMPLE: “FOR FILE DA-FILE, 20 RECORDS WILL BE RETURNED ON EACH DATABASE CALL”

9. 9 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)

10. 10 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

11. 11 SYNTAX: NATMLF. MULFETCH BUFFER QUICK 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)

12. 12 HOW IT WORKS. DIRECT CALLS ADABAS NUCLEUS FB: FORMAT BUFFER CB: CONTROL BLOCK CMD = L2/L5, L3/L6 L1/L4 where COP2=I or N ILL = MAX RECS TO RETURN COP1=M or O CID = NON-ZERO,NON-BLANK RB: RECORD BUFFER S 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) NOTE: V8 ACBX USES MLF ABD vs IB FOR HEADERS

13. 13 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 CMD=L3 ILL=10 COP1=M CID=X’02000101’ AC,020,A,AE,020,A,AD,020,A. REC1 REC2 REC3... REC 10 HDR1 HDR2 HDR3... HDR 10 CB: FB: RB: IB: FBL=27 RBL=10x60 =600 IBL=10x16 =160 ADABAS

14. 14 HOW IT WORKS. MAX #MFF, PREFNREC IBL=32768 / 16 = 2048 ADABAS V7 MAX AS DETERMINED BY IB: RBL=32768 / rec.size REC SIZE MAX FOR MLF 60 546 200 163 2000 16 MAX AS DETERMINED BY RB:

15. 15 HOW IT WORKS. ET/BT ADABAS NUCLEUS CB: CONTROL BLOCKCMD = 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) QUICK

16. 16 HOW IT WORKS. CA-APAS QUICK CB ISNLL = MAX MFF RECORDS REQUESTED 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 CA-APAS

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

18. 18 NATURAL (NATMLF) vs ADAMLF

19. 19 NATMLF PROCESSES ADABAS NUCLEUS ADALNKPROGRAM “NORMAL CALLS TO ADABAS” 1 ST MLF CALL ADABAS FILLS BUFFER PROGRAM READS BUFFER 2nd MLF CALL ADABAS FILLS BUFFER SAVE ON PGM-TO-ADA TIME CQ-THREAD TIME SOME PGM TIME SOME ADA TIME PROGRAM READS BUFFER 3 rd MLF CALL ADABAS FILLS BUFFER AND SO ON...

20. 20 ADAMLF PROCESSES ADABAS NUCLEUS ADALNKADAMLFPROGRAM ½ PREFSBL ½ “ASYNC CALLS TO ADABAS” 1 ST MLF CALL ADABAS FILLS BUFFER ADABAS FILLS BUFFER PROGRAM READS BUFFER 2nd MLF CALL PROGRAM READS BUFFER ADABAS FILLS BUFFER 3rd MLF CALL AND SO ON... WHILE PROGRAM PROCESS BUFFER, ADABAS FILLS NEXT BUFFER

21. 21 ADAMLF PREFSBL USAGE PREFSBL 1 / 2 1 / 4 3 / 4 IB RB PREFSBL = 64K 1/2 = 32K EACH IB = 8K EACH RB = 24K FOR EXAMPLE: PREFSBL = 130,000 1/2 = 65K EACH IB > 32K EACH RB > 32K ! USE PREFNREC ! IDEAL PREFSBL

22. 22 ADAMLF “WARM UP” NOT USED IN NATMLF DETERMINE RBL = ( PREFSBL / 2 ) X (3/4) 1 ST CALL - ONE RECORD RETURNED (NO MLF) 2 ND CALL - NUMBER OF RECORDS THAT CAN FIT IN 1/8 RBL 3 RD CALL - NUMBER OF RECORDS THAT CAN FIT IN 1/8 RBL 4 TH CALL - NUMBER OF RECORDS THAT CAN FIT IN 1/2 RBL 5 TH CALL - NUMBER OF RECORDS THAT CAN FIT IN RBL : : : 5+n CALL - NUMBER OF RECORDS THAT CAN FIT IN RBL MAX RECORDS RETURNED ON EACH MLF ADAMLF CALL

23. 23 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 2 8,190 3,071 30 3 8,190 3,071 30 4 8,190 12,286 122 5 8,190 24,573 200 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 11 8,190 24,573 200 12 8,190 24,573 200 13 8,190 24,573 200 14 8,190 24,573 17  1 REC, NOTE RBL=100  1/8 RBL  1/2 RBL  MAX REACHED  EOF * NOTE: CA-APAS ISNQ = RECS MLF’D

24. 24 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.)

25. 25 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

26. 26 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

27. 27 ADABASPROGRAM ADAMLF vs NATURAL MLF (Performance) A. NO DELAY ADAMLF NATMLF KEY: ELAPSED (NAT 12% Better) CPU (NAT 56% Better) CPU (3% Diff) DURATION (NAT 39% Better) ? CQ-TRHD DELAY

28. 28 ADABASPROGRAM ADAMLF vs NATURAL MLF (Performance) B. ADABAS DELAY ADAMLF NATMLF KEY: ELAPSED (ADA 8% Better) CPU (NAT 54% Better) CPU (ADA 5% Better ?) DURATION (No Diff)

29. 29 ADABASPROGRAM ADAMLF vs NATURAL MLF (Performance) C. DELAY PGM/ADA ADAMLF NATMLF KEY: ELAPSED (ADA 22% Better) CPU (2% Diff) DURATION (No Diff)

30. 30 MULTI-FETCH AND UPDATING ( ADAMLF )

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

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

33. 33 ADAMLF. UPDATES. ET CM COP1 ILL IBL L5 O 1 16,247 L5 O 100 16,247 ET P 0 606 L5 O 100 16,247 ET P 0 606 L5 O 100 16,247 ET P 0 606 L5 O 100 16,247 ET P 0 606 : RC S 0 0 ETLIMIT = PREFNREC = 100 (NOTE A1s NOT ON REPORT)  EVERY ET PUTS 101 RECS BACK ON HOLD MIN ADARUN NISNHQ=2 X PREFNREC  EOF, NO RI’s !! CANNOT SYNC ET’S WITH PREFNREC !!

34. 34 ADAMLF. UPDATES. ET COSTS ADABAS AVG CPU TIME / ET ET EVERY 1 A1 ET EVERY 10 A1 ET EVERY 100 A1 NREC = 0 25 50 100 200

35. 35 ADAMLF. UPDATES. ET COSTS ADABAS SUM CPU TIME ET’s ET EVERY 1 A1, 200K ET’S ET EVERY 10 A1, 20K ET’S ET EVERY 100 A1, 2K ET’S NREC = 0 25 50 100 200 ET COSTS INCREASE AS PREFNREC INCREASES

36. 36 ADAMLF. UPDATES. UPD/DELETE A1/E1 FOR EVERY UPDATE PREFSBL BUFFER SCANNED TO SEE IF ISN IN “YET-TO-BE-READ” RECORDS ( NOT CURRENT RECORD ) INCREASE IN PROGRAM CPU/ELAPSED TIME NO INCREASE IN ADABAS TIMES (NEITHER CPU NOR DURATION) TEST PROGRAM ? MEASURE CPU COSTS ? RECORD +1 RECORD +2 RECORD +3 RECORD +4 RECORD +5 : : : CURRENT RECORD RECORD BUFFER:

37. 37 ADAMLF. UPDATES. A1/E1 COSTS DEFINE DATA LOCAL 1 #CPU-PGM-ALL (I4) INIT /* TIME IN 10 MS UNITS 1 #CPU-UPD-ALL (I4) INIT /* TIME IN 10 MS FOR UPDS 1 #CPU-UPD (I4) /* CPU TIME COUNTER 1 TEST VIEW OF SOME-FILE : : : END-DEFINE ST. SETTIME ASSIGN #CPU-PGM-ALL = *CPU-TIME RD1. READ TEST PHYSICAL : : : 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 RESULTS VARY PREFNREC= QUICK

38. 38 ADAMLF. UPDATES. A1/E1 COSTS SUM PROGRAM CPU TIMEs NREC: ----- 0 ----- ---- 100 ---- ---- 400 ---- ---- 800 ---- ET A1 TOTAL UPDATE COSTS INCREASE AS PREFNREC INCREASES

39. 39 ADAMLF. UPDATES. A1/E1 VIA REREAD FOR EVERY READ, REREAD (L4) THEN UPDATE NO INCREASE IN ADABAS TIMES RESULTS MEASURE CPU COSTS NO INCREASE IN ET TIMES MAJOR INCREASE IN PROGRAM TIMES

40. 40 ADAMLF. UPDATES. A1/E1 VIA REREAD SUM PROGRAM CPU TIMEs NREC: ----- 0 ----- ---- 100 ---- ---- 400 ---- ---- 800 ---- A1 TOTAL !! DON’T REREAD RECORD AND UPDATE !!

41. 41 ADAMLF. UPDATES. OUTSIDE OF LOOP FOR EXAMPLE: 1. MLF READ 2. UPDATE/DELETE YET-TO-BE-READ-RECORD 3. IF THAT RECORD IS IN PREFSBL, IT WILL BE REREAD BY ADAMLF (L1/L4) FNR CM MFF COUNT --- -- ---- ------ 0 CL 0 1 0 ET 0 200 241 A1 0 19,980 241 L1 0 84 241 L3 800 28 241 L4 0 19,980  NOTE !! CAN CAUSE OUT-OF-SEQUENCE FOR READ LOGICAL !! FOR EXAMPLE: READ MLF LOGICAL GET isn-x/UPDATE/REC (isn-x not yet read ) RECORD +1 RECORD +2 RECORD +3 : : : CURRENT RECORD RB:

42. 42 SIZING MFF

43. 43 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)

44. 44 SIZE MFF/PREFNREC. VARY VALUE IF: 1. DATABASE USE: SHARED ( ) OR DEDICATED ( )?3. ADAMLF. ARE UPDATES BEING DONE ( )?2. ADAMLF. PROGRAM DELAY: MUCH ( ) OR LITTLE ( )?4. IS SEQUENCE READ PHYSICAL ( ) OR LOGICAL ( ) ?

45. 45 SIZE MFF/PREFNREC. 3. START SMALL (5,10,20,... ) MONITOR CPU, ELAPSED TIMES. ! DO NOT INCREASE IF ELAPSED TIME DOES NOT INCREASE ! 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 ANALYSIS REPORT for #1, #2

46. 46 FOR EXAMPLE SIZE MFF/PREFNREC. MCIMLF: SUMMARIZE(SUBTOT=OFF) MIN(TIME) 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) WHERE FILE = 241 AND CMD = 'L2‘ * AND CID = X'02000101' AND NAT-PROGRAM = 'TPGM' * AND JOBNAME = 'THISJOB‘ PRINT TO ADHOC1 INSIGHT-LINES=600; CA-APAS QUICK TO ENSURE ONLY 1 SEQUENCE IS MEASURED QUALIFY SEQUENCE ANALYSIS REPORT for #1, #2

47. 47 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 1. IO / CMD = 180K / 1103K =.16 10 /.16 = 60 (MFF) 2. ELAPSED TIME = 2780 TIME / DUR = 2780 / 531 = 6 (MFF) EXAMPLE 1 (L2 SEQ): 1. IO / CMD = 6604 / 4460 = 1.5 10 / 1.5 = 7 (MFF) 2. ELAPSED TIME = 555 TIME / DUR = 555 / 61 = 10 (MFF) EXAMPLE 2 (L3 SEQ):

48. 48 SIZE MFF/PREFNREC. AGAIN #3 3. START SMALL (5,10,20,... ) MONITOR CPU, ELAPSED TIMES. ! DO NOT INCREASE IF ELAPSED TIME DOES NOT INCREASE ! EXAMPLES ADABAS RESPONSE (CPU,IO,OVERLAP) PATHLENGTH TO/FROM PGM-ADABAS PGM PROCESS ADABAS CALLS PGM DELAY (CPU,IO,ETC.) PERFORMANCE (PGM ELAPSED TIME) =

49. 49 SIZE MFF/PREFNREC. MINIMAL PGM DELAY MINIMAL PATHLENGTH PGM ELAPSED TIME NREC: - 0 - - 25 - - 50 - - 100 - 200 - - 400 - ADABAS TIME PROGRAM TIME PATHLENGTH STOP

50. 50 SIZE MFF/PREFNREC. PGM DELAY: Lotsa MOVE stmts MINIMAL PATHLENGTH PGM ELAPSED TIME NREC: 0 - 5 - - 10 - - 20 - - 30 - - 60 - - 400 - ADABAS TIME PROGRAM TIME PATHLENGTH STOP

51. 51 SIZE MFF/PREFNREC. PGM DELAY: Lotsa MOVE stmts PATHLENGTH: Different LPAR PGM ELAPSED TIME ADABAS TIME PROGRAM TIME PATHLENGTH STOP NREC: - 0 - - 5 - - 10 - - 20 - - 30 - - 60 - - 400 -

52. 52 CONCERNS / ISSUES

53. 53 CONCERNS. ADARUNs LU=65K152 NAB=254,255 NISNHQ= 2 X PREFNREC47 NH=9 sub 1 NT=performance NC=151 ADARUN:IF TOO SMALL:

54. 54 CONCERNS. LOOP LIMITS RD1. READ FILE-X : : : RD2. READ #MFF FILE-Y THEDE = ‘A’ THRU ‘A’ LOOP EXAMPLE *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

55. 55 CONCERNS. LOOP EXITS ”ESCAPE...” “READ view WITH REPOSITION BY... “

56. 56 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

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

58. 58 CONCERNS. MADIO MADIO LIMITS THE NUMBER OF ADABAS CALLS READ (9000) DA-FILE... : : : ! FAILS ! FOR EXAMPLE, MADIO = 5000 READ (9000) MULTI-FETCH 100 DA-FILE... : : : ! DOES NOT FAIL !

59. 59 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

60. 60 CONCERNS. DB PERFORMANCE DECLARE FETCH (A3) VALOF IF COPT1 = 'M' RESULTIS 'YES' ELSEIF COPT1 = 'P' RESULTIS 'YES' ELSEIF COPT1 = 'O' RESULTIS 'YES' ELSE RESULTIS ' ' IFEND; CA-APAS PART 1

61. 61 CONCERNS. DB PERFORMANCE 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) 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; CA-APAS PART 2 MLF

62. 62 CONCERNS. DB PERFORMANCE 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 CA-APAS OPTION’s “DRILL DOWN” OPTIONS SAMPLE PERF REPORT

63. 63 CONCERNS. DB PERFORMANCE 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 DOCTOR’D REPORT

64. 64 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

65. 65 DAS ENDE