2.2. How to NOT use Assembly2.2.1. General procedure to achieve efficient codeAs Charles Fiterman says on
comp.compilers
about human vs computer-generated assembly code: The human should always win and here is why.
First the human writes the whole thing in a high level language.
Second he profiles it to find the hot spots where it spends its time.
Third he has the compiler produce assembly for those small sections of code.
Fourth he hand tunes them looking for tiny improvements over the machine generated code.
The human wins because he can use the machine.
2.2.2. Languages with optimizing compilersLanguages like ObjectiveCAML, SML, CommonLISP, Scheme, ADA, Pascal, C, C++,
among others, all have free optimizing compilers
that will optimize the bulk of your programs,
and often do better than hand-coded assembly even for tight loops,
while allowing you to focus on higher-level details,
and without forbidding you to grab
a few percent of extra performance in the above-mentioned way,
once you've reached a stable design.
Of course, there are also commercial optimizing compilers
for most of these languages, too! Some languages have compilers that produce C code,
which can be further optimized by a C compiler:
LISP, Scheme, Perl, and many other.
Speed is fairly good. 2.2.3. General procedure to speed your code upAs for speeding code up,
you should do it only for parts of a program
that a profiling tool has consistently identified
as being a performance bottleneck. Hence, if you identify some code portion as being too slow, you should
first try to use a better algorithm; then try to compile it rather than interpret it; then try to enable and tweak optimization from your compiler; then give the compiler hints about how to optimize
(typing information in LISP; register usage with GCC;
lots of options in most compilers, etc). then possibly fallback to assembly programming
Finally, before you end up writing assembly,
you should inspect generated code,
to check that the problem really is with bad code generation,
as this might really not be the case:
compiler-generated code might be better than what you'd have written,
particularly on modern multi-pipelined architectures!
Slow parts of a program might be intrinsically so.
The biggest problems on modern architectures with fast processors
are due to delays from memory access, cache-misses, TLB-misses,
and page-faults;
register optimization becomes useless,
and you'll more profitably re-think data structures and threading
to achieve better locality in memory access.
Perhaps a completely different approach to the problem might help, then. 2.2.4. Inspecting compiler-generated codeThere are many reasons to inspect compiler-generated assembly code.
Here is what you'll do with such code:
check whether generated code
can be obviously enhanced with hand-coded assembly
(or by tweaking compiler switches) when that's the case,
start from generated code and modify it
instead of starting from scratch more generally, use generated code as stubs to modify,
which at least gets right the way
your assembly routines interface to the external world track down bugs in your compiler (hopefully the rarer)
The standard way to have assembly code be generated
is to invoke your compiler with the -S flag.
This works with most Unix compilers,
including the GNU C Compiler (GCC), but YMMV.
As for GCC, it will produce more understandable assembly code with
the -fverbose-asm command-line option.
Of course, if you want to get good assembly code,
don't forget your usual optimization options and hints! |
|