Performance question/debugging

[razael1]

I am putting debugging messages into my program by putting blocks that
look like this:
#ifdef DEBUG
errlog << "Here is some information";
#endif

All these #ifdef blocks make the code bulky and harder to read, so I'd
like to do something where I put:
errMsg("Here is some information");

and then in a library:
void errMsg(string error)
{
#ifdef DEBUG
errlog << error;
#endif
}

My question is how this would affect the performance of the program.
Are compiler optimizers (specifically the GNU compiler) smart enough to
not spend CPU cycles calling this function and passing the argument
when DEBUG isn't defined, since the function does absolutely nothing?
Also, is there an elegant way to get rid of the "unused parameter"
warning.

I'd be interested to hear how others deal with putting debugging info
like this into their programs.

Thanks,
Colin

[Ian Collins]

ra*****@gmail.com wrote:

I am putting debugging messages into my program by putting blocks that
look like this:
#ifdef DEBUG
errlog << "Here is some information";
#endif

All these #ifdef blocks make the code bulky and harder to read, so I'd
like to do something where I put:
errMsg("Here is some information");

and then in a library:
void errMsg(string error)

Better to use const std::string&.

{
#ifdef DEBUG
errlog << error;
#endif
}

My question is how this would affect the performance of the program.
Are compiler optimizers (specifically the GNU compiler) smart enough to
not spend CPU cycles calling this function and passing the argument
when DEBUG isn't defined, since the function does absolutely nothing?
Also, is there an elegant way to get rid of the "unused parameter"
warning.

Most, if not all current compilers will inline and thus remove an empty
function.

I'd be interested to hear how others deal with putting debugging info
like this into their programs.

Either the way you have done it, or by creating a specialised stream.

--
Ian Collins.

[Phlip]

razael1 wrote:

>I am putting debugging messages into my program by putting blocks that
look like this:
#ifdef DEBUG
errlog << "Here is some information";
#endif

All these #ifdef blocks make the code bulky and harder to read, so I'd
like to do something where I put:
errMsg("Here is some information");

One way to do this is via macro abuse. There are other ways, with different
trade-offs. I would not use the following for the log of a server program.
That should be a complete subsystem.

Debugging traces must be absurdly easy to write, because you must belt them
out while in the throws of debugging, without their details distracting you.
So try this:

#ifndef DEBUG_
# ifdef _DEBUG // this helper makes irritations go away when we are not
debugging
# define DEBUG_(Q_) Q_
# else
# define DEBUG_(Q_)
# endif
#endif

That uses a platform that defines _DEBUG. You might also switch based on the
Standard !defined(NDEBUG).

#ifdef _DEBUG
# define SOURCE__ __FILE__ "(" << __LINE__ << "): "
# define SPEW(x) (std::cout << SOURCE__ "TRACE - " #x ": " << x <<
std::endl)
#endif

That outputs a line in the same format as a Visual Studio error message
(following the coding practice "assertion failures are syntax errors").

At debug time, you can write this:

SPEW(bigObject << " shouldn't be " << stringFoo);

The operator<< will put anything into the trace, not just strings. Anything
with an operator<<.

The SPEW() disappears when you compile for release. This is a feature. It's
to remind you to take the SPEW() out, and not rely on it for too long.

If you need to commit your code with a SPEW() in it, use
DEBUG_(SPEW(whatever)).

My question is how this would affect the performance of the program.

Your code, which I snipped, would be slow, not because the inside of the
function could go away, but because the calling site of the function could
assemble a string from parts, expensively.

In release mode, you could instead #define errMsg(x) as nothing.

Also, is there an elegant way to get rid of the "unused parameter"
warning.

error=error just inside the function. Or this:

void errMsg(string DEBUG_(error))

My evil ugly DEBUG_() macro allows you write code that is either slick, or
trick. Avoid the latter, because when debugging code differs too far from
production code, you could catch "debugitis", which is bugs caused by
debugging too much.

/The C++ Programming Language, 3rd Ed/ by Bjarne S. contains an alternative
that uses a template, and is closer to a log system than a debugging trace
system. Also study that. I didn't, so it might improve my macro abuse.

--
Phlip
http://c2.com/cgi/wiki?ZeekLand <-- NOT a blog!!!

[razael1]

I'm now trying to do this using inline functions, but I've run into
some problems. Here is a simplified version of what I have:

debug.h:
#ifdef DEBUG_H
#define DEBUG_H

#include <fstream>

static std::ofstream errlog;

void startDebug( )
{
#ifdef DEBUG
errlog.open("error.log");
errlog << "Starting log" << endl;
#endif
}

void endDebug()
{
#ifdef DEBUG
errlog << "Program exited normally" << endl;
errlog.close();
#endif
}

void errMsg(std::string& message)
{
#ifdef DEBUG
errlog << message << endl;
#endif
}

#endif

main.cpp:
#include "debug.h"
#include "func.h"
void main( )
{
startDebug( );
func();
endDebug();
}

func.cpp:
#include "debug.h"

void func( )
{
errMsg("Error");
}
I hope I haven't simplified this so far that I've gotten rid of the
error. After running my program, the message log contains "Starting
log" and "Program exited normally", but does not contain any of what
should have been written by the errMsg() function.

Thanks,
Colin

[razael1]

[e-mail] wrote:

I'm now trying to do this using inline functions, but I've run into
some problems. Here is a simplified version of what I have:

debug.h:
#ifdef DEBUG_H
#define DEBUG_H

#include <fstream>

static std::ofstream errlog;

void startDebug( )
{
#ifdef DEBUG
errlog.open("error.log");
errlog << "Starting log" << endl;
#endif
}

void endDebug()
{
#ifdef DEBUG
errlog << "Program exited normally" << endl;
errlog.close();
#endif
}

void errMsg(std::string& message)
{
#ifdef DEBUG
errlog << message << endl;
#endif
}

#endif

main.cpp:
#include "debug.h"
#include "func.h"
void main( )
{
startDebug( );
func();
endDebug();
}

func.cpp:
#include "debug.h"

void func( )
{
errMsg("Error");
}
I hope I haven't simplified this so far that I've gotten rid of the
error. After running my program, the message log contains "Starting
log" and "Program exited normally", but does not contain any of what
should have been written by the errMsg() function.

Thanks,
Colin

In my code above, I forgot to 'inline' all the functions in debug.h.

[razael1]

In my code above, I forgot to 'inline' all the functions in debug.h.

[Ian Collins]

ra*****@gmail.com wrote:

[e-mail] wrote:

>>I'm now trying to do this using inline functions, but I've run into
some problems. Here is a simplified version of what I have:

You should try and post something that compiles and exhibits the problem
you are trying to solve.

>>debug.h:
#ifdef DEBUG_H
#define DEBUG_H

#include <fstream>

static std::ofstream errlog;

This should be an extern and defined in a cc file.

>>void startDebug( )
{
#ifdef DEBUG
errlog.open("error.log");
errlog << "Starting log" << endl;

Missing std::

>>#endif
}

void endDebug()
{
#ifdef DEBUG
errlog << "Program exited normally" << endl;

Missing std::

>>errlog.close();
#endif
}

void errMsg(std::string& message)

Missing const

>>{
#ifdef DEBUG
errlog << message << endl;
#endif
}

#endif

main.cpp:
#include "debug.h"
#include "func.h"
void main( )

main() return int.

>>{
startDebug( );
func();
endDebug();
}

func.cpp:
#include "debug.h"

void func( )
{
errMsg("Error");
}
I hope I haven't simplified this so far that I've gotten rid of the
error. After running my program, the message log contains "Starting
log" and "Program exited normally", but does not contain any of what
should have been written by the errMsg() function.

You probably have, when fixed, the posted code would work correctly.
Did you compile both source files with DEBUG defined?

--
Ian Collins.

[Phlip]

razael1 wrote:

>void main( )

'void main' will make you regress to the late 1990s. Use 'int main'.

Next, debug statements, like my SPEW() system, are just that - for
debugging. If you leave these statements in your code, but don't turn them
into a proper log system (with a different architecture), then you are using
Debugger Driven Programming.

And that, in turn, is a sign you should be using Test Driven Programming.
That way, all the stuff you expect these errMsg() calls to tell the
programmer, you could instead tell to a test case. And it would read the
results for you, automatically, and only report to _you_ if there's some
descrepancy.

Look up TDD, and you will see what I mean. You are putting your energies in
the wrong direction. TDD is widely reported to prevent excessive debugging.

--
Phlip
http://c2.com/cgi/wiki?ZeekLand <-- NOT a blog!!!

[Frederick Gotham]

My question is how this would affect the performance of the program.

If your compiler is half-decent, then any empty functions will be vapourised.

However, if you want to be doubly sure, then move the #ifdef outside of the
function:

#ifdef NDEBUG
#define errMsg(str) /* Nothing */
#else
#define errMsg(str) (errlog << (str))
#endif
--

Frederick Gotham