Performance Example

Question

Last week, there was a question posted to the forum asking about how to retrieve multiple records from an internal table without using a loop…endloop construct. I posted an answer showing how it could be done using a binary search followed by indexed reads on the table. I wrote a small program which illustrates this point. I’ve posted the code below, but in a nutshell, what it does is select a number of FI document headers and line items from BKPF and BSEG. The select statement from BSEG is very inefficient. I did it that way for a reason, so please don’t give me any grief over it. It then reads all records from both tables using a nested loop. Finally it reads all records from both tables using the method I proposed. It keeps track of the number of records and time taken for each operation.
    I ran the program twice in our QA environment – once selecting a small amount of data and again selecting a moderate amount. The outputs are:
First run -
Time for unindexed select: 00:08:31  
    Number of BKPF entries:      1,892
    Number of BSEG entries:      5,777
Time for nested loop: 00:00:05       
    Number of BKPF reads:      1,892 
    Number of BSEG reads:      5,777 
Time for indexed loop: 00:00:00      
    Number of BKPF reads:      1,892 
    Number of BSEG reads:      5,777 
Second run –
Time for unindexed select: 00:17:31  
    Number of BKPF entries:     24,148
    Number of BSEG entries:     84,358
Time for nested loop: 00:23:44       
    Number of BKPF reads:     24,148 
    Number of BSEG reads:     84,358 
Time for indexed loop: 00:00:00      
    Number of BKPF reads:     24,148 
    Number of BSEG reads:     84,358 
    So what can we conclude? In the first case, a gain in time of five seconds is not much, but in a dialogue program, it might be worthwhile. But in the second case the other method gains over twenty minutes. This would allow a program that has to run in the background to run in the foreground. The most striking thing to me though, is the fact that the nested loop takes substantially longer than an extremely inefficient select statement.
    The select screen for the program is quite standard. The amount of data returned is determined by whatever the user enters and the programmer really has no control over it. So I’m suggesting that if you can’t guarantee that the amount of data is small, then you really ought to use the indexed read method.
    Also note that the first select statement returns 5,777 rows from BSEG and takes 08:31 to run and the second one returns 84,358 rows and takes 17:31. The second one retrieves almost 15 times as much data but takes only about twice as long to execute. The two runs of the program were on separate evenings when there shouldn’t be any load, so buffering and workload shouldn’t be issues.
    So, my final conclusion is: when tuning a program that you know will return a small amount of data, tune the select statement and don’t worry too much about loops; however, if the program may return a large amount of data, avoid nested loops.
Code follows:
REPORT ztest.
TABLES: bkpf, bseg.
SELECT-OPTIONS: s_bukrs FOR bseg-bukrs MEMORY ID buk OBLIGATORY,
                s_gjahr FOR bseg-gjahr MEMORY ID gjr OBLIGATORY,
                s_lifnr FOR bseg-lifnr MEMORY ID lif OBLIGATORY.
DATA: BEGIN OF bkpf_int OCCURS 0.
        INCLUDE STRUCTURE bkpf.
DATA: END   OF bkpf_int.
DATA: BEGIN OF bseg_int OCCURS 0.
        INCLUDE STRUCTURE bseg.
DATA: END   OF bseg_int.
DATA: start_time   LIKE sy-uzeit,
      end_time     LIKE sy-uzeit,
      difference   LIKE sy-uzeit,
      bkpf_entries LIKE sy-tabix,
      bseg_entries LIKE sy-tabix,
      bkpf_reads   LIKE sy-tabix,
      bseg_reads   LIKE sy-tabix.
START-OF-SELECTION.
  PERFORM unindexed_select.
  PERFORM nested_loop.
  PERFORM indexed_loop.
*&      Form  unindexed_select
FORM unindexed_select.
  GET TIME FIELD start_time.
  SELECT * FROM bseg INTO TABLE bseg_int
    WHERE  bukrs IN s_bukrs
    AND    gjahr IN s_gjahr
    AND    lifnr IN s_lifnr.
  SELECT * FROM bkpf INTO TABLE bkpf_int
    FOR ALL ENTRIES IN bseg_int
    WHERE bukrs = bseg_int-bukrs
    AND   belnr = bseg_int-belnr
    AND   gjahr = bseg_int-gjahr
    AND   bstat = space.
  CLEAR   bseg_int.
  REFRESH bseg_int.
  SELECT * FROM bseg INTO TABLE bseg_int
    FOR ALL ENTRIES IN bkpf_int
    WHERE bukrs = bkpf_int-bukrs
    AND   belnr = bkpf_int-belnr
    AND   gjahr = bkpf_int-gjahr.
  GET TIME FIELD end_time.
  difference = end_time - start_time.
  DESCRIBE TABLE bkpf_int LINES bkpf_entries.
  DESCRIBE TABLE bseg_int LINES bseg_entries.
  WRITE: /001 'Time for unindexed select:', difference,
         /005 'Number of BKPF entries:', bkpf_entries,
         /005 'Number of BSEG entries:', bseg_entries.
ENDFORM.                    " unindexed_select
*&      Form  nested_loop
FORM nested_loop.
  GET TIME FIELD start_time.
  LOOP AT bkpf_int.
    bkpf_reads = bkpf_reads + 1.
    LOOP AT bseg_int WHERE
      bukrs = bkpf_int-bukrs AND
      belnr = bkpf_int-belnr AND
      gjahr = bkpf_int-gjahr.
      bseg_reads = bseg_reads + 1.
    ENDLOOP.
  ENDLOOP.
  GET TIME FIELD end_time.
  difference = end_time - start_time.
  WRITE: /001 'Time for nested loop:', difference,
         /005 'Number of BKPF reads:', bkpf_reads,
         /005 'Number of BSEG reads:', bseg_reads.
ENDFORM.                    " nested_loop
*&      Form  indexed_loop
*       text
FORM indexed_loop.
  DATA: bkpf_index LIKE sy-tabix,
        bseg_index LIKE sy-tabix.
  CLEAR: bkpf_reads,
         bseg_reads.
  GET TIME FIELD start_time.
  SORT: bkpf_int BY bukrs belnr gjahr,
        bseg_int BY bukrs belnr gjahr.
  LOOP AT bkpf_int.
    READ TABLE bseg_int WITH KEY
      bukrs = bkpf_int-bukrs
      belnr = bkpf_int-belnr
      gjahr = bkpf_int-gjahr
      BINARY SEARCH.
    bkpf_reads = bkpf_reads + 1.
    bseg_index = sy-tabix.
    WHILE sy-subrc = 0.
      bseg_index = bseg_index + 1.
      bseg_reads = bseg_reads + 1.
      READ TABLE bseg_int INDEX bseg_index.
      IF bseg_int-bukrs <> bkpf_int-bukrs OR
         bseg_int-belnr <> bkpf_int-belnr OR
         bseg_int-gjahr <> bkpf_int-gjahr.
        sy-subrc = 99.
      ELSE.
      ENDIF.
    ENDWHILE.
  ENDLOOP.
  GET TIME FIELD end_time.
  difference = end_time - start_time.
  WRITE: /001 'Time for indexed loop:', difference,
         /005 'Number of BKPF reads:', bkpf_reads,
         /005 'Number of BSEG reads:', bseg_reads.
ENDFORM.                    " indexed_loop

Answer 1

Hi, something in additional.
Can anyone explain why the two ways has a so definitely difference in performance, in the ABAP runtime analyze view.
In my opinion, maybe binary read is a short quick action in the memory. On the opposite side, when do nested loop, the runtime will need many swap memory action as it need to keep the status info of external loop, that will cost a lost in performance.
That's the supposition of mine. Really hope anyone can explain the reason under the phenomena.
thanks