Is there a way to avoid use of static variable in a callback function?

Question

I need to define a function which will be called several times by a 3rd-party function. This external library has defined the prototype of the callback as:

typedef void (*fn) (const int *m, const int *n, const double *x, double *fvec, int *iflag );

First two args are size, 3rd is an input array, 4th is an output array, and last one is reserved for the parent function.

Now, my concern is that my function needs other data to perform the computation, and there is no way in this prototype to get user-data. Simply speaking, let's assume that the 3rd-party library exports such a function:

int makeSomeComputation(fn user_function, const int *m, const int *n, double *x, double *fvec, int *info, ...);

(There may be more arguments, let's pass over them). So in my code, I am supposed to do something like that:

void myFunc(const int *m, const int *n, const double *x, double *fvec, int *iflag) {
     //do something here
}
//and in another function
{ //...
    makeSomeComputation(myFunc, &m, &n, &x, &fvec, &info, ...);
}

As you see, there is no dedicated way to pass user-data (or user-callback).

I am quite reluctant to use static variables here because some day I may want to use my code in a multithreaded / distributed environment.

Is there another option?

Note: the 3rd-party is actually open-source, so I think I will change the library to add an extra parameter, but I don't like that neither.

Answer 1

You can create set of functions - different only in a global(might be static) variable they use.

void fn_implementation(const int *m, const int *n, const double *x, double *fvec, int *iflag, TheDataTypeYouNeed* theDataYouNeed)
{
 /* implementation */
}

Having this - in every file you can create necessary set of wrapper to fn_implementation functions, e.g. by these macros:

#define FN(global) fn_##global
#define DEFINE_FN(global) static void FN(global)(const int *m, const int *n, const double *x, double *fvec, int *iflag){ \
     fn_implementation(m, n, x, fvec, iflag, &global); \
     }

And use like this:

static TheDataTypeYouNeed global1;
static TheDataTypeYouNeed global2;

DEFINE_FN(global1);
DEFINE_FN(global2);

int main() {
     global1.x = 7;
    callLibrary(&FN(global1));
     global2.x = 6;
    callLibrary(&FN(global2));

}

Regarding many threads access - consider to use pthread_key. There are also some compiler extensions - like __thread in gcc

Answer 2

A pointer to a structure object, suitably converted, points to its initial member, so you can pass a pointer to int and then (in your callback) cast to your struct (containing more data):

#include <stdio.h>

struct cont {
    int iflag;
    char *more;
};

static void func(int *a, int *iflag)
{
    struct cont *b = (struct cont *)iflag;

    printf("%d\n", *a);
    printf("%d\n", b->iflag);
    printf("%s\n", b->more);
}

int main(void)
{
    int a = 5;
    struct cont b = {1, "Hello"};

    func(&a, (int *)&b);
    return 0;
}

Answer 3

When you allocate space for x, allocate more than it needs.

Instead of x = malloc(sizeOfDataNeededBy3rdParty);, write: x = malloc(sizeOfDataNeededBy3rdParty + sizeOfExtraDataIWantToPassToMyFunc);

You can put whatever data you want into the extra space appended to data required by 3rd-party.

Be careful not to break strict aliasing rules. You probably need to use memcpy to copy extra data into x, and also to copy the extra data out from x.