SH-3931 WIP Interesting: Add graphs to visualize scene load metrics

made recordings auto-update when executing query while active

5 files changed, 147 insertions, 108 deletions

diff --git a/indra/llcommon/lltracerecording.cpp b/indra/llcommon/lltracerecording.cpp
index e45639a034..aedb9c7542 100644
--- a/indra/llcommon/lltracerecording.cpp
+++ b/indra/llcommon/lltracerecording.cpp
@@ -221,88 +221,101 @@ void Recording::mergeRecording( const Recording& other)
 	setPlayState(play_state);
 }
 
-LLUnit<LLUnits::Seconds, F64> Recording::getSum(const TraceType<TimeBlockAccumulator>& stat) const
+LLUnit<LLUnits::Seconds, F64> Recording::getSum(const TraceType<TimeBlockAccumulator>& stat)
 {
 	const TimeBlockAccumulator& accumulator = mBuffers->mStackTimers[stat.getIndex()];
+	update();
 	return (F64)(accumulator.mTotalTimeCounter - accumulator.mStartTotalTimeCounter) 
 				/ (F64)LLTrace::TimeBlock::countsPerSecond();
 }
 
-LLUnit<LLUnits::Seconds, F64> Recording::getSum(const TraceType<TimeBlockAccumulator::SelfTimeAspect>& stat) const
+LLUnit<LLUnits::Seconds, F64> Recording::getSum(const TraceType<TimeBlockAccumulator::SelfTimeAspect>& stat)
 {
 	const TimeBlockAccumulator& accumulator = mBuffers->mStackTimers[stat.getIndex()];
+	update();
 	return (F64)(accumulator.mSelfTimeCounter) / (F64)LLTrace::TimeBlock::countsPerSecond();
 }
 
 
-U32 Recording::getSum(const TraceType<TimeBlockAccumulator::CallCountAspect>& stat) const
+U32 Recording::getSum(const TraceType<TimeBlockAccumulator::CallCountAspect>& stat)
 {
+	update();
 	return mBuffers->mStackTimers[stat.getIndex()].mCalls;
 }
 
-LLUnit<LLUnits::Seconds, F64> Recording::getPerSec(const TraceType<TimeBlockAccumulator>& stat) const
+LLUnit<LLUnits::Seconds, F64> Recording::getPerSec(const TraceType<TimeBlockAccumulator>& stat)
 {
 	const TimeBlockAccumulator& accumulator = mBuffers->mStackTimers[stat.getIndex()];
 
+	update();
 	return (F64)(accumulator.mTotalTimeCounter - accumulator.mStartTotalTimeCounter) 
 				/ ((F64)LLTrace::TimeBlock::countsPerSecond() * mElapsedSeconds);
 }
 
-LLUnit<LLUnits::Seconds, F64> Recording::getPerSec(const TraceType<TimeBlockAccumulator::SelfTimeAspect>& stat) const
+LLUnit<LLUnits::Seconds, F64> Recording::getPerSec(const TraceType<TimeBlockAccumulator::SelfTimeAspect>& stat)
 {
 	const TimeBlockAccumulator& accumulator = mBuffers->mStackTimers[stat.getIndex()];
 
+	update();
 	return (F64)(accumulator.mSelfTimeCounter) 
 			/ ((F64)LLTrace::TimeBlock::countsPerSecond() * mElapsedSeconds);
 }
 
-F32 Recording::getPerSec(const TraceType<TimeBlockAccumulator::CallCountAspect>& stat) const
+F32 Recording::getPerSec(const TraceType<TimeBlockAccumulator::CallCountAspect>& stat)
 {
+	update();
 	return (F32)mBuffers->mStackTimers[stat.getIndex()].mCalls / mElapsedSeconds;
 }
 
-LLUnit<LLUnits::Bytes, U32> Recording::getSum(const TraceType<MemStatAccumulator>& stat) const
+LLUnit<LLUnits::Bytes, U32> Recording::getSum(const TraceType<MemStatAccumulator>& stat)
 {
+	update();
 	return mBuffers->mMemStats[stat.getIndex()].mAllocatedCount;
 }
 
-LLUnit<LLUnits::Bytes, F32> Recording::getPerSec(const TraceType<MemStatAccumulator>& stat) const
+LLUnit<LLUnits::Bytes, F32> Recording::getPerSec(const TraceType<MemStatAccumulator>& stat)
 {
+	update();
 	return (F32)mBuffers->mMemStats[stat.getIndex()].mAllocatedCount / mElapsedSeconds;
 }
 
 
-F64 Recording::getSum( const TraceType<CountAccumulator<F64> >& stat ) const
+F64 Recording::getSum( const TraceType<CountAccumulator<F64> >& stat )
 {
+	update();
 	return mBuffers->mCountsFloat[stat.getIndex()].getSum();
 }
 
-S64 Recording::getSum( const TraceType<CountAccumulator<S64> >& stat ) const
+S64 Recording::getSum( const TraceType<CountAccumulator<S64> >& stat )
 {
+	update();
 	return mBuffers->mCounts[stat.getIndex()].getSum();
 }
 
-F64 Recording::getSum( const TraceType<EventAccumulator<F64> >& stat ) const
+F64 Recording::getSum( const TraceType<EventAccumulator<F64> >& stat )
 {
+	update();
 	return (F64)mBuffers->mEventsFloat[stat.getIndex()].getSum();
 }
 
-S64 Recording::getSum( const TraceType<EventAccumulator<S64> >& stat ) const
+S64 Recording::getSum( const TraceType<EventAccumulator<S64> >& stat )
 {
+	update();
 	return (S64)mBuffers->mEvents[stat.getIndex()].getSum();
 }
 
 
 
-F64 Recording::getPerSec( const TraceType<CountAccumulator<F64> >& stat ) const
+F64 Recording::getPerSec( const TraceType<CountAccumulator<F64> >& stat )
 {
+	update();
 	F64 sum = mBuffers->mCountsFloat[stat.getIndex()].getSum();
 	return  (sum != 0.0) 
 		? (sum / mElapsedSeconds)
 		: 0.0;
 }
 
-F64 Recording::getPerSec( const TraceType<CountAccumulator<S64> >& stat ) const
+F64 Recording::getPerSec( const TraceType<CountAccumulator<S64> >& stat )
 {
 	S64 sum = mBuffers->mCounts[stat.getIndex()].getSum();
 	return (sum != 0) 
@@ -310,133 +323,159 @@ F64 Recording::getPerSec( const TraceType<CountAccumulator<S64> >& stat ) const
 		: 0.0;
 }
 
-U32 Recording::getSampleCount( const TraceType<CountAccumulator<F64> >& stat ) const
+U32 Recording::getSampleCount( const TraceType<CountAccumulator<F64> >& stat )
 {
+	update();
 	return mBuffers->mCountsFloat[stat.getIndex()].getSampleCount();
 }
 
-U32 Recording::getSampleCount( const TraceType<CountAccumulator<S64> >& stat ) const
+U32 Recording::getSampleCount( const TraceType<CountAccumulator<S64> >& stat )
 {
+	update();
 	return mBuffers->mCounts[stat.getIndex()].getSampleCount();
 }
 
-F64 Recording::getMin( const TraceType<SampleAccumulator<F64> >& stat ) const
+F64 Recording::getMin( const TraceType<SampleAccumulator<F64> >& stat )
 {
+	update();
 	return mBuffers->mSamplesFloat[stat.getIndex()].getMin();
 }
 
-S64 Recording::getMin( const TraceType<SampleAccumulator<S64> >& stat ) const
+S64 Recording::getMin( const TraceType<SampleAccumulator<S64> >& stat )
 {
+	update();
 	return mBuffers->mSamples[stat.getIndex()].getMin();
 }
 
-F64 Recording::getMax( const TraceType<SampleAccumulator<F64> >& stat ) const
+F64 Recording::getMax( const TraceType<SampleAccumulator<F64> >& stat )
 {
+	update();
 	return mBuffers->mSamplesFloat[stat.getIndex()].getMax();
 }
 
-S64 Recording::getMax( const TraceType<SampleAccumulator<S64> >& stat ) const
+S64 Recording::getMax( const TraceType<SampleAccumulator<S64> >& stat )
 {
+	update();
 	return mBuffers->mSamples[stat.getIndex()].getMax();
 }
 
-F64 Recording::getMean( const TraceType<SampleAccumulator<F64> >& stat ) const
+F64 Recording::getMean( const TraceType<SampleAccumulator<F64> >& stat )
 {
+	update();
 	return mBuffers->mSamplesFloat[stat.getIndex()].getMean();
 }
 
-F64 Recording::getMean( const TraceType<SampleAccumulator<S64> >& stat ) const
+F64 Recording::getMean( const TraceType<SampleAccumulator<S64> >& stat )
 {
+	update();
 	return mBuffers->mSamples[stat.getIndex()].getMean();
 }
 
-F64 Recording::getStandardDeviation( const TraceType<SampleAccumulator<F64> >& stat ) const
+F64 Recording::getStandardDeviation( const TraceType<SampleAccumulator<F64> >& stat )
 {
+	update();
 	return mBuffers->mSamplesFloat[stat.getIndex()].getStandardDeviation();
 }
 
-F64 Recording::getStandardDeviation( const TraceType<SampleAccumulator<S64> >& stat ) const
+F64 Recording::getStandardDeviation( const TraceType<SampleAccumulator<S64> >& stat )
 {
+	update();
 	return mBuffers->mSamples[stat.getIndex()].getStandardDeviation();
 }
 
-F64 Recording::getLastValue( const TraceType<SampleAccumulator<F64> >& stat ) const
+F64 Recording::getLastValue( const TraceType<SampleAccumulator<F64> >& stat )
 {
+	update();
 	return mBuffers->mSamplesFloat[stat.getIndex()].getLastValue();
 }
 
-S64 Recording::getLastValue( const TraceType<SampleAccumulator<S64> >& stat ) const
+S64 Recording::getLastValue( const TraceType<SampleAccumulator<S64> >& stat )
 {
+	update();
 	return mBuffers->mSamples[stat.getIndex()].getLastValue();
 }
 
-U32 Recording::getSampleCount( const TraceType<SampleAccumulator<F64> >& stat ) const
+U32 Recording::getSampleCount( const TraceType<SampleAccumulator<F64> >& stat )
 {
+	update();
 	return mBuffers->mSamplesFloat[stat.getIndex()].getSampleCount();
 }
 
-U32 Recording::getSampleCount( const TraceType<SampleAccumulator<S64> >& stat ) const
+U32 Recording::getSampleCount( const TraceType<SampleAccumulator<S64> >& stat )
 {
+	update();
 	return mBuffers->mSamples[stat.getIndex()].getSampleCount();
 }
 
-F64 Recording::getMin( const TraceType<EventAccumulator<F64> >& stat ) const
+F64 Recording::getMin( const TraceType<EventAccumulator<F64> >& stat )
 {
+	update();
 	return mBuffers->mEventsFloat[stat.getIndex()].getMin();
 }
 
-S64 Recording::getMin( const TraceType<EventAccumulator<S64> >& stat ) const
+S64 Recording::getMin( const TraceType<EventAccumulator<S64> >& stat )
 {
+	update();
 	return mBuffers->mEvents[stat.getIndex()].getMin();
 }
 
-F64 Recording::getMax( const TraceType<EventAccumulator<F64> >& stat ) const
+F64 Recording::getMax( const TraceType<EventAccumulator<F64> >& stat )
 {
+	update();
 	return mBuffers->mEventsFloat[stat.getIndex()].getMax();
 }
 
-S64 Recording::getMax( const TraceType<EventAccumulator<S64> >& stat ) const
+S64 Recording::getMax( const TraceType<EventAccumulator<S64> >& stat )
 {
+	update();
 	return mBuffers->mEvents[stat.getIndex()].getMax();
 }
 
-F64 Recording::getMean( const TraceType<EventAccumulator<F64> >& stat ) const
+F64 Recording::getMean( const TraceType<EventAccumulator<F64> >& stat )
 {
+	update();
 	return mBuffers->mEventsFloat[stat.getIndex()].getMean();
 }
 
-F64 Recording::getMean( const TraceType<EventAccumulator<S64> >& stat ) const
+F64 Recording::getMean( const TraceType<EventAccumulator<S64> >& stat )
 {
+	update();
 	return mBuffers->mEvents[stat.getIndex()].getMean();
 }
 
-F64 Recording::getStandardDeviation( const TraceType<EventAccumulator<F64> >& stat ) const
+F64 Recording::getStandardDeviation( const TraceType<EventAccumulator<F64> >& stat )
 {
+	update();
 	return mBuffers->mEventsFloat[stat.getIndex()].getStandardDeviation();
 }
 
-F64 Recording::getStandardDeviation( const TraceType<EventAccumulator<S64> >& stat ) const
+F64 Recording::getStandardDeviation( const TraceType<EventAccumulator<S64> >& stat )
 {
+	update();
 	return mBuffers->mEvents[stat.getIndex()].getStandardDeviation();
 }
 
-F64 Recording::getLastValue( const TraceType<EventAccumulator<F64> >& stat ) const
+F64 Recording::getLastValue( const TraceType<EventAccumulator<F64> >& stat )
 {
+	update();
 	return mBuffers->mEventsFloat[stat.getIndex()].getLastValue();
 }
 
-S64 Recording::getLastValue( const TraceType<EventAccumulator<S64> >& stat ) const
+S64 Recording::getLastValue( const TraceType<EventAccumulator<S64> >& stat )
 {
+	update();
 	return mBuffers->mEvents[stat.getIndex()].getLastValue();
 }
 
-U32 Recording::getSampleCount( const TraceType<EventAccumulator<F64> >& stat ) const
+U32 Recording::getSampleCount( const TraceType<EventAccumulator<F64> >& stat )
 {
+	update();
 	return mBuffers->mEventsFloat[stat.getIndex()].getSampleCount();
 }
 
-U32 Recording::getSampleCount( const TraceType<EventAccumulator<S64> >& stat ) const
+U32 Recording::getSampleCount( const TraceType<EventAccumulator<S64> >& stat )
 {
+	update();
 	return mBuffers->mEvents[stat.getIndex()].getSampleCount();
 }
 
diff --git a/indra/llcommon/lltracerecording.h b/indra/llcommon/lltracerecording.h
index 4a77dfb1f6..58b40fa378 100644
--- a/indra/llcommon/lltracerecording.h
+++ b/indra/llcommon/lltracerecording.h
@@ -151,134 +151,134 @@ namespace LLTrace
 		void makeUnique() { mBuffers.makeUnique(); }
 
 		// Timer accessors
-		LLUnit<LLUnits::Seconds, F64> getSum(const TraceType<TimeBlockAccumulator>& stat) const;
-		LLUnit<LLUnits::Seconds, F64> getSum(const TraceType<TimeBlockAccumulator::SelfTimeAspect>& stat) const;
-		U32 getSum(const TraceType<TimeBlockAccumulator::CallCountAspect>& stat) const;
+		LLUnit<LLUnits::Seconds, F64> getSum(const TraceType<TimeBlockAccumulator>& stat);
+		LLUnit<LLUnits::Seconds, F64> getSum(const TraceType<TimeBlockAccumulator::SelfTimeAspect>& stat);
+		U32 getSum(const TraceType<TimeBlockAccumulator::CallCountAspect>& stat);
 
-		LLUnit<LLUnits::Seconds, F64> getPerSec(const TraceType<TimeBlockAccumulator>& stat) const;
-		LLUnit<LLUnits::Seconds, F64> getPerSec(const TraceType<TimeBlockAccumulator::SelfTimeAspect>& stat) const;
-		F32 getPerSec(const TraceType<TimeBlockAccumulator::CallCountAspect>& stat) const;
+		LLUnit<LLUnits::Seconds, F64> getPerSec(const TraceType<TimeBlockAccumulator>& stat);
+		LLUnit<LLUnits::Seconds, F64> getPerSec(const TraceType<TimeBlockAccumulator::SelfTimeAspect>& stat);
+		F32 getPerSec(const TraceType<TimeBlockAccumulator::CallCountAspect>& stat);
 
 		// Memory accessors
-		LLUnit<LLUnits::Bytes, U32> getSum(const TraceType<MemStatAccumulator>& stat) const;
-		LLUnit<LLUnits::Bytes, F32> getPerSec(const TraceType<MemStatAccumulator>& stat) const;
+		LLUnit<LLUnits::Bytes, U32> getSum(const TraceType<MemStatAccumulator>& stat);
+		LLUnit<LLUnits::Bytes, F32> getPerSec(const TraceType<MemStatAccumulator>& stat);
 
 		// CountStatHandle accessors
-		F64 getSum(const TraceType<CountAccumulator<F64> >& stat) const;
-		S64 getSum(const TraceType<CountAccumulator<S64> >& stat) const;
+		F64 getSum(const TraceType<CountAccumulator<F64> >& stat);
+		S64 getSum(const TraceType<CountAccumulator<S64> >& stat);
 		template <typename T>
-		T getSum(const CountStatHandle<T>& stat) const
+		T getSum(const CountStatHandle<T>& stat)
 		{
 			return (T)getSum(static_cast<const TraceType<CountAccumulator<typename LLUnits::HighestPrecisionType<T>::type_t> >&> (stat));
 		}
 
-		F64 getPerSec(const TraceType<CountAccumulator<F64> >& stat) const;
-		F64 getPerSec(const TraceType<CountAccumulator<S64> >& stat) const;
+		F64 getPerSec(const TraceType<CountAccumulator<F64> >& stat);
+		F64 getPerSec(const TraceType<CountAccumulator<S64> >& stat);
 		template <typename T>
-		T getPerSec(const CountStatHandle<T>& stat) const
+		T getPerSec(const CountStatHandle<T>& stat)
 		{
 			return (T)getPerSec(static_cast<const TraceType<CountAccumulator<typename LLUnits::HighestPrecisionType<T>::type_t> >&> (stat));
 		}
 
-		U32 getSampleCount(const TraceType<CountAccumulator<F64> >& stat) const;
-		U32 getSampleCount(const TraceType<CountAccumulator<S64> >& stat) const;
+		U32 getSampleCount(const TraceType<CountAccumulator<F64> >& stat);
+		U32 getSampleCount(const TraceType<CountAccumulator<S64> >& stat);
 
 
 		// SampleStatHandle accessors
-		F64 getMin(const TraceType<SampleAccumulator<F64> >& stat) const;
-		S64 getMin(const TraceType<SampleAccumulator<S64> >& stat) const;
+		F64 getMin(const TraceType<SampleAccumulator<F64> >& stat);
+		S64 getMin(const TraceType<SampleAccumulator<S64> >& stat);
 		template <typename T>
-		T getMin(const SampleStatHandle<T>& stat) const
+		T getMin(const SampleStatHandle<T>& stat)
 		{
 			return (T)getMin(static_cast<const TraceType<SampleAccumulator<typename LLUnits::HighestPrecisionType<T>::type_t> >&> (stat));
 		}
 
-		F64 getMax(const TraceType<SampleAccumulator<F64> >& stat) const;
-		S64 getMax(const TraceType<SampleAccumulator<S64> >& stat) const;
+		F64 getMax(const TraceType<SampleAccumulator<F64> >& stat);
+		S64 getMax(const TraceType<SampleAccumulator<S64> >& stat);
 		template <typename T>
-		T getMax(const SampleStatHandle<T>& stat) const
+		T getMax(const SampleStatHandle<T>& stat)
 		{
 			return (T)getMax(static_cast<const TraceType<SampleAccumulator<typename LLUnits::HighestPrecisionType<T>::type_t> >&> (stat));
 		}
 
-		F64 getMean(const TraceType<SampleAccumulator<F64> >& stat) const;
-		F64 getMean(const TraceType<SampleAccumulator<S64> >& stat) const;
+		F64 getMean(const TraceType<SampleAccumulator<F64> >& stat);
+		F64 getMean(const TraceType<SampleAccumulator<S64> >& stat);
 		template <typename T>
-		T getMean(SampleStatHandle<T>& stat) const
+		T getMean(SampleStatHandle<T>& stat)
 		{
 			return (T)getMean(static_cast<const TraceType<SampleAccumulator<typename LLUnits::HighestPrecisionType<T>::type_t> >&> (stat));
 		}
 
-		F64 getStandardDeviation(const TraceType<SampleAccumulator<F64> >& stat) const;
-		F64 getStandardDeviation(const TraceType<SampleAccumulator<S64> >& stat) const;
+		F64 getStandardDeviation(const TraceType<SampleAccumulator<F64> >& stat);
+		F64 getStandardDeviation(const TraceType<SampleAccumulator<S64> >& stat);
 		template <typename T>
-		T getStandardDeviation(const SampleStatHandle<T>& stat) const
+		T getStandardDeviation(const SampleStatHandle<T>& stat)
 		{
 			return (T)getStandardDeviation(static_cast<const TraceType<SampleAccumulator<typename LLUnits::HighestPrecisionType<T>::type_t> >&> (stat));
 		}
 
-		F64 getLastValue(const TraceType<SampleAccumulator<F64> >& stat) const;
-		S64 getLastValue(const TraceType<SampleAccumulator<S64> >& stat) const;
+		F64 getLastValue(const TraceType<SampleAccumulator<F64> >& stat);
+		S64 getLastValue(const TraceType<SampleAccumulator<S64> >& stat);
 		template <typename T>
-		T getLastValue(const SampleStatHandle<T>& stat) const
+		T getLastValue(const SampleStatHandle<T>& stat)
 		{
 			return (T)getLastValue(static_cast<const TraceType<SampleAccumulator<typename LLUnits::HighestPrecisionType<T>::type_t> >&> (stat));
 		}
 
-		U32 getSampleCount(const TraceType<SampleAccumulator<F64> >& stat) const;
-		U32 getSampleCount(const TraceType<SampleAccumulator<S64> >& stat) const;
+		U32 getSampleCount(const TraceType<SampleAccumulator<F64> >& stat);
+		U32 getSampleCount(const TraceType<SampleAccumulator<S64> >& stat);
 
 		// EventStatHandle accessors
-		F64 getSum(const TraceType<EventAccumulator<F64> >& stat) const;
-		S64 getSum(const TraceType<EventAccumulator<S64> >& stat) const;
+		F64 getSum(const TraceType<EventAccumulator<F64> >& stat);
+		S64 getSum(const TraceType<EventAccumulator<S64> >& stat);
 		template <typename T>
-		T getSum(const EventStatHandle<T>& stat) const
+		T getSum(const EventStatHandle<T>& stat)
 		{
 			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;
+		F64 getMin(const TraceType<EventAccumulator<F64> >& stat);
+		S64 getMin(const TraceType<EventAccumulator<S64> >& stat);
 		template <typename T>
-		T getMin(const EventStatHandle<T>& stat) const
+		T getMin(const EventStatHandle<T>& stat)
 		{
 			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;
+		F64 getMax(const TraceType<EventAccumulator<F64> >& stat);
+		S64 getMax(const TraceType<EventAccumulator<S64> >& stat);
 		template <typename T>
-		T getMax(const EventStatHandle<T>& stat) const
+		T getMax(const EventStatHandle<T>& stat)
 		{
 			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;
+		F64 getMean(const TraceType<EventAccumulator<F64> >& stat);
+		F64 getMean(const TraceType<EventAccumulator<S64> >& stat);
 		template <typename T>
-		T getMean(EventStatHandle<T>& stat) const
+		T getMean(EventStatHandle<T>& stat)
 		{
 			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;
+		F64 getStandardDeviation(const TraceType<EventAccumulator<F64> >& stat);
+		F64 getStandardDeviation(const TraceType<EventAccumulator<S64> >& stat);
 		template <typename T>
-		T getStandardDeviation(const EventStatHandle<T>& stat) const
+		T getStandardDeviation(const EventStatHandle<T>& stat)
 		{
 			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;
+		F64 getLastValue(const TraceType<EventAccumulator<F64> >& stat);
+		S64 getLastValue(const TraceType<EventAccumulator<S64> >& stat);
 		template <typename T>
-		T getLastValue(const EventStatHandle<T>& stat) const
+		T getLastValue(const EventStatHandle<T>& stat)
 		{
 			return (T)getLastValue(static_cast<const TraceType<EventAccumulator<typename LLUnits::HighestPrecisionType<T>::type_t> >&> (stat));
 		}
 
-		U32 getSampleCount(const TraceType<EventAccumulator<F64> >& stat) const;
-		U32 getSampleCount(const TraceType<EventAccumulator<S64> >& stat) const;
+		U32 getSampleCount(const TraceType<EventAccumulator<F64> >& stat);
+		U32 getSampleCount(const TraceType<EventAccumulator<S64> >& stat);
 
 		LLUnit<LLUnits::Seconds, F64> getDuration() const { return LLUnit<LLUnits::Seconds, F64>(mElapsedSeconds); }
 
@@ -321,7 +321,7 @@ namespace LLTrace
 
 		// 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
+		typename T::value_t getPeriodMin(const TraceType<T>& stat, size_t num_periods = U32_MAX)
 		{
 			size_t total_periods = mRecordingPeriods.size();
 			num_periods = llmin(num_periods, total_periods);
@@ -336,7 +336,7 @@ namespace LLTrace
 		}
 
 		template <typename T>
-		T getPeriodMin(const TraceType<SampleAccumulator<T> >& stat, size_t num_periods = U32_MAX) const
+		T getPeriodMin(const TraceType<SampleAccumulator<T> >& stat, size_t num_periods = U32_MAX)
 		{
 			size_t total_periods = mRecordingPeriods.size();
 			num_periods = llmin(num_periods, total_periods);
@@ -351,7 +351,7 @@ namespace LLTrace
 		}
 		
 		template <typename T>
-		T getPeriodMin(const TraceType<EventAccumulator<T> >& stat, size_t num_periods = U32_MAX) const
+		T getPeriodMin(const TraceType<EventAccumulator<T> >& stat, size_t num_periods = U32_MAX)
 		{
 			size_t total_periods = mRecordingPeriods.size();
 			num_periods = llmin(num_periods, total_periods);
@@ -366,7 +366,7 @@ namespace LLTrace
 		}
 
 		template <typename T>
-		F64 getPeriodMinPerSec(const TraceType<T>& stat, size_t num_periods = U32_MAX) const
+		F64 getPeriodMinPerSec(const TraceType<T>& stat, size_t num_periods = U32_MAX)
 		{
 			size_t total_periods = mRecordingPeriods.size();
 			num_periods = llmin(num_periods, total_periods);
@@ -382,7 +382,7 @@ namespace LLTrace
 
 		// 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
+		typename T::value_t getPeriodMax(const TraceType<T>& stat, size_t num_periods = U32_MAX)
 		{
 			size_t total_periods = mRecordingPeriods.size();
 			num_periods = llmin(num_periods, total_periods);
@@ -397,7 +397,7 @@ namespace LLTrace
 		}
 
 		template <typename T>
-		T getPeriodMax(const TraceType<SampleAccumulator<T> >& stat, size_t num_periods = U32_MAX) const
+		T getPeriodMax(const TraceType<SampleAccumulator<T> >& stat, size_t num_periods = U32_MAX)
 		{
 			size_t total_periods = mRecordingPeriods.size();
 			num_periods = llmin(num_periods, total_periods);
@@ -412,7 +412,7 @@ namespace LLTrace
 		}
 
 		template <typename T>
-		T getPeriodMax(const TraceType<EventAccumulator<T> >& stat, size_t num_periods = U32_MAX) const
+		T getPeriodMax(const TraceType<EventAccumulator<T> >& stat, size_t num_periods = U32_MAX)
 		{
 			size_t total_periods = mRecordingPeriods.size();
 			num_periods = llmin(num_periods, total_periods);
@@ -427,7 +427,7 @@ namespace LLTrace
 		}
 
 		template <typename T>
-		F64 getPeriodMaxPerSec(const TraceType<T>& stat, size_t num_periods = U32_MAX) const
+		F64 getPeriodMaxPerSec(const TraceType<T>& stat, size_t num_periods = U32_MAX)
 		{
 			size_t total_periods = mRecordingPeriods.size();
 			num_periods = llmin(num_periods, total_periods);
@@ -443,7 +443,7 @@ namespace LLTrace
 
 		// 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)
 		{
 			size_t total_periods = mRecordingPeriods.size();
 			num_periods = llmin(num_periods, total_periods);
@@ -464,7 +464,7 @@ namespace LLTrace
 		}
 
 		template <typename T>
-		typename SampleAccumulator<T>::mean_t getPeriodMean(const TraceType<SampleAccumulator<T> >& stat, size_t num_periods = U32_MAX) const
+		typename SampleAccumulator<T>::mean_t getPeriodMean(const TraceType<SampleAccumulator<T> >& stat, size_t num_periods = U32_MAX)
 		{
 			size_t total_periods = mRecordingPeriods.size();
 			num_periods = llmin(num_periods, total_periods);
@@ -493,7 +493,7 @@ namespace LLTrace
 		}
 
 		template <typename T>
-		typename EventAccumulator<T>::mean_t getPeriodMean(const TraceType<EventAccumulator<T> >& stat, size_t num_periods = U32_MAX) const
+		typename EventAccumulator<T>::mean_t getPeriodMean(const TraceType<EventAccumulator<T> >& stat, size_t num_periods = U32_MAX)
 		{
 			size_t total_periods = mRecordingPeriods.size();
 			num_periods = llmin(num_periods, total_periods);
@@ -522,7 +522,7 @@ namespace LLTrace
 		}
 
 		template <typename T>
-		typename T::mean_t getPeriodMeanPerSec(const TraceType<T>& stat, size_t num_periods = U32_MAX) const
+		typename T::mean_t getPeriodMeanPerSec(const TraceType<T>& stat, size_t num_periods = U32_MAX)
 		{
 			size_t total_periods = mRecordingPeriods.size();
 			num_periods = llmin(num_periods, total_periods);
diff --git a/indra/newview/llscenemonitor.cpp b/indra/newview/llscenemonitor.cpp
index 7eb48eb575..bb1cfaa9a8 100644
--- a/indra/newview/llscenemonitor.cpp
+++ b/indra/newview/llscenemonitor.cpp
@@ -240,7 +240,7 @@ void LLSceneMonitor::unfreezeScene()
 
 	if(mDiffState == VIEWER_QUITTING)
 	{
-		return; //we are quitting viewer.
+		return;
 	}
 
 	// thaw everything else
diff --git a/indra/newview/llviewerassetstats.cpp b/indra/newview/llviewerassetstats.cpp
index 0bbf2cbbea..062dabdd13 100644
--- a/indra/newview/llviewerassetstats.cpp
+++ b/indra/newview/llviewerassetstats.cpp
@@ -286,13 +286,13 @@ LLViewerAssetStats::LLViewerAssetStats(const LLViewerAssetStats & src)
 	mRegionRecordings = src.mRegionRecordings;
 
 	mCurRecording = &mRegionRecordings[mRegionHandle];
-	mCurRecording->stop();
 
 	// assume this is being passed to another thread, so make sure we have unique copies of recording data
 	for (PerRegionRecordingContainer::iterator it = mRegionRecordings.begin(), end_it = mRegionRecordings.end();
 		it != end_it;
 		++it)
 	{
+		it->second.stop();
 		it->second.makeUnique();
 	}
 
diff --git a/indra/newview/llviewerstats.h b/indra/newview/llviewerstats.h
index c0ac6d220f..ca8c347afa 100644
--- a/indra/newview/llviewerstats.h
+++ b/indra/newview/llviewerstats.h
@@ -207,7 +207,7 @@ public:
 
 	void updateFrameStats(const F64 time_diff);
 	
-	void addToMessage(LLSD &body) const;
+	void addToMessage(LLSD &body);
 
 	struct  StatsAccumulator
 	{