//-----------------------------------------------------------------------------
// Purpose: Re-sort all data and determine whether sort keys should be reset too ( after
// re-doing sort if needed ).
//-----------------------------------------------------------------------------
void ResetTimeMeasurements( void )
{
#if defined( _DEBUG ) || defined( FORCE_MEASURE )
bool sort_reset = false;
// Time to redo sort?
if ( measure_resort.GetFloat() > 0.0 &&
GetRealTime() >= CMeasureSection::m_dNextResort )
{
// Redo it
CMeasureSection::SortSections();
// Set next time
CMeasureSection::m_dNextResort = GetRealTime() + measure_resort.GetFloat();
// Flag to reset sort accumulator, too
sort_reset = true;
}
// Iterate through the sections now
CMeasureSection *p = CMeasureSection::GetList();
while ( p )
{
// Reset regular accum.
p->Reset();
// Reset sort accum less often
if ( sort_reset )
{
p->SortReset();
}
p = p->GetNext();
}
#endif
}
void
encoder_progress( lame_global_flags const* gf )
{
if (global_ui_config.silent <= 0) {
int const frames = lame_get_frameNum(gf);
int const frames_diff = frames - global_encoder_progress.last_frame_num;
if (global_ui_config.update_interval <= 0) { /* most likely --disptime x not used */
if (frames_diff < 100 && frames_diff != 0) { /* true, most of the time */
return;
}
global_encoder_progress.last_frame_num = (frames/100)*100;
}
else {
if (frames != 0 && frames != 9) {
double const act = GetRealTime();
double const dif = act - global_encoder_progress.last_time;
if (dif >= 0 && dif < global_ui_config.update_interval) {
return;
}
}
global_encoder_progress.last_time = GetRealTime(); /* from now! disp_time seconds */
}
if (global_ui_config.brhist) {
brhist_jump_back();
}
timestatus(gf);
if (global_ui_config.brhist) {
brhist_disp(gf);
}
console_flush();
}
}
void b3Time::Update() {
u64 ui64TimeNow = GetRealTime();
u64 ui64DeltaTime = ui64TimeNow - m_lastRealTime;
m_lastRealTime = ui64TimeNow;
UpdateBy(ui64DeltaTime);
}
int TimeCounter::GetTime()
{
int n = GetRealTime() - _starttime;
if(n < 0)
n += 0x100000 * 1000;
return n;
}
inline void StopWatch::Stop()
{
if (!Running) return;
#if (MFEM_TIMER_TYPE == 0)
user_time += ( std::clock() - start_utime );
#elif (MFEM_TIMER_TYPE == 1)
clock_t curr_rtime, curr_utime, curr_stime;
Current(&curr_rtime, &curr_utime, &curr_stime);
real_time += ( curr_rtime - start_rtime );
user_time += ( curr_utime - start_utime );
syst_time += ( curr_stime - start_stime );
#elif (MFEM_TIMER_TYPE == 2)
struct timespec curr_rtime, curr_utime;
GetRealTime(curr_rtime);
GetUserTime(curr_utime);
real_time.tv_sec += ( curr_rtime.tv_sec - start_rtime.tv_sec );
real_time.tv_nsec += ( curr_rtime.tv_nsec - start_rtime.tv_nsec );
user_time.tv_sec += ( curr_utime.tv_sec - start_utime.tv_sec );
user_time.tv_nsec += ( curr_utime.tv_nsec - start_utime.tv_nsec );
#elif (MFEM_TIMER_TYPE == 3)
LARGE_INTEGER curr_rtime;
QueryPerformanceCounter(&curr_rtime);
real_time.QuadPart += (curr_rtime.QuadPart - start_rtime.QuadPart);
#endif
Running = 0;
}
void TimeCounter::Pause()
{
if (_pause == true)
{
int pausedelay;
pausedelay = (GetRealTime() - _starttime) - _pausetime;
_starttime += pausedelay;
_pause = false;
}
else
{
_pausetime = GetRealTime() - _starttime;
_pause = true;
}
}
timeval GetRealTimeCommandSend() {
if (PlayerParam::instance().DynamicDebugMode() == true) {
return DynamicDebug::instance().GetTimeCommandSend();
}
timeval time_val = GetRealTime();
DynamicDebug::instance().AddTimeCommandSend(time_val);
return time_val;
}
b3Time::b3Time() :
m_frequency(B3_ONE_SECOND_MICROSECONDS),
m_curTime(0ULL),
m_lastTime(0ULL),
m_lastRealTime(0ULL),
m_curMicros(0ULL),
m_deltaMicros(0ULL) {
::QueryPerformanceFrequency(reinterpret_cast<LARGE_INTEGER*>(&m_frequency));
m_lastRealTime = GetRealTime();
}
NS_IMETHODIMP nsStopwatch::Resume()
{
if (!fRunning)
{
fStartRealTimeSecs = GetRealTime();
fStartCpuTimeSecs = GetCPUTime();
}
fRunning = true;
return NS_OK;
}
NS_IMETHODIMP nsStopwatch::Stop()
{
fStopRealTimeSecs = GetRealTime();
fStopCpuTimeSecs = GetCPUTime();
if (fRunning)
{
fTotalCpuTimeSecs += fStopCpuTimeSecs - fStartCpuTimeSecs;
fTotalRealTimeSecs += fStopRealTimeSecs - fStartRealTimeSecs;
}
fRunning = false;
return NS_OK;
}
inline void StopWatch::Start()
{
if (Running) return;
#if (MFEM_TIMER_TYPE == 0)
start_utime = std::clock();
#elif (MFEM_TIMER_TYPE == 1)
Current(&start_rtime, &start_utime, &start_stime);
#elif (MFEM_TIMER_TYPE == 2)
GetRealTime(start_rtime);
GetUserTime(start_utime);
#elif (MFEM_TIMER_TYPE == 3)
QueryPerformanceCounter(&start_rtime);
#endif
Running = 1;
}
void timestatus_klemm ( const lame_global_flags* const gfp )
{
static double last_time = 0.;
if ( silent <= 0 )
if ( lame_get_frameNum(gfp) == 0 ||
lame_get_frameNum(gfp) == 9 ||
GetRealTime () - last_time >= update_interval ||
GetRealTime () - last_time < 0 ) {
#ifdef BRHIST
brhist_jump_back();
#endif
timestatus ( lame_get_out_samplerate( gfp ),
lame_get_frameNum(gfp),
lame_get_totalframes(gfp),
lame_get_framesize(gfp) );
#ifdef BRHIST
if ( brhist ) {
brhist_disp ( gfp );
}
#endif
last_time = GetRealTime (); /* from now! disp_time seconds */
}
}
void Stopwatch::Stop() {
#ifndef R__UNIX
fStopRealTime = GetRealTime();
fStopCpuTime = GetCPUTime();
#else
struct tms cpt;
fStopRealTime = (double)times(&cpt) / gTicks;
fStopCpuTime = (double)(cpt.tms_utime+cpt.tms_stime) / gTicks;
#endif
if (fState == kRunning) {
fTotalCpuTime += fStopCpuTime - fStartCpuTime;
fTotalRealTime += fStopRealTime - fStartRealTime;
}
fState = kStopped;
}
void MediPixAlgoTimer::DumpTimers(){
std::map<TString, TStopwatch>::iterator timerItr = timers.begin();
std::cout << "Timers ------------------------------------" << std::endl;
std::cout << " AlgoName: realtime, cputime " << std::endl;
for( ; timerItr != timers.end() ; timerItr++)
{
std::cout << " " << (*timerItr).first << ": ";
std::cout << GetRealTime((*timerItr).first) << ", ";
std::cout << GetCpuTime((*timerItr).first) << " [s]" << std::endl;
}
std::cout << "-------------------------------------------" << std::endl;
}
void Stopwatch::Start(PRBool reset) {
if (reset) {
fTotalCpuTime = 0;
fTotalRealTime = 0;
}
if (fState != kRunning) {
#ifndef R__UNIX
fStartRealTime = GetRealTime();
fStartCpuTime = GetCPUTime();
#else
struct tms cpt;
fStartRealTime = (double)times(&cpt) / gTicks;
fStartCpuTime = (double)(cpt.tms_utime+cpt.tms_stime) / gTicks;
#endif
}
fState = kRunning;
}
inline double StopWatch::RealTime()
{
#if (MFEM_TIMER_TYPE == 0)
return UserTime();
#elif (MFEM_TIMER_TYPE == 1)
clock_t curr_rtime, curr_utime, curr_stime;
clock_t rtime = real_time;
if (Running)
{
Current(&curr_rtime, &curr_utime, &curr_stime);
rtime += (curr_rtime - start_rtime);
}
return (double)(rtime) / my_CLK_TCK;
#elif (MFEM_TIMER_TYPE == 2)
if (Running)
{
struct timespec curr_rtime;
GetRealTime(curr_rtime);
return ((real_time.tv_sec + (curr_rtime.tv_sec - start_rtime.tv_sec)) +
1e-9*(real_time.tv_nsec +
(curr_rtime.tv_nsec - start_rtime.tv_nsec)));
}
else
{
return real_time.tv_sec + 1e-9*real_time.tv_nsec;
}
#elif (MFEM_TIMER_TYPE == 3)
LARGE_INTEGER curr_rtime, rtime = real_time;
if (Running)
{
QueryPerformanceCounter(&curr_rtime);
rtime.QuadPart += (curr_rtime.QuadPart - start_rtime.QuadPart);
}
return (double)(rtime.QuadPart) / frequency.QuadPart;
#endif
}
inline void StopWatch::Clear()
{
#if (MFEM_TIMER_TYPE == 0)
user_time = 0;
if (Running)
start_utime = std::clock();
#elif (MFEM_TIMER_TYPE == 1)
real_time = user_time = syst_time = 0;
if (Running)
Current(&start_rtime, &start_utime, &start_stime);
#elif (MFEM_TIMER_TYPE == 2)
real_time.tv_sec = user_time.tv_sec = 0;
real_time.tv_nsec = user_time.tv_nsec = 0;
if (Running)
{
GetRealTime(start_rtime);
GetUserTime(start_utime);
}
#elif (MFEM_TIMER_TYPE == 3)
real_time.QuadPart = 0;
if (Running)
QueryPerformanceCounter(&start_rtime);
#endif
}
void SignalAll()
{
GetRealTime();
fDynThreadAdapter.StartMeasure();
fThreadPool->SignalAll(fDynamicNumThreads - 1);
}
void timestatus ( const int samp_rate,
const int frameNum,
const int totalframes,
const int framesize )
{
static timestatus_t real_time;
static timestatus_t proc_time;
int percent;
static int init = 0; /* What happens here? A work around instead of a bug fix ??? */
double tmx,delta;
if ( frameNum == 0 ) {
real_time.last_time = GetRealTime ();
proc_time.last_time = GetCPUTime ();
real_time.elapsed_time = 0;
proc_time.elapsed_time = 0;
}
/* we need rollover protection for GetCPUTime, and maybe GetRealTime(): */
tmx=GetRealTime();
delta=tmx-real_time.last_time;
if (delta<0) delta=0; /* ignore, clock has rolled over */
real_time.elapsed_time += delta;
real_time.last_time = tmx;
tmx=GetCPUTime();
delta=tmx-proc_time.last_time;
if (delta<0) delta=0; /* ignore, clock has rolled over */
proc_time.elapsed_time += delta;
proc_time.last_time = tmx;
if ( frameNum == 0 && init == 0 ) {
fprintf ( stderr,
"\r"
" Frame | CPU time/estim | REAL time/estim | play/CPU | ETA \n"
" 0/ ( 0%%)| 0:00/ : | 0:00/ : | " SPEED_CHAR "| : \r"
/* , Console_IO.str_clreoln, Console_IO.str_clreoln */ );
init = 1;
return;
}
/* reset init counter for next time we are called with frameNum==0 */
if (frameNum > 0)
init = 0;
ts_calc_times ( &real_time, samp_rate, frameNum, totalframes, framesize );
ts_calc_times ( &proc_time, samp_rate, frameNum, totalframes, framesize );
if ( frameNum < totalframes ) {
percent = (int) (100. * frameNum / totalframes + 0.5 );
} else {
percent = 100;
}
fprintf ( stderr, "\r%6i/%-6i", frameNum, totalframes );
fprintf ( stderr, percent < 100 ? " (%2d%%)|" : "(%3.3d%%)|", percent );
ts_time_decompose ( (unsigned long)proc_time.elapsed_time , '/' );
ts_time_decompose ( (unsigned long)proc_time.estimated_time, '|' );
ts_time_decompose ( (unsigned long)real_time.elapsed_time , '/' );
ts_time_decompose ( (unsigned long)real_time.estimated_time, '|' );
fprintf ( stderr, proc_time.speed_index <= 1. ?
"%9.4f" SPEED_CHAR "|" : "%#9.5g" SPEED_CHAR "|",
SPEED_MULT * proc_time.speed_index );
ts_time_decompose ( (unsigned long)(real_time.estimated_time - real_time.elapsed_time), ' ' );
fflush ( stderr );
}
/** \brief Initializers the event handlers
*
* \return void
*
*/
void CShooterGame::InitHandlers() {
///////////////////////////////////////////////////
//
// On User Events
//
///////////////////////////////////////////////////
m_Handlers["OnUserEvent"] = {
{
//
// STATE::SPLASH_SCREEN
//
(int)STATE::SPLASH_SCREEN,
[&](SDL_Event& ev){
int nEventType = ev.user.code;
if ( nEventType == DemoEngine::EVENTTYPE::SCENE_EVENT ) {
int nState = static_cast<int>(reinterpret_cast<uintptr_t>(ev.user.data1));
int nScene = static_cast<int>(reinterpret_cast<uintptr_t>(ev.user.data2));
switch ( nScene ) {
case SCENE_0_Intro:
//
// SCENE::INTRO
//
if ( nState == (int)SceneSplashScreen::STATE::FADE_OUT )
{
if ( !CSingleton<CProperties>::Instance()->Property( "Game", "Quit" ) ) {
LoadAndRunScene( SCENE_1_Game );
SetState( (int)STATE::GAME );
}
}
if ( nState == (int)SceneSplashScreen::STATE::END )
{
if ( CSingleton<CProperties>::Instance()->Property( "Game", "Quit" ) ) {
SetRunning( false );
}
}
break;
default:
break;
}
}
if ( nEventType == DemoEngine::EVENTTYPE::CUSTOM_EVENT ) {
int nEventID = static_cast<int>(reinterpret_cast<uintptr_t>(ev.user.data1));
int nScene = static_cast<int>(reinterpret_cast<uintptr_t>(ev.user.data2));
switch ( nEventID ) {
case (int)EVENT::START_NEW_GAME:
SetSceneState( nScene, (int)SceneSplashScreen::STATE::PRE_FADE_OUT );
LoadAndRunScene( SCENE_1_Game );
SetState( (int)STATE::GAME );
break;
case (int)EVENT::SHOW_HIGHSCORES:
SetSceneState( nScene, (int)SceneSplashScreen::STATE::PRE_FADE_OUT_NOMUSIC );
LoadAndRunScene( SCENE_3_Highscores );
SetState( (int)STATE::HIGHSCORES );
break;
case (int)EVENT::SHOW_HELP:
SetSceneState( nScene, (int)SceneSplashScreen::STATE::PRE_FADE_OUT_NOMUSIC );
LoadAndRunScene( SCENE_4_Help );
SetState( (int)STATE::HELP );
break;
case (int)EVENT::END_GAME:
SetSceneState( nScene, (int)SceneSplashScreen::STATE::PRE_FADE_OUT );
CSingleton<CProperties>::Instance()->Property( "Game", "Quit" ) = (bool)true;
break;
default:
break;
}
}
}
},
{
//
// STATE::HIGHSCORES
//
(int)STATE::HIGHSCORES,
[&](SDL_Event& ev){
int nEventType = ev.user.code;
if ( nEventType == DemoEngine::EVENTTYPE::SCENE_EVENT ) {
int nState = static_cast<int>(reinterpret_cast<uintptr_t>(ev.user.data1));
int nScene = static_cast<int>(reinterpret_cast<uintptr_t>(ev.user.data2));
switch ( nScene )
{
case SCENE_3_Highscores:
//
// SCENE::HELP
//
if ( nState == (int)SceneHighscores::STATE::FADE_OUT )
{
LoadAndRunScene( SCENE_0_Intro );
SetSceneState( SCENE_0_Intro, (int)SceneSplashScreen::STATE::START_NOMUSIC );
SetState( (int)STATE::SPLASH_SCREEN );
}
break;
default:
break;
}
}
}
},
{
//
// STATE::HELP
//
(int)STATE::HELP,
[&](SDL_Event& ev){
int nEventType = ev.user.code;
if ( nEventType == DemoEngine::EVENTTYPE::SCENE_EVENT ) {
int nState = static_cast<int>(reinterpret_cast<uintptr_t>(ev.user.data1));
int nScene = static_cast<int>(reinterpret_cast<uintptr_t>(ev.user.data2));
switch ( nScene )
{
case SCENE_4_Help:
//
// SCENE::HELP
//
if ( nState == (int)SceneHelp::STATE::FADE_OUT )
{
LoadAndRunScene( SCENE_0_Intro );
SetSceneState( SCENE_0_Intro, (int)SceneSplashScreen::STATE::START_NOMUSIC );
SetState( (int)STATE::SPLASH_SCREEN );
}
break;
default:
break;
}
}
}
},
{
//
// STATE::GAME
//
(int)STATE::GAME,
[&](SDL_Event& ev){
int nEventType = ev.user.code;
if ( nEventType == DemoEngine::EVENTTYPE::SCENE_EVENT ) {
int nState = static_cast<int>(reinterpret_cast<uintptr_t>(ev.user.data1));
int nScene = static_cast<int>(reinterpret_cast<uintptr_t>(ev.user.data2));
switch ( nScene )
{
case SCENE_1_Game:
//
// SCENE::GAME
//
if ( nState == (int)SceneLevel::STATE::FADE_OUT )
{
LoadAndRunScene( SCENE_2_GameOver );
SetState( (int)STATE::GAME_OVER );
}
break;
default:
break;
}
}
}
},
{
//
// STATE::GAME_OVER
//
(int)STATE::GAME_OVER,
[&](SDL_Event& ev){
int nEventType = ev.user.code;
if ( nEventType == DemoEngine::EVENTTYPE::SCENE_EVENT ) {
int nState = static_cast<int>(reinterpret_cast<uintptr_t>(ev.user.data1));
int nScene = static_cast<int>(reinterpret_cast<uintptr_t>(ev.user.data2));
switch ( nScene )
{
case SCENE_2_GameOver:
//
// SCENE::GAME_OVER
//
if ( nState == (int)SceneGameOver::STATE::FADE_OUT )
{
#ifdef DEBUG_SCENE1
cout << "Restarting Scene 1 because DEBUG_SCENE1 defined." << endl;
StopScene( SCENE_1_Game );
LoadAndRunScene( SCENE_1_Game );
SetState( (int)STATE::GAME );
#else
LoadAndRunScene( SCENE_0_Intro );
SetState( (int)STATE::SPLASH_SCREEN );
#endif
}
break;
default:
break;
}
}
}
}
};
///////////////////////////////////////////////////
//
// Post Render
//
///////////////////////////////////////////////////
m_Handlers["PostRender"] = {
{
//
// STATE::SPLASH_SCREEN
//
(int)CGame::STATE::ANY_STATE,
[&](SDL_Event& ev){
DISCARD_UNUNSED_PARAMETER( ev );
auto& renderer = CSingleton<CRenderer>::Instance();
int x = m_iScreenW + m_noteImgWidth - ((int)(GetRealTime()*60) % (m_iScreenW + m_noteImgWidth*2));
renderer->Render( TextFactory::Instance()->Get( RESOURCE::TEXT_BETA_BUILD_NOTE ), x, m_iScreenH-12 );
}
}
};
///////////////////////////////////////////////////
//
// OnKeyDown
//
///////////////////////////////////////////////////
m_Handlers["OnKeyDown"] = {
{
//
// STATE::TESTS
//
(int)CGame::STATE::ANY_STATE,
[&](SDL_Event& ev){
switch ( ev.key.keysym.sym ) {
#ifdef DEBUG
case SDLK_1:
cout << "Setting Game speed to 0.1" << endl;
CSingleton<CProperties>::Instance()->Property( "Game", "Speed" ) = (float)0.1f;
break;
case SDLK_2:
cout << "Setting Game speed to 0.3" << endl;
CSingleton<CProperties>::Instance()->Property( "Game", "Speed" ) = (float)0.3f;
break;
case SDLK_3:
cout << "Setting Game speed to 0.5" << endl;
CSingleton<CProperties>::Instance()->Property( "Game", "Speed" ) = (float)0.5f;
break;
case SDLK_4:
cout << "Setting Game speed to 0.7" << endl;
CSingleton<CProperties>::Instance()->Property( "Game", "Speed" ) = (float)0.7f;
break;
case SDLK_5:
cout << "Setting Game speed to 1.0" << endl;
CSingleton<CProperties>::Instance()->Property( "Game", "Speed" ) = (float)1.0f;
break;
case SDLK_6:
cout << "Setting Game speed to 1.3" << endl;
CSingleton<CProperties>::Instance()->Property( "Game", "Speed" ) = (float)1.3f;
break;
case SDLK_7:
cout << "Setting Game speed to 1.5" << endl;
CSingleton<CProperties>::Instance()->Property( "Game", "Speed" ) = (float)1.5f;
break;
case SDLK_8:
cout << "Setting Game speed to 1.7" << endl;
CSingleton<CProperties>::Instance()->Property( "Game", "Speed" ) = (float)1.7f;
break;
#endif
case SDLK_F1:
cout << "Setting FPS to 10" << endl;
SDL_setFramerate( &m_fpsManager, 10 );
break;
case SDLK_F2:
cout << "Setting FPS to 20" << endl;
SDL_setFramerate( &m_fpsManager, 20 );
break;
case SDLK_F3:
cout << "Setting FPS to 30" << endl;
SDL_setFramerate( &m_fpsManager, 30 );
break;
case SDLK_F4:
cout << "Setting FPS to 40" << endl;
SDL_setFramerate( &m_fpsManager, 40 );
break;
case SDLK_F5:
cout << "Setting FPS to 50" << endl;
SDL_setFramerate( &m_fpsManager, 50 );
break;
case SDLK_F6:
cout << "Setting FPS to 60" << endl;
SDL_setFramerate( &m_fpsManager, 60 );
break;
case SDLK_F7:
cout << "Setting FPS to 120" << endl;
SDL_setFramerate( &m_fpsManager, 120 );
break;
default:
break;
}
}
}
};
}
void TimeCounter::Reset()
{
_starttime = GetRealTime();
}
static void
timestatus(const lame_global_flags * const gfp)
{
timestatus_t* real_time = &global_encoder_progress.real_time;
timestatus_t* proc_time = &global_encoder_progress.proc_time;
int percent;
double tmx, delta;
int samp_rate = lame_get_out_samplerate(gfp)
, frameNum = lame_get_frameNum(gfp)
, totalframes = lame_get_totalframes(gfp)
, framesize = lame_get_framesize(gfp)
;
if (totalframes < frameNum) {
totalframes = frameNum;
}
if (global_encoder_progress.time_status_init == 0) {
real_time->last_time = GetRealTime();
proc_time->last_time = GetCPUTime();
real_time->elapsed_time = 0;
proc_time->elapsed_time = 0;
}
/* we need rollover protection for GetCPUTime, and maybe GetRealTime(): */
tmx = GetRealTime();
delta = tmx - real_time->last_time;
if (delta < 0)
delta = 0; /* ignore, clock has rolled over */
real_time->elapsed_time += delta;
real_time->last_time = tmx;
tmx = GetCPUTime();
delta = tmx - proc_time->last_time;
if (delta < 0)
delta = 0; /* ignore, clock has rolled over */
proc_time->elapsed_time += delta;
proc_time->last_time = tmx;
if (global_encoder_progress.time_status_init == 0) {
console_printf("\r"
" Frame | CPU time/estim | REAL time/estim | play/CPU | ETA \n"
" 0/ ( 0%%)| 0:00/ : | 0:00/ : | "
SPEED_CHAR "| : \r"
/* , Console_IO.str_clreoln, Console_IO.str_clreoln */ );
global_encoder_progress.time_status_init = 1;
return;
}
ts_calc_times(real_time, samp_rate, frameNum, totalframes, framesize);
ts_calc_times(proc_time, samp_rate, frameNum, totalframes, framesize);
if (frameNum < totalframes) {
percent = (int) (100. * frameNum / totalframes + 0.5);
}
else {
percent = 100;
}
console_printf("\r%6i/%-6i", frameNum, totalframes);
console_printf(percent < 100 ? " (%2d%%)|" : "(%3.3d%%)|", percent);
ts_time_decompose(proc_time->elapsed_time, '/');
ts_time_decompose(proc_time->estimated_time, '|');
ts_time_decompose(real_time->elapsed_time, '/');
ts_time_decompose(real_time->estimated_time, '|');
console_printf(proc_time->speed_index <= 1. ?
"%9.4f" SPEED_CHAR "|" : "%#9.5g" SPEED_CHAR "|",
SPEED_MULT * proc_time->speed_index);
ts_time_decompose((real_time->estimated_time - real_time->elapsed_time), ' ');
}
* DISCLAIMED. IN NO EVENT SHALL WrightEagle 2D Soccer Simulation Team BE LIABLE *
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL *
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR *
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER *
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, *
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF *
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. *
************************************************************************************/
#include "Utilities.h"
#include "PlayerParam.h"
#include "DynamicDebug.h"
#include <cstring>
timeval RealTime::mStartTime = GetRealTime();
const long RealTime::ONE_MILLION = 1000000;
timeval GetRealTime() {
timeval time_val;
#ifdef WIN32
LARGE_INTEGER frq,count;
QueryPerformanceFrequency(&frq);
QueryPerformanceCounter(&count);
time_val.tv_sec = (count.QuadPart / frq.QuadPart);
time_val.tv_usec = (count.QuadPart % frq.QuadPart) * 1000000 / frq.QuadPart;
#else
gettimeofday(&time_val, 0);
#endif
TimeCounter::TimeCounter()
{
_starttime = GetRealTime();
_pausetime = 0;
_pause = false;
}
void UpdateTime()
{
RECT r;
::GetClientRect(hWnd, &r);
double now = GetRealTime();
if (keyDown[VK_F3]) {
gPaused = !gPaused;
if (gPaused) {
lastPauseTime = now;
}
keyDown[VK_F3] = false;
::InvalidateRect(hWnd, 0, true);
}
if (keyDown[VK_F4]) {
::InvalidateRect(hWnd, 0, true);
gPaused = false;
gStepping = true;
keyDown[VK_F4] = false;
}
if (keyDown[VK_F2]) {
gPointDisplay = !gPointDisplay;
keyDown[VK_F2] = false;
::InvalidateRect(hWnd, 0, true);
}
if (gPaused) {
pauseDelta += (now - lastPauseTime);
lastPauseTime = now;
return;
}
now -= pauseDelta;
ReceivePackets(now);
double dt = now - lastReadTime;
lastReadTime = now;
if (keyDown[VK_RIGHT]) {
dir -= float(dt * turn);
}
if (keyDown[VK_LEFT]) {
dir += float(dt * turn);
}
if (dir < -M_PI) {
dir += 2 * M_PI;
}
if (dir > M_PI) {
dir -= 2 * M_PI;
}
myPos.x += float(cos(dir) * vel * dt);
myPos.y -= float(sin(dir) * vel * dt);
if (myPos.x > r.right) {
myPos.x = (float)r.right;
// bounce
if (fabs(dir) < M_PI / 2) {
if (dir > 0) {
dir = M_PI - dir;
}
else {
dir = -M_PI - dir;
}
}
}
if (myPos.x < 0) {
myPos.x = 0;
if (fabs(dir) > M_PI / 2) {
if (dir > 0) {
dir = M_PI - dir;
}
else {
dir = -M_PI - dir;
}
}
}
if (myPos.y > r.bottom) {
myPos.y = (float)r.bottom;
if (dir < 0) {
dir = -dir;
}
}
if (myPos.y < 0) {
myPos.y = 0;
if (dir > 0) {
dir = -dir;
}
}
recordArray[0] = myPos;
intPos.ReadPosition(now, &extrapolatedPos[0].x);
if (now >= lastRecordedPos + 1.0/STORERATE) {
memmove(&extrapolatedPos[1], &extrapolatedPos[0], sizeof(extrapolatedPos) - sizeof(extrapolatedPos[0]));
memmove(&recordArray[1], &recordArray[0], sizeof(recordArray) - sizeof(recordArray[0]));
lastRecordedPos = now;
if (gStepping) {
gStepping = false;
gPaused = true;
lastPauseTime = GetRealTime();
::InvalidateRect(hWnd, 0, true);
}
}
if (now >= lastSentTime + 1.0/SENDRATE) {
SendPacket(myPos, now);
lastSentTime = now;
}
DrawWindow(hWnd, GetDC(hWnd));
}
unsigned int Timer::GetTime() const {
if (!started)
return 0;
return GetRealTime() + penaltyTime;
}
/*
** NAME
** CalculateBasePerfStats
**
** DESCRIPTION
** This is the main function that calculates the stats. Stats
** that we caculate are:
** *uSecs per Packet
** *Packets per Second
** *Mbits per Second
** *Average bytes per Packet
** *CPU Time
** *Dropped Packets
** These statistics are processed and then stored in the
** SFBASE_STATS structure. This allows output functions to
** be easily formed and inserted.
** NOTE: We can break up these statistics into functions for easier
** reading.
**
** FORMAL INPUTS
** SFBASE * - ptr to performance struct
** SFBASE_STATS * - ptr to struct to fill in performance stats
**
** FORMAL OUTPUTS
** int - 0 is successful
*/
int CalculateBasePerfStats(SFBASE *sfBase, SFBASE_STATS *sfBaseStats)
{
SYSTIMES Systimes;
UINT64 total_bytes = sfBase->total_rebuilt_bytes +
sfBase->total_wire_bytes;
time_t clock;
#ifdef LINUX_SMP
/*
** We also give sfBaseStats access to the CPU usage
** contained in sfProcPidStats. This way we don't need
** to complicate sfBaseStats further.
*/
sfBaseStats->sfProcPidStats = &(sfBase->sfProcPidStats);
#endif
GetProcessingTime(&Systimes, sfBase);
GetRealTime(&Systimes, sfBase);
/*
** Avg. bytes per Packet
*/
sfBaseStats->avg_bytes_per_packet = (int)((double)(total_bytes) /
(double)(sfBase->total_packets));
/*
** CPU time
*/
GetCPUTime(sfBase, sfBaseStats, &Systimes);
/*
** Get Dropped Packets
*/
GetPktDropStats(sfBase, sfBaseStats);
/*
** Total packets
*/
sfBaseStats->total_packets = sfBase->total_packets;
/*
* Pattern Matching Performance in Real and User time
*/
sfBaseStats->patmatch_percent = 100.0 * mpseGetPatByteCount() /
sfBase->total_wire_bytes;
mpseResetByteCount();
if(sfBase->iFlags & MAX_PERF_STATS)
{
/*
** uSeconds per Packet
** user, system, total time
*/
GetuSecondsPerPacket(sfBase, sfBaseStats, &Systimes);
}
/*
** Mbits per sec
** user, system, total time
*/
GetMbitsPerSecond(sfBase, sfBaseStats, &Systimes);
/*
** EventsPerSecond
** We get the information from the global variable
** PacketCount.
*/
GetEventsPerSecond(sfBase, sfBaseStats, &Systimes);
/*
** Packets per seconds
** user, system, total time
*/
GetPacketsPerSecond(sfBase, sfBaseStats, &Systimes);
/*
** Set the date string for print out
*/
time(&clock);
sfBaseStats->time = clock;
sfBaseStats->Date = ctime(&clock);
/*
** Get rid of newline
*/
sfBaseStats->Date[strlen(sfBaseStats->Date) - 1] = 0x00;
return 0;
}
