Ath::DynamicDataHelper Class Reference

Helper class to gather all declared data IDs and propagate them to components which declare data dependencies dynamically. More...

#include <DynamicDataHelper.h>

Collaboration diagram for Ath::DynamicDataHelper:

Public Member Functions
void	gatherDataHandlesAndDynamicConsumers (const std::string &parent_name, Gaudi::Algorithm *theAlgorithm)
	Gather the input and output data declared by the given algorithm, its child algorithms and their tools.
StatusCode	addExtraDependencies (IClassIDSvc &clid_svc, std::vector< std::string > &undeclared_output_data, MsgStream &out)
	Add extra output data which is not declared by any of the gathered components.
void	updateDataNeeds (unsigned int max_pass, MsgStream &out)
	Update the data dependencies of all components which dynamically declare tehm.

Protected Member Functions
bool	updateDataNeeds (const std::vector< const DataObjID * > &input_data_in, const std::vector< const DataObjID * > &output_data_in, std::vector< const DataObjID * > &input_data_out, std::vector< const DataObjID * > &output_data_out, MsgStream &out)
	Update the data dependencies of all components once.

Protected Attributes
std::vector< DataObjID >	m_extraOutputIDs
DataObjIDPtrColl	m_inputHandles
DataObjIDPtrColl	m_outputHandles
std::unordered_map< IDynamicDataConsumer *, std::vector< Gaudi::Algorithm * > >	m_dynDataConsumer

Detailed Description

Helper class to gather all declared data IDs and propagate them to components which declare data dependencies dynamically.

Definition at line 25 of file DynamicDataHelper.h.

Member Function Documentation

addExtraDependencies()

StatusCode Ath::DynamicDataHelper::addExtraDependencies	(	IClassIDSvc &	clid_svc,
		std::vector< std::string > &	undeclared_output_data,
		MsgStream &	out )

Add extra output data which is not declared by any of the gathered components.

Parameters

clid_svc	the ClassIDSvc needed to translate the type name into a CLID.
undeclared_output_data	strings which are composed of the type and variable name separated by "/".
out	the message output stream used for error messages.

Definition at line 26 of file DynamicDataHelper.cxx.

                                                                                                                                         {
      std::stringstream error;
      if (!m_extraOutputIDs.empty()) {
         out << MSG::FATAL << "Logic erroor. Already added some extra output data IDs. This method can only be called once." << endmsg;
         return StatusCode::FAILURE;
      }
      m_extraOutputIDs.reserve( undeclared_output_data.size() );
      for(const std::string &type_and_name :  undeclared_output_data) {
         std::string::size_type pos = type_and_name.find('/');
         if (pos == std::string::npos) {
            error << " " << type_and_name;
         }
         else {
            std::string_view type_name(type_and_name.data(), pos);
            std::string_view var_name(&(type_and_name.data()[pos+1]), type_and_name.size()-pos-1);
            CLID clid;
            if (clid_svc.getIDOfTypeName(std::string(type_name), clid).isFailure() ) {
               // out << MSG::FATAL << " Failed to get CLID for " << type_name << endmsg;
               // return StatusCode::FAILURE;
               error << " no clid: "  << type_name;
            }
            else {
               m_extraOutputIDs.push_back( DataObjID(clid, std::string(var_name)) );
               if (msgLvl(out,MSG::VERBOSE)) {
                  out << MSG::VERBOSE << "DEBUG add extra dependency " << type_name << " / " << var_name << " -> " << clid << endmsg;
               }
            }
         }
      }
      if (!error.str().empty()) {
         out << MSG::FATAL << "Invaid alements in property " << error.str().c_str() << endmsg;
         return StatusCode::FAILURE;
      }
      for (const DataObjID &id : m_extraOutputIDs ) {
         m_outputHandles.insert( &id );
      }
      return StatusCode::SUCCESS;
   }

gatherDataHandlesAndDynamicConsumers()

void Ath::DynamicDataHelper::gatherDataHandlesAndDynamicConsumers	(	const std::string &	parent_name,
		Gaudi::Algorithm *	theAlgorithm )

Gather the input and output data declared by the given algorithm, its child algorithms and their tools.

Parameters

parent_name	the name of the parent component used in messsages
theAlgorithm	the top algorithm to start the collection Additionally also all components are collected which dynamically declare their data dependencies.

Definition at line 65 of file DynamicDataHelper.cxx.

                                                                                                                {
         //      |> debugging
         auto algorithm_visitor =
            [this](Gaudi::Algorithm *an_alg) {
               IDynamicDataConsumer *a_dyn_data_consumer=dynamic_cast<IDynamicDataConsumer *>(an_alg);
               if (a_dyn_data_consumer) {
                  std::vector<Gaudi::Algorithm *> &alg_list = m_dynDataConsumer[a_dyn_data_consumer];
                  if (std::find(alg_list.begin(),alg_list.end(),an_alg)==alg_list.end()) {
                     alg_list.push_back(an_alg);
                  }
               }
               // have to collect input and output handles because the sequence will only collect them  after initialize
               insertHandles(m_inputHandles, an_alg->inputHandles());
               insertHandles(m_outputHandles, an_alg->outputHandles());
               std::vector<IAlgTool *> &tools ATLAS_THREAD_SAFE
                  = const_cast< std::vector<IAlgTool *> &>(const_cast<const Gaudi::Algorithm *>(an_alg)->tools());
               //                               |> debugging
               auto tool_visitor = [this, an_alg](IAlgTool *alg_tool) {
                  IDynamicDataConsumer *a_dyn_data_consumer=dynamic_cast<IDynamicDataConsumer *>(alg_tool);
                  if (a_dyn_data_consumer) {
                     std::vector<Gaudi::Algorithm *> &alg_list = m_dynDataConsumer[a_dyn_data_consumer];
                     if (std::find(alg_list.begin(),alg_list.end(),an_alg)==alg_list.end()) {
                        alg_list.push_back(an_alg);
                     }
                  }
                  if (auto* tool_impl = dynamic_cast<AlgTool*>( alg_tool ); tool_impl) {
                     insertHandles(m_inputHandles, tool_impl->inputHandles());
                     insertHandles(m_outputHandles, tool_impl->outputHandles());
                  }
               };
               xGaudi::ToolVisitor::visit( tools,tool_visitor);
            };
         xGaudi::AlgorithmVisitor::visit({theAlgorithm},algorithm_visitor);
   }

updateDataNeeds() [1/2]

bool Ath::DynamicDataHelper::updateDataNeeds ( const std::vector< const DataObjID * > & input_data_in, const std::vector< const DataObjID * > & output_data_in, std::vector< const DataObjID * > & input_data_out, std::vector< const DataObjID * > & output_data_out, MsgStream & out )

protected

Update the data dependencies of all components once.

Parameters

input_data_in	IDs of all declared input data
output_data_in	IDs of all declared output data
input_data_out	IDs of newly declared input data in this iteration
output_data_out	IDs of newly declared input data in this iteration

Returns

true if new input or output data was declared.

Definition at line 121 of file DynamicDataHelper.cxx.

                                                           {
      bool updated=false;
      if (msgLvl(out,MSG::VERBOSE)) {
         out<< MSG::VERBOSE << " inputs:";
         for (const DataObjID *id : input_data_in) {
            out << " " << *id ;
         }
         out << endmsg;
         out << MSG::VERBOSE << " outputs:";
         for (const DataObjID *id : output_data_in) {
            out << " " << *id ;
         }
         out << endmsg;
      }
      for (std::pair<IDynamicDataConsumer * const,std::vector<Gaudi::Algorithm *> > &dyn_data_consumer :  m_dynDataConsumer ) {
         std::vector<Gaudi::DataHandle *> tmp_new_input_handles;
         std::vector<Gaudi::DataHandle *> tmp_new_output_handles;
         bool ret = dyn_data_consumer.first->updateDataNeeds(input_data_in, output_data_in, tmp_new_input_handles, tmp_new_output_handles);
         if (msgLvl(out,MSG::VERBOSE)) {
            out << MSG::VERBOSE << " new data for";
            for (const Gaudi::Algorithm *parent_alg : dyn_data_consumer.second) {
               out << " " << parent_alg->name();
            }
            out << " i:" << tmp_new_input_handles.size()
                << " o:" << tmp_new_output_handles.size()
                << endmsg;
         }
         updated |=  ret;
         if (ret) {
            if (msgLvl(out,MSG::DEBUG)) {
               if (Gaudi::Algorithm * const an_alg = dynamic_cast<Gaudi::Algorithm * const>(dyn_data_consumer.first); an_alg) {
                  out << MSG::DEBUG << an_alg->name() << " updated its data needs." << endmsg;
                  // DEBUG:
                  out << MSG::DEBUG << an_alg->name() << " inputs:";
                     for (const Gaudi::DataHandle *handle : an_alg->inputHandles()) {
                        out << " " << handle->fullKey();
                     }
                     out << endmsg;
               }
               else if (AlgTool *alg_tool = dynamic_cast<AlgTool * const>(dyn_data_consumer.first); alg_tool) {
                  out << MSG::DEBUG << alg_tool->name() << " updated its data needs." << endmsg;
                  // DEBUG:
                  out << MSG::DEBUG << alg_tool->name() << " inputs:";
                  for (const Gaudi::DataHandle *handle : alg_tool->inputHandles()) {
                     out << " " << handle->fullKey();
                  }
                  out << endmsg;
               }
               else {
                  out << MSG::WARNING << "Unknown dynamic data consumer type " << typeid(dyn_data_consumer.first).name() << endmsg;
               }
            }
         }
         for (Gaudi::Algorithm *parent_alg : dyn_data_consumer.second) {
            input_data_out.reserve(input_data_out.size()+tmp_new_input_handles.size());
            for (Gaudi::DataHandle *a_handle : tmp_new_input_handles) {
               parent_alg->addDependency(a_handle->fullKey(), Gaudi::DataHandle::Reader);
               input_data_out.push_back(&(a_handle->fullKey()));
               if (msgLvl(out,MSG::DEBUG)) out << MSG::DEBUG << " addDependency new input for " << parent_alg->name() << " "
                                               << a_handle->fullKey().className() << " / " <<  a_handle->objKey() << endmsg;
            }
            output_data_out.reserve(output_data_out.size()+tmp_new_output_handles.size());
            for (Gaudi::DataHandle *a_handle : tmp_new_output_handles) {
               parent_alg->addDependency(a_handle->fullKey(), Gaudi::DataHandle::Writer);
               output_data_out.push_back(&(a_handle->fullKey()));
               if (msgLvl(out,MSG::DEBUG)) out << MSG::DEBUG << " addDependency new output for " << parent_alg->name() << " "
                                               << a_handle->fullKey().className() << " / "  << a_handle->objKey() << endmsg;
            }
         }
      }
      return updated;
   }

updateDataNeeds() [2/2]

void Ath::DynamicDataHelper::updateDataNeeds	(	unsigned int	max_pass,
		MsgStream &	out )

Update the data dependencies of all components which dynamically declare tehm.

Parameters

max_pass	maximum number of iterations
out	the message stream of the parent component The update happens iteratively until non of the components declares new output data, but at most max_pass times.

Definition at line 100 of file DynamicDataHelper.cxx.

                                                           {
      if (msgLvl(out,MSG::VERBOSE)) out << MSG::VERBOSE << "Allow dynamic data consumers to update their data dependencies." << endmsg;
      std::vector<const DataObjID *> all_input_data;
      std::vector<const DataObjID *> all_output_data;
      all_input_data.insert( all_input_data.end(), m_inputHandles.begin(), m_inputHandles.end());
      all_output_data.insert( all_output_data.end(), m_outputHandles.begin(), m_outputHandles.end());
 
      std::vector<const DataObjID *> new_input_data;
      std::vector<const DataObjID *> new_output_data;
      unsigned int pass_i=max_pass;
      unsigned last_out_size=new_output_data.size();
      for (; --pass_i>0 && updateDataNeeds(all_input_data, all_output_data, new_input_data, new_output_data,out); ) {
         if (last_out_size == new_output_data.size() ) break;
         last_out_size=new_output_data.size();
      };
      if (last_out_size != new_output_data.size()) {
         out << MSG::WARNING << "Not iterating any further, although after " << max_pass << " iterations there are still algorithms which updated their data needs. " << endmsg;
      }
   }

Member Data Documentation

m_dynDataConsumer

std::unordered_map< IDynamicDataConsumer *,std::vector<Gaudi::Algorithm *> > Ath::DynamicDataHelper::m_dynDataConsumer

protected

Definition at line 69 of file DynamicDataHelper.h.

m_extraOutputIDs

std::vector<DataObjID> Ath::DynamicDataHelper::m_extraOutputIDs

protected

Definition at line 65 of file DynamicDataHelper.h.

m_inputHandles

DataObjIDPtrColl Ath::DynamicDataHelper::m_inputHandles

protected

Definition at line 66 of file DynamicDataHelper.h.

m_outputHandles

DataObjIDPtrColl Ath::DynamicDataHelper::m_outputHandles

protected

Definition at line 67 of file DynamicDataHelper.h.

---

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

• DynamicDataHelper.h
• DynamicDataHelper.cxx