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     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     for( size_t i = 0; i < _members.size(); i++ ) {
 325         if (name == _members[i]->name) {
 326             _members.erase(_members.begin() + i);
 327             return;
 328         }
 329     }
 330 }
 331
 332 void
 333 SGSubsystemGroup::set_fixed_update_time(double dt)
 334 {
 335   _fixedUpdateTime = dt;
 336 }
 337
 338 bool
 339 SGSubsystemGroup::has_subsystem (const string &name) const
 340 {
 341     return (((SGSubsystemGroup *)this)->get_member(name) != 0);
 342 }
 343
 344 SGSubsystemGroup::Member *
 345 SGSubsystemGroup::get_member (const string &name, bool create)
 346 {
 347     for( size_t i = 0; i < _members.size(); i++ ) {
 348         if (_members[i]->name == name)
 349             return _members[i];
 350     }
 351     if (create) {
 352         Member * member = new Member;
 353         _members.push_back(member);
 354         return member;
 355     } else {
 356         return 0;
 357     }
 358 }
 359
 360
 361 ////////////////////////////////////////////////////////////////////////
 362 // Implementation of SGSubsystemGroup::Member
 363 ////////////////////////////////////////////////////////////////////////
 364
 365
 366 SGSubsystemGroup::Member::Member ()
 367     : name(""),
 368       subsystem(0),
 369       min_step_sec(0),
 370       elapsed_sec(0),
 371       exceptionCount(0),
 372       initTime(0)
 373 {
 374 }
 375
 376 // This shouldn't be called due to subsystem pointer ownership issues.
 377 SGSubsystemGroup::Member::Member (const Member &)
 378 {
 379 }
 380
 381 SGSubsystemGroup::Member::~Member ()
 382 {
 383     delete subsystem;
 384 }
 385
 386 void
 387 SGSubsystemGroup::Member::update (double delta_time_sec)
 388 {
 389     elapsed_sec += delta_time_sec;
 390     if (elapsed_sec < min_step_sec) {
 391         return;
 392     }
 393
 394     if (subsystem->is_suspended()) {
 395         return;
 396     }
 397
 398     try {
 399       subsystem->update(elapsed_sec);
 400       elapsed_sec = 0;
 401     } catch (sg_exception& e) {
 402       SG_LOG(SG_GENERAL, SG_ALERT, "caught exception processing subsystem:" << name
 403         << "\nmessage:" << e.getMessage());
 404
 405       if (++exceptionCount > SG_MAX_SUBSYSTEM_EXCEPTIONS) {
 406         SG_LOG(SG_GENERAL, SG_ALERT, "(exceptionCount=" << exceptionCount <<
 407           ", suspending)");
 408         subsystem->suspend();
 409       }
 410     }
 411 }
 412
 413
 414 ////////////////////////////////////////////////////////////////////////
 415 // Implementation of SGSubsystemMgr.
 416 ////////////////////////////////////////////////////////////////////////
 417
 418
 419 SGSubsystemMgr::SGSubsystemMgr () :
 420   _initPosition(0)
 421 {
 422   for (int i = 0; i < MAX_GROUPS; i++) {
 423     _groups[i] = new SGSubsystemGroup;
 424   }
 425 }
 426
 427 SGSubsystemMgr::~SGSubsystemMgr ()
 428 {
 429   // ensure get_subsystem returns NULL from now onwards,
 430   // before the SGSubsystemGroup destructors are run
 431   _subsystem_map.clear();
 432
 433   for (int i = 0; i < MAX_GROUPS; i++) {
 434     delete _groups[i];
 435   }
 436 }
 437
 438 void
 439 SGSubsystemMgr::init ()
 440 {
 441     for (int i = 0; i < MAX_GROUPS; i++)
 442             _groups[i]->init();
 443 }
 444
 445 SGSubsystem::InitStatus
 446 SGSubsystemMgr::incrementalInit()
 447 {
 448   if (_initPosition >= MAX_GROUPS)
 449     return INIT_DONE;
 450
 451   InitStatus memberStatus = _groups[_initPosition]->incrementalInit();
 452   if (memberStatus == INIT_DONE)
 453     ++_initPosition;
 454
 455   return INIT_CONTINUE;
 456 }
 457
 458 void
 459 SGSubsystemMgr::postinit ()
 460 {
 461     for (int i = 0; i < MAX_GROUPS; i++)
 462             _groups[i]->postinit();
 463 }
 464
 465 void
 466 SGSubsystemMgr::reinit ()
 467 {
 468     for (int i = 0; i < MAX_GROUPS; i++)
 469             _groups[i]->reinit();
 470 }
 471
 472 void
 473 SGSubsystemMgr::shutdown ()
 474 {
 475     // reverse order to prevent order dependency problems
 476     for (int i = MAX_GROUPS-1; i >= 0; i--)
 477         _groups[i]->shutdown();
 478
 479     _initPosition = 0;
 480 }
 481
 482
 483 void
 484 SGSubsystemMgr::bind ()
 485 {
 486     for (int i = 0; i < MAX_GROUPS; i++)
 487         _groups[i]->bind();
 488 }
 489
 490 void
 491 SGSubsystemMgr::unbind ()
 492 {
 493     // reverse order to prevent order dependency problems
 494     for (int i = MAX_GROUPS-1; i >= 0; i--)
 495         _groups[i]->unbind();
 496 }
 497
 498 void
 499 SGSubsystemMgr::update (double delta_time_sec)
 500 {
 501     for (int i = 0; i < MAX_GROUPS; i++) {
 502         _groups[i]->update(delta_time_sec);
 503     }
 504 }
 505
 506 void
 507 SGSubsystemMgr::suspend ()
 508 {
 509     for (int i = 0; i < MAX_GROUPS; i++)
 510         _groups[i]->suspend();
 511 }
 512
 513 void
 514 SGSubsystemMgr::resume ()
 515 {
 516     for (int i = 0; i < MAX_GROUPS; i++)
 517         _groups[i]->resume();
 518 }
 519
 520 bool
 521 SGSubsystemMgr::is_suspended () const
 522 {
 523     return false;
 524 }
 525
 526 void
 527 SGSubsystemMgr::add (const char * name, SGSubsystem * subsystem,
 528                      GroupType group, double min_time_sec)
 529 {
 530     SG_LOG(SG_GENERAL, SG_INFO, "Adding subsystem " << name);
 531     get_group(group)->set_subsystem(name, subsystem, min_time_sec);
 532
 533     if (_subsystem_map.find(name) != _subsystem_map.end()) {
 534         SG_LOG(SG_GENERAL, SG_ALERT, "Adding duplicate subsystem " << name);
 535         throw sg_exception("duplicate subsystem");
 536     }
 537     _subsystem_map[name] = subsystem;
 538 }
 539
 540 SGSubsystem*
 541 SGSubsystemMgr::remove(const char* name)
 542 {
 543   SubsystemDict::iterator s =_subsystem_map.find(name);
 544   if (s == _subsystem_map.end()) {
 545     return NULL;
 546   }
 547
 548   SGSubsystem* sub = s->second;
 549   _subsystem_map.erase(s);
 550
 551 // tedious part - we don't know which group the subsystem belongs too
 552   for (int i = 0; i < MAX_GROUPS; i++) {
 553     if (_groups[i]->get_subsystem(name) == sub) {
 554       _groups[i]->remove_subsystem(name);
 555       break;
 556     }
 557   } // of groups iteration
 558
 559   return sub;
 560 }
 561
 562
 563 SGSubsystemGroup *
 564 SGSubsystemMgr::get_group (GroupType group)
 565 {
 566     return _groups[group];
 567 }
 568
 569 SGSubsystem *
 570 SGSubsystemMgr::get_subsystem (const string &name) const
 571 {
 572     SubsystemDict::const_iterator s =_subsystem_map.find(name);
 573
 574     if (s == _subsystem_map.end())
 575         return 0;
 576     else
 577         return s->second;
 578 }
 579
 580 /** Trigger the timing callback to report data for all subsystems. */
 581 void
 582 SGSubsystemMgr::reportTiming()
 583 {
 584     for (int i = 0; i < MAX_GROUPS; i++) {
 585         _groups[i]->reportTiming();
 586     } // of groups iteration
 587 }
 588
 589 // end of subsystem_mgr.cxx