Habitual optimization

From:

"Steven T. Hatton" <hattons@globalsymmetry.com>

Newsgroups:

comp.lang.c++.moderated

Date:

20 Dec 2006 08:41:23 -0500

Message-ID:

<qIqdnYexRpxFMxXYnZ2dnUVZ_u2mnZ2d@speakeasy.net>

I have long wondered about certain programming styles/strategies and how
they can impact performance.

I understand that the intent of the examples in _C++ GUI Programming with Qt
4_ is pedagogical and, therefore, they should stress clarity over optimal
efficiency. Nonetheless, the code shown on pg 130 gives me an opportunity
to ask a question about coding strategy in general.

Page 18 of _C++ Coding Standards_ by Sutter and Alexandrescu tells us "It is

not premature optimization to reduce spurious temporary copies of objects,
especially in inner loops, when doing so doesn't impact code
complexity." My question is whether any clock cycles might be saved by
moving some of the arithmetic out of the loops? For example, would anything
be gained by defining:

const int dTick((rect.width() - 1)/settings.numXTicks);

and then writing:

int x = rect.left() + i * dTick;?

Or even `int x(rect.left());' outside the loop, and `x+=dTick'; inside the
loop?

What about calls to functions such as settings.spanX()? If these values are
unchanged during the loop, can anything be gained by assigning them to a
constant before entering the loop?

void Plotter::drawGrid(QPainter *painter)
{
    QRect rect(Margin, Margin,
               width() - 2 * Margin, height() - 2 * Margin);
    if (!rect.isValid())
        return;

    PlotSettings settings = zoomStack[curZoom];
    QPen quiteDark = palette().dark().color().light();
    QPen light = palette().light().color();

    for (int i = 0; i <= settings.numXTicks; ++i) {
        int x = rect.left() + (i * (rect.width() - 1)
                                 / settings.numXTicks);
        double label = settings.minX + (i * settings.spanX()
                                          / settings.numXTicks);
        painter->setPen(quiteDark);
        painter->drawLine(x, rect.top(), x, rect.bottom());
        painter->setPen(light);
        painter->drawLine(x, rect.bottom(), x, rect.bottom() + 5);
        painter->drawText(x - 50, rect.bottom() + 5, 100, 15,
                          Qt::AlignHCenter | Qt::AlignTop,
                          QString::number(label));
    }
//...
}

I'm confident that the first part of any answer to these questions will
be "It depends...". The term "optimizer" will probably arise as well. I
also realize my arithmetic modifications might change the behavior of the
code due to the evaluation order of the multiplicative operations.

One additional question I have deals with for-loops.
std::vector<Object> v;
// fill the vector
for(unsigned i(0); i<v.size(); ++i){
//do something.
}

Is it likely that an optimizer could improve performance if it could
determine that v.size() is unchanged during the loop, and thus eliminate
calls to v.size()?
--
Regards,
Steven

      [ See http://www.gotw.ca/resources/clcm.htm for info about ]
      [ comp.lang.c++.moderated. First time posters: Do this! ]