renamed LLTrace stat gathering classes/methods to make the structure of LLTrace clearer

Count becomes CountStatHandle
Count.sum becomes sum(Count, value), etc.

2 files changed, 429 insertions, 426 deletions

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