livie
/
phoenix-firestorm
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

renamed LLFastTimerUtil to LLFastTimer

master
richard 2010-01-11 12:05:13 -08:00
parent eb228dcf3a
commit daa4965fe0
60 changed files with 319 additions and 335 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
indra/llcharacter/llcharacter.cpp
View File

@ -180,7 +180,7 @@ void LLCharacter::requestStopMotion( LLMotion* motion)
//-----------------------------------------------------------------------------
// updateMotions()
//-----------------------------------------------------------------------------
static LLFastTimerUtil::DeclareTimer FTM_UPDATE_ANIMATION("Update Animation");
static LLFastTimer::DeclareTimer FTM_UPDATE_ANIMATION("Update Animation");
void LLCharacter::updateMotions(e_update_t update_type)
{

2
indra/llcommon/lldate.cpp
View File

@ -94,7 +94,7 @@ std::string LLDate::asRFC1123() const
return toHTTPDateString (std::string ("%A, %d %b %Y %H:%M:%S GMT"));
}
LLFastTimerUtil::DeclareTimer FT_DATE_FORMAT("Date Format");
LLFastTimer::DeclareTimer FT_DATE_FORMAT("Date Format");
std::string LLDate::toHTTPDateString (std::string fmt) const
{

146
indra/llcommon/llfasttimer.h
View File

@ -97,8 +97,7 @@ class LLMutex;
#include <queue>
#include "llsd.h"
class LL_COMMON_API LLFastTimerUtil
class LL_COMMON_API LLFastTimer
{
public:
@ -153,9 +152,8 @@ public:
FrameState& getFrameState() const;
private:
friend class LLFastTimerUtil;
friend class LLFastTimer;
friend class NamedTimerFactory;
//
@ -172,7 +170,6 @@ public:
static void buildHierarchy();
static void resetFrame();
static void reset();
//
// members
@ -194,7 +191,6 @@ public:
std::vector<NamedTimer*> mChildren;
bool mCollapsed; // don't show children
bool mNeedsSorting; // sort children whenever child added
};
// used to statically declare a new named timer
@ -213,6 +209,63 @@ public:
FrameState* mFrameState;
};
public:
LLFastTimer(LLFastTimer::FrameState* state);
LL_INLINE LLFastTimer(LLFastTimer::DeclareTimer& timer)
: mFrameState(timer.mFrameState)
{
#if TIME_FAST_TIMERS
U64 timer_start = get_cpu_clock_count_64();
#endif
#if FAST_TIMER_ON
LLFastTimer::FrameState* frame_state = mFrameState;
mStartTime = get_cpu_clock_count_32();
frame_state->mActiveCount++;
frame_state->mCalls++;
// keep current parent as long as it is active when we are
frame_state->mMoveUpTree |= (frame_state->mParent->mActiveCount == 0);
LLFastTimer::CurTimerData* cur_timer_data = &LLFastTimer::sCurTimerData;
mLastTimerData = *cur_timer_data;
cur_timer_data->mCurTimer = this;
cur_timer_data->mFrameState = frame_state;
cur_timer_data->mChildTime = 0;
#endif
#if TIME_FAST_TIMERS
U64 timer_end = get_cpu_clock_count_64();
sTimerCycles += timer_end - timer_start;
#endif
}
LL_INLINE ~LLFastTimer()
{
#if TIME_FAST_TIMERS
U64 timer_start = get_cpu_clock_count_64();
#endif
#if FAST_TIMER_ON
LLFastTimer::FrameState* frame_state = mFrameState;
U32 total_time = get_cpu_clock_count_32() - mStartTime;
frame_state->mSelfTimeCounter += total_time - LLFastTimer::sCurTimerData.mChildTime;
frame_state->mActiveCount--;
// store last caller to bootstrap tree creation
// do this in the destructor in case of recursion to get topmost caller
frame_state->mLastCaller = mLastTimerData.mFrameState;
// we are only tracking self time, so subtract our total time delta from parents
mLastTimerData.mChildTime += total_time;
LLFastTimer::sCurTimerData = mLastTimerData;
#endif
#if TIME_FAST_TIMERS
U64 timer_end = get_cpu_clock_count_64();
sTimerCycles += timer_end - timer_start;
sTimerCalls++;
#endif
}
public:
static LLMutex* sLogLock;
@ -258,82 +311,13 @@ private:
static S32 sLastFrameIndex;
static U64 sLastFrameTime;
static info_list_t* sTimerInfos;
U32 mStartTime;
LLFastTimer::FrameState* mFrameState;
LLFastTimer::CurTimerData mLastTimerData;
};
class LLFastTimer
{
friend LLFastTimerUtil::NamedTimer;
public:
LLFastTimer(LLFastTimerUtil::FrameState* state)
: mFrameState(state)
{
U32 start_time = get_cpu_clock_count_32();
mStartTime = start_time;
mFrameState->mActiveCount++;
LLFastTimerUtil::sCurTimerData.mCurTimer = this;
LLFastTimerUtil::sCurTimerData.mFrameState = mFrameState;
LLFastTimerUtil::sCurTimerData.mChildTime = 0;
mLastTimerData = LLFastTimerUtil::sCurTimerData;
}
LL_INLINE LLFastTimer(LLFastTimerUtil::DeclareTimer& timer)
: mFrameState(timer.mFrameState)
{
#if TIME_FAST_TIMERS
U64 timer_start = get_cpu_clock_count_64();
#endif
#if FAST_TIMER_ON
LLFastTimerUtil::FrameState* frame_state = mFrameState;
mStartTime = get_cpu_clock_count_32();
frame_state->mActiveCount++;
frame_state->mCalls++;
// keep current parent as long as it is active when we are
frame_state->mMoveUpTree |= (frame_state->mParent->mActiveCount == 0);
LLFastTimerUtil::CurTimerData* cur_timer_data = &LLFastTimerUtil::sCurTimerData;
mLastTimerData = *cur_timer_data;
cur_timer_data->mCurTimer = this;
cur_timer_data->mFrameState = frame_state;
cur_timer_data->mChildTime = 0;
#endif
#if TIME_FAST_TIMERS
U64 timer_end = get_cpu_clock_count_64();
sTimerCycles += timer_end - timer_start;
#endif
}
LL_INLINE ~LLFastTimer()
{
#if TIME_FAST_TIMERS
U64 timer_start = get_cpu_clock_count_64();
#endif
#if FAST_TIMER_ON
LLFastTimerUtil::FrameState* frame_state = mFrameState;
U32 total_time = get_cpu_clock_count_32() - mStartTime;
frame_state->mSelfTimeCounter += total_time - LLFastTimerUtil::sCurTimerData.mChildTime;
frame_state->mActiveCount--;
// store last caller to bootstrap tree creation
// do this in the destructor in case of recursion to get topmost caller
frame_state->mLastCaller = mLastTimerData.mFrameState;
// we are only tracking self time, so subtract our total time delta from parents
mLastTimerData.mChildTime += total_time;
LLFastTimerUtil::sCurTimerData = mLastTimerData;
#endif
#if TIME_FAST_TIMERS
U64 timer_end = get_cpu_clock_count_64();
sTimerCycles += timer_end - timer_start;
sTimerCalls++;
#endif
}
private:
U32 mStartTime;
LLFastTimerUtil::FrameState* mFrameState;
LLFastTimerUtil::CurTimerData mLastTimerData;
};
typedef class LLFastTimer LLFastTimer;
#endif // LL_LLFASTTIMER_H

2
indra/llcommon/llstring.cpp
View File

@ -42,7 +42,7 @@
#include <winnls.h> // for WideCharToMultiByte
#endif
LLFastTimerUtil::DeclareTimer FT_STRING_FORMAT("String Format");
LLFastTimer::DeclareTimer FT_STRING_FORMAT("String Format");
std::string ll_safe_string(const char* in)

2
indra/llmessage/llpumpio.cpp
View File

@ -444,7 +444,7 @@ void LLPumpIO::pump()
pump(DEFAULT_POLL_TIMEOUT);
}
static LLFastTimerUtil::DeclareTimer FTM_PUMP("Pump");
static LLFastTimer::DeclareTimer FTM_PUMP("Pump");
//timeout is in microseconds
void LLPumpIO::pump(const S32& poll_timeout)

2
indra/llmessage/lltemplatemessagereader.cpp
View File

@ -531,7 +531,7 @@ void LLTemplateMessageReader::logRanOffEndOfPacket( const LLHost& host, const S3
gMessageSystem->callExceptionFunc(MX_RAN_OFF_END_OF_PACKET);
}
static LLFastTimerUtil::DeclareTimer FTM_PROCESS_MESSAGES("Process Messages");
static LLFastTimer::DeclareTimer FTM_PROCESS_MESSAGES("Process Messages");
// decode a given message
BOOL LLTemplateMessageReader::decodeData(const U8* buffer, const LLHost& sender )

2
indra/llrender/llfontgl.cpp
View File

@ -116,7 +116,7 @@ BOOL LLFontGL::loadFace(const std::string& filename, F32 point_size, F32 vert_dp
return mFontFreetype->loadFace(filename, point_size, vert_dpi, horz_dpi, components, is_fallback);
}
static LLFastTimerUtil::DeclareTimer FTM_RENDER_FONTS("Fonts");
static LLFastTimer::DeclareTimer FTM_RENDER_FONTS("Fonts");
S32 LLFontGL::render(const LLWString &wstr, S32 begin_offset, F32 x, F32 y, const LLColor4 &color, HAlign halign, VAlign valign, U8 style,
ShadowType shadow, S32 max_chars, S32 max_pixels, F32* right_x, BOOL use_ellipses) const

2
indra/llui/llfloater.cpp
View File

@ -2692,7 +2692,7 @@ void LLFloater::initFromParams(const LLFloater::Params& p)
}
}
LLFastTimerUtil::DeclareTimer POST_BUILD("Floater Post Build");
LLFastTimer::DeclareTimer POST_BUILD("Floater Post Build");
bool LLFloater::initFloaterXML(LLXMLNodePtr node, LLView *parent, LLXMLNodePtr output_node)
{

2
indra/llui/llkeywords.cpp
View File

@ -231,7 +231,7 @@ LLColor3 LLKeywords::readColor( const std::string& s )
return LLColor3( r, g, b );
}
LLFastTimerUtil::DeclareTimer FTM_SYNTAX_COLORING("Syntax Coloring");
LLFastTimer::DeclareTimer FTM_SYNTAX_COLORING("Syntax Coloring");
// Walk through a string, applying the rules specified by the keyword token list and
// create a list of color segments.

2
indra/llui/lllayoutstack.cpp
View File

@ -437,7 +437,7 @@ bool LLLayoutStack::getPanelMinSize(const std::string& panel_name, S32* min_widt
return NULL != panel;
}
static LLFastTimerUtil::DeclareTimer FTM_UPDATE_LAYOUT("Update LayoutStacks");
static LLFastTimer::DeclareTimer FTM_UPDATE_LAYOUT("Update LayoutStacks");
void LLLayoutStack::updateLayout(BOOL force_resize)
{
LLFastTimer ft(FTM_UPDATE_LAYOUT);

8
indra/llui/llpanel.cpp
View File

@ -369,7 +369,7 @@ void LLPanel::setBorderVisible(BOOL b)
}
}
LLFastTimerUtil::DeclareTimer FTM_PANEL_CONSTRUCTION("Panel Construction");
LLFastTimer::DeclareTimer FTM_PANEL_CONSTRUCTION("Panel Construction");
LLView* LLPanel::fromXML(LLXMLNodePtr node, LLView* parent, LLXMLNodePtr output_node)
{
@ -476,9 +476,9 @@ void LLPanel::initFromParams(const LLPanel::Params& p)
mBgAlphaImage = p.bg_alpha_image();
}
static LLFastTimerUtil::DeclareTimer FTM_PANEL_SETUP("Panel Setup");
static LLFastTimerUtil::DeclareTimer FTM_EXTERNAL_PANEL_LOAD("Load Extern Panel Reference");
static LLFastTimerUtil::DeclareTimer FTM_PANEL_POSTBUILD("Panel PostBuild");
static LLFastTimer::DeclareTimer FTM_PANEL_SETUP("Panel Setup");
static LLFastTimer::DeclareTimer FTM_EXTERNAL_PANEL_LOAD("Load Extern Panel Reference");
static LLFastTimer::DeclareTimer FTM_PANEL_POSTBUILD("Panel PostBuild");
BOOL LLPanel::initPanelXML(LLXMLNodePtr node, LLView *parent, LLXMLNodePtr output_node)
{

4
indra/llui/lltextbase.cpp
View File

@ -1065,7 +1065,7 @@ S32 LLTextBase::getLeftOffset(S32 width)
}
static LLFastTimerUtil::DeclareTimer FTM_TEXT_REFLOW ("Text Reflow");
static LLFastTimer::DeclareTimer FTM_TEXT_REFLOW ("Text Reflow");
void LLTextBase::reflow(S32 start_index)
{
LLFastTimer ft(FTM_TEXT_REFLOW);
@ -1377,7 +1377,7 @@ void LLTextBase::removeDocumentChild(LLView* view)
}
static LLFastTimerUtil::DeclareTimer FTM_UPDATE_TEXT_SEGMENTS("Update Text Segments");
static LLFastTimer::DeclareTimer FTM_UPDATE_TEXT_SEGMENTS("Update Text Segments");
void LLTextBase::updateSegments()
{
LLFastTimer ft(FTM_UPDATE_TEXT_SEGMENTS);

2
indra/llui/lltexteditor.cpp
View File

@ -2498,7 +2498,7 @@ BOOL LLTextEditor::tryToRevertToPristineState()
}
static LLFastTimerUtil::DeclareTimer FTM_SYNTAX_HIGHLIGHTING("Syntax Highlighting");
static LLFastTimer::DeclareTimer FTM_SYNTAX_HIGHLIGHTING("Syntax Highlighting");
void LLTextEditor::loadKeywords(const std::string& filename,
const std::vector<std::string>& funcs,
const std::vector<std::string>& tooltips,

16
indra/llui/lluictrlfactory.cpp
View File

@ -50,9 +50,9 @@
// this library includes
#include "llfloater.h"
LLFastTimerUtil::DeclareTimer FTM_WIDGET_CONSTRUCTION("Widget Construction");
LLFastTimerUtil::DeclareTimer FTM_INIT_FROM_PARAMS("Widget InitFromParams");
LLFastTimerUtil::DeclareTimer FTM_WIDGET_SETUP("Widget Setup");
LLFastTimer::DeclareTimer FTM_WIDGET_CONSTRUCTION("Widget Construction");
LLFastTimer::DeclareTimer FTM_INIT_FROM_PARAMS("Widget InitFromParams");
LLFastTimer::DeclareTimer FTM_WIDGET_SETUP("Widget Setup");
//-----------------------------------------------------------------------------
@ -105,7 +105,7 @@ void LLUICtrlFactory::loadWidgetTemplate(const std::string& widget_tag, LLInitPa
}
}
static LLFastTimerUtil::DeclareTimer FTM_CREATE_CHILDREN("Create XUI Children");
static LLFastTimer::DeclareTimer FTM_CREATE_CHILDREN("Create XUI Children");
//static
void LLUICtrlFactory::createChildren(LLView* viewp, LLXMLNodePtr node, const widget_registry_t& registry, LLXMLNodePtr output_node)
@ -147,7 +147,7 @@ void LLUICtrlFactory::createChildren(LLView* viewp, LLXMLNodePtr node, const wid
}
static LLFastTimerUtil::DeclareTimer FTM_XML_PARSE("XML Reading/Parsing");
static LLFastTimer::DeclareTimer FTM_XML_PARSE("XML Reading/Parsing");
//-----------------------------------------------------------------------------
// getLayeredXMLNode()
//-----------------------------------------------------------------------------
@ -175,7 +175,7 @@ bool LLUICtrlFactory::getLocalizedXMLNode(const std::string &xui_filename, LLXML
}
}
static LLFastTimerUtil::DeclareTimer FTM_BUILD_FLOATERS("Build Floaters");
static LLFastTimer::DeclareTimer FTM_BUILD_FLOATERS("Build Floaters");
//-----------------------------------------------------------------------------
// buildFloater()
@ -247,7 +247,7 @@ S32 LLUICtrlFactory::saveToXML(LLView* viewp, const std::string& filename)
return 0;
}
static LLFastTimerUtil::DeclareTimer FTM_BUILD_PANELS("Build Panels");
static LLFastTimer::DeclareTimer FTM_BUILD_PANELS("Build Panels");
//-----------------------------------------------------------------------------
// buildPanel()
@ -313,7 +313,7 @@ BOOL LLUICtrlFactory::buildPanel(LLPanel* panelp, const std::string& filename, L
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
static LLFastTimerUtil::DeclareTimer FTM_CREATE_FROM_XML("Create child widget");
static LLFastTimer::DeclareTimer FTM_CREATE_FROM_XML("Create child widget");
LLView *LLUICtrlFactory::createFromXML(LLXMLNodePtr node, LLView* parent, const std::string& filename, const widget_registry_t& registry, LLXMLNodePtr output_node)
{

6
indra/llui/lluictrlfactory.h
View File

@ -104,9 +104,9 @@ class LLDefaultWidgetRegistry
//: public LLRegistrySingleton<const std::type_info*, empty_param_block_func_t, LLDefaultParamBlockRegistry, LLCompareTypeID>
//{};
extern LLFastTimerUtil::DeclareTimer FTM_WIDGET_SETUP;
extern LLFastTimerUtil::DeclareTimer FTM_WIDGET_CONSTRUCTION;
extern LLFastTimerUtil::DeclareTimer FTM_INIT_FROM_PARAMS;
extern LLFastTimer::DeclareTimer FTM_WIDGET_SETUP;
extern LLFastTimer::DeclareTimer FTM_WIDGET_CONSTRUCTION;
extern LLFastTimer::DeclareTimer FTM_INIT_FROM_PARAMS;
// Build time optimization, generate this once in .cpp file
#ifndef LLUICTRLFACTORY_CPP

2
indra/llui/lluistring.cpp
View File

@ -35,7 +35,7 @@
#include "llsd.h"
#include "lltrans.h"
LLFastTimerUtil::DeclareTimer FTM_UI_STRING("UI String");
LLFastTimer::DeclareTimer FTM_UI_STRING("UI String");
LLUIString::LLUIString(const std::string& instring, const LLStringUtil::format_map_t& args)

2
indra/llui/llview.cpp
View File

@ -1707,7 +1707,7 @@ LLView* LLView::getChildView(const std::string& name, BOOL recurse) const
return child;
}
static LLFastTimerUtil::DeclareTimer FTM_FIND_VIEWS("Find Widgets");
static LLFastTimer::DeclareTimer FTM_FIND_VIEWS("Find Widgets");
LLView* LLView::findChildView(const std::string& name, BOOL recurse) const
{

2
indra/llvfs/llvfile.cpp
View File

@ -44,7 +44,7 @@ const S32 LLVFile::WRITE = 0x00000002;
const S32 LLVFile::READ_WRITE = 0x00000003; // LLVFile::READ & LLVFile::WRITE
const S32 LLVFile::APPEND = 0x00000006; // 0x00000004 & LLVFile::WRITE
static LLFastTimerUtil::DeclareTimer FTM_VFILE_WAIT("VFile Wait");
static LLFastTimer::DeclareTimer FTM_VFILE_WAIT("VFile Wait");
//----------------------------------------------------------------------------
LLVFSThread* LLVFile::sVFSThread = NULL;

4
indra/llwindow/llwindowwin32.cpp
View File

@ -1642,8 +1642,8 @@ void LLWindowWin32::gatherInput()
mMousePositionModified = FALSE;
}
static LLFastTimerUtil::DeclareTimer FTM_KEYHANDLER("Handle Keyboard");
static LLFastTimerUtil::DeclareTimer FTM_MOUSEHANDLER("Handle Mouse");
static LLFastTimer::DeclareTimer FTM_KEYHANDLER("Handle Keyboard");
static LLFastTimer::DeclareTimer FTM_MOUSEHANDLER("Handle Mouse");
LRESULT CALLBACK LLWindowWin32::mainWindowProc(HWND h_wnd, UINT u_msg, WPARAM w_param, LPARAM l_param)
{

2
indra/llxuixml/lltrans.cpp
View File

@ -137,7 +137,7 @@ bool LLTrans::parseLanguageStrings(LLXMLNodePtr &root)
static LLFastTimerUtil::DeclareTimer FTM_GET_TRANS("Translate string");
static LLFastTimer::DeclareTimer FTM_GET_TRANS("Translate string");
//static
std::string LLTrans::getString(const std::string &xml_desc, const LLStringUtil::format_map_t& msg_args)

2
indra/llxuixml/llxuiparser.cpp
View File

@ -400,7 +400,7 @@ LLXUIParser::LLXUIParser()
boost::bind(&LLXUIParser::writeSDValue, this, _1, _2));
}
static LLFastTimerUtil::DeclareTimer FTM_PARSE_XUI("XUI Parsing");
static LLFastTimer::DeclareTimer FTM_PARSE_XUI("XUI Parsing");
void LLXUIParser::readXUI(LLXMLNodePtr node, LLInitParam::BaseBlock& block, const std::string& filename, bool silent)
{

58
indra/newview/llappviewer.cpp
View File

@ -480,11 +480,11 @@ public:
LLFastTimerLogThread() : LLThread("fast timer log")
{
if(LLFastTimerUtil::sLog)
if(LLFastTimer::sLog)
{
mFile = gDirUtilp->getExpandedFilename(LL_PATH_LOGS, "performance.slp");
}
if(LLFastTimerUtil::sMetricLog)
if(LLFastTimer::sMetricLog)
{
mFile = gDirUtilp->getExpandedFilename(LL_PATH_LOGS, "metric.slp");
}
@ -496,7 +496,7 @@ public:
while (!LLAppViewer::instance()->isQuitting())
{
LLFastTimerUtil::writeLog(os);
LLFastTimer::writeLog(os);
os.flush();
ms_sleep(32);
}
@ -606,7 +606,7 @@ bool LLAppViewer::init()
// into the log files during normal startup until AFTER
// we run the "program crashed last time" error handler below.
//
LLFastTimerUtil::reset();
LLFastTimer::reset();
// Need to do this initialization before we do anything else, since anything
// that touches files should really go through the lldir API
@ -911,15 +911,15 @@ bool LLAppViewer::init()
return true;
}
static LLFastTimerUtil::DeclareTimer FTM_MESSAGES("System Messages");
static LLFastTimerUtil::DeclareTimer FTM_SLEEP("Sleep");
static LLFastTimerUtil::DeclareTimer FTM_TEXTURE_CACHE("Texture Cache");
static LLFastTimerUtil::DeclareTimer FTM_DECODE("Image Decode");
static LLFastTimerUtil::DeclareTimer FTM_VFS("VFS Thread");
static LLFastTimerUtil::DeclareTimer FTM_LFS("LFS Thread");
static LLFastTimerUtil::DeclareTimer FTM_PAUSE_THREADS("Pause Threads");
static LLFastTimerUtil::DeclareTimer FTM_IDLE("Idle");
static LLFastTimerUtil::DeclareTimer FTM_PUMP("Pump");
static LLFastTimer::DeclareTimer FTM_MESSAGES("System Messages");
static LLFastTimer::DeclareTimer FTM_SLEEP("Sleep");
static LLFastTimer::DeclareTimer FTM_TEXTURE_CACHE("Texture Cache");
static LLFastTimer::DeclareTimer FTM_DECODE("Image Decode");
static LLFastTimer::DeclareTimer FTM_VFS("VFS Thread");
static LLFastTimer::DeclareTimer FTM_LFS("LFS Thread");
static LLFastTimer::DeclareTimer FTM_PAUSE_THREADS("Pause Threads");
static LLFastTimer::DeclareTimer FTM_IDLE("Idle");
static LLFastTimer::DeclareTimer FTM_PUMP("Pump");
bool LLAppViewer::mainLoop()
{
@ -956,7 +956,7 @@ bool LLAppViewer::mainLoop()
// Handle messages
while (!LLApp::isExiting())
{
LLFastTimerUtil::nextFrame(); // Should be outside of any timer instances
LLFastTimer::nextFrame(); // Should be outside of any timer instances
try
{
@ -1551,14 +1551,14 @@ bool LLAppViewer::cleanup()
{
llinfos << "Analyzing performance" << llendl;
if(LLFastTimerUtil::sLog)
if(LLFastTimer::sLog)
{
LLFastTimerView::doAnalysis(
gDirUtilp->getExpandedFilename(LL_PATH_LOGS, "performance_baseline.slp"),
gDirUtilp->getExpandedFilename(LL_PATH_LOGS, "performance.slp"),
gDirUtilp->getExpandedFilename(LL_PATH_LOGS, "performance_report.csv"));
}
if(LLFastTimerUtil::sMetricLog)
if(LLFastTimer::sMetricLog)
{
LLFastTimerView::doAnalysis(
gDirUtilp->getExpandedFilename(LL_PATH_LOGS, "metric_baseline.slp"),
@ -1678,9 +1678,9 @@ bool LLAppViewer::initThreads()
LLAppViewer::sTextureFetch = new LLTextureFetch(LLAppViewer::getTextureCache(), sImageDecodeThread, enable_threads && false);
LLImage::initClass();
if (LLFastTimerUtil::sLog || LLFastTimerUtil::sMetricLog)
if (LLFastTimer::sLog || LLFastTimer::sMetricLog)
{
LLFastTimerUtil::sLogLock = new LLMutex(NULL);
LLFastTimer::sLogLock = new LLMutex(NULL);
mFastTimerLogThread = new LLFastTimerLogThread();
mFastTimerLogThread->start();
}
@ -2031,12 +2031,12 @@ bool LLAppViewer::initConfiguration()
if (clp.hasOption("logperformance"))
{
LLFastTimerUtil::sLog = TRUE;
LLFastTimer::sLog = TRUE;
}
if(clp.hasOption("logmetrics"))
{
LLFastTimerUtil::sMetricLog = TRUE ;
LLFastTimer::sMetricLog = TRUE ;
}
if (clp.hasOption("graphicslevel"))
@ -3370,14 +3370,14 @@ public:
}
};
static LLFastTimerUtil::DeclareTimer FTM_AUDIO_UPDATE("Update Audio");
static LLFastTimerUtil::DeclareTimer FTM_CLEANUP("Cleanup");
static LLFastTimerUtil::DeclareTimer FTM_IDLE_CB("Idle Callbacks");
static LLFastTimerUtil::DeclareTimer FTM_LOD_UPDATE("Update LOD");
static LLFastTimerUtil::DeclareTimer FTM_OBJECTLIST_UPDATE("Update Objectlist");
static LLFastTimerUtil::DeclareTimer FTM_REGION_UPDATE("Update Region");
static LLFastTimerUtil::DeclareTimer FTM_WORLD_UPDATE("Update World");
static LLFastTimerUtil::DeclareTimer FTM_NETWORK("Network");
static LLFastTimer::DeclareTimer FTM_AUDIO_UPDATE("Update Audio");
static LLFastTimer::DeclareTimer FTM_CLEANUP("Cleanup");
static LLFastTimer::DeclareTimer FTM_IDLE_CB("Idle Callbacks");
static LLFastTimer::DeclareTimer FTM_LOD_UPDATE("Update LOD");
static LLFastTimer::DeclareTimer FTM_OBJECTLIST_UPDATE("Update Objectlist");
static LLFastTimer::DeclareTimer FTM_REGION_UPDATE("Update Region");
static LLFastTimer::DeclareTimer FTM_WORLD_UPDATE("Update World");
static LLFastTimer::DeclareTimer FTM_NETWORK("Network");
///////////////////////////////////////////////////////
// idle()
@ -3882,7 +3882,7 @@ void LLAppViewer::sendLogoutRequest()
static F32 CheckMessagesMaxTime = CHECK_MESSAGES_DEFAULT_MAX_TIME;
#endif
static LLFastTimerUtil::DeclareTimer FTM_IDLE_NETWORK("Network");
static LLFastTimer::DeclareTimer FTM_IDLE_NETWORK("Network");
void LLAppViewer::idleNetwork()
{

2
indra/newview/lldrawable.cpp
View File

@ -60,7 +60,7 @@ const F32 MAX_INTERPOLATE_DISTANCE_SQUARED = 10.f * 10.f;
const F32 OBJECT_DAMPING_TIME_CONSTANT = 0.06f;
const F32 MIN_SHADOW_CASTER_RADIUS = 2.0f;
static LLFastTimerUtil::DeclareTimer FTM_CULL_REBOUND("Cull Rebound");
static LLFastTimer::DeclareTimer FTM_CULL_REBOUND("Cull Rebound");
////////////////////////

2
indra/newview/lldrawpoolavatar.cpp
View File

@ -94,7 +94,7 @@ S32 normal_channel = -1;
S32 specular_channel = -1;
S32 diffuse_channel = -1;
static LLFastTimerUtil::DeclareTimer FTM_SHADOW_AVATAR("Avatar Shadow");
static LLFastTimer::DeclareTimer FTM_SHADOW_AVATAR("Avatar Shadow");
LLDrawPoolAvatar::LLDrawPoolAvatar() :
LLFacePool(POOL_AVATAR)

4
indra/newview/lldrawpoolsimple.cpp
View File

@ -47,8 +47,8 @@
static LLGLSLShader* simple_shader = NULL;
static LLGLSLShader* fullbright_shader = NULL;
static LLFastTimerUtil::DeclareTimer FTM_RENDER_SIMPLE_DEFERRED("Deferred Simple");
static LLFastTimerUtil::DeclareTimer FTM_RENDER_GRASS_DEFERRED("Deferred Grass");
static LLFastTimer::DeclareTimer FTM_RENDER_SIMPLE_DEFERRED("Deferred Simple");
static LLFastTimer::DeclareTimer FTM_RENDER_GRASS_DEFERRED("Deferred Grass");
void LLDrawPoolGlow::render(S32 pass)
{

2
indra/newview/lldrawpoolterrain.cpp
View File

@ -61,7 +61,7 @@ int DebugDetailMap = 0;
S32 LLDrawPoolTerrain::sDetailMode = 1;
F32 LLDrawPoolTerrain::sDetailScale = DETAIL_SCALE;
static LLGLSLShader* sShader = NULL;
static LLFastTimerUtil::DeclareTimer FTM_SHADOW_TERRAIN("Terrain Shadow");
static LLFastTimer::DeclareTimer FTM_SHADOW_TERRAIN("Terrain Shadow");
LLDrawPoolTerrain::LLDrawPoolTerrain(LLViewerTexture *texturep) :

2
indra/newview/lldrawpooltree.cpp
View File

@ -46,7 +46,7 @@
S32 LLDrawPoolTree::sDiffTex = 0;
static LLGLSLShader* shader = NULL;
static LLFastTimerUtil::DeclareTimer FTM_SHADOW_TREE("Tree Shadow");
static LLFastTimer::DeclareTimer FTM_SHADOW_TREE("Tree Shadow");
LLDrawPoolTree::LLDrawPoolTree(LLViewerTexture *texturep) :
LLFacePool(POOL_TREE),

118
indra/newview/llfasttimerview.cpp
View File

@ -63,17 +63,17 @@ static const S32 LINE_GRAPH_HEIGHT = 240;
static S32 FTV_NUM_TIMERS;
const S32 FTV_MAX_DEPTH = 8;
std::vector<LLFastTimerUtil::NamedTimer*> ft_display_idx; // line of table entry for display purposes (for collapse)
std::vector<LLFastTimer::NamedTimer*> ft_display_idx; // line of table entry for display purposes (for collapse)
typedef LLTreeDFSIter<LLFastTimerUtil::NamedTimer, LLFastTimerUtil::NamedTimer::child_const_iter> timer_tree_iterator_t;
typedef LLTreeDFSIter<LLFastTimer::NamedTimer, LLFastTimer::NamedTimer::child_const_iter> timer_tree_iterator_t;
BOOL LLFastTimerView::sAnalyzePerformance = FALSE;
static timer_tree_iterator_t begin_timer_tree(LLFastTimerUtil::NamedTimer& id)
static timer_tree_iterator_t begin_timer_tree(LLFastTimer::NamedTimer& id)
{
return timer_tree_iterator_t(&id,
boost::bind(boost::mem_fn(&LLFastTimerUtil::NamedTimer::beginChildren), _1),
boost::bind(boost::mem_fn(&LLFastTimerUtil::NamedTimer::endChildren), _1));
boost::bind(boost::mem_fn(&LLFastTimer::NamedTimer::beginChildren), _1),
boost::bind(boost::mem_fn(&LLFastTimer::NamedTimer::endChildren), _1));
}
static timer_tree_iterator_t end_timer_tree()
@ -96,7 +96,7 @@ LLFastTimerView::LLFastTimerView(const LLRect& rect)
mScrollIndex = 0;
mHoverID = NULL;
mHoverBarIndex = -1;
FTV_NUM_TIMERS = LLFastTimerUtil::NamedTimer::instanceCount();
FTV_NUM_TIMERS = LLFastTimer::NamedTimer::instanceCount();
mPrintStats = -1;
mAverageCyclesPerTimer = 0;
}
@ -125,7 +125,7 @@ BOOL LLFastTimerView::handleRightMouseDown(S32 x, S32 y, MASK mask)
return FALSE;
}
LLFastTimerUtil::NamedTimer* LLFastTimerView::getLegendID(S32 y)
LLFastTimer::NamedTimer* LLFastTimerView::getLegendID(S32 y)
{
S32 idx = (getRect().getHeight() - y) / ((S32) LLFontGL::getFontMonospace()->getLineHeight()+2) - 5;
@ -141,7 +141,7 @@ BOOL LLFastTimerView::handleMouseDown(S32 x, S32 y, MASK mask)
{
if (x < mBarRect.mLeft)
{
LLFastTimerUtil::NamedTimer* idp = getLegendID(y);
LLFastTimer::NamedTimer* idp = getLegendID(y);
if (idp)
{
idp->setCollapsed(!idp->getCollapsed());
@ -175,9 +175,9 @@ BOOL LLFastTimerView::handleMouseDown(S32 x, S32 y, MASK mask)
else
{
// pause/unpause
LLFastTimerUtil::sPauseHistory = !LLFastTimerUtil::sPauseHistory;
LLFastTimer::sPauseHistory = !LLFastTimer::sPauseHistory;
// reset scroll to bottom when unpausing
if (!LLFastTimerUtil::sPauseHistory)
if (!LLFastTimer::sPauseHistory)
{
mScrollIndex = 0;
}
@ -196,9 +196,9 @@ BOOL LLFastTimerView::handleHover(S32 x, S32 y, MASK mask)
mHoverTimer = NULL;
mHoverID = NULL;
if(LLFastTimerUtil::sPauseHistory && mBarRect.pointInRect(x, y))
if(LLFastTimer::sPauseHistory && mBarRect.pointInRect(x, y))
{
mHoverBarIndex = llmin(LLFastTimerUtil::getCurFrameIndex() - 1,
mHoverBarIndex = llmin(LLFastTimer::getCurFrameIndex() - 1,
MAX_VISIBLE_HISTORY - ((y - mBarRect.mBottom) * (MAX_VISIBLE_HISTORY + 2) / mBarRect.getHeight()));
if (mHoverBarIndex == 0)
{
@ -210,7 +210,7 @@ BOOL LLFastTimerView::handleHover(S32 x, S32 y, MASK mask)
}
S32 i = 0;
for(timer_tree_iterator_t it = begin_timer_tree(LLFastTimerUtil::NamedTimer::getRootNamedTimer());
for(timer_tree_iterator_t it = begin_timer_tree(LLFastTimer::NamedTimer::getRootNamedTimer());
it != end_timer_tree();
++it, ++i)
{
@ -234,7 +234,7 @@ BOOL LLFastTimerView::handleHover(S32 x, S32 y, MASK mask)
}
else if (x < mBarRect.mLeft)
{
LLFastTimerUtil::NamedTimer* timer_id = getLegendID(y);
LLFastTimer::NamedTimer* timer_id = getLegendID(y);
if (timer_id)
{
mHoverID = timer_id;
@ -247,7 +247,7 @@ BOOL LLFastTimerView::handleHover(S32 x, S32 y, MASK mask)
BOOL LLFastTimerView::handleToolTip(S32 x, S32 y, MASK mask)
{
if(LLFastTimerUtil::sPauseHistory && mBarRect.pointInRect(x, y))
if(LLFastTimer::sPauseHistory && mBarRect.pointInRect(x, y))
{
// tooltips for timer bars
if (mHoverTimer)
@ -256,7 +256,7 @@ BOOL LLFastTimerView::handleToolTip(S32 x, S32 y, MASK mask)
localRectToScreen(mToolTipRect, &screen_rect);
LLToolTipMgr::instance().show(LLToolTip::Params()
.message(mHoverTimer->getToolTip(LLFastTimerUtil::NamedTimer::HISTORY_NUM - mScrollIndex - mHoverBarIndex))
.message(mHoverTimer->getToolTip(LLFastTimer::NamedTimer::HISTORY_NUM - mScrollIndex - mHoverBarIndex))
.sticky_rect(screen_rect)
.delay_time(0.f));
@ -268,7 +268,7 @@ BOOL LLFastTimerView::handleToolTip(S32 x, S32 y, MASK mask)
// tooltips for timer legend
if (x < mBarRect.mLeft)
{
LLFastTimerUtil::NamedTimer* idp = getLegendID(y);
LLFastTimer::NamedTimer* idp = getLegendID(y);
if (idp)
{
LLToolTipMgr::instance().show(idp->getToolTip());
@ -283,16 +283,16 @@ BOOL LLFastTimerView::handleToolTip(S32 x, S32 y, MASK mask)
BOOL LLFastTimerView::handleScrollWheel(S32 x, S32 y, S32 clicks)
{
LLFastTimerUtil::sPauseHistory = TRUE;
LLFastTimer::sPauseHistory = TRUE;
mScrollIndex = llclamp(mScrollIndex - clicks,
0,
llmin(LLFastTimerUtil::getLastFrameIndex(), (S32)LLFastTimerUtil::NamedTimer::HISTORY_NUM - MAX_VISIBLE_HISTORY));
llmin(LLFastTimer::getLastFrameIndex(), (S32)LLFastTimer::NamedTimer::HISTORY_NUM - MAX_VISIBLE_HISTORY));
return TRUE;
}
static LLFastTimerUtil::DeclareTimer FTM_RENDER_TIMER("Timers", true);
static LLFastTimer::DeclareTimer FTM_RENDER_TIMER("Timers", true);
static std::map<LLFastTimerUtil::NamedTimer*, LLColor4> sTimerColors;
static std::map<LLFastTimer::NamedTimer*, LLColor4> sTimerColors;
void LLFastTimerView::draw()
{
@ -300,7 +300,7 @@ void LLFastTimerView::draw()
std::string tdesc;
F64 clock_freq = (F64)LLFastTimerUtil::countsPerSecond();
F64 clock_freq = (F64)LLFastTimer::countsPerSecond();
F64 iclock_freq = 1000.0 / clock_freq;
S32 margin = 10;
@ -367,7 +367,7 @@ void LLFastTimerView::draw()
y -= (texth + 2);
}
S32 histmax = llmin(LLFastTimerUtil::getLastFrameIndex()+1, MAX_VISIBLE_HISTORY);
S32 histmax = llmin(LLFastTimer::getLastFrameIndex()+1, MAX_VISIBLE_HISTORY);
// Draw the legend
xleft = margin;
@ -375,15 +375,15 @@ void LLFastTimerView::draw()
y -= (texth + 2);
sTimerColors[&LLFastTimerUtil::NamedTimer::getRootNamedTimer()] = LLColor4::grey;
sTimerColors[&LLFastTimer::NamedTimer::getRootNamedTimer()] = LLColor4::grey;
F32 hue = 0.f;
for (timer_tree_iterator_t it = begin_timer_tree(LLFastTimerUtil::NamedTimer::getRootNamedTimer());
for (timer_tree_iterator_t it = begin_timer_tree(LLFastTimer::NamedTimer::getRootNamedTimer());
it != timer_tree_iterator_t();
++it)
{
LLFastTimerUtil::NamedTimer* idp = (*it);
LLFastTimer::NamedTimer* idp = (*it);
const F32 HUE_INCREMENT = 0.23f;
hue = fmodf(hue + HUE_INCREMENT, 1.f);
@ -403,12 +403,12 @@ void LLFastTimerView::draw()
LLLocalClipRect clip(LLRect(margin, y, LEGEND_WIDTH, margin));
S32 cur_line = 0;
ft_display_idx.clear();
std::map<LLFastTimerUtil::NamedTimer*, S32> display_line;
for (timer_tree_iterator_t it = begin_timer_tree(LLFastTimerUtil::NamedTimer::getRootNamedTimer());
std::map<LLFastTimer::NamedTimer*, S32> display_line;
for (timer_tree_iterator_t it = begin_timer_tree(LLFastTimer::NamedTimer::getRootNamedTimer());
it != timer_tree_iterator_t();
++it)
{
LLFastTimerUtil::NamedTimer* idp = (*it);
LLFastTimer::NamedTimer* idp = (*it);
display_line[idp] = cur_line;
ft_display_idx.push_back(idp);
cur_line++;
@ -428,7 +428,7 @@ void LLFastTimerView::draw()
S32 calls = 0;
if (mHoverBarIndex > 0 && mHoverID)
{
S32 hidx = LLFastTimerUtil::NamedTimer::HISTORY_NUM - mScrollIndex - mHoverBarIndex;
S32 hidx = LLFastTimer::NamedTimer::HISTORY_NUM - mScrollIndex - mHoverBarIndex;
U64 ticks = idp->getHistoricalCount(hidx);
ms = (F32)((F64)ticks * iclock_freq);
calls = (S32)idp->getHistoricalCalls(hidx);
@ -466,7 +466,7 @@ void LLFastTimerView::draw()
x += dx;
BOOL is_child_of_hover_item = (idp == mHoverID);
LLFastTimerUtil::NamedTimer* next_parent = idp->getParent();
LLFastTimer::NamedTimer* next_parent = idp->getParent();
while(!is_child_of_hover_item && next_parent)
{
is_child_of_hover_item = (mHoverID == next_parent);
@ -507,18 +507,18 @@ void LLFastTimerView::draw()
barw = width - xleft - margin;
// Draw the history bars
if (LLFastTimerUtil::getLastFrameIndex() >= 0)
if (LLFastTimer::getLastFrameIndex() >= 0)
{
LLLocalClipRect clip(LLRect(xleft, ytop, getRect().getWidth() - margin, margin));
U64 totalticks;
if (!LLFastTimerUtil::sPauseHistory)
if (!LLFastTimer::sPauseHistory)
{
U64 ticks = LLFastTimerUtil::NamedTimer::getRootNamedTimer().getHistoricalCount(mScrollIndex);
U64 ticks = LLFastTimer::NamedTimer::getRootNamedTimer().getHistoricalCount(mScrollIndex);
if (LLFastTimerUtil::getCurFrameIndex() >= 10)
if (LLFastTimer::getCurFrameIndex() >= 10)
{
U64 framec = LLFastTimerUtil::getCurFrameIndex();
U64 framec = LLFastTimer::getCurFrameIndex();
U64 avg = (U64)mAvgCountTotal;
mAvgCountTotal = (avg*framec + ticks) / (framec + 1);
if (ticks > mMaxCountTotal)
@ -529,10 +529,10 @@ void LLFastTimerView::draw()
if (ticks < mAvgCountTotal/100 || ticks > mAvgCountTotal*100)
{
LLFastTimerUtil::sResetHistory = true;
LLFastTimer::sResetHistory = true;
}
if (LLFastTimerUtil::getCurFrameIndex() < 10 || LLFastTimerUtil::sResetHistory)
if (LLFastTimer::getCurFrameIndex() < 10 || LLFastTimer::sResetHistory)
{
mAvgCountTotal = ticks;
mMaxCountTotal = ticks;
@ -553,7 +553,7 @@ void LLFastTimerView::draw()
totalticks = 0;
for (S32 j=0; j<histmax; j++)
{
U64 ticks = LLFastTimerUtil::NamedTimer::getRootNamedTimer().getHistoricalCount(j);
U64 ticks = LLFastTimer::NamedTimer::getRootNamedTimer().getHistoricalCount(j);
if (ticks > totalticks)
totalticks = ticks;
@ -643,7 +643,7 @@ void LLFastTimerView::draw()
S32 tidx;
if (j >= 0)
{
tidx = LLFastTimerUtil::NamedTimer::HISTORY_NUM - j - 1 - mScrollIndex;
tidx = LLFastTimer::NamedTimer::HISTORY_NUM - j - 1 - mScrollIndex;
}
else
{
@ -657,14 +657,14 @@ void LLFastTimerView::draw()
std::vector<S32> deltax;
xpos.push_back(xleft);
LLFastTimerUtil::NamedTimer* prev_id = NULL;
LLFastTimer::NamedTimer* prev_id = NULL;
S32 i = 0;
for(timer_tree_iterator_t it = begin_timer_tree(LLFastTimerUtil::NamedTimer::getRootNamedTimer());
for(timer_tree_iterator_t it = begin_timer_tree(LLFastTimer::NamedTimer::getRootNamedTimer());
it != end_timer_tree();
++it, ++i)
{
LLFastTimerUtil::NamedTimer* idp = (*it);
LLFastTimer::NamedTimer* idp = (*it);
F32 frac = tidx == -1
? (F32)idp->getCountAverage() / (F32)totalticks
: (F32)idp->getHistoricalCount(tidx) / (F32)totalticks;
@ -691,7 +691,7 @@ void LLFastTimerView::draw()
{
U64 sublevelticks = 0;
for (LLFastTimerUtil::NamedTimer::child_const_iter it = prev_id->beginChildren();
for (LLFastTimer::NamedTimer::child_const_iter it = prev_id->beginChildren();
it != prev_id->endChildren();
++it)
{
@ -733,7 +733,7 @@ void LLFastTimerView::draw()
S32 scale_offset = 0;
BOOL is_child_of_hover_item = (idp == mHoverID);
LLFastTimerUtil::NamedTimer* next_parent = idp->getParent();
LLFastTimer::NamedTimer* next_parent = idp->getParent();
while(!is_child_of_hover_item && next_parent)
{
is_child_of_hover_item = (mHoverID == next_parent);
@ -797,10 +797,10 @@ void LLFastTimerView::draw()
//highlight visible range
{
S32 first_frame = LLFastTimerUtil::NamedTimer::HISTORY_NUM - mScrollIndex;
S32 first_frame = LLFastTimer::NamedTimer::HISTORY_NUM - mScrollIndex;
S32 last_frame = first_frame - MAX_VISIBLE_HISTORY;
F32 frame_delta = ((F32) (graph_rect.getWidth()))/(LLFastTimerUtil::NamedTimer::HISTORY_NUM-1);
F32 frame_delta = ((F32) (graph_rect.getWidth()))/(LLFastTimer::NamedTimer::HISTORY_NUM-1);
F32 right = (F32) graph_rect.mLeft + frame_delta*first_frame;
F32 left = (F32) graph_rect.mLeft + frame_delta*last_frame;
@ -823,11 +823,11 @@ void LLFastTimerView::draw()
}
U64 cur_max = 0;
for(timer_tree_iterator_t it = begin_timer_tree(LLFastTimerUtil::NamedTimer::getRootNamedTimer());
for(timer_tree_iterator_t it = begin_timer_tree(LLFastTimer::NamedTimer::getRootNamedTimer());
it != end_timer_tree();
++it)
{
LLFastTimerUtil::NamedTimer* idp = (*it);
LLFastTimer::NamedTimer* idp = (*it);
//fatten highlighted timer
if (mHoverID == idp)
@ -851,7 +851,7 @@ void LLFastTimerView::draw()
gGL.color4f(col[0], col[1], col[2], alpha);
gGL.begin(LLRender::LINE_STRIP);
for (U32 j = 0; j < LLFastTimerUtil::NamedTimer::HISTORY_NUM; j++)
for (U32 j = 0; j < LLFastTimer::NamedTimer::HISTORY_NUM; j++)
{
U64 ticks = idp->getHistoricalCount(j);
@ -871,7 +871,7 @@ void LLFastTimerView::draw()
//normalize to highlighted timer
cur_max = llmax(cur_max, ticks);
}
F32 x = graph_rect.mLeft + ((F32) (graph_rect.getWidth()))/(LLFastTimerUtil::NamedTimer::HISTORY_NUM-1)*j;
F32 x = graph_rect.mLeft + ((F32) (graph_rect.getWidth()))/(LLFastTimer::NamedTimer::HISTORY_NUM-1)*j;
F32 y = graph_rect.mBottom + (F32) graph_rect.getHeight()/max_ticks*ticks;
gGL.vertex2f(x,y);
}
@ -919,11 +919,11 @@ void LLFastTimerView::draw()
{
std::string legend_stat;
bool first = true;
for(timer_tree_iterator_t it = begin_timer_tree(LLFastTimerUtil::NamedTimer::getRootNamedTimer());
for(timer_tree_iterator_t it = begin_timer_tree(LLFastTimer::NamedTimer::getRootNamedTimer());
it != end_timer_tree();
++it)
{
LLFastTimerUtil::NamedTimer* idp = (*it);
LLFastTimer::NamedTimer* idp = (*it);
if (!first)
{
@ -941,11 +941,11 @@ void LLFastTimerView::draw()
std::string timer_stat;
first = true;
for(timer_tree_iterator_t it = begin_timer_tree(LLFastTimerUtil::NamedTimer::getRootNamedTimer());
for(timer_tree_iterator_t it = begin_timer_tree(LLFastTimer::NamedTimer::getRootNamedTimer());
it != end_timer_tree();
++it)
{
LLFastTimerUtil::NamedTimer* idp = (*it);
LLFastTimer::NamedTimer* idp = (*it);
if (!first)
{
@ -984,10 +984,10 @@ void LLFastTimerView::draw()
F64 LLFastTimerView::getTime(const std::string& name)
{
const LLFastTimerUtil::NamedTimer* timerp = LLFastTimerUtil::getTimerByName(name);
const LLFastTimer::NamedTimer* timerp = LLFastTimer::getTimerByName(name);
if (timerp)
{
return (F64)timerp->getCountAverage() / (F64)LLFastTimerUtil::countsPerSecond();
return (F64)timerp->getCountAverage() / (F64)LLFastTimer::countsPerSecond();
}
return 0.0;
}
@ -1179,13 +1179,13 @@ void LLFastTimerView::doAnalysisMetrics(std::string baseline, std::string target
//static
void LLFastTimerView::doAnalysis(std::string baseline, std::string target, std::string output)
{
if(LLFastTimerUtil::sLog)
if(LLFastTimer::sLog)
{
doAnalysisDefault(baseline, target, output) ;
return ;
}
if(LLFastTimerUtil::sMetricLog)
if(LLFastTimer::sMetricLog)
{
doAnalysisMetrics(baseline, target, output) ;
return ;

6
indra/newview/llfasttimerview.h
View File

@ -61,7 +61,7 @@ public:
virtual BOOL handleScrollWheel(S32 x, S32 y, S32 clicks);
virtual void draw();
LLFastTimerUtil::NamedTimer* getLegendID(S32 y);
LLFastTimer::NamedTimer* getLegendID(S32 y);
F64 getTime(const std::string& name);
private:
@ -85,8 +85,8 @@ private:
U64 mMaxCountTotal;
LLRect mBarRect;
S32 mScrollIndex;
LLFastTimerUtil::NamedTimer* mHoverID;
LLFastTimerUtil::NamedTimer* mHoverTimer;
LLFastTimer::NamedTimer* mHoverID;
LLFastTimer::NamedTimer* mHoverTimer;
LLRect mToolTipRect;
S32 mHoverBarIndex;
LLFrameTimer mHighlightTimer;

2
indra/newview/llflexibleobject.cpp
View File

@ -261,7 +261,7 @@ void LLVolumeImplFlexible::onSetVolume(const LLVolumeParams &volume_params, cons
// updated every time step. In the future, perhaps there could be an
// optimization similar to what Havok does for objects that are stationary.
//---------------------------------------------------------------------------------
static LLFastTimerUtil::DeclareTimer FTM_FLEXIBLE_UPDATE("Update Flexies");
static LLFastTimer::DeclareTimer FTM_FLEXIBLE_UPDATE("Update Flexies");
BOOL LLVolumeImplFlexible::doIdleUpdate(LLAgent &agent, LLWorld &world, const F64 &time)
{
if (mVO->mDrawable.isNull())

10
indra/newview/llfolderview.cpp
View File

@ -295,7 +295,7 @@ void LLFolderView::checkTreeResortForModelChanged()
}
}
static LLFastTimerUtil::DeclareTimer FTM_SORT("Sort Inventory");
static LLFastTimer::DeclareTimer FTM_SORT("Sort Inventory");
void LLFolderView::setSortOrder(U32 order)
{
@ -377,7 +377,7 @@ void LLFolderView::setOpenArrangeRecursively(BOOL openitem, ERecurseType recurse
mIsOpen = TRUE;
}
static LLFastTimerUtil::DeclareTimer FTM_ARRANGE("Arrange");
static LLFastTimer::DeclareTimer FTM_ARRANGE("Arrange");
// This view grows and shinks to enclose all of its children items and folders.
S32 LLFolderView::arrange( S32* unused_width, S32* unused_height, S32 filter_generation )
@ -477,7 +477,7 @@ const std::string LLFolderView::getFilterSubString(BOOL trim)
return mFilter->getFilterSubString(trim);
}
static LLFastTimerUtil::DeclareTimer FTM_FILTER("Filter Inventory");
static LLFastTimer::DeclareTimer FTM_FILTER("Filter Inventory");
void LLFolderView::filter( LLInventoryFilter& filter )
{
@ -2056,8 +2056,8 @@ bool LLFolderView::doToSelected(LLInventoryModel* model, const LLSD& userdata)
return true;
}
static LLFastTimerUtil::DeclareTimer FTM_AUTO_SELECT("Open and Select");
static LLFastTimerUtil::DeclareTimer FTM_INVENTORY("Inventory");
static LLFastTimer::DeclareTimer FTM_AUTO_SELECT("Open and Select");
static LLFastTimer::DeclareTimer FTM_INVENTORY("Inventory");
// Main idle routine
void LLFolderView::doIdle()

2
indra/newview/llhudmanager.cpp
View File

@ -62,7 +62,7 @@ LLHUDManager::~LLHUDManager()
{
}
static LLFastTimerUtil::DeclareTimer FTM_HUD_EFFECTS("Hud Effects");
static LLFastTimer::DeclareTimer FTM_HUD_EFFECTS("Hud Effects");
void LLHUDManager::updateEffects()
{

2
indra/newview/llhudobject.cpp
View File

@ -254,7 +254,7 @@ LLHUDEffect *LLHUDObject::addHUDEffect(const U8 type)
return hud_objectp;
}
static LLFastTimerUtil::DeclareTimer FTM_HUD_UPDATE("Update Hud");
static LLFastTimer::DeclareTimer FTM_HUD_UPDATE("Update Hud");
// static
void LLHUDObject::updateAll()

2
indra/newview/llinventorypanel.cpp
View File

@ -258,7 +258,7 @@ LLInventoryFilter::EFolderShow LLInventoryPanel::getShowFolderState()
void LLInventoryPanel::modelChanged(U32 mask)
{
static LLFastTimerUtil::DeclareTimer FTM_REFRESH("Inventory Refresh");
static LLFastTimer::DeclareTimer FTM_REFRESH("Inventory Refresh");
LLFastTimer t2(FTM_REFRESH);
bool handled = false;

4
indra/newview/llmetricperformancetester.cpp
View File

@ -131,8 +131,8 @@ void LLMetricPerformanceTester::preOutputTestResults(LLSD* sd)
}
void LLMetricPerformanceTester::postOutputTestResults(LLSD* sd)
{
LLMutexLock lock(LLFastTimerUtil::sLogLock);
LLFastTimerUtil::sLogQueue.push((*sd));
LLMutexLock lock(LLFastTimer::sLogLock);
LLFastTimer::sLogQueue.push((*sd));
}
void LLMetricPerformanceTester::outputTestResults()

8
indra/newview/llspatialpartition.cpp
View File

@ -49,8 +49,8 @@
#include "llvoavatar.h"
#include "lltextureatlas.h"
static LLFastTimerUtil::DeclareTimer FTM_FRUSTUM_CULL("Frustum Culling");
static LLFastTimerUtil::DeclareTimer FTM_CULL_REBOUND("Cull Rebound");
static LLFastTimer::DeclareTimer FTM_FRUSTUM_CULL("Frustum Culling");
static LLFastTimer::DeclareTimer FTM_CULL_REBOUND("Cull Rebound");
const F32 SG_OCCLUSION_FUDGE = 0.25f;
#define SG_DISCARD_TOLERANCE 0.01f
@ -641,7 +641,7 @@ void LLSpatialGroup::rebuildMesh()
}
}
static LLFastTimerUtil::DeclareTimer FTM_REBUILD_VBO("VBO Rebuilt");
static LLFastTimer::DeclareTimer FTM_REBUILD_VBO("VBO Rebuilt");
void LLSpatialPartition::rebuildGeom(LLSpatialGroup* group)
{
@ -1508,7 +1508,7 @@ BOOL LLSpatialGroup::rebound()
return TRUE;
}
static LLFastTimerUtil::DeclareTimer FTM_OCCLUSION_READBACK("Readback Occlusion");
static LLFastTimer::DeclareTimer FTM_OCCLUSION_READBACK("Readback Occlusion");
void LLSpatialGroup::checkOcclusion()
{
if (LLPipeline::sUseOcclusion > 1)

2
indra/newview/llstartup.cpp
View File

@ -2087,7 +2087,7 @@ bool idle_startup()
LLAppViewer::instance()->handleLoginComplete();
// reset timers now that we are running "logged in" logic
LLFastTimerUtil::reset();
LLFastTimer::reset();
LLAgentPicksInfo::getInstance()->requestNumberOfPicks();

12
indra/newview/llviewerdisplay.cpp
View File

@ -212,11 +212,11 @@ void display_stats()
}
}
static LLFastTimerUtil::DeclareTimer FTM_PICK("Picking");
static LLFastTimerUtil::DeclareTimer FTM_RENDER("Render", true);
static LLFastTimerUtil::DeclareTimer FTM_UPDATE_SKY("Update Sky");
static LLFastTimerUtil::DeclareTimer FTM_UPDATE_TEXTURES("Update Textures");
static LLFastTimerUtil::DeclareTimer FTM_IMAGE_UPDATE("Update Images");
static LLFastTimer::DeclareTimer FTM_PICK("Picking");
static LLFastTimer::DeclareTimer FTM_RENDER("Render", true);
static LLFastTimer::DeclareTimer FTM_UPDATE_SKY("Update Sky");
static LLFastTimer::DeclareTimer FTM_UPDATE_TEXTURES("Update Textures");
static LLFastTimer::DeclareTimer FTM_IMAGE_UPDATE("Update Images");
// Paint the display!
void display(BOOL rebuild, F32 zoom_factor, int subfield, BOOL for_snapshot)
@ -1098,7 +1098,7 @@ BOOL setup_hud_matrices(const LLRect& screen_region)
return TRUE;
}
static LLFastTimerUtil::DeclareTimer FTM_SWAP("Swap");
static LLFastTimer::DeclareTimer FTM_SWAP("Swap");
void render_ui(F32 zoom_factor, int subfield)
{

2
indra/newview/llviewermenu.cpp
View File

@ -6841,7 +6841,7 @@ void handle_dump_avatar_local_textures(void*)
void handle_dump_timers()
{
LLFastTimerUtil::dumpCurTimes();
LLFastTimer::dumpCurTimes();
}
void handle_debug_avatar_textures(void*)

2
indra/newview/llviewermessage.cpp
View File

@ -3485,7 +3485,7 @@ void process_terse_object_update_improved(LLMessageSystem *mesgsys, void **user_
gObjectList.processCompressedObjectUpdate(mesgsys, user_data, OUT_TERSE_IMPROVED);
}
static LLFastTimerUtil::DeclareTimer FTM_PROCESS_OBJECTS("Process Objects");
static LLFastTimer::DeclareTimer FTM_PROCESS_OBJECTS("Process Objects");
void process_kill_object(LLMessageSystem *mesgsys, void **user_data)

2
indra/newview/llviewerobject.cpp
View File

@ -117,7 +117,7 @@ S32 LLViewerObject::sAxisArrowLength(50);
BOOL LLViewerObject::sPulseEnabled(FALSE);
BOOL LLViewerObject::sUseSharedDrawables(FALSE); // TRUE
static LLFastTimerUtil::DeclareTimer FTM_CREATE_OBJECT("Create Object");
static LLFastTimer::DeclareTimer FTM_CREATE_OBJECT("Create Object");
// static
LLViewerObject *LLViewerObject::createObject(const LLUUID &id, const LLPCode pcode, LLViewerRegion *regionp)

4
indra/newview/llviewerobjectlist.cpp
View File

@ -278,7 +278,7 @@ void LLViewerObjectList::processUpdateCore(LLViewerObject* objectp,
}
}
static LLFastTimerUtil::DeclareTimer FTM_PROCESS_OBJECTS("Process Objects");
static LLFastTimer::DeclareTimer FTM_PROCESS_OBJECTS("Process Objects");
void LLViewerObjectList::processObjectUpdate(LLMessageSystem *mesgsys,
void **user_data,
@ -1357,7 +1357,7 @@ LLViewerObject *LLViewerObjectList::createObjectViewer(const LLPCode pcode, LLVi
}
static LLFastTimerUtil::DeclareTimer FTM_CREATE_OBJECT("Create Object");
static LLFastTimer::DeclareTimer FTM_CREATE_OBJECT("Create Object");
LLViewerObject *LLViewerObjectList::createObject(const LLPCode pcode, LLViewerRegion *regionp,
const LLUUID &uuid, const U32 local_id, const LLHost &sender)

2
indra/newview/llviewerpartsim.cpp
View File

@ -633,7 +633,7 @@ void LLViewerPartSim::shift(const LLVector3 &offset)
}
}
static LLFastTimerUtil::DeclareTimer FTM_SIMULATE_PARTICLES("Simulate Particles");
static LLFastTimer::DeclareTimer FTM_SIMULATE_PARTICLES("Simulate Particles");
void LLViewerPartSim::updateSimulation()
{

2
indra/newview/llviewertexture.cpp
View File

@ -305,7 +305,7 @@ void LLViewerTextureManager::init()
LLViewerTexture::initClass() ;
if(LLFastTimerUtil::sMetricLog)
if(LLFastTimer::sMetricLog)
{
LLViewerTextureManager::sTesterp = new LLTexturePipelineTester() ;
}

6
indra/newview/llviewertexturelist.cpp
View File

@ -80,7 +80,7 @@ LLStat LLViewerTextureList::sRawMemStat(32, TRUE);
LLStat LLViewerTextureList::sFormattedMemStat(32, TRUE);
LLViewerTextureList gTextureList;
static LLFastTimerUtil::DeclareTimer FTM_PROCESS_IMAGES("Process Images");
static LLFastTimer::DeclareTimer FTM_PROCESS_IMAGES("Process Images");
///////////////////////////////////////////////////////////////////////////////
@ -570,7 +570,7 @@ void LLViewerTextureList::dirtyImage(LLViewerFetchedTexture *image)
}
////////////////////////////////////////////////////////////////////////////
static LLFastTimerUtil::DeclareTimer FTM_IMAGE_MARK_DIRTY("Dirty Images");
static LLFastTimer::DeclareTimer FTM_IMAGE_MARK_DIRTY("Dirty Images");
void LLViewerTextureList::updateImages(F32 max_time)
{
@ -735,7 +735,7 @@ void LLViewerTextureList::updateImagesDecodePriorities()
return type_from_host;
}
*/
static LLFastTimerUtil::DeclareTimer FTM_IMAGE_CREATE("Create Images");
static LLFastTimer::DeclareTimer FTM_IMAGE_CREATE("Create Images");
F32 LLViewerTextureList::updateImagesCreateTextures(F32 max_time)
{

2
indra/newview/llviewerwindow.cpp
View File

@ -2844,7 +2844,7 @@ void LLViewerWindow::updateKeyboardFocus()
LLSideTray::getInstance()->highlightFocused();
}
static LLFastTimerUtil::DeclareTimer FTM_UPDATE_WORLD_VIEW("Update World View");
static LLFastTimer::DeclareTimer FTM_UPDATE_WORLD_VIEW("Update World View");
void LLViewerWindow::updateWorldViewRect(bool use_full_window)
{
LLFastTimer ft(FTM_UPDATE_WORLD_VIEW);

10
indra/newview/llvoavatar.cpp
View File

@ -2110,8 +2110,8 @@ S32 LLVOAvatar::setTETexture(const U8 te, const LLUUID& uuid)
}
}
static LLFastTimerUtil::DeclareTimer FTM_AVATAR_UPDATE("Update Avatar");
static LLFastTimerUtil::DeclareTimer FTM_JOINT_UPDATE("Update Joints");
static LLFastTimer::DeclareTimer FTM_AVATAR_UPDATE("Update Avatar");
static LLFastTimer::DeclareTimer FTM_JOINT_UPDATE("Update Joints");
//------------------------------------------------------------------------
// idleUpdate()
@ -2304,7 +2304,7 @@ void LLVOAvatar::idleUpdateVoiceVisualizer(bool voice_enabled)
}//if ( voiceEnabled )
}
static LLFastTimerUtil::DeclareTimer FTM_ATTACHMENT_UPDATE("Update Attachments");
static LLFastTimer::DeclareTimer FTM_ATTACHMENT_UPDATE("Update Attachments");
void LLVOAvatar::idleUpdateMisc(bool detailed_update)
{
@ -4675,7 +4675,7 @@ void LLVOAvatar::requestStopMotion( LLMotion* motion )
//-----------------------------------------------------------------------------
// loadAvatar()
//-----------------------------------------------------------------------------
static LLFastTimerUtil::DeclareTimer FTM_LOAD_AVATAR("Load Avatar");
static LLFastTimer::DeclareTimer FTM_LOAD_AVATAR("Load Avatar");
BOOL LLVOAvatar::loadAvatar()
{
@ -5263,7 +5263,7 @@ void LLVOAvatar::updateGL()
//-----------------------------------------------------------------------------
// updateGeometry()
//-----------------------------------------------------------------------------
static LLFastTimerUtil::DeclareTimer FTM_UPDATE_AVATAR("Update Avatar");
static LLFastTimer::DeclareTimer FTM_UPDATE_AVATAR("Update Avatar");
BOOL LLVOAvatar::updateGeometry(LLDrawable *drawable)
{
LLFastTimer ftm(FTM_UPDATE_AVATAR);

2
indra/newview/llvoclouds.cpp
View File

@ -115,7 +115,7 @@ LLDrawable* LLVOClouds::createDrawable(LLPipeline *pipeline)
return mDrawable;
}
static LLFastTimerUtil::DeclareTimer FTM_UPDATE_CLOUDS("Update Clouds");
static LLFastTimer::DeclareTimer FTM_UPDATE_CLOUDS("Update Clouds");
BOOL LLVOClouds::updateGeometry(LLDrawable *drawable)
{

2
indra/newview/llvograss.cpp
View File

@ -382,7 +382,7 @@ LLDrawable* LLVOGrass::createDrawable(LLPipeline *pipeline)
return mDrawable;
}
static LLFastTimerUtil::DeclareTimer FTM_UPDATE_GRASS("Update Grass");
static LLFastTimer::DeclareTimer FTM_UPDATE_GRASS("Update Grass");
BOOL LLVOGrass::updateGeometry(LLDrawable *drawable)
{

6
indra/newview/llvopartgroup.cpp
View File

@ -139,7 +139,7 @@ LLVector3 LLVOPartGroup::getCameraPosition() const
return gAgent.getCameraPositionAgent();
}
static LLFastTimerUtil::DeclareTimer FTM_UPDATE_PARTICLES("Update Particles");
static LLFastTimer::DeclareTimer FTM_UPDATE_PARTICLES("Update Particles");
BOOL LLVOPartGroup::updateGeometry(LLDrawable *drawable)
{
LLFastTimer ftm(FTM_UPDATE_PARTICLES);
@ -428,8 +428,8 @@ void LLParticlePartition::addGeometryCount(LLSpatialGroup* group, U32& vertex_co
}
}
static LLFastTimerUtil::DeclareTimer FTM_REBUILD_GRASS_VB("Grass VB");
static LLFastTimerUtil::DeclareTimer FTM_REBUILD_PARTICLE_VB("Particle VB");
static LLFastTimer::DeclareTimer FTM_REBUILD_GRASS_VB("Grass VB");
static LLFastTimer::DeclareTimer FTM_REBUILD_PARTICLE_VB("Particle VB");
void LLParticlePartition::getGeometry(LLSpatialGroup* group)
{

4
indra/newview/llvosky.cpp
View File

@ -1231,7 +1231,7 @@ void LLVOSky::createDummyVertexBuffer()
}
}
static LLFastTimerUtil::DeclareTimer FTM_RENDER_FAKE_VBO_UPDATE("Fake VBO Update");
static LLFastTimer::DeclareTimer FTM_RENDER_FAKE_VBO_UPDATE("Fake VBO Update");
void LLVOSky::updateDummyVertexBuffer()
{
@ -1257,7 +1257,7 @@ void LLVOSky::updateDummyVertexBuffer()
//----------------------------------
//end of fake vertex buffer updating
//----------------------------------
static LLFastTimerUtil::DeclareTimer FTM_GEO_SKY("Sky Geometry");
static LLFastTimer::DeclareTimer FTM_GEO_SKY("Sky Geometry");
BOOL LLVOSky::updateGeometry(LLDrawable *drawable)
{

4
indra/newview/llvosurfacepatch.cpp
View File

@ -176,7 +176,7 @@ LLDrawable *LLVOSurfacePatch::createDrawable(LLPipeline *pipeline)
return mDrawable;
}
static LLFastTimerUtil::DeclareTimer FTM_UPDATE_TERRAIN("Update Terrain");
static LLFastTimer::DeclareTimer FTM_UPDATE_TERRAIN("Update Terrain");
void LLVOSurfacePatch::updateGL()
{
@ -1035,7 +1035,7 @@ LLVertexBuffer* LLTerrainPartition::createVertexBuffer(U32 type_mask, U32 usage)
return new LLVertexBufferTerrain();
}
static LLFastTimerUtil::DeclareTimer FTM_REBUILD_TERRAIN_VB("Terrain VB");
static LLFastTimer::DeclareTimer FTM_REBUILD_TERRAIN_VB("Terrain VB");
void LLTerrainPartition::getGeometry(LLSpatialGroup* group)
{
LLFastTimer ftm(FTM_REBUILD_TERRAIN_VB);

2
indra/newview/llvotree.cpp
View File

@ -500,7 +500,7 @@ LLDrawable* LLVOTree::createDrawable(LLPipeline *pipeline)
const S32 LEAF_INDICES = 24;
const S32 LEAF_VERTICES = 16;
static LLFastTimerUtil::DeclareTimer FTM_UPDATE_TREE("Update Tree");
static LLFastTimer::DeclareTimer FTM_UPDATE_TREE("Update Tree");
BOOL LLVOTree::updateGeometry(LLDrawable *drawable)
{

14
indra/newview/llvovolume.cpp
View File

@ -86,8 +86,8 @@ S32 LLVOVolume::sNumLODChanges = 0;
LLPointer<LLObjectMediaDataClient> LLVOVolume::sObjectMediaClient = NULL;
LLPointer<LLObjectMediaNavigateClient> LLVOVolume::sObjectMediaNavigateClient = NULL;
static LLFastTimerUtil::DeclareTimer FTM_GEN_TRIANGLES("Generate Triangles");
static LLFastTimerUtil::DeclareTimer FTM_GEN_VOLUME("Generate Volumes");
static LLFastTimer::DeclareTimer FTM_GEN_TRIANGLES("Generate Triangles");
static LLFastTimer::DeclareTimer FTM_GEN_VOLUME("Generate Volumes");
// Implementation class of LLMediaDataClientObject. See llmediadataclient.h
class LLMediaDataClientObjectImpl : public LLMediaDataClientObject
@ -1339,8 +1339,8 @@ void LLVOVolume::updateRelativeXform()
}
}
static LLFastTimerUtil::DeclareTimer FTM_GEN_FLEX("Generate Flexies");
static LLFastTimerUtil::DeclareTimer FTM_UPDATE_PRIMITIVES("Update Primitives");
static LLFastTimer::DeclareTimer FTM_GEN_FLEX("Generate Flexies");
static LLFastTimer::DeclareTimer FTM_UPDATE_PRIMITIVES("Update Primitives");
BOOL LLVOVolume::updateGeometry(LLDrawable *drawable)
{
@ -3190,8 +3190,8 @@ void LLVolumeGeometryManager::getGeometry(LLSpatialGroup* group)
}
static LLFastTimerUtil::DeclareTimer FTM_REBUILD_VOLUME_VB("Volume");
static LLFastTimerUtil::DeclareTimer FTM_REBUILD_VBO("VBO Rebuilt");
static LLFastTimer::DeclareTimer FTM_REBUILD_VOLUME_VB("Volume");
static LLFastTimer::DeclareTimer FTM_REBUILD_VBO("VBO Rebuilt");
void LLVolumeGeometryManager::rebuildGeom(LLSpatialGroup* group)
{
@ -3423,7 +3423,7 @@ void LLVolumeGeometryManager::rebuildGeom(LLSpatialGroup* group)
mFaceList.clear();
}
static LLFastTimerUtil::DeclareTimer FTM_VOLUME_GEOM("Volume Geometry");
static LLFastTimer::DeclareTimer FTM_VOLUME_GEOM("Volume Geometry");
void LLVolumeGeometryManager::rebuildMesh(LLSpatialGroup* group)
{
llpushcallstacks ;

2
indra/newview/llvowater.cpp
View File

@ -136,7 +136,7 @@ LLDrawable *LLVOWater::createDrawable(LLPipeline *pipeline)
return mDrawable;
}
static LLFastTimerUtil::DeclareTimer FTM_UPDATE_WATER("Update Water");
static LLFastTimer::DeclareTimer FTM_UPDATE_WATER("Update Water");
BOOL LLVOWater::updateGeometry(LLDrawable *drawable)
{

2
indra/newview/llvowlsky.cpp
View File

@ -307,7 +307,7 @@ void LLVOWLSky::restoreGL()
gPipeline.markRebuild(mDrawable, LLDrawable::REBUILD_ALL, TRUE);
}
static LLFastTimerUtil::DeclareTimer FTM_GEO_SKY("Sky Geometry");
static LLFastTimer::DeclareTimer FTM_GEO_SKY("Sky Geometry");
BOOL LLVOWLSky::updateGeometry(LLDrawable * drawable)
{

2
indra/newview/llwaterparammanager.cpp
View File

@ -261,7 +261,7 @@ void LLWaterParamManager::updateShaderUniforms(LLGLSLShader * shader)
}
}
static LLFastTimerUtil::DeclareTimer FTM_UPDATE_WLPARAM("Update Windlight Params");
static LLFastTimer::DeclareTimer FTM_UPDATE_WLPARAM("Update Windlight Params");
void LLWaterParamManager::update(LLViewerCamera * cam)
{

2
indra/newview/llwlparammanager.cpp
View File

@ -58,7 +58,7 @@
#include "curl/curl.h"
LLWLParamManager * LLWLParamManager::sInstance = NULL;
static LLFastTimerUtil::DeclareTimer FTM_UPDATE_WLPARAM("Update Windlight Params");
static LLFastTimer::DeclareTimer FTM_UPDATE_WLPARAM("Update Windlight Params");
LLWLParamManager::LLWLParamManager() :

90
indra/newview/pipeline.cpp
View File

@ -140,34 +140,34 @@ BOOL gDebugPipeline = FALSE;
LLPipeline gPipeline;
const LLMatrix4* gGLLastMatrix = NULL;
LLFastTimerUtil::DeclareTimer FTM_RENDER_GEOMETRY("Geometry");
LLFastTimerUtil::DeclareTimer FTM_RENDER_GRASS("Grass");
LLFastTimerUtil::DeclareTimer FTM_RENDER_INVISIBLE("Invisible");
LLFastTimerUtil::DeclareTimer FTM_RENDER_OCCLUSION("Occlusion");
LLFastTimerUtil::DeclareTimer FTM_RENDER_SHINY("Shiny");
LLFastTimerUtil::DeclareTimer FTM_RENDER_SIMPLE("Simple");
LLFastTimerUtil::DeclareTimer FTM_RENDER_TERRAIN("Terrain");
LLFastTimerUtil::DeclareTimer FTM_RENDER_TREES("Trees");
LLFastTimerUtil::DeclareTimer FTM_RENDER_UI("UI");
LLFastTimerUtil::DeclareTimer FTM_RENDER_WATER("Water");
LLFastTimerUtil::DeclareTimer FTM_RENDER_WL_SKY("Windlight Sky");
LLFastTimerUtil::DeclareTimer FTM_RENDER_ALPHA("Alpha Objects");
LLFastTimerUtil::DeclareTimer FTM_RENDER_CHARACTERS("Avatars");
LLFastTimerUtil::DeclareTimer FTM_RENDER_BUMP("Bump");
LLFastTimerUtil::DeclareTimer FTM_RENDER_FULLBRIGHT("Fullbright");
LLFastTimerUtil::DeclareTimer FTM_RENDER_GLOW("Glow");
LLFastTimerUtil::DeclareTimer FTM_GEO_UPDATE("Geo Update");
LLFastTimerUtil::DeclareTimer FTM_POOLRENDER("RenderPool");
LLFastTimerUtil::DeclareTimer FTM_POOLS("Pools");
LLFastTimerUtil::DeclareTimer FTM_RENDER_BLOOM_FBO("First FBO");
LLFastTimerUtil::DeclareTimer FTM_STATESORT("Sort Draw State");
LLFastTimerUtil::DeclareTimer FTM_PIPELINE("Pipeline");
LLFastTimerUtil::DeclareTimer FTM_CLIENT_COPY("Client Copy");
LLFastTimerUtil::DeclareTimer FTM_RENDER_DEFERRED("Deferred Shading");
LLFastTimer::DeclareTimer FTM_RENDER_GEOMETRY("Geometry");
LLFastTimer::DeclareTimer FTM_RENDER_GRASS("Grass");
LLFastTimer::DeclareTimer FTM_RENDER_INVISIBLE("Invisible");
LLFastTimer::DeclareTimer FTM_RENDER_OCCLUSION("Occlusion");
LLFastTimer::DeclareTimer FTM_RENDER_SHINY("Shiny");
LLFastTimer::DeclareTimer FTM_RENDER_SIMPLE("Simple");
LLFastTimer::DeclareTimer FTM_RENDER_TERRAIN("Terrain");
LLFastTimer::DeclareTimer FTM_RENDER_TREES("Trees");
LLFastTimer::DeclareTimer FTM_RENDER_UI("UI");
LLFastTimer::DeclareTimer FTM_RENDER_WATER("Water");
LLFastTimer::DeclareTimer FTM_RENDER_WL_SKY("Windlight Sky");
LLFastTimer::DeclareTimer FTM_RENDER_ALPHA("Alpha Objects");
LLFastTimer::DeclareTimer FTM_RENDER_CHARACTERS("Avatars");
LLFastTimer::DeclareTimer FTM_RENDER_BUMP("Bump");
LLFastTimer::DeclareTimer FTM_RENDER_FULLBRIGHT("Fullbright");
LLFastTimer::DeclareTimer FTM_RENDER_GLOW("Glow");
LLFastTimer::DeclareTimer FTM_GEO_UPDATE("Geo Update");
LLFastTimer::DeclareTimer FTM_POOLRENDER("RenderPool");
LLFastTimer::DeclareTimer FTM_POOLS("Pools");
LLFastTimer::DeclareTimer FTM_RENDER_BLOOM_FBO("First FBO");
LLFastTimer::DeclareTimer FTM_STATESORT("Sort Draw State");
LLFastTimer::DeclareTimer FTM_PIPELINE("Pipeline");
LLFastTimer::DeclareTimer FTM_CLIENT_COPY("Client Copy");
LLFastTimer::DeclareTimer FTM_RENDER_DEFERRED("Deferred Shading");
static LLFastTimerUtil::DeclareTimer FTM_STATESORT_DRAWABLE("Sort Drawables");
static LLFastTimerUtil::DeclareTimer FTM_STATESORT_POSTSORT("Post Sort");
static LLFastTimer::DeclareTimer FTM_STATESORT_DRAWABLE("Sort Drawables");
static LLFastTimer::DeclareTimer FTM_STATESORT_POSTSORT("Post Sort");
//----------------------------------------
std::string gPoolNames[] =
@ -508,7 +508,7 @@ void LLPipeline::destroyGL()
}
}
static LLFastTimerUtil::DeclareTimer FTM_RESIZE_SCREEN_TEXTURE("Resize Screen Texture");
static LLFastTimer::DeclareTimer FTM_RESIZE_SCREEN_TEXTURE("Resize Screen Texture");
void LLPipeline::resizeScreenTexture()
{
LLFastTimer ft(FTM_RESIZE_SCREEN_TEXTURE);
@ -1396,8 +1396,8 @@ void LLPipeline::updateMovedList(LLDrawable::drawable_vector_t& moved_list)
}
}
static LLFastTimerUtil::DeclareTimer FTM_OCTREE_BALANCE("Balance Octree");
static LLFastTimerUtil::DeclareTimer FTM_UPDATE_MOVE("Update Move");
static LLFastTimer::DeclareTimer FTM_OCTREE_BALANCE("Balance Octree");
static LLFastTimer::DeclareTimer FTM_UPDATE_MOVE("Update Move");
void LLPipeline::updateMove()
{
@ -1557,7 +1557,7 @@ BOOL LLPipeline::getVisibleExtents(LLCamera& camera, LLVector3& min, LLVector3&
return res;
}
static LLFastTimerUtil::DeclareTimer FTM_CULL("Object Culling");
static LLFastTimer::DeclareTimer FTM_CULL("Object Culling");
void LLPipeline::updateCull(LLCamera& camera, LLCullResult& result, S32 water_clip)
{
@ -2188,7 +2188,7 @@ void LLPipeline::markRebuild(LLDrawable *drawablep, LLDrawable::EDrawableFlags f
}
}
static LLFastTimerUtil::DeclareTimer FTM_RESET_DRAWORDER("Reset Draw Order");
static LLFastTimer::DeclareTimer FTM_RESET_DRAWORDER("Reset Draw Order");
void LLPipeline::stateSort(LLCamera& camera, LLCullResult &result)
{
@ -5519,7 +5519,7 @@ void LLPipeline::bindScreenToTexture()
}
static LLFastTimerUtil::DeclareTimer FTM_RENDER_BLOOM("Bloom");
static LLFastTimer::DeclareTimer FTM_RENDER_BLOOM("Bloom");
void LLPipeline::renderBloom(BOOL for_snapshot, F32 zoom_factor, int subfield)
{
LLMemType mt_ru(LLMemType::MTYPE_PIPELINE_RENDER_BLOOM);
@ -6227,16 +6227,16 @@ void LLPipeline::bindDeferredShader(LLGLSLShader& shader, U32 light_index, LLRen
}
}
static LLFastTimerUtil::DeclareTimer FTM_GI_TRACE("Trace");
static LLFastTimerUtil::DeclareTimer FTM_GI_GATHER("Gather");
static LLFastTimerUtil::DeclareTimer FTM_SUN_SHADOW("Shadow Map");
static LLFastTimerUtil::DeclareTimer FTM_SOFTEN_SHADOW("Shadow Soften");
static LLFastTimerUtil::DeclareTimer FTM_EDGE_DETECTION("Find Edges");
static LLFastTimerUtil::DeclareTimer FTM_LOCAL_LIGHTS("Local Lights");
static LLFastTimerUtil::DeclareTimer FTM_ATMOSPHERICS("Atmospherics");
static LLFastTimerUtil::DeclareTimer FTM_FULLSCREEN_LIGHTS("Fullscreen Lights");
static LLFastTimerUtil::DeclareTimer FTM_PROJECTORS("Projectors");
static LLFastTimerUtil::DeclareTimer FTM_POST("Post");
static LLFastTimer::DeclareTimer FTM_GI_TRACE("Trace");
static LLFastTimer::DeclareTimer FTM_GI_GATHER("Gather");
static LLFastTimer::DeclareTimer FTM_SUN_SHADOW("Shadow Map");
static LLFastTimer::DeclareTimer FTM_SOFTEN_SHADOW("Shadow Soften");
static LLFastTimer::DeclareTimer FTM_EDGE_DETECTION("Find Edges");
static LLFastTimer::DeclareTimer FTM_LOCAL_LIGHTS("Local Lights");
static LLFastTimer::DeclareTimer FTM_ATMOSPHERICS("Atmospherics");
static LLFastTimer::DeclareTimer FTM_FULLSCREEN_LIGHTS("Fullscreen Lights");
static LLFastTimer::DeclareTimer FTM_PROJECTORS("Projectors");
static LLFastTimer::DeclareTimer FTM_POST("Post");
void LLPipeline::renderDeferredLighting()
@ -7433,9 +7433,9 @@ glh::matrix4f scale_translate_to_fit(const LLVector3 min, const LLVector3 max)
return ret;
}
static LLFastTimerUtil::DeclareTimer FTM_SHADOW_RENDER("Render Shadows");
static LLFastTimerUtil::DeclareTimer FTM_SHADOW_ALPHA("Alpha Shadow");
static LLFastTimerUtil::DeclareTimer FTM_SHADOW_SIMPLE("Simple Shadow");
static LLFastTimer::DeclareTimer FTM_SHADOW_RENDER("Render Shadows");
static LLFastTimer::DeclareTimer FTM_SHADOW_ALPHA("Alpha Shadow");
static LLFastTimer::DeclareTimer FTM_SHADOW_SIMPLE("Simple Shadow");
void LLPipeline::renderShadow(glh::matrix4f& view, glh::matrix4f& proj, LLCamera& shadow_cam, LLCullResult &result, BOOL use_shader, BOOL use_occlusion)
{

38
indra/newview/pipeline.h
View File

@ -78,25 +78,25 @@ glh::matrix4f gl_ortho(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top,
glh::matrix4f gl_perspective(GLfloat fovy, GLfloat aspect, GLfloat zNear, GLfloat zFar);
glh::matrix4f gl_lookat(LLVector3 eye, LLVector3 center, LLVector3 up);
extern LLFastTimerUtil::DeclareTimer FTM_RENDER_GEOMETRY;
extern LLFastTimerUtil::DeclareTimer FTM_RENDER_GRASS;
extern LLFastTimerUtil::DeclareTimer FTM_RENDER_INVISIBLE;
extern LLFastTimerUtil::DeclareTimer FTM_RENDER_OCCLUSION;
extern LLFastTimerUtil::DeclareTimer FTM_RENDER_SHINY;
extern LLFastTimerUtil::DeclareTimer FTM_RENDER_SIMPLE;
extern LLFastTimerUtil::DeclareTimer FTM_RENDER_TERRAIN;
extern LLFastTimerUtil::DeclareTimer FTM_RENDER_TREES;
extern LLFastTimerUtil::DeclareTimer FTM_RENDER_UI;
extern LLFastTimerUtil::DeclareTimer FTM_RENDER_WATER;
extern LLFastTimerUtil::DeclareTimer FTM_RENDER_WL_SKY;
extern LLFastTimerUtil::DeclareTimer FTM_RENDER_ALPHA;
extern LLFastTimerUtil::DeclareTimer FTM_RENDER_CHARACTERS;
extern LLFastTimerUtil::DeclareTimer FTM_RENDER_BUMP;
extern LLFastTimerUtil::DeclareTimer FTM_RENDER_FULLBRIGHT;
extern LLFastTimerUtil::DeclareTimer FTM_RENDER_GLOW;
extern LLFastTimerUtil::DeclareTimer FTM_STATESORT;
extern LLFastTimerUtil::DeclareTimer FTM_PIPELINE;
extern LLFastTimerUtil::DeclareTimer FTM_CLIENT_COPY;
extern LLFastTimer::DeclareTimer FTM_RENDER_GEOMETRY;
extern LLFastTimer::DeclareTimer FTM_RENDER_GRASS;
extern LLFastTimer::DeclareTimer FTM_RENDER_INVISIBLE;
extern LLFastTimer::DeclareTimer FTM_RENDER_OCCLUSION;
extern LLFastTimer::DeclareTimer FTM_RENDER_SHINY;
extern LLFastTimer::DeclareTimer FTM_RENDER_SIMPLE;
extern LLFastTimer::DeclareTimer FTM_RENDER_TERRAIN;
extern LLFastTimer::DeclareTimer FTM_RENDER_TREES;
extern LLFastTimer::DeclareTimer FTM_RENDER_UI;
extern LLFastTimer::DeclareTimer FTM_RENDER_WATER;
extern LLFastTimer::DeclareTimer FTM_RENDER_WL_SKY;
extern LLFastTimer::DeclareTimer FTM_RENDER_ALPHA;
extern LLFastTimer::DeclareTimer FTM_RENDER_CHARACTERS;
extern LLFastTimer::DeclareTimer FTM_RENDER_BUMP;
extern LLFastTimer::DeclareTimer FTM_RENDER_FULLBRIGHT;
extern LLFastTimer::DeclareTimer FTM_RENDER_GLOW;
extern LLFastTimer::DeclareTimer FTM_STATESORT;
extern LLFastTimer::DeclareTimer FTM_PIPELINE;
extern LLFastTimer::DeclareTimer FTM_CLIENT_COPY;
class LLPipeline