DataFlowManager.cpp

Go to the documentation of this file.

#include "DataFlowManager.h"

//---------------------------------------------------------------------------
// Static members
std::vector<DataFlowManager::dependency_bitset> DataFlowManager::m_algosRequirements;
std::unordered_map<DataObjID, long int, DataObjID_Hasher> DataFlowManager::m_productName_index_map;
std::vector<DataObjID> DataFlowManager::m_productName_vec;
//---------------------------------------------------------------------------
DataFlowManager::DataFlowManager( algosDependenciesCollection algosDependencies )
{

  // 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;
  }
}

//---------------------------------------------------------------------------

bool DataFlowManager::canAlgorithmRun( unsigned int iAlgo )
{
  const dependency_bitset& thisAlgoRequirements = m_algosRequirements[iAlgo];
  return thisAlgoRequirements.is_subset_of( m_dataObjectsCatalog );
}

//---------------------------------------------------------------------------

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

//---------------------------------------------------------------------------

void DataFlowManager::reset()
{
  m_dataObjectsCatalog.reset();
  m_fc.clear();
}

//---------------------------------------------------------------------------

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

//---------------------------------------------------------------------------
DataObjIDColl DataFlowManager::dataDependencies( unsigned int iAlgo ) const
{
  // 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;
}

//---------------------------------------------------------------------------