SH-3406 WIP convert fast timers to lltrace system

improved performance of fast timer stat gathering

5 files changed, 33 insertions, 29 deletions

diff --git a/indra/llcommon/llfasttimer.cpp b/indra/llcommon/llfasttimer.cpp
index e6233a094e..37332da31c 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 fb2868ff98..2d87629561 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 ab4ad59e3d..1d3c376a58 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 c110e64380..ddd25bfe87 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 7b493a651e..9375c7bea3 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);