art::detail::SharedResources Class Reference

#include <SharedResource.h>

Public Types
using	queue_ptr_t = std::shared_ptr< hep::concurrency::SerialTaskQueue >

Public Member Functions
	SharedResources ()
void	registerSharedResources (std::set< std::string > const &names)
void	registerSharedResource (detail::SharedResource_t const &)
void	freeze (tbb::task_group &group)
std::vector< queue_ptr_t >	createQueues (std::vector< std::string > const &resourceNames) const

Private Member Functions
void	register_resource (std::string const &name)
void	ensure_not_frozen (std::string const &name)

Private Attributes
std::map< std::string, unsigned >	resourceCounts_
std::vector< std::pair< std::string, queue_ptr_t > >	sortedResources_
bool	frozen_ {false}
unsigned	nLegacy_ {}

Detailed Description

Definition at line 30 of file SharedResource.h.

Member Typedef Documentation

using art::detail::SharedResources::queue_ptr_t = std::shared_ptr<hep::concurrency::SerialTaskQueue>

Definition at line 38 of file SharedResource.h.

Constructor & Destructor Documentation

art::detail::SharedResources::SharedResources

(

)

Definition at line 35 of file SharedResource.cc.

  {
    // 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(LegacyResource);
  }

Member Function Documentation

std::vector< std::shared_ptr< SerialTaskQueue > > art::detail::SharedResources::createQueues

(

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

resourceNames

)

const

Definition at line 104 of file SharedResource.cc.

  {
    std::vector<queue_ptr_t> result;
    if (cet::search_all(resourceNames, LegacyResource.name)) {
      // We do not trust legacy modules as they may be accessing one
      // of the shared resources without our knowledge.  We therefore
      // isolate them from all other shared modules (and each other).
      for (auto const& pr : sortedResources_) {
        result.push_back(pr.second);
      }
    } else {
      // Not for a legacy module, get the queues for the named
      // resources.
      for (auto const& name : resourceNames) {
        auto it =
          std::find_if(begin(sortedResources_),
                       end(sortedResources_),
                       [&name](auto const& pr) { return pr.first == name; });
        assert(it != sortedResources_.end());
        result.push_back(it->second);
      }
    }

    assert(not empty(result));
    return result;
  }

void art::detail::SharedResources::ensure_not_frozen ( std::string const &  name )

private

Definition at line 45 of file SharedResource.cc.

  {
    if (frozen_) {
      throw Exception{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";
    }
  }

void art::detail::SharedResources::freeze

(

tbb::task_group &

group

)

Definition at line 78 of file SharedResource.cc.

  {
    frozen_ = true;

    std::vector<std::pair<unsigned, std::string>> resources_sorted_by_count;
    for (auto const& [name, count] : resourceCounts_) {
      // Make sure all non-legacy resources have a higher count, which
      // makes legacy always the first queue.
      auto const offset = (name == LegacyResource.name) ? 0u : nLegacy_;
      resources_sorted_by_count.emplace_back(count + offset, name);
    }
    cet::sort_all(resources_sorted_by_count, [](auto const& a, auto const& b) {
      return a.first < b.first;
    });

    assert(empty(sortedResources_));
    for (auto const& pr : resources_sorted_by_count) {
      sortedResources_.emplace_back(pr.second,
                                    std::make_shared<SerialTaskQueue>(group));
    }

    // Not needed any more now that we have a sorted list of resources.
    resourceCounts_.clear();
  }

void art::detail::SharedResources::register_resource ( std::string const &  name )

private

Definition at line 68 of file SharedResource.cc.

  {
    ensure_not_frozen(name);
    ++resourceCounts_[name];
    if (name == LegacyResource.name) {
      ++nLegacy_;
    }
  }

void art::detail::SharedResources::registerSharedResource

(

detail::SharedResource_t const &

resource

)

Definition at line 62 of file SharedResource.cc.

  {
    register_resource(resource.name);
  }

void art::detail::SharedResources::registerSharedResources

(

std::set< std::string > const &

names

)

Definition at line 56 of file SharedResource.cc.

  {
    cet::for_all(names, [this](auto const& name) { register_resource(name); });
  }

Member Data Documentation

bool art::detail::SharedResources::frozen_ {false}

private

Definition at line 48 of file SharedResource.h.

unsigned art::detail::SharedResources::nLegacy_ {}

private

Definition at line 49 of file SharedResource.h.

std::map<std::string, unsigned> art::detail::SharedResources::resourceCounts_

private

Definition at line 46 of file SharedResource.h.

std::vector<std::pair<std::string, queue_ptr_t> > art::detail::SharedResources::sortedResources_

private

Definition at line 47 of file SharedResource.h.

---

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

• art/art/Utilities/SharedResource.h
• art/art/Utilities/SharedResource.cc