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

renamed TimeBlock to BlockTimerStatHandle

master
Richard Linden 2013-10-15 20:24:42 -07:00
parent 8f82b0016e
commit 697d2e720b
108 changed files with 636 additions and 602 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
indra/llappearance/llpolymorph.cpp
View File

@ -525,7 +525,7 @@ F32 LLPolyMorphTarget::getMaxDistortion()
//-----------------------------------------------------------------------------
// apply()
//-----------------------------------------------------------------------------
static LLTrace::TimeBlock FTM_APPLY_MORPH_TARGET("Apply Morph");
static LLTrace::BlockTimerStatHandle FTM_APPLY_MORPH_TARGET("Apply Morph");
void LLPolyMorphTarget::apply( ESex avatar_sex )
{

2
indra/llappearance/llpolyskeletaldistortion.cpp
View File

@ -179,7 +179,7 @@ BOOL LLPolySkeletalDistortion::setInfo(LLPolySkeletalDistortionInfo *info)
//-----------------------------------------------------------------------------
// apply()
//-----------------------------------------------------------------------------
static LLTrace::TimeBlock FTM_POLYSKELETAL_DISTORTION_APPLY("Skeletal Distortion");
static LLTrace::BlockTimerStatHandle FTM_POLYSKELETAL_DISTORTION_APPLY("Skeletal Distortion");
void LLPolySkeletalDistortion::apply( ESex avatar_sex )
{

14
indra/llappearance/lltexlayer.cpp
View File

@ -518,7 +518,7 @@ const LLTexLayerSetBuffer* LLTexLayerSet::getComposite() const
return mComposite;
}
static LLTrace::TimeBlock FTM_GATHER_MORPH_MASK_ALPHA("gatherMorphMaskAlpha");
static LLTrace::BlockTimerStatHandle FTM_GATHER_MORPH_MASK_ALPHA("gatherMorphMaskAlpha");
void LLTexLayerSet::gatherMorphMaskAlpha(U8 *data, S32 origin_x, S32 origin_y, S32 width, S32 height)
{
LL_RECORD_BLOCK_TIME(FTM_GATHER_MORPH_MASK_ALPHA);
@ -534,7 +534,7 @@ void LLTexLayerSet::gatherMorphMaskAlpha(U8 *data, S32 origin_x, S32 origin_y, S
renderAlphaMaskTextures(origin_x, origin_y, width, height, true);
}
static LLTrace::TimeBlock FTM_RENDER_ALPHA_MASK_TEXTURES("renderAlphaMaskTextures");
static LLTrace::BlockTimerStatHandle FTM_RENDER_ALPHA_MASK_TEXTURES("renderAlphaMaskTextures");
void LLTexLayerSet::renderAlphaMaskTextures(S32 x, S32 y, S32 width, S32 height, bool forceClear)
{
LL_RECORD_BLOCK_TIME(FTM_RENDER_ALPHA_MASK_TEXTURES);
@ -1424,7 +1424,7 @@ BOOL LLTexLayer::blendAlphaTexture(S32 x, S32 y, S32 width, S32 height)
addAlphaMask(data, originX, originY, width, height);
}
static LLTrace::TimeBlock FTM_RENDER_MORPH_MASKS("renderMorphMasks");
static LLTrace::BlockTimerStatHandle FTM_RENDER_MORPH_MASKS("renderMorphMasks");
void LLTexLayer::renderMorphMasks(S32 x, S32 y, S32 width, S32 height, const LLColor4 &layer_color, bool force_render)
{
if (!force_render && !hasMorph())
@ -1575,7 +1575,7 @@ void LLTexLayer::renderMorphMasks(S32 x, S32 y, S32 width, S32 height, const LLC
}
}
static LLTrace::TimeBlock FTM_ADD_ALPHA_MASK("addAlphaMask");
static LLTrace::BlockTimerStatHandle FTM_ADD_ALPHA_MASK("addAlphaMask");
void LLTexLayer::addAlphaMask(U8 *data, S32 originX, S32 originY, S32 width, S32 height)
{
LL_RECORD_BLOCK_TIME(FTM_ADD_ALPHA_MASK);
@ -1921,7 +1921,7 @@ void LLTexLayerStaticImageList::deleteCachedImages()
// Returns an LLImageTGA that contains the encoded data from a tga file named file_name.
// Caches the result to speed identical subsequent requests.
static LLTrace::TimeBlock FTM_LOAD_STATIC_TGA("getImageTGA");
static LLTrace::BlockTimerStatHandle FTM_LOAD_STATIC_TGA("getImageTGA");
LLImageTGA* LLTexLayerStaticImageList::getImageTGA(const std::string& file_name)
{
LL_RECORD_BLOCK_TIME(FTM_LOAD_STATIC_TGA);
@ -1951,7 +1951,7 @@ LLImageTGA* LLTexLayerStaticImageList::getImageTGA(const std::string& file_name)
// Returns a GL Image (without a backing ImageRaw) that contains the decoded data from a tga file named file_name.
// Caches the result to speed identical subsequent requests.
static LLTrace::TimeBlock FTM_LOAD_STATIC_TEXTURE("getTexture");
static LLTrace::BlockTimerStatHandle FTM_LOAD_STATIC_TEXTURE("getTexture");
LLGLTexture* LLTexLayerStaticImageList::getTexture(const std::string& file_name, BOOL is_mask)
{
LL_RECORD_BLOCK_TIME(FTM_LOAD_STATIC_TEXTURE);
@ -2001,7 +2001,7 @@ LLGLTexture* LLTexLayerStaticImageList::getTexture(const std::string& file_name,
// Reads a .tga file, decodes it, and puts the decoded data in image_raw.
// Returns TRUE if successful.
static LLTrace::TimeBlock FTM_LOAD_IMAGE_RAW("loadImageRaw");
static LLTrace::BlockTimerStatHandle FTM_LOAD_IMAGE_RAW("loadImageRaw");
BOOL LLTexLayerStaticImageList::loadImageRaw(const std::string& file_name, LLImageRaw* image_raw)
{
LL_RECORD_BLOCK_TIME(FTM_LOAD_IMAGE_RAW);

2
indra/llappearance/lltexlayerparams.cpp
View File

@ -239,7 +239,7 @@ BOOL LLTexLayerParamAlpha::getSkip() const
}
static LLTrace::TimeBlock FTM_TEX_LAYER_PARAM_ALPHA("alpha render");
static LLTrace::BlockTimerStatHandle FTM_TEX_LAYER_PARAM_ALPHA("alpha render");
BOOL LLTexLayerParamAlpha::render(S32 x, S32 y, S32 width, S32 height)
{
LL_RECORD_BLOCK_TIME(FTM_TEX_LAYER_PARAM_ALPHA);

6
indra/llcharacter/llcharacter.cpp
View File

@ -188,9 +188,9 @@ void LLCharacter::requestStopMotion( LLMotion* motion)
//-----------------------------------------------------------------------------
// updateMotions()
//-----------------------------------------------------------------------------
static LLTrace::TimeBlock FTM_UPDATE_ANIMATION("Update Animation");
static LLTrace::TimeBlock FTM_UPDATE_HIDDEN_ANIMATION("Update Hidden Anim");
static LLTrace::TimeBlock FTM_UPDATE_MOTIONS("Update Motions");
static LLTrace::BlockTimerStatHandle FTM_UPDATE_ANIMATION("Update Animation");
static LLTrace::BlockTimerStatHandle FTM_UPDATE_HIDDEN_ANIMATION("Update Hidden Anim");
static LLTrace::BlockTimerStatHandle FTM_UPDATE_MOTIONS("Update Motions");
void LLCharacter::updateMotions(e_update_t update_type)
{

2
indra/llcharacter/llmotioncontroller.cpp
View File

@ -541,7 +541,7 @@ void LLMotionController::updateIdleActiveMotions()
//-----------------------------------------------------------------------------
// updateMotionsByType()
//-----------------------------------------------------------------------------
static LLTrace::TimeBlock FTM_MOTION_ON_UPDATE("Motion onUpdate");
static LLTrace::BlockTimerStatHandle FTM_MOTION_ON_UPDATE("Motion onUpdate");
void LLMotionController::updateMotionsByType(LLMotion::LLMotionBlendType anim_type)
{

2
indra/llcommon/lldate.cpp
View File

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

104
indra/llcommon/llfasttimer.cpp
View File

@ -60,14 +60,14 @@ namespace LLTrace
//////////////////////////////////////////////////////////////////////////////
// statics
bool TimeBlock::sLog = false;
std::string TimeBlock::sLogName = "";
bool TimeBlock::sMetricLog = false;
bool BlockTimerStatHandle::sLog = false;
std::string BlockTimerStatHandle::sLogName = "";
bool BlockTimerStatHandle::sMetricLog = false;
#if LL_LINUX || LL_SOLARIS
U64 TimeBlock::sClockResolution = 1000000000; // Nanosecond resolution
U64 BlockTimerStatHandle::sClockResolution = 1000000000; // Nanosecond resolution
#else
U64 TimeBlock::sClockResolution = 1000000; // Microsecond resolution
U64 BlockTimerStatHandle::sClockResolution = 1000000; // Microsecond resolution
#endif
static LLMutex* sLogLock = NULL;
@ -77,13 +77,13 @@ static std::queue<LLSD> sLogQueue;
// FIXME: move these declarations to the relevant modules
// helper functions
typedef LLTreeDFSPostIter<TimeBlock, TimeBlock::child_const_iter> timer_tree_bottom_up_iterator_t;
typedef LLTreeDFSPostIter<BlockTimerStatHandle, BlockTimerStatHandle::child_const_iter> timer_tree_bottom_up_iterator_t;
static timer_tree_bottom_up_iterator_t begin_timer_tree_bottom_up(TimeBlock& id)
static timer_tree_bottom_up_iterator_t begin_timer_tree_bottom_up(BlockTimerStatHandle& id)
{
return timer_tree_bottom_up_iterator_t(&id,
boost::bind(boost::mem_fn(&TimeBlock::beginChildren), _1),
boost::bind(boost::mem_fn(&TimeBlock::endChildren), _1));
boost::bind(boost::mem_fn(&BlockTimerStatHandle::beginChildren), _1),
boost::bind(boost::mem_fn(&BlockTimerStatHandle::endChildren), _1));
}
static timer_tree_bottom_up_iterator_t end_timer_tree_bottom_up()
@ -91,14 +91,14 @@ static timer_tree_bottom_up_iterator_t end_timer_tree_bottom_up()
return timer_tree_bottom_up_iterator_t();
}
typedef LLTreeDFSIter<TimeBlock, TimeBlock::child_const_iter> timer_tree_dfs_iterator_t;
typedef LLTreeDFSIter<BlockTimerStatHandle, BlockTimerStatHandle::child_const_iter> timer_tree_dfs_iterator_t;
static timer_tree_dfs_iterator_t begin_timer_tree(TimeBlock& id)
static timer_tree_dfs_iterator_t begin_timer_tree(BlockTimerStatHandle& id)
{
return timer_tree_dfs_iterator_t(&id,
boost::bind(boost::mem_fn(&TimeBlock::beginChildren), _1),
boost::bind(boost::mem_fn(&TimeBlock::endChildren), _1));
boost::bind(boost::mem_fn(&BlockTimerStatHandle::beginChildren), _1),
boost::bind(boost::mem_fn(&BlockTimerStatHandle::endChildren), _1));
}
static timer_tree_dfs_iterator_t end_timer_tree()
@ -110,26 +110,26 @@ static timer_tree_dfs_iterator_t end_timer_tree()
// sort child timers by name
struct SortTimerByName
{
bool operator()(const TimeBlock* i1, const TimeBlock* i2)
bool operator()(const BlockTimerStatHandle* i1, const BlockTimerStatHandle* i2)
{
return i1->getName() < i2->getName();
}
};
TimeBlock& TimeBlock::getRootTimeBlock()
BlockTimerStatHandle& BlockTimerStatHandle::getRootTimeBlock()
{
static TimeBlock root_timer("root", NULL);
static BlockTimerStatHandle root_timer("root", NULL);
return root_timer;
}
void TimeBlock::pushLog(LLSD log)
void BlockTimerStatHandle::pushLog(LLSD log)
{
LLMutexLock lock(sLogLock);
sLogQueue.push(log);
}
void TimeBlock::setLogLock(LLMutex* lock)
void BlockTimerStatHandle::setLogLock(LLMutex* lock)
{
sLogLock = lock;
}
@ -137,12 +137,12 @@ void TimeBlock::setLogLock(LLMutex* lock)
//static
#if (LL_DARWIN || LL_LINUX || LL_SOLARIS) && !(defined(__i386__) || defined(__amd64__))
U64 TimeBlock::countsPerSecond()
U64 BlockTimerStatHandle::countsPerSecond()
{
return sClockResolution;
}
#else // windows or x86-mac or x86-linux or x86-solaris
U64 TimeBlock::countsPerSecond()
U64 BlockTimerStatHandle::countsPerSecond()
{
#if LL_FASTTIMER_USE_RDTSC || !LL_WINDOWS
//getCPUFrequency returns MHz and sCPUClockFrequency wants to be in Hz
@ -164,11 +164,11 @@ U64 TimeBlock::countsPerSecond()
}
#endif
TimeBlock::TimeBlock(const char* name, TimeBlock* parent)
: StatType<TimeBlockAccumulator>(name)
BlockTimerStatHandle::BlockTimerStatHandle(const char* name, const char* description)
: StatType<TimeBlockAccumulator>(name, description)
{}
TimeBlockTreeNode& TimeBlock::getTreeNode() const
TimeBlockTreeNode& BlockTimerStatHandle::getTreeNode() const
{
TimeBlockTreeNode* nodep = LLTrace::get_thread_recorder()->getTimeBlockTreeNode(getIndex());
llassert(nodep);
@ -176,18 +176,18 @@ TimeBlockTreeNode& TimeBlock::getTreeNode() const
}
void TimeBlock::bootstrapTimerTree()
void BlockTimerStatHandle::bootstrapTimerTree()
{
for (LLInstanceTracker<TimeBlock>::instance_iter begin_it = LLInstanceTracker<TimeBlock>::beginInstances(), end_it = LLInstanceTracker<TimeBlock>::endInstances(), it = begin_it;
for (BlockTimerStatHandle::instance_tracker_t::instance_iter begin_it = BlockTimerStatHandle::instance_tracker_t::beginInstances(), end_it = BlockTimerStatHandle::instance_tracker_t::endInstances(), it = begin_it;
it != end_it;
++it)
{
TimeBlock& timer = *it;
if (&timer == &TimeBlock::getRootTimeBlock()) continue;
BlockTimerStatHandle& timer = static_cast<BlockTimerStatHandle&>(*it);
if (&timer == &BlockTimerStatHandle::getRootTimeBlock()) continue;
// bootstrap tree construction by attaching to last timer to be on stack
// when this timer was called
if (timer.getParent() == &TimeBlock::getRootTimeBlock())
if (timer.getParent() == &BlockTimerStatHandle::getRootTimeBlock())
{
TimeBlockAccumulator& accumulator = timer.getCurrentAccumulator();
@ -205,13 +205,13 @@ void TimeBlock::bootstrapTimerTree()
// bump timers up tree if they have been flagged as being in the wrong place
// do this in a bottom up order to promote descendants first before promoting ancestors
// this preserves partial order derived from current frame's observations
void TimeBlock::incrementalUpdateTimerTree()
void BlockTimerStatHandle::incrementalUpdateTimerTree()
{
for(timer_tree_bottom_up_iterator_t it = begin_timer_tree_bottom_up(TimeBlock::getRootTimeBlock());
for(timer_tree_bottom_up_iterator_t it = begin_timer_tree_bottom_up(BlockTimerStatHandle::getRootTimeBlock());
it != end_timer_tree_bottom_up();
++it)
{
TimeBlock* timerp = *it;
BlockTimerStatHandle* timerp = *it;
// sort timers by time last called, so call graph makes sense
TimeBlockTreeNode& tree_node = timerp->getTreeNode();
@ -221,7 +221,7 @@ void TimeBlock::incrementalUpdateTimerTree()
}
// skip root timer
if (timerp != &TimeBlock::getRootTimeBlock())
if (timerp != &BlockTimerStatHandle::getRootTimeBlock())
{
TimeBlockAccumulator& accumulator = timerp->getCurrentAccumulator();
@ -245,7 +245,7 @@ void TimeBlock::incrementalUpdateTimerTree()
}
void TimeBlock::updateTimes()
void BlockTimerStatHandle::updateTimes()
{
// walk up stack of active timers and accumulate current time while leaving timing structures active
BlockTimerStackRecord* stack_record = LLThreadLocalSingletonPointer<BlockTimerStackRecord>::getInstance();
@ -273,11 +273,11 @@ void TimeBlock::updateTimes()
}
}
static LLTrace::TimeBlock FTM_PROCESS_TIMES("Process FastTimer Times");
static LLTrace::BlockTimerStatHandle FTM_PROCESS_TIMES("Process FastTimer Times");
// not thread safe, so only call on main thread
//static
void TimeBlock::processTimes()
void BlockTimerStatHandle::processTimes()
{
LL_RECORD_BLOCK_TIME(FTM_PROCESS_TIMES);
get_clock_count(); // good place to calculate clock frequency
@ -290,12 +290,12 @@ void TimeBlock::processTimes()
updateTimes();
// reset for next frame
for (LLInstanceTracker<TimeBlock>::instance_iter it = LLInstanceTracker<TimeBlock>::beginInstances(),
end_it = LLInstanceTracker<TimeBlock>::endInstances();
for (BlockTimerStatHandle::instance_tracker_t::instance_iter it = BlockTimerStatHandle::instance_tracker_t::beginInstances(),
end_it = BlockTimerStatHandle::instance_tracker_t::endInstances();
it != end_it;
++it)
{
TimeBlock& timer = *it;
BlockTimerStatHandle& timer = static_cast<BlockTimerStatHandle&>(*it);
TimeBlockAccumulator& accumulator = timer.getCurrentAccumulator();
accumulator.mLastCaller = NULL;
@ -303,23 +303,23 @@ void TimeBlock::processTimes()
}
}
std::vector<TimeBlock*>::iterator TimeBlock::beginChildren()
std::vector<BlockTimerStatHandle*>::iterator BlockTimerStatHandle::beginChildren()
{
return getTreeNode().mChildren.begin();
}
std::vector<TimeBlock*>::iterator TimeBlock::endChildren()
std::vector<BlockTimerStatHandle*>::iterator BlockTimerStatHandle::endChildren()
{
return getTreeNode().mChildren.end();
}
std::vector<TimeBlock*>& TimeBlock::getChildren()
std::vector<BlockTimerStatHandle*>& BlockTimerStatHandle::getChildren()
{
return getTreeNode().mChildren;
}
// static
void TimeBlock::logStats()
void BlockTimerStatHandle::logStats()
{
// get ready for next frame
if (sLog)
@ -340,12 +340,12 @@ void TimeBlock::logStats()
LLSD sd;
{
for (LLInstanceTracker<TimeBlock>::instance_iter it = LLInstanceTracker<TimeBlock>::beginInstances(),
end_it = LLInstanceTracker<TimeBlock>::endInstances();
for (BlockTimerStatHandle::instance_tracker_t::instance_iter it = BlockTimerStatHandle::instance_tracker_t::beginInstances(),
end_it = BlockTimerStatHandle::instance_tracker_t::endInstances();
it != end_it;
++it)
{
TimeBlock& timer = *it;
BlockTimerStatHandle& timer = static_cast<BlockTimerStatHandle&>(*it);
LLTrace::PeriodicRecording& frame_recording = LLTrace::get_frame_recording();
sd[timer.getName()]["Time"] = (LLSD::Real) (frame_recording.getLastRecording().getSum(timer).value());
sd[timer.getName()]["Calls"] = (LLSD::Integer) (frame_recording.getLastRecording().getSum(timer.callCount()));
@ -368,17 +368,17 @@ void TimeBlock::logStats()
}
//static
void TimeBlock::dumpCurTimes()
void BlockTimerStatHandle::dumpCurTimes()
{
LLTrace::PeriodicRecording& frame_recording = LLTrace::get_frame_recording();
LLTrace::Recording& last_frame_recording = frame_recording.getLastRecording();
// walk over timers in depth order and output timings
for(timer_tree_dfs_iterator_t it = begin_timer_tree(TimeBlock::getRootTimeBlock());
for(timer_tree_dfs_iterator_t it = begin_timer_tree(BlockTimerStatHandle::getRootTimeBlock());
it != end_timer_tree();
++it)
{
TimeBlock* timerp = (*it);
BlockTimerStatHandle* timerp = (*it);
F64Seconds total_time = last_frame_recording.getSum(*timerp);
U32 num_calls = last_frame_recording.getSum(timerp->callCount());
@ -386,7 +386,7 @@ void TimeBlock::dumpCurTimes()
if (total_time < F32Milliseconds(0.1f)) continue;
std::ostringstream out_str;
TimeBlock* parent_timerp = timerp;
BlockTimerStatHandle* parent_timerp = timerp;
while(parent_timerp && parent_timerp != parent_timerp->getParent())
{
out_str << "\t";
@ -402,7 +402,7 @@ void TimeBlock::dumpCurTimes()
}
//static
void TimeBlock::writeLog(std::ostream& os)
void BlockTimerStatHandle::writeLog(std::ostream& os)
{
while (!sLogQueue.empty())
{
@ -458,9 +458,9 @@ void TimeBlockAccumulator::reset( const TimeBlockAccumulator* other )
F64Seconds BlockTimer::getElapsedTime()
{
U64 total_time = TimeBlock::getCPUClockCount64() - mStartTime;
U64 total_time = BlockTimerStatHandle::getCPUClockCount64() - mStartTime;
return F64Seconds((F64)total_time / (F64)TimeBlock::countsPerSecond());
return F64Seconds((F64)total_time / (F64)BlockTimerStatHandle::countsPerSecond());
}

54
indra/llcommon/llfasttimer.h
View File

@ -30,36 +30,34 @@
#include "llinstancetracker.h"
#include "lltrace.h"
#define FAST_TIMER_ON 1
#define LL_FAST_TIMER_ON 1
#define LL_FASTTIMER_USE_RDTSC 1
class LLMutex;
#define LL_RECORD_BLOCK_TIME(timer_stat) const LLTrace::BlockTimer& LL_GLUE_TOKENS(block_time_recorder, __LINE__)(LLTrace::timeThisBlock(timer_stat)); (void)LL_GLUE_TOKENS(block_time_recorder, __LINE__);
namespace LLTrace
{
class BlockTimer timeThisBlock(class TimeBlock& timer);
// use to create blocktimer rvalue to be captured in a reference so that the BlockTimer lives to the end of the block.
class BlockTimer timeThisBlock(class BlockTimerStatHandle& timer);
class BlockTimer
{
public:
typedef BlockTimer self_t;
typedef class TimeBlock DeclareTimer;
typedef class BlockTimerStatHandle DeclareTimer;
~BlockTimer();
F64Seconds getElapsedTime();
private:
friend class TimeBlock;
friend class BlockTimerStatHandle;
// FIXME: this friendship exists so that each thread can instantiate a root timer,
// which could be a derived class with a public constructor instead, possibly
friend class ThreadRecorder;
friend BlockTimer timeThisBlock(TimeBlock&);
friend BlockTimer timeThisBlock(BlockTimerStatHandle&);
BlockTimer(TimeBlock& timer);
BlockTimer(BlockTimerStatHandle& timer);
#if !defined(MSC_VER) || MSC_VER < 1700
// Visual Studio 2010 has a bug where capturing an object returned by value
// into a local reference requires access to the copy constructor at the call site.
@ -79,28 +77,28 @@ private:
// (This is most easily done using the macro LL_RECORD_BLOCK_TIME)
// Otherwise, it would be possible to store a BlockTimer on the heap, resulting in non-nested lifetimes,
// which would break the invariants of the timing hierarchy logic
LL_FORCE_INLINE class BlockTimer timeThisBlock(class TimeBlock& timer)
LL_FORCE_INLINE class BlockTimer timeThisBlock(class BlockTimerStatHandle& timer)
{
return BlockTimer(timer);
}
// stores a "named" timer instance to be reused via multiple BlockTimer stack instances
class TimeBlock
: public StatType<TimeBlockAccumulator>,
public LLInstanceTracker<TimeBlock>
class BlockTimerStatHandle
: public StatType<TimeBlockAccumulator>
{
public:
TimeBlock(const char* name, TimeBlock* parent = &getRootTimeBlock());
typedef LLInstanceTracker<StatType<TimeBlockAccumulator>, std::string> instance_tracker_t;
BlockTimerStatHandle(const char* name, const char* description = "");
TimeBlockTreeNode& getTreeNode() const;
TimeBlock* getParent() const { return getTreeNode().getParent(); }
void setParent(TimeBlock* parent) { getTreeNode().setParent(parent); }
BlockTimerStatHandle* getParent() const { return getTreeNode().getParent(); }
void setParent(BlockTimerStatHandle* parent) { getTreeNode().setParent(parent); }
typedef std::vector<TimeBlock*>::iterator child_iter;
typedef std::vector<TimeBlock*>::const_iterator child_const_iter;
typedef std::vector<BlockTimerStatHandle*>::iterator child_iter;
typedef std::vector<BlockTimerStatHandle*>::const_iterator child_const_iter;
child_iter beginChildren();
child_iter endChildren();
std::vector<TimeBlock*>& getChildren();
std::vector<BlockTimerStatHandle*>& getChildren();
StatType<TimeBlockAccumulator::CallCountFacet>& callCount()
{
@ -112,9 +110,9 @@ public:
return static_cast<StatType<TimeBlockAccumulator::SelfTimeFacet>&>(*(StatType<TimeBlockAccumulator>*)this);
}
static TimeBlock& getRootTimeBlock();
static BlockTimerStatHandle& getRootTimeBlock();
static void pushLog(LLSD sd);
static void setLogLock(LLMutex* mutex);
static void setLogLock(class LLMutex* mutex);
static void writeLog(std::ostream& os);
static void updateTimes();
@ -144,14 +142,14 @@ public:
//#undef _interlockedbittestandset
//#undef _interlockedbittestandreset
//inline U32 TimeBlock::getCPUClockCount32()
//inline U32 BlockTimerStatHandle::getCPUClockCount32()
//{
// U64 time_stamp = __rdtsc();
// return (U32)(time_stamp >> 8);
//}
//
//// return full timer value, *not* shifted by 8 bits
//inline U64 TimeBlock::getCPUClockCount64()
//inline U64 BlockTimerStatHandle::getCPUClockCount64()
//{
// return __rdtsc();
//}
@ -279,9 +277,9 @@ public:
static U64 sClockResolution;
};
LL_FORCE_INLINE BlockTimer::BlockTimer(TimeBlock& timer)
LL_FORCE_INLINE BlockTimer::BlockTimer(BlockTimerStatHandle& timer)
{
#if FAST_TIMER_ON
#if LL_FAST_TIMER_ON
BlockTimerStackRecord* cur_timer_data = LLThreadLocalSingletonPointer<BlockTimerStackRecord>::getInstance();
if (!cur_timer_data) return;
TimeBlockAccumulator& accumulator = timer.getCurrentAccumulator();
@ -296,14 +294,14 @@ LL_FORCE_INLINE BlockTimer::BlockTimer(TimeBlock& timer)
cur_timer_data->mTimeBlock = &timer;
cur_timer_data->mChildTime = 0;
mStartTime = TimeBlock::getCPUClockCount64();
mStartTime = BlockTimerStatHandle::getCPUClockCount64();
#endif
}
LL_FORCE_INLINE BlockTimer::~BlockTimer()
{
#if FAST_TIMER_ON
U64 total_time = TimeBlock::getCPUClockCount64() - mStartTime;
#if LL_FAST_TIMER_ON
U64 total_time = BlockTimerStatHandle::getCPUClockCount64() - mStartTime;
BlockTimerStackRecord* cur_timer_data = LLThreadLocalSingletonPointer<BlockTimerStackRecord>::getInstance();
if (!cur_timer_data) return;

4
indra/llcommon/llmetricperformancetester.cpp
View File

@ -91,7 +91,7 @@ LLMetricPerformanceTesterBasic* LLMetricPerformanceTesterBasic::getTester(std::s
// Return TRUE if this metric is requested or if the general default "catch all" metric is requested
BOOL LLMetricPerformanceTesterBasic::isMetricLogRequested(std::string name)
{
return (LLTrace::TimeBlock::sMetricLog && ((LLTrace::TimeBlock::sLogName == name) || (LLTrace::TimeBlock::sLogName == DEFAULT_METRIC_NAME)));
return (LLTrace::BlockTimerStatHandle::sMetricLog && ((LLTrace::BlockTimerStatHandle::sLogName == name) || (LLTrace::BlockTimerStatHandle::sLogName == DEFAULT_METRIC_NAME)));
}
/*static*/
@ -194,7 +194,7 @@ void LLMetricPerformanceTesterBasic::preOutputTestResults(LLSD* sd)
void LLMetricPerformanceTesterBasic::postOutputTestResults(LLSD* sd)
{
LLTrace::TimeBlock::pushLog(*sd);
LLTrace::BlockTimerStatHandle::pushLog(*sd);
}
void LLMetricPerformanceTesterBasic::outputTestResults()

2
indra/llcommon/llsdparam.cpp
View File

@ -37,7 +37,7 @@ static LLInitParam::Parser::parser_write_func_map_t sWriteFuncs;
static LLInitParam::Parser::parser_inspect_func_map_t sInspectFuncs;
static const LLSD NO_VALUE_MARKER;
LLTrace::TimeBlock FTM_SD_PARAM_ADAPTOR("LLSD to LLInitParam conversion");
LLTrace::BlockTimerStatHandle FTM_SD_PARAM_ADAPTOR("LLSD to LLInitParam conversion");
//
// LLParamSDParser

2
indra/llcommon/llsdparam.h
View File

@ -110,7 +110,7 @@ private:
};
extern LL_COMMON_API LLTrace::TimeBlock FTM_SD_PARAM_ADAPTOR;
extern LL_COMMON_API LLTrace::BlockTimerStatHandle FTM_SD_PARAM_ADAPTOR;
template<typename T>
class LLSDParamAdapter : public T
{

2
indra/llcommon/llstring.cpp
View File

@ -36,7 +36,7 @@
#include <winnls.h> // for WideCharToMultiByte
#endif
LLTrace::TimeBlock FT_STRING_FORMAT("String Format");
LLTrace::BlockTimerStatHandle FT_STRING_FORMAT("String Format");
std::string ll_safe_string(const char* in)

6
indra/llcommon/lltrace.cpp
View File

@ -59,7 +59,7 @@ TimeBlockTreeNode::TimeBlockTreeNode()
mCollapsed(true)
{}
void TimeBlockTreeNode::setParent( TimeBlock* parent )
void TimeBlockTreeNode::setParent( BlockTimerStatHandle* parent )
{
llassert_always(parent != mBlock);
llassert_always(parent != NULL);
@ -69,8 +69,8 @@ void TimeBlockTreeNode::setParent( TimeBlock* parent )
if (mParent)
{
std::vector<TimeBlock*>& children = mParent->getChildren();
std::vector<TimeBlock*>::iterator found_it = std::find(children.begin(), children.end(), mBlock);
std::vector<BlockTimerStatHandle*>& children = mParent->getChildren();
std::vector<BlockTimerStatHandle*>::iterator found_it = std::find(children.begin(), children.end(), mBlock);
if (found_it != children.end())
{
children.erase(found_it);

6
indra/llcommon/lltrace.h
View File

@ -72,7 +72,7 @@ class StatType
public LLInstanceTracker<StatType<ACCUMULATOR>, std::string>
{
public:
StatType(const char* name, const char* description = NULL)
StatType(const char* name, const char* description)
: LLInstanceTracker<StatType<ACCUMULATOR>, std::string>(name),
StatBase(name, description),
mAccumulatorIndex(AccumulatorBuffer<ACCUMULATOR>::getDefaultBuffer()->reserveSlot())
@ -210,8 +210,8 @@ class MemStatHandle : public StatType<MemAccumulator>
{
public:
typedef StatType<MemAccumulator> stat_t;
MemStatHandle(const char* name)
: stat_t(name)
MemStatHandle(const char* name, const char* description = "")
: stat_t(name, description)
{
mName = name;
}

18
indra/llcommon/lltraceaccumulators.h
View File

@ -460,26 +460,26 @@ namespace LLTrace
U64 mTotalTimeCounter,
mSelfTimeCounter;
S32 mCalls;
class TimeBlock* mParent; // last acknowledged parent of this time block
class TimeBlock* mLastCaller; // used to bootstrap tree construction
class BlockTimerStatHandle* mParent; // last acknowledged parent of this time block
class BlockTimerStatHandle* mLastCaller; // used to bootstrap tree construction
U16 mActiveCount; // number of timers with this ID active on stack
bool mMoveUpTree; // needs to be moved up the tree of timers at the end of frame
};
class TimeBlock;
class BlockTimerStatHandle;
class TimeBlockTreeNode
{
public:
TimeBlockTreeNode();
void setParent(TimeBlock* parent);
TimeBlock* getParent() { return mParent; }
void setParent(BlockTimerStatHandle* parent);
BlockTimerStatHandle* getParent() { return mParent; }
TimeBlock* mBlock;
TimeBlock* mParent;
std::vector<TimeBlock*> mChildren;
BlockTimerStatHandle* mBlock;
BlockTimerStatHandle* mParent;
std::vector<BlockTimerStatHandle*> mChildren;
bool mCollapsed;
bool mNeedsSorting;
};
@ -487,7 +487,7 @@ namespace LLTrace
struct BlockTimerStackRecord
{
class BlockTimer* mActiveTimer;
class TimeBlock* mTimeBlock;
class BlockTimerStatHandle* mTimeBlock;
U64 mChildTime;
};

44
indra/llcommon/lltracerecording.cpp
View File

@ -139,192 +139,228 @@ void Recording::appendRecording( Recording& other )
F64Seconds Recording::getSum(const StatType<TimeBlockAccumulator>& stat)
{
llassert(!isStarted());
const TimeBlockAccumulator& accumulator = mBuffers->mStackTimers[stat.getIndex()];
return F64Seconds((F64)(accumulator.mTotalTimeCounter)
/ (F64)LLTrace::TimeBlock::countsPerSecond());
/ (F64)LLTrace::BlockTimerStatHandle::countsPerSecond());
}
F64Seconds Recording::getSum(const StatType<TimeBlockAccumulator::SelfTimeFacet>& stat)
{
llassert(!isStarted());
const TimeBlockAccumulator& accumulator = mBuffers->mStackTimers[stat.getIndex()];
return F64Seconds((F64)(accumulator.mSelfTimeCounter) / (F64)LLTrace::TimeBlock::countsPerSecond());
return F64Seconds((F64)(accumulator.mSelfTimeCounter) / (F64)LLTrace::BlockTimerStatHandle::countsPerSecond());
}
S32 Recording::getSum(const StatType<TimeBlockAccumulator::CallCountFacet>& stat)
{
llassert(!isStarted());
return mBuffers->mStackTimers[stat.getIndex()].mCalls;
}
F64Seconds Recording::getPerSec(const StatType<TimeBlockAccumulator>& stat)
{
llassert(!isStarted());
const TimeBlockAccumulator& accumulator = mBuffers->mStackTimers[stat.getIndex()];
return F64Seconds((F64)(accumulator.mTotalTimeCounter)
/ ((F64)LLTrace::TimeBlock::countsPerSecond() * mElapsedSeconds.value()));
/ ((F64)LLTrace::BlockTimerStatHandle::countsPerSecond() * mElapsedSeconds.value()));
}
F64Seconds Recording::getPerSec(const StatType<TimeBlockAccumulator::SelfTimeFacet>& stat)
{
llassert(!isStarted());
const TimeBlockAccumulator& accumulator = mBuffers->mStackTimers[stat.getIndex()];
return F64Seconds((F64)(accumulator.mSelfTimeCounter)
/ ((F64)LLTrace::TimeBlock::countsPerSecond() * mElapsedSeconds.value()));
/ ((F64)LLTrace::BlockTimerStatHandle::countsPerSecond() * mElapsedSeconds.value()));
}
F32 Recording::getPerSec(const StatType<TimeBlockAccumulator::CallCountFacet>& stat)
{
llassert(!isStarted());
return (F32)mBuffers->mStackTimers[stat.getIndex()].mCalls / mElapsedSeconds.value();
}
bool Recording::hasValue(const StatType<MemAccumulator>& stat)
{
llassert(!isStarted());
return mBuffers->mMemStats[stat.getIndex()].mSize.hasValue();
}
F64Kilobytes Recording::getMin(const StatType<MemAccumulator>& stat)
{
llassert(!isStarted());
return F64Bytes(mBuffers->mMemStats[stat.getIndex()].mSize.getMin());
}
F64Kilobytes Recording::getMean(const StatType<MemAccumulator>& stat)
{
llassert(!isStarted());
return F64Bytes(mBuffers->mMemStats[stat.getIndex()].mSize.getMean());
}
F64Kilobytes Recording::getMax(const StatType<MemAccumulator>& stat)
{
llassert(!isStarted());
return F64Bytes(mBuffers->mMemStats[stat.getIndex()].mSize.getMax());
}
F64Kilobytes Recording::getStandardDeviation(const StatType<MemAccumulator>& stat)
{
llassert(!isStarted());
return F64Bytes(mBuffers->mMemStats[stat.getIndex()].mSize.getStandardDeviation());
}
F64Kilobytes Recording::getLastValue(const StatType<MemAccumulator>& stat)
{
llassert(!isStarted());
return F64Bytes(mBuffers->mMemStats[stat.getIndex()].mSize.getLastValue());
}
F64Kilobytes Recording::getSum(const StatType<MemAccumulator::AllocationFacet>& stat)
{
llassert(!isStarted());
return F64Bytes(mBuffers->mMemStats[stat.getIndex()].mAllocations.getSum());
}
F64Kilobytes Recording::getPerSec(const StatType<MemAccumulator::AllocationFacet>& stat)
{
llassert(!isStarted());
return F64Bytes(mBuffers->mMemStats[stat.getIndex()].mAllocations.getSum() / mElapsedSeconds.value());
}
S32 Recording::getSampleCount(const StatType<MemAccumulator::AllocationFacet>& stat)
{
llassert(!isStarted());
return mBuffers->mMemStats[stat.getIndex()].mAllocations.getSampleCount();
}
F64Kilobytes Recording::getSum(const StatType<MemAccumulator::DeallocationFacet>& stat)
{
llassert(!isStarted());
return F64Bytes(mBuffers->mMemStats[stat.getIndex()].mDeallocations.getSum());
}
F64Kilobytes Recording::getPerSec(const StatType<MemAccumulator::DeallocationFacet>& stat)
{
llassert(!isStarted());
return F64Bytes(mBuffers->mMemStats[stat.getIndex()].mDeallocations.getSum() / mElapsedSeconds.value());
}
S32 Recording::getSampleCount(const StatType<MemAccumulator::DeallocationFacet>& stat)
{
llassert(!isStarted());
return mBuffers->mMemStats[stat.getIndex()].mDeallocations.getSampleCount();
}
F64 Recording::getSum( const StatType<CountAccumulator>& stat )
{
llassert(!isStarted());
return mBuffers->mCounts[stat.getIndex()].getSum();
}
F64 Recording::getSum( const StatType<EventAccumulator>& stat )
{
llassert(!isStarted());
return (F64)mBuffers->mEvents[stat.getIndex()].getSum();
}
F64 Recording::getPerSec( const StatType<CountAccumulator>& stat )
{
llassert(!isStarted());
F64 sum = mBuffers->mCounts[stat.getIndex()].getSum();
return sum / mElapsedSeconds.value();
}
S32 Recording::getSampleCount( const StatType<CountAccumulator>& stat )
{
llassert(!isStarted());
return mBuffers->mCounts[stat.getIndex()].getSampleCount();
}
bool Recording::hasValue(const StatType<SampleAccumulator>& stat)
{
llassert(!isStarted());
return mBuffers->mSamples[stat.getIndex()].hasValue();
}
F64 Recording::getMin( const StatType<SampleAccumulator>& stat )
{
llassert(!isStarted());
return mBuffers->mSamples[stat.getIndex()].getMin();
}
F64 Recording::getMax( const StatType<SampleAccumulator>& stat )
{
llassert(!isStarted());
return mBuffers->mSamples[stat.getIndex()].getMax();
}
F64 Recording::getMean( const StatType<SampleAccumulator>& stat )
{
llassert(!isStarted());
return mBuffers->mSamples[stat.getIndex()].getMean();
}
F64 Recording::getStandardDeviation( const StatType<SampleAccumulator>& stat )
{
llassert(!isStarted());
return mBuffers->mSamples[stat.getIndex()].getStandardDeviation();
}
F64 Recording::getLastValue( const StatType<SampleAccumulator>& stat )
{
llassert(!isStarted());
return mBuffers->mSamples[stat.getIndex()].getLastValue();
}
S32 Recording::getSampleCount( const StatType<SampleAccumulator>& stat )
{
llassert(!isStarted());
return mBuffers->mSamples[stat.getIndex()].getSampleCount();
}
bool Recording::hasValue(const StatType<EventAccumulator>& stat)
{
llassert(!isStarted());
return mBuffers->mEvents[stat.getIndex()].hasValue();
}
F64 Recording::getMin( const StatType<EventAccumulator>& stat )
{
llassert(!isStarted());
return mBuffers->mEvents[stat.getIndex()].getMin();
}
F64 Recording::getMax( const StatType<EventAccumulator>& stat )
{
llassert(!isStarted());
return mBuffers->mEvents[stat.getIndex()].getMax();
}
F64 Recording::getMean( const StatType<EventAccumulator>& stat )
{
llassert(!isStarted());
return mBuffers->mEvents[stat.getIndex()].getMean();
}
F64 Recording::getStandardDeviation( const StatType<EventAccumulator>& stat )
{
llassert(!isStarted());
return mBuffers->mEvents[stat.getIndex()].getStandardDeviation();
}
F64 Recording::getLastValue( const StatType<EventAccumulator>& stat )
{
llassert(!isStarted());
return mBuffers->mEvents[stat.getIndex()].getLastValue();
}
S32 Recording::getSampleCount( const StatType<EventAccumulator>& stat )
{
llassert(!isStarted());
return mBuffers->mEvents[stat.getIndex()].getSampleCount();
}

14
indra/llcommon/lltracethreadrecorder.cpp
View File

@ -50,7 +50,7 @@ void ThreadRecorder::init()
LLThreadLocalSingletonPointer<BlockTimerStackRecord>::setInstance(&mBlockTimerStackRecord);
//NB: the ordering of initialization in this function is very fragile due to a large number of implicit dependencies
set_thread_recorder(this);
TimeBlock& root_time_block = TimeBlock::getRootTimeBlock();
BlockTimerStatHandle& root_time_block = BlockTimerStatHandle::getRootTimeBlock();
BlockTimerStackRecord* timer_stack = LLThreadLocalSingletonPointer<BlockTimerStackRecord>::getInstance();
timer_stack->mTimeBlock = &root_time_block;
@ -63,11 +63,11 @@ void ThreadRecorder::init()
activate(&mThreadRecordingBuffers);
// initialize time block parent pointers
for (LLInstanceTracker<TimeBlock>::instance_iter it = LLInstanceTracker<TimeBlock>::beginInstances(), end_it = LLInstanceTracker<TimeBlock>::endInstances();
for (BlockTimerStatHandle::instance_tracker_t::instance_iter it = BlockTimerStatHandle::instance_tracker_t::beginInstances(), end_it = BlockTimerStatHandle::instance_tracker_t::endInstances();
it != end_it;
++it)
{
TimeBlock& time_block = *it;
BlockTimerStatHandle& time_block = static_cast<BlockTimerStatHandle&>(*it);
TimeBlockTreeNode& tree_node = mTimeBlockTreeNodes[it->getIndex()];
tree_node.mBlock = &time_block;
tree_node.mParent = &root_time_block;
@ -78,7 +78,7 @@ void ThreadRecorder::init()
mRootTimer = new BlockTimer(root_time_block);
timer_stack->mActiveTimer = mRootTimer;
TimeBlock::getRootTimeBlock().getCurrentAccumulator().mActiveCount = 1;
BlockTimerStatHandle::getRootTimeBlock().getCurrentAccumulator().mActiveCount = 1;
claim_alloc(gTraceMemStat, this);
claim_alloc(gTraceMemStat, sizeof(BlockTimer));
@ -138,7 +138,7 @@ void ThreadRecorder::activate( AccumulatorBufferGroup* recording, bool from_hand
{
AccumulatorBufferGroup& prev_active_recording = mActiveRecordings.back()->mPartialRecording;
prev_active_recording.sync();
TimeBlock::updateTimes();
BlockTimerStatHandle::updateTimes();
prev_active_recording.handOffTo(active_recording->mPartialRecording);
}
mActiveRecordings.push_back(active_recording);
@ -151,7 +151,7 @@ ThreadRecorder::active_recording_list_t::iterator ThreadRecorder::bringUpToDate(
if (mActiveRecordings.empty()) return mActiveRecordings.end();
mActiveRecordings.back()->mPartialRecording.sync();
TimeBlock::updateTimes();
BlockTimerStatHandle::updateTimes();
active_recording_list_t::reverse_iterator it, end_it;
for (it = mActiveRecordings.rbegin(), end_it = mActiveRecordings.rend();
@ -265,7 +265,7 @@ void ThreadRecorder::pushToParent()
}
static LLTrace::TimeBlock FTM_PULL_TRACE_DATA_FROM_CHILDREN("Pull child thread trace data");
static LLTrace::BlockTimerStatHandle FTM_PULL_TRACE_DATA_FROM_CHILDREN("Pull child thread trace data");
void ThreadRecorder::pullFromChildren()
{

2
indra/llinventory/llinventory.cpp
View File

@ -1066,7 +1066,7 @@ void LLInventoryItem::asLLSD( LLSD& sd ) const
sd[INV_CREATION_DATE_LABEL] = (S32) mCreationDate;
}
LLTrace::TimeBlock FTM_INVENTORY_SD_DESERIALIZE("Inventory SD Deserialize");
LLTrace::BlockTimerStatHandle FTM_INVENTORY_SD_DESERIALIZE("Inventory SD Deserialize");
bool LLInventoryItem::fromLLSD(const LLSD& sd)
{

8
indra/llmessage/llfiltersd2xmlrpc.cpp
View File

@ -309,7 +309,7 @@ LLFilterSD2XMLRPCResponse::~LLFilterSD2XMLRPCResponse()
}
static LLTrace::TimeBlock FTM_PROCESS_SD2XMLRPC_RESPONSE("SD2XMLRPC Response");
static LLTrace::BlockTimerStatHandle FTM_PROCESS_SD2XMLRPC_RESPONSE("SD2XMLRPC Response");
// virtual
LLIOPipe::EStatus LLFilterSD2XMLRPCResponse::process_impl(
const LLChannelDescriptors& channels,
@ -386,7 +386,7 @@ LLFilterSD2XMLRPCRequest::~LLFilterSD2XMLRPCRequest()
{
}
static LLTrace::TimeBlock FTM_PROCESS_SD2XMLRPC_REQUEST("S22XMLRPC Request");
static LLTrace::BlockTimerStatHandle FTM_PROCESS_SD2XMLRPC_REQUEST("S22XMLRPC Request");
// virtual
LLIOPipe::EStatus LLFilterSD2XMLRPCRequest::process_impl(
@ -593,7 +593,7 @@ LLFilterXMLRPCResponse2LLSD::~LLFilterXMLRPCResponse2LLSD()
{
}
static LLTrace::TimeBlock FTM_PROCESS_XMLRPC2LLSD_RESPONSE("XMLRPC2LLSD Response");
static LLTrace::BlockTimerStatHandle FTM_PROCESS_XMLRPC2LLSD_RESPONSE("XMLRPC2LLSD Response");
LLIOPipe::EStatus LLFilterXMLRPCResponse2LLSD::process_impl(
const LLChannelDescriptors& channels,
@ -679,7 +679,7 @@ LLFilterXMLRPCRequest2LLSD::~LLFilterXMLRPCRequest2LLSD()
{
}
static LLTrace::TimeBlock FTM_PROCESS_XMLRPC2LLSD_REQUEST("XMLRPC2LLSD Request");
static LLTrace::BlockTimerStatHandle FTM_PROCESS_XMLRPC2LLSD_REQUEST("XMLRPC2LLSD Request");
LLIOPipe::EStatus LLFilterXMLRPCRequest2LLSD::process_impl(
const LLChannelDescriptors& channels,
buffer_ptr_t& buffer,

14
indra/llmessage/lliohttpserver.cpp
View File

@ -139,11 +139,11 @@ private:
LLSD mHeaders;
};
static LLTrace::TimeBlock FTM_PROCESS_HTTP_PIPE("HTTP Pipe");
static LLTrace::TimeBlock FTM_PROCESS_HTTP_GET("HTTP Get");
static LLTrace::TimeBlock FTM_PROCESS_HTTP_PUT("HTTP Put");
static LLTrace::TimeBlock FTM_PROCESS_HTTP_POST("HTTP Post");
static LLTrace::TimeBlock FTM_PROCESS_HTTP_DELETE("HTTP Delete");
static LLTrace::BlockTimerStatHandle FTM_PROCESS_HTTP_PIPE("HTTP Pipe");
static LLTrace::BlockTimerStatHandle FTM_PROCESS_HTTP_GET("HTTP Get");
static LLTrace::BlockTimerStatHandle FTM_PROCESS_HTTP_PUT("HTTP Put");
static LLTrace::BlockTimerStatHandle FTM_PROCESS_HTTP_POST("HTTP Post");
static LLTrace::BlockTimerStatHandle FTM_PROCESS_HTTP_DELETE("HTTP Delete");
LLIOPipe::EStatus LLHTTPPipe::process_impl(
const LLChannelDescriptors& channels,
@ -435,7 +435,7 @@ protected:
* LLHTTPResponseHeader
*/
static LLTrace::TimeBlock FTM_PROCESS_HTTP_HEADER("HTTP Header");
static LLTrace::BlockTimerStatHandle FTM_PROCESS_HTTP_HEADER("HTTP Header");
// virtual
LLIOPipe::EStatus LLHTTPResponseHeader::process_impl(
@ -635,7 +635,7 @@ void LLHTTPResponder::markBad(
<< "</body>\n</html>\n";
}
static LLTrace::TimeBlock FTM_PROCESS_HTTP_RESPONDER("HTTP Responder");
static LLTrace::BlockTimerStatHandle FTM_PROCESS_HTTP_RESPONDER("HTTP Responder");
// virtual
LLIOPipe::EStatus LLHTTPResponder::process_impl(

6
indra/llmessage/lliosocket.cpp
View File

@ -294,7 +294,7 @@ LLIOSocketReader::~LLIOSocketReader()
//LL_DEBUGS() << "Destroying LLIOSocketReader" << LL_ENDL;
}
static LLTrace::TimeBlock FTM_PROCESS_SOCKET_READER("Socket Reader");
static LLTrace::BlockTimerStatHandle FTM_PROCESS_SOCKET_READER("Socket Reader");
// virtual
LLIOPipe::EStatus LLIOSocketReader::process_impl(
@ -394,7 +394,7 @@ LLIOSocketWriter::~LLIOSocketWriter()
//LL_DEBUGS() << "Destroying LLIOSocketWriter" << LL_ENDL;
}
static LLTrace::TimeBlock FTM_PROCESS_SOCKET_WRITER("Socket Writer");
static LLTrace::BlockTimerStatHandle FTM_PROCESS_SOCKET_WRITER("Socket Writer");
// virtual
LLIOPipe::EStatus LLIOSocketWriter::process_impl(
const LLChannelDescriptors& channels,
@ -550,7 +550,7 @@ void LLIOServerSocket::setResponseTimeout(F32 timeout_secs)
mResponseTimeout = timeout_secs;
}
static LLTrace::TimeBlock FTM_PROCESS_SERVER_SOCKET("Server Socket");
static LLTrace::BlockTimerStatHandle FTM_PROCESS_SERVER_SOCKET("Server Socket");
// virtual
LLIOPipe::EStatus LLIOServerSocket::process_impl(
const LLChannelDescriptors& channels,

4
indra/llmessage/llioutil.cpp
View File

@ -45,7 +45,7 @@ LLIOPipe::EStatus LLIOFlush::process_impl(
}
static LLTrace::TimeBlock FTM_PROCESS_SLEEP("IO Sleep");
static LLTrace::BlockTimerStatHandle FTM_PROCESS_SLEEP("IO Sleep");
/**
* @class LLIOSleep
*/
@ -66,7 +66,7 @@ LLIOPipe::EStatus LLIOSleep::process_impl(
return STATUS_DONE;
}
static LLTrace::TimeBlock FTM_PROCESS_ADD_CHAIN("Add Chain");
static LLTrace::BlockTimerStatHandle FTM_PROCESS_ADD_CHAIN("Add Chain");
/**
* @class LLIOAddChain
*/

6
indra/llmessage/llpumpio.cpp
View File

@ -431,8 +431,8 @@ void LLPumpIO::pump()
pump(DEFAULT_POLL_TIMEOUT);
}
static LLTrace::TimeBlock FTM_PUMP_IO("Pump IO");
static LLTrace::TimeBlock FTM_PUMP_POLL("Pump Poll");
static LLTrace::BlockTimerStatHandle FTM_PUMP_IO("Pump IO");
static LLTrace::BlockTimerStatHandle FTM_PUMP_POLL("Pump Poll");
LLPumpIO::current_chain_t LLPumpIO::removeRunningChain(LLPumpIO::current_chain_t& run_chain)
{
@ -774,7 +774,7 @@ bool LLPumpIO::respond(
return true;
}
static LLTrace::TimeBlock FTM_PUMP_CALLBACK_CHAIN("Chain");
static LLTrace::BlockTimerStatHandle FTM_PUMP_CALLBACK_CHAIN("Chain");
void LLPumpIO::callback()
{

4
indra/llmessage/llsdrpcclient.cpp
View File

@ -79,7 +79,7 @@ bool LLSDRPCResponse::extractResponse(const LLSD& sd)
return rv;
}
static LLTrace::TimeBlock FTM_SDRPC_RESPONSE("SDRPC Response");
static LLTrace::BlockTimerStatHandle FTM_SDRPC_RESPONSE("SDRPC Response");
// virtual
LLIOPipe::EStatus LLSDRPCResponse::process_impl(
@ -173,7 +173,7 @@ bool LLSDRPCClient::call(
return true;
}
static LLTrace::TimeBlock FTM_PROCESS_SDRPC_CLIENT("SDRPC Client");
static LLTrace::BlockTimerStatHandle FTM_PROCESS_SDRPC_CLIENT("SDRPC Client");
// virtual
LLIOPipe::EStatus LLSDRPCClient::process_impl(

2
indra/llmessage/llsdrpcserver.cpp
View File

@ -95,7 +95,7 @@ void LLSDRPCServer::clearLock()
}
}
static LLTrace::TimeBlock FTM_PROCESS_SDRPC_SERVER("SDRPC Server");
static LLTrace::BlockTimerStatHandle FTM_PROCESS_SDRPC_SERVER("SDRPC Server");
// virtual
LLIOPipe::EStatus LLSDRPCServer::process_impl(

2
indra/llmessage/lltemplatemessagereader.cpp
View File

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

16
indra/llmessage/llurlrequest.cpp
View File

@ -282,11 +282,11 @@ LLIOPipe::EStatus LLURLRequest::handleError(
return status;
}
static LLTrace::TimeBlock FTM_PROCESS_URL_REQUEST("URL Request");
static LLTrace::TimeBlock FTM_PROCESS_URL_REQUEST_GET_RESULT("Get Result");
static LLTrace::TimeBlock FTM_URL_PERFORM("Perform");
static LLTrace::TimeBlock FTM_PROCESS_URL_PUMP_RESPOND("Pump Respond");
static LLTrace::TimeBlock FTM_URL_ADJUST_TIMEOUT("Adjust Timeout");
static LLTrace::BlockTimerStatHandle FTM_PROCESS_URL_REQUEST("URL Request");
static LLTrace::BlockTimerStatHandle FTM_PROCESS_URL_REQUEST_GET_RESULT("Get Result");
static LLTrace::BlockTimerStatHandle FTM_URL_PERFORM("Perform");
static LLTrace::BlockTimerStatHandle FTM_PROCESS_URL_PUMP_RESPOND("Pump Respond");
static LLTrace::BlockTimerStatHandle FTM_URL_ADJUST_TIMEOUT("Adjust Timeout");
// virtual
LLIOPipe::EStatus LLURLRequest::process_impl(
@ -466,7 +466,7 @@ void LLURLRequest::initialize()
mResponseTransferedBytes = 0;
}
static LLTrace::TimeBlock FTM_URL_REQUEST_CONFIGURE("URL Configure");
static LLTrace::BlockTimerStatHandle FTM_URL_REQUEST_CONFIGURE("URL Configure");
bool LLURLRequest::configure()
{
LL_RECORD_BLOCK_TIME(FTM_URL_REQUEST_CONFIGURE);
@ -668,7 +668,7 @@ static size_t headerCallback(void* data, size_t size, size_t nmemb, void* user)
return header_len;
}
static LLTrace::TimeBlock FTM_PROCESS_URL_EXTRACTOR("URL Extractor");
static LLTrace::BlockTimerStatHandle FTM_PROCESS_URL_EXTRACTOR("URL Extractor");
/**
* LLContextURLExtractor
*/
@ -755,7 +755,7 @@ void LLURLRequestComplete::responseStatus(LLIOPipe::EStatus status)
mRequestStatus = status;
}
static LLTrace::TimeBlock FTM_PROCESS_URL_COMPLETE("URL Complete");
static LLTrace::BlockTimerStatHandle FTM_PROCESS_URL_COMPLETE("URL Complete");
// virtual
LLIOPipe::EStatus LLURLRequestComplete::process_impl(
const LLChannelDescriptors& channels,

2
indra/llrender/llfontgl.cpp
View File

@ -98,7 +98,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 LLTrace::TimeBlock FTM_RENDER_FONTS("Fonts");
static LLTrace::BlockTimerStatHandle FTM_RENDER_FONTS("Fonts");
S32 LLFontGL::render(const LLWString &wstr, S32 begin_offset, const LLRect& rect, const LLColor4 &color, HAlign halign, VAlign valign, U8 style,
ShadowType shadow, S32 max_chars, F32* right_x, BOOL use_ellipses) const

14
indra/llrender/llimagegl.cpp
View File

@ -242,7 +242,7 @@ S32 LLImageGL::dataFormatComponents(S32 dataformat)
//----------------------------------------------------------------------------
static LLTrace::TimeBlock FTM_IMAGE_UPDATE_STATS("Image Stats");
static LLTrace::BlockTimerStatHandle FTM_IMAGE_UPDATE_STATS("Image Stats");
// static
void LLImageGL::updateStats(F32 current_time)
{
@ -623,7 +623,7 @@ void LLImageGL::setImage(const LLImageRaw* imageraw)
setImage(rawdata, FALSE);
}
static LLTrace::TimeBlock FTM_SET_IMAGE("setImage");
static LLTrace::BlockTimerStatHandle FTM_SET_IMAGE("setImage");
void LLImageGL::setImage(const U8* data_in, BOOL data_hasmips)
{
LL_RECORD_BLOCK_TIME(FTM_SET_IMAGE);
@ -1091,7 +1091,7 @@ BOOL LLImageGL::setSubImageFromFrameBuffer(S32 fb_x, S32 fb_y, S32 x_pos, S32 y_
}
// static
static LLTrace::TimeBlock FTM_GENERATE_TEXTURES("generate textures");
static LLTrace::BlockTimerStatHandle FTM_GENERATE_TEXTURES("generate textures");
void LLImageGL::generateTextures(LLTexUnit::eTextureType type, U32 format, S32 numTextures, U32 *textures)
{
LL_RECORD_BLOCK_TIME(FTM_GENERATE_TEXTURES);
@ -1184,7 +1184,7 @@ void LLImageGL::deleteTextures(LLTexUnit::eTextureType type, U32 format, S32 mip
}
// static
static LLTrace::TimeBlock FTM_SET_MANUAL_IMAGE("setManualImage");
static LLTrace::BlockTimerStatHandle FTM_SET_MANUAL_IMAGE("setManualImage");
void LLImageGL::setManualImage(U32 target, S32 miplevel, S32 intformat, S32 width, S32 height, U32 pixformat, U32 pixtype, const void *pixels, bool allow_compression)
{
LL_RECORD_BLOCK_TIME(FTM_SET_MANUAL_IMAGE);
@ -1291,7 +1291,7 @@ void LLImageGL::setManualImage(U32 target, S32 miplevel, S32 intformat, S32 widt
//create an empty GL texture: just create a texture name
//the texture is assiciate with some image by calling glTexImage outside LLImageGL
static LLTrace::TimeBlock FTM_CREATE_GL_TEXTURE1("createGLTexture()");
static LLTrace::BlockTimerStatHandle FTM_CREATE_GL_TEXTURE1("createGLTexture()");
BOOL LLImageGL::createGLTexture()
{
LL_RECORD_BLOCK_TIME(FTM_CREATE_GL_TEXTURE1);
@ -1322,7 +1322,7 @@ BOOL LLImageGL::createGLTexture()
return TRUE ;
}
static LLTrace::TimeBlock FTM_CREATE_GL_TEXTURE2("createGLTexture(raw)");
static LLTrace::BlockTimerStatHandle FTM_CREATE_GL_TEXTURE2("createGLTexture(raw)");
BOOL LLImageGL::createGLTexture(S32 discard_level, const LLImageRaw* imageraw, S32 usename/*=0*/, BOOL to_create, S32 category)
{
LL_RECORD_BLOCK_TIME(FTM_CREATE_GL_TEXTURE2);
@ -1397,7 +1397,7 @@ BOOL LLImageGL::createGLTexture(S32 discard_level, const LLImageRaw* imageraw, S
return createGLTexture(discard_level, rawdata, FALSE, usename);
}
static LLTrace::TimeBlock FTM_CREATE_GL_TEXTURE3("createGLTexture3(data)");
static LLTrace::BlockTimerStatHandle FTM_CREATE_GL_TEXTURE3("createGLTexture3(data)");
BOOL LLImageGL::createGLTexture(S32 discard_level, const U8* data_in, BOOL data_hasmips, S32 usename)
{
LL_RECORD_BLOCK_TIME(FTM_CREATE_GL_TEXTURE3);

2
indra/llrender/llrender2dutils.cpp
View File

@ -1062,7 +1062,7 @@ void gl_rect_2d_simple( S32 width, S32 height )
gGL.end();
}
static LLTrace::TimeBlock FTM_RENDER_SEGMENTED_RECT ("Render segmented rectangle");
static LLTrace::BlockTimerStatHandle FTM_RENDER_SEGMENTED_RECT ("Render segmented rectangle");
void gl_segmented_rect_2d_tex(const S32 left,
const S32 top,

28
indra/llrender/llvertexbuffer.cpp
View File

@ -569,7 +569,7 @@ void LLVertexBuffer::setupClientArrays(U32 data_mask)
}
//static
static LLTrace::TimeBlock FTM_VB_DRAW_ARRAYS("drawArrays");
static LLTrace::BlockTimerStatHandle FTM_VB_DRAW_ARRAYS("drawArrays");
void LLVertexBuffer::drawArrays(U32 mode, const std::vector<LLVector3>& pos, const std::vector<LLVector3>& norm)
{
LL_RECORD_BLOCK_TIME(FTM_VB_DRAW_ARRAYS);
@ -817,7 +817,7 @@ void LLVertexBuffer::draw(U32 mode, U32 count, U32 indices_offset) const
placeFence();
}
static LLTrace::TimeBlock FTM_GL_DRAW_ARRAYS("GL draw arrays");
static LLTrace::BlockTimerStatHandle FTM_GL_DRAW_ARRAYS("GL draw arrays");
void LLVertexBuffer::drawArrays(U32 mode, U32 first, U32 count) const
{
llassert(!LLGLSLShader::sNoFixedFunction || LLGLSLShader::sCurBoundShaderPtr != NULL);
@ -1348,7 +1348,7 @@ void LLVertexBuffer::allocateBuffer(S32 nverts, S32 nindices, bool create)
}
}
static LLTrace::TimeBlock FTM_SETUP_VERTEX_ARRAY("Setup VAO");
static LLTrace::BlockTimerStatHandle FTM_SETUP_VERTEX_ARRAY("Setup VAO");
void LLVertexBuffer::setupVertexArray()
{
@ -1512,8 +1512,8 @@ bool expand_region(LLVertexBuffer::MappedRegion& region, S32 index, S32 count)
return true;
}
static LLTrace::TimeBlock FTM_VBO_MAP_BUFFER_RANGE("VBO Map Range");
static LLTrace::TimeBlock FTM_VBO_MAP_BUFFER("VBO Map");
static LLTrace::BlockTimerStatHandle FTM_VBO_MAP_BUFFER_RANGE("VBO Map Range");
static LLTrace::BlockTimerStatHandle FTM_VBO_MAP_BUFFER("VBO Map");
// Map for data access
volatile U8* LLVertexBuffer::mapVertexBuffer(S32 type, S32 index, S32 count, bool map_range)
@ -1694,8 +1694,8 @@ volatile U8* LLVertexBuffer::mapVertexBuffer(S32 type, S32 index, S32 count, boo
}
static LLTrace::TimeBlock FTM_VBO_MAP_INDEX_RANGE("IBO Map Range");
static LLTrace::TimeBlock FTM_VBO_MAP_INDEX("IBO Map");
static LLTrace::BlockTimerStatHandle FTM_VBO_MAP_INDEX_RANGE("IBO Map Range");
static LLTrace::BlockTimerStatHandle FTM_VBO_MAP_INDEX("IBO Map");
volatile U8* LLVertexBuffer::mapIndexBuffer(S32 index, S32 count, bool map_range)
{
@ -1860,12 +1860,12 @@ volatile U8* LLVertexBuffer::mapIndexBuffer(S32 index, S32 count, bool map_range
}
}
static LLTrace::TimeBlock FTM_VBO_UNMAP("VBO Unmap");
static LLTrace::TimeBlock FTM_VBO_FLUSH_RANGE("Flush VBO Range");
static LLTrace::BlockTimerStatHandle FTM_VBO_UNMAP("VBO Unmap");
static LLTrace::BlockTimerStatHandle FTM_VBO_FLUSH_RANGE("Flush VBO Range");
static LLTrace::TimeBlock FTM_IBO_UNMAP("IBO Unmap");
static LLTrace::TimeBlock FTM_IBO_FLUSH_RANGE("Flush IBO Range");
static LLTrace::BlockTimerStatHandle FTM_IBO_UNMAP("IBO Unmap");
static LLTrace::BlockTimerStatHandle FTM_IBO_FLUSH_RANGE("Flush IBO Range");
void LLVertexBuffer::unmapBuffer()
{
@ -2130,7 +2130,7 @@ bool LLVertexBuffer::getClothWeightStrider(LLStrider<LLVector4>& strider, S32 in
//----------------------------------------------------------------------------
static LLTrace::TimeBlock FTM_BIND_GL_ARRAY("Bind Array");
static LLTrace::BlockTimerStatHandle FTM_BIND_GL_ARRAY("Bind Array");
bool LLVertexBuffer::bindGLArray()
{
if (mGLArray && sGLRenderArray != mGLArray)
@ -2153,7 +2153,7 @@ bool LLVertexBuffer::bindGLArray()
return false;
}
static LLTrace::TimeBlock FTM_BIND_GL_BUFFER("Bind Buffer");
static LLTrace::BlockTimerStatHandle FTM_BIND_GL_BUFFER("Bind Buffer");
bool LLVertexBuffer::bindGLBuffer(bool force_bind)
{
@ -2178,7 +2178,7 @@ bool LLVertexBuffer::bindGLBuffer(bool force_bind)
return ret;
}
static LLTrace::TimeBlock FTM_BIND_GL_INDICES("Bind Indices");
static LLTrace::BlockTimerStatHandle FTM_BIND_GL_INDICES("Bind Indices");
bool LLVertexBuffer::bindGLIndices(bool force_bind)
{

6
indra/llui/llfloater.cpp
View File

@ -3114,8 +3114,8 @@ boost::signals2::connection LLFloater::setCloseCallback( const commit_signal_t::
return mCloseSignal.connect(cb);
}
LLTrace::TimeBlock POST_BUILD("Floater Post Build");
static LLTrace::TimeBlock FTM_EXTERNAL_FLOATER_LOAD("Load Extern Floater Reference");
LLTrace::BlockTimerStatHandle POST_BUILD("Floater Post Build");
static LLTrace::BlockTimerStatHandle FTM_EXTERNAL_FLOATER_LOAD("Load Extern Floater Reference");
bool LLFloater::initFloaterXML(LLXMLNodePtr node, LLView *parent, const std::string& filename, LLXMLNodePtr output_node)
{
@ -3270,7 +3270,7 @@ bool LLFloater::isVisible(const LLFloater* floater)
return floater && floater->getVisible();
}
static LLTrace::TimeBlock FTM_BUILD_FLOATERS("Build Floaters");
static LLTrace::BlockTimerStatHandle FTM_BUILD_FLOATERS("Build Floaters");
bool LLFloater::buildFromFile(const std::string& filename)
{

8
indra/llui/llfolderview.cpp
View File

@ -318,7 +318,7 @@ S32 LLFolderView::arrange( S32* unused_width, S32* unused_height )
return llround(mTargetHeight);
}
static LLTrace::TimeBlock FTM_FILTER("Filter Folder View");
static LLTrace::BlockTimerStatHandle FTM_FILTER("Filter Folder View");
void LLFolderView::filter( LLFolderViewFilter& filter )
{
@ -482,7 +482,7 @@ BOOL LLFolderView::changeSelection(LLFolderViewItem* selection, BOOL selected)
return rv;
}
static LLTrace::TimeBlock FTM_SANITIZE_SELECTION("Sanitize Selection");
static LLTrace::BlockTimerStatHandle FTM_SANITIZE_SELECTION("Sanitize Selection");
void LLFolderView::sanitizeSelection()
{
LL_RECORD_BLOCK_TIME(FTM_SANITIZE_SELECTION);
@ -1588,8 +1588,8 @@ void LLFolderView::setShowSingleSelection(bool show)
}
}
static LLTrace::TimeBlock FTM_AUTO_SELECT("Open and Select");
static LLTrace::TimeBlock FTM_INVENTORY("Inventory");
static LLTrace::BlockTimerStatHandle FTM_AUTO_SELECT("Open and Select");
static LLTrace::BlockTimerStatHandle FTM_INVENTORY("Inventory");
// Main idle routine
void LLFolderView::update()

2
indra/llui/llfolderviewitem.cpp
View File

@ -942,7 +942,7 @@ void LLFolderViewFolder::addToFolder(LLFolderViewFolder* folder)
folder->addFolder(this);
}
static LLTrace::TimeBlock FTM_ARRANGE("Arrange");
static LLTrace::BlockTimerStatHandle FTM_ARRANGE("Arrange");
// Make everything right and in the right place ready for drawing (CHUI-849)
// * Sort everything correctly if necessary

2
indra/llui/llkeywords.cpp
View File

@ -347,7 +347,7 @@ LLColor3 LLKeywords::readColor( const std::string& s )
return LLColor3( r, g, b );
}
LLTrace::TimeBlock FTM_SYNTAX_COLORING("Syntax Coloring");
LLTrace::BlockTimerStatHandle 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

@ -349,7 +349,7 @@ void LLLayoutStack::collapsePanel(LLPanel* panel, BOOL collapsed)
mNeedsLayout = true;
}
static LLTrace::TimeBlock FTM_UPDATE_LAYOUT("Update LayoutStacks");
static LLTrace::BlockTimerStatHandle FTM_UPDATE_LAYOUT("Update LayoutStacks");
void LLLayoutStack::updateLayout()
{

10
indra/llui/llpanel.cpp
View File

@ -372,7 +372,7 @@ void LLPanel::setBorderVisible(BOOL b)
}
}
LLTrace::TimeBlock FTM_PANEL_CONSTRUCTION("Panel Construction");
LLTrace::BlockTimerStatHandle FTM_PANEL_CONSTRUCTION("Panel Construction");
LLView* LLPanel::fromXML(LLXMLNodePtr node, LLView* parent, LLXMLNodePtr output_node)
{
@ -488,9 +488,9 @@ void LLPanel::initFromParams(const LLPanel::Params& p)
setAcceptsBadge(p.accepts_badge);
}
static LLTrace::TimeBlock FTM_PANEL_SETUP("Panel Setup");
static LLTrace::TimeBlock FTM_EXTERNAL_PANEL_LOAD("Load Extern Panel Reference");
static LLTrace::TimeBlock FTM_PANEL_POSTBUILD("Panel PostBuild");
static LLTrace::BlockTimerStatHandle FTM_PANEL_SETUP("Panel Setup");
static LLTrace::BlockTimerStatHandle FTM_EXTERNAL_PANEL_LOAD("Load Extern Panel Reference");
static LLTrace::BlockTimerStatHandle FTM_PANEL_POSTBUILD("Panel PostBuild");
BOOL LLPanel::initPanelXML(LLXMLNodePtr node, LLView *parent, LLXMLNodePtr output_node, const LLPanel::Params& default_params)
{
@ -963,7 +963,7 @@ boost::signals2::connection LLPanel::setVisibleCallback( const commit_signal_t::
return mVisibleSignal->connect(cb);
}
static LLTrace::TimeBlock FTM_BUILD_PANELS("Build Panels");
static LLTrace::BlockTimerStatHandle FTM_BUILD_PANELS("Build Panels");
//-----------------------------------------------------------------------------
// buildPanel()

2
indra/llui/llscrolllistctrl.cpp
View File

@ -2840,7 +2840,7 @@ LLScrollListColumn* LLScrollListCtrl::getColumn(const std::string& name)
return NULL;
}
LLTrace::TimeBlock FTM_ADD_SCROLLLIST_ELEMENT("Add Scroll List Item");
LLTrace::BlockTimerStatHandle FTM_ADD_SCROLLLIST_ELEMENT("Add Scroll List Item");
LLScrollListItem* LLScrollListCtrl::addElement(const LLSD& element, EAddPosition pos, void* userdata)
{
LL_RECORD_BLOCK_TIME(FTM_ADD_SCROLLLIST_ELEMENT);

8
indra/llui/lltextbase.cpp
View File

@ -1437,7 +1437,7 @@ S32 LLTextBase::getLeftOffset(S32 width)
}
static LLTrace::TimeBlock FTM_TEXT_REFLOW ("Text Reflow");
static LLTrace::BlockTimerStatHandle FTM_TEXT_REFLOW ("Text Reflow");
void LLTextBase::reflow()
{
LL_RECORD_BLOCK_TIME(FTM_TEXT_REFLOW);
@ -1779,7 +1779,7 @@ void LLTextBase::removeDocumentChild(LLView* view)
}
static LLTrace::TimeBlock FTM_UPDATE_TEXT_SEGMENTS("Update Text Segments");
static LLTrace::BlockTimerStatHandle FTM_UPDATE_TEXT_SEGMENTS("Update Text Segments");
void LLTextBase::updateSegments()
{
LL_RECORD_BLOCK_TIME(FTM_UPDATE_TEXT_SEGMENTS);
@ -2020,7 +2020,7 @@ static LLUIImagePtr image_from_icon_name(const std::string& icon_name)
}
}
static LLTrace::TimeBlock FTM_PARSE_HTML("Parse HTML");
static LLTrace::BlockTimerStatHandle FTM_PARSE_HTML("Parse HTML");
void LLTextBase::appendTextImpl(const std::string &new_text, const LLStyle::Params& input_params)
{
@ -2097,7 +2097,7 @@ void LLTextBase::appendTextImpl(const std::string &new_text, const LLStyle::Para
}
}
static LLTrace::TimeBlock FTM_APPEND_TEXT("Append Text");
static LLTrace::BlockTimerStatHandle FTM_APPEND_TEXT("Append Text");
void LLTextBase::appendText(const std::string &new_text, bool prepend_newline, const LLStyle::Params& input_params)
{

2
indra/llui/lltexteditor.cpp
View File

@ -2501,7 +2501,7 @@ BOOL LLTextEditor::tryToRevertToPristineState()
}
static LLTrace::TimeBlock FTM_SYNTAX_HIGHLIGHTING("Syntax Highlighting");
static LLTrace::BlockTimerStatHandle FTM_SYNTAX_HIGHLIGHTING("Syntax Highlighting");
void LLTextEditor::loadKeywords(const std::string& filename,
const std::vector<std::string>& funcs,
const std::vector<std::string>& tooltips,

2
indra/llui/lltrans.cpp
View File

@ -135,7 +135,7 @@ bool LLTrans::parseLanguageStrings(LLXMLNodePtr &root)
static LLTrace::TimeBlock FTM_GET_TRANS("Translate string");
static LLTrace::BlockTimerStatHandle FTM_GET_TRANS("Translate string");
//static
std::string LLTrans::getString(const std::string &xml_desc, const LLStringUtil::format_map_t& msg_args)

2
indra/llui/lluictrl.cpp
View File

@ -737,7 +737,7 @@ public:
}
};
LLTrace::TimeBlock FTM_FOCUS_FIRST_ITEM("Focus First Item");
LLTrace::BlockTimerStatHandle FTM_FOCUS_FIRST_ITEM("Focus First Item");
BOOL LLUICtrl::focusFirstItem(BOOL prefer_text_fields, BOOL focus_flash)
{

12
indra/llui/lluictrlfactory.cpp
View File

@ -44,9 +44,9 @@
// this library includes
#include "llpanel.h"
LLTrace::TimeBlock FTM_WIDGET_CONSTRUCTION("Widget Construction");
LLTrace::TimeBlock FTM_INIT_FROM_PARAMS("Widget InitFromParams");
LLTrace::TimeBlock FTM_WIDGET_SETUP("Widget Setup");
LLTrace::BlockTimerStatHandle FTM_WIDGET_CONSTRUCTION("Widget Construction");
LLTrace::BlockTimerStatHandle FTM_INIT_FROM_PARAMS("Widget InitFromParams");
LLTrace::BlockTimerStatHandle FTM_WIDGET_SETUP("Widget Setup");
//-----------------------------------------------------------------------------
@ -105,7 +105,7 @@ void LLUICtrlFactory::loadWidgetTemplate(const std::string& widget_tag, LLInitPa
}
}
static LLTrace::TimeBlock FTM_CREATE_CHILDREN("Create XUI Children");
static LLTrace::BlockTimerStatHandle 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 LLTrace::TimeBlock FTM_XML_PARSE("XML Reading/Parsing");
static LLTrace::BlockTimerStatHandle FTM_XML_PARSE("XML Reading/Parsing");
//-----------------------------------------------------------------------------
// getLayeredXMLNode()
//-----------------------------------------------------------------------------
@ -179,7 +179,7 @@ S32 LLUICtrlFactory::saveToXML(LLView* viewp, const std::string& filename)
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
static LLTrace::TimeBlock FTM_CREATE_FROM_XML("Create child widget");
static LLTrace::BlockTimerStatHandle 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

@ -74,9 +74,9 @@ class LLWidgetNameRegistry
//: public LLRegistrySingleton<const std::type_info*, empty_param_block_func_t, LLDefaultParamBlockRegistry>
//{};
extern LLTrace::TimeBlock FTM_WIDGET_SETUP;
extern LLTrace::TimeBlock FTM_WIDGET_CONSTRUCTION;
extern LLTrace::TimeBlock FTM_INIT_FROM_PARAMS;
extern LLTrace::BlockTimerStatHandle FTM_WIDGET_SETUP;
extern LLTrace::BlockTimerStatHandle FTM_WIDGET_CONSTRUCTION;
extern LLTrace::BlockTimerStatHandle FTM_INIT_FROM_PARAMS;
// Build time optimization, generate this once in .cpp file
#ifndef LLUICTRLFACTORY_CPP

2
indra/llui/lluistring.cpp
View File

@ -31,7 +31,7 @@
#include "llsd.h"
#include "lltrans.h"
LLTrace::TimeBlock FTM_UI_STRING("UI String");
LLTrace::BlockTimerStatHandle FTM_UI_STRING("UI String");
LLUIString::LLUIString(const std::string& instring, const LLStringUtil::format_map_t& args)

2
indra/llui/llview.cpp
View File

@ -1504,7 +1504,7 @@ LLView* LLView::getChildView(const std::string& name, BOOL recurse) const
return getChild<LLView>(name, recurse);
}
static LLTrace::TimeBlock FTM_FIND_VIEWS("Find Widgets");
static LLTrace::BlockTimerStatHandle FTM_FIND_VIEWS("Find Widgets");
LLView* LLView::findChildView(const std::string& name, BOOL recurse) const
{

2
indra/llui/llxuiparser.cpp
View File

@ -677,7 +677,7 @@ LLXUIParser::LLXUIParser()
}
}
static LLTrace::TimeBlock FTM_PARSE_XUI("XUI Parsing");
static LLTrace::BlockTimerStatHandle FTM_PARSE_XUI("XUI Parsing");
const LLXMLNodePtr DUMMY_NODE = new LLXMLNode();
void LLXUIParser::readXUI(LLXMLNodePtr node, LLInitParam::BaseBlock& block, const std::string& filename, bool silent)

2
indra/llvfs/llvfile.cpp
View File

@ -40,7 +40,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 LLTrace::TimeBlock FTM_VFILE_WAIT("VFile Wait");
static LLTrace::BlockTimerStatHandle FTM_VFILE_WAIT("VFile Wait");
//----------------------------------------------------------------------------
LLVFSThread* LLVFile::sVFSThread = NULL;

4
indra/llwindow/llwindowwin32.cpp
View File

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

2
indra/newview/llagentcamera.cpp
View File

@ -1126,7 +1126,7 @@ void LLAgentCamera::updateLookAt(const S32 mouse_x, const S32 mouse_y)
}
}
static LLTrace::TimeBlock FTM_UPDATE_CAMERA("Camera");
static LLTrace::BlockTimerStatHandle FTM_UPDATE_CAMERA("Camera");
//-----------------------------------------------------------------------------
// updateCamera()

104
indra/newview/llappviewer.cpp
View File

@ -627,7 +627,7 @@ public:
while (!LLAppViewer::instance()->isQuitting())
{
LLTrace::TimeBlock::writeLog(os);
LLTrace::BlockTimerStatHandle::writeLog(os);
os.flush();
ms_sleep(32);
}
@ -1240,24 +1240,24 @@ void LLAppViewer::checkMemory()
}
}
static LLTrace::TimeBlock FTM_MESSAGES("System Messages");
static LLTrace::TimeBlock FTM_SLEEP("Sleep");
static LLTrace::TimeBlock FTM_YIELD("Yield");
static LLTrace::BlockTimerStatHandle FTM_MESSAGES("System Messages");
static LLTrace::BlockTimerStatHandle FTM_SLEEP("Sleep");
static LLTrace::BlockTimerStatHandle FTM_YIELD("Yield");
static LLTrace::TimeBlock FTM_TEXTURE_CACHE("Texture Cache");
static LLTrace::TimeBlock FTM_DECODE("Image Decode");
static LLTrace::TimeBlock FTM_VFS("VFS Thread");
static LLTrace::TimeBlock FTM_LFS("LFS Thread");
static LLTrace::TimeBlock FTM_PAUSE_THREADS("Pause Threads");
static LLTrace::TimeBlock FTM_IDLE("Idle");
static LLTrace::TimeBlock FTM_PUMP("Pump");
static LLTrace::TimeBlock FTM_PUMP_ARES("Ares");
static LLTrace::TimeBlock FTM_PUMP_SERVICE("Service");
static LLTrace::TimeBlock FTM_SERVICE_CALLBACK("Callback");
static LLTrace::TimeBlock FTM_AGENT_AUTOPILOT("Autopilot");
static LLTrace::TimeBlock FTM_AGENT_UPDATE("Update");
static LLTrace::BlockTimerStatHandle FTM_TEXTURE_CACHE("Texture Cache");
static LLTrace::BlockTimerStatHandle FTM_DECODE("Image Decode");
static LLTrace::BlockTimerStatHandle FTM_VFS("VFS Thread");
static LLTrace::BlockTimerStatHandle FTM_LFS("LFS Thread");
static LLTrace::BlockTimerStatHandle FTM_PAUSE_THREADS("Pause Threads");
static LLTrace::BlockTimerStatHandle FTM_IDLE("Idle");
static LLTrace::BlockTimerStatHandle FTM_PUMP("Pump");
static LLTrace::BlockTimerStatHandle FTM_PUMP_ARES("Ares");
static LLTrace::BlockTimerStatHandle FTM_PUMP_SERVICE("Service");
static LLTrace::BlockTimerStatHandle FTM_SERVICE_CALLBACK("Callback");
static LLTrace::BlockTimerStatHandle FTM_AGENT_AUTOPILOT("Autopilot");
static LLTrace::BlockTimerStatHandle FTM_AGENT_UPDATE("Update");
LLTrace::TimeBlock FTM_FRAME("Frame");
LLTrace::BlockTimerStatHandle FTM_FRAME("Frame");
bool LLAppViewer::mainLoop()
{
@ -1315,9 +1315,9 @@ bool LLAppViewer::mainLoop()
#endif
{
LL_RECORD_BLOCK_TIME(FTM_FRAME);
LLTrace::TimeBlock::processTimes();
LLTrace::BlockTimerStatHandle::processTimes();
LLTrace::get_frame_recording().nextPeriod();
LLTrace::TimeBlock::logStats();
LLTrace::BlockTimerStatHandle::logStats();
LLTrace::get_master_thread_recorder()->pullFromChildren();
@ -1662,9 +1662,9 @@ bool LLAppViewer::cleanup()
if (LLFastTimerView::sAnalyzePerformance)
{
LL_INFOS() << "Analyzing performance" << LL_ENDL;
std::string baseline_name = LLTrace::TimeBlock::sLogName + "_baseline.slp";
std::string current_name = LLTrace::TimeBlock::sLogName + ".slp";
std::string report_name = LLTrace::TimeBlock::sLogName + "_report.csv";
std::string baseline_name = LLTrace::BlockTimerStatHandle::sLogName + "_baseline.slp";
std::string current_name = LLTrace::BlockTimerStatHandle::sLogName + ".slp";
std::string report_name = LLTrace::BlockTimerStatHandle::sLogName + "_report.csv";
LLFastTimerView::doAnalysis(
gDirUtilp->getExpandedFilename(LL_PATH_LOGS, baseline_name),
@ -2018,9 +2018,9 @@ bool LLAppViewer::cleanup()
{
LL_INFOS() << "Analyzing performance" << LL_ENDL;
std::string baseline_name = LLTrace::TimeBlock::sLogName + "_baseline.slp";
std::string current_name = LLTrace::TimeBlock::sLogName + ".slp";
std::string report_name = LLTrace::TimeBlock::sLogName + "_report.csv";
std::string baseline_name = LLTrace::BlockTimerStatHandle::sLogName + "_baseline.slp";
std::string current_name = LLTrace::BlockTimerStatHandle::sLogName + ".slp";
std::string report_name = LLTrace::BlockTimerStatHandle::sLogName + "_report.csv";
LLFastTimerView::doAnalysis(
gDirUtilp->getExpandedFilename(LL_PATH_LOGS, baseline_name),
@ -2139,10 +2139,10 @@ bool LLAppViewer::initThreads()
enable_threads && true,
app_metrics_qa_mode);
if (LLTrace::TimeBlock::sLog || LLTrace::TimeBlock::sMetricLog)
if (LLTrace::BlockTimerStatHandle::sLog || LLTrace::BlockTimerStatHandle::sMetricLog)
{
LLTrace::TimeBlock::setLogLock(new LLMutex(NULL));
mFastTimerLogThread = new LLFastTimerLogThread(LLTrace::TimeBlock::sLogName);
LLTrace::BlockTimerStatHandle::setLogLock(new LLMutex(NULL));
mFastTimerLogThread = new LLFastTimerLogThread(LLTrace::BlockTimerStatHandle::sLogName);
mFastTimerLogThread->start();
}
@ -2597,18 +2597,18 @@ bool LLAppViewer::initConfiguration()
if (gSavedSettings.getBOOL("LogPerformance"))
{
LLTrace::TimeBlock::sLog = true;
LLTrace::TimeBlock::sLogName = std::string("performance");
LLTrace::BlockTimerStatHandle::sLog = true;
LLTrace::BlockTimerStatHandle::sLogName = std::string("performance");
}
std::string test_name(gSavedSettings.getString("LogMetrics"));
if (! test_name.empty())
{
LLTrace::TimeBlock::sMetricLog = TRUE ;
LLTrace::BlockTimerStatHandle::sMetricLog = TRUE ;
// '--logmetrics' is specified with a named test metric argument so the data gathering is done only on that test
// In the absence of argument, every metric would be gathered (makes for a rather slow run and hard to decipher report...)
LL_INFOS() << "'--logmetrics' argument : " << test_name << LL_ENDL;
LLTrace::TimeBlock::sLogName = test_name;
LLTrace::BlockTimerStatHandle::sLogName = test_name;
}
if (clp.hasOption("graphicslevel"))
@ -4470,20 +4470,20 @@ public:
}
};
static LLTrace::TimeBlock FTM_AUDIO_UPDATE("Update Audio");
static LLTrace::TimeBlock FTM_CLEANUP("Cleanup");
static LLTrace::TimeBlock FTM_CLEANUP_DRAWABLES("Drawables");
static LLTrace::TimeBlock FTM_CLEANUP_OBJECTS("Objects");
static LLTrace::TimeBlock FTM_IDLE_CB("Idle Callbacks");
static LLTrace::TimeBlock FTM_LOD_UPDATE("Update LOD");
static LLTrace::TimeBlock FTM_OBJECTLIST_UPDATE("Update Objectlist");
static LLTrace::TimeBlock FTM_REGION_UPDATE("Update Region");
static LLTrace::TimeBlock FTM_WORLD_UPDATE("Update World");
static LLTrace::TimeBlock FTM_NETWORK("Network");
static LLTrace::TimeBlock FTM_AGENT_NETWORK("Agent Network");
static LLTrace::TimeBlock FTM_VLMANAGER("VL Manager");
static LLTrace::TimeBlock FTM_AGENT_POSITION("Agent Position");
static LLTrace::TimeBlock FTM_HUD_EFFECTS("HUD Effects");
static LLTrace::BlockTimerStatHandle FTM_AUDIO_UPDATE("Update Audio");
static LLTrace::BlockTimerStatHandle FTM_CLEANUP("Cleanup");
static LLTrace::BlockTimerStatHandle FTM_CLEANUP_DRAWABLES("Drawables");
static LLTrace::BlockTimerStatHandle FTM_CLEANUP_OBJECTS("Objects");
static LLTrace::BlockTimerStatHandle FTM_IDLE_CB("Idle Callbacks");
static LLTrace::BlockTimerStatHandle FTM_LOD_UPDATE("Update LOD");
static LLTrace::BlockTimerStatHandle FTM_OBJECTLIST_UPDATE("Update Objectlist");
static LLTrace::BlockTimerStatHandle FTM_REGION_UPDATE("Update Region");
static LLTrace::BlockTimerStatHandle FTM_WORLD_UPDATE("Update World");
static LLTrace::BlockTimerStatHandle FTM_NETWORK("Network");
static LLTrace::BlockTimerStatHandle FTM_AGENT_NETWORK("Agent Network");
static LLTrace::BlockTimerStatHandle FTM_VLMANAGER("VL Manager");
static LLTrace::BlockTimerStatHandle FTM_AGENT_POSITION("Agent Position");
static LLTrace::BlockTimerStatHandle FTM_HUD_EFFECTS("HUD Effects");
///////////////////////////////////////////////////////
// idle()
@ -5079,12 +5079,12 @@ void LLAppViewer::idleNameCache()
static F32 CheckMessagesMaxTime = CHECK_MESSAGES_DEFAULT_MAX_TIME;
#endif
static LLTrace::TimeBlock FTM_IDLE_NETWORK("Idle Network");
static LLTrace::TimeBlock FTM_MESSAGE_ACKS("Message Acks");
static LLTrace::TimeBlock FTM_RETRANSMIT("Retransmit");
static LLTrace::TimeBlock FTM_TIMEOUT_CHECK("Timeout Check");
static LLTrace::TimeBlock FTM_DYNAMIC_THROTTLE("Dynamic Throttle");
static LLTrace::TimeBlock FTM_CHECK_REGION_CIRCUIT("Check Region Circuit");
static LLTrace::BlockTimerStatHandle FTM_IDLE_NETWORK("Idle Network");
static LLTrace::BlockTimerStatHandle FTM_MESSAGE_ACKS("Message Acks");
static LLTrace::BlockTimerStatHandle FTM_RETRANSMIT("Retransmit");
static LLTrace::BlockTimerStatHandle FTM_TIMEOUT_CHECK("Timeout Check");
static LLTrace::BlockTimerStatHandle FTM_DYNAMIC_THROTTLE("Dynamic Throttle");
static LLTrace::BlockTimerStatHandle FTM_CHECK_REGION_CIRCUIT("Check Region Circuit");
void LLAppViewer::idleNetwork()
{

2
indra/newview/llappviewer.h
View File

@ -43,7 +43,7 @@ class LLWatchdogTimeout;
class LLUpdaterService;
class LLViewerJoystick;
extern LLTrace::TimeBlock FTM_FRAME;
extern LLTrace::BlockTimerStatHandle FTM_FRAME;
class LLAppViewer : public LLApp

2
indra/newview/llchathistory.cpp
View File

@ -734,7 +734,7 @@ void LLChatHistory::clear()
mLastFromID = LLUUID::null;
}
static LLTrace::TimeBlock FTM_APPEND_MESSAGE("Append Chat Message");
static LLTrace::BlockTimerStatHandle FTM_APPEND_MESSAGE("Append Chat Message");
void LLChatHistory::appendMessage(const LLChat& chat, const LLSD &args, const LLStyle::Params& input_append_params)
{

2
indra/newview/lldebugview.cpp
View File

@ -89,7 +89,7 @@ void LLDebugView::init()
r.setLeftTopAndSize(25, rect.getHeight() - 50, (S32) (gViewerWindow->getWindowRectScaled().getWidth() * 0.75f),
(S32) (gViewerWindow->getWindowRectScaled().getHeight() * 0.75f));
mFastTimerView = dynamic_cast<LLFastTimerView*>(LLFloaterReg::getInstance("fast_timers"));
mFastTimerView = dynamic_cast<LLFastTimerView*>(LLFloaterReg::getInstance("block_timers"));
gSceneView = new LLSceneView(r);
gSceneView->setFollowsTop();

4
indra/newview/lldonotdisturbnotificationstorage.cpp
View File

@ -97,7 +97,7 @@ void LLDoNotDisturbNotificationStorage::resetDirty()
mDirty = false;
}
static LLTrace::TimeBlock FTM_SAVE_DND_NOTIFICATIONS("Save DND Notifications");
static LLTrace::BlockTimerStatHandle FTM_SAVE_DND_NOTIFICATIONS("Save DND Notifications");
void LLDoNotDisturbNotificationStorage::saveNotifications()
{
@ -128,7 +128,7 @@ void LLDoNotDisturbNotificationStorage::saveNotifications()
resetDirty();
}
static LLTrace::TimeBlock FTM_LOAD_DND_NOTIFICATIONS("Load DND Notifications");
static LLTrace::BlockTimerStatHandle FTM_LOAD_DND_NOTIFICATIONS("Load DND Notifications");
void LLDoNotDisturbNotificationStorage::loadNotifications()
{

10
indra/newview/lldrawable.cpp
View File

@ -56,7 +56,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 LLTrace::TimeBlock FTM_CULL_REBOUND("Cull Rebound");
static LLTrace::BlockTimerStatHandle FTM_CULL_REBOUND("Cull Rebound");
extern bool gShiftFrame;
@ -236,9 +236,9 @@ BOOL LLDrawable::isLight() const
}
}
static LLTrace::TimeBlock FTM_CLEANUP_DRAWABLE("Cleanup Drawable");
static LLTrace::TimeBlock FTM_DEREF_DRAWABLE("Deref");
static LLTrace::TimeBlock FTM_DELETE_FACES("Faces");
static LLTrace::BlockTimerStatHandle FTM_CLEANUP_DRAWABLE("Cleanup Drawable");
static LLTrace::BlockTimerStatHandle FTM_DEREF_DRAWABLE("Deref");
static LLTrace::BlockTimerStatHandle FTM_DELETE_FACES("Faces");
void LLDrawable::cleanupReferences()
{
@ -306,7 +306,7 @@ S32 LLDrawable::findReferences(LLDrawable *drawablep)
return count;
}
static LLTrace::TimeBlock FTM_ALLOCATE_FACE("Allocate Face");
static LLTrace::BlockTimerStatHandle FTM_ALLOCATE_FACE("Allocate Face");
LLFace* LLDrawable::addFace(LLFacePool *poolp, LLViewerTexture *texturep)
{

4
indra/newview/lldrawpoolalpha.cpp
View File

@ -363,8 +363,8 @@ void LLDrawPoolAlpha::renderAlphaHighlight(U32 mask)
}
}
static LLFastTimer::DeclareTimer FTM_RENDER_ALPHA_GROUP_LOOP("Alpha Group");
static LLFastTimer::DeclareTimer FTM_RENDER_ALPHA_PUSH("Alpha Push Verts");
static LLTrace::BlockTimerStatHandle FTM_RENDER_ALPHA_GROUP_LOOP("Alpha Group");
static LLTrace::BlockTimerStatHandle FTM_RENDER_ALPHA_PUSH("Alpha Push Verts");
void LLDrawPoolAlpha::renderAlpha(U32 mask, S32 pass)
{

6
indra/newview/lldrawpoolavatar.cpp
View File

@ -102,7 +102,7 @@ S32 normal_channel = -1;
S32 specular_channel = -1;
S32 cube_channel = -1;
static LLTrace::TimeBlock FTM_SHADOW_AVATAR("Avatar Shadow");
static LLTrace::BlockTimerStatHandle FTM_SHADOW_AVATAR("Avatar Shadow");
LLDrawPoolAvatar::LLDrawPoolAvatar() :
LLFacePool(POOL_AVATAR)
@ -1174,7 +1174,7 @@ void LLDrawPoolAvatar::endDeferredSkinned()
gGL.getTexUnit(0)->activate();
}
static LLTrace::TimeBlock FTM_RENDER_AVATARS("renderAvatars");
static LLTrace::BlockTimerStatHandle FTM_RENDER_AVATARS("renderAvatars");
void LLDrawPoolAvatar::renderAvatars(LLVOAvatar* single_avatar, S32 pass)
@ -1836,7 +1836,7 @@ void LLDrawPoolAvatar::renderDeferredRiggedMaterial(LLVOAvatar* avatar, S32 pass
renderRigged(avatar, pass);
}
static LLTrace::TimeBlock FTM_RIGGED_VBO("Rigged VBO");
static LLTrace::BlockTimerStatHandle FTM_RIGGED_VBO("Rigged VBO");
void LLDrawPoolAvatar::updateRiggedVertexBuffers(LLVOAvatar* avatar)
{

20
indra/newview/lldrawpoolbump.cpp
View File

@ -1095,7 +1095,7 @@ LLViewerTexture* LLBumpImageList::getBrightnessDarknessImage(LLViewerFetchedText
}
static LLTrace::TimeBlock FTM_BUMP_SOURCE_STANDARD_LOADED("Bump Standard Callback");
static LLTrace::BlockTimerStatHandle FTM_BUMP_SOURCE_STANDARD_LOADED("Bump Standard Callback");
// static
void LLBumpImageList::onSourceBrightnessLoaded( BOOL success, LLViewerFetchedTexture *src_vi, LLImageRaw* src, LLImageRaw* aux_src, S32 discard_level, BOOL final, void* userdata )
@ -1119,8 +1119,8 @@ void LLBumpImageList::onSourceDarknessLoaded( BOOL success, LLViewerFetchedTextu
}
}
static LLTrace::TimeBlock FTM_BUMP_GEN_NORMAL("Generate Normal Map");
static LLTrace::TimeBlock FTM_BUMP_CREATE_TEXTURE("Create GL Normal Map");
static LLTrace::BlockTimerStatHandle FTM_BUMP_GEN_NORMAL("Generate Normal Map");
static LLTrace::BlockTimerStatHandle FTM_BUMP_CREATE_TEXTURE("Create GL Normal Map");
void LLBumpImageList::onSourceStandardLoaded( BOOL success, LLViewerFetchedTexture* src_vi, LLImageRaw* src, LLImageRaw* aux_src, S32 discard_level, BOOL final, void* userdata)
{
@ -1196,13 +1196,13 @@ void LLBumpImageList::generateNormalMapFromAlpha(LLImageRaw* src, LLImageRaw* nr
}
static LLTrace::TimeBlock FTM_BUMP_SOURCE_LOADED("Bump Source Loaded");
static LLTrace::TimeBlock FTM_BUMP_SOURCE_ENTRIES_UPDATE("Entries Update");
static LLTrace::TimeBlock FTM_BUMP_SOURCE_MIN_MAX("Min/Max");
static LLTrace::TimeBlock FTM_BUMP_SOURCE_RGB2LUM("RGB to Luminance");
static LLTrace::TimeBlock FTM_BUMP_SOURCE_RESCALE("Rescale");
static LLTrace::TimeBlock FTM_BUMP_SOURCE_GEN_NORMAL("Generate Normal");
static LLTrace::TimeBlock FTM_BUMP_SOURCE_CREATE("Bump Source Create");
static LLTrace::BlockTimerStatHandle FTM_BUMP_SOURCE_LOADED("Bump Source Loaded");
static LLTrace::BlockTimerStatHandle FTM_BUMP_SOURCE_ENTRIES_UPDATE("Entries Update");
static LLTrace::BlockTimerStatHandle FTM_BUMP_SOURCE_MIN_MAX("Min/Max");
static LLTrace::BlockTimerStatHandle FTM_BUMP_SOURCE_RGB2LUM("RGB to Luminance");
static LLTrace::BlockTimerStatHandle FTM_BUMP_SOURCE_RESCALE("Rescale");
static LLTrace::BlockTimerStatHandle FTM_BUMP_SOURCE_GEN_NORMAL("Generate Normal");
static LLTrace::BlockTimerStatHandle FTM_BUMP_SOURCE_CREATE("Bump Source Create");
// static
void LLBumpImageList::onSourceLoaded( BOOL success, LLViewerTexture *src_vi, LLImageRaw* src, LLUUID& source_asset_id, EBumpEffect bump_code )

10
indra/newview/lldrawpoolsimple.cpp
View File

@ -42,8 +42,8 @@
static LLGLSLShader* simple_shader = NULL;
static LLGLSLShader* fullbright_shader = NULL;
static LLTrace::TimeBlock FTM_RENDER_SIMPLE_DEFERRED("Deferred Simple");
static LLTrace::TimeBlock FTM_RENDER_GRASS_DEFERRED("Deferred Grass");
static LLTrace::BlockTimerStatHandle FTM_RENDER_SIMPLE_DEFERRED("Deferred Simple");
static LLTrace::BlockTimerStatHandle FTM_RENDER_GRASS_DEFERRED("Deferred Grass");
void LLDrawPoolGlow::beginPostDeferredPass(S32 pass)
{
@ -51,7 +51,7 @@ void LLDrawPoolGlow::beginPostDeferredPass(S32 pass)
gDeferredEmissiveProgram.uniform1f(LLShaderMgr::TEXTURE_GAMMA, 2.2f);
}
static LLTrace::TimeBlock FTM_RENDER_GLOW_PUSH("Glow Push");
static LLTrace::BlockTimerStatHandle FTM_RENDER_GLOW_PUSH("Glow Push");
void LLDrawPoolGlow::renderPostDeferred(S32 pass)
{
@ -237,7 +237,7 @@ void LLDrawPoolSimple::render(S32 pass)
static LLTrace::TimeBlock FTM_RENDER_ALPHA_MASK("Alpha Mask");
static LLTrace::BlockTimerStatHandle FTM_RENDER_ALPHA_MASK("Alpha Mask");
LLDrawPoolAlphaMask::LLDrawPoolAlphaMask() :
LLRenderPass(POOL_ALPHA_MASK)
@ -420,7 +420,7 @@ void LLDrawPoolSimple::renderDeferred(S32 pass)
}
}
static LLTrace::TimeBlock FTM_RENDER_ALPHA_MASK_DEFERRED("Deferred Alpha Mask");
static LLTrace::BlockTimerStatHandle FTM_RENDER_ALPHA_MASK_DEFERRED("Deferred Alpha Mask");
void LLDrawPoolAlphaMask::beginDeferredPass(S32 pass)
{

2
indra/newview/lldrawpoolterrain.cpp
View File

@ -55,7 +55,7 @@ int DebugDetailMap = 0;
S32 LLDrawPoolTerrain::sDetailMode = 1;
F32 LLDrawPoolTerrain::sDetailScale = DETAIL_SCALE;
static LLGLSLShader* sShader = NULL;
static LLTrace::TimeBlock FTM_SHADOW_TERRAIN("Terrain Shadow");
static LLTrace::BlockTimerStatHandle FTM_SHADOW_TERRAIN("Terrain Shadow");
LLDrawPoolTerrain::LLDrawPoolTerrain(LLViewerTexture *texturep) :

2
indra/newview/lldrawpooltree.cpp
View File

@ -41,7 +41,7 @@
S32 LLDrawPoolTree::sDiffTex = 0;
static LLGLSLShader* shader = NULL;
static LLTrace::TimeBlock FTM_SHADOW_TREE("Tree Shadow");
static LLTrace::BlockTimerStatHandle FTM_SHADOW_TREE("Tree Shadow");
LLDrawPoolTree::LLDrawPoolTree(LLViewerTexture *texturep) :
LLFacePool(POOL_TREE),

52
indra/newview/llface.cpp
View File

@ -1081,7 +1081,7 @@ bool LLFace::canRenderAsMask()
}
static LLTrace::TimeBlock FTM_FACE_GEOM_VOLUME("Volume VB Cache");
static LLTrace::BlockTimerStatHandle FTM_FACE_GEOM_VOLUME("Volume VB Cache");
//static
void LLFace::cacheFaceInVRAM(const LLVolumeFace& vf)
@ -1148,33 +1148,33 @@ void push_for_transform(LLVertexBuffer* buff, U32 source_count, U32 dest_count)
}
}
static LLTrace::TimeBlock FTM_FACE_GET_GEOM("Face Geom");
static LLTrace::TimeBlock FTM_FACE_GEOM_POSITION("Position");
static LLTrace::TimeBlock FTM_FACE_GEOM_NORMAL("Normal");
static LLTrace::TimeBlock FTM_FACE_GEOM_TEXTURE("Texture");
static LLTrace::TimeBlock FTM_FACE_GEOM_COLOR("Color");
static LLTrace::TimeBlock FTM_FACE_GEOM_EMISSIVE("Emissive");
static LLTrace::TimeBlock FTM_FACE_GEOM_WEIGHTS("Weights");
static LLTrace::TimeBlock FTM_FACE_GEOM_TANGENT("Binormal");
static LLTrace::BlockTimerStatHandle FTM_FACE_GET_GEOM("Face Geom");
static LLTrace::BlockTimerStatHandle FTM_FACE_GEOM_POSITION("Position");
static LLTrace::BlockTimerStatHandle FTM_FACE_GEOM_NORMAL("Normal");
static LLTrace::BlockTimerStatHandle FTM_FACE_GEOM_TEXTURE("Texture");
static LLTrace::BlockTimerStatHandle FTM_FACE_GEOM_COLOR("Color");
static LLTrace::BlockTimerStatHandle FTM_FACE_GEOM_EMISSIVE("Emissive");
static LLTrace::BlockTimerStatHandle FTM_FACE_GEOM_WEIGHTS("Weights");
static LLTrace::BlockTimerStatHandle FTM_FACE_GEOM_TANGENT("Binormal");
static LLTrace::TimeBlock FTM_FACE_GEOM_FEEDBACK("Face Feedback");
static LLTrace::TimeBlock FTM_FACE_GEOM_FEEDBACK_POSITION("Feedback Position");
static LLTrace::TimeBlock FTM_FACE_GEOM_FEEDBACK_NORMAL("Feedback Normal");
static LLTrace::TimeBlock FTM_FACE_GEOM_FEEDBACK_TEXTURE("Feedback Texture");
static LLTrace::TimeBlock FTM_FACE_GEOM_FEEDBACK_COLOR("Feedback Color");
static LLTrace::TimeBlock FTM_FACE_GEOM_FEEDBACK_EMISSIVE("Feedback Emissive");
static LLTrace::TimeBlock FTM_FACE_GEOM_FEEDBACK_BINORMAL("Feedback Binormal");
static LLTrace::BlockTimerStatHandle FTM_FACE_GEOM_FEEDBACK("Face Feedback");
static LLTrace::BlockTimerStatHandle FTM_FACE_GEOM_FEEDBACK_POSITION("Feedback Position");
static LLTrace::BlockTimerStatHandle FTM_FACE_GEOM_FEEDBACK_NORMAL("Feedback Normal");
static LLTrace::BlockTimerStatHandle FTM_FACE_GEOM_FEEDBACK_TEXTURE("Feedback Texture");
static LLTrace::BlockTimerStatHandle FTM_FACE_GEOM_FEEDBACK_COLOR("Feedback Color");
static LLTrace::BlockTimerStatHandle FTM_FACE_GEOM_FEEDBACK_EMISSIVE("Feedback Emissive");
static LLTrace::BlockTimerStatHandle FTM_FACE_GEOM_FEEDBACK_BINORMAL("Feedback Binormal");
static LLTrace::TimeBlock FTM_FACE_GEOM_INDEX("Index");
static LLTrace::TimeBlock FTM_FACE_GEOM_INDEX_TAIL("Tail");
static LLTrace::TimeBlock FTM_FACE_POSITION_STORE("Pos");
static LLTrace::TimeBlock FTM_FACE_TEXTURE_INDEX_STORE("TexIdx");
static LLTrace::TimeBlock FTM_FACE_POSITION_PAD("Pad");
static LLTrace::TimeBlock FTM_FACE_TEX_DEFAULT("Default");
static LLTrace::TimeBlock FTM_FACE_TEX_QUICK("Quick");
static LLTrace::TimeBlock FTM_FACE_TEX_QUICK_NO_XFORM("No Xform");
static LLTrace::TimeBlock FTM_FACE_TEX_QUICK_XFORM("Xform");
static LLTrace::TimeBlock FTM_FACE_TEX_QUICK_PLANAR("Quick Planar");
static LLTrace::BlockTimerStatHandle FTM_FACE_GEOM_INDEX("Index");
static LLTrace::BlockTimerStatHandle FTM_FACE_GEOM_INDEX_TAIL("Tail");
static LLTrace::BlockTimerStatHandle FTM_FACE_POSITION_STORE("Pos");
static LLTrace::BlockTimerStatHandle FTM_FACE_TEXTURE_INDEX_STORE("TexIdx");
static LLTrace::BlockTimerStatHandle FTM_FACE_POSITION_PAD("Pad");
static LLTrace::BlockTimerStatHandle FTM_FACE_TEX_DEFAULT("Default");
static LLTrace::BlockTimerStatHandle FTM_FACE_TEX_QUICK("Quick");
static LLTrace::BlockTimerStatHandle FTM_FACE_TEX_QUICK_NO_XFORM("No Xform");
static LLTrace::BlockTimerStatHandle FTM_FACE_TEX_QUICK_XFORM("Xform");
static LLTrace::BlockTimerStatHandle FTM_FACE_TEX_QUICK_PLANAR("Quick Planar");
BOOL LLFace::getGeometryVolume(const LLVolume& volume,
const S32 &f,

74
indra/newview/llfasttimerview.cpp
View File

@ -64,17 +64,17 @@ static const S32 MIN_BAR_HEIGHT = 3;
static const S32 RUNNING_AVERAGE_WIDTH = 100;
static const S32 NUM_FRAMES_HISTORY = 200;
std::vector<TimeBlock*> ft_display_idx; // line of table entry for display purposes (for collapse)
std::vector<BlockTimerStatHandle*> ft_display_idx; // line of table entry for display purposes (for collapse)
typedef LLTreeDFSIter<TimeBlock, TimeBlock::child_const_iter> timer_tree_iterator_t;
typedef LLTreeDFSIter<BlockTimerStatHandle, BlockTimerStatHandle::child_const_iter> timer_tree_iterator_t;
BOOL LLFastTimerView::sAnalyzePerformance = FALSE;
static timer_tree_iterator_t begin_timer_tree(TimeBlock& id)
static timer_tree_iterator_t begin_timer_tree(BlockTimerStatHandle& id)
{
return timer_tree_iterator_t(&id,
boost::bind(boost::mem_fn(&TimeBlock::beginChildren), _1),
boost::bind(boost::mem_fn(&TimeBlock::endChildren), _1));
boost::bind(boost::mem_fn(&BlockTimerStatHandle::beginChildren), _1),
boost::bind(boost::mem_fn(&BlockTimerStatHandle::endChildren), _1));
}
static timer_tree_iterator_t end_timer_tree()
@ -82,10 +82,10 @@ static timer_tree_iterator_t end_timer_tree()
return timer_tree_iterator_t();
}
S32 get_depth(const TimeBlock* blockp)
S32 get_depth(const BlockTimerStatHandle* blockp)
{
S32 depth = 0;
TimeBlock* timerp = blockp->getParent();
BlockTimerStatHandle* timerp = blockp->getParent();
while(timerp)
{
depth++;
@ -172,7 +172,7 @@ BOOL LLFastTimerView::handleRightMouseDown(S32 x, S32 y, MASK mask)
return LLFloater::handleRightMouseDown(x, y, mask);
}
TimeBlock* LLFastTimerView::getLegendID(S32 y)
BlockTimerStatHandle* LLFastTimerView::getLegendID(S32 y)
{
S32 idx = (mLegendRect.mTop - y) / (LLFontGL::getFontMonospace()->getLineHeight() + 2);
@ -199,7 +199,7 @@ BOOL LLFastTimerView::handleMouseDown(S32 x, S32 y, MASK mask)
{
if (x < mBarRect.mLeft)
{
TimeBlock* idp = getLegendID(y);
BlockTimerStatHandle* idp = getLegendID(y);
if (idp)
{
idp->getTreeNode().mCollapsed = !idp->getTreeNode().mCollapsed;
@ -261,7 +261,7 @@ BOOL LLFastTimerView::handleHover(S32 x, S32 y, MASK mask)
TimerBar* hover_bar = NULL;
F32Seconds mouse_time_offset = ((F32)(x - mBarRect.mLeft) / (F32)mBarRect.getWidth()) * mTotalTimeDisplay;
for (int bar_index = 0, end_index = LLInstanceTracker<LLTrace::TimeBlock>::instanceCount();
for (int bar_index = 0, end_index = LLTrace::BlockTimerStatHandle::instance_tracker_t::instanceCount();
bar_index < end_index;
++bar_index)
{
@ -275,7 +275,7 @@ BOOL LLFastTimerView::handleHover(S32 x, S32 y, MASK mask)
hover_bar = &bar;
if (bar.mTimeBlock->getTreeNode().mCollapsed)
{
// stop on first collapsed timeblock, since we can't select any children
// stop on first collapsed BlockTimerStatHandle, since we can't select any children
break;
}
}
@ -300,7 +300,7 @@ BOOL LLFastTimerView::handleHover(S32 x, S32 y, MASK mask)
}
else if (x < mBarRect.mLeft)
{
TimeBlock* timer_id = getLegendID(y);
BlockTimerStatHandle* timer_id = getLegendID(y);
if (timer_id)
{
mHoverID = timer_id;
@ -311,7 +311,7 @@ BOOL LLFastTimerView::handleHover(S32 x, S32 y, MASK mask)
}
static std::string get_tooltip(TimeBlock& timer, S32 history_index, PeriodicRecording& frame_recording)
static std::string get_tooltip(BlockTimerStatHandle& timer, S32 history_index, PeriodicRecording& frame_recording)
{
std::string tooltip;
if (history_index == 0)
@ -351,7 +351,7 @@ BOOL LLFastTimerView::handleToolTip(S32 x, S32 y, MASK mask)
// tooltips for timer legend
if (x < mBarRect.mLeft)
{
TimeBlock* idp = getLegendID(y);
BlockTimerStatHandle* idp = getLegendID(y);
if (idp)
{
LLToolTipMgr::instance().show(get_tooltip(*idp, 0, mRecording));
@ -373,7 +373,7 @@ BOOL LLFastTimerView::handleScrollWheel(S32 x, S32 y, S32 clicks)
return TRUE;
}
static TimeBlock FTM_RENDER_TIMER("Timers");
static BlockTimerStatHandle FTM_RENDER_TIMER("Timers");
static const S32 MARGIN = 10;
static const S32 LEGEND_WIDTH = 220;
@ -938,13 +938,13 @@ void LLFastTimerView::outputAllMetrics()
//static
void LLFastTimerView::doAnalysis(std::string baseline, std::string target, std::string output)
{
if(TimeBlock::sLog)
if(BlockTimerStatHandle::sLog)
{
doAnalysisDefault(baseline, target, output) ;
return ;
}
if(TimeBlock::sMetricLog)
if(BlockTimerStatHandle::sMetricLog)
{
LLMetricPerformanceTesterBasic::doAnalysisMetrics(baseline, target, output) ;
return ;
@ -966,7 +966,7 @@ void LLFastTimerView::printLineStats()
it != end_timer_tree();
++it)
{
TimeBlock* idp = (*it);
BlockTimerStatHandle* idp = (*it);
if (!first)
{
@ -988,7 +988,7 @@ void LLFastTimerView::printLineStats()
it != end_timer_tree();
++it)
{
TimeBlock* idp = (*it);
BlockTimerStatHandle* idp = (*it);
if (!first)
{
@ -1019,7 +1019,7 @@ void LLFastTimerView::printLineStats()
}
}
static LLTrace::TimeBlock FTM_DRAW_LINE_GRAPH("Draw line graph");
static LLTrace::BlockTimerStatHandle FTM_DRAW_LINE_GRAPH("Draw line graph");
void LLFastTimerView::drawLineGraph()
{
@ -1066,7 +1066,7 @@ void LLFastTimerView::drawLineGraph()
it != end_timer_tree();
++it)
{
TimeBlock* idp = (*it);
BlockTimerStatHandle* idp = (*it);
//fatten highlighted timer
if (mHoverID == idp)
@ -1208,12 +1208,12 @@ void LLFastTimerView::drawLegend()
LLLocalClipRect clip(mLegendRect);
S32 cur_line = 0;
ft_display_idx.clear();
std::map<TimeBlock*, S32> display_line;
std::map<BlockTimerStatHandle*, S32> display_line;
for (timer_tree_iterator_t it = begin_timer_tree(FTM_FRAME);
it != timer_tree_iterator_t();
++it)
{
TimeBlock* idp = (*it);
BlockTimerStatHandle* idp = (*it);
display_line[idp] = cur_line;
ft_display_idx.push_back(idp);
cur_line++;
@ -1275,7 +1275,7 @@ void LLFastTimerView::drawLegend()
x += dx;
BOOL is_child_of_hover_item = (idp == mHoverID);
TimeBlock* next_parent = idp->getParent();
BlockTimerStatHandle* next_parent = idp->getParent();
while(!is_child_of_hover_item && next_parent)
{
is_child_of_hover_item = (mHoverID == next_parent);
@ -1303,7 +1303,7 @@ void LLFastTimerView::generateUniqueColors()
{
// generate unique colors
{
sTimerColors.resize(LLTrace::TimeBlock::getNumIndices());
sTimerColors.resize(LLTrace::BlockTimerStatHandle::getNumIndices());
sTimerColors[FTM_FRAME.getIndex()] = LLColor4::grey;
F32 hue = 0.f;
@ -1312,7 +1312,7 @@ void LLFastTimerView::generateUniqueColors()
it != timer_tree_iterator_t();
++it)
{
TimeBlock* idp = (*it);
BlockTimerStatHandle* idp = (*it);
const F32 HUE_INCREMENT = 0.23f;
hue = fmodf(hue + HUE_INCREMENT, 1.f);
@ -1462,7 +1462,7 @@ void LLFastTimerView::drawBars()
U32 bar_index = 0;
if (!mAverageTimerRow.mBars)
{
mAverageTimerRow.mBars = new TimerBar[LLInstanceTracker<LLTrace::TimeBlock>::instanceCount()];
mAverageTimerRow.mBars = new TimerBar[LLTrace::BlockTimerStatHandle::instance_tracker_t::instanceCount()];
}
updateTimerBarWidths(&FTM_FRAME, mAverageTimerRow, -1, bar_index);
updateTimerBarOffsets(&FTM_FRAME, mAverageTimerRow);
@ -1474,7 +1474,7 @@ void LLFastTimerView::drawBars()
bar_index = 0;
if (!row.mBars)
{
row.mBars = new TimerBar[LLInstanceTracker<LLTrace::TimeBlock>::instanceCount()];
row.mBars = new TimerBar[LLTrace::BlockTimerStatHandle::instance_tracker_t::instanceCount()];
updateTimerBarWidths(&FTM_FRAME, row, history_index, bar_index);
updateTimerBarOffsets(&FTM_FRAME, row);
}
@ -1509,9 +1509,9 @@ void LLFastTimerView::drawBars()
gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
}
static LLTrace::TimeBlock FTM_UPDATE_TIMER_BAR_WIDTHS("Update timer bar widths");
static LLTrace::BlockTimerStatHandle FTM_UPDATE_TIMER_BAR_WIDTHS("Update timer bar widths");
F32Seconds LLFastTimerView::updateTimerBarWidths(LLTrace::TimeBlock* time_block, TimerBarRow& row, S32 history_index, U32& bar_index)
F32Seconds LLFastTimerView::updateTimerBarWidths(LLTrace::BlockTimerStatHandle* time_block, TimerBarRow& row, S32 history_index, U32& bar_index)
{
LL_RECORD_BLOCK_TIME(FTM_UPDATE_TIMER_BAR_WIDTHS);
const F32Seconds self_time = history_index == -1
@ -1525,7 +1525,7 @@ F32Seconds LLFastTimerView::updateTimerBarWidths(LLTrace::TimeBlock* time_block,
TimerBar& timer_bar = row.mBars[bar_index];
bar_index++;
for (TimeBlock::child_iter it = time_block->beginChildren(), end_it = time_block->endChildren(); it != end_it; ++it)
for (BlockTimerStatHandle::child_iter it = time_block->beginChildren(), end_it = time_block->endChildren(); it != end_it; ++it)
{
full_time += updateTimerBarWidths(*it, row, history_index, bar_index);
}
@ -1537,9 +1537,9 @@ F32Seconds LLFastTimerView::updateTimerBarWidths(LLTrace::TimeBlock* time_block,
return full_time;
}
static LLTrace::TimeBlock FTM_UPDATE_TIMER_BAR_FRACTIONS("Update timer bar fractions");
static LLTrace::BlockTimerStatHandle FTM_UPDATE_TIMER_BAR_FRACTIONS("Update timer bar fractions");
S32 LLFastTimerView::updateTimerBarOffsets(LLTrace::TimeBlock* time_block, TimerBarRow& row, S32 timer_bar_index)
S32 LLFastTimerView::updateTimerBarOffsets(LLTrace::BlockTimerStatHandle* time_block, TimerBarRow& row, S32 timer_bar_index)
{
LL_RECORD_BLOCK_TIME(FTM_UPDATE_TIMER_BAR_FRACTIONS);
@ -1560,14 +1560,14 @@ S32 LLFastTimerView::updateTimerBarOffsets(LLTrace::TimeBlock* time_block, Timer
TimerBar* last_child_timer_bar = NULL;
bool first_child = true;
for (TimeBlock::child_iter it = time_block->beginChildren(), end_it = time_block->endChildren();
for (BlockTimerStatHandle::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;
BlockTimerStatHandle* child_time_block = *it;
if (last_child_timer_bar)
{
@ -1603,7 +1603,7 @@ S32 LLFastTimerView::updateTimerBarOffsets(LLTrace::TimeBlock* time_block, Timer
S32 LLFastTimerView::drawBar(LLRect bar_rect, TimerBarRow& row, S32 image_width, S32 image_height, bool hovered, bool visible, S32 bar_index)
{
TimerBar& timer_bar = row.mBars[bar_index];
LLTrace::TimeBlock* time_block = timer_bar.mTimeBlock;
LLTrace::BlockTimerStatHandle* time_block = timer_bar.mTimeBlock;
hovered |= mHoverID == time_block;
@ -1648,7 +1648,7 @@ S32 LLFastTimerView::drawBar(LLRect bar_rect, TimerBarRow& row, S32 image_width,
bool children_visible = visible && !time_block->getTreeNode().mCollapsed;
bar_index++;
const U32 num_bars = LLInstanceTracker<LLTrace::TimeBlock>::instanceCount();
const U32 num_bars = LLTrace::BlockTimerStatHandle::instance_tracker_t::instanceCount();
if (bar_index < num_bars && row.mBars[bar_index].mFirstChild)
{
bool is_last = false;

12
indra/newview/llfasttimerview.h
View File

@ -62,7 +62,7 @@ public:
virtual BOOL handleScrollWheel(S32 x, S32 y, S32 clicks);
virtual void draw();
virtual void onOpen(const LLSD& key);
LLTrace::TimeBlock* getLegendID(S32 y);
LLTrace::BlockTimerStatHandle* getLegendID(S32 y);
private:
virtual void onClickCloseBtn();
@ -93,7 +93,7 @@ private:
mChildrenEnd,
mSelfStart,
mSelfEnd;
LLTrace::TimeBlock* mTimeBlock;
LLTrace::BlockTimerStatHandle* mTimeBlock;
bool mVisible,
mFirstChild,
mLastChild;
@ -113,8 +113,8 @@ private:
TimerBar* mBars;
};
F32Seconds 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);
F32Seconds updateTimerBarWidths(LLTrace::BlockTimerStatHandle* time_block, TimerBarRow& row, S32 history_index, U32& bar_index);
S32 updateTimerBarOffsets(LLTrace::BlockTimerStatHandle* 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);
@ -134,8 +134,8 @@ private:
mHoverBarIndex,
mStatsIndex;
S32 mDisplayMode;
LLTrace::TimeBlock* mHoverID;
LLTrace::TimeBlock* mHoverTimer;
LLTrace::BlockTimerStatHandle* mHoverID;
LLTrace::BlockTimerStatHandle* mHoverTimer;
LLRect mToolTipRect,
mGraphRect,
mBarRect,

8
indra/newview/llflexibleobject.cpp
View File

@ -47,8 +47,8 @@
std::vector<LLVolumeImplFlexible*> LLVolumeImplFlexible::sInstanceList;
std::vector<S32> LLVolumeImplFlexible::sUpdateDelay;
static LLTrace::TimeBlock FTM_FLEXIBLE_REBUILD("Rebuild");
static LLTrace::TimeBlock FTM_DO_FLEXIBLE_UPDATE("Flexible Update");
static LLTrace::BlockTimerStatHandle FTM_FLEXIBLE_REBUILD("Rebuild");
static LLTrace::BlockTimerStatHandle FTM_DO_FLEXIBLE_UPDATE("Flexible Update");
// LLFlexibleObjectData::pack/unpack now in llprimitive.cpp
@ -334,7 +334,7 @@ void LLVolumeImplFlexible::updateRenderRes()
// updated every time step. In the future, perhaps there could be an
// optimization similar to what Havok does for objects that are stationary.
//---------------------------------------------------------------------------------
static LLTrace::TimeBlock FTM_FLEXIBLE_UPDATE("Update Flexies");
static LLTrace::BlockTimerStatHandle FTM_FLEXIBLE_UPDATE("Update Flexies");
void LLVolumeImplFlexible::doIdleUpdate()
{
LLDrawable* drawablep = mVO->mDrawable;
@ -715,7 +715,7 @@ void LLVolumeImplFlexible::doFlexibleUpdate()
mLastSegmentRotation = parentSegmentRotation;
}
static LLFastTimer::DeclareTimer FTM_FLEXI_PREBUILD("Flexi Prebuild");
static LLTrace::BlockTimerStatHandle FTM_FLEXI_PREBUILD("Flexi Prebuild");
void LLVolumeImplFlexible::preRebuild()
{

2
indra/newview/llfolderviewmodelinventory.cpp
View File

@ -34,7 +34,7 @@
//
// class LLFolderViewModelInventory
//
static LLTrace::TimeBlock FTM_INVENTORY_SORT("Sort");
static LLTrace::BlockTimerStatHandle FTM_INVENTORY_SORT("Sort");
bool LLFolderViewModelInventory::startDrag(std::vector<LLFolderViewModelItem*>& items)
{

2
indra/newview/llhudmanager.cpp
View File

@ -54,7 +54,7 @@ LLHUDManager::~LLHUDManager()
{
}
static LLTrace::TimeBlock FTM_HUD_EFFECTS("Hud Effects");
static LLTrace::BlockTimerStatHandle FTM_HUD_EFFECTS("Hud Effects");
void LLHUDManager::updateEffects()
{

2
indra/newview/llhudobject.cpp
View File

@ -252,7 +252,7 @@ LLHUDEffect *LLHUDObject::addHUDEffect(const U8 type)
return hud_objectp;
}
static LLTrace::TimeBlock FTM_HUD_UPDATE("Update Hud");
static LLTrace::BlockTimerStatHandle FTM_HUD_UPDATE("Update Hud");
// static
void LLHUDObject::updateAll()

2
indra/newview/llinventoryfilter.cpp
View File

@ -42,7 +42,7 @@
#include "llclipboard.h"
#include "lltrans.h"
LLTrace::TimeBlock FT_FILTER_CLIPBOARD("Filter Clipboard");
LLTrace::BlockTimerStatHandle FT_FILTER_CLIPBOARD("Filter Clipboard");
LLInventoryFilter::FilterOps::FilterOps(const Params& p)
: mFilterObjectTypes(p.object_types),

2
indra/newview/llinventoryitemslist.cpp
View File

@ -133,7 +133,7 @@ void LLInventoryItemsList::idle(void* user_data)
}
}
LLTrace::TimeBlock FTM_INVENTORY_ITEMS_REFRESH("Inventory List Refresh");
LLTrace::BlockTimerStatHandle FTM_INVENTORY_ITEMS_REFRESH("Inventory List Refresh");
void LLInventoryItemsList::refresh()
{

4
indra/newview/llinventorypanel.cpp
View File

@ -397,7 +397,7 @@ LLInventoryFilter::EFolderShow LLInventoryPanel::getShowFolderState()
}
// Called when something changed in the global model (new item, item coming through the wire, rename, move, etc...) (CHUI-849)
static LLTrace::TimeBlock FTM_REFRESH("Inventory Refresh");
static LLTrace::BlockTimerStatHandle FTM_REFRESH("Inventory Refresh");
void LLInventoryPanel::modelChanged(U32 mask)
{
LL_RECORD_BLOCK_TIME(FTM_REFRESH);
@ -1295,7 +1295,7 @@ void LLInventoryPanel::removeItemID(const LLUUID& id)
}
}
LLTrace::TimeBlock FTM_GET_ITEM_BY_ID("Get FolderViewItem by ID");
LLTrace::BlockTimerStatHandle FTM_GET_ITEM_BY_ID("Get FolderViewItem by ID");
LLFolderViewItem* LLInventoryPanel::getItemByID(const LLUUID& id)
{
LL_RECORD_BLOCK_TIME(FTM_GET_ITEM_BY_ID);

2
indra/newview/llmaterialmgr.cpp
View File

@ -527,7 +527,7 @@ void LLMaterialMgr::onPutResponse(bool success, const LLSD& content)
}
}
static LLTrace::TimeBlock FTM_MATERIALS_IDLE("Materials");
static LLTrace::BlockTimerStatHandle FTM_MATERIALS_IDLE("Materials");
void LLMaterialMgr::onIdle(void*)
{

4
indra/newview/llpersistentnotificationstorage.cpp
View File

@ -47,7 +47,7 @@ LLPersistentNotificationStorage::~LLPersistentNotificationStorage()
{
}
static LLTrace::TimeBlock FTM_SAVE_NOTIFICATIONS("Save Notifications");
static LLTrace::BlockTimerStatHandle FTM_SAVE_NOTIFICATIONS("Save Notifications");
void LLPersistentNotificationStorage::saveNotifications()
{
@ -82,7 +82,7 @@ void LLPersistentNotificationStorage::saveNotifications()
writeNotifications(output);
}
static LLTrace::TimeBlock FTM_LOAD_NOTIFICATIONS("Load Notifications");
static LLTrace::BlockTimerStatHandle FTM_LOAD_NOTIFICATIONS("Load Notifications");
void LLPersistentNotificationStorage::loadNotifications()
{

4
indra/newview/llscenemonitor.cpp
View File

@ -331,8 +331,8 @@ bool LLSceneMonitor::needsUpdate() const
return mDiffState == NEED_DIFF;
}
static LLTrace::TimeBlock FTM_GENERATE_SCENE_LOAD_DITHER_TEXTURE("Generate Scene Load Dither Texture");
static LLTrace::TimeBlock FTM_SCENE_LOAD_IMAGE_DIFF("Scene Load Image Diff");
static LLTrace::BlockTimerStatHandle FTM_GENERATE_SCENE_LOAD_DITHER_TEXTURE("Generate Scene Load Dither Texture");
static LLTrace::BlockTimerStatHandle FTM_SCENE_LOAD_IMAGE_DIFF("Scene Load Image Diff");
static LLStaticHashedString sDitherScale("dither_scale");
static LLStaticHashedString sDitherScaleS("dither_scale_s");

2
indra/newview/llscreenchannel.cpp
View File

@ -49,7 +49,7 @@ using namespace LLNotificationsUI;
bool LLScreenChannel::mWasStartUpToastShown = false;
LLTrace::TimeBlock FTM_GET_CHANNEL_RECT("Calculate Notification Channel Region");
LLTrace::BlockTimerStatHandle FTM_GET_CHANNEL_RECT("Calculate Notification Channel Region");
LLRect LLScreenChannelBase::getChannelRect()
{
LL_RECORD_BLOCK_TIME(FTM_GET_CHANNEL_RECT);

12
indra/newview/llspatialpartition.cpp
View File

@ -53,8 +53,8 @@
#include "lltextureatlas.h"
#include "llviewershadermgr.h"
static LLTrace::TimeBlock FTM_FRUSTUM_CULL("Frustum Culling");
static LLTrace::TimeBlock FTM_CULL_REBOUND("Cull Rebound Partition");
static LLTrace::BlockTimerStatHandle FTM_FRUSTUM_CULL("Frustum Culling");
static LLTrace::BlockTimerStatHandle FTM_CULL_REBOUND("Cull Rebound Partition");
extern bool gShiftFrame;
@ -409,10 +409,10 @@ void LLSpatialGroup::rebuildMesh()
}
}
static LLTrace::TimeBlock FTM_REBUILD_VBO("VBO Rebuilt");
static LLTrace::TimeBlock FTM_ADD_GEOMETRY_COUNT("Add Geometry");
static LLTrace::TimeBlock FTM_CREATE_VB("Create VB");
static LLTrace::TimeBlock FTM_GET_GEOMETRY("Get Geometry");
static LLTrace::BlockTimerStatHandle FTM_REBUILD_VBO("VBO Rebuilt");
static LLTrace::BlockTimerStatHandle FTM_ADD_GEOMETRY_COUNT("Add Geometry");
static LLTrace::BlockTimerStatHandle FTM_CREATE_VB("Create VB");
static LLTrace::BlockTimerStatHandle FTM_GET_GEOMETRY("Get Geometry");
void LLSpatialPartition::rebuildGeom(LLSpatialGroup* group)
{

32
indra/newview/llviewerdisplay.cpp
View File

@ -180,7 +180,7 @@ void display_startup()
glClear(GL_DEPTH_BUFFER_BIT);
}
static LLTrace::TimeBlock FTM_UPDATE_CAMERA("Update Camera");
static LLTrace::BlockTimerStatHandle FTM_UPDATE_CAMERA("Update Camera");
void display_update_camera()
{
@ -228,20 +228,20 @@ void display_stats()
}
}
static LLTrace::TimeBlock FTM_PICK("Picking");
static LLTrace::TimeBlock FTM_RENDER("Render");
static LLTrace::TimeBlock FTM_UPDATE_SKY("Update Sky");
static LLTrace::TimeBlock FTM_UPDATE_TEXTURES("Update Textures");
static LLTrace::TimeBlock FTM_IMAGE_UPDATE("Update Images");
static LLTrace::TimeBlock FTM_IMAGE_UPDATE_CLASS("Class");
static LLTrace::TimeBlock FTM_IMAGE_UPDATE_BUMP("Image Update Bump");
static LLTrace::TimeBlock FTM_IMAGE_UPDATE_LIST("List");
static LLTrace::TimeBlock FTM_IMAGE_UPDATE_DELETE("Delete");
static LLTrace::TimeBlock FTM_RESIZE_WINDOW("Resize Window");
static LLTrace::TimeBlock FTM_HUD_UPDATE("HUD Update");
static LLTrace::TimeBlock FTM_DISPLAY_UPDATE_GEOM("Update Geom");
static LLTrace::TimeBlock FTM_TEXTURE_UNBIND("Texture Unbind");
static LLTrace::TimeBlock FTM_TELEPORT_DISPLAY("Teleport Display");
static LLTrace::BlockTimerStatHandle FTM_PICK("Picking");
static LLTrace::BlockTimerStatHandle FTM_RENDER("Render");
static LLTrace::BlockTimerStatHandle FTM_UPDATE_SKY("Update Sky");
static LLTrace::BlockTimerStatHandle FTM_UPDATE_TEXTURES("Update Textures");
static LLTrace::BlockTimerStatHandle FTM_IMAGE_UPDATE("Update Images");
static LLTrace::BlockTimerStatHandle FTM_IMAGE_UPDATE_CLASS("Class");
static LLTrace::BlockTimerStatHandle FTM_IMAGE_UPDATE_BUMP("Image Update Bump");
static LLTrace::BlockTimerStatHandle FTM_IMAGE_UPDATE_LIST("List");
static LLTrace::BlockTimerStatHandle FTM_IMAGE_UPDATE_DELETE("Delete");
static LLTrace::BlockTimerStatHandle FTM_RESIZE_WINDOW("Resize Window");
static LLTrace::BlockTimerStatHandle FTM_HUD_UPDATE("HUD Update");
static LLTrace::BlockTimerStatHandle FTM_DISPLAY_UPDATE_GEOM("Update Geom");
static LLTrace::BlockTimerStatHandle FTM_TEXTURE_UNBIND("Texture Unbind");
static LLTrace::BlockTimerStatHandle FTM_TELEPORT_DISPLAY("Teleport Display");
// Paint the display!
void display(BOOL rebuild, F32 zoom_factor, int subfield, BOOL for_snapshot)
@ -1331,7 +1331,7 @@ void render_ui(F32 zoom_factor, int subfield)
}
}
static LLTrace::TimeBlock FTM_SWAP("Swap");
static LLTrace::BlockTimerStatHandle FTM_SWAP("Swap");
void swap()
{

2
indra/newview/llviewerfloaterreg.cpp
View File

@ -172,7 +172,7 @@ void LLViewerFloaterReg::registerFloaters()
// *NOTE: Please keep these alphabetized for easier merges
LLFloaterAboutUtil::registerFloater();
LLFloaterReg::add("fast_timers", "floater_fast_timers.xml", (LLFloaterBuildFunc)&LLFloaterReg::build<LLFastTimerView>);
LLFloaterReg::add("block_timers", "floater_fast_timers.xml", (LLFloaterBuildFunc)&LLFloaterReg::build<LLFastTimerView>);
LLFloaterReg::add("about_land", "floater_about_land.xml", (LLFloaterBuildFunc)&LLFloaterReg::build<LLFloaterLand>);
LLFloaterReg::add("appearance", "floater_my_appearance.xml", (LLFloaterBuildFunc)&LLFloaterReg::build<LLFloaterSidePanelContainer>);
LLFloaterReg::add("auction", "floater_auction.xml", (LLFloaterBuildFunc)&LLFloaterReg::build<LLFloaterAuction>);

2
indra/newview/llviewerjointmesh.cpp
View File

@ -376,7 +376,7 @@ void LLViewerJointMesh::updateFaceSizes(U32 &num_vertices, U32& num_indices, F32
//-----------------------------------------------------------------------------
// updateFaceData()
//-----------------------------------------------------------------------------
static LLTrace::TimeBlock FTM_AVATAR_FACE("Avatar Face");
static LLTrace::BlockTimerStatHandle FTM_AVATAR_FACE("Avatar Face");
void LLViewerJointMesh::updateFaceData(LLFace *face, F32 pixel_area, BOOL damp_wind, bool terse_update)
{

20
indra/newview/llviewermedia.cpp
View File

@ -776,12 +776,12 @@ static bool proximity_comparitor(const LLViewerMediaImpl* i1, const LLViewerMedi
}
}
static LLTrace::TimeBlock FTM_MEDIA_UPDATE("Update Media");
static LLTrace::TimeBlock FTM_MEDIA_SPARE_IDLE("Spare Idle");
static LLTrace::TimeBlock FTM_MEDIA_UPDATE_INTEREST("Update/Interest");
static LLTrace::TimeBlock FTM_MEDIA_SORT("Sort");
static LLTrace::TimeBlock FTM_MEDIA_SORT2("Sort 2");
static LLTrace::TimeBlock FTM_MEDIA_MISC("Misc");
static LLTrace::BlockTimerStatHandle FTM_MEDIA_UPDATE("Update Media");
static LLTrace::BlockTimerStatHandle FTM_MEDIA_SPARE_IDLE("Spare Idle");
static LLTrace::BlockTimerStatHandle FTM_MEDIA_UPDATE_INTEREST("Update/Interest");
static LLTrace::BlockTimerStatHandle FTM_MEDIA_SORT("Sort");
static LLTrace::BlockTimerStatHandle FTM_MEDIA_SORT2("Sort 2");
static LLTrace::BlockTimerStatHandle FTM_MEDIA_MISC("Misc");
//////////////////////////////////////////////////////////////////////////////////////////
@ -2746,9 +2746,9 @@ bool LLViewerMediaImpl::canNavigateBack()
}
//////////////////////////////////////////////////////////////////////////////////////////
static LLTrace::TimeBlock FTM_MEDIA_DO_UPDATE("Do Update");
static LLTrace::TimeBlock FTM_MEDIA_GET_DATA("Get Data");
static LLTrace::TimeBlock FTM_MEDIA_SET_SUBIMAGE("Set Subimage");
static LLTrace::BlockTimerStatHandle FTM_MEDIA_DO_UPDATE("Do Update");
static LLTrace::BlockTimerStatHandle FTM_MEDIA_GET_DATA("Get Data");
static LLTrace::BlockTimerStatHandle FTM_MEDIA_SET_SUBIMAGE("Set Subimage");
void LLViewerMediaImpl::update()
@ -3435,7 +3435,7 @@ BOOL LLViewerMediaImpl::isUpdated()
return mIsUpdated ;
}
static LLTrace::TimeBlock FTM_MEDIA_CALCULATE_INTEREST("Calculate Interest");
static LLTrace::BlockTimerStatHandle FTM_MEDIA_CALCULATE_INTEREST("Calculate Interest");
void LLViewerMediaImpl::calculateInterest()
{

6
indra/newview/llviewermenu.cpp
View File

@ -524,7 +524,7 @@ class LLAdvancedToggleConsole : public view_listener_t
}
else if ("fast timers" == console_type)
{
LLFloaterReg::toggleInstance("fast_timers");
LLFloaterReg::toggleInstance("block_timers");
}
else if ("scene view" == console_type)
{
@ -550,7 +550,7 @@ class LLAdvancedCheckConsole : public view_listener_t
}
else if ("fast timers" == console_type)
{
new_value = LLFloaterReg::instanceVisible("fast_timers");
new_value = LLFloaterReg::instanceVisible("block_timers");
}
else if ("scene view" == console_type)
{
@ -7491,7 +7491,7 @@ void handle_dump_avatar_local_textures(void*)
void handle_dump_timers()
{
LLTrace::TimeBlock::dumpCurTimes();
LLTrace::BlockTimerStatHandle::dumpCurTimes();
}
void handle_debug_avatar_textures(void*)

4
indra/newview/llviewermessage.cpp
View File

@ -4245,7 +4245,7 @@ const F32 THRESHOLD_HEAD_ROT_QDOT = 0.9997f; // ~= 2.5 degrees -- if its less th
const F32 MAX_HEAD_ROT_QDOT = 0.99999f; // ~= 0.5 degrees -- if its greater than this then no need to update head_rot
// between these values we delay the updates (but no more than one second)
static LLTrace::TimeBlock FTM_AGENT_UPDATE_SEND("Send Message");
static LLTrace::BlockTimerStatHandle FTM_AGENT_UPDATE_SEND("Send Message");
void send_agent_update(BOOL force_send, BOOL send_reliable)
{
@ -4560,7 +4560,7 @@ void process_terse_object_update_improved(LLMessageSystem *mesgsys, void **user_
gObjectList.processCompressedObjectUpdate(mesgsys, user_data, OUT_TERSE_IMPROVED);
}
static LLTrace::TimeBlock FTM_PROCESS_OBJECTS("Process Kill Objects");
static LLTrace::BlockTimerStatHandle FTM_PROCESS_OBJECTS("Process Kill Objects");
void process_kill_object(LLMessageSystem *mesgsys, void **user_data)
{

4
indra/newview/llviewerobject.cpp
View File

@ -132,7 +132,7 @@ std::map<std::string, U32> LLViewerObject::sObjectDataMap;
const F32 PHYSICS_TIMESTEP = 1.f / 45.f;
static LLTrace::TimeBlock FTM_CREATE_OBJECT("Create Object");
static LLTrace::BlockTimerStatHandle FTM_CREATE_OBJECT("Create Object");
// static
LLViewerObject *LLViewerObject::createObject(const LLUUID &id, const LLPCode pcode, LLViewerRegion *regionp)
@ -2409,7 +2409,7 @@ void LLViewerObject::loadFlags(U32 flags)
void LLViewerObject::idleUpdate(LLAgent &agent, LLWorld &world, const F64 &time)
{
//static LLTrace::TimeBlock ftm("Viewer Object");
//static LLTrace::BlockTimerStatHandle ftm("Viewer Object");
//LL_RECORD_BLOCK_TIME(ftm);
if (!mDead)

12
indra/newview/llviewerobjectlist.cpp
View File

@ -289,7 +289,7 @@ void LLViewerObjectList::processUpdateCore(LLViewerObject* objectp,
}
}
static LLTrace::TimeBlock FTM_PROCESS_OBJECTS("Process Objects");
static LLTrace::BlockTimerStatHandle FTM_PROCESS_OBJECTS("Process Objects");
LLViewerObject* LLViewerObjectList::processObjectUpdateFromCache(LLVOCacheEntry* entry, LLViewerRegion* regionp)
{
@ -978,7 +978,7 @@ private:
LLSD mObjectIDs;
};
static LLTrace::TimeBlock FTM_IDLE_COPY("Idle Copy");
static LLTrace::BlockTimerStatHandle FTM_IDLE_COPY("Idle Copy");
void LLViewerObjectList::update(LLAgent &agent, LLWorld &world)
{
@ -1328,7 +1328,7 @@ void LLViewerObjectList::cleanupReferences(LLViewerObject *objectp)
mNumDeadObjects++;
}
static LLTrace::TimeBlock FTM_REMOVE_DRAWABLE("Remove Drawable");
static LLTrace::BlockTimerStatHandle FTM_REMOVE_DRAWABLE("Remove Drawable");
void LLViewerObjectList::removeDrawable(LLDrawable* drawablep)
{
@ -1617,9 +1617,9 @@ void LLViewerObjectList::onPhysicsFlagsFetchFailure(const LLUUID& object_id)
mPendingPhysicsFlags.erase(object_id);
}
static LLTrace::TimeBlock FTM_SHIFT_OBJECTS("Shift Objects");
static LLTrace::TimeBlock FTM_PIPELINE_SHIFT("Pipeline Shift");
static LLTrace::TimeBlock FTM_REGION_SHIFT("Region Shift");
static LLTrace::BlockTimerStatHandle FTM_SHIFT_OBJECTS("Shift Objects");
static LLTrace::BlockTimerStatHandle FTM_PIPELINE_SHIFT("Pipeline Shift");
static LLTrace::BlockTimerStatHandle FTM_REGION_SHIFT("Region Shift");
void LLViewerObjectList::shiftObjects(const LLVector3 &offset)
{

24
indra/newview/llvieweroctree.cpp
View File

@ -1020,8 +1020,8 @@ void LLOcclusionCullingGroup::clearOcclusionState(U32 state, S32 mode)
}
}
static LLTrace::TimeBlock FTM_OCCLUSION_READBACK("Readback Occlusion");
static LLTrace::TimeBlock FTM_OCCLUSION_WAIT("Occlusion Wait");
static LLTrace::BlockTimerStatHandle FTM_OCCLUSION_READBACK("Readback Occlusion");
static LLTrace::BlockTimerStatHandle FTM_OCCLUSION_WAIT("Occlusion Wait");
BOOL LLOcclusionCullingGroup::earlyFail(LLCamera* camera, const LLVector4a* bounds)
{
@ -1158,16 +1158,16 @@ void LLOcclusionCullingGroup::checkOcclusion()
}
}
static LLTrace::TimeBlock FTM_PUSH_OCCLUSION_VERTS("Push Occlusion");
static LLTrace::TimeBlock FTM_SET_OCCLUSION_STATE("Occlusion State");
static LLTrace::TimeBlock FTM_OCCLUSION_EARLY_FAIL("Occlusion Early Fail");
static LLTrace::TimeBlock FTM_OCCLUSION_ALLOCATE("Allocate");
static LLTrace::TimeBlock FTM_OCCLUSION_BUILD("Build");
static LLTrace::TimeBlock FTM_OCCLUSION_BEGIN_QUERY("Begin Query");
static LLTrace::TimeBlock FTM_OCCLUSION_END_QUERY("End Query");
static LLTrace::TimeBlock FTM_OCCLUSION_SET_BUFFER("Set Buffer");
static LLTrace::TimeBlock FTM_OCCLUSION_DRAW_WATER("Draw Water");
static LLTrace::TimeBlock FTM_OCCLUSION_DRAW("Draw");
static LLTrace::BlockTimerStatHandle FTM_PUSH_OCCLUSION_VERTS("Push Occlusion");
static LLTrace::BlockTimerStatHandle FTM_SET_OCCLUSION_STATE("Occlusion State");
static LLTrace::BlockTimerStatHandle FTM_OCCLUSION_EARLY_FAIL("Occlusion Early Fail");
static LLTrace::BlockTimerStatHandle FTM_OCCLUSION_ALLOCATE("Allocate");
static LLTrace::BlockTimerStatHandle FTM_OCCLUSION_BUILD("Build");
static LLTrace::BlockTimerStatHandle FTM_OCCLUSION_BEGIN_QUERY("Begin Query");
static LLTrace::BlockTimerStatHandle FTM_OCCLUSION_END_QUERY("End Query");
static LLTrace::BlockTimerStatHandle FTM_OCCLUSION_SET_BUFFER("Set Buffer");
static LLTrace::BlockTimerStatHandle FTM_OCCLUSION_DRAW_WATER("Draw Water");
static LLTrace::BlockTimerStatHandle FTM_OCCLUSION_DRAW("Draw");
void LLOcclusionCullingGroup::doOcclusion(LLCamera* camera, const LLVector4a* shift)
{

2
indra/newview/llviewerpartsim.cpp
View File

@ -657,7 +657,7 @@ void LLViewerPartSim::shift(const LLVector3 &offset)
}
}
static LLTrace::TimeBlock FTM_SIMULATE_PARTICLES("Simulate Particles");
static LLTrace::BlockTimerStatHandle FTM_SIMULATE_PARTICLES("Simulate Particles");
void LLViewerPartSim::updateSimulation()
{

2
indra/newview/llviewerprecompiledheaders.cpp
View File

@ -26,7 +26,7 @@
// source file that includes just the standard includes
// newview.pch will be the pre-compiled header
// llviewerprecompiledheaders.obj will contain the pre-compllviewiled type information
// llviewerprecompiledheaders.obj will contain the pre-compiled type information
#include "llviewerprecompiledheaders.h"

6
indra/newview/llviewertexture.cpp
View File

@ -455,7 +455,7 @@ const S32 min_non_tex_system_mem = (128<<20); // 128 MB
F32 texmem_lower_bound_scale = 0.85f;
F32 texmem_middle_bound_scale = 0.925f;
static LLTrace::TimeBlock FTM_TEXTURE_MEMORY_CHECK("Memory Check");
static LLTrace::BlockTimerStatHandle FTM_TEXTURE_MEMORY_CHECK("Memory Check");
//static
bool LLViewerTexture::isMemoryForTextureLow()
@ -510,8 +510,8 @@ bool LLViewerTexture::isMemoryForTextureLow()
return low_mem;
}
static LLTrace::TimeBlock FTM_TEXTURE_UPDATE_MEDIA("Media");
static LLTrace::TimeBlock FTM_TEXTURE_UPDATE_TEST("Test");
static LLTrace::BlockTimerStatHandle FTM_TEXTURE_UPDATE_MEDIA("Media");
static LLTrace::BlockTimerStatHandle FTM_TEXTURE_UPDATE_TEST("Test");
//static
void LLViewerTexture::updateClass(const F32 velocity, const F32 angular_velocity)

18
indra/newview/llviewertexturelist.cpp
View File

@ -68,7 +68,7 @@ void (*LLViewerTextureList::sUUIDCallback)(void **, const LLUUID&) = NULL;
S32 LLViewerTextureList::sNumImages = 0;
LLViewerTextureList gTextureList;
static LLTrace::TimeBlock FTM_PROCESS_IMAGES("Process Images");
static LLTrace::BlockTimerStatHandle FTM_PROCESS_IMAGES("Process Images");
///////////////////////////////////////////////////////////////////////////////
@ -662,14 +662,14 @@ void LLViewerTextureList::dirtyImage(LLViewerFetchedTexture *image)
}
////////////////////////////////////////////////////////////////////////////
static LLTrace::TimeBlock FTM_IMAGE_MARK_DIRTY("Dirty Images");
static LLTrace::TimeBlock FTM_IMAGE_UPDATE_PRIORITIES("Prioritize");
static LLTrace::TimeBlock FTM_IMAGE_CALLBACKS("Callbacks");
static LLTrace::TimeBlock FTM_IMAGE_FETCH("Fetch");
static LLTrace::TimeBlock FTM_FAST_CACHE_IMAGE_FETCH("Fast Cache Fetch");
static LLTrace::TimeBlock FTM_IMAGE_CREATE("Create");
static LLTrace::TimeBlock FTM_IMAGE_STATS("Stats");
static LLTrace::TimeBlock FTM_UPDATE_IMAGES("Update Images");
static LLTrace::BlockTimerStatHandle FTM_IMAGE_MARK_DIRTY("Dirty Images");
static LLTrace::BlockTimerStatHandle FTM_IMAGE_UPDATE_PRIORITIES("Prioritize");
static LLTrace::BlockTimerStatHandle FTM_IMAGE_CALLBACKS("Callbacks");
static LLTrace::BlockTimerStatHandle FTM_IMAGE_FETCH("Fetch");
static LLTrace::BlockTimerStatHandle FTM_FAST_CACHE_IMAGE_FETCH("Fast Cache Fetch");
static LLTrace::BlockTimerStatHandle FTM_IMAGE_CREATE("Create");
static LLTrace::BlockTimerStatHandle FTM_IMAGE_STATS("Stats");
static LLTrace::BlockTimerStatHandle FTM_UPDATE_IMAGES("Update Images");
void LLViewerTextureList::updateImages(F32 max_time)
{

8
indra/newview/llviewerwindow.cpp
View File

@ -288,7 +288,7 @@ public:
// LLDebugText
//
static LLTrace::TimeBlock FTM_DISPLAY_DEBUG_TEXT("Display Debug Text");
static LLTrace::BlockTimerStatHandle FTM_DISPLAY_DEBUG_TEXT("Display Debug Text");
class LLDebugText
{
@ -2839,7 +2839,7 @@ void append_xui_tooltip(LLView* viewp, LLToolTip::Params& params)
}
}
static LLTrace::TimeBlock ftm("Update UI");
static LLTrace::BlockTimerStatHandle ftm("Update UI");
// Update UI based on stored mouse position from mouse-move
// event processing.
@ -3417,7 +3417,7 @@ void LLViewerWindow::updateKeyboardFocus()
}
}
static LLTrace::TimeBlock FTM_UPDATE_WORLD_VIEW("Update World View");
static LLTrace::BlockTimerStatHandle FTM_UPDATE_WORLD_VIEW("Update World View");
void LLViewerWindow::updateWorldViewRect(bool use_full_window)
{
LL_RECORD_BLOCK_TIME(FTM_UPDATE_WORLD_VIEW);
@ -4914,7 +4914,7 @@ void LLViewerWindow::requestResolutionUpdate()
mResDirty = true;
}
static LLTrace::TimeBlock FTM_WINDOW_CHECK_SETTINGS("Window Settings");
static LLTrace::BlockTimerStatHandle FTM_WINDOW_CHECK_SETTINGS("Window Settings");
void LLViewerWindow::checkSettings()
{

8
indra/newview/llvoavatar.cpp
View File

@ -1929,8 +1929,8 @@ S32 LLVOAvatar::setTETexture(const U8 te, const LLUUID& uuid)
return setTETextureCore(te, image);
}
static LLTrace::TimeBlock FTM_AVATAR_UPDATE("Avatar Update");
static LLTrace::TimeBlock FTM_JOINT_UPDATE("Update Joints");
static LLTrace::BlockTimerStatHandle FTM_AVATAR_UPDATE("Avatar Update");
static LLTrace::BlockTimerStatHandle FTM_JOINT_UPDATE("Update Joints");
//------------------------------------------------------------------------
// LLVOAvatar::dumpAnimationState()
@ -2169,7 +2169,7 @@ void LLVOAvatar::idleUpdateVoiceVisualizer(bool voice_enabled)
}//if ( voiceEnabled )
}
static LLTrace::TimeBlock FTM_ATTACHMENT_UPDATE("Update Attachments");
static LLTrace::BlockTimerStatHandle FTM_ATTACHMENT_UPDATE("Update Attachments");
void LLVOAvatar::idleUpdateMisc(bool detailed_update)
{
@ -5426,7 +5426,7 @@ void LLVOAvatar::updateGL()
//-----------------------------------------------------------------------------
// updateGeometry()
//-----------------------------------------------------------------------------
static LLTrace::TimeBlock FTM_UPDATE_AVATAR("Update Avatar");
static LLTrace::BlockTimerStatHandle FTM_UPDATE_AVATAR("Update Avatar");
BOOL LLVOAvatar::updateGeometry(LLDrawable *drawable)
{
LL_RECORD_BLOCK_TIME(FTM_UPDATE_AVATAR);

4
indra/newview/llvograss.cpp
View File

@ -412,7 +412,7 @@ LLDrawable* LLVOGrass::createDrawable(LLPipeline *pipeline)
return mDrawable;
}
static LLTrace::TimeBlock FTM_UPDATE_GRASS("Update Grass");
static LLTrace::BlockTimerStatHandle FTM_UPDATE_GRASS("Update Grass");
BOOL LLVOGrass::updateGeometry(LLDrawable *drawable)
{
@ -671,7 +671,7 @@ void LLGrassPartition::addGeometryCount(LLSpatialGroup* group, U32& vertex_count
}
}
static LLTrace::TimeBlock FTM_REBUILD_GRASS_VB("Grass VB");
static LLTrace::BlockTimerStatHandle FTM_REBUILD_GRASS_VB("Grass VB");
void LLGrassPartition::getGeometry(LLSpatialGroup* group)
{

2
indra/newview/llvoicevivox.cpp
View File

@ -6314,7 +6314,7 @@ LLVivoxProtocolParser::~LLVivoxProtocolParser()
XML_ParserFree(parser);
}
static LLTrace::TimeBlock FTM_VIVOX_PROCESS("Vivox Process");
static LLTrace::BlockTimerStatHandle FTM_VIVOX_PROCESS("Vivox Process");
// virtual
LLIOPipe::EStatus LLVivoxProtocolParser::process_impl(

6
indra/newview/llvopartgroup.cpp
View File

@ -292,7 +292,7 @@ LLVector3 LLVOPartGroup::getCameraPosition() const
return gAgentCamera.getCameraPositionAgent();
}
static LLTrace::TimeBlock FTM_UPDATE_PARTICLES("Update Particles");
static LLTrace::BlockTimerStatHandle FTM_UPDATE_PARTICLES("Update Particles");
BOOL LLVOPartGroup::updateGeometry(LLDrawable *drawable)
{
LL_RECORD_BLOCK_TIME(FTM_UPDATE_PARTICLES);
@ -739,7 +739,7 @@ LLHUDParticlePartition::LLHUDParticlePartition(LLViewerRegion* regionp) :
mPartitionType = LLViewerRegion::PARTITION_HUD_PARTICLE;
}
static LLTrace::TimeBlock FTM_REBUILD_PARTICLE_VBO("Particle VBO");
static LLTrace::BlockTimerStatHandle FTM_REBUILD_PARTICLE_VBO("Particle VBO");
void LLParticlePartition::rebuildGeom(LLSpatialGroup* group)
{
@ -828,7 +828,7 @@ void LLParticlePartition::addGeometryCount(LLSpatialGroup* group, U32& vertex_co
}
static LLTrace::TimeBlock FTM_REBUILD_PARTICLE_GEOM("Particle Geom");
static LLTrace::BlockTimerStatHandle FTM_REBUILD_PARTICLE_GEOM("Particle Geom");
void LLParticlePartition::getGeometry(LLSpatialGroup* group)
{

4
indra/newview/llvosky.cpp
View File

@ -1243,7 +1243,7 @@ void LLVOSky::createDummyVertexBuffer()
}
}
static LLTrace::TimeBlock FTM_RENDER_FAKE_VBO_UPDATE("Fake VBO Update");
static LLTrace::BlockTimerStatHandle FTM_RENDER_FAKE_VBO_UPDATE("Fake VBO Update");
void LLVOSky::updateDummyVertexBuffer()
{
@ -1269,7 +1269,7 @@ void LLVOSky::updateDummyVertexBuffer()
//----------------------------------
//end of fake vertex buffer updating
//----------------------------------
static LLTrace::TimeBlock FTM_GEO_SKY("Sky Geometry");
static LLTrace::BlockTimerStatHandle FTM_GEO_SKY("Sky Geometry");
BOOL LLVOSky::updateGeometry(LLDrawable *drawable)
{

4
indra/newview/llvosurfacepatch.cpp
View File

@ -212,7 +212,7 @@ LLDrawable *LLVOSurfacePatch::createDrawable(LLPipeline *pipeline)
return mDrawable;
}
static LLTrace::TimeBlock FTM_UPDATE_TERRAIN("Update Terrain");
static LLTrace::BlockTimerStatHandle FTM_UPDATE_TERRAIN("Update Terrain");
void LLVOSurfacePatch::updateGL()
{
@ -1070,7 +1070,7 @@ LLVertexBuffer* LLTerrainPartition::createVertexBuffer(U32 type_mask, U32 usage)
return new LLVertexBufferTerrain();
}
static LLTrace::TimeBlock FTM_REBUILD_TERRAIN_VB("Terrain VB");
static LLTrace::BlockTimerStatHandle FTM_REBUILD_TERRAIN_VB("Terrain VB");
void LLTerrainPartition::getGeometry(LLSpatialGroup* group)
{
LL_RECORD_BLOCK_TIME(FTM_REBUILD_TERRAIN_VB);

2
indra/newview/llvotree.cpp
View File

@ -479,7 +479,7 @@ LLDrawable* LLVOTree::createDrawable(LLPipeline *pipeline)
const S32 LEAF_INDICES = 24;
const S32 LEAF_VERTICES = 16;
static LLTrace::TimeBlock FTM_UPDATE_TREE("Update Tree");
static LLTrace::BlockTimerStatHandle FTM_UPDATE_TREE("Update Tree");
BOOL LLVOTree::updateGeometry(LLDrawable *drawable)
{

36
indra/newview/llvovolume.cpp
View File

@ -96,9 +96,9 @@ S32 LLVOVolume::mRenderComplexity_current = 0;
LLPointer<LLObjectMediaDataClient> LLVOVolume::sObjectMediaClient = NULL;
LLPointer<LLObjectMediaNavigateClient> LLVOVolume::sObjectMediaNavigateClient = NULL;
static LLTrace::TimeBlock FTM_GEN_TRIANGLES("Generate Triangles");
static LLTrace::TimeBlock FTM_GEN_VOLUME("Generate Volumes");
static LLTrace::TimeBlock FTM_VOLUME_TEXTURES("Volume Textures");
static LLTrace::BlockTimerStatHandle FTM_GEN_TRIANGLES("Generate Triangles");
static LLTrace::BlockTimerStatHandle FTM_GEN_VOLUME("Generate Volumes");
static LLTrace::BlockTimerStatHandle FTM_VOLUME_TEXTURES("Volume Textures");
extern BOOL gGLDebugLoggingEnabled;
@ -1630,9 +1630,9 @@ void LLVOVolume::updateRelativeXform(bool force_identity)
}
}
static LLTrace::TimeBlock FTM_GEN_FLEX("Generate Flexies");
static LLTrace::TimeBlock FTM_UPDATE_PRIMITIVES("Update Primitives");
static LLTrace::TimeBlock FTM_UPDATE_RIGGED_VOLUME("Update Rigged");
static LLTrace::BlockTimerStatHandle FTM_GEN_FLEX("Generate Flexies");
static LLTrace::BlockTimerStatHandle FTM_UPDATE_PRIMITIVES("Update Primitives");
static LLTrace::BlockTimerStatHandle FTM_UPDATE_RIGGED_VOLUME("Update Rigged");
BOOL LLVOVolume::updateGeometry(LLDrawable *drawable)
{
@ -3917,8 +3917,8 @@ void LLVOVolume::updateRiggedVolume()
}
static LLTrace::TimeBlock FTM_SKIN_RIGGED("Skin");
static LLTrace::TimeBlock FTM_RIGGED_OCTREE("Octree");
static LLTrace::BlockTimerStatHandle FTM_SKIN_RIGGED("Skin");
static LLTrace::BlockTimerStatHandle FTM_RIGGED_OCTREE("Octree");
void LLRiggedVolume::update(const LLMeshSkinInfo* skin, LLVOAvatar* avatar, const LLVolume* volume)
{
@ -4115,7 +4115,7 @@ bool can_batch_texture(LLFace* facep)
return true;
}
static LLTrace::TimeBlock FTM_REGISTER_FACE("Register Face");
static LLTrace::BlockTimerStatHandle FTM_REGISTER_FACE("Register Face");
void LLVolumeGeometryManager::registerFace(LLSpatialGroup* group, LLFace* facep, U32 type)
{
@ -4346,9 +4346,9 @@ void LLVolumeGeometryManager::getGeometry(LLSpatialGroup* group)
}
static LLTrace::TimeBlock FTM_REBUILD_VOLUME_VB("Volume VB");
static LLTrace::TimeBlock FTM_REBUILD_VOLUME_FACE_LIST("Build Face List");
static LLTrace::TimeBlock FTM_REBUILD_VOLUME_GEN_DRAW_INFO("Gen Draw Info");
static LLTrace::BlockTimerStatHandle FTM_REBUILD_VOLUME_VB("Volume VB");
static LLTrace::BlockTimerStatHandle FTM_REBUILD_VOLUME_FACE_LIST("Build Face List");
static LLTrace::BlockTimerStatHandle FTM_REBUILD_VOLUME_GEN_DRAW_INFO("Gen Draw Info");
static LLDrawPoolAvatar* get_avatar_drawpool(LLViewerObject* vobj)
{
@ -5047,7 +5047,7 @@ void LLVolumeGeometryManager::rebuildGeom(LLSpatialGroup* group)
}
}
static LLFastTimer::DeclareTimer FTM_REBUILD_MESH_FLUSH("Flush Mesh");
static LLTrace::BlockTimerStatHandle FTM_REBUILD_MESH_FLUSH("Flush Mesh");
void LLVolumeGeometryManager::rebuildMesh(LLSpatialGroup* group)
{
@ -5195,11 +5195,11 @@ struct CompareBatchBreakerModified
}
};
static LLTrace::TimeBlock FTM_GEN_DRAW_INFO_SORT("Draw Info Face Sort");
static LLTrace::TimeBlock FTM_GEN_DRAW_INFO_FACE_SIZE("Face Sizing");
static LLTrace::TimeBlock FTM_GEN_DRAW_INFO_ALLOCATE("Allocate VB");
static LLTrace::TimeBlock FTM_GEN_DRAW_INFO_FIND_VB("Find VB");
static LLTrace::TimeBlock FTM_GEN_DRAW_INFO_RESIZE_VB("Resize VB");
static LLTrace::BlockTimerStatHandle FTM_GEN_DRAW_INFO_SORT("Draw Info Face Sort");
static LLTrace::BlockTimerStatHandle FTM_GEN_DRAW_INFO_FACE_SIZE("Face Sizing");
static LLTrace::BlockTimerStatHandle FTM_GEN_DRAW_INFO_ALLOCATE("Allocate VB");
static LLTrace::BlockTimerStatHandle FTM_GEN_DRAW_INFO_FIND_VB("Find VB");
static LLTrace::BlockTimerStatHandle FTM_GEN_DRAW_INFO_RESIZE_VB("Resize VB");

Some files were not shown because too many files have changed in this diff Show More