ryzom/server/src/frontend_service/module_manager.cpp

   1 // Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
   2 // Copyright (C) 2010  Winch Gate Property Limited
   3 //
   4 // This source file has been modified by the following contributors:
   5 // Copyright (C) 2014  Jan BOON (Kaetemi) <jan.boon@kaetemi.be>
   6 //
   7 // This program is free software: you can redistribute it and/or modify
   8 // it under the terms of the GNU Affero General Public License as
   9 // published by the Free Software Foundation, either version 3 of the
  10 // License, or (at your option) any later version.
  11 //
  12 // This program is distributed in the hope that it will be useful,
  13 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 // GNU Affero General Public License for more details.
  16 //
  17 // You should have received a copy of the GNU Affero General Public License
  18 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19
  20
  21
  22 #include "stdpch.h"
  23
  24 #include "nel/misc/debug.h"
  25 #include "nel/misc/hierarchical_timer.h"
  26
  27 #include "module_manager.h"
  28
  29 using namespace NLMISC;
  30 using namespace std;
  31
  32 /*
  33  * Static variables
  34  */
  35
  36 uint                                                                    CModuleManager::_MaxModules = 0;
  37
  38 NLMISC::CMutex                                                  *CModuleManager::_ModMutexes = NULL;
  39
  40 vector<CModuleManager*>                                 CModuleManager::_RegisteredManagers;
  41
  42
  43 // Constructor
  44 CModuleManager::CModuleManager(const char *name, bool independent)
  45 {
  46         _Independent = independent;
  47         _Thread = NULL;
  48         _StopThread = false;
  49         _ThreadStopped = false;
  50
  51         _StackName = (name != NULL) ? string(name) : "<unnamed>";
  52
  53         _Id = (uint)_RegisteredManagers.size();
  54         _Cycle = 0;
  55         _CompleteCycle = false;
  56         _RegisteredManagers.push_back(this);
  57 }
  58
  59 // Destructor
  60 CModuleManager::~CModuleManager()
  61 {
  62         if (_Thread != NULL)
  63         {
  64                 nlwarning("FEMMAN: [%s] Execution is not finished yet. Brutal thread killing", _StackName.c_str());
  65                 _Thread->terminate();
  66                 delete _Thread;
  67         }
  68 }
  69
  70
  71
  72 //
  73
  74 void    CModuleManager::init(uint maxModules)
  75 {
  76         nlassert(_MaxModules == 0);
  77         nlassert(_ModMutexes == NULL);
  78
  79         _MaxModules = maxModules;
  80         _ModMutexes = new CMutex[maxModules];
  81 }
  82
  83 //
  84
  85 void    CModuleManager::release()
  86 {
  87         _MaxModules = 0;
  88         delete [] _ModMutexes;
  89         _ModMutexes = NULL;
  90 }
  91
  92 //
  93
  94 void    CModuleManager::startAll()
  95 {
  96         // first reset cycle
  97         resetCycle();
  98
  99         uint    i;
 100
 101         // and start all managers at once
 102         for (i=0; i<_RegisteredManagers.size(); ++i)
 103                 if (_RegisteredManagers[i]->_Independent)
 104                         _RegisteredManagers[i]->start();
 105 }
 106
 107 void    CModuleManager::stopAll(TTime timeout)
 108 {
 109         uint    i;
 110
 111         // send soft stop
 112         for (i=0; i<_RegisteredManagers.size(); ++i)
 113                 _RegisteredManagers[i]->stop(false, 0);
 114
 115         // wait for all managers to stop or timeout
 116         TTime   before = CTime::getLocalTime();
 117         while (!allStopped() && CTime::getLocalTime()-before < timeout)
 118                 nlSleep(10);
 119
 120         // and hard stop
 121         for (i=0; i<_RegisteredManagers.size(); ++i)
 122                 _RegisteredManagers[i]->stop(true, 0);
 123 }
 124
 125 void    CModuleManager::resetCycle()
 126 {
 127         uint    i;
 128
 129         // reset all managers cycle counter
 130         for (i=0; i<_RegisteredManagers.size(); ++i)
 131                 _RegisteredManagers[i]->_Cycle = 0;
 132 }
 133
 134 bool    CModuleManager::allReady()
 135 {
 136         uint    i;
 137
 138         // checks if all managers are at the same cycle
 139         for (i=0; i<_RegisteredManagers.size()-1; ++i)
 140                 if (_RegisteredManagers[i]->_Cycle != _RegisteredManagers[i+1]->_Cycle)
 141                         return false;
 142
 143         return true;
 144 }
 145
 146 bool    CModuleManager::allComplete()
 147 {
 148         uint    i;
 149
 150         // checks if all managers have set the stop flag
 151         for (i=0; i<_RegisteredManagers.size()-1; ++i)
 152                 if (_RegisteredManagers[i]->_CompleteCycle != _RegisteredManagers[i+1]->_CompleteCycle)
 153                         return false;
 154
 155         return true;
 156 }
 157
 158 bool    CModuleManager::allStopped()
 159 {
 160         uint    i;
 161
 162         // checks if all managers have set the stop flag
 163         for (i=0; i<_RegisteredManagers.size(); ++i)
 164                 if (!_RegisteredManagers[i]->_ThreadStopped)
 165                         return false;
 166
 167         return true;
 168 }
 169
 170 void    CModuleManager::resetManagers()
 171 {
 172         // clear all registered managers
 173         _RegisteredManagers.clear();
 174 }
 175
 176
 177
 178 //
 179
 180 void    CModuleManager::addModule(uint id, TModuleExecCallback cb)
 181 {
 182         nlassert(id < _MaxModules);
 183         nlassert(cb != NULL);
 184         nldebug("FEMMAN: [%s] Added module %d (Cb=%p) to stack", _StackName.c_str(), id, (void *)cb);
 185
 186         _ExecutionStack.push_back(CExecutionItem());
 187
 188         _ExecutionStack.back().Type = Module;
 189         _ExecutionStack.back().Id = id;
 190         _ExecutionStack.back().Cb = cb;
 191
 192         _ExecutedModules.push_back(id);
 193 }
 194
 195 //
 196
 197 void    CModuleManager::addWait(uint id)
 198 {
 199         nlassert(id < _MaxModules);
 200         nldebug("FEMMAN: [%s] Added wait %d to stack", _StackName.c_str(), id);
 201
 202         _ExecutionStack.push_back(CExecutionItem());
 203
 204         _ExecutionStack.back().Type = Wait;
 205         _ExecutionStack.back().Id = id;
 206         _ExecutionStack.back().Cb = NULL;
 207 }
 208
 209 //
 210
 211 void    CModuleManager::start()
 212 {
 213         _Thread = IThread::create(this);
 214
 215         _StopThread = false;
 216         _ThreadStopped = false;
 217
 218         _Thread->start();
 219         //nlinfo("FEMMAN: [%s] Start", _StackName.c_str());
 220 }
 221
 222 //
 223
 224 void    CModuleManager::runOnce()
 225 {
 226         _StopThread = false;
 227         _ThreadStopped = false;
 228
 229         //nlinfo("FEMMAN: [%s] Running one time", _StackName.c_str());
 230
 231         // step cycle
 232         stepCycle();
 233
 234         // wait for all managers to sync on the same cycle before entering mutexes
 235         waitAllReady();
 236
 237         // lock mutexes
 238         enterMutexes();
 239
 240         completeCycle();
 241
 242         // and wait for all managers to finish entering mutexes
 243         waitAllComplete();
 244
 245         //H_BEFORE(MMExecuteStack);
 246         executeStack();
 247         //H_AFTER(MMExecuteStack);
 248
 249         _ThreadStopped = true;
 250 }
 251
 252 //
 253
 254 void    CModuleManager::stop(bool blockingMode, TTime timeout)
 255 {
 256         // non independent modules (called by main thread) are always stopped at this point, no need to force stop
 257         if (!_Independent)
 258         {
 259                 _ThreadStopped = true;
 260                 return;
 261         }
 262
 263
 264         if (!blockingMode)
 265         {
 266                 // if soft stop, just send stop message and leave
 267                 nlinfo("FEMMAN: [%s] soft stop", _StackName.c_str());
 268                 _StopThread = true;
 269                 return;
 270         }
 271
 272         if (!_StopThread)
 273         {
 274                 // if not yet called stop, send message stop
 275                 nlinfo("FEMMAN: [%s] hard stop", _StackName.c_str());
 276                 _StopThread = true;
 277
 278                 // wait for stop or timeout
 279                 TTime   before = CTime::getLocalTime();
 280                 while (!_ThreadStopped && CTime::getLocalTime()-before < timeout)
 281                         nlSleep(10);
 282         }
 283
 284         if ( _Thread )
 285         {
 286                 // if timeout, terminate thread
 287                 if (!_ThreadStopped)
 288                 {
 289                         nlwarning("FEMMAN: [%s] Can't stop. Brutal thread killing", _StackName.c_str());
 290                         _Thread->terminate();
 291                 }
 292
 293                 delete _Thread;
 294                 _Thread = NULL;
 295         }
 296 }
 297
 298
 299 //
 300
 301 void    CModuleManager::run()
 302 {
 303         nldebug("FEMMAN: [%s] attached thread loop start", _StackName.c_str());
 304
 305         while (true)
 306         {
 307                 // step cycle
 308                 stepCycle();
 309
 310                 // wait for all managers to sync on the same cycle before entering mutexes
 311                 waitAllReady();
 312
 313                 // lock mutexes
 314                 enterMutexes();
 315
 316                 completeCycle();
 317
 318                 // and wait for all managers to finish entering mutexes
 319                 waitAllComplete();
 320
 321                 //H_BEFORE(MMExecuteStack);
 322                 executeStack();
 323                 //H_AFTER(MMExecuteStack);
 324
 325                 // if stop sent, just leave
 326                 if (_StopThread)
 327                         break;
 328         }
 329
 330         nldebug("FEMMAN: [%s] attached thread loop end", _StackName.c_str());
 331
 332         _ThreadStopped = true;
 333 }
 334
 335 //
 336
 337 void    CModuleManager::executeStack()
 338 {
 339         // for each item,
 340         //   if a module,
 341         //      calls associated callback
 342         //      leaves mutex
 343         //   else
 344         //      enters mutex
 345         //      leaves mutex
 346
 347         //nldebug("FEMMAN: [%s] execute stack", _StackName.c_str());
 348
 349         uint    i;
 350
 351         for (i=0; i<_ExecutionStack.size(); ++i)
 352         {
 353                 CExecutionItem  &item = _ExecutionStack[i];
 354
 355                 if (item.Type == Module)
 356                 {
 357                         //nldebug("FEMMAN: [%s] execute module %d at %p", _StackName.c_str(), item.Id, item.Cb);
 358                         //H_BEFORE(MMCall);
 359                         item.Cb();
 360                         //H_AFTER(MMCall);
 361                         _ModMutexes[item.Id].leave();
 362                 }
 363                 else if (item.Type == Wait)
 364                 {
 365                         //nldebug("FEMMAN: [%s] wait for module %d to finish", _StackName.c_str(), item.Id);
 366                         //H_BEFORE(MMWait);
 367                         //TTime t = CTime::getLocalTime();
 368                         _ModMutexes[item.Id].enter();
 369                         //nlinfo( "Waited %u ms", (uint32)(CTime::getLocalTime()-t) );
 370                         _ModMutexes[item.Id].leave();
 371                         //H_AFTER(MMWait);
 372                 }
 373                 else
 374                 {
 375                         nlwarning("FEMMAN: Unexpected ExecutionItem type (%d) at item %d of the execution stack %s", item.Type, i, _StackName.c_str());
 376                         uint    j;
 377                         for (j=0; j<_ExecutionStack.size(); ++j)
 378                                 nlwarning("FEMMAN: > %d [%s] Id=%d Cb=%p", j, (item.Type == Module) ? "MOD" : (item.Type == Wait) ? "WAIT" : "ERR", item.Id, (void *)item.Cb);
 379                         nlerror("FEMMAN: Error in execution stack %s", _StackName.c_str());
 380                 }
 381         }
 382
 383         //nldebug("FEMMAN: [%s] stack executed", _StackName.c_str());
 384 }
 385
 386 void    CModuleManager::enterMutexes()
 387 {
 388         // enters all controlled mutexes
 389
 390         //nldebug("FEMMAN: [%s] Entering all controlled mutexes", _StackName.c_str());
 391
 392         uint    i;
 393
 394         for (i=0; i<_ExecutedModules.size(); ++i)
 395         {
 396                 //nldebug("FEMMAN: [%s] Entering mutex %d", _StackName.c_str(), _ExecutedModules[i]);
 397                 //TTime t = CTime::getLocalTime();
 398                 _ModMutexes[_ExecutedModules[i]].enter();
 399                 //nlinfo( "Waited %u ms", (uint32)(CTime::getLocalTime()-t) );
 400         }
 401         //nldebug("FEMMAN: [%s] All controlled mutexes successfully entered", _StackName.c_str());
 402 }
 403
 404