6.2.5 For-Loop Level

The following qualifiers set a minimum for -loop nest level for function call expansion. The /inline_ looplevel and /ipa_looplevel qualifiers enable you to limit inlining and IPA to just functions that are referenced in nested loops, where the reduced function call overhead or enhanced optimization will be multiplied. For example:

/inline_looplevel=<n>  [/inll]
/ipa_looplevel=<n>     [/ipall]

The argument is defined from the most deeply nested leaf of the call tree. A small value restricts inlining (IPA) to the best candidate functions. For example:

main
{
..
  a(); ------>  a() {...}
    }

 ..
 for (..) {
   for (..) {
     b(); --------->  b() {
     }        for (..) {
 }         for (..) {
      c(); -------> c() {...}
             }
              }
        }

The call to b is inside a doubly nested loop, and would be more profitable to expand than the call to a . The call to c is quadruply nested, so inlining c would yield the biggest gain of the three.

The argument is defined from the most deeply nested function reference:

• /Inline_looplevel=1 means only the functions referenced in the most deeply nested call sites may be inlined, for example, function c in the previous example. If more than one function call is at the same loop nest level, all of them are selected when that level is included.

• /Inline_looplevel=2 means only function calls at the most deeply nested level and one loop less deeply nested may be expanded. /Inline_looplevel=3 would be required to inline function b , since its call is two loops less nested than the call to function c . A value of 3 or greater will cause c to be inlined into b , and then the new b to be inlined into the main program.

• /Inline_looplevel (or /ipa_looplevel)= permits inlining at any nesting level.

  The calling tree and loop tables written to the listing file with /listoptions=cl include the nesting depth level of each call in each program unit and the aggregate nesting depth, that is the sum of the nesting depths for each call site, starting from the main program. This information can be used to identify the best functions for inlining.

  A function that passes the inline_looplevel test will be inlined everywhere it is used, even in places that are not in deeply nested loops. If some, but not all, invocations of a function are to be expanded, use the inline and IPA pragmas Just before each function call that is to be expanded. (See Section 6.2.6.)

  Because inlining increases the size of the code, the extra paging and cache contention can actually slow down a program. Restricting inlining to functions used in for loops multiplies the benefits of eliminating function call overhead for a given amount of code space expansion. If inlining appears to have slowed an application code, investigate using IPA, which has little effect on code space and the number of temporary variables.

Copyright © Digital Equipment Corporation. 1999. All Rights Reserved.