Mac Forum / Programming / CodeWarrior / November 2004

I frankly admit that I'm out of my depth on this one.

I have a C++ (PP, Carbon, *not* Mach-O) app with some highly optimized
matrix manipulations in it (because the runtime can be long).  I noticed
recently that the runtime had increased by nearly 1/3 for no apparent
reason.

Using the profiler, I tracked down what seemed to be the bottleneck but
that function was unchanged in a old/fast vs. new/slow compilation of
the app.  Even the assembly was identical.

The function in question has the following prototype:

void transposeProduct4(double *G, int Nrows, double *C);

Here, G and C reference the beginning of fixed-length arrays defined in
the private portion of the class which is instantiated just once.

After considerable floundering, I was finally able to decrease the
runtime back to what it had been formerly by removing these two arrays
from the object and declaring them as static arrays at the top of the
module where they are used (and, thus, local to the module).  Otherwise,
the new/fast vs. new/slow code is identical.

Apparently, the mysterious runtime increase was somehow due to the
accessing of the addresses of these arrays, not to the subsequent matrix
computation.

Can anyone clue me in as to why this should be?  Is there some basic
fact that I am missing here?

TIA.

Note:
a) In the old/fast code, the G and C arrays are still in the object.
b) The executables are of different sizes: old/fast = 1,074,706 bytes
and new/fast = 1,112,900 bytes due to other additions.

--
Mike McLaughlin