Question

I am trying to write a program where I have to call some functions through a (shared) library (its source is available). The C code for the library has several global variables, and many functions change the values of these global variables. What I have to do in my program requires that each function call that I make gets to work with a fresh set of variables.

For example, let this function be a part of the library:

int x = 1;

int foo()  
{  
    int a = 0;
    //do somethings to 'a'
    //...
    x++;
    return a;
}  

Now every time I invoke foo() from my program, the value of x gets update from 1 to 2 then 3 then 4 and so on… I am try to construct a program so that every time foo() is invoked, it sees x = 1.

I am sorry to say that my knowledge of how C/linux treat these variable spaces is insufficient, so this question may seem vague. The above is just a small example; in reality, there are so many variables that is practically impossible to reset their values manually.

What may be the best way to compile that library and/or use it my program so as to refresh the variables?

(On a side note, what I am also trying to do is to parallelize calls to foo(), but because of the shared variables, I cannot do that.)

EDIT:
When working on some web dev projects, I used to encapsulate some code in webservices and then invoke those services from the main program. Does a similar framework exist in C/Linux? Please note that functions are returning data.

Answer 1

You have discovered one of the main reasons that global variables (or global state in general) are a really bad idea.

Since you have access to the source, I would suggest investing some time to refactor the source code.

You can achieve the ability to parallelize calls to foo with the following strategy:

• Gather up all of the global variables into a single struct. Call it something like Context.
• Change each function that acts on a global variable to take a pointer to a Context, and change the function to update the variables in the Context instead of updating global variables.
• Now each thread that wants to use the library can create a new Context and pass that into foo and related functions.

If it’s not feasible to make such a change to the source code, you can use more than one CPU core by starting child processes. Each child process has it’s own memory space. That option is not nearly as efficient as using multiple threads.