| The Gaudi Framework v28r2-patches (bc4ad17a)

- Main Page
- Related Pages
- Modules
- Namespaces
- Classes
- Files

- File List
- File Members

DataFlowManager.cpp
Go to the documentation of this file.
1 #include "DataFlowManager.h"
2
3 //---------------------------------------------------------------------------
4 // Static members
5 std::vector< DataFlowManager::dependency_bitset > DataFlowManager::m_algosRequirements;
6 std::unordered_map<DataObjID,long int,DataObjID_Hasher> DataFlowManager::m_productName_index_map;
7 std::vector<DataObjID> DataFlowManager::m_productName_vec;
8 //---------------------------------------------------------------------------
13 DataFlowManager::DataFlowManager(algosDependenciesCollection algosDependencies){
14
15 // Count how many products are actually requested
16 unsigned int nProducts(0);
17 for (auto& thisAlgoDependencies : algosDependencies){
18 nProducts += thisAlgoDependencies.size();
19 }
20 m_dataObjectsCatalog.resize(nProducts);
21
22 // If it's not the first instance, nothing to do here
23 if (m_algosRequirements.size()==0){
24 // This is the first instance, compile the requirements
25 m_algosRequirements.resize(algosDependencies.size(),dependency_bitset(nProducts));
26
27 // Fill the requirements
28 unsigned int algoIndex=0;
29 long int productIndex=0;
30 for (auto& thisAlgoDependencies : algosDependencies){
31 // Make a local alias for better readability
32 auto& dependency_bits = m_algosRequirements[algoIndex];
33 for (auto& product : thisAlgoDependencies){
34 auto ret_val = m_productName_index_map.insert(std::pair<DataObjID, long int>(product,productIndex));
35 // insert successful means product wasn't known before. So increment counter
36 if (ret_val.second==true) ++productIndex;
37 // in any case the return value holds the proper product index
38 dependency_bits[ret_val.first->second] = true;
39 }// end loop on products on which the algo depends
40 algoIndex++;
41 }// end loop on algorithms
42
43 // Now the vector of products
44 m_productName_vec.resize(m_productName_index_map.size());
45 for (auto& name_idx : m_productName_index_map)
46 m_productName_vec[name_idx.second]=name_idx.first;
47 }
48
49 }
50
51 //---------------------------------------------------------------------------
52
57 bool DataFlowManager::canAlgorithmRun(unsigned int iAlgo){
58 const dependency_bitset& thisAlgoRequirements = m_algosRequirements[iAlgo];
59 return thisAlgoRequirements.is_subset_of(m_dataObjectsCatalog);
60 }
61
62 //---------------------------------------------------------------------------
63
65 void DataFlowManager::updateDataObjectsCatalog(const DataObjIDColl& newProducts){
66 for (const auto& new_product : newProducts){
67 m_fc.insert(new_product);
68 const int index = productName2index(new_product);
69 if (index>=0)
70 m_dataObjectsCatalog[index]=true;
71 }
72
73 }
74
75 //---------------------------------------------------------------------------
76
78 void DataFlowManager::reset(){
79 m_dataObjectsCatalog.reset();
80 m_fc.clear();
81 }
82
83 //---------------------------------------------------------------------------
84
86 DataObjIDColl DataFlowManager::content() const{
87 DataObjIDColl products;
88 for (const auto& p : m_fc) {
89 products.insert( p );
90 }
91 return products;
92 }
93
94 //---------------------------------------------------------------------------
96 DataObjIDColl DataFlowManager::dataDependencies(unsigned int iAlgo) const{
97 // with move semantics this is ~fine
98 DataObjIDColl deps;
99 for (unsigned int i=0;i<m_productName_vec.size();++i){
100 if (m_algosRequirements[iAlgo][i])
101 deps.insert(m_productName_vec[i]);
102 }
103 return deps;
104 }
105
106 //---------------------------------------------------------------------------
DataFlowManager::dependency_bitset
boost::dynamic_bitset dependency_bitset
Type holding the dependencies for one single algorithm.
Definition: DataFlowManager.h:33
DataFlowManager::updateDataObjectsCatalog
void updateDataObjectsCatalog(const DataObjIDColl &newProducts)
Update the catalog of available products in the slot.
Definition: DataFlowManager.cpp:65
DataFlowManager::dataDependencies
DataObjIDColl dataDependencies(unsigned int iAlgo) const
Get the dependencies of a single algo;.
Definition: DataFlowManager.cpp:96
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:66
DataFlowManager::content
DataObjIDColl content() const
Get the content of the catalog.
Definition: DataFlowManager.cpp:86
DataFlowManager::m_productName_index_map
static std::unordered_map< productName_t, long int, DataObjID_Hasher > m_productName_index_map
Definition: DataFlowManager.h:70
DataFlowManager::m_fc
DataObjIDColl m_fc
Definition: DataFlowManager.h:59
DataFlowManager::m_algosRequirements
static std::vector< dependency_bitset > m_algosRequirements
Requirements of algos. Static since the same for all events.
Definition: DataFlowManager.h:64
std::vector::resize
T resize(T...args)
std::unordered_set< DataObjID, DataObjID_Hasher >
std::unordered_set::clear
T clear(T...args)
DataFlowManager::productName2index
long int productName2index(const productName_t &productName)
Simple helper method to convert the product name into an index.
Definition: DataFlowManager.h:72
std::pair
std::unordered_set::insert
T insert(T...args)
std::vector::size
T size(T...args)
std::vector
STL class.
DataFlowManager::reset
void reset()
Reset to default values.
Definition: DataFlowManager.cpp:78
DataFlowManager::m_dataObjectsCatalog
dependency_bitset m_dataObjectsCatalog
Catalog of the products in the whiteboard.
Definition: DataFlowManager.h:62
DataFlowManager::DataFlowManager
DataFlowManager(const std::list< IAlgorithm * > &)
Constructor.
Definition: DataFlowManager.h:37
DataFlowManager::canAlgorithmRun
bool canAlgorithmRun(unsigned int iAlgo)
Needed data products are available.
Definition: DataFlowManager.cpp:57
DataFlowManager.h
std::unordered_map< DataObjID, long int, DataObjID_Hasher >