Automated merge with bundle:d:\code\viewer-interesting+c:\users\richard\appdata\local\temp\thg.7jrj8n\https__bitbucket.org_lindenlab_viewer-interesting_jch9cd.hg

17 files changed, 529 insertions, 379 deletions

diff --git a/indra/newview/llappviewer.cpp b/indra/newview/llappviewer.cpp
index 42bf9b657b..ef24ba21ee 100755
--- a/indra/newview/llappviewer.cpp
+++ b/indra/newview/llappviewer.cpp
@@ -296,7 +296,7 @@ LLPumpIO* gServicePump = NULL;
 
 U64 gFrameTime = 0;
 F32 gFrameTimeSeconds = 0.f;
-LLUnit<LLUnits::Seconds, F32> gFrameIntervalSeconds = 0.f;
+LLUnit<F32, LLUnits::Seconds> gFrameIntervalSeconds = 0.f;
 F32 gFPSClamped = 10.f;						// Pretend we start at target rate.
 F32 gFrameDTClamped = 0.f;					// Time between adjacent checks to network for packets
 U64	gStartTime = 0; // gStartTime is "private", used only to calculate gFrameTimeSeconds
diff --git a/indra/newview/llappviewer.h b/indra/newview/llappviewer.h
index 2e75de445f..ad662d8ea1 100755
--- a/indra/newview/llappviewer.h
+++ b/indra/newview/llappviewer.h
@@ -337,7 +337,7 @@ extern LLPumpIO* gServicePump;
 
 extern U64      gFrameTime;					// The timestamp of the most-recently-processed frame
 extern F32		gFrameTimeSeconds;			// Loses msec precision after ~4.5 hours...
-extern LLUnit<LLUnits::Seconds, F32>		gFrameIntervalSeconds;		// Elapsed time between current and previous gFrameTimeSeconds
+extern LLUnit<F32, LLUnits::Seconds>		gFrameIntervalSeconds;		// Elapsed time between current and previous gFrameTimeSeconds
 extern F32		gFPSClamped;				// Frames per second, smoothed, weighted toward last frame
 extern F32		gFrameDTClamped;
 extern U64		gStartTime;
diff --git a/indra/newview/llfasttimerview.cpp b/indra/newview/llfasttimerview.cpp
index 40526d3357..1355b58f8b 100755
--- a/indra/newview/llfasttimerview.cpp
+++ b/indra/newview/llfasttimerview.cpp
@@ -30,12 +30,14 @@
 
 #include "llviewerwindow.h"
 #include "llrect.h"
+#include "llcombobox.h"
 #include "llerror.h"
 #include "llgl.h"
 #include "llimagepng.h"
 #include "llrender.h"
 #include "llrendertarget.h"
 #include "lllocalcliprect.h"
+#include "lllayoutstack.h"
 #include "llmath.h"
 #include "llfontgl.h"
 #include "llsdserialize.h"
@@ -56,9 +58,11 @@
 
 using namespace LLTrace;
 
-static const S32 MAX_VISIBLE_HISTORY = 10;
+static const S32 MAX_VISIBLE_HISTORY = 12;
 static const S32 LINE_GRAPH_HEIGHT = 240;
 static const S32 MIN_BAR_HEIGHT = 3;
+static const S32 RUNNING_AVERAGE_WIDTH = 100;
+static const S32 NUM_FRAMES_HISTORY = 256;
 
 std::vector<TimeBlock*> ft_display_idx; // line of table entry for display purposes (for collapse)
 
@@ -95,27 +99,19 @@ LLFastTimerView::LLFastTimerView(const LLSD& key)
 :	LLFloater(key),
 	mHoverTimer(NULL),
 	mDisplayMode(0),
-	mDisplayCenter(ALIGN_CENTER),
-	mDisplayCalls(false),
-	mDisplayHz(false),
+	mDisplayType(TIME),
 	mScrollIndex(0),
 	mHoverID(NULL),
 	mHoverBarIndex(-1),
-	mPrintStats(-1),
-	mRecording(&get_frame_recording()),
-	mPauseHistory(false)
+	mStatsIndex(-1),
+	mPauseHistory(false),
+	mRecording(NUM_FRAMES_HISTORY)
 {
-	mTimerBars = new std::vector<TimerBar>[MAX_VISIBLE_HISTORY + 1];
+	mTimerBarRows.resize(NUM_FRAMES_HISTORY);
 }
 
 LLFastTimerView::~LLFastTimerView()
 {
-	if (mRecording != &get_frame_recording())
-	{
-		delete mRecording;
-	}
-	mRecording = NULL;
-	delete [] mTimerBars;
 }
 
 void LLFastTimerView::onPause()
@@ -130,16 +126,11 @@ void LLFastTimerView::setPauseState(bool pause_state)
 	// reset scroll to bottom when unpausing
 	if (!pause_state)
 	{
-		if (mRecording != &get_frame_recording())
-		{
-			delete mRecording;
-		}
-		mRecording = &get_frame_recording();
+		
 		getChild<LLButton>("pause_btn")->setLabel(getString("pause"));
 	}
 	else
 	{
-		mRecording = new PeriodicRecording(get_frame_recording());
 		mScrollIndex = 0;
 
 		getChild<LLButton>("pause_btn")->setLabel(getString("run"));
@@ -175,7 +166,7 @@ BOOL LLFastTimerView::handleRightMouseDown(S32 x, S32 y, MASK mask)
 	{
 		S32 bar_idx = MAX_VISIBLE_HISTORY - ((y - mBarRect.mBottom) * (MAX_VISIBLE_HISTORY + 2) / mBarRect.getHeight());
 		bar_idx = llclamp(bar_idx, 0, MAX_VISIBLE_HISTORY);
-		mPrintStats = mScrollIndex + bar_idx;
+		mStatsIndex = mScrollIndex + bar_idx;
 		return TRUE;
 	}
 	return LLFloater::handleRightMouseDown(x, y, mask);
@@ -183,7 +174,7 @@ BOOL LLFastTimerView::handleRightMouseDown(S32 x, S32 y, MASK mask)
 
 TimeBlock* LLFastTimerView::getLegendID(S32 y)
 {
-	S32 idx = (mBarRect.mTop - y) / (LLFontGL::getFontMonospace()->getLineHeight()+2) - 1;
+	S32 idx = (mLegendRect.mTop - y) / (LLFontGL::getFontMonospace()->getLineHeight() + 2);
 
 	if (idx >= 0 && idx < (S32)ft_display_idx.size())
 	{
@@ -219,26 +210,6 @@ BOOL LLFastTimerView::handleMouseDown(S32 x, S32 y, MASK mask)
 		//left click drills down by expanding timers
 		mHoverTimer->setCollapsed(false);
 	}
-	else if (mask & MASK_ALT)
-	{
-		if (mask & MASK_CONTROL)
-		{
-			mDisplayHz = !mDisplayHz;	
-		}
-		else
-		{
-			mDisplayCalls = !mDisplayCalls;
-		}
-	}
-	else if (mask & MASK_SHIFT)
-	{
-		if (++mDisplayMode > 3)
-			mDisplayMode = 0;
-	}
-	else if (mask & MASK_CONTROL)
-	{
-		mDisplayCenter = (ChildAlignment)((mDisplayCenter + 1) % ALIGN_COUNT);
-	}
 	else if (mGraphRect.pointInRect(x, y))
 	{
 		gFocusMgr.setMouseCapture(this);
@@ -262,8 +233,8 @@ BOOL LLFastTimerView::handleHover(S32 x, S32 y, MASK mask)
 	if (hasMouseCapture())
 	{
 		F32 lerp = llclamp(1.f - (F32) (x - mGraphRect.mLeft) / (F32) mGraphRect.getWidth(), 0.f, 1.f);
-		mScrollIndex = llround( lerp * (F32)(mRecording->getNumPeriods() - MAX_VISIBLE_HISTORY));
-		mScrollIndex = llclamp(	mScrollIndex, 0, (S32)mRecording->getNumPeriods());
+		mScrollIndex = llround( lerp * (F32)(mRecording.getNumRecordedPeriods() - MAX_VISIBLE_HISTORY));
+		mScrollIndex = llclamp(	mScrollIndex, 0, (S32)mRecording.getNumRecordedPeriods());
 		return TRUE;
 	}
 	mHoverTimer = NULL;
@@ -271,8 +242,11 @@ BOOL LLFastTimerView::handleHover(S32 x, S32 y, MASK mask)
 
 	if(mPauseHistory && mBarRect.pointInRect(x, y))
 	{
-		mHoverBarIndex = llmin((mBarRect.mTop - y) / (mBarRect.getHeight() / (MAX_VISIBLE_HISTORY + 2)) - 1,
-								(S32)mRecording->getNumPeriods() - 1,
+		//const S32 bars_top = mBarRect.mTop;
+		const S32 bars_top = mBarRect.mTop - ((S32)LLFontGL::getFontMonospace()->getLineHeight() + 4);
+
+		mHoverBarIndex = llmin((bars_top - y) / (mBarRect.getHeight() / (MAX_VISIBLE_HISTORY + 2)) - 1,
+								(S32)mRecording.getNumRecordedPeriods() - 1,
 								MAX_VISIBLE_HISTORY);
 		if (mHoverBarIndex == 0)
 		{
@@ -283,30 +257,44 @@ BOOL LLFastTimerView::handleHover(S32 x, S32 y, MASK mask)
 			mHoverBarIndex = 0;
 		}
 
-		S32 i = 0;
-		for(timer_tree_iterator_t it = begin_timer_tree(FTM_FRAME);
-			it != end_timer_tree();
-			++it, ++i)
+		TimerBarRow& row = mHoverBarIndex == 0 ? mAverageTimerRow : mTimerBarRows[mScrollIndex + mHoverBarIndex - 1];
+
+		TimerBar* hover_bar = NULL;
+		LLUnit<F32, LLUnits::Seconds> mouse_time_offset = ((F32)(x - mBarRect.mLeft) / (F32)mBarRect.getWidth()) * mTotalTimeDisplay;
+		for (int bar_index = 0, end_index = LLInstanceTracker<LLTrace::TimeBlock>::instanceCount(); 
+			bar_index < end_index; 
+			++bar_index)
 		{
-			// is mouse over bar for this timer?
-			if (mTimerBars[mHoverBarIndex][i].mVisibleRect.pointInRect(x, y))
+			TimerBar& bar = row.mBars[bar_index];
+			if (bar.mSelfStart > mouse_time_offset)
+			{
+				break;
+			}
+			if (bar.mSelfEnd > mouse_time_offset)
 			{
-				mHoverID = (*it);
-				if (mHoverTimer != *it)
+				hover_bar = &bar;
+				if (bar.mTimeBlock->getCollapsed())
 				{
-					// could be that existing tooltip is for a parent and is thus
-					// covering region for this new timer, go ahead and unblock 
-					// so we can create a new tooltip
-					LLToolTipMgr::instance().unblockToolTips();
-					mHoverTimer = (*it);
+					// stop on first collapsed timeblock, since we can't select any children
+					break;
 				}
-
-				mToolTipRect = mTimerBars[mHoverBarIndex][i].mVisibleRect;
 			}
+		}
 
-			if ((*it)->getCollapsed())
+		if (hover_bar)
+		{
+			mHoverID = hover_bar->mTimeBlock;
+			if (mHoverTimer != mHoverID)
 			{
-				it.skipDescendants();
+				// could be that existing tooltip is for a parent and is thus
+				// covering region for this new timer, go ahead and unblock 
+				// so we can create a new tooltip
+				LLToolTipMgr::instance().unblockToolTips();
+				mHoverTimer = mHoverID;
+				mToolTipRect.set(mBarRect.mLeft + (hover_bar->mSelfStart / mTotalTimeDisplay) * mBarRect.getWidth(),
+								row.mTop,
+								mBarRect.mLeft + (hover_bar->mSelfEnd / mTotalTimeDisplay) * mBarRect.getWidth(),
+								row.mBottom);
 			}
 		}
 	}
@@ -329,11 +317,11 @@ static std::string get_tooltip(TimeBlock& timer, S32 history_index, PeriodicReco
 	if (history_index == 0)
 	{
 		// by default, show average number of call
-		tooltip = llformat("%s (%d ms, %d calls)", timer.getName().c_str(), (S32)LLUnit<LLUnits::Milliseconds, F64>(frame_recording.getPeriodMean(timer)).value(), (S32)frame_recording.getPeriodMean(timer.callCount()));
+		tooltip = llformat("%s (%d ms, %d calls)", timer.getName().c_str(), (S32)LLUnit<F64, LLUnits::Milliseconds>(frame_recording.getPeriodMean (timer, RUNNING_AVERAGE_WIDTH)).value(), (S32)frame_recording.getPeriodMean(timer.callCount(), RUNNING_AVERAGE_WIDTH));
 	}
 	else
 	{
-		tooltip = llformat("%s (%d ms, %d calls)", timer.getName().c_str(), (S32)LLUnit<LLUnits::Milliseconds, F64>(frame_recording.getPrevRecording(history_index).getSum(timer)).value(), (S32)frame_recording.getPrevRecording(history_index).getSum(timer.callCount()));
+		tooltip = llformat("%s (%d ms, %d calls)", timer.getName().c_str(), (S32)LLUnit<F64, LLUnits::Milliseconds>(frame_recording.getPrevRecording(history_index).getSum(timer)).value(), (S32)frame_recording.getPrevRecording(history_index).getSum(timer.callCount()));
 	}
 	return tooltip;
 }
@@ -348,7 +336,7 @@ BOOL LLFastTimerView::handleToolTip(S32 x, S32 y, MASK mask)
 			LLRect screen_rect;
 			localRectToScreen(mToolTipRect, &screen_rect);
 
-			std::string tooltip = get_tooltip(*mHoverTimer, mHoverBarIndex > 0 ? mScrollIndex + mHoverBarIndex : 0, *mRecording);
+			std::string tooltip = get_tooltip(*mHoverTimer, mHoverBarIndex > 0 ? mScrollIndex + mHoverBarIndex : 0, mRecording);
 
 			LLToolTipMgr::instance().show(LLToolTip::Params()
 				.message(tooltip)
@@ -366,7 +354,7 @@ BOOL LLFastTimerView::handleToolTip(S32 x, S32 y, MASK mask)
 			TimeBlock* idp = getLegendID(y);
 			if (idp)
 			{
-				LLToolTipMgr::instance().show(get_tooltip(*idp, 0, *mRecording));
+				LLToolTipMgr::instance().show(get_tooltip(*idp, 0, mRecording));
 
 				return TRUE;
 			}
@@ -381,7 +369,7 @@ BOOL LLFastTimerView::handleScrollWheel(S32 x, S32 y, S32 clicks)
 	setPauseState(true);
 	mScrollIndex = llclamp(	mScrollIndex + clicks,
 							0,
-							llmin((S32)mRecording->getNumPeriods(), (S32)mRecording->getNumPeriods() - MAX_VISIBLE_HISTORY));
+							llmin((S32)mRecording.getNumRecordedPeriods(), (S32)mRecording.getNumRecordedPeriods() - MAX_VISIBLE_HISTORY));
 	return TRUE;
 }
 
@@ -389,39 +377,73 @@ static TimeBlock FTM_RENDER_TIMER("Timers", true);
 static const S32 MARGIN = 10;
 static const S32 LEGEND_WIDTH = 220;
 
-static std::map<TimeBlock*, LLColor4> sTimerColors;
+static std::vector<LLColor4> sTimerColors;
 
 void LLFastTimerView::draw()
 {
 	LLFastTimer t(FTM_RENDER_TIMER);
 	
+	if (!mPauseHistory)
+	{
+		mRecording.appendRecording(LLTrace::get_frame_recording().getLastRecording());
+		mTimerBarRows.pop_back();
+		mTimerBarRows.push_front(TimerBarRow());
+	}
+
+	mDisplayMode = llclamp(getChild<LLComboBox>("time_scale_combo")->getCurrentIndex(), 0, 3);
+	mDisplayType = (EDisplayType)llclamp(getChild<LLComboBox>("metric_combo")->getCurrentIndex(), 0, 2);
+
 	generateUniqueColors();
 
+	LLView::drawChildren();
+	//getChild<LLLayoutStack>("timer_bars_stack")->updateLayout();
+	//getChild<LLLayoutStack>("legend_stack")->updateLayout();
+	LLView* bars_panel = getChildView("bars_panel");
+	bars_panel->localRectToOtherView(bars_panel->getLocalRect(), &mBarRect, this);
+
+	LLView* lines_panel = getChildView("lines_panel");
+	lines_panel->localRectToOtherView(lines_panel->getLocalRect(), &mGraphRect, this);
+
+	LLView* legend_panel = getChildView("legend");
+	legend_panel->localRectToOtherView(legend_panel->getLocalRect(), &mLegendRect, this);
+
 	// Draw the window background
 	gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
 	gl_rect_2d(getLocalRect(), LLColor4(0.f, 0.f, 0.f, 0.25f));
 	
-	S32 y = drawHelp(getRect().getHeight() - MARGIN);
-	drawLegend(y - ((S32)LLFontGL::getFontMonospace()->getLineHeight() + 2));
+	drawHelp(getRect().getHeight() - MARGIN);
+	drawLegend();
 
-	// update rectangle that includes timer bars
-	const S32 LEGEND_WIDTH = 220;
-
-	mBarRect.mLeft = MARGIN + LEGEND_WIDTH + 8;
-	mBarRect.mTop = y;
-	mBarRect.mRight = getRect().getWidth() - MARGIN;
-	mBarRect.mBottom = MARGIN + LINE_GRAPH_HEIGHT;
+	//mBarRect.mLeft = MARGIN + LEGEND_WIDTH + 8;
+	//mBarRect.mTop = y;
+	//mBarRect.mRight = getRect().getWidth() - MARGIN;
+	//mBarRect.mBottom = MARGIN + LINE_GRAPH_HEIGHT;
 
 	drawBars();
 	drawLineGraph();
 	printLineStats();
 	LLView::draw();
 		
-	mAllTimeMax = llmax(mAllTimeMax, mRecording->getLastRecording().getSum(FTM_FRAME));
+	mAllTimeMax = llmax(mAllTimeMax, mRecording.getLastRecording().getSum(FTM_FRAME));
 	mHoverID = NULL;
 	mHoverBarIndex = -1;
 }
 
+void LLFastTimerView::onOpen(const LLSD& key)
+{
+	setPauseState(false);
+	mRecording.reset();
+	mRecording.appendPeriodicRecording(LLTrace::get_frame_recording());
+	for(std::deque<TimerBarRow>::iterator it = mTimerBarRows.begin(), end_it = mTimerBarRows.end();
+		it != end_it; 
+		++it)
+	{
+		delete []it->mBars;
+		it->mBars = NULL;
+	}
+}
+
+
 void saveChart(const std::string& label, const char* suffix, LLImageRaw* scratch)
 {
 	//read result back into raw image
@@ -828,7 +850,7 @@ void LLFastTimerView::doAnalysisDefault(std::string baseline, std::string target
 	LLSD current = analyzePerformanceLogDefault(target_is);
 	target_is.close();
 
-	//output comparision
+	//output comparison
 	std::ofstream os(output.c_str());
 
 	LLSD::Real session_time = current["SessionTime"].asReal();
@@ -936,7 +958,7 @@ void	LLFastTimerView::onClickCloseBtn()
 void LLFastTimerView::printLineStats()
 {
 	// Output stats for clicked bar to log
-	if (mPrintStats >= 0)
+	if (mStatsIndex >= 0)
 	{
 		std::string legend_stat;
 		bool first = true;
@@ -974,16 +996,16 @@ void LLFastTimerView::printLineStats()
 			}
 			first = false;
 
-			LLUnit<LLUnits::Seconds, F32> ticks;
-			if (mPrintStats > 0)
+			LLUnit<F32, LLUnits::Seconds> ticks;
+			if (mStatsIndex == 0)
 			{
-				ticks = mRecording->getPrevRecording(mPrintStats).getSum(*idp);
+				ticks = mRecording.getPeriodMean(*idp, RUNNING_AVERAGE_WIDTH);
 			}
 			else
 			{
-				ticks = mRecording->getPeriodMean(*idp);
+				ticks = mRecording.getPrevRecording(mStatsIndex).getSum(*idp);
 			}
-			LLUnit<LLUnits::Milliseconds, F32> ms = ticks;
+			LLUnit<F32, LLUnits::Milliseconds> ms = ticks;
 
 			timer_stat += llformat("%.1f",ms.value());
 
@@ -993,7 +1015,7 @@ void LLFastTimerView::printLineStats()
 			}
 		}
 		llinfos << timer_stat << llendl;
-		mPrintStats = -1;
+		mStatsIndex = -1;
 	}
 }
 
@@ -1003,37 +1025,20 @@ void LLFastTimerView::drawLineGraph()
 {
 	LLFastTimer _(FTM_DRAW_LINE_GRAPH);
 	//draw line graph history
-	S32 x = mBarRect.mLeft;
-	S32 y = LINE_GRAPH_HEIGHT;
 	gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
 	LLLocalClipRect clip(mGraphRect);
 
 	//normalize based on last frame's maximum
-	static LLUnit<LLUnits::Seconds, F32> max_time = 0.000001;
+	static LLUnit<F32, LLUnits::Seconds> max_time = 0.000001;
 	static U32 max_calls = 0;
 	static F32 alpha_interp = 0.f;
 
-	//display y-axis range
-	std::string axis_label;
-	if (mDisplayCalls)
-		axis_label = llformat("%d calls", (int)max_calls);
-	else if (mDisplayHz)
-		axis_label = llformat("%d Hz", (int)(1.f / max_time.value()));
-	else
-		axis_label = llformat("%4.2f ms", LLUnit<LLUnits::Milliseconds, F32>(max_time).value());
-
-	x = mGraphRect.mRight - LLFontGL::getFontMonospace()->getWidth(axis_label)-5;
-	y = mGraphRect.mTop - LLFontGL::getFontMonospace()->getLineHeight();
-
-	LLFontGL::getFontMonospace()->renderUTF8(axis_label, 0, x, y, LLColor4::white,
-		LLFontGL::LEFT, LLFontGL::TOP);
-
 	//highlight visible range
 	{
-		S32 first_frame = mRecording->getNumPeriods() - mScrollIndex;
+		S32 first_frame = mRecording.getNumRecordedPeriods() - mScrollIndex;
 		S32 last_frame = first_frame - MAX_VISIBLE_HISTORY;
 
-		F32 frame_delta = ((F32) (mGraphRect.getWidth()))/(mRecording->getNumPeriods()-1);
+		F32 frame_delta = ((F32) (mGraphRect.getWidth()))/(mRecording.getNumRecordedPeriods()-1);
 
 		F32 right = (F32) mGraphRect.mLeft + frame_delta*first_frame;
 		F32 left = (F32) mGraphRect.mLeft + frame_delta*last_frame;
@@ -1043,7 +1048,7 @@ void LLFastTimerView::drawLineGraph()
 
 		if (mHoverBarIndex > 0)
 		{
-			S32 bar_frame = first_frame - mHoverBarIndex - 1;
+			S32 bar_frame = first_frame - (mScrollIndex + mHoverBarIndex) - 1;
 			F32 bar = (F32) mGraphRect.mLeft + frame_delta*bar_frame;
 
 			gGL.color4f(0.5f,0.5f,0.5f,1);
@@ -1055,7 +1060,7 @@ void LLFastTimerView::drawLineGraph()
 		}
 	}
 
-	LLUnit<LLUnits::Seconds, F32> cur_max = 0;
+	LLUnit<F32, LLUnits::Seconds> cur_max = 0;
 	U32 cur_max_calls = 0;
 	for(timer_tree_iterator_t it = begin_timer_tree(FTM_FRAME);
 		it != end_timer_tree();
@@ -1070,9 +1075,11 @@ void LLFastTimerView::drawLineGraph()
 			glLineWidth(3);
 		}
 
-		const F32 * col = sTimerColors[idp].mV;// ft_display_table[idx].color->mV;
+		llassert(idp->getIndex() < sTimerColors.size());
+		const F32 * col = sTimerColors[idp->getIndex()].mV;// ft_display_table[idx].color->mV;
 
 		F32 alpha = 1.f;
+		bool is_hover_timer = true;
 
 		if (mHoverID != NULL &&
 			mHoverID != idp)
@@ -1080,28 +1087,43 @@ void LLFastTimerView::drawLineGraph()
 			if (idp->getParent() != mHoverID)
 			{
 				alpha = alpha_interp;
+				is_hover_timer = false;
 			}
 		}
 
 		gGL.color4f(col[0], col[1], col[2], alpha);				
 		gGL.begin(LLRender::TRIANGLE_STRIP);
-		for (U32 j = mRecording->getNumPeriods();
+		F32 call_scale_factor = (F32)mGraphRect.getHeight() / (F32)max_calls;
+		F32 time_scale_factor = (F32)mGraphRect.getHeight() / max_time.value();
+		F32 hz_scale_factor = (F32) mGraphRect.getHeight() / (1.f / max_time.value());
+		for (U32 j = mRecording.getNumRecordedPeriods();
 			j > 0;
 			j--)
 		{
-			LLUnit<LLUnits::Seconds, F32> time = llmax(mRecording->getPrevRecording(j).getSum(*idp), LLUnit<LLUnits::Seconds, F64>(0.000001));
-			U32 calls = mRecording->getPrevRecording(j).getSum(idp->callCount());
+			LLTrace::Recording& recording = mRecording.getPrevRecording(j);
+			LLUnit<F32, LLUnits::Seconds> time = llmax(recording.getSum(*idp), LLUnit<F64, LLUnits::Seconds>(0.000001));
+			U32 calls = recording.getSum(idp->callCount());
 
-			if (alpha == 1.f)
+			if (is_hover_timer)
 			{ 
 				//normalize to highlighted timer
 				cur_max = llmax(cur_max, time);
 				cur_max_calls = llmax(cur_max_calls, calls);
 			}
-			F32 x = mGraphRect.mRight - j * (F32)(mGraphRect.getWidth())/(mRecording->getNumPeriods()-1);
-			F32 y = mDisplayHz 
-				? mGraphRect.mBottom + (1.f / time.value()) * ((F32) mGraphRect.getHeight() / (1.f / max_time.value()))
-				: mGraphRect.mBottom + time / max_time * (F32)mGraphRect.getHeight();
+			F32 x = mGraphRect.mRight - j * (F32)(mGraphRect.getWidth())/(mRecording.getNumRecordedPeriods()-1);
+			F32 y;
+			switch(mDisplayType)
+			{
+			case TIME:
+				y = mGraphRect.mBottom + time.value() * time_scale_factor;
+				break;
+			case CALLS:
+				y = mGraphRect.mBottom + (F32)calls * call_scale_factor;
+				break;
+			case HZ:
+				y = mGraphRect.mBottom + (1.f / time.value()) * hz_scale_factor;
+				break;
+			}
 			gGL.vertex2f(x,y);
 			gGL.vertex2f(x,mGraphRect.mBottom);
 		}
@@ -1122,9 +1144,9 @@ void LLFastTimerView::drawLineGraph()
 	
 	//interpolate towards new maximum
 	max_time = lerp(max_time.value(), cur_max.value(), LLSmoothInterpolation::getInterpolant(0.1f));
-	if (max_time - cur_max <= 1 ||  cur_max - max_time  <= 1)
+	if (llabs((max_time - cur_max).value()) <= 1)
 	{
-		max_time = llmax(LLUnit<LLUnits::Microseconds, F32>(1), LLUnit<LLUnits::Microseconds, F32>(cur_max));
+		max_time = llmax(LLUnit<F32, LLUnits::Microseconds>(1), LLUnit<F32, LLUnits::Microseconds>(cur_max));
 	}
 
 	max_calls = llround(lerp((F32)max_calls, (F32) cur_max_calls, LLSmoothInterpolation::getInterpolant(0.1f)));
@@ -1141,8 +1163,8 @@ void LLFastTimerView::drawLineGraph()
 
 	if (mHoverID != NULL)
 	{
-		x = (mGraphRect.mRight + mGraphRect.mLeft)/2;
-		y = mGraphRect.mBottom + 8;
+		S32 x = (mGraphRect.mRight + mGraphRect.mLeft)/2;
+		S32 y = mGraphRect.mBottom + 8;
 
 		LLFontGL::getFontMonospace()->renderUTF8(
 			mHoverID->getName(), 
@@ -1150,18 +1172,40 @@ void LLFastTimerView::drawLineGraph()
 			x, y, 
 			LLColor4::white,
 			LLFontGL::LEFT, LLFontGL::BOTTOM);
-	}					
+	}
+
+	//display y-axis range
+	std::string axis_label;
+	switch(mDisplayType)
+	{
+	case TIME:
+		axis_label = llformat("%4.2f ms", LLUnit<F32, LLUnits::Milliseconds>(max_time).value());
+		break;
+	case CALLS:
+		axis_label = llformat("%d calls", (int)max_calls);
+		break;
+	case HZ:
+		axis_label = llformat("%4.2f Hz", max_time.value() ? 1.f / max_time.value() : 0.f);
+		break;
+	}
+
+	LLFontGL* font = LLFontGL::getFontMonospace();
+	S32 x = mGraphRect.mRight - font->getWidth(axis_label)-5;
+	S32 y = mGraphRect.mTop - font->getLineHeight();;
+
+	font->renderUTF8(axis_label, 0, x, y, LLColor4::white, LLFontGL::LEFT, LLFontGL::TOP);
 }
 
-void LLFastTimerView::drawLegend( S32 y )
+void LLFastTimerView::drawLegend()
 {
 	// draw legend
 	S32 dx;
-	S32 x = MARGIN;
+	S32 x = mLegendRect.mLeft;
+	S32 y = mLegendRect.mTop;
 	const S32 TEXT_HEIGHT = (S32)LLFontGL::getFontMonospace()->getLineHeight();
 
 	{
-		LLLocalClipRect clip(LLRect(MARGIN, y, LEGEND_WIDTH, MARGIN));
+		LLLocalClipRect clip(mLegendRect);
 		S32 cur_line = 0;
 		ft_display_idx.clear();
 		std::map<TimeBlock*, S32> display_line;
@@ -1183,30 +1227,35 @@ void LLFastTimerView::drawLegend( S32 y )
 				scale_offset = llfloor(sinf(mHighlightTimer.getElapsedTimeF32() * 6.f) * 2.f);
 			}
 			bar_rect.stretch(scale_offset);
-			gl_rect_2d(bar_rect, sTimerColors[idp]);
+			llassert(idp->getIndex() < sTimerColors.size());
+			gl_rect_2d(bar_rect, sTimerColors[idp->getIndex()]);
 
-			LLUnit<LLUnits::Milliseconds, F32> ms = 0;
+			LLUnit<F32, LLUnits::Milliseconds> ms = 0;
 			S32 calls = 0;
 			if (mHoverBarIndex > 0 && mHoverID)
 			{
 				S32 hidx = mScrollIndex + mHoverBarIndex;
-				ms = mRecording->getPrevRecording(hidx).getSum(*idp);
-				calls = mRecording->getPrevRecording(hidx).getSum(idp->callCount());
+				ms = mRecording.getPrevRecording(hidx).getSum(*idp);
+				calls = mRecording.getPrevRecording(hidx).getSum(idp->callCount());
 			}
 			else
 			{
-				ms = LLUnit<LLUnits::Seconds, F64>(mRecording->getPeriodMean(*idp));
-				calls = (S32)mRecording->getPeriodMean(idp->callCount());
+				ms = LLUnit<F64, LLUnits::Seconds>(mRecording.getPeriodMean(*idp, RUNNING_AVERAGE_WIDTH));
+				calls = (S32)mRecording.getPeriodMean(idp->callCount(), RUNNING_AVERAGE_WIDTH);
 			}
 
 			std::string timer_label;
-			if (mDisplayCalls)
-			{
-				timer_label = llformat("%s (%d)",idp->getName().c_str(),calls);
-			}
-			else
+			switch(mDisplayType)
 			{
+			case TIME:
 				timer_label = llformat("%s [%.1f]",idp->getName().c_str(),ms.value());
+				break;
+			case CALLS:
+				timer_label = llformat("%s (%d)",idp->getName().c_str(),calls);
+				break;
+			case HZ:
+				timer_label = llformat("%.1f", ms.value() ? (1.f / ms.value()) : 0.f);
+				break;
 			}
 			dx = (TEXT_HEIGHT+4) + get_depth(idp)*8;
 
@@ -1254,7 +1303,8 @@ void LLFastTimerView::generateUniqueColors()
 {
 	// generate unique colors
 	{
-		sTimerColors[&FTM_FRAME] = LLColor4::grey;
+		sTimerColors.resize(LLTrace::TimeBlock::getNumIndices());
+		sTimerColors[FTM_FRAME.getIndex()] = LLColor4::grey;
 
 		F32 hue = 0.f;
 
@@ -1274,48 +1324,29 @@ void LLFastTimerView::generateUniqueColors()
 			LLColor4 child_color;
 			child_color.setHSL(hue, saturation, lightness);
 
-			sTimerColors[idp] = child_color;
+			llassert(idp->getIndex() < sTimerColors.size());
+			sTimerColors[idp->getIndex()] = child_color;
 		}
 	}
 }
 
-S32 LLFastTimerView::drawHelp( S32 y )
+void LLFastTimerView::drawHelp( S32 y )
 {
 	// Draw some help
 	const S32 texth = (S32)LLFontGL::getFontMonospace()->getLineHeight();
 
-	char modedesc[][32] = {
-		"2 x Average ",
-		"Max         ",
-		"Recent Max  ",
-		"100 ms      "
-	};
-	char centerdesc[][32] = {
-		"Left      ",
-		"Centered  ",
-		"Ordered   "
-	};
-
-	std::string text;
-	text = llformat("Full bar = %s [Click to pause/reset] [SHIFT-Click to toggle]",modedesc[mDisplayMode]);
-	LLFontGL::getFontMonospace()->renderUTF8(text, 0, MARGIN, y, LLColor4::white, LLFontGL::LEFT, LLFontGL::TOP);
-
 	y -= (texth + 2);
-	text = llformat("Justification = %s [CTRL-Click to toggle]",centerdesc[mDisplayCenter]);
-	LLFontGL::getFontMonospace()->renderUTF8(text, 0, MARGIN, y, LLColor4::white, LLFontGL::LEFT, LLFontGL::TOP);
 	y -= (texth + 2);
 
-	LLFontGL::getFontMonospace()->renderUTF8(std::string("[Right-Click log selected] [ALT-Click toggle counts] [ALT-SHIFT-Click sub hidden]"),
+	LLFontGL::getFontMonospace()->renderUTF8(std::string("[Right-Click log selected] [ALT-Click toggle counts]"),
 		0, MARGIN, y, LLColor4::white, LLFontGL::LEFT, LLFontGL::TOP);
-	y -= (texth + 2);
-	return y;
 }
 
 void LLFastTimerView::drawTicks()
 {
 	// Draw MS ticks
 	{
-		LLUnit<LLUnits::Milliseconds, U32> ms = mTotalTimeDisplay;
+		LLUnit<U32, LLUnits::Milliseconds> ms = mTotalTimeDisplay;
 		std::string tick_label;
 		S32 x;
 		S32 barw = mBarRect.getWidth();
@@ -1368,10 +1399,10 @@ void LLFastTimerView::drawBorders( S32 y, const S32 x_start, S32 bar_height, S32
 		//history bars
 		gl_rect_2d(x_start-5, by, getRect().getWidth()-5, LINE_GRAPH_HEIGHT-bar_height-dy-2, LLColor4::grey, FALSE);			
 
-		by = LINE_GRAPH_HEIGHT-bar_height-dy-7;
+		by = LINE_GRAPH_HEIGHT-dy;
 
 		//line graph
-		mGraphRect = LLRect(x_start-5, by, getRect().getWidth()-5, 5);
+		//mGraphRect = LLRect(x_start-5, by, getRect().getWidth()-5, 5);
 
 		gl_rect_2d(mGraphRect, FALSE);
 	}
@@ -1382,210 +1413,251 @@ void LLFastTimerView::updateTotalTime()
 	switch(mDisplayMode)
 	{
 	case 0:
-		mTotalTimeDisplay = mRecording->getPeriodMean(FTM_FRAME)*2;
+		mTotalTimeDisplay = mRecording.getPeriodMean(FTM_FRAME, RUNNING_AVERAGE_WIDTH)*2;
 		break;
 	case 1:
-		mTotalTimeDisplay = mAllTimeMax;
+		mTotalTimeDisplay = mRecording.getPeriodMax(FTM_FRAME);
 		break;
 	case 2:
 		// Calculate the max total ticks for the current history
-		mTotalTimeDisplay = mRecording->getPeriodMax(FTM_FRAME);
+		mTotalTimeDisplay = mRecording.getPeriodMax(FTM_FRAME, 20);
 		break;
 	default:
-		mTotalTimeDisplay = LLUnit<LLUnits::Milliseconds, F32>(100);
+		mTotalTimeDisplay = LLUnit<F32, LLUnits::Milliseconds>(100);
 		break;
 	}
 
-	mTotalTimeDisplay = LLUnit<LLUnits::Milliseconds, F32>(llceil(mTotalTimeDisplay.as<LLUnits::Milliseconds>().value() / 20.f) * 20.f);
+	mTotalTimeDisplay = LLUnit<F32, LLUnits::Milliseconds>(llceil(mTotalTimeDisplay.getAs<LLUnits::Milliseconds>() / 20.f) * 20.f);
 }
 
 void LLFastTimerView::drawBars()
 {
-	updateTotalTime();
-	if (mTotalTimeDisplay <= 0.0) return;
-
 	LLLocalClipRect clip(mBarRect);
 
 	S32 bar_height = mBarRect.getHeight() / (MAX_VISIBLE_HISTORY + 2);
-	S32 vpad = llmax(1, bar_height / 4); // spacing between bars
+	const S32 vpad = llmax(1, bar_height / 4); // spacing between bars
 	bar_height -= vpad;
 
+	updateTotalTime();
+	if (mTotalTimeDisplay <= 0.0) return;
+
 	drawTicks();
-	S32 y = mBarRect.mTop - ((S32)LLFontGL::getFontMonospace()->getLineHeight() + 4);
-	drawBorders(y, mBarRect.mLeft, bar_height, vpad);
+	const S32 bars_top = mBarRect.mTop - ((S32)LLFontGL::getFontMonospace()->getLineHeight() + 4);
+	drawBorders(bars_top, mBarRect.mLeft, bar_height, vpad);
 
 	// Draw bars for each history entry
-	// Special: -1 = show running average
+	// Special: 0 = show running average
 	LLPointer<LLUIImage> bar_image = LLUI::getUIImage("Rounded_Square");
+
+	const S32 image_width = bar_image->getTextureWidth();
+	const S32 image_height = bar_image->getTextureHeight();
+
 	gGL.getTexUnit(0)->bind(bar_image->getImage());
-	const S32 histmax = llmin((S32)mRecording->getNumPeriods(), MAX_VISIBLE_HISTORY) + 1;
+	{	
+		const S32 histmax = (S32)mRecording.getNumRecordedPeriods();
 
-	for (S32 bar_index = 0; bar_index < histmax && y > LINE_GRAPH_HEIGHT; bar_index++)
-	{
-		S32 history_index = (bar_index > 0)
-			? bar_index + mScrollIndex
-			: -1;
-		mTimerBars[bar_index].clear();
-		mTimerBars[bar_index].reserve(LLInstanceTracker<LLTrace::TimeBlock>::instanceCount());
-
-		updateTimerBarWidths(&FTM_FRAME, mTimerBars[bar_index], history_index, true);
-		LLRect frame_bar_rect(mBarRect.mLeft, y, mBarRect.mLeft + mTimerBars[bar_index][0].mWidth, y-bar_height);
-		mTimerBars[bar_index][0].mVisibleRect = frame_bar_rect;
-		updateTimerBarFractions(&FTM_FRAME, 0, mTimerBars[bar_index]);
-		drawBar(&FTM_FRAME, frame_bar_rect, mTimerBars[bar_index], 0, bar_image);
-				
-		y -= (bar_height + vpad);
-		if (bar_index == 0)
-			y -= bar_height;
-	}
+		// update widths
+		if (!mPauseHistory)
+		{
+			U32 bar_index = 0;
+			if (!mAverageTimerRow.mBars)
+			{
+				mAverageTimerRow.mBars = new TimerBar[LLInstanceTracker<LLTrace::TimeBlock>::instanceCount()];
+			}
+			updateTimerBarWidths(&FTM_FRAME, mAverageTimerRow, -1, bar_index);
+			updateTimerBarOffsets(&FTM_FRAME, mAverageTimerRow);
+
+			for (S32 history_index = 1; history_index <= histmax; history_index++)
+			{
+				llassert(history_index <= mTimerBarRows.size());
+				TimerBarRow& row = mTimerBarRows[history_index - 1];
+				bar_index = 0;
+				if (!row.mBars)
+				{
+					row.mBars = new TimerBar[LLInstanceTracker<LLTrace::TimeBlock>::instanceCount()];
+					updateTimerBarWidths(&FTM_FRAME, row, history_index, bar_index);
+					updateTimerBarOffsets(&FTM_FRAME, row);
+				}
+			}
+		}
+
+		// draw bars
+		LLRect frame_bar_rect;
+		frame_bar_rect.setLeftTopAndSize(mBarRect.mLeft, 
+										bars_top, 
+										llround((mAverageTimerRow.mBars[0].mTotalTime / mTotalTimeDisplay) * mBarRect.getWidth()), 
+										bar_height);
+		mAverageTimerRow.mTop = frame_bar_rect.mTop;
+		mAverageTimerRow.mBottom = frame_bar_rect.mBottom;
+		drawBar(frame_bar_rect, mAverageTimerRow, image_width, image_height);
+		frame_bar_rect.translate(0, -(bar_height + vpad + bar_height));
+
+		for(S32 bar_index = mScrollIndex; bar_index < llmin(histmax, mScrollIndex + MAX_VISIBLE_HISTORY); ++bar_index)
+		{
+			llassert(bar_index < mTimerBarRows.size());
+			TimerBarRow& row = mTimerBarRows[bar_index];
+			row.mTop = frame_bar_rect.mTop;
+			row.mBottom = frame_bar_rect.mBottom;
+			frame_bar_rect.mRight = frame_bar_rect.mLeft 
+									+ llround((row.mBars[0].mTotalTime / mTotalTimeDisplay) * mBarRect.getWidth());
+ 			drawBar(frame_bar_rect, row, image_width, image_height);
+
+			frame_bar_rect.translate(0, -(bar_height + vpad));
+		}
+
+	}	
 	gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
 }
 
 static LLFastTimer::DeclareTimer FTM_UPDATE_TIMER_BAR_WIDTHS("Update timer bar widths");
 
-S32 LLFastTimerView::updateTimerBarWidths(LLTrace::TimeBlock* time_block, std::vector<TimerBar>& bars, S32 history_index, bool visible)
+LLUnit<F32, LLUnits::Seconds> LLFastTimerView::updateTimerBarWidths(LLTrace::TimeBlock* time_block, TimerBarRow& row, S32 history_index, U32& bar_index)
 {
 	LLFastTimer _(FTM_UPDATE_TIMER_BAR_WIDTHS);
-	F32 self_time_frame_fraction = history_index == -1
-		? (mRecording->getPeriodMean(time_block->selfTime()) / mTotalTimeDisplay) 
-		: (mRecording->getPrevRecording(history_index).getSum(time_block->selfTime()) / mTotalTimeDisplay);
-
-	S32 self_time_width = llround(self_time_frame_fraction * (F32)mBarRect.getWidth());
-	S32 full_width = self_time_width;
+	const LLUnit<F32, LLUnits::Seconds> self_time = history_index == -1
+										? mRecording.getPeriodMean(time_block->selfTime(), RUNNING_AVERAGE_WIDTH) 
+										: mRecording.getPrevRecording(history_index).getSum(time_block->selfTime());
 
-	bool children_visible = visible;
+	LLUnit<F32, LLUnits::Seconds> full_time = self_time;
 
 	// reserve a spot for this bar to be rendered before its children
 	// even though we don't know its size yet
-	S32 bar_rect_index = bars.size();
-	if (visible)
-	{
-		bars.push_back(TimerBar());
-	}
+	TimerBar& timer_bar = row.mBars[bar_index];
+	bar_index++;
 
-	if (time_block->getCollapsed())
-	{
-		children_visible = false;
-	}
 	for (TimeBlock::child_iter it = time_block->beginChildren(), end_it = time_block->endChildren(); it != end_it; ++it)
 	{
-		full_width += updateTimerBarWidths(*it, bars, history_index, children_visible);
+		full_time += updateTimerBarWidths(*it, row, history_index, bar_index);
 	}
 
-	if (visible)
-	{
-		TimerBar& timer_bar = bars[bar_rect_index];
-
-		timer_bar.mWidth = full_width;
-		timer_bar.mSelfWidth = self_time_width;
-		timer_bar.mColor = sTimerColors[time_block];
-
-		BOOL is_child_of_hover_item = (time_block == mHoverID);
-		TimeBlock* next_parent = time_block->getParent();
-		while(!is_child_of_hover_item && next_parent)
-		{
-			is_child_of_hover_item = (mHoverID == next_parent);
-			if (next_parent->getParent() == next_parent) break;
-			next_parent = next_parent->getParent();
-		}
-
-		if (mHoverID != NULL 
-			&& time_block != mHoverID 
-			&& !is_child_of_hover_item)
-		{
-			timer_bar.mColor = lerp(timer_bar.mColor, LLColor4::grey, 0.8f);
-		}
-	}
-	return full_width;
+	timer_bar.mTotalTime  = full_time;
+	timer_bar.mSelfTime   = self_time;
+	timer_bar.mTimeBlock  = time_block;
+	
+	return full_time;
 }
 
 static LLFastTimer::DeclareTimer FTM_UPDATE_TIMER_BAR_FRACTIONS("Update timer bar fractions");
 
-S32 LLFastTimerView::updateTimerBarFractions(LLTrace::TimeBlock* time_block, S32 timer_bar_index, std::vector<TimerBar>& bars)
+S32 LLFastTimerView::updateTimerBarOffsets(LLTrace::TimeBlock* time_block, TimerBarRow& row, S32 timer_bar_index)
 {
 	LLFastTimer _(FTM_UPDATE_TIMER_BAR_FRACTIONS);
-	TimerBar& timer_bar = bars[timer_bar_index];
-	S32 child_time_width = timer_bar.mWidth - timer_bar.mSelfWidth;
-	LLRect children_rect = timer_bar.mVisibleRect;
 
-	if (mDisplayCenter == ALIGN_CENTER)
-	{
-		children_rect.mLeft += timer_bar.mSelfWidth / 2;
-	}
-	else if (mDisplayCenter == ALIGN_RIGHT)
-	{
-		children_rect.mLeft += timer_bar.mSelfWidth;
-	}
-	children_rect.mRight = children_rect.mLeft + timer_bar.mWidth - timer_bar.mSelfWidth;
+	TimerBar& timer_bar = row.mBars[timer_bar_index];
+	const LLUnit<F32, LLUnits::Seconds> bar_time = timer_bar.mTotalTime - timer_bar.mSelfTime;
+	timer_bar.mChildrenStart = timer_bar.mSelfStart + timer_bar.mSelfTime / 2;
+	timer_bar.mChildrenEnd = timer_bar.mChildrenStart + timer_bar.mTotalTime - timer_bar.mSelfTime;
 
-	if (children_rect.getHeight() > MIN_BAR_HEIGHT)
+	if (timer_bar_index == 0)
 	{
-		children_rect.mTop -= 1;
-		children_rect.mBottom += 1;
+		timer_bar.mSelfStart = 0.f;
+		timer_bar.mSelfEnd = bar_time;
 	}
-	timer_bar.mChildrenRect = children_rect;
 
 	//now loop through children and figure out portion of bar image covered by each bar, now that we know the
 	//sum of all children
-	if (!time_block->getCollapsed())
+	F32 bar_fraction_start = 0.f;
+	TimerBar* last_child_timer_bar = NULL;
+
+	bool first_child = true;
+	for (TimeBlock::child_iter it = time_block->beginChildren(), end_it = time_block->endChildren(); 
+		it != end_it; 
+		++it)
 	{
-		F32 bar_fraction_start = 0.f;
-		for (TimeBlock::child_iter it = time_block->beginChildren(), end_it = time_block->endChildren(); 
-			it != end_it; 
-			++it)
+		timer_bar_index++;
+		
+		TimerBar& child_timer_bar = row.mBars[timer_bar_index];
+		TimeBlock* child_time_block = *it;
+
+		if (last_child_timer_bar)
 		{
-			timer_bar_index++;
+			last_child_timer_bar->mLastChild = false;
+		}
+		child_timer_bar.mLastChild = true;
+		last_child_timer_bar = &child_timer_bar;
 
-			TimerBar& child_timer_bar = bars[timer_bar_index];
-			TimeBlock* child_time_block = *it;
+		child_timer_bar.mFirstChild = first_child;
+		if (first_child)
+		{
+			first_child = false;
+		}
 
-			child_timer_bar.mStartFraction = bar_fraction_start;
-			child_timer_bar.mEndFraction = child_time_width > 0
-				? bar_fraction_start + (F32)child_timer_bar.mWidth / child_time_width
-				: 1.f;
-			child_timer_bar.mVisibleRect.set(children_rect.mLeft + llround(child_timer_bar.mStartFraction * children_rect.getWidth()), 
-				children_rect.mTop, 
-				children_rect.mLeft + llround(child_timer_bar.mEndFraction * children_rect.getWidth()), 
-				children_rect.mBottom);
+		child_timer_bar.mStartFraction = bar_fraction_start;
+		child_timer_bar.mEndFraction = bar_time > 0
+										? bar_fraction_start + child_timer_bar.mTotalTime / bar_time
+										: 1.f;
+		child_timer_bar.mSelfStart = timer_bar.mChildrenStart 
+									+ child_timer_bar.mStartFraction 
+										* (timer_bar.mChildrenEnd - timer_bar.mChildrenStart);
+		child_timer_bar.mSelfEnd =	timer_bar.mChildrenStart 
+									+ child_timer_bar.mEndFraction 
+										* (timer_bar.mChildrenEnd - timer_bar.mChildrenStart);
 
-			timer_bar_index = updateTimerBarFractions(child_time_block, timer_bar_index, bars);
+		timer_bar_index = updateTimerBarOffsets(child_time_block, row, timer_bar_index);
 
-			bar_fraction_start = child_timer_bar.mEndFraction;
-		}
+		bar_fraction_start = child_timer_bar.mEndFraction;
 	}
 	return timer_bar_index;
 }
 
-S32 LLFastTimerView::drawBar(LLTrace::TimeBlock* time_block, LLRect bar_rect, std::vector<TimerBar>& bars, S32 bar_index, LLPointer<LLUIImage>& bar_image)
+S32 LLFastTimerView::drawBar(LLRect bar_rect, TimerBarRow& row, S32 image_width, S32 image_height, bool hovered, bool visible, S32 bar_index)
 {
-	TimerBar& timer_bar = bars[bar_index];
+	TimerBar& timer_bar = row.mBars[bar_index];
+	LLTrace::TimeBlock* time_block = timer_bar.mTimeBlock;
+
+	hovered |= mHoverID == time_block;
 
 	// animate scale of bar when hovering over that particular timer
-	if (bar_rect.getWidth() > 0)
+	if (visible && (F32)bar_rect.getWidth() * (timer_bar.mEndFraction - timer_bar.mStartFraction) > 2.f)
 	{
 		LLRect render_rect(bar_rect);
 		S32 scale_offset = 0;
-		if (time_block == mHoverID)
+		if (mHoverID == time_block)
 		{
 			scale_offset = llfloor(sinf(mHighlightTimer.getElapsedTimeF32() * 6.f) * 3.f);
 			render_rect.mTop += scale_offset;
 			render_rect.mBottom -= scale_offset;
 		}
 
-		gGL.color4fv(timer_bar.mColor.mV);
+		llassert(time_block->getIndex() < sTimerColors.size());
+		LLColor4 color = sTimerColors[time_block->getIndex()];
+		if (!hovered) color = lerp(color, LLColor4::grey, 0.2f);
+		gGL.color4fv(color.mV);
 		gl_segmented_rect_2d_fragment_tex(render_rect,
-			bar_image->getTextureWidth(), bar_image->getTextureHeight(), 
+			image_width, image_height, 
 			16, 
 			timer_bar.mStartFraction, timer_bar.mEndFraction);
 	}
 
-	if (!time_block->getCollapsed())
+	LLRect children_rect;
+	children_rect.mLeft  = llround(timer_bar.mChildrenStart / mTotalTimeDisplay * (F32)mBarRect.getWidth()) + mBarRect.mLeft;
+	children_rect.mRight = llround(timer_bar.mChildrenEnd   / mTotalTimeDisplay * (F32)mBarRect.getWidth()) + mBarRect.mLeft;
+
+	if (bar_rect.getHeight() > MIN_BAR_HEIGHT)
+	{
+		// shrink as we go down a level
+		children_rect.mTop = bar_rect.mTop - 1;
+		children_rect.mBottom = bar_rect.mBottom + 1;
+	}
+	else
+	{
+		children_rect.mTop = bar_rect.mTop;
+		children_rect.mBottom = bar_rect.mBottom;
+	}
+
+	bool children_visible = visible && !time_block->getCollapsed();
+
+	bar_index++;
+	const U32 num_bars = LLInstanceTracker<LLTrace::TimeBlock>::instanceCount();
+	if (bar_index < num_bars && row.mBars[bar_index].mFirstChild)
 	{
-		for (TimeBlock::child_iter it = time_block->beginChildren(), end_it = time_block->endChildren(); it != end_it; ++it)
+		bool is_last = false;
+		do
 		{
-			++bar_index;
-			bar_index = drawBar(*it, timer_bar.mChildrenRect, bars, bar_index, bar_image);
+			is_last = row.mBars[bar_index].mLastChild;
+			bar_index = drawBar(children_rect, row, image_width, image_height, hovered, children_visible, bar_index);
 		}
+		while(!is_last && bar_index < num_bars);
 	}
 
 	return bar_index;
diff --git a/indra/newview/llfasttimerview.h b/indra/newview/llfasttimerview.h
index 341adacd65..d931f25a7e 100755
--- a/indra/newview/llfasttimerview.h
+++ b/indra/newview/llfasttimerview.h
@@ -31,6 +31,7 @@
 #include "llfasttimer.h"
 #include "llunit.h"
 #include "lltracerecording.h"
+#include <deque>
 
 class LLFastTimerView : public LLFloater
 {
@@ -60,17 +61,15 @@ public:
 	virtual BOOL handleToolTip(S32 x, S32 y, MASK mask);
 	virtual BOOL handleScrollWheel(S32 x, S32 y, S32 clicks);
 	virtual void draw();
-
+	virtual void onOpen(const LLSD& key);
 	LLTrace::TimeBlock* getLegendID(S32 y);
 
-protected:
-	virtual	void	onClickCloseBtn();
-
 private:	
+	virtual	void	onClickCloseBtn();
 	void drawTicks();
 	void drawLineGraph();
-	void drawLegend(S32 y);
-	S32 drawHelp(S32 y);
+	void drawLegend();
+	void drawHelp(S32 y);
 	void drawBorders( S32 y, const S32 x_start, S32 barh, S32 dy);
 	void drawBars();
 
@@ -81,53 +80,63 @@ private:
 	struct TimerBar
 	{
 		TimerBar()
-		:	mWidth(0),
-			mSelfWidth(0),
-			mVisible(true),
+		:	mTotalTime(0),
+			mSelfTime(0),
 			mStartFraction(0.f),
-			mEndFraction(1.f)
+			mEndFraction(1.f),
+			mFirstChild(false),
+			mLastChild(false)
 		{}
-		S32			mWidth;
-		S32			mSelfWidth;
-		LLRect		mVisibleRect,
-					mChildrenRect;
-		LLColor4	mColor;
-		bool		mVisible;
-		F32			mStartFraction,
-					mEndFraction;
+		LLUnit<F32, LLUnits::Seconds>	mTotalTime,
+										mSelfTime,
+										mChildrenStart,
+										mChildrenEnd,
+										mSelfStart,
+										mSelfEnd;
+		LLTrace::TimeBlock* mTimeBlock;
+		bool				mVisible,
+							mFirstChild,
+							mLastChild;
+		F32					mStartFraction,
+							mEndFraction;
 	};
-	S32 updateTimerBarWidths(LLTrace::TimeBlock* time_block, std::vector<TimerBar>& bars, S32 history_index, bool visible);
-	S32 updateTimerBarFractions(LLTrace::TimeBlock* time_block, S32 timer_bar_index, std::vector<TimerBar>& bars);
-	S32 drawBar(LLTrace::TimeBlock* time_block, LLRect bar_rect, std::vector<TimerBar>& bars, S32 bar_index, LLPointer<LLUIImage>& bar_image);
+
+	struct TimerBarRow
+	{
+		S32			mBottom,
+					mTop;
+		TimerBar*	mBars;
+	};
+
+	LLUnit<F32, LLUnits::Seconds> updateTimerBarWidths(LLTrace::TimeBlock* time_block, TimerBarRow& row, S32 history_index, U32& bar_index);
+	S32 updateTimerBarOffsets(LLTrace::TimeBlock* time_block, TimerBarRow& row, S32 timer_bar_index = 0);
+	S32 drawBar(LLRect bar_rect, TimerBarRow& row, S32 image_width, S32 image_height, bool hovered = false, bool visible = true, S32 bar_index = 0);
 	void setPauseState(bool pause_state);
 
-	std::vector<TimerBar>* mTimerBars;
-	S32 mDisplayMode;
+	std::deque<TimerBarRow> mTimerBarRows;
+	TimerBarRow				mAverageTimerRow;
 
-	typedef enum child_alignment
+	enum EDisplayType
 	{
-		ALIGN_LEFT,
-		ALIGN_CENTER,
-		ALIGN_RIGHT,
-		ALIGN_COUNT
-	} ChildAlignment;
-
-	ChildAlignment mDisplayCenter;
-	bool                          mDisplayCalls,
-								  mDisplayHz;
-	LLUnit<LLUnits::Seconds, F64> mAllTimeMax,
-								  mTotalTimeDisplay;
-	LLRect mBarRect;
-	S32	mScrollIndex;
-	LLTrace::TimeBlock*           mHoverID;
-	LLTrace::TimeBlock*           mHoverTimer;
-	LLRect					mToolTipRect;
-	S32 mHoverBarIndex;
-	LLFrameTimer mHighlightTimer;
-	S32 mPrintStats;
-	LLRect mGraphRect;
-	LLTrace::PeriodicRecording*	  mRecording;
-	bool						  mPauseHistory;
+		TIME,
+		CALLS,
+		HZ
+	}								mDisplayType;
+	bool							mPauseHistory;
+	LLUnit<F64, LLUnits::Seconds>	mAllTimeMax,
+									mTotalTimeDisplay;
+	S32								mScrollIndex,
+									mHoverBarIndex,
+									mStatsIndex;
+	S32								mDisplayMode;
+	LLTrace::TimeBlock*				mHoverID;
+	LLTrace::TimeBlock*				mHoverTimer;
+	LLRect							mToolTipRect,
+									mGraphRect,
+									mBarRect,
+									mLegendRect;
+	LLFrameTimer					mHighlightTimer;
+	LLTrace::PeriodicRecording		mRecording;
 };
 
 #endif
diff --git a/indra/newview/llscenemonitor.cpp b/indra/newview/llscenemonitor.cpp
index dccf8a2a17..8086745471 100644
--- a/indra/newview/llscenemonitor.cpp
+++ b/indra/newview/llscenemonitor.cpp
@@ -503,9 +503,9 @@ void LLSceneMonitor::dumpToFile(std::string file_name)
 	os << std::setprecision(3);
 
 	PeriodicRecording& scene_load_recording = mSceneLoadRecording.getAcceptedRecording();
-	const U32 frame_count = scene_load_recording.getNumPeriods();
+	const U32 frame_count = scene_load_recording.getNumRecordedPeriods();
 
-	LLUnit<LLUnits::Seconds, F64> frame_time;
+	LLUnit<F64, LLUnits::Seconds> frame_time;
 
 	os << "Stat";
 	for (S32 frame = 0; frame < frame_count; frame++)
@@ -616,7 +616,7 @@ void LLSceneMonitor::dumpToFile(std::string file_name)
 
 		for (S32 frame = 0; frame < frame_count; frame++)
 		{
-			os << ", " << scene_load_recording.getPrevRecording(frame_count - frame).getMax(*it).as<LLUnits::Kibibytes>().value();
+			os << ", " << scene_load_recording.getPrevRecording(frame_count - frame).getMax(*it).getAs<LLUnits::Kibibytes>();
 		}
 
 		os << std::endl;
diff --git a/indra/newview/lltexturefetch.h b/indra/newview/lltexturefetch.h
index 2530beb722..7fc58e230c 100755
--- a/indra/newview/lltexturefetch.h
+++ b/indra/newview/lltexturefetch.h
@@ -330,7 +330,7 @@ private:
 	LLTextureInfo mTextureInfo;
 
 	// XXX possible delete
-	LLUnit<LLUnits::Bits, U32> mHTTPTextureBits;												// Mfnq
+	LLUnit<U32, LLUnits::Bits> mHTTPTextureBits;												// Mfnq
 
 	// XXX possible delete
 	//debug use
diff --git a/indra/newview/lltextureview.cpp b/indra/newview/lltextureview.cpp
index c9ec5d9bf6..766b66efa0 100755
--- a/indra/newview/lltextureview.cpp
+++ b/indra/newview/lltextureview.cpp
@@ -507,17 +507,17 @@ private:
 
 void LLGLTexMemBar::draw()
 {
-	LLUnit<LLUnits::Mibibytes, S32> bound_mem = LLViewerTexture::sBoundTextureMemory;
- 	LLUnit<LLUnits::Mibibytes, S32> max_bound_mem = LLViewerTexture::sMaxBoundTextureMem;
-	LLUnit<LLUnits::Mibibytes, S32> total_mem = LLViewerTexture::sTotalTextureMemory;
-	LLUnit<LLUnits::Mibibytes, S32> max_total_mem = LLViewerTexture::sMaxTotalTextureMem;
+	LLUnit<S32, LLUnits::Mibibytes> bound_mem = LLViewerTexture::sBoundTextureMemory;
+ 	LLUnit<S32, LLUnits::Mibibytes> max_bound_mem = LLViewerTexture::sMaxBoundTextureMem;
+	LLUnit<S32, LLUnits::Mibibytes> total_mem = LLViewerTexture::sTotalTextureMemory;
+	LLUnit<S32, LLUnits::Mibibytes> max_total_mem = LLViewerTexture::sMaxTotalTextureMem;
 	F32 discard_bias = LLViewerTexture::sDesiredDiscardBias;
 	F32 cache_usage = (F32)LLTrace::Mibibytes(LLAppViewer::getTextureCache()->getUsage()).value() ;
 	F32 cache_max_usage = (F32)LLTrace::Mibibytes(LLAppViewer::getTextureCache()->getMaxUsage()).value() ;
 	S32 line_height = LLFontGL::getFontMonospace()->getLineHeight();
 	S32 v_offset = 0;//(S32)((texture_bar_height + 2.2f) * mTextureView->mNumTextureBars + 2.0f);
-	LLUnit<LLUnits::Bytes, F32> total_texture_downloaded = gTotalTextureData;
-	LLUnit<LLUnits::Bytes, F32> total_object_downloaded = gTotalObjectData;
+	LLUnit<F32, LLUnits::Bytes> total_texture_downloaded = gTotalTextureData;
+	LLUnit<F32, LLUnits::Bytes> total_object_downloaded = gTotalObjectData;
 	U32 total_http_requests = LLAppViewer::getTextureFetch()->getTotalNumHTTPRequests() ;
 	U32 total_active_cached_objects = LLWorld::getInstance()->getNumOfActiveCachedObjects();
 	U32 total_objects = gObjectList.getNumObjects();
diff --git a/indra/newview/llviewerassetstats.cpp b/indra/newview/llviewerassetstats.cpp
index 3a6ee636d4..dc4c9fe4ad 100755
--- a/indra/newview/llviewerassetstats.cpp
+++ b/indra/newview/llviewerassetstats.cpp
@@ -486,10 +486,10 @@ void LLViewerAssetStats::getStats(AssetStats& stats, bool compact_output)
 		grid_from_region_handle(it->first, &grid_x, &grid_y);
 		r.grid_x(grid_x);
 		r.grid_y(grid_y);
-		r.duration(LLUnit<LLUnits::Microseconds, F64>(rec.getDuration()).value());
+		r.duration(LLUnit<F64, LLUnits::Microseconds>(rec.getDuration()).value());
 	}
 
-	stats.duration(mCurRecording ? LLUnit<LLUnits::Microseconds, F64>(mCurRecording->getDuration()).value() : 0.0);
+	stats.duration(mCurRecording ? LLUnit<F64, LLUnits::Microseconds>(mCurRecording->getDuration()).value() : 0.0);
 }
 
 LLSD LLViewerAssetStats::asLLSD(bool compact_output)
diff --git a/indra/newview/llviewerassetstats.h b/indra/newview/llviewerassetstats.h
index 1a8770f8a7..e03b7c53a6 100755
--- a/indra/newview/llviewerassetstats.h
+++ b/indra/newview/llviewerassetstats.h
@@ -83,7 +83,7 @@ public:
 	 * for compatibility with the pre-existing timestamp on the texture
 	 * fetcher class, LLTextureFetch.
 	 */
-	typedef LLUnit<LLUnits::Microseconds, U64> duration_t;
+	typedef LLUnit<U64, LLUnits::Microseconds> duration_t;
 
 	/**
 	 * Type for the region identifier used in stats.  Currently uses
diff --git a/indra/newview/llviewermessage.cpp b/indra/newview/llviewermessage.cpp
index f2a3ffc3dc..0309acdad2 100755
--- a/indra/newview/llviewermessage.cpp
+++ b/indra/newview/llviewermessage.cpp
@@ -4480,18 +4480,18 @@ void send_agent_update(BOOL force_send, BOOL send_reliable)
 
 // *TODO: Remove this dependency, or figure out a better way to handle
 // this hack.
-extern LLUnit<LLUnits::Bits, U32> gObjectData;
+extern LLUnit<U32, LLUnits::Bits> gObjectData;
 
 void process_object_update(LLMessageSystem *mesgsys, void **user_data)
 {	
 	// Update the data counters
 	if (mesgsys->getReceiveCompressedSize())
 	{
-		gObjectData += (LLUnit<LLUnits::Bytes, U32>)mesgsys->getReceiveCompressedSize();
+		gObjectData += (LLUnit<U32, LLUnits::Bytes>)mesgsys->getReceiveCompressedSize();
 	}
 	else
 	{
-		gObjectData += (LLUnit<LLUnits::Bytes, U32>)mesgsys->getReceiveSize();
+		gObjectData += (LLUnit<U32, LLUnits::Bytes>)mesgsys->getReceiveSize();
 	}
 
 	// Update the object...
@@ -4503,11 +4503,11 @@ void process_compressed_object_update(LLMessageSystem *mesgsys, void **user_data
 	// Update the data counters
 	if (mesgsys->getReceiveCompressedSize())
 	{
-		gObjectData += (LLUnit<LLUnits::Bytes, U32>)mesgsys->getReceiveCompressedSize();
+		gObjectData += (LLUnit<U32, LLUnits::Bytes>)mesgsys->getReceiveCompressedSize();
 	}
 	else
 	{
-		gObjectData += (LLUnit<LLUnits::Bytes, U32>)mesgsys->getReceiveSize();
+		gObjectData += (LLUnit<U32, LLUnits::Bytes>)mesgsys->getReceiveSize();
 	}
 
 	// Update the object...
@@ -4519,11 +4519,11 @@ void process_cached_object_update(LLMessageSystem *mesgsys, void **user_data)
 	// Update the data counters
 	if (mesgsys->getReceiveCompressedSize())
 	{
-		gObjectData += (LLUnit<LLUnits::Bytes, U32>)mesgsys->getReceiveCompressedSize();
+		gObjectData += (LLUnit<U32, LLUnits::Bytes>)mesgsys->getReceiveCompressedSize();
 	}
 	else
 	{
-		gObjectData += (LLUnit<LLUnits::Bytes, U32>)mesgsys->getReceiveSize();
+		gObjectData += (LLUnit<U32, LLUnits::Bytes>)mesgsys->getReceiveSize();
 	}
 
 	// Update the object...
@@ -4535,11 +4535,11 @@ void process_terse_object_update_improved(LLMessageSystem *mesgsys, void **user_
 {
 	if (mesgsys->getReceiveCompressedSize())
 	{
-		gObjectData += (LLUnit<LLUnits::Bytes, U32>)mesgsys->getReceiveCompressedSize();
+		gObjectData += (LLUnit<U32, LLUnits::Bytes>)mesgsys->getReceiveCompressedSize();
 	}
 	else
 	{
-		gObjectData += (LLUnit<LLUnits::Bytes, U32>)mesgsys->getReceiveSize();
+		gObjectData += (LLUnit<U32, LLUnits::Bytes>)mesgsys->getReceiveSize();
 	}
 
 	gObjectList.processCompressedObjectUpdate(mesgsys, user_data, OUT_TERSE_IMPROVED);
diff --git a/indra/newview/llviewerstats.cpp b/indra/newview/llviewerstats.cpp
index be477f7f9a..7ddee48b38 100755
--- a/indra/newview/llviewerstats.cpp
+++ b/indra/newview/llviewerstats.cpp
@@ -290,13 +290,13 @@ F32		gAveLandCompression = 0.f,
 		gWorstLandCompression = 0.f, 
 		gWorstWaterCompression = 0.f;
 
-LLUnit<LLUnits::Bytes, U32>		gTotalWorldData = 0, 
+LLUnit<U32, LLUnits::Bytes>		gTotalWorldData = 0, 
 						gTotalObjectData = 0, 
 						gTotalTextureData = 0;
 U32						gSimPingCount = 0;
-LLUnit<LLUnits::Bits, U32>		gObjectData = 0;
+LLUnit<U32, LLUnits::Bits>		gObjectData = 0;
 F32		gAvgSimPing = 0.f;
-LLUnit<LLUnits::Bytes, U32>		gTotalTextureBytesPerBoostLevel[LLViewerTexture::MAX_GL_IMAGE_CATEGORY] = {0};
+LLUnit<U32, LLUnits::Bytes>		gTotalTextureBytesPerBoostLevel[LLViewerTexture::MAX_GL_IMAGE_CATEGORY] = {0};
 
 extern U32  gVisCompared;
 extern U32  gVisTested;
@@ -334,8 +334,8 @@ void update_statistics()
 
 	typedef LLInstanceTracker<LLTrace::TraceType<LLTrace::TimeBlockAccumulator>, std::string> trace_type_t;
 
-	LLUnit<LLUnits::Seconds, F64> idle_secs = last_frame_recording.getSum(*trace_type_t::getInstance("Idle"));
-	LLUnit<LLUnits::Seconds, F64> network_secs = last_frame_recording.getSum(*trace_type_t::getInstance("Network"));
+	LLUnit<F64, LLUnits::Seconds> idle_secs = last_frame_recording.getSum(*trace_type_t::getInstance("Idle"));
+	LLUnit<F64, LLUnits::Seconds> network_secs = last_frame_recording.getSum(*trace_type_t::getInstance("Network"));
 
 	record(LLStatViewer::FRAME_STACKTIME, last_frame_recording.getSum(*trace_type_t::getInstance("Frame")));
 	record(LLStatViewer::UPDATE_STACKTIME, idle_secs - network_secs);
diff --git a/indra/newview/llviewerstats.h b/indra/newview/llviewerstats.h
index bfba7bca9a..4e48a61264 100755
--- a/indra/newview/llviewerstats.h
+++ b/indra/newview/llviewerstats.h
@@ -331,7 +331,7 @@ void update_statistics();
 void send_stats();
 
 extern LLFrameTimer gTextureTimer;
-extern LLUnit<LLUnits::Bytes, U32>	gTotalTextureData;
-extern LLUnit<LLUnits::Bytes, U32>  gTotalObjectData;
-extern LLUnit<LLUnits::Bytes, U32>  gTotalTextureBytesPerBoostLevel[] ;
+extern LLUnit<U32, LLUnits::Bytes>	gTotalTextureData;
+extern LLUnit<U32, LLUnits::Bytes>  gTotalObjectData;
+extern LLUnit<U32, LLUnits::Bytes>  gTotalTextureBytesPerBoostLevel[] ;
 #endif // LL_LLVIEWERSTATS_H
diff --git a/indra/newview/llviewertexture.cpp b/indra/newview/llviewertexture.cpp
index e0a88bfad6..f468df0674 100755
--- a/indra/newview/llviewertexture.cpp
+++ b/indra/newview/llviewertexture.cpp
@@ -66,8 +66,8 @@
 ///////////////////////////////////////////////////////////////////////////////
 
 // extern
-const LLUnit<LLUnits::Mibibytes, S32> gMinVideoRam = 32;
-const LLUnit<LLUnits::Mibibytes, S32> gMaxVideoRam = 512;
+const LLUnit<S32, LLUnits::Mibibytes> gMinVideoRam = 32;
+const LLUnit<S32, LLUnits::Mibibytes> gMaxVideoRam = 512;
 
 
 // statics
@@ -88,11 +88,11 @@ S32 LLViewerTexture::sAuxCount = 0;
 LLFrameTimer LLViewerTexture::sEvaluationTimer;
 F32 LLViewerTexture::sDesiredDiscardBias = 0.f;
 F32 LLViewerTexture::sDesiredDiscardScale = 1.1f;
-LLUnit<LLUnits::Bytes, S32> LLViewerTexture::sBoundTextureMemory = 0;
-LLUnit<LLUnits::Bytes, S32> LLViewerTexture::sTotalTextureMemory = 0;
-LLUnit<LLUnits::Mibibytes, S32> LLViewerTexture::sMaxBoundTextureMem = 0;
-LLUnit<LLUnits::Mibibytes, S32> LLViewerTexture::sMaxTotalTextureMem = 0;
-LLUnit<LLUnits::Bytes, S32> LLViewerTexture::sMaxDesiredTextureMem = 0 ;
+LLUnit<S32, LLUnits::Bytes> LLViewerTexture::sBoundTextureMemory = 0;
+LLUnit<S32, LLUnits::Bytes> LLViewerTexture::sTotalTextureMemory = 0;
+LLUnit<S32, LLUnits::Mibibytes> LLViewerTexture::sMaxBoundTextureMem = 0;
+LLUnit<S32, LLUnits::Mibibytes> LLViewerTexture::sMaxTotalTextureMem = 0;
+LLUnit<S32, LLUnits::Bytes> LLViewerTexture::sMaxDesiredTextureMem = 0 ;
 S8  LLViewerTexture::sCameraMovingDiscardBias = 0 ;
 F32 LLViewerTexture::sCameraMovingBias = 0.0f ;
 S32 LLViewerTexture::sMaxSculptRez = 128 ; //max sculpt image size
@@ -542,7 +542,7 @@ void LLViewerTexture::updateClass(const F32 velocity, const F32 angular_velocity
 		sTotalTextureMemory >= sMaxTotalTextureMem)
 	{
 		//when texture memory overflows, lower down the threshold to release the textures more aggressively.
-		sMaxDesiredTextureMem = llmin(sMaxDesiredTextureMem * 0.75f, LLUnit<LLUnits::Bytes, S32>(gMaxVideoRam));
+		sMaxDesiredTextureMem = llmin(sMaxDesiredTextureMem * 0.75f, LLUnit<S32, LLUnits::Bytes>(gMaxVideoRam));
 	
 		// If we are using more texture memory than we should,
 		// scale up the desired discard level
diff --git a/indra/newview/llviewertexture.h b/indra/newview/llviewertexture.h
index e939731cf2..529b812f41 100755
--- a/indra/newview/llviewertexture.h
+++ b/indra/newview/llviewertexture.h
@@ -39,8 +39,8 @@
 #include <map>
 #include <list>
 
-extern const LLUnit<LLUnits::Mibibytes, S32> gMinVideoRam;
-extern const LLUnit<LLUnits::Mibibytes, S32> gMaxVideoRam;
+extern const LLUnit<S32, LLUnits::Mibibytes> gMinVideoRam;
+extern const LLUnit<S32, LLUnits::Mibibytes> gMaxVideoRam;
 
 class LLFace;
 class LLImageGL ;
@@ -205,11 +205,11 @@ public:
 	static LLFrameTimer sEvaluationTimer;
 	static F32 sDesiredDiscardBias;
 	static F32 sDesiredDiscardScale;
-	static LLUnit<LLUnits::Bytes, S32> sBoundTextureMemory;
-	static LLUnit<LLUnits::Bytes, S32> sTotalTextureMemory;
-	static LLUnit<LLUnits::Mibibytes, S32> sMaxBoundTextureMem;
-	static LLUnit<LLUnits::Mibibytes, S32> sMaxTotalTextureMem;
-	static LLUnit<LLUnits::Bytes, S32> sMaxDesiredTextureMem ;
+	static LLUnit<S32, LLUnits::Bytes> sBoundTextureMemory;
+	static LLUnit<S32, LLUnits::Bytes> sTotalTextureMemory;
+	static LLUnit<S32, LLUnits::Mibibytes> sMaxBoundTextureMem;
+	static LLUnit<S32, LLUnits::Mibibytes> sMaxTotalTextureMem;
+	static LLUnit<S32, LLUnits::Bytes> sMaxDesiredTextureMem ;
 	static S8  sCameraMovingDiscardBias;
 	static F32 sCameraMovingBias;
 	static S32 sMaxSculptRez ;
diff --git a/indra/newview/llviewerwindow.cpp b/indra/newview/llviewerwindow.cpp
index 349849a267..97f7baa98d 100755
--- a/indra/newview/llviewerwindow.cpp
+++ b/indra/newview/llviewerwindow.cpp
@@ -738,7 +738,7 @@ public:
 			{
 				if(gTotalTextureBytesPerBoostLevel[i] > 0)
 				{
-					addText(xpos, ypos, llformat("Boost_Level %d:  %.3f MB", i, LLUnit<LLUnits::Mibibytes, F32>(gTotalTextureBytesPerBoostLevel[i]).value()));
+					addText(xpos, ypos, llformat("Boost_Level %d:  %.3f MB", i, LLUnit<F32, LLUnits::Mibibytes>(gTotalTextureBytesPerBoostLevel[i]).value()));
 					ypos += y_inc;
 				}
 			}
diff --git a/indra/newview/pipeline.cpp b/indra/newview/pipeline.cpp
index dd5c153d55..7cf30e1661 100755
--- a/indra/newview/pipeline.cpp
+++ b/indra/newview/pipeline.cpp
@@ -2792,7 +2792,7 @@ void LLPipeline::updateGeom(F32 max_dtime)
 		
 	S32 count = 0;
 	
-	max_dtime = llmax(update_timer.getElapsedTimeF32()+0.001f, LLUnitImplicit<LLUnits::Seconds, F32>(max_dtime));
+	max_dtime = llmax(update_timer.getElapsedTimeF32()+0.001f, LLUnitImplicit<F32, LLUnits::Seconds>(max_dtime));
 	LLSpatialGroup* last_group = NULL;
 	LLSpatialBridge* last_bridge = NULL;
 
diff --git a/indra/newview/skins/default/xui/en/floater_fast_timers.xml b/indra/newview/skins/default/xui/en/floater_fast_timers.xml
index 77adb5524e..671f116df3 100755
--- a/indra/newview/skins/default/xui/en/floater_fast_timers.xml
+++ b/indra/newview/skins/default/xui/en/floater_fast_timers.xml
@@ -16,6 +16,27 @@
  width="700">
   <string name="pause" >Pause</string>
   <string name="run">Run</string>
+  <combo_box name="time_scale_combo"
+             follows="left|top"
+             left="10"
+             top="5"
+             width="150"
+             height="20">
+    <item label="2x Average"/>
+    <item label="Max"/>
+    <item label="Recent Max"/>
+    <item label="100ms"/>
+  </combo_box>
+  <combo_box name="metric_combo"
+             follows="left|top"
+             left_pad="10"
+             top="5"
+             width="150"
+             height="20">
+    <item label="Time"/>
+    <item label="Number of Calls"/>
+    <item label="Hz"/>
+  </combo_box>
   <button follows="top|right" 
           name="pause_btn"
           left="-200"
@@ -24,4 +45,52 @@
           height="40"
           label="Pause"
           font="SansSerifHuge"/>
+  <layout_stack name="legend_stack"
+                orientation="horizontal"
+                left="0"
+                top="50"
+                right="695"
+                bottom="500"
+                follows="all">
+    <layout_panel name="legend_panel"
+                  auto_resize="false"
+                  user_resize="true"
+                  width="220"
+                  height="450"
+                  min_width="100">
+      <panel top="0"
+             left="0"
+             width="220"
+             height="440"
+             name="legend"
+             follows="all"/>
+    </layout_panel>
+    <layout_panel name="timers_panel"
+                  auto_resize="true"
+                  user_resize="true"
+                  height="450"
+                  width="475"
+                  min_width="100">
+      <layout_stack name="timer_bars_stack"
+                    orientation="vertical"
+                    left="0"
+                    top="0"
+                    width="475"
+                    height="445"
+                    follows="all">
+        <layout_panel name="bars_panel"
+                      auto_resize="true"
+                      user_resize="true"
+                      top="0"
+                      width="475"
+                      height="210"/>
+        <layout_panel name="lines_panel"
+                      auto_resize="false"
+                      user_resize="true"
+                      width="475"
+                      min_height="50"
+                      height="240"/>
+      </layout_stack>
+    </layout_panel>
+  </layout_stack>
 </floater>