SH-3405 WIP convert existing stats to lltrace system

SH-3403 FIX implement unit conversion
LLUnit implements unit tracking and conversion
added support for LLUnit to LLTrace
duplicated most llstats into LLTrace equivalents

indra/llcommon/CMakeLists.txt

@@ -247,6 +247,7 @@ set(llcommon_HEADER_FILES
     lltracerecording.h
     lltreeiterators.h
     lltypeinfolookup.h
+    llunit.h
     lluri.h
     lluuid.h
     lluuidhashmap.h

indra/llcommon/lltrace.h

@@ -35,6 +35,7 @@
 #include "lltimer.h"
 #include "llrefcount.h"
 #include "lltracerecording.h"
+#include "llunit.h"
 
 #include <list>
 
@@ -42,11 +43,8 @@
 #define TOKEN_PASTE(x, y) TOKEN_PASTE_ACTUAL(x, y)
 #define RECORD_BLOCK_TIME(block_timer) LLTrace::BlockTimer::Recorder TOKEN_PASTE(block_time_recorder, __COUNTER__)(block_timer);
 
-
 namespace LLTrace
 {
-	class Recording;
-
 	void init();
 	void cleanup();
 
@@ -325,10 +323,10 @@ namespace LLTrace
 		U32	mNumSamples;
 	};
 
-	template <typename T>
+	template <typename T, typename IS_UNIT = void>
 	class LL_COMMON_API Measurement
 	:	public TraceType<MeasurementAccumulator<T> >, 
-		public LLInstanceTracker<Measurement<T>, std::string>
+		public LLInstanceTracker<Measurement<T, IS_UNIT>, std::string>
 	{
 	public:
 		Measurement(const std::string& name) 
@@ -343,13 +341,37 @@ namespace LLTrace
 	};
 
 	template <typename T>
+	class LL_COMMON_API Measurement <T, typename T::is_unit_t>
+	:	public Measurement<typename T::value_t>
+	{
+	public:
+		typedef Measurement<typename T::value_t> base_measurement_t;
+		Measurement(const std::string& name) 
+		:	Measurement<typename T::value_t>(name)
+		{}
+
+		template<typename UNIT_T>
+		void sample(UNIT_T value)
+		{
+			base_measurement_t::sample(value.get());
+		}
+
+		template<typename UNIT_T>
+		typename T::value_t get()
+		{
+			UNIT_T value(*this);
+			return value.get();
+		}
+	};
+
+	template <typename T, typename IS_UNIT = void>
 	class LL_COMMON_API Rate 
-		:	public TraceType<RateAccumulator<T> >, 
+	:	public TraceType<RateAccumulator<T> >, 
 		public LLInstanceTracker<Rate<T>, std::string>
 	{
 	public:
 		Rate(const std::string& name) 
-			:	TraceType(name),
+		:	TraceType(name),
 			LLInstanceTracker(name)
 		{}
 
@@ -359,6 +381,30 @@ namespace LLTrace
 		}
 	};
 
+	template <typename T>
+	class LL_COMMON_API Rate <T, typename T::is_unit_t>
+	:	public Rate<typename T::value_t>
+	{
+	public:
+		Rate(const std::string& name) 
+		:	Rate<typename T::value_t>(name)
+		{}
+
+		template<typename UNIT_T>
+		void add(UNIT_T value)
+		{
+			getPrimaryAccumulator().add(value.get());
+		}
+
+		template<typename UNIT_T>
+		typename T::value_t get()
+		{
+			UNIT_T value(*this);
+			return value.get();
+		}
+
+	};
+
 	class LL_COMMON_API TimerAccumulator
 	{
 	public:
@@ -482,6 +528,8 @@ namespace LLTrace
 		static Recorder::StackEntry sCurRecorder;
 	};
 
+	class Recording;
+
 	class LL_COMMON_API ThreadRecorder
 	{
 	public:

indra/llcommon/lltracerecording.h

@@ -35,8 +35,8 @@
 
 namespace LLTrace
 {
-	template<typename T> class Rate;
-	template<typename T> class Measurement;
+	template<typename T, typename IS_UNIT> class Rate;
+	template<typename T, typename IS_UNIT> class Measurement;
 	template<typename T> class AccumulatorBuffer;
 	template<typename T> class RateAccumulator;
 	template<typename T> class MeasurementAccumulator;
@@ -63,14 +63,14 @@ namespace LLTrace
 
 		bool isStarted() { return mIsStarted; }
 
-		F32 getSum(Rate<F32>& stat);
-		F32 getPerSec(Rate<F32>& stat);
+		F32 getSum(Rate<F32, void>& stat);
+		F32 getPerSec(Rate<F32, void>& stat);
 
-		F32 getSum(Measurement<F32>& stat);
-		F32 getMin(Measurement<F32>& stat);
-		F32 getMax(Measurement<F32>& stat);
-		F32 getMean(Measurement<F32>& stat);
-		F32 getStandardDeviation(Measurement<F32>& stat);
+		F32 getSum(Measurement<F32, void>& stat);
+		F32 getMin(Measurement<F32, void>& stat);
+		F32 getMax(Measurement<F32, void>& stat);
+		F32 getMean(Measurement<F32, void>& stat);
+		F32 getStandardDeviation(Measurement<F32, void>& stat);
 
 		F64 getSampleTime() { return mElapsedSeconds; }
 

indra/llcommon/llunit.h

+/** 
+ * @file llunit.h
+ * @brief Unit conversion classes
+ *
+ * $LicenseInfo:firstyear=2001&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2012, Linden Research, Inc.
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ * 
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+
+#ifndef LL_LLUNIT_H
+#define LL_LLUNIT_H
+
+#include "stdtypes.h"
+#include "llpreprocessor.h"
+
+template<typename BASE_UNIT, typename DERIVED_UNIT = BASE_UNIT>
+struct LLUnit : public BASE_UNIT
+{
+	typedef LLUnit<BASE_UNIT, DERIVED_UNIT> unit_t;
+	typedef typename BASE_UNIT::value_t value_t;
+	typedef void is_unit_t;
+
+	LLUnit()
+	{}
+
+	explicit LLUnit(value_t value)
+	:	BASE_UNIT(convertToBase(value))
+	{}
+
+	operator value_t() { return get(); }
+
+	value_t get() const
+	{
+		return convertToDerived(mValue);
+	}
+
+	static value_t convertToBase(value_t derived_value)
+	{
+		return (value_t)((F32)derived_value * DERIVED_UNIT::conversionToBaseFactor());
+	}
+
+	static value_t convertToDerived(value_t base_value)
+	{
+		return (value_t)((F32)base_value / DERIVED_UNIT::conversionToBaseFactor());
+	}
+
+};
+
+template<typename T>
+struct LLUnit<T, T>
+{
+	typedef LLUnit<T, T> unit_t;
+	typedef T value_t;
+	typedef void is_unit_t;
+
+	LLUnit()
+	:	mValue()
+	{}
+
+	explicit LLUnit(T value)
+	:	mValue(value)
+	{}
+
+	unit_t& operator=(T value)
+	{
+		setBaseValue(value);
+		return *this;
+	}
+
+	value_t get() { return mValue; }
+
+	static value_t convertToBase(value_t derived_value)
+	{
+		return (value_t)1;
+	}
+
+	static value_t convertToDerived(value_t base_value)
+	{
+		return (value_t)1;
+	}
+
+	unit_t operator + (const unit_t other) const
+	{
+		return unit_t(mValue + other.mValue);
+	}
+
+	void operator += (const unit_t other)
+	{
+		mValue += other.mValue;
+	}
+
+	unit_t operator - (const unit_t other) const
+	{
+		return unit_t(mValue - other.mValue);
+	}
+
+	void operator -= (const unit_t other)
+	{
+		mValue -= other.mValue;
+	}
+
+	unit_t operator * (value_t multiplicand) const
+	{
+		return unit_t(mValue * multiplicand);
+	}
+
+	void operator *= (value_t multiplicand)
+	{
+		mValue *= multiplicand;
+	}
+
+	unit_t operator / (value_t divisor) const
+	{
+		return unit_t(mValue / divisor);
+	}
+
+	void operator /= (value_t divisor)
+	{
+		mValue /= divisor;
+	}
+
+protected:
+	void setBaseValue(T value)
+	{
+		mValue = value;
+	}
+
+	T mValue;
+};
+
+#define LL_DECLARE_BASE_UNIT(unit_name)                 \
+	template<typename STORAGE_TYPE>                     \
+	struct unit_name : public LLUnit<STORAGE_TYPE>      \
+	{                                                   \
+		unit_name(STORAGE_TYPE value)                   \
+		:	LLUnit(value)                               \
+		{}                                              \
+		                                                \
+		unit_name()                                     \
+		{}                                              \
+		                                                \
+		template <typename T>                           \
+		unit_name(const LLUnit<unit_name, T>& other)    \
+		{                                               \
+			setBaseValue(other.unit_name::get());       \
+		}                                               \
+		                                                \
+		using LLUnit<STORAGE_TYPE>::operator +;	        \
+		using LLUnit<STORAGE_TYPE>::operator +=;        \
+		using LLUnit<STORAGE_TYPE>::operator -;         \
+		using LLUnit<STORAGE_TYPE>::operator -=;        \
+		using LLUnit<STORAGE_TYPE>::operator *;         \
+		using LLUnit<STORAGE_TYPE>::operator *=;        \
+		using LLUnit<STORAGE_TYPE>::operator /;         \
+		using LLUnit<STORAGE_TYPE>::operator /=;        \
+	};
+
+#define LL_DECLARE_DERIVED_UNIT(base_unit, derived_unit, conversion_factor)                   \
+	template<typename STORAGE_TYPE>                                                           \
+	struct derived_unit : public LLUnit<base_unit<STORAGE_TYPE>, derived_unit<STORAGE_TYPE> > \
+	{                                                                                         \
+		derived_unit(value_t value)                                                           \
+		:	LLUnit(value)                                                                     \
+		{}                                                                                    \
+		                                                                                      \
+		derived_unit()                                                                        \
+		{}                                                                                    \
+		                                                                                      \
+		template <typename T>                                                                 \
+		derived_unit(const LLUnit<base_unit<STORAGE_TYPE>, T>& other)                         \
+		{                                                                                     \
+			setBaseValue(other.base_unit<STORAGE_TYPE>::get());                               \
+		}                                                                                     \
+		                                                                                      \
+		static F32 conversionToBaseFactor() { return (F32)(conversion_factor); }              \
+		                                                                                      \
+	using LLUnit<STORAGE_TYPE>::operator +;	                                                  \
+	using LLUnit<STORAGE_TYPE>::operator +=;                                                  \
+	using LLUnit<STORAGE_TYPE>::operator -;                                                   \
+	using LLUnit<STORAGE_TYPE>::operator -=;                                                  \
+	using LLUnit<STORAGE_TYPE>::operator *;                                                   \
+	using LLUnit<STORAGE_TYPE>::operator *=;                                                  \
+	using LLUnit<STORAGE_TYPE>::operator /;                                                   \
+	using LLUnit<STORAGE_TYPE>::operator /=;                                                  \
+	};
+
+namespace LLUnits
+{
+	LL_DECLARE_BASE_UNIT(Bytes);
+	LL_DECLARE_DERIVED_UNIT(Bytes, Kilobytes, 1024);
+	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, Megabits,  (1024 / 8));
+	LL_DECLARE_DERIVED_UNIT(Bytes, Gigabits,  (1024 * 1024 * 1024 / 8));
+
+	LL_DECLARE_BASE_UNIT(Seconds);
+	LL_DECLARE_DERIVED_UNIT(Seconds, Minutes,		60);
+	LL_DECLARE_DERIVED_UNIT(Seconds, Hours,			60 * 60);
+	LL_DECLARE_DERIVED_UNIT(Seconds, Days,			60 * 60 * 24);
+	LL_DECLARE_DERIVED_UNIT(Seconds, Weeks,			60 * 60 * 24 * 7);
+	LL_DECLARE_DERIVED_UNIT(Seconds, Milliseconds,	(1.f / 1000.f));
+	LL_DECLARE_DERIVED_UNIT(Seconds, Microseconds,	(1.f / (1000000.f)));
+	LL_DECLARE_DERIVED_UNIT(Seconds, Nanoseconds,	(1.f / (1000000000.f)));
+
+}
+
+#endif // LL_LLUNIT_H

indra/newview/llstatusbar.cpp

@@ -198,7 +198,7 @@ BOOL LLStatusBar::postBuild()
 	sgp.rect(r);
 	sgp.follows.flags(FOLLOWS_BOTTOM | FOLLOWS_RIGHT);
 	sgp.mouse_opaque(false);
-	sgp.stat.rate_stat(&STAT_KBIT);
+	sgp.stat.rate_stat(&LLStatViewer::KBIT);
 	sgp.units("Kbps");
 	sgp.precision(0);
 	mSGBandwidth = LLUICtrlFactory::create<LLStatGraph>(sgp);

indra/newview/llviewerstats.cpp

@@ -61,21 +61,128 @@
 #include "llviewernetwork.h"
 #include "llmeshrepository.h" //for LLMeshRepository::sBytesReceived
 
+namespace LLStatViewer
+{
 
-LLTrace::Rate<F32>	STAT_KBIT("kbitstat"),
-					STAT_LAYERS_KBIT("layerskbitstat"),
-					STAT_OBJECT_KBIT("objectkbitstat"),
-					STAT_ASSET_KBIT("assetkbitstat"),
-					STAT_TEXTURE_KBIT("texturekbitstat");
-
+LLTrace::Rate<F32>					FPS("fpsstat"),
+									PACKETS_IN("packetsinstat"),
+									PACKETS_LOST("packetsloststat"),
+									PACKETS_OUT("packetsoutstat"),
+									TEXTURE_PACKETS("texturepacketsstat"),
+									TRIANGLES_DRAWN("trianglesdrawnstat"),
+									CHAT_COUNT("chatcount"),
+									IM_COUNT("imcount"),
+									OBJECT_CREATE("objectcreate"),
+									OBJECT_REZ("objectrez"),
+									LOADING_WEARABLES_LONG_DELAY("loadingwearableslongdelay"),
+									LOGIN_TIMEOUTS("logintimeouts"),
+									FAILED_DOWNLOADS("faileddownloads"),
+									LSL_SAVES("lslsaves"),
+									ANIMATION_UPLOADS("animationuploads"),
+									FLY("fly"),
+									TELEPORT("teleport"),
+									DELETE_OBJECT("deleteobject"),
+									SNAPSHOT("snapshot"),
+									UPLOAD_SOUND("uploadsound"),
+									UPLOAD_TEXTURE("uploadtexture"),
+									EDIT_TEXTURE("edittexture"),
+									KILLED("killed"),
+									FRAMETIME_DOUBLED("frametimedoubled"),
+									TEX_BAKES("texbakes"),
+									TEX_REBAKES("texrebakes");
+LLTrace::Rate<LLUnits::Bytes<F32> >	KBIT("kbitstat"),
+									LAYERS_KBIT("layerskbitstat"),
+									OBJECT_KBIT("objectkbitstat"),
+									ASSET_KBIT("assetkbitstat"),
+									TEXTURE_KBIT("texturekbitstat"),
+									ACTUAL_IN_KBIT("actualinkbit"),
+									ACTUAL_OUT_KBIT("actualoutkbit");
+
+LLTrace::Rate<LLUnits::Seconds<F32> > AVATAR_EDIT_TIME("avataredittimr"),
+									 TOOLBOX_TIME("toolboxtime"),
+									 MOUSELOOK_TIME("mouselooktime"),
+									 FPS_10_TIME("fps10time"),
+									 FPS_8_TIME("fps8time"),
+									 FPS_2_TIME("fps2time"),
+									 SIM_20_FPS_TIME("sim20fpstime"),
+									 SIM_PHYSICS_20_FPS_TIME("simphysics20fpstime"),
+									 LOSS_5_PERCENT_TIME("loss5percenttime");
+
+LLTrace::Measurement<F32>			SIM_TIME_DILATION("simtimedilation"),
+									SIM_FPS("simfps"),
+									SIM_PHYSICS_FPS("simphysicsfps"),
+									SIM_AGENT_UPS("simagentups"),
+									SIM_SCRIPT_EPS("simscripteps"),
+									SIM_SKIPPED_SILHOUETTE("simsimskippedsilhouettesteps"),
+									SIM_SKIPPED_CHARACTERS_PERCENTAGE("simsimpctsteppedcharacters"),
+									SIM_MAIN_AGENTS("simmainagents"),
+									SIM_CHILD_AGENTS("simchildagents"),
+									SIM_OBJECTS("simobjects"),
+									SIM_ACTIVE_OBJECTS("simactiveobjects"),
+									SIM_ACTIVE_SCRIPTS("simactivescripts"),
+									SIM_PERCENTAGE_SCRIPTS_RUN("simpctscriptsrun"),
+									SIM_IN_PACKETS_PER_SEC("siminpps"),
+									SIM_OUT_PACKETS_PER_SEC("simoutpps"),
+									SIM_PENDING_DOWNLOADS("simpendingdownloads"),
+									SIM_PENDING_UPLOADS("simpendinguploads"),
+									SIM_PENING_LOCAL_UPLOADS("simpendinglocaluploads"),
+									SIM_PHYSICS_PINNED_TASKS("physicspinnedtasks"),
+									SIM_PHYSICS_LOD_TASKS("physicslodtasks"),
+									NUM_IMAGES("numimagesstat"),
+									NUM_RAW_IMAGES("numrawimagesstat"),
+									NUM_OBJECTS("numobjectsstat"),
+									NUM_ACTIVE_OBJECTS("numactiveobjectsstat"),
+									NUM_NEW_OBJECTS("numnewobjectsstat"),
+									NUM_SIZE_CULLED("numsizeculledstat"),
+									NUM_VIS_CULLED("numvisculledstat"),
+									ENABLE_VBO("enablevbo"),
+									DELTA_BANDWIDTH("deltabandwidth"),
+									MAX_BANDWIDTH("maxbandwidth"),
+									LIGHTING_DETAIL("lightingdetail"),
+									VISIBLE_AVATARS("visibleavatars"),
+									SHADER_OBJECTS("shaderobjects"),
+									DRAW_DISTANCE("drawdistance"),
+									CHAT_BUBBLES("chatbubbles"),
+									WINDOW_WIDTH("windowwidth"),
+									WINDOW_HEIGHT("windowheight");
+
+LLTrace::Measurement<LLUnits::Bytes<F32> >	SIM_UNACKED_BYTES("simtotalunackedbytes"),
+											SIM_PHYSICS_MEM("physicsmemoryallocated"),
+											GL_TEX_MEM("gltexmemstat"),
+											GL_BOUND_MEM("glboundmemstat"),
+											RAW_MEM("rawmemstat"),
+											FORMATTED_MEM("formattedmemstat");
+
+
+LLTrace::Measurement<LLUnits::Seconds<F32> > SIM_PHYSICS_TIME("simsimphysicsmsec"),
+											SIM_PHYSICS_STEP_TIME("simsimphysicsstepmsec"),
+											SIM_PHYSICS_SHAPE_UPDATE_TIME("simsimphysicsshapeupdatemsec"),
+											SIM_PHYSICS_OTHER_TIME("simsimphysicsothermsec"),
+											SIM_AI_TIME("simsimaistepmsec"),
+											SIM_AGENTS_TIME("simagentmsec"),
+											SIM_IMAGES_TIME("simimagesmsec"),
+											SIM_SCRIPTS_TIME("simscriptmsec"),
+											SIM_SPARE_TIME("simsparemsec"),
+											SIM_SLEEP_TIME("simsleepmsec"),
+											SIM_PUMP_IO_TIME("simpumpiomsec"),
+											SIM_PING("simpingstat"),
+											LOGIN_SECONDS("loginseconds"),
+											REGION_CROSSING_TIME("regioncrossingtime"),
+											FRAME_STACKTIME("framestacktime"),
+											UPDATE_STACKTIME("updatestacktime"),
+											NETWORK_STACKTIME("networkstacktime"),
+											IMAGE_STACKTIME("imagestacktime"),
+											REBUILD_STACKTIME("rebuildstacktime"),
+											RENDER_STACKTIME("renderstacktime");
+}
 
 class StatAttributes
 {
 public:
 	StatAttributes(const char* name,
 				   const BOOL enabled)
-		: mName(name),
-		  mEnabled(enabled)
+	:	mName(name),
+		mEnabled(enabled)
 	{
 	}
 	
@@ -465,12 +572,12 @@ void update_statistics()
 
 	stats.mFPSStat.addValue(1);
 	F32 layer_bits = (F32)(gVLManager.getLandBits() + gVLManager.getWindBits() + gVLManager.getCloudBits());
-	STAT_LAYERS_KBIT.add(layer_bits/1024.f);
+	LLStatViewer::LAYERS_KBIT.add<LLUnits::Bits<F32> >(layer_bits);
 	//stats.mLayersKBitStat.addValue(layer_bits/1024.f);
-	STAT_OBJECT_KBIT.add(gObjectBits/1024.f);
+	LLStatViewer::OBJECT_KBIT.add<LLUnits::Bits<F32> >(gObjectBits);
 	//stats.mObjectKBitStat.addValue(gObjectBits/1024.f);
 	stats.mVFSPendingOperations.addValue(LLVFile::getVFSThread()->getPending());
-	STAT_ASSET_KBIT.add(gTransferManager.getTransferBitsIn(LLTCT_ASSET)/1024.f);
+	LLStatViewer::ASSET_KBIT.add<LLUnits::Bits<F32> >(gTransferManager.getTransferBitsIn(LLTCT_ASSET));
 	//stats.mAssetKBitStat.addValue(gTransferManager.getTransferBitsIn(LLTCT_ASSET)/1024.f);
 	gTransferManager.resetTransferBitsIn(LLTCT_ASSET);
 
@@ -508,7 +615,7 @@ void update_statistics()
 		static LLFrameTimer texture_stats_timer;
 		if (texture_stats_timer.getElapsedTimeF32() >= texture_stats_freq)
 		{
-			STAT_TEXTURE_KBIT.add(LLViewerTextureList::sTextureBits/1024.f);
+			LLStatViewer::TEXTURE_KBIT.add<LLUnits::Bits<F32> >(LLViewerTextureList::sTextureBits);
 			//stats.mTextureKBitStat.addValue(LLViewerTextureList::sTextureBits/1024.f);
 			stats.mTexturePacketsStat.addValue(LLViewerTextureList::sTexturePackets);
 			gTotalTextureBytes += LLViewerTextureList::sTextureBits / 8;

indra/newview/llviewerstats.h

@@ -32,11 +32,121 @@
 #include "lltracerecording.h"
 #include "lltrace.h"
 
-extern LLTrace::Rate<F32>	STAT_KBIT,
-							STAT_LAYERS_KBIT,
-							STAT_OBJECT_KBIT,
-							STAT_ASSET_KBIT,
-							STAT_TEXTURE_KBIT;
+namespace LLStatViewer
+{
+extern LLTrace::Rate<F32>					FPS,
+											PACKETS_IN,
+											PACKETS_LOST,
+											PACKETS_OUT,
+											TEXTURE_PACKETS,
+											TRIANGLES_DRAWN,
+											CHAT_COUNT,
+											IM_COUNT,
+											OBJECT_CREATE,
+											OBJECT_REZ,
+											LOADING_WEARABLES_LONG_DELAY,
+											LOGIN_TIMEOUTS,
+											FAILED_DOWNLOADS,
+											LSL_SAVES,
+											ANIMATION_UPLOADS,
+											FLY,
+											TELEPORT,
+											DELETE_OBJECT,
+											SNAPSHOT,
+											UPLOAD_SOUND,
+											UPLOAD_TEXTURE,
+											EDIT_TEXTURE,
+											KILLED,
+											FRAMETIME_DOUBLED,
+											TEX_BAKES,
+											TEX_REBAKES;
+
+
+extern LLTrace::Rate<LLUnits::Bytes<F32> >	KBIT,
+											LAYERS_KBIT,
+											OBJECT_KBIT,
+											ASSET_KBIT,
+											TEXTURE_KBIT,
+											ACTUAL_IN_KBIT,
+											ACTUAL_OUT_KBIT;
+
+extern LLTrace::Rate<LLUnits::Seconds<F32> > AVATAR_EDIT_TIME,
+											 TOOLBOX_TIME,
+											 MOUSELOOK_TIME,
+											 FPS_10_TIME,
+											 FPS_8_TIME,
+											 FPS_2_TIME,
+											 SIM_20_FPS_TIME,
+											 SIM_PHYSICS_20_FPS_TIME,
+											 LOSS_5_PERCENT_TIME;
+
+extern LLTrace::Measurement<F32>			SIM_TIME_DILATION,
+											SIM_FPS,
+											SIM_PHYSICS_FPS,
+											SIM_AGENT_UPS,
+											SIM_SCRIPT_EPS,
+											SIM_SKIPPED_SILHOUETTE,
+											SIM_SKIPPED_CHARACTERS_PERCENTAGE,
+											SIM_MAIN_AGENTS,
+											SIM_CHILD_AGENTS,
+											SIM_OBJECTS,
+											SIM_ACTIVE_OBJECTS,
+											SIM_ACTIVE_SCRIPTS,
+											SIM_PERCENTAGE_SCRIPTS_RUN,
+											SIM_IN_PACKETS_PER_SEC,
+											SIM_OUT_PACKETS_PER_SEC,
+											SIM_PENDING_DOWNLOADS,
+											SIM_PENDING_UPLOADS,
+											SIM_PENING_LOCAL_UPLOADS,
+											SIM_PHYSICS_PINNED_TASKS,
+											SIM_PHYSICS_LOD_TASKS,
+											NUM_IMAGES,
+											NUM_RAW_IMAGES,
+											NUM_OBJECTS,
+											NUM_ACTIVE_OBJECTS,
+											NUM_NEW_OBJECTS,
+											NUM_SIZE_CULLED,
+											NUM_VIS_CULLED,
+											ENABLE_VBO,
+											DELTA_BANDWIDTH,
+											MAX_BANDWIDTH,
+											LIGHTING_DETAIL,
+											VISIBLE_AVATARS,
+											SHADER_OBJECTS,
+											DRAW_DISTANCE,
+											CHAT_BUBBLES,
+											WINDOW_WIDTH,
+											WINDOW_HEIGHT;
+
+extern LLTrace::Measurement<LLUnits::Bytes<F32> >	SIM_UNACKED_BYTES,
+													SIM_PHYSICS_MEM,
+													GL_TEX_MEM,
+													GL_BOUND_MEM,
+													RAW_MEM,
+													FORMATTED_MEM;
+
+
+extern LLTrace::Measurement<LLUnits::Seconds<F32> > SIM_PHYSICS_TIME,
+													SIM_PHYSICS_STEP_TIME,
+													SIM_PHYSICS_SHAPE_UPDATE_TIME,
+													SIM_PHYSICS_OTHER_TIME,
+													SIM_AI_TIME,
+													SIM_AGENTS_TIME,
+													SIM_IMAGES_TIME,
+													SIM_SCRIPTS_TIME,
+													SIM_SPARE_TIME,
+													SIM_SLEEP_TIME,
+													SIM_PUMP_IO_TIME,
+													SIM_PING,
+													LOGIN_SECONDS,
+													REGION_CROSSING_TIME,
+													FRAME_STACKTIME,
+													UPDATE_STACKTIME,
+													NETWORK_STACKTIME,
+													IMAGE_STACKTIME,
+													REBUILD_STACKTIME,
+													RENDER_STACKTIME;
+}
 
 class LLViewerStats : public LLSingleton<LLViewerStats>
 {

indra/newview/llviewertexturelist.cpp

@@ -624,7 +624,7 @@ void LLViewerTextureList::updateImages(F32 max_time)
 
 	LLTrace::Recording* recording = LLTrace::get_thread_recorder()->getPrimaryRecording();
 
-	LLAppViewer::getTextureFetch()->setTextureBandwidth(recording->getPerSec(STAT_TEXTURE_KBIT));
+	LLAppViewer::getTextureFetch()->setTextureBandwidth(recording->getPerSec(LLStatViewer::TEXTURE_KBIT));
 
 	LLViewerStats::getInstance()->mNumImagesStat.addValue(sNumImages);
 	LLViewerStats::getInstance()->mNumRawImagesStat.addValue(LLImageRaw::sRawImageCount);

indra/newview/llworld.cpp

@@ -702,9 +702,10 @@ void LLWorld::updateNetStats()
 
 	S32 actual_in_bits = gMessageSystem->mPacketRing.getAndResetActualInBits();
 	S32 actual_out_bits = gMessageSystem->mPacketRing.getAndResetActualOutBits();
+
 	LLViewerStats::getInstance()->mActualInKBitStat.addValue(actual_in_bits/1024.f);
 	LLViewerStats::getInstance()->mActualOutKBitStat.addValue(actual_out_bits/1024.f);
-	STAT_KBIT.add(bits/1024.f);
+	LLStatViewer::KBIT.add<LLUnits::Bits<F32> >(bits);
 	//LLViewerStats::getInstance()->mKBitStat.addValue(bits/1024.f);
 	LLViewerStats::getInstance()->mPacketsInStat.addValue(packets_in);
 	LLViewerStats::getInstance()->mPacketsOutStat.addValue(packets_out);