/ray/src/lib/module/pool.cc

Go to the documentation of this file.

/*
 * lib/module/pool.cc
 * 
 * Implementing shared objects loadable at runtime (.so, .dll, ...)
 * 
 * Copyright (c) 2004 by Wolfgang Wieser ] wwieser (a) gmx <*> de [ 
 * 
 * This file may be distributed and/or modified under the terms of the 
 * GNU General Public License version 2 as published by the Free Software 
 * Foundation. (See COPYING.GPL for details.)
 * 
 * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 * 
 */

#include "pool.h"

#include <stdio.h>     


// Initializing static data: 
ModulePool *ModulePool::pool=NULL;


_ISharedObject *ModulePool::_FindObjectByName(const char *name,bool requeue)
{
    _ISharedObject *res=NULL;
    
    pool_mutex.lock();
    for(_ISharedObject *so=so_list.first(); so; so=so->next)
    {
        if(!strcmp(so->mname,name))
        {
            res=so;
            if(requeue && so->prev)
            {
                // Re-queue at the beginning (if not already there). 
                so_list.dequeue(so);
                so_list.insert(so);
            }
            break;
        }
    }
    pool_mutex.unlock();
    
    return(res);
}


SharedObject ModulePool::_load(const char *name,int flags)
{
    if(!this || !name)  return SharedObject();
    
    // First, see if we have already loaded this object: 
    _ISharedObject *so=_FindObjectByName(name,/*requeue=*/1);
    if(so)
    {  return(SharedObject(so));  }
    
    // so=NULL; here. Good. 
    
    // We need to load the object. 
    pool_mutex.lock();  // We lock here for correct g_module_error reporting. 
    GModule *module=g_module_open(name,(GModuleFlags)flags);
    if(!module)
    {
        // Failure. Compose SharedObject which indicated failure by 
        // setting the module to NULL and storing the error string 
        // as the name: 
        so=new _ISharedObject(NULL,g_module_error());
        // This has module=NULL; do NOT insert into so_list. 
    }
    else
    {
        so=new _ISharedObject(module,name);
        // Insert into list (at the beginning!)
        so_list.insert(so);
    }
    pool_mutex.unlock();
    
    return(SharedObject(so));
}


int ModulePool::_unload(const char *name)
{
    if(!this)  return(2);
    if(!name)  return(0);
    
    _ISharedObject *so=_FindObjectByName(name,/*requeue=*/0);
    if(!so)  return(1);
    
    _unregister(so);
    
    return(0);
}


void ModulePool::_unregister(_ISharedObject *iso)
{
    if(!this || !iso)  return;
    
    pool_mutex.lock();
    so_list.dequeue(iso);
    pool_mutex.unlock();
    
    // It is important to set the module pointer to NULL after 
    // having removed the object from the so_list since 
    // _unregister() is also used by _unload(). 
    GModule *module=iso->module;
    iso->module=NULL;
    
    // Unload the module: 
    if(!g_module_close(module))
    {
        // Closing the module failed. Hmm...
        fprintf(stderr,"OOPS: Failed to unload module %s\n",iso->name());
    }
}


int ModulePool::init()
{
    // If modules are not supported, return immediately. 
    // The pool pointer will stay NULL. Members check for this==NULL. 
    if(!g_module_supported())
    {  return(1);  }
    
    // Initialize the pool. 
    new ModulePool();    // <-- Constructor will set ModulePool::pool. 
    
    return(0);
}


void ModulePool::cleanup()
{
    if(pool)
    {  delete pool;  }
    // pool=NULL here by destructor of ModulePool. 
}


ModulePool::ModulePool() : 
    so_list(),
    pool_mutex()
{
    Assert(!pool);
    pool=this;
}


ModulePool::~ModulePool()
{
    Assert(pool==this);
    
    // Well, what should we do with these loaded modules?
    pool_mutex.lock();
    Assert(so_list.IsEmpty());
    while(!so_list.IsEmpty())
    {  _unregister(so_list.first());  }
    pool_mutex.unlock();
    
    pool=NULL;
}


#if 0
// Example implementation. 

#include <lib/module/pool.h>
#include <lib/module/symbol.h>

int main()
{
    if(ModulePool::init())
    {  fprintf(stderr,"Modules not supported.\n");  exit(1);  }
    
    // Start your threads...
    // One of them calls "foo"
    
    ModulePool::cleanup();
    return(0);
}

void foo()
{
    ModuleSymbol sym;
    
    {
        // We need to load a module: 
        SharedObject so=ModulePool::load("mymodule.so");
        if(so->error())  // Note: "pointer feeling" :) [overloaded operator!]
        { fprintf(stderr,"Failed to load module: %s\n",so->error()); return; }
        
        // Loading was success. Get a symbol: 
        ModuleSymbol sym_bar=so->lookup("bar");
        if(!sym_bar)  // equiv: if(!sym_bar.ptr())
        { fprintf(stderr,"OOPS: Symbol bar not present in module.\n"); return; }
        
        // You can use ModuleSymbol and SharedObject just like any other 
        // safe type (like PODs e.g.); just do not use pointers on them: 
        sym=sym_bar;
        
        // SharedObject "so" and ModuleSymbol "sym_bar" get destroyed but 
        // module will NOT be unloaded here since "sym" still holds a 
        // reference. 
    }
    
    typedef int (*bar_fptr)(double);
    // Call the function "bar" (which is provided by the module / shared 
    // object): 
    (*(bar_fptr)sym.ptr())( 3.14 );
    
    // Or, we can use the more convenient ModuleFunction class which is 
    // also a safe type and can be used like a function pointer: 
    ModuleFunction<int(*)(double)> bar=sym;  // or ModuleFunction<bar_fptr> ...
    (*bar)( 3.14 );
    
    // This will unload the module as we explicitly delete the last reference 
    // to it. 
    sym=ModuleSymbol();
    
    // NOTE that you can explicitly de-reference a shared object (i.e. 
    // make it a NULL reference) using: 
    //   SharedObject::deref(), i.e. so.deref() above (NOT so->deref()) 
    // or by assigning a NULL ref: 
    //   so = SharedObject();     (with so from above)
}
#endif

---