mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-11-25 22:01:30 +00:00
0538cd57e2
We're changing the counters behavior since they are not notifications anymore. In the new behavior they don't get reset when they are retrieved, so we can have several consumers via the promise. If the values overflow, we let the wrapping occur (unsigned values). MozReview-Commit-ID: 1adkszScYo4 --HG-- extra : rebase_source : cd554ad4cfa643b09f75bb07e38b5d35e08cf470
128 lines
3.7 KiB
C++
128 lines
3.7 KiB
C++
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
|
|
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
#ifndef mozilla_PerformanceCounter_h
|
|
#define mozilla_PerformanceCounter_h
|
|
|
|
namespace mozilla {
|
|
|
|
|
|
/*
|
|
* The DispatchCategory class is used to fake the inheritance
|
|
* of the TaskCategory enum so we can extend it to hold
|
|
* one more value corresponding to the category
|
|
* we use when a worker dispatches a call.
|
|
*
|
|
*/
|
|
class DispatchCategory final
|
|
{
|
|
public:
|
|
explicit DispatchCategory(uint32_t aValue)
|
|
: mValue(aValue)
|
|
{
|
|
// Since DispatchCategory is adding one single value to the
|
|
// TaskCategory enum, we can check here that the value is
|
|
// the next index e.g. TaskCategory::Count
|
|
MOZ_ASSERT(aValue == (uint32_t)TaskCategory::Count);
|
|
}
|
|
|
|
constexpr explicit DispatchCategory(TaskCategory aValue)
|
|
: mValue((uint32_t)aValue)
|
|
{}
|
|
|
|
uint32_t
|
|
GetValue() const
|
|
{
|
|
return mValue;
|
|
}
|
|
|
|
static const DispatchCategory Worker;
|
|
private:
|
|
uint32_t mValue;
|
|
};
|
|
|
|
typedef Array<Atomic<uint32_t>, (uint32_t)TaskCategory::Count + 1> DispatchCounter;
|
|
|
|
// PerformanceCounter is a class that can be used to keep track of
|
|
// runnable execution times and dispatch counts.
|
|
//
|
|
// - runnable execution time: time spent in a runnable when called
|
|
// in nsThread::ProcessNextEvent (not counting recursive calls)
|
|
// - dispatch counts: number of times a tracked runnable is dispatched
|
|
// in nsThread. Useful to measure the activity of a tab or worker.
|
|
//
|
|
// The PerformanceCounter class is currently instantiated in DocGroup
|
|
// and WorkerPrivate in order to count how many scheduler dispatches
|
|
// are done through them, and how long the execution lasts.
|
|
//
|
|
// The execution time is calculated by the nsThread class (and its
|
|
// inherited WorkerThread class) in its ProcessNextEvent method.
|
|
//
|
|
// For each processed runnable, nsThread will reach out the
|
|
// PerformanceCounter attached to the runnable via its DocGroup
|
|
// or WorkerPrivate and call IncrementExecutionDuration()
|
|
//
|
|
// Notice that the execution duration counting takes into account
|
|
// recursivity. If an event triggers a recursive call to
|
|
// nsThread::ProcessNextEVent, the counter will discard the time
|
|
// spent in sub events.
|
|
class PerformanceCounter final
|
|
{
|
|
public:
|
|
NS_INLINE_DECL_THREADSAFE_REFCOUNTING(PerformanceCounter)
|
|
|
|
explicit PerformanceCounter(const nsACString& aName);
|
|
|
|
/**
|
|
* This is called everytime a runnable is dispatched.
|
|
*
|
|
* aCategory can be used to distinguish counts per TaskCategory
|
|
*
|
|
* Note that an overflow will simply reset the counter.
|
|
*/
|
|
void IncrementDispatchCounter(DispatchCategory aCategory);
|
|
|
|
/**
|
|
* This is called via nsThread::ProcessNextEvent to measure runnable
|
|
* execution duration.
|
|
*
|
|
* Note that an overflow will simply reset the counter.
|
|
*/
|
|
void IncrementExecutionDuration(uint32_t aMicroseconds);
|
|
|
|
/**
|
|
* Returns a category/counter array of all dispatches.
|
|
*/
|
|
const DispatchCounter& GetDispatchCounter();
|
|
|
|
/**
|
|
* Returns the total execution duration.
|
|
*/
|
|
uint64_t GetExecutionDuration();
|
|
|
|
/**
|
|
* Returns the number of dispatches per TaskCategory.
|
|
*/
|
|
uint32_t GetDispatchCount(DispatchCategory aCategory);
|
|
|
|
/**
|
|
* Returns the total number of dispatches.
|
|
*/
|
|
uint64_t GetTotalDispatchCount();
|
|
|
|
private:
|
|
~PerformanceCounter() {}
|
|
|
|
Atomic<uint64_t> mExecutionDuration;
|
|
Atomic<uint64_t> mTotalDispatchCount;
|
|
DispatchCounter mDispatchCounter;
|
|
nsCString mName;
|
|
};
|
|
|
|
} // namespace mozilla
|
|
|
|
#endif // mozilla_PerformanceCounter_h
|