SH-3405 WIP convert existing stats to lltrace system

default to double precision now
fixed unit conversion logic for LLUnit
renamed LLTrace::Rate to LLTrace::Count and got rid of the old count as it was confusing
some const correctness changes

6 files changed, 122 insertions, 194 deletions

diff --git a/indra/llcommon/llpointer.h b/indra/llcommon/llpointer.h
index 0fee4f0990..6a3bbeb768 100644
--- a/indra/llcommon/llpointer.h
+++ b/indra/llcommon/llpointer.h
@@ -207,7 +207,9 @@ public:
 	using LLPointer<Type>::operator >;
 
 
+	operator Type*()							{ return mPointer; }
 	operator const Type*()   const				{ return mPointer; }
+	Type*	operator->()						{ return mPointer; }
 	const Type*	operator->() const				{ return mPointer; }
 
 };
diff --git a/indra/llcommon/lltrace.h b/indra/llcommon/lltrace.h
index 0c618a2f4b..221c226ad1 100644
--- a/indra/llcommon/lltrace.h
+++ b/indra/llcommon/lltrace.h
@@ -91,6 +91,11 @@ namespace LLTrace
 			return mStorage[index]; 
 		}
 
+		LL_FORCE_INLINE const ACCUMULATOR& operator[](size_t index) const
+		{ 
+			return mStorage[index]; 
+		}
+
 		void addSamples(const AccumulatorBuffer<ACCUMULATOR>& other)
 		{
 			llassert(mNextStorageSlot == other.mNextStorageSlot);
@@ -178,7 +183,7 @@ namespace LLTrace
 		}
 
 		ACCUMULATOR& getAccumulator(AccumulatorBuffer<ACCUMULATOR>* buffer) { return (*buffer)[mAccumulatorIndex]; }
-		const ACCUMULATOR& getAccumulator(AccumulatorBuffer<ACCUMULATOR>* buffer) const { return (*buffer)[mAccumulatorIndex]; }
+		const ACCUMULATOR& getAccumulator(const AccumulatorBuffer<ACCUMULATOR>* buffer) const { return (*buffer)[mAccumulatorIndex]; }
 
 	protected:
 		std::string	mName;
@@ -213,9 +218,9 @@ namespace LLTrace
 			{
 				mMax = value;
 			}
-			F32 old_mean = mMean;
-			mMean += ((F32)value - old_mean) / (F32)mNumSamples;
-			mVarianceSum += ((F32)value - old_mean) * ((F32)value - mMean);
+			F64 old_mean = mMean;
+			mMean += ((F64)value - old_mean) / (F64)mNumSamples;
+			mVarianceSum += ((F64)value - old_mean) * ((F64)value - mMean);
 			mLastValue = value;
 		}
 
@@ -231,14 +236,14 @@ namespace LLTrace
 				mMax = other.mMax;
 			}
 			mNumSamples += other.mNumSamples;
-			F32 weight = (F32)mNumSamples / (F32)(mNumSamples + other.mNumSamples);
+			F64 weight = (F64)mNumSamples / (F64)(mNumSamples + other.mNumSamples);
 			mMean = mMean * weight + other.mMean * (1.f - weight);
 
-			F32 n_1 = (F32)mNumSamples,
-				n_2 = (F32)other.mNumSamples;
-			F32 m_1 = mMean,
+			F64 n_1 = (F64)mNumSamples,
+				n_2 = (F64)other.mNumSamples;
+			F64 m_1 = mMean,
 				m_2 = other.mMean;
-			F32 sd_1 = getStandardDeviation(),
+			F64 sd_1 = getStandardDeviation(),
 				sd_2 = other.getStandardDeviation();
 			// 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
@@ -275,8 +280,8 @@ namespace LLTrace
 		T	getMin() const { return mMin; }
 		T	getMax() const { return mMax; }
 		T	getLastValue() const { return mLastValue; }
-		F32	getMean() const { return mMean; }
-		F32 getStandardDeviation() const { return sqrtf(mVarianceSum / mNumSamples); }
+		F64	getMean() const { return mMean; }
+		F64 getStandardDeviation() const { return sqrtf(mVarianceSum / mNumSamples); }
 
 	private:
 		T	mSum,
@@ -284,17 +289,17 @@ namespace LLTrace
 			mMax,
 			mLastValue;
 
-		F32 mMean,
+		F64 mMean,
 			mVarianceSum;
 
 		U32	mNumSamples;
 	};
 
 	template<typename T>
-	class LL_COMMON_API RateAccumulator
+	class LL_COMMON_API CountAccumulator
 	{
 	public:
-		RateAccumulator()
+		CountAccumulator()
 		:	mSum(0),
 			mNumSamples(0)
 		{}
@@ -305,7 +310,7 @@ namespace LLTrace
 			mSum += value;
 		}
 
-		void addSamples(const RateAccumulator<T>& other)
+		void addSamples(const CountAccumulator<T>& other)
 		{
 			mSum += other.mSum;
 			mNumSamples += other.mNumSamples;
@@ -325,7 +330,7 @@ namespace LLTrace
 		U32	mNumSamples;
 	};
 
-	template <typename T, typename IS_UNIT = void>
+	template <typename T = F64, typename IS_UNIT = void>
 	class LL_COMMON_API Measurement
 	:	public TraceType<MeasurementAccumulator<T> >, 
 		public LLInstanceTracker<Measurement<T, IS_UNIT>, std::string>
@@ -352,8 +357,8 @@ namespace LLTrace
 	public:
 		typedef typename T::storage_t storage_t;
 		typedef typename T::base_unit_t base_unit_t;
-
 		typedef Measurement<typename T::value_t> base_measurement_t;
+
 		Measurement(const char* name, const char* description = NULL) 
 		:	Measurement<typename T::value_t>(name)
 		{}
@@ -361,20 +366,20 @@ namespace LLTrace
 		template<typename UNIT_T>
 		void sample(UNIT_T value)
 		{
-			base_measurement_t::sample(value.value());
+			base_measurement_t::sample(((T)value).value());
 		}
 	};
 
-	template <typename T, typename IS_UNIT = void>
-	class LL_COMMON_API Rate 
-	:	public TraceType<RateAccumulator<T> >, 
-		public LLInstanceTracker<Rate<T>, std::string>
+	template <typename T = F64, typename IS_UNIT = void>
+	class LL_COMMON_API Count 
+	:	public TraceType<CountAccumulator<T> >, 
+		public LLInstanceTracker<Count<T>, std::string>
 	{
 	public:
 		typedef T storage_t;
 		typedef T base_unit_t;
 
-		Rate(const char* name, const char* description = NULL) 
+		Count(const char* name, const char* description = NULL) 
 		:	TraceType(name),
 			LLInstanceTracker(name)
 		{}
@@ -386,53 +391,23 @@ namespace LLTrace
 	};
 
 	template <typename T>
-	class LL_COMMON_API Rate <T, typename T::is_unit_t>
-	:	public Rate<typename T::value_t>
+	class LL_COMMON_API Count <T, typename T::is_unit_t>
+	:	public Count<typename T::value_t>
 	{
 	public:
 		typedef typename T::storage_t storage_t;
 		typedef typename T::base_unit_t base_unit_t;
+		typedef Count<typename T::value_t> base_count_t;
 
-		Rate(const char* name, const char* description = NULL) 
-		:	Rate<typename T::value_t>(name)
+		Count(const char* name, const char* description = NULL) 
+		:	Count<typename T::value_t>(name)
 		{}
 
 		template<typename UNIT_T>
 		void add(UNIT_T value)
 		{
-			getPrimaryAccumulator().add(value.value());
-		}
-	};
-
-	template <typename T>
-	class LL_COMMON_API Count 
-	{
-	public:
-		typedef typename Rate<T>::base_unit_t base_unit_t;
-
-		Count(const char* name) 
-		:	mIncrease(name + "_increase"),
-			mDecrease(name + "_decrease"),
-			mTotal(name)
-		{}
-
-		void count(T value)
-		{
-			if (value < 0)
-			{
-				mDecrease.add(value * -1);
-			}
-			else
-			{
-				mIncrease.add(value);
-			}
-			mTotal.add(value);
+			base_count_t::add(((T)value).value());
 		}
-	private:
-		friend LLTrace::Recording;
-		Rate<T> mIncrease;
-		Rate<T> mDecrease;
-		Rate<T> mTotal;
 	};
 
 	class LL_COMMON_API TimerAccumulator
diff --git a/indra/llcommon/lltracerecording.cpp b/indra/llcommon/lltracerecording.cpp
index 5d7b231b7d..9a769ff344 100644
--- a/indra/llcommon/lltracerecording.cpp
+++ b/indra/llcommon/lltracerecording.cpp
@@ -39,8 +39,8 @@ namespace LLTrace
 
 Recording::Recording() 
 :	mElapsedSeconds(0),
-	mRates(new AccumulatorBuffer<RateAccumulator<F32> >()),
-	mMeasurements(new AccumulatorBuffer<MeasurementAccumulator<F32> >()),
+	mCounts(new AccumulatorBuffer<CountAccumulator<F64> >()),
+	mMeasurements(new AccumulatorBuffer<MeasurementAccumulator<F64> >()),
 	mStackTimers(new AccumulatorBuffer<TimerAccumulator>())
 {}
 
@@ -59,7 +59,7 @@ void Recording::update()
 
 void Recording::handleReset()
 {
-	mRates.write()->reset();
+	mCounts.write()->reset();
 	mMeasurements.write()->reset();
 	mStackTimers.write()->reset();
 
@@ -88,21 +88,22 @@ void Recording::handleSplitTo(Recording& other)
 
 void Recording::makePrimary()
 {
-	mRates.write()->makePrimary();
+	mCounts.write()->makePrimary();
 	mMeasurements.write()->makePrimary();
 	mStackTimers.write()->makePrimary();
 }
 
 bool Recording::isPrimary() const
 {
-	return mRates->isPrimary();
+	return mCounts->isPrimary();
 }
 
 void Recording::mergeRecording( const Recording& other )
 {
-	mRates.write()->addSamples(*other.mRates);
+	mCounts.write()->addSamples(*other.mCounts);
 	mMeasurements.write()->addSamples(*other.mMeasurements);
 	mStackTimers.write()->addSamples(*other.mStackTimers);
+	mElapsedSeconds += other.mElapsedSeconds;
 }
 
 ///////////////////////////////////////////////////////////////////////
@@ -149,9 +150,9 @@ Recording& PeriodicRecording::getTotalRecording()
 	if (!mTotalValid)
 	{
 		mTotalRecording.reset();
-		for (S32 i = (mCurPeriod + 1) % mNumPeriods; i < mCurPeriod; i++)
+		for (S32 i = mCurPeriod + 1; i < mCurPeriod + mNumPeriods; i++)
 		{
-			mTotalRecording.mergeRecording(mRecordingPeriods[i]);
+			mTotalRecording.mergeRecording(mRecordingPeriods[i % mNumPeriods]);
 		}
 	}
 	mTotalValid = true;
@@ -212,7 +213,6 @@ void ExtendableRecording::handleSplitTo( ExtendableRecording& other )
 PeriodicRecording& get_frame_recording()
 {
 	static PeriodicRecording sRecording(64);
-	sRecording.start();
 	return sRecording;
 }
 
diff --git a/indra/llcommon/lltracerecording.h b/indra/llcommon/lltracerecording.h
index 924a7bffd5..d9ac8c327a 100644
--- a/indra/llcommon/lltracerecording.h
+++ b/indra/llcommon/lltracerecording.h
@@ -111,17 +111,17 @@ namespace LLTrace
 
 		void update();
 
-		// Rate accessors
+		// Count accessors
 		template <typename T, typename IS_UNIT>
-		typename Rate<T, IS_UNIT>::base_unit_t getSum(const Rate<T, IS_UNIT>& stat) const
+		typename Count<T, IS_UNIT>::base_unit_t getSum(const Count<T, IS_UNIT>& stat) const
 		{
-			return (typename Rate<T, IS_UNIT>::base_unit_t)stat.getAccumulator(mRates).getSum();
+			return (typename Count<T, IS_UNIT>::base_unit_t)stat.getAccumulator(mCounts).getSum();
 		}
 
 		template <typename T, typename IS_UNIT>
-		typename Rate<T, IS_UNIT>::base_unit_t getPerSec(const Rate<T, IS_UNIT>& stat) const
+		typename Count<T, IS_UNIT>::base_unit_t getPerSec(const Count<T, IS_UNIT>& stat) const
 		{
-			return (typename Rate<T, IS_UNIT>::base_unit_t)stat.getAccumulator(mRates).getSum() / mElapsedSeconds;
+			return (typename Count<T, IS_UNIT>::base_unit_t)stat.getAccumulator(mCounts).getSum() / mElapsedSeconds;
 		}
 
 		// Measurement accessors
@@ -135,7 +135,7 @@ namespace LLTrace
 		template <typename T, typename IS_UNIT>
 		typename Measurement<T, IS_UNIT>::base_unit_t getPerSec(const Measurement<T, IS_UNIT>& stat) const
 		{
-			return (typename Rate<T, IS_UNIT>::base_unit_t)stat.getAccumulator(mMeasurements).getSum() / mElapsedSeconds;
+			return (typename Count<T, IS_UNIT>::base_unit_t)stat.getAccumulator(mMeasurements).getSum() / mElapsedSeconds;
 		}
 
 		template <typename T, typename IS_UNIT>
@@ -151,7 +151,7 @@ namespace LLTrace
 		}
 
 		template <typename T, typename IS_UNIT>
-		typename Measurement<T, IS_UNIT>::base_unit_t getMean(const Measurement<T, IS_UNIT>& stat) const
+		typename Measurement<T, IS_UNIT>::base_unit_t getMean(Measurement<T, IS_UNIT>& stat) const
 		{
 			return (typename Measurement<T, IS_UNIT>::base_unit_t)stat.getAccumulator(mMeasurements).getMean();
 		}
@@ -168,56 +168,7 @@ namespace LLTrace
 			return (typename Measurement<T, IS_UNIT>::base_unit_t)stat.getAccumulator(mMeasurements).getLastValue();
 		}
 
-		// Count accessors
-		template <typename T>
-		typename Count<T>::base_unit_t getSum(const Count<T>& stat) const
-		{
-			return getSum(stat.mTotal);
-		}
-
-		template <typename T>
-		typename Count<T>::base_unit_t getPerSec(const Count<T>& stat) const
-		{
-			return getPerSec(stat.mTotal);
-		}
-
-		template <typename T>
-		typename Count<T>::base_unit_t getIncrease(const Count<T>& stat) const
-		{
-			return getPerSec(stat.mTotal);
-		}
-
-		template <typename T>
-		typename Count<T>::base_unit_t getIncreasePerSec(const Count<T>& stat) const
-		{
-			return getPerSec(stat.mIncrease);
-		}
-
-		template <typename T>
-		typename Count<T>::base_unit_t getDecrease(const Count<T>& stat) const
-		{
-			return getPerSec(stat.mDecrease);
-		}
-
-		template <typename T>
-		typename Count<T>::base_unit_t getDecreasePerSec(const Count<T>& stat) const
-		{
-			return getPerSec(stat.mDecrease);
-		}
-
-		template <typename T>
-		typename Count<T>::base_unit_t getChurn(const Count<T>& stat) const
-		{
-			return getIncrease(stat) + getDecrease(stat);
-		}
-
-		template <typename T>
-		typename Count<T>::base_unit_t getChurnPerSec(const Count<T>& stat) const
-		{
-			return getIncreasePerSec(stat) + getDecreasePerSec(stat);
-		}
-
-		F64 getSampleTime() const { return mElapsedSeconds; }
+		F64 getDuration() const { return mElapsedSeconds; }
 
 		// implementation for LLVCRControlsMixin
 		/*virtual*/ void handleStart();
@@ -230,8 +181,8 @@ namespace LLTrace
 		// returns data for current thread
 		class ThreadRecorder* getThreadRecorder(); 
 
-		LLCopyOnWritePointer<AccumulatorBuffer<RateAccumulator<F32> > >			mRates;
-		LLCopyOnWritePointer<AccumulatorBuffer<MeasurementAccumulator<F32> > >	mMeasurements;
+		LLCopyOnWritePointer<AccumulatorBuffer<CountAccumulator<F64> > >		mCounts;
+		LLCopyOnWritePointer<AccumulatorBuffer<MeasurementAccumulator<F64> > >	mMeasurements;
 		LLCopyOnWritePointer<AccumulatorBuffer<TimerAccumulator> >				mStackTimers;
 
 		LLTimer			mSamplingTimer;
diff --git a/indra/llcommon/lltracethreadrecorder.cpp b/indra/llcommon/lltracethreadrecorder.cpp
index 48aa1a42f2..02dc55771b 100644
--- a/indra/llcommon/lltracethreadrecorder.cpp
+++ b/indra/llcommon/lltracethreadrecorder.cpp
@@ -114,10 +114,10 @@ ThreadRecorder::ActiveRecording::ActiveRecording( Recording* target )
 void ThreadRecorder::ActiveRecording::moveBaselineToTarget()
 {
 	mTargetRecording->mMeasurements.write()->addSamples(*mBaseline.mMeasurements);
-	mTargetRecording->mRates.write()->addSamples(*mBaseline.mRates);
+	mTargetRecording->mCounts.write()->addSamples(*mBaseline.mCounts);
 	mTargetRecording->mStackTimers.write()->addSamples(*mBaseline.mStackTimers);
 	mBaseline.mMeasurements.write()->reset();
-	mBaseline.mRates.write()->reset();
+	mBaseline.mCounts.write()->reset();
 	mBaseline.mStackTimers.write()->reset();
 }
 
diff --git a/indra/llcommon/llunit.h b/indra/llcommon/llunit.h
index 2664bd77e9..090e42607e 100644
--- a/indra/llcommon/llunit.h
+++ b/indra/llcommon/llunit.h
@@ -51,7 +51,7 @@ struct LLUnitType : public BASE_UNIT
 
 	value_t value() const
 	{
-		return convertToDerived(mValue);
+		return convertToDerived(mBaseValue);
 	}
 
 	template<typename CONVERTED_TYPE>
@@ -72,22 +72,22 @@ struct LLUnitType : public BASE_UNIT
 
 	unit_t operator + (const unit_t other) const
 	{
-		return unit_t(mValue + other.mValue);
+		return unit_t(mBaseValue + other.mBaseValue);
 	}
 
 	unit_t operator - (const unit_t other) const
 	{
-		return unit_t(mValue - other.mValue);
+		return unit_t(mBaseValue - other.mBaseValue);
 	}
 
 	unit_t operator * (value_t multiplicand) const
 	{
-		return unit_t(mValue * multiplicand);
+		return unit_t(mBaseValue * multiplicand);
 	}
 
 	unit_t operator / (value_t divisor) const
 	{
-		return unit_t(mValue / divisor);
+		return unit_t(mBaseValue / divisor);
 	}
 
 };
@@ -100,11 +100,11 @@ struct LLUnitType<STORAGE_TYPE, T, T>
 	typedef void is_unit_t;
 
 	LLUnitType()
-	:	mValue()
+	:	mBaseValue()
 	{}
 
 	explicit LLUnitType(value_t value)
-	:	mValue(value)
+	:	mBaseValue(value)
 	{}
 
 	unit_t& operator=(value_t value)
@@ -118,7 +118,7 @@ struct LLUnitType<STORAGE_TYPE, T, T>
 		return static_cast<unit_t&>(*this);
 	}
 
-	value_t value() { return mValue; }
+	value_t value() const { return mBaseValue; }
 
 	static value_t convertToBase(value_t derived_value)
 	{
@@ -132,73 +132,73 @@ struct LLUnitType<STORAGE_TYPE, T, T>
 
 	unit_t operator + (const unit_t other) const
 	{
-		return unit_t(mValue + other.mValue);
+		return unit_t(mBaseValue + other.mBaseValue);
 	}
 
 	void operator += (const unit_t other)
 	{
-		mValue += other.mValue;
+		mBaseValue += other.mBaseValue;
 	}
 
 	unit_t operator - (const unit_t other) const
 	{
-		return unit_t(mValue - other.mValue);
+		return unit_t(mBaseValue - other.mBaseValue);
 	}
 
 	void operator -= (const unit_t other)
 	{
-		mValue -= other.mValue;
+		mBaseValue -= other.mBaseValue;
 	}
 
 	unit_t operator * (value_t multiplicand) const
 	{
-		return unit_t(mValue * multiplicand);
+		return unit_t(mBaseValue * multiplicand);
 	}
 
 	void operator *= (value_t multiplicand)
 	{
-		mValue *= multiplicand;
+		mBaseValue *= multiplicand;
 	}
 
 	unit_t operator / (value_t divisor) const
 	{
-		return unit_t(mValue / divisor);
+		return unit_t(mBaseValue / divisor);
 	}
 
 	void operator /= (value_t divisor)
 	{
-		mValue /= divisor;
+		mBaseValue /= divisor;
 	}
 
 protected:
 	void setBaseValue(value_t value)
 	{
-		mValue = value;
+		mBaseValue = value;
 	}
 
-	value_t mValue;
+	value_t mBaseValue;
 };
 
-#define LL_DECLARE_BASE_UNIT(unit_name)                 \
-	template<typename STORAGE_TYPE>                     \
-	struct unit_name : public LLUnitType<STORAGE_TYPE, unit_name<STORAGE_TYPE> >            \
-	{                                                   \
-		typedef unit_name<STORAGE_TYPE> base_unit_t;                                        \
-		typedef STORAGE_TYPE			storage_t;			                                \
+#define LL_DECLARE_BASE_UNIT(unit_name)                                                     \
+	struct unit_name : public LLUnitType<F64, unit_name>									\
+	{                                                                                       \
+		typedef unit_name base_unit_t;                                                      \
+		typedef LLUnitType<F64, unit_name> unit_t;						                    \
+		typedef F64			storage_t;			                                            \
 	                                                                                        \
-		unit_name(STORAGE_TYPE value)                   \
+		unit_name(F64 value)                                                                \
 		:	LLUnitType(value)                                                               \
-		{}                                              \
-		                                                \
-		unit_name()                                     \
-		{}                                              \
-		                                                \
+		{}                                                                                  \
+		                                                                                    \
+		unit_name()                                                                         \
+		{}                                                                                  \
+		                                                                                    \
 		template <typename SOURCE_STORAGE_TYPE, typename SOURCE_TYPE>                       \
 		unit_name(const LLUnitType<SOURCE_STORAGE_TYPE, unit_name, SOURCE_TYPE>& source)    \
-		{                                               \
-			setBaseValue(source.unit_t::value());												\
-		}                                               \
-		                                                \
+		{                                                                                   \
+			setBaseValue((F64)source.unit_name::unit_t::value());				            \
+		}                                                                                   \
+		                                                                                    \
 		using LLUnitType::operator +;	                                                    \
 		using LLUnitType::operator +=;														\
 		using LLUnitType::operator -;														\
@@ -209,36 +209,36 @@ protected:
 		using LLUnitType::operator /=;														\
 	};
 
-#define LL_DECLARE_DERIVED_UNIT(base_unit, derived_unit, conversion_factor)                   \
-	template<typename STORAGE_TYPE>                                                           \
-	struct derived_unit : public LLUnitType<STORAGE_TYPE, base_unit<STORAGE_TYPE>, derived_unit<STORAGE_TYPE> >     \
-	{                                                                                         \
-		typedef base_unit<STORAGE_TYPE> base_unit_t;                                                                \
-		typedef STORAGE_TYPE			storage_t;							                                        \
-		                                                                                                            \
-		derived_unit(value_t value)                                                           \
-		:	LLUnitType(value)                                                                                       \
-		{}                                                                                    \
-		                                                                                      \
-		derived_unit()                                                                        \
-		{}                                                                                    \
-		                                                                                      \
-		template <typename SOURCE_STORAGE_TYPE, typename SOURCE_TYPE>                                               \
-		derived_unit(const LLUnitType<SOURCE_STORAGE_TYPE, base_unit<STORAGE_TYPE>, SOURCE_TYPE>& source)           \
-		{                                                                                     \
-			setBaseValue(source.base_unit_t::value());																\
-		}                                                                                     \
-		                                                                                      \
-		static F32 conversionToBaseFactor() { return (F32)(conversion_factor); }              \
-		                                                                                      \
-		using LLUnitType::operator +;	                                                                            \
-		using LLUnitType::operator +=;                                                                              \
-		using LLUnitType::operator -;                                                                               \
-		using LLUnitType::operator -=;                                                                              \
-		using LLUnitType::operator *;                                                                               \
-		using LLUnitType::operator *=;                                                                              \
-		using LLUnitType::operator /;                                                                               \
-		using LLUnitType::operator /=;                                                                              \
+#define LL_DECLARE_DERIVED_UNIT(base_unit, derived_unit, conversion_factor)                 \
+	struct derived_unit : public LLUnitType<F64, base_unit, derived_unit>                   \
+	{                                                                                       \
+		typedef base_unit base_unit_t;                                                      \
+		typedef LLUnitType<F64, base_unit, derived_unit> unit_t;				            \
+		typedef F64			storage_t;							                            \
+		                                                                                    \
+		derived_unit(value_t value)                                                         \
+		:	LLUnitType(value)                                                               \
+		{}                                                                                  \
+		                                                                                    \
+		derived_unit()                                                                      \
+		{}                                                                                  \
+		                                                                                    \
+		template <typename SOURCE_STORAGE_TYPE, typename SOURCE_TYPE>                       \
+		derived_unit(const LLUnitType<SOURCE_STORAGE_TYPE, base_unit, SOURCE_TYPE>& source) \
+		{                                                                                   \
+			setBaseValue((F64)source.base_unit::unit_t::value());						    \
+		}                                                                                   \
+		                                                                                    \
+		static F32 conversionToBaseFactor() { return (F32)(conversion_factor); }            \
+		                                                                                    \
+		using LLUnitType::operator +;	                                                    \
+		using LLUnitType::operator +=;                                                      \
+		using LLUnitType::operator -;                                                       \
+		using LLUnitType::operator -=;                                                      \
+		using LLUnitType::operator *;                                                       \
+		using LLUnitType::operator *=;                                                      \
+		using LLUnitType::operator /;                                                       \
+		using LLUnitType::operator /=;                                                      \
 	};
 
 namespace LLUnits
@@ -248,7 +248,7 @@ namespace LLUnits
 	LL_DECLARE_DERIVED_UNIT(Bytes, Megabytes, 1024 * 1024);
 	LL_DECLARE_DERIVED_UNIT(Bytes, Gigabytes, 1024 * 1024 * 1024);
 	LL_DECLARE_DERIVED_UNIT(Bytes, Bits,	  (1.f / 8.f));
-	LL_DECLARE_DERIVED_UNIT(Bytes, Kilobit,   (1024 / 8));
+	LL_DECLARE_DERIVED_UNIT(Bytes, Kilobits,  (1024 / 8));
 	LL_DECLARE_DERIVED_UNIT(Bytes, Megabits,  (1024 / 8));
 	LL_DECLARE_DERIVED_UNIT(Bytes, Gigabits,  (1024 * 1024 * 1024 / 8));