SH-3275 WIP Update viewer metrics system to be more flexible

moved threadrecorder classes into separate file
added Count trace type, which tracks value increases and decreases and can report churn
as well as overall growth rate

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;
 
 }