#include <SharedResourcesRegistry.h>

Public Member Functions
SharedResourcesAcquirer	createAcquirer (std::vector< std::string > const &) const

std::pair< SharedResourcesAcquirer, std::shared_ptr< std::recursive_mutex > >	createAcquirerForSourceDelayedReader ()

void	registerSharedResource (const std::string &)
	A resource name must be registered before it can be used in the createAcquirer call. More...

Static Public Member Functions
static SharedResourcesRegistry *	instance ()

Static Public Attributes
static const std::string	kLegacyModuleResourceName {"__legacy__"}
	All legacy modules share this resource. More...

Private Member Functions
const SharedResourcesRegistry &	operator= (const SharedResourcesRegistry &)=delete

	SharedResourcesRegistry ()

	SharedResourcesRegistry (const SharedResourcesRegistry &)=delete

	~SharedResourcesRegistry ()=default

Private Attributes
unsigned int	nLegacy_

edm::propagate_const< std::shared_ptr< SerialTaskQueue > >	queueForDelayedReader_

edm::propagate_const< std::shared_ptr< std::recursive_mutex > >	resourceForDelayedReader_

std::map< std::string, std::pair< std::shared_ptr< SerialTaskQueue >, unsigned int > >	resourceMap_

Friends
class	::testSharedResourcesRegistry

Detailed Description

Definition at line 39 of file SharedResourcesRegistry.h.

Constructor & Destructor Documentation

SharedResourcesRegistry::SharedResourcesRegistry ( )

private

Definition at line 30 of file SharedResourcesRegistry.cc.

30 : nLegacy_(0) {}

edm::SharedResourcesRegistry::nLegacy_

unsigned int nLegacy_

Definition: SharedResourcesRegistry.h:81

edm::SharedResourcesRegistry::~SharedResourcesRegistry ( )

privatedefault

edm::SharedResourcesRegistry::SharedResourcesRegistry ( const SharedResourcesRegistry & )

privatedelete

Member Function Documentation

SharedResourcesAcquirer SharedResourcesRegistry::createAcquirer ( std::vector< std::string > const & resourceNames ) const

Definition at line 75 of file SharedResourcesRegistry.cc.

References spr::find(), kLegacyModuleResourceName, eostools::move(), dataset::name, and resourceMap_.

Referenced by edm::one::impl::SharedResourcesUser< T >::createAcquirer(), edm::EDAnalyzer::doBeginJob(), edm::EDProducer::doBeginJob(), edm::EDFilter::doBeginJob(), and edm::OutputModule::doBeginJob().

                                                                                                                  {
     // The acquirer will acquire the shared resources declared by a module
     // so that only it can use those resources while it runs. The other
     // modules using the same resource will not be run until the module
     // that acquired the resources completes its task.
 
     // The legacy shared resource is special.
     // Legacy modules cannot run concurrently with each other or
     // any other module that has declared any shared resource. Treat
     // one modules that call usesResource with no argument in the
     // same way.
 
     // Sort by how often used and then by name
     // Consistent sorting avoids deadlocks and this particular order optimizes performance
     std::map<std::pair<unsigned int, std::string>, std::shared_ptr<SerialTaskQueue>> sortedResources;
 
     // Is this acquirer for a module that depends on the legacy shared resource?
     if (std::find(resourceNames.begin(), resourceNames.end(), kLegacyModuleResourceName) != resourceNames.end()) {
       for (auto const& resource : resourceMap_) {
         // It's redundant to declare legacy if the legacy modules
         // all declare all the other resources, so just skip it.
         // But if the only shared resource is the legacy resource don't skip it.
         if (resource.first == kLegacyModuleResourceName && resourceMap_.size() > 1)
           continue;
         //If only one module wants it, it really isn't shared
         if (resource.second.second > 1) {
           sortedResources.insert(
               std::make_pair(std::make_pair(resource.second.second, resource.first), resource.second.first));
         }
       }
       // Handle cases where the module does not declare the legacy resource
     } else {
       for (auto const& name : resourceNames) {
         auto resource = resourceMap_.find(name);
         assert(resource != resourceMap_.end());
         //If only one module wants it, it really isn't shared
         if (resource->second.second > 1) {
           sortedResources.insert(
               std::make_pair(std::make_pair(resource->second.second, resource->first), resource->second.first));
         }
       }
     }
 
     std::vector<std::shared_ptr<SerialTaskQueue>> queues;
     queues.reserve(sortedResources.size());
     for (auto const& resource : sortedResources) {
       queues.push_back(resource.second);
     }
     if (queues.empty()) {
       //Calling code is depending on there being at least one shared queue
       queues.reserve(1);
       queues.push_back(std::make_shared<SerialTaskQueue>());
     }
 
     return SharedResourcesAcquirer(std::move(queues));
   }

std::pair< SharedResourcesAcquirer, std::shared_ptr< std::recursive_mutex > > SharedResourcesRegistry::createAcquirerForSourceDelayedReader ( )

Definition at line 64 of file SharedResourcesRegistry.cc.

References edm::get_underlying(), eostools::move(), queueForDelayedReader_, and resourceForDelayedReader_.

Referenced by edm::PoolSource::PoolSource(), and edm::RootDelayedReader::RootDelayedReader().

                                                                 {
     if (not resourceForDelayedReader_) {
       resourceForDelayedReader_ =
           std::make_shared<std::recursive_mutex>();  // propagate_const<T> has no reset() function
       queueForDelayedReader_ = std::make_shared<SerialTaskQueue>();
     }
 
     std::vector<std::shared_ptr<SerialTaskQueue>> queues = {get_underlying(queueForDelayedReader_)};
     return std::make_pair(SharedResourcesAcquirer(std::move(queues)), get_underlying(resourceForDelayedReader_));
   }

SharedResourcesRegistry * SharedResourcesRegistry::instance ( )

static

Definition at line 25 of file SharedResourcesRegistry.cc.

Referenced by edm::one::impl::SharedResourcesUser< T >::createAcquirer(), edm::EDAnalyzer::doBeginJob(), edm::EDProducer::doBeginJob(), edm::EDFilter::doBeginJob(), edm::OutputModule::doBeginJob(), edm::EDAnalyzer::EDAnalyzer(), edm::EDFilter::EDFilter(), edm::EDProducer::EDProducer(), edm::OutputModule::OutputModule(), edm::PoolSource::PoolSource(), edm::RootDelayedReader::RootDelayedReader(), and edm::one::impl::SharedResourcesUser< T >::usesResource().

                                                              {
     static SharedResourcesRegistry s_instance;
     return &s_instance;
   }

const SharedResourcesRegistry& edm::SharedResourcesRegistry::operator= ( const SharedResourcesRegistry & )

privatedelete

void SharedResourcesRegistry::registerSharedResource ( const std::string & resourceName )

A resource name must be registered before it can be used in the createAcquirer call.

Definition at line 32 of file SharedResourcesRegistry.cc.

References kLegacyModuleResourceName, nLegacy_, resourceMap_, and mitigatedMETSequence_cff::U.

Referenced by edm::EDAnalyzer::EDAnalyzer(), edm::EDFilter::EDFilter(), edm::EDProducer::EDProducer(), edm::OutputModule::OutputModule(), and edm::one::impl::SharedResourcesUser< T >::usesResource().

                                                                                     {
     auto& queueAndCounter = resourceMap_[resourceName];
 
     if (resourceName == kLegacyModuleResourceName) {
       ++nLegacy_;
       for (auto& resource : resourceMap_) {
         if (!resource.second.first) {
           resource.second.first = std::make_shared<SerialTaskQueue>();
         }
         ++resource.second.second;
       }
     } else {
       // count the number of times the resource was registered
       ++queueAndCounter.second;
 
       // When first registering a nonlegacy resource, we have to
       // account for any legacy resource registrations already made.
       if (queueAndCounter.second == 1) {
         if (nLegacy_ > 0U) {
           queueAndCounter.first = std::make_shared<SerialTaskQueue>();
           queueAndCounter.second += nLegacy_;
         }
         // If registering a nonlegacy resource the second time and
         // the legacy resource has not been registered yet,
         // we know we will need the queue so go ahead and create it.
       } else if (queueAndCounter.second == 2) {
         queueAndCounter.first = std::make_shared<SerialTaskQueue>();
       }
     }
   }