| << Chapter < Page | Chapter >> Page > |
COMMON /USELESS/ KDO K=1,1000
IF (K .EQ. 1) CALL AUXENDDO
In this example, K has been declared as a
COMMON variable. It is used only as a do-loop counter, so there really is no reason for it to be anything but local. However, because it is in a
COMMON block, the call to
AUX forces the compiler to store and reload
K each iteration. This is because the side effects of the call are unknown.
So far, it looks as if we are preparing a case for huge main programs without any subroutines or functions! Not at all. Modularity is important for keeping source code compact and understandable. And frankly, the need for maintainability and modularity is always more important than the need for small performance improvements. However, there are a few approaches for streamlining subroutine calls that don’t require you to scrap modular coding techniques: macros and procedure inlining.
Remember, if the function or subroutine does a reasonable amount of work, procedure call overhead isn’t going to matter very much. However, if one small routine appears as a leaf node in one of the busiest sections of the call graph, you might want to think about inserting it in appropriate places in the program.
Macros are little procedures that are substituted inline at compile time. Unlike subroutines or functions, which are included once during the link, macros are replicated every place they are used. When the compiler makes its first pass through your program, it looks for patterns that match previous macro definitions and expands them inline. In fact, in later stages, the compiler sees an expanded macro as source code.
Macros are part of both C and FORTRAN (although the FORTRAN notion of a macro, the
statement function , is reviled by the FORTRAN community, and won’t survive much longer).
The statement function has been eliminated in FORTRAN 90. For C programs, macros are created with a
#define construct, as demonstrated here:
#define average(x,y) ((x+y)/2)
main (){
float q = 100, p = 50;float a;
a = average(p,q);printf ("%f\n",a);
}
The first compilation step for a C program is a pass through the C preprocessor,
cpp . This happens automatically when you invoke the compiler.
cpp expands
#define statements inline, replacing the pattern matched by the macro definition. In the program above, the statement:
a = average(p,q);
gets replaced with:
a = ((p+q)/2);
You have to be careful how you define the macro because it literally replaces the pattern located by cpp . For instance, if the macro definition said:
#define multiply(a,b) (a*b)
and you invoked it as:
c = multiply(x+t,y+v);
the resulting expansion would be
x+t*y+v — probably not what you intended.
If you are a C programmer you may be using macros without being conscious of it. Many C header files ( .h ) contain macro definitions. In fact, some “standard” C library functions are really defined as macros in the header files. For instance, the function getchar can be linked in when you build your program. If you have a statement:
#include<stdio.h>
Notification Switch
Would you like to follow the 'High performance computing' conversation and receive update notifications?
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|