---

Timer.cpp

Go to the documentation of this file.

/*
 * Timer.cpp
 *
 * Copyright 2003, MobileSpear Inc. (www.mobilespear.com). All rights reserved.
 * Copyright 2003, David Resnick. All rights reserved.
 *
 * See the file doc\license.txt for the terms of usage and distribution.
 */

#include <bogotel/portability.h>
#include <bogotel/Timer.h>
#include <bogotel/Util.h>
#include <bogotel/DevBase.h>
#include <bogotel/TimerTarget.h>

#include <boost/thread/xtime.hpp>

#include <log4cpp/NDC.hh>

// CTimer

namespace bogotel {

    CTimer::CTimer(int period) :
    m_period(period),
    m_bStop(false)
    {
        m_pThrd = new boost::thread(thread_adapter(&CTimer::do_thread, this));
    }

    CTimer::~CTimer()
    {
        m_bStop = true;
        m_condStop.notify_one();
        m_pThrd->join();
        delete m_pThrd;
    }

    void CTimer::do_thread(void* param)
    {
        log4cpp::NDC::push("CTimer");
        try {
            static_cast<CTimer*>(param)->run();
        } catch (std::exception& e) {
            g_util->log(1, -1, "CTimer::do_thread: Exception %s", e.what());
        } catch (char *p) {
            g_util->log(1, -1, "CTimer::do_thread: Exception %s", p);
        } catch (...) {
            g_util->log(1, -1, "CTimer::do_thread: Exception");
        }
    }
 
    void CTimer::run()
    {
        boost::xtime xt;
        boost::mutex::scoped_lock lock(m_mtxStop);

        do {
            handleDefunctTargets();
            checkForExpirations();
            boost::xtime_get(&xt, boost::TIME_UTC);
            xt.nsec += m_period * 1000000;
        } while (! m_condStop.timed_wait(lock, xt, cond_predicate(m_bStop, true)));
    }

    void CTimer::checkForExpirations()
    {
        char method[] = "CTimer::checkForExpirations";

        boost::mutex::scoped_lock lock(m_mtxTimerInfoList);
        LST_TIMER::iterator i = m_lstTimer.begin();
    
        while (i != m_lstTimer.end()) {
            assert(m_lstTimer.begin() != m_lstTimer.end());

            timer_info* pTimerInfo = (*i);
        
            if (pTimerInfo->m_count < 0) {

                // Check if the timer target is still active.
                // This is done only when its timer expires because
                // doing it (searching the set of active targets) every time 
                // for each timer is potentially much more expensive in time.
                if (targetIsActive(pTimerInfo->m_lTargetId)) {
                    g_util->log(9, -1, "%s: Expired timer. target %s", method, 
                        pTimerInfo->m_pTarget->toString().c_str());
                    if (pTimerInfo->m_lTargetId != pTimerInfo->m_pTarget->getId()) {
                        g_util->log(3, -1, "%s: Timer doesn't match target. timer has id:%d, "
                            "target id:%d", method, pTimerInfo->m_lTargetId,
                            pTimerInfo->m_pTarget->getId());
                    }
                    pTimerInfo->m_pTarget->timerExpired(pTimerInfo->m_iTimerType, 
                        pTimerInfo->m_iTargetStateId);
                }

                i = m_lstTimer.erase(i);
                g_util->log(9, -1, "%s: Deleting timer_info %s", method, 
                    pTimerInfo->toString().c_str());
                delete pTimerInfo;

            } else {
                pTimerInfo->m_count--;
                i++;
            }        
        }
    }

    bool CTimer::targetIsActive(long lTimerId)
    {
        boost::mutex::scoped_lock lock2(m_mtxActiveTimerSet);
        return m_setActive.find(lTimerId) != m_setActive.end();
    }

    void CTimer::handleDefunctTargets()
    {
        char method[] = "CTimer::handleDefunctTargets";
        boost::mutex::scoped_lock lock1(m_mtxDefunctVec);
        boost::mutex::scoped_lock lock2(m_mtxActiveTimerSet);

        for (VEC_TIMERTARGET::reverse_iterator iter = m_vecDefunct.rbegin();
             iter != m_vecDefunct.rend();
             iter++) {

            CTimerTarget* pTarget = (*iter);

            g_util->log(9, -1, "%s: Removing target %s", method, 
                pTarget->toString().c_str());

            // remove from active list
            if (m_setActive.erase(pTarget->getId()) == 0) {
                g_util->log(3, -1, "%s: target didn't exist in active list.", method);
            }
            // destroy timer target
            delete pTarget;
        }
        m_vecDefunct.clear();
    }

    /*
     *  Create a timer_info structure for ADlgcDev (d).
     *  Set timer_info.Count to d.m_delay / Period.
     *  
     *  Add the timer_info structure to the ordered TimerList.
     */
    void CTimer::add(long lDelay, CTimerTarget *pTarget, int timerType, int stateId) {

        char method[] = "CTimer::add";

        timer_info* pTimerInfo;

        int numPeriods = lDelay / m_period;

        assert(numPeriods > 0);

        pTimerInfo = new timer_info(numPeriods, pTarget, timerType, stateId);
    
        g_util->log(9, -1, "%s: timer_info %s", method, pTimerInfo->toString().c_str());

        if (pTimerInfo->m_pTarget != NULL) {
            boost::mutex::scoped_lock lock(m_mtxTimerInfoList);

            m_lstTimer.push_back(pTimerInfo);
            m_lstTimer.sort();
        }
    }

    int CTimer::registerTarget(CTimerTarget *pTarget)
    {
        char method[] = "CTimer::registerTarget";
        g_util->log(9, -1, "%s: target %s", method, pTarget->toString().c_str());

        std::pair<SET_LONG::const_iterator,bool> rv;
        {
            boost::mutex::scoped_lock lock(m_mtxActiveTimerSet);
            rv = m_setActive.insert(pTarget->getId());
        }
        if (! rv.second) {
            g_util->log(3, -1, "%s: already registered. Target: %s", method, pTarget->toString().c_str());
            return resultFUNC_BAD_PARAMETER;
        }
        return resultSUCCESS;
    }

    void CTimer::requestTargetDeletion(CTimerTarget *pTarget)
    {
        char method[] = "CTimer::requestTargetDeletion";
        g_util->log(9, -1, "%s: target: %s", method, pTarget->toString().c_str());
        boost::mutex::scoped_lock lock(m_mtxDefunctVec);
        m_vecDefunct.push_back(pTarget);
    }

    // timer_info

    timer_info::timer_info(int count, CTimerTarget* pTarget, int timerType, int targetStateId) :
    m_pTarget(pTarget),
    m_count(count),
    m_iTimerType(timerType),
    m_iTargetStateId(targetStateId),
    m_lTargetId(pTarget->getId())
    {}

    std::string timer_info::toString()
    {
        std::ostringstream str;
        str << "target id:" << m_lTargetId;
        return str.str();
    }

}

---