Khaganat-NeL/khanat-opennel-code
2
0
Fork 0
Code Issues 21 Pull requests Projects Releases 1 Packages Wiki Activity
khanat-opennel-code/code/ryzom/server/src/tick_service/tick_service.cpp

1262 lines
31 KiB
C++
Raw Blame History

// Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
// Copyright (C) 2010 Winch Gate Property Limited
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "nel/misc/command.h"
#include "nel/misc/variable.h"
#include "nel/misc/common.h"
#include "nel/misc/file.h"
#include "game_share/ryzom_version.h"
#include "game_share/tick_event_handler.h"
#include "game_share/backup_service_interface.h"
#include "game_share/singleton_registry.h"
#include <time.h>
#include "tick_service.h"
#include <string>
#ifdef NL_OS_WINDOWS
# ifndef NL_COMP_MINGW
# define NOMINMAX
# endif
# include <windows.h>
#endif // NL_OS_WINDOWS
using namespace std;
using namespace NLMISC;
using namespace NLNET;
// force admin module to link in
extern void admin_modules_forceLink();
void foo()
{
admin_modules_forceLink();
}
CTickService * TS = NULL;
NLNET::TServiceId SlowestService(0);
NLNET::TServiceId SlowestCandidate(0);
double SlowestTock = 0.0;
string WaitingForServices;
const string GAME_CYCLE_FILE = "game_cycle.ticks";
const NLMISC::TGameCycle INTERVAL_FOR_SAVING_GAME_CYCLE = 300;
// when true the tick service stops broadcasting ticks
bool Pause = false;
// In the Tick Service, set TotalSpeedLoop to the duration of a whole tick cycle
// (between send tick and the last tock received)
extern CVariable<sint32> TotalSpeedLoop;
extern CVariable<sint32> TickSpeedLoop;
static NLMISC::TTime BeginOfTickTime = 0;
CVariable<uint> TickSendingMode( "tick", "TickSendingMode", "0=Continuous 1=StepByStep 2=Fastest", 0,
0, true );
/*CVariable<float> WaitForBSThreshold( "tick", "WaitForBSThreshold", "Threshold for BSAckDelay beyond which tick starts to slow down to wait for BS (expressed as a factor of _TickTimeStep)", 1.0f,
0, true );
*/
//-----------------------------------------------
// cbRegister
//
//-----------------------------------------------
static void cbRegister(CMessage& msgin, const string &serviceName, NLNET::TServiceId serviceId)
{
if( serviceId.get() > 255 )
{
nlwarning("<cbRegister> Service %s id is too higher than 255 : %d, this service will be not registered",serviceName.c_str(),serviceId.get());
return;
}
bool tocking = true;
uint16 threshold = 0;
msgin.serial( tocking );
msgin.serial( threshold );
TS->registerClient( serviceId, tocking, threshold );
CMessage msgout( "REGISTERED" );
TGameTime gameTime = TS->getGameTime();
TGameTime gameTimeStep = TS->getGameTimeStep();
TGameCycle gameCycle = TS->getGameCycle();
msgout.serial( gameTime );
msgout.serial( gameTimeStep );
msgout.serial( gameCycle );
CUnifiedNetwork::getInstance()->send(serviceId,msgout);
if( TS->getClientCount() == 1 )
{
TS->FirstTime = true;
BeginOfTickTime = CTime::getLocalTime();
TS->checkTockReceived();
}
} // cbRegister //
//-----------------------------------------------
// cbTock
//
//-----------------------------------------------
static void cbTock(CMessage& msgin, const string &serviceName, NLNET::TServiceId serviceId)
{
// Receive measures of client service
TS->MainTimeMeasures.CurrentMirrorMeasures.push_back( CMirrorGameCycleTimeMeasureMS() );
CMirrorGameCycleTimeMeasureMS& mm = TS->MainTimeMeasures.CurrentMirrorMeasures.back();
msgin.serial( mm );
mm.MSId = serviceId;
// Process Tock
//nlinfo( "TOCK rcvd at %.6f", CTime::ticksToSecond( CTime::getPerformanceTime() ) );
SlowestCandidate=serviceId;
TS->addTock( serviceId );
} // cbTock //
//-----------------------------------------------
// cbHaltTick
//
//-----------------------------------------------
static void cbHaltTick(CMessage& msgin, const string &serviceName, NLNET::TServiceId serviceId)
{
std::string reason = "<UNKNOWN>";
try
{
msgin.serial(reason);
}
catch(const Exception&)
{
}
reason = toString("service %s:%d halted: %s", serviceName.c_str(), serviceId.get(), reason.c_str());
TS->haltTick(reason);
} // cbHaltTick //
//-----------------------------------------------
// cbResumeTick
//
//-----------------------------------------------
static void cbResumeTick(CMessage& msgin, const string &serviceName, NLNET::TServiceId serviceId)
{
TS->resumeTick();
} // cbHaltTick //
//-----------------------------------------------
// callback table for input message
//
//-----------------------------------------------
TUnifiedCallbackItem CbArray[] =
{
{ "REGISTER", cbRegister },
{ "TOCK", cbTock },
{ "HALT_TICK", cbHaltTick },
{ "RESUME_TICK", cbResumeTick },
};
/*
* halt ticking
*/
void CTickService::haltTick(const std::string& reason)
{
if (CurrentMode == TickHalted)
return;
CurrentMode = TickHalted;
nlwarning("***********************************************************");
nlwarning("WARNING:");
nlwarning("TICK SERVICE IS ENTERING HALTED MODE");
nlwarning("HALT REQUEST IS '%s'", reason.c_str());
nlwarning("***********************************************************");
HaltedReason = reason;
IService::setCurrentStatus("HALTED");
}
/*
* resume ticking
*/
void CTickService::resumeTick()
{
if (CurrentMode == TickRunning)
return;
// restart ticking
CurrentMode = TickRunning;
nlwarning("***********************************************************");
nlwarning("WARNING:");
nlwarning("TICK SERVICE IS RESUMED");
nlwarning("HALT REQUEST WAS '%s'", HaltedReason.c_str());
nlwarning("***********************************************************");
// check in case tocks were received during halt
checkTockReceived();
IService::clearCurrentStatus("HALTED");
}
//-----------------------------------------------
// registerClient
//
//-----------------------------------------------
void CTickService::registerClient( NLNET::TServiceId serviceId, bool tocking, uint16 threshold )
{
if( serviceId.get() < _ClientInfos.size() )
{
if( _ClientInfos[serviceId.get()].Registered == true )
{
nlerror("<CTickService::registerClient> The service %d is alredy registered",serviceId.get());
}
_ClientInfos[serviceId.get()].Registered = true;
_ClientInfos[serviceId.get()].Tocking = tocking;
_ClientInfos[serviceId.get()].Threshold = threshold;
_QuickLog.displayNL( "%u: +%hu", getGameCycle(), serviceId.get() );
}
else
{
nlwarning("<CTickService::registerClient> Service id too high : %d (max is %d)",serviceId.get(),_ClientInfos.size()-1);
}
} // registerClient //
//-----------------------------------------------
// addTock
//
//-----------------------------------------------
void CTickService::addTock( NLNET::TServiceId serviceId )
{
time_t t; time( &t );
_QuickLog.displayNL( "%s: %u: [<-%hu] TOCK-r", IDisplayer::dateToHumanString(t), getGameCycle(), serviceId.get() );
if( serviceId.get() < _ClientInfos.size() )
{
if( _ClientInfos[serviceId.get()].Registered )
{
if( _ClientInfos[serviceId.get()].TockReceived )
{
if( _ClientInfos[serviceId.get()].Threshold == 0 )
{
nlwarning("<CTickService::addTock> Tock received more than once despite a threshold null");
}
}
else
{
_ClientInfos[serviceId.get()].TockReceived = true;
_QuickLog.displayNL( "%u: [<-%hu] TOCK-p", getGameCycle(), serviceId.get() );
}
if( _ClientInfos[serviceId.get()].TockMissingCount > 0 )
{
_ClientInfos[serviceId.get()].TockMissingCount--;
}
else
{
nlwarning("<CTickService::addTock> Receiving a tock, but there was no tock missing !");
}
}
else
{
nlwarning("(TICKS)<CTickService::addTock> Tock received from service %d which is not registered",serviceId.get());
}
checkTockReceived();
}
else
{
nlwarning("<CTickService::addTock> Service id too high : %d (max is %d)", serviceId.get(), _ClientInfos.size()-1);
}
} // addTock //
//-----------------------------------------------
// checkTockReceived
//
//-----------------------------------------------
void CTickService::checkTockReceived()
{
// Do not tick if ticking is halted
if (CurrentMode == TickHalted)
return;
// check if all the tocks have been received (or if missing is less than threshold )
uint i;
for( i=0; i<_ClientInfos.size(); i++ )
{
// if this client is supposed to send a tock
if( _ClientInfos[i].Registered )
{
// if tock was not received yet
if( _ClientInfos[i].TockReceived == false )
{
// if we have to wait for this client
if( _ClientInfos[i].Tocking == true )
{
// we check threshold
if( _ClientInfos[i].TockMissingCount > _ClientInfos[i].Threshold )
{
return;
}
}
}
}
}
TotalSpeedLoop = (sint32)(CTime::getLocalTime() - BeginOfTickTime);
// set the TickSpeedLoop var to the same value
TickSpeedLoop = TotalSpeedLoop;
MainTimeMeasures.CurrentTickServiceMeasure[PrevTotalTickDuration] = (uint16)TotalSpeedLoop.get();
//nlinfo( "End of tick at %.6f", CTime::ticksToSecond( CTime::getPerformanceTime() ) );
// Step by step mode
if( TickSendingMode.get() == StepByStep )
{
if( _StepCount > 0 )
{
// broadcast the tick
broadcastTick();
_StepCount--;
}
}
// Continuous or fastest mode
else
{
TLocalTime currentTime = ((double)CTime::getLocalTime())/1000.0;
SlowestService=SlowestCandidate;
SlowestTock = currentTime - _TickSendTime;
// if it's the first time we send a tick, we init the tick send time
if( FirstTime )
{
_TickSendTime = currentTime - _TickTimeStep;
_LastTickTimeStep = _TickTimeStep;
FirstTime = false;
}
// setup the default value for the time step to use
NLMISC::TLocalTime effectiveTimeStep= _TickTimeStep;
// if the backup service is taking longer than _TickTimeStep to respond, then we need to slow down to a little slower than its pace
/* NLMISC::TLocalTime lastBSAckDelay= ((NLMISC::TLocalTime)Bsi.getLastAckDelay())/1000.0;
if ((WaitForBSThreshold>=1.0f) && (float)lastBSAckDelay>(float)_TickTimeStep*WaitForBSThreshold)
{
effectiveTimeStep= lastBSAckDelay+ (lastBSAckDelay-_TickTimeStep)/2;
}
*/
// smooth out BS update rate fluctuations with a simple filter and store away the time step value for next time round
effectiveTimeStep= (effectiveTimeStep+3*_LastTickTimeStep)/4;
_LastTickTimeStep= effectiveTimeStep;
// if we have to wait before sending tick
while ( ( currentTime < (_TickSendTime + effectiveTimeStep) ) && ( TickSendingMode.get() != Fastest) )
{
if ( currentTime < _TickSendTime )
{
nlinfo( "Backward time sync detected (about %.1f s)", _TickSendTime - currentTime );
_TickSendTime = currentTime;
}
else
{
nlSleep( (uint32)((_TickSendTime + effectiveTimeStep - currentTime)*1000.0) );
}
currentTime = ((double)CTime::getLocalTime())/1000.0;
}
// increment the send time
TLocalTime oldTime = _TickSendTime;
_TickSendTime = ((double)CTime::getLocalTime())/1000.0;
double dt = _TickSendTime - oldTime;
// round off the send time to iron out high frequency effects
if (_TickSendTime<oldTime+effectiveTimeStep)
_TickSendTime=oldTime+effectiveTimeStep;
if (effectiveTimeStep*1000.0>1.0)
{
dt = double(uint32(dt*1000.0)/ uint32(effectiveTimeStep*1000.0) * uint32(effectiveTimeStep*1000.0))/1000.0;
_TickSendTime = oldTime + dt;
}
//nlinfo( " %"NL_I64"u %"NL_I64"u", (TTime)((_TickSendTime-oldTime)*1000), (TTime)((d2-oldTime)*1000) );
// broadcast the tick
broadcastTick();
// update the tick time step
//updateTickTimeStep
}
} // checkTockReceived //
//-----------------------------------------------
// broadcastTick
//
//-----------------------------------------------
void CTickService::broadcastTick()
{
if ( Pause == true ) return;
MainTimeMeasures.beginNewCycle();
BeginOfTickTime = CTime::getLocalTime();
// increment the game time and cycle
_GameTime += _GameTimeStep;
_GameCycle++;
CTickEventHandler::setGameCycle( _GameCycle ); // to display the good value in the variable
// we send a tick to every registered client
uint i;
for( i=0; i<_ClientInfos.size(); i++ )
{
if( _ClientInfos[i].Registered )
{
CMessage msgout;
if( _GameTimeStepHasChanged )
{
msgout.setType( "STEP_TICK" );
msgout.serial( _GameTimeStep );
_QuickLog.displayNL( "%u: [->%u] STEP_TICK", getGameCycle(), i );
}
else
{
msgout.setType( "TICK" );
time_t t; time( &t );
_QuickLog.displayNL( "%s: %u: [->%u] TICK", IDisplayer::dateToHumanString(t), getGameCycle(), i );
}
CUnifiedNetwork::getInstance()->send(NLNET::TServiceId(i),msgout);
TSockId host;
CCallbackNetBase *cnb;
cnb = CUnifiedNetwork::getInstance()->getNetBase(NLNET::TServiceId(i),host);
if( cnb )
{
cnb->flush( host );
}
// we are now waiting for a tick from this client
_ClientInfos[i].TockReceived = false;
_ClientInfos[i].TockMissingCount++;
}
}
_GameTimeStepHasChanged = false;
CSingletonRegistry::getInstance()->tickUpdate();
} // broadcastTick //
//-----------------------------------------------
// cbClientDisconnection
//
//-----------------------------------------------
void cbClientDisconnection( const std::string &serviceName, NLNET::TServiceId serviceId, void *arg)
{
TS->unregisterClient( serviceId );
TS->checkTockReceived();
} // cbClientDisconnection //
//-----------------------------------------------
// unregisterClient
//
//-----------------------------------------------
void CTickService::unregisterClient( NLNET::TServiceId serviceId )
{
if( serviceId.get() < _ClientInfos.size() )
{
if ( _ClientInfos[serviceId.get()].Registered )
{
_ClientInfos[serviceId.get()].Registered = false;
_ClientInfos[serviceId.get()].TockReceived = true;
_ClientInfos[serviceId.get()].Tocking = true;
_ClientInfos[serviceId.get()].Threshold = 0;
_ClientInfos[serviceId.get()].TockMissingCount = 0;
_QuickLog.displayNL( "%u: -%hu", getGameCycle(), serviceId.get() );
}
else
{
nlinfo("<CTickService::unregisterClient> Service %d disconnection detected but this service is not registered : nothing to do",serviceId.get());
}
}
else
{
nlwarning("<CTickService::unregisterClient> Service %d : service id too big ! (max is %d)",serviceId.get(),_ClientInfos.size()-1);
}
} // unregisterClient //
//-----------------------------------------------
// getClientCount
//
//-----------------------------------------------
uint16 CTickService::getClientCount()
{
uint16 clientCount = 0;
uint i;
for( i=0; i<_ClientInfos.size(); i++ )
{
if( _ClientInfos[i].Registered )
{
clientCount++;
}
}
return clientCount;
} // getClientCount //
//-----------------------------------------------
// displayGameTime()
//
//-----------------------------------------------
void CTickService::displayGameTime() const
{
CMessage msgout( "DISPLAY_TIME" );
uint i;
for( i=0; i<_ClientInfos.size(); i++ )
{
if( _ClientInfos[i].Registered )
{
CUnifiedNetwork::getInstance()->send(NLNET::TServiceId(i),msgout);
}
}
nlinfo("(TICKS)<CTickService::displayTime> : Game time in the Tick Service : %f sec (local: %f ms)", (double)_GameTime,(double)CTime::getLocalTime());
} // displayGameTime //
/*
* Initialise the service
*/
void CTickService::init()
{
setVersion (RYZOM_VERSION);
CurrentMode = TickRunning;
CSingletonRegistry::getInstance()->init();
// keep pointer on class
TS = this;
_StepCount = 1;
// maximum 256 clients can be connected
_ClientInfos.resize(256);
try
{
_GameTime = ConfigFile.getVar("GameTime").asFloat();
}
catch(const Exception &)
{
// init the game time
_GameTime = 0.0f;
}
try
{
_GameCycle = ConfigFile.getVar("GameCycle").asInt();
_SavedGameCycle = _GameCycle;
}
catch(const Exception &)
{
// init the game cycle from file
loadGameCycle();
}
CTickEventHandler::setGameCycle( _GameCycle ); // to display the good value in the variable
try
{
_TickTimeStep = ConfigFile.getVar("TickTimeStep").asFloat();
}
catch(const Exception &)
{
// tick service time step between two ticks
_TickTimeStep = 0.1f;
}
try
{
_GameTimeStep = ConfigFile.getVar("GameTimeStep").asFloat();
}
catch(const Exception &)
{
// game time between two ticks
_GameTimeStep = 0.1f;
}
// thus the time step will be sent along with the first tick
_GameTimeStepHasChanged = true;
// local time when last tick was sent
_TickSendTime = 0;
FirstTime = true;
CUnifiedNetwork::getInstance()->setServiceDownCallback("*", cbClientDisconnection, NULL);
RecentHistory.setParam( 20 );
_QuickLog.addDisplayer( &RecentHistory, false );
_RangeMirrorManager.init();
} // init //
/*
* Release
*/
void CTickService::release()
{
if ( saveGameCycle() )
{
// nlinfo( "Game cycle %u saved to %s", _GameCycle, GAME_CYCLE_FILE.c_str() );
}
CSingletonRegistry::getInstance()->release();
}
/*
* Update
*/
bool CTickService::update()
{
CSingletonRegistry::getInstance()->serviceUpdate();
if (CurrentMode == TickHalted)
{
WaitingForServices = "TICK HALTED: "+HaltedReason;
}
else
{
WaitingForServices = "";
// check if all the tocks have been received (or if missing is less than threshold )
uint i;
for( i=0; i<_ClientInfos.size(); i++ )
{
// if this client is supposed to send a tock
if( _ClientInfos[i].Registered )
{
// if tock was not received yet
if( _ClientInfos[i].TockReceived == false )
{
// if we have to wait for this client
if( _ClientInfos[i].Tocking == true )
{
// we check threshold
if( _ClientInfos[i].TockMissingCount > _ClientInfos[i].Threshold )
{
WaitingForServices += toString(i) + " ";
}
}
}
}
}
// don't saveGameCycle if tick halted
// because BS probably sent an error report, and it would be hazardous
// to send BS new commands!!
if ( _GameCycle > _SavedGameCycle + INTERVAL_FOR_SAVING_GAME_CYCLE )
{
saveGameCycle();
}
}
return true;
}
/*
* Save to file
*/
bool CTickService::saveGameCycle()
{
_SavedGameCycle = _GameCycle; // do it anyway
try
{
CBackupMsgSaveFile msg( GAME_CYCLE_FILE, CBackupMsgSaveFile::SaveFile, Bsi );
msg.DataMsg.serialVersion( 0 );
msg.DataMsg.serial( _GameCycle );
Bsi.sendFile(msg);
/*
COFile file;
if ( file.open( SaveShardRoot.get() + IService::getInstance()->SaveFilesDirectory.toString() + GAME_CYCLE_FILE ) )
{
file.serialVersion( 0 );
file.serial( _GameCycle );
file.close();
}
else
throw EFileNotOpened( SaveShardRoot.get() + IService::getInstance()->SaveFilesDirectory.toString() + GAME_CYCLE_FILE );
return true;
*/
return true;
}
catch (const Exception &e)
{
nlwarning( "Can't save game cycle: %s", e.what() );
return false;
}
}
struct TTickFileCallback : public IBackupFileReceiveCallback
{
CTickService *TickService;
TTickFileCallback(CTickService *tickService)
: TickService(tickService)
{
}
virtual void callback(const CFileDescription& fileDescription, NLMISC::IStream& dataStream)
{
TickService->tickFileCallback(fileDescription, dataStream);
}
};
void CTickService::tickFileCallback(const CFileDescription& fileDescription, NLMISC::IStream& dataStream)
{
if (!fileDescription.FileName.empty())
{
dataStream.serialVersion( 0 );
dataStream.serial( _GameCycle );
_SavedGameCycle = _GameCycle;
}
else
{
_GameCycle = 0;
_SavedGameCycle = 0;
nlwarning("No tick file found, starting with fresh tick");
}
}
/*
* Load from file
*/
bool CTickService::loadGameCycle()
{
TTickFileCallback *cb = new TTickFileCallback(this);
Bsi.syncLoadFile(GAME_CYCLE_FILE, cb);
return true;
// try
// {
// CIFile file;
// if ( file.open( Bsi.getLocalPath() + GAME_CYCLE_FILE ) )
// {
// file.serialVersion( 0 );
// file.serial( _GameCycle );
// file.close();
// _SavedGameCycle = _GameCycle;
// }
// else
// throw EFileNotOpened( Bsi.getLocalPath() + GAME_CYCLE_FILE );
// nlinfo( "Loaded game cycle %u from %s, will be saved every %u game cycles", _GameCycle, (CPath::standardizePath(IService::getInstance()->SaveFilesDirectory.toString()) + GAME_CYCLE_FILE).c_str(), INTERVAL_FOR_SAVING_GAME_CYCLE );
// return true;
// }
// catch (const Exception &e)
// {
// nlwarning( "Can't load game cycle: %s", e.what() );
// _GameCycle = 0;
// _SavedGameCycle = _GameCycle;
// return false;
// }
}
/*
*
*/
CTickServiceGameCycleTimeMeasure::CTickServiceGameCycleTimeMeasure() : HistoryMain( CTickService::getInstance()->getServiceId(), NLNET::TServiceId(std::numeric_limits<uint16>::max()), false ) {}
/*
*
*/
void CTickServiceGameCycleTimeMeasure::beginNewCycle()
{
if ( ! CurrentMirrorMeasures.empty() )
{
// Update stats
for ( TMirrorMeasures::const_iterator imm=CurrentMirrorMeasures.begin(); imm!=CurrentMirrorMeasures.end(); ++imm )
{
storeMeasureToHistory( HistoryByMirror, imm->MirrorMeasure, imm->MSId, TServiceId(0) );
for ( std::vector<CServiceGameCycleTimeMeasure>::const_iterator ism=(*imm).ServiceMeasures.begin(); ism!=(*imm).ServiceMeasures.end(); ++ism )
{
storeMeasureToHistory( HistoryByService, (*ism).ServiceMeasure, (*ism).ClientServiceId, (*imm).MSId );
}
}
//nlinfo( "AV: C=%hu H=%hu", CurrentTickServiceMeasure[0], HistoryMain.Stats[MHTMax][0] );
HistoryMain.updateStats( CurrentTickServiceMeasure );
//nlinfo( "AP: C=%hu H=%hu", CurrentTickServiceMeasure[0], HistoryMain.Stats[MHTMax][0] );
// Clear current
CurrentMirrorMeasures.clear();
}
}
/*
*
*/
void CTickServiceGameCycleTimeMeasure::resetMeasures()
{
HistoryByMirror.clear();
HistoryByService.clear();
HistoryMain.reset( false );
}
/*
*
*/
void CTickServiceGameCycleTimeMeasure::displayStats( NLMISC::CLog *log )
{
log->displayNL( "Shard timings at GC %u:", CTickEventHandler::getGameCycle() );
log->displayRawNL( "___AVG__" );
displayStat( log, MHTSum );
log->displayRawNL( "___MAX___" );
displayStat( log, MHTMax );
log->displayRawNL( "___MIN___" );
displayStat( log, MHTMin );
}
const char * ServiceTimeMeasureTypeToCString [NbServiceTimeMeasureTypes] =
{ "TickTockInterval", "TickUpdateDuration", "PrevProcessMirrorUpdateDuration", "PrevReceiveMsgsViaMirrorDuration", "PrevTotalGameCycleDuration" };
const char * MirrorTimeMeasureTypeToCString [NbMirrorTimeMeasureTypes] =
{ "WaitAllReceivedDeltaDuration", "BuildAndSendDeltaDuration", "PrevApplyReceivedDeltaDuration", "PrevSendUMMDuration" };
const char * TickServiceTimeMeasureTypeToCString [NbTickServiceTimeMeasureTypes] =
{ "PrevTotalTickDuration" };
/*
*
*/
void CTickServiceGameCycleTimeMeasure::displayStat( NLMISC::CLog *log, TTimeMeasureHistoryStat stat )
{
log->displayRawNL( "\tTICKS, %u measures:", HistoryMain.NbMeasures );
uint divideBy = (HistoryMain.NbMeasures==0) ? 0 : ((stat==MHTSum) ? HistoryMain.NbMeasures : 1);
HistoryMain.Stats[stat].displayStat( log, TickServiceTimeMeasureTypeToCString, divideBy );
{
CMirrorTimeMeasure gatheredStats [NbTimeMeasureHistoryStats] = { 0, std::numeric_limits<uint16>::max(), 0 };
for ( std::vector<CMirrorTimeMeasureHistory>::const_iterator ihm=HistoryByMirror.begin(); ihm!=HistoryByMirror.end(); ++ihm )
{
log->displayRawNL( "\tMS-%hu, %u measures:", (*ihm).ServiceId.get(), (*ihm).NbMeasures );
divideBy = (stat==MHTSum) ? (*ihm).NbMeasures : 1;
(*ihm).Stats[stat].displayStat( log, MirrorTimeMeasureTypeToCString, divideBy );
gatheredStats[MHTSum] += (*ihm).Stats[stat] / (*ihm).NbMeasures;
gatheredStats[MHTMin].copyLowerValues( (*ihm).Stats[stat] );
gatheredStats[MHTMax].copyHigherValues( (*ihm).Stats[stat] );
}
if ( HistoryByMirror.size() > 1 )
{
log->displayRawNL( "\tAll mirror services:" );
gatheredStats[stat].displayStat( log, MirrorTimeMeasureTypeToCString, (stat==MHTSum) ? (uint)HistoryByMirror.size() : 1 ); // not displaying the 3 stats
}
}
{
CServiceTimeMeasure gatheredStats [NbTimeMeasureHistoryStats] = { 0, std::numeric_limits<uint16>::max(), 0 };
for ( std::vector<CServiceTimeMeasureHistory>::const_iterator ihs=HistoryByService.begin(); ihs!=HistoryByService.end(); ++ihs )
{
log->displayRawNL( "\t%s (on MS-%hu), %u measures:", CUnifiedNetwork::getInstance()->getServiceUnifiedName( (*ihs).ServiceId ).c_str(), (*ihs).ParentServiceId.get(), (*ihs).NbMeasures );
divideBy = (stat==MHTSum) ? (*ihs).NbMeasures : 1;
(*ihs).Stats[stat].displayStat( log, ServiceTimeMeasureTypeToCString, divideBy );
gatheredStats[MHTSum] += (*ihs).Stats[stat] / (*ihs).NbMeasures;
gatheredStats[MHTMin].copyLowerValues( (*ihs).Stats[stat] );
gatheredStats[MHTMax].copyHigherValues( (*ihs).Stats[stat] );
}
if ( HistoryByService.size() > 1 )
{
log->displayRawNL( "\tAll client services:" );
gatheredStats[stat].displayStat( log, ServiceTimeMeasureTypeToCString, (stat==MHTSum) ? (uint)HistoryByService.size() : 1 ); // not displaying the 3 stats
}
}
}
//-----------------------------------------------
// NLNET_SERVICE_MAIN
//-----------------------------------------------
NLNET_SERVICE_MAIN( CTickService, "TICKS", "tick_service", 0, CbArray, "", "" );
//
// Variables
//
NLMISC_VARIABLE(NLNET::TServiceId, SlowestService, "SId of the slowest service");
NLMISC_VARIABLE(double, SlowestTock, "Time in millisecond to receive the slowest tock");
NLMISC_VARIABLE(string, WaitingForServices, "Services that haven't tocked yet");
NLMISC_DYNVARIABLE(TGameTime, GameTime, "Current game time in second")
{
if (get) *pointer = TS->getGameTime();
}
NLMISC_DYNVARIABLE(TLocalTime, TickTimeStep, "Current tick time step in second")
{
if (get) *pointer = TS->getTickTimeStep();
else TS->setTickTimeStep(*pointer);
}
NLMISC_DYNVARIABLE(string, TickMode, "Current ticking mode")
{
if (get)
{
if (TS->CurrentMode == CTickService::TickRunning)
*pointer = "Normal";
else
*pointer = "HALTED: "+TS->HaltedReason;
}
}
//
// Commands
//
NLMISC_COMMAND(haltTick, "Halt tick server", "[reason]" )
{
if (args.size() > 1)
return false;
log.displayNL("TICK SERVICE HALTED MANUALLY.");
log.displayNL("PLEASE RESTART TICK SERVICE USING resumeTick COMMAND.");
std::string reason = "MANUAL HALT";
if (args.size() == 1)
reason += ": "+args[0];
TS->haltTick(reason);
return true;
}
NLMISC_COMMAND(resumeTick, "Resume tick server", "" )
{
log.displayNL("TICK SERVICE RESUMED MANUALLY.");
TS->resumeTick();
return true;
}
NLMISC_COMMAND(displayTimingsOfShard, "Display all timings", "" )
{
TS->MainTimeMeasures.displayStats( &log );
return true;
}
NLMISC_COMMAND(resetTimingsOfShard, "Reset all timings", "" )
{
TS->MainTimeMeasures.resetMeasures();
return true;
}
NLMISC_COMMAND(displayGameTime, "The tick service and all connected services display its current game time", "")
{
TS->displayGameTime();
return true;
}
NLMISC_COMMAND(send,"enable send (in the step by step mode)"," ")
{
TS->enableSend();
return true;
}
NLMISC_COMMAND(clients,"Give the number of clients"," ")
{
log.displayNL("Number of connected client : %d", TS->getClientCount());
return true;
}
/*
NLMISC_COMMAND(getServicesState,"Give the current state of all services"," ")
{
// todo end the code
uint i;
for( i=0; i<_ClientInfos.size(); i++ )
{
// if this client is supposed to send a tock
if( _ClientInfos[i].Registered )
{
// if tock was not received yet
if( _ClientInfos[i].TockReceived == false )
{
// if we have to wait for this client
if( _ClientInfos[i].Tocking == true )
{
// we check threshold
if( _ClientInfos[i].TockMissingCount > _ClientInfos[i].Threshold )
{
return;
}
}
}
}
}
return true;
}
*/
NLMISC_COMMAND(displayRecentHistory,"Display the history of tick events","")
{
TS->RecentHistory.write( &log );
return true;
}
NLMISC_COMMAND( pause, "Pause the tick service", "" )
{
Pause = !Pause;
if( Pause )
nlinfo("Pause On");
else
{
nlinfo("Pause Off");
TS->checkTockReceived();
}
return true;
}
/*
*/
/*
// ADDED by ben: BS test purpose, you can remove this
NLMISC_COMMAND( sendFileBS, "send file to BS", "<file to send> <file name to be written>")
{
if (args.size() != 2)
return false;
CIFile fi;
if (!fi.open(args[0]))
return false;
std::vector<uint8> buffer(fi.getFileSize());
fi.serialBuffer(&(buffer[0]), buffer.size());
CBackupMsgSaveFile msgSave;
msgSave.Data.serialBuffer(&(buffer[0]), buffer.size());
msgSave.FileName = args[1];
Bsi.sendFile(msgSave);
return true;
}
NLMISC_COMMAND( sendFileAndCheckBS, "send file to BS", "<file to send> <file name to be written>")
{
if (args.size() != 2)
return false;
CIFile fi;
if (!fi.open(args[0]))
return false;
std::vector<uint8> buffer(fi.getFileSize());
fi.serialBuffer(&(buffer[0]), buffer.size());
CBackupMsgSaveFile msgSave;
msgSave.Data.serialBuffer(&(buffer[0]), buffer.size());
msgSave.FileName = args[1];
Bsi.sendFile(msgSave, true);
return true;
}
NLMISC_COMMAND( appendFileBS, "append file to BS", "<file to send> <file name to be written>")
{
if (args.size() != 2)
return false;
CIFile fi;
if (!fi.open(args[0]))
return false;
std::vector<uint8> buffer(fi.getFileSize());
fi.serialBuffer(&(buffer[0]), buffer.size());
CBackupMsgSaveFile msgSave;
msgSave.Data.serialBuffer(&(buffer[0]), buffer.size());
msgSave.FileName = args[1];
Bsi.append(msgSave);
return true;
}
NLMISC_COMMAND( appendLineBS, "append line to file via BS", "<line to be sent> <file name to be written>")
{
if (args.size() != 2)
return false;
Bsi.append(args[0], args[1]);
return true;
}
NLMISC_COMMAND( deleteFileBS, "delete file via BS", "<file name to be deleted> [backup file]")
{
if (args.size() < 1 || args.size() > 2)
return false;
bool backupFile = false;
if (args.size() == 2)
{
NLMISC::fromString(args[1], backupFile);
}
Bsi.deleteFile(args[0], backupFile);
return true;
}
class CFileReceiveCb: public IBackupFileReceiveCallback
{
public:
virtual void callback(const CFileDescription& fileDescription, NLMISC::IStream& dataStream)
{
nlinfo("received file '%s'", fileDescription.FileName.c_str());
}
};
NLMISC_COMMAND( loadFileBS, "load a file from BS", "<file to be loaded>")
{
if (args.size() != 1)
return false;
Bsi.requestFile(args[0], new CFileReceiveCb());
return true;
}
*/
class CFileClassReceiveCb: public IBackupFileClassReceiveCallback
{
public:
virtual void callback(const CFileDescriptionContainer& list)
{
nlinfo("received fileclass");
uint i;
for (i=0; i<list.size(); ++i)
nlinfo("file: %s", list[i].FileName.c_str());
nlinfo("end of class");
}
};
NLMISC_COMMAND( loadFileClassBS, "load a fileclass from BS", "<directory> <classes to be loaded>")
{
if (args.size() <= 1)
return false;
std::string directory;
std::vector<CBackupFileClass> classes;
CBackupFileClass bclass;
directory = args[0];
uint i;
for (i=1; i<args.size(); ++i)
bclass.Patterns.push_back(args[i]);
classes.push_back(bclass);
Bsi.requestFileClass(directory, classes, new CFileClassReceiveCb());
return true;
}
//NLMISC_COMMAND( dumpVectorMemory, "Dump memory used in vector", "")
//{
// static char buffer[1024*16];
// _vector_memory_usage::dump_memory(buffer, 1024*16);
//
// log.displayNL("Vector memory usage : \n%s", buffer);
//
// return true;
//}
Reference in a new issue View git blame Copy permalink