/** * @file lltrace.h * @brief Runtime statistics accumulation. * * $LicenseInfo:firstyear=2001&license=viewerlgpl$ * Second Life Viewer Source Code * Copyright (C) 2012, Linden Research, Inc. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; * version 2.1 of the License only. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA * * Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA * $/LicenseInfo$ */ #ifndef LL_LLTRACE_H #define LL_LLTRACE_H #include "stdtypes.h" #include "llpreprocessor.h" #include "llmemory.h" #include "llrefcount.h" #include "llunit.h" #include "llapr.h" #include "llthreadlocalstorage.h" #include #define LL_RECORD_BLOCK_TIME(block_timer) LLTrace::TimeBlock::Recorder LL_GLUE_TOKENS(block_time_recorder, __COUNTER__)(block_timer); namespace LLTrace { class Recording; typedef LLUnit Bytes; typedef LLUnit Kilobytes; typedef LLUnit Megabytes; typedef LLUnit Gigabytes; typedef LLUnit Bits; typedef LLUnit Kilobits; typedef LLUnit Megabits; typedef LLUnit Gigabits; typedef LLUnit Seconds; typedef LLUnit Milliseconds; typedef LLUnit Minutes; typedef LLUnit Hours; typedef LLUnit Milliseconds; typedef LLUnit Microseconds; typedef LLUnit Nanoseconds; typedef LLUnit Meters; typedef LLUnit Kilometers; typedef LLUnit Centimeters; typedef LLUnit Millimeters; void init(); void cleanup(); bool isInitialized(); const LLThreadLocalPointer& get_thread_recorder(); void set_thread_recorder(class ThreadRecorder*); class MasterThreadRecorder& getMasterThreadRecorder(); // one per thread per type template class AccumulatorBuffer : public LLRefCount { typedef AccumulatorBuffer self_t; static const U32 DEFAULT_ACCUMULATOR_BUFFER_SIZE = 64; private: struct StaticAllocationMarker { }; AccumulatorBuffer(StaticAllocationMarker m) : mStorageSize(0), mStorage(NULL), mNextStorageSlot(0) { } public: AccumulatorBuffer(const AccumulatorBuffer& other = *getDefaultBuffer()) : mStorageSize(0), mStorage(NULL), mNextStorageSlot(other.mNextStorageSlot) { resize(other.mStorageSize); for (S32 i = 0; i < mNextStorageSlot; i++) { mStorage[i] = other.mStorage[i]; } } ~AccumulatorBuffer() { if (LLThreadLocalSingletonPointer::getInstance() == mStorage) { LLThreadLocalSingletonPointer::setInstance(getDefaultBuffer()->mStorage); } delete[] mStorage; } LL_FORCE_INLINE ACCUMULATOR& operator[](size_t index) { return mStorage[index]; } LL_FORCE_INLINE const ACCUMULATOR& operator[](size_t index) const { return mStorage[index]; } void addSamples(const AccumulatorBuffer& other) { llassert(mNextStorageSlot == other.mNextStorageSlot); for (size_t i = 0; i < mNextStorageSlot; i++) { mStorage[i].addSamples(other.mStorage[i]); } } void copyFrom(const AccumulatorBuffer& other) { for (size_t i = 0; i < mNextStorageSlot; i++) { mStorage[i] = other.mStorage[i]; } } void reset(const AccumulatorBuffer* other = NULL) { for (size_t i = 0; i < mNextStorageSlot; i++) { mStorage[i].reset(other ? &other->mStorage[i] : NULL); } } void makePrimary() { LLThreadLocalSingletonPointer::setInstance(mStorage); } bool isPrimary() const { return LLThreadLocalSingletonPointer::getInstance() == mStorage; } LL_FORCE_INLINE static ACCUMULATOR* getPrimaryStorage() { return LLThreadLocalSingletonPointer::getInstance(); } // NOTE: this is not thread-safe. We assume that slots are reserved in the main thread before any child threads are spawned size_t reserveSlot() { if (LLTrace::isInitialized()) { llerrs << "Attempting to declare trace object after program initialization. Trace objects should be statically initialized." << llendl; } size_t next_slot = mNextStorageSlot++; if (next_slot >= mStorageSize) { resize(mStorageSize + (mStorageSize >> 2)); } llassert(mStorage && next_slot < mStorageSize); return next_slot; } void resize(size_t new_size) { if (new_size <= mStorageSize) return; ACCUMULATOR* old_storage = mStorage; mStorage = new ACCUMULATOR[new_size]; if (old_storage) { for (S32 i = 0; i < mStorageSize; i++) { mStorage[i] = old_storage[i]; } } mStorageSize = new_size; delete[] old_storage; self_t* default_buffer = getDefaultBuffer(); if (this != default_buffer && new_size > default_buffer->size()) { //NB: this is not thread safe, but we assume that all resizing occurs during static initialization default_buffer->resize(new_size); } } size_t size() const { return mNextStorageSlot; } static self_t* getDefaultBuffer() { // this buffer is allowed to leak so that trace calls from global destructors have somewhere to put their data // so as not to trigger an access violation static self_t* sBuffer = new AccumulatorBuffer(StaticAllocationMarker()); static bool sInitialized = false; if (!sInitialized) { sBuffer->resize(DEFAULT_ACCUMULATOR_BUFFER_SIZE); sInitialized = true; } return sBuffer; } private: ACCUMULATOR* mStorage; size_t mStorageSize; size_t mNextStorageSlot; }; //TODO: replace with decltype when C++11 is enabled template struct MeanValueType { typedef F64 type; }; template class TraceType : public LLInstanceTracker, std::string> { public: typedef typename MeanValueType >::type mean_t; TraceType(const char* name, const char* description = NULL) : LLInstanceTracker, std::string>(name), mName(name), mDescription(description ? description : ""), mAccumulatorIndex(AccumulatorBuffer::getDefaultBuffer()->reserveSlot()) {} LL_FORCE_INLINE ACCUMULATOR* getPrimaryAccumulator() const { ACCUMULATOR* accumulator_storage = AccumulatorBuffer::getPrimaryStorage(); return &accumulator_storage[mAccumulatorIndex]; } size_t getIndex() const { return mAccumulatorIndex; } const std::string& getName() const { return mName; } protected: const std::string mName; const std::string mDescription; const size_t mAccumulatorIndex; }; template class MeasurementAccumulator { public: typedef T value_t; typedef MeasurementAccumulator self_t; MeasurementAccumulator() : mSum(0), mMin((std::numeric_limits::max)()), mMax((std::numeric_limits::min)()), mMean(0), mVarianceSum(0), mNumSamples(0), mLastValue(0) {} LL_FORCE_INLINE void sample(T value) { T storage_value(value); mNumSamples++; mSum += storage_value; if (storage_value < mMin) { mMin = storage_value; } if (storage_value > mMax) { mMax = storage_value; } F64 old_mean = mMean; mMean += ((F64)storage_value - old_mean) / (F64)mNumSamples; mVarianceSum += ((F64)storage_value - old_mean) * ((F64)storage_value - mMean); mLastValue = storage_value; } void addSamples(const self_t& other) { if (other.mNumSamples) { mSum += other.mSum; if (other.mMin < mMin) { mMin = other.mMin; } if (other.mMax > mMax) { mMax = other.mMax; } F64 weight = (F64)mNumSamples / (F64)(mNumSamples + other.mNumSamples); mNumSamples += other.mNumSamples; mMean = mMean * weight + other.mMean * (1.f - weight); // combine variance (and hence standard deviation) of 2 different sized sample groups using // the following formula: http://www.mrc-bsu.cam.ac.uk/cochrane/handbook/chapter_7/7_7_3_8_combining_groups.htm F64 n_1 = (F64)mNumSamples, n_2 = (F64)other.mNumSamples; F64 m_1 = mMean, m_2 = other.mMean; F64 sd_1 = getStandardDeviation(), sd_2 = other.getStandardDeviation(); if (n_1 == 0) { mVarianceSum = other.mVarianceSum; } else if (n_2 == 0) { // don't touch variance // mVarianceSum = mVarianceSum; } else { mVarianceSum = (F64)mNumSamples * ((((n_1 - 1.f) * sd_1 * sd_1) + ((n_2 - 1.f) * sd_2 * sd_2) + (((n_1 * n_2) / (n_1 + n_2)) * ((m_1 * m_1) + (m_2 * m_2) - (2.f * m_1 * m_2)))) / (n_1 + n_2 - 1.f)); } mLastValue = other.mLastValue; } } void reset(const self_t* other) { mNumSamples = 0; mSum = 0; mMin = 0; mMax = 0; mMean = 0; mVarianceSum = 0; mLastValue = other ? other->mLastValue : 0; } T getSum() const { return (T)mSum; } T getMin() const { return (T)mMin; } T getMax() const { return (T)mMax; } T getLastValue() const { return (T)mLastValue; } F64 getMean() const { return mMean; } F64 getStandardDeviation() const { return sqrtf(mVarianceSum / mNumSamples); } U32 getSampleCount() const { return mNumSamples; } private: T mSum, mMin, mMax, mLastValue; F64 mMean, mVarianceSum; U32 mNumSamples; }; template class CountAccumulator { public: typedef CountAccumulator self_t; typedef T value_t; CountAccumulator() : mSum(0), mNumSamples(0) {} LL_FORCE_INLINE void add(T value) { mNumSamples++; mSum += value; } void addSamples(const CountAccumulator& other) { mSum += other.mSum; mNumSamples += other.mNumSamples; } void reset(const self_t* other) { mNumSamples = 0; mSum = 0; } T getSum() const { return (T)mSum; } U32 getSampleCount() const { return mNumSamples; } private: T mSum; U32 mNumSamples; }; class TimeBlockAccumulator { public: typedef LLUnit value_t; typedef TimeBlockAccumulator self_t; // fake class that allows us to view call count aspect of timeblock accumulator struct CallCountAspect { typedef U32 value_t; }; struct SelfTimeAspect { typedef LLUnit value_t; }; TimeBlockAccumulator(); void addSamples(const self_t& other); void reset(const self_t* other); // // members // U64 mChildTimeCounter, mTotalTimeCounter; U32 mCalls; class TimeBlock* mParent; // last acknowledged parent of this time block class TimeBlock* mLastCaller; // used to bootstrap tree construction U16 mActiveCount; // number of timers with this ID active on stack bool mMoveUpTree; // needs to be moved up the tree of timers at the end of frame }; template<> struct MeanValueType > { typedef LLUnit type; }; template<> class TraceType : public TraceType { public: typedef F32 mean_t; TraceType(const char* name, const char* description = "") : TraceType(name, description) {} }; template<> class TraceType : public TraceType { public: typedef F32 mean_t; TraceType(const char* name, const char* description = "") : TraceType(name, description) {} }; class TimeBlock; class TimeBlockTreeNode { public: TimeBlockTreeNode(); void setParent(TimeBlock* parent); TimeBlock* getParent() { return mParent; } TimeBlock* mBlock; TimeBlock* mParent; std::vector mChildren; bool mNeedsSorting; }; template class Measurement : public TraceType::type_t> > { public: typedef typename LLUnits::HighestPrecisionType::type_t storage_t; typedef TraceType::type_t> > trace_t; Measurement(const char* name, const char* description = NULL) : trace_t(name, description) {} template void sample(UNIT_T value) { T converted_value(value); trace_t::getPrimaryAccumulator()->sample(LLUnits::rawValue(converted_value)); } }; template class Count : public TraceType::type_t> > { public: typedef typename LLUnits::HighestPrecisionType::type_t storage_t; typedef TraceType::type_t> > trace_t; Count(const char* name, const char* description = NULL) : trace_t(name) {} template void add(UNIT_T value) { T converted_value(value); trace_t::getPrimaryAccumulator()->add(LLUnits::rawValue(converted_value)); } }; struct MemStatAccumulator { MemStatAccumulator() : mSize(0), mChildSize(0), mAllocatedCount(0), mDeallocatedCount(0) {} void addSamples(const MemStatAccumulator& other) { mSize += other.mSize; mChildSize += other.mChildSize; mAllocatedCount += other.mAllocatedCount; mDeallocatedCount += other.mDeallocatedCount; } void reset(const MemStatAccumulator* other) { mSize = 0; mChildSize = 0; mAllocatedCount = 0; mDeallocatedCount = 0; } size_t mSize, mChildSize; int mAllocatedCount, mDeallocatedCount; }; class MemStat : public TraceType { public: typedef TraceType trace_t; MemStat(const char* name) : trace_t(name) {} }; // measures effective memory footprint of specified type // specialize to cover different types template struct MemFootprint { static size_t measure(const T& value) { return sizeof(T); } static size_t measure() { return sizeof(T); } }; template struct MemFootprint { static size_t measure(const T* value) { if (!value) { return 0; } return MemFootprint::measure(*value); } static size_t measure() { return MemFootprint::measure(); } }; template struct MemFootprint > { static size_t measure(const std::basic_string& value) { return value.capacity() * sizeof(T); } static size_t measure() { return sizeof(std::basic_string); } }; template struct MemFootprint > { static size_t measure(const std::vector& value) { return value.capacity() * MemFootprint::measure(); } static size_t measure() { return sizeof(std::vector); } }; template struct MemFootprint > { static size_t measure(const std::list& value) { return value.size() * (MemFootprint::measure() + sizeof(void*) * 2); } static size_t measure() { return sizeof(std::list); } }; template void* allocAligned(size_t size) { llstatic_assert((ALIGNMENT > 0) && (ALIGNMENT & (ALIGNMENT - 1)) == 0, "Alignment must be a power of 2"); void* padded_allocation; const size_t aligned_reserve = (RESERVE / ALIGNMENT) + ((RESERVE % ALIGNMENT) ? ALIGNMENT : 0); const size_t size_with_reserve = size + aligned_reserve; if (ALIGNMENT <= LL_DEFAULT_HEAP_ALIGN) { padded_allocation = malloc(size_with_reserve); } else { #if LL_WINDOWS padded_allocation = _aligned_malloc(size_with_reserve, ALIGNMENT); #elif LL_DARWIN padded_allocation = ll_aligned_malloc(size_with_reserve, ALIGNMENT); #else if (LL_UNLIKELY(0 != posix_memalign(&padded_allocation, 16, size))) padded_allocation = NULL; #endif } return (char*)padded_allocation + aligned_reserve; } template void deallocAligned(void* ptr) { const size_t aligned_reserve = (RESERVE / ALIGNMENT) + ((RESERVE % ALIGNMENT) ? ALIGNMENT : 0); void* original_allocation = (char*)ptr - aligned_reserve; if (ALIGNMENT <= LL_DEFAULT_HEAP_ALIGN) { free(original_allocation); } else { #if LL_WINDOWS _aligned_free(original_allocation); #elif LL_DARWIN ll_aligned_free(original_allocation); #else free(original_allocation); #endif } } template class MemTrackable { template struct TrackMemImpl; typedef MemTrackable mem_trackable_t; public: typedef void mem_trackable_tag_t; ~MemTrackable() { memDisclaim(mMemFootprint); } void* operator new(size_t size) { MemStatAccumulator* accumulator = DERIVED::sMemStat.getPrimaryAccumulator(); if (accumulator) { accumulator->mSize += size; accumulator->mAllocatedCount++; } // reserve 4 bytes for allocation size (and preserving requested alignment) void* allocation = allocAligned(size); ((size_t*)allocation)[-1] = size; return allocation; } void operator delete(void* ptr) { size_t allocation_size = ((size_t*)ptr)[-1]; MemStatAccumulator* accumulator = DERIVED::sMemStat.getPrimaryAccumulator(); if (accumulator) { accumulator->mSize -= allocation_size; accumulator->mAllocatedCount--; accumulator->mDeallocatedCount++; } deallocAligned(ptr); } void *operator new [](size_t size) { MemStatAccumulator* accumulator = DERIVED::sMemStat.getPrimaryAccumulator(); if (accumulator) { accumulator->mSize += size; accumulator->mAllocatedCount++; } // reserve 4 bytes for allocation size (and preserving requested alignment) void* allocation = allocAligned(size); ((size_t*)allocation)[-1] = size; return allocation; } void operator delete[](void* ptr) { size_t* allocation_size = (size_t*)((char*)ptr - 8); MemStatAccumulator* accumulator = DERIVED::sMemStat.getPrimaryAccumulator(); if (accumulator) { accumulator->mSize -= *allocation_size; accumulator->mAllocatedCount--; accumulator->mDeallocatedCount++; } deallocAligned(ptr); } // claim memory associated with other objects/data as our own, adding to our calculated footprint template CLAIM_T& memClaim(CLAIM_T& value) { TrackMemImpl::claim(*this, value); return value; } template const CLAIM_T& memClaim(const CLAIM_T& value) { TrackMemImpl::claim(*this, value); return value; } void memClaim(size_t size) { MemStatAccumulator* accumulator = DERIVED::sMemStat.getPrimaryAccumulator(); mMemFootprint += size; if (accumulator) { accumulator->mSize += size; } } // remove memory we had claimed from our calculated footprint template CLAIM_T& memDisclaim(CLAIM_T& value) { TrackMemImpl::disclaim(*this, value); return value; } template const CLAIM_T& memDisclaim(const CLAIM_T& value) { TrackMemImpl::disclaim(*this, value); return value; } void memDisclaim(size_t size) { MemStatAccumulator* accumulator = DERIVED::sMemStat.getPrimaryAccumulator(); if (accumulator) { accumulator->mSize -= size; } mMemFootprint -= size; } private: size_t mMemFootprint; template struct TrackMemImpl { static void claim(mem_trackable_t& tracker, const TRACKED& tracked) { MemStatAccumulator* accumulator = DERIVED::sMemStat.getPrimaryAccumulator(); if (accumulator) { size_t footprint = MemFootprint::measure(tracked); accumulator->mSize += footprint; tracker.mMemFootprint += footprint; } } static void disclaim(mem_trackable_t& tracker, const TRACKED& tracked) { MemStatAccumulator* accumulator = DERIVED::sMemStat.getPrimaryAccumulator(); if (accumulator) { size_t footprint = MemFootprint::measure(tracked); accumulator->mSize -= footprint; tracker.mMemFootprint -= footprint; } } }; template struct TrackMemImpl { static void claim(mem_trackable_t& tracker, TRACKED& tracked) { MemStatAccumulator* accumulator = DERIVED::sMemStat.getPrimaryAccumulator(); if (accumulator) { accumulator->mChildSize += MemFootprint::measure(tracked); } } static void disclaim(mem_trackable_t& tracker, TRACKED& tracked) { MemStatAccumulator* accumulator = DERIVED::sMemStat.getPrimaryAccumulator(); if (accumulator) { accumulator->mChildSize -= MemFootprint::measure(tracked); } } }; }; } #endif // LL_LLTRACE_H