diff --git a/indra/llcommon/llthread.cpp b/indra/llcommon/llthread.cpp
index 6374b5398bb3066cb55e4c569091d5e70f9bb0a4..118568d5efd39cdf8da469e59fb354393a4af9e0 100644
--- a/indra/llcommon/llthread.cpp
+++ b/indra/llcommon/llthread.cpp
@@ -93,7 +93,7 @@ void *APR_THREAD_FUNC LLThread::staticRun(apr_thread_t *apr_threadp, void *datap
{
LLThread *threadp = (LLThread *)datap;
- LLTrace::ThreadRecorder* thread_recorder = new LLTrace::SlaveThreadRecorder();
+ LLTrace::ThreadRecorder* thread_recorder = new LLTrace::SlaveThreadRecorder(LLTrace::getUIThreadRecorder());
#if !LL_DARWIN
sThreadID = threadp->mID;
diff --git a/indra/llcommon/llthreadlocalstorage.h b/indra/llcommon/llthreadlocalstorage.h
index 4873b2740dd37ded197bddd5bbcadcf36280ded8..471784749bdf9bfac608d16e8e1957c7a99a8821 100644
--- a/indra/llcommon/llthreadlocalstorage.h
+++ b/indra/llcommon/llthreadlocalstorage.h
@@ -131,6 +131,10 @@ class LLThreadLocalPointer : public LLThreadLocalPointerBase
if (!sInitialized) return false;
return get() == other;
}
+
+ bool isNull() const { return !sInitialized || get() == NULL; }
+
+ bool notNull() const { return sInitialized && get() != NULL; }
};
template<typename DERIVED_TYPE>
diff --git a/indra/llcommon/lltrace.cpp b/indra/llcommon/lltrace.cpp
index 463048008f256815e883e8888bdaecb43eb7fa57..c831a1548d10368b02d75cb83516bd294ea3a5e9 100644
--- a/indra/llcommon/lltrace.cpp
+++ b/indra/llcommon/lltrace.cpp
@@ -35,13 +35,13 @@ static S32 sInitializationCount = 0;
namespace LLTrace
{
-static MasterThreadRecorder* gMasterThreadRecorder = NULL;
+static MasterThreadRecorder* gUIThreadRecorder = NULL;
void init()
{
if (sInitializationCount++ == 0)
{
- gMasterThreadRecorder = new MasterThreadRecorder();
+ gUIThreadRecorder = new MasterThreadRecorder();
}
}
@@ -54,15 +54,15 @@ void cleanup()
{
if (--sInitializationCount == 0)
{
- delete gMasterThreadRecorder;
- gMasterThreadRecorder = NULL;
+ delete gUIThreadRecorder;
+ gUIThreadRecorder = NULL;
}
}
-MasterThreadRecorder& getMasterThreadRecorder()
+MasterThreadRecorder& getUIThreadRecorder()
{
- llassert(gMasterThreadRecorder != NULL);
- return *gMasterThreadRecorder;
+ llassert(gUIThreadRecorder != NULL);
+ return *gUIThreadRecorder;
}
LLThreadLocalPointer<ThreadRecorder>& get_thread_recorder_ptr()
diff --git a/indra/llcommon/lltrace.h b/indra/llcommon/lltrace.h
index d1edaf969bb109593a2a60c1d5840f297ead63c9..f94576de45c960b123ab0d6f98143dc2f60b0771 100644
--- a/indra/llcommon/lltrace.h
+++ b/indra/llcommon/lltrace.h
@@ -73,7 +73,7 @@ bool isInitialized();
const LLThreadLocalPointer<class ThreadRecorder>& get_thread_recorder();
void set_thread_recorder(class ThreadRecorder*);
-class MasterThreadRecorder& getMasterThreadRecorder();
+class MasterThreadRecorder& getUIThreadRecorder();
// one per thread per type
template<typename ACCUMULATOR>
@@ -148,6 +148,15 @@ class AccumulatorBuffer : public LLRefCount
}
}
+ void flush()
+ {
+ llassert(mStorageSize >= sNextStorageSlot);
+ for (size_t i = 0; i < sNextStorageSlot; i++)
+ {
+ mStorage[i].flush();
+ }
+ }
+
void makePrimary()
{
LLThreadLocalSingletonPointer<ACCUMULATOR>::setInstance(mStorage);
@@ -260,14 +269,14 @@ class TraceType
};
template<typename T>
-class MeasurementAccumulator
+class EventAccumulator
{
public:
typedef T value_t;
typedef F64 mean_t;
- typedef MeasurementAccumulator<T> self_t;
+ typedef EventAccumulator<T> self_t;
- MeasurementAccumulator()
+ EventAccumulator()
: mSum(0),
mMin((std::numeric_limits<T>::max)()),
mMax((std::numeric_limits<T>::min)()),
@@ -277,7 +286,7 @@ class MeasurementAccumulator
mLastValue(0)
{}
- void sample(T value)
+ void record(T value)
{
mNumSamples++;
mSum += value;
@@ -301,17 +310,10 @@ class MeasurementAccumulator
if (other.mNumSamples)
{
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);
+
+ // NOTE: both conditions will hold first time through
+ if (other.mMin < mMin) { mMin = other.mMin; }
+ if (other.mMax > mMax) { mMax = other.mMax; }
// 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
@@ -333,12 +335,16 @@ class MeasurementAccumulator
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));
+ * ((((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));
}
+
+ F64 weight = (F64)mNumSamples / (F64)(mNumSamples + other.mNumSamples);
+ mNumSamples += other.mNumSamples;
+ mMean = mMean * weight + other.mMean * (1.f - weight);
mLastValue = other.mLastValue;
}
}
@@ -347,13 +353,15 @@ class MeasurementAccumulator
{
mNumSamples = 0;
mSum = 0;
- mMin = 0;
- mMax = 0;
+ mMin = std::numeric_limits<T>::max();
+ mMax = std::numeric_limits<T>::min();
mMean = 0;
mVarianceSum = 0;
mLastValue = other ? other->mLastValue : 0;
}
+ void flush() {}
+
T getSum() const { return (T)mSum; }
T getMin() const { return (T)mMin; }
T getMax() const { return (T)mMax; }
@@ -375,6 +383,150 @@ class MeasurementAccumulator
};
+template<typename T>
+class SampleAccumulator
+{
+public:
+ typedef T value_t;
+ typedef F64 mean_t;
+ typedef SampleAccumulator<T> self_t;
+
+ SampleAccumulator()
+ : mSum(0),
+ mMin((std::numeric_limits<T>::max)()),
+ mMax((std::numeric_limits<T>::min)()),
+ mMean(0),
+ mVarianceSum(0),
+ mLastSampleTimeStamp(LLTimer::getTotalSeconds()),
+ mTotalSamplingTime(0),
+ mNumSamples(0),
+ mLastValue(0),
+ mHasValue(false)
+ {}
+
+ void sample(T value)
+ {
+ LLUnitImplicit<LLUnits::Seconds, F64> time_stamp = LLTimer::getTotalSeconds();
+ LLUnitImplicit<LLUnits::Seconds, F64> delta_time = time_stamp - mLastSampleTimeStamp;
+ mLastSampleTimeStamp = time_stamp;
+
+ if (mHasValue)
+ {
+ mTotalSamplingTime += delta_time;
+ mSum += (F64)mLastValue * delta_time;
+
+ // NOTE: both conditions will hold first time through
+ if (value < mMin) { mMin = value; }
+ if (value > mMax) { mMax = value; }
+
+ F64 old_mean = mMean;
+ mMean += (delta_time / mTotalSamplingTime) * ((F64)mLastValue - old_mean);
+ mVarianceSum += delta_time * ((F64)mLastValue - old_mean) * ((F64)mLastValue - mMean);
+ }
+
+ mLastValue = value;
+ mNumSamples++;
+ mHasValue = true;
+ }
+
+ void addSamples(const self_t& other)
+ {
+ if (other.mTotalSamplingTime)
+ {
+ mSum += other.mSum;
+
+ // NOTE: both conditions will hold first time through
+ if (other.mMin < mMin) { mMin = other.mMin; }
+ if (other.mMax > mMax) { mMax = other.mMax; }
+
+ // 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 = mTotalSamplingTime,
+ n_2 = other.mTotalSamplingTime;
+ F64 m_1 = mMean,
+ m_2 = other.mMean;
+ F64 v_1 = mVarianceSum / mTotalSamplingTime,
+ v_2 = other.mVarianceSum / other.mTotalSamplingTime;
+ if (n_1 == 0)
+ {
+ mVarianceSum = other.mVarianceSum;
+ }
+ else if (n_2 == 0)
+ {
+ // variance is unchanged
+ // mVarianceSum = mVarianceSum;
+ }
+ else
+ {
+ mVarianceSum = mTotalSamplingTime
+ * ((((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));
+ }
+
+ llassert(other.mTotalSamplingTime > 0);
+ F64 weight = mTotalSamplingTime / (mTotalSamplingTime + other.mTotalSamplingTime);
+ mNumSamples += other.mNumSamples;
+ mTotalSamplingTime += other.mTotalSamplingTime;
+ mMean = (mMean * weight) + (other.mMean * (1.0 - weight));
+ mLastValue = other.mLastValue;
+ mLastSampleTimeStamp = other.mLastSampleTimeStamp;
+ mHasValue |= other.mHasValue;
+ }
+ }
+
+ void reset(const self_t* other)
+ {
+ mNumSamples = 0;
+ mSum = 0;
+ mMin = std::numeric_limits<T>::max();
+ mMax = std::numeric_limits<T>::min();
+ mMean = other ? other->mLastValue : 0;
+ mVarianceSum = 0;
+ mLastSampleTimeStamp = LLTimer::getTotalSeconds();
+ mTotalSamplingTime = 0;
+ mLastValue = other ? other->mLastValue : 0;
+ mHasValue = other ? other->mHasValue : false;
+ }
+
+ void flush()
+ {
+ LLUnitImplicit<LLUnits::Seconds, F64> time_stamp = LLTimer::getTotalSeconds();
+ LLUnitImplicit<LLUnits::Seconds, F64> delta_time = time_stamp - mLastSampleTimeStamp;
+
+ mSum += (F64)mLastValue * delta_time;
+
+ mTotalSamplingTime += delta_time;
+ mLastSampleTimeStamp = time_stamp;
+ }
+
+ 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 / mTotalSamplingTime); }
+ U32 getSampleCount() const { return mNumSamples; }
+
+private:
+ T mSum,
+ mMin,
+ mMax,
+ mLastValue;
+
+ bool mHasValue;
+
+ F64 mMean,
+ mVarianceSum;
+
+ LLUnitImplicit<LLUnits::Seconds, F64> mLastSampleTimeStamp,
+ mTotalSamplingTime;
+
+ U32 mNumSamples;
+};
+
template<typename T>
class CountAccumulator
{
@@ -406,6 +558,8 @@ class CountAccumulator
mSum = 0;
}
+ void flush() {}
+
T getSum() const { return (T)mSum; }
U32 getSampleCount() const { return mNumSamples; }
@@ -439,6 +593,7 @@ class TimeBlockAccumulator
TimeBlockAccumulator();
void addSamples(const self_t& other);
void reset(const self_t* other);
+ void flush() {}
//
// members
@@ -493,25 +648,44 @@ class TimeBlockTreeNode
template <typename T = F64>
-class MeasurementStatHandle
-: public TraceType<MeasurementAccumulator<typename LLUnits::HighestPrecisionType<T>::type_t> >
+class EventStatHandle
+: public TraceType<EventAccumulator<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;
+ typedef TraceType<EventAccumulator<typename LLUnits::HighestPrecisionType<T>::type_t> > trace_t;
- MeasurementStatHandle(const char* name, const char* description = NULL)
+ EventStatHandle(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)
+void record(EventStatHandle<T>& measurement, VALUE_T value)
{
T converted_value(value);
- measurement.getPrimaryAccumulator()->sample(LLUnits::rawValue(converted_value));
+ measurement.getPrimaryAccumulator()->record(LLUnits::rawValue(converted_value));
}
+template <typename T = F64>
+class SampleStatHandle
+: public TraceType<SampleAccumulator<typename LLUnits::HighestPrecisionType<T>::type_t> >
+{
+public:
+ typedef typename LLUnits::HighestPrecisionType<T>::type_t storage_t;
+ typedef TraceType<SampleAccumulator<typename LLUnits::HighestPrecisionType<T>::type_t> > trace_t;
+
+ SampleStatHandle(const char* name, const char* description = NULL)
+ : trace_t(name, description)
+ {}
+};
+
+template<typename T, typename VALUE_T>
+void sample(SampleStatHandle<T>& measurement, VALUE_T value)
+{
+ T converted_value(value);
+ measurement.getPrimaryAccumulator()->sample(LLUnits::rawValue(converted_value));
+}
template <typename T = F64>
class CountStatHandle
@@ -560,6 +734,8 @@ struct MemStatAccumulator
mDeallocatedCount = 0;
}
+ void flush() {}
+
size_t mSize,
mChildSize;
int mAllocatedCount,
diff --git a/indra/llcommon/lltracerecording.cpp b/indra/llcommon/lltracerecording.cpp
index cced6546baa3395e5818578eed6e9dc27bd07ed0..5b0b74524f49ae78c4f9623b58647fb8d21f317a 100644
--- a/indra/llcommon/lltracerecording.cpp
+++ b/indra/llcommon/lltracerecording.cpp
@@ -45,9 +45,11 @@ RecordingBuffers::RecordingBuffers()
void RecordingBuffers::handOffTo(RecordingBuffers& other)
{
other.mCountsFloat.reset(&mCountsFloat);
- other.mMeasurementsFloat.reset(&mMeasurementsFloat);
other.mCounts.reset(&mCounts);
- other.mMeasurements.reset(&mMeasurements);
+ other.mSamplesFloat.reset(&mSamplesFloat);
+ other.mSamples.reset(&mSamples);
+ other.mEventsFloat.reset(&mEventsFloat);
+ other.mEvents.reset(&mEvents);
other.mStackTimers.reset(&mStackTimers);
other.mMemStats.reset(&mMemStats);
}
@@ -55,9 +57,11 @@ void RecordingBuffers::handOffTo(RecordingBuffers& other)
void RecordingBuffers::makePrimary()
{
mCountsFloat.makePrimary();
- mMeasurementsFloat.makePrimary();
mCounts.makePrimary();
- mMeasurements.makePrimary();
+ mSamplesFloat.makePrimary();
+ mSamples.makePrimary();
+ mEventsFloat.makePrimary();
+ mEvents.makePrimary();
mStackTimers.makePrimary();
mMemStats.makePrimary();
@@ -82,9 +86,11 @@ bool RecordingBuffers::isPrimary() const
void RecordingBuffers::append( const RecordingBuffers& other )
{
mCountsFloat.addSamples(other.mCountsFloat);
- mMeasurementsFloat.addSamples(other.mMeasurementsFloat);
mCounts.addSamples(other.mCounts);
- mMeasurements.addSamples(other.mMeasurements);
+ mSamplesFloat.addSamples(other.mSamplesFloat);
+ mSamples.addSamples(other.mSamples);
+ mEventsFloat.addSamples(other.mEventsFloat);
+ mEvents.addSamples(other.mEvents);
mMemStats.addSamples(other.mMemStats);
mStackTimers.addSamples(other.mStackTimers);
}
@@ -92,22 +98,32 @@ void RecordingBuffers::append( const RecordingBuffers& other )
void RecordingBuffers::merge( const RecordingBuffers& other)
{
mCountsFloat.addSamples(other.mCountsFloat);
- mMeasurementsFloat.addSamples(other.mMeasurementsFloat);
mCounts.addSamples(other.mCounts);
- mMeasurements.addSamples(other.mMeasurements);
+ mSamplesFloat.addSamples(other.mSamplesFloat);
+ mSamples.addSamples(other.mSamples);
+ mEventsFloat.addSamples(other.mEventsFloat);
+ mEvents.addSamples(other.mEvents);
mMemStats.addSamples(other.mMemStats);
}
void RecordingBuffers::reset(RecordingBuffers* other)
{
mCountsFloat.reset(other ? &other->mCountsFloat : NULL);
- mMeasurementsFloat.reset(other ? &other->mMeasurementsFloat : NULL);
mCounts.reset(other ? &other->mCounts : NULL);
- mMeasurements.reset(other ? &other->mMeasurements : NULL);
+ mSamplesFloat.reset(other ? &other->mSamplesFloat : NULL);
+ mSamples.reset(other ? &other->mSamples : NULL);
+ mEventsFloat.reset(other ? &other->mEventsFloat : NULL);
+ mEvents.reset(other ? &other->mEvents : NULL);
mStackTimers.reset(other ? &other->mStackTimers : NULL);
mMemStats.reset(other ? &other->mMemStats : NULL);
}
+void RecordingBuffers::flush()
+{
+ mSamplesFloat.flush();
+ mSamples.flush();
+}
+
///////////////////////////////////////////////////////////////////////
// Recording
///////////////////////////////////////////////////////////////////////
@@ -120,6 +136,9 @@ Recording::Recording()
Recording::Recording( const Recording& other )
{
+ // this will allow us to seamlessly start without affecting any data we've acquired from other
+ setPlayState(PAUSED);
+
Recording& mutable_other = const_cast<Recording&>(other);
EPlayState other_play_state = other.getPlayState();
mutable_other.pause();
@@ -137,15 +156,18 @@ Recording::Recording( const Recording& other )
Recording::~Recording()
{
- stop();
- llassert(isStopped());
+ if (isStarted() && LLTrace::get_thread_recorder().notNull())
+ {
+ LLTrace::get_thread_recorder()->deactivate(this);
+ }
}
void Recording::update()
{
if (isStarted())
{
- LLTrace::get_thread_recorder()->update(this);
+ mBuffers.write()->flush();
+ LLTrace::get_thread_recorder()->bringUpToDate(this);
mSamplingTimer.reset();
}
}
@@ -167,6 +189,7 @@ void Recording::handleStart()
void Recording::handleStop()
{
mElapsedSeconds += mSamplingTimer.getElapsedTimeF64();
+ mBuffers.write()->flush();
LLTrace::TimeBlock::processTimes();
LLTrace::get_thread_recorder()->deactivate(this);
}
@@ -178,13 +201,23 @@ void Recording::handleSplitTo(Recording& other)
void Recording::appendRecording( const Recording& other )
{
- mBuffers.write()->append(*other.mBuffers);
- mElapsedSeconds += other.mElapsedSeconds;
+ EPlayState play_state = getPlayState();
+ {
+ pause();
+ mBuffers.write()->append(*other.mBuffers);
+ mElapsedSeconds += other.mElapsedSeconds;
+ }
+ setPlayState(play_state);
}
void Recording::mergeRecording( const Recording& other)
{
- mBuffers.write()->merge(*other.mBuffers);
+ EPlayState play_state = getPlayState();
+ {
+ pause();
+ mBuffers.write()->merge(*other.mBuffers);
+ }
+ setPlayState(play_state);
}
LLUnit<LLUnits::Seconds, F64> Recording::getSum(const TraceType<TimeBlockAccumulator>& stat) const
@@ -248,14 +281,14 @@ S64 Recording::getSum( const TraceType<CountAccumulator<S64> >& stat ) const
return mBuffers->mCounts[stat.getIndex()].getSum();
}
-F64 Recording::getSum( const TraceType<MeasurementAccumulator<F64> >& stat ) const
+F64 Recording::getSum( const TraceType<EventAccumulator<F64> >& stat ) const
{
- return (F64)mBuffers->mMeasurementsFloat[stat.getIndex()].getSum();
+ return (F64)mBuffers->mEventsFloat[stat.getIndex()].getSum();
}
-S64 Recording::getSum( const TraceType<MeasurementAccumulator<S64> >& stat ) const
+S64 Recording::getSum( const TraceType<EventAccumulator<S64> >& stat ) const
{
- return (S64)mBuffers->mMeasurements[stat.getIndex()].getSum();
+ return (S64)mBuffers->mEvents[stat.getIndex()].getSum();
}
@@ -283,67 +316,127 @@ U32 Recording::getSampleCount( const TraceType<CountAccumulator<F64> >& stat ) c
U32 Recording::getSampleCount( const TraceType<CountAccumulator<S64> >& stat ) const
{
- return mBuffers->mMeasurementsFloat[stat.getIndex()].getSampleCount();
+ return mBuffers->mCounts[stat.getIndex()].getSampleCount();
+}
+
+F64 Recording::getMin( const TraceType<SampleAccumulator<F64> >& stat ) const
+{
+ return mBuffers->mSamplesFloat[stat.getIndex()].getMin();
+}
+
+S64 Recording::getMin( const TraceType<SampleAccumulator<S64> >& stat ) const
+{
+ return mBuffers->mSamples[stat.getIndex()].getMin();
+}
+
+F64 Recording::getMax( const TraceType<SampleAccumulator<F64> >& stat ) const
+{
+ return mBuffers->mSamplesFloat[stat.getIndex()].getMax();
+}
+
+S64 Recording::getMax( const TraceType<SampleAccumulator<S64> >& stat ) const
+{
+ return mBuffers->mSamples[stat.getIndex()].getMax();
+}
+
+F64 Recording::getMean( const TraceType<SampleAccumulator<F64> >& stat ) const
+{
+ return mBuffers->mSamplesFloat[stat.getIndex()].getMean();
+}
+
+F64 Recording::getMean( const TraceType<SampleAccumulator<S64> >& stat ) const
+{
+ return mBuffers->mSamples[stat.getIndex()].getMean();
}
-F64 Recording::getMin( const TraceType<MeasurementAccumulator<F64> >& stat ) const
+F64 Recording::getStandardDeviation( const TraceType<SampleAccumulator<F64> >& stat ) const
{
- return mBuffers->mMeasurementsFloat[stat.getIndex()].getMin();
+ return mBuffers->mSamplesFloat[stat.getIndex()].getStandardDeviation();
}
-S64 Recording::getMin( const TraceType<MeasurementAccumulator<S64> >& stat ) const
+F64 Recording::getStandardDeviation( const TraceType<SampleAccumulator<S64> >& stat ) const
{
- return mBuffers->mMeasurements[stat.getIndex()].getMin();
+ return mBuffers->mSamples[stat.getIndex()].getStandardDeviation();
}
-F64 Recording::getMax( const TraceType<MeasurementAccumulator<F64> >& stat ) const
+F64 Recording::getLastValue( const TraceType<SampleAccumulator<F64> >& stat ) const
{
- return mBuffers->mMeasurementsFloat[stat.getIndex()].getMax();
+ return mBuffers->mSamplesFloat[stat.getIndex()].getLastValue();
}
-S64 Recording::getMax( const TraceType<MeasurementAccumulator<S64> >& stat ) const
+S64 Recording::getLastValue( const TraceType<SampleAccumulator<S64> >& stat ) const
{
- return mBuffers->mMeasurements[stat.getIndex()].getMax();
+ return mBuffers->mSamples[stat.getIndex()].getLastValue();
}
-F64 Recording::getMean( const TraceType<MeasurementAccumulator<F64> >& stat ) const
+U32 Recording::getSampleCount( const TraceType<SampleAccumulator<F64> >& stat ) const
{
- return mBuffers->mMeasurementsFloat[stat.getIndex()].getMean();
+ return mBuffers->mSamplesFloat[stat.getIndex()].getSampleCount();
}
-F64 Recording::getMean( const TraceType<MeasurementAccumulator<S64> >& stat ) const
+U32 Recording::getSampleCount( const TraceType<SampleAccumulator<S64> >& stat ) const
{
- return mBuffers->mMeasurements[stat.getIndex()].getMean();
+ return mBuffers->mSamples[stat.getIndex()].getSampleCount();
}
-F64 Recording::getStandardDeviation( const TraceType<MeasurementAccumulator<F64> >& stat ) const
+F64 Recording::getMin( const TraceType<EventAccumulator<F64> >& stat ) const
{
- return mBuffers->mMeasurementsFloat[stat.getIndex()].getStandardDeviation();
+ return mBuffers->mEventsFloat[stat.getIndex()].getMin();
}
-F64 Recording::getStandardDeviation( const TraceType<MeasurementAccumulator<S64> >& stat ) const
+S64 Recording::getMin( const TraceType<EventAccumulator<S64> >& stat ) const
{
- return mBuffers->mMeasurements[stat.getIndex()].getStandardDeviation();
+ return mBuffers->mEvents[stat.getIndex()].getMin();
}
-F64 Recording::getLastValue( const TraceType<MeasurementAccumulator<F64> >& stat ) const
+F64 Recording::getMax( const TraceType<EventAccumulator<F64> >& stat ) const
{
- return mBuffers->mMeasurementsFloat[stat.getIndex()].getLastValue();
+ return mBuffers->mEventsFloat[stat.getIndex()].getMax();
}
-S64 Recording::getLastValue( const TraceType<MeasurementAccumulator<S64> >& stat ) const
+S64 Recording::getMax( const TraceType<EventAccumulator<S64> >& stat ) const
{
- return mBuffers->mMeasurements[stat.getIndex()].getLastValue();
+ return mBuffers->mEvents[stat.getIndex()].getMax();
}
-U32 Recording::getSampleCount( const TraceType<MeasurementAccumulator<F64> >& stat ) const
+F64 Recording::getMean( const TraceType<EventAccumulator<F64> >& stat ) const
{
- return mBuffers->mMeasurementsFloat[stat.getIndex()].getSampleCount();
+ return mBuffers->mEventsFloat[stat.getIndex()].getMean();
}
-U32 Recording::getSampleCount( const TraceType<MeasurementAccumulator<S64> >& stat ) const
+F64 Recording::getMean( const TraceType<EventAccumulator<S64> >& stat ) const
{
- return mBuffers->mMeasurements[stat.getIndex()].getSampleCount();
+ return mBuffers->mEvents[stat.getIndex()].getMean();
+}
+
+F64 Recording::getStandardDeviation( const TraceType<EventAccumulator<F64> >& stat ) const
+{
+ return mBuffers->mEventsFloat[stat.getIndex()].getStandardDeviation();
+}
+
+F64 Recording::getStandardDeviation( const TraceType<EventAccumulator<S64> >& stat ) const
+{
+ return mBuffers->mEvents[stat.getIndex()].getStandardDeviation();
+}
+
+F64 Recording::getLastValue( const TraceType<EventAccumulator<F64> >& stat ) const
+{
+ return mBuffers->mEventsFloat[stat.getIndex()].getLastValue();
+}
+
+S64 Recording::getLastValue( const TraceType<EventAccumulator<S64> >& stat ) const
+{
+ return mBuffers->mEvents[stat.getIndex()].getLastValue();
+}
+
+U32 Recording::getSampleCount( const TraceType<EventAccumulator<F64> >& stat ) const
+{
+ return mBuffers->mEventsFloat[stat.getIndex()].getSampleCount();
+}
+
+U32 Recording::getSampleCount( const TraceType<EventAccumulator<S64> >& stat ) const
+{
+ return mBuffers->mEvents[stat.getIndex()].getSampleCount();
}
///////////////////////////////////////////////////////////////////////
@@ -377,7 +470,7 @@ void PeriodicRecording::appendPeriodicRecording( PeriodicRecording& other )
if (other.mRecordingPeriods.empty()) return;
EPlayState play_state = getPlayState();
- stop();
+ pause();
EPlayState other_play_state = other.getPlayState();
other.pause();
@@ -466,8 +559,7 @@ LLTrace::Recording PeriodicRecording::snapshotCurRecording() const
Recording& PeriodicRecording::getLastRecording()
{
- U32 num_periods = mRecordingPeriods.size();
- return mRecordingPeriods[(mCurPeriod + num_periods - 1) % num_periods];
+ return getPrevRecording(1);
}
const Recording& PeriodicRecording::getLastRecording() const
diff --git a/indra/llcommon/lltracerecording.h b/indra/llcommon/lltracerecording.h
index b339e72e5cc5462606f1235e0026970ca817312a..19a4fae7376f04b6555713054729eaee9625acff 100644
--- a/indra/llcommon/lltracerecording.h
+++ b/indra/llcommon/lltracerecording.h
@@ -117,11 +117,14 @@ namespace LLTrace
void append(const RecordingBuffers& other);
void merge(const RecordingBuffers& other);
void reset(RecordingBuffers* other = NULL);
+ void flush();
AccumulatorBuffer<CountAccumulator<F64> > mCountsFloat;
- AccumulatorBuffer<MeasurementAccumulator<F64> > mMeasurementsFloat;
AccumulatorBuffer<CountAccumulator<S64> > mCounts;
- AccumulatorBuffer<MeasurementAccumulator<S64> > mMeasurements;
+ AccumulatorBuffer<SampleAccumulator<F64> > mSamplesFloat;
+ AccumulatorBuffer<SampleAccumulator<S64> > mSamples;
+ AccumulatorBuffer<EventAccumulator<F64> > mEventsFloat;
+ AccumulatorBuffer<EventAccumulator<S64> > mEvents;
AccumulatorBuffer<TimeBlockAccumulator> mStackTimers;
AccumulatorBuffer<MemStatAccumulator> mMemStats;
};
@@ -181,57 +184,101 @@ namespace LLTrace
U32 getSampleCount(const TraceType<CountAccumulator<S64> >& stat) const;
- // MeasurementStatHandle accessors
- F64 getSum(const TraceType<MeasurementAccumulator<F64> >& stat) const;
- S64 getSum(const TraceType<MeasurementAccumulator<S64> >& stat) const;
+ // SampleStatHandle accessors
+ F64 getMin(const TraceType<SampleAccumulator<F64> >& stat) const;
+ S64 getMin(const TraceType<SampleAccumulator<S64> >& stat) const;
template <typename T>
- T getSum(const MeasurementStatHandle<T>& stat) const
+ T getMin(const SampleStatHandle<T>& stat) const
{
- return (T)getSum(static_cast<const TraceType<MeasurementAccumulator<typename LLUnits::HighestPrecisionType<T>::type_t> >&> (stat));
+ return (T)getMin(static_cast<const TraceType<SampleAccumulator<typename LLUnits::HighestPrecisionType<T>::type_t> >&> (stat));
}
- F64 getMin(const TraceType<MeasurementAccumulator<F64> >& stat) const;
- S64 getMin(const TraceType<MeasurementAccumulator<S64> >& stat) const;
+ F64 getMax(const TraceType<SampleAccumulator<F64> >& stat) const;
+ S64 getMax(const TraceType<SampleAccumulator<S64> >& stat) const;
template <typename T>
- T getMin(const MeasurementStatHandle<T>& stat) const
+ T getMax(const SampleStatHandle<T>& stat) const
{
- return (T)getMin(static_cast<const TraceType<MeasurementAccumulator<typename LLUnits::HighestPrecisionType<T>::type_t> >&> (stat));
+ return (T)getMax(static_cast<const TraceType<SampleAccumulator<typename LLUnits::HighestPrecisionType<T>::type_t> >&> (stat));
}
- F64 getMax(const TraceType<MeasurementAccumulator<F64> >& stat) const;
- S64 getMax(const TraceType<MeasurementAccumulator<S64> >& stat) const;
+ F64 getMean(const TraceType<SampleAccumulator<F64> >& stat) const;
+ F64 getMean(const TraceType<SampleAccumulator<S64> >& stat) const;
template <typename T>
- T getMax(const MeasurementStatHandle<T>& stat) const
+ T getMean(SampleStatHandle<T>& stat) const
{
- return (T)getMax(static_cast<const TraceType<MeasurementAccumulator<typename LLUnits::HighestPrecisionType<T>::type_t> >&> (stat));
+ return (T)getMean(static_cast<const TraceType<SampleAccumulator<typename LLUnits::HighestPrecisionType<T>::type_t> >&> (stat));
}
- F64 getMean(const TraceType<MeasurementAccumulator<F64> >& stat) const;
- F64 getMean(const TraceType<MeasurementAccumulator<S64> >& stat) const;
+ F64 getStandardDeviation(const TraceType<SampleAccumulator<F64> >& stat) const;
+ F64 getStandardDeviation(const TraceType<SampleAccumulator<S64> >& stat) const;
template <typename T>
- T getMean(MeasurementStatHandle<T>& stat) const
+ T getStandardDeviation(const SampleStatHandle<T>& stat) const
{
- return (T)getMean(static_cast<const TraceType<MeasurementAccumulator<typename LLUnits::HighestPrecisionType<T>::type_t> >&> (stat));
+ return (T)getStandardDeviation(static_cast<const TraceType<SampleAccumulator<typename LLUnits::HighestPrecisionType<T>::type_t> >&> (stat));
}
- F64 getStandardDeviation(const TraceType<MeasurementAccumulator<F64> >& stat) const;
- F64 getStandardDeviation(const TraceType<MeasurementAccumulator<S64> >& stat) const;
+ F64 getLastValue(const TraceType<SampleAccumulator<F64> >& stat) const;
+ S64 getLastValue(const TraceType<SampleAccumulator<S64> >& stat) const;
template <typename T>
- T getStandardDeviation(const MeasurementStatHandle<T>& stat) const
+ T getLastValue(const SampleStatHandle<T>& stat) const
{
- return (T)getMean(static_cast<const TraceType<MeasurementAccumulator<typename LLUnits::HighestPrecisionType<T>::type_t> >&> (stat));
+ return (T)getLastValue(static_cast<const TraceType<SampleAccumulator<typename LLUnits::HighestPrecisionType<T>::type_t> >&> (stat));
}
- F64 getLastValue(const TraceType<MeasurementAccumulator<F64> >& stat) const;
- S64 getLastValue(const TraceType<MeasurementAccumulator<S64> >& stat) const;
+ U32 getSampleCount(const TraceType<SampleAccumulator<F64> >& stat) const;
+ U32 getSampleCount(const TraceType<SampleAccumulator<S64> >& stat) const;
+
+ // EventStatHandle accessors
+ F64 getSum(const TraceType<EventAccumulator<F64> >& stat) const;
+ S64 getSum(const TraceType<EventAccumulator<S64> >& stat) const;
+ template <typename T>
+ T getSum(const EventStatHandle<T>& stat) const
+ {
+ return (T)getSum(static_cast<const TraceType<EventAccumulator<typename LLUnits::HighestPrecisionType<T>::type_t> >&> (stat));
+ }
+
+ F64 getMin(const TraceType<EventAccumulator<F64> >& stat) const;
+ S64 getMin(const TraceType<EventAccumulator<S64> >& stat) const;
+ template <typename T>
+ T getMin(const EventStatHandle<T>& stat) const
+ {
+ return (T)getMin(static_cast<const TraceType<EventAccumulator<typename LLUnits::HighestPrecisionType<T>::type_t> >&> (stat));
+ }
+
+ F64 getMax(const TraceType<EventAccumulator<F64> >& stat) const;
+ S64 getMax(const TraceType<EventAccumulator<S64> >& stat) const;
+ template <typename T>
+ T getMax(const EventStatHandle<T>& stat) const
+ {
+ return (T)getMax(static_cast<const TraceType<EventAccumulator<typename LLUnits::HighestPrecisionType<T>::type_t> >&> (stat));
+ }
+
+ F64 getMean(const TraceType<EventAccumulator<F64> >& stat) const;
+ F64 getMean(const TraceType<EventAccumulator<S64> >& stat) const;
+ template <typename T>
+ T getMean(EventStatHandle<T>& stat) const
+ {
+ return (T)getMean(static_cast<const TraceType<EventAccumulator<typename LLUnits::HighestPrecisionType<T>::type_t> >&> (stat));
+ }
+
+ F64 getStandardDeviation(const TraceType<EventAccumulator<F64> >& stat) const;
+ F64 getStandardDeviation(const TraceType<EventAccumulator<S64> >& stat) const;
+ template <typename T>
+ T getStandardDeviation(const EventStatHandle<T>& stat) const
+ {
+ return (T)getStandardDeviation(static_cast<const TraceType<EventAccumulator<typename LLUnits::HighestPrecisionType<T>::type_t> >&> (stat));
+ }
+
+ F64 getLastValue(const TraceType<EventAccumulator<F64> >& stat) const;
+ S64 getLastValue(const TraceType<EventAccumulator<S64> >& stat) const;
template <typename T>
- T getLastValue(const MeasurementStatHandle<T>& stat) const
+ T getLastValue(const EventStatHandle<T>& stat) const
{
- return (T)getLastValue(static_cast<const TraceType<MeasurementAccumulator<typename LLUnits::HighestPrecisionType<T>::type_t> >&> (stat));
+ return (T)getLastValue(static_cast<const TraceType<EventAccumulator<typename LLUnits::HighestPrecisionType<T>::type_t> >&> (stat));
}
- U32 getSampleCount(const TraceType<MeasurementAccumulator<F64> >& stat) const;
- U32 getSampleCount(const TraceType<MeasurementAccumulator<S64> >& stat) const;
+ U32 getSampleCount(const TraceType<EventAccumulator<F64> >& stat) const;
+ U32 getSampleCount(const TraceType<EventAccumulator<S64> >& stat) const;
LLUnit<LLUnits::Seconds, F64> getDuration() const { return LLUnit<LLUnits::Seconds, F64>(mElapsedSeconds); }
@@ -272,13 +319,14 @@ namespace LLTrace
const Recording& getPrevRecording(U32 offset) const;
Recording snapshotCurRecording() const;
+ // catch all for stats that have a defined sum
template <typename T>
typename T::value_t getPeriodMin(const TraceType<T>& stat, size_t num_periods = U32_MAX) const
{
size_t total_periods = mRecordingPeriods.size();
num_periods = llmin(num_periods, total_periods);
- typename T::value_t min_val = (std::numeric_limits<typename T::value_t>::max)();
+ typename T::value_t min_val = std::numeric_limits<typename T::value_t>::max();
for (S32 i = 1; i <= num_periods; i++)
{
S32 index = (mCurPeriod + total_periods - i) % total_periods;
@@ -287,13 +335,43 @@ namespace LLTrace
return min_val;
}
+ template <typename T>
+ typename T getPeriodMin(const TraceType<SampleAccumulator<T> >& stat, size_t num_periods = U32_MAX) const
+ {
+ size_t total_periods = mRecordingPeriods.size();
+ num_periods = llmin(num_periods, total_periods);
+
+ typename T min_val = std::numeric_limits<T>::max();
+ for (S32 i = 1; i <= num_periods; i++)
+ {
+ S32 index = (mCurPeriod + total_periods - i) % total_periods;
+ min_val = llmin(min_val, mRecordingPeriods[index].getMin(stat));
+ }
+ return min_val;
+ }
+
+ template <typename T>
+ typename T getPeriodMin(const TraceType<EventAccumulator<T> >& stat, size_t num_periods = U32_MAX) const
+ {
+ size_t total_periods = mRecordingPeriods.size();
+ num_periods = llmin(num_periods, total_periods);
+
+ typename T min_val = std::numeric_limits<T>::max();
+ for (S32 i = 1; i <= num_periods; i++)
+ {
+ S32 index = (mCurPeriod + total_periods - i) % total_periods;
+ min_val = llmin(min_val, mRecordingPeriods[index].getMin(stat));
+ }
+ return min_val;
+ }
+
template <typename T>
F64 getPeriodMinPerSec(const TraceType<T>& stat, size_t num_periods = U32_MAX) const
{
size_t total_periods = mRecordingPeriods.size();
num_periods = llmin(num_periods, total_periods);
- F64 min_val = (std::numeric_limits<F64>::max)();
+ F64 min_val = std::numeric_limits<F64>::max();
for (S32 i = 1; i <= num_periods; i++)
{
S32 index = (mCurPeriod + total_periods - i) % total_periods;
@@ -302,13 +380,14 @@ namespace LLTrace
return min_val;
}
+ // catch all for stats that have a defined sum
template <typename T>
typename T::value_t getPeriodMax(const TraceType<T>& stat, size_t num_periods = U32_MAX) const
{
size_t total_periods = mRecordingPeriods.size();
num_periods = llmin(num_periods, total_periods);
- typename T::value_t max_val = (std::numeric_limits<typename T::value_t>::min)();
+ typename T::value_t max_val = std::numeric_limits<typename T::value_t>::min();
for (S32 i = 1; i <= num_periods; i++)
{
S32 index = (mCurPeriod + total_periods - i) % total_periods;
@@ -317,13 +396,43 @@ namespace LLTrace
return max_val;
}
+ template <typename T>
+ typename T getPeriodMax(const TraceType<SampleAccumulator<T> >& stat, size_t num_periods = U32_MAX) const
+ {
+ size_t total_periods = mRecordingPeriods.size();
+ num_periods = llmin(num_periods, total_periods);
+
+ typename T max_val = std::numeric_limits<T>::min();
+ for (S32 i = 1; i <= num_periods; i++)
+ {
+ S32 index = (mCurPeriod + total_periods - i) % total_periods;
+ max_val = llmax(max_val, mRecordingPeriods[index].getMax(stat));
+ }
+ return max_val;
+ }
+
+ template <typename T>
+ typename T getPeriodMax(const TraceType<EventAccumulator<T> >& stat, size_t num_periods = U32_MAX) const
+ {
+ size_t total_periods = mRecordingPeriods.size();
+ num_periods = llmin(num_periods, total_periods);
+
+ typename T max_val = std::numeric_limits<T>::min();
+ for (S32 i = 1; i <= num_periods; i++)
+ {
+ S32 index = (mCurPeriod + total_periods - i) % total_periods;
+ max_val = llmax(max_val, mRecordingPeriods[index].getMax(stat));
+ }
+ return max_val;
+ }
+
template <typename T>
F64 getPeriodMaxPerSec(const TraceType<T>& stat, size_t num_periods = U32_MAX) const
{
size_t total_periods = mRecordingPeriods.size();
num_periods = llmin(num_periods, total_periods);
- F64 max_val = (std::numeric_limits<F64>::min)();
+ F64 max_val = std::numeric_limits<F64>::min();
for (S32 i = 1; i <= num_periods; i++)
{
S32 index = (mCurPeriod + total_periods - i) % total_periods;
@@ -332,13 +441,14 @@ namespace LLTrace
return max_val;
}
+ // catch all for stats that have a defined sum
template <typename T>
- typename T::mean_t getPeriodMean(const TraceType<T>& stat, size_t num_periods = U32_MAX) const
+ typename T::mean_t getPeriodMean(const TraceType<T >& stat, size_t num_periods = U32_MAX) const
{
size_t total_periods = mRecordingPeriods.size();
num_periods = llmin(num_periods, total_periods);
- typename T::mean_t mean = typename T::mean_t();
+ typename T::mean_t mean = 0;
if (num_periods <= 0) { return mean; }
for (S32 i = 1; i <= num_periods; i++)
@@ -349,7 +459,65 @@ namespace LLTrace
mean += mRecordingPeriods[index].getSum(stat);
}
}
- mean /= num_periods;
+ mean = mean / num_periods;
+ return mean;
+ }
+
+ template <typename T>
+ typename SampleAccumulator<T>::mean_t getPeriodMean(const TraceType<SampleAccumulator<T> >& stat, size_t num_periods = U32_MAX) const
+ {
+ size_t total_periods = mRecordingPeriods.size();
+ num_periods = llmin(num_periods, total_periods);
+
+ LLUnit<LLUnits::Seconds, F64> total_duration = 0.f;
+
+ typename SampleAccumulator<T>::mean_t mean = 0;
+ if (num_periods <= 0) { return mean; }
+
+ for (S32 i = 1; i <= num_periods; i++)
+ {
+ S32 index = (mCurPeriod + total_periods - i) % total_periods;
+ if (mRecordingPeriods[index].getDuration() > 0.f)
+ {
+ LLUnit<LLUnits::Seconds, F64> recording_duration = mRecordingPeriods[index].getDuration();
+ mean += mRecordingPeriods[index].getMean(stat) * recording_duration.value();
+ total_duration += recording_duration;
+ }
+ }
+
+ if (total_duration.value())
+ {
+ mean = mean / total_duration;
+ }
+ return mean;
+ }
+
+ template <typename T>
+ typename EventAccumulator<T>::mean_t getPeriodMean(const TraceType<EventAccumulator<T> >& stat, size_t num_periods = U32_MAX) const
+ {
+ size_t total_periods = mRecordingPeriods.size();
+ num_periods = llmin(num_periods, total_periods);
+
+ typename EventAccumulator<T>::mean_t mean = 0;
+ if (num_periods <= 0) { return mean; }
+
+ S32 total_sample_count = 0;
+
+ for (S32 i = 1; i <= num_periods; i++)
+ {
+ S32 index = (mCurPeriod + total_periods - i) % total_periods;
+ if (mRecordingPeriods[index].getDuration() > 0.f)
+ {
+ S32 period_sample_count = mRecordingPeriods[index].getSampleCount(stat);
+ mean += mRecordingPeriods[index].getMean(stat) * period_sample_count;
+ total_sample_count += period_sample_count;
+ }
+ }
+
+ if (total_sample_count)
+ {
+ mean = mean / total_sample_count;
+ }
return mean;
}
@@ -359,7 +527,7 @@ namespace LLTrace
size_t total_periods = mRecordingPeriods.size();
num_periods = llmin(num_periods, total_periods);
- typename T::mean_t mean = typename T::mean_t();
+ typename T::mean_t mean = 0;
if (num_periods <= 0) { return mean; }
for (S32 i = 1; i <= num_periods; i++)
@@ -370,7 +538,7 @@ namespace LLTrace
mean += mRecordingPeriods[index].getPerSec(stat);
}
}
- mean /= num_periods;
+ mean = mean / num_periods;
return mean;
}
diff --git a/indra/llcommon/lltracethreadrecorder.cpp b/indra/llcommon/lltracethreadrecorder.cpp
index 2001b9cd7f4813fd3a1f4d072786ea8b4f4c7a3c..75c7cb2ff1772487b4b50a97087a55bea98c3fea 100644
--- a/indra/llcommon/lltracethreadrecorder.cpp
+++ b/indra/llcommon/lltracethreadrecorder.cpp
@@ -74,10 +74,12 @@ ThreadRecorder::~ThreadRecorder()
{
delete mRootTimer;
- while(mActiveRecordings.size())
+ if (!mActiveRecordings.empty())
{
- mActiveRecordings.front()->mTargetRecording->stop();
+ std::for_each(mActiveRecordings.begin(), mActiveRecordings.end(), DeletePointer());
+ mActiveRecordings.clear();
}
+
set_thread_recorder(NULL);
delete[] mTimeBlockTreeNodes;
}
@@ -97,34 +99,40 @@ void ThreadRecorder::activate( Recording* recording )
ActiveRecording* active_recording = new ActiveRecording(recording);
if (!mActiveRecordings.empty())
{
- mActiveRecordings.front()->mPartialRecording.handOffTo(active_recording->mPartialRecording);
+ mActiveRecordings.back()->mPartialRecording.handOffTo(active_recording->mPartialRecording);
}
- mActiveRecordings.push_front(active_recording);
+ mActiveRecordings.push_back(active_recording);
- mActiveRecordings.front()->mPartialRecording.makePrimary();
+ mActiveRecordings.back()->mPartialRecording.makePrimary();
}
-ThreadRecorder::active_recording_list_t::iterator ThreadRecorder::update( Recording* recording )
+ThreadRecorder::active_recording_list_t::reverse_iterator ThreadRecorder::bringUpToDate( Recording* recording )
{
- active_recording_list_t::iterator it, end_it;
- for (it = mActiveRecordings.begin(), end_it = mActiveRecordings.end();
+ if (mActiveRecordings.empty()) return mActiveRecordings.rend();
+
+ mActiveRecordings.back()->mPartialRecording.flush();
+
+ active_recording_list_t::reverse_iterator it, end_it;
+ for (it = mActiveRecordings.rbegin(), end_it = mActiveRecordings.rend();
it != end_it;
++it)
{
- active_recording_list_t::iterator next_it = it;
+ ActiveRecording* cur_recording = *it;
+
+ active_recording_list_t::reverse_iterator next_it = it;
++next_it;
// if we have another recording further down in the stack...
- if (next_it != mActiveRecordings.end())
+ if (next_it != mActiveRecordings.rend())
{
// ...push our gathered data down to it
- (*next_it)->mPartialRecording.append((*it)->mPartialRecording);
+ (*next_it)->mPartialRecording.append(cur_recording->mPartialRecording);
}
// copy accumulated measurements into result buffer and clear accumulator (mPartialRecording)
- (*it)->moveBaselineToTarget();
+ cur_recording->movePartialToTarget();
- if ((*it)->mTargetRecording == recording)
+ if (cur_recording->mTargetRecording == recording)
{
// found the recording, so return it
break;
@@ -139,28 +147,30 @@ ThreadRecorder::active_recording_list_t::iterator ThreadRecorder::update( Record
return it;
}
-AccumulatorBuffer<CountAccumulator<F64> > gCountsFloat;
-AccumulatorBuffer<MeasurementAccumulator<F64> > gMeasurementsFloat;
-AccumulatorBuffer<CountAccumulator<S64> > gCounts;
-AccumulatorBuffer<MeasurementAccumulator<S64> > gMeasurements;
-AccumulatorBuffer<TimeBlockAccumulator> gStackTimers;
-AccumulatorBuffer<MemStatAccumulator> gMemStats;
+AccumulatorBuffer<CountAccumulator<F64> > gCountsFloat;
+AccumulatorBuffer<EventAccumulator<F64> > gMeasurementsFloat;
+AccumulatorBuffer<CountAccumulator<S64> > gCounts;
+AccumulatorBuffer<EventAccumulator<S64> > gMeasurements;
+AccumulatorBuffer<TimeBlockAccumulator> gStackTimers;
+AccumulatorBuffer<MemStatAccumulator> gMemStats;
void ThreadRecorder::deactivate( Recording* recording )
{
- active_recording_list_t::iterator it = update(recording);
- if (it != mActiveRecordings.end())
+ active_recording_list_t::reverse_iterator it = bringUpToDate(recording);
+ if (it != mActiveRecordings.rend())
{
// and if we've found the recording we wanted to update
- active_recording_list_t::iterator next_it = it;
+ active_recording_list_t::reverse_iterator next_it = it;
++next_it;
- if (next_it != mActiveRecordings.end())
+ if (next_it != mActiveRecordings.rend())
{
- (*next_it)->mTargetRecording->mBuffers.write()->makePrimary();
+ (*next_it)->mPartialRecording.makePrimary();
}
- delete *it;
- mActiveRecordings.erase(it);
+ active_recording_list_t::iterator recording_to_remove = (++it).base();
+ llassert((*recording_to_remove)->mTargetRecording == recording);
+ delete *recording_to_remove;
+ mActiveRecordings.erase(recording_to_remove);
}
}
@@ -169,10 +179,11 @@ ThreadRecorder::ActiveRecording::ActiveRecording( Recording* target )
{
}
-void ThreadRecorder::ActiveRecording::moveBaselineToTarget()
+void ThreadRecorder::ActiveRecording::movePartialToTarget()
{
mTargetRecording->mBuffers.write()->append(mPartialRecording);
- mPartialRecording.reset();
+ // reset based on self to keep history
+ mPartialRecording.reset(&mPartialRecording);
}
@@ -180,21 +191,22 @@ void ThreadRecorder::ActiveRecording::moveBaselineToTarget()
// SlaveThreadRecorder
///////////////////////////////////////////////////////////////////////
-SlaveThreadRecorder::SlaveThreadRecorder()
+SlaveThreadRecorder::SlaveThreadRecorder(MasterThreadRecorder& master)
+: mMasterRecorder(master)
{
- getMasterThreadRecorder().addSlaveThread(this);
+ mMasterRecorder.addSlaveThread(this);
}
SlaveThreadRecorder::~SlaveThreadRecorder()
{
- getMasterThreadRecorder().removeSlaveThread(this);
+ mMasterRecorder.removeSlaveThread(this);
}
void SlaveThreadRecorder::pushToMaster()
{
mThreadRecording.stop();
{
- LLMutexLock(getMasterThreadRecorder().getSlaveListMutex());
+ LLMutexLock(mMasterRecorder.getSlaveListMutex());
mSharedData.appendFrom(mThreadRecording);
}
mThreadRecording.start();
@@ -243,7 +255,7 @@ void MasterThreadRecorder::pullFromSlaveThreads()
LLMutexLock lock(&mSlaveListMutex);
- RecordingBuffers& target_recording_buffers = mActiveRecordings.front()->mPartialRecording;
+ RecordingBuffers& target_recording_buffers = mActiveRecordings.back()->mPartialRecording;
for (slave_thread_recorder_list_t::iterator it = mSlaveThreadRecorders.begin(), end_it = mSlaveThreadRecorders.end();
it != end_it;
++it)
diff --git a/indra/llcommon/lltracethreadrecorder.h b/indra/llcommon/lltracethreadrecorder.h
index c44bcbd12d139ef3faad2068dab97a8587ee2ee0..17a2d4a9a96e1c14e401ce9b472bd7d6df88e8c1 100644
--- a/indra/llcommon/lltracethreadrecorder.h
+++ b/indra/llcommon/lltracethreadrecorder.h
@@ -39,15 +39,15 @@ namespace LLTrace
{
protected:
struct ActiveRecording;
- typedef std::list<ActiveRecording*> active_recording_list_t;
+ typedef std::vector<ActiveRecording*> active_recording_list_t;
public:
ThreadRecorder();
virtual ~ThreadRecorder();
void activate(Recording* recording);
- active_recording_list_t::iterator update(Recording* recording);
void deactivate(Recording* recording);
+ active_recording_list_t::reverse_iterator bringUpToDate(Recording* recording);
virtual void pushToMaster() = 0;
@@ -58,10 +58,10 @@ namespace LLTrace
{
ActiveRecording(Recording* target);
- Recording* mTargetRecording;
+ Recording* mTargetRecording;
RecordingBuffers mPartialRecording;
- void moveBaselineToTarget();
+ void movePartialToTarget();
};
Recording mThreadRecording;
@@ -98,7 +98,7 @@ namespace LLTrace
class LL_COMMON_API SlaveThreadRecorder : public ThreadRecorder
{
public:
- SlaveThreadRecorder();
+ SlaveThreadRecorder(MasterThreadRecorder& master);
~SlaveThreadRecorder();
// call this periodically to gather stats data for master thread to consume
@@ -117,7 +117,8 @@ namespace LLTrace
private:
LLMutex mRecordingMutex;
};
- SharedData mSharedData;
+ SharedData mSharedData;
+ MasterThreadRecorder& mMasterRecorder;
};
}
diff --git a/indra/llui/llstatbar.cpp b/indra/llui/llstatbar.cpp
index 972b436bdcbf1cda219d7f86a932c069559d8790..22ca90df7a23b7d3914741868d9d0317e44c5fdd 100644
--- a/indra/llui/llstatbar.cpp
+++ b/indra/llui/llstatbar.cpp
@@ -47,10 +47,6 @@ LLStatBar::LLStatBar(const Params& p)
mMinBar(p.bar_min),
mMaxBar(p.bar_max),
mCurMaxBar(p.bar_max),
- mCountFloatp(LLTrace::CountStatHandle<>::getInstance(p.stat)),
- mCountIntp(LLTrace::CountStatHandle<S64>::getInstance(p.stat)),
- mMeasurementFloatp(LLTrace::MeasurementStatHandle<>::getInstance(p.stat)),
- mMeasurementIntp(LLTrace::MeasurementStatHandle<S64>::getInstance(p.stat)),
mTickSpacing(p.tick_spacing),
mPrecision(p.precision),
mUpdatesPerSec(p.update_rate),
@@ -63,7 +59,9 @@ LLStatBar::LLStatBar(const Params& p)
mDisplayMean(p.show_mean),
mOrientation(p.orientation),
mScaleRange(p.scale_range)
-{}
+{
+ setStat(p.stat);
+}
BOOL LLStatBar::handleMouseDown(S32 x, S32 y, MASK mask)
{
@@ -143,23 +141,41 @@ void LLStatBar::draw()
mean = frame_recording.getPeriodMean(*mCountIntp, mNumFrames);
}
}
- else if (mMeasurementFloatp)
+ else if (mEventFloatp)
{
- LLTrace::Recording& last_frame_recording = frame_recording.getLastRecording();
+ LLTrace::Recording& last_frame_recording = frame_recording.getLastRecording();
- current = last_frame_recording.getLastValue(*mMeasurementFloatp);
- min = frame_recording.getPeriodMin(*mMeasurementFloatp, mNumFrames);
- max = frame_recording.getPeriodMax(*mMeasurementFloatp, mNumFrames);
- mean = frame_recording.getPeriodMean(*mMeasurementFloatp, mNumFrames);
+ current = last_frame_recording.getMean(*mEventFloatp);
+ min = frame_recording.getPeriodMin(*mEventFloatp, mNumFrames);
+ max = frame_recording.getPeriodMax(*mEventFloatp, mNumFrames);
+ mean = frame_recording.getPeriodMean(*mEventFloatp, mNumFrames);
}
- else if (mMeasurementIntp)
+ else if (mEventIntp)
{
- LLTrace::Recording& last_frame_recording = frame_recording.getLastRecording();
+ LLTrace::Recording& last_frame_recording = frame_recording.getLastRecording();
+
+ current = last_frame_recording.getLastValue(*mEventIntp);
+ min = frame_recording.getPeriodMin(*mEventIntp, mNumFrames);
+ max = frame_recording.getPeriodMax(*mEventIntp, mNumFrames);
+ mean = frame_recording.getPeriodMean(*mEventIntp, mNumFrames);
+ }
+ else if (mSampleFloatp)
+ {
+ LLTrace::Recording& last_frame_recording = frame_recording.getLastRecording();
+
+ current = last_frame_recording.getLastValue(*mSampleFloatp);
+ min = frame_recording.getPeriodMin(*mSampleFloatp, mNumFrames);
+ max = frame_recording.getPeriodMax(*mSampleFloatp, mNumFrames);
+ mean = frame_recording.getPeriodMean(*mSampleFloatp, mNumFrames);
+ }
+ else if (mSampleIntp)
+ {
+ LLTrace::Recording& last_frame_recording = frame_recording.getLastRecording();
- current = last_frame_recording.getLastValue(*mMeasurementIntp);
- min = frame_recording.getPeriodMin(*mMeasurementIntp, mNumFrames);
- max = frame_recording.getPeriodMax(*mMeasurementIntp, mNumFrames);
- mean = frame_recording.getPeriodMean(*mMeasurementIntp, mNumFrames);
+ current = last_frame_recording.getLastValue(*mSampleIntp);
+ min = frame_recording.getPeriodMin(*mSampleIntp, mNumFrames);
+ max = frame_recording.getPeriodMax(*mSampleIntp, mNumFrames);
+ mean = frame_recording.getPeriodMean(*mSampleIntp, mNumFrames);
}
current *= mUnitScale;
@@ -247,7 +263,7 @@ void LLStatBar::draw()
}
value_format = llformat( "%%.%df", mPrecision);
- if (mDisplayBar && (mCountFloatp || mCountIntp || mMeasurementFloatp || mMeasurementIntp))
+ if (mDisplayBar && (mCountFloatp || mCountIntp || mEventFloatp || mEventIntp || mSampleFloatp || mSampleIntp))
{
std::string tick_label;
@@ -334,7 +350,7 @@ void LLStatBar::draw()
? (bar_right - bar_left)
: (bar_top - bar_bottom);
- if (mDisplayHistory && (mCountFloatp || mCountIntp || mMeasurementFloatp || mMeasurementIntp))
+ if (mDisplayHistory && (mCountFloatp || mCountIntp || mEventFloatp || mEventIntp || mSampleFloatp || mSampleIntp))
{
const S32 num_values = frame_recording.getNumPeriods() - 1;
F32 begin = 0;
@@ -362,19 +378,33 @@ void LLStatBar::draw()
end = ((recording.getPerSec(*mCountIntp) - mMinBar) * value_scale) + 1;
num_samples = recording.getSampleCount(*mCountIntp);
}
- else if (mMeasurementFloatp)
+ else if (mEventFloatp)
{
//rate isn't defined for measurement stats, so use mean
- begin = ((recording.getMean(*mMeasurementFloatp) - mMinBar) * value_scale);
- end = ((recording.getMean(*mMeasurementFloatp) - mMinBar) * value_scale) + 1;
- num_samples = recording.getSampleCount(*mMeasurementFloatp);
+ begin = ((recording.getMean(*mEventFloatp) - mMinBar) * value_scale);
+ end = ((recording.getMean(*mEventFloatp) - mMinBar) * value_scale) + 1;
+ num_samples = recording.getSampleCount(*mEventFloatp);
}
- else if (mMeasurementIntp)
+ else if (mEventIntp)
{
//rate isn't defined for measurement stats, so use mean
- begin = ((recording.getMean(*mMeasurementIntp) - mMinBar) * value_scale);
- end = ((recording.getMean(*mMeasurementIntp) - mMinBar) * value_scale) + 1;
- num_samples = recording.getSampleCount(*mMeasurementIntp);
+ begin = ((recording.getMean(*mEventIntp) - mMinBar) * value_scale);
+ end = ((recording.getMean(*mEventIntp) - mMinBar) * value_scale) + 1;
+ num_samples = recording.getSampleCount(*mEventIntp);
+ }
+ else if (mSampleFloatp)
+ {
+ //rate isn't defined for sample stats, so use mean
+ begin = ((recording.getMean(*mEventFloatp) - mMinBar) * value_scale);
+ end = ((recording.getMean(*mEventFloatp) - mMinBar) * value_scale) + 1;
+ num_samples = recording.getSampleCount(*mEventFloatp);
+ }
+ else if (mSampleIntp)
+ {
+ //rate isn't defined for sample stats, so use mean
+ begin = ((recording.getMean(*mEventFloatp) - mMinBar) * value_scale);
+ end = ((recording.getMean(*mEventFloatp) - mMinBar) * value_scale) + 1;
+ num_samples = recording.getSampleCount(*mEventFloatp);
}
}
else
@@ -391,17 +421,29 @@ void LLStatBar::draw()
end = ((recording.getSum(*mCountIntp) - mMinBar) * value_scale) + 1;
num_samples = recording.getSampleCount(*mCountIntp);
}
- else if (mMeasurementFloatp)
+ else if (mEventFloatp)
+ {
+ begin = ((recording.getMean(*mEventFloatp) - mMinBar) * value_scale);
+ end = ((recording.getMean(*mEventFloatp) - mMinBar) * value_scale) + 1;
+ num_samples = recording.getSampleCount(*mEventFloatp);
+ }
+ else if (mEventIntp)
+ {
+ begin = ((recording.getMean(*mEventIntp) - mMinBar) * value_scale);
+ end = ((recording.getMean(*mEventIntp) - mMinBar) * value_scale) + 1;
+ num_samples = recording.getSampleCount(*mEventIntp);
+ }
+ else if (mSampleFloatp)
{
- begin = ((recording.getMean(*mMeasurementFloatp) - mMinBar) * value_scale);
- end = ((recording.getMean(*mMeasurementFloatp) - mMinBar) * value_scale) + 1;
- num_samples = recording.getSampleCount(*mMeasurementFloatp);
+ begin = ((recording.getMean(*mEventFloatp) - mMinBar) * value_scale);
+ end = ((recording.getMean(*mEventFloatp) - mMinBar) * value_scale) + 1;
+ num_samples = recording.getSampleCount(*mEventFloatp);
}
- else if (mMeasurementIntp)
+ else if (mSampleIntp)
{
- begin = ((recording.getMean(*mMeasurementIntp) - mMinBar) * value_scale);
- end = ((recording.getMean(*mMeasurementIntp) - mMinBar) * value_scale) + 1;
- num_samples = recording.getSampleCount(*mMeasurementIntp);
+ begin = ((recording.getMean(*mEventFloatp) - mMinBar) * value_scale);
+ end = ((recording.getMean(*mEventFloatp) - mMinBar) * value_scale) + 1;
+ num_samples = recording.getSampleCount(*mEventFloatp);
}
}
@@ -461,8 +503,10 @@ void LLStatBar::setStat(const std::string& stat_name)
{
mCountFloatp = LLTrace::CountStatHandle<>::getInstance(stat_name);
mCountIntp = LLTrace::CountStatHandle<S64>::getInstance(stat_name);
- mMeasurementFloatp = LLTrace::MeasurementStatHandle<>::getInstance(stat_name);
- mMeasurementIntp = LLTrace::MeasurementStatHandle<S64>::getInstance(stat_name);
+ mEventFloatp = LLTrace::EventStatHandle<>::getInstance(stat_name);
+ mEventIntp = LLTrace::EventStatHandle<S64>::getInstance(stat_name);
+ mSampleFloatp = LLTrace::SampleStatHandle<>::getInstance(stat_name);
+ mSampleIntp = LLTrace::SampleStatHandle<S64>::getInstance(stat_name);
}
diff --git a/indra/llui/llstatbar.h b/indra/llui/llstatbar.h
index db667aa07deab1a02fd2d7beffa297445d25834b..a0ed9699aae283c2bcef55fd6612e2323f9bc2bd 100644
--- a/indra/llui/llstatbar.h
+++ b/indra/llui/llstatbar.h
@@ -111,10 +111,12 @@ class LLStatBar : public LLView
bool mScaleRange;
EOrientation mOrientation;
- LLTrace::TraceType<LLTrace::CountAccumulator<F64> >* mCountFloatp;
- LLTrace::TraceType<LLTrace::CountAccumulator<S64> >* mCountIntp;
- LLTrace::TraceType<LLTrace::MeasurementAccumulator<F64> >* mMeasurementFloatp;
- LLTrace::TraceType<LLTrace::MeasurementAccumulator<S64> >* mMeasurementIntp;
+ LLTrace::TraceType<LLTrace::CountAccumulator<F64> >* mCountFloatp;
+ LLTrace::TraceType<LLTrace::CountAccumulator<S64> >* mCountIntp;
+ LLTrace::TraceType<LLTrace::EventAccumulator<F64> >* mEventFloatp;
+ LLTrace::TraceType<LLTrace::EventAccumulator<S64> >* mEventIntp;
+ LLTrace::TraceType<LLTrace::SampleAccumulator<F64> >* mSampleFloatp;
+ LLTrace::TraceType<LLTrace::SampleAccumulator<S64> >* mSampleIntp;
LLFrameTimer mUpdateTimer;
LLUIString mLabel;
diff --git a/indra/llui/llstatgraph.h b/indra/llui/llstatgraph.h
index c9e33ed9029ff0546fb64f307bd01b104644d02e..08681b37040569a547e517196ba33b4fa0db34de 100644
--- a/indra/llui/llstatgraph.h
+++ b/indra/llui/llstatgraph.h
@@ -57,10 +57,12 @@ class LLStatGraph : public LLView
struct StatParams : public LLInitParam::ChoiceBlock<StatParams>
{
- Alternative<LLTrace::TraceType<LLTrace::CountAccumulator<F64> >* > count_stat_float;
- Alternative<LLTrace::TraceType<LLTrace::CountAccumulator<S64> >* > count_stat_int;
- Alternative<LLTrace::TraceType<LLTrace::MeasurementAccumulator<F64> >* > measurement_stat_float;
- Alternative<LLTrace::TraceType<LLTrace::MeasurementAccumulator<S64> >* > measurement_stat_int;
+ Alternative<LLTrace::TraceType<LLTrace::CountAccumulator<F64> >* > count_stat_float;
+ Alternative<LLTrace::TraceType<LLTrace::CountAccumulator<S64> >* > count_stat_int;
+ Alternative<LLTrace::TraceType<LLTrace::EventAccumulator<F64> >* > event_stat_float;
+ Alternative<LLTrace::TraceType<LLTrace::EventAccumulator<S64> >* > event_stat_int;
+ Alternative<LLTrace::TraceType<LLTrace::SampleAccumulator<F64> >* > sample_stat_float;
+ Alternative<LLTrace::TraceType<LLTrace::SampleAccumulator<S64> >* > sample_stat_int;
};
struct Params : public LLInitParam::Block<Params, LLView::Params>
diff --git a/indra/newview/llappviewer.cpp b/indra/newview/llappviewer.cpp
index 3a3fe2b65636777711c92fb14c5a6121fb2efb01..edf874d744ddf888277a650efc04d1253434f2fa 100644
--- a/indra/newview/llappviewer.cpp
+++ b/indra/newview/llappviewer.cpp
@@ -1244,7 +1244,7 @@ bool LLAppViewer::mainLoop()
LLTrace::get_frame_recording().nextPeriod();
LLTrace::TimeBlock::logStats();
- LLTrace::getMasterThreadRecorder().pullFromSlaveThreads();
+ LLTrace::getUIThreadRecorder().pullFromSlaveThreads();
//clear call stack records
llclearcallstacks;
diff --git a/indra/newview/llfloaterjoystick.cpp b/indra/newview/llfloaterjoystick.cpp
index dbdf3e5e9f43e0ee032620e58191e91622d4d171..b71ab4c53bc73d3276f6c9fc71a3f94ec543d057 100644
--- a/indra/newview/llfloaterjoystick.cpp
+++ b/indra/newview/llfloaterjoystick.cpp
@@ -42,13 +42,13 @@
#include "llviewerjoystick.h"
#include "llcheckboxctrl.h"
-static LLTrace::MeasurementStatHandle<> sJoystickAxis1("Joystick axis 1"),
- sJoystickAxis2("Joystick axis 2"),
- sJoystickAxis3("Joystick axis 3"),
- sJoystickAxis4("Joystick axis 4"),
- sJoystickAxis5("Joystick axis 5"),
- sJoystickAxis6("Joystick axis 6");
-static LLTrace::MeasurementStatHandle<>* sJoystickAxes[6] =
+static LLTrace::SampleStatHandle<> sJoystickAxis1("Joystick axis 1"),
+ sJoystickAxis2("Joystick axis 2"),
+ sJoystickAxis3("Joystick axis 3"),
+ sJoystickAxis4("Joystick axis 4"),
+ sJoystickAxis5("Joystick axis 5"),
+ sJoystickAxis6("Joystick axis 6");
+static LLTrace::SampleStatHandle<>* sJoystickAxes[6] =
{
&sJoystickAxis1,
&sJoystickAxis2,
diff --git a/indra/newview/llscenemonitor.cpp b/indra/newview/llscenemonitor.cpp
index 94c2e40bb1d4f74dfbd9d1657dea7d231aad4cab..15f2f6d76240fcccc02a50f141f50e342135eb8f 100644
--- a/indra/newview/llscenemonitor.cpp
+++ b/indra/newview/llscenemonitor.cpp
@@ -462,7 +462,7 @@ void LLSceneMonitor::calcDiffAggregate()
}
}
-static LLTrace::MeasurementStatHandle<> sFramePixelDiff("FramePixelDifference");
+static LLTrace::EventStatHandle<> sFramePixelDiff("FramePixelDifference");
void LLSceneMonitor::fetchQueryResult()
{
LLFastTimer _(FTM_SCENE_LOAD_IMAGE_DIFF);
@@ -481,16 +481,18 @@ void LLSceneMonitor::fetchQueryResult()
mDiffResult = count * 0.5f / (mDiff->getWidth() * mDiff->getHeight() * mDiffPixelRatio * mDiffPixelRatio); //0.5 -> (front face + back face)
LL_DEBUGS("SceneMonitor") << "Frame difference: " << std::setprecision(4) << mDiffResult << LL_ENDL;
- sample(sFramePixelDiff, mDiffResult);
+ record(sFramePixelDiff, mDiffResult);
static LLCachedControl<F32> diff_threshold(gSavedSettings,"SceneLoadingPixelDiffThreshold");
if(mDiffResult > diff_threshold())
{
mRecording->extend();
+ llassert(mRecording->getAcceptedRecording().getLastRecording().getSum(LLStatViewer::FPS));
}
else
{
mRecording->getPotentialRecording().nextPeriod();
+ llassert(mRecording->getPotentialRecording().getLastRecording().getSum(LLStatViewer::FPS));
}
}
}
@@ -503,7 +505,6 @@ void LLSceneMonitor::dumpToFile(std::string file_name)
std::ofstream os(file_name.c_str());
- //total scene loading time
os << std::setprecision(4);
LLTrace::PeriodicRecording& scene_load_recording = mRecording->getAcceptedRecording();
@@ -565,7 +566,7 @@ void LLSceneMonitor::dumpToFile(std::string file_name)
}
}
- for (LLTrace::MeasurementStatHandle<F64>::instance_iter it = LLTrace::MeasurementStatHandle<F64>::beginInstances(), end_it = LLTrace::MeasurementStatHandle<F64>::endInstances();
+ for (LLTrace::EventStatHandle<F64>::instance_iter it = LLTrace::EventStatHandle<F64>::beginInstances(), end_it = LLTrace::EventStatHandle<F64>::endInstances();
it != end_it;
++it)
{
@@ -588,7 +589,53 @@ void LLSceneMonitor::dumpToFile(std::string file_name)
}
}
- for (LLTrace::MeasurementStatHandle<S64>::instance_iter it = LLTrace::MeasurementStatHandle<S64>::beginInstances(), end_it = LLTrace::MeasurementStatHandle<S64>::endInstances();
+ for (LLTrace::EventStatHandle<S64>::instance_iter it = LLTrace::EventStatHandle<S64>::beginInstances(), end_it = LLTrace::EventStatHandle<S64>::endInstances();
+ it != end_it;
+ ++it)
+ {
+ std::ostringstream row;
+ row << it->getName();
+
+ S32 samples = 0;
+
+ for (S32 i = frame_count - 1; i >= 0; --i)
+ {
+ samples += scene_load_recording.getPrevRecording(i).getSampleCount(*it);
+ row << ", " << scene_load_recording.getPrevRecording(i).getMean(*it);
+ }
+
+ row << std::endl;
+
+ if (samples > 0)
+ {
+ os << row.str();
+ }
+ }
+
+ for (LLTrace::SampleStatHandle<F64>::instance_iter it = LLTrace::SampleStatHandle<F64>::beginInstances(), end_it = LLTrace::SampleStatHandle<F64>::endInstances();
+ it != end_it;
+ ++it)
+ {
+ std::ostringstream row;
+ row << it->getName();
+
+ S32 samples = 0;
+
+ for (S32 i = frame_count - 1; i >= 0; --i)
+ {
+ samples += scene_load_recording.getPrevRecording(i).getSampleCount(*it);
+ row << ", " << scene_load_recording.getPrevRecording(i).getMean(*it);
+ }
+
+ row << std::endl;
+
+ if (samples > 0)
+ {
+ os << row.str();
+ }
+ }
+
+ for (LLTrace::SampleStatHandle<S64>::instance_iter it = LLTrace::SampleStatHandle<S64>::beginInstances(), end_it = LLTrace::SampleStatHandle<S64>::endInstances();
it != end_it;
++it)
{
diff --git a/indra/newview/llstartup.cpp b/indra/newview/llstartup.cpp
index f748344cc8596879556abd3d2fcff418821f5238..f060e8933b6cc01b557c552f51247f29a0e14102 100644
--- a/indra/newview/llstartup.cpp
+++ b/indra/newview/llstartup.cpp
@@ -2071,7 +2071,7 @@ bool idle_startup()
if (wearables_time > max_wearables_time())
{
LLNotificationsUtil::add("ClothingLoading");
- add(LLStatViewer::LOADING_WEARABLES_LONG_DELAY, 1);
+ record(LLStatViewer::LOADING_WEARABLES_LONG_DELAY, wearables_time);
LLStartUp::setStartupState( STATE_CLEANUP );
return TRUE;
}
diff --git a/indra/newview/llstatusbar.cpp b/indra/newview/llstatusbar.cpp
index b945ec2318cfb8cff07dac00efddc54c91ea3f08..f3406d9f8da063ee75965dd43f02dc8992c1b641 100644
--- a/indra/newview/llstatusbar.cpp
+++ b/indra/newview/llstatusbar.cpp
@@ -212,7 +212,7 @@ BOOL LLStatusBar::postBuild()
pgp.rect(r);
pgp.follows.flags(FOLLOWS_BOTTOM | FOLLOWS_RIGHT);
pgp.mouse_opaque(false);
- pgp.stat.measurement_stat_float(&LLStatViewer::PACKETS_LOST_PERCENT);
+ pgp.stat.sample_stat_float(&LLStatViewer::PACKETS_LOST_PERCENT);
pgp.units("%");
pgp.min(0.f);
pgp.max(5.f);
diff --git a/indra/newview/lltexturefetch.cpp b/indra/newview/lltexturefetch.cpp
index 8bf7bcc398de7f9928b6d3e974361ede15f920ab..910cb24bb2b682ba7a38829d7529bc353febf79e 100755
--- a/indra/newview/lltexturefetch.cpp
+++ b/indra/newview/lltexturefetch.cpp
@@ -65,8 +65,8 @@
#include "bufferstream.h"
bool LLTextureFetchDebugger::sDebuggerEnabled = false ;
-LLTrace::MeasurementStatHandle<> LLTextureFetch::sCacheHitRate("texture_cache_hits");
-LLTrace::MeasurementStatHandle<> LLTextureFetch::sCacheReadLatency("texture_cache_read_latency");
+LLTrace::SampleStatHandle<> LLTextureFetch::sCacheHitRate("texture_cache_hits");
+LLTrace::SampleStatHandle<> LLTextureFetch::sCacheReadLatency("texture_cache_read_latency");
//////////////////////////////////////////////////////////////////////////////
@@ -1833,7 +1833,7 @@ void LLTextureFetchWorker::onCompleted(LLCore::HttpHandle handle, LLCore::HttpRe
if (log_to_viewer_log || log_to_sim)
{
U64 timeNow = LLTimer::getTotalTime();
- mFetcher->mTextureInfo.setRequestStartTime(mID, mMetricsStartTime);
+ mFetcher->mTextureInfo.setRequestStartTime(mID, mMetricsStartTime.value());
mFetcher->mTextureInfo.setRequestType(mID, LLTextureInfoDetails::REQUEST_TYPE_HTTP);
mFetcher->mTextureInfo.setRequestSize(mID, mRequestedSize);
mFetcher->mTextureInfo.setRequestOffset(mID, mRequestedOffset);
@@ -2278,7 +2278,7 @@ bool LLTextureFetchWorker::writeToCacheComplete()
// Threads: Ttf
void LLTextureFetchWorker::recordTextureStart(bool is_http)
{
- if (! mMetricsStartTime)
+ if (! mMetricsStartTime.value())
{
mMetricsStartTime = LLViewerAssetStatsFF::get_timestamp();
}
@@ -2291,7 +2291,7 @@ void LLTextureFetchWorker::recordTextureStart(bool is_http)
// Threads: Ttf
void LLTextureFetchWorker::recordTextureDone(bool is_http)
{
- if (mMetricsStartTime)
+ if (mMetricsStartTime.value())
{
LLViewerAssetStatsFF::record_response(LLViewerAssetType::AT_TEXTURE,
is_http,
diff --git a/indra/newview/lltexturefetch.h b/indra/newview/lltexturefetch.h
index 4dcb9dd4b82698b6b3ea266db715e3e7e65b185e..573b32c4bd0de09ddaf1ea5fc15efb21330000bb 100644
--- a/indra/newview/lltexturefetch.h
+++ b/indra/newview/lltexturefetch.h
@@ -308,8 +308,8 @@ class LLTextureFetch : public LLWorkerThread
LLMutex mQueueMutex; //to protect mRequestMap and mCommands only
LLMutex mNetworkQueueMutex; //to protect mNetworkQueue, mHTTPTextureQueue and mCancelQueue.
- static LLTrace::MeasurementStatHandle<> sCacheHitRate;
- static LLTrace::MeasurementStatHandle<> sCacheReadLatency;
+ static LLTrace::SampleStatHandle<> sCacheHitRate;
+ static LLTrace::SampleStatHandle<> sCacheReadLatency;
LLTextureCache* mTextureCache;
LLImageDecodeThread* mImageDecodeThread;
diff --git a/indra/newview/llviewerassetstats.cpp b/indra/newview/llviewerassetstats.cpp
index 8623af52ff184807909257228dc104adbd73e426..0bbf2cbbea292c5da440a3e40412cc8b7ed2a3ef 100644
--- a/indra/newview/llviewerassetstats.cpp
+++ b/indra/newview/llviewerassetstats.cpp
@@ -233,7 +233,7 @@ namespace LLViewerAssetStatsFF
&sDequeuedAssetRequestsOther
};
- static LLTrace::MeasurementStatHandle<LLTrace::Seconds> sResponseAssetRequestsTempTextureHTTP ("assetresponsetimestemptexturehttp",
+ static LLTrace::EventStatHandle<LLTrace::Seconds> sResponseAssetRequestsTempTextureHTTP ("assetresponsetimestemptexturehttp",
"Time spent responding to temporary texture asset http requests"),
sResponseAssetRequestsTempTextureUDP ("assetresponsetimestemptextureudp",
"Time spent responding to temporary texture asset udp requests"),
@@ -250,7 +250,7 @@ namespace LLViewerAssetStatsFF
sResponsedAssetRequestsOther ("assetresponsetimesother",
"Time spent responding to other asset requests");
- static LLTrace::MeasurementStatHandle<LLTrace::Seconds>* sResponse[EVACCount] = {
+ static LLTrace::EventStatHandle<LLTrace::Seconds>* sResponse[EVACCount] = {
&sResponseAssetRequestsTempTextureHTTP,
&sResponseAssetRequestsTempTextureUDP,
&sResponseAssetRequestsNonTempTextureHTTP,
@@ -283,7 +283,6 @@ LLViewerAssetStats::LLViewerAssetStats(const LLViewerAssetStats & src)
mPhaseStats(src.mPhaseStats),
mAvatarRezStates(src.mAvatarRezStates)
{
- src.mCurRecording->update();
mRegionRecordings = src.mRegionRecordings;
mCurRecording = &mRegionRecordings[mRegionHandle];
@@ -485,7 +484,7 @@ void LLViewerAssetStats::getStats(AssetStats& stats, bool compact_output)
.resp_mean(rec.getMean(*sResponse[EVACOtherGet]).value());
}
- S32 fps = (S32)rec.getSum(LLStatViewer::FPS_SAMPLE);
+ S32 fps = (S32)rec.getLastValue(LLStatViewer::FPS_SAMPLE);
if (!compact_output || fps != 0)
{
r.fps.count(fps);
@@ -561,7 +560,7 @@ void record_response(LLViewerAssetType::EType at, bool with_http, bool is_temp,
{
const EViewerAssetCategories eac(asset_type_to_category(at, with_http, is_temp));
- sample(*sResponse[int(eac)], LLTrace::Microseconds(duration));
+ record(*sResponse[int(eac)], LLTrace::Microseconds(duration));
}
void record_avatar_stats()
diff --git a/indra/newview/llviewerassetstats.h b/indra/newview/llviewerassetstats.h
index 56eaa13df9bdfb8365fe67cd2a003ebb2a147f3e..af99710acac75e36e08fc47ef15bd07892a66a1e 100644
--- a/indra/newview/llviewerassetstats.h
+++ b/indra/newview/llviewerassetstats.h
@@ -83,7 +83,7 @@ class LLViewerAssetStats : public LLStopWatchControlsMixin<LLViewerAssetStats>
* for compatibility with the pre-existing timestamp on the texture
* fetcher class, LLTextureFetch.
*/
- typedef U64 duration_t;
+ typedef LLUnit<LLUnits::Microseconds, U64> duration_t;
/**
* Type for the region identifier used in stats. Currently uses
diff --git a/indra/newview/llviewerassetstorage.cpp b/indra/newview/llviewerassetstorage.cpp
index 6f41abbd8a89fee5c48065ede0d60d5508dba92a..5c2dd20ec377c66dbeb44b0d1657d97feaa60092 100644
--- a/indra/newview/llviewerassetstorage.cpp
+++ b/indra/newview/llviewerassetstorage.cpp
@@ -69,7 +69,7 @@ class LLViewerAssetRequest : public LLAssetRequest
protected:
void recordMetrics()
{
- if (mMetricsStartTime)
+ if (mMetricsStartTime.value())
{
// Okay, it appears this request was used for useful things. Record
// the expected dequeue and duration of request processing.
diff --git a/indra/newview/llviewerobject.cpp b/indra/newview/llviewerobject.cpp
index 50b14183c7a6ce55ce6b66a0174b01189783a9d9..d9129181298197cdc2e5f40c4df60f938601c656 100644
--- a/indra/newview/llviewerobject.cpp
+++ b/indra/newview/llviewerobject.cpp
@@ -2222,7 +2222,7 @@ U32 LLViewerObject::processUpdateMessage(LLMessageSystem *mesgsys,
// If we're snapping the position by more than 0.5m, update LLViewerStats::mAgentPositionSnaps
if ( asAvatar() && asAvatar()->isSelf() && (mag_sqr > 0.25f) )
{
- sample(LLStatViewer::AGENT_POSITION_SNAP, LLTrace::Meters(diff.length()));
+ record(LLStatViewer::AGENT_POSITION_SNAP, LLTrace::Meters(diff.length()));
}
}
diff --git a/indra/newview/llviewerobjectlist.cpp b/indra/newview/llviewerobjectlist.cpp
index 6ffd3d8fa4215a8c556faac123ce991d73e9511f..c6ac7af93cdd1dcc328aa066b9c220ac1468292c 100644
--- a/indra/newview/llviewerobjectlist.cpp
+++ b/indra/newview/llviewerobjectlist.cpp
@@ -95,7 +95,7 @@ extern LLPipeline gPipeline;
U32 LLViewerObjectList::sSimulatorMachineIndex = 1; // Not zero deliberately, to speed up index check.
std::map<U64, U32> LLViewerObjectList::sIPAndPortToIndex;
std::map<U64, LLUUID> LLViewerObjectList::sIndexAndLocalIDToUUID;
-LLTrace::MeasurementStatHandle<> LLViewerObjectList::sCacheHitRate("object_cache_hits");
+LLTrace::SampleStatHandle<> LLViewerObjectList::sCacheHitRate("object_cache_hits");
LLViewerObjectList::LLViewerObjectList()
{
diff --git a/indra/newview/llviewerobjectlist.h b/indra/newview/llviewerobjectlist.h
index 65447156e7972d56ccd8ce75c4e02fc84dbb489f..464554245e5f55f5c23abdbcf634f5effdf008f9 100644
--- a/indra/newview/llviewerobjectlist.h
+++ b/indra/newview/llviewerobjectlist.h
@@ -198,7 +198,7 @@ class LLViewerObjectList
std::vector<OrphanInfo> mOrphanChildren; // UUID's of orphaned objects
S32 mNumOrphans;
- static LLTrace::MeasurementStatHandle<> sCacheHitRate;
+ static LLTrace::SampleStatHandle<> sCacheHitRate;
typedef std::vector<LLPointer<LLViewerObject> > vobj_list_t;
diff --git a/indra/newview/llviewerstats.cpp b/indra/newview/llviewerstats.cpp
index e8196e965578755a06cf77dd4cd54c974394924f..635611c02e67d40004390bcad36196e48254fc27 100644
--- a/indra/newview/llviewerstats.cpp
+++ b/indra/newview/llviewerstats.cpp
@@ -74,7 +74,6 @@ LLTrace::CountStatHandle<> FPS("framesrendered"),
IM_COUNT("imcount", "IMs sent"),
OBJECT_CREATE("objectcreate"),
OBJECT_REZ("objectrez", "Object rez count"),
- LOADING_WEARABLES_LONG_DELAY("loadingwearableslongdelay", "Wearables took too long to load"),
LOGIN_TIMEOUTS("logintimeouts", "Number of login attempts that timed out"),
LSL_SAVES("lslsaves", "Number of times user has saved a script"),
ANIMATION_UPLOADS("animationuploads", "Animations uploaded"),
@@ -98,13 +97,7 @@ LLTrace::CountStatHandle<LLTrace::Kilobits> KBIT("kbitstat"),
ACTUAL_IN_KBIT("actualinkbitstat"),
ACTUAL_OUT_KBIT("actualoutkbitstat");
-LLTrace::CountStatHandle<LLTrace::Seconds> AVATAR_EDIT_TIME("avataredittime", "Seconds in Edit Appearence"),
- TOOLBOX_TIME("toolboxtime", "Seconds using Toolbox"),
- MOUSELOOK_TIME("mouselooktime", "Seconds in Mouselook"),
- FPS_10_TIME("fps10time", "Seconds below 10 FPS"),
- FPS_8_TIME("fps8time", "Seconds below 8 FPS"),
- FPS_2_TIME("fps2time", "Seconds below 2 FPS"),
- SIM_20_FPS_TIME("sim20fpstime", "Seconds with sim FPS below 20"),
+LLTrace::CountStatHandle<LLTrace::Seconds> SIM_20_FPS_TIME("sim20fpstime", "Seconds with sim FPS below 20"),
SIM_PHYSICS_20_FPS_TIME("simphysics20fpstime", "Seconds with physics FPS below 20"),
LOSS_5_PERCENT_TIME("loss5percenttime", "Seconds with packet loss > 5%");
@@ -129,36 +122,34 @@ SimMeasurement<> SIM_TIME_DILATION("simtimedilation", "", LL_SIM_STAT_TIME_DIL
SIM_PHYSICS_PINNED_TASKS("physicspinnedtasks", "", LL_SIM_STAT_PHYSICS_PINNED_TASKS),
SIM_PHYSICS_LOD_TASKS("physicslodtasks", "", LL_SIM_STAT_PHYSICS_LOD_TASKS);
-LLTrace::MeasurementStatHandle<> FPS_SAMPLE("fpssample"),
- NUM_IMAGES("numimagesstat"),
- NUM_RAW_IMAGES("numrawimagesstat"),
- NUM_OBJECTS("numobjectsstat"),
- NUM_ACTIVE_OBJECTS("numactiveobjectsstat"),
- NUM_SIZE_CULLED("numsizeculledstat"),
- NUM_VIS_CULLED("numvisculledstat"),
- ENABLE_VBO("enablevbo", "Vertex Buffers Enabled"),
- LIGHTING_DETAIL("lightingdetail", "Lighting Detail"),
- VISIBLE_AVATARS("visibleavatars", "Visible Avatars"),
- SHADER_OBJECTS("shaderobjects", "Object Shaders"),
- DRAW_DISTANCE("drawdistance", "Draw Distance"),
- CHAT_BUBBLES("chatbubbles", "Chat Bubbles Enabled"),
- PENDING_VFS_OPERATIONS("vfspendingoperations"),
- PACKETS_LOST_PERCENT("packetslostpercentstat"),
- WINDOW_WIDTH("windowwidth", "Window width"),
- WINDOW_HEIGHT("windowheight", "Window height");
+LLTrace::SampleStatHandle<> FPS_SAMPLE("fpssample"),
+ NUM_IMAGES("numimagesstat"),
+ NUM_RAW_IMAGES("numrawimagesstat"),
+ NUM_OBJECTS("numobjectsstat"),
+ NUM_ACTIVE_OBJECTS("numactiveobjectsstat"),
+ NUM_SIZE_CULLED("numsizeculledstat"),
+ NUM_VIS_CULLED("numvisculledstat"),
+ ENABLE_VBO("enablevbo", "Vertex Buffers Enabled"),
+ LIGHTING_DETAIL("lightingdetail", "Lighting Detail"),
+ VISIBLE_AVATARS("visibleavatars", "Visible Avatars"),
+ SHADER_OBJECTS("shaderobjects", "Object Shaders"),
+ DRAW_DISTANCE("drawdistance", "Draw Distance"),
+ PENDING_VFS_OPERATIONS("vfspendingoperations"),
+ PACKETS_LOST_PERCENT("packetslostpercentstat"),
+ WINDOW_WIDTH("windowwidth", "Window width"),
+ WINDOW_HEIGHT("windowheight", "Window height");
-LLTrace::MeasurementStatHandle<LLTrace::Meters> AGENT_POSITION_SNAP("agentpositionsnap", "agent position corrections");
+static LLTrace::SampleStatHandle<S64> CHAT_BUBBLES("chatbubbles", "Chat Bubbles Enabled");
-
-LLTrace::MeasurementStatHandle<LLTrace::Bytes> GL_TEX_MEM("gltexmemstat"),
- GL_BOUND_MEM("glboundmemstat"),
- RAW_MEM("rawmemstat"),
- FORMATTED_MEM("formattedmemstat"),
- DELTA_BANDWIDTH("deltabandwidth", "Increase/Decrease in bandwidth based on packet loss"),
- MAX_BANDWIDTH("maxbandwidth", "Max bandwidth setting");
+LLTrace::SampleStatHandle<LLTrace::Bytes> GL_TEX_MEM("gltexmemstat"),
+ GL_BOUND_MEM("glboundmemstat"),
+ RAW_MEM("rawmemstat"),
+ FORMATTED_MEM("formattedmemstat"),
+ DELTA_BANDWIDTH("deltabandwidth", "Increase/Decrease in bandwidth based on packet loss"),
+ MAX_BANDWIDTH("maxbandwidth", "Max bandwidth setting");
-SimMeasurement<LLTrace::Milliseconds> SIM_FRAME_TIME("simframemsec", "", LL_SIM_STAT_FRAMEMS),
+SimMeasurement<LLTrace::Milliseconds> SIM_FRAME_TIME("simframemsec", "", LL_SIM_STAT_FRAMEMS),
SIM_NET_TIME("simnetmsec", "", LL_SIM_STAT_NETMS),
SIM_OTHER_TIME("simsimothermsec", "", LL_SIM_STAT_SIMOTHERMS),
SIM_PHYSICS_TIME("simsimphysicsmsec", "", LL_SIM_STAT_SIMPHYSICSMS),
@@ -173,21 +164,32 @@ SimMeasurement<LLTrace::Milliseconds> SIM_FRAME_TIME("simframemsec", "", LL_SIM_
SIM_SLEEP_TIME("simsleepmsec", "", LL_SIM_STAT_SIMSLEEPTIME),
SIM_PUMP_IO_TIME("simpumpiomsec", "", LL_SIM_STAT_IOPUMPTIME);
-SimMeasurement<LLTrace::Bytes> SIM_UNACKED_BYTES("simtotalunackedbytes", "", LL_SIM_STAT_TOTAL_UNACKED_BYTES),
+SimMeasurement<LLTrace::Bytes> SIM_UNACKED_BYTES("simtotalunackedbytes", "", LL_SIM_STAT_TOTAL_UNACKED_BYTES),
SIM_PHYSICS_MEM("physicsmemoryallocated", "", LL_SIM_STAT_SIMPHYSICSMEMORY);
+LLTrace::SampleStatHandle<LLTrace::Milliseconds> FRAMETIME_JITTER("frametimejitter", "Average delta between successive frame times"),
+ FRAMETIME_SLEW("frametimeslew", "Average delta between frame time and mean"),
+ SIM_PING("simpingstat");
+
+LLTrace::EventStatHandle<LLTrace::Meters> AGENT_POSITION_SNAP("agentpositionsnap", "agent position corrections");
+
+LLTrace::EventStatHandle<> LOADING_WEARABLES_LONG_DELAY("loadingwearableslongdelay", "Wearables took too long to load");
+
+LLTrace::EventStatHandle<LLTrace::Milliseconds> REGION_CROSSING_TIME("regioncrossingtime", "CROSSING_AVG"),
+ FRAME_STACKTIME("framestacktime", "FRAME_SECS"),
+ UPDATE_STACKTIME("updatestacktime", "UPDATE_SECS"),
+ NETWORK_STACKTIME("networkstacktime", "NETWORK_SECS"),
+ IMAGE_STACKTIME("imagestacktime", "IMAGE_SECS"),
+ REBUILD_STACKTIME("rebuildstacktime", "REBUILD_SECS"),
+ RENDER_STACKTIME("renderstacktime", "RENDER_SECS");
+
+LLTrace::EventStatHandle<LLTrace::Seconds> AVATAR_EDIT_TIME("avataredittime", "Seconds in Edit Appearance"),
+ TOOLBOX_TIME("toolboxtime", "Seconds using Toolbox"),
+ MOUSELOOK_TIME("mouselooktime", "Seconds in Mouselook"),
+ FPS_10_TIME("fps10time", "Seconds below 10 FPS"),
+ FPS_8_TIME("fps8time", "Seconds below 8 FPS"),
+ FPS_2_TIME("fps2time", "Seconds below 2 FPS");
-LLTrace::MeasurementStatHandle<LLTrace::Milliseconds> FRAMETIME_JITTER("frametimejitter", "Average delta between successive frame times"),
- FRAMETIME_SLEW("frametimeslew", "Average delta between frame time and mean"),
- LOGIN_SECONDS("loginseconds", "Time between LoginRequest and LoginReply"),
- REGION_CROSSING_TIME("regioncrossingtime", "CROSSING_AVG"),
- FRAME_STACKTIME("framestacktime", "FRAME_SECS"),
- UPDATE_STACKTIME("updatestacktime", "UPDATE_SECS"),
- NETWORK_STACKTIME("networkstacktime", "NETWORK_SECS"),
- IMAGE_STACKTIME("imagestacktime", "IMAGE_SECS"),
- REBUILD_STACKTIME("rebuildstacktime", "REBUILD_SECS"),
- RENDER_STACKTIME("renderstacktime", "RENDER_SECS"),
- SIM_PING("simpingstat");
}
@@ -230,15 +232,15 @@ void LLViewerStats::updateFrameStats(const F64 time_diff)
if (time_diff >= 0.5)
{
- add(LLStatViewer::FPS_2_TIME, time_diff_seconds);
+ record(LLStatViewer::FPS_2_TIME, time_diff_seconds);
}
if (time_diff >= 0.125)
{
- add(LLStatViewer::FPS_8_TIME, time_diff_seconds);
+ record(LLStatViewer::FPS_8_TIME, time_diff_seconds);
}
if (time_diff >= 0.1)
{
- add(LLStatViewer::FPS_10_TIME, time_diff_seconds);
+ record(LLStatViewer::FPS_10_TIME, time_diff_seconds);
}
if (gFrameCount && mLastTimeDiff > 0.0)
@@ -311,35 +313,36 @@ void update_statistics()
{
if (gAgentCamera.getCameraMode() == CAMERA_MODE_MOUSELOOK)
{
- add(LLStatViewer::MOUSELOOK_TIME, gFrameIntervalSeconds);
+ record(LLStatViewer::MOUSELOOK_TIME, gFrameIntervalSeconds);
}
else if (gAgentCamera.getCameraMode() == CAMERA_MODE_CUSTOMIZE_AVATAR)
{
- add(LLStatViewer::AVATAR_EDIT_TIME, gFrameIntervalSeconds);
+ record(LLStatViewer::AVATAR_EDIT_TIME, gFrameIntervalSeconds);
}
else if (LLFloaterReg::instanceVisible("build"))
{
- add(LLStatViewer::TOOLBOX_TIME, gFrameIntervalSeconds);
+ record(LLStatViewer::TOOLBOX_TIME, gFrameIntervalSeconds);
}
}
LLTrace::Recording& last_frame_recording = LLTrace::get_frame_recording().getLastRecording();
- sample(LLStatViewer::ENABLE_VBO, (F64)gSavedSettings.getBOOL("RenderVBOEnable"));
+ sample(LLStatViewer::ENABLE_VBO, (F64)gSavedSettings.getBOOL("RenderVBOEnable"));
sample(LLStatViewer::LIGHTING_DETAIL, (F64)gPipeline.getLightingDetail());
- sample(LLStatViewer::DRAW_DISTANCE, (F64)gSavedSettings.getF32("RenderFarClip"));
- sample(LLStatViewer::CHAT_BUBBLES, (F64)gSavedSettings.getBOOL("UseChatBubbles"));
+ sample(LLStatViewer::DRAW_DISTANCE, (F64)gSavedSettings.getF32("RenderFarClip"));
+ sample(LLStatViewer::CHAT_BUBBLES, gSavedSettings.getBOOL("UseChatBubbles"));
typedef LLInstanceTracker<LLTrace::TraceType<LLTrace::TimeBlockAccumulator>, std::string> trace_type_t;
- sample(LLStatViewer::FRAME_STACKTIME, last_frame_recording.getSum(*trace_type_t::getInstance("Frame")).as<LLUnits::Seconds>());
LLUnit<LLUnits::Seconds, F64> idle_secs = last_frame_recording.getSum(*trace_type_t::getInstance("Idle"));
LLUnit<LLUnits::Seconds, F64> network_secs = last_frame_recording.getSum(*trace_type_t::getInstance("Network"));
- sample(LLStatViewer::UPDATE_STACKTIME, idle_secs - network_secs);
- sample(LLStatViewer::NETWORK_STACKTIME, network_secs);
- sample(LLStatViewer::IMAGE_STACKTIME, last_frame_recording.getSum(*trace_type_t::getInstance("Update Images")).as<LLUnits::Seconds>());
- sample(LLStatViewer::REBUILD_STACKTIME, last_frame_recording.getSum(*trace_type_t::getInstance("Sort Draw State")).as<LLUnits::Seconds>());
- sample(LLStatViewer::RENDER_STACKTIME, last_frame_recording.getSum(*trace_type_t::getInstance("Render Geometry")).as<LLUnits::Seconds>());
+
+ record(LLStatViewer::FRAME_STACKTIME, last_frame_recording.getSum(*trace_type_t::getInstance("Frame")));
+ record(LLStatViewer::UPDATE_STACKTIME, idle_secs - network_secs);
+ record(LLStatViewer::NETWORK_STACKTIME, network_secs);
+ record(LLStatViewer::IMAGE_STACKTIME, last_frame_recording.getSum(*trace_type_t::getInstance("Update Images")));
+ record(LLStatViewer::REBUILD_STACKTIME, last_frame_recording.getSum(*trace_type_t::getInstance("Sort Draw State")));
+ record(LLStatViewer::RENDER_STACKTIME, last_frame_recording.getSum(*trace_type_t::getInstance("Render Geometry")));
LLCircuitData *cdp = gMessageSystem->mCircuitInfo.findCircuit(gAgent.getRegion()->getHost());
if (cdp)
diff --git a/indra/newview/llviewerstats.h b/indra/newview/llviewerstats.h
index e94ba2316304e5f6922b8605847948d48edbad0b..c0ac6d220f73988aa878dbb4e13038f5bc20f18a 100644
--- a/indra/newview/llviewerstats.h
+++ b/indra/newview/llviewerstats.h
@@ -46,10 +46,10 @@ struct SimMeasurementSampler : public LLInstanceTracker<SimMeasurementSampler, E
};
template<typename T = F64>
-struct SimMeasurement : public LLTrace::MeasurementStatHandle<T>, public SimMeasurementSampler
+struct SimMeasurement : public LLTrace::SampleStatHandle<T>, public SimMeasurementSampler
{
SimMeasurement(const char* name, const char* description, ESimStatID stat_id)
- : LLTrace::MeasurementStatHandle<T>(name, description),
+ : LLTrace::SampleStatHandle<T>(name, description),
SimMeasurementSampler(stat_id)
{}
@@ -66,7 +66,8 @@ void sample(SimMeasurement<T>& measurement, VALUE_T value)
{
LLTrace::sample(measurement, value);
}
-extern LLTrace::CountStatHandle<> FPS,
+
+extern LLTrace::CountStatHandle<> FPS,
PACKETS_IN,
PACKETS_LOST,
PACKETS_OUT,
@@ -76,7 +77,6 @@ extern LLTrace::CountStatHandle<> FPS,
IM_COUNT,
OBJECT_CREATE,
OBJECT_REZ,
- LOADING_WEARABLES_LONG_DELAY,
LOGIN_TIMEOUTS,
LSL_SAVES,
ANIMATION_UPLOADS,
@@ -102,15 +102,9 @@ extern LLTrace::CountStatHandle<LLTrace::Kilobits> KBIT,
ACTUAL_IN_KBIT,
ACTUAL_OUT_KBIT;
-extern LLTrace::CountStatHandle<LLTrace::Seconds> AVATAR_EDIT_TIME,
- TOOLBOX_TIME,
- MOUSELOOK_TIME,
- FPS_10_TIME,
- FPS_8_TIME,
- FPS_2_TIME,
- SIM_20_FPS_TIME,
- SIM_PHYSICS_20_FPS_TIME,
- LOSS_5_PERCENT_TIME;
+extern LLTrace::CountStatHandle<LLTrace::Seconds> SIM_20_FPS_TIME,
+ SIM_PHYSICS_20_FPS_TIME,
+ LOSS_5_PERCENT_TIME;
extern SimMeasurement<> SIM_TIME_DILATION,
SIM_FPS,
@@ -133,32 +127,29 @@ extern SimMeasurement<> SIM_TIME_DILATION,
SIM_PHYSICS_PINNED_TASKS,
SIM_PHYSICS_LOD_TASKS;
-extern LLTrace::MeasurementStatHandle<> FPS_SAMPLE,
- NUM_IMAGES,
- NUM_RAW_IMAGES,
- NUM_OBJECTS,
- NUM_ACTIVE_OBJECTS,
- NUM_SIZE_CULLED,
- NUM_VIS_CULLED,
- ENABLE_VBO,
- LIGHTING_DETAIL,
- VISIBLE_AVATARS,
- SHADER_OBJECTS,
- DRAW_DISTANCE,
- CHAT_BUBBLES,
- PENDING_VFS_OPERATIONS,
- PACKETS_LOST_PERCENT,
- WINDOW_WIDTH,
- WINDOW_HEIGHT;
-
-extern LLTrace::MeasurementStatHandle<LLTrace::Meters> AGENT_POSITION_SNAP;
-
-extern LLTrace::MeasurementStatHandle<LLTrace::Bytes> DELTA_BANDWIDTH,
- MAX_BANDWIDTH,
- GL_TEX_MEM,
- GL_BOUND_MEM,
- RAW_MEM,
- FORMATTED_MEM;
+extern LLTrace::SampleStatHandle<> FPS_SAMPLE,
+ NUM_IMAGES,
+ NUM_RAW_IMAGES,
+ NUM_OBJECTS,
+ NUM_ACTIVE_OBJECTS,
+ NUM_SIZE_CULLED,
+ NUM_VIS_CULLED,
+ ENABLE_VBO,
+ LIGHTING_DETAIL,
+ VISIBLE_AVATARS,
+ SHADER_OBJECTS,
+ DRAW_DISTANCE,
+ PENDING_VFS_OPERATIONS,
+ PACKETS_LOST_PERCENT,
+ WINDOW_WIDTH,
+ WINDOW_HEIGHT;
+
+extern LLTrace::SampleStatHandle<LLTrace::Bytes> DELTA_BANDWIDTH,
+ MAX_BANDWIDTH,
+ GL_TEX_MEM,
+ GL_BOUND_MEM,
+ RAW_MEM,
+ FORMATTED_MEM;
extern SimMeasurement<LLTrace::Milliseconds> SIM_FRAME_TIME,
SIM_NET_TIME,
@@ -179,17 +170,29 @@ extern SimMeasurement<LLTrace::Bytes> SIM_UNACKED_BYTES,
SIM_PHYSICS_MEM;
-extern LLTrace::MeasurementStatHandle<LLTrace::Milliseconds> FRAMETIME_JITTER,
- FRAMETIME_SLEW,
- LOGIN_SECONDS,
- REGION_CROSSING_TIME,
- FRAME_STACKTIME,
- UPDATE_STACKTIME,
- NETWORK_STACKTIME,
- IMAGE_STACKTIME,
- REBUILD_STACKTIME,
- RENDER_STACKTIME,
- SIM_PING;
+extern LLTrace::SampleStatHandle<LLTrace::Milliseconds> FRAMETIME_JITTER,
+ FRAMETIME_SLEW,
+ SIM_PING;
+
+extern LLTrace::EventStatHandle<LLTrace::Meters> AGENT_POSITION_SNAP;
+
+extern LLTrace::EventStatHandle<> LOADING_WEARABLES_LONG_DELAY;
+
+extern LLTrace::EventStatHandle<LLTrace::Milliseconds> REGION_CROSSING_TIME,
+ FRAME_STACKTIME,
+ UPDATE_STACKTIME,
+ NETWORK_STACKTIME,
+ IMAGE_STACKTIME,
+ REBUILD_STACKTIME,
+ RENDER_STACKTIME;
+
+extern LLTrace::EventStatHandle<LLTrace::Seconds> AVATAR_EDIT_TIME,
+ TOOLBOX_TIME,
+ MOUSELOOK_TIME,
+ FPS_10_TIME,
+ FPS_8_TIME,
+ FPS_2_TIME;
+
}
class LLViewerStats : public LLSingleton<LLViewerStats>
diff --git a/indra/newview/llviewerwindow.cpp b/indra/newview/llviewerwindow.cpp
index 08d296b88ec3e06fba01c271d357b69d1f7bf21a..5299e7d2c147fb9c4e90abc4b86af73e139a0ff7 100755
--- a/indra/newview/llviewerwindow.cpp
+++ b/indra/newview/llviewerwindow.cpp
@@ -249,7 +249,7 @@ std::string LLViewerWindow::sSnapshotDir;
std::string LLViewerWindow::sMovieBaseName;
-LLTrace::MeasurementStatHandle<> LLViewerWindow::sMouseVelocityStat("Mouse Velocity");
+LLTrace::SampleStatHandle<> LLViewerWindow::sMouseVelocityStat("Mouse Velocity");
class RecordToChatConsole : public LLError::Recorder, public LLSingleton<RecordToChatConsole>
@@ -456,6 +456,8 @@ class LLDebugText
if (gSavedSettings.getBOOL("DebugShowRenderInfo"))
{
+ LLTrace::Recording& last_frame_recording = LLTrace::get_frame_recording().getLastRecording();
+
if (gPipeline.getUseVertexShaders() == 0)
{
addText(xpos, ypos, "Shaders Disabled");
@@ -561,7 +563,7 @@ class LLDebugText
addText(xpos, ypos, llformat("%d Unique Textures", LLImageGL::sUniqueCount));
ypos += y_inc;
- addText(xpos, ypos, llformat("%d Render Calls", gPipeline.mBatchCount));
+ addText(xpos, ypos, llformat("%d Render Calls", last_frame_recording.getSampleCount(LLPipeline::sStatBatchSize)));
ypos += y_inc;
addText(xpos, ypos, llformat("%d/%d Objects Active", gObjectList.getNumActiveObjects(), gObjectList.getNumObjects()));
@@ -576,15 +578,10 @@ class LLDebugText
gPipeline.mTextureMatrixOps = 0;
gPipeline.mMatrixOpCount = 0;
- if (gPipeline.mBatchCount > 0)
- {
- addText(xpos, ypos, llformat("Batch min/max/mean: %d/%d/%d", gPipeline.mMinBatchSize, gPipeline.mMaxBatchSize,
- gPipeline.mTrianglesDrawn/gPipeline.mBatchCount));
-
- gPipeline.mMinBatchSize = gPipeline.mMaxBatchSize;
- gPipeline.mMaxBatchSize = 0;
- gPipeline.mBatchCount = 0;
- }
+ if (last_frame_recording.getSampleCount(LLPipeline::sStatBatchSize) > 0)
+ {
+ addText(xpos, ypos, llformat("Batch min/max/mean: %d/%d/%d", last_frame_recording.getMin(LLPipeline::sStatBatchSize), last_frame_recording.getMax(LLPipeline::sStatBatchSize), last_frame_recording.getMean(LLPipeline::sStatBatchSize)));
+ }
ypos += y_inc;
addText(xpos, ypos, llformat("UI Verts/Calls: %d/%d", LLRender::sUIVerts, LLRender::sUICalls));
diff --git a/indra/newview/llviewerwindow.h b/indra/newview/llviewerwindow.h
index 004a59fda5141f2f573dea2d3bdaaa09e641c504..9fbb06a41ea89cc4317b0ccfd81c11a085d8fc2e 100644
--- a/indra/newview/llviewerwindow.h
+++ b/indra/newview/llviewerwindow.h
@@ -250,7 +250,7 @@ class LLViewerWindow : public LLWindowCallbacks
S32 getCurrentMouseDX() const { return mCurrentMouseDelta.mX; }
S32 getCurrentMouseDY() const { return mCurrentMouseDelta.mY; }
LLCoordGL getCurrentMouseDelta() const { return mCurrentMouseDelta; }
- static LLTrace::MeasurementStatHandle<>* getMouseVelocityStat() { return &sMouseVelocityStat; }
+ static LLTrace::SampleStatHandle<>* getMouseVelocityStat() { return &sMouseVelocityStat; }
BOOL getLeftMouseDown() const { return mLeftMouseDown; }
BOOL getMiddleMouseDown() const { return mMiddleMouseDown; }
BOOL getRightMouseDown() const { return mRightMouseDown; }
@@ -482,7 +482,7 @@ class LLViewerWindow : public LLWindowCallbacks
// Object temporarily hovered over while dragging
LLPointer<LLViewerObject> mDragHoveredObject;
- static LLTrace::MeasurementStatHandle<> sMouseVelocityStat;
+ static LLTrace::SampleStatHandle<> sMouseVelocityStat;
};
//
diff --git a/indra/newview/llvoavatarself.cpp b/indra/newview/llvoavatarself.cpp
index 69f998f0f3e9dd9dcbd41c980c0bc17669096030..b6f48b4a664522f8da600bef2d23c1b4f6fe51c0 100644
--- a/indra/newview/llvoavatarself.cpp
+++ b/indra/newview/llvoavatarself.cpp
@@ -914,7 +914,7 @@ void LLVOAvatarSelf::updateRegion(LLViewerRegion *regionp)
{
++mRegionCrossingCount;
LLTrace::Seconds delta = mRegionCrossingTimer.getElapsedTimeF32();
- sample(LLStatViewer::REGION_CROSSING_TIME, delta);
+ record(LLStatViewer::REGION_CROSSING_TIME, delta);
// Diagnostics
llinfos << "Region crossing took " << (F32)(delta * 1000.0).value() << " ms " << llendl;
diff --git a/indra/newview/pipeline.cpp b/indra/newview/pipeline.cpp
index 3f6269e7683d5a940e33c6b4d32ed6dfcbae5091..6a0ef13894bcf5c7a7e19ed25ffecc69c415dd38 100644
--- a/indra/newview/pipeline.cpp
+++ b/indra/newview/pipeline.cpp
@@ -198,6 +198,7 @@ BOOL LLPipeline::CameraOffset;
F32 LLPipeline::CameraMaxCoF;
F32 LLPipeline::CameraDoFResScale;
F32 LLPipeline::RenderAutoHideSurfaceAreaLimit;
+LLTrace::EventStatHandle<S64> LLPipeline::sStatBatchSize("renderbatchsize");
const F32 BACKLIGHT_DAY_MAGNITUDE_AVATAR = 0.2f;
const F32 BACKLIGHT_NIGHT_MAGNITUDE_AVATAR = 0.1f;
@@ -403,17 +404,9 @@ bool addDeferredAttachments(LLRenderTarget& target)
LLPipeline::LLPipeline() :
mBackfaceCull(FALSE),
- mBatchCount(0),
mMatrixOpCount(0),
mTextureMatrixOps(0),
- mMaxBatchSize(0),
- mMinBatchSize(0),
- mMeanBatchSize(0),
- mTrianglesDrawn(0),
mNumVisibleNodes(0),
- mVerticesRelit(0),
- mLightingChanges(0),
- mGeometryChanges(0),
mNumVisibleFaces(0),
mInitialized(FALSE),
@@ -1809,17 +1802,7 @@ void LLPipeline::resetFrameStats()
{
assertInitialized();
- add(LLStatViewer::TRIANGLES_DRAWN, mTrianglesDrawn);
-
- if (mBatchCount > 0)
- {
- mMeanBatchSize = gPipeline.mTrianglesDrawn/gPipeline.mBatchCount;
- }
- mTrianglesDrawn = 0;
sCompiles = 0;
- mVerticesRelit = 0;
- mLightingChanges = 0;
- mGeometryChanges = 0;
mNumVisibleFaces = 0;
if (mOldRenderDebugMask != mRenderDebugMask)
@@ -1827,7 +1810,6 @@ void LLPipeline::resetFrameStats()
gObjectList.clearDebugText();
mOldRenderDebugMask = mRenderDebugMask;
}
-
}
//external functions for asynchronous updating
@@ -2585,7 +2567,6 @@ BOOL LLPipeline::updateDrawableGeom(LLDrawable* drawablep, BOOL priority)
if (update_complete && assertInitialized())
{
drawablep->setState(LLDrawable::BUILT);
- mGeometryChanges++;
}
return update_complete;
}
@@ -3347,7 +3328,6 @@ void LLPipeline::stateSort(LLDrawable* drawablep, LLCamera& camera)
}
}
-
mNumVisibleFaces += drawablep->getNumFaces();
}
@@ -4516,10 +4496,8 @@ void LLPipeline::addTrianglesDrawn(S32 index_count, U32 render_type)
count = index_count/3;
}
- mTrianglesDrawn += count;
- mBatchCount++;
- mMaxBatchSize = llmax(mMaxBatchSize, count);
- mMinBatchSize = llmin(mMinBatchSize, count);
+ record(sStatBatchSize, count);
+ add(LLStatViewer::TRIANGLES_DRAWN, count);
if (LLPipeline::sRenderFrameTest)
{
diff --git a/indra/newview/pipeline.h b/indra/newview/pipeline.h
index 720ddf79f5788cdec994affe86f2aa4ac46fd901..ec976d3ecc3b3a7c95963ec4398304b17b6cc349 100644
--- a/indra/newview/pipeline.h
+++ b/indra/newview/pipeline.h
@@ -492,23 +492,14 @@ class LLPipeline
LLQuaternion mFlyCamRotation;
BOOL mBackfaceCull;
- S32 mBatchCount;
S32 mMatrixOpCount;
S32 mTextureMatrixOps;
- S32 mMaxBatchSize;
- S32 mMinBatchSize;
- S32 mMeanBatchSize;
- S32 mTrianglesDrawn;
S32 mNumVisibleNodes;
- S32 mVerticesRelit;
S32 mDebugTextureUploadCost;
S32 mDebugSculptUploadCost;
S32 mDebugMeshUploadCost;
- S32 mLightingChanges;
- S32 mGeometryChanges;
-
S32 mNumVisibleFaces;
static S32 sCompiles;
@@ -542,6 +533,8 @@ class LLPipeline
static S32 sVisibleLightCount;
static F32 sMinRenderSize;
+ static LLTrace::EventStatHandle<S64> sStatBatchSize;
+
//screen texture
U32 mScreenWidth;
U32 mScreenHeight;