summaryrefslogtreecommitdiff
path: root/indra/llcommon
diff options
context:
space:
mode:
Diffstat (limited to 'indra/llcommon')
-rw-r--r--indra/llcommon/lltrace.h832
-rw-r--r--indra/llcommon/lltracerecording.h23
2 files changed, 429 insertions, 426 deletions
diff --git a/indra/llcommon/lltrace.h b/indra/llcommon/lltrace.h
index 5d57327a14..44da1939c6 100644
--- a/indra/llcommon/lltrace.h
+++ b/indra/llcommon/lltrace.h
@@ -42,517 +42,519 @@
namespace LLTrace
{
- class Recording;
-
- typedef LLUnit<LLUnits::Bytes, F64> Bytes;
- typedef LLUnit<LLUnits::Kilobytes, F64> Kilobytes;
- typedef LLUnit<LLUnits::Megabytes, F64> Megabytes;
- typedef LLUnit<LLUnits::Gigabytes, F64> Gigabytes;
- typedef LLUnit<LLUnits::Bits, F64> Bits;
- typedef LLUnit<LLUnits::Kilobits, F64> Kilobits;
- typedef LLUnit<LLUnits::Megabits, F64> Megabits;
- typedef LLUnit<LLUnits::Gigabits, F64> Gigabits;
-
- typedef LLUnit<LLUnits::Seconds, F64> Seconds;
- typedef LLUnit<LLUnits::Milliseconds, F64> Milliseconds;
- typedef LLUnit<LLUnits::Minutes, F64> Minutes;
- typedef LLUnit<LLUnits::Hours, F64> Hours;
- typedef LLUnit<LLUnits::Milliseconds, F64> Milliseconds;
- typedef LLUnit<LLUnits::Microseconds, F64> Microseconds;
- typedef LLUnit<LLUnits::Nanoseconds, F64> Nanoseconds;
-
- typedef LLUnit<LLUnits::Meters, F64> Meters;
- typedef LLUnit<LLUnits::Kilometers, F64> Kilometers;
- typedef LLUnit<LLUnits::Centimeters, F64> Centimeters;
- typedef LLUnit<LLUnits::Millimeters, F64> Millimeters;
-
- void init();
- void cleanup();
- bool isInitialized();
-
- const LLThreadLocalPointer<class ThreadRecorder>& get_thread_recorder();
- void set_thread_recorder(class ThreadRecorder*);
-
- class MasterThreadRecorder& getMasterThreadRecorder();
-
- // one per thread per type
- template<typename ACCUMULATOR>
- class AccumulatorBuffer : public LLRefCount
- {
- typedef AccumulatorBuffer<ACCUMULATOR> self_t;
- static const U32 DEFAULT_ACCUMULATOR_BUFFER_SIZE = 64;
- private:
- struct StaticAllocationMarker { };
-
- AccumulatorBuffer(StaticAllocationMarker m)
- : mStorageSize(0),
- mStorage(NULL),
- mNextStorageSlot(0)
- {
- }
+class Recording;
+
+typedef LLUnit<LLUnits::Bytes, F64> Bytes;
+typedef LLUnit<LLUnits::Kilobytes, F64> Kilobytes;
+typedef LLUnit<LLUnits::Megabytes, F64> Megabytes;
+typedef LLUnit<LLUnits::Gigabytes, F64> Gigabytes;
+typedef LLUnit<LLUnits::Bits, F64> Bits;
+typedef LLUnit<LLUnits::Kilobits, F64> Kilobits;
+typedef LLUnit<LLUnits::Megabits, F64> Megabits;
+typedef LLUnit<LLUnits::Gigabits, F64> Gigabits;
+
+typedef LLUnit<LLUnits::Seconds, F64> Seconds;
+typedef LLUnit<LLUnits::Milliseconds, F64> Milliseconds;
+typedef LLUnit<LLUnits::Minutes, F64> Minutes;
+typedef LLUnit<LLUnits::Hours, F64> Hours;
+typedef LLUnit<LLUnits::Milliseconds, F64> Milliseconds;
+typedef LLUnit<LLUnits::Microseconds, F64> Microseconds;
+typedef LLUnit<LLUnits::Nanoseconds, F64> Nanoseconds;
+
+typedef LLUnit<LLUnits::Meters, F64> Meters;
+typedef LLUnit<LLUnits::Kilometers, F64> Kilometers;
+typedef LLUnit<LLUnits::Centimeters, F64> Centimeters;
+typedef LLUnit<LLUnits::Millimeters, F64> Millimeters;
+
+void init();
+void cleanup();
+bool isInitialized();
+
+const LLThreadLocalPointer<class ThreadRecorder>& get_thread_recorder();
+void set_thread_recorder(class ThreadRecorder*);
+
+class MasterThreadRecorder& getMasterThreadRecorder();
+
+// one per thread per type
+template<typename ACCUMULATOR>
+class AccumulatorBuffer : public LLRefCount
+{
+ typedef AccumulatorBuffer<ACCUMULATOR> self_t;
+ static const U32 DEFAULT_ACCUMULATOR_BUFFER_SIZE = 64;
+private:
+ struct StaticAllocationMarker { };
- public:
+ AccumulatorBuffer(StaticAllocationMarker m)
+ : mStorageSize(0),
+ mStorage(NULL),
+ mNextStorageSlot(0)
+ {
+ }
- AccumulatorBuffer(const AccumulatorBuffer& other = *getDefaultBuffer())
- : mStorageSize(0),
- mStorage(NULL),
- mNextStorageSlot(other.mNextStorageSlot)
- {
- resize(other.mStorageSize);
- for (S32 i = 0; i < mNextStorageSlot; i++)
- {
- mStorage[i] = other.mStorage[i];
- }
- }
+public:
- ~AccumulatorBuffer()
+ AccumulatorBuffer(const AccumulatorBuffer& other = *getDefaultBuffer())
+ : mStorageSize(0),
+ mStorage(NULL),
+ mNextStorageSlot(other.mNextStorageSlot)
+ {
+ resize(other.mStorageSize);
+ for (S32 i = 0; i < mNextStorageSlot; i++)
{
- if (LLThreadLocalSingletonPointer<ACCUMULATOR>::getInstance() == mStorage)
- {
- LLThreadLocalSingletonPointer<ACCUMULATOR>::setInstance(getDefaultBuffer()->mStorage);
- }
- delete[] mStorage;
+ mStorage[i] = other.mStorage[i];
}
+ }
- LL_FORCE_INLINE ACCUMULATOR& operator[](size_t index)
- {
- return mStorage[index];
+ ~AccumulatorBuffer()
+ {
+ if (LLThreadLocalSingletonPointer<ACCUMULATOR>::getInstance() == mStorage)
+ {
+ LLThreadLocalSingletonPointer<ACCUMULATOR>::setInstance(getDefaultBuffer()->mStorage);
}
+ delete[] mStorage;
+ }
- LL_FORCE_INLINE const ACCUMULATOR& operator[](size_t index) const
- {
- return mStorage[index];
- }
+ LL_FORCE_INLINE ACCUMULATOR& operator[](size_t index)
+ {
+ return mStorage[index];
+ }
- void addSamples(const AccumulatorBuffer<ACCUMULATOR>& other)
- {
- llassert(mNextStorageSlot == other.mNextStorageSlot);
+ LL_FORCE_INLINE const ACCUMULATOR& operator[](size_t index) const
+ {
+ return mStorage[index];
+ }
- for (size_t i = 0; i < mNextStorageSlot; i++)
- {
- mStorage[i].addSamples(other.mStorage[i]);
- }
- }
+ void addSamples(const AccumulatorBuffer<ACCUMULATOR>& other)
+ {
+ llassert(mNextStorageSlot == other.mNextStorageSlot);
- void copyFrom(const AccumulatorBuffer<ACCUMULATOR>& other)
+ for (size_t i = 0; i < mNextStorageSlot; i++)
{
- for (size_t i = 0; i < mNextStorageSlot; i++)
- {
- mStorage[i] = other.mStorage[i];
- }
+ mStorage[i].addSamples(other.mStorage[i]);
}
+ }
- void reset(const AccumulatorBuffer<ACCUMULATOR>* other = NULL)
+ void copyFrom(const AccumulatorBuffer<ACCUMULATOR>& other)
+ {
+ for (size_t i = 0; i < mNextStorageSlot; i++)
{
- for (size_t i = 0; i < mNextStorageSlot; i++)
- {
- mStorage[i].reset(other ? &other->mStorage[i] : NULL);
- }
+ mStorage[i] = other.mStorage[i];
}
+ }
- void makePrimary()
+ void reset(const AccumulatorBuffer<ACCUMULATOR>* other = NULL)
+ {
+ for (size_t i = 0; i < mNextStorageSlot; i++)
{
- LLThreadLocalSingletonPointer<ACCUMULATOR>::setInstance(mStorage);
+ mStorage[i].reset(other ? &other->mStorage[i] : NULL);
}
+ }
- bool isPrimary() const
- {
- return LLThreadLocalSingletonPointer<ACCUMULATOR>::getInstance() == mStorage;
- }
+ void makePrimary()
+ {
+ LLThreadLocalSingletonPointer<ACCUMULATOR>::setInstance(mStorage);
+ }
- LL_FORCE_INLINE static ACCUMULATOR* getPrimaryStorage()
- {
- return LLThreadLocalSingletonPointer<ACCUMULATOR>::getInstance();
- }
+ bool isPrimary() const
+ {
+ return LLThreadLocalSingletonPointer<ACCUMULATOR>::getInstance() == mStorage;
+ }
- // NOTE: this is not thread-safe. We assume that slots are reserved in the main thread before any child threads are spawned
- size_t reserveSlot()
+ LL_FORCE_INLINE static ACCUMULATOR* getPrimaryStorage()
+ {
+ return LLThreadLocalSingletonPointer<ACCUMULATOR>::getInstance();
+ }
+
+ // NOTE: this is not thread-safe. We assume that slots are reserved in the main thread before any child threads are spawned
+ size_t reserveSlot()
+ {
+ if (LLTrace::isInitialized())
{
- if (LLTrace::isInitialized())
- {
- llerrs << "Attempting to declare trace object after program initialization. Trace objects should be statically initialized." << llendl;
- }
- size_t next_slot = mNextStorageSlot++;
- if (next_slot >= mStorageSize)
- {
- resize(mStorageSize + (mStorageSize >> 2));
- }
- llassert(mStorage && next_slot < mStorageSize);
- return next_slot;
+ llerrs << "Attempting to declare trace object after program initialization. Trace objects should be statically initialized." << llendl;
}
-
- void resize(size_t new_size)
+ size_t next_slot = mNextStorageSlot++;
+ if (next_slot >= mStorageSize)
{
- if (new_size <= mStorageSize) return;
+ resize(mStorageSize + (mStorageSize >> 2));
+ }
+ llassert(mStorage && next_slot < mStorageSize);
+ return next_slot;
+ }
- ACCUMULATOR* old_storage = mStorage;
- mStorage = new ACCUMULATOR[new_size];
- if (old_storage)
- {
- for (S32 i = 0; i < mStorageSize; i++)
- {
- mStorage[i] = old_storage[i];
- }
- }
- mStorageSize = new_size;
- delete[] old_storage;
+ void resize(size_t new_size)
+ {
+ if (new_size <= mStorageSize) return;
- self_t* default_buffer = getDefaultBuffer();
- if (this != default_buffer
- && new_size > default_buffer->size())
+ ACCUMULATOR* old_storage = mStorage;
+ mStorage = new ACCUMULATOR[new_size];
+ if (old_storage)
+ {
+ for (S32 i = 0; i < mStorageSize; i++)
{
- //NB: this is not thread safe, but we assume that all resizing occurs during static initialization
- default_buffer->resize(new_size);
+ mStorage[i] = old_storage[i];
}
}
+ mStorageSize = new_size;
+ delete[] old_storage;
- size_t size() const
+ self_t* default_buffer = getDefaultBuffer();
+ if (this != default_buffer
+ && new_size > default_buffer->size())
{
- return mNextStorageSlot;
+ //NB: this is not thread safe, but we assume that all resizing occurs during static initialization
+ default_buffer->resize(new_size);
}
+ }
+
+ size_t size() const
+ {
+ return mNextStorageSlot;
+ }
- static self_t* getDefaultBuffer()
+ static self_t* getDefaultBuffer()
+ {
+ // this buffer is allowed to leak so that trace calls from global destructors have somewhere to put their data
+ // so as not to trigger an access violation
+ static self_t* sBuffer = new AccumulatorBuffer(StaticAllocationMarker());
+ static bool sInitialized = false;
+ if (!sInitialized)
{
- // this buffer is allowed to leak so that trace calls from global destructors have somewhere to put their data
- // so as not to trigger an access violation
- static self_t* sBuffer = new AccumulatorBuffer(StaticAllocationMarker());
- static bool sInitialized = false;
- if (!sInitialized)
- {
- sBuffer->resize(DEFAULT_ACCUMULATOR_BUFFER_SIZE);
- sInitialized = true;
- }
- return sBuffer;
+ sBuffer->resize(DEFAULT_ACCUMULATOR_BUFFER_SIZE);
+ sInitialized = true;
}
+ return sBuffer;
+ }
- private:
- ACCUMULATOR* mStorage;
- size_t mStorageSize;
- size_t mNextStorageSlot;
- };
+private:
+ ACCUMULATOR* mStorage;
+ size_t mStorageSize;
+ size_t mNextStorageSlot;
+};
- //TODO: replace with decltype when C++11 is enabled
- template<typename T>
- struct MeanValueType
- {
- typedef F64 type;
- };
+//TODO: replace with decltype when C++11 is enabled
+template<typename T>
+struct MeanValueType
+{
+ typedef F64 type;
+};
- template<typename ACCUMULATOR>
- class TraceType
- : public LLInstanceTracker<TraceType<ACCUMULATOR>, std::string>
+template<typename ACCUMULATOR>
+class TraceType
+: public LLInstanceTracker<TraceType<ACCUMULATOR>, std::string>
+{
+public:
+ TraceType(const char* name, const char* description = NULL)
+ : LLInstanceTracker<TraceType<ACCUMULATOR>, std::string>(name),
+ mName(name),
+ mDescription(description ? description : ""),
+ mAccumulatorIndex(AccumulatorBuffer<ACCUMULATOR>::getDefaultBuffer()->reserveSlot())
+ {}
+
+ LL_FORCE_INLINE ACCUMULATOR* getPrimaryAccumulator() const
{
- public:
- TraceType(const char* name, const char* description = NULL)
- : LLInstanceTracker<TraceType<ACCUMULATOR>, std::string>(name),
- mName(name),
- mDescription(description ? description : ""),
- mAccumulatorIndex(AccumulatorBuffer<ACCUMULATOR>::getDefaultBuffer()->reserveSlot())
- {}
+ ACCUMULATOR* accumulator_storage = AccumulatorBuffer<ACCUMULATOR>::getPrimaryStorage();
+ return &accumulator_storage[mAccumulatorIndex];
+ }
- LL_FORCE_INLINE ACCUMULATOR* getPrimaryAccumulator() const
- {
- ACCUMULATOR* accumulator_storage = AccumulatorBuffer<ACCUMULATOR>::getPrimaryStorage();
- return &accumulator_storage[mAccumulatorIndex];
- }
+ size_t getIndex() const { return mAccumulatorIndex; }
- size_t getIndex() const { return mAccumulatorIndex; }
+ const std::string& getName() const { return mName; }
- const std::string& getName() const { return mName; }
+protected:
+ const std::string mName;
+ const std::string mDescription;
+ const size_t mAccumulatorIndex;
+};
- protected:
- const std::string mName;
- const std::string mDescription;
- const size_t mAccumulatorIndex;
- };
+template<typename T>
+class MeasurementAccumulator
+{
+public:
+ typedef T value_t;
+ typedef MeasurementAccumulator<T> self_t;
+
+ MeasurementAccumulator()
+ : mSum(0),
+ mMin((std::numeric_limits<T>::max)()),
+ mMax((std::numeric_limits<T>::min)()),
+ mMean(0),
+ mVarianceSum(0),
+ mNumSamples(0),
+ mLastValue(0)
+ {}
- template<typename T>
- class MeasurementAccumulator
+ void sample(T value)
{
- public:
- typedef T value_t;
- typedef MeasurementAccumulator<T> self_t;
-
- MeasurementAccumulator()
- : mSum(0),
- mMin((std::numeric_limits<T>::max)()),
- mMax((std::numeric_limits<T>::min)()),
- mMean(0),
- mVarianceSum(0),
- mNumSamples(0),
- mLastValue(0)
- {}
+ mNumSamples++;
+ mSum += value;
+ if (value < mMin)
+ {
+ mMin = value;
+ }
+ if (value > mMax)
+ {
+ mMax = value;
+ }
+ F64 old_mean = mMean;
+ mMean += ((F64)value - old_mean) / (F64)mNumSamples;
+ mVarianceSum += ((F64)value - old_mean) * ((F64)value - mMean);
+ mLastValue = value;
+ }
- LL_FORCE_INLINE void sample(T value)
+ void addSamples(const self_t& other)
+ {
+ if (other.mNumSamples)
{
- T storage_value(value);
- mNumSamples++;
- mSum += storage_value;
- if (storage_value < mMin)
+ mSum += other.mSum;
+ if (other.mMin < mMin)
{
- mMin = storage_value;
+ mMin = other.mMin;
}
- if (storage_value > mMax)
+ if (other.mMax > mMax)
{
- mMax = storage_value;
+ mMax = other.mMax;
}
- F64 old_mean = mMean;
- mMean += ((F64)storage_value - old_mean) / (F64)mNumSamples;
- mVarianceSum += ((F64)storage_value - old_mean) * ((F64)storage_value - mMean);
- mLastValue = storage_value;
- }
-
- void addSamples(const self_t& other)
- {
- if (other.mNumSamples)
+ F64 weight = (F64)mNumSamples / (F64)(mNumSamples + other.mNumSamples);
+ mNumSamples += other.mNumSamples;
+ mMean = mMean * weight + other.mMean * (1.f - weight);
+
+ // combine variance (and hence standard deviation) of 2 different sized sample groups using
+ // the following formula: http://www.mrc-bsu.cam.ac.uk/cochrane/handbook/chapter_7/7_7_3_8_combining_groups.htm
+ F64 n_1 = (F64)mNumSamples,
+ n_2 = (F64)other.mNumSamples;
+ F64 m_1 = mMean,
+ m_2 = other.mMean;
+ F64 v_1 = mVarianceSum / mNumSamples,
+ v_2 = other.mVarianceSum / other.mNumSamples;
+ if (n_1 == 0)
+ {
+ mVarianceSum = other.mVarianceSum;
+ }
+ else if (n_2 == 0)
{
- mSum += other.mSum;
- if (other.mMin < mMin)
- {
- mMin = other.mMin;
- }
- if (other.mMax > mMax)
- {
- mMax = other.mMax;
- }
- F64 weight = (F64)mNumSamples / (F64)(mNumSamples + other.mNumSamples);
- mNumSamples += other.mNumSamples;
- mMean = mMean * weight + other.mMean * (1.f - weight);
-
- // combine variance (and hence standard deviation) of 2 different sized sample groups using
- // the following formula: http://www.mrc-bsu.cam.ac.uk/cochrane/handbook/chapter_7/7_7_3_8_combining_groups.htm
- F64 n_1 = (F64)mNumSamples,
- n_2 = (F64)other.mNumSamples;
- F64 m_1 = mMean,
- m_2 = other.mMean;
- F64 sd_1 = getStandardDeviation(),
- sd_2 = other.getStandardDeviation();
- if (n_1 == 0)
- {
- mVarianceSum = other.mVarianceSum;
- }
- else if (n_2 == 0)
- {
- // don't touch variance
- // mVarianceSum = mVarianceSum;
- }
- else
- {
- mVarianceSum = (F64)mNumSamples
- * ((((n_1 - 1.f) * sd_1 * sd_1)
- + ((n_2 - 1.f) * sd_2 * sd_2)
- + (((n_1 * n_2) / (n_1 + n_2))
- * ((m_1 * m_1) + (m_2 * m_2) - (2.f * m_1 * m_2))))
- / (n_1 + n_2 - 1.f));
- }
- mLastValue = other.mLastValue;
+ // don't touch variance
+ // mVarianceSum = mVarianceSum;
}
+ else
+ {
+ mVarianceSum = (F64)mNumSamples
+ * ((((n_1 - 1.f) * v_1)
+ + ((n_2 - 1.f) * v_2)
+ + (((n_1 * n_2) / (n_1 + n_2))
+ * ((m_1 * m_1) + (m_2 * m_2) - (2.f * m_1 * m_2))))
+ / (n_1 + n_2 - 1.f));
+ }
+ mLastValue = other.mLastValue;
}
+ }
- void reset(const self_t* other)
- {
- mNumSamples = 0;
- mSum = 0;
- mMin = 0;
- mMax = 0;
- mMean = 0;
- mVarianceSum = 0;
- mLastValue = other ? other->mLastValue : 0;
- }
+ void reset(const self_t* other)
+ {
+ mNumSamples = 0;
+ mSum = 0;
+ mMin = 0;
+ mMax = 0;
+ mMean = 0;
+ mVarianceSum = 0;
+ mLastValue = other ? other->mLastValue : 0;
+ }
- T getSum() const { return (T)mSum; }
- T getMin() const { return (T)mMin; }
- T getMax() const { return (T)mMax; }
- T getLastValue() const { return (T)mLastValue; }
- F64 getMean() const { return mMean; }
- F64 getStandardDeviation() const { return sqrtf(mVarianceSum / mNumSamples); }
- U32 getSampleCount() const { return mNumSamples; }
+ T getSum() const { return (T)mSum; }
+ T getMin() const { return (T)mMin; }
+ T getMax() const { return (T)mMax; }
+ T getLastValue() const { return (T)mLastValue; }
+ F64 getMean() const { return mMean; }
+ F64 getStandardDeviation() const { return sqrtf(mVarianceSum / mNumSamples); }
+ U32 getSampleCount() const { return mNumSamples; }
- private:
- T mSum,
- mMin,
- mMax,
- mLastValue;
+private:
+ T mSum,
+ mMin,
+ mMax,
+ mLastValue;
- F64 mMean,
- mVarianceSum;
+ F64 mMean,
+ mVarianceSum;
- U32 mNumSamples;
- };
+ U32 mNumSamples;
+};
+
+template<typename T>
+class CountAccumulator
+{
+public:
+ typedef CountAccumulator<T> self_t;
+ typedef T value_t;
+
+ CountAccumulator()
+ : mSum(0),
+ mNumSamples(0)
+ {}
- template<typename T>
- class CountAccumulator
+ void add(T value)
{
- public:
- typedef CountAccumulator<T> self_t;
- typedef T value_t;
+ mNumSamples++;
+ mSum += value;
+ }
- CountAccumulator()
- : mSum(0),
- mNumSamples(0)
- {}
+ void addSamples(const CountAccumulator<T>& other)
+ {
+ mSum += other.mSum;
+ mNumSamples += other.mNumSamples;
+ }
- LL_FORCE_INLINE void add(T value)
- {
- mNumSamples++;
- mSum += value;
- }
+ void reset(const self_t* other)
+ {
+ mNumSamples = 0;
+ mSum = 0;
+ }
- void addSamples(const CountAccumulator<T>& other)
- {
- mSum += other.mSum;
- mNumSamples += other.mNumSamples;
- }
+ T getSum() const { return (T)mSum; }
- void reset(const self_t* other)
- {
- mNumSamples = 0;
- mSum = 0;
- }
+ U32 getSampleCount() const { return mNumSamples; }
- T getSum() const { return (T)mSum; }
+private:
+ T mSum;
- U32 getSampleCount() const { return mNumSamples; }
+ U32 mNumSamples;
+};
- private:
- T mSum;
+class TimeBlockAccumulator
+{
+public:
+ typedef LLUnit<LLUnits::Seconds, F64> value_t;
+ typedef TimeBlockAccumulator self_t;
- U32 mNumSamples;
+ // fake class that allows us to view call count aspect of timeblock accumulator
+ struct CallCountAspect
+ {
+ typedef U32 value_t;
};
- class TimeBlockAccumulator
+ struct SelfTimeAspect
{
- public:
typedef LLUnit<LLUnits::Seconds, F64> value_t;
- typedef TimeBlockAccumulator self_t;
+ };
- // fake class that allows us to view call count aspect of timeblock accumulator
- struct CallCountAspect
- {
- typedef U32 value_t;
- };
+ TimeBlockAccumulator();
+ void addSamples(const self_t& other);
+ void reset(const self_t* other);
+
+ //
+ // members
+ //
+ U64 mStartTotalTimeCounter,
+ mTotalTimeCounter,
+ mSelfTimeCounter;
+ U32 mCalls;
+ class TimeBlock* mParent; // last acknowledged parent of this time block
+ class TimeBlock* mLastCaller; // used to bootstrap tree construction
+ U16 mActiveCount; // number of timers with this ID active on stack
+ bool mMoveUpTree; // needs to be moved up the tree of timers at the end of frame
- struct SelfTimeAspect
- {
- typedef LLUnit<LLUnits::Seconds, F64> value_t;
- };
-
- TimeBlockAccumulator();
- void addSamples(const self_t& other);
- void reset(const self_t* other);
-
- //
- // members
- //
- U64 mStartTotalTimeCounter,
- mTotalTimeCounter,
- mSelfTimeCounter;
- U32 mCalls;
- class TimeBlock* mParent; // last acknowledged parent of this time block
- class TimeBlock* mLastCaller; // used to bootstrap tree construction
- U16 mActiveCount; // number of timers with this ID active on stack
- bool mMoveUpTree; // needs to be moved up the tree of timers at the end of frame
+};
- };
+template<>
+struct MeanValueType<TraceType<TimeBlockAccumulator> >
+{
+ typedef LLUnit<LLUnits::Seconds, F64> type;
+};
- template<>
- struct MeanValueType<TraceType<TimeBlockAccumulator> >
- {
- typedef LLUnit<LLUnits::Seconds, F64> type;
- };
+template<>
+class TraceType<TimeBlockAccumulator::CallCountAspect>
+: public TraceType<TimeBlockAccumulator>
+{
+public:
- template<>
- class TraceType<TimeBlockAccumulator::CallCountAspect>
+ TraceType(const char* name, const char* description = "")
+ : TraceType<TimeBlockAccumulator>(name, description)
+ {}
+};
+
+template<>
+struct MeanValueType<TraceType<TimeBlockAccumulator::CallCountAspect> >
+{
+ typedef F64 type;
+};
+
+
+template<>
+class TraceType<TimeBlockAccumulator::SelfTimeAspect>
: public TraceType<TimeBlockAccumulator>
- {
- public:
+{
+public:
- TraceType(const char* name, const char* description = "")
+ TraceType(const char* name, const char* description = "")
: TraceType<TimeBlockAccumulator>(name, description)
- {}
- };
-
- template<>
- struct MeanValueType<TraceType<TimeBlockAccumulator::CallCountAspect> >
- {
- typedef F64 type;
- };
+ {}
+};
+template<>
+struct MeanValueType<TraceType<TimeBlockAccumulator::SelfTimeAspect> >
+{
+ typedef LLUnit<LLUnits::Seconds, F64> type;
+};
- template<>
- class TraceType<TimeBlockAccumulator::SelfTimeAspect>
- : public TraceType<TimeBlockAccumulator>
- {
- public:
- TraceType(const char* name, const char* description = "")
- : TraceType<TimeBlockAccumulator>(name, description)
- {}
- };
+class TimeBlock;
+class TimeBlockTreeNode
+{
+public:
+ TimeBlockTreeNode();
- template<>
- struct MeanValueType<TraceType<TimeBlockAccumulator::SelfTimeAspect> >
- {
- typedef LLUnit<LLUnits::Seconds, F64> type;
- };
+ void setParent(TimeBlock* parent);
+ TimeBlock* getParent() { return mParent; }
+ TimeBlock* mBlock;
+ TimeBlock* mParent;
+ std::vector<TimeBlock*> mChildren;
+ bool mNeedsSorting;
+};
- class TimeBlock;
- class TimeBlockTreeNode
- {
- public:
- TimeBlockTreeNode();
- void setParent(TimeBlock* parent);
- TimeBlock* getParent() { return mParent; }
+template <typename T = F64>
+class MeasurementStatHandle
+: public TraceType<MeasurementAccumulator<typename LLUnits::HighestPrecisionType<T>::type_t> >
+{
+public:
+ typedef typename LLUnits::HighestPrecisionType<T>::type_t storage_t;
+ typedef TraceType<MeasurementAccumulator<typename LLUnits::HighestPrecisionType<T>::type_t> > trace_t;
- TimeBlock* mBlock;
- TimeBlock* mParent;
- std::vector<TimeBlock*> mChildren;
- bool mNeedsSorting;
- };
+ MeasurementStatHandle(const char* name, const char* description = NULL)
+ : trace_t(name, description)
+ {}
+};
+template<typename T, typename VALUE_T>
+void sample(MeasurementStatHandle<T>& measurement, VALUE_T value)
+{
+ T converted_value(value);
+ measurement.getPrimaryAccumulator()->sample(LLUnits::rawValue(converted_value));
+}
- template <typename T = F64>
- class Measurement
- : public TraceType<MeasurementAccumulator<typename LLUnits::HighestPrecisionType<T>::type_t> >
- {
- public:
- typedef typename LLUnits::HighestPrecisionType<T>::type_t storage_t;
- typedef TraceType<MeasurementAccumulator<typename LLUnits::HighestPrecisionType<T>::type_t> > trace_t;
- Measurement(const char* name, const char* description = NULL)
- : trace_t(name, description)
- {}
+template <typename T = F64>
+class CountStatHandle
+: public TraceType<CountAccumulator<typename LLUnits::HighestPrecisionType<T>::type_t> >
+{
+public:
+ typedef typename LLUnits::HighestPrecisionType<T>::type_t storage_t;
+ typedef TraceType<CountAccumulator<typename LLUnits::HighestPrecisionType<T>::type_t> > trace_t;
- template<typename UNIT_T>
- void sample(UNIT_T value)
- {
- T converted_value(value);
- trace_t::getPrimaryAccumulator()->sample(LLUnits::rawValue(converted_value));
- }
- };
+ CountStatHandle(const char* name, const char* description = NULL)
+ : trace_t(name)
+ {}
- template <typename T = F64>
- class Count
- : public TraceType<CountAccumulator<typename LLUnits::HighestPrecisionType<T>::type_t> >
- {
- public:
- typedef typename LLUnits::HighestPrecisionType<T>::type_t storage_t;
- typedef TraceType<CountAccumulator<typename LLUnits::HighestPrecisionType<T>::type_t> > trace_t;
+};
- Count(const char* name, const char* description = NULL)
- : trace_t(name)
- {}
+template<typename T, typename VALUE_T>
+void add(CountStatHandle<T>& count, VALUE_T value)
+{
+ T converted_value(value);
+ count.getPrimaryAccumulator()->add(LLUnits::rawValue(converted_value));
+}
- template<typename UNIT_T>
- void add(UNIT_T value)
- {
- T converted_value(value);
- trace_t::getPrimaryAccumulator()->add(LLUnits::rawValue(converted_value));
- }
- };
struct MemStatAccumulator
{
@@ -585,11 +587,11 @@ struct MemStatAccumulator
mDeallocatedCount;
};
-class MemStat : public TraceType<MemStatAccumulator>
+class MemStatHandle : public TraceType<MemStatAccumulator>
{
public:
typedef TraceType<MemStatAccumulator> trace_t;
- MemStat(const char* name)
+ MemStatHandle(const char* name)
: trace_t(name)
{}
};
diff --git a/indra/llcommon/lltracerecording.h b/indra/llcommon/lltracerecording.h
index af9ba02b29..6b4d4357db 100644
--- a/indra/llcommon/lltracerecording.h
+++ b/indra/llcommon/lltracerecording.h
@@ -135,11 +135,11 @@ namespace LLTrace
LLUnit<LLUnits::Bytes, U32> getSum(const TraceType<MemStatAccumulator>& stat) const;
LLUnit<LLUnits::Bytes, F32> getPerSec(const TraceType<MemStatAccumulator>& stat) const;
- // Count accessors
+ // CountStatHandle accessors
F64 getSum(const TraceType<CountAccumulator<F64> >& stat) const;
S64 getSum(const TraceType<CountAccumulator<S64> >& stat) const;
template <typename T>
- T getSum(const Count<T>& stat) const
+ T getSum(const CountStatHandle<T>& stat) const
{
return (T)getSum(static_cast<const TraceType<CountAccumulator<typename LLUnits::HighestPrecisionType<T>::type_t> >&> (stat));
}
@@ -147,7 +147,7 @@ namespace LLTrace
F64 getPerSec(const TraceType<CountAccumulator<F64> >& stat) const;
F64 getPerSec(const TraceType<CountAccumulator<S64> >& stat) const;
template <typename T>
- T getPerSec(const Count<T>& stat) const
+ T getPerSec(const CountStatHandle<T>& stat) const
{
return (T)getPerSec(static_cast<const TraceType<CountAccumulator<typename LLUnits::HighestPrecisionType<T>::type_t> >&> (stat));
}
@@ -156,11 +156,11 @@ namespace LLTrace
U32 getSampleCount(const TraceType<CountAccumulator<S64> >& stat) const;
- // Measurement accessors
+ // MeasurementStatHandle accessors
F64 getSum(const TraceType<MeasurementAccumulator<F64> >& stat) const;
S64 getSum(const TraceType<MeasurementAccumulator<S64> >& stat) const;
template <typename T>
- T getSum(const Measurement<T>& stat) const
+ T getSum(const MeasurementStatHandle<T>& stat) const
{
return (T)getSum(static_cast<const TraceType<MeasurementAccumulator<typename LLUnits::HighestPrecisionType<T>::type_t> >&> (stat));
}
@@ -168,7 +168,7 @@ namespace LLTrace
F64 getPerSec(const TraceType<MeasurementAccumulator<F64> >& stat) const;
F64 getPerSec(const TraceType<MeasurementAccumulator<S64> >& stat) const;
template <typename T>
- T getPerSec(const Measurement<T>& stat) const
+ T getPerSec(const MeasurementStatHandle<T>& stat) const
{
return (T)getPerSec(static_cast<const TraceType<MeasurementAccumulator<typename LLUnits::HighestPrecisionType<T>::type_t> >&> (stat));
}
@@ -176,7 +176,7 @@ namespace LLTrace
F64 getMin(const TraceType<MeasurementAccumulator<F64> >& stat) const;
S64 getMin(const TraceType<MeasurementAccumulator<S64> >& stat) const;
template <typename T>
- T getMin(const Measurement<T>& stat) const
+ T getMin(const MeasurementStatHandle<T>& stat) const
{
return (T)getMin(static_cast<const TraceType<MeasurementAccumulator<typename LLUnits::HighestPrecisionType<T>::type_t> >&> (stat));
}
@@ -184,7 +184,7 @@ namespace LLTrace
F64 getMax(const TraceType<MeasurementAccumulator<F64> >& stat) const;
S64 getMax(const TraceType<MeasurementAccumulator<S64> >& stat) const;
template <typename T>
- T getMax(const Measurement<T>& stat) const
+ T getMax(const MeasurementStatHandle<T>& stat) const
{
return (T)getMax(static_cast<const TraceType<MeasurementAccumulator<typename LLUnits::HighestPrecisionType<T>::type_t> >&> (stat));
}
@@ -192,7 +192,7 @@ namespace LLTrace
F64 getMean(const TraceType<MeasurementAccumulator<F64> >& stat) const;
F64 getMean(const TraceType<MeasurementAccumulator<S64> >& stat) const;
template <typename T>
- T getMean(Measurement<T>& stat) const
+ T getMean(MeasurementStatHandle<T>& stat) const
{
return (T)getMean(static_cast<const TraceType<MeasurementAccumulator<typename LLUnits::HighestPrecisionType<T>::type_t> >&> (stat));
}
@@ -200,7 +200,7 @@ namespace LLTrace
F64 getStandardDeviation(const TraceType<MeasurementAccumulator<F64> >& stat) const;
F64 getStandardDeviation(const TraceType<MeasurementAccumulator<S64> >& stat) const;
template <typename T>
- T getStandardDeviation(const Measurement<T>& stat) const
+ T getStandardDeviation(const MeasurementStatHandle<T>& stat) const
{
return (T)getMean(static_cast<const TraceType<MeasurementAccumulator<typename LLUnits::HighestPrecisionType<T>::type_t> >&> (stat));
}
@@ -208,7 +208,7 @@ namespace LLTrace
F64 getLastValue(const TraceType<MeasurementAccumulator<F64> >& stat) const;
S64 getLastValue(const TraceType<MeasurementAccumulator<S64> >& stat) const;
template <typename T>
- T getLastValue(const Measurement<T>& stat) const
+ T getLastValue(const MeasurementStatHandle<T>& stat) const
{
return (T)getLastValue(static_cast<const TraceType<MeasurementAccumulator<typename LLUnits::HighestPrecisionType<T>::type_t> >&> (stat));
}
@@ -394,6 +394,7 @@ namespace LLTrace
{
public:
void extend();
+
Recording& getAcceptedRecording() { return mAcceptedRecording; }
// implementation for LLStopWatchControlsMixin