summaryrefslogtreecommitdiff
path: root/indra/newview
diff options
context:
space:
mode:
Diffstat (limited to 'indra/newview')
-rwxr-xr-xindra/newview/llappviewer.cpp4
-rwxr-xr-xindra/newview/llappviewer.h2
-rwxr-xr-xindra/newview/lldrawable.cpp2
-rwxr-xr-xindra/newview/llfasttimerview.cpp664
-rwxr-xr-xindra/newview/llfasttimerview.h101
-rw-r--r--indra/newview/llscenemonitor.cpp6
-rwxr-xr-xindra/newview/lltexturefetch.h2
-rwxr-xr-xindra/newview/lltextureview.cpp12
-rwxr-xr-xindra/newview/llviewerassetstats.cpp4
-rwxr-xr-xindra/newview/llviewerassetstats.h2
-rwxr-xr-xindra/newview/llviewerdisplay.cpp2
-rwxr-xr-xindra/newview/llviewermessage.cpp18
-rwxr-xr-xindra/newview/llviewerstats.cpp10
-rwxr-xr-xindra/newview/llviewerstats.h6
-rwxr-xr-xindra/newview/llviewertexture.cpp16
-rwxr-xr-xindra/newview/llviewertexture.h14
-rwxr-xr-xindra/newview/llviewerwindow.cpp2
-rwxr-xr-xindra/newview/pipeline.cpp2
-rwxr-xr-xindra/newview/skins/default/xui/en/floater_fast_timers.xml69
19 files changed, 544 insertions, 394 deletions
diff --git a/indra/newview/llappviewer.cpp b/indra/newview/llappviewer.cpp
index 42bf9b657b..8c51bd4198 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
@@ -1248,7 +1248,7 @@ static LLFastTimer::DeclareTimer FTM_SERVICE_CALLBACK("Callback");
static LLFastTimer::DeclareTimer FTM_AGENT_AUTOPILOT("Autopilot");
static LLFastTimer::DeclareTimer FTM_AGENT_UPDATE("Update");
-LLFastTimer::DeclareTimer FTM_FRAME("Frame", true);
+LLFastTimer::DeclareTimer FTM_FRAME("Frame");
bool LLAppViewer::mainLoop()
{
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/lldrawable.cpp b/indra/newview/lldrawable.cpp
index 30d1b7fdba..8587c7852b 100755
--- a/indra/newview/lldrawable.cpp
+++ b/indra/newview/lldrawable.cpp
@@ -300,7 +300,7 @@ S32 LLDrawable::findReferences(LLDrawable *drawablep)
return count;
}
-static LLFastTimer::DeclareTimer FTM_ALLOCATE_FACE("Allocate Face", true);
+static LLFastTimer::DeclareTimer FTM_ALLOCATE_FACE("Allocate Face");
LLFace* LLDrawable::addFace(LLFacePool *poolp, LLViewerTexture *texturep)
{
diff --git a/indra/newview/llfasttimerview.cpp b/indra/newview/llfasttimerview.cpp
index 40526d3357..ec307b841e 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"));
@@ -161,13 +152,13 @@ BOOL LLFastTimerView::handleRightMouseDown(S32 x, S32 y, MASK mask)
if (mHoverTimer )
{
// right click collapses timers
- if (!mHoverTimer->getCollapsed())
+ if (!mHoverTimer->getTreeNode().mCollapsed)
{
- mHoverTimer->setCollapsed(true);
+ mHoverTimer->getTreeNode().mCollapsed = true;
}
else if (mHoverTimer->getParent())
{
- mHoverTimer->getParent()->setCollapsed(true);
+ mHoverTimer->getParent()->getTreeNode().mCollapsed = true;
}
return TRUE;
}
@@ -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())
{
@@ -199,7 +190,7 @@ BOOL LLFastTimerView::handleDoubleClick(S32 x, S32 y, MASK mask)
it != end_timer_tree();
++it)
{
- (*it)->setCollapsed(false);
+ (*it)->getTreeNode().mCollapsed = false;
}
return TRUE;
}
@@ -211,33 +202,13 @@ BOOL LLFastTimerView::handleMouseDown(S32 x, S32 y, MASK mask)
TimeBlock* idp = getLegendID(y);
if (idp)
{
- idp->setCollapsed(!idp->getCollapsed());
+ idp->getTreeNode().mCollapsed = !idp->getTreeNode().mCollapsed;
}
}
else if (mHoverTimer)
{
//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);
+ mHoverTimer->getTreeNode().mCollapsed = false;
}
else if (mGraphRect.pointInRect(x, y))
{
@@ -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->getTreeNode().mCollapsed)
{
- // 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,47 +369,81 @@ 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;
}
-static TimeBlock FTM_RENDER_TIMER("Timers", true);
+static TimeBlock FTM_RENDER_TIMER("Timers");
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;
@@ -953,7 +975,7 @@ void LLFastTimerView::printLineStats()
first = false;
legend_stat += idp->getName();
- if (idp->getCollapsed())
+ if (idp->getTreeNode().mCollapsed)
{
it.skipDescendants();
}
@@ -974,26 +996,26 @@ 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());
- if (idp->getCollapsed())
+ if (idp->getTreeNode().mCollapsed)
{
it.skipDescendants();
}
}
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);
}
@@ -1113,7 +1135,7 @@ void LLFastTimerView::drawLineGraph()
glLineWidth(1);
}
- if (idp->getCollapsed())
+ if (idp->getTreeNode().mCollapsed)
{
//skip hidden timers
it.skipDescendants();
@@ -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;
@@ -1218,7 +1267,7 @@ void LLFastTimerView::drawLegend( S32 y )
gl_line_2d(x + dx - 8, line_start_y, x + dx, line_start_y, color);
S32 line_x = x + (TEXT_HEIGHT + 4) + ((get_depth(idp) - 1) * 8);
gl_line_2d(line_x, line_start_y, line_x, line_end_y, color);
- if (idp->getCollapsed() && !idp->getChildren().empty())
+ if (idp->getTreeNode().mCollapsed && !idp->getChildren().empty())
{
gl_line_2d(line_x+4, line_start_y-3, line_x+4, line_start_y+4, color);
}
@@ -1242,7 +1291,7 @@ void LLFastTimerView::drawLegend( S32 y )
y -= (TEXT_HEIGHT + 2);
- if (idp->getCollapsed())
+ if (idp->getTreeNode().mCollapsed)
{
it.skipDescendants();
}
@@ -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->getTreeNode().mCollapsed;
+
+ 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/llviewerdisplay.cpp b/indra/newview/llviewerdisplay.cpp
index 7ad4743d82..bd85056d70 100755
--- a/indra/newview/llviewerdisplay.cpp
+++ b/indra/newview/llviewerdisplay.cpp
@@ -210,7 +210,7 @@ void display_stats()
}
static LLFastTimer::DeclareTimer FTM_PICK("Picking");
-static LLFastTimer::DeclareTimer FTM_RENDER("Render", true);
+static LLFastTimer::DeclareTimer FTM_RENDER("Render");
static LLFastTimer::DeclareTimer FTM_UPDATE_SKY("Update Sky");
static LLFastTimer::DeclareTimer FTM_UPDATE_TEXTURES("Update Textures");
static LLFastTimer::DeclareTimer FTM_IMAGE_UPDATE("Update Images");
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>
generated by cgit v1.2.3 (git 2.25.1) at 2024-12-01 22:59:51 +0000