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 31 of file SharedResource.h.

Member Typedef Documentation

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

Definition at line 39 of file SharedResource.h.

Constructor & Destructor Documentation

art::detail::SharedResources::SharedResources

(

)

Definition at line 37 of file SharedResource.cc.

References art::detail::LegacyResource.

  {
    // 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 108 of file SharedResource.cc.

References util::begin(), util::empty(), util::end(), art::detail::LegacyResource, art::detail::SharedResource_t::name, and util::values().

Referenced by art::detail::SharedModule::createQueues().

  {
    using namespace ::ranges;
    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).
      return sortedResources_ | views::values | to<std::vector>();
    }
    std::vector<std::shared_ptr<SerialTaskQueue>> result;
    // 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 47 of file SharedResource.cc.

References art::errors::LogicError.

  {
    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 80 of file SharedResource.cc.

References art::detail::LegacyResource, art::detail::SharedResource_t::name, and util::values().

Referenced by art::EventProcessor::EventProcessor().

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

    using namespace ::ranges;
    sortedResources_ =
      resources_sorted_by_count | views::values |
      views::transform([&group](auto const& key) {
        return std::pair{key, std::make_shared<SerialTaskQueue>(group)};
      }) |
      to<std::vector>();

    // 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 70 of file SharedResource.cc.

References art::detail::LegacyResource, and art::detail::SharedResource_t::name.

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

void art::detail::SharedResources::registerSharedResource

(

detail::SharedResource_t const &

resource

)

Definition at line 64 of file SharedResource.cc.

References art::detail::SharedResource_t::name.

  {
    register_resource(resource.name);
  }

void art::detail::SharedResources::registerSharedResources

(

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

names

)

Definition at line 58 of file SharedResource.cc.

References art::detail::SharedResource_t::name.

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

Member Data Documentation

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

private

Definition at line 49 of file SharedResource.h.

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

private

Definition at line 50 of file SharedResource.h.

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

private

Definition at line 47 of file SharedResource.h.

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

private

Definition at line 48 of file SharedResource.h.

---

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

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