Automated merge with http://bitbucket.org/lindenlab/viewer-interesting

10 files changed, 147 insertions, 68 deletions

diff --git a/indra/llcommon/CMakeLists.txt b/indra/llcommon/CMakeLists.txt
index e138a54d29..e2e2cb436d 100755
--- a/indra/llcommon/CMakeLists.txt
+++ b/indra/llcommon/CMakeLists.txt
@@ -34,7 +34,7 @@ set(llcommon_SOURCE_FILES
     llassettype.cpp
     llbase32.cpp
     llbase64.cpp
-	llbitpack.cpp
+    llbitpack.cpp
     llcommon.cpp
     llcommonutils.cpp
     llcoros.cpp
@@ -205,7 +205,7 @@ set(llcommon_HEADER_FILES
     llthreadsafequeue.h
     lltimer.h
     lltrace.h
-	lltraceaccumulators.h
+    lltraceaccumulators.h
     lltracerecording.h
     lltracethreadrecorder.h
     lltreeiterators.h
@@ -213,7 +213,7 @@ set(llcommon_HEADER_FILES
     llunittype.h
     lluri.h
     lluuid.h
-	llwin32headers.h
+    llwin32headers.h
     llwin32headerslean.h
     llworkerthread.h
     stdtypes.h
diff --git a/indra/llcommon/indra_constants.cpp b/indra/llcommon/indra_constants.cpp
index b61dca3243..f3989ee1d0 100755
--- a/indra/llcommon/indra_constants.cpp
+++ b/indra/llcommon/indra_constants.cpp
@@ -66,4 +66,4 @@ const LLUUID TERRAIN_GRASS_DETAIL		("63338ede-0037-c4fd-855b-015d77112fc8"); //
 const LLUUID TERRAIN_MOUNTAIN_DETAIL	("303cd381-8560-7579-23f1-f0a880799740"); // VIEWER
 const LLUUID TERRAIN_ROCK_DETAIL		("53a2f406-4895-1d13-d541-d2e3b86bc19c"); // VIEWER
 
-const LLUUID DEFAULT_WATER_NORMAL		("822ded49-9a6c-f61c-cb89-6df54f42cdf4"); // VIEWER
\ No newline at end of file
+const LLUUID DEFAULT_WATER_NORMAL		("822ded49-9a6c-f61c-cb89-6df54f42cdf4"); // VIEWER
diff --git a/indra/llcommon/lltrace.cpp b/indra/llcommon/lltrace.cpp
index e4a6f4c902..73846ba900 100644
--- a/indra/llcommon/lltrace.cpp
+++ b/indra/llcommon/lltrace.cpp
@@ -33,6 +33,8 @@
 namespace LLTrace
 {
 
+MemStatHandle gTraceMemStat("LLTrace");
+
 TraceBase::TraceBase( const char* name, const char* description ) 
 :	mName(name),
 	mDescription(description ? description : "")
diff --git a/indra/llcommon/lltrace.h b/indra/llcommon/lltrace.h
index 226f64d0c7..3dc2e5248f 100644
--- a/indra/llcommon/lltrace.h
+++ b/indra/llcommon/lltrace.h
@@ -320,23 +320,23 @@ struct MeasureMem<std::basic_string<T>, IS_MEM_TRACKABLE, IS_BYTES>
 
 
 template<typename T>
-inline void claim_footprint(MemStatHandle& measurement, const T& value)
+inline void claim_alloc(MemStatHandle& measurement, const T& value)
 {
 	S32 size = MeasureMem<T>::measureFootprint(value);
 	if(size == 0) return;
 	MemStatAccumulator& accumulator = measurement.getCurrentAccumulator();
 	accumulator.mSize.sample(accumulator.mSize.hasValue() ? accumulator.mSize.getLastValue() + (F64)size : (F64)size);
-	accumulator.mFootprintAllocations.record(size);
+	accumulator.mAllocations.record(size);
 }
 
 template<typename T>
-inline void disclaim_footprint(MemStatHandle& measurement, const T& value)
+inline void disclaim_alloc(MemStatHandle& measurement, const T& value)
 {
 	S32 size = MeasureMem<T>::measureFootprint(value);
 	if(size == 0) return;
 	MemStatAccumulator& accumulator = measurement.getCurrentAccumulator();
 	accumulator.mSize.sample(accumulator.mSize.hasValue() ? accumulator.mSize.getLastValue() - (F64)size : -(F64)size);
-	accumulator.mFootprintDeallocations.add(size);
+	accumulator.mDeallocations.add(size);
 }
 
 template<typename DERIVED, size_t ALIGNMENT = LL_DEFAULT_HEAP_ALIGN>
@@ -370,25 +370,25 @@ public:
 
 	void* operator new(size_t size) 
 	{
-		claim_footprint(sMemStat, size);
+		claim_alloc(sMemStat, size);
 		return ll_aligned_malloc(ALIGNMENT, size);
 	}
 
 	void operator delete(void* ptr, size_t size)
 	{
-		disclaim_footprint(sMemStat, size);
+		disclaim_alloc(sMemStat, size);
 		ll_aligned_free(ALIGNMENT, ptr);
 	}
 
 	void* operator new [](size_t size)
 	{
-		claim_footprint(sMemStat, size);
+		claim_alloc(sMemStat, size);
 		return ll_aligned_malloc(ALIGNMENT, size);
 	}
 
 	void operator delete[](void* ptr, size_t size)
 	{
-		disclaim_footprint(sMemStat, size);
+		disclaim_alloc(sMemStat, size);
 		ll_aligned_free(ALIGNMENT, ptr);
 	}
 
@@ -397,7 +397,7 @@ public:
 	void claimMem(const CLAIM_T& value) const
 	{
 		S32 size = MeasureMem<CLAIM_T>::measureFootprint(value);
-		claim_footprint(sMemStat, size);
+		claim_alloc(sMemStat, size);
 		mMemFootprint += size;
 	}
 
@@ -406,7 +406,7 @@ public:
 	void disclaimMem(const CLAIM_T& value) const
 	{
 		S32 size = MeasureMem<CLAIM_T>::measureFootprint(value);
-		disclaim_footprint(sMemStat, size);
+		disclaim_alloc(sMemStat, size);
 		mMemFootprint -= size;
 	}
 
diff --git a/indra/llcommon/lltraceaccumulators.cpp b/indra/llcommon/lltraceaccumulators.cpp
index f5f2e7df1c..c25bb704f5 100644
--- a/indra/llcommon/lltraceaccumulators.cpp
+++ b/indra/llcommon/lltraceaccumulators.cpp
@@ -26,18 +26,50 @@
 #include "linden_common.h"
 
 #include "lltraceaccumulators.h"
+#include "lltrace.h"
 #include "lltracethreadrecorder.h"
 
 namespace LLTrace
 {
 
+extern MemStatHandle gTraceMemStat;
+
 
 ///////////////////////////////////////////////////////////////////////
 // AccumulatorBufferGroup
 ///////////////////////////////////////////////////////////////////////
 
 AccumulatorBufferGroup::AccumulatorBufferGroup() 
-{}
+{
+	claim_alloc(gTraceMemStat, mCounts.capacity() * sizeof(CountAccumulator));
+	claim_alloc(gTraceMemStat, mSamples.capacity() * sizeof(SampleAccumulator));
+	claim_alloc(gTraceMemStat, mEvents.capacity() * sizeof(EventAccumulator));
+	claim_alloc(gTraceMemStat, mStackTimers.capacity() * sizeof(TimeBlockAccumulator));
+	claim_alloc(gTraceMemStat, mMemStats.capacity() * sizeof(MemStatAccumulator));
+}
+
+AccumulatorBufferGroup::AccumulatorBufferGroup(const AccumulatorBufferGroup& other)
+:	mCounts(other.mCounts),
+	mSamples(other.mSamples),
+	mEvents(other.mEvents),
+	mStackTimers(other.mStackTimers),
+	mMemStats(other.mMemStats)
+{
+	claim_alloc(gTraceMemStat, mCounts.capacity() * sizeof(CountAccumulator));
+	claim_alloc(gTraceMemStat, mSamples.capacity() * sizeof(SampleAccumulator));
+	claim_alloc(gTraceMemStat, mEvents.capacity() * sizeof(EventAccumulator));
+	claim_alloc(gTraceMemStat, mStackTimers.capacity() * sizeof(TimeBlockAccumulator));
+	claim_alloc(gTraceMemStat, mMemStats.capacity() * sizeof(MemStatAccumulator));
+}
+
+AccumulatorBufferGroup::~AccumulatorBufferGroup()
+{
+	disclaim_alloc(gTraceMemStat, mCounts.capacity() * sizeof(CountAccumulator));
+	disclaim_alloc(gTraceMemStat, mSamples.capacity() * sizeof(SampleAccumulator));
+	disclaim_alloc(gTraceMemStat, mEvents.capacity() * sizeof(EventAccumulator));
+	disclaim_alloc(gTraceMemStat, mStackTimers.capacity() * sizeof(TimeBlockAccumulator));
+	disclaim_alloc(gTraceMemStat, mMemStats.capacity() * sizeof(MemStatAccumulator));
+}
 
 void AccumulatorBufferGroup::handOffTo(AccumulatorBufferGroup& other)
 {
diff --git a/indra/llcommon/lltraceaccumulators.h b/indra/llcommon/lltraceaccumulators.h
index ecc569f5d6..27c0910665 100644
--- a/indra/llcommon/lltraceaccumulators.h
+++ b/indra/llcommon/lltraceaccumulators.h
@@ -188,6 +188,11 @@ namespace LLTrace
 			return getNumIndices();
 		}
 
+		size_t capacity() const
+		{
+			return mStorageSize;
+		}
+
 		static size_t getNumIndices() 
 		{
 			return sNextStorageSlot;
@@ -261,8 +266,8 @@ namespace LLTrace
 		void sync(F64SecondsImplicit) {}
 
 		F64	getSum() const               { return mSum; }
-		F64	getMin() const               { return mMin; }
-		F64	getMax() const               { return mMax; }
+		F32	getMin() const               { return mMin; }
+		F32	getMax() const               { return mMax; }
 		F64	getLastValue() const         { return mLastValue; }
 		F64	getMean() const              { return mMean; }
 		F64 getStandardDeviation() const { return sqrtf(mSumOfSquares / mNumSamples); }
@@ -272,13 +277,14 @@ namespace LLTrace
 
 	private:
 		F64	mSum,
-			mMin,
-			mMax,
 			mLastValue;
 
 		F64	mMean,
 			mSumOfSquares;
 
+		F32 mMin,
+			mMax;
+
 		S32	mNumSamples;
 	};
 
@@ -345,8 +351,8 @@ namespace LLTrace
 		}
 
 		F64	getSum() const               { return mSum; }
-		F64	getMin() const               { return mMin; }
-		F64	getMax() const               { return mMax; }
+		F32	getMin() const               { return mMin; }
+		F32	getMax() const               { return mMax; }
 		F64	getLastValue() const         { return mLastValue; }
 		F64	getMean() const              { return mMean; }
 		F64 getStandardDeviation() const { return sqrtf(mSumOfSquares / mTotalSamplingTime); }
@@ -357,12 +363,8 @@ namespace LLTrace
 
 	private:
 		F64		mSum,
-				mMin,
-				mMax,
 				mLastValue;
 
-		bool	mHasValue;		// distinct from mNumSamples, since we might have inherited an old sample
-
 		F64		mMean,
 				mSumOfSquares;
 
@@ -370,7 +372,13 @@ namespace LLTrace
 				mLastSampleTimeStamp,
 				mTotalSamplingTime;
 
+		F32		mMin,
+				mMax;
+
 		S32		mNumSamples;
+		// distinct from mNumSamples, since we might have inherited a last value from
+		// a previous sampling period
+		bool	mHasValue;		
 	};
 
 	class CountAccumulator
@@ -500,8 +508,8 @@ namespace LLTrace
 
 		void addSamples(const MemStatAccumulator& other, EBufferAppendType append_type)
 		{
-			mFootprintAllocations.addSamples(other.mFootprintAllocations, append_type);
-			mFootprintDeallocations.addSamples(other.mFootprintDeallocations, append_type);
+			mAllocations.addSamples(other.mAllocations, append_type);
+			mDeallocations.addSamples(other.mDeallocations, append_type);
 
 			if (append_type == SEQUENTIAL)
 			{
@@ -509,7 +517,7 @@ namespace LLTrace
 			}
 			else
 			{
-				F64 allocation_delta(other.mFootprintAllocations.getSum() - other.mFootprintDeallocations.getSum());
+				F64 allocation_delta(other.mAllocations.getSum() - other.mDeallocations.getSum());
 				mSize.sample(mSize.hasValue() 
 					? mSize.getLastValue() + allocation_delta 
 					: allocation_delta);
@@ -519,8 +527,8 @@ namespace LLTrace
 		void reset(const MemStatAccumulator* other)
 		{
 			mSize.reset(other ? &other->mSize : NULL);
-			mFootprintAllocations.reset(other ? &other->mFootprintAllocations : NULL);
-			mFootprintDeallocations.reset(other ? &other->mFootprintDeallocations : NULL);
+			mAllocations.reset(other ? &other->mAllocations : NULL);
+			mDeallocations.reset(other ? &other->mDeallocations : NULL);
 		}
 
 		void sync(F64SecondsImplicit time_stamp) 
@@ -529,13 +537,15 @@ namespace LLTrace
 		}
 
 		SampleAccumulator	mSize;
-		EventAccumulator	mFootprintAllocations;
-		CountAccumulator	mFootprintDeallocations;
+		EventAccumulator	mAllocations;
+		CountAccumulator	mDeallocations;
 	};
 
 	struct AccumulatorBufferGroup : public LLRefCount
 	{
 		AccumulatorBufferGroup();
+		AccumulatorBufferGroup(const AccumulatorBufferGroup&);
+		~AccumulatorBufferGroup();
 
 		void handOffTo(AccumulatorBufferGroup& other);
 		void makeCurrent();
diff --git a/indra/llcommon/lltracerecording.cpp b/indra/llcommon/lltracerecording.cpp
index ce4a433cca..06b4351339 100644
--- a/indra/llcommon/lltracerecording.cpp
+++ b/indra/llcommon/lltracerecording.cpp
@@ -25,15 +25,18 @@
 
 #include "linden_common.h"
 
+#include "lltracerecording.h"
+
 #include "lltrace.h"
 #include "llfasttimer.h"
-#include "lltracerecording.h"
 #include "lltracethreadrecorder.h"
 #include "llthread.h"
 
 namespace LLTrace
 {
-	
+
+extern MemStatHandle gTraceMemStat;
+
 ///////////////////////////////////////////////////////////////////////
 // Recording
 ///////////////////////////////////////////////////////////////////////
@@ -42,12 +45,15 @@ Recording::Recording(EPlayState state)
 :	mElapsedSeconds(0),
 	mInHandOff(false)
 {
+	claim_alloc(gTraceMemStat, this);
 	mBuffers = new AccumulatorBufferGroup();
+	claim_alloc(gTraceMemStat, mBuffers);
 	setPlayState(state);
 }
 
 Recording::Recording( const Recording& other )
 {
+	claim_alloc(gTraceMemStat, this);
 	*this = other;
 }
 
@@ -73,6 +79,9 @@ Recording& Recording::operator = (const Recording& other)
 
 Recording::~Recording()
 {
+	disclaim_alloc(gTraceMemStat, this);
+	disclaim_alloc(gTraceMemStat, mBuffers);
+
 	if (isStarted() && LLTrace::get_thread_recorder().notNull())
 	{
 		LLTrace::get_thread_recorder()->deactivate(mBuffers.write());
@@ -200,32 +209,32 @@ F64Kilobytes Recording::getLastValue(const TraceType<MemStatAccumulator>& stat)
 
 F64Kilobytes Recording::getSum(const TraceType<MemStatAccumulator::AllocationFacet>& stat)
 {
-	return F64Bytes(mBuffers->mMemStats[stat.getIndex()].mFootprintAllocations.getSum());
+	return F64Bytes(mBuffers->mMemStats[stat.getIndex()].mAllocations.getSum());
 }
 
 F64Kilobytes Recording::getPerSec(const TraceType<MemStatAccumulator::AllocationFacet>& stat)
 {
-	return F64Bytes(mBuffers->mMemStats[stat.getIndex()].mFootprintAllocations.getSum() / mElapsedSeconds.value());
+	return F64Bytes(mBuffers->mMemStats[stat.getIndex()].mAllocations.getSum() / mElapsedSeconds.value());
 }
 
 S32 Recording::getSampleCount(const TraceType<MemStatAccumulator::AllocationFacet>& stat)
 {
-	return mBuffers->mMemStats[stat.getIndex()].mFootprintAllocations.getSampleCount();
+	return mBuffers->mMemStats[stat.getIndex()].mAllocations.getSampleCount();
 }
 
 F64Kilobytes Recording::getSum(const TraceType<MemStatAccumulator::DeallocationFacet>& stat)
 {
-	return F64Bytes(mBuffers->mMemStats[stat.getIndex()].mFootprintDeallocations.getSum());
+	return F64Bytes(mBuffers->mMemStats[stat.getIndex()].mDeallocations.getSum());
 }
 
 F64Kilobytes Recording::getPerSec(const TraceType<MemStatAccumulator::DeallocationFacet>& stat)
 {
-	return F64Bytes(mBuffers->mMemStats[stat.getIndex()].mFootprintDeallocations.getSum() / mElapsedSeconds.value());
+	return F64Bytes(mBuffers->mMemStats[stat.getIndex()].mDeallocations.getSum() / mElapsedSeconds.value());
 }
 
 S32 Recording::getSampleCount(const TraceType<MemStatAccumulator::DeallocationFacet>& stat)
 {
-	return mBuffers->mMemStats[stat.getIndex()].mFootprintDeallocations.getSampleCount();
+	return mBuffers->mMemStats[stat.getIndex()].mDeallocations.getSampleCount();
 }
 
 F64 Recording::getSum( const TraceType<CountAccumulator>& stat )
@@ -330,6 +339,12 @@ PeriodicRecording::PeriodicRecording( S32 num_periods, EPlayState state)
 	mRecordingPeriods(num_periods ? num_periods : 1)
 {
 	setPlayState(state);
+	claim_alloc(gTraceMemStat, this);
+}
+
+PeriodicRecording::~PeriodicRecording()
+{
+	disclaim_alloc(gTraceMemStat, this);
 }
 
 void PeriodicRecording::nextPeriod()
diff --git a/indra/llcommon/lltracerecording.h b/indra/llcommon/lltracerecording.h
index 5cf7596966..8bb0b1892f 100644
--- a/indra/llcommon/lltracerecording.h
+++ b/indra/llcommon/lltracerecording.h
@@ -313,7 +313,7 @@ namespace LLTrace
 		class ThreadRecorder* getThreadRecorder(); 
 
 		LLTimer											mSamplingTimer;
-		F64Seconds					mElapsedSeconds;
+		F64Seconds										mElapsedSeconds;
 		LLCopyOnWritePointer<AccumulatorBufferGroup>	mBuffers;
 		bool											mInHandOff;
 
@@ -324,6 +324,7 @@ namespace LLTrace
 	{
 	public:
 		PeriodicRecording(S32 num_periods, EPlayState state = STOPPED);
+		~PeriodicRecording();
 
 		void nextPeriod();
 		S32 getNumRecordedPeriods() { return mNumPeriods; }
diff --git a/indra/llcommon/lltracethreadrecorder.cpp b/indra/llcommon/lltracethreadrecorder.cpp
index e131af5f16..9dac4f6771 100644
--- a/indra/llcommon/lltracethreadrecorder.cpp
+++ b/indra/llcommon/lltracethreadrecorder.cpp
@@ -27,9 +27,11 @@
 
 #include "lltracethreadrecorder.h"
 #include "llfasttimer.h"
+#include "lltrace.h"
 
 namespace LLTrace
 {
+extern MemStatHandle gTraceMemStat;
 
 static ThreadRecorder* sMasterThreadRecorder = NULL;
 
@@ -55,6 +57,7 @@ void ThreadRecorder::init()
 	timer_stack->mActiveTimer = NULL;
 
 	mNumTimeBlockTreeNodes = AccumulatorBuffer<TimeBlockAccumulator>::getDefaultBuffer()->size();
+
 	mTimeBlockTreeNodes = new TimeBlockTreeNode[mNumTimeBlockTreeNodes];
 
 	activate(&mThreadRecordingBuffers);
@@ -76,10 +79,14 @@ void ThreadRecorder::init()
 	timer_stack->mActiveTimer = mRootTimer;
 
 	TimeBlock::getRootTimeBlock().getCurrentAccumulator().mActiveCount = 1;
+
+	claim_alloc(gTraceMemStat, this);
+	claim_alloc(gTraceMemStat, sizeof(BlockTimer));
+	claim_alloc(gTraceMemStat, sizeof(TimeBlockTreeNode) * mNumTimeBlockTreeNodes);
 }
 
 
-ThreadRecorder::ThreadRecorder(ThreadRecorder& master)
+ThreadRecorder::ThreadRecorder( ThreadRecorder& master )
 :	mMasterRecorder(&master)
 {
 	init();
@@ -91,6 +98,10 @@ ThreadRecorder::~ThreadRecorder()
 {
 	LLThreadLocalSingletonPointer<BlockTimerStackRecord>::setInstance(NULL);
 
+	disclaim_alloc(gTraceMemStat, this);
+	disclaim_alloc(gTraceMemStat, sizeof(BlockTimer));
+	disclaim_alloc(gTraceMemStat, sizeof(TimeBlockTreeNode) * mNumTimeBlockTreeNodes);
+
 	deactivate(&mThreadRecordingBuffers);
 
 	delete mRootTimer;
@@ -135,9 +146,9 @@ void ThreadRecorder::activate( AccumulatorBufferGroup* recording, bool from_hand
 	mActiveRecordings.back()->mPartialRecording.makeCurrent();
 }
 
-ThreadRecorder::active_recording_list_t::reverse_iterator ThreadRecorder::bringUpToDate( AccumulatorBufferGroup* recording )
+ThreadRecorder::active_recording_list_t::iterator ThreadRecorder::bringUpToDate( AccumulatorBufferGroup* recording )
 {
-	if (mActiveRecordings.empty()) return mActiveRecordings.rend();
+	if (mActiveRecordings.empty()) return mActiveRecordings.end();
 
 	mActiveRecordings.back()->mPartialRecording.sync();
 	TimeBlock::updateTimes();
@@ -174,19 +185,18 @@ ThreadRecorder::active_recording_list_t::reverse_iterator ThreadRecorder::bringU
 		LL_WARNS() << "Recording not active on this thread" << LL_ENDL;
 	}
 
-	return it;
+	return (++it).base();
 }
 
 void ThreadRecorder::deactivate( AccumulatorBufferGroup* recording )
 {
-	active_recording_list_t::reverse_iterator it = bringUpToDate(recording);
-	if (it != mActiveRecordings.rend())
+	active_recording_list_t::iterator recording_it = bringUpToDate(recording);
+	if (recording_it != mActiveRecordings.end())
 	{
-		active_recording_list_t::iterator recording_to_remove = (++it).base();
-		bool was_current = (*recording_to_remove)->mPartialRecording.isCurrent();
-		llassert((*recording_to_remove)->mTargetRecording == recording);
-		delete *recording_to_remove;
-		mActiveRecordings.erase(recording_to_remove);
+		ActiveRecording* recording_to_remove = *recording_it;
+		bool was_current = recording_to_remove->mPartialRecording.isCurrent();
+		llassert(recording_to_remove->mTargetRecording == recording);
+		mActiveRecordings.erase(recording_it);
 		if (was_current)
 		{
 			if (mActiveRecordings.empty())
@@ -198,6 +208,7 @@ void ThreadRecorder::deactivate( AccumulatorBufferGroup* recording )
 				mActiveRecordings.back()->mPartialRecording.makeCurrent();
 			}
 		}
+		delete recording_to_remove;
 	}
 }
 
@@ -216,25 +227,33 @@ void ThreadRecorder::ActiveRecording::movePartialToTarget()
 
 // called by child thread
 void ThreadRecorder::addChildRecorder( class ThreadRecorder* child )
-{ LLMutexLock lock(&mChildListMutex);
-	mChildThreadRecorders.push_back(child);
+{
+	{ LLMutexLock lock(&mChildListMutex);
+		mChildThreadRecorders.push_back(child);
+	}
 }
 
 // called by child thread
 void ThreadRecorder::removeChildRecorder( class ThreadRecorder* child )
-{ LLMutexLock lock(&mChildListMutex);
-
-for (child_thread_recorder_list_t::iterator it = mChildThreadRecorders.begin(), end_it = mChildThreadRecorders.end();
-	it != end_it;
-	++it)
-{
-	if ((*it) == child)
-	{
-		mChildThreadRecorders.erase(it);
-		break;
+{	
+	{ LLMutexLock lock(&mChildListMutex);
+		for (child_thread_recorder_list_t::iterator it = mChildThreadRecorders.begin(), end_it = mChildThreadRecorders.end();
+			it != end_it;
+			++it)
+		{
+			if ((*it) == child)
+			{
+				// FIXME: this won't do any good, as the child stores the "pushed" values internally
+				// and it is in the process of being deleted.
+				// We need a way to finalize the stats from the outgoing thread, but the storage
+				// for those stats needs to be outside the child's thread recorder
+				//(*it)->pushToParent();
+				mChildThreadRecorders.erase(it);
+				break;
+			}
+		}
 	}
 }
-}
 
 void ThreadRecorder::pushToParent()
 {
@@ -269,7 +288,7 @@ void ThreadRecorder::pullFromChildren()
 }
 
 
-void set_master_thread_recorder(ThreadRecorder* recorder)
+void set_master_thread_recorder( ThreadRecorder* recorder )
 {
 	sMasterThreadRecorder = recorder;
 }
@@ -291,7 +310,7 @@ const LLThreadLocalPointer<ThreadRecorder>& get_thread_recorder()
 	return get_thread_recorder_ptr();
 }
 
-void set_thread_recorder(ThreadRecorder* recorder)
+void set_thread_recorder( ThreadRecorder* recorder )
 {
 	get_thread_recorder_ptr() = recorder;
 }
diff --git a/indra/llcommon/lltracethreadrecorder.h b/indra/llcommon/lltracethreadrecorder.h
index c40228785e..c6afcdac80 100644
--- a/indra/llcommon/lltracethreadrecorder.h
+++ b/indra/llcommon/lltracethreadrecorder.h
@@ -49,7 +49,7 @@ namespace LLTrace
 
 		void activate(AccumulatorBufferGroup* recording, bool from_handoff = false);
 		void deactivate(AccumulatorBufferGroup* recording);
-		active_recording_list_t::reverse_iterator bringUpToDate(AccumulatorBufferGroup* recording);
+		active_recording_list_t::iterator bringUpToDate(AccumulatorBufferGroup* recording);
 
 		void addChildRecorder(class ThreadRecorder* child);
 		void removeChildRecorder(class ThreadRecorder* child);