AND OPTIMIZATION OF EXCUTION TIME, POWER, NRGY , PROGRAM SIZE:
memory footprint of a program is determined by the size of its data and
instructions. Both must be considered to minimize program size.
provide an excellent opportunity for minimizing size because the data are most
highly dependent on programming style. Because inefficient programs often keep
several copies of data, identifying and eliminating duplications can lead to
significant memory savings usually with little performance penalty.
should be sized carefully rather than defining a data array to a large size
that the program will never attain, determine the actual maximum amount of data
held in the buffer and allocate the array accordingly. Data can sometimes be
packed, such as by storing several flags in a single word and extracting them
by using bit-level operations.
low-level technique for minimizing data is to reuse values. For instance, if
several constants happen to have the same value, they can be mapped to the same
location. Data buffers can often be reused at several different points in the
program. This technique must be used with extreme caution, however, since
subsequent versions of the program may not use the same values for the
generally applicable technique is to generate data on the fly rather than store
it. Of course, the code required to generate the data takes up space in the
program, but when complex data structures are involved there may be some net
space savings from using code to generate data.
the size of the instruction text of a program requires a mix of high-level
program transformations and careful instruction selection.
functions in subroutines can reduce program size when done carefully. Because
subroutines have overhead for parameter passing that is not obvious from the
high-level language code, there is a minimum-size function body for which a
subroutine makes sense.
that have variable-size instruction lengths are particularly good candidates
for careful coding to minimize program size, which may require assembly
language coding of key program segments. There may also be cases in which one
or a sequence of instructions is much smaller than alternative implementations
for example, a multiply-accumulate instruction may be both smaller and faster
than separate arithmetic operations.
reducing the number of instructions in a program, one important technique is
the proper use of subroutines. If the program performs identical operations
repeatedly, these operations are natural candidates for subroutines.
the operations vary somewhat, you may be able to construct a properly
parameterized subroutine that saves space. Of course, when considering the code
size savings, the subroutine linkage code must be counted into the equation.
There is extra code not only in the subroutine body but also in each call to
the subroutine that handles parameters.. In some cases, proper instruction
selection may reduce code size; this is particularly true in CPUs that use
microprocessor architectures support dense instruction sets, specially
designed instruction sets that use shorter instruction formats to encode the
Thumb instruction set and the MIPS-16 instruction set for the MIPS architecture
are two examples of this type of instruction set. In many cases, a
microprocessor that supports the dense instruction set also supports the normal
instruction set, although it is possible to build a microprocessor that
executes only the dense instruction set.
compilation modes produce the program in terms of the dense instruction set.
Program size of course varies with the type of program, but programs using the
dense instruction set are often 70 to 80% of the size of the standard
instruction set equivalents.