LinuxQuestions.org
Review your favorite Linux distribution.
Go Back   LinuxQuestions.org > Forums > Linux Forums > Linux - Distributions > Slackware
User Name
Password
Slackware This Forum is for the discussion of Slackware Linux.

Notices



Reply
 
Search this Thread
Old 03-26-2003, 11:10 PM   #1
jatbudhwar
LQ Newbie
 
Registered: Mar 2003
Location: Melbourne, Australia
Distribution: Slackware current
Posts: 4

Rep: Reputation: 0
Smile Optimise GCC for your CPU


Hi people, i spent quite a while searching the net for a way to make GCC use my CPU to its fullest and compile source code to run as fast as possible on my machine.

Open the file called profile in the /etc directory.

add these lines
This will work for AthlonXPs:
export CXXFLAGS="-O3 -march=athlon-xp -mcpu=athlon-xp"
export CPPFLAGS="-O3 -march=athlon-xp -mcpu=athlon-xp"
export CFLAGS="-O3 -march=athlon-xp -mcpu=athlon-xp"

And this one, for Pentium 4s:
export CXXFLAGS="-O3 -march=pentium4 -mcpu=pentium4"
export CPPFLAGS="-O3 -march=pentium4 -mcpu=pentium4"
export CFLAGS="-O3 -march=pentium4 -mcpu=pentium4"

save and reboot.
Now everytime you run
./configure
make
make install, it will the above.

cheers.
 
Old 03-27-2003, 12:22 AM   #2
bilbod
Member
 
Registered: Mar 2003
Posts: 42

Rep: Reputation: 16
you might want to add -s and -fomit-frame-pointer.

Also, I think I read in some kernel docs not to use anything higher than -O2 to compile the kernel.

The gcc3.2 docs say -O3 is very aggressive and may result in larger executables and slower execution.
 
Old 03-27-2003, 12:51 AM   #3
jatbudhwar
LQ Newbie
 
Registered: Mar 2003
Location: Melbourne, Australia
Distribution: Slackware current
Posts: 4

Original Poster
Rep: Reputation: 0
Quote:
Originally posted by bilbod
you might want to add -s and -fomit-frame-pointer.

Also, I think I read in some kernel docs not to use anything higher than -O2 to compile the kernel.

The gcc3.2 docs say -O3 is very aggressive and may result in larger executables and slower execution.
Good point about the -s and frame pointer thingy, i believe it does free up a register. Could you please write up the full line for me / append it to the lines i mentioned earlier. It took me long enough to find these.

About the -03, i read some conflicting reports on that, do you have any real life results on it?
cheers
 
Old 03-27-2003, 01:05 AM   #4
jatbudhwar
LQ Newbie
 
Registered: Mar 2003
Location: Melbourne, Australia
Distribution: Slackware current
Posts: 4

Original Poster
Rep: Reputation: 0
I found this guide, it says the -0 automatically turns on -fomit-frame-pointer, give it a read and let me know if you find something different.

Options That Control Optimization
=================================

These options control various sorts of optimizations:

`-O'
`-O1'
Optimize. Optimizing compilation takes somewhat more time, and a
lot more memory for a large function.

Without `-O', the compiler's goal is to reduce the cost of
compilation and to make debugging produce the expected results.
Statements are independent: if you stop the program with a
breakpoint between statements, you can then assign a new value to
any variable or change the program counter to any other statement
in the function and get exactly the results you would expect from
the source code.

Without `-O', the compiler only allocates variables declared
`register' in registers. The resulting compiled code is a little
worse than produced by PCC without `-O'.

With `-O', the compiler tries to reduce code size and execution
time.

When you specify `-O', the compiler turns on `-fthread-jumps' and
`-fdefer-pop' on all machines. The compiler turns on
`-fdelayed-branch' on machines that have delay slots, and
`-fomit-frame-pointer' on machines that can support debugging even
without a frame pointer. On some machines the compiler also turns
on other flags.

`-O2'
Optimize even more. GCC performs nearly all supported
optimizations that do not involve a space-speed tradeoff. The
compiler does not perform loop unrolling or function inlining when
you specify `-O2'. As compared to `-O', this option increases
both compilation time and the performance of the generated code.

`-O2' turns on all optional optimizations except for loop
unrolling, function inlining, and strict aliasing optimizations.
It also turns on the `-fforce-mem' option on all machines and
frame pointer elimination on machines where doing so does not
interfere with debugging.

`-O3'
Optimize yet more. `-O3' turns on all optimizations specified by
`-O2' and also turns on the `inline-functions' option.

`-O0'
Do not optimize.

`-Os'
Optimize for size. `-Os' enables all `-O2' optimizations that do
not typically increase code size. It also performs further
optimizations designed to reduce code size.

If you use multiple `-O' options, with or without level numbers,
the last such option is the one that is effective.

Options of the form `-fFLAG' specify machine-independent flags.
Most flags have both positive and negative forms; the negative form of
`-ffoo' would be `-fno-foo'. In the table below, only one of the forms
is listed--the one which is not the default. You can figure out the
other form by either removing `no-' or adding it.

`-ffloat-store'
Do not store floating point variables in registers, and inhibit
other options that might change whether a floating point value is
taken from a register or memory.

This option prevents undesirable excess precision on machines such
as the 68000 where the floating registers (of the 68881) keep more
precision than a `double' is supposed to have. Similarly for the
x86 architecture. For most programs, the excess precision does
only good, but a few programs rely on the precise definition of
IEEE floating point. Use `-ffloat-store' for such programs, after
modifying them to store all pertinent intermediate computations
into variables.

`-fno-default-inline'
Do not make member functions inline by default merely because they
are defined inside the class scope (C++ only). Otherwise, when
you specify `-O', member functions defined inside class scope are
compiled inline by default; i.e., you don't need to add `inline'
in front of the member function name.

`-fno-defer-pop'
Always pop the arguments to each function call as soon as that
function returns. For machines which must pop arguments after a
function call, the compiler normally lets arguments accumulate on
the stack for several function calls and pops them all at once.

`-fforce-mem'
Force memory operands to be copied into registers before doing
arithmetic on them. This produces better code by making all memory
references potential common subexpressions. When they are not
common subexpressions, instruction combination should eliminate
the separate register-load. The `-O2' option turns on this option.

`-fforce-addr'
Force memory address constants to be copied into registers before
doing arithmetic on them. This may produce better code just as
`-fforce-mem' may.

`-fomit-frame-pointer'
Don't keep the frame pointer in a register for functions that
don't need one. This avoids the instructions to save, set up and
restore frame pointers; it also makes an extra register available
in many functions. *It also makes debugging impossible on some
machines.*

On some machines, such as the Vax, this flag has no effect, because
the standard calling sequence automatically handles the frame
pointer and nothing is saved by pretending it doesn't exist. The
machine-description macro `FRAME_POINTER_REQUIRED' controls
whether a target machine supports this flag. Registers.

`-fno-inline'
Don't pay attention to the `inline' keyword. Normally this option
is used to keep the compiler from expanding any functions inline.
Note that if you are not optimizing, no functions can be expanded
inline.

`-finline-functions'
Integrate all simple functions into their callers. The compiler
heuristically decides which functions are simple enough to be worth
integrating in this way.

If all calls to a given function are integrated, and the function
is declared `static', then the function is normally not output as
assembler code in its own right.

`-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 (ie 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
10000. 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++.

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

`-fkeep-inline-functions'
Even if all calls to a given function are integrated, and the
function is declared `static', nevertheless output a separate
run-time callable version of the function. This switch does not
affect `extern inline' functions.

`-fkeep-static-consts'
Emit variables declared `static const' when optimization isn't
turned on, even if the variables aren't referenced.

GCC enables this option by default. If you want to force the
compiler to check if the variable was referenced, regardless of
whether or not optimization is turned on, use the
`-fno-keep-static-consts' option.

`-fno-function-cse'
Do not put function addresses in registers; make each instruction
that calls a constant function contain the function's address
explicitly.

This option results in less efficient code, but some strange hacks
that alter the assembler output may be confused by the
optimizations performed when this option is not used.

`-ffast-math'
This option allows GCC to violate some ANSI or IEEE rules and/or
specifications in the interest of optimizing code for speed. For
example, it allows the compiler to assume arguments to the `sqrt'
function are non-negative numbers and that no floating-point values
are NaNs.

This option should never be turned on by any `-O' option since it
can result in incorrect output for programs which depend on an
exact implementation of IEEE or ANSI rules/specifications for math
functions.

The following options control specific optimizations. The `-O2'
option turns on all of these optimizations except `-funroll-loops'
`-funroll-all-loops', and `-fstrict-aliasing'. On most machines, the
`-O' option turns on the `-fthread-jumps' and `-fdelayed-branch'
options, but specific machines may handle it differently.

You can use the following flags in the rare cases when "fine-tuning"
of optimizations to be performed is desired.

`-fstrength-reduce'
Perform the optimizations of loop strength reduction and
elimination of iteration variables.

`-fthread-jumps'
Perform optimizations where we check to see if a jump branches to a
location where another comparison subsumed by the first is found.
If so, the first branch is redirected to either the destination of
the second branch or a point immediately following it, depending
on whether the condition is known to be true or false.

`-fcse-follow-jumps'
In common subexpression elimination, scan through jump instructions
when the target of the jump is not reached by any other path. For
example, when CSE encounters an `if' statement with an `else'
clause, CSE will follow the jump when the condition tested is
false.

`-fcse-skip-blocks'
This is similar to `-fcse-follow-jumps', but causes CSE to follow
jumps which conditionally skip over blocks. When CSE encounters a
simple `if' statement with no else clause, `-fcse-skip-blocks'
causes CSE to follow the jump around the body of the `if'.

`-frerun-cse-after-loop'
Re-run common subexpression elimination after loop optimizations
has been performed.

`-frerun-loop-opt'
Run the loop optimizer twice.

`-fgcse'
Perform a global common subexpression elimination pass. This pass
also performs global constant and copy propagation.

`-fexpensive-optimizations'
Perform a number of minor optimizations that are relatively
expensive.

`-foptimize-register-moves'
`-fregmove'
Attempt to reassign register numbers in move instructions and as
operands of other simple instructions in order to maximize the
amount of register tying. This is especially helpful on machines
with two-operand instructions. GCC enables this optimization by
default with `-O2' or higher.

Note `-fregmove' and `-foptimize-register-moves' are the same
optimization.

`-fdelayed-branch'
If supported for the target machine, attempt to reorder
instructions to exploit instruction slots available after delayed
branch instructions.

`-fschedule-insns'
If supported for the target machine, attempt to reorder
instructions to eliminate execution stalls due to required data
being unavailable. This helps machines that have slow floating
point or memory load instructions by allowing other instructions
to be issued until the result of the load or floating point
instruction is required.

`-fschedule-insns2'
Similar to `-fschedule-insns', but requests an additional pass of
instruction scheduling after register allocation has been done.
This is especially useful on machines with a relatively small
number of registers and where memory load instructions take more
than one cycle.

`-ffunction-sections'
`-fdata-sections'
Place each function or data item into its own section in the output
file if the target supports arbitrary sections. The name of the
function or the name of the data item determines the section's name
in the output file.

Use these options on systems where the linker can perform
optimizations to improve locality of reference in the instruction
space. HPPA processors running HP-UX and Sparc processors running
Solaris 2 have linkers with such optimizations. Other systems
using the ELF object format as well as AIX may have these
optimizations in the future.

Only use these options when there are significant benefits from
doing so. When you specify these options, the assembler and
linker will create larger object and executable files and will
also be slower. You will not be able to use `gprof' on all
systems if you specify this option and you may have problems with
debugging if you specify both this option and `-g'.

`-fcaller-saves'
Enable values to be allocated in registers that will be clobbered
by function calls, by emitting extra instructions to save and
restore the registers around such calls. Such allocation is done
only when it seems to result in better code than would otherwise
be produced.

This option is always enabled by default on certain machines,
usually those which have no call-preserved registers to use
instead.

For all machines, optimization level 2 and higher enables this
flag by default.

`-funroll-loops'
Perform the optimization of loop unrolling. This is only done for
loops whose number of iterations can be determined at compile time
or run time. `-funroll-loops' implies both `-fstrength-reduce' and
`-frerun-cse-after-loop'.

`-funroll-all-loops'
Perform the optimization of loop unrolling. This is done for all
loops and usually makes programs run more slowly.
`-funroll-all-loops' implies `-fstrength-reduce' as well as
`-frerun-cse-after-loop'.

`-fmove-all-movables'
Forces all invariant computations in loops to be moved outside the
loop.

`-freduce-all-givs'
Forces all general-induction variables in loops to be
strength-reduced.

_Note:_ When compiling programs written in Fortran,
`-fmove-all-movables' and `-freduce-all-givs' are enabled by
default when you use the optimizer.

These options may generate better or worse code; results are highly
dependent on the structure of loops within the source code.

These two options are intended to be removed someday, once they
have helped determine the efficacy of various approaches to
improving loop optimizations.

Please let us (`gcc@gcc.gnu.org' and `fortran@gnu.org') know how
use of these options affects the performance of your production
code. We're very interested in code that runs _slower_ when these
options are _enabled_.

`-fno-peephole'
Disable any machine-specific peephole optimizations.

`-fbranch-probabilities'
After running a program compiled with `-fprofile-arcs' (
Options for Debugging Your Program or `gcc' Debugging Options.),
you can compile it a second time using `-fbranch-probabilities',
to improve optimizations based on guessing the path a branch might
take.

With `-fbranch-probabilities', GCC puts a `REG_EXEC_COUNT' note on
the first instruction of each basic block, and a `REG_BR_PROB'
note on each `JUMP_INSN' and `CALL_INSN'. These can be used to
improve optimization. Currently, they are only used in one place:
in `reorg.c', instead of guessing which path a branch is mostly to
take, the `REG_BR_PROB' values are used to exactly determine which
path is taken more often.

`-fstrict-aliasing'
Allows the compiler to assume the strictest aliasing rules
applicable to the language being compiled. For C (and C++), this
activates optimizations based on the type of expressions. In
particular, an object of one type is assumed never to reside at
the same address as an object of a different type, unless the
types are almost the same. For example, an `unsigned int' can
alias an `int', but not a `void*' or a `double'. A character type
may alias any other type.

Pay special attention to code like this:
union a_union {
int i;
double d;
};

int f() {
a_union t;
t.d = 3.0;
return t.i;
}
The practice of reading from a different union member than the one
most recently written to (called "type-punning") is common. Even
with `-fstrict-aliasing', type-punning is allowed, provided the
memory is accessed through the union type. So, the code above
will work as expected. However, this code might not:
int f() {
a_union t;
int* ip;
t.d = 3.0;
ip = &t.i;
return *ip;
}

Every language that wishes to perform language-specific alias
analysis should define a function that computes, given an `tree'
node, an alias set for the node. Nodes in different alias sets
are not allowed to alias. For an example, see the C front-end
function `c_get_alias_set'.
 
Old 03-27-2003, 01:16 AM   #5
bilbod
Member
 
Registered: Mar 2003
Posts: 42

Rep: Reputation: 16
>>"-O3 -march=athlon-xp -mcpu=athlon-xp"<<

="-O2 -s -fomit-frame-pointer -march=athlon-xp"

I think if you use -march switch you only need mcpu if they are different.

>>About the -03, i read some conflicting reports on that, do you have any real life results on it?<<

I never tried it because from what I read, the problems may not be immediately obvious and since its benefits are questionable I decided not to use it.

You may want to test several apps compiled with O2 and O3 to compare performance.

If you install and uninstall a lot of programs, you may like checkinstall, it will create Slack packages for you which makes uninstall easy. It is in the /extra directory of Slack 9.0
 
Old 03-27-2003, 01:27 AM   #6
bilbod
Member
 
Registered: Mar 2003
Posts: 42

Rep: Reputation: 16
>>`-O2' turns on...frame pointer elimination on machines where doing so does not interfere with debugging<<

It is not turned on unconditionally and adding it does no harm so unless you know for sure that O or O2 turns it on for your machine it would be wise to include it.
 
Old 03-27-2003, 01:28 AM   #7
jatbudhwar
LQ Newbie
 
Registered: Mar 2003
Location: Melbourne, Australia
Distribution: Slackware current
Posts: 4

Original Poster
Rep: Reputation: 0
Quote:
Originally posted by bilbod
>>"-O3 -march=athlon-xp -mcpu=athlon-xp"<<

="-O2 -s -fomit-frame-pointer -march=athlon-xp"

I think if you use -march switch you only need mcpu if they are different.

>>About the -03, i read some conflicting reports on that, do you have any real life results on it?<<

I never tried it because from what I read, the problems may not be immediately obvious and since its benefits are questionable I decided not to use it.

You may want to test several apps compiled with O2 and O3 to compare performance.

If you install and uninstall a lot of programs, you may like checkinstall, it will create Slack packages for you which makes uninstall easy. It is in the /extra directory of Slack 9.0
Thanks mate, will give it a go.
 
Old 03-27-2003, 03:18 AM   #8
crashmeister
Senior Member
 
Registered: Feb 2002
Distribution: t2 - trying to anyway
Posts: 2,541

Rep: Reputation: 47
You should add -pipe to your flags to get it to compile a little faster.
Most sane flags get set by the CPU and O options.Don't worry about the kernel - it will override your settings anyway when you compile it.So will many other apps.
There are some things that might not work if compiled with CPU flags.
 
Old 03-27-2003, 05:35 AM   #9
unSpawn
Moderator
 
Registered: May 2001
Posts: 27,709
Blog Entries: 54

Rep: Reputation: 2966Reputation: 2966Reputation: 2966Reputation: 2966Reputation: 2966Reputation: 2966Reputation: 2966Reputation: 2966Reputation: 2966Reputation: 2966Reputation: 2966
Here's a good Freshmeat article on GCC (3) flags: GCC Myths and Facts. It's got good notes on optimization level flags.
 
Old 04-07-2003, 08:00 PM   #10
xcourse
LQ Newbie
 
Registered: Apr 2003
Location: Madison,WI
Distribution: SuSE, Gentoo
Posts: 9

Rep: Reputation: 1
Use either -march or -mcpu, but not both. The difference in them is that -march compiles explicitly for your particular processor, such as athlon-xp or pentium3 (or 4 or 2, etc). If you were to pull out the athlon-xp and plug in an early duron, you'd have problems. With -mcpu, you could pull out the pentium-whatever and plug in an earlier model (assuming socket-compatibility) and your system would still function.

"-march"-optimized systems are more closely tuned to your particular setup, and don't particularly have any problems compiling (at least I never ran into any with Gentoo, whether using "-O2 -pipe" or "-O3 -pipe".

I think if both are uncommented, it'll still compile, only it'll use "-mcpu", which will result in a slight performance hit.
 
  


Reply


Thread Tools Search this Thread
Search this Thread:

Advanced Search

Posting Rules
You may not post new threads
You may not post replies
You may not post attachments
You may not edit your posts

BB code is On
Smilies are On
[IMG] code is Off
HTML code is Off


Similar Threads
Thread Thread Starter Forum Replies Last Post
Identifying CPU/Architecture for GCC Optimisations detly Linux - Hardware 3 04-27-2005 10:44 PM
Modem Speed - linux vs. windows, and how to optimise furryspider Linux - Networking 7 04-07-2005 03:43 PM
How Optimise Kernel for my AthlonXP Mandrake 10.1 system?? carl0ski Mandriva 1 12-31-2004 03:07 AM
Easy editor to optimise an mpeg for web streaming? wolfpeach Linux - Software 0 07-27-2004 12:04 PM
GCC has option for Xeon cpu ??? xudeyong Programming 1 05-22-2003 02:56 PM


All times are GMT -5. The time now is 03:57 AM.

Main Menu
Advertisement
My LQ
Write for LQ
LinuxQuestions.org is looking for people interested in writing Editorials, Articles, Reviews, and more. If you'd like to contribute content, let us know.
Main Menu
Syndicate
RSS1  Latest Threads
RSS1  LQ News
Twitter: @linuxquestions
identi.ca: @linuxquestions
Facebook: linuxquestions Google+: linuxquestions
Open Source Consulting | Domain Registration