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

SH-3931 WIP Interesting: Add graphs to visualize scene load metrics 

removed unnecessary templates from accumulator types...now always
track data in double precision floating point, using templated accessors to
convert to and from arbitrary types
master
Richard Linden 2013-06-02 22:49:17 -07:00
parent aa7024ffba
commit 233201f822
9 changed files with 297 additions and 526 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

96
indra/llcommon/lltrace.h
View File

@ -273,25 +273,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 +303,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 +352,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 +365,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 +386,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 +405,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 +414,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 +430,7 @@ public:
mHasValue = true;
}
void addSamples(const self_t& other, bool append)
void addSamples(const SampleAccumulator& other, bool append)
{
if (other.mTotalSamplingTime)
{
@ -485,12 +481,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();
@ -506,22 +502,22 @@ public:
if (mHasValue)
{
mSum += (F64)mLastValue * delta_time;
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;
@ -537,12 +533,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()
@ -550,19 +544,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;
@ -570,12 +564,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;
};
@ -659,11 +653,11 @@ 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 TraceType<EventAccumulator> trace_t;
EventStatHandle(const char* name, const char* description = NULL)
: trace_t(name, description)
@ -679,11 +673,11 @@ 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)
@ -699,11 +693,11 @@ 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 TraceType<CountAccumulator> trace_t;
CountStatHandle(const char* name, const char* description = NULL)
: trace_t(name)

268
indra/llcommon/lltracerecording.cpp
View File

@ -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();
}
@ -280,200 +264,100 @@ LLUnit<LLUnits::Bytes, F32> Recording::getPerSec(const TraceType<MemStatAccumula
}
F64 Recording::getSum( const TraceType<CountAccumulator<F64> >& stat )
{
update();
return mBuffers->mCountsFloat[stat.getIndex()].getSum();
}
S64 Recording::getSum( const TraceType<CountAccumulator<S64> >& stat )
F64 Recording::getSum( const TraceType<CountAccumulator>& stat )
{
update();
return mBuffers->mCounts[stat.getIndex()].getSum();
}
F64 Recording::getSum( const TraceType<EventAccumulator<F64> >& stat )
F64 Recording::getSum( const TraceType<EventAccumulator>& stat )
{
update();
return (F64)mBuffers->mEventsFloat[stat.getIndex()].getSum();
return (F64)mBuffers->mEvents[stat.getIndex()].getSum();
}
S64 Recording::getSum( const TraceType<EventAccumulator<S64> >& stat )
F64 Recording::getPerSec( const TraceType<CountAccumulator>& stat )
{
update();
return (S64)mBuffers->mEvents[stat.getIndex()].getSum();
}
F64 Recording::getPerSec( const TraceType<CountAccumulator<F64> >& stat )
{
update();
F64 sum = mBuffers->mCountsFloat[stat.getIndex()].getSum();
F64 sum = mBuffers->mCounts[stat.getIndex()].getSum();
return (sum != 0.0)
? (sum / mElapsedSeconds)
: 0.0;
}
F64 Recording::getPerSec( const TraceType<CountAccumulator<S64> >& stat )
{
S64 sum = mBuffers->mCounts[stat.getIndex()].getSum();
return (sum != 0)
? ((F64)sum / mElapsedSeconds)
: 0.0;
}
U32 Recording::getSampleCount( const TraceType<CountAccumulator<F64> >& stat )
{
update();
return mBuffers->mCountsFloat[stat.getIndex()].getSampleCount();
}
U32 Recording::getSampleCount( const TraceType<CountAccumulator<S64> >& stat )
U32 Recording::getSampleCount( const TraceType<CountAccumulator>& stat )
{
update();
return mBuffers->mCounts[stat.getIndex()].getSampleCount();
}
F64 Recording::getMin( const TraceType<SampleAccumulator<F64> >& stat )
{
update();
return mBuffers->mSamplesFloat[stat.getIndex()].getMin();
}
S64 Recording::getMin( const TraceType<SampleAccumulator<S64> >& stat )
F64 Recording::getMin( const TraceType<SampleAccumulator>& stat )
{
update();
return mBuffers->mSamples[stat.getIndex()].getMin();
}
F64 Recording::getMax( const TraceType<SampleAccumulator<F64> >& stat )
{
update();
return mBuffers->mSamplesFloat[stat.getIndex()].getMax();
}
S64 Recording::getMax( const TraceType<SampleAccumulator<S64> >& stat )
F64 Recording::getMax( const TraceType<SampleAccumulator>& stat )
{
update();
return mBuffers->mSamples[stat.getIndex()].getMax();
}
F64 Recording::getMean( const TraceType<SampleAccumulator<F64> >& stat )
{
update();
return mBuffers->mSamplesFloat[stat.getIndex()].getMean();
}
F64 Recording::getMean( const TraceType<SampleAccumulator<S64> >& stat )
F64 Recording::getMean( const TraceType<SampleAccumulator>& stat )
{
update();
return mBuffers->mSamples[stat.getIndex()].getMean();
}
F64 Recording::getStandardDeviation( const TraceType<SampleAccumulator<F64> >& stat )
{
update();
return mBuffers->mSamplesFloat[stat.getIndex()].getStandardDeviation();
}
F64 Recording::getStandardDeviation( const TraceType<SampleAccumulator<S64> >& stat )
F64 Recording::getStandardDeviation( const TraceType<SampleAccumulator>& stat )
{
update();
return mBuffers->mSamples[stat.getIndex()].getStandardDeviation();
}
F64 Recording::getLastValue( const TraceType<SampleAccumulator<F64> >& stat )
{
update();
return mBuffers->mSamplesFloat[stat.getIndex()].getLastValue();
}
S64 Recording::getLastValue( const TraceType<SampleAccumulator<S64> >& stat )
F64 Recording::getLastValue( const TraceType<SampleAccumulator>& stat )
{
update();
return mBuffers->mSamples[stat.getIndex()].getLastValue();
}
U32 Recording::getSampleCount( const TraceType<SampleAccumulator<F64> >& stat )
{
update();
return mBuffers->mSamplesFloat[stat.getIndex()].getSampleCount();
}
U32 Recording::getSampleCount( const TraceType<SampleAccumulator<S64> >& stat )
U32 Recording::getSampleCount( const TraceType<SampleAccumulator>& stat )
{
update();
return mBuffers->mSamples[stat.getIndex()].getSampleCount();
}
F64 Recording::getMin( const TraceType<EventAccumulator<F64> >& stat )
{
update();
return mBuffers->mEventsFloat[stat.getIndex()].getMin();
}
S64 Recording::getMin( const TraceType<EventAccumulator<S64> >& stat )
F64 Recording::getMin( const TraceType<EventAccumulator>& stat )
{
update();
return mBuffers->mEvents[stat.getIndex()].getMin();
}
F64 Recording::getMax( const TraceType<EventAccumulator<F64> >& stat )
{
update();
return mBuffers->mEventsFloat[stat.getIndex()].getMax();
}
S64 Recording::getMax( const TraceType<EventAccumulator<S64> >& stat )
F64 Recording::getMax( const TraceType<EventAccumulator>& stat )
{
update();
return mBuffers->mEvents[stat.getIndex()].getMax();
}
F64 Recording::getMean( const TraceType<EventAccumulator<F64> >& stat )
{
update();
return mBuffers->mEventsFloat[stat.getIndex()].getMean();
}
F64 Recording::getMean( const TraceType<EventAccumulator<S64> >& stat )
F64 Recording::getMean( const TraceType<EventAccumulator>& stat )
{
update();
return mBuffers->mEvents[stat.getIndex()].getMean();
}
F64 Recording::getStandardDeviation( const TraceType<EventAccumulator<F64> >& stat )
{
update();
return mBuffers->mEventsFloat[stat.getIndex()].getStandardDeviation();
}
F64 Recording::getStandardDeviation( const TraceType<EventAccumulator<S64> >& stat )
F64 Recording::getStandardDeviation( const TraceType<EventAccumulator>& stat )
{
update();
return mBuffers->mEvents[stat.getIndex()].getStandardDeviation();
}
F64 Recording::getLastValue( const TraceType<EventAccumulator<F64> >& stat )
{
update();
return mBuffers->mEventsFloat[stat.getIndex()].getLastValue();
}
S64 Recording::getLastValue( const TraceType<EventAccumulator<S64> >& stat )
F64 Recording::getLastValue( const TraceType<EventAccumulator>& stat )
{
update();
return mBuffers->mEvents[stat.getIndex()].getLastValue();
}
U32 Recording::getSampleCount( const TraceType<EventAccumulator<F64> >& stat )
{
update();
return mBuffers->mEventsFloat[stat.getIndex()].getSampleCount();
}
U32 Recording::getSampleCount( const TraceType<EventAccumulator<S64> >& stat )
U32 Recording::getSampleCount( const TraceType<EventAccumulator>& stat )
{
update();
return mBuffers->mEvents[stat.getIndex()].getSampleCount();
@ -667,6 +551,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
///////////////////////////////////////////////////////////////////////

209
indra/llcommon/lltracerecording.h
View File

@ -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;
};
@ -164,121 +161,105 @@ namespace LLTrace
LLUnit<LLUnits::Bytes, F32> getPerSec(const TraceType<MemStatAccumulator>& stat);
// CountStatHandle accessors
F64 getSum(const TraceType<CountAccumulator<F64> >& stat);
S64 getSum(const TraceType<CountAccumulator<S64> >& stat);
F64 getSum(const TraceType<CountAccumulator>& stat);
template <typename T>
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);
F64 getPerSec(const TraceType<CountAccumulator<S64> >& stat);
F64 getPerSec(const TraceType<CountAccumulator>& stat);
template <typename T>
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);
U32 getSampleCount(const TraceType<CountAccumulator<S64> >& stat);
U32 getSampleCount(const TraceType<CountAccumulator>& stat);
// SampleStatHandle accessors
F64 getMin(const TraceType<SampleAccumulator<F64> >& stat);
S64 getMin(const TraceType<SampleAccumulator<S64> >& stat);
F64 getMin(const TraceType<SampleAccumulator>& stat);
template <typename T>
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);
S64 getMax(const TraceType<SampleAccumulator<S64> >& stat);
F64 getMax(const TraceType<SampleAccumulator>& stat);
template <typename T>
T getMax(const SampleStatHandle<T>& stat)
{
return (T)getMax(static_cast<const TraceType<SampleAccumulator<typename LLUnits::HighestPrecisionType<T>::type_t> >&> (stat));
return (T)getMax(static_cast<const TraceType<SampleAccumulator>&> (stat));
}
F64 getMean(const TraceType<SampleAccumulator<F64> >& stat);
F64 getMean(const TraceType<SampleAccumulator<S64> >& stat);
F64 getMean(const TraceType<SampleAccumulator>& stat);
template <typename T>
T getMean(SampleStatHandle<T>& stat)
{
return (T)getMean(static_cast<const TraceType<SampleAccumulator<typename LLUnits::HighestPrecisionType<T>::type_t> >&> (stat));
return (T)getMean(static_cast<const TraceType<SampleAccumulator>&> (stat));
}
F64 getStandardDeviation(const TraceType<SampleAccumulator<F64> >& stat);
F64 getStandardDeviation(const TraceType<SampleAccumulator<S64> >& stat);
F64 getStandardDeviation(const TraceType<SampleAccumulator>& stat);
template <typename T>
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);
S64 getLastValue(const TraceType<SampleAccumulator<S64> >& stat);
F64 getLastValue(const TraceType<SampleAccumulator>& stat);
template <typename T>
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);
U32 getSampleCount(const TraceType<SampleAccumulator<S64> >& stat);
U32 getSampleCount(const TraceType<SampleAccumulator>& stat);
// EventStatHandle accessors
F64 getSum(const TraceType<EventAccumulator<F64> >& stat);
S64 getSum(const TraceType<EventAccumulator<S64> >& stat);
F64 getSum(const TraceType<EventAccumulator>& stat);
template <typename T>
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);
S64 getMin(const TraceType<EventAccumulator<S64> >& stat);
F64 getMin(const TraceType<EventAccumulator>& stat);
template <typename T>
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);
S64 getMax(const TraceType<EventAccumulator<S64> >& stat);
F64 getMax(const TraceType<EventAccumulator>& stat);
template <typename T>
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);
F64 getMean(const TraceType<EventAccumulator<S64> >& stat);
F64 getMean(const TraceType<EventAccumulator>& stat);
template <typename T>
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);
F64 getStandardDeviation(const TraceType<EventAccumulator<S64> >& stat);
F64 getStandardDeviation(const TraceType<EventAccumulator>& stat);
template <typename T>
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);
S64 getLastValue(const TraceType<EventAccumulator<S64> >& stat);
F64 getLastValue(const TraceType<EventAccumulator>& stat);
template <typename T>
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);
U32 getSampleCount(const TraceType<EventAccumulator<S64> >& stat);
U32 getSampleCount(const TraceType<EventAccumulator>& stat);
LLUnit<LLUnits::Seconds, F64> getDuration() const { return LLUnit<LLUnits::Seconds, F64>(mElapsedSeconds); }
@ -335,34 +316,18 @@ namespace LLTrace
return min_val;
}
template <typename T>
T getPeriodMin(const TraceType<SampleAccumulator<T> >& stat, size_t num_periods = U32_MAX)
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)
{
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;
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>
@ -396,34 +361,18 @@ namespace LLTrace
return max_val;
}
template <typename T>
T getPeriodMax(const TraceType<SampleAccumulator<T> >& stat, size_t num_periods = U32_MAX)
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>
T getPeriodMax(const TraceType<EventAccumulator<T> >& stat, size_t num_periods = U32_MAX)
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>
@ -463,62 +412,18 @@ namespace LLTrace
return mean;
}
template <typename T>
typename SampleAccumulator<T>::mean_t getPeriodMean(const TraceType<SampleAccumulator<T> >& stat, size_t num_periods = U32_MAX)
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)
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>

7
indra/llcommon/lltracethreadrecorder.cpp
View File

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

170
indra/llui/llstatbar.cpp
View File

@ -97,9 +97,9 @@ BOOL LLStatBar::handleMouseDown(S32 x, S32 y, MASK mask)
void LLStatBar::draw()
{
F32 current = 0.f,
min = 0.f,
max = 0.f,
mean = 0.f;
min = 0.f,
max = 0.f,
mean = 0.f;
LLTrace::PeriodicRecording& frame_recording = LLTrace::get_frame_recording();
@ -110,35 +110,16 @@ void LLStatBar::draw()
if (mPerSec)
{
current = last_frame_recording.getPerSec(*mCountFloatp);
min = frame_recording.getPeriodMinPerSec(*mCountFloatp, mNumFrames);
max = frame_recording.getPeriodMaxPerSec(*mCountFloatp, mNumFrames);
mean = frame_recording.getPeriodMeanPerSec(*mCountFloatp, mNumFrames);
min = frame_recording.getPeriodMinPerSec(*mCountFloatp, mNumFrames);
max = frame_recording.getPeriodMaxPerSec(*mCountFloatp, mNumFrames);
mean = frame_recording.getPeriodMeanPerSec(*mCountFloatp, mNumFrames);
}
else
{
current = last_frame_recording.getSum(*mCountFloatp);
min = frame_recording.getPeriodMin(*mCountFloatp, mNumFrames);
max = frame_recording.getPeriodMax(*mCountFloatp, mNumFrames);
mean = frame_recording.getPeriodMean(*mCountFloatp, mNumFrames);
}
}
else if (mCountIntp)
{
LLTrace::Recording& last_frame_recording = frame_recording.getLastRecording();
if (mPerSec)
{
current = last_frame_recording.getPerSec(*mCountIntp);
min = frame_recording.getPeriodMinPerSec(*mCountIntp, mNumFrames);
max = frame_recording.getPeriodMaxPerSec(*mCountIntp, mNumFrames);
mean = frame_recording.getPeriodMeanPerSec(*mCountIntp, mNumFrames);
}
else
{
current = last_frame_recording.getSum(*mCountIntp);
min = frame_recording.getPeriodMin(*mCountIntp, mNumFrames);
max = frame_recording.getPeriodMax(*mCountIntp, mNumFrames);
mean = frame_recording.getPeriodMean(*mCountIntp, mNumFrames);
min = frame_recording.getPeriodMin(*mCountFloatp, mNumFrames);
max = frame_recording.getPeriodMax(*mCountFloatp, mNumFrames);
mean = frame_recording.getPeriodMean(*mCountFloatp, mNumFrames);
}
}
else if (mEventFloatp)
@ -146,42 +127,24 @@ void LLStatBar::draw()
LLTrace::Recording& last_frame_recording = frame_recording.getLastRecording();
current = last_frame_recording.getMean(*mEventFloatp);
min = frame_recording.getPeriodMin(*mEventFloatp, mNumFrames);
max = frame_recording.getPeriodMax(*mEventFloatp, mNumFrames);
mean = frame_recording.getPeriodMean(*mEventFloatp, mNumFrames);
}
else if (mEventIntp)
{
LLTrace::Recording& last_frame_recording = frame_recording.getLastRecording();
current = last_frame_recording.getLastValue(*mEventIntp);
min = frame_recording.getPeriodMin(*mEventIntp, mNumFrames);
max = frame_recording.getPeriodMax(*mEventIntp, mNumFrames);
mean = frame_recording.getPeriodMean(*mEventIntp, mNumFrames);
min = frame_recording.getPeriodMin(*mEventFloatp, mNumFrames);
max = frame_recording.getPeriodMax(*mEventFloatp, mNumFrames);
mean = frame_recording.getPeriodMean(*mEventFloatp, mNumFrames);
}
else if (mSampleFloatp)
{
LLTrace::Recording& last_frame_recording = frame_recording.getLastRecording();
current = last_frame_recording.getLastValue(*mSampleFloatp);
min = frame_recording.getPeriodMin(*mSampleFloatp, mNumFrames);
max = frame_recording.getPeriodMax(*mSampleFloatp, mNumFrames);
mean = frame_recording.getPeriodMean(*mSampleFloatp, mNumFrames);
}
else if (mSampleIntp)
{
LLTrace::Recording& last_frame_recording = frame_recording.getLastRecording();
current = last_frame_recording.getLastValue(*mSampleIntp);
min = frame_recording.getPeriodMin(*mSampleIntp, mNumFrames);
max = frame_recording.getPeriodMax(*mSampleIntp, mNumFrames);
mean = frame_recording.getPeriodMean(*mSampleIntp, mNumFrames);
min = frame_recording.getPeriodMin(*mSampleFloatp, mNumFrames);
max = frame_recording.getPeriodMax(*mSampleFloatp, mNumFrames);
mean = frame_recording.getPeriodMean(*mSampleFloatp, mNumFrames);
}
current *= mUnitScale;
min *= mUnitScale;
max *= mUnitScale;
mean *= mUnitScale;
min *= mUnitScale;
max *= mUnitScale;
mean *= mUnitScale;
if ((mUpdatesPerSec == 0.f) || (mUpdateTimer.getElapsedTimeF32() > 1.f/mUpdatesPerSec) || (mValue == 0.f))
{
@ -199,16 +162,16 @@ void LLStatBar::draw()
S32 bar_top, bar_left, bar_right, bar_bottom;
if (mOrientation == HORIZONTAL)
{
bar_top = llmax(5, getRect().getHeight() - 15);
bar_left = 0;
bar_right = getRect().getWidth() - 40;
bar_top = llmax(5, getRect().getHeight() - 15);
bar_left = 0;
bar_right = getRect().getWidth() - 40;
bar_bottom = llmin(bar_top - 5, 0);
}
else // VERTICAL
{
bar_top = llmax(5, getRect().getHeight() - 15);
bar_left = 0;
bar_right = getRect().getWidth();
bar_top = llmax(5, getRect().getHeight() - 15);
bar_left = 0;
bar_right = getRect().getWidth();
bar_bottom = llmin(bar_top - 5, 20);
}
const S32 tick_length = 4;
@ -263,7 +226,7 @@ void LLStatBar::draw()
}
value_format = llformat( "%%.%df", mPrecision);
if (mDisplayBar && (mCountFloatp || mCountIntp || mEventFloatp || mEventIntp || mSampleFloatp || mSampleIntp))
if (mDisplayBar && (mCountFloatp || mEventFloatp || mSampleFloatp))
{
std::string tick_label;
@ -272,7 +235,7 @@ void LLStatBar::draw()
gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
S32 last_tick = 0;
S32 last_label = 0;
const S32 MIN_TICK_SPACING = mOrientation == HORIZONTAL ? 20 : 30;
const S32 MIN_TICK_SPACING = mOrientation == HORIZONTAL ? 20 : 30;
const S32 MIN_LABEL_SPACING = mOrientation == HORIZONTAL ? 40 : 60;
for (F32 tick_value = mMinBar + mTickSpacing; tick_value <= mCurMaxBar; tick_value += mTickSpacing)
{
@ -350,7 +313,7 @@ void LLStatBar::draw()
? (bar_right - bar_left)
: (bar_top - bar_bottom);
if (mDisplayHistory && (mCountFloatp || mCountIntp || mEventFloatp || mEventIntp || mSampleFloatp || mSampleIntp))
if (mDisplayHistory && (mCountFloatp || mEventFloatp || mSampleFloatp))
{
const S32 num_values = frame_recording.getNumPeriods() - 1;
F32 begin = 0;
@ -368,42 +331,22 @@ void LLStatBar::draw()
{
if (mCountFloatp)
{
begin = ((recording.getPerSec(*mCountFloatp) - mMinBar) * value_scale);
end = ((recording.getPerSec(*mCountFloatp) - mMinBar) * value_scale) + 1;
begin = ((recording.getPerSec(*mCountFloatp) - mMinBar) * value_scale);
end = ((recording.getPerSec(*mCountFloatp) - mMinBar) * value_scale) + 1;
num_samples = recording.getSampleCount(*mCountFloatp);
}
else if (mCountIntp)
{
begin = ((recording.getPerSec(*mCountIntp) - mMinBar) * value_scale);
end = ((recording.getPerSec(*mCountIntp) - mMinBar) * value_scale) + 1;
num_samples = recording.getSampleCount(*mCountIntp);
}
else if (mEventFloatp)
{
//rate isn't defined for measurement stats, so use mean
begin = ((recording.getMean(*mEventFloatp) - mMinBar) * value_scale);
end = ((recording.getMean(*mEventFloatp) - mMinBar) * value_scale) + 1;
begin = ((recording.getMean(*mEventFloatp) - mMinBar) * value_scale);
end = ((recording.getMean(*mEventFloatp) - mMinBar) * value_scale) + 1;
num_samples = recording.getSampleCount(*mEventFloatp);
}
else if (mEventIntp)
{
//rate isn't defined for measurement stats, so use mean
begin = ((recording.getMean(*mEventIntp) - mMinBar) * value_scale);
end = ((recording.getMean(*mEventIntp) - mMinBar) * value_scale) + 1;
num_samples = recording.getSampleCount(*mEventIntp);
}
else if (mSampleFloatp)
{
//rate isn't defined for sample stats, so use mean
begin = ((recording.getMean(*mEventFloatp) - mMinBar) * value_scale);
end = ((recording.getMean(*mEventFloatp) - mMinBar) * value_scale) + 1;
num_samples = recording.getSampleCount(*mEventFloatp);
}
else if (mSampleIntp)
{
//rate isn't defined for sample stats, so use mean
begin = ((recording.getMean(*mEventFloatp) - mMinBar) * value_scale);
end = ((recording.getMean(*mEventFloatp) - mMinBar) * value_scale) + 1;
begin = ((recording.getMean(*mEventFloatp) - mMinBar) * value_scale);
end = ((recording.getMean(*mEventFloatp) - mMinBar) * value_scale) + 1;
num_samples = recording.getSampleCount(*mEventFloatp);
}
}
@ -411,41 +354,23 @@ void LLStatBar::draw()
{
if (mCountFloatp)
{
begin = ((recording.getSum(*mCountFloatp) - mMinBar) * value_scale);
end = ((recording.getSum(*mCountFloatp) - mMinBar) * value_scale) + 1;
begin = ((recording.getSum(*mCountFloatp) - mMinBar) * value_scale);
end = ((recording.getSum(*mCountFloatp) - mMinBar) * value_scale) + 1;
num_samples = recording.getSampleCount(*mCountFloatp);
}
else if (mCountIntp)
{
begin = ((recording.getSum(*mCountIntp) - mMinBar) * value_scale);
end = ((recording.getSum(*mCountIntp) - mMinBar) * value_scale) + 1;
num_samples = recording.getSampleCount(*mCountIntp);
}
else if (mEventFloatp)
{
begin = ((recording.getMean(*mEventFloatp) - mMinBar) * value_scale);
end = ((recording.getMean(*mEventFloatp) - mMinBar) * value_scale) + 1;
begin = ((recording.getMean(*mEventFloatp) - mMinBar) * value_scale);
end = ((recording.getMean(*mEventFloatp) - mMinBar) * value_scale) + 1;
num_samples = recording.getSampleCount(*mEventFloatp);
}
else if (mEventIntp)
{
begin = ((recording.getMean(*mEventIntp) - mMinBar) * value_scale);
end = ((recording.getMean(*mEventIntp) - mMinBar) * value_scale) + 1;
num_samples = recording.getSampleCount(*mEventIntp);
}
else if (mSampleFloatp)
{
begin = ((recording.getMean(*mEventFloatp) - mMinBar) * value_scale);
end = ((recording.getMean(*mEventFloatp) - mMinBar) * value_scale) + 1;
begin = ((recording.getMean(*mEventFloatp) - mMinBar) * value_scale);
end = ((recording.getMean(*mEventFloatp) - mMinBar) * value_scale) + 1;
num_samples = recording.getSampleCount(*mEventFloatp);
}
else if (mSampleIntp)
{
begin = ((recording.getMean(*mEventFloatp) - mMinBar) * value_scale);
end = ((recording.getMean(*mEventFloatp) - mMinBar) * value_scale) + 1;
num_samples = recording.getSampleCount(*mEventFloatp);
}
}
}
if (!num_samples) continue;
@ -501,20 +426,17 @@ void LLStatBar::draw()
void LLStatBar::setStat(const std::string& stat_name)
{
mCountFloatp = LLTrace::CountStatHandle<>::getInstance(stat_name);
mCountIntp = LLTrace::CountStatHandle<S64>::getInstance(stat_name);
mEventFloatp = LLTrace::EventStatHandle<>::getInstance(stat_name);
mEventIntp = LLTrace::EventStatHandle<S64>::getInstance(stat_name);
mSampleFloatp = LLTrace::SampleStatHandle<>::getInstance(stat_name);
mSampleIntp = LLTrace::SampleStatHandle<S64>::getInstance(stat_name);
mCountFloatp = LLTrace::TraceType<LLTrace::CountAccumulator>::getInstance(stat_name);
mEventFloatp = LLTrace::TraceType<LLTrace::EventAccumulator>::getInstance(stat_name);
mSampleFloatp = LLTrace::TraceType<LLTrace::SampleAccumulator>::getInstance(stat_name);
}
void LLStatBar::setRange(F32 bar_min, F32 bar_max, F32 tick_spacing)
{
mMinBar = bar_min;
mMaxBar = bar_max;
mTickSpacing = tick_spacing;
mMinBar = bar_min;
mMaxBar = bar_max;
mTickSpacing = tick_spacing;
}
LLRect LLStatBar::getRequiredRect()

9
indra/llui/llstatbar.h
View File

@ -111,12 +111,9 @@ private:
bool mScaleRange;
EOrientation mOrientation;
LLTrace::TraceType<LLTrace::CountAccumulator<F64> >* mCountFloatp;
LLTrace::TraceType<LLTrace::CountAccumulator<S64> >* mCountIntp;
LLTrace::TraceType<LLTrace::EventAccumulator<F64> >* mEventFloatp;
LLTrace::TraceType<LLTrace::EventAccumulator<S64> >* mEventIntp;
LLTrace::TraceType<LLTrace::SampleAccumulator<F64> >* mSampleFloatp;
LLTrace::TraceType<LLTrace::SampleAccumulator<S64> >* mSampleIntp;
LLTrace::TraceType<LLTrace::CountAccumulator>* mCountFloatp;
LLTrace::TraceType<LLTrace::EventAccumulator>* mEventFloatp;
LLTrace::TraceType<LLTrace::SampleAccumulator>* mSampleFloatp;
LLFrameTimer mUpdateTimer;
LLUIString mLabel;

16
indra/llui/llstatgraph.cpp
View File

@ -47,8 +47,7 @@ LLStatGraph::LLStatGraph(const Params& p)
mPerSec(true),
mPrecision(p.precision),
mValue(p.value),
mNewStatFloatp(p.stat.count_stat_float),
mNewStatIntp(p.stat.count_stat_int)
mNewStatFloatp(p.stat.count_stat_float)
{
setToolTip(p.name());
@ -77,19 +76,6 @@ void LLStatGraph::draw()
mValue = recording.getSum(*mNewStatFloatp);
}
}
else if (mNewStatIntp)
{
LLTrace::Recording& recording = LLTrace::get_frame_recording().getLastRecording();
if (mPerSec)
{
mValue = recording.getPerSec(*mNewStatIntp);
}
else
{
mValue = recording.getSum(*mNewStatIntp);
}
}
frac = (mValue - mMin) / range;
frac = llmax(0.f, frac);

12
indra/llui/llstatgraph.h
View File

@ -57,12 +57,9 @@ public:
struct StatParams : public LLInitParam::ChoiceBlock<StatParams>
{
Alternative<LLTrace::TraceType<LLTrace::CountAccumulator<F64> >* > count_stat_float;
Alternative<LLTrace::TraceType<LLTrace::CountAccumulator<S64> >* > count_stat_int;
Alternative<LLTrace::TraceType<LLTrace::EventAccumulator<F64> >* > event_stat_float;
Alternative<LLTrace::TraceType<LLTrace::EventAccumulator<S64> >* > event_stat_int;
Alternative<LLTrace::TraceType<LLTrace::SampleAccumulator<F64> >* > sample_stat_float;
Alternative<LLTrace::TraceType<LLTrace::SampleAccumulator<S64> >* > sample_stat_int;
Alternative<LLTrace::TraceType<LLTrace::CountAccumulator>* > count_stat_float;
Alternative<LLTrace::TraceType<LLTrace::EventAccumulator>* > event_stat_float;
Alternative<LLTrace::TraceType<LLTrace::SampleAccumulator>* > sample_stat_float;
};
struct Params : public LLInitParam::Block<Params, LLView::Params>
@ -107,8 +104,7 @@ public:
/*virtual*/ void setValue(const LLSD& value);
private:
LLTrace::TraceType<LLTrace::CountAccumulator<F64> >* mNewStatFloatp;
LLTrace::TraceType<LLTrace::CountAccumulator<S64> >* mNewStatIntp;
LLTrace::TraceType<LLTrace::CountAccumulator>* mNewStatFloatp;
BOOL mPerSec;

36
indra/newview/llscenemonitor.cpp
View File

@ -493,6 +493,7 @@ void LLSceneMonitor::fetchQueryResult()
//dump results to a file _scene_xmonitor_results.csv
void LLSceneMonitor::dumpToFile(std::string file_name)
{
using namespace LLTrace;
if (!hasResults()) return;
LL_INFOS("SceneMonitor") << "Saving scene load stats to " << file_name << LL_ENDL;
@ -501,7 +502,7 @@ void LLSceneMonitor::dumpToFile(std::string file_name)
os << std::setprecision(4);
LLTrace::PeriodicRecording& scene_load_recording = mSceneLoadRecording.getAcceptedRecording();
PeriodicRecording& scene_load_recording = mSceneLoadRecording.getAcceptedRecording();
U32 frame_count = scene_load_recording.getNumPeriods();
LLUnit<LLUnits::Seconds, F64> frame_time;
@ -514,7 +515,7 @@ void LLSceneMonitor::dumpToFile(std::string file_name)
}
os << std::endl;
for (LLTrace::CountStatHandle<F64>::instance_iter it = LLTrace::CountStatHandle<F64>::beginInstances(), end_it = LLTrace::CountStatHandle<F64>::endInstances();
for (CountStatHandle<F64>::instance_iter it = CountStatHandle<F64>::beginInstances(), end_it = CountStatHandle<F64>::endInstances();
it != end_it;
++it)
{
@ -537,7 +538,7 @@ void LLSceneMonitor::dumpToFile(std::string file_name)
}
}
for (LLTrace::CountStatHandle<S64>::instance_iter it = LLTrace::CountStatHandle<S64>::beginInstances(), end_it = LLTrace::CountStatHandle<S64>::endInstances();
for (CountStatHandle<S64>::instance_iter it = CountStatHandle<S64>::beginInstances(), end_it = CountStatHandle<S64>::endInstances();
it != end_it;
++it)
{
@ -560,7 +561,7 @@ void LLSceneMonitor::dumpToFile(std::string file_name)
}
}
for (LLTrace::EventStatHandle<F64>::instance_iter it = LLTrace::EventStatHandle<F64>::beginInstances(), end_it = LLTrace::EventStatHandle<F64>::endInstances();
for (EventStatHandle<F64>::instance_iter it = EventStatHandle<F64>::beginInstances(), end_it = EventStatHandle<F64>::endInstances();
it != end_it;
++it)
{
@ -583,7 +584,7 @@ void LLSceneMonitor::dumpToFile(std::string file_name)
}
}
for (LLTrace::EventStatHandle<S64>::instance_iter it = LLTrace::EventStatHandle<S64>::beginInstances(), end_it = LLTrace::EventStatHandle<S64>::endInstances();
for (EventStatHandle<S64>::instance_iter it = EventStatHandle<S64>::beginInstances(), end_it = EventStatHandle<S64>::endInstances();
it != end_it;
++it)
{
@ -606,30 +607,7 @@ void LLSceneMonitor::dumpToFile(std::string file_name)
}
}
for (LLTrace::SampleStatHandle<F64>::instance_iter it = LLTrace::SampleStatHandle<F64>::beginInstances(), end_it = LLTrace::SampleStatHandle<F64>::endInstances();
it != end_it;
++it)
{
std::ostringstream row;
row << it->getName();
S32 samples = 0;
for (S32 i = frame_count - 1; i >= 0; --i)
{
samples += scene_load_recording.getPrevRecording(i).getSampleCount(*it);
row << ", " << scene_load_recording.getPrevRecording(i).getMean(*it);
}
row << std::endl;
if (samples > 0)
{
os << row.str();
}
}
for (LLTrace::SampleStatHandle<S64>::instance_iter it = LLTrace::SampleStatHandle<S64>::beginInstances(), end_it = LLTrace::SampleStatHandle<S64>::endInstances();
for (TraceType<SampleAccumulator>::instance_iter it = TraceType<SampleAccumulator>::beginInstances(), end_it = TraceType<SampleAccumulator>::endInstances();
it != end_it;
++it)
{