comparison src/vamp-sdk/PluginAdapter.cpp @ 527:bc5e76e90e95 c++11-mutex

A better way, I think, of handling static initialisation order

     void checkOutputMap(Plugin *plugin);
     void markOutputsChanged(Plugin *plugin);
 
     void cleanup(Plugin *plugin);
     unsigned int getOutputCount(Plugin *plugin);
-    VampOutputDescriptor *getOutputDescriptor(Plugin *plugin,
-                                             unsigned int i);
+    VampOutputDescriptor *getOutputDescriptor(Plugin *plugin, unsigned int i);
     VampFeatureList *process(Plugin *plugin,
                              const float *const *inputBuffers,
                              int sec, int nsec);
     VampFeatureList *getRemainingFeatures(Plugin *plugin);
     VampFeatureList *convertFeatures(Plugin *plugin,
                                      const Plugin::FeatureSet &features);
     
     // maps both plugins and descriptors to adapters
     typedef map<const void *, Impl *> AdapterMap;
+
     static AdapterMap *m_adapterMap;
-    static mutex *m_adapterMapMutex;
+
+    static mutex &adapterMapMutex() {
+        // If this mutex was a global static, then it might be
+        // destroyed before the last adapter, and we would end up
+        // trying to lock an invalid mutex when removing an adapter
+        // from the adapter map. To ensure it outlasts the adapters,
+        // we need to ensure it is constructed before the construction
+        // of any of them is complete, since destruction order is
+        // reverse of construction. So we have to make sure this is
+        // called from the PluginAdapterBase::Impl constructor below.
+        static mutex m;
+        return m;
+    }
+        
     static Impl *lookupAdapter(VampPluginHandle);
 
     mutex m_mutex; // guards all of the below
     
     bool m_populated;

     m_populated(false)
 {
 #ifdef DEBUG_PLUGIN_ADAPTER
     cerr << "PluginAdapterBase::Impl[" << this << "]::Impl" << endl;
 #endif
+
+    (void)adapterMapMutex(); // see comment in adapterMapMutex function above
 }
 
 const VampPluginDescriptor *
 PluginAdapterBase::Impl::getDescriptor()
 {

     m_descriptor.releaseOutputDescriptor = vampReleaseOutputDescriptor;
     m_descriptor.process = vampProcess;
     m_descriptor.getRemainingFeatures = vampGetRemainingFeatures;
     m_descriptor.releaseFeatureSet = vampReleaseFeatureSet;
 
-    lock_guard<mutex> adapterMapGuard(*m_adapterMapMutex);
+    lock_guard<mutex> adapterMapGuard(adapterMapMutex());
     
     if (!m_adapterMap) {
         m_adapterMap = new AdapterMap;
     }
     (*m_adapterMap)[&m_descriptor] = this;

     for (unsigned int i = 0; i < m_descriptor.programCount; ++i) {
         free((void *)m_descriptor.programs[i]);
     }
     free((void *)m_descriptor.programs);
 
-    lock_guard<mutex> adapterMapGuard(*m_adapterMapMutex);
+    lock_guard<mutex> adapterMapGuard(adapterMapMutex());
     
     if (m_adapterMap) {
         
         m_adapterMap->erase(&m_descriptor);
         

 {
 #ifdef DEBUG_PLUGIN_ADAPTER
     cerr << "PluginAdapterBase::Impl::lookupAdapter(" << handle << ")" << endl;
 #endif
 
-    lock_guard<mutex> adapterMapGuard(*m_adapterMapMutex);
+    lock_guard<mutex> adapterMapGuard(adapterMapMutex());
     
     if (!m_adapterMap) return 0;
     AdapterMap::const_iterator i = m_adapterMap->find(handle);
     if (i == m_adapterMap->end()) return 0;
     return i->second;

 {
 #ifdef DEBUG_PLUGIN_ADAPTER
     cerr << "PluginAdapterBase::Impl::vampInstantiate(" << desc << ")" << endl;
 #endif
 
-    lock_guard<mutex> adapterMapGuard(*m_adapterMapMutex);
+    lock_guard<mutex> adapterMapGuard(adapterMapMutex());
     
     if (!m_adapterMap) {
         m_adapterMap = new AdapterMap();
     }
 

 void 
 PluginAdapterBase::Impl::cleanup(Plugin *plugin)
 {
     // at this point no mutex is held
     
-    lock_guard<mutex> adapterMapGuard(*m_adapterMapMutex);
+    lock_guard<mutex> adapterMapGuard(adapterMapMutex());
     lock_guard<mutex> guard(m_mutex);
     
     if (m_fs.find(plugin) != m_fs.end()) {
         size_t outputCount = 0;
         if (m_pluginOutputs[plugin]) {

 }
   
 PluginAdapterBase::Impl::AdapterMap *
 PluginAdapterBase::Impl::m_adapterMap = 0;
 
-// This is allocated on the heap so that we can be sure it outlives
-// the adapters themselves, which are typically static within the
-// plugin library. If this was also static, then it might be destroyed
-// before the last adapter, and we would end up trying to lock an
-// invalid mutex when removing an adapter from the adapter map.
-mutex *
-PluginAdapterBase::Impl::m_adapterMapMutex = new mutex;
-
 }
 
 _VAMP_SDK_PLUGSPACE_END(PluginAdapter.cpp)