simgear/structure/subsystem_mgr.cxx

   1
   2 #include <simgear/debug/logstream.hxx>
   3 #include <simgear/timing/timestamp.hxx>
   4
   5 #include "exception.hxx"
   6 #include "subsystem_mgr.hxx"
   7
   8
   9 \f
  10 ////////////////////////////////////////////////////////////////////////
  11 // Implementation of SGSubsystem
  12 ////////////////////////////////////////////////////////////////////////
  13
  14
  15 SGSubsystem::SGSubsystem ()
  16   : _suspended(false)
  17 {
  18 }
  19
  20 SGSubsystem::~SGSubsystem ()
  21 {
  22 }
  23
  24 void
  25 SGSubsystem::init ()
  26 {
  27 }
  28
  29 void
  30 SGSubsystem::postinit ()
  31 {
  32 }
  33
  34 void
  35 SGSubsystem::reinit ()
  36 {
  37 }
  38
  39 void
  40 SGSubsystem::bind ()
  41 {
  42 }
  43
  44 void
  45 SGSubsystem::unbind ()
  46 {
  47 }
  48
  49 void
  50 SGSubsystem::suspend ()
  51 {
  52   _suspended = true;
  53 }
  54
  55 void
  56 SGSubsystem::suspend (bool suspended)
  57 {
  58   _suspended = suspended;
  59 }
  60
  61 void
  62 SGSubsystem::resume ()
  63 {
  64   _suspended = false;
  65 }
  66
  67 bool
  68 SGSubsystem::is_suspended () const
  69 {
  70   return _suspended;
  71 }
  72
  73
  74 void
  75 SGSubsystem::printTimingInformation ()
  76 {
  77   SGTimeStamp startTime, endTime;
  78    long duration;
  79    for ( eventTimeVecIterator i = timingInfo.begin();
  80           i != timingInfo.end();
  81           i++) {
  82        if (i == timingInfo.begin()) {
  83            startTime = i->getTime();
  84        } else {
  85            endTime = i->getTime();
  86            duration = (endTime - startTime);
  87            startTime = endTime;
  88            SG_LOG(SG_GENERAL, SG_ALERT, "- Getting to timestamp :   " << i->getName() << " takes " << duration << " usec.");
  89        }
  90    }
  91 }
  92
  93 void SGSubsystem::stamp(string name)
  94 {
  95     SGTimeStamp now;
  96     now.stamp();
  97     timingInfo.push_back(TimingInfo(name, now));
  98 }
  99
 100 \f
 101 ////////////////////////////////////////////////////////////////////////
 102 // Implementation of SGSubsystemGroup.
 103 ////////////////////////////////////////////////////////////////////////
 104
 105 SGSubsystemGroup::SGSubsystemGroup ()
 106 {
 107 }
 108
 109 SGSubsystemGroup::~SGSubsystemGroup ()
 110 {
 111     for (unsigned int i = 0; i < _members.size(); i++)
 112         delete _members[i];
 113 }
 114
 115 void
 116 SGSubsystemGroup::init ()
 117 {
 118     for (unsigned int i = 0; i < _members.size(); i++)
 119         _members[i]->subsystem->init();
 120 }
 121
 122 void
 123 SGSubsystemGroup::postinit ()
 124 {
 125     for (unsigned int i = 0; i < _members.size(); i++)
 126         _members[i]->subsystem->postinit();
 127 }
 128
 129 void
 130 SGSubsystemGroup::reinit ()
 131 {
 132     for (unsigned int i = 0; i < _members.size(); i++)
 133         _members[i]->subsystem->reinit();
 134 }
 135
 136 void
 137 SGSubsystemGroup::bind ()
 138 {
 139     for (unsigned int i = 0; i < _members.size(); i++)
 140         _members[i]->subsystem->bind();
 141 }
 142
 143 void
 144 SGSubsystemGroup::unbind ()
 145 {
 146     for (unsigned int i = 0; i < _members.size(); i++)
 147         _members[i]->subsystem->unbind();
 148 }
 149
 150 void
 151 SGSubsystemGroup::update (double delta_time_sec)
 152 {
 153     for (unsigned int i = 0; i < _members.size(); i++)
 154     {
 155          SGTimeStamp start, now;
 156          start.stamp();
 157          _members[i]->update(delta_time_sec); // indirect call
 158          now.stamp();
 159          long b = ( now - start );
 160          if ( b > 10000 ) {
 161              SG_LOG(SG_GENERAL, SG_ALERT, "Subsystem Timing Alert : " << b << " " << _members[i]->name);
 162              //int a = 1;
 163              _members[i]->printTimingInformation();
 164          }
 165     }
 166 }
 167
 168 void
 169 SGSubsystemGroup::suspend ()
 170 {
 171     for (unsigned int i = 0; i < _members.size(); i++)
 172         _members[i]->subsystem->suspend();
 173 }
 174
 175 void
 176 SGSubsystemGroup::resume ()
 177 {
 178     for (unsigned int i = 0; i < _members.size(); i++)
 179         _members[i]->subsystem->resume();
 180 }
 181
 182 bool
 183 SGSubsystemGroup::is_suspended () const
 184 {
 185     return false;
 186 }
 187
 188 void
 189 SGSubsystemGroup::set_subsystem (const string &name, SGSubsystem * subsystem,
 190                                  double min_step_sec)
 191 {
 192     Member * member = get_member(name, true);
 193     if (member->subsystem != 0)
 194         delete member->subsystem;
 195     member->name = name;
 196     member->subsystem = subsystem;
 197     member->min_step_sec = min_step_sec;
 198 }
 199
 200 SGSubsystem *
 201 SGSubsystemGroup::get_subsystem (const string &name)
 202 {
 203     Member * member = get_member(name);
 204     if (member != 0)
 205         return member->subsystem;
 206     else
 207         return 0;
 208 }
 209
 210 void
 211 SGSubsystemGroup::remove_subsystem (const string &name)
 212 {
 213     for (unsigned int i = 0; i < _members.size(); i++) {
 214         if (name == _members[i]->name) {
 215             _members.erase(_members.begin() + i);
 216             return;
 217         }
 218     }
 219 }
 220
 221 bool
 222 SGSubsystemGroup::has_subsystem (const string &name) const
 223 {
 224     return (((SGSubsystemGroup *)this)->get_member(name) != 0);
 225 }
 226
 227 SGSubsystemGroup::Member *
 228 SGSubsystemGroup::get_member (const string &name, bool create)
 229 {
 230     for (unsigned int i = 0; i < _members.size(); i++) {
 231         if (_members[i]->name == name)
 232             return _members[i];
 233     }
 234     if (create) {
 235         Member * member = new Member;
 236         _members.push_back(member);
 237         return member;
 238     } else {
 239         return 0;
 240     }
 241 }
 242
 243
 244 \f
 245 ////////////////////////////////////////////////////////////////////////
 246 // Implementation of SGSubsystemGroup::Member
 247 ////////////////////////////////////////////////////////////////////////
 248
 249
 250 SGSubsystemGroup::Member::Member ()
 251     : name(""),
 252       subsystem(0),
 253       min_step_sec(0),
 254       elapsed_sec(0)
 255 {
 256 }
 257
 258 SGSubsystemGroup::Member::Member (const Member &)
 259 {
 260     Member();
 261 }
 262
 263 SGSubsystemGroup::Member::~Member ()
 264 {
 265     delete subsystem;
 266 }
 267
 268 void
 269 SGSubsystemGroup::Member::update (double delta_time_sec)
 270 {
 271     elapsed_sec += delta_time_sec;
 272     if (elapsed_sec >= min_step_sec) {
 273         if (!subsystem->is_suspended()) {
 274             subsystem->update(elapsed_sec);
 275             elapsed_sec = 0;
 276         }
 277     }
 278 }
 279
 280
 281 void
 282 SGSubsystemGroup::Member::printTimingInformation()
 283 {
 284      subsystem->printTimingInformation();
 285 }
 286
 287
 288 \f
 289 ////////////////////////////////////////////////////////////////////////
 290 // Implementation of SGSubsystemMgr.
 291 ////////////////////////////////////////////////////////////////////////
 292
 293
 294 SGSubsystemMgr::SGSubsystemMgr ()
 295 {
 296 }
 297
 298 SGSubsystemMgr::~SGSubsystemMgr ()
 299 {
 300 }
 301
 302 void
 303 SGSubsystemMgr::init ()
 304 {
 305     for (int i = 0; i < MAX_GROUPS; i++)
 306             _groups[i].init();
 307 }
 308
 309 void
 310 SGSubsystemMgr::postinit ()
 311 {
 312     for (int i = 0; i < MAX_GROUPS; i++)
 313             _groups[i].postinit();
 314 }
 315
 316 void
 317 SGSubsystemMgr::reinit ()
 318 {
 319     for (int i = 0; i < MAX_GROUPS; i++)
 320             _groups[i].reinit();
 321 }
 322
 323 void
 324 SGSubsystemMgr::bind ()
 325 {
 326     for (int i = 0; i < MAX_GROUPS; i++)
 327         _groups[i].bind();
 328 }
 329
 330 void
 331 SGSubsystemMgr::unbind ()
 332 {
 333     for (int i = 0; i < MAX_GROUPS; i++)
 334         _groups[i].unbind();
 335 }
 336
 337 void
 338 SGSubsystemMgr::update (double delta_time_sec)
 339 {
 340     for (int i = 0; i < MAX_GROUPS; i++) {
 341         _groups[i].update(delta_time_sec);
 342     }
 343 }
 344
 345 void
 346 SGSubsystemMgr::suspend ()
 347 {
 348     for (int i = 0; i < MAX_GROUPS; i++)
 349         _groups[i].suspend();
 350 }
 351
 352 void
 353 SGSubsystemMgr::resume ()
 354 {
 355     for (int i = 0; i < MAX_GROUPS; i++)
 356         _groups[i].resume();
 357 }
 358
 359 bool
 360 SGSubsystemMgr::is_suspended () const
 361 {
 362     return false;
 363 }
 364
 365 void
 366 SGSubsystemMgr::add (const char * name, SGSubsystem * subsystem,
 367                      GroupType group, double min_time_sec)
 368 {
 369     SG_LOG(SG_GENERAL, SG_INFO, "Adding subsystem " << name);
 370     get_group(group)->set_subsystem(name, subsystem, min_time_sec);
 371
 372     if (_subsystem_map.find(name) != _subsystem_map.end()) {
 373         SG_LOG(SG_GENERAL, SG_ALERT, "Adding duplicate subsystem " << name);
 374         throw sg_exception("duplicate subsystem");
 375     }
 376     _subsystem_map[name] = subsystem;
 377 }
 378
 379 SGSubsystemGroup *
 380 SGSubsystemMgr::get_group (GroupType group)
 381 {
 382     return &(_groups[group]);
 383 }
 384
 385 SGSubsystem *
 386 SGSubsystemMgr::get_subsystem (const string &name)
 387 {
 388     map<string,SGSubsystem *>::iterator s =_subsystem_map.find(name);
 389
 390     if (s == _subsystem_map.end())
 391         return 0;
 392     else
 393         return s->second;
 394 }
 395
 396 // end of fgfs.cxx