Question

我们正在测量多线程实时应用程序的性能规模。我需要编写一个适配器来测量花在

上的时间

锁定互斥锁的等待时间
mutex.lock之间花费的时间 - ＆gt; mutex.unlock：临界区执行时间

以及locktimer或看门狗定时器等组件。如果持有互斥锁的线程超过配置的时间..必须通知错误日志..

这样做最好的方法..？

Answer 1

在调用互斥锁之前和获取互斥锁之后，您可以花些时间（使用标准ctime）。这两者之间的差异将为您提供线程等待获取互斥锁的大致时间可以对过程2进行类似的过程以找到关键部分执行时间。

Answer 2

也许RAII成语会帮助你。例如：

class MutexHolder
{
public:
    MutexHolder()
    {
        //here you should take start time
        m_mutex.lock();
        //here you should take time and find a differnce between start time 
    }
    ~MutexHolder()
    {
        m_mutex.unlock();
        //here you should track the time spent between mutex.lock -> mutex.unlock and do smth else
    }
private:
    Mutex m_mutex;
};

然后使用课程：

//your code

{//start of critical section
    MutexHolder lock;

    //code guarded by mutex locking

}//here the destructor of the MutexHolder object will call automatically

Answer 3

您可以轻松使用某种统计计数器。首先定义你需要多少个计数器......比如10

int timecounters[10];

然后使用你拥有的任何计时器......更精细的粒度和更低的开销当然是最好的...例如clock（）/ GetTickCount（）/ QueryPerformanceCounter / rdtsc。最后使用类似下面的秒表类

struct StopWatch
{
    int n;
    StopWatch(int n) : n(n) { timecounters[n] -= timer(); }
    ~StopWatch() { timecounters[n] += timer(); }
};

然后对于您需要跟踪写入的每个代码段

{
    StopWatch sw(1);
    // code to be instrumented
}

在程序执行结束时，您将拥有在各种仪表部分中花费的总时间，并且开销应该非常低。在单个执行时间上添加限制检查也很容易......例如：

struct WatchDog
{
    int n, limit, start;

    WatchDog(int n, int limit) : n(n), limit(limit)
    {
        start = timer();
    }

    ~WatchDog()
    {
        int delta = timer() - start;
        if (delta > limit)
        {
            log("WatchDog(%i): Time limit exceeded (%i > %i)",
                n, delta, limit);
        }
        timecounters[n] += delta;
    }
};

当然WatchDog类永远不会中断活动，如果它需要的时间超过它应该...它只会在活动结束时报告问题。一个真正中断的通用监视程序类实现起来要复杂得多。

互斥锁等待时间和看门狗

3 个答案: