Changeset 2424


Ignore:
Timestamp:
Feb 17, 2013, 4:46:35 PM (6 years ago)
Author:
sam
Message:

base: refactor the Timer class to make it more understandable.

Location:
trunk/src
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/lol/sys/timer.h

    r2257 r2424  
    3434private:
    3535    TimerData *data;
     36
     37    /* Copying timers is forbidden for now. */
     38    Timer(Timer const &t);
     39    Timer operator =(Timer const &t);
    3640};
    3741
  • trunk/src/sys/timer.cpp

    r2301 r2424  
    5353    TimerData()
    5454    {
    55 #if defined __linux__ || defined __native_client__ || defined __APPLE__
    56         gettimeofday(&tv0, NULL);
    57 #elif defined _WIN32
    58         QueryPerformanceCounter(&cycles0);
    59 #elif defined __CELLOS_LV2__
    60         SYS_TIMEBASE_GET(cycles0);
    61 #else
    62         SDL_Init(SDL_INIT_TIMER);
    63         ticks0 = SDL_GetTicks();
    64 #endif
     55        (void)GetSeconds(true);
    6556    }
    6657
    67     float GetOrWait(float seconds, bool update)
     58#if defined __linux__ || defined __native_client__ || defined __APPLE__
     59    float GetSeconds(bool reset)
    6860    {
    69         float secs_elapsed, secs_towait;
    70 #if defined __linux__ || defined __native_client__ || defined __APPLE__
    71         struct timeval tv;
     61        struct timeval tv, tv0 = m_tv;
    7262        gettimeofday(&tv, NULL);
    73         secs_elapsed = 1e-6f * (tv.tv_usec - tv0.tv_usec)
    74                      + (tv.tv_sec - tv0.tv_sec);
    75         if (update)
    76             tv0 = tv;
    77         secs_towait = seconds - secs_elapsed;
    78         if (secs_towait > 0.0f)
    79             usleep((int)(secs_towait * 1e6f));
     63        if (reset)
     64            m_tv = tv;
     65        return 1e-6f * (tv.tv_usec - tv0.tv_usec) + (tv.tv_sec - tv0.tv_sec);
     66    }
     67
     68    static float WaitSeconds(float seconds)
     69    {
     70        if (seconds > 0.0f)
     71            usleep((int)(seconds * 1e6f));
     72    }
     73
     74    struct timeval m_tv;
     75
    8076#elif defined _WIN32
    81         LARGE_INTEGER cycles;
     77    float GetSeconds(bool reset)
     78    {
     79        static float secs_per_cycle = GetSecondsPerCycle();
     80        LARGE_INTEGER cycles, cycles0 = m_cycles;
    8281        QueryPerformanceCounter(&cycles);
    83         static float secs_per_cycle = GetSecondsPerCycle();
    84         secs_elapsed = secs_per_cycle * (cycles.QuadPart - cycles0.QuadPart);
    85         if (update)
    86             cycles0 = cycles;
    87         secs_towait = seconds - secs_elapsed;
    88         if (secs_towait > 5e-4f)
    89             Sleep((int)(secs_towait * 1e3f + 0.5f));
    90 #elif defined __CELLOS_LV2__
    91         uint64_t cycles;
    92         SYS_TIMEBASE_GET(cycles);
    93         static float secs_per_cycle = GetSecondsPerCycle();
    94         secs_elapsed = secs_per_cycle * (cycles - cycles0);
    95         if (update)
    96             cycles0 = cycles;
    97         secs_towait = seconds - secs_elapsed;
    98         if (secs_towait > 0.0f)
    99             sys_timer_usleep((int)(secs_towait * 1e6f));
    100 #else
    101         /* The crappy SDL fallback */
    102         Uint32 ticks = SDL_GetTicks();
    103         secs_elapsed = 1e-3f * (ticks - ticks0);
    104         if (update)
    105             ticks0 = ticks;
    106         secs_towait = seconds - secs_elapsed;
    107         if (secs_towait > 5e-4f)
    108             SDL_Delay((int)(secs_towait * 1e3f + 0.5f));
    109 #endif
    110         return secs_elapsed;
     82        if (reset)
     83            m_cycles = cycles;
     84        return secs_per_cycle * (cycles.QuadPart - cycles0.QuadPart);
     85    }
     86
     87    static float WaitSeconds(float seconds)
     88    {
     89        if (seconds > 5e-4f)
     90            Sleep((int)(seconds * 1e3f + 0.5f));
    11191    }
    11292
    11393    static float GetSecondsPerCycle()
    11494    {
    115 #if defined __linux__ || defined __native_client__ || defined __APPLE__
    116         return 1e-3f;
    117 #elif defined _WIN32
    118         LARGE_INTEGER tmp;
     95        LARGE_INTEGER tmp
    11996        QueryPerformanceFrequency(&tmp);
    12097        return 1.f / tmp.QuadPart;
    121 #elif defined __CELLOS_LV2__
    122         return 1.f / sys_time_get_timebase_frequency();
    123 #else
    124         return 1e-3f;
    125 #endif
    12698    }
    12799
    128 #if defined __linux__ || defined __native_client__ || defined __APPLE__
    129     struct timeval tv0;
    130 #elif defined _WIN32
    131     LARGE_INTEGER cycles0;
     100    LARGE_INTEGER m_cycles;
     101
    132102#elif defined __CELLOS_LV2__
    133     uint64_t cycles0;
     103    float GetSeconds(bool reset)
     104    {
     105        static float secs_per_cycle = GetSecondsPerCycle();
     106        uint64_t cycles, cycles0 = m_cycles;
     107        SYS_TIMEBASE_GET(cycles);
     108        if (reset)
     109            m_cycles = cycles;
     110        return secs_per_cycle * (cycles - cycles0);
     111    }
     112
     113    static float WaitSeconds(float seconds)
     114    {
     115        if (seconds > 0.0f)
     116            sys_timer_usleep((int)(seconds * 1e6f));
     117    }
     118
     119    static float GetSecondsPerCycle()
     120    {
     121        return 1.f / sys_time_get_timebase_frequency();
     122    }
     123
     124    uint64_t m_cycles;
     125
    134126#else
    135     Uint32 ticks0;
     127    float GetSeconds(bool reset)
     128    {
     129        static bool initialised = Init();
     130
     131        /* The crappy SDL fallback */
     132        Uint32 ticks = SDL_GetTicks(), ticks0 = m_ticks;
     133        if (reset)
     134            m_ticks = ticks;
     135        return 1e-3f * (ticks - ticks0);
     136    }
     137
     138    static float WaitSeconds(float seconds)
     139    {
     140        if (seconds > 5e-4f)
     141            SDL_Delay((int)(seconds * 1e3f + 0.5f));
     142    }
     143
     144    static bool Init()
     145    {
     146        SDL_Init(SDL_INIT_TIMER);
     147        return true;
     148    }
     149
     150    Uint32 m_ticks;
    136151#endif
    137152};
     
    153168float Timer::Get()
    154169{
    155     return data->GetOrWait(0.0f, true);
     170    return data->GetSeconds(true);
    156171}
    157172
    158173float Timer::Poll()
    159174{
    160     return data->GetOrWait(0.0f, false);
     175    return data->GetSeconds(false);
    161176}
    162177
    163178void Timer::Wait(float seconds)
    164179{
    165     (void)data->GetOrWait(seconds, false);
     180    float secs_elapsed = data->GetSeconds(false);
     181    data->WaitSeconds(seconds - secs_elapsed);
    166182}
    167183
Note: See TracChangeset for help on using the changeset viewer.