Merge branch 'marchcat/w-whitespace' into marchcat/x-mf-merge

1 files changed, 163 insertions, 163 deletions

diff --git a/indra/llcommon/lltracethreadrecorder.cpp b/indra/llcommon/lltracethreadrecorder.cpp
index 914bfb55dc..be3e585ef8 100644
--- a/indra/llcommon/lltracethreadrecorder.cpp
+++ b/indra/llcommon/lltracethreadrecorder.cpp
@@ -1,24 +1,24 @@
-/** 
+/**
  * @file lltracethreadrecorder.cpp
  *
  * $LicenseInfo:firstyear=2001&license=viewerlgpl$
  * Second Life Viewer Source Code
  * Copyright (C) 2012, Linden Research, Inc.
- * 
+ *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation;
  * version 2.1 of the License only.
- * 
+ *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
- * 
+ *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
+ *
  * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
  * $/LicenseInfo$
  */
@@ -41,203 +41,203 @@ static ThreadRecorder* sMasterThreadRecorder = NULL;
 ///////////////////////////////////////////////////////////////////////
 
 ThreadRecorder::ThreadRecorder()
-:	mParentRecorder(NULL)
+:   mParentRecorder(NULL)
 {
-	init();
+    init();
 }
 
 void ThreadRecorder::init()
 {
 #if LL_TRACE_ENABLED
-	LLThreadLocalSingletonPointer<BlockTimerStackRecord>::setInstance(&mBlockTimerStackRecord);
-	//NB: the ordering of initialization in this function is very fragile due to a large number of implicit dependencies
-	set_thread_recorder(this);
-	BlockTimerStatHandle& root_time_block = BlockTimer::getRootTimeBlock();
+    LLThreadLocalSingletonPointer<BlockTimerStackRecord>::setInstance(&mBlockTimerStackRecord);
+    //NB: the ordering of initialization in this function is very fragile due to a large number of implicit dependencies
+    set_thread_recorder(this);
+    BlockTimerStatHandle& root_time_block = BlockTimer::getRootTimeBlock();
 
-	BlockTimerStackRecord* timer_stack = LLThreadLocalSingletonPointer<BlockTimerStackRecord>::getInstance();
-	timer_stack->mTimeBlock = &root_time_block;
-	timer_stack->mActiveTimer = NULL;
+    BlockTimerStackRecord* timer_stack = LLThreadLocalSingletonPointer<BlockTimerStackRecord>::getInstance();
+    timer_stack->mTimeBlock = &root_time_block;
+    timer_stack->mActiveTimer = NULL;
 
-	mNumTimeBlockTreeNodes = AccumulatorBuffer<TimeBlockAccumulator>::getDefaultBuffer()->size();
+    mNumTimeBlockTreeNodes = AccumulatorBuffer<TimeBlockAccumulator>::getDefaultBuffer()->size();
 
-	mTimeBlockTreeNodes = new TimeBlockTreeNode[mNumTimeBlockTreeNodes];
+    mTimeBlockTreeNodes = new TimeBlockTreeNode[mNumTimeBlockTreeNodes];
 
-	activate(&mThreadRecordingBuffers);
+    activate(&mThreadRecordingBuffers);
 
-	// initialize time block parent pointers
-	for (auto& base : BlockTimerStatHandle::instance_snapshot())
-	{
-		// because of indirect derivation from LLInstanceTracker, have to downcast
-		BlockTimerStatHandle& time_block = static_cast<BlockTimerStatHandle&>(base);
-		TimeBlockTreeNode& tree_node = mTimeBlockTreeNodes[time_block.getIndex()];
-		tree_node.mBlock = &time_block;
-		tree_node.mParent = &root_time_block;
+    // initialize time block parent pointers
+    for (auto& base : BlockTimerStatHandle::instance_snapshot())
+    {
+        // because of indirect derivation from LLInstanceTracker, have to downcast
+        BlockTimerStatHandle& time_block = static_cast<BlockTimerStatHandle&>(base);
+        TimeBlockTreeNode& tree_node = mTimeBlockTreeNodes[time_block.getIndex()];
+        tree_node.mBlock = &time_block;
+        tree_node.mParent = &root_time_block;
 
-		time_block.getCurrentAccumulator().mParent = &root_time_block;
-	}
+        time_block.getCurrentAccumulator().mParent = &root_time_block;
+    }
 
-	mRootTimer = new BlockTimer(root_time_block);
-	timer_stack->mActiveTimer = mRootTimer;
+    mRootTimer = new BlockTimer(root_time_block);
+    timer_stack->mActiveTimer = mRootTimer;
 
-	BlockTimer::getRootTimeBlock().getCurrentAccumulator().mActiveCount = 1;
+    BlockTimer::getRootTimeBlock().getCurrentAccumulator().mActiveCount = 1;
 
-	//claim_alloc(gTraceMemStat, this);
-	//claim_alloc(gTraceMemStat, mRootTimer);
-	//claim_alloc(gTraceMemStat, sizeof(TimeBlockTreeNode) * mNumTimeBlockTreeNodes);
+    //claim_alloc(gTraceMemStat, this);
+    //claim_alloc(gTraceMemStat, mRootTimer);
+    //claim_alloc(gTraceMemStat, sizeof(TimeBlockTreeNode) * mNumTimeBlockTreeNodes);
 #endif
 }
 
 
 ThreadRecorder::ThreadRecorder( ThreadRecorder& parent )
-:	mParentRecorder(&parent)
+:   mParentRecorder(&parent)
 {
-	init();
-	mParentRecorder->addChildRecorder(this);
+    init();
+    mParentRecorder->addChildRecorder(this);
 }
 
 
 ThreadRecorder::~ThreadRecorder()
 {
 #if LL_TRACE_ENABLED
-	LLThreadLocalSingletonPointer<BlockTimerStackRecord>::setInstance(NULL);
+    LLThreadLocalSingletonPointer<BlockTimerStackRecord>::setInstance(NULL);
 
-	//disclaim_alloc(gTraceMemStat, this);
-	//disclaim_alloc(gTraceMemStat, sizeof(BlockTimer));
-	//disclaim_alloc(gTraceMemStat, sizeof(TimeBlockTreeNode) * mNumTimeBlockTreeNodes);
+    //disclaim_alloc(gTraceMemStat, this);
+    //disclaim_alloc(gTraceMemStat, sizeof(BlockTimer));
+    //disclaim_alloc(gTraceMemStat, sizeof(TimeBlockTreeNode) * mNumTimeBlockTreeNodes);
 
-	deactivate(&mThreadRecordingBuffers);
+    deactivate(&mThreadRecordingBuffers);
 
-	delete mRootTimer;
+    delete mRootTimer;
 
-	if (!mActiveRecordings.empty())
-	{
-		std::for_each(mActiveRecordings.begin(), mActiveRecordings.end(), DeletePointer());
-		mActiveRecordings.clear();
-	}
+    if (!mActiveRecordings.empty())
+    {
+        std::for_each(mActiveRecordings.begin(), mActiveRecordings.end(), DeletePointer());
+        mActiveRecordings.clear();
+    }
 
-	set_thread_recorder(NULL);
-	delete[] mTimeBlockTreeNodes;
+    set_thread_recorder(NULL);
+    delete[] mTimeBlockTreeNodes;
 
-	if (mParentRecorder)
-	{
-		mParentRecorder->removeChildRecorder(this);
-	}
+    if (mParentRecorder)
+    {
+        mParentRecorder->removeChildRecorder(this);
+    }
 #endif
 }
 
 TimeBlockTreeNode* ThreadRecorder::getTimeBlockTreeNode( size_t index )
 {
 #if LL_TRACE_ENABLED
-	if (0 <= index && index < mNumTimeBlockTreeNodes)
-	{
-		return &mTimeBlockTreeNodes[index];
-	}
+    if (0 <= index && index < mNumTimeBlockTreeNodes)
+    {
+        return &mTimeBlockTreeNodes[index];
+    }
 #endif
-	return NULL;
+    return NULL;
 }
 
 AccumulatorBufferGroup* ThreadRecorder::activate( AccumulatorBufferGroup* recording)
 {
 #if LL_TRACE_ENABLED
-	ActiveRecording* active_recording = new ActiveRecording(recording);
-	if (!mActiveRecordings.empty())
-	{
-		AccumulatorBufferGroup& prev_active_recording = mActiveRecordings.back()->mPartialRecording;
-		prev_active_recording.sync();
-		BlockTimer::updateTimes();
-		prev_active_recording.handOffTo(active_recording->mPartialRecording);
-	}
-	mActiveRecordings.push_back(active_recording);
-
-	mActiveRecordings.back()->mPartialRecording.makeCurrent();
-	return &active_recording->mPartialRecording;
+    ActiveRecording* active_recording = new ActiveRecording(recording);
+    if (!mActiveRecordings.empty())
+    {
+        AccumulatorBufferGroup& prev_active_recording = mActiveRecordings.back()->mPartialRecording;
+        prev_active_recording.sync();
+        BlockTimer::updateTimes();
+        prev_active_recording.handOffTo(active_recording->mPartialRecording);
+    }
+    mActiveRecordings.push_back(active_recording);
+
+    mActiveRecordings.back()->mPartialRecording.makeCurrent();
+    return &active_recording->mPartialRecording;
 #else
-	return NULL;
+    return NULL;
 #endif
 }
 
 ThreadRecorder::active_recording_list_t::iterator ThreadRecorder::bringUpToDate( AccumulatorBufferGroup* recording )
 {
 #if LL_TRACE_ENABLED
-	if (mActiveRecordings.empty()) return mActiveRecordings.end();
-
-	mActiveRecordings.back()->mPartialRecording.sync();
-	BlockTimer::updateTimes();
-
-	active_recording_list_t::reverse_iterator it, end_it;
-	for (it = mActiveRecordings.rbegin(), end_it = mActiveRecordings.rend();
-		it != end_it;
-		++it)
-	{
-		ActiveRecording* cur_recording = *it;
-
-		active_recording_list_t::reverse_iterator next_it = it;
-		++next_it;
-
-		// if we have another recording further down in the stack...
-		if (next_it != mActiveRecordings.rend())
-		{
-			// ...push our gathered data down to it
-			(*next_it)->mPartialRecording.append(cur_recording->mPartialRecording);
-		}
-
-		// copy accumulated measurements into result buffer and clear accumulator (mPartialRecording)
-		cur_recording->movePartialToTarget();
-
-		if (cur_recording->mTargetRecording == recording)
-		{
-			// found the recording, so return it
-			break;
-		}
-	}
-
-	if (it == end_it)
-	{
-		LL_WARNS() << "Recording not active on this thread" << LL_ENDL;
-	}
-
-	return (++it).base();
+    if (mActiveRecordings.empty()) return mActiveRecordings.end();
+
+    mActiveRecordings.back()->mPartialRecording.sync();
+    BlockTimer::updateTimes();
+
+    active_recording_list_t::reverse_iterator it, end_it;
+    for (it = mActiveRecordings.rbegin(), end_it = mActiveRecordings.rend();
+        it != end_it;
+        ++it)
+    {
+        ActiveRecording* cur_recording = *it;
+
+        active_recording_list_t::reverse_iterator next_it = it;
+        ++next_it;
+
+        // if we have another recording further down in the stack...
+        if (next_it != mActiveRecordings.rend())
+        {
+            // ...push our gathered data down to it
+            (*next_it)->mPartialRecording.append(cur_recording->mPartialRecording);
+        }
+
+        // copy accumulated measurements into result buffer and clear accumulator (mPartialRecording)
+        cur_recording->movePartialToTarget();
+
+        if (cur_recording->mTargetRecording == recording)
+        {
+            // found the recording, so return it
+            break;
+        }
+    }
+
+    if (it == end_it)
+    {
+        LL_WARNS() << "Recording not active on this thread" << LL_ENDL;
+    }
+
+    return (++it).base();
 #else
-	return ThreadRecorder::active_recording_list_t::iterator();
+    return ThreadRecorder::active_recording_list_t::iterator();
 #endif
 }
 
 void ThreadRecorder::deactivate( AccumulatorBufferGroup* recording )
 {
 #if LL_TRACE_ENABLED
-	active_recording_list_t::iterator recording_it = bringUpToDate(recording);
-	// this method should only be called on a thread where the recorder is active
-	llassert_always(recording_it != mActiveRecordings.end());
-
-	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())
-		{
-			AccumulatorBufferGroup::clearCurrent();
-		}
-		else
-		{
-			mActiveRecordings.back()->mPartialRecording.makeCurrent();
-		}
-	}
-	delete recording_to_remove;
+    active_recording_list_t::iterator recording_it = bringUpToDate(recording);
+    // this method should only be called on a thread where the recorder is active
+    llassert_always(recording_it != mActiveRecordings.end());
+
+    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())
+        {
+            AccumulatorBufferGroup::clearCurrent();
+        }
+        else
+        {
+            mActiveRecordings.back()->mPartialRecording.makeCurrent();
+        }
+    }
+    delete recording_to_remove;
 #endif
 }
 
-ThreadRecorder::ActiveRecording::ActiveRecording( AccumulatorBufferGroup* target ) 
-:	mTargetRecording(target)
+ThreadRecorder::ActiveRecording::ActiveRecording( AccumulatorBufferGroup* target )
+:   mTargetRecording(target)
 {}
 
 void ThreadRecorder::ActiveRecording::movePartialToTarget()
 {
 #if LL_TRACE_ENABLED
-	mTargetRecording->append(mPartialRecording);
-	// reset based on self to keep history
-	mPartialRecording.reset(&mPartialRecording);
+    mTargetRecording->append(mPartialRecording);
+    // reset based on self to keep history
+    mPartialRecording.reset(&mPartialRecording);
 #endif
 }
 
@@ -246,30 +246,30 @@ void ThreadRecorder::ActiveRecording::movePartialToTarget()
 void ThreadRecorder::addChildRecorder( class ThreadRecorder* child )
 {
 #if LL_TRACE_ENABLED
-	{ LLMutexLock lock(&mChildListMutex);
-		mChildThreadRecorders.push_back(child);
-	}
+    { LLMutexLock lock(&mChildListMutex);
+        mChildThreadRecorders.push_back(child);
+    }
 #endif
 }
 
 // called by child thread
 void ThreadRecorder::removeChildRecorder( class ThreadRecorder* child )
-{	
+{
 #if LL_TRACE_ENABLED
-	{ LLMutexLock lock(&mChildListMutex);
-		mChildThreadRecorders.remove(child);
-	}
+    { LLMutexLock lock(&mChildListMutex);
+        mChildThreadRecorders.remove(child);
+    }
 #endif
 }
 
 void ThreadRecorder::pushToParent()
 {
 #if LL_TRACE_ENABLED
-	{ LLMutexLock lock(&mSharedRecordingMutex);	
-		LLTrace::get_thread_recorder()->bringUpToDate(&mThreadRecordingBuffers);
-		mSharedRecordingBuffers.append(mThreadRecordingBuffers);
-		mThreadRecordingBuffers.reset();
-	}
+    { LLMutexLock lock(&mSharedRecordingMutex);
+        LLTrace::get_thread_recorder()->bringUpToDate(&mThreadRecordingBuffers);
+        mSharedRecordingBuffers.append(mThreadRecordingBuffers);
+        mThreadRecordingBuffers.reset();
+    }
 #endif
 }
 
@@ -278,48 +278,48 @@ void ThreadRecorder::pullFromChildren()
 {
 #if LL_TRACE_ENABLED
     LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
-	if (mActiveRecordings.empty()) return;
+    if (mActiveRecordings.empty()) return;
 
-	{ LLMutexLock lock(&mChildListMutex);
+    { LLMutexLock lock(&mChildListMutex);
 
-		AccumulatorBufferGroup& target_recording_buffers = mActiveRecordings.back()->mPartialRecording;
-		target_recording_buffers.sync();
-		for (LLTrace::ThreadRecorder* rec : mChildThreadRecorders)
-		{ LLMutexLock lock(&(rec->mSharedRecordingMutex));
+        AccumulatorBufferGroup& target_recording_buffers = mActiveRecordings.back()->mPartialRecording;
+        target_recording_buffers.sync();
+        for (LLTrace::ThreadRecorder* rec : mChildThreadRecorders)
+        { LLMutexLock lock(&(rec->mSharedRecordingMutex));
 
-			target_recording_buffers.merge(rec->mSharedRecordingBuffers);
-			rec->mSharedRecordingBuffers.reset();
-		}
-	}
+            target_recording_buffers.merge(rec->mSharedRecordingBuffers);
+            rec->mSharedRecordingBuffers.reset();
+        }
+    }
 #endif
 }
 
 
 void set_master_thread_recorder( ThreadRecorder* recorder )
 {
-	sMasterThreadRecorder = recorder;
+    sMasterThreadRecorder = recorder;
 }
 
 
 ThreadRecorder* get_master_thread_recorder()
 {
-	return sMasterThreadRecorder;
+    return sMasterThreadRecorder;
 }
 
 ThreadRecorder*& get_thread_recorder_ptr()
 {
-	static thread_local ThreadRecorder* s_thread_recorder;
-	return s_thread_recorder;
+    static thread_local ThreadRecorder* s_thread_recorder;
+    return s_thread_recorder;
 }
 
 ThreadRecorder* get_thread_recorder()
 {
-	return get_thread_recorder_ptr();
+    return get_thread_recorder_ptr();
 }
 
 void set_thread_recorder( ThreadRecorder* recorder )
 {
-	get_thread_recorder_ptr() = recorder;
+    get_thread_recorder_ptr() = recorder;
 }
 
 }