The DataFlowManager takes care of keeping track of the dependencies of the algorithms in terms of dataObjects. More...

#include <GaudiHive/src/DataFlowManager.h>

Collaboration diagram for DataFlowManager:

[legend]

Public Types
typedef boost::dynamic_bitset	dependency_bitset
	Type holding the dependencies for one single algorithm. More...

typedef std::vector< DataObjIDColl >	algosDependenciesCollection

Public Member Functions
	DataFlowManager (const std::list< IAlgorithm * > &)
	Constructor. More...

	DataFlowManager (algosDependenciesCollection algoDependencies)
	Constructor (transitional, will be deprecated once handles are in place) More...

bool	canAlgorithmRun (unsigned int iAlgo)
	Needed data products are available. More...

void	updateDataObjectsCatalog (const DataObjIDColl &newProducts)
	Update the catalog of available products in the slot. More...

void	reset ()
	Reset to default values. More...

DataObjIDColl	content () const
	Get the content of the catalog. More...

DataObjIDColl	dataDependencies (unsigned int iAlgo) const
	Get the dependencies of a single algo;. More...

Private Types
typedef DataObjID	productName_t
	Track the products, assigning an index to them. Static since the same for all events. More...

Private Member Functions
long int	productName2index (const productName_t &productName)
	Simple helper method to convert the product name into an index. More...

DataObjID &	index2productName (const unsigned int i)
	Simple helper method to convert an index to a product name. More...

Private Attributes
DataObjIDColl	m_fc

dependency_bitset	m_dataObjectsCatalog
	Catalog of the products in the whiteboard. More...

Static Private Attributes
static std::vector< dependency_bitset >	m_algosRequirements
	Requirements of algos. Static since the same for all events. More...

static std::vector< DataObjID >	m_productName_vec
	Track the products, assigning an index to them. Static since the same for all events. More...

static std::unordered_map< productName_t, long int, DataObjID_Hasher >	m_productName_index_map

Detailed Description

The DataFlowManager takes care of keeping track of the dependencies of the algorithms in terms of dataObjects.

One instance of the DataFlowManager is responsible for one event.

Author: Danilo Piparo, Benedikt Hegner

Version: 1.0

Definition at line 28 of file DataFlowManager.h.

Member Typedef Documentation

typedef std::vector<DataObjIDColl> DataFlowManager::algosDependenciesCollection

Definition at line 35 of file DataFlowManager.h.

typedef boost::dynamic_bitset DataFlowManager::dependency_bitset

Type holding the dependencies for one single algorithm.

Definition at line 33 of file DataFlowManager.h.

typedef DataObjID DataFlowManager::productName_t

private

Track the products, assigning an index to them. Static since the same for all events.

Definition at line 67 of file DataFlowManager.h.

Constructor & Destructor Documentation

DataFlowManager::DataFlowManager ( const std::list< IAlgorithm * > & )

inline

Constructor.

Definition at line 37 of file DataFlowManager.h.

37 : m_dataObjectsCatalog( 0 ){};

DataFlowManager::m_dataObjectsCatalog

dependency_bitset m_dataObjectsCatalog

Catalog of the products in the whiteboard.

Definition: DataFlowManager.h:61

DataFlowManager::DataFlowManager ( algosDependenciesCollection algoDependencies )

Constructor (transitional, will be deprecated once handles are in place)

If this is the first instance, the constructor fills the requirements of all algorithms and indexes the data products.

Definition at line 13 of file DataFlowManager.cpp.

 {
 
   // Count how many products are actually requested
   unsigned int nProducts( 0 );
   for ( auto& thisAlgoDependencies : algosDependencies ) {
     nProducts += thisAlgoDependencies.size();
   }
   m_dataObjectsCatalog.resize( nProducts );
 
   // If it's not the first instance, nothing to do here
   if ( m_algosRequirements.size() == 0 ) {
     // This is the first instance, compile the requirements
     m_algosRequirements.resize( algosDependencies.size(), dependency_bitset( nProducts ) );
 
     // Fill the requirements
     unsigned int algoIndex = 0;
     long int productIndex  = 0;
     for ( auto& thisAlgoDependencies : algosDependencies ) {
       // Make a local alias for better readability
       auto& dependency_bits = m_algosRequirements[algoIndex];
       for ( auto& product : thisAlgoDependencies ) {
         auto ret_val = m_productName_index_map.insert( std::pair<DataObjID, long int>( product, productIndex ) );
         // insert successful means product wasn't known before. So increment counter
         if ( ret_val.second == true ) ++productIndex;
         // in any case the return value holds the proper product index
         dependency_bits[ret_val.first->second] = true;
       } // end loop on products on which the algo depends
       algoIndex++;
     } // end loop on algorithms
 
     // Now the vector of products
     m_productName_vec.resize( m_productName_index_map.size() );
     for ( auto& name_idx : m_productName_index_map ) m_productName_vec[name_idx.second] = name_idx.first;
   }
 }

Member Function Documentation

bool DataFlowManager::canAlgorithmRun ( unsigned int iAlgo )

Needed data products are available.

This method is called to know if the algorithm can run according to what data objects are in the event.

Definition at line 56 of file DataFlowManager.cpp.

 {
   const dependency_bitset& thisAlgoRequirements = m_algosRequirements[iAlgo];
   return thisAlgoRequirements.is_subset_of( m_dataObjectsCatalog );
 }

DataObjIDColl DataFlowManager::content ( ) const

Get the content of the catalog.

Get the content (inefficient, only for debug in case of crashes)

Definition at line 86 of file DataFlowManager.cpp.

 {
   DataObjIDColl products;
   for ( const auto& p : m_fc ) {
     products.insert( p );
   }
   return products;
 }

DataObjIDColl DataFlowManager::dataDependencies ( unsigned int iAlgo ) const

Get the dependencies of a single algo;.

Get the data dependencies (inefficient, only for debug in case of crashes)

Definition at line 97 of file DataFlowManager.cpp.

 {
   // with move semantics this is ~fine
   DataObjIDColl deps;
   for ( unsigned int i = 0; i < m_productName_vec.size(); ++i ) {
     if ( m_algosRequirements[iAlgo][i] ) deps.insert( m_productName_vec[i] );
   }
   return deps;
 }

DataObjID& DataFlowManager::index2productName ( const unsigned int i )

inlineprivate

Simple helper method to convert an index to a product name.

Definition at line 76 of file DataFlowManager.h.

76 { return m_productName_vec[i]; };

DataFlowManager::m_productName_vec

static std::vector< DataObjID > m_productName_vec

Track the products, assigning an index to them. Static since the same for all events.

Definition: DataFlowManager.h:65

long int DataFlowManager::productName2index ( const productName_t & productName )

inlineprivate

Simple helper method to convert the product name into an index.

Definition at line 71 of file DataFlowManager.h.

   {
     return m_productName_index_map.count( productName ) > 0 ? m_productName_index_map[productName] : -1;
   };

void DataFlowManager::reset ( )

Reset to default values.

Reset the slot for a new event.

Definition at line 77 of file DataFlowManager.cpp.

 {
   m_dataObjectsCatalog.reset();
   m_fc.clear();
 }

void DataFlowManager::updateDataObjectsCatalog ( const DataObjIDColl & newProducts )

Update the catalog of available products in the slot.

Definition at line 65 of file DataFlowManager.cpp.

 {
   for ( const auto& new_product : newProducts ) {
     m_fc.insert( new_product );
     const int index                               = productName2index( new_product );
     if ( index >= 0 ) m_dataObjectsCatalog[index] = true;
   }
 }

Member Data Documentation

std::vector< DataFlowManager::dependency_bitset > DataFlowManager::m_algosRequirements

staticprivate

Requirements of algos. Static since the same for all events.

Definition at line 63 of file DataFlowManager.h.

dependency_bitset DataFlowManager::m_dataObjectsCatalog

private

Catalog of the products in the whiteboard.

Definition at line 61 of file DataFlowManager.h.

DataObjIDColl DataFlowManager::m_fc

private

Definition at line 58 of file DataFlowManager.h.

std::unordered_map< DataObjID, long int, DataObjID_Hasher > DataFlowManager::m_productName_index_map

staticprivate

Definition at line 69 of file DataFlowManager.h.

std::vector< DataObjID > DataFlowManager::m_productName_vec

staticprivate

Track the products, assigning an index to them. Static since the same for all events.

Definition at line 65 of file DataFlowManager.h.

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

GaudiHive/src/DataFlowManager.h
GaudiHive/src/DataFlowManager.cpp

Public Types

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation