From 20b2fa4052ae6789ec8894f33f4764a1f7233b24 Mon Sep 17 00:00:00 2001
From: Richard Linden <none@none>
Date: Mon, 14 Jan 2013 23:08:01 -0800
Subject: [PATCH] SH-3406 WIP convert fast timers to lltrace system improved
performance of fast timer stat gathering
---
indra/llcommon/llfasttimer.cpp | 28 ++++++++++++------------
indra/llcommon/llfasttimer.h | 19 ++++++++--------
indra/llcommon/lltrace.h | 5 +++--
indra/llcommon/lltracerecording.cpp | 4 ++--
indra/llcommon/lltracethreadrecorder.cpp | 6 +++--
5 files changed, 33 insertions(+), 29 deletions(-)
diff --git a/indra/llcommon/llfasttimer.cpp b/indra/llcommon/llfasttimer.cpp
index e6233a094e8..37332da31c3 100644
--- a/indra/llcommon/llfasttimer.cpp
+++ b/indra/llcommon/llfasttimer.cpp
@@ -199,10 +199,11 @@ void TimeBlock::processTimes()
{
TimeBlockAccumulator* accumulator = timer.getPrimaryAccumulator();
- if (accumulator->mLastCaller)
+ if (accumulator->mLastAccumulator)
{
- timer.setParent(accumulator->mLastCaller);
- accumulator->mParent = accumulator->mLastCaller;
+ TimeBlock* parent = accumulator->mLastAccumulator->mBlock;
+ timer.setParent(parent);
+ accumulator->mParent = parent;
}
// no need to push up tree on first use, flag can be set spuriously
accumulator->mMoveUpTree = false;
@@ -250,23 +251,22 @@ void TimeBlock::processTimes()
// walk up stack of active timers and accumulate current time while leaving timing structures active
BlockTimer* cur_timer = stack_record->mActiveTimer;
- TimeBlockAccumulator* accumulator = stack_record->mTimeBlock->getPrimaryAccumulator();
+ TimeBlockAccumulator* accumulator = stack_record->mAccumulator;
// root defined by parent pointing to self
while(cur_timer && cur_timer->mLastTimerData.mActiveTimer != cur_timer)
{
U64 cumulative_time_delta = cur_time - cur_timer->mStartTime;
- U64 self_time_delta = cumulative_time_delta - stack_record->mChildTime;
+ accumulator->mChildTimeCounter += stack_record->mChildTime;
stack_record->mChildTime = 0;
- accumulator->mSelfTimeCounter += self_time_delta;
accumulator->mTotalTimeCounter += cumulative_time_delta;
cur_timer->mStartTime = cur_time;
stack_record = &cur_timer->mLastTimerData;
stack_record->mChildTime += cumulative_time_delta;
- if (stack_record->mTimeBlock)
+ if (stack_record->mAccumulator)
{
- accumulator = stack_record->mTimeBlock->getPrimaryAccumulator();
+ accumulator = stack_record->mAccumulator;
}
cur_timer = cur_timer->mLastTimerData.mActiveTimer;
@@ -282,7 +282,7 @@ void TimeBlock::processTimes()
TimeBlock& timer = *it;
TimeBlockAccumulator* accumulator = timer.getPrimaryAccumulator();
- accumulator->mLastCaller = NULL;
+ accumulator->mLastAccumulator = NULL;
accumulator->mMoveUpTree = false;
}
@@ -417,10 +417,10 @@ void TimeBlock::writeLog(std::ostream& os)
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
TimeBlockAccumulator::TimeBlockAccumulator()
-: mSelfTimeCounter(0),
+: mChildTimeCounter(0),
mTotalTimeCounter(0),
mCalls(0),
- mLastCaller(NULL),
+ mLastAccumulator(NULL),
mActiveCount(0),
mMoveUpTree(false),
mParent(NULL)
@@ -428,10 +428,10 @@ TimeBlockAccumulator::TimeBlockAccumulator()
void TimeBlockAccumulator::addSamples( const TimeBlockAccumulator& other )
{
- mSelfTimeCounter += other.mSelfTimeCounter;
+ mChildTimeCounter += other.mChildTimeCounter;
mTotalTimeCounter += other.mTotalTimeCounter;
mCalls += other.mCalls;
- mLastCaller = other.mLastCaller;
+ mLastAccumulator = other.mLastAccumulator;
mActiveCount = other.mActiveCount;
mMoveUpTree = other.mMoveUpTree;
mParent = other.mParent;
@@ -440,7 +440,7 @@ void TimeBlockAccumulator::addSamples( const TimeBlockAccumulator& other )
void TimeBlockAccumulator::reset( const TimeBlockAccumulator* other )
{
mTotalTimeCounter = 0;
- mSelfTimeCounter = 0;
+ mChildTimeCounter = 0;
mCalls = 0;
}
diff --git a/indra/llcommon/llfasttimer.h b/indra/llcommon/llfasttimer.h
index fb2868ff98d..2d876295617 100644
--- a/indra/llcommon/llfasttimer.h
+++ b/indra/llcommon/llfasttimer.h
@@ -40,9 +40,9 @@ namespace LLTrace
struct BlockTimerStackRecord
{
- class BlockTimer* mActiveTimer;
- class TimeBlock* mTimeBlock;
- U64 mChildTime;
+ class BlockTimer* mActiveTimer;
+ class TimeBlockAccumulator* mAccumulator;
+ U64 mChildTime;
};
class ThreadTimerStack
@@ -277,7 +277,7 @@ LL_FORCE_INLINE BlockTimer::BlockTimer(TimeBlock& timer)
mStartTime = TimeBlock::getCPUClockCount64();
BlockTimerStackRecord* cur_timer_data = ThreadTimerStack::getIfExists();
- TimeBlockAccumulator* accumulator = cur_timer_data->mTimeBlock->getPrimaryAccumulator();
+ TimeBlockAccumulator* accumulator = timer.getPrimaryAccumulator();
accumulator->mActiveCount++;
// keep current parent as long as it is active when we are
accumulator->mMoveUpTree |= (accumulator->mParent->getPrimaryAccumulator()->mActiveCount == 0);
@@ -286,7 +286,7 @@ LL_FORCE_INLINE BlockTimer::BlockTimer(TimeBlock& timer)
mLastTimerData = *cur_timer_data;
// push new information
cur_timer_data->mActiveTimer = this;
- cur_timer_data->mTimeBlock = &timer;
+ cur_timer_data->mAccumulator = accumulator;
cur_timer_data->mChildTime = 0;
#endif
}
@@ -296,21 +296,22 @@ LL_FORCE_INLINE BlockTimer::~BlockTimer()
#if FAST_TIMER_ON
U64 total_time = TimeBlock::getCPUClockCount64() - mStartTime;
BlockTimerStackRecord* cur_timer_data = ThreadTimerStack::getIfExists();
- TimeBlockAccumulator* accumulator = cur_timer_data->mTimeBlock->getPrimaryAccumulator();
+ TimeBlockAccumulator* accumulator = cur_timer_data->mAccumulator;
accumulator->mCalls++;
- accumulator->mSelfTimeCounter += total_time - cur_timer_data->mChildTime;
+ accumulator->mChildTimeCounter += cur_timer_data->mChildTime;
accumulator->mTotalTimeCounter += total_time;
accumulator->mActiveCount--;
// store last caller to bootstrap tree creation
// do this in the destructor in case of recursion to get topmost caller
- accumulator->mLastCaller = mLastTimerData.mTimeBlock;
+ accumulator->mLastAccumulator = mLastTimerData.mAccumulator;
// we are only tracking self time, so subtract our total time delta from parents
mLastTimerData.mChildTime += total_time;
- *ThreadTimerStack::getIfExists() = mLastTimerData;
+ //pop stack
+ *cur_timer_data = mLastTimerData;
#endif
}
diff --git a/indra/llcommon/lltrace.h b/indra/llcommon/lltrace.h
index ab4ad59e3d7..1d3c376a588 100644
--- a/indra/llcommon/lltrace.h
+++ b/indra/llcommon/lltrace.h
@@ -446,11 +446,12 @@ namespace LLTrace
//
// members
//
- U64 mSelfTimeCounter,
+ U64 mChildTimeCounter,
mTotalTimeCounter;
U32 mCalls;
+ class TimeBlock* mBlock; // block associated with this accumulator
class TimeBlock* mParent; // last acknowledged parent of this time block
- class TimeBlock* mLastCaller; // used to bootstrap tree construction
+ TimeBlockAccumulator* mLastAccumulator; // 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
diff --git a/indra/llcommon/lltracerecording.cpp b/indra/llcommon/lltracerecording.cpp
index c110e643803..ddd25bfe87d 100644
--- a/indra/llcommon/lltracerecording.cpp
+++ b/indra/llcommon/lltracerecording.cpp
@@ -179,7 +179,7 @@ LLUnit<LLUnits::Seconds, F64> Recording::getSum(const TraceType<TimeBlockAccumul
LLUnit<LLUnits::Seconds, F64> Recording::getSum(const TraceType<TimeBlockAccumulator::SelfTimeAspect>& stat) const
{
- return (F64)(*mStackTimers)[stat.getIndex()].mSelfTimeCounter / (F64)LLTrace::TimeBlock::countsPerSecond();
+ return ((F64)(*mStackTimers)[stat.getIndex()].mTotalTimeCounter - (F64)(*mStackTimers)[stat.getIndex()].mChildTimeCounter) / (F64)LLTrace::TimeBlock::countsPerSecond();
}
@@ -195,7 +195,7 @@ LLUnit<LLUnits::Seconds, F64> Recording::getPerSec(const TraceType<TimeBlockAccu
LLUnit<LLUnits::Seconds, F64> Recording::getPerSec(const TraceType<TimeBlockAccumulator::SelfTimeAspect>& stat) const
{
- return (F64)(*mStackTimers)[stat.getIndex()].mSelfTimeCounter / ((F64)LLTrace::TimeBlock::countsPerSecond() * mElapsedSeconds);
+ return ((F64)(*mStackTimers)[stat.getIndex()].mTotalTimeCounter - (F64)(*mStackTimers)[stat.getIndex()].mChildTimeCounter) / ((F64)LLTrace::TimeBlock::countsPerSecond() * mElapsedSeconds);
}
F32 Recording::getPerSec(const TraceType<TimeBlockAccumulator::CallCountAspect>& stat) const
diff --git a/indra/llcommon/lltracethreadrecorder.cpp b/indra/llcommon/lltracethreadrecorder.cpp
index 7b493a651ed..9375c7bea33 100644
--- a/indra/llcommon/lltracethreadrecorder.cpp
+++ b/indra/llcommon/lltracethreadrecorder.cpp
@@ -43,7 +43,7 @@ ThreadRecorder::ThreadRecorder()
TimeBlock& root_time_block = TimeBlock::getRootTimeBlock();
ThreadTimerStack* timer_stack = ThreadTimerStack::getInstance();
- timer_stack->mTimeBlock = &root_time_block;
+ timer_stack->mAccumulator = root_time_block.getPrimaryAccumulator();
timer_stack->mActiveTimer = NULL;
mNumTimeBlockTreeNodes = AccumulatorBuffer<TimeBlockAccumulator>::getDefaultBuffer()->size();
@@ -61,7 +61,9 @@ ThreadRecorder::ThreadRecorder()
tree_node.mBlock = &time_block;
tree_node.mParent = &root_time_block;
- it->getPrimaryAccumulator()->mParent = &root_time_block;
+ TimeBlockAccumulator* accumulator = it->getPrimaryAccumulator();
+ accumulator->mParent = &root_time_block;
+ accumulator->mBlock = time_block;
}
mRootTimer = new BlockTimer(root_time_block);
--
GitLab