livie
/
phoenix-firestorm
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

merge

meow-7.2.2
Richard Linden 2013-09-18 14:20:30 -07:00
parent e9515b4731
commit 72f979135b
6 changed files with 85 additions and 60 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

81
indra/llcommon/lltrace.h
View File

@ -80,8 +80,8 @@ public:
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 @@ public:
};
template<>
class TraceType<MemStatAccumulator::ChildMemFacet>
class TraceType<MemStatAccumulator::ShadowMemFacet>
: public TraceType<MemStatAccumulator>
{
public:
@ -258,12 +258,51 @@ public:
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 @@ public:
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 @@ public:
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 @@ public:
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 @@ public:
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 @@ public:
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 @@ public:
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 @@ private:
{
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 @@ private:
{
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));
}
};

12
indra/llcommon/lltraceaccumulators.cpp
View File

@ -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

20
indra/llcommon/lltraceaccumulators.h
View File

@ -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);

20
indra/llcommon/lltracerecording.cpp
View File

@ -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)

10
indra/llcommon/lltracerecording.h
View File

@ -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);

2
indra/llcommon/lltracethreadrecorder.cpp
View File

@ -194,7 +194,7 @@ void ThreadRecorder::deactivate( AccumulatorBufferGroup* recording )
{
if (mActiveRecordings.empty())
{
AccumulatorBufferGroup::resetCurrent();
AccumulatorBufferGroup::clearCurrent();
}
else
{