C ++测量函数调用和回调之间的时间

Question

I am working on an automated test framework for asynchronous applications. One of the aspects to abserve is the applications answering time behavior. And I wonder if and how it would be possible to track the time between a function call, and the call of the corresponding event callback function.

Example:

I am setting the input gain of an audio input device

virtual void setGain(unsigned int gain) = 0; 

This causes the underlaying library to perform some system calls, and the fire an event sooner or later

virtual void onGainChanged(IRtcAudioRecordingDevicePtr device, unsigned int gain) = 0;

The aim is now, to get the current time when setGain is calles, and when onGainChanged is called, to determine the timespan.

This should be done by an external component (eg a RuntimeObserver), as generic as possible.

Do you have any clues on how to design such a module?

Thank you in advance

Answer 1

If everything is on the same platform it boils down to two parts for this system: 1:Time measurement and 2:Generic Implementation(more problematic)

1 Time Measurement:

The concept behind this is to measure the time when setGain and onGainChanged are called. The difference between those two time measurement will be equal to time delay you want to measure.

Here is some basic example using made up types and functions (will explain those later):

TimeValue s = GetNowTime();
setGain(...);

//after some computations:
TimeValue e = GetNowTime();
onGainChanged(...);
TimeDuration d = (e - s);
cout << "Lag:" << d;

On win32 platform TimeValue (and TimeDuration ) can be unsigned int and GetNowTime can be timeGetTime . The result of this will be in miliseconds.

If you are looking for a cross platform solution (in c++98) it would be best to choose a library such as boost::timer or boost::chrono (you should investigate first and check the available solutions first). Ideally, if you switch to c++ 11 you can use std::chrono (here TimeValue is std::chrono::time_point and TimeDuration is std::chrono::duration )

2: Implementation

There are a lot of ways you can implement this in a generic way and i don't think there is one perfect solution. One way i would do it is like this:

//some header
enum Events
{
    kGainEvent  
};

#ifdef USE_EVENT_TRACKING

    class EventTimeHandler
    {
    public:
        using Duration = std::chrono::high_resolution_clock::duration;
        using TimePoint = std::chrono::high_resolution_clock::time_point;

        static EventTimeHandler* Instance;
        EventTimeHandler();

        void TrackStartEvent(Events e);
        void TrackEndEvent(Events e);

    private:
        std::map<Events,TimePoint> m_times;
    };



    inline void TrackStartEvent(Events e)
    {
        EventTimeHandler::Instance->TrackStartEvent(e);
    }
    inline void TrackEndEvent(Events e)
    {
        EventTimeHandler::Instance->TrackEndEvent(e);
    }

#else

    inline void TrackStartEvent(Events e){}//empty implementaiton
    inline void TrackEndEvent(Events e){}//empty implementaiton

#endif

//cpp file:
EventTimeHandler::EventTimeHandler()
{
    Instance = this;
}
void EventTimeHandler::TrackStartEvent(Events e)
{
    m_times[e] = std::chrono::high_resolution_clock::now();
}
void EventTimeHandler::TrackEndEvent(Events e)
{
    TimePoint now_time = std::chrono::high_resolution_clock::now();
    Duration d = now_time - m_times[e];//should check here if m_times has key e for safety ?

    //print time in milseconds as double
    std::cout << std::chrono::duration_cast<std::chrono::milliseconds<double>>(d).count();
}

Usage:

TrackStartEvent(kGainEvent);
setGain(...);

//after some computations:
TrackEndEvent(kGainEvent);
onGainChanged(...);

//code will do nothing if USE_EVENT_TRACKING is not defined. This will allow to turn the system on and off

I wrote the code out of my head , i hope i did not miss any errors.