1 files changed, 4 insertions, 191 deletions

diff --git a/indra/llcommon/lltrace.cpp b/indra/llcommon/lltrace.cpp
index 6d928721de..2b1c8d8ce8 100644
--- a/indra/llcommon/lltrace.cpp
+++ b/indra/llcommon/lltrace.cpp
@@ -44,206 +44,19 @@ void cleanup()
 	gMasterThreadRecorder = NULL;
 }
 
-LLThreadLocalPointer<ThreadRecorder>& get_thread_recorder()
-{
-	static LLThreadLocalPointer<ThreadRecorder> s_thread_recorder;
-	return s_thread_recorder;
-
-}
-
-BlockTimer::Recorder::StackEntry BlockTimer::sCurRecorder;
-
-
-
 MasterThreadRecorder& getMasterThreadRecorder()
 {
 	llassert(gMasterThreadRecorder != NULL);
 	return *gMasterThreadRecorder;
 }
 
-///////////////////////////////////////////////////////////////////////
-// ThreadRecorder
-///////////////////////////////////////////////////////////////////////
-
-ThreadRecorder::ThreadRecorder()
-:	mPrimaryRecording(NULL)
-{
-	get_thread_recorder() = this;
-	mFullRecording.start();
-}
-
-ThreadRecorder::ThreadRecorder( const ThreadRecorder& other ) 
-:	mFullRecording(other.mFullRecording),
-	mPrimaryRecording(NULL)
-{
-	get_thread_recorder() = this;
-	mFullRecording.start();
-}
-
-ThreadRecorder::~ThreadRecorder()
-{
-	get_thread_recorder() = NULL;
-}
-
-//TODO: remove this and use llviewerstats recording
-Recording* ThreadRecorder::getPrimaryRecording()
-{
-	return mPrimaryRecording;
-}
-
-void ThreadRecorder::activate( Recording* recording )
-{
-	mActiveRecordings.push_front(ActiveRecording(mPrimaryRecording, recording));
-	mActiveRecordings.front().mBaseline.makePrimary();
-	mPrimaryRecording = &mActiveRecordings.front().mBaseline;
-}
-
-//TODO: consider merging results down the list to one past the buffered item.
-// this would require 2 buffers per sampler, to separate current total from running total
-
-void ThreadRecorder::deactivate( Recording* recording )
-{
-	for (std::list<ActiveRecording>::iterator it = mActiveRecordings.begin(), end_it = mActiveRecordings.end();
-		it != end_it;
-		++it)
-	{
-		std::list<ActiveRecording>::iterator next_it = it;
-		if (++next_it != mActiveRecordings.end())
-		{
-			next_it->mergeMeasurements((*it));
-		}
-
-		it->flushAccumulators(mPrimaryRecording);
-
-		if (it->mTargetRecording == recording)
-		{
-			if (next_it != mActiveRecordings.end())
-			{
-				next_it->mBaseline.makePrimary();
-				mPrimaryRecording = &next_it->mBaseline;
-			}
-			mActiveRecordings.erase(it);
-			break;
-		}
-	}
-}
-
-ThreadRecorder::ActiveRecording::ActiveRecording( Recording* source, Recording* target ) 
-:	mTargetRecording(target)
-{
-	// take snapshots of current values rates and timers
-	if (source)
-	{
-		mBaseline.mRates.write()->copyFrom(*source->mRates);
-		mBaseline.mStackTimers.write()->copyFrom(*source->mStackTimers);
-	}
-}
-
-void ThreadRecorder::ActiveRecording::mergeMeasurements(ThreadRecorder::ActiveRecording& other)
-{
-	mBaseline.mMeasurements.write()->mergeSamples(*other.mBaseline.mMeasurements);
-}
-
-void ThreadRecorder::ActiveRecording::flushAccumulators(Recording* current)
-{
-	// accumulate statistics-like measurements
-	mTargetRecording->mMeasurements.write()->mergeSamples(*mBaseline.mMeasurements);
-	// for rate-like measurements, merge total change since baseline
-	mTargetRecording->mRates.write()->mergeDeltas(*mBaseline.mRates, *current->mRates);
-	mTargetRecording->mStackTimers.write()->mergeDeltas(*mBaseline.mStackTimers, *current->mStackTimers);
-	// reset baselines
-	mBaseline.mRates.write()->copyFrom(*current->mRates);
-	mBaseline.mStackTimers.write()->copyFrom(*current->mStackTimers);
-}
-
-///////////////////////////////////////////////////////////////////////
-// SlaveThreadRecorder
-///////////////////////////////////////////////////////////////////////
-
-SlaveThreadRecorder::SlaveThreadRecorder()
-:	ThreadRecorder(getMasterThreadRecorder())
-{
-	getMasterThreadRecorder().addSlaveThread(this);
-}
-
-SlaveThreadRecorder::~SlaveThreadRecorder()
-{
-	getMasterThreadRecorder().removeSlaveThread(this);
-}
-
-void SlaveThreadRecorder::pushToMaster()
-{
-	mFullRecording.stop();
-	{
-		LLMutexLock(getMasterThreadRecorder().getSlaveListMutex());
-		mSharedData.copyFrom(mFullRecording);
-	}
-	mFullRecording.start();
-}
-
-void SlaveThreadRecorder::SharedData::copyFrom( const Recording& source )
-{
-	LLMutexLock lock(&mRecorderMutex);
-	mRecorder.mergeSamples(source);
-}
-
-void SlaveThreadRecorder::SharedData::copyTo( Recording& sink )
-{
-	LLMutexLock lock(&mRecorderMutex);
-	sink.mergeSamples(mRecorder);
-}
-
-///////////////////////////////////////////////////////////////////////
-// MasterThreadRecorder
-///////////////////////////////////////////////////////////////////////
-
-void MasterThreadRecorder::pullFromSlaveThreads()
-{
-	LLMutexLock lock(&mSlaveListMutex);
-
-	for (slave_thread_recorder_list_t::iterator it = mSlaveThreadRecorders.begin(), end_it = mSlaveThreadRecorders.end();
-		it != end_it;
-		++it)
-	{
-		(*it)->mRecorder->mSharedData.copyTo((*it)->mSlaveRecording);
-	}
-}
-
-void MasterThreadRecorder::addSlaveThread( class SlaveThreadRecorder* child )
-{
-	LLMutexLock lock(&mSlaveListMutex);
-
-	mSlaveThreadRecorders.push_back(new SlaveThreadRecorderProxy(child));
-}
-
-void MasterThreadRecorder::removeSlaveThread( class SlaveThreadRecorder* child )
+LLThreadLocalPointer<ThreadRecorder>& get_thread_recorder()
 {
-	LLMutexLock lock(&mSlaveListMutex);
+	static LLThreadLocalPointer<ThreadRecorder> s_thread_recorder;
+	return s_thread_recorder;
 
-	for (slave_thread_recorder_list_t::iterator it = mSlaveThreadRecorders.begin(), end_it = mSlaveThreadRecorders.end();
-		it != end_it;
-		++it)
-	{
-		if ((*it)->mRecorder == child)
-		{
-			mSlaveThreadRecorders.erase(it);
-			break;
-		}
-	}
 }
 
-void MasterThreadRecorder::pushToMaster()
-{}
-
-MasterThreadRecorder::MasterThreadRecorder()
-{}
-
-///////////////////////////////////////////////////////////////////////
-// MasterThreadRecorder::SlaveThreadTraceProxy
-///////////////////////////////////////////////////////////////////////
-
-MasterThreadRecorder::SlaveThreadRecorderProxy::SlaveThreadRecorderProxy( class SlaveThreadRecorder* recorder) 
-:	mRecorder(recorder)
-{}
+BlockTimer::Recorder::StackEntry BlockTimer::sCurRecorder;
 
 }