summaryrefslogtreecommitdiff
path: root/indra/llcommon
diff options
context:
space:
mode:
Diffstat (limited to 'indra/llcommon')
-rw-r--r--indra/llcommon/llfasttimer.h12
-rw-r--r--indra/llcommon/lltrace.h259
-rw-r--r--indra/llcommon/lltracerecording.cpp321
-rw-r--r--indra/llcommon/lltracerecording.h278
-rw-r--r--indra/llcommon/lltracethreadrecorder.cpp9
-rw-r--r--indra/llcommon/llunit.h109
6 files changed, 538 insertions, 450 deletions
diff --git a/indra/llcommon/llfasttimer.h b/indra/llcommon/llfasttimer.h
index 32a0629a87..f329b30472 100644
--- a/indra/llcommon/llfasttimer.h
+++ b/indra/llcommon/llfasttimer.h
@@ -101,14 +101,14 @@ public:
void setCollapsed(bool collapsed) { mCollapsed = collapsed; }
bool getCollapsed() const { return mCollapsed; }
- TraceType<TimeBlockAccumulator::CallCountAspect>& callCount()
+ TraceType<TimeBlockAccumulator::CallCountFacet>& callCount()
{
- return static_cast<TraceType<TimeBlockAccumulator::CallCountAspect>&>(*(TraceType<TimeBlockAccumulator>*)this);
+ return static_cast<TraceType<TimeBlockAccumulator::CallCountFacet>&>(*(TraceType<TimeBlockAccumulator>*)this);
}
- TraceType<TimeBlockAccumulator::SelfTimeAspect>& selfTime()
+ TraceType<TimeBlockAccumulator::SelfTimeFacet>& selfTime()
{
- return static_cast<TraceType<TimeBlockAccumulator::SelfTimeAspect>&>(*(TraceType<TimeBlockAccumulator>*)this);
+ return static_cast<TraceType<TimeBlockAccumulator::SelfTimeFacet>&>(*(TraceType<TimeBlockAccumulator>*)this);
}
static TimeBlock& getRootTimeBlock();
@@ -277,8 +277,6 @@ public:
LL_FORCE_INLINE BlockTimer::BlockTimer(TimeBlock& timer)
{
#if FAST_TIMER_ON
- mStartTime = TimeBlock::getCPUClockCount64();
-
BlockTimerStackRecord* cur_timer_data = ThreadTimerStack::getIfExists();
TimeBlockAccumulator* accumulator = timer.getPrimaryAccumulator();
accumulator->mActiveCount++;
@@ -292,6 +290,8 @@ LL_FORCE_INLINE BlockTimer::BlockTimer(TimeBlock& timer)
cur_timer_data->mActiveTimer = this;
cur_timer_data->mTimeBlock = &timer;
cur_timer_data->mChildTime = 0;
+
+ mStartTime = TimeBlock::getCPUClockCount64();
#endif
}
diff --git a/indra/llcommon/lltrace.h b/indra/llcommon/lltrace.h
index 6dfe9e4b4e..37196d9f63 100644
--- a/indra/llcommon/lltrace.h
+++ b/indra/llcommon/lltrace.h
@@ -46,13 +46,13 @@ namespace LLTrace
class Recording;
typedef LLUnit<LLUnits::Bytes, F64> Bytes;
-typedef LLUnit<LLUnits::Kilobytes, F64> Kilobytes;
-typedef LLUnit<LLUnits::Megabytes, F64> Megabytes;
-typedef LLUnit<LLUnits::Gigabytes, F64> Gigabytes;
+typedef LLUnit<LLUnits::Kibibytes, F64> Kibibytes;
+typedef LLUnit<LLUnits::Mibibytes, F64> Mibibytes;
+typedef LLUnit<LLUnits::Gibibytes, F64> Gibibytes;
typedef LLUnit<LLUnits::Bits, F64> Bits;
-typedef LLUnit<LLUnits::Kilobits, F64> Kilobits;
-typedef LLUnit<LLUnits::Megabits, F64> Megabits;
-typedef LLUnit<LLUnits::Gigabits, F64> Gigabits;
+typedef LLUnit<LLUnits::Kibibits, F64> Kibibits;
+typedef LLUnit<LLUnits::Mibibits, F64> Mibibits;
+typedef LLUnit<LLUnits::Gibibits, F64> Gibibits;
typedef LLUnit<LLUnits::Seconds, F64> Seconds;
typedef LLUnit<LLUnits::Milliseconds, F64> Milliseconds;
@@ -265,6 +265,8 @@ public:
size_t getIndex() const { return mAccumulatorIndex; }
+ virtual const char* getUnitLabel() { return ""; }
+
const std::string& getName() const { return mName; }
protected:
@@ -273,25 +275,23 @@ protected:
const size_t mAccumulatorIndex;
};
-template<typename T>
class EventAccumulator
{
public:
- typedef T value_t;
+ typedef F64 value_t;
typedef F64 mean_t;
- typedef EventAccumulator<T> self_t;
EventAccumulator()
: mSum(0),
- mMin((std::numeric_limits<T>::max)()),
- mMax((std::numeric_limits<T>::min)()),
+ mMin((std::numeric_limits<F64>::max)()),
+ mMax((std::numeric_limits<F64>::min)()),
mMean(0),
mVarianceSum(0),
mNumSamples(0),
mLastValue(0)
{}
- void record(T value)
+ void record(F64 value)
{
mNumSamples++;
mSum += value;
@@ -305,12 +305,12 @@ public:
mMax = value;
}
F64 old_mean = mMean;
- mMean += ((F64)value - old_mean) / (F64)mNumSamples;
- mVarianceSum += ((F64)value - old_mean) * ((F64)value - mMean);
+ mMean += (value - old_mean) / (F64)mNumSamples;
+ mVarianceSum += (value - old_mean) * (value - mMean);
mLastValue = value;
}
- void addSamples(const self_t& other, bool append)
+ void addSamples(const EventAccumulator& other, bool append)
{
if (other.mNumSamples)
{
@@ -354,12 +354,12 @@ public:
}
}
- void reset(const self_t* other)
+ void reset(const EventAccumulator* other)
{
mNumSamples = 0;
mSum = 0;
- mMin = std::numeric_limits<T>::max();
- mMax = std::numeric_limits<T>::min();
+ mMin = std::numeric_limits<F64>::max();
+ mMax = std::numeric_limits<F64>::min();
mMean = 0;
mVarianceSum = 0;
mLastValue = other ? other->mLastValue : 0;
@@ -367,16 +367,16 @@ public:
void flush() {}
- 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 getSum() const { return mSum; }
+ F64 getMin() const { return mMin; }
+ F64 getMax() const { return mMax; }
+ F64 getLastValue() const { return mLastValue; }
F64 getMean() const { return mMean; }
F64 getStandardDeviation() const { return sqrtf(mVarianceSum / mNumSamples); }
U32 getSampleCount() const { return mNumSamples; }
private:
- T mSum,
+ F64 mSum,
mMin,
mMax,
mLastValue;
@@ -388,18 +388,16 @@ private:
};
-template<typename T>
class SampleAccumulator
{
public:
- typedef T value_t;
+ typedef F64 value_t;
typedef F64 mean_t;
- typedef SampleAccumulator<T> self_t;
SampleAccumulator()
: mSum(0),
- mMin((std::numeric_limits<T>::max)()),
- mMax((std::numeric_limits<T>::min)()),
+ mMin((std::numeric_limits<F64>::max)()),
+ mMax((std::numeric_limits<F64>::min)()),
mMean(0),
mVarianceSum(0),
mLastSampleTimeStamp(LLTimer::getTotalSeconds()),
@@ -409,7 +407,7 @@ public:
mHasValue(false)
{}
- void sample(T value)
+ void sample(F64 value)
{
LLUnitImplicit<LLUnits::Seconds, F64> time_stamp = LLTimer::getTotalSeconds();
LLUnitImplicit<LLUnits::Seconds, F64> delta_time = time_stamp - mLastSampleTimeStamp;
@@ -418,15 +416,15 @@ public:
if (mHasValue)
{
mTotalSamplingTime += delta_time;
- mSum += (F64)mLastValue * delta_time;
+ mSum += mLastValue * delta_time;
// NOTE: both conditions will hold first time through
if (value < mMin) { mMin = value; }
if (value > mMax) { mMax = value; }
F64 old_mean = mMean;
- mMean += (delta_time / mTotalSamplingTime) * ((F64)mLastValue - old_mean);
- mVarianceSum += delta_time * ((F64)mLastValue - old_mean) * ((F64)mLastValue - mMean);
+ mMean += (delta_time / mTotalSamplingTime) * (mLastValue - old_mean);
+ mVarianceSum += delta_time * (mLastValue - old_mean) * (mLastValue - mMean);
}
mLastValue = value;
@@ -434,7 +432,7 @@ public:
mHasValue = true;
}
- void addSamples(const self_t& other, bool append)
+ void addSamples(const SampleAccumulator& other, bool append)
{
if (other.mTotalSamplingTime)
{
@@ -485,12 +483,12 @@ public:
}
}
- void reset(const self_t* other)
+ void reset(const SampleAccumulator* other)
{
mNumSamples = 0;
mSum = 0;
- mMin = std::numeric_limits<T>::max();
- mMax = std::numeric_limits<T>::min();
+ mMin = std::numeric_limits<F64>::max();
+ mMax = std::numeric_limits<F64>::min();
mMean = other ? other->mLastValue : 0;
mVarianceSum = 0;
mLastSampleTimeStamp = LLTimer::getTotalSeconds();
@@ -504,22 +502,24 @@ public:
LLUnitImplicit<LLUnits::Seconds, F64> time_stamp = LLTimer::getTotalSeconds();
LLUnitImplicit<LLUnits::Seconds, F64> delta_time = time_stamp - mLastSampleTimeStamp;
- mSum += (F64)mLastValue * delta_time;
-
- mTotalSamplingTime += delta_time;
+ if (mHasValue)
+ {
+ mSum += mLastValue * delta_time;
+ mTotalSamplingTime += delta_time;
+ }
mLastSampleTimeStamp = time_stamp;
}
- 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 getSum() const { return mSum; }
+ F64 getMin() const { return mMin; }
+ F64 getMax() const { return mMax; }
+ F64 getLastValue() const { return mLastValue; }
F64 getMean() const { return mMean; }
F64 getStandardDeviation() const { return sqrtf(mVarianceSum / mTotalSamplingTime); }
U32 getSampleCount() const { return mNumSamples; }
private:
- T mSum,
+ F64 mSum,
mMin,
mMax,
mLastValue;
@@ -535,12 +535,10 @@ private:
U32 mNumSamples;
};
-template<typename T>
class CountAccumulator
{
public:
- typedef CountAccumulator<T> self_t;
- typedef T value_t;
+ typedef F64 value_t;
typedef F64 mean_t;
CountAccumulator()
@@ -548,19 +546,19 @@ public:
mNumSamples(0)
{}
- void add(T value)
+ void add(F64 value)
{
mNumSamples++;
mSum += value;
}
- void addSamples(const CountAccumulator<T>& other, bool /*append*/)
+ void addSamples(const CountAccumulator& other, bool /*append*/)
{
mSum += other.mSum;
mNumSamples += other.mNumSamples;
}
- void reset(const self_t* other)
+ void reset(const CountAccumulator* other)
{
mNumSamples = 0;
mSum = 0;
@@ -568,12 +566,12 @@ public:
void flush() {}
- T getSum() const { return (T)mSum; }
+ F64 getSum() const { return mSum; }
U32 getSampleCount() const { return mNumSamples; }
private:
- T mSum;
+ F64 mSum;
U32 mNumSamples;
};
@@ -585,14 +583,14 @@ public:
typedef LLUnit<LLUnits::Seconds, F64> mean_t;
typedef TimeBlockAccumulator self_t;
- // fake class that allows us to view call count aspect of timeblock accumulator
- struct CallCountAspect
+ // fake classes that allows us to view different facets of underlying statistic
+ struct CallCountFacet
{
typedef U32 value_t;
typedef F32 mean_t;
};
- struct SelfTimeAspect
+ struct SelfTimeFacet
{
typedef LLUnit<LLUnits::Seconds, F64> value_t;
typedef LLUnit<LLUnits::Seconds, F64> mean_t;
@@ -618,7 +616,7 @@ public:
};
template<>
-class TraceType<TimeBlockAccumulator::CallCountAspect>
+class TraceType<TimeBlockAccumulator::CallCountFacet>
: public TraceType<TimeBlockAccumulator>
{
public:
@@ -629,7 +627,7 @@ public:
};
template<>
-class TraceType<TimeBlockAccumulator::SelfTimeAspect>
+class TraceType<TimeBlockAccumulator::SelfTimeFacet>
: public TraceType<TimeBlockAccumulator>
{
public:
@@ -657,15 +655,18 @@ public:
template <typename T = F64>
class EventStatHandle
-: public TraceType<EventAccumulator<typename LLUnits::HighestPrecisionType<T>::type_t> >
+: public TraceType<EventAccumulator>
{
public:
- typedef typename LLUnits::HighestPrecisionType<T>::type_t storage_t;
- typedef TraceType<EventAccumulator<typename LLUnits::HighestPrecisionType<T>::type_t> > trace_t;
+ typedef typename F64 storage_t;
+ typedef TraceType<EventAccumulator> trace_t;
EventStatHandle(const char* name, const char* description = NULL)
: trace_t(name, description)
{}
+
+ /*virtual*/ const char* getUnitLabel() { return LLGetUnitLabel<T>::getUnitLabel(); }
+
};
template<typename T, typename VALUE_T>
@@ -677,15 +678,17 @@ void record(EventStatHandle<T>& measurement, VALUE_T value)
template <typename T = F64>
class SampleStatHandle
-: public TraceType<SampleAccumulator<typename LLUnits::HighestPrecisionType<T>::type_t> >
+: public TraceType<SampleAccumulator>
{
public:
- typedef typename LLUnits::HighestPrecisionType<T>::type_t storage_t;
- typedef TraceType<SampleAccumulator<typename LLUnits::HighestPrecisionType<T>::type_t> > trace_t;
+ typedef F64 storage_t;
+ typedef TraceType<SampleAccumulator> trace_t;
SampleStatHandle(const char* name, const char* description = NULL)
: trace_t(name, description)
{}
+
+ /*virtual*/ const char* getUnitLabel() { return LLGetUnitLabel<T>::getUnitLabel(); }
};
template<typename T, typename VALUE_T>
@@ -697,16 +700,17 @@ void sample(SampleStatHandle<T>& measurement, VALUE_T value)
template <typename T = F64>
class CountStatHandle
-: public TraceType<CountAccumulator<typename LLUnits::HighestPrecisionType<T>::type_t> >
+: public TraceType<CountAccumulator>
{
public:
- typedef typename LLUnits::HighestPrecisionType<T>::type_t storage_t;
- typedef TraceType<CountAccumulator<typename LLUnits::HighestPrecisionType<T>::type_t> > trace_t;
+ typedef typename F64 storage_t;
+ typedef TraceType<CountAccumulator> trace_t;
CountStatHandle(const char* name, const char* description = NULL)
: trace_t(name)
{}
+ /*virtual*/ const char* getUnitLabel() { return LLGetUnitLabel<T>::getUnitLabel(); }
};
template<typename T, typename VALUE_T>
@@ -721,35 +725,90 @@ struct MemStatAccumulator
{
typedef MemStatAccumulator self_t;
+ // fake classes that allows us to view different facets of underlying statistic
+ struct AllocationCountFacet
+ {
+ typedef U32 value_t;
+ typedef F32 mean_t;
+ };
+
+ struct DeallocationCountFacet
+ {
+ typedef U32 value_t;
+ typedef F32 mean_t;
+ };
+
+ struct ChildMemFacet
+ {
+ typedef LLUnit<LLUnits::Bytes, F64> value_t;
+ typedef LLUnit<LLUnits::Bytes, F64> mean_t;
+ };
+
MemStatAccumulator()
- : mSize(0),
- mChildSize(0),
- mAllocatedCount(0),
+ : mAllocatedCount(0),
mDeallocatedCount(0)
{}
- void addSamples(const MemStatAccumulator& other, bool /*append*/)
+ void addSamples(const MemStatAccumulator& other, bool append)
{
- mSize += other.mSize;
- mChildSize += other.mChildSize;
+ mSize.addSamples(other.mSize, append);
+ mChildSize.addSamples(other.mChildSize, append);
mAllocatedCount += other.mAllocatedCount;
mDeallocatedCount += other.mDeallocatedCount;
}
void reset(const MemStatAccumulator* other)
{
- mSize = 0;
- mChildSize = 0;
+ mSize.reset(other ? &other->mSize : NULL);
+ mChildSize.reset(other ? &other->mChildSize : NULL);
mAllocatedCount = 0;
mDeallocatedCount = 0;
}
- void flush() {}
+ void flush()
+ {
+ mSize.flush();
+ mChildSize.flush();
+ }
- size_t mSize,
- mChildSize;
- int mAllocatedCount,
- mDeallocatedCount;
+ SampleAccumulator mSize,
+ mChildSize;
+ int mAllocatedCount,
+ mDeallocatedCount;
+};
+
+
+template<>
+class TraceType<MemStatAccumulator::AllocationCountFacet>
+: public TraceType<MemStatAccumulator>
+{
+public:
+
+ TraceType(const char* name, const char* description = "")
+ : TraceType<MemStatAccumulator>(name, description)
+ {}
+};
+
+template<>
+class TraceType<MemStatAccumulator::DeallocationCountFacet>
+: public TraceType<MemStatAccumulator>
+{
+public:
+
+ TraceType(const char* name, const char* description = "")
+ : TraceType<MemStatAccumulator>(name, description)
+ {}
+};
+
+template<>
+class TraceType<MemStatAccumulator::ChildMemFacet>
+ : public TraceType<MemStatAccumulator>
+{
+public:
+
+ TraceType(const char* name, const char* description = "")
+ : TraceType<MemStatAccumulator>(name, description)
+ {}
};
class MemStatHandle : public TraceType<MemStatAccumulator>
@@ -759,6 +818,23 @@ public:
MemStatHandle(const char* name)
: trace_t(name)
{}
+
+ /*virtual*/ const char* getUnitLabel() { return "B"; }
+
+ TraceType<MemStatAccumulator::AllocationCountFacet>& allocationCount()
+ {
+ return static_cast<TraceType<MemStatAccumulator::AllocationCountFacet>&>(*(TraceType<MemStatAccumulator>*)this);
+ }
+
+ TraceType<MemStatAccumulator::DeallocationCountFacet>& deallocationCount()
+ {
+ return static_cast<TraceType<MemStatAccumulator::DeallocationCountFacet>&>(*(TraceType<MemStatAccumulator>*)this);
+ }
+
+ TraceType<MemStatAccumulator::ChildMemFacet>& childMem()
+ {
+ return static_cast<TraceType<MemStatAccumulator::ChildMemFacet>&>(*(TraceType<MemStatAccumulator>*)this);
+ }
};
// measures effective memory footprint of specified type
@@ -859,7 +935,7 @@ public:
MemStatAccumulator* accumulator = DERIVED::sMemStat.getPrimaryAccumulator();
if (accumulator)
{
- accumulator->mSize += size;
+ accumulator->mSize.sample(accumulator->mSize.getLastValue() + (F64)size);
accumulator->mAllocatedCount++;
}
@@ -871,7 +947,7 @@ public:
MemStatAccumulator* accumulator = DERIVED::sMemStat.getPrimaryAccumulator();
if (accumulator)
{
- accumulator->mSize -= size;
+ accumulator->mSize.sample(accumulator->mSize.getLastValue() - (F64)size);
accumulator->mAllocatedCount--;
accumulator->mDeallocatedCount++;
}
@@ -883,7 +959,7 @@ public:
MemStatAccumulator* accumulator = DERIVED::sMemStat.getPrimaryAccumulator();
if (accumulator)
{
- accumulator->mSize += size;
+ accumulator->mSize.sample(accumulator->mSize.getLastValue() + (F64)size);
accumulator->mAllocatedCount++;
}
@@ -895,7 +971,7 @@ public:
MemStatAccumulator* accumulator = DERIVED::sMemStat.getPrimaryAccumulator();
if (accumulator)
{
- accumulator->mSize -= size;
+ accumulator->mSize.sample(accumulator->mSize.getLastValue() - (F64)size);
accumulator->mAllocatedCount--;
accumulator->mDeallocatedCount++;
}
@@ -918,13 +994,13 @@ public:
}
- void memClaim(size_t size)
+ void memClaimAmount(size_t size)
{
MemStatAccumulator* accumulator = DERIVED::sMemStat.getPrimaryAccumulator();
mMemFootprint += size;
if (accumulator)
{
- accumulator->mSize += size;
+ accumulator->mSize.sample(accumulator->mSize.getLastValue() + (F64)size);
}
}
@@ -943,14 +1019,13 @@ public:
return value;
}
- void memDisclaim(size_t size)
+ void memDisclaimAmount(size_t size)
{
MemStatAccumulator* accumulator = DERIVED::sMemStat.getPrimaryAccumulator();
if (accumulator)
{
- accumulator->mSize -= size;
+ accumulator->mSize.sample(accumulator->mSize.getLastValue() - (F64)size);
}
- mMemFootprint -= size;
}
private:
@@ -965,7 +1040,7 @@ private:
if (accumulator)
{
size_t footprint = MemFootprint<TRACKED>::measure(tracked);
- accumulator->mSize += footprint;
+ accumulator->mSize.sample(accumulator->mSize.getLastValue() + (F64)footprint);
tracker.mMemFootprint += footprint;
}
}
@@ -976,7 +1051,7 @@ private:
if (accumulator)
{
size_t footprint = MemFootprint<TRACKED>::measure(tracked);
- accumulator->mSize -= footprint;
+ accumulator->mSize.sample(accumulator->mSize.getLastValue() - (F64)footprint);
tracker.mMemFootprint -= footprint;
}
}
@@ -990,7 +1065,7 @@ private:
MemStatAccumulator* accumulator = DERIVED::sMemStat.getPrimaryAccumulator();
if (accumulator)
{
- accumulator->mChildSize += MemFootprint<TRACKED>::measure(tracked);
+ accumulator->mChildSize.sample(accumulator->mChildSize.getLastValue() + (F64)MemFootprint<TRACKED>::measure(tracked));
}
}
@@ -999,7 +1074,7 @@ private:
MemStatAccumulator* accumulator = DERIVED::sMemStat.getPrimaryAccumulator();
if (accumulator)
{
- accumulator->mChildSize -= MemFootprint<TRACKED>::measure(tracked);
+ accumulator->mChildSize.sample(accumulator->mChildSize.getLastValue() - (F64)MemFootprint<TRACKED>::measure(tracked));
}
}
};
diff --git a/indra/llcommon/lltracerecording.cpp b/indra/llcommon/lltracerecording.cpp
index 3994e4f521..d32504b014 100644
--- a/indra/llcommon/lltracerecording.cpp
+++ b/indra/llcommon/lltracerecording.cpp
@@ -44,11 +44,8 @@ RecordingBuffers::RecordingBuffers()
void RecordingBuffers::handOffTo(RecordingBuffers& other)
{
- other.mCountsFloat.reset(&mCountsFloat);
other.mCounts.reset(&mCounts);
- other.mSamplesFloat.reset(&mSamplesFloat);
other.mSamples.reset(&mSamples);
- other.mEventsFloat.reset(&mEventsFloat);
other.mEvents.reset(&mEvents);
other.mStackTimers.reset(&mStackTimers);
other.mMemStats.reset(&mMemStats);
@@ -56,11 +53,8 @@ void RecordingBuffers::handOffTo(RecordingBuffers& other)
void RecordingBuffers::makePrimary()
{
- mCountsFloat.makePrimary();
mCounts.makePrimary();
- mSamplesFloat.makePrimary();
mSamples.makePrimary();
- mEventsFloat.makePrimary();
mEvents.makePrimary();
mStackTimers.makePrimary();
mMemStats.makePrimary();
@@ -85,11 +79,8 @@ bool RecordingBuffers::isPrimary() const
void RecordingBuffers::append( const RecordingBuffers& other )
{
- mCountsFloat.addSamples(other.mCountsFloat);
mCounts.addSamples(other.mCounts);
- mSamplesFloat.addSamples(other.mSamplesFloat);
mSamples.addSamples(other.mSamples);
- mEventsFloat.addSamples(other.mEventsFloat);
mEvents.addSamples(other.mEvents);
mMemStats.addSamples(other.mMemStats);
mStackTimers.addSamples(other.mStackTimers);
@@ -97,11 +88,8 @@ void RecordingBuffers::append( const RecordingBuffers& other )
void RecordingBuffers::merge( const RecordingBuffers& other)
{
- mCountsFloat.addSamples(other.mCountsFloat, false);
mCounts.addSamples(other.mCounts, false);
- mSamplesFloat.addSamples(other.mSamplesFloat, false);
mSamples.addSamples(other.mSamples, false);
- mEventsFloat.addSamples(other.mEventsFloat, false);
mEvents.addSamples(other.mEvents, false);
mMemStats.addSamples(other.mMemStats, false);
// for now, hold out timers from merge, need to be displayed per thread
@@ -110,11 +98,8 @@ void RecordingBuffers::merge( const RecordingBuffers& other)
void RecordingBuffers::reset(RecordingBuffers* other)
{
- mCountsFloat.reset(other ? &other->mCountsFloat : NULL);
mCounts.reset(other ? &other->mCounts : NULL);
- mSamplesFloat.reset(other ? &other->mSamplesFloat : NULL);
mSamples.reset(other ? &other->mSamples : NULL);
- mEventsFloat.reset(other ? &other->mEventsFloat : NULL);
mEvents.reset(other ? &other->mEvents : NULL);
mStackTimers.reset(other ? &other->mStackTimers : NULL);
mMemStats.reset(other ? &other->mMemStats : NULL);
@@ -122,7 +107,6 @@ void RecordingBuffers::reset(RecordingBuffers* other)
void RecordingBuffers::flush()
{
- mSamplesFloat.flush();
mSamples.flush();
}
@@ -221,222 +205,221 @@ void Recording::mergeRecording( const Recording& other)
setPlayState(play_state);
}
-LLUnit<LLUnits::Seconds, F64> Recording::getSum(const TraceType<TimeBlockAccumulator>& stat) const
+LLUnit<LLUnits::Seconds, F64> Recording::getSum(const TraceType<TimeBlockAccumulator>& stat)
{
const TimeBlockAccumulator& accumulator = mBuffers->mStackTimers[stat.getIndex()];
+ update();
return (F64)(accumulator.mTotalTimeCounter - accumulator.mStartTotalTimeCounter)
/ (F64)LLTrace::TimeBlock::countsPerSecond();
}
-LLUnit<LLUnits::Seconds, F64> Recording::getSum(const TraceType<TimeBlockAccumulator::SelfTimeAspect>& stat) const
+LLUnit<LLUnits::Seconds, F64> Recording::getSum(const TraceType<TimeBlockAccumulator::SelfTimeFacet>& stat)
{
const TimeBlockAccumulator& accumulator = mBuffers->mStackTimers[stat.getIndex()];
+ update();
return (F64)(accumulator.mSelfTimeCounter) / (F64)LLTrace::TimeBlock::countsPerSecond();
}
-U32 Recording::getSum(const TraceType<TimeBlockAccumulator::CallCountAspect>& stat) const
+U32 Recording::getSum(const TraceType<TimeBlockAccumulator::CallCountFacet>& stat)
{
+ update();
return mBuffers->mStackTimers[stat.getIndex()].mCalls;
}
-LLUnit<LLUnits::Seconds, F64> Recording::getPerSec(const TraceType<TimeBlockAccumulator>& stat) const
+LLUnit<LLUnits::Seconds, F64> Recording::getPerSec(const TraceType<TimeBlockAccumulator>& stat)
{
const TimeBlockAccumulator& accumulator = mBuffers->mStackTimers[stat.getIndex()];
+ update();
return (F64)(accumulator.mTotalTimeCounter - accumulator.mStartTotalTimeCounter)
/ ((F64)LLTrace::TimeBlock::countsPerSecond() * mElapsedSeconds);
}
-LLUnit<LLUnits::Seconds, F64> Recording::getPerSec(const TraceType<TimeBlockAccumulator::SelfTimeAspect>& stat) const
+LLUnit<LLUnits::Seconds, F64> Recording::getPerSec(const TraceType<TimeBlockAccumulator::SelfTimeFacet>& stat)
{
const TimeBlockAccumulator& accumulator = mBuffers->mStackTimers[stat.getIndex()];
+ update();
return (F64)(accumulator.mSelfTimeCounter)
/ ((F64)LLTrace::TimeBlock::countsPerSecond() * mElapsedSeconds);
}
-F32 Recording::getPerSec(const TraceType<TimeBlockAccumulator::CallCountAspect>& stat) const
+F32 Recording::getPerSec(const TraceType<TimeBlockAccumulator::CallCountFacet>& stat)
{
+ update();
return (F32)mBuffers->mStackTimers[stat.getIndex()].mCalls / mElapsedSeconds;
}
-LLUnit<LLUnits::Bytes, U32> Recording::getSum(const TraceType<MemStatAccumulator>& stat) const
+LLUnit<LLUnits::Bytes, F64> Recording::getMin(const TraceType<MemStatAccumulator>& stat)
{
- return mBuffers->mMemStats[stat.getIndex()].mAllocatedCount;
+ update();
+ return mBuffers->mMemStats[stat.getIndex()].mSize.getMin();
}
-LLUnit<LLUnits::Bytes, F32> Recording::getPerSec(const TraceType<MemStatAccumulator>& stat) const
+LLUnit<LLUnits::Bytes, F64> Recording::getMean(const TraceType<MemStatAccumulator>& stat)
{
- return (F32)mBuffers->mMemStats[stat.getIndex()].mAllocatedCount / mElapsedSeconds;
+ update();
+ return mBuffers->mMemStats[stat.getIndex()].mSize.getMean();
}
-
-F64 Recording::getSum( const TraceType<CountAccumulator<F64> >& stat ) const
+LLUnit<LLUnits::Bytes, F64> Recording::getMax(const TraceType<MemStatAccumulator>& stat)
{
- return mBuffers->mCountsFloat[stat.getIndex()].getSum();
+ update();
+ return mBuffers->mMemStats[stat.getIndex()].mSize.getMax();
}
-S64 Recording::getSum( const TraceType<CountAccumulator<S64> >& stat ) const
+LLUnit<LLUnits::Bytes, F64> Recording::getStandardDeviation(const TraceType<MemStatAccumulator>& stat)
{
- return mBuffers->mCounts[stat.getIndex()].getSum();
+ update();
+ return mBuffers->mMemStats[stat.getIndex()].mSize.getStandardDeviation();
}
-F64 Recording::getSum( const TraceType<EventAccumulator<F64> >& stat ) const
+LLUnit<LLUnits::Bytes, F64> Recording::getLastValue(const TraceType<MemStatAccumulator>& stat)
{
- return (F64)mBuffers->mEventsFloat[stat.getIndex()].getSum();
+ update();
+ return mBuffers->mMemStats[stat.getIndex()].mSize.getLastValue();
}
-S64 Recording::getSum( const TraceType<EventAccumulator<S64> >& stat ) const
+LLUnit<LLUnits::Bytes, F64> Recording::getMin(const TraceType<MemStatAccumulator::ChildMemFacet>& stat)
{
- return (S64)mBuffers->mEvents[stat.getIndex()].getSum();
+ update();
+ return mBuffers->mMemStats[stat.getIndex()].mChildSize.getMin();
}
-
-
-F64 Recording::getPerSec( const TraceType<CountAccumulator<F64> >& stat ) const
+LLUnit<LLUnits::Bytes, F64> Recording::getMean(const TraceType<MemStatAccumulator::ChildMemFacet>& stat)
{
- F64 sum = mBuffers->mCountsFloat[stat.getIndex()].getSum();
- return (sum != 0.0)
- ? (sum / mElapsedSeconds)
- : 0.0;
+ update();
+ return mBuffers->mMemStats[stat.getIndex()].mChildSize.getMean();
}
-F64 Recording::getPerSec( const TraceType<CountAccumulator<S64> >& stat ) const
+LLUnit<LLUnits::Bytes, F64> Recording::getMax(const TraceType<MemStatAccumulator::ChildMemFacet>& stat)
{
- S64 sum = mBuffers->mCounts[stat.getIndex()].getSum();
- return (sum != 0)
- ? ((F64)sum / mElapsedSeconds)
- : 0.0;
+ update();
+ return mBuffers->mMemStats[stat.getIndex()].mChildSize.getMax();
}
-U32 Recording::getSampleCount( const TraceType<CountAccumulator<F64> >& stat ) const
+LLUnit<LLUnits::Bytes, F64> Recording::getStandardDeviation(const TraceType<MemStatAccumulator::ChildMemFacet>& stat)
{
- return mBuffers->mCountsFloat[stat.getIndex()].getSampleCount();
+ update();
+ return mBuffers->mMemStats[stat.getIndex()].mChildSize.getStandardDeviation();
}
-U32 Recording::getSampleCount( const TraceType<CountAccumulator<S64> >& stat ) const
+LLUnit<LLUnits::Bytes, F64> Recording::getLastValue(const TraceType<MemStatAccumulator::ChildMemFacet>& stat)
{
- return mBuffers->mCounts[stat.getIndex()].getSampleCount();
+ update();
+ return mBuffers->mMemStats[stat.getIndex()].mChildSize.getLastValue();
}
-F64 Recording::getMin( const TraceType<SampleAccumulator<F64> >& stat ) const
+U32 Recording::getSum(const TraceType<MemStatAccumulator::AllocationCountFacet>& stat)
{
- return mBuffers->mSamplesFloat[stat.getIndex()].getMin();
+ update();
+ return mBuffers->mMemStats[stat.getIndex()].mAllocatedCount;
}
-S64 Recording::getMin( const TraceType<SampleAccumulator<S64> >& stat ) const
+U32 Recording::getSum(const TraceType<MemStatAccumulator::DeallocationCountFacet>& stat)
{
- return mBuffers->mSamples[stat.getIndex()].getMin();
+ update();
+ return mBuffers->mMemStats[stat.getIndex()].mAllocatedCount;
}
-F64 Recording::getMax( const TraceType<SampleAccumulator<F64> >& stat ) const
-{
- return mBuffers->mSamplesFloat[stat.getIndex()].getMax();
-}
-S64 Recording::getMax( const TraceType<SampleAccumulator<S64> >& stat ) const
+F64 Recording::getSum( const TraceType<CountAccumulator>& stat )
{
- return mBuffers->mSamples[stat.getIndex()].getMax();
+ update();
+ return mBuffers->mCounts[stat.getIndex()].getSum();
}
-F64 Recording::getMean( const TraceType<SampleAccumulator<F64> >& stat ) const
+F64 Recording::getSum( const TraceType<EventAccumulator>& stat )
{
- return mBuffers->mSamplesFloat[stat.getIndex()].getMean();
+ update();
+ return (F64)mBuffers->mEvents[stat.getIndex()].getSum();
}
-F64 Recording::getMean( const TraceType<SampleAccumulator<S64> >& stat ) const
+F64 Recording::getPerSec( const TraceType<CountAccumulator>& stat )
{
- return mBuffers->mSamples[stat.getIndex()].getMean();
+ update();
+ F64 sum = mBuffers->mCounts[stat.getIndex()].getSum();
+ return (sum != 0.0)
+ ? (sum / mElapsedSeconds)
+ : 0.0;
}
-F64 Recording::getStandardDeviation( const TraceType<SampleAccumulator<F64> >& stat ) const
+U32 Recording::getSampleCount( const TraceType<CountAccumulator>& stat )
{
- return mBuffers->mSamplesFloat[stat.getIndex()].getStandardDeviation();
+ update();
+ return mBuffers->mCounts[stat.getIndex()].getSampleCount();
}
-F64 Recording::getStandardDeviation( const TraceType<SampleAccumulator<S64> >& stat ) const
+F64 Recording::getMin( const TraceType<SampleAccumulator>& stat )
{
- return mBuffers->mSamples[stat.getIndex()].getStandardDeviation();
+ update();
+ return mBuffers->mSamples[stat.getIndex()].getMin();
}
-F64 Recording::getLastValue( const TraceType<SampleAccumulator<F64> >& stat ) const
+F64 Recording::getMax( const TraceType<SampleAccumulator>& stat )
{
- return mBuffers->mSamplesFloat[stat.getIndex()].getLastValue();
+ update();
+ return mBuffers->mSamples[stat.getIndex()].getMax();
}
-S64 Recording::getLastValue( const TraceType<SampleAccumulator<S64> >& stat ) const
+F64 Recording::getMean( const TraceType<SampleAccumulator>& stat )
{
- return mBuffers->mSamples[stat.getIndex()].getLastValue();
+ update();
+ return mBuffers->mSamples[stat.getIndex()].getMean();
}
-U32 Recording::getSampleCount( const TraceType<SampleAccumulator<F64> >& stat ) const
+F64 Recording::getStandardDeviation( const TraceType<SampleAccumulator>& stat )
{
- return mBuffers->mSamplesFloat[stat.getIndex()].getSampleCount();
+ update();
+ return mBuffers->mSamples[stat.getIndex()].getStandardDeviation();
}
-U32 Recording::getSampleCount( const TraceType<SampleAccumulator<S64> >& stat ) const
+F64 Recording::getLastValue( const TraceType<SampleAccumulator>& stat )
{
- return mBuffers->mSamples[stat.getIndex()].getSampleCount();
+ update();
+ return mBuffers->mSamples[stat.getIndex()].getLastValue();
}
-F64 Recording::getMin( const TraceType<EventAccumulator<F64> >& stat ) const
+U32 Recording::getSampleCount( const TraceType<SampleAccumulator>& stat )
{
- return mBuffers->mEventsFloat[stat.getIndex()].getMin();
+ update();
+ return mBuffers->mSamples[stat.getIndex()].getSampleCount();
}
-S64 Recording::getMin( const TraceType<EventAccumulator<S64> >& stat ) const
+F64 Recording::getMin( const TraceType<EventAccumulator>& stat )
{
+ update();
return mBuffers->mEvents[stat.getIndex()].getMin();
}
-F64 Recording::getMax( const TraceType<EventAccumulator<F64> >& stat ) const
-{
- return mBuffers->mEventsFloat[stat.getIndex()].getMax();
-}
-
-S64 Recording::getMax( const TraceType<EventAccumulator<S64> >& stat ) const
+F64 Recording::getMax( const TraceType<EventAccumulator>& stat )
{
+ update();
return mBuffers->mEvents[stat.getIndex()].getMax();
}
-F64 Recording::getMean( const TraceType<EventAccumulator<F64> >& stat ) const
-{
- return mBuffers->mEventsFloat[stat.getIndex()].getMean();
-}
-
-F64 Recording::getMean( const TraceType<EventAccumulator<S64> >& stat ) const
+F64 Recording::getMean( const TraceType<EventAccumulator>& stat )
{
+ update();
return mBuffers->mEvents[stat.getIndex()].getMean();
}
-F64 Recording::getStandardDeviation( const TraceType<EventAccumulator<F64> >& stat ) const
-{
- return mBuffers->mEventsFloat[stat.getIndex()].getStandardDeviation();
-}
-
-F64 Recording::getStandardDeviation( const TraceType<EventAccumulator<S64> >& stat ) const
+F64 Recording::getStandardDeviation( const TraceType<EventAccumulator>& stat )
{
+ update();
return mBuffers->mEvents[stat.getIndex()].getStandardDeviation();
}
-F64 Recording::getLastValue( const TraceType<EventAccumulator<F64> >& stat ) const
-{
- return mBuffers->mEventsFloat[stat.getIndex()].getLastValue();
-}
-
-S64 Recording::getLastValue( const TraceType<EventAccumulator<S64> >& stat ) const
+F64 Recording::getLastValue( const TraceType<EventAccumulator>& stat )
{
+ update();
return mBuffers->mEvents[stat.getIndex()].getLastValue();
}
-U32 Recording::getSampleCount( const TraceType<EventAccumulator<F64> >& stat ) const
-{
- return mBuffers->mEventsFloat[stat.getIndex()].getSampleCount();
-}
-
-U32 Recording::getSampleCount( const TraceType<EventAccumulator<S64> >& stat ) const
+U32 Recording::getSampleCount( const TraceType<EventAccumulator>& stat )
{
+ update();
return mBuffers->mEvents[stat.getIndex()].getSampleCount();
}
@@ -538,7 +521,7 @@ void PeriodicRecording::appendPeriodicRecording( PeriodicRecording& other )
other.setPlayState(other_play_state);
}
-LLUnit<LLUnits::Seconds, F64> PeriodicRecording::getDuration()
+LLUnit<LLUnits::Seconds, F64> PeriodicRecording::getDuration() const
{
LLUnit<LLUnits::Seconds, F64> duration;
size_t num_periods = mRecordingPeriods.size();
@@ -628,6 +611,122 @@ void PeriodicRecording::handleSplitTo(PeriodicRecording& other)
getCurRecording().splitTo(other.getCurRecording());
}
+
+F64 PeriodicRecording::getPeriodMean( const TraceType<EventAccumulator>& stat, size_t num_periods /*= U32_MAX*/ )
+{
+ size_t total_periods = mRecordingPeriods.size();
+ num_periods = llmin(num_periods, total_periods);
+
+ F64 mean = 0;
+ if (num_periods <= 0) { return mean; }
+
+ S32 total_sample_count = 0;
+
+ for (S32 i = 1; i <= num_periods; i++)
+ {
+ S32 index = (mCurPeriod + total_periods - i) % total_periods;
+ if (mRecordingPeriods[index].getDuration() > 0.f)
+ {
+ S32 period_sample_count = mRecordingPeriods[index].getSampleCount(stat);
+ mean += mRecordingPeriods[index].getMean(stat) * period_sample_count;
+ total_sample_count += period_sample_count;
+ }
+ }
+
+ if (total_sample_count)
+ {
+ mean = mean / total_sample_count;
+ }
+ return mean;
+}
+
+F64 PeriodicRecording::getPeriodMin( const TraceType<EventAccumulator>& stat, size_t num_periods /*= U32_MAX*/ )
+{
+ size_t total_periods = mRecordingPeriods.size();
+ num_periods = llmin(num_periods, total_periods);
+
+ F64 min_val = std::numeric_limits<F64>::max();
+ for (S32 i = 1; i <= num_periods; i++)
+ {
+ S32 index = (mCurPeriod + total_periods - i) % total_periods;
+ min_val = llmin(min_val, mRecordingPeriods[index].getMin(stat));
+ }
+ return min_val;
+}
+
+F64 PeriodicRecording::getPeriodMax( const TraceType<EventAccumulator>& stat, size_t num_periods /*= U32_MAX*/ )
+{
+ size_t total_periods = mRecordingPeriods.size();
+ num_periods = llmin(num_periods, total_periods);
+
+ F64 max_val = std::numeric_limits<F64>::min();
+ for (S32 i = 1; i <= num_periods; i++)
+ {
+ S32 index = (mCurPeriod + total_periods - i) % total_periods;
+ max_val = llmax(max_val, mRecordingPeriods[index].getMax(stat));
+ }
+ return max_val;
+}
+
+F64 PeriodicRecording::getPeriodMin( const TraceType<SampleAccumulator>& stat, size_t num_periods /*= U32_MAX*/ )
+{
+ size_t total_periods = mRecordingPeriods.size();
+ num_periods = llmin(num_periods, total_periods);
+
+ F64 min_val = std::numeric_limits<F64>::max();
+ for (S32 i = 1; i <= num_periods; i++)
+ {
+ S32 index = (mCurPeriod + total_periods - i) % total_periods;
+ min_val = llmin(min_val, mRecordingPeriods[index].getMin(stat));
+ }
+ return min_val;
+}
+
+F64 PeriodicRecording::getPeriodMax(const TraceType<SampleAccumulator>& stat, size_t num_periods /*= U32_MAX*/)
+{
+ size_t total_periods = mRecordingPeriods.size();
+ num_periods = llmin(num_periods, total_periods);
+
+ F64 max_val = std::numeric_limits<F64>::min();
+ for (S32 i = 1; i <= num_periods; i++)
+ {
+ S32 index = (mCurPeriod + total_periods - i) % total_periods;
+ max_val = llmax(max_val, mRecordingPeriods[index].getMax(stat));
+ }
+ return max_val;
+}
+
+
+F64 PeriodicRecording::getPeriodMean( const TraceType<SampleAccumulator>& stat, size_t num_periods /*= U32_MAX*/ )
+{
+ size_t total_periods = mRecordingPeriods.size();
+ num_periods = llmin(num_periods, total_periods);
+
+ LLUnit<LLUnits::Seconds, F64> total_duration = 0.f;
+
+ F64 mean = 0;
+ if (num_periods <= 0) { return mean; }
+
+ for (S32 i = 1; i <= num_periods; i++)
+ {
+ S32 index = (mCurPeriod + total_periods - i) % total_periods;
+ if (mRecordingPeriods[index].getDuration() > 0.f)
+ {
+ LLUnit<LLUnits::Seconds, F64> recording_duration = mRecordingPeriods[index].getDuration();
+ mean += mRecordingPeriods[index].getMean(stat) * recording_duration.value();
+ total_duration += recording_duration;
+ }
+ }
+
+ if (total_duration.value())
+ {
+ mean = mean / total_duration;
+ }
+ return mean;
+}
+
+
+
///////////////////////////////////////////////////////////////////////
// ExtendableRecording
///////////////////////////////////////////////////////////////////////
diff --git a/indra/llcommon/lltracerecording.h b/indra/llcommon/lltracerecording.h
index aaeb32e891..4651bfcb61 100644
--- a/indra/llcommon/lltracerecording.h
+++ b/indra/llcommon/lltracerecording.h
@@ -119,12 +119,9 @@ namespace LLTrace
void reset(RecordingBuffers* other = NULL);
void flush();
- AccumulatorBuffer<CountAccumulator<F64> > mCountsFloat;
- AccumulatorBuffer<CountAccumulator<S64> > mCounts;
- AccumulatorBuffer<SampleAccumulator<F64> > mSamplesFloat;
- AccumulatorBuffer<SampleAccumulator<S64> > mSamples;
- AccumulatorBuffer<EventAccumulator<F64> > mEventsFloat;
- AccumulatorBuffer<EventAccumulator<S64> > mEvents;
+ AccumulatorBuffer<CountAccumulator> mCounts;
+ AccumulatorBuffer<SampleAccumulator> mSamples;
+ AccumulatorBuffer<EventAccumulator> mEvents;
AccumulatorBuffer<TimeBlockAccumulator> mStackTimers;
AccumulatorBuffer<MemStatAccumulator> mMemStats;
};
@@ -151,134 +148,130 @@ namespace LLTrace
void makeUnique() { mBuffers.makeUnique(); }
// Timer accessors
- LLUnit<LLUnits::Seconds, F64> getSum(const TraceType<TimeBlockAccumulator>& stat) const;
- LLUnit<LLUnits::Seconds, F64> getSum(const TraceType<TimeBlockAccumulator::SelfTimeAspect>& stat) const;
- U32 getSum(const TraceType<TimeBlockAccumulator::CallCountAspect>& stat) const;
+ LLUnit<LLUnits::Seconds, F64> getSum(const TraceType<TimeBlockAccumulator>& stat);
+ LLUnit<LLUnits::Seconds, F64> getSum(const TraceType<TimeBlockAccumulator::SelfTimeFacet>& stat);
+ U32 getSum(const TraceType<TimeBlockAccumulator::CallCountFacet>& stat);
- LLUnit<LLUnits::Seconds, F64> getPerSec(const TraceType<TimeBlockAccumulator>& stat) const;
- LLUnit<LLUnits::Seconds, F64> getPerSec(const TraceType<TimeBlockAccumulator::SelfTimeAspect>& stat) const;
- F32 getPerSec(const TraceType<TimeBlockAccumulator::CallCountAspect>& stat) const;
+ LLUnit<LLUnits::Seconds, F64> getPerSec(const TraceType<TimeBlockAccumulator>& stat);
+ LLUnit<LLUnits::Seconds, F64> getPerSec(const TraceType<TimeBlockAccumulator::SelfTimeFacet>& stat);
+ F32 getPerSec(const TraceType<TimeBlockAccumulator::CallCountFacet>& stat);
// Memory accessors
- LLUnit<LLUnits::Bytes, U32> getSum(const TraceType<MemStatAccumulator>& stat) const;
- LLUnit<LLUnits::Bytes, F32> getPerSec(const TraceType<MemStatAccumulator>& stat) const;
+ LLUnit<LLUnits::Bytes, F64> getMin(const TraceType<MemStatAccumulator>& stat);
+ LLUnit<LLUnits::Bytes, F64> getMean(const TraceType<MemStatAccumulator>& stat);
+ LLUnit<LLUnits::Bytes, F64> getMax(const TraceType<MemStatAccumulator>& stat);
+ LLUnit<LLUnits::Bytes, F64> getStandardDeviation(const TraceType<MemStatAccumulator>& stat);
+ LLUnit<LLUnits::Bytes, F64> getLastValue(const TraceType<MemStatAccumulator>& stat);
+
+ LLUnit<LLUnits::Bytes, F64> getMin(const TraceType<MemStatAccumulator::ChildMemFacet>& stat);
+ LLUnit<LLUnits::Bytes, F64> getMean(const TraceType<MemStatAccumulator::ChildMemFacet>& stat);
+ LLUnit<LLUnits::Bytes, F64> getMax(const TraceType<MemStatAccumulator::ChildMemFacet>& stat);
+ LLUnit<LLUnits::Bytes, F64> getStandardDeviation(const TraceType<MemStatAccumulator::ChildMemFacet>& stat);
+ LLUnit<LLUnits::Bytes, F64> getLastValue(const TraceType<MemStatAccumulator::ChildMemFacet>& stat);
+
+ U32 getSum(const TraceType<MemStatAccumulator::AllocationCountFacet>& stat);
+ U32 getSum(const TraceType<MemStatAccumulator::DeallocationCountFacet>& stat);
// CountStatHandle accessors
- F64 getSum(const TraceType<CountAccumulator<F64> >& stat) const;
- S64 getSum(const TraceType<CountAccumulator<S64> >& stat) const;
+ F64 getSum(const TraceType<CountAccumulator>& stat);
template <typename T>
- T getSum(const CountStatHandle<T>& stat) const
+ T getSum(const CountStatHandle<T>& stat)
{
- return (T)getSum(static_cast<const TraceType<CountAccumulator<typename LLUnits::HighestPrecisionType<T>::type_t> >&> (stat));
+ return (T)getSum(static_cast<const TraceType<CountAccumulator>&> (stat));
}
- F64 getPerSec(const TraceType<CountAccumulator<F64> >& stat) const;
- F64 getPerSec(const TraceType<CountAccumulator<S64> >& stat) const;
+ F64 getPerSec(const TraceType<CountAccumulator>& stat);
template <typename T>
- T getPerSec(const CountStatHandle<T>& stat) const
+ T getPerSec(const CountStatHandle<T>& stat)
{
- return (T)getPerSec(static_cast<const TraceType<CountAccumulator<typename LLUnits::HighestPrecisionType<T>::type_t> >&> (stat));
+ return (T)getPerSec(static_cast<const TraceType<CountAccumulator>&> (stat));
}
- U32 getSampleCount(const TraceType<CountAccumulator<F64> >& stat) const;
- U32 getSampleCount(const TraceType<CountAccumulator<S64> >& stat) const;
+ U32 getSampleCount(const TraceType<CountAccumulator>& stat);
// SampleStatHandle accessors
- F64 getMin(const TraceType<SampleAccumulator<F64> >& stat) const;
- S64 getMin(const TraceType<SampleAccumulator<S64> >& stat) const;
+ F64 getMin(const TraceType<SampleAccumulator>& stat);
template <typename T>
- T getMin(const SampleStatHandle<T>& stat) const
+ T getMin(const SampleStatHandle<T>& stat)
{
- return (T)getMin(static_cast<const TraceType<SampleAccumulator<typename LLUnits::HighestPrecisionType<T>::type_t> >&> (stat));
+ return (T)getMin(static_cast<const TraceType<SampleAccumulator>&> (stat));
}
- F64 getMax(const TraceType<SampleAccumulator<F64> >& stat) const;
- S64 getMax(const TraceType<SampleAccumulator<S64> >& stat) const;
+ F64 getMean(const TraceType<SampleAccumulator>& stat);
template <typename T>
- T getMax(const SampleStatHandle<T>& stat) const
+ T getMean(SampleStatHandle<T>& stat)
{
- return (T)getMax(static_cast<const TraceType<SampleAccumulator<typename LLUnits::HighestPrecisionType<T>::type_t> >&> (stat));
+ return (T)getMean(static_cast<const TraceType<SampleAccumulator>&> (stat));
}
- F64 getMean(const TraceType<SampleAccumulator<F64> >& stat) const;
- F64 getMean(const TraceType<SampleAccumulator<S64> >& stat) const;
+ F64 getMax(const TraceType<SampleAccumulator>& stat);
template <typename T>
- T getMean(SampleStatHandle<T>& stat) const
+ T getMax(const SampleStatHandle<T>& stat)
{
- return (T)getMean(static_cast<const TraceType<SampleAccumulator<typename LLUnits::HighestPrecisionType<T>::type_t> >&> (stat));
+ return (T)getMax(static_cast<const TraceType<SampleAccumulator>&> (stat));
}
- F64 getStandardDeviation(const TraceType<SampleAccumulator<F64> >& stat) const;
- F64 getStandardDeviation(const TraceType<SampleAccumulator<S64> >& stat) const;
+ F64 getStandardDeviation(const TraceType<SampleAccumulator>& stat);
template <typename T>
- T getStandardDeviation(const SampleStatHandle<T>& stat) const
+ T getStandardDeviation(const SampleStatHandle<T>& stat)
{
- return (T)getStandardDeviation(static_cast<const TraceType<SampleAccumulator<typename LLUnits::HighestPrecisionType<T>::type_t> >&> (stat));
+ return (T)getStandardDeviation(static_cast<const TraceType<SampleAccumulator>&> (stat));
}
- F64 getLastValue(const TraceType<SampleAccumulator<F64> >& stat) const;
- S64 getLastValue(const TraceType<SampleAccumulator<S64> >& stat) const;
+ F64 getLastValue(const TraceType<SampleAccumulator>& stat);
template <typename T>
- T getLastValue(const SampleStatHandle<T>& stat) const
+ T getLastValue(const SampleStatHandle<T>& stat)
{
- return (T)getLastValue(static_cast<const TraceType<SampleAccumulator<typename LLUnits::HighestPrecisionType<T>::type_t> >&> (stat));
+ return (T)getLastValue(static_cast<const TraceType<SampleAccumulator>&> (stat));
}
- U32 getSampleCount(const TraceType<SampleAccumulator<F64> >& stat) const;
- U32 getSampleCount(const TraceType<SampleAccumulator<S64> >& stat) const;
+ U32 getSampleCount(const TraceType<SampleAccumulator>& stat);
// EventStatHandle accessors
- F64 getSum(const TraceType<EventAccumulator<F64> >& stat) const;
- S64 getSum(const TraceType<EventAccumulator<S64> >& stat) const;
+ F64 getSum(const TraceType<EventAccumulator>& stat);
template <typename T>
- T getSum(const EventStatHandle<T>& stat) const
+ T getSum(const EventStatHandle<T>& stat)
{
- return (T)getSum(static_cast<const TraceType<EventAccumulator<typename LLUnits::HighestPrecisionType<T>::type_t> >&> (stat));
+ return (T)getSum(static_cast<const TraceType<EventAccumulator>&> (stat));
}
- F64 getMin(const TraceType<EventAccumulator<F64> >& stat) const;
- S64 getMin(const TraceType<EventAccumulator<S64> >& stat) const;
+ F64 getMin(const TraceType<EventAccumulator>& stat);
template <typename T>
- T getMin(const EventStatHandle<T>& stat) const
+ T getMin(const EventStatHandle<T>& stat)
{
- return (T)getMin(static_cast<const TraceType<EventAccumulator<typename LLUnits::HighestPrecisionType<T>::type_t> >&> (stat));
+ return (T)getMin(static_cast<const TraceType<EventAccumulator>&> (stat));
}
- F64 getMax(const TraceType<EventAccumulator<F64> >& stat) const;
- S64 getMax(const TraceType<EventAccumulator<S64> >& stat) const;
+ F64 getMax(const TraceType<EventAccumulator>& stat);
template <typename T>
- T getMax(const EventStatHandle<T>& stat) const
+ T getMax(const EventStatHandle<T>& stat)
{
- return (T)getMax(static_cast<const TraceType<EventAccumulator<typename LLUnits::HighestPrecisionType<T>::type_t> >&> (stat));
+ return (T)getMax(static_cast<const TraceType<EventAccumulator>&> (stat));
}
- F64 getMean(const TraceType<EventAccumulator<F64> >& stat) const;
- F64 getMean(const TraceType<EventAccumulator<S64> >& stat) const;
+ F64 getMean(const TraceType<EventAccumulator>& stat);
template <typename T>
- T getMean(EventStatHandle<T>& stat) const
+ T getMean(EventStatHandle<T>& stat)
{
- return (T)getMean(static_cast<const TraceType<EventAccumulator<typename LLUnits::HighestPrecisionType<T>::type_t> >&> (stat));
+ return (T)getMean(static_cast<const TraceType<EventAccumulator>&> (stat));
}
- F64 getStandardDeviation(const TraceType<EventAccumulator<F64> >& stat) const;
- F64 getStandardDeviation(const TraceType<EventAccumulator<S64> >& stat) const;
+ F64 getStandardDeviation(const TraceType<EventAccumulator>& stat);
template <typename T>
- T getStandardDeviation(const EventStatHandle<T>& stat) const
+ T getStandardDeviation(const EventStatHandle<T>& stat)
{
- return (T)getStandardDeviation(static_cast<const TraceType<EventAccumulator<typename LLUnits::HighestPrecisionType<T>::type_t> >&> (stat));
+ return (T)getStandardDeviation(static_cast<const TraceType<EventAccumulator>&> (stat));
}
- F64 getLastValue(const TraceType<EventAccumulator<F64> >& stat) const;
- S64 getLastValue(const TraceType<EventAccumulator<S64> >& stat) const;
+ F64 getLastValue(const TraceType<EventAccumulator>& stat);
template <typename T>
- T getLastValue(const EventStatHandle<T>& stat) const
+ T getLastValue(const EventStatHandle<T>& stat)
{
- return (T)getLastValue(static_cast<const TraceType<EventAccumulator<typename LLUnits::HighestPrecisionType<T>::type_t> >&> (stat));
+ return (T)getLastValue(static_cast<const TraceType<EventAccumulator>&> (stat));
}
- U32 getSampleCount(const TraceType<EventAccumulator<F64> >& stat) const;
- U32 getSampleCount(const TraceType<EventAccumulator<S64> >& stat) const;
+ U32 getSampleCount(const TraceType<EventAccumulator>& stat);
LLUnit<LLUnits::Seconds, F64> getDuration() const { return LLUnit<LLUnits::Seconds, F64>(mElapsedSeconds); }
@@ -308,7 +301,7 @@ namespace LLTrace
void nextPeriod();
U32 getNumPeriods() { return mRecordingPeriods.size(); }
- LLUnit<LLUnits::Seconds, F64> getDuration();
+ LLUnit<LLUnits::Seconds, F64> getDuration() const;
void appendPeriodicRecording(PeriodicRecording& other);
Recording& getLastRecording();
@@ -321,7 +314,7 @@ namespace LLTrace
// catch all for stats that have a defined sum
template <typename T>
- typename T::value_t getPeriodMin(const TraceType<T>& stat, size_t num_periods = U32_MAX) const
+ typename T::value_t getPeriodMin(const TraceType<T>& stat, size_t num_periods = U32_MAX)
{
size_t total_periods = mRecordingPeriods.size();
num_periods = llmin(num_periods, total_periods);
@@ -335,38 +328,22 @@ namespace LLTrace
return min_val;
}
- template <typename T>
- T getPeriodMin(const TraceType<SampleAccumulator<T> >& stat, size_t num_periods = U32_MAX) const
+ F64 getPeriodMin(const TraceType<SampleAccumulator>& stat, size_t num_periods = U32_MAX);
+ template<typename T>
+ T getPeriodMin(const SampleStatHandle<T>& stat, size_t num_periods = U32_MAX)
{
- size_t total_periods = mRecordingPeriods.size();
- num_periods = llmin(num_periods, total_periods);
-
- T min_val = std::numeric_limits<T>::max();
- for (S32 i = 1; i <= num_periods; i++)
- {
- S32 index = (mCurPeriod + total_periods - i) % total_periods;
- min_val = llmin(min_val, mRecordingPeriods[index].getMin(stat));
- }
- return min_val;
+ return T(getPeriodMin(static_cast<const TraceType<SampleAccumulator>&>(stat), num_periods));
}
-
- template <typename T>
- T getPeriodMin(const TraceType<EventAccumulator<T> >& stat, size_t num_periods = U32_MAX) const
- {
- size_t total_periods = mRecordingPeriods.size();
- num_periods = llmin(num_periods, total_periods);
- typename T min_val = std::numeric_limits<T>::max();
- for (S32 i = 1; i <= num_periods; i++)
- {
- S32 index = (mCurPeriod + total_periods - i) % total_periods;
- min_val = llmin(min_val, mRecordingPeriods[index].getMin(stat));
- }
- return min_val;
+ F64 getPeriodMin(const TraceType<EventAccumulator>& stat, size_t num_periods = U32_MAX);
+ template<typename T>
+ T getPeriodMin(const EventStatHandle<T>& stat, size_t num_periods = U32_MAX)
+ {
+ return T(getPeriodMin(static_cast<const TraceType<EventAccumulator>&>(stat), num_periods));
}
template <typename T>
- F64 getPeriodMinPerSec(const TraceType<T>& stat, size_t num_periods = U32_MAX) const
+ F64 getPeriodMinPerSec(const TraceType<T>& stat, size_t num_periods = U32_MAX)
{
size_t total_periods = mRecordingPeriods.size();
num_periods = llmin(num_periods, total_periods);
@@ -382,7 +359,7 @@ namespace LLTrace
// catch all for stats that have a defined sum
template <typename T>
- typename T::value_t getPeriodMax(const TraceType<T>& stat, size_t num_periods = U32_MAX) const
+ typename T::value_t getPeriodMax(const TraceType<T>& stat, size_t num_periods = U32_MAX)
{
size_t total_periods = mRecordingPeriods.size();
num_periods = llmin(num_periods, total_periods);
@@ -396,38 +373,22 @@ namespace LLTrace
return max_val;
}
- template <typename T>
- typename T getPeriodMax(const TraceType<SampleAccumulator<T> >& stat, size_t num_periods = U32_MAX) const
+ F64 getPeriodMax(const TraceType<SampleAccumulator>& stat, size_t num_periods = U32_MAX);
+ template<typename T>
+ T getPeriodMax(const SampleStatHandle<T>& stat, size_t num_periods = U32_MAX)
{
- size_t total_periods = mRecordingPeriods.size();
- num_periods = llmin(num_periods, total_periods);
-
- typename T max_val = std::numeric_limits<T>::min();
- for (S32 i = 1; i <= num_periods; i++)
- {
- S32 index = (mCurPeriod + total_periods - i) % total_periods;
- max_val = llmax(max_val, mRecordingPeriods[index].getMax(stat));
- }
- return max_val;
+ return T(getPeriodMax(static_cast<const TraceType<SampleAccumulator>&>(stat), num_periods));
}
- template <typename T>
- typename T getPeriodMax(const TraceType<EventAccumulator<T> >& stat, size_t num_periods = U32_MAX) const
+ F64 getPeriodMax(const TraceType<EventAccumulator>& stat, size_t num_periods = U32_MAX);
+ template<typename T>
+ T getPeriodMax(const EventStatHandle<T>& stat, size_t num_periods = U32_MAX)
{
- size_t total_periods = mRecordingPeriods.size();
- num_periods = llmin(num_periods, total_periods);
-
- typename T max_val = std::numeric_limits<T>::min();
- for (S32 i = 1; i <= num_periods; i++)
- {
- S32 index = (mCurPeriod + total_periods - i) % total_periods;
- max_val = llmax(max_val, mRecordingPeriods[index].getMax(stat));
- }
- return max_val;
+ return T(getPeriodMax(static_cast<const TraceType<EventAccumulator>&>(stat), num_periods));
}
template <typename T>
- F64 getPeriodMaxPerSec(const TraceType<T>& stat, size_t num_periods = U32_MAX) const
+ F64 getPeriodMaxPerSec(const TraceType<T>& stat, size_t num_periods = U32_MAX)
{
size_t total_periods = mRecordingPeriods.size();
num_periods = llmin(num_periods, total_periods);
@@ -443,7 +404,7 @@ namespace LLTrace
// catch all for stats that have a defined sum
template <typename T>
- typename T::mean_t getPeriodMean(const TraceType<T >& stat, size_t num_periods = U32_MAX) const
+ typename T::mean_t getPeriodMean(const TraceType<T >& stat, size_t num_periods = U32_MAX)
{
size_t total_periods = mRecordingPeriods.size();
num_periods = llmin(num_periods, total_periods);
@@ -463,66 +424,22 @@ namespace LLTrace
return mean;
}
- template <typename T>
- typename SampleAccumulator<T>::mean_t getPeriodMean(const TraceType<SampleAccumulator<T> >& stat, size_t num_periods = U32_MAX) const
+ F64 getPeriodMean(const TraceType<SampleAccumulator>& stat, size_t num_periods = U32_MAX);
+ template<typename T>
+ T getPeriodMean(const SampleStatHandle<T>& stat, size_t num_periods = U32_MAX)
{
- size_t total_periods = mRecordingPeriods.size();
- num_periods = llmin(num_periods, total_periods);
-
- LLUnit<LLUnits::Seconds, F64> total_duration = 0.f;
-
- typename SampleAccumulator<T>::mean_t mean = 0;
- if (num_periods <= 0) { return mean; }
-
- for (S32 i = 1; i <= num_periods; i++)
- {
- S32 index = (mCurPeriod + total_periods - i) % total_periods;
- if (mRecordingPeriods[index].getDuration() > 0.f)
- {
- LLUnit<LLUnits::Seconds, F64> recording_duration = mRecordingPeriods[index].getDuration();
- mean += mRecordingPeriods[index].getMean(stat) * recording_duration.value();
- total_duration += recording_duration;
- }
- }
-
- if (total_duration.value())
- {
- mean = mean / total_duration;
- }
- return mean;
+ return T(getPeriodMean(static_cast<const TraceType<SampleAccumulator>&>(stat), num_periods));
}
- template <typename T>
- typename EventAccumulator<T>::mean_t getPeriodMean(const TraceType<EventAccumulator<T> >& stat, size_t num_periods = U32_MAX) const
+ F64 getPeriodMean(const TraceType<EventAccumulator>& stat, size_t num_periods = U32_MAX);
+ template<typename T>
+ T getPeriodMean(const EventStatHandle<T>& stat, size_t num_periods = U32_MAX)
{
- size_t total_periods = mRecordingPeriods.size();
- num_periods = llmin(num_periods, total_periods);
-
- typename EventAccumulator<T>::mean_t mean = 0;
- if (num_periods <= 0) { return mean; }
-
- S32 total_sample_count = 0;
-
- for (S32 i = 1; i <= num_periods; i++)
- {
- S32 index = (mCurPeriod + total_periods - i) % total_periods;
- if (mRecordingPeriods[index].getDuration() > 0.f)
- {
- S32 period_sample_count = mRecordingPeriods[index].getSampleCount(stat);
- mean += mRecordingPeriods[index].getMean(stat) * period_sample_count;
- total_sample_count += period_sample_count;
- }
- }
-
- if (total_sample_count)
- {
- mean = mean / total_sample_count;
- }
- return mean;
+ return T(getPeriodMean(static_cast<const TraceType<EventAccumulator>&>(stat), num_periods));
}
template <typename T>
- typename T::mean_t getPeriodMeanPerSec(const TraceType<T>& stat, size_t num_periods = U32_MAX) const
+ typename T::mean_t getPeriodMeanPerSec(const TraceType<T>& stat, size_t num_periods = U32_MAX)
{
size_t total_periods = mRecordingPeriods.size();
num_periods = llmin(num_periods, total_periods);
@@ -551,7 +468,6 @@ namespace LLTrace
private:
std::vector<Recording> mRecordingPeriods;
- Recording mTotalRecording;
const bool mAutoResize;
S32 mCurPeriod;
};
diff --git a/indra/llcommon/lltracethreadrecorder.cpp b/indra/llcommon/lltracethreadrecorder.cpp
index 75c7cb2ff1..c1a0700eff 100644
--- a/indra/llcommon/lltracethreadrecorder.cpp
+++ b/indra/llcommon/lltracethreadrecorder.cpp
@@ -147,13 +147,6 @@ ThreadRecorder::active_recording_list_t::reverse_iterator ThreadRecorder::bringU
return it;
}
-AccumulatorBuffer<CountAccumulator<F64> > gCountsFloat;
-AccumulatorBuffer<EventAccumulator<F64> > gMeasurementsFloat;
-AccumulatorBuffer<CountAccumulator<S64> > gCounts;
-AccumulatorBuffer<EventAccumulator<S64> > gMeasurements;
-AccumulatorBuffer<TimeBlockAccumulator> gStackTimers;
-AccumulatorBuffer<MemStatAccumulator> gMemStats;
-
void ThreadRecorder::deactivate( Recording* recording )
{
active_recording_list_t::reverse_iterator it = bringUpToDate(recording);
@@ -247,7 +240,7 @@ void SlaveThreadRecorder::SharedData::reset()
// MasterThreadRecorder
///////////////////////////////////////////////////////////////////////
-LLFastTimer::DeclareTimer FTM_PULL_TRACE_DATA_FROM_SLAVES("Pull slave trace data");
+static LLFastTimer::DeclareTimer FTM_PULL_TRACE_DATA_FROM_SLAVES("Pull slave trace data");
void MasterThreadRecorder::pullFromSlaveThreads()
{
LLFastTimer _(FTM_PULL_TRACE_DATA_FROM_SLAVES);
diff --git a/indra/llcommon/llunit.h b/indra/llcommon/llunit.h
index f86f111b90..a5406fb3f0 100644
--- a/indra/llcommon/llunit.h
+++ b/indra/llcommon/llunit.h
@@ -34,24 +34,10 @@
namespace LLUnits
{
-template<typename T>
-struct HighestPrecisionType
-{
- typedef T type_t;
-};
-
-template<> struct HighestPrecisionType<F32> { typedef F64 type_t; };
-template<> struct HighestPrecisionType<S32> { typedef S64 type_t; };
-template<> struct HighestPrecisionType<U32> { typedef S64 type_t; };
-template<> struct HighestPrecisionType<S16> { typedef S64 type_t; };
-template<> struct HighestPrecisionType<U16> { typedef S64 type_t; };
-template<> struct HighestPrecisionType<S8> { typedef S64 type_t; };
-template<> struct HighestPrecisionType<U8> { typedef S64 type_t; };
-
template<typename DERIVED_UNITS_TAG, typename BASE_UNITS_TAG, typename VALUE_TYPE>
struct ConversionFactor
{
- static typename HighestPrecisionType<VALUE_TYPE>::type_t get()
+ static F64 get()
{
// spurious use of dependent type to stop gcc from triggering the static assertion before instantiating the template
llstatic_assert_template(DERIVED_UNITS_TAG, false, "Cannot convert between types.");
@@ -61,7 +47,7 @@ struct ConversionFactor
template<typename BASE_UNITS_TAG, typename VALUE_TYPE>
struct ConversionFactor<BASE_UNITS_TAG, BASE_UNITS_TAG, VALUE_TYPE>
{
- static typename HighestPrecisionType<VALUE_TYPE>::type_t get()
+ static F64 get()
{
return 1;
}
@@ -406,6 +392,22 @@ COMPARISON_OPERATORS(>=)
COMPARISON_OPERATORS(==)
COMPARISON_OPERATORS(!=)
+
+template<typename T>
+struct LLGetUnitLabel
+{
+ static const char* getUnitLabel() { return ""; }
+};
+
+template<typename T, typename STORAGE_T>
+struct LLGetUnitLabel<LLUnit<T, STORAGE_T> >
+{
+ static const char* getUnitLabel() { return T::getUnitLabel(); }
+};
+
+//
+// Unit declarations
+//
namespace LLUnits
{
template<typename T>
@@ -417,60 +419,63 @@ STORAGE_TYPE rawValue(LLUnit<UNIT_TYPE, STORAGE_TYPE> val) { return val.value();
template<typename UNIT_TYPE, typename STORAGE_TYPE>
STORAGE_TYPE rawValue(LLUnitImplicit<UNIT_TYPE, STORAGE_TYPE> val) { return val.value(); }
-template<typename UNIT_TYPE, typename STORAGE_TYPE>
-struct HighestPrecisionType<LLUnit<UNIT_TYPE, STORAGE_TYPE> >
-{
- typedef typename HighestPrecisionType<STORAGE_TYPE>::type_t type_t;
-};
-
-#define LL_DECLARE_DERIVED_UNIT(conversion_factor, base_unit_name, unit_name) \
+#define LL_DECLARE_DERIVED_UNIT(conversion_factor, base_unit_name, unit_name, unit_label) \
struct unit_name \
{ \
typedef base_unit_name base_unit_t; \
+ static const char* getUnitLabel() { return unit_label; } \
}; \
template<typename STORAGE_TYPE> \
struct ConversionFactor<unit_name, base_unit_name, STORAGE_TYPE> \
{ \
- static typename HighestPrecisionType<STORAGE_TYPE>::type_t get() \
+ static F64 get() \
{ \
- return typename HighestPrecisionType<STORAGE_TYPE>::type_t(conversion_factor); \
+ return (F64)conversion_factor; \
} \
}; \
\
template<typename STORAGE_TYPE> \
struct ConversionFactor<base_unit_name, unit_name, STORAGE_TYPE> \
{ \
- static typename HighestPrecisionType<STORAGE_TYPE>::type_t get() \
+ static F64 get() \
{ \
- return typename HighestPrecisionType<STORAGE_TYPE>::type_t(1.0 / (conversion_factor)); \
+ return (F64)(1.0 / (conversion_factor)); \
} \
}
-struct Bytes { typedef Bytes base_unit_t; };
-LL_DECLARE_DERIVED_UNIT(1024, Bytes, Kilobytes);
-LL_DECLARE_DERIVED_UNIT(1024 * 1024, Bytes, Megabytes);
-LL_DECLARE_DERIVED_UNIT(1024 * 1024 * 1024, Bytes, Gigabytes);
-LL_DECLARE_DERIVED_UNIT(1.0 / 8.0, Bytes, Bits);
-LL_DECLARE_DERIVED_UNIT(1024 / 8, Bytes, Kilobits);
-LL_DECLARE_DERIVED_UNIT(1024 / 8, Bytes, Megabits);
-LL_DECLARE_DERIVED_UNIT(1024 * 1024 * 1024 / 8, Bytes, Gigabits);
-
-struct Seconds { typedef Seconds base_unit_t; };
-LL_DECLARE_DERIVED_UNIT(60, Seconds, Minutes);
-LL_DECLARE_DERIVED_UNIT(60 * 60, Seconds, Hours);
-LL_DECLARE_DERIVED_UNIT(1.0 / 1000.0, Seconds, Milliseconds);
-LL_DECLARE_DERIVED_UNIT(1.0 / 1000000.0, Seconds, Microseconds);
-LL_DECLARE_DERIVED_UNIT(1.0 / 1000000000.0, Seconds, Nanoseconds);
-
-struct Meters { typedef Meters base_unit_t; };
-LL_DECLARE_DERIVED_UNIT(1000, Meters, Kilometers);
-LL_DECLARE_DERIVED_UNIT(1.0 / 100.0, Meters, Centimeters);
-LL_DECLARE_DERIVED_UNIT(1.0 / 1000.0, Meters, Millimeters);
-
-struct Hertz { typedef Hertz base_unit_t; };
-LL_DECLARE_DERIVED_UNIT(1000, Hertz, Kilohertz);
-LL_DECLARE_DERIVED_UNIT(1000 * 1000, Hertz, Megahertz);
-LL_DECLARE_DERIVED_UNIT(1000 * 1000 * 1000, Hertz, Gigahertz);
+#define LL_DECLARE_BASE_UNIT(base_unit_name, unit_label) \
+struct base_unit_name { typedef base_unit_name base_unit_t; static const char* getUnitLabel() { return unit_label; }}
+
+LL_DECLARE_BASE_UNIT(Bytes, "B");
+LL_DECLARE_DERIVED_UNIT(1024, Bytes, Kibibytes, "KiB");
+LL_DECLARE_DERIVED_UNIT(1024 * 1024, Bytes, Mibibytes, "MiB");
+LL_DECLARE_DERIVED_UNIT(1024 * 1024 * 1024, Bytes, Gibibytes, "GiB");
+LL_DECLARE_DERIVED_UNIT(1.0 / 8.0, Bytes, Bits, "b");
+LL_DECLARE_DERIVED_UNIT(1024 / 8, Bytes, Kibibits, "Kib");
+LL_DECLARE_DERIVED_UNIT(1024 / 8, Bytes, Mibibits, "Mib");
+LL_DECLARE_DERIVED_UNIT(1024 * 1024 * 1024 / 8, Bytes, Gibibits, "Gib");
+
+LL_DECLARE_BASE_UNIT(Seconds, "s");
+LL_DECLARE_DERIVED_UNIT(60, Seconds, Minutes, "min");
+LL_DECLARE_DERIVED_UNIT(60 * 60, Seconds, Hours, "h");
+LL_DECLARE_DERIVED_UNIT(1.0 / 1000.0, Seconds, Milliseconds, "ms");
+LL_DECLARE_DERIVED_UNIT(1.0 / 1000000.0, Seconds, Microseconds, "\x09\x3cs");
+LL_DECLARE_DERIVED_UNIT(1.0 / 1000000000.0, Seconds, Nanoseconds, "ns");
+
+LL_DECLARE_BASE_UNIT(Meters, "m");
+LL_DECLARE_DERIVED_UNIT(1000, Meters, Kilometers, "km");
+LL_DECLARE_DERIVED_UNIT(1.0 / 100.0, Meters, Centimeters, "cm");
+LL_DECLARE_DERIVED_UNIT(1.0 / 1000.0, Meters, Millimeters, "mm");
+
+LL_DECLARE_BASE_UNIT(Hertz, "Hz");
+LL_DECLARE_DERIVED_UNIT(1000, Hertz, Kilohertz, "KHz");
+LL_DECLARE_DERIVED_UNIT(1000 * 1000, Hertz, Megahertz, "MHz");
+LL_DECLARE_DERIVED_UNIT(1000 * 1000 * 1000, Hertz, Gigahertz, "GHz");
+
+LL_DECLARE_BASE_UNIT(Radians, "rad");
+LL_DECLARE_DERIVED_UNIT(DEG_TO_RAD, Radians, Degrees, "deg");
+
+
} // namespace LLUnits
#endif // LL_LLUNIT_H
generated by cgit v1.2.3 (git 2.25.1) at 2025-09-16 16:25:40 +0000