The constants related to inlining involve pcode, not actual assembly 
instructions, and are compiler version dependent as well as subject to change 
without notice by the GNU folks...

from:
http://gcc.gnu.org/onlinedocs/gcc-3.3.5/gcc/Optimize-Options.html#Optimize-Options

"-finline-limit=n
By default, gcc limits the size of functions that can be inlined. This flag 
allows the control of this limit for functions that are explicitly marked as 
inline (i.e., marked with the inline keyword or defined within the class 
definition in c++). n is the size of functions that can be inlined in number of 
pseudo instructions (not counting parameter handling). The default value of n 
is 600. Increasing this value can result in more inlined code at the cost of 
compilation time and memory consumption. Decreasing usually makes the 
compilation faster and less code will be inlined (which presumably means slower 
programs). This option is particularly useful for programs that use inlining 
heavily such as those based on recursive templates with C++.

Inlining is actually controlled by a number of parameters, which may be 
specified individually by using --param name=value. The -finline-limit=n option 
sets some of these parameters as follows:

    max-inline-insns
        is set to n.
    max-inline-insns-single
        is set to n/2.
    max-inline-insns-auto
        is set to n/2.
    min-inline-insns
        is set to 130 or n/4, whichever is smaller.
    max-inline-insns-rtl
        is set to n. 

Using -finline-limit=600 thus results in the default settings for these 
parameters. See below for a documentation of the individual parameters 
controlling inlining.

Note: pseudo instruction represents, in this particular context, an abstract 
measurement of function's size. In no way, it represents a count of assembly 
instructions and as such its exact meaning might change from one release to an 
another." 
    
Further Down It Says...

"--param name=value
In some places, GCC uses various constants to control the amount of 
optimization that is done. For example, GCC will not inline functions that 
contain more that a certain number of instructions. You can control some of 
these constants on the command-line using the --param option.

The names of specific parameters, and the meaning of the values, are tied to 
the internals of the compiler, and are subject to change without notice in 
future releases.

In each case, the value is an integer. The allowable choices for name are given 
in the following table:

    <snip>
    
    max-inline-insns-single
Several parameters control the tree inliner used in gcc. This number sets the 
maximum number of instructions (counted in gcc's internal representation) in a 
single function that the tree inliner will consider for inlining. This only 
affects functions declared inline and methods implemented in a class 
declaration (C++). The default value is 300.

    max-inline-insns-auto
When you use -finline-functions (included in -O3), a lot of functions that 
would otherwise not be considered for inlining by the compiler will be 
investigated. To those functions, a different (more restrictive) limit compared 
to functions declared inline can be applied. The default value is 300.

    max-inline-insns
The tree inliner does decrease the allowable size for single functions to be 
inlined after we already inlined the number of instructions given here by 
repeated inlining. This number should be a factor of two or more larger than 
the single function limit. Higher numbers result in better runtime performance, 
but incur higher compile-time resource (CPU time, memory) requirements and 
result in larger binaries. Very high values are not advisable, as too large 
binaries may adversely affect runtime performance. The default value is 600.
    
    max-inline-slope
After exceeding the maximum number of inlined instructions by repeated 
inlining, a linear function is used to decrease the allowable size for single 
functions. The slope of that function is the negative reciprocal of the number 
specified here. The default value is 32.

    min-inline-insns
The repeated inlining is throttled more and more by the linear function after 
exceeding the limit. To avoid too much throttling, a minimum for this function 
is specified here to allow repeated inlining for very small functions even when 
a lot of repeated inlining already has been done. The default value is 130.

    max-inline-insns-rtl
For languages that use the RTL inliner (this happens at a later stage than tree 
inlining), you can set the maximum allowable size (counted in RTL instructions) 
for the RTL inliner with this parameter. The default value is 600.


-----Original Message-----
From: Martijn van Oosterhout <kleptog@svana.org>
Sent: Oct 4, 2005 8:24 AM
To: Simon Riggs <[EMAIL PROTECTED]>
Cc: Tom Lane <[EMAIL PROTECTED]>, Ron Peacetree <[EMAIL PROTECTED]>, 
pgsql-hackers@postgresql.org
Subject: Re: [HACKERS] [PERFORM] A Better External Sort?

On Tue, Oct 04, 2005 at 12:24:54PM +0100, Simon Riggs wrote:
> How did you determine the 1500 figure? Can you give some more info to
> surround that recommendation to allow everybody to evaluate it?

[EMAIL PROTECTED]:~/dl/cvs/pgsql-local/src/backend/utils/sort$ gcc 
-finline-limit-1000 -Winline -O2 -Wall -Wmissing-prototypes -Wpointer-arith 
-Wendif-labels -fno-strict-aliasing -g -I../../../../src/include -D_GNU_SOURCE  
 -c -o tuplesort.o tuplesort.c

<snip>

A quick binary search puts the cutoff between 1200 and 1300. Given
version variation I picked a nice round number, 1500.

Ugh, that's for -O2, for -O3 and above it needs to be 4100 to work.
Maybe we should go for 5000 or so.

I'm using: gcc (GCC) 3.3.5 (Debian 1:3.3.5-13)

---------------------------(end of broadcast)---------------------------
TIP 4: Have you searched our list archives?

               http://archives.postgresql.org

Reply via email to