src/engine/DeploymentTree.cxx

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