views:

411

answers:

4

I am running Linux, and I would like to be able to make parallel function calls into a shared library (.so) which is unfortunately not threadsafe (I am guessing it has global datastructures).

For performance reasons, I do not want to simply wrap the function calls in a mutex.

What I would like to do is to spawn, say 4 threads, and also load 4 copies of the same library into the process memory. Each thread then makes the function calls into its own copy of the library.

Unfortunately, dlopen does not allow me to load more one instance of any library.

Does anyone know of any method which will allow me to load the library more than once? (Other than making 4 copies of the .so file, each with a different name)

+5  A: 

Instead of using threads, you can use multiple processes, each doing some of the work. This is very common on *nix, and is usually easier to code.

Roger Pate
I don't know about easier to code. Sure, it's mildly easier to call `fork()` then it is to launch a thread. But if you need to communicate between processes, or share data between processes then you get into the world of IPC, (shared memory, pipes, etc.), which is arguably more complicated to code.
Charles Salvia
For starters, it's easier to use his non-thread-safe library. :) I find it easier to code because it's easier to avoid deadlocks and related problems, but, yes, they have their versions in IPC too.
Roger Pate
@Charles - given the OP's objective, going to multiple processes is probably his least painful option.
Michael Kohne
@Charles: All depends of the amount of shared data between your threads/processes. The good thing with using processes is that it leads to good program design with a well controled communication system. The apparent simplicity with thread is quite often poor design.
kriss
Boost.Interprocess helps greatly to share memory... but of course ideally you would like to just give the process a copy of its own and just wait for the result.
Matthieu M.
+2  A: 

Looks like a bad idea. That is no more possible with shared libraries as it would be with static ones.

You could probably use dlopen() with RTLD_LOCAL flag so that subsequent calls to dlopen won't see it's allready loaded and make it work as you want... but it still looks like a bad design idea. If you have performance issues it would be better avoiding to clutter memory with several copies of the same library.

I would suggest either using several processes or going the mutex way, it's probably more efficient.

As you work on Linux there also may exists other approaches if you can access the source code of the library, like renaming it's symbols to have as many separate instances as needed... Well, once you get the source there may be other ways, like making the library thread safe.

kriss
+1  A: 

What library is it? Is it something large? I'm wondering if you couldn't fix the library to be threadsafe in some way, then build your code using the threadsafe version of the library. It depends on the size of the library, and what's wrong with it, but if you could fix the library, you'd be able to build your app the way you want, as well as help everyone else out.

Michael Kohne
+2  A: 

You can load multiple independent copies of the library like this:

#define _GNU_SOURCE
#include <dlfcn.h>
...
void *handle = dlmopen(LM_ID_NEWLM, "/path/to/library.so", RTLD_NOW);

More info here.

Employed Russian