7 Optimizing Your Project

If you program is running slower than you expected, or is using more memory or disk space than you expected, you should first examine the approach you used in your Ada source code. Can you use better data structures, or implement faster algorithms? For example, a bubble sort is an easy way to sort relatively small amounts of data, but a quick sort is faster on thousands or millions of pieces of data.

In large programs, the subprogram causing the biggest bottlenecks may not be obvious. Experimenting with different test data and timing the results can often narrow down the problem areas. You could also try the gprof profiling tool, which will give you statistics on your program performance and will show that you are on the right track. Why spend hours or days improving a section of your program that isn't causing the problem? This is especially important in a business environment: focus your time on the sections that will give the greatest improvements.

Some optimizations can be done automatically by the Gnat compiler. There are both compiler switches and language pragmas for fine tuning your programs.

7.1 Compiler Optimization Options

The -O switch tells the compiler how much time it should spend optimizing the program:

• No -O - fastest compiling, but gives you gnat warnings for optimization pragmas. Use only when fast compiling is essential.
• -O/-O1 - slower compiling, cleaner executable, and no pragma optimize warnings from gnat. You should normally include this.
• -O2 - more optimization. Use this for the smallest executable.
• -O3 - full optimization, automatic code inlining for small subprograms and loop unraveling. Use this for the fastest executable.

When using floating point numbers, you may experience rounding errors if you don't use the -ffloat-store switch as discussed in 8.5.

Inlining is also affected by two other switches:

• -gnatn - allow inlining between packages where pragma inline is used in a package specifications.
• -gnatN - allow automatic inlining between packages (this is very memory intensive)
• No -gnatn/N - no inlining between packages, even if a pragma inline is used in a package specification.

These switches both require a -O switch for inlining to take effect.

There are some other gcc optimization switches which can sometimes be used:

-ffast-math - gcc will ignore certain ANSI & IEEE math rules. For example, it will not check for negative numbers before invoking the sqrt function. This improves math performance but can cause side- effects for libraries expecting the ANSI/IEEE rules to be honoured.

-fomit-frame-pointer - gcc will free the register usually dedicated to hold the stack frame pointer. This improves performance, but makes debugging difficult--many debugging utilities require the frame pointer.

7.2 Gnat Source Optimization Options

Pragma Pack compresses an array, record or tagged record so that it uses the minimum space possible. For example, a packed boolean array takes up one bit for each boolean. Pack only packs the aggregate, not any aggregate items that might make up the aggregate: if you have an array of records, you'll need to both pack the array and the records to use the minimum space possible. Packing aggregates usually slows down the execution of your program.

type CustomerProfile is record
  Preferred : boolean;
  PreordersAllowed : boolean;
  SalesToDate : float;
end record;
pragma Pack( CustomerProfile );

Pragma Optimize specifies how you want your statements to be optimized: to run as fast as possible (time), to be as small as possible (space), or no optimization at all. Optimize does not affect data structures.

pragma Optimize ( space );
package body AccountsPayable is

procedure Increment( x : integer ) is
begin
  x := x + 1;
end Increment;
pragma Inline( Increment );

Compiling switch -O3 must be used or pragma inline is ignored. -O3 will also automatically inline short subprograms for you.

Pragma Inline_Always forces inlining between packages (like -gnatn) regardless of whether or not -gnatn or -gnatN has been used.

Pragma Discard_Names frees up space by discarding the ASCII images (names) of identifiers. For example, if you have a big enumerated type, Ada normally maintains strings for the names of each of the enumerated items in case you want to use the 'img attribute. You can discard these names if you never intend to use 'img.

type aDogBreed is (Unknown, Boxer, Shepherd, MixedBreed );
pragma Discard_Names( aDogBreed );

When you discard names, the 'img is still available. Instead of returning the enumerated value's image, 'img returns the position of the enumerated type (for example, 0, 1, 2 and so forth).

7.3 CPU Optimization Options

-mno-486 - optimize for 80386.
-m486 - optimize for 80486. These programs will still run on a 80386.

Future versions of Gnat built for GCC 3.x or later will probably support: -mpentium - optimize for Pentium / Intel 586 -mcpu=i686 - optimize for Pentium II/ Intel 686 -mcpu=k6 - optimize for AMD K6

There are currently no switches newer CPUs such as Pentiums. Under GCC 2.8.1 (and Gnat), the GCC FAQ recommends the following switches for reasonable Pentium performance: "-m486 -malign-loops=2 -malign-jumps=2 -malign-functions=2 -fno-strength-reduce".

There are other switches that may or may not be helpful, depending on your program: read the gcc FAQ for full details.

Let's put all these flags together. Suppose you are trying to develop a program for the Intel Pentium CPU with an emphasis on speed. During development, the Gnatmake switches would be "-O1" since this setting suppresses pragma optimize warnings. For the final release, the Gnatmake switches should be "-m486 -O3 -malign-loops=2 -malign-jumps=2 -malign-functions=2 -fno-strength-reduce -gnatp" for maximum performance on a Pentium processor.
 

7.4 What Difference Does Optimization Make?

In the previous sections, we saw GCC compiler switches and and Ada pragmas that affect the speed and size of your finished application. But how much of a difference does optimization make? And are there any problems caused by optimization?

The optimization switches and pragmas affect different applications differently. Some will give better results to certain kinds of applications, while others may actually have a negative effect. The following table summarizes the results of optimizing on the Hartstone Ada benchmark program. Hartstone is a multithreading mathematics test available freely on the Internet http://ftp.sunet.se/pub4/benchmark/hartstone/.

Table: Hartstone 1.1 Benchmark Summary

Pent - GCC Pentium optimization switches
Max - Pent + -ffast-math + -fomit-frame-pointer
This test was conducted with a Pentium II 350, 64 Megs RAM and ALT Gnat 3.12p-9. As they say, your milage many vary (and probably will).

By optimizing the application, Hartstone can be reduced to half its size and run about 2/3 faster than using no optimization. However, if we pack the arrays in Hartstone, we save two bytes but lose all the improvements in speed. Sometimes smaller programs are not faster.

Let's try optimizing a convoluted program that uses integers, arrays, functions and mathematics and see what effect the optimization techniques have.

procedure bench is

  --Simple benchmark program to test optimization

  pragma optimize( time );

  type bench_integer is new long_integer range long_integer'range;
  type small_integer is new long_integer range 0..9;

  function p( param : bench_integer ) return bench_integer is
    divideby : constant bench_integer := 4;
  begin
    return param / divideby;
  end p;
  pragma inline( p );

  j : bench_integer := bench_integer'last;

  -- deliberate error in main program for j * 2

  type atype is array(0..9) of small_integer;
  --pragma pack( atype);

  a : atype;

begin

  for i in 1..100_000_000 loop

    j := abs( p( bench_integer( i ) ) - (j * 2) );
      a( integer( j mod 10 ) ) := small_integer( j mod
      bench_integer( small_integer'last) );

  end loop;

end bench;

Notice that j is assigned the largest bench_integer possible. This will force an overflow error the first time around the for loop, when j is multiplied by two. The following chart shows the effect of the different switches and pragmas, and indicates when gnat caught the overflow error. The test was conducted on a Pentium II 350 with 64 Megs of RAM using the gnat 3.11 NYU binaries and was timed with the time command.

We can compare the results to the equivalent C program:

int p( int param ) {
  return param / 4;
}

int i;
int j = 2147483647;
int a[10];
int main() {
  for (i=1; i<=100000000; i++) {
    j = abs( p(i)-(j*2));
    a[ j%10 ] = j%10;
  }

  return 0;
}

In this case, notice that C never detected the overflow error. Secondly, notice that the Ada program ran twice as fast as the C program.

In theory, an Ada compiler can take advantage of the typing information and the optimization hints provided by the pragmas. The C compiler has less information and this can hinders the optimization process. (I've never investigated whether or not Gnat does this or how much of an effect it has.)

The optimization techniques will affect different programs differently. You need to chose the best approach for your particular project.

7.5 Working with the Assembly Source

The Linux assembler is called gas (the GNU assembler). Like GNAT and C++, gas works through gcc. To assemble an assembly language source file, simply run gcc. The compiler will recognize the assembly language file and will assemble it using gas.

If you want to view the assembly source code of your Ada program, use the "-c -S -fverbose-asm" options when compiling. GNAT will create a file with a ".s" suffix containing the assembly source. You can view it, or even edit it and assemble afterwards. Improving the instructions produced by the compiler and then assembling afterwards is known as hand optimizing. This technique is typically used for high performance applications such as games, where the programmer needs to get the maximum performance from the hardware.

The following is the stderr.s file for the stderr.adb program described elsewhere in this document.

.file"stderr.adb"

See Chapter 19 for a discussion of embedding assembly language into an Ada program.