From 43a92d01afdb4f1dd4003059b79f87e9687527a1 Mon Sep 17 00:00:00 2001
From: Richard Linden <none@none>
Date: Thu, 17 Jan 2013 20:11:43 -0800
Subject: SH-3406 WIP convert fast timers to lltrace system fixed some
 uninitialized variables root timer accumulator was being initialized to NULL

---
 indra/llcommon/llfasttimer.cpp           | 30 +++++++++++++++++-------------
 indra/llcommon/llfasttimer.h             | 11 ++++++-----
 indra/llcommon/lltracethreadrecorder.cpp |  6 ++++--
 3 files changed, 27 insertions(+), 20 deletions(-)

diff --git a/indra/llcommon/llfasttimer.cpp b/indra/llcommon/llfasttimer.cpp
index 37332da31c..b4a422816e 100644
--- a/indra/llcommon/llfasttimer.cpp
+++ b/indra/llcommon/llfasttimer.cpp
@@ -183,7 +183,6 @@ void TimeBlock::processTimes()
 {
 	get_clock_count(); // good place to calculate clock frequency
 	U64 cur_time = getCPUClockCount64();
-	BlockTimerStackRecord* stack_record = ThreadTimerStack::getInstance();
 
 	// set up initial tree
 	for (LLInstanceTracker<TimeBlock>::instance_iter it = LLInstanceTracker<TimeBlock>::beginInstances(), end_it = LLInstanceTracker<TimeBlock>::endInstances(); 
@@ -202,6 +201,7 @@ void TimeBlock::processTimes()
 			if (accumulator->mLastAccumulator)
 			{
 				TimeBlock* parent = accumulator->mLastAccumulator->mBlock;
+				llassert(parent);
 				timer.setParent(parent);
 				accumulator->mParent = parent;
 			}
@@ -250,26 +250,28 @@ 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->mAccumulator;
+	BlockTimerStackRecord* stack_record			= ThreadTimerStack::getInstance();
+	BlockTimer* cur_timer						= stack_record->mActiveTimer;
+	TimeBlockAccumulator* accumulator			= stack_record->mAccumulator;
+
+	llassert(accumulator);
+
 	// root defined by parent pointing to self
-	while(cur_timer && cur_timer->mLastTimerData.mActiveTimer != cur_timer)
+	while(cur_timer && cur_timer->mParentTimerData.mActiveTimer != cur_timer)
 	{
 		U64 cumulative_time_delta = cur_time - cur_timer->mStartTime;
+	
+		accumulator->mTotalTimeCounter += cumulative_time_delta;
 		accumulator->mChildTimeCounter += stack_record->mChildTime;
 		stack_record->mChildTime = 0;
-		accumulator->mTotalTimeCounter += cumulative_time_delta;
 
 		cur_timer->mStartTime = cur_time;
 
-		stack_record = &cur_timer->mLastTimerData;
-		stack_record->mChildTime += cumulative_time_delta;
-		if (stack_record->mAccumulator)
-		{
-			accumulator = stack_record->mAccumulator;
-		}
+		stack_record = &cur_timer->mParentTimerData;
+		accumulator = stack_record->mAccumulator;
+		cur_timer = stack_record->mActiveTimer;
 
-		cur_timer = cur_timer->mLastTimerData.mActiveTimer;
+		stack_record->mChildTime += cumulative_time_delta;
 	}
 
 
@@ -423,7 +425,8 @@ TimeBlockAccumulator::TimeBlockAccumulator()
 	mLastAccumulator(NULL),
 	mActiveCount(0),
 	mMoveUpTree(false),
-	mParent(NULL)
+	mParent(NULL),
+	mBlock(NULL)
 {}
 
 void TimeBlockAccumulator::addSamples( const TimeBlockAccumulator& other )
@@ -435,6 +438,7 @@ void TimeBlockAccumulator::addSamples( const TimeBlockAccumulator& other )
 	mActiveCount = other.mActiveCount;
 	mMoveUpTree = other.mMoveUpTree;
 	mParent = other.mParent;
+	mBlock = other.mBlock;
 }
 
 void TimeBlockAccumulator::reset( const TimeBlockAccumulator* other )
diff --git a/indra/llcommon/llfasttimer.h b/indra/llcommon/llfasttimer.h
index 2d87629561..06de8ea6ee 100644
--- a/indra/llcommon/llfasttimer.h
+++ b/indra/llcommon/llfasttimer.h
@@ -74,7 +74,7 @@ public:
 private:
 
 	U64				mStartTime;
-	BlockTimerStackRecord	mLastTimerData;
+	BlockTimerStackRecord	mParentTimerData;
 };
 
 // stores a "named" timer instance to be reused via multiple BlockTimer stack instances
@@ -280,10 +280,11 @@ LL_FORCE_INLINE BlockTimer::BlockTimer(TimeBlock& timer)
 	TimeBlockAccumulator* accumulator = timer.getPrimaryAccumulator();
 	accumulator->mActiveCount++;
 	// keep current parent as long as it is active when we are
+	llassert(accumulator->mParent);
 	accumulator->mMoveUpTree |= (accumulator->mParent->getPrimaryAccumulator()->mActiveCount == 0);
 
 	// store top of stack
-	mLastTimerData = *cur_timer_data;
+	mParentTimerData = *cur_timer_data;
 	// push new information
 	cur_timer_data->mActiveTimer = this;
 	cur_timer_data->mAccumulator = accumulator;
@@ -305,13 +306,13 @@ LL_FORCE_INLINE BlockTimer::~BlockTimer()
 
 	// store last caller to bootstrap tree creation
 	// do this in the destructor in case of recursion to get topmost caller
-	accumulator->mLastAccumulator = mLastTimerData.mAccumulator;
+	accumulator->mLastAccumulator = mParentTimerData.mAccumulator;
 
 	// we are only tracking self time, so subtract our total time delta from parents
-	mLastTimerData.mChildTime += total_time;
+	mParentTimerData.mChildTime += total_time;
 
 	//pop stack
-	*cur_timer_data = mLastTimerData;
+	*cur_timer_data = mParentTimerData;
 #endif
 }
 
diff --git a/indra/llcommon/lltracethreadrecorder.cpp b/indra/llcommon/lltracethreadrecorder.cpp
index bc1d19e72c..7c5995a104 100644
--- a/indra/llcommon/lltracethreadrecorder.cpp
+++ b/indra/llcommon/lltracethreadrecorder.cpp
@@ -43,14 +43,16 @@ ThreadRecorder::ThreadRecorder()
 	TimeBlock& root_time_block = TimeBlock::getRootTimeBlock();
 
 	ThreadTimerStack* timer_stack = ThreadTimerStack::getInstance();
-	timer_stack->mAccumulator = root_time_block.getPrimaryAccumulator();
-	timer_stack->mActiveTimer = NULL;
 
 	mNumTimeBlockTreeNodes = AccumulatorBuffer<TimeBlockAccumulator>::getDefaultBuffer()->size();
 	mTimeBlockTreeNodes = new TimeBlockTreeNode[mNumTimeBlockTreeNodes];
 
 	mThreadRecording.start();
 
+	timer_stack->mAccumulator = root_time_block.getPrimaryAccumulator();
+	timer_stack->mActiveTimer = NULL;
+
+
 	// initialize time block parent pointers
 	for (LLInstanceTracker<TimeBlock>::instance_iter it = LLInstanceTracker<TimeBlock>::beginInstances(), end_it = LLInstanceTracker<TimeBlock>::endInstances(); 
 		it != end_it; 
-- 
cgit v1.2.3