diff --git a/indra/llcommon/lltrace.h b/indra/llcommon/lltrace.h
index f7ceaf585d0f6d2ee7a50d4a3de34fe5d1fdb72f..472f0b0cf062e12d9c90cb3b744069d11039096f 100644
--- a/indra/llcommon/lltrace.h
+++ b/indra/llcommon/lltrace.h
@@ -80,8 +80,8 @@ class TraceType
LL_FORCE_INLINE ACCUMULATOR& getCurrentAccumulator() const
{
- ACCUMULATOR* accumulator_storage = AccumulatorBuffer<ACCUMULATOR>::getCurrentStorage();
- return accumulator_storage[mAccumulatorIndex];
+ ACCUMULATOR* accumulator_storage = LLThreadLocalSingletonPointer<ACCUMULATOR>::getInstance();
+ return accumulator_storage ? accumulator_storage[mAccumulatorIndex] : (*AccumulatorBuffer<ACCUMULATOR>::getDefaultBuffer())[mAccumulatorIndex];
}
size_t getIndex() const { return mAccumulatorIndex; }
@@ -222,7 +222,7 @@ class TraceType<MemStatAccumulator::DeallocationCountFacet>
};
template<>
-class TraceType<MemStatAccumulator::ChildMemFacet>
+class TraceType<MemStatAccumulator::ShadowMemFacet>
: public TraceType<MemStatAccumulator>
{
public:
@@ -258,12 +258,51 @@ class MemStatHandle : public TraceType<MemStatAccumulator>
return static_cast<TraceType<MemStatAccumulator::DeallocationCountFacet>&>(*(TraceType<MemStatAccumulator>*)this);
}
- TraceType<MemStatAccumulator::ChildMemFacet>& childMem()
+ TraceType<MemStatAccumulator::ShadowMemFacet>& childMem()
{
- return static_cast<TraceType<MemStatAccumulator::ChildMemFacet>&>(*(TraceType<MemStatAccumulator>*)this);
+ return static_cast<TraceType<MemStatAccumulator::ShadowMemFacet>&>(*(TraceType<MemStatAccumulator>*)this);
}
};
+inline void track_alloc(MemStatHandle& measurement, size_t size)
+{
+ MemStatAccumulator& accumulator = measurement.getCurrentAccumulator();
+ accumulator.mSize.sample(accumulator.mSize.hasValue() ? accumulator.mSize.getLastValue() + (F64)size : (F64)size);
+ accumulator.mAllocatedCount++;
+}
+
+inline void track_dealloc(MemStatHandle& measurement, size_t size)
+{
+ MemStatAccumulator& accumulator = measurement.getCurrentAccumulator();
+ accumulator.mSize.sample(accumulator.mSize.hasValue() ? accumulator.mSize.getLastValue() - (F64)size : -(F64)size);
+ accumulator.mAllocatedCount--;
+ accumulator.mDeallocatedCount++;
+}
+
+inline void claim_mem(MemStatHandle& measurement, size_t size)
+{
+ MemStatAccumulator& accumulator = measurement.getCurrentAccumulator();
+ accumulator.mSize.sample(accumulator.mSize.hasValue() ? accumulator.mSize.getLastValue() + (F64)size : (F64)size);
+}
+
+inline void disclaim_mem(MemStatHandle& measurement, size_t size)
+{
+ MemStatAccumulator& accumulator = measurement.getCurrentAccumulator();
+ accumulator.mSize.sample(accumulator.mSize.hasValue() ? accumulator.mSize.getLastValue() - (F64)size : -(F64)size);
+}
+
+inline void claim_shadow_mem(MemStatHandle& measurement, size_t size)
+{
+ MemStatAccumulator& accumulator = measurement.getCurrentAccumulator();
+ accumulator.mShadowSize.sample(accumulator.mSize.hasValue() ? accumulator.mSize.getLastValue() + (F64)size : (F64)size);
+}
+
+inline void disclaim_shadow_mem(MemStatHandle& measurement, size_t size)
+{
+ MemStatAccumulator& accumulator = measurement.getCurrentAccumulator();
+ accumulator.mShadowSize.sample(accumulator.mSize.hasValue() ? accumulator.mSize.getLastValue() - (F64)size : -(F64)size);
+}
+
// measures effective memory footprint of specified type
// specialize to cover different types
@@ -369,9 +408,7 @@ class MemTrackable
void* operator new(size_t size)
{
- MemStatAccumulator& accumulator = sMemStat.getCurrentAccumulator();
- accumulator.mSize.sample(accumulator.mSize.hasValue() ? accumulator.mSize.getLastValue() + (F64)size : (F64)size);
- accumulator.mAllocatedCount++;
+ track_alloc(sMemStat, size);
if (ALIGNMENT == LL_DEFAULT_HEAP_ALIGN)
{
@@ -393,10 +430,7 @@ class MemTrackable
void operator delete(void* ptr, size_t size)
{
- MemStatAccumulator& accumulator = sMemStat.getCurrentAccumulator();
- accumulator.mSize.sample(accumulator.mSize.hasValue() ? accumulator.mSize.getLastValue() - (F64)size : -(F64)size);
- accumulator.mAllocatedCount--;
- accumulator.mDeallocatedCount++;
+ track_dealloc(sMemStat, size);
if (ALIGNMENT == LL_DEFAULT_HEAP_ALIGN)
{
@@ -418,9 +452,7 @@ class MemTrackable
void *operator new [](size_t size)
{
- MemStatAccumulator& accumulator = sMemStat.getCurrentAccumulator();
- accumulator.mSize.sample(accumulator.mSize.hasValue() ? accumulator.mSize.getLastValue() + (F64)size : (F64)size);
- accumulator.mAllocatedCount++;
+ track_alloc(sMemStat, size);
if (ALIGNMENT == LL_DEFAULT_HEAP_ALIGN)
{
@@ -442,7 +474,7 @@ class MemTrackable
void operator delete[](void* ptr, size_t size)
{
- MemStatAccumulator& accumulator = sMemStat.getCurrentAccumulator();
+ MemStatAccumulator& accumulator = sMemStat.getPrimaryAccumulator();
accumulator.mSize.sample(accumulator.mSize.hasValue() ? accumulator.mSize.getLastValue() - (F64)size : -(F64)size);
accumulator.mAllocatedCount--;
accumulator.mDeallocatedCount++;
@@ -484,9 +516,8 @@ class MemTrackable
template<typename AMOUNT_T>
AMOUNT_T& memClaimAmount(AMOUNT_T& size)
{
- MemStatAccumulator& accumulator = sMemStat.getCurrentAccumulator();
+ MemStatAccumulator& accumulator = sMemStat.getPrimaryAccumulator();
mMemFootprint += (size_t)size;
- accumulator.mSize.sample(accumulator.mSize.hasValue() ? accumulator.mSize.getLastValue() + (F64)size : (F64)size);
return size;
}
@@ -508,7 +539,7 @@ class MemTrackable
template<typename AMOUNT_T>
AMOUNT_T& memDisclaimAmount(AMOUNT_T& size)
{
- MemStatAccumulator& accumulator = sMemStat.getCurrentAccumulator();
+ MemStatAccumulator& accumulator = sMemStat.getPrimaryAccumulator();
accumulator.mSize.sample(accumulator.mSize.hasValue() ? accumulator.mSize.getLastValue() - (F64)size : -(F64)size);
return size;
}
@@ -521,17 +552,17 @@ class MemTrackable
{
static void claim(mem_trackable_t& tracker, const TRACKED& tracked)
{
- MemStatAccumulator& accumulator = sMemStat.getCurrentAccumulator();
+ MemStatAccumulator& accumulator = sMemStat.getPrimaryAccumulator();
size_t footprint = MemFootprint<TRACKED>::measure(tracked);
- accumulator.mSize.sample(accumulator.mSize.hasValue() ? accumulator.mSize.getLastValue() + (F64)footprint : (F64)footprint);
+ claim_mem(sMemStat, footprint);
tracker.mMemFootprint += footprint;
}
static void disclaim(mem_trackable_t& tracker, const TRACKED& tracked)
{
- MemStatAccumulator& accumulator = sMemStat.getCurrentAccumulator();
+ MemStatAccumulator& accumulator = sMemStat.getPrimaryAccumulator();
size_t footprint = MemFootprint<TRACKED>::measure(tracked);
- accumulator.mSize.sample(accumulator.mSize.hasValue() ? accumulator.mSize.getLastValue() - (F64)footprint : -(F64)footprint);
+ disclaim_mem(sMemStat, footprint);
tracker.mMemFootprint -= footprint;
}
};
@@ -541,13 +572,13 @@ class MemTrackable
{
static void claim(mem_trackable_t& tracker, TRACKED& tracked)
{
- MemStatAccumulator& accumulator = sMemStat.getCurrentAccumulator();
+ MemStatAccumulator& accumulator = sMemStat.getPrimaryAccumulator();
accumulator.mChildSize.sample(accumulator.mChildSize.hasValue() ? accumulator.mChildSize.getLastValue() + (F64)MemFootprint<TRACKED>::measure(tracked) : (F64)MemFootprint<TRACKED>::measure(tracked));
}
static void disclaim(mem_trackable_t& tracker, TRACKED& tracked)
{
- MemStatAccumulator& accumulator = sMemStat.getCurrentAccumulator();
+ MemStatAccumulator& accumulator = sMemStat.getPrimaryAccumulator();
accumulator.mChildSize.sample(accumulator.mChildSize.hasValue() ? accumulator.mChildSize.getLastValue() - (F64)MemFootprint<TRACKED>::measure(tracked) : -(F64)MemFootprint<TRACKED>::measure(tracked));
}
};
diff --git a/indra/llcommon/lltraceaccumulators.cpp b/indra/llcommon/lltraceaccumulators.cpp
index b234f43337ff402347329fab87617c9dbfda09ec..58d0b5b22711bbb04780c419e8799f571cfe80a1 100644
--- a/indra/llcommon/lltraceaccumulators.cpp
+++ b/indra/llcommon/lltraceaccumulators.cpp
@@ -70,13 +70,13 @@ void AccumulatorBufferGroup::makeCurrent()
}
//static
-void AccumulatorBufferGroup::resetCurrent()
+void AccumulatorBufferGroup::clearCurrent()
{
- AccumulatorBuffer<CountAccumulator>::resetCurrent();
- AccumulatorBuffer<SampleAccumulator>::resetCurrent();
- AccumulatorBuffer<EventAccumulator>::resetCurrent();
- AccumulatorBuffer<TimeBlockAccumulator>::resetCurrent();
- AccumulatorBuffer<MemStatAccumulator>::resetCurrent();
+ AccumulatorBuffer<CountAccumulator>::clearCurrent();
+ AccumulatorBuffer<SampleAccumulator>::clearCurrent();
+ AccumulatorBuffer<EventAccumulator>::clearCurrent();
+ AccumulatorBuffer<TimeBlockAccumulator>::clearCurrent();
+ AccumulatorBuffer<MemStatAccumulator>::clearCurrent();
}
bool AccumulatorBufferGroup::isCurrent() const
diff --git a/indra/llcommon/lltraceaccumulators.h b/indra/llcommon/lltraceaccumulators.h
index e31058ab4b8a5d8ec31dd6316d49cdbdff08d631..c5a0693fefaccc2f401d92ef4a10d1739d831237 100644
--- a/indra/llcommon/lltraceaccumulators.h
+++ b/indra/llcommon/lltraceaccumulators.h
@@ -138,17 +138,11 @@ namespace LLTrace
return LLThreadLocalSingletonPointer<ACCUMULATOR>::getInstance() == mStorage;
}
- static void resetCurrent()
+ static void clearCurrent()
{
LLThreadLocalSingletonPointer<ACCUMULATOR>::setInstance(NULL);
}
- LL_FORCE_INLINE static ACCUMULATOR* getCurrentStorage()
- {
- ACCUMULATOR* accumulator = LLThreadLocalSingletonPointer<ACCUMULATOR>::getInstance();
- return accumulator ? accumulator : getDefaultBuffer()->mStorage;
- }
-
// NOTE: this is not thread-safe. We assume that slots are reserved in the main thread before any child threads are spawned
size_t reserveSlot()
{
@@ -491,7 +485,7 @@ namespace LLTrace
typedef U32 value_t;
};
- struct ChildMemFacet
+ struct ShadowMemFacet
{
typedef F64Bytes value_t;
};
@@ -504,7 +498,7 @@ namespace LLTrace
void addSamples(const MemStatAccumulator& other, EBufferAppendType append_type)
{
mSize.addSamples(other.mSize, append_type);
- mChildSize.addSamples(other.mChildSize, append_type);
+ mShadowSize.addSamples(other.mShadowSize, append_type);
mAllocatedCount += other.mAllocatedCount;
mDeallocatedCount += other.mDeallocatedCount;
}
@@ -512,7 +506,7 @@ namespace LLTrace
void reset(const MemStatAccumulator* other)
{
mSize.reset(other ? &other->mSize : NULL);
- mChildSize.reset(other ? &other->mChildSize : NULL);
+ mShadowSize.reset(other ? &other->mShadowSize : NULL);
mAllocatedCount = 0;
mDeallocatedCount = 0;
}
@@ -520,11 +514,11 @@ namespace LLTrace
void sync(F64SecondsImplicit time_stamp)
{
mSize.sync(time_stamp);
- mChildSize.sync(time_stamp);
+ mShadowSize.sync(time_stamp);
}
SampleAccumulator mSize,
- mChildSize;
+ mShadowSize;
int mAllocatedCount,
mDeallocatedCount;
};
@@ -536,7 +530,7 @@ namespace LLTrace
void handOffTo(AccumulatorBufferGroup& other);
void makeCurrent();
bool isCurrent() const;
- static void resetCurrent();
+ static void clearCurrent();
void append(const AccumulatorBufferGroup& other);
void merge(const AccumulatorBufferGroup& other);
diff --git a/indra/llcommon/lltracerecording.cpp b/indra/llcommon/lltracerecording.cpp
index bc98eebf313c94a4dc52e20d0cf170ef2d52ab33..c278901bc09a13ab6a45edbb9432867c48a923fb 100644
--- a/indra/llcommon/lltracerecording.cpp
+++ b/indra/llcommon/lltracerecording.cpp
@@ -193,29 +193,29 @@ F64Bytes Recording::getLastValue(const TraceType<MemStatAccumulator>& stat)
return F64Bytes(mBuffers->mMemStats[stat.getIndex()].mSize.getLastValue());
}
-F64Bytes Recording::getMin(const TraceType<MemStatAccumulator::ChildMemFacet>& stat)
+F64Bytes Recording::getMin(const TraceType<MemStatAccumulator::ShadowMemFacet>& stat)
{
- return F64Bytes(mBuffers->mMemStats[stat.getIndex()].mChildSize.getMin());
+ return F64Bytes(mBuffers->mMemStats[stat.getIndex()].mShadowSize.getMin());
}
-F64Bytes Recording::getMean(const TraceType<MemStatAccumulator::ChildMemFacet>& stat)
+F64Bytes Recording::getMean(const TraceType<MemStatAccumulator::ShadowMemFacet>& stat)
{
- return F64Bytes(mBuffers->mMemStats[stat.getIndex()].mChildSize.getMean());
+ return F64Bytes(mBuffers->mMemStats[stat.getIndex()].mShadowSize.getMean());
}
-F64Bytes Recording::getMax(const TraceType<MemStatAccumulator::ChildMemFacet>& stat)
+F64Bytes Recording::getMax(const TraceType<MemStatAccumulator::ShadowMemFacet>& stat)
{
- return F64Bytes(mBuffers->mMemStats[stat.getIndex()].mChildSize.getMax());
+ return F64Bytes(mBuffers->mMemStats[stat.getIndex()].mShadowSize.getMax());
}
-F64Bytes Recording::getStandardDeviation(const TraceType<MemStatAccumulator::ChildMemFacet>& stat)
+F64Bytes Recording::getStandardDeviation(const TraceType<MemStatAccumulator::ShadowMemFacet>& stat)
{
- return F64Bytes(mBuffers->mMemStats[stat.getIndex()].mChildSize.getStandardDeviation());
+ return F64Bytes(mBuffers->mMemStats[stat.getIndex()].mShadowSize.getStandardDeviation());
}
-F64Bytes Recording::getLastValue(const TraceType<MemStatAccumulator::ChildMemFacet>& stat)
+F64Bytes Recording::getLastValue(const TraceType<MemStatAccumulator::ShadowMemFacet>& stat)
{
- return F64Bytes(mBuffers->mMemStats[stat.getIndex()].mChildSize.getLastValue());
+ return F64Bytes(mBuffers->mMemStats[stat.getIndex()].mShadowSize.getLastValue());
}
U32 Recording::getSum(const TraceType<MemStatAccumulator::AllocationCountFacet>& stat)
diff --git a/indra/llcommon/lltracerecording.h b/indra/llcommon/lltracerecording.h
index ea090e6ee1cb23fc6c4863f2efef4d45e0f4858d..9550838798852c096586e0863305b6886e1f3bad 100644
--- a/indra/llcommon/lltracerecording.h
+++ b/indra/llcommon/lltracerecording.h
@@ -181,11 +181,11 @@ namespace LLTrace
F64Bytes getStandardDeviation(const TraceType<MemStatAccumulator>& stat);
F64Bytes getLastValue(const TraceType<MemStatAccumulator>& stat);
- F64Bytes getMin(const TraceType<MemStatAccumulator::ChildMemFacet>& stat);
- F64Bytes getMean(const TraceType<MemStatAccumulator::ChildMemFacet>& stat);
- F64Bytes getMax(const TraceType<MemStatAccumulator::ChildMemFacet>& stat);
- F64Bytes getStandardDeviation(const TraceType<MemStatAccumulator::ChildMemFacet>& stat);
- F64Bytes getLastValue(const TraceType<MemStatAccumulator::ChildMemFacet>& stat);
+ F64Bytes getMin(const TraceType<MemStatAccumulator::ShadowMemFacet>& stat);
+ F64Bytes getMean(const TraceType<MemStatAccumulator::ShadowMemFacet>& stat);
+ F64Bytes getMax(const TraceType<MemStatAccumulator::ShadowMemFacet>& stat);
+ F64Bytes getStandardDeviation(const TraceType<MemStatAccumulator::ShadowMemFacet>& stat);
+ F64Bytes getLastValue(const TraceType<MemStatAccumulator::ShadowMemFacet>& stat);
U32 getSum(const TraceType<MemStatAccumulator::AllocationCountFacet>& stat);
U32 getSum(const TraceType<MemStatAccumulator::DeallocationCountFacet>& stat);
diff --git a/indra/llcommon/lltracethreadrecorder.cpp b/indra/llcommon/lltracethreadrecorder.cpp
index 8cddc49e719ef9b90956b09d6719bcee5e54dcb8..d3d9eb5ca70b10416ad0990673124ad8f7a37664 100644
--- a/indra/llcommon/lltracethreadrecorder.cpp
+++ b/indra/llcommon/lltracethreadrecorder.cpp
@@ -194,7 +194,7 @@ void ThreadRecorder::deactivate( AccumulatorBufferGroup* recording )
{
if (mActiveRecordings.empty())
{
- AccumulatorBufferGroup::resetCurrent();
+ AccumulatorBufferGroup::clearCurrent();
}
else
{