diff options
Diffstat (limited to 'indra')
30 files changed, 439 insertions, 447 deletions
diff --git a/indra/llcommon/llfasttimer.cpp b/indra/llcommon/llfasttimer.cpp index 32ef01b2b6..c948e0ac85 100755 --- a/indra/llcommon/llfasttimer.cpp +++ b/indra/llcommon/llfasttimer.cpp @@ -165,7 +165,7 @@ U64 TimeBlock::countsPerSecond() #endif TimeBlock::TimeBlock(const char* name, TimeBlock* parent) -: TraceType<TimeBlockAccumulator>(name) +: StatType<TimeBlockAccumulator>(name) {} TimeBlockTreeNode& TimeBlock::getTreeNode() const diff --git a/indra/llcommon/llfasttimer.h b/indra/llcommon/llfasttimer.h index 4eb12907dc..1266d87f08 100755 --- a/indra/llcommon/llfasttimer.h +++ b/indra/llcommon/llfasttimer.h @@ -86,7 +86,7 @@ LL_FORCE_INLINE class BlockTimer timeThisBlock(class TimeBlock& timer) // stores a "named" timer instance to be reused via multiple BlockTimer stack instances class TimeBlock -: public TraceType<TimeBlockAccumulator>, +: public StatType<TimeBlockAccumulator>, public LLInstanceTracker<TimeBlock> { public: @@ -102,14 +102,14 @@ public: child_iter endChildren(); std::vector<TimeBlock*>& getChildren(); - TraceType<TimeBlockAccumulator::CallCountFacet>& callCount() + StatType<TimeBlockAccumulator::CallCountFacet>& callCount() { - return static_cast<TraceType<TimeBlockAccumulator::CallCountFacet>&>(*(TraceType<TimeBlockAccumulator>*)this); + return static_cast<StatType<TimeBlockAccumulator::CallCountFacet>&>(*(StatType<TimeBlockAccumulator>*)this); } - TraceType<TimeBlockAccumulator::SelfTimeFacet>& selfTime() + StatType<TimeBlockAccumulator::SelfTimeFacet>& selfTime() { - return static_cast<TraceType<TimeBlockAccumulator::SelfTimeFacet>&>(*(TraceType<TimeBlockAccumulator>*)this); + return static_cast<StatType<TimeBlockAccumulator::SelfTimeFacet>&>(*(StatType<TimeBlockAccumulator>*)this); } static TimeBlock& getRootTimeBlock(); diff --git a/indra/llcommon/lltrace.cpp b/indra/llcommon/lltrace.cpp index 73846ba900..1ad31cacfe 100644 --- a/indra/llcommon/lltrace.cpp +++ b/indra/llcommon/lltrace.cpp @@ -35,7 +35,7 @@ namespace LLTrace MemStatHandle gTraceMemStat("LLTrace"); -TraceBase::TraceBase( const char* name, const char* description ) +StatBase::StatBase( const char* name, const char* description ) : mName(name), mDescription(description ? description : "") { @@ -47,7 +47,7 @@ TraceBase::TraceBase( const char* name, const char* description ) #endif } -const char* TraceBase::getUnitLabel() const +const char* StatBase::getUnitLabel() const { return ""; } diff --git a/indra/llcommon/lltrace.h b/indra/llcommon/lltrace.h index 3dc2e5248f..325112b9b1 100644 --- a/indra/llcommon/lltrace.h +++ b/indra/llcommon/lltrace.h @@ -38,8 +38,6 @@ #include "llpointer.h" #include "llunits.h" -#include <list> - namespace LLTrace { class Recording; @@ -53,11 +51,11 @@ STORAGE_TYPE storage_value(LLUnit<STORAGE_TYPE, UNIT_TYPE> val) { return val.val template<typename UNIT_TYPE, typename STORAGE_TYPE> STORAGE_TYPE storage_value(LLUnitImplicit<STORAGE_TYPE, UNIT_TYPE> val) { return val.value(); } -class TraceBase +class StatBase { public: - TraceBase(const char* name, const char* description); - virtual ~TraceBase() {}; + StatBase(const char* name, const char* description); + virtual ~StatBase() {}; virtual const char* getUnitLabel() const; const std::string& getName() const { return mName; } @@ -69,14 +67,14 @@ protected: }; template<typename ACCUMULATOR> -class TraceType -: public TraceBase, - public LLInstanceTracker<TraceType<ACCUMULATOR>, std::string> +class StatType +: public StatBase, + public LLInstanceTracker<StatType<ACCUMULATOR>, std::string> { public: - TraceType(const char* name, const char* description = NULL) - : LLInstanceTracker<TraceType<ACCUMULATOR>, std::string>(name), - TraceBase(name, description), + StatType(const char* name, const char* description = NULL) + : LLInstanceTracker<StatType<ACCUMULATOR>, std::string>(name), + StatBase(name, description), mAccumulatorIndex(AccumulatorBuffer<ACCUMULATOR>::getDefaultBuffer()->reserveSlot()) {} @@ -95,38 +93,38 @@ protected: template<> -class TraceType<TimeBlockAccumulator::CallCountFacet> -: public TraceType<TimeBlockAccumulator> +class StatType<TimeBlockAccumulator::CallCountFacet> +: public StatType<TimeBlockAccumulator> { public: - TraceType(const char* name, const char* description = "") - : TraceType<TimeBlockAccumulator>(name, description) + StatType(const char* name, const char* description = "") + : StatType<TimeBlockAccumulator>(name, description) {} }; template<> -class TraceType<TimeBlockAccumulator::SelfTimeFacet> - : public TraceType<TimeBlockAccumulator> +class StatType<TimeBlockAccumulator::SelfTimeFacet> + : public StatType<TimeBlockAccumulator> { public: - TraceType(const char* name, const char* description = "") - : TraceType<TimeBlockAccumulator>(name, description) + StatType(const char* name, const char* description = "") + : StatType<TimeBlockAccumulator>(name, description) {} }; template <typename T = F64> class EventStatHandle -: public TraceType<EventAccumulator> +: public StatType<EventAccumulator> { public: typedef F64 storage_t; - typedef TraceType<EventAccumulator> trace_t; + typedef StatType<EventAccumulator> stat_t; typedef EventStatHandle<T> self_t; EventStatHandle(const char* name, const char* description = NULL) - : trace_t(name, description) + : stat_t(name, description) {} /*virtual*/ const char* getUnitLabel() const { return LLGetUnitLabel<T>::getUnitLabel(); } @@ -142,15 +140,15 @@ void record(EventStatHandle<T>& measurement, VALUE_T value) template <typename T = F64> class SampleStatHandle -: public TraceType<SampleAccumulator> +: public StatType<SampleAccumulator> { public: typedef F64 storage_t; - typedef TraceType<SampleAccumulator> trace_t; + typedef StatType<SampleAccumulator> stat_t; typedef SampleStatHandle<T> self_t; SampleStatHandle(const char* name, const char* description = NULL) - : trace_t(name, description) + : stat_t(name, description) {} /*virtual*/ const char* getUnitLabel() const { return LLGetUnitLabel<T>::getUnitLabel(); } @@ -165,15 +163,15 @@ void sample(SampleStatHandle<T>& measurement, VALUE_T value) template <typename T = F64> class CountStatHandle -: public TraceType<CountAccumulator> +: public StatType<CountAccumulator> { public: typedef F64 storage_t; - typedef TraceType<CountAccumulator> trace_t; + typedef StatType<CountAccumulator> stat_t; typedef CountStatHandle<T> self_t; CountStatHandle(const char* name, const char* description = NULL) - : trace_t(name, description) + : stat_t(name, description) {} /*virtual*/ const char* getUnitLabel() const { return LLGetUnitLabel<T>::getUnitLabel(); } @@ -187,34 +185,36 @@ void add(CountStatHandle<T>& count, VALUE_T value) } template<> -class TraceType<MemStatAccumulator::AllocationFacet> -: public TraceType<MemStatAccumulator> +class StatType<MemAccumulator::AllocationFacet> +: public StatType<MemAccumulator> { public: - TraceType(const char* name, const char* description = "") - : TraceType<MemStatAccumulator>(name, description) + StatType(const char* name, const char* description = "") + : StatType<MemAccumulator>(name, description) {} }; template<> -class TraceType<MemStatAccumulator::DeallocationFacet> -: public TraceType<MemStatAccumulator> +class StatType<MemAccumulator::DeallocationFacet> +: public StatType<MemAccumulator> { public: - TraceType(const char* name, const char* description = "") - : TraceType<MemStatAccumulator>(name, description) + StatType(const char* name, const char* description = "") + : StatType<MemAccumulator>(name, description) {} }; -class MemStatHandle : public TraceType<MemStatAccumulator> +class MemStatHandle : public StatType<MemAccumulator> { public: - typedef TraceType<MemStatAccumulator> trace_t; + typedef StatType<MemAccumulator> stat_t; MemStatHandle(const char* name) - : trace_t(name) - {} + : stat_t(name) + { + mName = name; + } void setName(const char* name) { @@ -224,14 +224,14 @@ public: /*virtual*/ const char* getUnitLabel() const { return "KB"; } - TraceType<MemStatAccumulator::AllocationFacet>& allocations() + StatType<MemAccumulator::AllocationFacet>& allocations() { - return static_cast<TraceType<MemStatAccumulator::AllocationFacet>&>(*(TraceType<MemStatAccumulator>*)this); + return static_cast<StatType<MemAccumulator::AllocationFacet>&>(*(StatType<MemAccumulator>*)this); } - TraceType<MemStatAccumulator::DeallocationFacet>& deallocations() + StatType<MemAccumulator::DeallocationFacet>& deallocations() { - return static_cast<TraceType<MemStatAccumulator::DeallocationFacet>&>(*(TraceType<MemStatAccumulator>*)this); + return static_cast<StatType<MemAccumulator::DeallocationFacet>&>(*(StatType<MemAccumulator>*)this); } }; @@ -324,7 +324,7 @@ inline void claim_alloc(MemStatHandle& measurement, const T& value) { S32 size = MeasureMem<T>::measureFootprint(value); if(size == 0) return; - MemStatAccumulator& accumulator = measurement.getCurrentAccumulator(); + MemAccumulator& accumulator = measurement.getCurrentAccumulator(); accumulator.mSize.sample(accumulator.mSize.hasValue() ? accumulator.mSize.getLastValue() + (F64)size : (F64)size); accumulator.mAllocations.record(size); } @@ -334,18 +334,18 @@ inline void disclaim_alloc(MemStatHandle& measurement, const T& value) { S32 size = MeasureMem<T>::measureFootprint(value); if(size == 0) return; - MemStatAccumulator& accumulator = measurement.getCurrentAccumulator(); + MemAccumulator& accumulator = measurement.getCurrentAccumulator(); accumulator.mSize.sample(accumulator.mSize.hasValue() ? accumulator.mSize.getLastValue() - (F64)size : -(F64)size); accumulator.mDeallocations.add(size); } template<typename DERIVED, size_t ALIGNMENT = LL_DEFAULT_HEAP_ALIGN> -class MemTrackable +class MemTrackableNonVirtual { public: typedef void mem_trackable_tag_t; - MemTrackable(const char* name) + MemTrackableNonVirtual(const char* name) : mMemFootprint(0) { static bool name_initialized = false; @@ -356,7 +356,7 @@ public: } } - virtual ~MemTrackable() + ~MemTrackableNonVirtual() { disclaimMem(mMemFootprint); } @@ -374,12 +374,27 @@ public: return ll_aligned_malloc(ALIGNMENT, size); } + template<int CUSTOM_ALIGNMENT> + static void* aligned_new(size_t size) + { + claim_alloc(sMemStat, size); + return ll_aligned_malloc(CUSTOM_ALIGNMENT, size); + } + void operator delete(void* ptr, size_t size) { disclaim_alloc(sMemStat, size); ll_aligned_free(ALIGNMENT, ptr); } + template<int CUSTOM_ALIGNMENT> + static void aligned_delete(void* ptr, size_t size) + { + disclaim_alloc(sMemStat, size); + ll_aligned_free(CUSTOM_ALIGNMENT, ptr); + } + + void* operator new [](size_t size) { claim_alloc(sMemStat, size); @@ -420,7 +435,19 @@ private: }; template<typename DERIVED, size_t ALIGNMENT> -MemStatHandle MemTrackable<DERIVED, ALIGNMENT>::sMemStat(""); +MemStatHandle MemTrackableNonVirtual<DERIVED, ALIGNMENT>::sMemStat(typeid(MemTrackableNonVirtual<DERIVED, ALIGNMENT>).name()); +template<typename DERIVED, size_t ALIGNMENT = LL_DEFAULT_HEAP_ALIGN> +class MemTrackable : public MemTrackableNonVirtual<DERIVED, ALIGNMENT> +{ +public: + MemTrackable(const char* name) + : MemTrackableNonVirtual<DERIVED, ALIGNMENT>(name) + {} + + virtual ~MemTrackable() + {} +}; } + #endif // LL_LLTRACE_H diff --git a/indra/llcommon/lltraceaccumulators.cpp b/indra/llcommon/lltraceaccumulators.cpp index c25bb704f5..7d0e63e76a 100644 --- a/indra/llcommon/lltraceaccumulators.cpp +++ b/indra/llcommon/lltraceaccumulators.cpp @@ -45,7 +45,7 @@ AccumulatorBufferGroup::AccumulatorBufferGroup() 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)); + claim_alloc(gTraceMemStat, mMemStats.capacity() * sizeof(MemAccumulator)); } AccumulatorBufferGroup::AccumulatorBufferGroup(const AccumulatorBufferGroup& other) @@ -59,7 +59,7 @@ AccumulatorBufferGroup::AccumulatorBufferGroup(const AccumulatorBufferGroup& oth 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)); + claim_alloc(gTraceMemStat, mMemStats.capacity() * sizeof(MemAccumulator)); } AccumulatorBufferGroup::~AccumulatorBufferGroup() @@ -68,7 +68,7 @@ AccumulatorBufferGroup::~AccumulatorBufferGroup() 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)); + disclaim_alloc(gTraceMemStat, mMemStats.capacity() * sizeof(MemAccumulator)); } void AccumulatorBufferGroup::handOffTo(AccumulatorBufferGroup& other) @@ -108,7 +108,7 @@ void AccumulatorBufferGroup::clearCurrent() AccumulatorBuffer<SampleAccumulator>::clearCurrent(); AccumulatorBuffer<EventAccumulator>::clearCurrent(); AccumulatorBuffer<TimeBlockAccumulator>::clearCurrent(); - AccumulatorBuffer<MemStatAccumulator>::clearCurrent(); + AccumulatorBuffer<MemAccumulator>::clearCurrent(); } bool AccumulatorBufferGroup::isCurrent() const diff --git a/indra/llcommon/lltraceaccumulators.h b/indra/llcommon/lltraceaccumulators.h index 27c0910665..85873d469a 100644 --- a/indra/llcommon/lltraceaccumulators.h +++ b/indra/llcommon/lltraceaccumulators.h @@ -52,7 +52,7 @@ namespace LLTrace class AccumulatorBuffer : public LLRefCount { typedef AccumulatorBuffer<ACCUMULATOR> self_t; - static const S32 ACCUMULATOR_BUFFER_SIZE_INCREMENT = 16; + static const S32 DEFAULT_ACCUMULATOR_BUFFER_SIZE = 32; private: struct StaticAllocationMarker { }; @@ -67,7 +67,7 @@ namespace LLTrace : mStorageSize(0), mStorage(NULL) { - resize(other.mStorageSize); + resize(sNextStorageSlot); for (S32 i = 0; i < sNextStorageSlot; i++) { mStorage[i] = other.mStorage[i]; @@ -152,7 +152,7 @@ namespace LLTrace { // don't perform doubling, as this should only happen during startup // want to keep a tight bounds as we will have a lot of these buffers - resize(mStorageSize + ACCUMULATOR_BUFFER_SIZE_INCREMENT); + resize(mStorageSize + mStorageSize / 2); } llassert(mStorage && next_slot < mStorageSize); return next_slot; @@ -207,7 +207,7 @@ namespace LLTrace // so as not to trigger an access violation sDefaultBuffer = new AccumulatorBuffer(StaticAllocationMarker()); sInitialized = true; - sDefaultBuffer->resize(ACCUMULATOR_BUFFER_SIZE_INCREMENT); + sDefaultBuffer->resize(DEFAULT_ACCUMULATOR_BUFFER_SIZE); } return sDefaultBuffer; } @@ -491,9 +491,9 @@ namespace LLTrace U64 mChildTime; }; - struct MemStatAccumulator + struct MemAccumulator { - typedef MemStatAccumulator self_t; + typedef MemAccumulator self_t; // fake classes that allows us to view different facets of underlying statistic struct AllocationFacet @@ -506,7 +506,7 @@ namespace LLTrace typedef F64Bytes value_t; }; - void addSamples(const MemStatAccumulator& other, EBufferAppendType append_type) + void addSamples(const MemAccumulator& other, EBufferAppendType append_type) { mAllocations.addSamples(other.mAllocations, append_type); mDeallocations.addSamples(other.mDeallocations, append_type); @@ -524,7 +524,7 @@ namespace LLTrace } } - void reset(const MemStatAccumulator* other) + void reset(const MemAccumulator* other) { mSize.reset(other ? &other->mSize : NULL); mAllocations.reset(other ? &other->mAllocations : NULL); @@ -561,7 +561,7 @@ namespace LLTrace AccumulatorBuffer<SampleAccumulator> mSamples; AccumulatorBuffer<EventAccumulator> mEvents; AccumulatorBuffer<TimeBlockAccumulator> mStackTimers; - AccumulatorBuffer<MemStatAccumulator> mMemStats; + AccumulatorBuffer<MemAccumulator> mMemStats; }; } diff --git a/indra/llcommon/lltracerecording.cpp b/indra/llcommon/lltracerecording.cpp index 06b4351339..87083eee96 100644 --- a/indra/llcommon/lltracerecording.cpp +++ b/indra/llcommon/lltracerecording.cpp @@ -137,26 +137,26 @@ void Recording::appendRecording( Recording& other ) mElapsedSeconds += other.mElapsedSeconds; } -F64Seconds Recording::getSum(const TraceType<TimeBlockAccumulator>& stat) +F64Seconds Recording::getSum(const StatType<TimeBlockAccumulator>& stat) { const TimeBlockAccumulator& accumulator = mBuffers->mStackTimers[stat.getIndex()]; return F64Seconds((F64)(accumulator.mTotalTimeCounter) / (F64)LLTrace::TimeBlock::countsPerSecond()); } -F64Seconds Recording::getSum(const TraceType<TimeBlockAccumulator::SelfTimeFacet>& stat) +F64Seconds Recording::getSum(const StatType<TimeBlockAccumulator::SelfTimeFacet>& stat) { const TimeBlockAccumulator& accumulator = mBuffers->mStackTimers[stat.getIndex()]; return F64Seconds((F64)(accumulator.mSelfTimeCounter) / (F64)LLTrace::TimeBlock::countsPerSecond()); } -S32 Recording::getSum(const TraceType<TimeBlockAccumulator::CallCountFacet>& stat) +S32 Recording::getSum(const StatType<TimeBlockAccumulator::CallCountFacet>& stat) { return mBuffers->mStackTimers[stat.getIndex()].mCalls; } -F64Seconds Recording::getPerSec(const TraceType<TimeBlockAccumulator>& stat) +F64Seconds Recording::getPerSec(const StatType<TimeBlockAccumulator>& stat) { const TimeBlockAccumulator& accumulator = mBuffers->mStackTimers[stat.getIndex()]; @@ -164,7 +164,7 @@ F64Seconds Recording::getPerSec(const TraceType<TimeBlockAccumulator>& stat) / ((F64)LLTrace::TimeBlock::countsPerSecond() * mElapsedSeconds.value())); } -F64Seconds Recording::getPerSec(const TraceType<TimeBlockAccumulator::SelfTimeFacet>& stat) +F64Seconds Recording::getPerSec(const StatType<TimeBlockAccumulator::SelfTimeFacet>& stat) { const TimeBlockAccumulator& accumulator = mBuffers->mStackTimers[stat.getIndex()]; @@ -172,158 +172,158 @@ F64Seconds Recording::getPerSec(const TraceType<TimeBlockAccumulator::SelfTimeFa / ((F64)LLTrace::TimeBlock::countsPerSecond() * mElapsedSeconds.value())); } -F32 Recording::getPerSec(const TraceType<TimeBlockAccumulator::CallCountFacet>& stat) +F32 Recording::getPerSec(const StatType<TimeBlockAccumulator::CallCountFacet>& stat) { return (F32)mBuffers->mStackTimers[stat.getIndex()].mCalls / mElapsedSeconds.value(); } -bool Recording::hasValue(const TraceType<MemStatAccumulator>& stat) +bool Recording::hasValue(const StatType<MemAccumulator>& stat) { return mBuffers->mMemStats[stat.getIndex()].mSize.hasValue(); } -F64Kilobytes Recording::getMin(const TraceType<MemStatAccumulator>& stat) +F64Kilobytes Recording::getMin(const StatType<MemAccumulator>& stat) { return F64Bytes(mBuffers->mMemStats[stat.getIndex()].mSize.getMin()); } -F64Kilobytes Recording::getMean(const TraceType<MemStatAccumulator>& stat) +F64Kilobytes Recording::getMean(const StatType<MemAccumulator>& stat) { return F64Bytes(mBuffers->mMemStats[stat.getIndex()].mSize.getMean()); } -F64Kilobytes Recording::getMax(const TraceType<MemStatAccumulator>& stat) +F64Kilobytes Recording::getMax(const StatType<MemAccumulator>& stat) { return F64Bytes(mBuffers->mMemStats[stat.getIndex()].mSize.getMax()); } -F64Kilobytes Recording::getStandardDeviation(const TraceType<MemStatAccumulator>& stat) +F64Kilobytes Recording::getStandardDeviation(const StatType<MemAccumulator>& stat) { return F64Bytes(mBuffers->mMemStats[stat.getIndex()].mSize.getStandardDeviation()); } -F64Kilobytes Recording::getLastValue(const TraceType<MemStatAccumulator>& stat) +F64Kilobytes Recording::getLastValue(const StatType<MemAccumulator>& stat) { return F64Bytes(mBuffers->mMemStats[stat.getIndex()].mSize.getLastValue()); } -F64Kilobytes Recording::getSum(const TraceType<MemStatAccumulator::AllocationFacet>& stat) +F64Kilobytes Recording::getSum(const StatType<MemAccumulator::AllocationFacet>& stat) { return F64Bytes(mBuffers->mMemStats[stat.getIndex()].mAllocations.getSum()); } -F64Kilobytes Recording::getPerSec(const TraceType<MemStatAccumulator::AllocationFacet>& stat) +F64Kilobytes Recording::getPerSec(const StatType<MemAccumulator::AllocationFacet>& stat) { return F64Bytes(mBuffers->mMemStats[stat.getIndex()].mAllocations.getSum() / mElapsedSeconds.value()); } -S32 Recording::getSampleCount(const TraceType<MemStatAccumulator::AllocationFacet>& stat) +S32 Recording::getSampleCount(const StatType<MemAccumulator::AllocationFacet>& stat) { return mBuffers->mMemStats[stat.getIndex()].mAllocations.getSampleCount(); } -F64Kilobytes Recording::getSum(const TraceType<MemStatAccumulator::DeallocationFacet>& stat) +F64Kilobytes Recording::getSum(const StatType<MemAccumulator::DeallocationFacet>& stat) { return F64Bytes(mBuffers->mMemStats[stat.getIndex()].mDeallocations.getSum()); } -F64Kilobytes Recording::getPerSec(const TraceType<MemStatAccumulator::DeallocationFacet>& stat) +F64Kilobytes Recording::getPerSec(const StatType<MemAccumulator::DeallocationFacet>& stat) { return F64Bytes(mBuffers->mMemStats[stat.getIndex()].mDeallocations.getSum() / mElapsedSeconds.value()); } -S32 Recording::getSampleCount(const TraceType<MemStatAccumulator::DeallocationFacet>& stat) +S32 Recording::getSampleCount(const StatType<MemAccumulator::DeallocationFacet>& stat) { return mBuffers->mMemStats[stat.getIndex()].mDeallocations.getSampleCount(); } -F64 Recording::getSum( const TraceType<CountAccumulator>& stat ) +F64 Recording::getSum( const StatType<CountAccumulator>& stat ) { return mBuffers->mCounts[stat.getIndex()].getSum(); } -F64 Recording::getSum( const TraceType<EventAccumulator>& stat ) +F64 Recording::getSum( const StatType<EventAccumulator>& stat ) { return (F64)mBuffers->mEvents[stat.getIndex()].getSum(); } -F64 Recording::getPerSec( const TraceType<CountAccumulator>& stat ) +F64 Recording::getPerSec( const StatType<CountAccumulator>& stat ) { F64 sum = mBuffers->mCounts[stat.getIndex()].getSum(); return sum / mElapsedSeconds.value(); } -S32 Recording::getSampleCount( const TraceType<CountAccumulator>& stat ) +S32 Recording::getSampleCount( const StatType<CountAccumulator>& stat ) { return mBuffers->mCounts[stat.getIndex()].getSampleCount(); } -bool Recording::hasValue(const TraceType<SampleAccumulator>& stat) +bool Recording::hasValue(const StatType<SampleAccumulator>& stat) { return mBuffers->mSamples[stat.getIndex()].hasValue(); } -F64 Recording::getMin( const TraceType<SampleAccumulator>& stat ) +F64 Recording::getMin( const StatType<SampleAccumulator>& stat ) { return mBuffers->mSamples[stat.getIndex()].getMin(); } -F64 Recording::getMax( const TraceType<SampleAccumulator>& stat ) +F64 Recording::getMax( const StatType<SampleAccumulator>& stat ) { return mBuffers->mSamples[stat.getIndex()].getMax(); } -F64 Recording::getMean( const TraceType<SampleAccumulator>& stat ) +F64 Recording::getMean( const StatType<SampleAccumulator>& stat ) { return mBuffers->mSamples[stat.getIndex()].getMean(); } -F64 Recording::getStandardDeviation( const TraceType<SampleAccumulator>& stat ) +F64 Recording::getStandardDeviation( const StatType<SampleAccumulator>& stat ) { return mBuffers->mSamples[stat.getIndex()].getStandardDeviation(); } -F64 Recording::getLastValue( const TraceType<SampleAccumulator>& stat ) +F64 Recording::getLastValue( const StatType<SampleAccumulator>& stat ) { return mBuffers->mSamples[stat.getIndex()].getLastValue(); } -S32 Recording::getSampleCount( const TraceType<SampleAccumulator>& stat ) +S32 Recording::getSampleCount( const StatType<SampleAccumulator>& stat ) { return mBuffers->mSamples[stat.getIndex()].getSampleCount(); } -bool Recording::hasValue(const TraceType<EventAccumulator>& stat) +bool Recording::hasValue(const StatType<EventAccumulator>& stat) { return mBuffers->mEvents[stat.getIndex()].hasValue(); } -F64 Recording::getMin( const TraceType<EventAccumulator>& stat ) +F64 Recording::getMin( const StatType<EventAccumulator>& stat ) { return mBuffers->mEvents[stat.getIndex()].getMin(); } -F64 Recording::getMax( const TraceType<EventAccumulator>& stat ) +F64 Recording::getMax( const StatType<EventAccumulator>& stat ) { return mBuffers->mEvents[stat.getIndex()].getMax(); } -F64 Recording::getMean( const TraceType<EventAccumulator>& stat ) +F64 Recording::getMean( const StatType<EventAccumulator>& stat ) { return mBuffers->mEvents[stat.getIndex()].getMean(); } -F64 Recording::getStandardDeviation( const TraceType<EventAccumulator>& stat ) +F64 Recording::getStandardDeviation( const StatType<EventAccumulator>& stat ) { return mBuffers->mEvents[stat.getIndex()].getStandardDeviation(); } -F64 Recording::getLastValue( const TraceType<EventAccumulator>& stat ) +F64 Recording::getLastValue( const StatType<EventAccumulator>& stat ) { return mBuffers->mEvents[stat.getIndex()].getLastValue(); } -S32 Recording::getSampleCount( const TraceType<EventAccumulator>& stat ) +S32 Recording::getSampleCount( const StatType<EventAccumulator>& stat ) { return mBuffers->mEvents[stat.getIndex()].getSampleCount(); } @@ -534,7 +534,7 @@ void PeriodicRecording::handleSplitTo(PeriodicRecording& other) getCurRecording().splitTo(other.getCurRecording()); } -F64 PeriodicRecording::getPeriodMin( const TraceType<EventAccumulator>& stat, S32 num_periods /*= S32_MAX*/ ) +F64 PeriodicRecording::getPeriodMin( const StatType<EventAccumulator>& stat, S32 num_periods /*= S32_MAX*/ ) { S32 total_periods = mRecordingPeriods.size(); num_periods = llmin(num_periods, isStarted() ? total_periods - 1 : total_periods); @@ -556,7 +556,7 @@ F64 PeriodicRecording::getPeriodMin( const TraceType<EventAccumulator>& stat, S3 : NaN; } -F64 PeriodicRecording::getPeriodMax( const TraceType<EventAccumulator>& stat, S32 num_periods /*= S32_MAX*/ ) +F64 PeriodicRecording::getPeriodMax( const StatType<EventAccumulator>& stat, S32 num_periods /*= S32_MAX*/ ) { S32 total_periods = mRecordingPeriods.size(); num_periods = llmin(num_periods, isStarted() ? total_periods - 1 : total_periods); @@ -579,7 +579,7 @@ F64 PeriodicRecording::getPeriodMax( const TraceType<EventAccumulator>& stat, S3 } // calculates means using aggregates per period -F64 PeriodicRecording::getPeriodMean( const TraceType<EventAccumulator>& stat, S32 num_periods /*= S32_MAX*/ ) +F64 PeriodicRecording::getPeriodMean( const StatType<EventAccumulator>& stat, S32 num_periods /*= S32_MAX*/ ) { S32 total_periods = mRecordingPeriods.size(); num_periods = llmin(num_periods, isStarted() ? total_periods - 1 : total_periods); @@ -603,7 +603,7 @@ F64 PeriodicRecording::getPeriodMean( const TraceType<EventAccumulator>& stat, S } -F64 PeriodicRecording::getPeriodStandardDeviation( const TraceType<EventAccumulator>& stat, S32 num_periods /*= S32_MAX*/ ) +F64 PeriodicRecording::getPeriodStandardDeviation( const StatType<EventAccumulator>& stat, S32 num_periods /*= S32_MAX*/ ) { S32 total_periods = mRecordingPeriods.size(); num_periods = llmin(num_periods, isStarted() ? total_periods - 1 : total_periods); @@ -628,7 +628,7 @@ F64 PeriodicRecording::getPeriodStandardDeviation( const TraceType<EventAccumula : NaN; } -F64 PeriodicRecording::getPeriodMin( const TraceType<SampleAccumulator>& stat, S32 num_periods /*= S32_MAX*/ ) +F64 PeriodicRecording::getPeriodMin( const StatType<SampleAccumulator>& stat, S32 num_periods /*= S32_MAX*/ ) { S32 total_periods = mRecordingPeriods.size(); num_periods = llmin(num_periods, isStarted() ? total_periods - 1 : total_periods); @@ -650,7 +650,7 @@ F64 PeriodicRecording::getPeriodMin( const TraceType<SampleAccumulator>& stat, S : NaN; } -F64 PeriodicRecording::getPeriodMax(const TraceType<SampleAccumulator>& stat, S32 num_periods /*= S32_MAX*/) +F64 PeriodicRecording::getPeriodMax(const StatType<SampleAccumulator>& stat, S32 num_periods /*= S32_MAX*/) { S32 total_periods = mRecordingPeriods.size(); num_periods = llmin(num_periods, isStarted() ? total_periods - 1 : total_periods); @@ -673,7 +673,7 @@ F64 PeriodicRecording::getPeriodMax(const TraceType<SampleAccumulator>& stat, S3 } -F64 PeriodicRecording::getPeriodMean( const TraceType<SampleAccumulator>& stat, S32 num_periods /*= S32_MAX*/ ) +F64 PeriodicRecording::getPeriodMean( const StatType<SampleAccumulator>& stat, S32 num_periods /*= S32_MAX*/ ) { S32 total_periods = mRecordingPeriods.size(); num_periods = llmin(num_periods, isStarted() ? total_periods - 1 : total_periods); @@ -696,7 +696,7 @@ F64 PeriodicRecording::getPeriodMean( const TraceType<SampleAccumulator>& stat, : NaN; } -F64 PeriodicRecording::getPeriodStandardDeviation( const TraceType<SampleAccumulator>& stat, S32 num_periods /*= S32_MAX*/ ) +F64 PeriodicRecording::getPeriodStandardDeviation( const StatType<SampleAccumulator>& stat, S32 num_periods /*= S32_MAX*/ ) { S32 total_periods = mRecordingPeriods.size(); num_periods = llmin(num_periods, isStarted() ? total_periods - 1 : total_periods); @@ -722,7 +722,7 @@ F64 PeriodicRecording::getPeriodStandardDeviation( const TraceType<SampleAccumul } -F64Kilobytes PeriodicRecording::getPeriodMin( const TraceType<MemStatAccumulator>& stat, S32 num_periods /*= S32_MAX*/ ) +F64Kilobytes PeriodicRecording::getPeriodMin( const StatType<MemAccumulator>& stat, S32 num_periods /*= S32_MAX*/ ) { S32 total_periods = mRecordingPeriods.size(); num_periods = llmin(num_periods, isStarted() ? total_periods - 1 : total_periods); @@ -739,10 +739,10 @@ F64Kilobytes PeriodicRecording::getPeriodMin( const TraceType<MemStatAccumulator F64Kilobytes PeriodicRecording::getPeriodMin(const MemStatHandle& stat, S32 num_periods) { - return getPeriodMin(static_cast<const TraceType<MemStatAccumulator>&>(stat), num_periods); + return getPeriodMin(static_cast<const StatType<MemAccumulator>&>(stat), num_periods); } -F64Kilobytes PeriodicRecording::getPeriodMax(const TraceType<MemStatAccumulator>& stat, S32 num_periods /*= S32_MAX*/) +F64Kilobytes PeriodicRecording::getPeriodMax(const StatType<MemAccumulator>& stat, S32 num_periods /*= S32_MAX*/) { S32 total_periods = mRecordingPeriods.size(); num_periods = llmin(num_periods, isStarted() ? total_periods - 1 : total_periods); @@ -759,10 +759,10 @@ F64Kilobytes PeriodicRecording::getPeriodMax(const TraceType<MemStatAccumulator> F64Kilobytes PeriodicRecording::getPeriodMax(const MemStatHandle& stat, S32 num_periods) { - return getPeriodMax(static_cast<const TraceType<MemStatAccumulator>&>(stat), num_periods); + return getPeriodMax(static_cast<const StatType<MemAccumulator>&>(stat), num_periods); } -F64Kilobytes PeriodicRecording::getPeriodMean( const TraceType<MemStatAccumulator>& stat, S32 num_periods /*= S32_MAX*/ ) +F64Kilobytes PeriodicRecording::getPeriodMean( const StatType<MemAccumulator>& stat, S32 num_periods /*= S32_MAX*/ ) { S32 total_periods = mRecordingPeriods.size(); num_periods = llmin(num_periods, isStarted() ? total_periods - 1 : total_periods); @@ -780,10 +780,10 @@ F64Kilobytes PeriodicRecording::getPeriodMean( const TraceType<MemStatAccumulato F64Kilobytes PeriodicRecording::getPeriodMean(const MemStatHandle& stat, S32 num_periods) { - return getPeriodMean(static_cast<const TraceType<MemStatAccumulator>&>(stat), num_periods); + return getPeriodMean(static_cast<const StatType<MemAccumulator>&>(stat), num_periods); } -F64Kilobytes PeriodicRecording::getPeriodStandardDeviation( const TraceType<MemStatAccumulator>& stat, S32 num_periods /*= S32_MAX*/ ) +F64Kilobytes PeriodicRecording::getPeriodStandardDeviation( const StatType<MemAccumulator>& stat, S32 num_periods /*= S32_MAX*/ ) { S32 total_periods = mRecordingPeriods.size(); num_periods = llmin(num_periods, isStarted() ? total_periods - 1 : total_periods); @@ -810,7 +810,7 @@ F64Kilobytes PeriodicRecording::getPeriodStandardDeviation( const TraceType<MemS F64Kilobytes PeriodicRecording::getPeriodStandardDeviation(const MemStatHandle& stat, S32 num_periods) { - return getPeriodStandardDeviation(static_cast<const TraceType<MemStatAccumulator>&>(stat), num_periods); + return getPeriodStandardDeviation(static_cast<const StatType<MemAccumulator>&>(stat), num_periods); } /////////////////////////////////////////////////////////////////////// diff --git a/indra/llcommon/lltracerecording.h b/indra/llcommon/lltracerecording.h index 8bb0b1892f..810f796666 100644 --- a/indra/llcommon/lltracerecording.h +++ b/indra/llcommon/lltracerecording.h @@ -113,7 +113,7 @@ private: namespace LLTrace { template<typename T> - class TraceType; + class StatType; template<typename T> class CountStatHandle; @@ -168,135 +168,135 @@ namespace LLTrace void makeUnique() { mBuffers.makeUnique(); } // Timer accessors - F64Seconds getSum(const TraceType<TimeBlockAccumulator>& stat); - F64Seconds getSum(const TraceType<TimeBlockAccumulator::SelfTimeFacet>& stat); - S32 getSum(const TraceType<TimeBlockAccumulator::CallCountFacet>& stat); + F64Seconds getSum(const StatType<TimeBlockAccumulator>& stat); + F64Seconds getSum(const StatType<TimeBlockAccumulator::SelfTimeFacet>& stat); + S32 getSum(const StatType<TimeBlockAccumulator::CallCountFacet>& stat); - F64Seconds getPerSec(const TraceType<TimeBlockAccumulator>& stat); - F64Seconds getPerSec(const TraceType<TimeBlockAccumulator::SelfTimeFacet>& stat); - F32 getPerSec(const TraceType<TimeBlockAccumulator::CallCountFacet>& stat); + F64Seconds getPerSec(const StatType<TimeBlockAccumulator>& stat); + F64Seconds getPerSec(const StatType<TimeBlockAccumulator::SelfTimeFacet>& stat); + F32 getPerSec(const StatType<TimeBlockAccumulator::CallCountFacet>& stat); // Memory accessors - bool hasValue(const TraceType<MemStatAccumulator>& stat); + bool hasValue(const StatType<MemAccumulator>& stat); - F64Kilobytes getMin(const TraceType<MemStatAccumulator>& stat); - F64Kilobytes getMean(const TraceType<MemStatAccumulator>& stat); - F64Kilobytes getMax(const TraceType<MemStatAccumulator>& stat); - F64Kilobytes getStandardDeviation(const TraceType<MemStatAccumulator>& stat); - F64Kilobytes getLastValue(const TraceType<MemStatAccumulator>& stat); + F64Kilobytes getMin(const StatType<MemAccumulator>& stat); + F64Kilobytes getMean(const StatType<MemAccumulator>& stat); + F64Kilobytes getMax(const StatType<MemAccumulator>& stat); + F64Kilobytes getStandardDeviation(const StatType<MemAccumulator>& stat); + F64Kilobytes getLastValue(const StatType<MemAccumulator>& stat); - F64Kilobytes getSum(const TraceType<MemStatAccumulator::AllocationFacet>& stat); - F64Kilobytes getPerSec(const TraceType<MemStatAccumulator::AllocationFacet>& stat); - S32 getSampleCount(const TraceType<MemStatAccumulator::AllocationFacet>& stat); + F64Kilobytes getSum(const StatType<MemAccumulator::AllocationFacet>& stat); + F64Kilobytes getPerSec(const StatType<MemAccumulator::AllocationFacet>& stat); + S32 getSampleCount(const StatType<MemAccumulator::AllocationFacet>& stat); - F64Kilobytes getSum(const TraceType<MemStatAccumulator::DeallocationFacet>& stat); - F64Kilobytes getPerSec(const TraceType<MemStatAccumulator::DeallocationFacet>& stat); - S32 getSampleCount(const TraceType<MemStatAccumulator::DeallocationFacet>& stat); + F64Kilobytes getSum(const StatType<MemAccumulator::DeallocationFacet>& stat); + F64Kilobytes getPerSec(const StatType<MemAccumulator::DeallocationFacet>& stat); + S32 getSampleCount(const StatType<MemAccumulator::DeallocationFacet>& stat); // CountStatHandle accessors - F64 getSum(const TraceType<CountAccumulator>& stat); + F64 getSum(const StatType<CountAccumulator>& stat); template <typename T> typename RelatedTypes<T>::sum_t getSum(const CountStatHandle<T>& stat) { - return (typename RelatedTypes<T>::sum_t)getSum(static_cast<const TraceType<CountAccumulator>&> (stat)); + return (typename RelatedTypes<T>::sum_t)getSum(static_cast<const StatType<CountAccumulator>&> (stat)); } - F64 getPerSec(const TraceType<CountAccumulator>& stat); + F64 getPerSec(const StatType<CountAccumulator>& stat); template <typename T> typename RelatedTypes<T>::fractional_t getPerSec(const CountStatHandle<T>& stat) { - return (typename RelatedTypes<T>::fractional_t)getPerSec(static_cast<const TraceType<CountAccumulator>&> (stat)); + return (typename RelatedTypes<T>::fractional_t)getPerSec(static_cast<const StatType<CountAccumulator>&> (stat)); } - S32 getSampleCount(const TraceType<CountAccumulator>& stat); + S32 getSampleCount(const StatType<CountAccumulator>& stat); // SampleStatHandle accessors - bool hasValue(const TraceType<SampleAccumulator>& stat); + bool hasValue(const StatType<SampleAccumulator>& stat); - F64 getMin(const TraceType<SampleAccumulator>& stat); + F64 getMin(const StatType<SampleAccumulator>& stat); template <typename T> T getMin(const SampleStatHandle<T>& stat) { - return (T)getMin(static_cast<const TraceType<SampleAccumulator>&> (stat)); + return (T)getMin(static_cast<const StatType<SampleAccumulator>&> (stat)); } - F64 getMax(const TraceType<SampleAccumulator>& stat); + F64 getMax(const StatType<SampleAccumulator>& stat); template <typename T> T getMax(const SampleStatHandle<T>& stat) { - return (T)getMax(static_cast<const TraceType<SampleAccumulator>&> (stat)); + return (T)getMax(static_cast<const StatType<SampleAccumulator>&> (stat)); } - F64 getMean(const TraceType<SampleAccumulator>& stat); + F64 getMean(const StatType<SampleAccumulator>& stat); template <typename T> typename RelatedTypes<T>::fractional_t getMean(SampleStatHandle<T>& stat) { - return (typename RelatedTypes<T>::fractional_t)getMean(static_cast<const TraceType<SampleAccumulator>&> (stat)); + return (typename RelatedTypes<T>::fractional_t)getMean(static_cast<const StatType<SampleAccumulator>&> (stat)); } - F64 getStandardDeviation(const TraceType<SampleAccumulator>& stat); + F64 getStandardDeviation(const StatType<SampleAccumulator>& stat); template <typename T> typename RelatedTypes<T>::fractional_t getStandardDeviation(const SampleStatHandle<T>& stat) { - return (typename RelatedTypes<T>::fractional_t)getStandardDeviation(static_cast<const TraceType<SampleAccumulator>&> (stat)); + return (typename RelatedTypes<T>::fractional_t)getStandardDeviation(static_cast<const StatType<SampleAccumulator>&> (stat)); } - F64 getLastValue(const TraceType<SampleAccumulator>& stat); + F64 getLastValue(const StatType<SampleAccumulator>& stat); template <typename T> T getLastValue(const SampleStatHandle<T>& stat) { - return (T)getLastValue(static_cast<const TraceType<SampleAccumulator>&> (stat)); + return (T)getLastValue(static_cast<const StatType<SampleAccumulator>&> (stat)); } - S32 getSampleCount(const TraceType<SampleAccumulator>& stat); + S32 getSampleCount(const StatType<SampleAccumulator>& stat); // EventStatHandle accessors - bool hasValue(const TraceType<EventAccumulator>& stat); + bool hasValue(const StatType<EventAccumulator>& stat); - F64 getSum(const TraceType<EventAccumulator>& stat); + F64 getSum(const StatType<EventAccumulator>& stat); template <typename T> typename RelatedTypes<T>::sum_t getSum(const EventStatHandle<T>& stat) { - return (typename RelatedTypes<T>::sum_t)getSum(static_cast<const TraceType<EventAccumulator>&> (stat)); + return (typename RelatedTypes<T>::sum_t)getSum(static_cast<const StatType<EventAccumulator>&> (stat)); } - F64 getMin(const TraceType<EventAccumulator>& stat); + F64 getMin(const StatType<EventAccumulator>& stat); template <typename T> T getMin(const EventStatHandle<T>& stat) { - return (T)getMin(static_cast<const TraceType<EventAccumulator>&> (stat)); + return (T)getMin(static_cast<const StatType<EventAccumulator>&> (stat)); } - F64 getMax(const TraceType<EventAccumulator>& stat); + F64 getMax(const StatType<EventAccumulator>& stat); template <typename T> T getMax(const EventStatHandle<T>& stat) { - return (T)getMax(static_cast<const TraceType<EventAccumulator>&> (stat)); + return (T)getMax(static_cast<const StatType<EventAccumulator>&> (stat)); } - F64 getMean(const TraceType<EventAccumulator>& stat); + F64 getMean(const StatType<EventAccumulator>& stat); template <typename T> typename RelatedTypes<T>::fractional_t getMean(EventStatHandle<T>& stat) { - return (typename RelatedTypes<T>::fractional_t)getMean(static_cast<const TraceType<EventAccumulator>&> (stat)); + return (typename RelatedTypes<T>::fractional_t)getMean(static_cast<const StatType<EventAccumulator>&> (stat)); } - F64 getStandardDeviation(const TraceType<EventAccumulator>& stat); + F64 getStandardDeviation(const StatType<EventAccumulator>& stat); template <typename T> typename RelatedTypes<T>::fractional_t getStandardDeviation(const EventStatHandle<T>& stat) { - return (typename RelatedTypes<T>::fractional_t)getStandardDeviation(static_cast<const TraceType<EventAccumulator>&> (stat)); + return (typename RelatedTypes<T>::fractional_t)getStandardDeviation(static_cast<const StatType<EventAccumulator>&> (stat)); } - F64 getLastValue(const TraceType<EventAccumulator>& stat); + F64 getLastValue(const StatType<EventAccumulator>& stat); template <typename T> T getLastValue(const EventStatHandle<T>& stat) { - return (T)getLastValue(static_cast<const TraceType<EventAccumulator>&> (stat)); + return (T)getLastValue(static_cast<const StatType<EventAccumulator>&> (stat)); } - S32 getSampleCount(const TraceType<EventAccumulator>& stat); + S32 getSampleCount(const StatType<EventAccumulator>& stat); F64Seconds getDuration() const { return mElapsedSeconds; } @@ -342,7 +342,7 @@ namespace LLTrace Recording snapshotCurRecording() const; template <typename T> - S32 getSampleCount(const TraceType<T>& stat, S32 num_periods = S32_MAX) + S32 getSampleCount(const StatType<T>& stat, S32 num_periods = S32_MAX) { S32 total_periods = mNumPeriods; num_periods = llmin(num_periods, isStarted() ? total_periods - 1 : total_periods); @@ -362,7 +362,7 @@ namespace LLTrace // catch all for stats that have a defined sum template <typename T> - typename T::value_t getPeriodMin(const TraceType<T>& stat, S32 num_periods = S32_MAX) + typename T::value_t getPeriodMin(const StatType<T>& stat, S32 num_periods = S32_MAX) { S32 total_periods = mNumPeriods; num_periods = llmin(num_periods, isStarted() ? total_periods - 1 : total_periods); @@ -379,28 +379,28 @@ namespace LLTrace template<typename T> T getPeriodMin(const CountStatHandle<T>& stat, S32 num_periods = S32_MAX) { - return T(getPeriodMin(static_cast<const TraceType<CountAccumulator>&>(stat), num_periods)); + return T(getPeriodMin(static_cast<const StatType<CountAccumulator>&>(stat), num_periods)); } - F64 getPeriodMin(const TraceType<SampleAccumulator>& stat, S32 num_periods = S32_MAX); + F64 getPeriodMin(const StatType<SampleAccumulator>& stat, S32 num_periods = S32_MAX); template<typename T> T getPeriodMin(const SampleStatHandle<T>& stat, S32 num_periods = S32_MAX) { - return T(getPeriodMin(static_cast<const TraceType<SampleAccumulator>&>(stat), num_periods)); + return T(getPeriodMin(static_cast<const StatType<SampleAccumulator>&>(stat), num_periods)); } - F64 getPeriodMin(const TraceType<EventAccumulator>& stat, S32 num_periods = S32_MAX); + F64 getPeriodMin(const StatType<EventAccumulator>& stat, S32 num_periods = S32_MAX); template<typename T> T getPeriodMin(const EventStatHandle<T>& stat, S32 num_periods = S32_MAX) { - return T(getPeriodMin(static_cast<const TraceType<EventAccumulator>&>(stat), num_periods)); + return T(getPeriodMin(static_cast<const StatType<EventAccumulator>&>(stat), num_periods)); } - F64Kilobytes getPeriodMin(const TraceType<MemStatAccumulator>& stat, S32 num_periods = S32_MAX); + F64Kilobytes getPeriodMin(const StatType<MemAccumulator>& stat, S32 num_periods = S32_MAX); F64Kilobytes getPeriodMin(const MemStatHandle& stat, S32 num_periods = S32_MAX); template <typename T> - typename RelatedTypes<typename T::value_t>::fractional_t getPeriodMinPerSec(const TraceType<T>& stat, S32 num_periods = S32_MAX) + typename RelatedTypes<typename T::value_t>::fractional_t getPeriodMinPerSec(const StatType<T>& stat, S32 num_periods = S32_MAX) { S32 total_periods = mNumPeriods; num_periods = llmin(num_periods, isStarted() ? total_periods - 1 : total_periods); @@ -417,7 +417,7 @@ namespace LLTrace template<typename T> typename RelatedTypes<T>::fractional_t getPeriodMinPerSec(const CountStatHandle<T>& stat, S32 num_periods = S32_MAX) { - return typename RelatedTypes<T>::fractional_t(getPeriodMinPerSec(static_cast<const TraceType<CountAccumulator>&>(stat), num_periods)); + return typename RelatedTypes<T>::fractional_t(getPeriodMinPerSec(static_cast<const StatType<CountAccumulator>&>(stat), num_periods)); } // @@ -426,7 +426,7 @@ namespace LLTrace // catch all for stats that have a defined sum template <typename T> - typename T::value_t getPeriodMax(const TraceType<T>& stat, S32 num_periods = S32_MAX) + typename T::value_t getPeriodMax(const StatType<T>& stat, S32 num_periods = S32_MAX) { S32 total_periods = mNumPeriods; num_periods = llmin(num_periods, isStarted() ? total_periods - 1 : total_periods); @@ -443,28 +443,28 @@ namespace LLTrace template<typename T> T getPeriodMax(const CountStatHandle<T>& stat, S32 num_periods = S32_MAX) { - return T(getPeriodMax(static_cast<const TraceType<CountAccumulator>&>(stat), num_periods)); + return T(getPeriodMax(static_cast<const StatType<CountAccumulator>&>(stat), num_periods)); } - F64 getPeriodMax(const TraceType<SampleAccumulator>& stat, S32 num_periods = S32_MAX); + F64 getPeriodMax(const StatType<SampleAccumulator>& stat, S32 num_periods = S32_MAX); template<typename T> T getPeriodMax(const SampleStatHandle<T>& stat, S32 num_periods = S32_MAX) { - return T(getPeriodMax(static_cast<const TraceType<SampleAccumulator>&>(stat), num_periods)); + return T(getPeriodMax(static_cast<const StatType<SampleAccumulator>&>(stat), num_periods)); } - F64 getPeriodMax(const TraceType<EventAccumulator>& stat, S32 num_periods = S32_MAX); + F64 getPeriodMax(const StatType<EventAccumulator>& stat, S32 num_periods = S32_MAX); template<typename T> T getPeriodMax(const EventStatHandle<T>& stat, S32 num_periods = S32_MAX) { - return T(getPeriodMax(static_cast<const TraceType<EventAccumulator>&>(stat), num_periods)); + return T(getPeriodMax(static_cast<const StatType<EventAccumulator>&>(stat), num_periods)); } - F64Kilobytes getPeriodMax(const TraceType<MemStatAccumulator>& stat, S32 num_periods = S32_MAX); + F64Kilobytes getPeriodMax(const StatType<MemAccumulator>& stat, S32 num_periods = S32_MAX); F64Kilobytes getPeriodMax(const MemStatHandle& stat, S32 num_periods = S32_MAX); template <typename T> - typename RelatedTypes<typename T::value_t>::fractional_t getPeriodMaxPerSec(const TraceType<T>& stat, S32 num_periods = S32_MAX) + typename RelatedTypes<typename T::value_t>::fractional_t getPeriodMaxPerSec(const StatType<T>& stat, S32 num_periods = S32_MAX) { S32 total_periods = mNumPeriods; num_periods = llmin(num_periods, isStarted() ? total_periods - 1 : total_periods); @@ -481,7 +481,7 @@ namespace LLTrace template<typename T> typename RelatedTypes<T>::fractional_t getPeriodMaxPerSec(const CountStatHandle<T>& stat, S32 num_periods = S32_MAX) { - return typename RelatedTypes<T>::fractional_t(getPeriodMaxPerSec(static_cast<const TraceType<CountAccumulator>&>(stat), num_periods)); + return typename RelatedTypes<T>::fractional_t(getPeriodMaxPerSec(static_cast<const StatType<CountAccumulator>&>(stat), num_periods)); } // @@ -490,7 +490,7 @@ namespace LLTrace // catch all for stats that have a defined sum template <typename T> - typename RelatedTypes<typename T::value_t>::fractional_t getPeriodMean(const TraceType<T >& stat, S32 num_periods = S32_MAX) + typename RelatedTypes<typename T::value_t>::fractional_t getPeriodMean(const StatType<T >& stat, S32 num_periods = S32_MAX) { S32 total_periods = mNumPeriods; num_periods = llmin(num_periods, isStarted() ? total_periods - 1 : total_periods); @@ -513,27 +513,27 @@ namespace LLTrace template<typename T> typename RelatedTypes<T>::fractional_t getPeriodMean(const CountStatHandle<T>& stat, S32 num_periods = S32_MAX) { - return typename RelatedTypes<T>::fractional_t(getPeriodMean(static_cast<const TraceType<CountAccumulator>&>(stat), num_periods)); + return typename RelatedTypes<T>::fractional_t(getPeriodMean(static_cast<const StatType<CountAccumulator>&>(stat), num_periods)); } - F64 getPeriodMean(const TraceType<SampleAccumulator>& stat, S32 num_periods = S32_MAX); + F64 getPeriodMean(const StatType<SampleAccumulator>& stat, S32 num_periods = S32_MAX); template<typename T> typename RelatedTypes<T>::fractional_t getPeriodMean(const SampleStatHandle<T>& stat, S32 num_periods = S32_MAX) { - return typename RelatedTypes<T>::fractional_t(getPeriodMean(static_cast<const TraceType<SampleAccumulator>&>(stat), num_periods)); + return typename RelatedTypes<T>::fractional_t(getPeriodMean(static_cast<const StatType<SampleAccumulator>&>(stat), num_periods)); } - F64 getPeriodMean(const TraceType<EventAccumulator>& stat, S32 num_periods = S32_MAX); + F64 getPeriodMean(const StatType<EventAccumulator>& stat, S32 num_periods = S32_MAX); template<typename T> typename RelatedTypes<T>::fractional_t getPeriodMean(const EventStatHandle<T>& stat, S32 num_periods = S32_MAX) { - return typename RelatedTypes<T>::fractional_t(getPeriodMean(static_cast<const TraceType<EventAccumulator>&>(stat), num_periods)); + return typename RelatedTypes<T>::fractional_t(getPeriodMean(static_cast<const StatType<EventAccumulator>&>(stat), num_periods)); } - F64Kilobytes getPeriodMean(const TraceType<MemStatAccumulator>& stat, S32 num_periods = S32_MAX); + F64Kilobytes getPeriodMean(const StatType<MemAccumulator>& stat, S32 num_periods = S32_MAX); F64Kilobytes getPeriodMean(const MemStatHandle& stat, S32 num_periods = S32_MAX); template <typename T> - typename RelatedTypes<typename T::value_t>::fractional_t getPeriodMeanPerSec(const TraceType<T>& stat, S32 num_periods = S32_MAX) + typename RelatedTypes<typename T::value_t>::fractional_t getPeriodMeanPerSec(const StatType<T>& stat, S32 num_periods = S32_MAX) { S32 total_periods = mNumPeriods; num_periods = llmin(num_periods, isStarted() ? total_periods - 1 : total_periods); @@ -557,29 +557,29 @@ namespace LLTrace template<typename T> typename RelatedTypes<T>::fractional_t getPeriodMeanPerSec(const CountStatHandle<T>& stat, S32 num_periods = S32_MAX) { - return typename RelatedTypes<T>::fractional_t(getPeriodMeanPerSec(static_cast<const TraceType<CountAccumulator>&>(stat), num_periods)); + return typename RelatedTypes<T>::fractional_t(getPeriodMeanPerSec(static_cast<const StatType<CountAccumulator>&>(stat), num_periods)); } // // PERIODIC STANDARD DEVIATION // - F64 getPeriodStandardDeviation(const TraceType<SampleAccumulator>& stat, S32 num_periods = S32_MAX); + F64 getPeriodStandardDeviation(const StatType<SampleAccumulator>& stat, S32 num_periods = S32_MAX); template<typename T> typename RelatedTypes<T>::fractional_t getPeriodStandardDeviation(const SampleStatHandle<T>& stat, S32 num_periods = S32_MAX) { - return typename RelatedTypes<T>::fractional_t(getPeriodStandardDeviation(static_cast<const TraceType<SampleAccumulator>&>(stat), num_periods)); + return typename RelatedTypes<T>::fractional_t(getPeriodStandardDeviation(static_cast<const StatType<SampleAccumulator>&>(stat), num_periods)); } - F64 getPeriodStandardDeviation(const TraceType<EventAccumulator>& stat, S32 num_periods = S32_MAX); + F64 getPeriodStandardDeviation(const StatType<EventAccumulator>& stat, S32 num_periods = S32_MAX); template<typename T> typename RelatedTypes<T>::fractional_t getPeriodStandardDeviation(const EventStatHandle<T>& stat, S32 num_periods = S32_MAX) { - return typename RelatedTypes<T>::fractional_t(getPeriodStandardDeviation(static_cast<const TraceType<EventAccumulator>&>(stat), num_periods)); + return typename RelatedTypes<T>::fractional_t(getPeriodStandardDeviation(static_cast<const StatType<EventAccumulator>&>(stat), num_periods)); } - F64Kilobytes getPeriodStandardDeviation(const TraceType<MemStatAccumulator>& stat, S32 num_periods = S32_MAX); + F64Kilobytes getPeriodStandardDeviation(const StatType<MemAccumulator>& stat, S32 num_periods = S32_MAX); F64Kilobytes getPeriodStandardDeviation(const MemStatHandle& stat, S32 num_periods = S32_MAX); private: diff --git a/indra/llrender/lltexture.h b/indra/llrender/lltexture.h index ff711b8004..9fca8b8cd3 100755 --- a/indra/llrender/lltexture.h +++ b/indra/llrender/lltexture.h @@ -33,6 +33,8 @@ #define LL_TEXTURE_H #include "llrefcount.h" +#include "lltrace.h" + class LLImageGL ; class LLTexUnit ; class LLFontGL ; @@ -40,7 +42,7 @@ class LLFontGL ; // //this is an abstract class as the parent for the class LLGLTexture // -class LLTexture : public virtual LLRefCount +class LLTexture : public virtual LLRefCount, public LLTrace::MemTrackable<LLTexture> { friend class LLTexUnit ; friend class LLFontGL ; @@ -49,7 +51,9 @@ protected: virtual ~LLTexture(); public: - LLTexture(){} + LLTexture() + : LLTrace::MemTrackable<LLTexture>("LLTexture") + {} // //interfaces to access LLGLTexture diff --git a/indra/llui/llstatbar.cpp b/indra/llui/llstatbar.cpp index bc8235132e..24256c3193 100755 --- a/indra/llui/llstatbar.cpp +++ b/indra/llui/llstatbar.cpp @@ -284,7 +284,7 @@ S32 calc_num_rapid_changes(LLTrace::PeriodicRecording& periodic_recording, const return num_rapid_changes; } -S32 calc_num_rapid_changes(LLTrace::PeriodicRecording& periodic_recording, const LLTrace::TraceType<LLTrace::CountAccumulator>& stat, const F32Seconds time_period) +S32 calc_num_rapid_changes(LLTrace::PeriodicRecording& periodic_recording, const LLTrace::StatType<LLTrace::CountAccumulator>& stat, const F32Seconds time_period) { F32Seconds elapsed_time, time_since_value_changed; @@ -332,7 +332,7 @@ void LLStatBar::draw() { case STAT_COUNT: { - const LLTrace::TraceType<LLTrace::CountAccumulator>& count_stat = *mStat.countStatp; + const LLTrace::StatType<LLTrace::CountAccumulator>& count_stat = *mStat.countStatp; unit_label = std::string(count_stat.getUnitLabel()) + "/s"; current = last_frame_recording.getPerSec(count_stat); @@ -344,7 +344,7 @@ void LLStatBar::draw() break; case STAT_EVENT: { - const LLTrace::TraceType<LLTrace::EventAccumulator>& event_stat = *mStat.eventStatp; + const LLTrace::StatType<LLTrace::EventAccumulator>& event_stat = *mStat.eventStatp; unit_label = mUnitLabel.empty() ? event_stat.getUnitLabel() : mUnitLabel; current = last_frame_recording.getLastValue(event_stat); @@ -356,7 +356,7 @@ void LLStatBar::draw() break; case STAT_SAMPLE: { - const LLTrace::TraceType<LLTrace::SampleAccumulator>& sample_stat = *mStat.sampleStatp; + const LLTrace::StatType<LLTrace::SampleAccumulator>& sample_stat = *mStat.sampleStatp; unit_label = mUnitLabel.empty() ? sample_stat.getUnitLabel() : mUnitLabel; current = last_frame_recording.getLastValue(sample_stat); @@ -379,7 +379,7 @@ void LLStatBar::draw() break; case STAT_MEM: { - const LLTrace::TraceType<LLTrace::MemStatAccumulator>& mem_stat = *mStat.memStatp; + const LLTrace::StatType<LLTrace::MemAccumulator>& mem_stat = *mStat.memStatp; unit_label = mUnitLabel.empty() ? mem_stat.getUnitLabel() : mUnitLabel; current = last_frame_recording.getLastValue(mem_stat).value(); @@ -578,27 +578,27 @@ void LLStatBar::draw() void LLStatBar::setStat(const std::string& stat_name) { using namespace LLTrace; - const TraceType<CountAccumulator>* count_stat; - const TraceType<EventAccumulator>* event_stat; - const TraceType<SampleAccumulator>* sample_stat; - const TraceType<MemStatAccumulator>* mem_stat; + const StatType<CountAccumulator>* count_stat; + const StatType<EventAccumulator>* event_stat; + const StatType<SampleAccumulator>* sample_stat; + const StatType<MemAccumulator>* mem_stat; - if ((count_stat = TraceType<CountAccumulator>::getInstance(stat_name))) + if ((count_stat = StatType<CountAccumulator>::getInstance(stat_name))) { mStat.countStatp = count_stat; mStatType = STAT_COUNT; } - else if ((event_stat = TraceType<EventAccumulator>::getInstance(stat_name))) + else if ((event_stat = StatType<EventAccumulator>::getInstance(stat_name))) { mStat.eventStatp = event_stat; mStatType = STAT_EVENT; } - else if ((sample_stat = TraceType<SampleAccumulator>::getInstance(stat_name))) + else if ((sample_stat = StatType<SampleAccumulator>::getInstance(stat_name))) { mStat.sampleStatp = sample_stat; mStatType = STAT_SAMPLE; } - else if ((mem_stat = TraceType<MemStatAccumulator>::getInstance(stat_name))) + else if ((mem_stat = StatType<MemAccumulator>::getInstance(stat_name))) { mStat.memStatp = mem_stat; mStatType = STAT_MEM; diff --git a/indra/llui/llstatbar.h b/indra/llui/llstatbar.h index 5e9255b9eb..57e492bc80 100755 --- a/indra/llui/llstatbar.h +++ b/indra/llui/llstatbar.h @@ -105,10 +105,10 @@ private: union { void* valid; - const LLTrace::TraceType<LLTrace::CountAccumulator>* countStatp; - const LLTrace::TraceType<LLTrace::EventAccumulator>* eventStatp; - const LLTrace::TraceType<LLTrace::SampleAccumulator>* sampleStatp; - const LLTrace::TraceType<LLTrace::MemStatAccumulator>* memStatp; + const LLTrace::StatType<LLTrace::CountAccumulator>* countStatp; + const LLTrace::StatType<LLTrace::EventAccumulator>* eventStatp; + const LLTrace::StatType<LLTrace::SampleAccumulator>* sampleStatp; + const LLTrace::StatType<LLTrace::MemAccumulator>* memStatp; } mStat; LLUIString mLabel; diff --git a/indra/llui/llstatgraph.h b/indra/llui/llstatgraph.h index 38fe12d18b..f381e92a4d 100755 --- a/indra/llui/llstatgraph.h +++ b/indra/llui/llstatgraph.h @@ -57,9 +57,9 @@ public: struct StatParams : public LLInitParam::ChoiceBlock<StatParams> { - Alternative<LLTrace::TraceType<LLTrace::CountAccumulator>* > count_stat_float; - Alternative<LLTrace::TraceType<LLTrace::EventAccumulator>* > event_stat_float; - Alternative<LLTrace::TraceType<LLTrace::SampleAccumulator>* > sample_stat_float; + Alternative<LLTrace::StatType<LLTrace::CountAccumulator>* > count_stat_float; + Alternative<LLTrace::StatType<LLTrace::EventAccumulator>* > event_stat_float; + Alternative<LLTrace::StatType<LLTrace::SampleAccumulator>* > sample_stat_float; }; struct Params : public LLInitParam::Block<Params, LLView::Params> @@ -104,7 +104,7 @@ public: /*virtual*/ void setValue(const LLSD& value); private: - LLTrace::TraceType<LLTrace::CountAccumulator>* mNewStatFloatp; + LLTrace::StatType<LLTrace::CountAccumulator>* mNewStatFloatp; BOOL mPerSec; diff --git a/indra/llui/lltextbase.cpp b/indra/llui/lltextbase.cpp index 730c3b2ada..00382125a8 100755 --- a/indra/llui/lltextbase.cpp +++ b/indra/llui/lltextbase.cpp @@ -1871,7 +1871,6 @@ LLTextBase::segment_set_t::iterator LLTextBase::getSegIterContaining(S32 index) // when there are no segments, we return the end iterator, which must be checked by caller if (mSegments.size() <= 1) { return mSegments.begin(); } - //FIXME: avoid operator new somehow (without running into refcount problems) index_segment->setStart(index); index_segment->setEnd(index); segment_set_t::iterator it = mSegments.upper_bound(index_segment); diff --git a/indra/newview/lldrawable.cpp b/indra/newview/lldrawable.cpp index 4b6c80b51a..5981153bd5 100755 --- a/indra/newview/lldrawable.cpp +++ b/indra/newview/lldrawable.cpp @@ -1047,7 +1047,7 @@ bool LLDrawable::isVisible() const } { - LLviewerOctreeGroup* group = mEntry->getGroup(); + LLViewerOctreeGroup* group = mEntry->getGroup(); if (group && group->isVisible()) { LLViewerOctreeEntryData::setVisible(); @@ -1073,7 +1073,7 @@ bool LLDrawable::isRecentlyVisible() const return vis ; } -void LLDrawable::setGroup(LLviewerOctreeGroup *groupp) +void LLDrawable::setGroup(LLViewerOctreeGroup *groupp) { LLSpatialGroup* cur_groupp = (LLSpatialGroup*)getGroup(); diff --git a/indra/newview/lldrawable.h b/indra/newview/lldrawable.h index 067cee6838..a3461d4c01 100755 --- a/indra/newview/lldrawable.h +++ b/indra/newview/lldrawable.h @@ -176,7 +176,7 @@ public: virtual void cleanupReferences(); - void setGroup(LLviewerOctreeGroup* group); + void setGroup(LLViewerOctreeGroup* group); void setRadius(const F32 radius); F32 getRadius() const { return mRadius; } F32 getVisibilityRadius() const; diff --git a/indra/newview/lldynamictexture.h b/indra/newview/lldynamictexture.h index d287ae6eeb..f3f57c9a6b 100755 --- a/indra/newview/lldynamictexture.h +++ b/indra/newview/lldynamictexture.h @@ -38,12 +38,12 @@ class LLViewerDynamicTexture : public LLViewerTexture public: void* operator new(size_t size) { - return ll_aligned_malloc_16(size); + return LLTrace::MemTrackable<LLTexture>::aligned_new<16>(size); } - void operator delete(void* ptr) + void operator delete(void* ptr, size_t size) { - ll_aligned_free_16(ptr); + LLTrace::MemTrackable<LLTexture>::aligned_delete<16>(ptr, size); } enum diff --git a/indra/newview/llface.h b/indra/newview/llface.h index 25c87b54f8..40f4968801 100755 --- a/indra/newview/llface.h +++ b/indra/newview/llface.h @@ -53,22 +53,11 @@ class LLDrawInfo; const F32 MIN_ALPHA_SIZE = 1024.f; const F32 MIN_TEX_ANIM_SIZE = 512.f; -class LLFace +class LLFace : public LLTrace::MemTrackableNonVirtual<LLFace, 16> { public: - - void* operator new(size_t size) - { - return ll_aligned_malloc_16(size); - } - - void operator delete(void* ptr) - { - ll_aligned_free_16(ptr); - } - - LLFace(const LLFace& rhs) + : LLTrace::MemTrackableNonVirtual<LLFace, 16>("LLFace") { *this = rhs; } @@ -96,7 +85,11 @@ public: static void cacheFaceInVRAM(const LLVolumeFace& vf); public: - LLFace(LLDrawable* drawablep, LLViewerObject* objp) { init(drawablep, objp); } + LLFace(LLDrawable* drawablep, LLViewerObject* objp) + : LLTrace::MemTrackableNonVirtual<LLFace, 16>("LLFace") + { + init(drawablep, objp); + } ~LLFace() { destroy(); } const LLMatrix4& getWorldMatrix() const { return mVObjp->getWorldMatrix(mXform); } diff --git a/indra/newview/llscenemonitor.cpp b/indra/newview/llscenemonitor.cpp index c1ebd1f435..db2936b1fd 100644 --- a/indra/newview/llscenemonitor.cpp +++ b/indra/newview/llscenemonitor.cpp @@ -546,7 +546,7 @@ void LLSceneMonitor::dumpToFile(std::string file_name) os << '\n'; - typedef TraceType<CountAccumulator> trace_count; + typedef StatType<CountAccumulator> trace_count; for (trace_count::instance_iter it = trace_count::beginInstances(), end_it = trace_count::endInstances(); it != end_it; ++it) @@ -579,7 +579,7 @@ void LLSceneMonitor::dumpToFile(std::string file_name) } } - typedef TraceType<EventAccumulator> trace_event; + typedef StatType<EventAccumulator> trace_event; for (trace_event::instance_iter it = trace_event::beginInstances(), end_it = trace_event::endInstances(); it != end_it; @@ -620,7 +620,7 @@ void LLSceneMonitor::dumpToFile(std::string file_name) } } - typedef TraceType<SampleAccumulator> trace_sample; + typedef StatType<SampleAccumulator> trace_sample; for (trace_sample::instance_iter it = trace_sample::beginInstances(), end_it = trace_sample::endInstances(); it != end_it; @@ -661,7 +661,7 @@ void LLSceneMonitor::dumpToFile(std::string file_name) } } - typedef TraceType<MemStatAccumulator> trace_mem; + typedef StatType<MemAccumulator> trace_mem; for (trace_mem::instance_iter it = trace_mem::beginInstances(), end_it = trace_mem::endInstances(); it != end_it; ++it) diff --git a/indra/newview/llspatialpartition.cpp b/indra/newview/llspatialpartition.cpp index 0fbe1578cf..045fcccad7 100755 --- a/indra/newview/llspatialpartition.cpp +++ b/indra/newview/llspatialpartition.cpp @@ -483,7 +483,7 @@ void LLSpatialPartition::rebuildMesh(LLSpatialGroup* group) LLSpatialGroup* LLSpatialGroup::getParent() { - return (LLSpatialGroup*)LLviewerOctreeGroup::getParent(); + return (LLSpatialGroup*)LLViewerOctreeGroup::getParent(); } BOOL LLSpatialGroup::removeObject(LLDrawable *drawablep, BOOL from_octree) @@ -831,7 +831,7 @@ void LLSpatialGroup::handleInsertion(const TreeNode* node, LLViewerOctreeEntry* void LLSpatialGroup::handleRemoval(const TreeNode* node, LLViewerOctreeEntry* entry) { removeObject((LLDrawable*)entry->getDrawable(), TRUE); - LLviewerOctreeGroup::handleRemoval(node, entry); + LLViewerOctreeGroup::handleRemoval(node, entry); } void LLSpatialGroup::handleDestruction(const TreeNode* node) @@ -1065,7 +1065,7 @@ class LLOctreeCull : public LLViewerOctreeCull public: LLOctreeCull(LLCamera* camera) : LLViewerOctreeCull(camera) {} - virtual bool earlyFail(LLviewerOctreeGroup* base_group) + virtual bool earlyFail(LLViewerOctreeGroup* base_group) { LLSpatialGroup* group = (LLSpatialGroup*)base_group; group->checkOcclusion(); @@ -1081,7 +1081,7 @@ public: return false; } - virtual S32 frustumCheck(const LLviewerOctreeGroup* group) + virtual S32 frustumCheck(const LLViewerOctreeGroup* group) { S32 res = AABBInFrustumNoFarClipGroupBounds(group); if (res != 0) @@ -1091,7 +1091,7 @@ public: return res; } - virtual S32 frustumCheckObjects(const LLviewerOctreeGroup* group) + virtual S32 frustumCheckObjects(const LLViewerOctreeGroup* group) { S32 res = AABBInFrustumNoFarClipObjectBounds(group); if (res != 0) @@ -1101,7 +1101,7 @@ public: return res; } - virtual void processGroup(LLviewerOctreeGroup* base_group) + virtual void processGroup(LLViewerOctreeGroup* base_group) { LLSpatialGroup* group = (LLSpatialGroup*)base_group; if (group->needsUpdate() || @@ -1119,12 +1119,12 @@ public: LLOctreeCullNoFarClip(LLCamera* camera) : LLOctreeCull(camera) { } - virtual S32 frustumCheck(const LLviewerOctreeGroup* group) + virtual S32 frustumCheck(const LLViewerOctreeGroup* group) { return AABBInFrustumNoFarClipGroupBounds(group); } - virtual S32 frustumCheckObjects(const LLviewerOctreeGroup* group) + virtual S32 frustumCheckObjects(const LLViewerOctreeGroup* group) { S32 res = AABBInFrustumNoFarClipObjectBounds(group); return res; @@ -1137,12 +1137,12 @@ public: LLOctreeCullShadow(LLCamera* camera) : LLOctreeCull(camera) { } - virtual S32 frustumCheck(const LLviewerOctreeGroup* group) + virtual S32 frustumCheck(const LLViewerOctreeGroup* group) { return AABBInFrustumGroupBounds(group); } - virtual S32 frustumCheckObjects(const LLviewerOctreeGroup* group) + virtual S32 frustumCheckObjects(const LLViewerOctreeGroup* group) { return AABBInFrustumObjectBounds(group); } @@ -1154,7 +1154,7 @@ public: LLOctreeCullVisExtents(LLCamera* camera, LLVector4a& min, LLVector4a& max) : LLOctreeCullShadow(camera), mMin(min), mMax(max), mEmpty(TRUE) { } - virtual bool earlyFail(LLviewerOctreeGroup* base_group) + virtual bool earlyFail(LLViewerOctreeGroup* base_group) { LLSpatialGroup* group = (LLSpatialGroup*)base_group; @@ -1195,7 +1195,7 @@ public: } } - virtual void processGroup(LLviewerOctreeGroup* base_group) + virtual void processGroup(LLViewerOctreeGroup* base_group) { LLSpatialGroup* group = (LLSpatialGroup*)base_group; @@ -1231,7 +1231,7 @@ public: LLOctreeCullDetectVisible(LLCamera* camera) : LLOctreeCullShadow(camera), mResult(FALSE) { } - virtual bool earlyFail(LLviewerOctreeGroup* base_group) + virtual bool earlyFail(LLViewerOctreeGroup* base_group) { LLSpatialGroup* group = (LLSpatialGroup*)base_group; @@ -1246,7 +1246,7 @@ public: return false; } - virtual void processGroup(LLviewerOctreeGroup* base_group) + virtual void processGroup(LLViewerOctreeGroup* base_group) { if (base_group->isVisible()) { @@ -1263,10 +1263,10 @@ public: LLOctreeSelect(LLCamera* camera, std::vector<LLDrawable*>* results) : LLOctreeCull(camera), mResults(results) { } - virtual bool earlyFail(LLviewerOctreeGroup* group) { return false; } - virtual void preprocess(LLviewerOctreeGroup* group) { } + virtual bool earlyFail(LLViewerOctreeGroup* group) { return false; } + virtual void preprocess(LLViewerOctreeGroup* group) { } - virtual void processGroup(LLviewerOctreeGroup* base_group) + virtual void processGroup(LLViewerOctreeGroup* base_group) { LLSpatialGroup* group = (LLSpatialGroup*)base_group; OctreeNode* branch = group->getOctreeNode(); @@ -3909,7 +3909,7 @@ LLDrawable* LLSpatialPartition::lineSegmentIntersect(const LLVector4a& start, co LLDrawInfo::LLDrawInfo(U16 start, U16 end, U32 count, U32 offset, LLViewerTexture* texture, LLVertexBuffer* buffer, BOOL fullbright, U8 bump, BOOL particle, F32 part_size) -: +: LLTrace::MemTrackableNonVirtual<LLDrawInfo, 16>("LLDrawInfo"), mVertexBuffer(buffer), mTexture(texture), mTextureMatrix(NULL), diff --git a/indra/newview/llspatialpartition.h b/indra/newview/llspatialpartition.h index 4026175a9a..fef6fdc2c2 100755 --- a/indra/newview/llspatialpartition.h +++ b/indra/newview/llspatialpartition.h @@ -55,24 +55,14 @@ class LLViewerRegion; void pushVerts(LLFace* face, U32 mask); -class LLDrawInfo : public LLRefCount +class LLDrawInfo : public LLRefCount, public LLTrace::MemTrackableNonVirtual<LLDrawInfo, 16> { protected: ~LLDrawInfo(); public: - void* operator new(size_t size) - { - return ll_aligned_malloc_16(size); - } - - void operator delete(void* ptr) - { - ll_aligned_free_16(ptr); - } - - LLDrawInfo(const LLDrawInfo& rhs) + : LLTrace::MemTrackableNonVirtual<LLDrawInfo, 16>("LLDrawInfo") { *this = rhs; } @@ -209,16 +199,6 @@ public: *this = rhs; } - void* operator new(size_t size) - { - return ll_aligned_malloc_16(size); - } - - void operator delete(void* ptr) - { - ll_aligned_free_16(ptr); - } - const LLSpatialGroup& operator=(const LLSpatialGroup& rhs) { LL_ERRS() << "Illegal operation!" << LL_ENDL; @@ -262,7 +242,7 @@ public: typedef enum { - GEOM_DIRTY = LLviewerOctreeGroup::INVALID_STATE, + GEOM_DIRTY = LLViewerOctreeGroup::INVALID_STATE, ALPHA_DIRTY = (GEOM_DIRTY << 1), IN_IMAGE_QUEUE = (ALPHA_DIRTY << 1), IMAGE_DIRTY = (IN_IMAGE_QUEUE << 1), diff --git a/indra/newview/llvieweroctree.cpp b/indra/newview/llvieweroctree.cpp index e8eba43242..5bd0a95387 100644 --- a/indra/newview/llvieweroctree.cpp +++ b/indra/newview/llvieweroctree.cpp @@ -231,9 +231,10 @@ S32 AABBSphereIntersectR2(const LLVector4a& min, const LLVector4a& max, const LL //class LLViewerOctreeEntry definitions //----------------------------------------------------------------------------------- LLViewerOctreeEntry::LLViewerOctreeEntry() - : mGroup(NULL), - mBinRadius(0.f), - mBinIndex(-1) +: LLTrace::MemTrackable<LLViewerOctreeEntry, 16>("LLViewerOctreeEntry"), + mGroup(NULL), + mBinRadius(0.f), + mBinIndex(-1) { mPositionGroup.clear(); mExtents[0].clear(); @@ -271,7 +272,7 @@ void LLViewerOctreeEntry::removeData(LLViewerOctreeEntryData* data) if(mGroup != NULL && !mData[LLDRAWABLE]) { - LLviewerOctreeGroup* group = mGroup; + LLViewerOctreeGroup* group = mGroup; mGroup = NULL; group->removeFromGroup(data); @@ -285,7 +286,7 @@ void LLViewerOctreeEntry::nullGroup() mGroup = NULL; } -void LLViewerOctreeEntry::setGroup(LLviewerOctreeGroup* group) +void LLViewerOctreeEntry::setGroup(LLViewerOctreeGroup* group) { if(mGroup == group) { @@ -294,7 +295,7 @@ void LLViewerOctreeEntry::setGroup(LLviewerOctreeGroup* group) if(mGroup) { - LLviewerOctreeGroup* group = mGroup; + LLViewerOctreeGroup* group = mGroup; mGroup = NULL; group->removeFromGroup(this); @@ -363,7 +364,7 @@ const LLVector4a* LLViewerOctreeEntryData::getSpatialExtents() const } //virtual -void LLViewerOctreeEntryData::setGroup(LLviewerOctreeGroup* group) +void LLViewerOctreeEntryData::setGroup(LLViewerOctreeGroup* group) { mEntry->setGroup(group); } @@ -375,7 +376,7 @@ void LLViewerOctreeEntryData::shift(const LLVector4a &shift_vector) mEntry->mPositionGroup.add(shift_vector); } -LLviewerOctreeGroup* LLViewerOctreeEntryData::getGroup()const +LLViewerOctreeGroup* LLViewerOctreeEntryData::getGroup()const { return mEntry.notNull() ? mEntry->mGroup : NULL; } @@ -425,15 +426,16 @@ void LLViewerOctreeEntryData::setVisible() const } //----------------------------------------------------------------------------------- -//class LLviewerOctreeGroup definitions +//class LLViewerOctreeGroup definitions //----------------------------------------------------------------------------------- -LLviewerOctreeGroup::~LLviewerOctreeGroup() +LLViewerOctreeGroup::~LLViewerOctreeGroup() { //empty here } -LLviewerOctreeGroup::LLviewerOctreeGroup(OctreeNode* node) : +LLViewerOctreeGroup::LLViewerOctreeGroup(OctreeNode* node) +: LLTrace::MemTrackable<LLViewerOctreeGroup, 16>("LLViewerOctreeGroup"), mOctreeNode(node), mState(CLEAN) { @@ -448,7 +450,7 @@ LLviewerOctreeGroup::LLviewerOctreeGroup(OctreeNode* node) : mOctreeNode->addListener(this); } -bool LLviewerOctreeGroup::hasElement(LLViewerOctreeEntryData* data) +bool LLViewerOctreeGroup::hasElement(LLViewerOctreeEntryData* data) { if(!data->getEntry()) { @@ -457,12 +459,12 @@ bool LLviewerOctreeGroup::hasElement(LLViewerOctreeEntryData* data) return std::find(getDataBegin(), getDataEnd(), data->getEntry()) != getDataEnd(); } -bool LLviewerOctreeGroup::removeFromGroup(LLViewerOctreeEntryData* data) +bool LLViewerOctreeGroup::removeFromGroup(LLViewerOctreeEntryData* data) { return removeFromGroup(data->getEntry()); } -bool LLviewerOctreeGroup::removeFromGroup(LLViewerOctreeEntry* entry) +bool LLViewerOctreeGroup::removeFromGroup(LLViewerOctreeEntry* entry) { llassert(entry != NULL); llassert(!entry->getGroup()); @@ -483,7 +485,7 @@ bool LLviewerOctreeGroup::removeFromGroup(LLViewerOctreeEntry* entry) } //virtual -void LLviewerOctreeGroup::unbound() +void LLViewerOctreeGroup::unbound() { if (isDirty()) { @@ -498,7 +500,7 @@ void LLviewerOctreeGroup::unbound() OctreeNode* parent = (OctreeNode*) mOctreeNode->getParent(); while (parent != NULL) { - LLviewerOctreeGroup* group = (LLviewerOctreeGroup*) parent->getListener(0); + LLViewerOctreeGroup* group = (LLViewerOctreeGroup*) parent->getListener(0); if (!group || group->isDirty()) { return; @@ -511,7 +513,7 @@ void LLviewerOctreeGroup::unbound() } //virtual -void LLviewerOctreeGroup::rebound() +void LLViewerOctreeGroup::rebound() { if (!isDirty()) { @@ -520,7 +522,7 @@ void LLviewerOctreeGroup::rebound() if (mOctreeNode->getChildCount() == 1 && mOctreeNode->getElementCount() == 0) { - LLviewerOctreeGroup* group = (LLviewerOctreeGroup*) mOctreeNode->getChild(0)->getListener(0); + LLViewerOctreeGroup* group = (LLViewerOctreeGroup*) mOctreeNode->getChild(0)->getListener(0); group->rebound(); //copy single child's bounding box @@ -541,7 +543,7 @@ void LLviewerOctreeGroup::rebound() { LLVector4a& newMin = mExtents[0]; LLVector4a& newMax = mExtents[1]; - LLviewerOctreeGroup* group = (LLviewerOctreeGroup*) mOctreeNode->getChild(0)->getListener(0); + LLViewerOctreeGroup* group = (LLViewerOctreeGroup*) mOctreeNode->getChild(0)->getListener(0); group->clearState(SKIP_FRUSTUM_CHECK); group->rebound(); //initialize to first child @@ -551,7 +553,7 @@ void LLviewerOctreeGroup::rebound() //first, rebound children for (U32 i = 1; i < mOctreeNode->getChildCount(); i++) { - group = (LLviewerOctreeGroup*) mOctreeNode->getChild(i)->getListener(0); + group = (LLViewerOctreeGroup*) mOctreeNode->getChild(i)->getListener(0); group->clearState(SKIP_FRUSTUM_CHECK); group->rebound(); const LLVector4a& max = group->mExtents[1]; @@ -575,7 +577,7 @@ void LLviewerOctreeGroup::rebound() } //virtual -void LLviewerOctreeGroup::handleInsertion(const TreeNode* node, LLViewerOctreeEntry* obj) +void LLViewerOctreeGroup::handleInsertion(const TreeNode* node, LLViewerOctreeEntry* obj) { obj->setGroup(this); unbound(); @@ -583,7 +585,7 @@ void LLviewerOctreeGroup::handleInsertion(const TreeNode* node, LLViewerOctreeEn } //virtual -void LLviewerOctreeGroup::handleRemoval(const TreeNode* node, LLViewerOctreeEntry* obj) +void LLViewerOctreeGroup::handleRemoval(const TreeNode* node, LLViewerOctreeEntry* obj) { unbound(); setState(OBJECT_DIRTY); @@ -592,7 +594,7 @@ void LLviewerOctreeGroup::handleRemoval(const TreeNode* node, LLViewerOctreeEntr } //virtual -void LLviewerOctreeGroup::handleDestruction(const TreeNode* node) +void LLViewerOctreeGroup::handleDestruction(const TreeNode* node) { for (OctreeNode::element_iter i = mOctreeNode->getDataBegin(); i != mOctreeNode->getDataEnd(); ++i) { @@ -607,7 +609,7 @@ void LLviewerOctreeGroup::handleDestruction(const TreeNode* node) } //virtual -void LLviewerOctreeGroup::handleStateChange(const TreeNode* node) +void LLViewerOctreeGroup::handleStateChange(const TreeNode* node) { //drop bounding box upon state change if (mOctreeNode != node) @@ -618,29 +620,29 @@ void LLviewerOctreeGroup::handleStateChange(const TreeNode* node) } //virtual -void LLviewerOctreeGroup::handleChildAddition(const OctreeNode* parent, OctreeNode* child) +void LLViewerOctreeGroup::handleChildAddition(const OctreeNode* parent, OctreeNode* child) { if (child->getListenerCount() == 0) { - new LLviewerOctreeGroup(child); + new LLViewerOctreeGroup(child); } else { - OCT_ERRS << "LLviewerOctreeGroup redundancy detected." << LL_ENDL; + OCT_ERRS << "LLViewerOctreeGroup redundancy detected." << LL_ENDL; } unbound(); - ((LLviewerOctreeGroup*)child->getListener(0))->unbound(); + ((LLViewerOctreeGroup*)child->getListener(0))->unbound(); } //virtual -void LLviewerOctreeGroup::handleChildRemoval(const OctreeNode* parent, const OctreeNode* child) +void LLViewerOctreeGroup::handleChildRemoval(const OctreeNode* parent, const OctreeNode* child) { unbound(); } -LLviewerOctreeGroup* LLviewerOctreeGroup::getParent() +LLViewerOctreeGroup* LLViewerOctreeGroup::getParent() { if (isDead()) { @@ -656,14 +658,14 @@ LLviewerOctreeGroup* LLviewerOctreeGroup::getParent() if (parent) { - return (LLviewerOctreeGroup*) parent->getListener(0); + return (LLViewerOctreeGroup*) parent->getListener(0); } return NULL; } //virtual -bool LLviewerOctreeGroup::boundObjects(BOOL empty, LLVector4a& minOut, LLVector4a& maxOut) +bool LLViewerOctreeGroup::boundObjects(BOOL empty, LLVector4a& minOut, LLVector4a& maxOut) { const OctreeNode* node = mOctreeNode; @@ -721,23 +723,23 @@ bool LLviewerOctreeGroup::boundObjects(BOOL empty, LLVector4a& minOut, LLVector4 } //virtual -BOOL LLviewerOctreeGroup::isVisible() const +BOOL LLViewerOctreeGroup::isVisible() const { return mVisible[LLViewerCamera::sCurCameraID] >= LLViewerOctreeEntryData::getCurrentFrame() ? TRUE : FALSE; } //virtual -BOOL LLviewerOctreeGroup::isRecentlyVisible() const +BOOL LLViewerOctreeGroup::isRecentlyVisible() const { return FALSE; } -void LLviewerOctreeGroup::setVisible() +void LLViewerOctreeGroup::setVisible() { mVisible[LLViewerCamera::sCurCameraID] = LLViewerOctreeEntryData::getCurrentFrame(); } -void LLviewerOctreeGroup::checkStates() +void LLViewerOctreeGroup::checkStates() { #if LL_OCTREE_PARANOIA_CHECK //LLOctreeStateCheck checker; @@ -837,7 +839,7 @@ public: LLOcclusionCullingGroup::LLOcclusionCullingGroup(OctreeNode* node, LLViewerOctreePartition* part) : - LLviewerOctreeGroup(node), + LLViewerOctreeGroup(node), mSpatialPartition(part) { part->mLODSeed = (part->mLODSeed+1)%part->mLODPeriod; @@ -885,7 +887,7 @@ void LLOcclusionCullingGroup::handleChildAddition(const OctreeNode* parent, Octr unbound(); - ((LLviewerOctreeGroup*)child->getListener(0))->unbound(); + ((LLViewerOctreeGroup*)child->getListener(0))->unbound(); } void LLOcclusionCullingGroup::releaseOcclusionQueryObjectNames() @@ -1316,7 +1318,7 @@ BOOL LLViewerOctreePartition::isOcclusionEnabled() //----------------------------------------------------------------------------------- //virtual -bool LLViewerOctreeCull::earlyFail(LLviewerOctreeGroup* group) +bool LLViewerOctreeCull::earlyFail(LLViewerOctreeGroup* group) { return false; } @@ -1324,7 +1326,7 @@ bool LLViewerOctreeCull::earlyFail(LLviewerOctreeGroup* group) //virtual void LLViewerOctreeCull::traverse(const OctreeNode* n) { - LLviewerOctreeGroup* group = (LLviewerOctreeGroup*) n->getListener(0); + LLViewerOctreeGroup* group = (LLViewerOctreeGroup*) n->getListener(0); if (earlyFail(group)) { @@ -1332,7 +1334,7 @@ void LLViewerOctreeCull::traverse(const OctreeNode* n) } if (mRes == 2 || - (mRes && group->hasState(LLviewerOctreeGroup::SKIP_FRUSTUM_CHECK))) + (mRes && group->hasState(LLViewerOctreeGroup::SKIP_FRUSTUM_CHECK))) { //fully in, just add everything OctreeTraveler::traverse(n); } @@ -1351,17 +1353,17 @@ void LLViewerOctreeCull::traverse(const OctreeNode* n) //------------------------------------------ //agent space group culling -S32 LLViewerOctreeCull::AABBInFrustumNoFarClipGroupBounds(const LLviewerOctreeGroup* group) +S32 LLViewerOctreeCull::AABBInFrustumNoFarClipGroupBounds(const LLViewerOctreeGroup* group) { return mCamera->AABBInFrustumNoFarClip(group->mBounds[0], group->mBounds[1]); } -S32 LLViewerOctreeCull::AABBSphereIntersectGroupExtents(const LLviewerOctreeGroup* group) +S32 LLViewerOctreeCull::AABBSphereIntersectGroupExtents(const LLViewerOctreeGroup* group) { return AABBSphereIntersect(group->mExtents[0], group->mExtents[1], mCamera->getOrigin(), mCamera->mFrustumCornerDist); } -S32 LLViewerOctreeCull::AABBInFrustumGroupBounds(const LLviewerOctreeGroup* group) +S32 LLViewerOctreeCull::AABBInFrustumGroupBounds(const LLViewerOctreeGroup* group) { return mCamera->AABBInFrustum(group->mBounds[0], group->mBounds[1]); } @@ -1369,17 +1371,17 @@ S32 LLViewerOctreeCull::AABBInFrustumGroupBounds(const LLviewerOctreeGroup* grou //------------------------------------------ //agent space object set culling -S32 LLViewerOctreeCull::AABBInFrustumNoFarClipObjectBounds(const LLviewerOctreeGroup* group) +S32 LLViewerOctreeCull::AABBInFrustumNoFarClipObjectBounds(const LLViewerOctreeGroup* group) { return mCamera->AABBInFrustumNoFarClip(group->mObjectBounds[0], group->mObjectBounds[1]); } -S32 LLViewerOctreeCull::AABBSphereIntersectObjectExtents(const LLviewerOctreeGroup* group) +S32 LLViewerOctreeCull::AABBSphereIntersectObjectExtents(const LLViewerOctreeGroup* group) { return AABBSphereIntersect(group->mObjectExtents[0], group->mObjectExtents[1], mCamera->getOrigin(), mCamera->mFrustumCornerDist); } -S32 LLViewerOctreeCull::AABBInFrustumObjectBounds(const LLviewerOctreeGroup* group) +S32 LLViewerOctreeCull::AABBInFrustumObjectBounds(const LLViewerOctreeGroup* group) { return mCamera->AABBInFrustum(group->mObjectBounds[0], group->mObjectBounds[1]); } @@ -1387,17 +1389,17 @@ S32 LLViewerOctreeCull::AABBInFrustumObjectBounds(const LLviewerOctreeGroup* gro //------------------------------------------ //local regional space group culling -S32 LLViewerOctreeCull::AABBInRegionFrustumNoFarClipGroupBounds(const LLviewerOctreeGroup* group) +S32 LLViewerOctreeCull::AABBInRegionFrustumNoFarClipGroupBounds(const LLViewerOctreeGroup* group) { return mCamera->AABBInRegionFrustumNoFarClip(group->mBounds[0], group->mBounds[1]); } -S32 LLViewerOctreeCull::AABBInRegionFrustumGroupBounds(const LLviewerOctreeGroup* group) +S32 LLViewerOctreeCull::AABBInRegionFrustumGroupBounds(const LLViewerOctreeGroup* group) { return mCamera->AABBInRegionFrustum(group->mBounds[0], group->mBounds[1]); } -S32 LLViewerOctreeCull::AABBRegionSphereIntersectGroupExtents(const LLviewerOctreeGroup* group, const LLVector3& shift) +S32 LLViewerOctreeCull::AABBRegionSphereIntersectGroupExtents(const LLViewerOctreeGroup* group, const LLVector3& shift) { return AABBSphereIntersect(group->mExtents[0], group->mExtents[1], mCamera->getOrigin() - shift, mCamera->mFrustumCornerDist); } @@ -1405,24 +1407,24 @@ S32 LLViewerOctreeCull::AABBRegionSphereIntersectGroupExtents(const LLviewerOctr //------------------------------------------ //local regional space object culling -S32 LLViewerOctreeCull::AABBInRegionFrustumObjectBounds(const LLviewerOctreeGroup* group) +S32 LLViewerOctreeCull::AABBInRegionFrustumObjectBounds(const LLViewerOctreeGroup* group) { return mCamera->AABBInRegionFrustum(group->mObjectBounds[0], group->mObjectBounds[1]); } -S32 LLViewerOctreeCull::AABBInRegionFrustumNoFarClipObjectBounds(const LLviewerOctreeGroup* group) +S32 LLViewerOctreeCull::AABBInRegionFrustumNoFarClipObjectBounds(const LLViewerOctreeGroup* group) { return mCamera->AABBInRegionFrustumNoFarClip(group->mObjectBounds[0], group->mObjectBounds[1]); } -S32 LLViewerOctreeCull::AABBRegionSphereIntersectObjectExtents(const LLviewerOctreeGroup* group, const LLVector3& shift) +S32 LLViewerOctreeCull::AABBRegionSphereIntersectObjectExtents(const LLViewerOctreeGroup* group, const LLVector3& shift) { return AABBSphereIntersect(group->mObjectExtents[0], group->mObjectExtents[1], mCamera->getOrigin() - shift, mCamera->mFrustumCornerDist); } //------------------------------------------ //virtual -bool LLViewerOctreeCull::checkObjects(const OctreeNode* branch, const LLviewerOctreeGroup* group) +bool LLViewerOctreeCull::checkObjects(const OctreeNode* branch, const LLViewerOctreeGroup* group) { if (branch->getElementCount() == 0) //no elements { @@ -1441,19 +1443,19 @@ bool LLViewerOctreeCull::checkObjects(const OctreeNode* branch, const LLviewerOc } //virtual -void LLViewerOctreeCull::preprocess(LLviewerOctreeGroup* group) +void LLViewerOctreeCull::preprocess(LLViewerOctreeGroup* group) { } //virtual -void LLViewerOctreeCull::processGroup(LLviewerOctreeGroup* group) +void LLViewerOctreeCull::processGroup(LLViewerOctreeGroup* group) { } //virtual void LLViewerOctreeCull::visit(const OctreeNode* branch) { - LLviewerOctreeGroup* group = (LLviewerOctreeGroup*) branch->getListener(0); + LLViewerOctreeGroup* group = (LLViewerOctreeGroup*) branch->getListener(0); preprocess(group); @@ -1475,12 +1477,12 @@ void LLViewerOctreeDebug::visit(const OctreeNode* branch) LL_INFOS() << "Child " << i << " : " << (U32)branch->getChild(i) << LL_ENDL; } #endif - LLviewerOctreeGroup* group = (LLviewerOctreeGroup*) branch->getListener(0); + LLViewerOctreeGroup* group = (LLViewerOctreeGroup*) branch->getListener(0); processGroup(group); } //virtual -void LLViewerOctreeDebug::processGroup(LLviewerOctreeGroup* group) +void LLViewerOctreeDebug::processGroup(LLViewerOctreeGroup* group) { #if 0 const LLVector4a* vec4 = group->getBounds(); diff --git a/indra/newview/llvieweroctree.h b/indra/newview/llvieweroctree.h index 174af5e22f..1eaa1b931e 100644 --- a/indra/newview/llvieweroctree.h +++ b/indra/newview/llvieweroctree.h @@ -41,7 +41,7 @@ class LLViewerRegion; class LLViewerOctreeEntryData; -class LLviewerOctreeGroup; +class LLViewerOctreeGroup; class LLViewerOctreeEntry; class LLViewerOctreePartition; @@ -53,7 +53,7 @@ typedef LLOctreeTraveler<LLViewerOctreeEntry> OctreeTraveler; #if LL_OCTREE_PARANOIA_CHECK #define assert_octree_valid(x) x->validate() -#define assert_states_valid(x) ((LLviewerOctreeGroup*) x->mSpatialPartition->mOctree->getListener(0))->checkStates() +#define assert_states_valid(x) ((LLViewerOctreeGroup*) x->mSpatialPartition->mOctree->getListener(0))->checkStates() #else #define assert_octree_valid(x) #define assert_states_valid(x) @@ -71,7 +71,7 @@ S32 AABBSphereIntersectR2(const LLVector3& min, const LLVector3& max, const LLVe //defines data needed for octree of an entry //LL_ALIGN_PREFIX(16) -class LLViewerOctreeEntry : public LLRefCount +class LLViewerOctreeEntry : public LLRefCount, public LLTrace::MemTrackable<LLViewerOctreeEntry, 16> { friend class LLViewerOctreeEntryData; @@ -90,7 +90,7 @@ public: LLViewerOctreeEntry(); void nullGroup(); //called by group handleDestruction() only - void setGroup(LLviewerOctreeGroup* group); + void setGroup(LLViewerOctreeGroup* group); void removeData(LLViewerOctreeEntryData* data); LLViewerOctreeEntryData* getDrawable() const {return mData[LLDRAWABLE];} @@ -100,28 +100,18 @@ public: const LLVector4a* getSpatialExtents() const {return mExtents;} const LLVector4a& getPositionGroup() const {return mPositionGroup;} - LLviewerOctreeGroup* getGroup()const {return mGroup;} + LLViewerOctreeGroup* getGroup()const {return mGroup;} F32 getBinRadius() const {return mBinRadius;} S32 getBinIndex() const {return mBinIndex; } void setBinIndex(S32 index) const {mBinIndex = index; } - void* operator new(size_t size) - { - return ll_aligned_malloc_16(size); - } - - void operator delete(void* ptr) - { - ll_aligned_free_16(ptr); - } - private: void addData(LLViewerOctreeEntryData* data); private: LLViewerOctreeEntryData* mData[NUM_DATA_TYPE]; //do not use LLPointer here. - LLviewerOctreeGroup* mGroup; + LLViewerOctreeGroup* mGroup; //aligned members LL_ALIGN_16(LLVector4a mExtents[2]); @@ -153,7 +143,7 @@ public: F32 getBinRadius() const {return mEntry->getBinRadius();} const LLVector4a* getSpatialExtents() const; - LLviewerOctreeGroup* getGroup()const; + LLViewerOctreeGroup* getGroup()const; const LLVector4a& getPositionGroup() const; void setBinRadius(F32 rad) {mEntry->mBinRadius = rad;} @@ -161,7 +151,7 @@ public: void setSpatialExtents(const LLVector4a& min, const LLVector4a& max); void setPositionGroup(const LLVector4a& pos); - virtual void setGroup(LLviewerOctreeGroup* group); + virtual void setGroup(LLViewerOctreeGroup* group); void shift(const LLVector4a &shift_vector); U32 getVisible() const {return mEntry ? mEntry->mVisible : 0;} @@ -185,11 +175,12 @@ protected: //defines an octree group for an octree node, which contains multiple entries. //LL_ALIGN_PREFIX(16) -class LLviewerOctreeGroup : public LLOctreeListener<LLViewerOctreeEntry> +class LLViewerOctreeGroup +: public LLOctreeListener<LLViewerOctreeEntry>, public LLTrace::MemTrackable<LLViewerOctreeGroup, 16> { friend class LLViewerOctreeCull; protected: - virtual ~LLviewerOctreeGroup(); + virtual ~LLViewerOctreeGroup(); public: enum @@ -206,22 +197,13 @@ public: typedef LLOctreeNode<LLViewerOctreeEntry>::element_iter element_iter; typedef LLOctreeNode<LLViewerOctreeEntry>::element_list element_list; - LLviewerOctreeGroup(OctreeNode* node); - LLviewerOctreeGroup(const LLviewerOctreeGroup& rhs) + LLViewerOctreeGroup(OctreeNode* node); + LLViewerOctreeGroup(const LLViewerOctreeGroup& rhs) + : LLTrace::MemTrackable<LLViewerOctreeGroup, 16>("LLViewerOctreeGroup") { *this = rhs; } - void* operator new(size_t size) - { - return ll_aligned_malloc_16(size); - } - - void operator delete(void* ptr) - { - ll_aligned_free_16(ptr); - } - bool removeFromGroup(LLViewerOctreeEntryData* data); bool removeFromGroup(LLViewerOctreeEntry* entry); @@ -250,7 +232,7 @@ public: virtual void handleChildRemoval(const OctreeNode* parent, const OctreeNode* child); OctreeNode* getOctreeNode() {return mOctreeNode;} - LLviewerOctreeGroup* getParent(); + LLViewerOctreeGroup* getParent(); const LLVector4a* getBounds() const {return mBounds;} const LLVector4a* getExtents() const {return mExtents;} @@ -285,7 +267,7 @@ public: //octree group which has capability to support occlusion culling //LL_ALIGN_PREFIX(16) -class LLOcclusionCullingGroup : public LLviewerOctreeGroup +class LLOcclusionCullingGroup : public LLViewerOctreeGroup { public: typedef enum @@ -310,7 +292,7 @@ protected: public: LLOcclusionCullingGroup(OctreeNode* node, LLViewerOctreePartition* part); - LLOcclusionCullingGroup(const LLOcclusionCullingGroup& rhs) : LLviewerOctreeGroup(rhs) + LLOcclusionCullingGroup(const LLOcclusionCullingGroup& rhs) : LLViewerOctreeGroup(rhs) { *this = rhs; } @@ -379,35 +361,35 @@ public: LLViewerOctreeCull(LLCamera* camera) : mCamera(camera), mRes(0) { } - virtual bool earlyFail(LLviewerOctreeGroup* group); + virtual bool earlyFail(LLViewerOctreeGroup* group); virtual void traverse(const OctreeNode* n); //agent space group cull - S32 AABBInFrustumNoFarClipGroupBounds(const LLviewerOctreeGroup* group); - S32 AABBSphereIntersectGroupExtents(const LLviewerOctreeGroup* group); - S32 AABBInFrustumGroupBounds(const LLviewerOctreeGroup* group); + S32 AABBInFrustumNoFarClipGroupBounds(const LLViewerOctreeGroup* group); + S32 AABBSphereIntersectGroupExtents(const LLViewerOctreeGroup* group); + S32 AABBInFrustumGroupBounds(const LLViewerOctreeGroup* group); //agent space object set cull - S32 AABBInFrustumNoFarClipObjectBounds(const LLviewerOctreeGroup* group); - S32 AABBSphereIntersectObjectExtents(const LLviewerOctreeGroup* group); - S32 AABBInFrustumObjectBounds(const LLviewerOctreeGroup* group); + S32 AABBInFrustumNoFarClipObjectBounds(const LLViewerOctreeGroup* group); + S32 AABBSphereIntersectObjectExtents(const LLViewerOctreeGroup* group); + S32 AABBInFrustumObjectBounds(const LLViewerOctreeGroup* group); //local region space group cull - S32 AABBInRegionFrustumNoFarClipGroupBounds(const LLviewerOctreeGroup* group); - S32 AABBInRegionFrustumGroupBounds(const LLviewerOctreeGroup* group); - S32 AABBRegionSphereIntersectGroupExtents(const LLviewerOctreeGroup* group, const LLVector3& shift); + S32 AABBInRegionFrustumNoFarClipGroupBounds(const LLViewerOctreeGroup* group); + S32 AABBInRegionFrustumGroupBounds(const LLViewerOctreeGroup* group); + S32 AABBRegionSphereIntersectGroupExtents(const LLViewerOctreeGroup* group, const LLVector3& shift); //local region space object set cull - S32 AABBInRegionFrustumNoFarClipObjectBounds(const LLviewerOctreeGroup* group); - S32 AABBInRegionFrustumObjectBounds(const LLviewerOctreeGroup* group); - S32 AABBRegionSphereIntersectObjectExtents(const LLviewerOctreeGroup* group, const LLVector3& shift); + S32 AABBInRegionFrustumNoFarClipObjectBounds(const LLViewerOctreeGroup* group); + S32 AABBInRegionFrustumObjectBounds(const LLViewerOctreeGroup* group); + S32 AABBRegionSphereIntersectObjectExtents(const LLViewerOctreeGroup* group, const LLVector3& shift); - virtual S32 frustumCheck(const LLviewerOctreeGroup* group) = 0; - virtual S32 frustumCheckObjects(const LLviewerOctreeGroup* group) = 0; + virtual S32 frustumCheck(const LLViewerOctreeGroup* group) = 0; + virtual S32 frustumCheckObjects(const LLViewerOctreeGroup* group) = 0; - virtual bool checkObjects(const OctreeNode* branch, const LLviewerOctreeGroup* group); - virtual void preprocess(LLviewerOctreeGroup* group); - virtual void processGroup(LLviewerOctreeGroup* group); + virtual bool checkObjects(const OctreeNode* branch, const LLViewerOctreeGroup* group); + virtual void preprocess(LLViewerOctreeGroup* group); + virtual void processGroup(LLViewerOctreeGroup* group); virtual void visit(const OctreeNode* branch); protected: @@ -419,7 +401,7 @@ protected: class LLViewerOctreeDebug : public OctreeTraveler { public: - virtual void processGroup(LLviewerOctreeGroup* group); + virtual void processGroup(LLViewerOctreeGroup* group); virtual void visit(const OctreeNode* branch); public: diff --git a/indra/newview/llviewerregion.cpp b/indra/newview/llviewerregion.cpp index 6e9f649d23..4b4de583d8 100755 --- a/indra/newview/llviewerregion.cpp +++ b/indra/newview/llviewerregion.cpp @@ -148,7 +148,7 @@ public: LLVOCacheEntry::vocache_entry_map_t mCacheMap; //all cached entries LLVOCacheEntry::vocache_entry_set_t mActiveSet; //all active entries; LLVOCacheEntry::vocache_entry_set_t mWaitingSet; //entries waiting for LLDrawable to be generated. - std::set< LLPointer<LLviewerOctreeGroup> > mVisibleGroups; //visible groupa + std::set< LLPointer<LLViewerOctreeGroup> > mVisibleGroups; //visible groupa LLVOCachePartition* mVOCachePartition; LLVOCacheEntry::vocache_entry_set_t mVisibleEntries; //must-be-created visible entries wait for objects creation. LLVOCacheEntry::vocache_entry_priority_list_t mWaitingList; //transient list storing sorted visible entries waiting for object creation. @@ -963,7 +963,7 @@ void LLViewerRegion::removeActiveCacheEntry(LLVOCacheEntry* entry, LLDrawable* d entry->setState(LLVOCacheEntry::INACTIVE); } -bool LLViewerRegion::addVisibleGroup(LLviewerOctreeGroup* group) +bool LLViewerRegion::addVisibleGroup(LLViewerOctreeGroup* group) { if(mDead || group->isEmpty()) { @@ -1110,17 +1110,17 @@ F32 LLViewerRegion::updateVisibleEntries(F32 max_time) } //process visible groups - std::set< LLPointer<LLviewerOctreeGroup> >::iterator group_iter = mImpl->mVisibleGroups.begin(); + std::set< LLPointer<LLViewerOctreeGroup> >::iterator group_iter = mImpl->mVisibleGroups.begin(); for(; group_iter != mImpl->mVisibleGroups.end(); ++group_iter) { - LLPointer<LLviewerOctreeGroup> group = *group_iter; + LLPointer<LLViewerOctreeGroup> group = *group_iter; if(group->getNumRefs() < 3 || //group to be deleted !group->getOctreeNode() || group->isEmpty()) //group empty { continue; } - for (LLviewerOctreeGroup::element_iter i = group->getDataBegin(); i != group->getDataEnd(); ++i) + for (LLViewerOctreeGroup::element_iter i = group->getDataBegin(); i != group->getDataEnd(); ++i) { if((*i)->hasVOCacheEntry()) { diff --git a/indra/newview/llviewerregion.h b/indra/newview/llviewerregion.h index 79a992a4c1..4e2252b75b 100755 --- a/indra/newview/llviewerregion.h +++ b/indra/newview/llviewerregion.h @@ -68,7 +68,7 @@ class LLBBox; class LLSpatialGroup; class LLDrawable; class LLViewerRegionImpl; -class LLviewerOctreeGroup; +class LLViewerOctreeGroup; class LLVOCachePartition; class LLViewerRegion: public LLCapabilityProvider // implements this interface @@ -230,7 +230,7 @@ public: F32 getWidth() const { return mWidth; } BOOL idleUpdate(F32 max_update_time); - bool addVisibleGroup(LLviewerOctreeGroup* group); + bool addVisibleGroup(LLViewerOctreeGroup* group); void addVisibleCacheEntry(LLVOCacheEntry* entry); void addActiveCacheEntry(LLVOCacheEntry* entry); void removeActiveCacheEntry(LLVOCacheEntry* entry, LLDrawable* drawablep); diff --git a/indra/newview/llviewerstats.cpp b/indra/newview/llviewerstats.cpp index f300983f19..c81a9a0ad3 100755 --- a/indra/newview/llviewerstats.cpp +++ b/indra/newview/llviewerstats.cpp @@ -343,17 +343,17 @@ void update_statistics() sample(LLStatViewer::DRAW_DISTANCE, (F64)gSavedSettings.getF32("RenderFarClip")); sample(LLStatViewer::CHAT_BUBBLES, gSavedSettings.getBOOL("UseChatBubbles")); - typedef LLInstanceTracker<LLTrace::TraceType<LLTrace::TimeBlockAccumulator>, std::string> trace_type_t; + typedef LLInstanceTracker<LLTrace::StatType<LLTrace::TimeBlockAccumulator>, std::string> stat_type_t; - F64Seconds idle_secs = last_frame_recording.getSum(*trace_type_t::getInstance("Idle")); - F64Seconds network_secs = last_frame_recording.getSum(*trace_type_t::getInstance("Network")); + F64Seconds idle_secs = last_frame_recording.getSum(*stat_type_t::getInstance("Idle")); + F64Seconds network_secs = last_frame_recording.getSum(*stat_type_t::getInstance("Network")); - record(LLStatViewer::FRAME_STACKTIME, last_frame_recording.getSum(*trace_type_t::getInstance("Frame"))); + record(LLStatViewer::FRAME_STACKTIME, last_frame_recording.getSum(*stat_type_t::getInstance("Frame"))); record(LLStatViewer::UPDATE_STACKTIME, idle_secs - network_secs); record(LLStatViewer::NETWORK_STACKTIME, network_secs); - record(LLStatViewer::IMAGE_STACKTIME, last_frame_recording.getSum(*trace_type_t::getInstance("Update Images"))); - record(LLStatViewer::REBUILD_STACKTIME, last_frame_recording.getSum(*trace_type_t::getInstance("Sort Draw State"))); - record(LLStatViewer::RENDER_STACKTIME, last_frame_recording.getSum(*trace_type_t::getInstance("Render Geometry"))); + record(LLStatViewer::IMAGE_STACKTIME, last_frame_recording.getSum(*stat_type_t::getInstance("Update Images"))); + record(LLStatViewer::REBUILD_STACKTIME, last_frame_recording.getSum(*stat_type_t::getInstance("Sort Draw State"))); + record(LLStatViewer::RENDER_STACKTIME, last_frame_recording.getSum(*stat_type_t::getInstance("Render Geometry"))); LLCircuitData *cdp = gMessageSystem->mCircuitInfo.findCircuit(gAgent.getRegion()->getHost()); if (cdp) diff --git a/indra/newview/llvoavatar.h b/indra/newview/llvoavatar.h index b600d2a8f1..6800fe3785 100755 --- a/indra/newview/llvoavatar.h +++ b/indra/newview/llvoavatar.h @@ -97,12 +97,12 @@ public: public: void* operator new(size_t size) { - return ll_aligned_malloc_16(size); + return LLTrace::MemTrackable<LLViewerObject>::aligned_new<16>(size); } - void operator delete(void* ptr) + void operator delete(void* ptr, size_t size) { - ll_aligned_free_16(ptr); + LLTrace::MemTrackable<LLViewerObject>::aligned_delete<16>(ptr, size); } LLVOAvatar(const LLUUID &id, const LLPCode pcode, LLViewerRegion *regionp); diff --git a/indra/newview/llvoavatarself.h b/indra/newview/llvoavatarself.h index 9e9e2b61d7..c280988fd6 100755 --- a/indra/newview/llvoavatarself.h +++ b/indra/newview/llvoavatarself.h @@ -50,16 +50,6 @@ class LLVOAvatarSelf : **/ public: - void* operator new(size_t size) - { - return ll_aligned_malloc_16(size); - } - - void operator delete(void* ptr) - { - ll_aligned_free_16(ptr); - } - LLVOAvatarSelf(const LLUUID &id, const LLPCode pcode, LLViewerRegion *regionp); virtual ~LLVOAvatarSelf(); virtual void markDead(); diff --git a/indra/newview/llvocache.cpp b/indra/newview/llvocache.cpp index ada412be8c..3f01ffa3cd 100755 --- a/indra/newview/llvocache.cpp +++ b/indra/newview/llvocache.cpp @@ -495,7 +495,7 @@ void LLVOCacheGroup::handleChildAddition(const OctreeNode* parent, OctreeNode* c unbound(); - ((LLviewerOctreeGroup*)child->getListener(0))->unbound(); + ((LLViewerOctreeGroup*)child->getListener(0))->unbound(); } LLVOCachePartition::LLVOCachePartition(LLViewerRegion* regionp) @@ -542,7 +542,7 @@ public: mUseObjectCacheOcclusion = use_object_cache_occlusion; } - virtual bool earlyFail(LLviewerOctreeGroup* base_group) + virtual bool earlyFail(LLViewerOctreeGroup* base_group) { if( mUseObjectCacheOcclusion && base_group->getOctreeNode()->getParent()) //never occlusion cull the root node @@ -565,7 +565,7 @@ public: return false; } - virtual S32 frustumCheck(const LLviewerOctreeGroup* group) + virtual S32 frustumCheck(const LLViewerOctreeGroup* group) { #if 1 S32 res = AABBInRegionFrustumGroupBounds(group); @@ -579,7 +579,7 @@ public: return res; } - virtual S32 frustumCheckObjects(const LLviewerOctreeGroup* group) + virtual S32 frustumCheckObjects(const LLViewerOctreeGroup* group) { #if 1 S32 res = AABBInRegionFrustumObjectBounds(group); @@ -593,7 +593,7 @@ public: return res; } - virtual void processGroup(LLviewerOctreeGroup* base_group) + virtual void processGroup(LLViewerOctreeGroup* base_group) { if( !mUseObjectCacheOcclusion || !base_group->getOctreeNode()->getParent()) @@ -647,19 +647,19 @@ public: mSphereRadius = back_sphere_radius; } - virtual S32 frustumCheck(const LLviewerOctreeGroup* group) + virtual S32 frustumCheck(const LLViewerOctreeGroup* group) { const LLVector4a* exts = group->getExtents(); return backSphereCheck(exts[0], exts[1]); } - virtual S32 frustumCheckObjects(const LLviewerOctreeGroup* group) + virtual S32 frustumCheckObjects(const LLViewerOctreeGroup* group) { const LLVector4a* exts = group->getObjectExtents(); return backSphereCheck(exts[0], exts[1]); } - virtual void processGroup(LLviewerOctreeGroup* base_group) + virtual void processGroup(LLViewerOctreeGroup* base_group) { mRegionp->addVisibleGroup(base_group); return; @@ -721,7 +721,7 @@ S32 LLVOCachePartition::cull(LLCamera &camera, bool do_occlusion) return 0; } - ((LLviewerOctreeGroup*)mOctree->getListener(0))->rebound(); + ((LLViewerOctreeGroup*)mOctree->getListener(0))->rebound(); if(LLViewerCamera::sCurCameraID >= LLViewerCamera::CAMERA_WATER0) { @@ -779,7 +779,7 @@ S32 LLVOCachePartition::cull(LLCamera &camera, bool do_occlusion) return 1; } -void LLVOCachePartition::addOccluders(LLviewerOctreeGroup* gp) +void LLVOCachePartition::addOccluders(LLViewerOctreeGroup* gp) { LLVOCacheGroup* group = (LLVOCacheGroup*)gp; diff --git a/indra/newview/llvocache.h b/indra/newview/llvocache.h index b58bb3d499..eef364dd5d 100755 --- a/indra/newview/llvocache.h +++ b/indra/newview/llvocache.h @@ -180,7 +180,7 @@ public: void addEntry(LLViewerOctreeEntry* entry); void removeEntry(LLViewerOctreeEntry* entry); /*virtual*/ S32 cull(LLCamera &camera, bool do_occlusion); - void addOccluders(LLviewerOctreeGroup* gp); + void addOccluders(LLViewerOctreeGroup* gp); void resetOccluders(); void processOccluders(LLCamera* camera); void removeOccluder(LLVOCacheGroup* group); diff --git a/indra/newview/skins/default/xui/en/floater_stats.xml b/indra/newview/skins/default/xui/en/floater_stats.xml index b2399123be..6c776907f5 100755 --- a/indra/newview/skins/default/xui/en/floater_stats.xml +++ b/indra/newview/skins/default/xui/en/floater_stats.xml @@ -125,12 +125,27 @@ <stat_bar name="LLViewerObject" label="Viewer Objects" stat="LLViewerObject"/> - <stat_bar name="LLVOCacheEntry" + <stat_bar name="LLViewerOctreeGroup" + label="Octree Group Data" + stat="LLViewerOctreeGroup"/> + <stat_bar name="LLViewerOctreeEntry" + label="Octree Data" + stat="LLViewerOctreeEntry"/> + <stat_bar name="LLVOCacheEntry" label="Viewer Object Cache" stat="LLVOCacheEntry"/> <stat_bar name="LLDrawable" label="Drawables" stat="LLDrawable"/> + <stat_bar name="LLFace" + label="Face Data" + stat="LLFace"/> + <stat_bar name="LLDrawInfo" + label="Draw Info" + stat="LLDrawInfo"/> + <stat_bar name="LLTexture" + label="Texture Data" + stat="LLTexture"/> <stat_bar name="LLImage" label="Image Data" stat="LLImage"/> |