CODEWITHSUNDEEP
cinstrumentation
Tibor
Tibor

Reputation: 589

Portable instrumentation

GCC has a nice feature about instrumentation which let you call a routine every time a function is called, or every time a function returns.

Now, I want to create my own system to make it portable to other compilers, and also to allow to instrumentalize the functions I want (which can vary in number of parameters), so I was thinking in two macro for both situations. I am thinking in making some kind of profile that it is activated only with a define clause.

#define FUNCT(t,function_name,...)   \
    (t) function_name(...) { \
        (void) *func_pointer = &(function_name); \
        start_data(func_pointer, myclock());

#define RETURN(x) {stop_data(func_pointer, myclock()); return (x);}

FUNCT(BOOL, LMP, const int prof, const int nmo))
    if (nmo <= 5 ||
        prof > (prof_l / 3)) {
        .... do long operations....
        RETURN(FALSE);
    }
    ... do more....
    RETURN(TRUE);
}

but I can’t get it to work. Can someone help me with this? or is this a difficult task to accomplish?

Other alternative that comes to my mind is let the function declare without a macro, and if it is anyway to know the function pointer without knowing its name, something like in VB when you call a Form with Me, with it is a generic alias. is it possible?

Upvotes: 0

Views: 108

Answers (3)

Peter Miehle
Peter Miehle

Reputation: 6070

in addition to Mat, there is a ergonimical problem with using #define RETURN(x) {...}:

if (test)
  RETURN (TRUE);
else
  RETURN (FALSE);

will evaluate to

if (test)
  {...}
;           // <syntactical error
else
  {...}
;

Upvotes: 0

Jens Gustedt
Jens Gustedt

Reputation: 78953

It is much easier to instrument your functions at the calling side instead of the function side. A macro can have the same name as a function. Declare your replacement function somewhere

double myfunc_wrapper(int someArg) {
  double ret = 0;
  // do something before
   ...
  // now call it
  ret = (myfunc)(someArg);

  // Then do something after
  ....
  return ret;
}

Just to be sure put the () arround the call itself to be sure that always a function is called and not a macro.

And then "overload" your function with a macro

#define myfunc(...) mfunc_wrapper(__VA_ARGS__)

with that idea you can replace your function on the fly in the compilation units that interes you.

Upvotes: 1

Mat
Mat

Reputation: 206851

Use gcc -E to debug your macros. Using the code you posted:

$ gcc -E t.c
# ... skip stuff ....

(BOOL) LMP(...) { (void) *func_pointer = &(LMP);
                  start_data(func_pointer, myclock());)
    if (nmo <= 5 ||
        prof > (prof_l / 3)) {
        .... do long operations....
        {stop_data(func_pointer, myclock()); return (FALSE);};
    }
    ... do more....
    {stop_data(func_pointer, myclock()); return (TRUE);};
}

(I added some whitespace to make it readable.)

You can see two problems immediately: function arguments didn't get expanded as you thought they would, and there's an extra ) from somewhere.

To get the expanded variadic arguments, use __VA_ARGS__, not .... The stray ) is at the call site.

So:

#define FUNCT(t,function_name,...)   \
    (t) function_name(__VA_ARGS__) { \
        (void) *func_pointer = &(function_name); \
        start_data(func_pointer, myclock());

#define RETURN(x) {stop_data(func_pointer, myclock()); return (x);}

FUNCT(BOOL, LMP, const int prof, const int nmo)
    if (nmo <= 5 ||
        prof > (prof_l / 3)) {
        .... do long operations....
        RETURN(FALSE);
    }
    ... do more....
    RETURN(TRUE);
}

As to whether this is worth trying (variadic macros came with C99, not all compilers implement that standard, and support might vary from compiler to compiler), I'm not certain. You are probably better off using each compiler's native profiling tools - you'll get better results with hopefully less overhead.

Upvotes: 3

Related Questions