Merge pull request #995 from rmcgibbo/loadFailures

Record plugin load failures

olla/include/openmm/Platform.h

@@ -49,13 +49,13 @@ class KernelFactory;
  * More precisely, a Platform object acts as a registry for a set of KernelFactory
  * objects which together implement the kernels.  The Platform class, in turn, provides a
  * static registry of all available Platform objects.
- * 
+ *
  * To get a Platform object, call
- * 
+ *
  * <pre>
  * Platform& platform Platform::findPlatform(kernelNames);
  * </pre>
- * 
+ *
  * passing in the names of all kernels that will be required for the calculation you plan to perform.  It
  * will return the fastest available Platform which provides implementations of all the specified kernels.
  * You can then call createKernel() to construct particular kernels as needed.
@@ -133,14 +133,14 @@ public:
      * Register a KernelFactory which should be used to create Kernels with a particular name.
      * The Platform takes over ownership of the factory, and will delete it when the Platform itself
      * is deleted.
-     * 
+     *
      * @param name     the kernel name for which the factory should be used
      * @param factory  the factory to use for creating Kernels with the specified name
      */
     void registerKernelFactory(const std::string& name, KernelFactory* factory);
     /**
      * Determine whether this Platforms provides implementations of a set of kernels.
-     * 
+     *
      * @param kernelNames the names of the kernels of interests
      * @return true if this Platform provides implementations of all the kernels in the list,
      * false if there are any which it does not support
@@ -151,9 +151,9 @@ public:
      * the returned Kernels are independent and do not interact with each other.  This means
      * that it is possible to have multiple simulations in progress at one time without them
      * interfering.
-     * 
+     *
      * If no KernelFactory has been registered for the specified name, this will throw an exception.
-     * 
+     *
      * @param name the name of the Kernel to get
      * @param context the context for which to create a Kernel
      * @return a newly created Kernel object
@@ -171,6 +171,10 @@ public:
      * Get a registered Platform by index.
      */
     static Platform& getPlatform(int index);
+    /**
+     * Get any failures caused during the last call to loadPluginsFromDirectory
+     */
+    static std::vector<std::string> getPluginLoadFailures();
     /**
      * Get the registered Platform with a particular name.  If no Platform with that name has been
      * registered, this throws an exception.
@@ -178,7 +182,7 @@ public:
     static Platform& getPlatformByName(const std::string& name);
     /**
      * Find a Platform which can be used to perform a calculation.
-     * 
+     *
      * @param kernelNames the names of all kernels which will be needed for the calculation
      * @return the fastest registered Platform which supports all of the requested kernels.  If no
      * Platform exists which supports all of them, this will throw an exception.
@@ -201,7 +205,7 @@ public:
      * Load multiple dynamic libraries (DLLs) which contain OpenMM plugins from a single directory.
      * This method loops over every file contained in the specified directory and calls loadPluginLibrary()
      * for each one.  If an error occurs while trying to load a particular file, that file is simply
-     * ignored.
+     * ignored. You can retrieve a list of all such errors by calling getPluginLoadFailures().
      *
      * @param directory    the path to the directory containing libraries to load
      * @return the names of all files which were successfully loaded as libraries
@@ -233,8 +237,10 @@ private:
     std::map<std::string, KernelFactory*> kernelFactories;
     std::map<std::string, std::string> defaultProperties;
     static std::vector<Platform*>& getPlatforms();
+    static std::vector<std::string> pluginLoadFailures;
 };
 
+
 } // namespace OpenMM
 
 #endif /*OPENMM_PLATFORM_H_*/

olla/src/Platform.cpp

@@ -51,6 +51,8 @@
 using namespace OpenMM;
 using namespace std;
 
+std::vector<std::string> Platform::pluginLoadFailures;
+
 static int registerPlatforms() {
 
     // Register the Platforms built into the main library.  This should eventually be moved elsewhere.
@@ -140,6 +142,10 @@ Platform& Platform::getPlatform(int index) {
     throw OpenMMException("Invalid platform index");
 }
 
+std::vector<std::string> Platform::getPluginLoadFailures() {
+  return pluginLoadFailures;
+}
+
 Platform& Platform::getPlatformByName(const string& name) {
     for (int i = 0; i < getNumPlatforms(); i++)
         if (getPlatform(i).getName() == name)
@@ -196,8 +202,9 @@ static void* loadOneLibrary(const string& file) {
     throw OpenMMException("Loading dynamic libraries is not supported on PNaCl");
 #else    
     void *handle = dlopen(file.c_str(), RTLD_LAZY | RTLD_GLOBAL);
-    if (handle == NULL)
+    if (handle == NULL) {
         throw OpenMMException("Error loading library "+file+": "+dlerror());
+    }
     return handle;
 #endif
 }
@@ -261,12 +268,14 @@ vector<string> Platform::loadPluginsFromDirectory(const string& directory) {
     vector<void*> plugins;
 #endif
     vector<string> loadedLibraries;
+    pluginLoadFailures.resize(0);
+
     for (unsigned int i = 0; i < files.size(); ++i) {
         try {
             plugins.push_back(loadOneLibrary(directory+dirSeparator+files[i]));
             loadedLibraries.push_back(files[i]);
         } catch (OpenMMException& ex) {
-            // Just ignore it.
+	    pluginLoadFailures.push_back(ex.what());
         }
     }
     initializePlugins(plugins);

wrappers/generateWrappers.py

@@ -68,7 +68,7 @@ class WrapperGenerator:
     
     def __init__(self, inputDirname, output):
         self.skipClasses = ['OpenMM::Vec3', 'OpenMM::XmlSerializer', 'OpenMM::Kernel', 'OpenMM::KernelImpl', 'OpenMM::KernelFactory', 'OpenMM::ContextImpl', 'OpenMM::SerializationNode', 'OpenMM::SerializationProxy']
-        self.skipMethods = ['OpenMM::Context::getState', 'OpenMM::Platform::loadPluginsFromDirectory', 'OpenMM::Context::createCheckpoint', 'OpenMM::Context::loadCheckpoint', 'OpenMM::Context::getMolecules']
+        self.skipMethods = ['OpenMM::Context::getState', 'OpenMM::Platform::loadPluginsFromDirectory', 'OpenMM::Platform::getPluginLoadFailures', 'OpenMM::Context::createCheckpoint', 'OpenMM::Context::loadCheckpoint', 'OpenMM::Context::getMolecules']
         self.hideClasses = ['Kernel', 'KernelImpl', 'KernelFactory', 'ContextImpl', 'SerializationNode', 'SerializationProxy']
         self.nodeByID={}
 
@@ -398,6 +398,7 @@ extern OPENMM_EXPORT void %(name)s_insert(%(name)s* set, %(type)s value);""" % v
    Unlike the C++ versions, the return value is allocated on the heap, and you must delete it yourself. */
 extern OPENMM_EXPORT OpenMM_State* OpenMM_Context_getState(const OpenMM_Context* target, int types, int enforcePeriodicBox);
 extern OPENMM_EXPORT OpenMM_StringArray* OpenMM_Platform_loadPluginsFromDirectory(const char* directory);
+extern OPENMM_EXPORT OpenMM_StringArray* OpenMM_Platform_getPluginLoadFailures();
 extern OPENMM_EXPORT char* OpenMM_XmlSerializer_serializeSystem(const OpenMM_System* system);
 extern OPENMM_EXPORT char* OpenMM_XmlSerializer_serializeState(const OpenMM_State* state);
 extern OPENMM_EXPORT char* OpenMM_XmlSerializer_serializeIntegrator(const OpenMM_Integrator* integrator);
@@ -804,6 +805,10 @@ OPENMM_EXPORT OpenMM_StringArray* OpenMM_Platform_loadPluginsFromDirectory(const
     vector<string> result = Platform::loadPluginsFromDirectory(string(directory));
     return reinterpret_cast<OpenMM_StringArray*>(new vector<string>(result));
 }
+OPENMM_EXPORT OpenMM_StringArray* OpenMM_Platform_getPluginLoadFailures() {
+    vector<string> result = Platform::getPluginLoadFailures();
+    return reinterpret_cast<OpenMM_StringArray*>(new vector<string>(result));
+}
 static char* createStringFromStream(stringstream& stream) {
     int length = stream.str().size();
     char* result = (char*) malloc(length+1);
@@ -1314,6 +1319,10 @@ MODULE OpenMM
             character(*) directory
             type(OpenMM_StringArray) result
         end subroutine
+        subroutine OpenMM_Platform_getPluginLoadFailures(result)
+            use OpenMM_Types; implicit none
+            type(OpenMM_StringArray) result
+        end subroutine
         subroutine OpenMM_XmlSerializer_serializeSystemToC(system, result, result_length)
             use iso_c_binding; use OpenMM_Types; implicit none
             type(OpenMM_System), intent(in) :: system
@@ -1988,6 +1997,12 @@ OPENMM_EXPORT void openmm_platform_loadpluginsfromdirectory_(const char* directo
 OPENMM_EXPORT void OPENMM_PLATFORM_LOADPLUGINSFROMDIRECTORY(const char* directory, OpenMM_StringArray*& result, int length) {
     result = OpenMM_Platform_loadPluginsFromDirectory(makeString(directory, length).c_str());
 }
+OPENMM_EXPORT void openmm_platform_getpluginloadfailures_(OpenMM_StringArray*& result) {
+    result = OpenMM_Platform_getPluginLoadFailures();
+}
+OPENMM_EXPORT void OPENMM_PLATFORM_GETPLUGINLOADFAILURES(OpenMM_StringArray*& result) {
+    result = OpenMM_Platform_getPluginLoadFailures();
+}
 OPENMM_EXPORT void openmm_xmlserializer_serializesystemtoc_(OpenMM_System*& system, char*& result, int& result_length) {
     convertStringToChars(OpenMM_XmlSerializer_serializeSystem(system), result, result_length);
 }

wrappers/python/src/swig_doxygen/swigInputConfig.py

@@ -180,6 +180,7 @@ UNITS = {
 ("*", "getParticleMass") : ("unit.amu", ()),
 ("*", "getPlatform") : (None, ()),
 ("*", "getPlatformByName") : (None, ()),
+("*", "getPluginLoadFailures"): (None, ()),
 ("*", "getRandomNumberSeed") : (None, ()),
 ("*", "getReactionFieldDielectric") : (None, ()),
 ("*", "getSoluteDielectric") : (None, ()),