art::SharedResourcesRegistry Class Reference

#include <SharedResourcesRegistry.h>

Classes
class	QueueAndCounter

Public Member Functions
	SharedResourcesRegistry ()
	SharedResourcesRegistry (SharedResourcesRegistry const &)=delete
	SharedResourcesRegistry (SharedResourcesRegistry &&)=delete
SharedResourcesRegistry &	operator= (SharedResourcesRegistry const &)=delete
SharedResourcesRegistry &	operator= (SharedResourcesRegistry &&)=delete
bool	containsResource (std::string const &) const
void	registerSharedResource (detail::SharedResource_t const &) noexcept( false)
void	registerSharedResource (std::string const &) noexcept(false)
void	updateSharedResource (std::string const &) noexcept(false)
void	freeze ()
std::vector< std::shared_ptr< hep::concurrency::SerialTaskQueue > >	createQueues (std::string const &resourceName) const
std::vector< std::shared_ptr< hep::concurrency::SerialTaskQueue > >	createQueues (std::vector< std::string > const &resourceNames) const

Static Public Member Functions
static SharedResourcesRegistry *	instance (bool shutdown=false)

Static Public Attributes
static detail::SharedResource_t const	Legacy

Private Attributes
hep::concurrency::RecursiveMutex	mutex_ {"srr::mutex_"}
std::map< std::string, QueueAndCounter >	resourceMap_
bool	frozen_
unsigned	nLegacy_

Detailed Description

Definition at line 22 of file SharedResourcesRegistry.h.

Constructor & Destructor Documentation

art::SharedResourcesRegistry::SharedResourcesRegistry

(

)

Definition at line 67 of file SharedResourcesRegistry.cc.

  {
    frozen_ = false;
    nLegacy_ = 0U;
    // Propulate queues for known shared resources.  Creating these
    // slots does *not* automatically introduce synchronization.
    // Synchronization is enabled based on the resource-names argument
    // presented to the 'createQueues' member function.
    registerSharedResource(Legacy);
  }

art::SharedResourcesRegistry::SharedResourcesRegistry ( SharedResourcesRegistry const &  )

delete

art::SharedResourcesRegistry::SharedResourcesRegistry ( SharedResourcesRegistry &&  )

delete

Member Function Documentation

bool art::SharedResourcesRegistry::containsResource

(

std::string const &

)

const

vector< shared_ptr< SerialTaskQueue > > art::SharedResourcesRegistry::createQueues

(

std::string const &

resourceName

)

const

Definition at line 151 of file SharedResourcesRegistry.cc.

  {
    RecursiveMutexSentry sentry{mutex_, __func__};
    vector const names{resourceName};
    return createQueues(names);
  }

vector< shared_ptr< SerialTaskQueue > > art::SharedResourcesRegistry::createQueues

(

std::vector< std::string > const &

resourceNames

)

const

Definition at line 159 of file SharedResourcesRegistry.cc.

  {
    RecursiveMutexSentry sentry{mutex_, __func__};
    map<pair<unsigned, string>, shared_ptr<SerialTaskQueue>> sortedResources;
    if (cet::search_all(resourceNames, Legacy.name)) {
      // This acquirer is for a legacy module, get the queues for all
      // resources.
      // Note: We do not trust legacy modules, they may be accessing
      // one of the shared resources without our knowledge, so we
      // isolate them from the one modules as well as each other.
      for (auto const& [key, queueAndCounter] : resourceMap_) {
        sortedResources.emplace(make_pair(queueAndCounter.counter_.load(), key),
                                atomic_load(&queueAndCounter.queue_));
      }
    } else {
      // Not for a legacy module, get the queues for the named
      // resources.
      for (auto const& name : resourceNames) {
        auto iter = resourceMap_.find(name);
        assert(iter != resourceMap_.end());
        auto const& [key, queueAndCounter] = *iter;
        sortedResources.emplace(make_pair(queueAndCounter.counter_.load(), key),
                                atomic_load(&queueAndCounter.queue_));
      }
    }
    vector<shared_ptr<SerialTaskQueue>> queues;
    if (sortedResources.empty()) {
      // Error, none of the resource names were registered.  Calling
      // code is depending on there being at least one shared queue.
      queues.emplace_back(make_shared<SerialTaskQueue>());
    } else {
      // At least some of the named resources exist.
      queues.reserve(sortedResources.size());
      for (auto const& keyAndVal : sortedResources) {
        // Note: keyAndVal.second is a shared_ptr<SerialTaskQueue>
        queues.push_back(keyAndVal.second);
      }
    }
    return queues;
  }

void art::SharedResourcesRegistry::freeze

(

)

Definition at line 145 of file SharedResourcesRegistry.cc.

  {
    frozen_ = true;
  }

SharedResourcesRegistry * art::SharedResourcesRegistry::instance ( bool  shutdown = false )

static

Definition at line 34 of file SharedResourcesRegistry.cc.

  {
    static SharedResourcesRegistry* me{nullptr};
    if (shutdown) {
      delete me;
      me = nullptr;
      return me;
    }
    if (me == nullptr) {
      me = new SharedResourcesRegistry{};
    }
    return me;
  }

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

delete

SharedResourcesRegistry& art::SharedResourcesRegistry::operator= ( SharedResourcesRegistry &&  )

delete

void art::SharedResourcesRegistry::registerSharedResource ( detail::SharedResource_t const &  resource )

noexcept

Definition at line 126 of file SharedResourcesRegistry.cc.

  {
    RecursiveMutexSentry sentry{mutex_, __func__};
    resourceMap_[resource.name];
  }

void art::SharedResourcesRegistry::registerSharedResource ( std::string const &  name )

noexcept

Definition at line 134 of file SharedResourcesRegistry.cc.

  {
    RecursiveMutexSentry sentry{mutex_, __func__};
    // Note: This has the intended side-effect of creating the entry
    // if it does not yet exist.
    resourceMap_[name];
    updateSharedResource(name);
  }

void art::SharedResourcesRegistry::updateSharedResource ( std::string const &  name )

noexcept

Definition at line 79 of file SharedResourcesRegistry.cc.

  {
    RecursiveMutexSentry sentry{mutex_, __func__};
    if (frozen_) {
      throw art::Exception{art::errors::LogicError, error_context(name)}
        << "The shared-resources registry has been frozen.  All 'serialize' "
           "calls\n"
        << "must be made in the constructor of a shared module and no later.\n";
    }
    auto it = resourceMap_.find(name);
    if (it == cend(resourceMap_)) {
      throw art::Exception{art::errors::LogicError, error_context(name)}
        << "A 'serialize' call was made for a resource that has not been "
           "registered.\n"
        << "If the resource is an art-based service, make sure that the "
           "service\n"
        << "has been configured for this job.  Otherwise, use the "
           "'serializeExternal'\n"
        << "function call.  If neither of these approaches is appropriate, "
           "contact\n"
        << "artists@fnal.gov.\n";
    }
    auto& queueAndCounter = it->second;
    if (name == Legacy.name) {
      ++nLegacy_;
      // Make sure all non-legacy resources have a higher count, which
      // makes legacy always the first queue.
      for (auto& keyAndVal : resourceMap_) {
        // Note: keyAndVal.first  is a string (name of resource)
        // Note: keyAndVal.second is a QueueAndCounter
        ++keyAndVal.second.counter_;
      }
      return;
    }
    // count the number of times the resource was registered
    ++queueAndCounter.counter_;
    if (queueAndCounter.counter_.load() == 1) {
      // Make sure all non-legacy resources have a higher count, which
      // makes legacy always the first queue.  When first registering
      // a non-legacy resource, we have to account for any legacy
      // resource registrations already made.
      queueAndCounter.counter_ += nLegacy_;
    }
  }

Member Data Documentation

bool art::SharedResourcesRegistry::frozen_

private

Definition at line 60 of file SharedResourcesRegistry.h.

detail::SharedResource_t const art::SharedResourcesRegistry::Legacy

static

Initial value:

{"__legacy__",
                                                                 false}

Definition at line 38 of file SharedResourcesRegistry.h.

hep::concurrency::RecursiveMutex art::SharedResourcesRegistry::mutex_ {"srr::mutex_"}

mutableprivate

Definition at line 58 of file SharedResourcesRegistry.h.

unsigned art::SharedResourcesRegistry::nLegacy_

private

Definition at line 61 of file SharedResourcesRegistry.h.

std::map<std::string, QueueAndCounter> art::SharedResourcesRegistry::resourceMap_

private

Definition at line 59 of file SharedResourcesRegistry.h.

---

The documentation for this class was generated from the following files:

• art/art/Utilities/SharedResourcesRegistry.h
• art/art/Utilities/SharedResourcesRegistry.cc