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

removed unnecessary templates from accumulator types...now always
track data in double precision floating point, using templated accessors to
convert to and from arbitrary types

4 files changed, 236 insertions, 344 deletions

diff --git a/indra/llcommon/lltrace.h b/indra/llcommon/lltrace.h
index 0daac95ea4..d6b51a63ee 100644
--- a/indra/llcommon/lltrace.h
+++ b/indra/llcommon/lltrace.h
@@ -273,25 +273,23 @@ protected:
 	const size_t		mAccumulatorIndex;
 };
 
-template<typename T>
 class EventAccumulator
 {
 public:
-	typedef T value_t;
+	typedef F64 value_t;
 	typedef F64 mean_t;
-	typedef EventAccumulator<T> self_t;
 
 	EventAccumulator()
 	:	mSum(0),
-		mMin((std::numeric_limits<T>::max)()),
-		mMax((std::numeric_limits<T>::min)()),
+		mMin((std::numeric_limits<F64>::max)()),
+		mMax((std::numeric_limits<F64>::min)()),
 		mMean(0),
 		mVarianceSum(0),
 		mNumSamples(0),
 		mLastValue(0)
 	{}
 
-	void record(T value)
+	void record(F64 value)
 	{
 		mNumSamples++;
 		mSum += value;
@@ -305,12 +303,12 @@ public:
 			mMax = value;
 		}
 		F64 old_mean = mMean;
-		mMean += ((F64)value - old_mean) / (F64)mNumSamples;
-		mVarianceSum += ((F64)value - old_mean) * ((F64)value - mMean);
+		mMean += (value - old_mean) / (F64)mNumSamples;
+		mVarianceSum += (value - old_mean) * (value - mMean);
 		mLastValue = value;
 	}
 
-	void addSamples(const self_t& other, bool append)
+	void addSamples(const EventAccumulator& other, bool append)
 	{
 		if (other.mNumSamples)
 		{
@@ -354,12 +352,12 @@ public:
 		}
 	}
 
-	void reset(const self_t* other)
+	void reset(const EventAccumulator* other)
 	{
 		mNumSamples = 0;
 		mSum = 0;
-		mMin = std::numeric_limits<T>::max();
-		mMax = std::numeric_limits<T>::min();
+		mMin = std::numeric_limits<F64>::max();
+		mMax = std::numeric_limits<F64>::min();
 		mMean = 0;
 		mVarianceSum = 0;
 		mLastValue = other ? other->mLastValue : 0;
@@ -367,16 +365,16 @@ public:
 
 	void flush() {}
 
-	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	getSum() const { return mSum; }
+	F64	getMin() const { return mMin; }
+	F64	getMax() const { return mMax; }
+	F64	getLastValue() const { return mLastValue; }
 	F64	getMean() const { return mMean; }
 	F64 getStandardDeviation() const { return sqrtf(mVarianceSum / mNumSamples); }
 	U32 getSampleCount() const { return mNumSamples; }
 
 private:
-	T	mSum,
+	F64	mSum,
 		mMin,
 		mMax,
 		mLastValue;
@@ -388,18 +386,16 @@ private:
 };
 
 
-template<typename T>
 class SampleAccumulator
 {
 public:
-	typedef T value_t;
+	typedef F64 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)()),
+		mMin((std::numeric_limits<F64>::max)()),
+		mMax((std::numeric_limits<F64>::min)()),
 		mMean(0),
 		mVarianceSum(0),
 		mLastSampleTimeStamp(LLTimer::getTotalSeconds()),
@@ -409,7 +405,7 @@ public:
 		mHasValue(false)
 	{}
 
-	void sample(T value)
+	void sample(F64 value)
 	{
 		LLUnitImplicit<LLUnits::Seconds, F64> time_stamp = LLTimer::getTotalSeconds();
 		LLUnitImplicit<LLUnits::Seconds, F64> delta_time = time_stamp - mLastSampleTimeStamp;
@@ -418,15 +414,15 @@ public:
 		if (mHasValue)
 		{
 			mTotalSamplingTime += delta_time;
-			mSum += (F64)mLastValue * delta_time;
+			mSum += 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);
+			mMean += (delta_time / mTotalSamplingTime) * (mLastValue - old_mean);
+			mVarianceSum += delta_time * (mLastValue - old_mean) * (mLastValue - mMean);
 		}
 
 		mLastValue = value;
@@ -434,7 +430,7 @@ public:
 		mHasValue = true;
 	}
 
-	void addSamples(const self_t& other, bool append)
+	void addSamples(const SampleAccumulator& other, bool append)
 	{
 		if (other.mTotalSamplingTime)
 		{
@@ -485,12 +481,12 @@ public:
 		}
 	}
 
-	void reset(const self_t* other)
+	void reset(const SampleAccumulator* other)
 	{
 		mNumSamples = 0;
 		mSum = 0;
-		mMin = std::numeric_limits<T>::max();
-		mMax = std::numeric_limits<T>::min();
+		mMin = std::numeric_limits<F64>::max();
+		mMax = std::numeric_limits<F64>::min();
 		mMean = other ? other->mLastValue : 0;
 		mVarianceSum = 0;
 		mLastSampleTimeStamp = LLTimer::getTotalSeconds();
@@ -506,22 +502,22 @@ public:
 
 		if (mHasValue)
 		{
-			mSum += (F64)mLastValue * delta_time;
+			mSum += 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	getSum() const { return mSum; }
+	F64	getMin() const { return mMin; }
+	F64	getMax() const { return mMax; }
+	F64	getLastValue() const { return mLastValue; }
 	F64	getMean() const { return mMean; }
 	F64 getStandardDeviation() const { return sqrtf(mVarianceSum / mTotalSamplingTime); }
 	U32 getSampleCount() const { return mNumSamples; }
 
 private:
-	T	mSum,
+	F64	mSum,
 		mMin,
 		mMax,
 		mLastValue;
@@ -537,12 +533,10 @@ private:
 	U32	mNumSamples;
 };
 
-template<typename T>
 class CountAccumulator
 {
 public:
-	typedef CountAccumulator<T> self_t;
-	typedef T value_t;
+	typedef F64 value_t;
 	typedef F64 mean_t;
 
 	CountAccumulator()
@@ -550,19 +544,19 @@ public:
 		mNumSamples(0)
 	{}
 
-	void add(T value)
+	void add(F64 value)
 	{
 		mNumSamples++;
 		mSum += value;
 	}
 
-	void addSamples(const CountAccumulator<T>& other, bool /*append*/)
+	void addSamples(const CountAccumulator& other, bool /*append*/)
 	{
 		mSum += other.mSum;
 		mNumSamples += other.mNumSamples;
 	}
 
-	void reset(const self_t* other)
+	void reset(const CountAccumulator* other)
 	{
 		mNumSamples = 0;
 		mSum = 0;
@@ -570,12 +564,12 @@ public:
 
 	void flush() {}
 
-	T	getSum() const { return (T)mSum; }
+	F64	getSum() const { return mSum; }
 
 	U32 getSampleCount() const { return mNumSamples; }
 
 private:
-	T	mSum;
+	F64	mSum;
 
 	U32	mNumSamples;
 };
@@ -659,11 +653,11 @@ public:
 
 template <typename T = F64>
 class EventStatHandle
-:	public TraceType<EventAccumulator<typename LLUnits::HighestPrecisionType<T>::type_t> >
+:	public TraceType<EventAccumulator>
 {
 public:
 	typedef typename LLUnits::HighestPrecisionType<T>::type_t storage_t;
-	typedef TraceType<EventAccumulator<typename LLUnits::HighestPrecisionType<T>::type_t> > trace_t;
+	typedef TraceType<EventAccumulator> trace_t;
 
 	EventStatHandle(const char* name, const char* description = NULL)
 	:	trace_t(name, description)
@@ -679,11 +673,11 @@ void record(EventStatHandle<T>& measurement, VALUE_T value)
 
 template <typename T = F64>
 class SampleStatHandle
-:	public TraceType<SampleAccumulator<typename LLUnits::HighestPrecisionType<T>::type_t> >
+:	public TraceType<SampleAccumulator>
 {
 public:
-	typedef typename LLUnits::HighestPrecisionType<T>::type_t storage_t;
-	typedef TraceType<SampleAccumulator<typename LLUnits::HighestPrecisionType<T>::type_t> > trace_t;
+	typedef F64 storage_t;
+	typedef TraceType<SampleAccumulator> trace_t;
 
 	SampleStatHandle(const char* name, const char* description = NULL)
 	:	trace_t(name, description)
@@ -699,11 +693,11 @@ void sample(SampleStatHandle<T>& measurement, VALUE_T value)
 
 template <typename T = F64>
 class CountStatHandle
-:	public TraceType<CountAccumulator<typename LLUnits::HighestPrecisionType<T>::type_t> >
+:	public TraceType<CountAccumulator>
 {
 public:
 	typedef typename LLUnits::HighestPrecisionType<T>::type_t storage_t;
-	typedef TraceType<CountAccumulator<typename LLUnits::HighestPrecisionType<T>::type_t> > trace_t;
+	typedef TraceType<CountAccumulator> trace_t;
 
 	CountStatHandle(const char* name, const char* description = NULL) 
 	:	trace_t(name)
diff --git a/indra/llcommon/lltracerecording.cpp b/indra/llcommon/lltracerecording.cpp
index aedb9c7542..61ba21a365 100644
--- a/indra/llcommon/lltracerecording.cpp
+++ b/indra/llcommon/lltracerecording.cpp
@@ -44,11 +44,8 @@ RecordingBuffers::RecordingBuffers()
 
 void RecordingBuffers::handOffTo(RecordingBuffers& other)
 {
-	other.mCountsFloat.reset(&mCountsFloat);
 	other.mCounts.reset(&mCounts);
-	other.mSamplesFloat.reset(&mSamplesFloat);
 	other.mSamples.reset(&mSamples);
-	other.mEventsFloat.reset(&mEventsFloat);
 	other.mEvents.reset(&mEvents);
 	other.mStackTimers.reset(&mStackTimers);
 	other.mMemStats.reset(&mMemStats);
@@ -56,11 +53,8 @@ void RecordingBuffers::handOffTo(RecordingBuffers& other)
 
 void RecordingBuffers::makePrimary()
 {
-	mCountsFloat.makePrimary();
 	mCounts.makePrimary();
-	mSamplesFloat.makePrimary();
 	mSamples.makePrimary();
-	mEventsFloat.makePrimary();
 	mEvents.makePrimary();
 	mStackTimers.makePrimary();
 	mMemStats.makePrimary();
@@ -85,11 +79,8 @@ bool RecordingBuffers::isPrimary() const
 
 void RecordingBuffers::append( const RecordingBuffers& other )
 {
-	mCountsFloat.addSamples(other.mCountsFloat);
 	mCounts.addSamples(other.mCounts);
-	mSamplesFloat.addSamples(other.mSamplesFloat);
 	mSamples.addSamples(other.mSamples);
-	mEventsFloat.addSamples(other.mEventsFloat);
 	mEvents.addSamples(other.mEvents);
 	mMemStats.addSamples(other.mMemStats);
 	mStackTimers.addSamples(other.mStackTimers);
@@ -97,11 +88,8 @@ void RecordingBuffers::append( const RecordingBuffers& other )
 
 void RecordingBuffers::merge( const RecordingBuffers& other)
 {
-	mCountsFloat.addSamples(other.mCountsFloat, false);
 	mCounts.addSamples(other.mCounts, false);
-	mSamplesFloat.addSamples(other.mSamplesFloat, false);
 	mSamples.addSamples(other.mSamples, false);
-	mEventsFloat.addSamples(other.mEventsFloat, false);
 	mEvents.addSamples(other.mEvents, false);
 	mMemStats.addSamples(other.mMemStats, false);
 	// for now, hold out timers from merge, need to be displayed per thread
@@ -110,11 +98,8 @@ void RecordingBuffers::merge( const RecordingBuffers& other)
 
 void RecordingBuffers::reset(RecordingBuffers* other)
 {
-	mCountsFloat.reset(other ? &other->mCountsFloat : NULL);
 	mCounts.reset(other ? &other->mCounts : 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);
@@ -122,7 +107,6 @@ void RecordingBuffers::reset(RecordingBuffers* other)
 
 void RecordingBuffers::flush()
 {
-	mSamplesFloat.flush();
 	mSamples.flush();
 }
 
@@ -280,200 +264,100 @@ LLUnit<LLUnits::Bytes, F32> Recording::getPerSec(const TraceType<MemStatAccumula
 }
 
 
-F64 Recording::getSum( const TraceType<CountAccumulator<F64> >& stat )
-{
-	update();
-	return mBuffers->mCountsFloat[stat.getIndex()].getSum();
-}
-
-S64 Recording::getSum( const TraceType<CountAccumulator<S64> >& stat )
+F64 Recording::getSum( const TraceType<CountAccumulator>& stat )
 {
 	update();
 	return mBuffers->mCounts[stat.getIndex()].getSum();
 }
 
-F64 Recording::getSum( const TraceType<EventAccumulator<F64> >& stat )
+F64 Recording::getSum( const TraceType<EventAccumulator>& stat )
 {
 	update();
-	return (F64)mBuffers->mEventsFloat[stat.getIndex()].getSum();
+	return (F64)mBuffers->mEvents[stat.getIndex()].getSum();
 }
 
-S64 Recording::getSum( const TraceType<EventAccumulator<S64> >& stat )
+F64 Recording::getPerSec( const TraceType<CountAccumulator>& stat )
 {
 	update();
-	return (S64)mBuffers->mEvents[stat.getIndex()].getSum();
-}
-
-
-
-F64 Recording::getPerSec( const TraceType<CountAccumulator<F64> >& stat )
-{
-	update();
-	F64 sum = mBuffers->mCountsFloat[stat.getIndex()].getSum();
+	F64 sum = mBuffers->mCounts[stat.getIndex()].getSum();
 	return  (sum != 0.0) 
 		? (sum / mElapsedSeconds)
 		: 0.0;
 }
 
-F64 Recording::getPerSec( const TraceType<CountAccumulator<S64> >& stat )
-{
-	S64 sum = mBuffers->mCounts[stat.getIndex()].getSum();
-	return (sum != 0) 
-		? ((F64)sum / mElapsedSeconds)
-		: 0.0;
-}
-
-U32 Recording::getSampleCount( const TraceType<CountAccumulator<F64> >& stat )
-{
-	update();
-	return mBuffers->mCountsFloat[stat.getIndex()].getSampleCount();
-}
-
-U32 Recording::getSampleCount( const TraceType<CountAccumulator<S64> >& stat )
+U32 Recording::getSampleCount( const TraceType<CountAccumulator>& stat )
 {
 	update();
 	return mBuffers->mCounts[stat.getIndex()].getSampleCount();
 }
 
-F64 Recording::getMin( const TraceType<SampleAccumulator<F64> >& stat )
-{
-	update();
-	return mBuffers->mSamplesFloat[stat.getIndex()].getMin();
-}
-
-S64 Recording::getMin( const TraceType<SampleAccumulator<S64> >& stat )
+F64 Recording::getMin( const TraceType<SampleAccumulator>& stat )
 {
 	update();
 	return mBuffers->mSamples[stat.getIndex()].getMin();
 }
 
-F64 Recording::getMax( const TraceType<SampleAccumulator<F64> >& stat )
-{
-	update();
-	return mBuffers->mSamplesFloat[stat.getIndex()].getMax();
-}
-
-S64 Recording::getMax( const TraceType<SampleAccumulator<S64> >& stat )
+F64 Recording::getMax( const TraceType<SampleAccumulator>& stat )
 {
 	update();
 	return mBuffers->mSamples[stat.getIndex()].getMax();
 }
 
-F64 Recording::getMean( const TraceType<SampleAccumulator<F64> >& stat )
-{
-	update();
-	return mBuffers->mSamplesFloat[stat.getIndex()].getMean();
-}
-
-F64 Recording::getMean( const TraceType<SampleAccumulator<S64> >& stat )
+F64 Recording::getMean( const TraceType<SampleAccumulator>& stat )
 {
 	update();
 	return mBuffers->mSamples[stat.getIndex()].getMean();
 }
 
-F64 Recording::getStandardDeviation( const TraceType<SampleAccumulator<F64> >& stat )
-{
-	update();
-	return mBuffers->mSamplesFloat[stat.getIndex()].getStandardDeviation();
-}
-
-F64 Recording::getStandardDeviation( const TraceType<SampleAccumulator<S64> >& stat )
+F64 Recording::getStandardDeviation( const TraceType<SampleAccumulator>& stat )
 {
 	update();
 	return mBuffers->mSamples[stat.getIndex()].getStandardDeviation();
 }
 
-F64 Recording::getLastValue( const TraceType<SampleAccumulator<F64> >& stat )
-{
-	update();
-	return mBuffers->mSamplesFloat[stat.getIndex()].getLastValue();
-}
-
-S64 Recording::getLastValue( const TraceType<SampleAccumulator<S64> >& stat )
+F64 Recording::getLastValue( const TraceType<SampleAccumulator>& stat )
 {
 	update();
 	return mBuffers->mSamples[stat.getIndex()].getLastValue();
 }
 
-U32 Recording::getSampleCount( const TraceType<SampleAccumulator<F64> >& stat )
-{
-	update();
-	return mBuffers->mSamplesFloat[stat.getIndex()].getSampleCount();
-}
-
-U32 Recording::getSampleCount( const TraceType<SampleAccumulator<S64> >& stat )
+U32 Recording::getSampleCount( const TraceType<SampleAccumulator>& stat )
 {
 	update();
 	return mBuffers->mSamples[stat.getIndex()].getSampleCount();
 }
 
-F64 Recording::getMin( const TraceType<EventAccumulator<F64> >& stat )
-{
-	update();
-	return mBuffers->mEventsFloat[stat.getIndex()].getMin();
-}
-
-S64 Recording::getMin( const TraceType<EventAccumulator<S64> >& stat )
+F64 Recording::getMin( const TraceType<EventAccumulator>& stat )
 {
 	update();
 	return mBuffers->mEvents[stat.getIndex()].getMin();
 }
 
-F64 Recording::getMax( const TraceType<EventAccumulator<F64> >& stat )
-{
-	update();
-	return mBuffers->mEventsFloat[stat.getIndex()].getMax();
-}
-
-S64 Recording::getMax( const TraceType<EventAccumulator<S64> >& stat )
+F64 Recording::getMax( const TraceType<EventAccumulator>& stat )
 {
 	update();
 	return mBuffers->mEvents[stat.getIndex()].getMax();
 }
 
-F64 Recording::getMean( const TraceType<EventAccumulator<F64> >& stat )
-{
-	update();
-	return mBuffers->mEventsFloat[stat.getIndex()].getMean();
-}
-
-F64 Recording::getMean( const TraceType<EventAccumulator<S64> >& stat )
+F64 Recording::getMean( const TraceType<EventAccumulator>& stat )
 {
 	update();
 	return mBuffers->mEvents[stat.getIndex()].getMean();
 }
 
-F64 Recording::getStandardDeviation( const TraceType<EventAccumulator<F64> >& stat )
-{
-	update();
-	return mBuffers->mEventsFloat[stat.getIndex()].getStandardDeviation();
-}
-
-F64 Recording::getStandardDeviation( const TraceType<EventAccumulator<S64> >& stat )
+F64 Recording::getStandardDeviation( const TraceType<EventAccumulator>& stat )
 {
 	update();
 	return mBuffers->mEvents[stat.getIndex()].getStandardDeviation();
 }
 
-F64 Recording::getLastValue( const TraceType<EventAccumulator<F64> >& stat )
-{
-	update();
-	return mBuffers->mEventsFloat[stat.getIndex()].getLastValue();
-}
-
-S64 Recording::getLastValue( const TraceType<EventAccumulator<S64> >& stat )
+F64 Recording::getLastValue( const TraceType<EventAccumulator>& stat )
 {
 	update();
 	return mBuffers->mEvents[stat.getIndex()].getLastValue();
 }
 
-U32 Recording::getSampleCount( const TraceType<EventAccumulator<F64> >& stat )
-{
-	update();
-	return mBuffers->mEventsFloat[stat.getIndex()].getSampleCount();
-}
-
-U32 Recording::getSampleCount( const TraceType<EventAccumulator<S64> >& stat )
+U32 Recording::getSampleCount( const TraceType<EventAccumulator>& stat )
 {
 	update();
 	return mBuffers->mEvents[stat.getIndex()].getSampleCount();
@@ -667,6 +551,122 @@ void PeriodicRecording::handleSplitTo(PeriodicRecording& other)
 	getCurRecording().splitTo(other.getCurRecording());
 }
 
+
+F64 PeriodicRecording::getPeriodMean( const TraceType<EventAccumulator>& stat, size_t num_periods /*= U32_MAX*/ )
+{
+	size_t total_periods = mRecordingPeriods.size();
+	num_periods = llmin(num_periods, total_periods);
+
+	F64 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;
+}
+
+F64 PeriodicRecording::getPeriodMin( const TraceType<EventAccumulator>& stat, size_t num_periods /*= U32_MAX*/ )
+{
+	size_t total_periods = mRecordingPeriods.size();
+	num_periods = llmin(num_periods, total_periods);
+
+	F64 min_val = std::numeric_limits<F64>::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;
+}
+
+F64 PeriodicRecording::getPeriodMax( const TraceType<EventAccumulator>& stat, size_t num_periods /*= U32_MAX*/ )
+{
+	size_t total_periods = mRecordingPeriods.size();
+	num_periods = llmin(num_periods, total_periods);
+
+	F64 max_val = std::numeric_limits<F64>::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;
+}
+
+F64 PeriodicRecording::getPeriodMin( const TraceType<SampleAccumulator>& stat, size_t num_periods /*= U32_MAX*/ )
+{
+	size_t total_periods = mRecordingPeriods.size();
+	num_periods = llmin(num_periods, total_periods);
+
+	F64 min_val = std::numeric_limits<F64>::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;
+}
+
+F64 PeriodicRecording::getPeriodMax(const TraceType<SampleAccumulator>& stat, size_t num_periods /*= U32_MAX*/)
+{
+	size_t total_periods = mRecordingPeriods.size();
+	num_periods = llmin(num_periods, total_periods);
+
+	F64 max_val = std::numeric_limits<F64>::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;
+}
+
+
+F64 PeriodicRecording::getPeriodMean( const TraceType<SampleAccumulator>& stat, size_t num_periods /*= U32_MAX*/ )
+{
+	size_t total_periods = mRecordingPeriods.size();
+	num_periods = llmin(num_periods, total_periods);
+
+	LLUnit<LLUnits::Seconds, F64> total_duration = 0.f;
+
+	F64 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;
+}
+
+
+
 ///////////////////////////////////////////////////////////////////////
 // ExtendableRecording
 ///////////////////////////////////////////////////////////////////////
diff --git a/indra/llcommon/lltracerecording.h b/indra/llcommon/lltracerecording.h
index 58b40fa378..b4452d67a0 100644
--- a/indra/llcommon/lltracerecording.h
+++ b/indra/llcommon/lltracerecording.h
@@ -119,12 +119,9 @@ namespace LLTrace
 		void reset(RecordingBuffers* other = NULL);
 		void flush();
 
-		AccumulatorBuffer<CountAccumulator<F64> > 		mCountsFloat;
-		AccumulatorBuffer<CountAccumulator<S64> > 		mCounts;
-		AccumulatorBuffer<SampleAccumulator<F64> >		mSamplesFloat;
-		AccumulatorBuffer<SampleAccumulator<S64> >		mSamples;
-		AccumulatorBuffer<EventAccumulator<F64> >		mEventsFloat;
-		AccumulatorBuffer<EventAccumulator<S64> >		mEvents;
+		AccumulatorBuffer<CountAccumulator>	 			mCounts;
+		AccumulatorBuffer<SampleAccumulator>			mSamples;
+		AccumulatorBuffer<EventAccumulator>				mEvents;
 		AccumulatorBuffer<TimeBlockAccumulator> 		mStackTimers;
 		AccumulatorBuffer<MemStatAccumulator> 			mMemStats;
 	};
@@ -164,121 +161,105 @@ namespace LLTrace
 		LLUnit<LLUnits::Bytes, F32> getPerSec(const TraceType<MemStatAccumulator>& stat);
 
 		// CountStatHandle accessors
-		F64 getSum(const TraceType<CountAccumulator<F64> >& stat);
-		S64 getSum(const TraceType<CountAccumulator<S64> >& stat);
+		F64 getSum(const TraceType<CountAccumulator>& stat);
 		template <typename T>
 		T getSum(const CountStatHandle<T>& stat)
 		{
-			return (T)getSum(static_cast<const TraceType<CountAccumulator<typename LLUnits::HighestPrecisionType<T>::type_t> >&> (stat));
+			return (T)getSum(static_cast<const TraceType<CountAccumulator>&> (stat));
 		}
 
-		F64 getPerSec(const TraceType<CountAccumulator<F64> >& stat);
-		F64 getPerSec(const TraceType<CountAccumulator<S64> >& stat);
+		F64 getPerSec(const TraceType<CountAccumulator>& stat);
 		template <typename T>
 		T getPerSec(const CountStatHandle<T>& stat)
 		{
-			return (T)getPerSec(static_cast<const TraceType<CountAccumulator<typename LLUnits::HighestPrecisionType<T>::type_t> >&> (stat));
+			return (T)getPerSec(static_cast<const TraceType<CountAccumulator>&> (stat));
 		}
 
-		U32 getSampleCount(const TraceType<CountAccumulator<F64> >& stat);
-		U32 getSampleCount(const TraceType<CountAccumulator<S64> >& stat);
+		U32 getSampleCount(const TraceType<CountAccumulator>& stat);
 
 
 		// SampleStatHandle accessors
-		F64 getMin(const TraceType<SampleAccumulator<F64> >& stat);
-		S64 getMin(const TraceType<SampleAccumulator<S64> >& stat);
+		F64 getMin(const TraceType<SampleAccumulator>& stat);
 		template <typename T>
 		T getMin(const SampleStatHandle<T>& stat)
 		{
-			return (T)getMin(static_cast<const TraceType<SampleAccumulator<typename LLUnits::HighestPrecisionType<T>::type_t> >&> (stat));
+			return (T)getMin(static_cast<const TraceType<SampleAccumulator>&> (stat));
 		}
 
-		F64 getMax(const TraceType<SampleAccumulator<F64> >& stat);
-		S64 getMax(const TraceType<SampleAccumulator<S64> >& stat);
+		F64 getMax(const TraceType<SampleAccumulator>& stat);
 		template <typename T>
 		T getMax(const SampleStatHandle<T>& stat)
 		{
-			return (T)getMax(static_cast<const TraceType<SampleAccumulator<typename LLUnits::HighestPrecisionType<T>::type_t> >&> (stat));
+			return (T)getMax(static_cast<const TraceType<SampleAccumulator>&> (stat));
 		}
 
-		F64 getMean(const TraceType<SampleAccumulator<F64> >& stat);
-		F64 getMean(const TraceType<SampleAccumulator<S64> >& stat);
+		F64 getMean(const TraceType<SampleAccumulator>& stat);
 		template <typename T>
 		T getMean(SampleStatHandle<T>& stat)
 		{
-			return (T)getMean(static_cast<const TraceType<SampleAccumulator<typename LLUnits::HighestPrecisionType<T>::type_t> >&> (stat));
+			return (T)getMean(static_cast<const TraceType<SampleAccumulator>&> (stat));
 		}
 
-		F64 getStandardDeviation(const TraceType<SampleAccumulator<F64> >& stat);
-		F64 getStandardDeviation(const TraceType<SampleAccumulator<S64> >& stat);
+		F64 getStandardDeviation(const TraceType<SampleAccumulator>& stat);
 		template <typename T>
 		T getStandardDeviation(const SampleStatHandle<T>& stat)
 		{
-			return (T)getStandardDeviation(static_cast<const TraceType<SampleAccumulator<typename LLUnits::HighestPrecisionType<T>::type_t> >&> (stat));
+			return (T)getStandardDeviation(static_cast<const TraceType<SampleAccumulator>&> (stat));
 		}
 
-		F64 getLastValue(const TraceType<SampleAccumulator<F64> >& stat);
-		S64 getLastValue(const TraceType<SampleAccumulator<S64> >& stat);
+		F64 getLastValue(const TraceType<SampleAccumulator>& stat);
 		template <typename T>
 		T getLastValue(const SampleStatHandle<T>& stat)
 		{
-			return (T)getLastValue(static_cast<const TraceType<SampleAccumulator<typename LLUnits::HighestPrecisionType<T>::type_t> >&> (stat));
+			return (T)getLastValue(static_cast<const TraceType<SampleAccumulator>&> (stat));
 		}
 
-		U32 getSampleCount(const TraceType<SampleAccumulator<F64> >& stat);
-		U32 getSampleCount(const TraceType<SampleAccumulator<S64> >& stat);
+		U32 getSampleCount(const TraceType<SampleAccumulator>& stat);
 
 		// EventStatHandle accessors
-		F64 getSum(const TraceType<EventAccumulator<F64> >& stat);
-		S64 getSum(const TraceType<EventAccumulator<S64> >& stat);
+		F64 getSum(const TraceType<EventAccumulator>& stat);
 		template <typename T>
 		T getSum(const EventStatHandle<T>& stat)
 		{
-			return (T)getSum(static_cast<const TraceType<EventAccumulator<typename LLUnits::HighestPrecisionType<T>::type_t> >&> (stat));
+			return (T)getSum(static_cast<const TraceType<EventAccumulator>&> (stat));
 		}
 
-		F64 getMin(const TraceType<EventAccumulator<F64> >& stat);
-		S64 getMin(const TraceType<EventAccumulator<S64> >& stat);
+		F64 getMin(const TraceType<EventAccumulator>& stat);
 		template <typename T>
 		T getMin(const EventStatHandle<T>& stat)
 		{
-			return (T)getMin(static_cast<const TraceType<EventAccumulator<typename LLUnits::HighestPrecisionType<T>::type_t> >&> (stat));
+			return (T)getMin(static_cast<const TraceType<EventAccumulator>&> (stat));
 		}
 
-		F64 getMax(const TraceType<EventAccumulator<F64> >& stat);
-		S64 getMax(const TraceType<EventAccumulator<S64> >& stat);
+		F64 getMax(const TraceType<EventAccumulator>& stat);
 		template <typename T>
 		T getMax(const EventStatHandle<T>& stat)
 		{
-			return (T)getMax(static_cast<const TraceType<EventAccumulator<typename LLUnits::HighestPrecisionType<T>::type_t> >&> (stat));
+			return (T)getMax(static_cast<const TraceType<EventAccumulator>&> (stat));
 		}
 
-		F64 getMean(const TraceType<EventAccumulator<F64> >& stat);
-		F64 getMean(const TraceType<EventAccumulator<S64> >& stat);
+		F64 getMean(const TraceType<EventAccumulator>& stat);
 		template <typename T>
 		T getMean(EventStatHandle<T>& stat)
 		{
-			return (T)getMean(static_cast<const TraceType<EventAccumulator<typename LLUnits::HighestPrecisionType<T>::type_t> >&> (stat));
+			return (T)getMean(static_cast<const TraceType<EventAccumulator>&> (stat));
 		}
 
-		F64 getStandardDeviation(const TraceType<EventAccumulator<F64> >& stat);
-		F64 getStandardDeviation(const TraceType<EventAccumulator<S64> >& stat);
+		F64 getStandardDeviation(const TraceType<EventAccumulator>& stat);
 		template <typename T>
 		T getStandardDeviation(const EventStatHandle<T>& stat)
 		{
-			return (T)getStandardDeviation(static_cast<const TraceType<EventAccumulator<typename LLUnits::HighestPrecisionType<T>::type_t> >&> (stat));
+			return (T)getStandardDeviation(static_cast<const TraceType<EventAccumulator>&> (stat));
 		}
 
-		F64 getLastValue(const TraceType<EventAccumulator<F64> >& stat);
-		S64 getLastValue(const TraceType<EventAccumulator<S64> >& stat);
+		F64 getLastValue(const TraceType<EventAccumulator>& stat);
 		template <typename T>
 		T getLastValue(const EventStatHandle<T>& stat)
 		{
-			return (T)getLastValue(static_cast<const TraceType<EventAccumulator<typename LLUnits::HighestPrecisionType<T>::type_t> >&> (stat));
+			return (T)getLastValue(static_cast<const TraceType<EventAccumulator>&> (stat));
 		}
 
-		U32 getSampleCount(const TraceType<EventAccumulator<F64> >& stat);
-		U32 getSampleCount(const TraceType<EventAccumulator<S64> >& stat);
+		U32 getSampleCount(const TraceType<EventAccumulator>& stat);
 
 		LLUnit<LLUnits::Seconds, F64> getDuration() const { return LLUnit<LLUnits::Seconds, F64>(mElapsedSeconds); }
 
@@ -335,34 +316,18 @@ namespace LLTrace
 			return min_val;
 		}
 
-		template <typename T>
-		T getPeriodMin(const TraceType<SampleAccumulator<T> >& stat, size_t num_periods = U32_MAX)
+		F64 getPeriodMin(const TraceType<SampleAccumulator>& stat, size_t num_periods = U32_MAX);
+		template<typename T>
+		T getPeriodMin(const SampleStatHandle<T>& stat, size_t num_periods = U32_MAX)
 		{
-			size_t total_periods = mRecordingPeriods.size();
-			num_periods = llmin(num_periods, total_periods);
-
-			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;
+			return T(getPeriodMin(static_cast<const TraceType<SampleAccumulator>&>(stat), num_periods));
 		}
-		
-		template <typename T>
-		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);
 
-			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;
+		F64 getPeriodMin(const TraceType<EventAccumulator>& stat, size_t num_periods = U32_MAX);
+		template<typename T>
+		T getPeriodMin(const EventStatHandle<T>& stat, size_t num_periods = U32_MAX)
+		{
+			return T(getPeriodMin(static_cast<const TraceType<EventAccumulator>&>(stat), num_periods));
 		}
 
 		template <typename T>
@@ -396,34 +361,18 @@ namespace LLTrace
 			return max_val;
 		}
 
-		template <typename T>
-		T getPeriodMax(const TraceType<SampleAccumulator<T> >& stat, size_t num_periods = U32_MAX)
+		F64 getPeriodMax(const TraceType<SampleAccumulator>& stat, size_t num_periods = U32_MAX);
+		template<typename T>
+		T getPeriodMax(const SampleStatHandle<T>& stat, size_t num_periods = U32_MAX)
 		{
-			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;
+			return T(getPeriodMax(static_cast<const TraceType<SampleAccumulator>&>(stat), num_periods));
 		}
 
-		template <typename T>
-		T getPeriodMax(const TraceType<EventAccumulator<T> >& stat, size_t num_periods = U32_MAX)
+		F64 getPeriodMax(const TraceType<EventAccumulator>& stat, size_t num_periods = U32_MAX);
+		template<typename T>
+		T getPeriodMax(const EventStatHandle<T>& stat, size_t num_periods = U32_MAX)
 		{
-			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;
+			return T(getPeriodMax(static_cast<const TraceType<EventAccumulator>&>(stat), num_periods));
 		}
 
 		template <typename T>
@@ -463,62 +412,18 @@ namespace LLTrace
 			return mean;
 		}
 
-		template <typename T>
-		typename SampleAccumulator<T>::mean_t getPeriodMean(const TraceType<SampleAccumulator<T> >& stat, size_t num_periods = U32_MAX)
+		F64 getPeriodMean(const TraceType<SampleAccumulator>& stat, size_t num_periods = U32_MAX);
+		template<typename T> 
+		T getPeriodMean(const SampleStatHandle<T>& stat, size_t num_periods = U32_MAX)
 		{
-			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;
+			return T(getPeriodMean(static_cast<const TraceType<SampleAccumulator>&>(stat), num_periods));
 		}
 
-		template <typename T>
-		typename EventAccumulator<T>::mean_t getPeriodMean(const TraceType<EventAccumulator<T> >& stat, size_t num_periods = U32_MAX)
+		F64 getPeriodMean(const TraceType<EventAccumulator>& stat, size_t num_periods = U32_MAX);
+		template<typename T>
+		T getPeriodMean(const EventStatHandle<T>& stat, size_t num_periods = U32_MAX)
 		{
-			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;
+			return T(getPeriodMean(static_cast<const TraceType<EventAccumulator>&>(stat), num_periods));
 		}
 
 		template <typename T>
diff --git a/indra/llcommon/lltracethreadrecorder.cpp b/indra/llcommon/lltracethreadrecorder.cpp
index c281b768ce..c1a0700eff 100644
--- a/indra/llcommon/lltracethreadrecorder.cpp
+++ b/indra/llcommon/lltracethreadrecorder.cpp
@@ -147,13 +147,6 @@ ThreadRecorder::active_recording_list_t::reverse_iterator ThreadRecorder::bringU
 	return it;
 }
 
-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::reverse_iterator it = bringUpToDate(recording);