Runtime Dynamic Loading and Singletons

Question

I have a program that uses a singleton. This program loads a shared object library at runtime. This library also makes use of the same singleton. The problem is, that when accessing the singleton from the library, a new instance of the singleton is created.

The program is linked with -rdynamic, I use -fPIC for both and the loading happens like this:

std::shared_ptr<Module> createModuleObject(const std::string& filename)
{
    if (!fs::exists(filename))
        throw std::runtime_error("Library not found: " + std::string(filename));

    struct export_vtable* imports;
    void *handle = dlopen(filename.c_str(), RTLD_LAZY | RTLD_GLOBAL);

    if (handle) {
        imports = static_cast<export_vtable*>(dlsym(handle, "exports"));
        if (imports)
            return std::shared_ptr<Module>(imports->make());
        else 
            throw std::runtime_error("Error trying to find exported function in library!");
    } else
        throw std::runtime_error("Error trying to load library: " + std::string(filename));
}

The library exports a class like this:

Module* make_instance()
{
    return new HelloWorld();
}
struct export_vtable 
{
    Module* (*make)(void);
};
struct export_vtable exports = { make_instance };

and that class makes use of the singleton.

This is how the singleton is created (Configuration.cpp):

std::unique_ptr<Configuration> Configuration::instance_(nullptr);
std::once_flag Configuration::onlyOnceFlag_;

Configuration& Configuration::instance()
{
    if (instance_ == nullptr)
    {
        std::cout << "INSTANCE IS NULL, CREATING NEW ONE" << std::endl;
        std::call_once(Configuration::onlyOnceFlag_,
                    [] {
                            Configuration::instance_.reset(new Configuration());
                       });
    }

    return *Configuration::instance_;
}    

Both the program and the library link against the Configuration.cpp. If I omit that from the library, I get an undefined symbol error when trying to access the singleton.

Anyone got an idea how to solve this? Thank you very much!

Answer 1

Here's how I solved it for https://github.com/kvahed/codeare/blob/master/src/core/ReconStrategy.hpp After having loaded the shared object I assign the instance of the global singleton Workspace to the loaded class in the dll. All classes in https://github.com/kvahed/codeare/tree/master/src/modules are derived from ReconStrategy and in shared objects. The good thing is that this code is portable.

When constructing such a ReconStrategy this happens:

ReconContext::ReconContext (const char* name) {
    m_dlib = LoadModule ((char*)name);
  if (m_dlib) {
    create_t* create = (create_t*) GetFunction (m_dlib, (char*)"create");
    m_strategy = create();
    m_strategy->Name (name);
    m_strategy->WSpace (&Workspace::Instance());
    } else {
      m_strategy = 0;
    }
  }
}

The key line here is m_strategy->WSpace (&Workspace::Instance());