CTimer Class Reference

#include <timer.h>

Data Structures
struct	TimerEntry
Public Types
typedef void(*	callback_t )(void *callbackparm)
Public Member Functions
void	Handler (void)
	CTimer ()
	~CTimer ()
int	Initialize (const int nTimers)
int	Stop ()
int	GetTimer (callback_t callback)
int	FreeTimer (const int TimerId)
int	StartTimer (const int TimerId, struct timeval Interval, TimerType Type, void *Param)
int	StopTimer (const int TimerId)
struct timeval	CurrentTime ()
Private Types
enum	TimerStatus { TimerStatusFree = 0, TimerStatusInactive = 1, TimerStatusActive = 2 }
Private Member Functions
void	TimerThread ()
void	InitTimerSignalAction (void)
void	ProgramTimer (struct timeval Time)
void	Remove (int TimerId)
void	Insert (int TimerId)
void	ProcessExpiredTimers ()
void	ReprogramTimer ()
Static Private Member Functions
static void *	Thread (void *param)
Private Attributes
TimerEntry *	m_Table
int	m_Free
int	m_First
int	m_nTimers
struct timeval	m_StartTime
bool	m_Initialized
bool	m_StopThread
CvsiMutex	m_Mutex
CvsiThread	m_Thread

---

Detailed Description

Definition at line 40 of file timer.h.

---

Member Typedef Documentation

typedef void(* CTimer::callback_t)(void *callbackparm)

Definition at line 43 of file timer.h.

---

Member Enumeration Documentation

enum CTimer::TimerStatus [private]

Enumerator:

TimerStatusFree
TimerStatusInactive
TimerStatusActive

Definition at line 46 of file timer.h.

        {
            TimerStatusFree     = 0,
            TimerStatusInactive = 1,
            TimerStatusActive   = 2
        } TimerStatus;

---

Constructor & Destructor Documentation

CTimer::CTimer

(

)

Definition at line 62 of file timer.cpp.

{
    m_Table   = NULL;
    m_Free    = -1;
    m_First   = -1;
    m_nTimers = 0;

    m_StartTime.tv_sec = 0;
    m_StartTime.tv_usec = 0;

    m_Initialized = false;
    m_StopThread  = false;
    // m_Mutex  does not need to be initialized
    // m_Thread does not need to be initialized
}

CTimer::~CTimer

(

)

Definition at line 78 of file timer.cpp.

{
    if( m_Table != 0 )
    {
        delete[] m_Table;
        m_Table = 0;
    }
}

---

Member Function Documentation

struct timeval CTimer::CurrentTime

(

)

[read]

Definition at line 463 of file timer.cpp.

{
    struct timeval val, current_time;

    gettimeofday( &val, 0 );

    current_time.tv_sec  = val.tv_sec - m_StartTime.tv_sec;
    current_time.tv_usec = val.tv_usec - m_StartTime.tv_usec;
    if( current_time.tv_usec < 0 )
    {
        current_time.tv_sec -= 1;
        current_time.tv_usec += 1000000;
    }

    return ( current_time );
}

int CTimer::FreeTimer

(

const int

TimerId

)

Definition at line 236 of file timer.cpp.

{

    // Get exclusive access to timer control structures
    m_Mutex.Wait();

    // Check if initialized
    if( !m_Initialized )
    {
        m_Mutex.Release();
        return ERROR5;
    }

    // Check if Timer Id is valid
    if( ( TimerId < 0 ) || ( TimerId >= m_nTimers ) )
    {
        m_Mutex.Release();
        return ERROR7;
    }

    // Check if the Timer is not already free
    if( m_Table[TimerId].Status == TimerStatusFree )
    {
        m_Mutex.Release();
        return ERROR8;
    }

    // Remove timer from list of active timers if needed
    if( m_Table[TimerId].Status == TimerStatusActive )
    {
        Remove( TimerId );
    }

    // update timer status
    m_Table[TimerId].Status = TimerStatusFree;

    // Include timer on free list
    m_Table[TimerId].Previous = -1;
    m_Table[TimerId].Next = m_Free;
    if( m_Free >= 0 )
    {
        m_Table[m_Free].Previous = TimerId;
    }
    m_Free = TimerId;

    // release access to timer control structures
    m_Mutex.Release();

    return 0;
}

int CTimer::GetTimer

(

callback_t

callback

)

Definition at line 197 of file timer.cpp.

{
    int Id;

    // Get exclusive access to timer control structures
    m_Mutex.Wait();

    // Check if initialized
    if( !m_Initialized )
    {
        m_Mutex.Release();
        return ERROR5;
    }

    if( m_Free == -1 )
    {
        m_Mutex.Release();
        return ERROR6;
    }

    Id = m_Free;

    m_Free = m_Table[Id].Next;

    if( m_Free >= 0 )
    {
        m_Table[m_Free].Previous = -1;
    }

    m_Table[Id].Status = TimerStatusInactive;
    m_Table[Id].Callback = callback;

    // release access to timer control structures
    m_Mutex.Release();

    return Id;
}

void CTimer::Handler

(

void

)

int CTimer::Initialize

(

const int

nTimers

)

Definition at line 88 of file timer.cpp.

{

    // Check if parameter is valid
    if( nTimers < 1 )
        return (ERROR3);

    // Check if mutex was opened successfully
    if( !m_Mutex.IsOpen() )
        return (ERROR1);

    // Check if semaphore was opened successfully
    if( !m_Mutex.IsOpen() )
        return (ERROR9);

    // Get exclusive access to timer control structures
    m_Mutex.Wait();

    if( m_First >= 0 )
    {
        m_Mutex.Release();
        return (ERROR2);
    }

    if( m_Thread.IsActive() )
    {
        m_StopThread = true;
        Semaphore.V();
        m_Mutex.Release();
        m_Thread.Join(0);
        m_Mutex.Wait();
    }

    if( m_Table != 0 )
    {
        delete[] m_Table;
        m_Table = 0;
    }

    m_nTimers = nTimers;
    m_Table = new TimerEntry[nTimers];

    for( int i = 0; i < nTimers; i++ )
    {
        m_Table[i].Next = i+1;
        m_Table[i].Previous = i-1;
        m_Table[i].Status = TimerStatusFree;
    }

    m_Table[nTimers-1].Next = -1;
    m_Free = 0;

    int result = 0;
    if( m_Thread.Create( Thread, (void*)this ) < 0 )
        result = ERROR4;

    // Initialize zero reference time
    gettimeofday( &m_StartTime, 0 );

    m_Initialized = true;

    // release access to timer control structures
    m_Mutex.Release();

    return result;
}

void CTimer::InitTimerSignalAction

(

void

)

[private]

Definition at line 481 of file timer.cpp.

{
    struct sigaction action;
    action.sa_handler   = TimerSignalHandler;
    action.sa_flags     = SA_RESTART;
    sigemptyset( &action.sa_mask );
    sigaction( SIGALRM, &action, NULL );
}

void CTimer::Insert

(

int

TimerId

)

[private]

Definition at line 420 of file timer.cpp.

{
    int Next = m_First;
    int Previous = -1;

    struct timeval Time = m_Table[TimerId].Time;

    // Find right place to insert new Timer. Timers are ordered in
    // decreasing order of time; i.e. the first in the list will
    // be the first to expire
    while( Next >= 0 )
    {
        if( ( m_Table[Next].Time.tv_sec > Time.tv_sec ) ||
           (( m_Table[Next].Time.tv_sec == Time.tv_sec ) &&
            ( m_Table[Next].Time.tv_usec > Time.tv_usec )))
            break;
        Previous = Next;
        Next = m_Table[Next].Next;
    }

    // Update new timer links
    m_Table[TimerId].Next     = Next;
    m_Table[TimerId].Previous = Previous;

    // Update previous and next timers links
    if( Previous >= 0 )
    {
        m_Table[Previous].Next = TimerId;
    }
    else
    {
        m_First = TimerId;
    }
    if( Next >= 0 )
    {
        m_Table[Next].Previous = TimerId;
    }

    m_Table[TimerId].Status = TimerStatusActive;
    return;
}

void CTimer::ProcessExpiredTimers

(

)

[private]

Definition at line 571 of file timer.cpp.

{
    int Current = m_First;
    int Next;

    struct timeval current_time, time;

    Current = m_First;
    while( Current >= 0 )
    {
        Next = m_Table[Current].Next;

        time.tv_sec  = m_Table[Current].Time.tv_sec;
        time.tv_usec = m_Table[Current].Time.tv_usec;

        time.tv_usec -= TIMER_PRECISION;
        if( time.tv_usec < 0 )
        {
            time.tv_sec  -= 1;
            time.tv_usec += 1000000;
        }

        current_time = CurrentTime();

        if( ( current_time.tv_sec > time.tv_sec) ||
            (( current_time.tv_sec == time.tv_sec ) &&
             ( current_time.tv_usec > time.tv_usec )))
        {
            Remove( Current );
            // Release mutex while excuting caller's callback function
            m_Mutex.Release();
            (m_Table[Current].Callback)(m_Table[Current].Param);
            m_Mutex.Wait();
            if( m_Table[Current].Type == TimerTypePeriodic )
            {
                m_Table[Current].Time.tv_sec  += m_Table[Current].Interval.tv_sec;
                m_Table[Current].Time.tv_usec += m_Table[Current].Interval.tv_usec;
                if( m_Table[Current].Time.tv_usec > 1000000 )
                {
                    m_Table[Current].Time.tv_sec += 1;
                    m_Table[Current].Time.tv_usec -= 1000000;
                }
                Insert( Current );
            }
        }
        else
        {
            return;
        }
        Current = Next;
    }
}

void CTimer::ProgramTimer

(

struct timeval

Time

)

[private]

Definition at line 491 of file timer.cpp.

{
    struct itimerval TimerValue;
    struct timeval current_time, timer;

    TimerValue.it_interval.tv_sec   = 0;
    TimerValue.it_interval.tv_usec  = 0;

    current_time = CurrentTime();

    timer.tv_sec  = Time.tv_sec  - current_time.tv_sec;
    timer.tv_usec = Time.tv_usec - current_time.tv_usec;
    if( timer.tv_usec < 0 )
    {
        timer.tv_sec -= 1;
        timer.tv_usec += 1000000;
    }

    if( ( timer.tv_sec < 0 ) || (( timer.tv_sec == 0 )&&( timer.tv_usec <= 0 )) )
    {
        timer.tv_sec  = 0;
        timer.tv_usec = 1;
    }

    if( ( timer.tv_sec == 0 ) && ( timer.tv_usec < 1000000 ) )
    {
        TimerValue.it_value.tv_sec = 0;
        TimerValue.it_value.tv_usec = timer.tv_usec;
    }
    else
    {
        TimerValue.it_value.tv_sec  = timer.tv_sec;
        TimerValue.it_value.tv_usec = timer.tv_usec;

    }
    setitimer( ITIMER_REAL, &TimerValue, NULL );
}

void CTimer::Remove

(

int

TimerId

)

[private]

Definition at line 394 of file timer.cpp.

{
    int Next = m_Table[TimerId].Next;
    int Previous = m_Table[TimerId].Previous;

    if( Next >= 0 )
    {
        m_Table[Next].Previous = Previous;
    }

    if( Previous >= 0 )
    {
        m_Table[Previous].Next = Next;
    }
    else
    {
        m_First = Next;
    }

    m_Table[TimerId].Status = TimerStatusInactive;
    return;
}

void CTimer::ReprogramTimer

(

)

[private]

Definition at line 625 of file timer.cpp.

{
    if( m_First >= 0 )
        ProgramTimer( m_Table[m_First].Time );
}

int CTimer::StartTimer	(	const int	TimerId,
		struct timeval	Interval,
		TimerType	Type,
		void *	Param
	)

Definition at line 288 of file timer.cpp.

{
    // Get exclusive access to timer control structures
    m_Mutex.Wait();

    // Check if initialized
    if( !m_Initialized )
    {
        m_Mutex.Release();
        return ERROR5;
    }

    // Check if Timer Id is valid
    if( ( TimerId < 0 ) || ( TimerId >= m_nTimers ) )
    {
        m_Mutex.Release();
        return ERROR7;
    }

    // Check if the Timer is not free
    if( m_Table[TimerId].Status == TimerStatusFree )
    {
        m_Mutex.Release();
        return ERROR8;
    }

    // Remove timer from list of active timers if needed
    if( m_Table[TimerId].Status == TimerStatusActive )
    {
        Remove(TimerId);
    }

    // Update timer entry
    m_Table[TimerId].Interval = Interval;
    m_Table[TimerId].Type = Type;

    struct timeval initial_time, current_time;
    current_time = CurrentTime();
    initial_time.tv_sec  = current_time.tv_sec  + Interval.tv_sec;
    initial_time.tv_usec = current_time.tv_usec + Interval.tv_usec;
    if( initial_time.tv_usec > 1000000 )
    {
        initial_time.tv_sec  += 1;
        initial_time.tv_usec -= 1000000;
    }
    m_Table[TimerId].Time = initial_time;
    // ------------------------------------------------------------------------

    m_Table[TimerId].Param = Param;

    Insert( TimerId );

    // If new timer is the first to expire may have to change
    // Unix Timer programming. Signal timer process to
    // reprogram    UNIX timer to right value
    if( m_First == TimerId )
    {
        ReprogramTimer();
    }
    // release access to timer control structures
    m_Mutex.Release();
    return 0;
}

int CTimer::Stop

(

void

)

Definition at line 156 of file timer.cpp.

{
    // Get exclusive access to timer control structures
    m_Mutex.Wait();

    // Check if initialized
    if( !m_Initialized )
    {
        m_Mutex.Release();
        return ERROR5;
    }

    // Abort thread
    m_StopThread = true;
    Semaphore.V();
    m_Mutex.Release();
    m_Thread.Join(0);

    // Clean Table
    m_Mutex.Wait();
    if( m_Table != 0 )
    {
        delete[] m_Table;
        m_Table = 0;
    }

    // Reset member variables
    m_Free = -1;
    m_First = -1;
    m_nTimers = 0;
    m_Initialized = false;
    m_StopThread = false;

    // release access to timer control structures
    m_Mutex.Release();

    return 0;

}

int CTimer::StopTimer

(

const int

TimerId

)

Definition at line 354 of file timer.cpp.

{
    // Get exclusive access to timer control structures
    m_Mutex.Wait();

    // Check if initialized
    if( !m_Initialized )
    {
        m_Mutex.Release();
        return ERROR5;
    }

    // Check if Timer Id is valid
    if( ( TimerId < 0 ) || ( TimerId >= m_nTimers ) )
    {
        m_Mutex.Release();
        return ERROR7;
    }

    // Check if the Timer is not free
    if( m_Table[TimerId].Status == TimerStatusFree )
    {
        m_Mutex.Release();
        return ERROR8;
    }

    // Remove timer from list of active timers if in fact active
    if( m_Table[TimerId].Status == TimerStatusActive )
    {
        Remove( TimerId );
    }

    // release access to timer control structures
    m_Mutex.Release();

    return 0;
}

void * CTimer::Thread

(

void *

param

)

[static, private]

Definition at line 531 of file timer.cpp.

{
    CTimer* Timer= (CTimer*) param;
    Timer->TimerThread();
    return 0;
}

void CTimer::TimerThread

(

)

[private]

Definition at line 539 of file timer.cpp.

{

    RioErr << "TIMERTHREADID " << syscall( SYS_gettid ) << endl;

    InitTimerSignalAction();
    while( 1 )
    {
        // Check if thread should exit
        if( m_StopThread )
        {
            return;
        }

        // Wait for Unix Timer to expire
        Semaphore.P();
        // Check if thread should exit
        if( m_StopThread )
        {
            return;
        }

        m_Mutex.Wait();

        ProcessExpiredTimers();
        ReprogramTimer();

        m_Mutex.Release();
    }
}

---

Field Documentation

int CTimer::m_First [private]

Definition at line 66 of file timer.h.

int CTimer::m_Free [private]

Definition at line 65 of file timer.h.

bool CTimer::m_Initialized [private]

Definition at line 71 of file timer.h.

CvsiMutex CTimer::m_Mutex [private]

Definition at line 74 of file timer.h.

int CTimer::m_nTimers [private]

Definition at line 67 of file timer.h.

struct timeval CTimer::m_StartTime [private]

Definition at line 69 of file timer.h.

bool CTimer::m_StopThread [private]

Definition at line 72 of file timer.h.

TimerEntry* CTimer::m_Table [private]

Definition at line 64 of file timer.h.

CvsiThread CTimer::m_Thread [private]

Definition at line 75 of file timer.h.

---

The documentation for this class was generated from the following files:

• timer.h
• timer.cpp