Writing dynamically loadable components in c++

Question

I'm currently working on a program which should perform calculations on a home brewed data structure.

I want to build it in a way that it would be easy to add supported calculations (say, as source files which conform to a predetermined structure).

The problem is that I don't want to load all calculations in advance, because there might be a lot of them. The only mechanism I found which supports dynamic loading of functionality is dlopen, which expects .so files, so in this context, using dlopen means compiling a separate so file for every group of computations.

While I don't see any inherent problem with this design, my spider senses tell me I should verify with the all-knowing-web that it's not utterly stupid. If there are any other suggested ways to do so I'd be glad to hear.

possible duplicate of [What's the simplest way to write portable dynamically loadable libraries in C++?](http://stackoverflow.com/questions/3561022/whats-the-simplest-way-to-write-portable-dynamically-loadable-libraries-in-c) — Lightness Races in Orbit, Apr 06 '11 at 10:22
There are a million dups for this question. like http://stackoverflow.com/questions/2903427/plug-in-architecture-based-c-c-application — Lightness Races in Orbit, Apr 06 '11 at 10:22

score 1 · Accepted Answer · answered Apr 06 '11 at 10:16

Using dlopen() is the most widely used way to load executable code dynamically in an application on POSIX-compatible operating systems. It allows using a modular architecture where optional or rarely used code is only loaded on-demand, which sounds pretty much like what you need.

I would certainly use this method - if after some time you find that the shared object compilation step is becoming a hurdle, you can build additional dynamically loaded modules to support e.g. an interpretted language such as Lua or Python. This would allow you to keep your existing codebase without losing in extensibility.

This is actually the plan. I want to use cython to have python scripts call and run my code. — Shai Deshe, Apr 06 '11 at 10:25

score 1 · Answer 2 · answered Apr 06 '11 at 10:22

Seems like a good approach.

A good way to do this is to declare an abstract (pure) class in C++, say Calculator, with all the methods and accessors you need to perform a calculation. Then, have your separate dynamic libraries or .so files implement a global function Calculator * create_calculator() that creates an instance of a class that derives from Calculator. Finally, you'll have to devise a registration mechanism so that your main program can determine the name of the dynamic library to load, based on some kind of identifier like a string , enum, or uuid. This would typically be available as a easily editable configuration file.

void    *handle;
int     (*create_calculator)();

/* open the needed object file */
char    *libName = get_lib_name_from_config(identifier);
handle = dlopen(libName, RTLD_LOCAL | RTLD_LAZY);

/* find the address of create_calculator function */
create_calculator = (*(Calculator*)()) dlsym(handle, "create_calculator");
Calculator * calc = create_calculator();

This scheme can be made more flexible (and complex) by allowing the create_calculator method name to vary, at the cost of having to obtain that from the config file as well.

score 0 · Answer 3 · answered Apr 06 '11 at 10:13

0

Opening shared libraries using dlopen() is certainly the first thing that comes to my mind; it's a fine plan.

answered Apr 06 '11 at 10:13

Ernest Friedman-Hill

80,601
10
150
186

Writing dynamically loadable components in c++

3 Answers3