summaryrefslogtreecommitdiff
path: root/indra/llcommon
diff options
context:
space:
mode:
authorRichard Linden <none@none>2013-10-03 14:30:34 -0700
committerRichard Linden <none@none>2013-10-03 14:30:34 -0700
commit754e8752a9b9a2e75d425a10cb8a0a6f85ad4bf5 (patch)
tree8c58bdba12578ccd5267bab122c2a63187abcb7a /indra/llcommon
parentb3d42e9b99db7e14354338383239122ef4cbeade (diff)
added initial memory usage tracking for lltrace
Diffstat (limited to 'indra/llcommon')
-rw-r--r--indra/llcommon/lltrace.cpp2
-rw-r--r--indra/llcommon/lltrace.h16
-rw-r--r--indra/llcommon/lltraceaccumulators.cpp20
-rw-r--r--indra/llcommon/lltraceaccumulators.h6
-rw-r--r--indra/llcommon/lltracerecording.cpp19
-rw-r--r--indra/llcommon/lltracerecording.h3
-rw-r--r--indra/llcommon/lltracethreadrecorder.cpp62
-rw-r--r--indra/llcommon/lltracethreadrecorder.h2
8 files changed, 95 insertions, 35 deletions
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..421ec3bda5 100644
--- a/indra/llcommon/lltrace.h
+++ b/indra/llcommon/lltrace.h
@@ -320,7 +320,7 @@ 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;
@@ -330,7 +330,7 @@ inline void claim_footprint(MemStatHandle& measurement, const T& value)
}
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;
@@ -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..9f270e60b9 100644
--- a/indra/llcommon/lltraceaccumulators.cpp
+++ b/indra/llcommon/lltraceaccumulators.cpp
@@ -26,18 +26,36 @@
#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()
+{
+ /*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..d03c6ce5c0 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;
@@ -536,6 +541,7 @@ namespace LLTrace
struct AccumulatorBufferGroup : public LLRefCount
{
AccumulatorBufferGroup();
+ ~AccumulatorBufferGroup();
void handOffTo(AccumulatorBufferGroup& other);
void makeCurrent();
diff --git a/indra/llcommon/lltracerecording.cpp b/indra/llcommon/lltracerecording.cpp
index ce4a433cca..c33d9aedcc 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, sizeof(*this));
mBuffers = new AccumulatorBufferGroup();
+ claim_alloc(gTraceMemStat, mBuffers);
setPlayState(state);
}
Recording::Recording( const Recording& other )
{
+ claim_alloc(gTraceMemStat, sizeof(*this));
*this = other;
}
@@ -73,6 +79,9 @@ Recording& Recording::operator = (const Recording& other)
Recording::~Recording()
{
+ disclaim_alloc(gTraceMemStat, sizeof(*this));
+ disclaim_alloc(gTraceMemStat, mBuffers);
+
if (isStarted() && LLTrace::get_thread_recorder().notNull())
{
LLTrace::get_thread_recorder()->deactivate(mBuffers.write());
@@ -330,6 +339,12 @@ PeriodicRecording::PeriodicRecording( S32 num_periods, EPlayState state)
mRecordingPeriods(num_periods ? num_periods : 1)
{
setPlayState(state);
+ claim_alloc(gTraceMemStat, sizeof(*this));
+}
+
+PeriodicRecording::~PeriodicRecording()
+{
+ disclaim_alloc(gTraceMemStat, sizeof(*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..bf6189dd25 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, sizeof(*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, sizeof(*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,15 +185,14 @@ 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_to_remove = bringUpToDate(recording);
+ if (recording_to_remove != 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;
@@ -216,25 +226,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 +287,7 @@ void ThreadRecorder::pullFromChildren()
}
-void set_master_thread_recorder(ThreadRecorder* recorder)
+void set_master_thread_recorder( ThreadRecorder* recorder )
{
sMasterThreadRecorder = recorder;
}
@@ -291,7 +309,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);