diff options
Diffstat (limited to 'indra')
28 files changed, 270 insertions, 273 deletions
diff --git a/indra/llcommon/llfasttimer.cpp b/indra/llcommon/llfasttimer.cpp index 52b3bb39b2..32ef01b2b6 100755 --- a/indra/llcommon/llfasttimer.cpp +++ b/indra/llcommon/llfasttimer.cpp @@ -259,15 +259,12 @@ void TimeBlock::updateTimes() && cur_timer->mParentTimerData.mActiveTimer != cur_timer) // root defined by parent pointing to self { U64 cumulative_time_delta = cur_time - cur_timer->mStartTime; - accumulator->mTotalTimeCounter += cumulative_time_delta - - (accumulator->mTotalTimeCounter - - cur_timer->mBlockStartTotalTimeCounter); + cur_timer->mStartTime = cur_time; + + accumulator->mTotalTimeCounter += cumulative_time_delta; accumulator->mSelfTimeCounter += cumulative_time_delta - stack_record->mChildTime; stack_record->mChildTime = 0; - cur_timer->mStartTime = cur_time; - cur_timer->mBlockStartTotalTimeCounter = accumulator->mTotalTimeCounter; - stack_record = &cur_timer->mParentTimerData; accumulator = &stack_record->mTimeBlock->getCurrentAccumulator(); cur_timer = stack_record->mActiveTimer; @@ -423,7 +420,6 @@ void TimeBlock::writeLog(std::ostream& os) TimeBlockAccumulator::TimeBlockAccumulator() : mTotalTimeCounter(0), mSelfTimeCounter(0), - mStartTotalTimeCounter(0), mCalls(0), mLastCaller(NULL), mActiveCount(0), @@ -436,7 +432,7 @@ void TimeBlockAccumulator::addSamples( const TimeBlockAccumulator& other, EBuffe // we can't merge two unrelated time block samples, as that will screw with the nested timings // due to the call hierarchy of each thread llassert(append_type == SEQUENTIAL); - mTotalTimeCounter += other.mTotalTimeCounter - other.mStartTotalTimeCounter; + mTotalTimeCounter += other.mTotalTimeCounter; mSelfTimeCounter += other.mSelfTimeCounter; mCalls += other.mCalls; mLastCaller = other.mLastCaller; @@ -449,21 +445,15 @@ void TimeBlockAccumulator::reset( const TimeBlockAccumulator* other ) { mCalls = 0; mSelfTimeCounter = 0; + mTotalTimeCounter = 0; if (other) { - mStartTotalTimeCounter = other->mTotalTimeCounter; - mTotalTimeCounter = mStartTotalTimeCounter; - mLastCaller = other->mLastCaller; mActiveCount = other->mActiveCount; mMoveUpTree = other->mMoveUpTree; mParent = other->mParent; } - else - { - mStartTotalTimeCounter = mTotalTimeCounter; - } } F64Seconds BlockTimer::getElapsedTime() diff --git a/indra/llcommon/llfasttimer.h b/indra/llcommon/llfasttimer.h index 53c61734e5..4eb12907dc 100755 --- a/indra/llcommon/llfasttimer.h +++ b/indra/llcommon/llfasttimer.h @@ -71,7 +71,6 @@ public: private: U64 mStartTime; - U64 mBlockStartTotalTimeCounter; BlockTimerStackRecord mParentTimerData; }; @@ -287,7 +286,6 @@ LL_FORCE_INLINE BlockTimer::BlockTimer(TimeBlock& timer) if (!cur_timer_data) return; TimeBlockAccumulator& accumulator = timer.getCurrentAccumulator(); accumulator.mActiveCount++; - mBlockStartTotalTimeCounter = accumulator.mTotalTimeCounter; // keep current parent as long as it is active when we are accumulator.mMoveUpTree |= (accumulator.mParent->getCurrentAccumulator().mActiveCount == 0); @@ -312,7 +310,7 @@ LL_FORCE_INLINE BlockTimer::~BlockTimer() TimeBlockAccumulator& accumulator = cur_timer_data->mTimeBlock->getCurrentAccumulator(); accumulator.mCalls++; - accumulator.mTotalTimeCounter += total_time - (accumulator.mTotalTimeCounter - mBlockStartTotalTimeCounter); + accumulator.mTotalTimeCounter += total_time; accumulator.mSelfTimeCounter += total_time - cur_timer_data->mChildTime; accumulator.mActiveCount--; diff --git a/indra/llcommon/llmemory.h b/indra/llcommon/llmemory.h index d3c5e5235d..2330bfb8ea 100755 --- a/indra/llcommon/llmemory.h +++ b/indra/llcommon/llmemory.h @@ -54,7 +54,7 @@ class LLMutex ; #define LL_DEFAULT_HEAP_ALIGN 8 #endif -inline void* ll_aligned_malloc( size_t size, int align ) +inline void* ll_aligned_malloc_fallback( size_t size, int align ) { void* mem = malloc( size + (align - 1) + sizeof(void*) ); char* aligned = ((char*)mem) + sizeof(void*); @@ -64,7 +64,7 @@ inline void* ll_aligned_malloc( size_t size, int align ) return aligned; } -inline void ll_aligned_free( void* ptr ) +inline void ll_aligned_free_fallback( void* ptr ) { free( ((void**)ptr)[-1] ); } @@ -130,7 +130,7 @@ inline void* ll_aligned_malloc_32(size_t size) // returned hunk MUST be freed wi #if defined(LL_WINDOWS) return _aligned_malloc(size, 32); #elif defined(LL_DARWIN) - return ll_aligned_malloc( size, 32 ); + return ll_aligned_malloc_fallback( size, 32 ); #else void *rtn; if (LL_LIKELY(0 == posix_memalign(&rtn, 32, size))) @@ -151,6 +151,49 @@ inline void ll_aligned_free_32(void *p) #endif } +// general purpose dispatch functions that are forced inline so they can compile down to a single call +LL_FORCE_INLINE void* ll_aligned_malloc(size_t alignment, size_t size) +{ + if (LL_DEFAULT_HEAP_ALIGN % alignment == 0) + { + return malloc(size); + } + else if (alignment == 16) + { + return ll_aligned_malloc_16(size); + } + else if (alignment == 32) + { + return ll_aligned_malloc_32(size); + } + else + { + return ll_aligned_malloc_fallback(size, alignment); + } +} + +LL_FORCE_INLINE void ll_aligned_free(size_t alignment, void* ptr) +{ + if (alignment == LL_DEFAULT_HEAP_ALIGN) + { + free(ptr); + } + else if (alignment == 16) + { + ll_aligned_free_16(ptr); + } + else if (alignment == 32) + { + return ll_aligned_free_32(ptr); + } + else + { + return ll_aligned_free_fallback(ptr); + } +} + + + #ifndef __DEBUG_PRIVATE_MEM__ #define __DEBUG_PRIVATE_MEM__ 0 #endif diff --git a/indra/llcommon/lltrace.h b/indra/llcommon/lltrace.h index 5c833ea287..355617a898 100644 --- a/indra/llcommon/lltrace.h +++ b/indra/llcommon/lltrace.h @@ -161,21 +161,6 @@ void sample(SampleStatHandle<T>& measurement, VALUE_T value) measurement.getCurrentAccumulator().sample(storage_value(converted_value)); } -template<typename T, typename VALUE_T> -void add(SampleStatHandle<T>& measurement, VALUE_T value) -{ - T converted_value(value); - SampleAccumulator& acc = measurement.getCurrentAccumulator(); - if (acc.hasValue()) - { - acc.sample(acc.getLastValue() + converted_value); - } - else - { - acc.sample(converted_value); - } -} - template <typename T = F64> class CountStatHandle : public TraceType<CountAccumulator> @@ -296,28 +281,28 @@ public: } }; -inline void claim_mem(MemStatHandle& measurement, size_t size) +inline void claim_footprint(MemStatHandle& measurement, S32 size) { MemStatAccumulator& accumulator = measurement.getCurrentAccumulator(); accumulator.mSize.sample(accumulator.mSize.hasValue() ? accumulator.mSize.getLastValue() + (F64)size : (F64)size); accumulator.mAllocated.add(1); } -inline void disclaim_mem(MemStatHandle& measurement, size_t size) +inline void disclaim_footprint(MemStatHandle& measurement, S32 size) { MemStatAccumulator& accumulator = measurement.getCurrentAccumulator(); accumulator.mSize.sample(accumulator.mSize.hasValue() ? accumulator.mSize.getLastValue() - (F64)size : -(F64)size); accumulator.mDeallocated.add(1); } -inline void claim_shadow_mem(MemStatHandle& measurement, size_t size) +inline void claim_shadow(MemStatHandle& measurement, S32 size) { MemStatAccumulator& accumulator = measurement.getCurrentAccumulator(); accumulator.mShadowSize.sample(accumulator.mSize.hasValue() ? accumulator.mSize.getLastValue() + (F64)size : (F64)size); accumulator.mShadowAllocated.add(1); } -inline void disclaim_shadow_mem(MemStatHandle& measurement, size_t size) +inline void disclaim_shadow(MemStatHandle& measurement, S32 size) { MemStatAccumulator& accumulator = measurement.getCurrentAccumulator(); accumulator.mShadowSize.sample(accumulator.mSize.hasValue() ? accumulator.mSize.getLastValue() - (F64)size : -(F64)size); @@ -327,94 +312,122 @@ inline void disclaim_shadow_mem(MemStatHandle& measurement, size_t size) // measures effective memory footprint of specified type // specialize to cover different types -template<typename T> -struct MemFootprint +template<typename T, typename IS_MEM_TRACKABLE = void> +struct MeasureMem { - static size_t measure(const T& value) + static size_t measureFootprint(const T& value) { return sizeof(T); } - static size_t measure() + static size_t measureFootprint() { return sizeof(T); } + + static size_t measureShadow(const T& value) + { + return 0; + } + + static size_t measureShadow() + { + return 0; + } }; template<typename T> -struct MemFootprint<T*> +struct MeasureMem<T, typename T::mem_trackable_tag_t> { - static size_t measure(const T* value) + static size_t measureFootprint(const T& value) + { + return sizeof(T) + value.getMemFootprint(); + } + + static size_t measureFootprint() + { + return sizeof(T); + } + + static size_t measureShadow(const T& value) + { + return value.getMemShadow(); + } + + static size_t measureShadow() + { + return MeasureMem<T>::measureShadow(); + } +}; + + +template<typename T, typename IS_MEM_TRACKABLE> +struct MeasureMem<T*, IS_MEM_TRACKABLE> +{ + static size_t measureFootprint(const T* value) { if (!value) { return 0; } - return MemFootprint<T>::measure(*value); + return MeasureMem<T>::measureFootprint(*value); } - static size_t measure() + static size_t measureFootprint() { - return MemFootprint<T>::measure(); + return MeasureMem<T>::measureFootprint(); } -}; -template<typename T> -struct MemFootprint<std::basic_string<T> > -{ - static size_t measure(const std::basic_string<T>& value) + static size_t measureShadow(const T* value) { - return value.capacity() * sizeof(T); + return MeasureMem<T>::measureShadow(*value); } - static size_t measure() + static size_t measureShadow() { - return sizeof(std::basic_string<T>); + return MeasureMem<T>::measureShadow(); } }; -template<typename T> -struct MemFootprint<std::vector<T> > +template<typename T, typename IS_MEM_TRACKABLE> +struct MeasureMem<std::basic_string<T>, IS_MEM_TRACKABLE> { - static size_t measure(const std::vector<T>& value) + static size_t measureFootprint(const std::basic_string<T>& value) { - return value.capacity() * MemFootprint<T>::measure(); + return value.capacity() * sizeof(T); } - static size_t measure() + static size_t measureFootprint() { - return sizeof(std::vector<T>); + return sizeof(std::basic_string<T>); } -}; -template<typename T> -struct MemFootprint<std::list<T> > -{ - static size_t measure(const std::list<T>& value) + static size_t measureShadow(const std::basic_string<T>& value) { - return value.size() * (MemFootprint<T>::measure() + sizeof(void*) * 2); + return 0; } - static size_t measure() + static size_t measureShadow() { - return sizeof(std::list<T>); + return 0; } }; template<typename DERIVED, size_t ALIGNMENT = LL_DEFAULT_HEAP_ALIGN> class MemTrackable { - template<typename TRACKED, typename TRACKED_IS_TRACKER> - struct TrackMemImpl; - - typedef MemTrackable<DERIVED, ALIGNMENT> mem_trackable_t; - static MemStatHandle sMemStat; - public: typedef void mem_trackable_tag_t; + enum EMemType + { + MEM_FOOTPRINT, + MEM_SHADOW + }; + MemTrackable() - : mMemFootprint(0) + : mMemFootprint(0), + mMemShadow(0) { static bool name_initialized = false; if (!name_initialized) @@ -426,7 +439,8 @@ public: virtual ~MemTrackable() { - memDisclaim(mMemFootprint); + disclaimMem(mMemFootprint, MEM_FOOTPRINT); + disclaimMem(mMemShadow, MEM_SHADOW); } static MemStatHandle& getMemStatHandle() @@ -434,186 +448,129 @@ public: return sMemStat; } + S32 getMemFootprint() const { return mMemFootprint; } + S32 getMemShadow() const { return mMemShadow; } + void* operator new(size_t size) { - claim_mem(sMemStat, size); - - if (ALIGNMENT == LL_DEFAULT_HEAP_ALIGN) - { - return ::operator new(size); - } - else if (ALIGNMENT == 16) - { - return ll_aligned_malloc_16(size); - } - else if (ALIGNMENT == 32) - { - return ll_aligned_malloc_32(size); - } - else - { - return ll_aligned_malloc(size, ALIGNMENT); - } + claim_footprint(sMemStat, size); + return ll_aligned_malloc(ALIGNMENT, size); } void operator delete(void* ptr, size_t size) { - disclaim_mem(sMemStat, size); - - if (ALIGNMENT == LL_DEFAULT_HEAP_ALIGN) - { - ::operator delete(ptr); - } - else if (ALIGNMENT == 16) - { - ll_aligned_free_16(ptr); - } - else if (ALIGNMENT == 32) - { - return ll_aligned_free_32(ptr); - } - else - { - return ll_aligned_free(ptr); - } + disclaim_footprint(sMemStat, size); + ll_aligned_free(ALIGNMENT, ptr); } void *operator new [](size_t size) { - claim_mem(sMemStat, size); - - if (ALIGNMENT == LL_DEFAULT_HEAP_ALIGN) - { - return ::operator new[](size); - } - else if (ALIGNMENT == 16) - { - return ll_aligned_malloc_16(size); - } - else if (ALIGNMENT == 32) - { - return ll_aligned_malloc_32(size); - } - else - { - return ll_aligned_malloc(size, ALIGNMENT); - } + claim_footprint(sMemStat, size); + return ll_aligned_malloc(ALIGNMENT, size); } void operator delete[](void* ptr, size_t size) { - disclaim_mem(sMemStat, size); - - if (ALIGNMENT == LL_DEFAULT_HEAP_ALIGN) - { - ::operator delete[](ptr); - } - else if (ALIGNMENT == 16) - { - ll_aligned_free_16(ptr); - } - else if (ALIGNMENT == 32) - { - return ll_aligned_free_32(ptr); - } - else - { - return ll_aligned_free(ptr); - } + disclaim_footprint(sMemStat, size); + ll_aligned_free(ALIGNMENT, ptr); } // claim memory associated with other objects/data as our own, adding to our calculated footprint template<typename CLAIM_T> - CLAIM_T& memClaim(CLAIM_T& value) + CLAIM_T& claimMem(CLAIM_T& value, EMemType mem_type = MEM_FOOTPRINT) { - TrackMemImpl<CLAIM_T>::claim(*this, value); + trackAlloc(MeasureMem<CLAIM_T>::measureFootprint(value), mem_type); + trackAlloc(MeasureMem<CLAIM_T>::measureShadow(value), MEM_SHADOW); return value; } template<typename CLAIM_T> - const CLAIM_T& memClaim(const CLAIM_T& value) + const CLAIM_T& claimMem(const CLAIM_T& value, EMemType mem_type = MEM_FOOTPRINT) { - TrackMemImpl<CLAIM_T>::claim(*this, value); + trackAlloc(MeasureMem<CLAIM_T>::measureFootprint(value), mem_type); + trackAlloc(MeasureMem<CLAIM_T>::measureShadow(value), MEM_SHADOW); return value; } - size_t& memClaim(size_t& size) + size_t& claimMem(size_t& size, EMemType mem_type = MEM_FOOTPRINT) { - claim_mem(sMemStat, size); - mMemFootprint += size; + trackAlloc(size, mem_type); return size; } - int& memClaim(int& size) + S32& claimMem(S32& size, EMemType mem_type = MEM_FOOTPRINT) { - claim_mem(sMemStat, size); - mMemFootprint += size; + trackAlloc(size, mem_type); return size; } // remove memory we had claimed from our calculated footprint template<typename CLAIM_T> - CLAIM_T& memDisclaim(CLAIM_T& value) + CLAIM_T& disclaimMem(CLAIM_T& value, EMemType mem_type = MEM_FOOTPRINT) { - TrackMemImpl<CLAIM_T>::disclaim(*this, value); + trackDealloc(MeasureMem<CLAIM_T>::measureFootprint(value), mem_type); + trackDealloc(MeasureMem<CLAIM_T>::measureShadow(value), MEM_SHADOW); return value; } template<typename CLAIM_T> - const CLAIM_T& memDisclaim(const CLAIM_T& value) + const CLAIM_T& disclaimMem(const CLAIM_T& value, EMemType mem_type = MEM_FOOTPRINT) { - TrackMemImpl<CLAIM_T>::disclaim(*this, value); + trackDealloc(MeasureMem<CLAIM_T>::measureFootprint(value), mem_type); + trackDealloc(MeasureMem<CLAIM_T>::measureShadow(value), MEM_SHADOW); return value; } - size_t& memDisclaim(size_t& size) + size_t& disclaimMem(size_t& size, EMemType mem_type = MEM_FOOTPRINT) { - disclaim_mem(sMemStat, size); - mMemFootprint -= size; + trackDealloc(size, mem_type); return size; } - int& memDisclaim(int& size) + S32& disclaimMem(S32& size, EMemType mem_type = MEM_FOOTPRINT) { - disclaim_mem(sMemStat, size); - mMemFootprint -= size; + trackDealloc(size, mem_type); return size; } private: - size_t mMemFootprint; - template<typename TRACKED, typename TRACKED_IS_TRACKER = void> - struct TrackMemImpl + void trackAlloc(S32 size, EMemType mem_type) { - static void claim(mem_trackable_t& tracker, const TRACKED& tracked) + if (mem_type == MEM_FOOTPRINT) { - size_t footprint = MemFootprint<TRACKED>::measure(tracked); - claim_mem(sMemStat, footprint); - tracker.mMemFootprint += footprint; + claim_footprint(sMemStat, size); + mMemFootprint += size; } - - static void disclaim(mem_trackable_t& tracker, const TRACKED& tracked) + else { - size_t footprint = MemFootprint<TRACKED>::measure(tracked); - disclaim_mem(sMemStat, footprint); - tracker.mMemFootprint -= footprint; + claim_shadow(sMemStat, size); + mMemShadow += size; } - }; + } - template<typename TRACKED> - struct TrackMemImpl<TRACKED, typename TRACKED::mem_trackable_tag_t> + void trackDealloc(S32 size, EMemType mem_type) { - static void claim(mem_trackable_t& tracker, TRACKED& tracked) + if (mem_type == MEM_FOOTPRINT) { - claim_shadow_mem( sMemStat, MemFootprint<TRACKED>::measure(tracked)); + disclaim_footprint(sMemStat, size); + mMemFootprint -= size; } - - static void disclaim(mem_trackable_t& tracker, TRACKED& tracked) + else { - disclaim_shadow_mem(sMemStat, MemFootprint<TRACKED>::measure(tracked)); + disclaim_shadow(sMemStat, size); + mMemShadow -= size; } - }; + } + +private: + // use signed values so that we can temporarily go negative + // and reconcile in destructor + // NB: this assumes that no single class is responsible for > 2GB of allocations + S32 mMemFootprint, + mMemShadow; + + static MemStatHandle sMemStat; }; template<typename DERIVED, size_t ALIGNMENT> diff --git a/indra/llcommon/lltraceaccumulators.h b/indra/llcommon/lltraceaccumulators.h index 37a35f4e23..4fe84455a6 100644 --- a/indra/llcommon/lltraceaccumulators.h +++ b/indra/llcommon/lltraceaccumulators.h @@ -35,6 +35,7 @@ #include "lltimer.h" #include "llrefcount.h" #include "llthreadlocalstorage.h" +#include "llmemory.h" #include <limits> namespace LLTrace @@ -51,7 +52,7 @@ namespace LLTrace class AccumulatorBuffer : public LLRefCount { typedef AccumulatorBuffer<ACCUMULATOR> self_t; - static const U32 DEFAULT_ACCUMULATOR_BUFFER_SIZE = 64; + static const U32 ACCUMULATOR_BUFFER_SIZE_INCREMENT = 16; private: struct StaticAllocationMarker { }; @@ -149,7 +150,9 @@ namespace LLTrace size_t next_slot = sNextStorageSlot++; if (next_slot >= mStorageSize) { - resize(mStorageSize + (mStorageSize >> 2)); + // 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); } llassert(mStorage && next_slot < mStorageSize); return next_slot; @@ -199,7 +202,7 @@ namespace LLTrace // so as not to trigger an access violation sDefaultBuffer = new AccumulatorBuffer(StaticAllocationMarker()); sInitialized = true; - sDefaultBuffer->resize(DEFAULT_ACCUMULATOR_BUFFER_SIZE); + sDefaultBuffer->resize(ACCUMULATOR_BUFFER_SIZE_INCREMENT); } return sDefaultBuffer; } @@ -427,6 +430,17 @@ namespace LLTrace typedef F64Seconds value_t; }; + // arrays are allocated with 32 byte alignment + void *operator new [](size_t size) + { + return ll_aligned_malloc(32, size); + } + + void operator delete[](void* ptr, size_t size) + { + ll_aligned_free(32, ptr); + } + TimeBlockAccumulator(); void addSamples(const self_t& other, EBufferAppendType append_type); void reset(const self_t* other); @@ -435,8 +449,7 @@ namespace LLTrace // // members // - U64 mStartTotalTimeCounter, - mTotalTimeCounter, + U64 mTotalTimeCounter, mSelfTimeCounter; U32 mCalls; class TimeBlock* mParent; // last acknowledged parent of this time block diff --git a/indra/llcommon/lltracerecording.cpp b/indra/llcommon/lltracerecording.cpp index c606007d89..c16d02216d 100644 --- a/indra/llcommon/lltracerecording.cpp +++ b/indra/llcommon/lltracerecording.cpp @@ -131,7 +131,7 @@ void Recording::appendRecording( Recording& other ) F64Seconds Recording::getSum(const TraceType<TimeBlockAccumulator>& stat) { const TimeBlockAccumulator& accumulator = mBuffers->mStackTimers[stat.getIndex()]; - return F64Seconds((F64)(accumulator.mTotalTimeCounter - accumulator.mStartTotalTimeCounter) + return F64Seconds((F64)(accumulator.mTotalTimeCounter) / (F64)LLTrace::TimeBlock::countsPerSecond()); } @@ -151,7 +151,7 @@ F64Seconds Recording::getPerSec(const TraceType<TimeBlockAccumulator>& stat) { const TimeBlockAccumulator& accumulator = mBuffers->mStackTimers[stat.getIndex()]; - return F64Seconds((F64)(accumulator.mTotalTimeCounter - accumulator.mStartTotalTimeCounter) + return F64Seconds((F64)(accumulator.mTotalTimeCounter) / ((F64)LLTrace::TimeBlock::countsPerSecond() * mElapsedSeconds.value())); } @@ -935,7 +935,7 @@ void ExtendablePeriodicRecording::handleSplitTo(ExtendablePeriodicRecording& oth PeriodicRecording& get_frame_recording() { - static LLThreadLocalPointer<PeriodicRecording> sRecording(new PeriodicRecording(1000, PeriodicRecording::STARTED)); + static LLThreadLocalPointer<PeriodicRecording> sRecording(new PeriodicRecording(200, PeriodicRecording::STARTED)); return *sRecording; } diff --git a/indra/llcommon/lltracethreadrecorder.cpp b/indra/llcommon/lltracethreadrecorder.cpp index d3d9eb5ca7..e131af5f16 100644 --- a/indra/llcommon/lltracethreadrecorder.cpp +++ b/indra/llcommon/lltracethreadrecorder.cpp @@ -127,10 +127,7 @@ void ThreadRecorder::activate( AccumulatorBufferGroup* recording, bool from_hand { AccumulatorBufferGroup& prev_active_recording = mActiveRecordings.back()->mPartialRecording; prev_active_recording.sync(); - if (!from_handoff) - { - TimeBlock::updateTimes(); - } + TimeBlock::updateTimes(); prev_active_recording.handOffTo(active_recording->mPartialRecording); } mActiveRecordings.push_back(active_recording); diff --git a/indra/llimage/llimage.cpp b/indra/llimage/llimage.cpp index 34e0e202b6..326f477504 100755 --- a/indra/llimage/llimage.cpp +++ b/indra/llimage/llimage.cpp @@ -50,7 +50,6 @@ LLMutex* LLImage::sMutex = NULL; bool LLImage::sUseNewByteRange = false; S32 LLImage::sMinimalReverseByteRangePercent = 75; LLPrivateMemoryPool* LLImageBase::sPrivatePoolp = NULL ; -//LLTrace::MemStatHandle LLImageBase::sMemStat("LLImage"); //static void LLImage::initClass(bool use_new_byte_range, S32 minimal_reverse_byte_range_percent) @@ -159,7 +158,7 @@ void LLImageBase::sanityCheck() void LLImageBase::deleteData() { FREE_MEM(sPrivatePoolp, mData) ; - memDisclaim(mDataSize) = 0; + disclaimMem(mDataSize) = 0; mData = NULL; } @@ -202,7 +201,7 @@ U8* LLImageBase::allocateData(S32 size) mBadBufferAllocation = true ; } mDataSize = size; - memClaim(mDataSize); + claimMem(mDataSize); } return mData; @@ -224,7 +223,7 @@ U8* LLImageBase::reallocateData(S32 size) FREE_MEM(sPrivatePoolp, mData) ; } mData = new_datap; - memClaim(memDisclaim(mDataSize) = size); + claimMem(disclaimMem(mDataSize) = size); return mData; } @@ -1619,7 +1618,7 @@ void LLImageBase::setDataAndSize(U8 *data, S32 size) { ll_assert_aligned(data, 16); mData = data; - memClaim(memDisclaim(mDataSize) = size); + claimMem(disclaimMem(mDataSize) = size); } //static diff --git a/indra/llui/llfolderview.cpp b/indra/llui/llfolderview.cpp index f0caba3e13..e6582a7ae9 100755 --- a/indra/llui/llfolderview.cpp +++ b/indra/llui/llfolderview.cpp @@ -174,7 +174,7 @@ LLFolderView::LLFolderView(const Params& p) mShowItemLinkOverlays(p.show_item_link_overlays), mViewModel(p.view_model) { - memClaim(mViewModel); + claimMem(mViewModel); mViewModel->setFolderView(this); mRoot = this; diff --git a/indra/llui/llfolderviewitem.cpp b/indra/llui/llfolderviewitem.cpp index 26ea9651b5..802cb783ed 100644 --- a/indra/llui/llfolderviewitem.cpp +++ b/indra/llui/llfolderviewitem.cpp @@ -1496,16 +1496,16 @@ void LLFolderViewFolder::extractItem( LLFolderViewItem* item ) ft = std::find(mFolders.begin(), mFolders.end(), f); if (ft != mFolders.end()) { - memDisclaim(mFolders); + disclaimMem(mFolders); mFolders.erase(ft); - memClaim(mFolders); + claimMem(mFolders); } } else { - memDisclaim(mItems); + disclaimMem(mItems); mItems.erase(it); - memClaim(mItems); + claimMem(mItems); } //item has been removed, need to update filter getViewModelItem()->removeChild(item->getViewModelItem()); @@ -1582,9 +1582,9 @@ void LLFolderViewFolder::addItem(LLFolderViewItem* item) } item->setParentFolder(this); - memDisclaim(mItems); + disclaimMem(mItems); mItems.push_back(item); - memClaim(mItems); + claimMem(mItems); item->setRect(LLRect(0, 0, getRect().getWidth(), 0)); item->setVisible(FALSE); @@ -1607,9 +1607,9 @@ void LLFolderViewFolder::addFolder(LLFolderViewFolder* folder) folder->mParentFolder->extractItem(folder); } folder->mParentFolder = this; - memDisclaim(mFolders); + disclaimMem(mFolders); mFolders.push_back(folder); - memClaim(mFolders); + claimMem(mFolders); folder->setOrigin(0, 0); folder->reshape(getRect().getWidth(), 0); folder->setVisible(FALSE); diff --git a/indra/llui/lltextbase.cpp b/indra/llui/lltextbase.cpp index 975f9df382..5c221edea7 100755 --- a/indra/llui/lltextbase.cpp +++ b/indra/llui/lltextbase.cpp @@ -48,8 +48,6 @@ const F32 CURSOR_FLASH_DELAY = 1.0f; // in seconds const S32 CURSOR_THICKNESS = 2; const F32 TRIPLE_CLICK_INTERVAL = 0.3f; // delay between double and triple click. -//LLTrace::MemStatHandle LLTextSegment::sMemStat("LLTextSegment"); - LLTextBase::line_info::line_info(S32 index_start, S32 index_end, LLRect rect, S32 line_num) : mDocIndexStart(index_start), mDocIndexEnd(index_end), @@ -578,7 +576,7 @@ void LLTextBase::drawText() if ( (mSpellCheckStart != start) || (mSpellCheckEnd != end) ) { const LLWString& wstrText = getWText(); - memDisclaim(mMisspellRanges).clear(); + disclaimMem(mMisspellRanges).clear(); segment_set_t::const_iterator seg_it = getSegIterContaining(start); while (mSegments.end() != seg_it) @@ -654,7 +652,7 @@ void LLTextBase::drawText() mSpellCheckStart = start; mSpellCheckEnd = end; - memClaim(mMisspellRanges); + claimMem(mMisspellRanges); } } else @@ -924,11 +922,11 @@ void LLTextBase::createDefaultSegment() if (mSegments.empty()) { LLStyleConstSP sp(new LLStyle(getStyleParams())); - memDisclaim(mSegments); + disclaimMem(mSegments); LLTextSegmentPtr default_segment = new LLNormalTextSegment( sp, 0, getLength() + 1, *this); mSegments.insert(default_segment); default_segment->linkToDocument(this); - memClaim(mSegments); + claimMem(mSegments); } } @@ -939,7 +937,7 @@ void LLTextBase::insertSegment(LLTextSegmentPtr segment_to_insert) return; } - memDisclaim(mSegments); + disclaimMem(mSegments); segment_set_t::iterator cur_seg_iter = getSegIterContaining(segment_to_insert->getStart()); S32 reflow_start_index = 0; @@ -1013,7 +1011,7 @@ void LLTextBase::insertSegment(LLTextSegmentPtr segment_to_insert) // layout potentially changed needsReflow(reflow_start_index); - memClaim(mSegments); + claimMem(mSegments); } BOOL LLTextBase::handleMouseDown(S32 x, S32 y, MASK mask) @@ -1324,10 +1322,10 @@ void LLTextBase::replaceWithSuggestion(U32 index) removeStringNoUndo(it->first, it->second - it->first); // Insert the suggestion in its place - memDisclaim(mSuggestionList); + disclaimMem(mSuggestionList); LLWString suggestion = utf8str_to_wstring(mSuggestionList[index]); insertStringNoUndo(it->first, utf8str_to_wstring(mSuggestionList[index])); - memClaim(mSuggestionList); + claimMem(mSuggestionList); setCursorPos(it->first + (S32)suggestion.length()); @@ -1390,7 +1388,7 @@ bool LLTextBase::isMisspelledWord(U32 pos) const void LLTextBase::onSpellCheckSettingsChange() { // Recheck the spelling on every change - memDisclaim(mMisspellRanges).clear(); + disclaimMem(mMisspellRanges).clear(); mSpellCheckStart = mSpellCheckEnd = -1; } @@ -1668,7 +1666,7 @@ LLRect LLTextBase::getTextBoundingRect() void LLTextBase::clearSegments() { - memDisclaim(mSegments).clear(); + disclaimMem(mSegments).clear(); createDefaultSegment(); } @@ -3212,9 +3210,9 @@ void LLNormalTextSegment::setToolTip(const std::string& tooltip) LL_WARNS() << "LLTextSegment::setToolTip: cannot replace keyword tooltip." << LL_ENDL; return; } - memDisclaim(mTooltip); + disclaimMem(mTooltip); mTooltip = tooltip; - memClaim(mTooltip); + claimMem(mTooltip); } bool LLNormalTextSegment::getDimensions(S32 first_char, S32 num_chars, S32& width, S32& height) const diff --git a/indra/llui/lltextbase.h b/indra/llui/lltextbase.h index 8925ec9e45..b1558a7abe 100755 --- a/indra/llui/lltextbase.h +++ b/indra/llui/lltextbase.h @@ -100,8 +100,6 @@ public: S32 getEnd() const { return mEnd; } void setEnd( S32 end ) { mEnd = end; } - //static LLTrace::MemStatHandle sMemStat; - protected: S32 mStart; S32 mEnd; diff --git a/indra/llui/lluictrl.cpp b/indra/llui/lluictrl.cpp index 9a1a0e0677..9a81c91e0d 100755 --- a/indra/llui/lluictrl.cpp +++ b/indra/llui/lluictrl.cpp @@ -118,7 +118,7 @@ LLUICtrl::LLUICtrl(const LLUICtrl::Params& p, const LLViewModelPtr& viewmodel) mDoubleClickSignal(NULL), mTransparencyType(TT_DEFAULT) { - memClaim(viewmodel.get()); + claimMem(viewmodel.get()); } void LLUICtrl::initFromParams(const Params& p) @@ -941,7 +941,7 @@ boost::signals2::connection LLUICtrl::setCommitCallback( boost::function<void (L } boost::signals2::connection LLUICtrl::setValidateBeforeCommit( boost::function<bool (const LLSD& data)> cb ) { - if (!mValidateSignal) mValidateSignal = memClaim(new enable_signal_t()); + if (!mValidateSignal) mValidateSignal = claimMem(new enable_signal_t()); return mValidateSignal->connect(boost::bind(cb, _2)); } @@ -1004,55 +1004,55 @@ boost::signals2::connection LLUICtrl::setValidateCallback(const EnableCallbackPa boost::signals2::connection LLUICtrl::setCommitCallback( const commit_signal_t::slot_type& cb ) { - if (!mCommitSignal) mCommitSignal = memClaim(new commit_signal_t()); + if (!mCommitSignal) mCommitSignal = claimMem(new commit_signal_t()); return mCommitSignal->connect(cb); } boost::signals2::connection LLUICtrl::setValidateCallback( const enable_signal_t::slot_type& cb ) { - if (!mValidateSignal) mValidateSignal = memClaim(new enable_signal_t()); + if (!mValidateSignal) mValidateSignal = claimMem(new enable_signal_t()); return mValidateSignal->connect(cb); } boost::signals2::connection LLUICtrl::setMouseEnterCallback( const commit_signal_t::slot_type& cb ) { - if (!mMouseEnterSignal) mMouseEnterSignal = memClaim(new commit_signal_t()); + if (!mMouseEnterSignal) mMouseEnterSignal = claimMem(new commit_signal_t()); return mMouseEnterSignal->connect(cb); } boost::signals2::connection LLUICtrl::setMouseLeaveCallback( const commit_signal_t::slot_type& cb ) { - if (!mMouseLeaveSignal) mMouseLeaveSignal = memClaim(new commit_signal_t()); + if (!mMouseLeaveSignal) mMouseLeaveSignal = claimMem(new commit_signal_t()); return mMouseLeaveSignal->connect(cb); } boost::signals2::connection LLUICtrl::setMouseDownCallback( const mouse_signal_t::slot_type& cb ) { - if (!mMouseDownSignal) mMouseDownSignal = memClaim(new mouse_signal_t()); + if (!mMouseDownSignal) mMouseDownSignal = claimMem(new mouse_signal_t()); return mMouseDownSignal->connect(cb); } boost::signals2::connection LLUICtrl::setMouseUpCallback( const mouse_signal_t::slot_type& cb ) { - if (!mMouseUpSignal) mMouseUpSignal = memClaim(new mouse_signal_t()); + if (!mMouseUpSignal) mMouseUpSignal = claimMem(new mouse_signal_t()); return mMouseUpSignal->connect(cb); } boost::signals2::connection LLUICtrl::setRightMouseDownCallback( const mouse_signal_t::slot_type& cb ) { - if (!mRightMouseDownSignal) mRightMouseDownSignal = memClaim(new mouse_signal_t()); + if (!mRightMouseDownSignal) mRightMouseDownSignal = claimMem(new mouse_signal_t()); return mRightMouseDownSignal->connect(cb); } boost::signals2::connection LLUICtrl::setRightMouseUpCallback( const mouse_signal_t::slot_type& cb ) { - if (!mRightMouseUpSignal) mRightMouseUpSignal = memClaim(new mouse_signal_t()); + if (!mRightMouseUpSignal) mRightMouseUpSignal = claimMem(new mouse_signal_t()); return mRightMouseUpSignal->connect(cb); } boost::signals2::connection LLUICtrl::setDoubleClickCallback( const mouse_signal_t::slot_type& cb ) { - if (!mDoubleClickSignal) mDoubleClickSignal = memClaim(new mouse_signal_t()); + if (!mDoubleClickSignal) mDoubleClickSignal = claimMem(new mouse_signal_t()); return mDoubleClickSignal->connect(cb); } diff --git a/indra/llui/llview.cpp b/indra/llui/llview.cpp index 22461083a6..e81d19ae3a 100755 --- a/indra/llui/llview.cpp +++ b/indra/llui/llview.cpp @@ -69,7 +69,6 @@ LLView* LLView::sPreviewClickedElement = NULL; BOOL LLView::sDrawPreviewHighlights = FALSE; S32 LLView::sLastLeftXML = S32_MIN; S32 LLView::sLastBottomXML = S32_MIN; -//LLTrace::MemStatHandle LLView::sMemStat("LLView"); std::vector<LLViewDrawContext*> LLViewDrawContext::sDrawContextStack; LLView::DrilldownFunc LLView::sDrilldown = diff --git a/indra/llui/llview.h b/indra/llui/llview.h index f6799d8cd9..3a0dfb5f42 100755 --- a/indra/llui/llview.h +++ b/indra/llui/llview.h @@ -675,7 +675,6 @@ public: static S32 sLastLeftXML; static S32 sLastBottomXML; static BOOL sForceReshape; - //static LLTrace::MemStatHandle sMemStat; }; namespace LLInitParam diff --git a/indra/llui/llviewmodel.cpp b/indra/llui/llviewmodel.cpp index 21c4e0fcac..6459ade027 100755 --- a/indra/llui/llviewmodel.cpp +++ b/indra/llui/llviewmodel.cpp @@ -35,8 +35,6 @@ // external library headers // other Linden headers -//LLTrace::MemStatHandle LLViewModel::sMemStat("LLViewModel"); - /// LLViewModel::LLViewModel() : mDirty(false) @@ -83,11 +81,11 @@ void LLTextViewModel::setValue(const LLSD& value) { LLViewModel::setValue(value); // approximate LLSD storage usage - memDisclaim(mDisplay.size()); - memDisclaim(mDisplay); + disclaimMem(mDisplay.size()); + disclaimMem(mDisplay); mDisplay = utf8str_to_wstring(value.asString()); - memClaim(mDisplay); - memClaim(mDisplay.size()); + claimMem(mDisplay); + claimMem(mDisplay.size()); // mDisplay and mValue agree mUpdateFromDisplay = false; @@ -99,11 +97,11 @@ void LLTextViewModel::setDisplay(const LLWString& value) // and do the utf8str_to_wstring() to get the corresponding mDisplay // value. But a text editor might want to edit the display string // directly, then convert back to UTF8 on commit. - memDisclaim(mDisplay.size()); - memDisclaim(mDisplay); + disclaimMem(mDisplay.size()); + disclaimMem(mDisplay); mDisplay = value; - memClaim(mDisplay); - memClaim(mDisplay.size()); + claimMem(mDisplay); + claimMem(mDisplay.size()); mDirty = true; // Don't immediately convert to UTF8 -- do it lazily -- we expect many // more setDisplay() calls than getValue() calls. Just flag that it needs diff --git a/indra/llui/llviewmodel.h b/indra/llui/llviewmodel.h index f329201b9f..49d7c322a3 100755 --- a/indra/llui/llviewmodel.h +++ b/indra/llui/llviewmodel.h @@ -83,8 +83,6 @@ public: // void setDirty() { mDirty = true; } - //static LLTrace::MemStatHandle sMemStat; - protected: LLSD mValue; bool mDirty; diff --git a/indra/newview/lldrawable.cpp b/indra/newview/lldrawable.cpp index 1837974604..5baebab5a3 100755 --- a/indra/newview/lldrawable.cpp +++ b/indra/newview/lldrawable.cpp @@ -59,7 +59,6 @@ const F32 MIN_SHADOW_CASTER_RADIUS = 2.0f; static LLTrace::TimeBlock FTM_CULL_REBOUND("Cull Rebound"); extern bool gShiftFrame; -//LLTrace::MemStatHandle LLDrawable::sMemStat("LLDrawable"); //////////////////////// diff --git a/indra/newview/lldrawable.h b/indra/newview/lldrawable.h index 3dab496a20..a0ac417b24 100755 --- a/indra/newview/lldrawable.h +++ b/indra/newview/lldrawable.h @@ -291,7 +291,6 @@ public: F32 mDistanceWRTCamera; static F32 sCurPixelAngle; //current pixels per radian - //static LLTrace::MemStatHandle sMemStat; private: typedef std::vector<LLFace*> face_list_t; diff --git a/indra/newview/lltexturecache.h b/indra/newview/lltexturecache.h index c2a5cf9405..6ff4c44568 100755 --- a/indra/newview/lltexturecache.h +++ b/indra/newview/lltexturecache.h @@ -131,8 +131,8 @@ public: // debug S32 getNumReads() { return mReaders.size(); } S32 getNumWrites() { return mWriters.size(); } - S64 getUsage() { return mTexturesSizeTotal; } - S64 getMaxUsage() { return sCacheMaxTexturesSize; } + S64Bytes getUsage() { return S64Bytes(mTexturesSizeTotal); } + S64Bytes getMaxUsage() { return S64Bytes(sCacheMaxTexturesSize); } U32 getEntries() { return mHeaderEntriesInfo.mEntries; } U32 getMaxEntries() { return sCacheMaxEntries; }; BOOL isInCache(const LLUUID& id) ; diff --git a/indra/newview/lltextureview.cpp b/indra/newview/lltextureview.cpp index 3974668d09..17aebebd92 100755 --- a/indra/newview/lltextureview.cpp +++ b/indra/newview/lltextureview.cpp @@ -512,8 +512,8 @@ void LLGLTexMemBar::draw() S32Megabytes total_mem = LLViewerTexture::sTotalTextureMemory; S32Megabytes max_total_mem = LLViewerTexture::sMaxTotalTextureMem; F32 discard_bias = LLViewerTexture::sDesiredDiscardBias; - F32 cache_usage = (F32)F32Megabytes(LLAppViewer::getTextureCache()->getUsage()).value() ; - F32 cache_max_usage = (F32)F32Megabytes(LLAppViewer::getTextureCache()->getMaxUsage()).value() ; + F32 cache_usage = F32Megabytes(LLAppViewer::getTextureCache()->getUsage()).value(); + F32 cache_max_usage = F32Megabytes(LLAppViewer::getTextureCache()->getMaxUsage()).value(); S32 line_height = LLFontGL::getFontMonospace()->getLineHeight(); S32 v_offset = 0;//(S32)((texture_bar_height + 2.2f) * mTextureView->mNumTextureBars + 2.0f); F32Bytes total_texture_downloaded = gTotalTextureData; @@ -555,8 +555,8 @@ void LLGLTexMemBar::draw() LLAppViewer::getTextureFetch()->getStateStats(&cache_read, &cache_write, &res_wait); text = llformat("Net Tot Tex: %.1f MB Tot Obj: %.1f MB #Objs/#Cached: %d/%d Tot Htp: %d Cread: %u Cwrite: %u Rwait: %u", - total_texture_downloaded.value(), - total_object_downloaded.value(), + total_texture_downloaded.valueInUnits<LLUnits::Megabytes>(), + total_object_downloaded.valueInUnits<LLUnits::Megabytes>(), total_objects, total_active_cached_objects, total_http_requests, diff --git a/indra/newview/llviewerobject.cpp b/indra/newview/llviewerobject.cpp index 2c1ab3a73b..394b11b759 100755 --- a/indra/newview/llviewerobject.cpp +++ b/indra/newview/llviewerobject.cpp @@ -112,7 +112,6 @@ BOOL LLViewerObject::sMapDebug = TRUE; LLColor4 LLViewerObject::sEditSelectColor( 1.0f, 1.f, 0.f, 0.3f); // Edit OK LLColor4 LLViewerObject::sNoEditSelectColor( 1.0f, 0.f, 0.f, 0.3f); // Can't edit S32 LLViewerObject::sAxisArrowLength(50); -//LLTrace::MemStatHandle LLViewerObject::sMemStat("LLViewerObject"); BOOL LLViewerObject::sPulseEnabled(FALSE); diff --git a/indra/newview/llviewerobject.h b/indra/newview/llviewerobject.h index e3972ccae8..56518cca69 100755 --- a/indra/newview/llviewerobject.h +++ b/indra/newview/llviewerobject.h @@ -661,7 +661,6 @@ public: LLPointer<class LLHUDIcon> mIcon; static BOOL sUseSharedDrawables; - //static LLTrace::MemStatHandle sMemStat; protected: // delete an item in the inventory, but don't tell the diff --git a/indra/newview/llvieweroctree.h b/indra/newview/llvieweroctree.h index bc3c7cbfa2..6ebd1d6da1 100644 --- a/indra/newview/llvieweroctree.h +++ b/indra/newview/llvieweroctree.h @@ -135,7 +135,7 @@ private: class LLViewerOctreeEntryData : public LLRefCount { protected: - ~LLViewerOctreeEntryData(); + virtual ~LLViewerOctreeEntryData(); public: LLViewerOctreeEntryData(const LLViewerOctreeEntryData& rhs) diff --git a/indra/newview/llviewerprecompiledheaders.cpp b/indra/newview/llviewerprecompiledheaders.cpp index 307e903726..768f1f3387 100755 --- a/indra/newview/llviewerprecompiledheaders.cpp +++ b/indra/newview/llviewerprecompiledheaders.cpp @@ -26,7 +26,7 @@ // source file that includes just the standard includes // newview.pch will be the pre-compiled header -// llviewerprecompiledheaders.obj will contain the pre-compiled type information +// llviewerprecompiledheaders.obj will contain the pre-compllviewiled type information #include "llviewerprecompiledheaders.h" diff --git a/indra/newview/llvocache.cpp b/indra/newview/llvocache.cpp index dfc9ee57d8..25dd1f4d07 100755 --- a/indra/newview/llvocache.cpp +++ b/indra/newview/llvocache.cpp @@ -38,7 +38,6 @@ F32 LLVOCacheEntry::sBackDistanceSquared = 0.f; F32 LLVOCacheEntry::sBackAngleTanSquared = 0.f; BOOL LLVOCachePartition::sNeedsOcclusionCheck = FALSE; -//LLTrace::MemStatHandle LLVOCachePartition::sMemStat("LLVOCachePartition"); BOOL check_read(LLAPRFile* apr_file, void* src, S32 n_bytes) { diff --git a/indra/newview/llvocache.h b/indra/newview/llvocache.h index 867f9ab93c..70900a7e22 100755 --- a/indra/newview/llvocache.h +++ b/indra/newview/llvocache.h @@ -176,7 +176,6 @@ private: public: static BOOL sNeedsOcclusionCheck; - //static LLTrace::MemStatHandle sMemStat; private: U32 mCullHistory[LLViewerCamera::NUM_CAMERAS]; diff --git a/indra/newview/skins/default/xui/en/floater_stats.xml b/indra/newview/skins/default/xui/en/floater_stats.xml index 2291f81fcc..f0a464dfc9 100755 --- a/indra/newview/skins/default/xui/en/floater_stats.xml +++ b/indra/newview/skins/default/xui/en/floater_stats.xml @@ -114,6 +114,22 @@ label="LLView Memory" stat="class LLView" show_history="true"/> + <stat_bar name="LLViewerObject" + label="LLViewerObject Memory" + stat="class LLViewerObject" + show_history="true"/> + <stat_bar name="LLVOCacheEntry" + label="LLVOCacheEntry Memory" + stat="class LLVOCacheEntry" + show_history="true"/> + <stat_bar name="LLDrawable" + label="LLDrawable Memory" + stat="class LLDrawable" + show_history="true"/> + <stat_bar name="LLImage" + label="LLImage Memory" + stat="class LLImageBase" + show_history="true"/> </stat_view> <stat_view name="network" label="Network" |