simgear/structure/subsystem_mgr.cxx

   1 // Written by David Megginson, started 2000-12
   2 //
   3 // Copyright (C) 2000  David Megginson, david@megginson.com
   4 //
   5 // This program is free software; you can redistribute it and/or
   6 // modify it under the terms of the GNU General Public License as
   7 // published by the Free Software Foundation; either version 2 of the
   8 // License, or (at your option) any later version.
   9 //
  10 // This program is distributed in the hope that it will be useful, but
  11 // WITHOUT ANY WARRANTY; without even the implied warranty of
  12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13 // General Public License for more details.
  14 //
  15 // You should have received a copy of the GNU General Public License
  16 // along with this program; if not, write to the Free Software
  17 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  18 //
  19 // $Id$
  20
  21 #ifdef HAVE_CONFIG_H
  22 #  include <simgear_config.h>
  23 #endif
  24
  25 #include <simgear/debug/logstream.hxx>
  26 #include <simgear/timing/timestamp.hxx>
  27
  28 #include "exception.hxx"
  29 #include "subsystem_mgr.hxx"
  30
  31 #include <simgear/math/SGMath.hxx>
  32 #include "SGSmplstat.hxx"
  33
  34 const int SG_MAX_SUBSYSTEM_EXCEPTIONS = 4;
  35
  36 using std::string;
  37
  38 ////////////////////////////////////////////////////////////////////////
  39 // Implementation of SGSubsystem
  40 ////////////////////////////////////////////////////////////////////////
  41
  42 SGSubsystemTimingCb SGSubsystem::reportTimingCb = NULL;
  43 void* SGSubsystem::reportTimingUserData = NULL;
  44
  45 SGSubsystem::SGSubsystem ()
  46   : _suspended(false)
  47 {
  48 }
  49
  50 SGSubsystem::~SGSubsystem ()
  51 {
  52 }
  53
  54 void
  55 SGSubsystem::init ()
  56 {
  57 }
  58
  59 SGSubsystem::InitStatus
  60 SGSubsystem::incrementalInit ()
  61 {
  62   init();
  63   return INIT_DONE;
  64 }
  65
  66 void
  67 SGSubsystem::postinit ()
  68 {
  69 }
  70
  71 void
  72 SGSubsystem::reinit ()
  73 {
  74 }
  75
  76 void
  77 SGSubsystem::shutdown ()
  78 {
  79 }
  80
  81 void
  82 SGSubsystem::bind ()
  83 {
  84 }
  85
  86 void
  87 SGSubsystem::unbind ()
  88 {
  89 }
  90
  91 void
  92 SGSubsystem::suspend ()
  93 {
  94   _suspended = true;
  95 }
  96
  97 void
  98 SGSubsystem::suspend (bool suspended)
  99 {
 100   _suspended = suspended;
 101 }
 102
 103 void
 104 SGSubsystem::resume ()
 105 {
 106   _suspended = false;
 107 }
 108
 109 bool
 110 SGSubsystem::is_suspended () const
 111 {
 112   return _suspended;
 113 }
 114
 115 void SGSubsystem::stamp(const string& name)
 116 {
 117     timingInfo.push_back(TimingInfo(name, SGTimeStamp::now()));
 118 }
 119
 120 ////////////////////////////////////////////////////////////////////////
 121 // Implementation of SGSubsystemGroup.
 122 ////////////////////////////////////////////////////////////////////////
 123
 124 class SGSubsystemGroup::Member
 125 {
 126 private:
 127     Member (const Member &member);
 128 public:
 129     Member ();
 130     virtual ~Member ();
 131
 132     virtual void update (double delta_time_sec);
 133
 134     void reportTiming(void) { if (reportTimingCb) reportTimingCb(reportTimingUserData, name, &timeStat); }
 135     void updateExecutionTime(double time) { timeStat += time;}
 136
 137     SampleStatistic timeStat;
 138     std::string name;
 139     SGSharedPtr<SGSubsystem> subsystem;
 140     double min_step_sec;
 141     double elapsed_sec;
 142     bool collectTimeStats;
 143     int exceptionCount;
 144     int initTime;
 145 };
 146
 147
 148
 149 SGSubsystemGroup::SGSubsystemGroup () :
 150   _fixedUpdateTime(-1.0),
 151   _updateTimeRemainder(0.0),
 152   _initPosition(0)
 153 {
 154 }
 155
 156 SGSubsystemGroup::~SGSubsystemGroup ()
 157 {
 158     // reverse order to prevent order dependency problems
 159     for( size_t i = _members.size(); i > 0; i-- )
 160     {
 161         delete _members[i-1];
 162     }
 163 }
 164
 165 void
 166 SGSubsystemGroup::init ()
 167 {
 168     for( size_t i = 0; i < _members.size(); i++ )
 169         _members[i]->subsystem->init();
 170 }
 171
 172 SGSubsystem::InitStatus
 173 SGSubsystemGroup::incrementalInit()
 174 {
 175   if (_initPosition >= _members.size())
 176     return INIT_DONE;
 177
 178   SGTimeStamp st;
 179   st.stamp();
 180   InitStatus memberStatus = _members[_initPosition]->subsystem->incrementalInit();
 181   _members[_initPosition]->initTime += st.elapsedMSec();
 182
 183   if (memberStatus == INIT_DONE)
 184     ++_initPosition;
 185
 186   return INIT_CONTINUE;
 187 }
 188
 189 void
 190 SGSubsystemGroup::postinit ()
 191 {
 192     for( size_t i = 0; i < _members.size(); i++ )
 193         _members[i]->subsystem->postinit();
 194 }
 195
 196 void
 197 SGSubsystemGroup::reinit ()
 198 {
 199     for( size_t i = 0; i < _members.size(); i++ )
 200         _members[i]->subsystem->reinit();
 201 }
 202
 203 void
 204 SGSubsystemGroup::shutdown ()
 205 {
 206     // reverse order to prevent order dependency problems
 207     for( size_t i = _members.size(); i > 0; i-- )
 208         _members[i-1]->subsystem->shutdown();
 209   _initPosition = 0;
 210 }
 211
 212 void
 213 SGSubsystemGroup::bind ()
 214 {
 215     for( size_t i = 0; i < _members.size(); i++ )
 216         _members[i]->subsystem->bind();
 217 }
 218
 219 void
 220 SGSubsystemGroup::unbind ()
 221 {
 222     // reverse order to prevent order dependency problems
 223     for( size_t i = _members.size(); i > 0; i-- )
 224        _members[i-1]->subsystem->unbind();
 225 }
 226
 227 void
 228 SGSubsystemGroup::update (double delta_time_sec)
 229 {
 230     int loopCount = 1;
 231     // if dt == 0.0, we are paused, so we need to run one iteration
 232     // of our members; if we have a fixed update time, we compute a
 233     // loop count, and locally adjust dt
 234     if ((delta_time_sec > 0.0) && (_fixedUpdateTime > 0.0)) {
 235       double localDelta = delta_time_sec + _updateTimeRemainder;
 236       loopCount = SGMiscd::roundToInt(localDelta / _fixedUpdateTime);
 237       _updateTimeRemainder = delta_time_sec - (loopCount * _fixedUpdateTime);
 238       delta_time_sec = _fixedUpdateTime;
 239     }
 240
 241     bool recordTime = (reportTimingCb != NULL);
 242     SGTimeStamp timeStamp;
 243     while (loopCount-- > 0) {
 244       for( size_t i = 0; i < _members.size(); i++ )
 245       {
 246           if (recordTime)
 247               timeStamp = SGTimeStamp::now();
 248
 249           _members[i]->update(delta_time_sec); // indirect call
 250
 251           if ((recordTime)&&(reportTimingCb))
 252           {
 253               timeStamp = SGTimeStamp::now() - timeStamp;
 254               _members[i]->updateExecutionTime(timeStamp.toUSecs());
 255           }
 256       }
 257     } // of multiple update loop
 258 }
 259
 260 void
 261 SGSubsystemGroup::reportTiming(void)
 262 {
 263     for( size_t i = _members.size(); i > 0; i-- )
 264     {
 265         _members[i-1]->reportTiming();
 266     }
 267 }
 268
 269 void
 270 SGSubsystemGroup::suspend ()
 271 {
 272     for( size_t i = 0; i < _members.size(); i++ )
 273         _members[i]->subsystem->suspend();
 274 }
 275
 276 void
 277 SGSubsystemGroup::resume ()
 278 {
 279     for( size_t i = 0; i < _members.size(); i++ )
 280         _members[i]->subsystem->resume();
 281 }
 282
 283 string_list
 284 SGSubsystemGroup::member_names() const
 285 {
 286         string_list result;
 287         for( size_t i = 0; i < _members.size(); i++ )
 288                 result.push_back( _members[i]->name );
 289
 290         return result;
 291 }
 292
 293 bool
 294 SGSubsystemGroup::is_suspended () const
 295 {
 296     return false;
 297 }
 298
 299 void
 300 SGSubsystemGroup::set_subsystem (const string &name, SGSubsystem * subsystem,
 301                                  double min_step_sec)
 302 {
 303     Member * member = get_member(name, true);
 304     if (member->subsystem != 0)
 305         delete member->subsystem;
 306     member->name = name;
 307     member->subsystem = subsystem;
 308     member->min_step_sec = min_step_sec;
 309 }
 310
 311 SGSubsystem *
 312 SGSubsystemGroup::get_subsystem (const string &name)
 313 {
 314     Member * member = get_member(name);
 315     if (member != 0)
 316         return member->subsystem;
 317     else
 318         return 0;
 319 }
 320
 321 void
 322 SGSubsystemGroup::remove_subsystem (const string &name)
 323 {
 324     MemberVec::iterator it = _members.begin();
 325     for (; it != _members.end(); ++it) {
 326         if (name == (*it)->name) {
 327             delete *it;
 328             _members.erase(it);
 329             return;
 330         }
 331     }
 332
 333     SG_LOG(SG_GENERAL, SG_WARN, "remove_subsystem: missing:" << name);
 334 }
 335
 336 //------------------------------------------------------------------------------
 337 void SGSubsystemGroup::clearSubsystems()
 338 {
 339   for( MemberVec::iterator it = _members.begin();
 340                            it != _members.end();
 341                          ++it )
 342     delete *it;
 343   _members.clear();
 344 }
 345
 346 void
 347 SGSubsystemGroup::set_fixed_update_time(double dt)
 348 {
 349   _fixedUpdateTime = dt;
 350 }
 351
 352 bool
 353 SGSubsystemGroup::has_subsystem (const string &name) const
 354 {
 355     return (((SGSubsystemGroup *)this)->get_member(name) != 0);
 356 }
 357
 358 SGSubsystemGroup::Member *
 359 SGSubsystemGroup::get_member (const string &name, bool create)
 360 {
 361     for( size_t i = 0; i < _members.size(); i++ ) {
 362         if (_members[i]->name == name)
 363             return _members[i];
 364     }
 365     if (create) {
 366         Member * member = new Member;
 367         _members.push_back(member);
 368         return member;
 369     } else {
 370         return 0;
 371     }
 372 }
 373
 374
 375 ////////////////////////////////////////////////////////////////////////
 376 // Implementation of SGSubsystemGroup::Member
 377 ////////////////////////////////////////////////////////////////////////
 378
 379
 380 SGSubsystemGroup::Member::Member ()
 381     : name(""),
 382       subsystem(0),
 383       min_step_sec(0),
 384       elapsed_sec(0),
 385       exceptionCount(0),
 386       initTime(0)
 387 {
 388 }
 389
 390 // This shouldn't be called due to subsystem pointer ownership issues.
 391 SGSubsystemGroup::Member::Member (const Member &)
 392 {
 393 }
 394
 395 SGSubsystemGroup::Member::~Member ()
 396 {
 397 }
 398
 399 void
 400 SGSubsystemGroup::Member::update (double delta_time_sec)
 401 {
 402     elapsed_sec += delta_time_sec;
 403     if (elapsed_sec < min_step_sec) {
 404         return;
 405     }
 406
 407     if (subsystem->is_suspended()) {
 408         return;
 409     }
 410
 411     try {
 412       subsystem->update(elapsed_sec);
 413       elapsed_sec = 0;
 414     } catch (sg_exception& e) {
 415       SG_LOG(SG_GENERAL, SG_ALERT, "caught exception processing subsystem:" << name
 416         << "\nmessage:" << e.getMessage());
 417
 418       if (++exceptionCount > SG_MAX_SUBSYSTEM_EXCEPTIONS) {
 419         SG_LOG(SG_GENERAL, SG_ALERT, "(exceptionCount=" << exceptionCount <<
 420           ", suspending)");
 421         subsystem->suspend();
 422       }
 423     }
 424 }
 425
 426
 427 ////////////////////////////////////////////////////////////////////////
 428 // Implementation of SGSubsystemMgr.
 429 ////////////////////////////////////////////////////////////////////////
 430
 431
 432 SGSubsystemMgr::SGSubsystemMgr () :
 433   _initPosition(0)
 434 {
 435   for (int i = 0; i < MAX_GROUPS; i++) {
 436     _groups[i] = new SGSubsystemGroup;
 437   }
 438 }
 439
 440 SGSubsystemMgr::~SGSubsystemMgr ()
 441 {
 442   // ensure get_subsystem returns NULL from now onwards,
 443   // before the SGSubsystemGroup destructors are run
 444   _subsystem_map.clear();
 445
 446   for (int i = 0; i < MAX_GROUPS; i++) {
 447     delete _groups[i];
 448   }
 449 }
 450
 451 void
 452 SGSubsystemMgr::init ()
 453 {
 454     for (int i = 0; i < MAX_GROUPS; i++)
 455             _groups[i]->init();
 456 }
 457
 458 SGSubsystem::InitStatus
 459 SGSubsystemMgr::incrementalInit()
 460 {
 461   if (_initPosition >= MAX_GROUPS)
 462     return INIT_DONE;
 463
 464   InitStatus memberStatus = _groups[_initPosition]->incrementalInit();
 465   if (memberStatus == INIT_DONE)
 466     ++_initPosition;
 467
 468   return INIT_CONTINUE;
 469 }
 470
 471 void
 472 SGSubsystemMgr::postinit ()
 473 {
 474     for (int i = 0; i < MAX_GROUPS; i++)
 475             _groups[i]->postinit();
 476 }
 477
 478 void
 479 SGSubsystemMgr::reinit ()
 480 {
 481     for (int i = 0; i < MAX_GROUPS; i++)
 482             _groups[i]->reinit();
 483 }
 484
 485 void
 486 SGSubsystemMgr::shutdown ()
 487 {
 488     // reverse order to prevent order dependency problems
 489     for (int i = MAX_GROUPS-1; i >= 0; i--)
 490         _groups[i]->shutdown();
 491
 492     _initPosition = 0;
 493 }
 494
 495
 496 void
 497 SGSubsystemMgr::bind ()
 498 {
 499     for (int i = 0; i < MAX_GROUPS; i++)
 500         _groups[i]->bind();
 501 }
 502
 503 void
 504 SGSubsystemMgr::unbind ()
 505 {
 506     // reverse order to prevent order dependency problems
 507     for (int i = MAX_GROUPS-1; i >= 0; i--)
 508         _groups[i]->unbind();
 509 }
 510
 511 void
 512 SGSubsystemMgr::update (double delta_time_sec)
 513 {
 514     for (int i = 0; i < MAX_GROUPS; i++) {
 515         _groups[i]->update(delta_time_sec);
 516     }
 517 }
 518
 519 void
 520 SGSubsystemMgr::suspend ()
 521 {
 522     for (int i = 0; i < MAX_GROUPS; i++)
 523         _groups[i]->suspend();
 524 }
 525
 526 void
 527 SGSubsystemMgr::resume ()
 528 {
 529     for (int i = 0; i < MAX_GROUPS; i++)
 530         _groups[i]->resume();
 531 }
 532
 533 bool
 534 SGSubsystemMgr::is_suspended () const
 535 {
 536     return false;
 537 }
 538
 539 void
 540 SGSubsystemMgr::add (const char * name, SGSubsystem * subsystem,
 541                      GroupType group, double min_time_sec)
 542 {
 543     SG_LOG(SG_GENERAL, SG_DEBUG, "Adding subsystem " << name);
 544     get_group(group)->set_subsystem(name, subsystem, min_time_sec);
 545
 546     if (_subsystem_map.find(name) != _subsystem_map.end()) {
 547         SG_LOG(SG_GENERAL, SG_ALERT, "Adding duplicate subsystem " << name);
 548         throw sg_exception("duplicate subsystem:" + std::string(name));
 549     }
 550     _subsystem_map[name] = subsystem;
 551 }
 552
 553 void
 554 SGSubsystemMgr::remove(const char* name)
 555 {
 556   SubsystemDict::iterator s =_subsystem_map.find(name);
 557   if (s == _subsystem_map.end()) {
 558     return;
 559   }
 560
 561   _subsystem_map.erase(s);
 562
 563 // tedious part - we don't know which group the subsystem belongs too
 564   for (int i = 0; i < MAX_GROUPS; i++) {
 565     if (_groups[i]->get_subsystem(name) != NULL) {
 566       _groups[i]->remove_subsystem(name);
 567       break;
 568     }
 569   } // of groups iteration
 570 }
 571
 572
 573 SGSubsystemGroup *
 574 SGSubsystemMgr::get_group (GroupType group)
 575 {
 576     return _groups[group];
 577 }
 578
 579 SGSubsystem *
 580 SGSubsystemMgr::get_subsystem (const string &name) const
 581 {
 582     SubsystemDict::const_iterator s =_subsystem_map.find(name);
 583
 584     if (s == _subsystem_map.end())
 585         return 0;
 586     else
 587         return s->second;
 588 }
 589
 590 /** Trigger the timing callback to report data for all subsystems. */
 591 void
 592 SGSubsystemMgr::reportTiming()
 593 {
 594     for (int i = 0; i < MAX_GROUPS; i++) {
 595         _groups[i]->reportTiming();
 596     } // of groups iteration
 597 }
 598
 599 // end of subsystem_mgr.cxx