src/engine/Bloc_impl.cxx

   1 // Copyright (C) 2006-2019  CEA/DEN, EDF R&D
   2 //
   3 // This library is free software; you can redistribute it and/or
   4 // modify it under the terms of the GNU Lesser General Public
   5 // License as published by the Free Software Foundation; either
   6 // version 2.1 of the License, or (at your option) any later version.
   7 //
   8 // This library is distributed in the hope that it will be useful,
   9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11 // Lesser General Public License for more details.
  12 //
  13 // You should have received a copy of the GNU Lesser General Public
  14 // License along with this library; if not, write to the Free Software
  15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  16 //
  17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  18 //
  19
  20 #include "Bloc.hxx"
  21 #include "Proc.hxx"
  22 #include "Visitor.hxx"
  23 #include "ForEachLoop.hxx"
  24 #include "InlineNode.hxx"
  25 #include "HomogeneousPoolContainer.hxx"
  26
  27 using namespace YACS::ENGINE;
  28
  29 void Bloc::fitToPlayGround(const PlayGround *pg)
  30 {
  31   static const char MSG[]="Bloc::fitToPlayGround : Not implemented yet for this type of node !";
  32   class MyVisitor : public Visitor
  33     {
  34     public:
  35       MyVisitor(ComposedNode *root):Visitor(root),_lev(0),_max_lev(0) { }
  36       void visitBloc(Bloc *node) { node->ComposedNode::accept(this); }
  37       void visitElementaryNode(ElementaryNode *node) { }
  38       void visitForEachLoop(ForEachLoop *node)
  39       {
  40         _max_lev=std::max(_max_lev,_lev);
  41         {
  42           _lev++;
  43           node->ComposedNode::accept(this);
  44           _lev--;
  45         }
  46         node->edGetNbOfBranchesPort()->edInit(1);
  47         if(_lev==_max_lev)
  48           {
  49           _fes.push_back(node);// locate all leaves ForEach
  50           }
  51         if(_lev==0)
  52           _max_lev=0;
  53         }
  54       void visitForEachLoopDyn(ForEachLoopDyn *node) { throw YACS::Exception(MSG); }
  55       void visitOptimizerLoop(OptimizerLoop *node) { throw YACS::Exception(MSG); }
  56       void visitDynParaLoop(DynParaLoop *node) { throw YACS::Exception(MSG); }
  57       void visitForLoop(ForLoop *node) { throw YACS::Exception(MSG); }
  58       void visitInlineNode(InlineNode *node)
  59       {
  60           Container *cont(node->getContainer());
  61           HomogeneousPoolContainer *cont2(dynamic_cast<HomogeneousPoolContainer *>(cont));
  62           if(!cont2)
  63             return ;
  64           _cont.push_back(cont2);
  65           _cont2.insert(cont2);
  66       }
  67       void visitInlineFuncNode(InlineFuncNode *node) { throw YACS::Exception(MSG); }
  68       void visitLoop(Loop *node) { throw YACS::Exception(MSG); }
  69       void visitProc(Proc *node) { node->ComposedNode::accept(this); }
  70       void visitServiceNode(ServiceNode *node) { throw YACS::Exception(MSG); }
  71       void visitServerNode(ServerNode *node) { throw YACS::Exception(MSG); }
  72       void visitServiceInlineNode(ServiceInlineNode *node) { throw YACS::Exception(MSG); }
  73       void visitSwitch(Switch *node) { throw YACS::Exception(MSG); }
  74       void visitWhileLoop(WhileLoop *node) { throw YACS::Exception(MSG); }
  75       void visitPresetNode(DataNode *node) { throw YACS::Exception(MSG); }
  76       void visitOutNode(DataNode *node) { throw YACS::Exception(MSG); }
  77       void visitStudyInNode(DataNode *node) { throw YACS::Exception(MSG); }
  78       void visitStudyOutNode(DataNode *node) { throw YACS::Exception(MSG); }
  79     public:
  80       std::list<ForEachLoop *> _fes;
  81       std::list< HomogeneousPoolContainer *> _cont;
  82       std::set< HomogeneousPoolContainer * > _cont2;
  83       int _lev;
  84       int _max_lev;
  85   };
  86   YACS::BASES::AutoRefCnt<PartDefinition> pd(new AllPartDefinition(pg));
  87   std::map<ComposedNode *,YACS::BASES::AutoRefCnt<PartDefinition> > zeMap;
  88   MyVisitor vis(this);
  89   this->accept(&vis);
  90   for(std::list<ForEachLoop *>::const_iterator it=vis._fes.begin();it!=vis._fes.end();it++)
  91     (*it)->edGetNbOfBranchesPort()->edInit(1);
  92   this->removeRecursivelyRedundantCL();
  93   if (this->getMaxLevelOfParallelism() > pg->getNumberOfCoresAvailable())
  94     throw YACS::Exception("Bloc::fitToPlayGround : Not enough cores available to run the calculation !");
  95   this->partitionRegardingDPL(pd,zeMap);
  96   this->accept(&vis);
  97   for(std::list<ForEachLoop *>::const_iterator it=vis._fes.begin();it!=vis._fes.end();it++)
  98     {
  99       std::map<ComposedNode *,YACS::BASES::AutoRefCnt<PartDefinition> >::iterator it2(zeMap.find(*it));
 100       if(it2==zeMap.end())
 101         throw YACS::Exception("Bloc::fitToPlayGround : internal error !");
 102       int maxLev((*it)->getExecNode()->getMaxLevelOfParallelism());
 103       int a((*it2).second->getNumberOfCoresConsumed());
 104       int res(a/maxLev);
 105       (*it)->edGetNbOfBranchesPort()->edInit(res);
 106     }
 107   for(std::set< HomogeneousPoolContainer * >::const_iterator it=vis._cont2.begin();it!=vis._cont2.end();it++)
 108     (*it)->setSizeOfPool(pg->getNumberOfWorkers((*it)->getNumberOfCoresPerWorker()));
 109   //FIXME
 110 }