plumed

dlsym dlopen

2.5.1

15 / 5058 files match, 3 filtered matches.

src/wrapper/Plumed.h
src/core/PlumedMainInitializer.h
src/tools/PlumedHandle.h

src/wrapper/Plumed.h

|   As of PLUMED 2.5, you can also initialize a plumed object using the following functions,
|   that load a specific kernel:
| \verbatim
|   (C)        plumed_create_dlopen
|   (C++)      PLMD::Plumed::dlopen
|   (FORTRAN)  PLUMED_F_CREATE_DLOPEN
| \endverbatim
| // now plumed has been really finalized
| \endverbatim
| 
|   In other words, every \ref plumed_create, \ref plumed_create_dlopen, \ref plumed_create_reference,
|   \ref plumed_create_reference_f, and \ref plumed_create_reference_v call must be matched by a \ref plumed_finalize.
|   Notice that in C++ whenever an object goes out of scope the reference counter
| 
|   Another difference is that the value of the variable `PLUMED_KERNEL` is read every time a new
|   plumed object is instantiated. So, you might even use it to load different plumed versions
|   simultaneously, although the preferred way to do this is using the function \ref plumed_create_dlopen.
|   Notice that if you want to load multiple versions simultaneously you should load them in a local namespace.
|   \ref plumed_create_dlopen does it automatically, whereas loading through env var `PLUMED_KERNEL` only does it if
|   you also set env var `PLUMED_NAMESPACE=LOCAL`.
| 
|   - Functions to find if a plumed object is valid
|     (\ref plumed_valid(), \ref plumed_gvalid(), \ref PLMD::Plumed::valid(), and \ref PLMD::Plumed::gvalid()).
|   - Functions to create a plumed object based on the path of a specific kernel
|     (\ref plumed_create_dlopen() and \ref PLMD::Plumed::dlopen()).
|   - Functions to create a plumed object referencing to another one, implementing a reference counter
|     (\ref plumed_create_reference(), \ref plumed_create_reference_v(), \ref plumed_create_reference_f().
|     \return The constructed plumed object
| */
| __PLUMED_WRAPPER_C_BEGIN
| plumed plumed_create_dlopen(const char*path);
| __PLUMED_WRAPPER_C_END
| 
| /**
|   \brief Constructor from path. Available as of PLUMED 2.5
| 
|   Same as \ref plumed_create_dlopen, but also allows to specify the mode for dlopen.
| 
|   \warning
|   Use with care, since not all the possible modes work correctly with PLUMED.
| */
| __PLUMED_WRAPPER_C_BEGIN
| plumed plumed_create_dlopen2(const char*path,int mode);
| __PLUMED_WRAPPER_C_END
| 
|     \brief Constructor as invalid. Available as of PLUMED 2.5
| 
|    Can be used to create an object in the same state as if it was returned by
|    plumed_create_dlopen with an incorrect path (or plumed_create using runtime binding
|    and an incorrect PLUMED_KERNEL).
| 
|   /**
|     Create a PLUMED object loading a specific kernel. Available as of PLUMED 2.5.
| 
|     It returns an object created with \ref plumed_create_dlopen. The object is owned and
|     is then finalized in the destructor. It can be used as follows:
|   \verbatim
|     PLMD::Plumed p = PLMD::Plumed::dlopen("/path/to/libplumedKernel.so");
|   // or, equivalenty:
|   //    PLMD::Plumed p(PLMD::Plumed::dlopen("/path/to/libplumedKernel.so"));
|   \endverbatim
|     or, equivalently, as
|   \verbatim
|     auto p = PLMD::Plumed::dlopen("/path/to/libplumedKernel.so");
|     p.cmd("init");
|   \endverbatim
|   */
|   static Plumed dlopen(const char* path)__PLUMED_WRAPPER_CXX_NOEXCEPT  {
| // use decref to remove the extra reference
|     return Plumed(plumed_create_dlopen(path)).decref();
|   }
| 
|   /**
|     Create a PLUMED object loading a specific kernel. Available as of PLUMED 2.5.
| 
|     Same as \ref dlopen(const char* path), but allows a dlopen mode to be chosen explicitly.
|   */
|   static Plumed dlopen(const char* path,int mode)__PLUMED_WRAPPER_CXX_NOEXCEPT  {
| // use decref to remove the extra reference
|     return Plumed(plumed_create_dlopen2(path,mode)).decref();
|   }
|   /** Invalid constructor. Available as of PLUMED 2.5.
|     A possible usage is to transfer the ownership of a temporary
|     object when it is converted
|   \verbatim
|   plumed p=Plumed::dlopen(path).incref()
|   // without incref(), the just constructed object will be destroyed
|   // when the temporary object is deleted.
| 
| #if defined( __PLUMED_HAS_DLOPEN) /*{*/
| /**
| Try to dlopen a path with a given mode.
| If the dlopen command fails, it tries to strip the `Kernel` part of the name.
| 
| This function is declared static (internal linkage) so that it is not visible from outside.
| */
| 
| __PLUMED_WRAPPER_INTERNALS_BEGIN
| void* plumed_attempt_dlopen(const char*path,int mode) {
|   char* pathcopy;
|   void* p;
|   }
|   __PLUMED_WRAPPER_STD fclose(fp);
|   dlerror();
|   p=dlopen(path,mode);
|   if(!p) {
|     /*
|       not visible. All the other cases (either PLUMED>=2.5 or symbols in the main executable visible)
|       should work correctly without entering here.
|     */
|     __PLUMED_FPRINTF(stderr,"+++ An error occurred. Message from dlopen(): %s +++\n",dlerror());
|     strlenpath=__PLUMED_WRAPPER_STD strlen(path);
|     pathcopy=(char*) __PLUMED_MALLOC(strlenpath+1);
|       }
|       __PLUMED_WRAPPER_STD fclose(fp);
|       dlerror();
|       p=dlopen(pathcopy,mode);
|       if(!p) __PLUMED_FPRINTF(stderr,"+++ An error occurred. Message from dlopen(): %s +++\n",dlerror());
|     }
|     __PLUMED_FREE(pathcopy);
|   }
| 
| /**
| Search symbols in a dlopened library.
| 
| This function is declared static (internal linkage) so that it is not visible from outside.
|   (if available).
|   Notice that problems can be detected checking if the functions have a NULL ptr.
|   On the other hand, the symbol table pointer might be NULL just because the plumed version is <=2.4.
|   If handle is not NULL, it is used to return a dlopen handle that could be subsequently dlclosed.
| */
| __PLUMED_WRAPPER_INTERNALS_BEGIN
|   if(functions) *functions=ptr->functions;
| #elif ! defined(__PLUMED_HAS_DLOPEN)
|   /*
|     When dlopen is not available, we hard code them to NULL
|   */
|   fprintf(stderr,"+++ PLUMED has been compiled without dlopen and without a static kernel +++\n");
|   plumed_plumedmain_function_holder g= {NULL,NULL,NULL};
|   if(plumed_symbol_table_ptr) *plumed_symbol_table_ptr=NULL;
|   const char* path;
|   void* p;
|   char* debug;
|   int dlopenmode;
|   g.create=NULL;
|   g.cmd=NULL;
|   path=__PLUMED_GETENV("PLUMED_KERNEL");
|   p=NULL;
|   debug=__PLUMED_GETENV("PLUMED_LOAD_DEBUG");
|   dlopenmode=0;
|   if(plumed_symbol_table_ptr) *plumed_symbol_table_ptr=NULL;
|   if(handle) *handle=NULL;
|     fprintf(stderr,"+++ Loading the PLUMED kernel runtime +++\n");
|     fprintf(stderr,"+++ PLUMED_KERNEL=\"%s\" +++\n",path);
|     if(debug) __PLUMED_FPRINTF(stderr,"+++ Loading with mode RTLD_NOW");
|     dlopenmode=RTLD_NOW;
|     if(__PLUMED_GETENV("PLUMED_LOAD_NAMESPACE") && !__PLUMED_WRAPPER_STD strcmp(__PLUMED_GETENV("PLUMED_LOAD_NAMESPACE"),"LOCAL")) {
|       dlopenmode=dlopenmode|RTLD_LOCAL;
|       if(debug) __PLUMED_FPRINTF(stderr,"|RTLD_LOCAL");
|     } else {
|       dlopenmode=dlopenmode|RTLD_GLOBAL;
|       if(debug) __PLUMED_FPRINTF(stderr,"|RTLD_GLOBAL");
|     }
| #ifdef RTLD_DEEPBIND
|     if(!__PLUMED_GETENV("PLUMED_LOAD_NODEEPBIND")) {
|       dlopenmode=dlopenmode|RTLD_DEEPBIND;
|       if(debug) __PLUMED_FPRINTF(stderr,"|RTLD_DEEPBIND");
|     }
| #endif
|     if(debug) __PLUMED_FPRINTF(stderr," +++\n");
|     p=plumed_attempt_dlopen(path,dlopenmode);
|     if(p) plumed_search_symbols(p,&g,plumed_symbol_table_ptr);
|   }
| __PLUMED_WRAPPER_C_END
| 
| __PLUMED_WRAPPER_C_BEGIN
| plumed plumed_create_dlopen(const char*path) {
|   int dlopenmode;
|   /* plumed_create_dlopen always uses RTLD_LOCAL and, when possible, RTLD_DEEPBIND to allow multiple versions */
| #ifdef __PLUMED_HAS_DLOPEN
|   dlopenmode=RTLD_NOW|RTLD_LOCAL;
| #ifdef RTLD_DEEPBIND
|   dlopenmode=dlopenmode|RTLD_DEEPBIND;
| #endif
| #else
|   dlopenmode=0;
| #endif
|   return plumed_create_dlopen2(path,dlopenmode);
| }
| __PLUMED_WRAPPER_C_END
| 
| __PLUMED_WRAPPER_C_BEGIN
| plumed plumed_create_dlopen2(const char*path,int mode) {
|   /* returned object */
|   plumed p;
|   /* allocate space for implementation object. this is free-ed in plumed_finalize(). */
|   pimpl=plumed_malloc_pimpl();
| #ifdef __PLUMED_HAS_DLOPEN
|   if(path) pimpl->dlhandle=plumed_attempt_dlopen(path,mode);
|   /* mark this library to be dlclosed when the object is finalized */
|   pimpl->dlclose=1;
|   plumed_c2f(plumed_create(),c);
| }
| 
| __PLUMED_IMPLEMENT_FORTRAN(plumed_f_create_dlopen,PLUMED_F_CREATE_DLOPEN,(char*path,char*c),(path,c)) {
|   plumed_c2f(plumed_create_dlopen(path),c);
| }
| 

src/core/PlumedMainInitializer.h

| /**
|   Static symbol table that is accessed by the plumed loader.
|   Notice that this table is initialized with a static object construction.
|   In principle, it should be accessed by other programs dlopening the plumed kernel.
|   In that case, it is guaranteed to be already initialized.
|   However, when accessed directly it might be safer to first call \ref plumed_symbol_table_init.

src/tools/PlumedHandle.h

| 
| The following syntax instead creates a handle referring to a loaded kernel
| \verbatim
| PlumedHandle p(PlumedHandle::dlopen("/path/to/libplumedkernel.so");
| // Alternatively:
| // auto p=PlumedHandle::dlopen("/path/to/libplumedkernel.so");
|   PlumedHandle();
| /// Construct a PlumedHandle given the path to a kernel.
| /// It just uses the private constructor PlumedHandle(const char* path).
|   static PlumedHandle dlopen(const char* path);
| /// Destructor.
| /// In case a kernel was dlopened, it dlcloses it.