src/engine/DeploymentTree.cxx

   1 //  Copyright (C) 2006-2008  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.
   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 #include "DeploymentTree.hxx"
  20 #include "ComponentInstance.hxx"
  21 #include "Container.hxx"
  22 #include "Scheduler.hxx"
  23 #include "Task.hxx"
  24
  25 using namespace std;
  26 using namespace YACS::ENGINE;
  27
  28 DeploymentTreeOnHeap::DeploymentTreeOnHeap():_cnt(1)
  29 {
  30 }
  31
  32 DeploymentTreeOnHeap::~DeploymentTreeOnHeap()
  33 {
  34 }
  35
  36 bool DeploymentTreeOnHeap::decrRef()
  37 {
  38   bool ret=(--_cnt==0);
  39   if(ret)
  40     delete this;
  41   return ret;
  42 }
  43
  44 void DeploymentTreeOnHeap::incrRef() const
  45 {
  46   _cnt++;
  47 }
  48
  49 unsigned char DeploymentTreeOnHeap::appendTask(Task *task, Scheduler *cloner)
  50 {
  51   if(!task)
  52     return DeploymentTree::NULL_TASK;
  53   if(!task->isDeployable())//Task not needed to be placed.
  54     return DeploymentTree::NOT_DEPLOYABLE_TASK;
  55   ComponentInstance *ci=task->getComponent();
  56   if(!ci)//Task is not attached to a Component -> not needed to be placed.
  57     {
  58       _freePlacableTasks.push_back(pair<Task *,Scheduler *>(task,cloner));
  59       return DeploymentTree::DEPLOYABLE_BUT_NOT_SPECIFIED;
  60     }
  61   Container *cont=ci->getContainer();
  62   vector< vector< vector< pair<Task *, Scheduler *> > > >::iterator iter1;
  63   vector< vector< pair<Task *, Scheduler * > > >::iterator iter2;
  64   vector< pair<Task *, Scheduler *> >::iterator iter3;
  65   for(iter1=_tree.begin();iter1!=_tree.end();iter1++)
  66     if(((*iter1)[0][0]).first->getComponent()->getContainer()==cont)
  67       break;
  68   if(iter1==_tree.end())
  69     {
  70       _tree.push_back(vector< vector< pair< Task *, Scheduler *> > >());
  71       iter1=_tree.end();
  72       iter1--;
  73     }
  74   for(iter2=(*iter1).begin();iter2!=(*iter1).end();iter2++)
  75     if(((*iter2)[0]).first->getComponent()==ci)
  76       break;
  77   if(iter2==(*iter1).end())
  78     {
  79       (*iter1).push_back(vector< pair< Task *, Scheduler *> >());
  80       iter2=(*iter1).end();
  81       iter2--;
  82     }
  83   for(iter3=(*iter2).begin();iter3!=(*iter2).end();iter3++)
  84     if((*iter3).first==task)
  85       return DeploymentTree::ALREADY_IN_TREE;
  86   if(!isConsistentTaskRegardingShCompInst(*iter2,cloner))
  87     return DeploymentTree::DUP_TASK_NOT_COMPATIBLE_WITH_EXISTING_TREE;
  88   (*iter2).push_back(pair<Task *,Scheduler *>(task,cloner));
  89   return DeploymentTree::APPEND_OK;
  90 }
  91
  92 unsigned DeploymentTreeOnHeap::getNumberOfCTDefContainer() const
  93 {
  94   vector< vector< vector< pair<Task *, Scheduler *> > > >::const_iterator iter1;
  95   vector< vector< pair<Task *, Scheduler * > > >::const_iterator iter2;
  96   vector< pair<Task *, Scheduler *> >::const_iterator iter3;
  97   unsigned ret=0;
  98   for(iter1=_tree.begin();iter1!=_tree.end();iter1++)
  99     {
 100       bool isCTDefSurely1=true;
 101       for(iter2=(*iter1).begin();iter2!=(*iter1).end() && isCTDefSurely1;iter2++)
 102         {
 103           bool isCTDefSurely2=true;
 104           for(iter3=(*iter2).begin();iter3!=(*iter2).end() && isCTDefSurely2;iter3++)
 105             if((*iter3).second!=0)
 106               isCTDefSurely2=false;
 107           if(isCTDefSurely2)
 108             isCTDefSurely1=true;
 109           else
 110             isCTDefSurely1=(((*iter2)[0].first)->getComponent()->isAttachedOnCloning());
 111         }
 112       Container *cont=((*iter1)[0][0].first)->getComponent()->getContainer();
 113       if(isCTDefSurely1)
 114         {
 115           if(cont)
 116             ret++;
 117         }
 118       else
 119         if(cont)
 120           if(cont->isAttachedOnCloning())
 121             ret++;
 122           else
 123             {
 124               unsigned val;
 125               if((*iter1)[0][0].second->isMultiplicitySpecified(val))
 126                 ret+=val;
 127             }
 128       }
 129   return ret;
 130 }
 131
 132 unsigned DeploymentTreeOnHeap::getNumberOfRTODefContainer() const
 133 {
 134   vector< vector< vector< pair<Task *, Scheduler *> > > >::const_iterator iter1;
 135   vector< vector< pair<Task *, Scheduler * > > >::const_iterator iter2;
 136   vector< pair<Task *, Scheduler *> >::const_iterator iter3;
 137   unsigned ret=0;
 138   for(iter1=_tree.begin();iter1!=_tree.end();iter1++)
 139     {
 140       bool isRTODefSurely1=true;
 141       for(iter2=(*iter1).begin();iter2!=(*iter1).end() && isRTODefSurely1;iter2++)
 142         {
 143           bool isRTODefSurely2=true;
 144           for(iter3=(*iter2).begin();iter3!=(*iter2).end() && isRTODefSurely2;iter3++)
 145             if((*iter3).second==0)
 146               isRTODefSurely2=false;
 147           if(isRTODefSurely2)
 148             isRTODefSurely1=!(((*iter2)[0].first)->getComponent()->isAttachedOnCloning());
 149           else
 150             isRTODefSurely1=false;
 151         }
 152       if(isRTODefSurely1)
 153         if(((*iter1)[0][0].first)->getComponent()->getContainer())
 154           if(!((*iter1)[0][0].first)->getComponent()->getContainer()->isAttachedOnCloning())
 155             ret++;
 156     }
 157   return ret;
 158 }
 159
 160 unsigned DeploymentTreeOnHeap::getNumberOfCTDefComponentInstances() const
 161 {
 162   vector< vector< vector< pair<Task *, Scheduler *> > > >::const_iterator iter1;
 163   vector< vector< pair<Task *, Scheduler * > > >::const_iterator iter2;
 164   vector< pair<Task *, Scheduler *> >::const_iterator iter3;
 165   unsigned ret=0;
 166   for(iter1=_tree.begin();iter1!=_tree.end();iter1++)
 167     for(iter2=(*iter1).begin();iter2!=(*iter1).end();iter2++)
 168       {
 169         bool isCTDefSurely=true;
 170         for(iter3=(*iter2).begin();iter3!=(*iter2).end() && isCTDefSurely;iter3++)
 171           if((*iter3).second!=0)
 172             isCTDefSurely=false;
 173         if(isCTDefSurely)
 174           ret++;
 175         else
 176           if(((*iter2)[0].first)->getComponent()->isAttachedOnCloning())
 177             ret++;
 178       }
 179   return ret;
 180 }
 181
 182 unsigned DeploymentTreeOnHeap::getNumberOfRTODefComponentInstances() const
 183 {
 184   vector< vector< vector< pair<Task *, Scheduler *> > > >::const_iterator iter1;
 185   vector< vector< pair<Task *, Scheduler * > > >::const_iterator iter2;
 186   vector< pair<Task *, Scheduler *> >::const_iterator iter3;
 187   unsigned ret=0;
 188   for(iter1=_tree.begin();iter1!=_tree.end();iter1++)
 189     for(iter2=(*iter1).begin();iter2!=(*iter1).end();iter2++)
 190       {
 191         bool isRTODef=false;
 192         for(iter3=(*iter2).begin();iter3!=(*iter2).end() && !isRTODef;iter3++)
 193           if((*iter3).second!=0)
 194             isRTODef=true;
 195         if(isRTODef && !((*iter2)[0].first)->getComponent()->isAttachedOnCloning())
 196           ret++;
 197       }
 198   return ret;
 199 }
 200
 201 std::vector<Container *> DeploymentTreeOnHeap::getAllContainers() const
 202 {
 203   vector<Container *> ret;
 204   vector< vector< vector< pair<Task *, Scheduler *> > > >::const_iterator iter1;
 205   for(iter1=_tree.begin();iter1!=_tree.end();iter1++)
 206     ret.push_back(((*iter1)[0][0].first)->getComponent()->getContainer());
 207   return ret;
 208 }
 209
 210 std::vector<Container *> DeploymentTreeOnHeap::getAllCTDefContainers() const
 211 {
 212   vector<Container *> ret;
 213   vector< vector< vector< pair<Task *, Scheduler *> > > >::const_iterator iter1;
 214   vector< vector< pair<Task *, Scheduler * > > >::const_iterator iter2;
 215   vector< pair<Task *, Scheduler *> >::const_iterator iter3;
 216   for(iter1=_tree.begin();iter1!=_tree.end();iter1++)
 217     {
 218       bool isCTDefSurely1=true;
 219       for(iter2=(*iter1).begin();iter2!=(*iter1).end() && isCTDefSurely1;iter2++)
 220         {
 221           bool isCTDefSurely2=true;
 222           for(iter3=(*iter2).begin();iter3!=(*iter2).end() && isCTDefSurely2;iter3++)
 223             if((*iter3).second!=0)
 224               isCTDefSurely2=false;
 225           if(isCTDefSurely2)
 226             isCTDefSurely1=true;
 227           else
 228             isCTDefSurely1=(((*iter2)[0].first)->getComponent()->isAttachedOnCloning());
 229         }
 230       Container *cont=((*iter1)[0][0].first)->getComponent()->getContainer();
 231       if(isCTDefSurely1)
 232         {
 233           if(cont)
 234             ret.push_back(cont);
 235         }
 236       else
 237         if(cont)
 238           if(cont->isAttachedOnCloning())
 239             ret.push_back(cont);
 240       }
 241   return ret;
 242 }
 243
 244 std::vector<Container *> DeploymentTreeOnHeap::getAllRTODefContainers() const
 245 {
 246   vector< vector< vector< pair<Task *, Scheduler *> > > >::const_iterator iter1;
 247   vector< vector< pair<Task *, Scheduler * > > >::const_iterator iter2;
 248   vector< pair<Task *, Scheduler *> >::const_iterator iter3;
 249   vector<Container *> ret;
 250   for(iter1=_tree.begin();iter1!=_tree.end();iter1++)
 251     {
 252       bool isRTODefSurely1=true;
 253       for(iter2=(*iter1).begin();iter2!=(*iter1).end() && isRTODefSurely1;iter2++)
 254         {
 255           bool isRTODefSurely2=true;
 256           for(iter3=(*iter2).begin();iter3!=(*iter2).end() && isRTODefSurely2;iter3++)
 257             if((*iter3).second==0)
 258               isRTODefSurely2=false;
 259           if(isRTODefSurely2)
 260             isRTODefSurely1=!(((*iter2)[0].first)->getComponent()->isAttachedOnCloning());
 261           else
 262             isRTODefSurely1=false;
 263         }
 264       if(isRTODefSurely1)
 265         if(((*iter1)[0][0].first)->getComponent()->getContainer())
 266           if(!((*iter1)[0][0].first)->getComponent()->getContainer()->isAttachedOnCloning())
 267             ret.push_back(((*iter1)[0][0].first)->getComponent()->getContainer());
 268     }
 269   return ret;
 270 }
 271
 272 std::vector<Task *> DeploymentTreeOnHeap::getTasksLinkedToComponent(ComponentInstance *comp) const
 273 {
 274   vector< vector< vector< pair<Task *, Scheduler *> > > >::const_iterator iter1;
 275   vector< vector< pair<Task *, Scheduler * > > >::const_iterator iter2;
 276   vector< pair<Task *, Scheduler *> >::const_iterator iter3;
 277
 278   std::vector<Task *> ret;
 279   for(iter1=_tree.begin();iter1!=_tree.end();iter1++)
 280     for(iter2=(*iter1).begin();iter2!=(*iter1).end();iter2++)
 281       if(((*iter2)[0].first)->getComponent()==comp)
 282         for(iter3=(*iter2).begin();iter3!=(*iter2).end();iter3++)
 283           ret.push_back((*iter3).first);
 284   return ret;
 285 }
 286
 287 std::vector<ComponentInstance *> DeploymentTreeOnHeap::getComponentsLinkedToContainer(Container *cont) const
 288 {
 289   vector<ComponentInstance *> ret;
 290   vector< vector< vector< pair<Task *, Scheduler *> > > >::const_iterator iter1;
 291   vector< vector< pair<Task *, Scheduler * > > >::const_iterator iter2;
 292   for(iter1=_tree.begin();iter1!=_tree.end();iter1++)
 293     if(((*iter1)[0][0].first)->getComponent()->getContainer()==cont)
 294       for(iter2=(*iter1).begin();iter2!=(*iter1).end();iter2++)
 295         ret.push_back(((*iter2)[0].first)->getComponent());
 296   return ret;
 297 }
 298
 299 bool DeploymentTreeOnHeap::presenceOfDefaultContainer() const
 300 {
 301   vector< vector< vector< pair<Task *, Scheduler *> > > >::const_iterator iter1;
 302   for(iter1=_tree.begin();iter1!=_tree.end();iter1++)
 303     if(!((*iter1)[0][0].first)->getComponent()->getContainer())
 304       return true;
 305   return false;
 306 }
 307
 308 std::vector<Task *> DeploymentTreeOnHeap::getFreeDeployableTasks() const
 309 {
 310   vector<Task *> ret;
 311   for(vector< pair<Task *,Scheduler *> >::const_iterator iter=_freePlacableTasks.begin();iter!=_freePlacableTasks.end();iter++)
 312     ret.push_back((*iter).first);
 313   return ret;
 314 }
 315
 316 bool DeploymentTreeOnHeap::isConsistentTaskRegardingShCompInst(std::vector< std::pair<Task *, Scheduler * > >& tasksSharingSameCompInst, Scheduler *cloner)
 317 {
 318   vector< std::pair<Task *, Scheduler * > >::const_iterator iter;
 319   bool coexistenceOfDifferentSched=false;
 320   for(iter=tasksSharingSameCompInst.begin();iter!=tasksSharingSameCompInst.end() && !coexistenceOfDifferentSched;iter++)
 321     {
 322       coexistenceOfDifferentSched=(((*iter).second)!=cloner);
 323     }
 324   if(!coexistenceOfDifferentSched)
 325     return true;
 326   //In this case the component is duplicated on cloning raising on runtime on different policy (schedulers) than other tasks in tasksSharingSameCompInst
 327   return (tasksSharingSameCompInst[0].first)->getComponent()->isAttachedOnCloning();
 328 }
 329
 330 DeploymentTree::DeploymentTree():_treeHandle(0)
 331 {
 332 }
 333
 334 DeploymentTree::~DeploymentTree()
 335 {
 336   if(_treeHandle)
 337     _treeHandle->decrRef();
 338 }
 339
 340 DeploymentTree::DeploymentTree(const DeploymentTree& other)
 341 {
 342   _treeHandle=other._treeHandle;
 343   if(_treeHandle)
 344     _treeHandle->incrRef();
 345 }
 346
 347 const DeploymentTree &DeploymentTree::operator=(const DeploymentTree& other)
 348 {
 349   if(_treeHandle)
 350     _treeHandle->decrRef();
 351   _treeHandle=other._treeHandle;
 352   if(_treeHandle)
 353     _treeHandle->incrRef();
 354   return *this;
 355 }
 356
 357 unsigned char DeploymentTree::appendTask(Task *task, Scheduler *cloner)
 358 {
 359   if(_treeHandle)
 360     return _treeHandle->appendTask(task,cloner);
 361   if(!task)
 362     return DeploymentTree::NULL_TASK;
 363   if(!task->isDeployable())//Task not needed to be placed.
 364     return DeploymentTree::NOT_DEPLOYABLE_TASK;
 365   _treeHandle=new DeploymentTreeOnHeap;
 366   return _treeHandle->appendTask(task,cloner);
 367 }
 368
 369 /*!
 370  * Returns number of containers predictably launchable \b without counting default container.
 371  */
 372 unsigned DeploymentTree::getNumberOfCTDefContainer() const
 373 {
 374   if(_treeHandle)
 375     return _treeHandle->getNumberOfCTDefContainer();
 376   return 0;
 377 }
 378
 379 /*!
 380  * Returns number of containers unpredictably launchable \b without counting default container.
 381  */
 382 unsigned DeploymentTree::getNumberOfRTODefContainer() const
 383 {
 384   if(_treeHandle)
 385     return _treeHandle->getNumberOfRTODefContainer();
 386   return 0;
 387 }
 388
 389 unsigned DeploymentTree::getNumberOfCTDefComponentInstances() const
 390 {
 391   if(_treeHandle)
 392     return _treeHandle->getNumberOfCTDefComponentInstances();
 393   return 0;
 394 }
 395
 396 unsigned DeploymentTree::getNumberOfRTODefComponentInstances() const
 397 {
 398   if(_treeHandle)
 399     return _treeHandle->getNumberOfRTODefComponentInstances();
 400   return 0;
 401 }
 402
 403 /*!
 404  * Returns all containers default included (0).
 405  */
 406 std::vector<Container *> DeploymentTree::getAllContainers() const
 407 {
 408   if(_treeHandle)
 409     return _treeHandle->getAllContainers();
 410   return vector<Container *>();
 411 }
 412
 413 /*!
 414  * Returns containers predictably launchable \b without counting default container.
 415  */
 416 std::vector<Container *> DeploymentTree::getAllCTDefContainers() const
 417 {
 418   if(_treeHandle)
 419     return _treeHandle->getAllCTDefContainers();
 420   return vector<Container *>();
 421 }
 422
 423 /*!
 424  * Returns containers unpredictably launchable \b without counting default container.
 425  */
 426 std::vector<Container *> DeploymentTree::getAllRTODefContainers() const
 427 {
 428   if(_treeHandle)
 429     return _treeHandle->getAllRTODefContainers();
 430   return vector<Container *>();
 431 }
 432
 433 std::vector<Task *> DeploymentTree::getTasksLinkedToComponent(ComponentInstance *comp) const
 434 {
 435   if(_treeHandle)
 436     return _treeHandle->getTasksLinkedToComponent(comp);
 437   return vector<Task *>();
 438 }
 439
 440 std::vector<ComponentInstance *> DeploymentTree::getComponentsLinkedToContainer(Container *cont) const
 441 {
 442   if(_treeHandle)
 443     return _treeHandle->getComponentsLinkedToContainer(cont);
 444   return vector<ComponentInstance *>();
 445 }
 446
 447 bool DeploymentTree::presenceOfDefaultContainer() const
 448 {
 449   if(_treeHandle)
 450     return _treeHandle->presenceOfDefaultContainer();
 451   return false;
 452 }
 453
 454 bool DeploymentTree::isNull() const
 455 {
 456   return _treeHandle==0;
 457 }
 458
 459 std::vector<Task *> DeploymentTree::getFreeDeployableTasks() const
 460 {
 461   if(_treeHandle)
 462     return _treeHandle->getFreeDeployableTasks();
 463   return vector<Task *>();
 464 }