Line data    Source code

       1              : #include "confmodel/Application.hpp"
       2              : #include "confmodel/Resource.hpp"
       3              : #include "confmodel/ResourceSet.hpp"
       4              : #include "confmodel/Segment.hpp"
       5              : #include "confmodel/Session.hpp"
       6              : 
       7              : #include "confmodel/confmodelIssues.hpp"
       8              : #include "confmodel/DisabledResources.hpp"
       9              : 
      10              : #include "logging/Logging.hpp"
      11              : 
      12              : #include "confmodel/test_circular_dependency.hpp"
      13              : 
      14              : using namespace dunedaq::confmodel;
      15              : 
      16              : ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
      17              : 
      18              : 
      19            5 : DisabledResources::DisabledResources(const ResourceSet* root,
      20            5 :                                      std::vector<const Resource*> initial_list)
      21              : {
      22            5 :   TLOG_DEBUG(2) <<  "construct the object from Resource " << root->UID() ;
      23            5 :   update(root, initial_list);
      24            5 : }
      25              : 
      26              : 
      27           24 : void DisabledResources::update(const ResourceSet* root,
      28              :                                std::vector<const Resource*> initial_list) {
      29              : 
      30           24 :   m_disabled.clear();
      31              : 
      32           24 :   m_initialised = true;
      33              : 
      34              :   // get list of all root's resource-sets also test any
      35              :   // circular dependencies between segments and resource sets
      36           24 :   TestCircularDependency cd_fuse("component \'is-disabled\' status", root);
      37           24 :   std::vector<const ResourceSet*> resource_sets;
      38           24 :   std::set<const Resource*> simple_resources;
      39           24 :   fill(*root, resource_sets, simple_resources, cd_fuse);
      40              : 
      41           54 :   for (auto & comp : initial_list) {
      42           30 :     disable(*comp);
      43           30 :     TLOG_DEBUG(6) << comp->UID() << " is disabled in session";
      44           30 :     if (const ResourceSet * rs = comp->cast<ResourceSet>()) {
      45            5 :       disable_children(*rs);
      46              :     }
      47              :   }
      48              : 
      49           24 :   for (unsigned long count = 1; true; ++count) {
      50           32 :     const unsigned long num(size()); // Remember current size
      51              : 
      52           32 :     TLOG_DEBUG(6) <<  "before auto-disabling iteration " << count << " the number of disabled components is " << num ;
      53          153 :     for (const auto& res_set : resource_sets) {
      54          121 :       if (is_enabled(res_set)) {
      55           96 :         if (res_set->compute_disabled_state(m_disabled)) {
      56            7 :           TLOG_DEBUG(6) <<  "disable custom resource-set- " << res_set->UID() << " because children are disabled" ;
      57            7 :           disable(*res_set);
      58            7 :           disable_children(*res_set);
      59              :         }
      60              :       }
      61              :     }
      62              : 
      63          227 :     for (auto& res : simple_resources) {
      64          195 :       if (is_enabled(res) && res->compute_disabled_state(m_disabled)) {
      65            1 :         TLOG_DEBUG(6) << "Marking " << res->UID() << " as disabled\n";
      66            1 :         disable(*res);
      67              :       }
      68              :     }
      69              : 
      70           32 :     if (size() == num) {
      71           24 :       TLOG_DEBUG(6) <<  "after " << count << " iteration(s) auto-disabling algorithm found no newly disabled sets, exiting loop ..." ;
      72           24 :       break;
      73              :     }
      74              : 
      75            8 :     unsigned int iLimit(1000);
      76            8 :     if (count > iLimit) {
      77            0 :       ers::error(ReadMaxAllowedIterations(ERS_HERE, iLimit));
      78            0 :       break;
      79              :     }
      80            8 :   }
      81           24 : }
      82              : 
      83              : // fill data from resource sets
      84           98 : void DisabledResources::fill(const ResourceSet& rs,
      85              :                              std::vector<const ResourceSet*>& all_resource_sets,
      86              :                              std::set<const Resource*>& simple_resources,
      87              :                              TestCircularDependency& cd_fuse)
      88              : {
      89           98 :   TLOG_DEBUG(6) << "rs.UID=" << rs.UID() << ", class=" << rs.class_name();
      90           98 :   all_resource_sets.push_back(&rs);
      91           98 :   auto rptr = &rs;
      92           98 :   if (rptr->cast<Resource>() == nullptr) {
      93            0 :     throw (MissingConstructor(ERS_HERE, "Resource", rs.full_name()));
      94              :   }
      95          339 :   for (auto & res : rs.contained_resources()) {
      96          241 :     AddTestOnCircularDependency add_fuse_test(cd_fuse, res);
      97          241 :     if (const ResourceSet * rs2 = res->cast<ResourceSet>()) {
      98           74 :       fill(*rs2, all_resource_sets, simple_resources, cd_fuse);
      99              :     } else {
     100          167 :         simple_resources.insert(res);
     101              :     }
     102          339 :   }
     103           98 : }
     104              : 
     105              : 
     106              : 
     107              : void
     108           20 : DisabledResources::disable_children(const ResourceSet& rs)
     109              : {
     110           20 :   TLOG_DEBUG(6) << "Disabling children of " << rs.UID();
     111           80 :   for (auto & res : rs.contained_resources()) {
     112           60 :     TLOG_DEBUG(6) << "Disabling child " << res->UID();
     113           60 :     disable(*res);
     114           60 :     if (const auto * rs2 = res->cast<ResourceSet>()) {
     115            8 :       disable_children(*rs2);
     116              :     }
     117           20 :   }
     118           20 : }
     119              :