diff --git a/indra/llcommon/CMakeLists.txt b/indra/llcommon/CMakeLists.txt
index d876842cf127c5460ce00c2a9e5bb79e33b5725a..0f5ded86edd207f66e8a1fd5b2f9ee247d5181d3 100644
--- a/indra/llcommon/CMakeLists.txt
+++ b/indra/llcommon/CMakeLists.txt
@@ -91,7 +91,6 @@ set(llcommon_SOURCE_FILES
llsdutil.cpp
llsecondlifeurls.cpp
llsingleton.cpp
- llstat.cpp
llstacktrace.cpp
llstreamqueue.cpp
llstreamtools.cpp
@@ -234,7 +233,6 @@ set(llcommon_HEADER_FILES
llsortedvector.h
llstack.h
llstacktrace.h
- llstat.h
llstatenums.h
llstl.h
llstreamqueue.h
diff --git a/indra/llcommon/llinstancetracker.h b/indra/llcommon/llinstancetracker.h
index 403df08990e48c3db81e81ad037ec91a74223e98..3a1187a4c132c117e72eeb959a87667c1a033979 100644
--- a/indra/llcommon/llinstancetracker.h
+++ b/indra/llcommon/llinstancetracker.h
@@ -77,8 +77,8 @@ class LL_COMMON_API LLInstanceTrackerBase : public boost::noncopyable
/// This mix-in class adds support for tracking all instances of the specified class parameter T
/// The (optional) key associates a value of type KEY with a given instance of T, for quick lookup
/// If KEY is not provided, then instances are stored in a simple set
-/// @NOTE: see explicit specialization below for default KEY==T* case
-template<typename T, typename KEY = T*>
+/// @NOTE: see explicit specialization below for default KEY==void case
+template<typename T, typename KEY = void>
class LLInstanceTracker : public LLInstanceTrackerBase
{
typedef LLInstanceTracker<T, KEY> MyT;
@@ -224,12 +224,12 @@ class LLInstanceTracker : public LLInstanceTrackerBase
KEY mInstanceKey;
};
-/// explicit specialization for default case where KEY is T*
+/// explicit specialization for default case where KEY is void
/// use a simple std::set<T*>
template<typename T>
-class LLInstanceTracker<T, T*> : public LLInstanceTrackerBase
+class LLInstanceTracker<T, void> : public LLInstanceTrackerBase
{
- typedef LLInstanceTracker<T, T*> MyT;
+ typedef LLInstanceTracker<T, void> MyT;
typedef typename std::set<T*> InstanceSet;
struct StaticData: public StaticBase
{
diff --git a/indra/llcommon/llmetricperformancetester.cpp b/indra/llcommon/llmetricperformancetester.cpp
index 41d3eb0bf369881da267876ef9224e7bcfaf9446..a1b0a684c5c86faf89d967bcc6a4a15f7896f711 100644
--- a/indra/llcommon/llmetricperformancetester.cpp
+++ b/indra/llcommon/llmetricperformancetester.cpp
@@ -29,7 +29,6 @@
#include "indra_constants.h"
#include "llerror.h"
#include "llsdserialize.h"
-#include "llstat.h"
#include "lltreeiterators.h"
#include "llmetricperformancetester.h"
diff --git a/indra/llcommon/llpredicate.h b/indra/llcommon/llpredicate.h
index 3f1bf1c8e6ee7259ed3bf10a42911d568f23a20e..75744667d97fdb9bf6b32220cf475047130771ce 100644
--- a/indra/llcommon/llpredicate.h
+++ b/indra/llcommon/llpredicate.h
@@ -165,6 +165,10 @@ namespace LLPredicate
: Literal(e)
{}
+ Value(const Literal other)
+ : Literal(other)
+ {}
+
Value()
{}
};
diff --git a/indra/llcommon/llstat.cpp b/indra/llcommon/llstat.cpp
deleted file mode 100644
index b46d2e58b2bbb7cbfbef9b408c59e0fe06f2ca42..0000000000000000000000000000000000000000
--- a/indra/llcommon/llstat.cpp
+++ /dev/null
@@ -1,352 +0,0 @@
-/**
- * @file llstat.cpp
- *
- * $LicenseInfo:firstyear=2001&license=viewerlgpl$
- * Second Life Viewer Source Code
- * Copyright (C) 2010, Linden Research, Inc.
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation;
- * version 2.1 of the License only.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- *
- * Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA
- * $/LicenseInfo$
- */
-
-#include "linden_common.h"
-
-#include "llstat.h"
-#include "lllivefile.h"
-#include "llerrorcontrol.h"
-#include "llframetimer.h"
-#include "timing.h"
-#include "llsd.h"
-#include "llsdserialize.h"
-#include "llstl.h"
-#include "u64.h"
-
-
-// statics
-//------------------------------------------------------------------------
-LLTimer LLStat::sTimer;
-LLFrameTimer LLStat::sFrameTimer;
-
-void LLStat::reset()
-{
- mNumValues = 0;
- mLastValue = 0.f;
- delete[] mBins;
- mBins = new ValueEntry[mNumBins];
- mCurBin = mNumBins-1;
- mNextBin = 0;
-}
-
-LLStat::LLStat(std::string name, BOOL use_frame_timer)
-: LLInstanceTracker<LLStat, std::string>(name),
- mUseFrameTimer(use_frame_timer),
- mNumBins(50),
- mName(name),
- mBins(NULL)
-{
- llassert(mNumBins > 0);
- mLastTime = 0.f;
-
- reset();
-}
-
-LLStat::~LLStat()
-{
- delete[] mBins;
-}
-//
-//void LLStat::start()
-//{
-// if (mUseFrameTimer)
-// {
-// mBins[mNextBin].mBeginTime = sFrameTimer.getElapsedSeconds();
-// }
-// else
-// {
-// mBins[mNextBin].mBeginTime = sTimer.getElapsedTimeF64();
-// }
-//}
-
-void LLStat::addValue(const F32 value)
-{
- if (mNumValues < mNumBins)
- {
- mNumValues++;
- }
-
- // Increment the bin counters.
- mCurBin++;
- if (mCurBin >= mNumBins)
- {
- mCurBin = 0;
- }
- mNextBin++;
- if (mNextBin >= mNumBins)
- {
- mNextBin = 0;
- }
-
- mBins[mCurBin].mValue = value;
- if (mUseFrameTimer)
- {
- mBins[mCurBin].mTime = sFrameTimer.getElapsedSeconds();
- }
- else
- {
- mBins[mCurBin].mTime = sTimer.getElapsedTimeF64();
- }
- mBins[mCurBin].mDT = (F32)(mBins[mCurBin].mTime - mBins[mCurBin].mBeginTime);
-
- //this value is used to prime the min/max calls
- mLastTime = mBins[mCurBin].mTime;
- mLastValue = value;
-
- // Set the begin time for the next stat segment.
- mBins[mNextBin].mBeginTime = mBins[mCurBin].mTime;
- mBins[mNextBin].mTime = mBins[mCurBin].mTime;
- mBins[mNextBin].mDT = 0.f;
-}
-
-
-F32 LLStat::getMax() const
-{
- S32 i;
- F32 current_max = mLastValue;
- if (mNumBins == 0)
- {
- current_max = 0.f;
- }
- else
- {
- for (i = 0; (i < mNumBins) && (i < mNumValues); i++)
- {
- // Skip the bin we're currently filling.
- if (i == mNextBin)
- {
- continue;
- }
- if (mBins[i].mValue > current_max)
- {
- current_max = mBins[i].mValue;
- }
- }
- }
- return current_max;
-}
-
-F32 LLStat::getMean() const
-{
- S32 i;
- F32 current_mean = 0.f;
- S32 samples = 0;
- for (i = 0; (i < mNumBins) && (i < mNumValues); i++)
- {
- // Skip the bin we're currently filling.
- if (i == mNextBin)
- {
- continue;
- }
- current_mean += mBins[i].mValue;
- samples++;
- }
-
- // There will be a wrap error at 2^32. :)
- if (samples != 0)
- {
- current_mean /= samples;
- }
- else
- {
- current_mean = 0.f;
- }
- return current_mean;
-}
-
-F32 LLStat::getMin() const
-{
- S32 i;
- F32 current_min = mLastValue;
-
- if (mNumBins == 0)
- {
- current_min = 0.f;
- }
- else
- {
- for (i = 0; (i < mNumBins) && (i < mNumValues); i++)
- {
- // Skip the bin we're currently filling.
- if (i == mNextBin)
- {
- continue;
- }
- if (mBins[i].mValue < current_min)
- {
- current_min = mBins[i].mValue;
- }
- }
- }
- return current_min;
-}
-
-F32 LLStat::getPrev(S32 age) const
-{
- S32 bin;
- bin = mCurBin - age;
-
- while (bin < 0)
- {
- bin += mNumBins;
- }
-
- if (bin == mNextBin)
- {
- // Bogus for bin we're currently working on.
- return 0.f;
- }
- return mBins[bin].mValue;
-}
-
-F32 LLStat::getPrevPerSec(S32 age) const
-{
- S32 bin;
- bin = mCurBin - age;
-
- while (bin < 0)
- {
- bin += mNumBins;
- }
-
- if (bin == mNextBin)
- {
- // Bogus for bin we're currently working on.
- return 0.f;
- }
- return mBins[bin].mValue / mBins[bin].mDT;
-}
-
-F32 LLStat::getCurrent() const
-{
- return mBins[mCurBin].mValue;
-}
-
-F32 LLStat::getCurrentPerSec() const
-{
- return mBins[mCurBin].mValue / mBins[mCurBin].mDT;
-}
-
-F32 LLStat::getMeanPerSec() const
-{
- S32 i;
- F32 value = 0.f;
- F32 dt = 0.f;
-
- for (i = 0; (i < mNumBins) && (i < mNumValues); i++)
- {
- // Skip the bin we're currently filling.
- if (i == mNextBin)
- {
- continue;
- }
- value += mBins[i].mValue;
- dt += mBins[i].mDT;
- }
-
- if (dt > 0.f)
- {
- return value/dt;
- }
- else
- {
- return 0.f;
- }
-}
-
-F32 LLStat::getMaxPerSec() const
-{
- F32 value;
-
- if (mNextBin != 0)
- {
- value = mBins[0].mValue/mBins[0].mDT;
- }
- else if (mNumValues > 0)
- {
- value = mBins[1].mValue/mBins[1].mDT;
- }
- else
- {
- value = 0.f;
- }
-
- for (S32 i = 0; (i < mNumBins) && (i < mNumValues); i++)
- {
- // Skip the bin we're currently filling.
- if (i == mNextBin)
- {
- continue;
- }
- value = llmax(value, mBins[i].mValue/mBins[i].mDT);
- }
- return value;
-}
-
-F32 LLStat::getMinPerSec() const
-{
- S32 i;
- F32 value;
-
- if (mNextBin != 0)
- {
- value = mBins[0].mValue/mBins[0].mDT;
- }
- else if (mNumValues > 0)
- {
- value = mBins[1].mValue/mBins[0].mDT;
- }
- else
- {
- value = 0.f;
- }
-
- for (i = 0; (i < mNumBins) && (i < mNumValues); i++)
- {
- // Skip the bin we're currently filling.
- if (i == mNextBin)
- {
- continue;
- }
- value = llmin(value, mBins[i].mValue/mBins[i].mDT);
- }
- return value;
-}
-
-U32 LLStat::getNumValues() const
-{
- return mNumValues;
-}
-
-S32 LLStat::getNumBins() const
-{
- return mNumBins;
-}
-
-S32 LLStat::getNextBin() const
-{
- return mNextBin;
-}
-
diff --git a/indra/llcommon/llstat.h b/indra/llcommon/llstat.h
deleted file mode 100644
index 82a246275d5f2f16f1bb608e83cba5fe728f3275..0000000000000000000000000000000000000000
--- a/indra/llcommon/llstat.h
+++ /dev/null
@@ -1,103 +0,0 @@
-/**
- * @file llstat.h
- * @brief Runtime statistics accumulation.
- *
- * $LicenseInfo:firstyear=2001&license=viewerlgpl$
- * Second Life Viewer Source Code
- * Copyright (C) 2010, Linden Research, Inc.
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation;
- * version 2.1 of the License only.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- *
- * Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA
- * $/LicenseInfo$
- */
-
-#ifndef LL_LLSTAT_H
-#define LL_LLSTAT_H
-
-#include <map>
-
-#include "lltimer.h"
-#include "llframetimer.h"
-#include "llinstancetracker.h"
-
-class LLSD;
-
-// ----------------------------------------------------------------------------
-class LL_COMMON_API LLStat : public LLInstanceTracker<LLStat, std::string>
-{
-public:
- LLStat(std::string name = std::string(), BOOL use_frame_timer = FALSE);
- ~LLStat();
-
- //void start(); // Start the timer for the current "frame", otherwise uses the time tracked from
- // the last addValue
- void reset();
- void addValue(const F32 value = 1.f); // Adds the current value being tracked, and tracks the DT.
- void addValue(const S32 value) { addValue((F32)value); }
- void addValue(const U32 value) { addValue((F32)value); }
-
- S32 getNextBin() const;
-
- F32 getPrev(S32 age) const; // Age is how many "addValues" previously - zero is current
- F32 getPrevPerSec(S32 age) const; // Age is how many "addValues" previously - zero is current
-
- F32 getCurrent() const;
- F32 getCurrentPerSec() const;
-
- F32 getMin() const;
- F32 getMinPerSec() const;
-
- F32 getMean() const;
- F32 getMeanPerSec() const;
-
- F32 getMax() const;
- F32 getMaxPerSec() const;
-
- U32 getNumValues() const;
- S32 getNumBins() const;
-
-private:
- bool mUseFrameTimer;
- U32 mNumValues;
- U32 mNumBins;
- F32 mLastValue;
- F64 mLastTime;
-
- struct ValueEntry
- {
- ValueEntry()
- : mValue(0.f),
- mBeginTime(0.0),
- mTime(0.0),
- mDT(0.f)
- {}
- F32 mValue;
- F64 mBeginTime;
- F64 mTime;
- F32 mDT;
- };
- ValueEntry* mBins;
-
- S32 mCurBin;
- S32 mNextBin;
-
- std::string mName;
-
- static LLTimer sTimer;
- static LLFrameTimer sFrameTimer;
-};
-
-#endif // LL_STAT_
diff --git a/indra/llcommon/lltrace.h b/indra/llcommon/lltrace.h
index 2cdae4b0d266037ff163485e6417182b288e6b25..2823db5cbbaf972adfe05aa01e1e8f79cd317e31 100644
--- a/indra/llcommon/lltrace.h
+++ b/indra/llcommon/lltrace.h
@@ -227,10 +227,33 @@ namespace LLTrace
};
+ template<typename T, typename IS_UNIT = void>
+ struct StorageType
+ {
+ typedef T type_t;
+ };
+
+ template<typename T>
+ struct StorageType<T, typename T::is_unit_tag_t>
+ {
+ typedef typename StorageType<typename T::storage_t>::type_t type_t;
+ };
+
+ template<> struct StorageType<F32> { typedef F64 type_t; };
+ template<> struct StorageType<S32> { typedef S64 type_t; };
+ template<> struct StorageType<U32> { typedef S64 type_t; };
+ template<> struct StorageType<S16> { typedef S64 type_t; };
+ template<> struct StorageType<U16> { typedef S64 type_t; };
+ template<> struct StorageType<S8> { typedef S64 type_t; };
+ template<> struct StorageType<U8> { typedef S64 type_t; };
+
template<typename T>
class LL_COMMON_API MeasurementAccumulator
{
public:
+ typedef T value_t;
+ typedef MeasurementAccumulator<T> self_t;
+
MeasurementAccumulator()
: mSum(0),
mMin(std::numeric_limits<T>::max()),
@@ -243,23 +266,24 @@ namespace LLTrace
LL_FORCE_INLINE void sample(T value)
{
+ T storage_value(value);
mNumSamples++;
- mSum += value;
- if (value < mMin)
+ mSum += storage_value;
+ if (storage_value < mMin)
{
- mMin = value;
+ mMin = storage_value;
}
- else if (value > mMax)
+ if (storage_value > mMax)
{
- mMax = value;
+ mMax = storage_value;
}
F64 old_mean = mMean;
- mMean += ((F64)value - old_mean) / (F64)mNumSamples;
- mVarianceSum += ((F64)value - old_mean) * ((F64)value - mMean);
- mLastValue = value;
+ mMean += ((F64)storage_value - old_mean) / (F64)mNumSamples;
+ mVarianceSum += ((F64)storage_value - old_mean) * ((F64)storage_value - mMean);
+ mLastValue = storage_value;
}
- void addSamples(const MeasurementAccumulator<T>& other)
+ void addSamples(const self_t& other)
{
mSum += other.mSum;
if (other.mMin < mMin)
@@ -293,7 +317,7 @@ namespace LLTrace
}
else
{
- mVarianceSum = (F32)mNumSamples
+ mVarianceSum = (F64)mNumSamples
* ((((n_1 - 1.f) * sd_1 * sd_1)
+ ((n_2 - 1.f) * sd_2 * sd_2)
+ (((n_1 * n_2) / (n_1 + n_2))
@@ -311,10 +335,10 @@ namespace LLTrace
mMax = 0;
}
- T getSum() const { return mSum; }
- T getMin() const { return mMin; }
- T getMax() const { return mMax; }
- T getLastValue() const { return mLastValue; }
+ T getSum() const { return (T)mSum; }
+ T getMin() const { return (T)mMin; }
+ T getMax() const { return (T)mMax; }
+ T getLastValue() const { return (T)mLastValue; }
F64 getMean() const { return mMean; }
F64 getStandardDeviation() const { return sqrtf(mVarianceSum / mNumSamples); }
U32 getSampleCount() const { return mNumSamples; }
@@ -325,7 +349,7 @@ namespace LLTrace
mMax,
mLastValue;
- F64 mMean,
+ F64 mMean,
mVarianceSum;
U32 mNumSamples;
@@ -335,6 +359,8 @@ namespace LLTrace
class LL_COMMON_API CountAccumulator
{
public:
+ typedef T value_t;
+
CountAccumulator()
: mSum(0),
mNumSamples(0)
@@ -358,7 +384,7 @@ namespace LLTrace
mSum = 0;
}
- T getSum() const { return mSum; }
+ T getSum() const { return (T)mSum; }
private:
T mSum;
@@ -366,14 +392,15 @@ namespace LLTrace
U32 mNumSamples;
};
- typedef TraceType<MeasurementAccumulator<F64> > measurement_common_t;
+ typedef TraceType<MeasurementAccumulator<F64> > measurement_common_float_t;
+ typedef TraceType<MeasurementAccumulator<S64> > measurement_common_int_t;
template <typename T = F64, typename IS_UNIT = void>
class LL_COMMON_API Measurement
- : public TraceType<MeasurementAccumulator<T> >
+ : public TraceType<MeasurementAccumulator<typename StorageType<T>::type_t> >
{
public:
- typedef T storage_t;
+ typedef typename StorageType<T>::type_t storage_t;
Measurement(const char* name, const char* description = NULL)
: TraceType(name, description)
@@ -381,17 +408,16 @@ namespace LLTrace
void sample(T value)
{
- getPrimaryAccumulator().sample(value);
+ getPrimaryAccumulator().sample((storage_t)value);
}
};
template <typename T>
class LL_COMMON_API Measurement <T, typename T::is_unit_tag_t>
- : public TraceType<MeasurementAccumulator<typename T::storage_t> >
+ : public TraceType<MeasurementAccumulator<typename StorageType<typename T::storage_t>::type_t> >
{
public:
- typedef typename T::storage_t storage_t;
- typedef Measurement<typename T::storage_t> base_measurement_t;
+ typedef typename StorageType<typename T::storage_t>::type_t storage_t;
Measurement(const char* name, const char* description = NULL)
: TraceType(name, description)
@@ -402,18 +428,19 @@ namespace LLTrace
{
T converted_value;
converted_value.assignFrom(value);
- getPrimaryAccumulator().sample(converted_value.value());
+ getPrimaryAccumulator().sample((storage_t)converted_value.value());
}
};
- typedef TraceType<CountAccumulator<F64> > count_common_t;
+ typedef TraceType<CountAccumulator<F64> > count_common_float_t;
+ typedef TraceType<CountAccumulator<S64> > count_common_int_t;
template <typename T = F64, typename IS_UNIT = void>
class LL_COMMON_API Count
- : public TraceType<CountAccumulator<T> >
+ : public TraceType<CountAccumulator<typename StorageType<T>::type_t> >
{
public:
- typedef T storage_t;
+ typedef typename StorageType<T>::type_t storage_t;
Count(const char* name, const char* description = NULL)
: TraceType(name)
@@ -421,17 +448,16 @@ namespace LLTrace
void add(T value)
{
- getPrimaryAccumulator().add(value);
+ getPrimaryAccumulator().add((storage_t)value);
}
};
template <typename T>
class LL_COMMON_API Count <T, typename T::is_unit_tag_t>
- : public TraceType<CountAccumulator<typename T::storage_t> >
+ : public TraceType<CountAccumulator<typename StorageType<typename T::storage_t>::type_t> >
{
public:
- typedef typename T::storage_t storage_t;
- typedef Count<typename T::storage_t> base_count_t;
+ typedef typename StorageType<typename T::storage_t>::type_t storage_t;
Count(const char* name, const char* description = NULL)
: TraceType(name)
@@ -442,7 +468,7 @@ namespace LLTrace
{
T converted_value;
converted_value.assignFrom(value);
- getPrimaryAccumulator().add(converted_value.value());
+ getPrimaryAccumulator().add((storage_t)converted_value.value());
}
};
diff --git a/indra/llcommon/lltracerecording.cpp b/indra/llcommon/lltracerecording.cpp
index 9a769ff344b0ad2611187fde47cd70350a53d1c7..f44a0a27644d6132a52436bdc36e03faa96be06f 100644
--- a/indra/llcommon/lltracerecording.cpp
+++ b/indra/llcommon/lltracerecording.cpp
@@ -39,8 +39,10 @@ namespace LLTrace
Recording::Recording()
: mElapsedSeconds(0),
- mCounts(new AccumulatorBuffer<CountAccumulator<F64> >()),
- mMeasurements(new AccumulatorBuffer<MeasurementAccumulator<F64> >()),
+ mCountsFloat(new AccumulatorBuffer<CountAccumulator<F64> >()),
+ mMeasurementsFloat(new AccumulatorBuffer<MeasurementAccumulator<F64> >()),
+ mCounts(new AccumulatorBuffer<CountAccumulator<S64> >()),
+ mMeasurements(new AccumulatorBuffer<MeasurementAccumulator<S64> >()),
mStackTimers(new AccumulatorBuffer<TimerAccumulator>())
{}
@@ -59,6 +61,8 @@ void Recording::update()
void Recording::handleReset()
{
+ mCountsFloat.write()->reset();
+ mMeasurementsFloat.write()->reset();
mCounts.write()->reset();
mMeasurements.write()->reset();
mStackTimers.write()->reset();
@@ -88,6 +92,8 @@ void Recording::handleSplitTo(Recording& other)
void Recording::makePrimary()
{
+ mCountsFloat.write()->makePrimary();
+ mMeasurementsFloat.write()->makePrimary();
mCounts.write()->makePrimary();
mMeasurements.write()->makePrimary();
mStackTimers.write()->makePrimary();
@@ -100,14 +106,120 @@ bool Recording::isPrimary() const
void Recording::mergeRecording( const Recording& other )
{
+ mCountsFloat.write()->addSamples(*other.mCountsFloat);
+ mMeasurementsFloat.write()->addSamples(*other.mMeasurementsFloat);
mCounts.write()->addSamples(*other.mCounts);
mMeasurements.write()->addSamples(*other.mMeasurements);
mStackTimers.write()->addSamples(*other.mStackTimers);
mElapsedSeconds += other.mElapsedSeconds;
}
+F64 Recording::getSum( const TraceType<CountAccumulator<F64> >& stat ) const
+{
+ return stat.getAccumulator(mCountsFloat).getSum();
+}
+
+S64 Recording::getSum( const TraceType<CountAccumulator<S64> >& stat ) const
+{
+ return stat.getAccumulator(mCounts).getSum();
+}
+
+F64 Recording::getSum( const TraceType<MeasurementAccumulator<F64> >& stat ) const
+{
+ return (F64)stat.getAccumulator(mMeasurementsFloat).getSum();
+}
+
+S64 Recording::getSum( const TraceType<MeasurementAccumulator<S64> >& stat ) const
+{
+ return (S64)stat.getAccumulator(mMeasurements).getSum();
+}
+
+
+
+F64 Recording::getPerSec( const TraceType<CountAccumulator<F64> >& stat ) const
+{
+ return stat.getAccumulator(mCountsFloat).getSum() / mElapsedSeconds;
+}
+
+F64 Recording::getPerSec( const TraceType<CountAccumulator<S64> >& stat ) const
+{
+ return (F64)stat.getAccumulator(mCounts).getSum() / mElapsedSeconds;
+}
+
+F64 Recording::getPerSec( const TraceType<MeasurementAccumulator<F64> >& stat ) const
+{
+ return stat.getAccumulator(mMeasurementsFloat).getSum() / mElapsedSeconds;
+}
+
+F64 Recording::getPerSec( const TraceType<MeasurementAccumulator<S64> >& stat ) const
+{
+ return (F64)stat.getAccumulator(mMeasurements).getSum() / mElapsedSeconds;
+}
+
+F64 Recording::getMin( const TraceType<MeasurementAccumulator<F64> >& stat ) const
+{
+ return stat.getAccumulator(mMeasurementsFloat).getMin();
+}
+
+S64 Recording::getMin( const TraceType<MeasurementAccumulator<S64> >& stat ) const
+{
+ return stat.getAccumulator(mMeasurements).getMin();
+}
+
+F64 Recording::getMax( const TraceType<MeasurementAccumulator<F64> >& stat ) const
+{
+ return stat.getAccumulator(mMeasurementsFloat).getMax();
+}
+
+S64 Recording::getMax( const TraceType<MeasurementAccumulator<S64> >& stat ) const
+{
+ return stat.getAccumulator(mMeasurements).getMax();
+}
+
+F64 Recording::getMean( const TraceType<MeasurementAccumulator<F64> >& stat ) const
+{
+ return stat.getAccumulator(mMeasurementsFloat).getMean();
+}
+
+F64 Recording::getMean( const TraceType<MeasurementAccumulator<S64> >& stat ) const
+{
+ return stat.getAccumulator(mMeasurements).getMean();
+}
+
+F64 Recording::getStandardDeviation( const TraceType<MeasurementAccumulator<F64> >& stat ) const
+{
+ return stat.getAccumulator(mMeasurementsFloat).getStandardDeviation();
+}
+
+F64 Recording::getStandardDeviation( const TraceType<MeasurementAccumulator<S64> >& stat ) const
+{
+ return stat.getAccumulator(mMeasurements).getStandardDeviation();
+}
+
+F64 Recording::getLastValue( const TraceType<MeasurementAccumulator<F64> >& stat ) const
+{
+ return stat.getAccumulator(mMeasurementsFloat).getLastValue();
+}
+
+S64 Recording::getLastValue( const TraceType<MeasurementAccumulator<S64> >& stat ) const
+{
+ return stat.getAccumulator(mMeasurements).getLastValue();
+}
+
+U32 Recording::getSampleCount( const TraceType<MeasurementAccumulator<F64> >& stat ) const
+{
+ return stat.getAccumulator(mMeasurementsFloat).getSampleCount();
+}
+
+U32 Recording::getSampleCount( const TraceType<MeasurementAccumulator<S64> >& stat ) const
+{
+ return stat.getAccumulator(mMeasurements).getSampleCount();
+}
+
+
+
///////////////////////////////////////////////////////////////////////
-// Recording
+// PeriodicRecording
///////////////////////////////////////////////////////////////////////
PeriodicRecording::PeriodicRecording( S32 num_periods )
@@ -179,6 +291,7 @@ void PeriodicRecording::handleSplitTo( PeriodicRecording& other )
getCurRecordingPeriod().handleSplitTo(other.getCurRecordingPeriod());
}
+
///////////////////////////////////////////////////////////////////////
// ExtendableRecording
///////////////////////////////////////////////////////////////////////
diff --git a/indra/llcommon/lltracerecording.h b/indra/llcommon/lltracerecording.h
index d3f001ab6a2ff5c9d12c8c331ddc8a8f32a45120..4af973515df0f08d9ed968593a307b2fa97c91ea 100644
--- a/indra/llcommon/lltracerecording.h
+++ b/indra/llcommon/lltracerecording.h
@@ -112,124 +112,81 @@ namespace LLTrace
void update();
// Count accessors
+ F64 getSum(const TraceType<CountAccumulator<F64> >& stat) const;
+ S64 getSum(const TraceType<CountAccumulator<S64> >& stat) const;
template <typename T>
- T getSum(const TraceType<CountAccumulator<T> >& stat) const
+ T getSum(const Count<T, typename T::is_unit_tag_t>& stat) const
{
- return (T)stat.getAccumulator(mCounts).getSum();
- }
-
- template <typename T, typename IS_UNIT>
- T getSum(const Count<T, IS_UNIT>& stat) const
- {
- return (T)stat.getAccumulator(mCounts).getSum();
+ return (T)getSum(static_cast<const TraceType<CountAccumulator<StorageType<T>::type_t> >&> (stat));
}
+ F64 getPerSec(const TraceType<CountAccumulator<F64> >& stat) const;
+ F64 getPerSec(const TraceType<CountAccumulator<S64> >& stat) const;
template <typename T>
- T getPerSec(const TraceType<CountAccumulator<T> >& stat) const
+ T getPerSec(const Count<T, typename T::is_unit_tag_t>& stat) const
{
- return (T)stat.getAccumulator(mCounts).getSum() / mElapsedSeconds;
- }
-
- template <typename T, typename IS_UNIT>
- T getPerSec(const Count<T, IS_UNIT>& stat) const
- {
- return (T)stat.getAccumulator(mCounts).getSum() / mElapsedSeconds;
+ return (T)getPerSec(static_cast<const TraceType<CountAccumulator<StorageType<T>::type_t> >&> (stat));
}
// Measurement accessors
+ F64 getSum(const TraceType<MeasurementAccumulator<F64> >& stat) const;
+ S64 getSum(const TraceType<MeasurementAccumulator<S64> >& stat) const;
template <typename T>
- T getSum(const TraceType<MeasurementAccumulator<T> >& stat) const
+ T getSum(const Measurement<T, typename T::is_unit_tag_t>& stat) const
{
- return (T)stat.getAccumulator(mMeasurements).getSum();
-
- }
-
- template <typename T, typename IS_UNIT>
- T getSum(const Measurement<T, IS_UNIT>& stat) const
- {
- return (T)stat.getAccumulator(mMeasurements).getSum();
-
+ return (T)getSum(static_cast<const TraceType<MeasurementAccumulator<StorageType<T>::type_t> >&> (stat));
}
+ F64 getPerSec(const TraceType<MeasurementAccumulator<F64> >& stat) const;
+ F64 getPerSec(const TraceType<MeasurementAccumulator<S64> >& stat) const;
template <typename T>
- T getPerSec(const TraceType<MeasurementAccumulator<T> >& stat) const
- {
- return (T)stat.getAccumulator(mMeasurements).getSum() / mElapsedSeconds;
- }
-
- template <typename T, typename IS_UNIT>
- T getPerSec(const Measurement<T, IS_UNIT>& stat) const
+ T getPerSec(const Measurement<T, typename T::is_unit_tag_t>& stat) const
{
- return (typename Count<T, IS_UNIT>::base_unit_t)stat.getAccumulator(mMeasurements).getSum() / mElapsedSeconds;
+ return (T)getPerSec(static_cast<const TraceType<MeasurementAccumulator<StorageType<T>::type_t> >&> (stat));
}
+ F64 getMin(const TraceType<MeasurementAccumulator<F64> >& stat) const;
+ S64 getMin(const TraceType<MeasurementAccumulator<S64> >& stat) const;
template <typename T>
- T getMin(const TraceType<MeasurementAccumulator<T> >& stat) const
- {
- return (T)stat.getAccumulator(mMeasurements).getMin();
- }
-
- template <typename T, typename IS_UNIT>
- T getMin(const Measurement<T, IS_UNIT>& stat) const
+ T getMin(const Measurement<T, typename T::is_unit_tag_t>& stat) const
{
- return (T)stat.getAccumulator(mMeasurements).getMin();
+ return (T)getMin(static_cast<const TraceType<MeasurementAccumulator<StorageType<T>::type_t> >&> (stat));
}
-
+ F64 getMax(const TraceType<MeasurementAccumulator<F64> >& stat) const;
+ S64 getMax(const TraceType<MeasurementAccumulator<S64> >& stat) const;
template <typename T>
- T getMax(const TraceType<MeasurementAccumulator<T> >& stat) const
- {
- return (T)stat.getAccumulator(mMeasurements).getMax();
- }
-
- template <typename T, typename IS_UNIT>
- T getMax(const Measurement<T, IS_UNIT>& stat) const
+ T getMax(const Measurement<T, typename T::is_unit_tag_t>& stat) const
{
- return (T)stat.getAccumulator(mMeasurements).getMax();
+ return (T)getMax(static_cast<const TraceType<MeasurementAccumulator<StorageType<T>::type_t> >&> (stat));
}
+ F64 getMean(const TraceType<MeasurementAccumulator<F64> >& stat) const;
+ F64 getMean(const TraceType<MeasurementAccumulator<S64> >& stat) const;
template <typename T>
- T getMean(const TraceType<MeasurementAccumulator<T> >& stat) const
+ T getMean(Measurement<T, typename T::is_unit_tag_t>& stat) const
{
- return (T)stat.getAccumulator(mMeasurements).getMean();
- }
-
- template <typename T, typename IS_UNIT>
- T getMean(Measurement<T, IS_UNIT>& stat) const
- {
- return (T)stat.getAccumulator(mMeasurements).getMean();
+ return (T)getMean(static_cast<const TraceType<MeasurementAccumulator<StorageType<T>::type_t> >&> (stat));
}
+ F64 getStandardDeviation(const TraceType<MeasurementAccumulator<F64> >& stat) const;
+ F64 getStandardDeviation(const TraceType<MeasurementAccumulator<S64> >& stat) const;
template <typename T>
- T getStandardDeviation(const TraceType<MeasurementAccumulator<T> >& stat) const
- {
- return (T)stat.getAccumulator(mMeasurements).getStandardDeviation();
- }
-
- template <typename T, typename IS_UNIT>
- T getStandardDeviation(const Measurement<T, IS_UNIT>& stat) const
+ T getStandardDeviation(const Measurement<T, typename T::is_unit_tag_t>& stat) const
{
- return (T)stat.getAccumulator(mMeasurements).getStandardDeviation();
+ return (T)getMean(static_cast<const TraceType<MeasurementAccumulator<StorageType<T>::type_t> >&> (stat));
}
+ F64 getLastValue(const TraceType<MeasurementAccumulator<F64> >& stat) const;
+ S64 getLastValue(const TraceType<MeasurementAccumulator<S64> >& stat) const;
template <typename T>
- T getLastValue(const TraceType<MeasurementAccumulator<T> >& stat) const
- {
- return (T)stat.getAccumulator(mMeasurements).getLastValue();
- }
-
- template <typename T, typename IS_UNIT>
- T getLastValue(const Measurement<T, IS_UNIT>& stat) const
+ T getLastValue(const Measurement<T, typename T::is_unit_tag_t>& stat) const
{
- return (T)stat.getAccumulator(mMeasurements).getLastValue();
+ return (T)getLastValue(static_cast<const TraceType<MeasurementAccumulator<StorageType<T>::type_t> >&> (stat));
}
-
- template <typename T>
- U32 getSampleCount(const TraceType<MeasurementAccumulator<T> >& stat) const
- {
- return stat.getAccumulator(mMeasurements).getSampleCount();
- }
+ U32 getSampleCount(const TraceType<MeasurementAccumulator<F64> >& stat) const;
+ U32 getSampleCount(const TraceType<MeasurementAccumulator<S64> >& stat) const;
LLUnit::Seconds<F64> getDuration() const { return mElapsedSeconds; }
@@ -244,8 +201,10 @@ namespace LLTrace
// returns data for current thread
class ThreadRecorder* getThreadRecorder();
- LLCopyOnWritePointer<AccumulatorBuffer<CountAccumulator<F64> > > mCounts;
- LLCopyOnWritePointer<AccumulatorBuffer<MeasurementAccumulator<F64> > > mMeasurements;
+ LLCopyOnWritePointer<AccumulatorBuffer<CountAccumulator<F64> > > mCountsFloat;
+ LLCopyOnWritePointer<AccumulatorBuffer<MeasurementAccumulator<F64> > > mMeasurementsFloat;
+ LLCopyOnWritePointer<AccumulatorBuffer<CountAccumulator<S64> > > mCounts;
+ LLCopyOnWritePointer<AccumulatorBuffer<MeasurementAccumulator<S64> > > mMeasurements;
LLCopyOnWritePointer<AccumulatorBuffer<TimerAccumulator> > mStackTimers;
LLTimer mSamplingTimer;
@@ -260,6 +219,7 @@ namespace LLTrace
~PeriodicRecording();
void nextPeriod();
+ S32 getNumPeriods() { return mNumPeriods; }
Recording& getLastRecordingPeriod()
{
@@ -268,7 +228,7 @@ namespace LLTrace
const Recording& getLastRecordingPeriod() const
{
- return mRecordingPeriods[(mCurPeriod + mNumPeriods - 1) % mNumPeriods];
+ return getPrevRecordingPeriod(1);
}
Recording& getCurRecordingPeriod()
@@ -281,6 +241,16 @@ namespace LLTrace
return mRecordingPeriods[mCurPeriod];
}
+ Recording& getPrevRecordingPeriod(S32 offset)
+ {
+ return mRecordingPeriods[(mCurPeriod + mNumPeriods - offset) % mNumPeriods];
+ }
+
+ const Recording& getPrevRecordingPeriod(S32 offset) const
+ {
+ return mRecordingPeriods[(mCurPeriod + mNumPeriods - offset) % mNumPeriods];
+ }
+
Recording snapshotCurRecordingPeriod() const
{
Recording recording_copy(getCurRecordingPeriod());
@@ -290,6 +260,84 @@ namespace LLTrace
Recording& getTotalRecording();
+ template <typename T>
+ typename T getPeriodMin(const TraceType<CountAccumulator<T> >& stat) const
+ {
+ T min_val = std::numeric_limits<T>::max();
+ for (S32 i = 0; i < mNumPeriods; i++)
+ {
+ min_val = llmin(min_val, mRecordingPeriods[i].getSum(stat));
+ }
+ return (T)min_val;
+ }
+
+ template <typename T>
+ F64 getPeriodMinPerSec(const TraceType<CountAccumulator<T> >& stat) const
+ {
+ F64 min_val = std::numeric_limits<F64>::max();
+ for (S32 i = 0; i < mNumPeriods; i++)
+ {
+ min_val = llmin(min_val, mRecordingPeriods[i].getPerSec(stat));
+ }
+ return min_val;
+ }
+
+ template <typename T>
+ T getPeriodMax(const TraceType<CountAccumulator<T> >& stat) const
+ {
+ T max_val = std::numeric_limits<T>::min();
+ for (S32 i = 0; i < mNumPeriods; i++)
+ {
+ max_val = llmax(max_val, mRecordingPeriods[i].getSum(stat));
+ }
+ return max_val;
+ }
+
+ template <typename T>
+ F64 getPeriodMaxPerSec(const TraceType<CountAccumulator<T> >& stat) const
+ {
+ F64 max_val = std::numeric_limits<F64>::min();
+ for (S32 i = 0; i < mNumPeriods; i++)
+ {
+ max_val = llmax(max_val, mRecordingPeriods[i].getPerSec(stat));
+ }
+ return max_val;
+ }
+
+ template <typename T>
+ F64 getPeriodMean(const TraceType<CountAccumulator<T> >& stat) const
+ {
+ F64 mean = 0.0;
+ F64 count = 0;
+ for (S32 i = 0; i < mNumPeriods; i++)
+ {
+ if (mRecordingPeriods[i].getDuration() > 0.f)
+ {
+ count++;
+ mean += mRecordingPeriods[i].getSum(stat);
+ }
+ }
+ mean /= (F64)mNumPeriods;
+ return mean;
+ }
+
+ template <typename T>
+ F64 getPeriodMeanPerSec(const TraceType<CountAccumulator<T> >& stat) const
+ {
+ F64 mean = 0.0;
+ F64 count = 0;
+ for (S32 i = 0; i < mNumPeriods; i++)
+ {
+ if (mRecordingPeriods[i].getDuration() > 0.f)
+ {
+ count++;
+ mean += mRecordingPeriods[i].getPerSec(stat);
+ }
+ }
+ mean /= count;
+ return mean;
+ }
+
private:
// implementation for LLVCRControlsMixin
diff --git a/indra/llcommon/lltracethreadrecorder.cpp b/indra/llcommon/lltracethreadrecorder.cpp
index e81333f7f285b4df653e033a7afcc9a2aabb3ed1..15056b80e477566a6763fd47130a19b5567474ce 100644
--- a/indra/llcommon/lltracethreadrecorder.cpp
+++ b/indra/llcommon/lltracethreadrecorder.cpp
@@ -113,9 +113,13 @@ ThreadRecorder::ActiveRecording::ActiveRecording( Recording* target )
void ThreadRecorder::ActiveRecording::moveBaselineToTarget()
{
+ mTargetRecording->mMeasurementsFloat.write()->addSamples(*mBaseline.mMeasurementsFloat);
+ mTargetRecording->mCountsFloat.write()->addSamples(*mBaseline.mCountsFloat);
mTargetRecording->mMeasurements.write()->addSamples(*mBaseline.mMeasurements);
mTargetRecording->mCounts.write()->addSamples(*mBaseline.mCounts);
mTargetRecording->mStackTimers.write()->addSamples(*mBaseline.mStackTimers);
+ mBaseline.mMeasurementsFloat.write()->reset();
+ mBaseline.mCountsFloat.write()->reset();
mBaseline.mMeasurements.write()->reset();
mBaseline.mCounts.write()->reset();
mBaseline.mStackTimers.write()->reset();
diff --git a/indra/llui/llstatbar.cpp b/indra/llui/llstatbar.cpp
index 535c6f96e37cf867cfb2d0424cbab7553ba2ad97..6b40f8d47507c629523f8f1ac543674df39c7437 100644
--- a/indra/llui/llstatbar.cpp
+++ b/indra/llui/llstatbar.cpp
@@ -34,7 +34,6 @@
#include "llgl.h"
#include "llfontgl.h"
-#include "llstat.h"
#include "lluictrlfactory.h"
#include "lltracerecording.h"
@@ -46,8 +45,10 @@ LLStatBar::LLStatBar(const Params& p)
mUnitLabel(p.unit_label),
mMinBar(p.bar_min),
mMaxBar(p.bar_max),
- mStatp(LLStat::getInstance(p.stat)),
- mNewStatp(LLTrace::Count<>::getInstance(p.stat)),
+ mCountFloatp(LLTrace::Count<>::getInstance(p.stat)),
+ mCountIntp(LLTrace::Count<S64>::getInstance(p.stat)),
+ mMeasurementFloatp(LLTrace::Measurement<>::getInstance(p.stat)),
+ mMeasurementIntp(LLTrace::Measurement<S64>::getInstance(p.stat)),
mTickSpacing(p.tick_spacing),
mLabelSpacing(p.label_spacing),
mPrecision(p.precision),
@@ -90,46 +91,62 @@ void LLStatBar::draw()
max = 0.f,
mean = 0.f;
- if (mStatp)
+ LLTrace::PeriodicRecording& frame_recording = LLTrace::get_frame_recording();
+
+ if (mCountFloatp)
{
- // Get the values.
+ LLTrace::Recording& last_frame_recording = frame_recording.getLastRecordingPeriod();
+
if (mPerSec)
{
- current = mStatp->getCurrentPerSec();
- min = mStatp->getMinPerSec();
- max = mStatp->getMaxPerSec();
- mean = mStatp->getMeanPerSec();
+ current = last_frame_recording.getPerSec(*mCountFloatp);
+ min = frame_recording.getPeriodMinPerSec(*mCountFloatp);
+ max = frame_recording.getPeriodMaxPerSec(*mCountFloatp);
+ mean = frame_recording.getPeriodMeanPerSec(*mCountFloatp);
}
else
{
- current = mStatp->getCurrent();
- min = mStatp->getMin();
- max = mStatp->getMax();
- mean = mStatp->getMean();
+ current = last_frame_recording.getSum(*mCountFloatp);
+ min = frame_recording.getPeriodMin(*mCountFloatp);
+ max = frame_recording.getPeriodMax(*mCountFloatp);
+ mean = frame_recording.getPeriodMean(*mCountFloatp);
}
}
- else if (mNewStatp)
+ else if (mCountIntp)
{
- LLTrace::PeriodicRecording& frame_recording = LLTrace::get_frame_recording();
LLTrace::Recording& last_frame_recording = frame_recording.getLastRecordingPeriod();
- LLTrace::Recording& windowed_frame_recording = frame_recording.getTotalRecording();
if (mPerSec)
{
- current = last_frame_recording.getPerSec(*mNewStatp);
- //min = frame_window_recording.getMin(*mNewStatp) / frame_window_recording.getDuration();
- //max = frame_window_recording.getMax(*mNewStatp) / frame_window_recording.getDuration();
- mean = windowed_frame_recording.getPerSec(*mNewStatp);//frame_window_recording.getMean(*mNewStatp) / frame_window_recording.getDuration();
+ current = last_frame_recording.getPerSec(*mCountIntp);
+ min = frame_recording.getPeriodMinPerSec(*mCountIntp);
+ max = frame_recording.getPeriodMaxPerSec(*mCountIntp);
+ mean = frame_recording.getPeriodMeanPerSec(*mCountIntp);
}
else
{
- current = last_frame_recording.getSum(*mNewStatp);
- //min = last_frame_recording.getMin(*mNewStatp);
- //max = last_frame_recording.getMax(*mNewStatp);
- mean = windowed_frame_recording.getSum(*mNewStatp);
+ current = last_frame_recording.getSum(*mCountIntp);
+ min = frame_recording.getPeriodMin(*mCountIntp);
+ max = frame_recording.getPeriodMax(*mCountIntp);
+ mean = frame_recording.getPeriodMean(*mCountIntp);
}
}
-
+ else if (mMeasurementFloatp)
+ {
+ LLTrace::Recording& recording = frame_recording.getTotalRecording();
+ current = recording.getLastValue(*mMeasurementFloatp);
+ min = recording.getMin(*mMeasurementFloatp);
+ max = recording.getMax(*mMeasurementFloatp);
+ mean = recording.getMean(*mMeasurementFloatp);
+ }
+ else if (mMeasurementIntp)
+ {
+ LLTrace::Recording& recording = frame_recording.getTotalRecording();
+ current = recording.getLastValue(*mMeasurementIntp);
+ min = recording.getMin(*mMeasurementIntp);
+ max = recording.getMax(*mMeasurementIntp);
+ mean = recording.getMean(*mMeasurementIntp);
+ }
if ((mUpdatesPerSec == 0.f) || (mUpdateTimer.getElapsedTimeF32() > 1.f/mUpdatesPerSec) || (mValue == 0.f))
{
@@ -176,7 +193,7 @@ void LLStatBar::draw()
LLFontGL::RIGHT, LLFontGL::TOP);
value_format = llformat( "%%.%df", mPrecision);
- if (mDisplayBar && mStatp)
+ if (mDisplayBar && (mCountFloatp || mCountIntp || mMeasurementFloatp || mMeasurementIntp))
{
std::string tick_label;
@@ -219,7 +236,7 @@ void LLStatBar::draw()
right = width;
gl_rect_2d(left, top, right, bottom, LLColor4(0.f, 0.f, 0.f, 0.25f));
- if (mStatp->getNumValues() == 0)
+ if (frame_recording.getNumPeriods() == 0)
{
// No data, don't draw anything...
return;
@@ -236,26 +253,58 @@ void LLStatBar::draw()
right = (S32) ((max - mMinBar) * value_scale);
gl_rect_2d(left, top, right, bottom, LLColor4(1.f, 0.f, 0.f, 0.25f));
- if (mDisplayHistory)
+ if (mDisplayHistory && (mCountFloatp || mCountIntp || mMeasurementFloatp || mMeasurementIntp))
{
- S32 num_values = mStatp->getNumValues() - 1;
+ S32 num_values = frame_recording.getNumPeriods() - 1;
S32 i;
- for (i = 0; i < num_values; i++)
+ for (i = 1; i <= num_values; i++)
{
- if (i == mStatp->getNextBin())
- {
- continue;
- }
if (mPerSec)
{
- left = (S32)((mStatp->getPrevPerSec(i) - mMinBar) * value_scale);
- right = (S32)((mStatp->getPrevPerSec(i) - mMinBar) * value_scale) + 1;
+ if (mCountFloatp)
+ {
+ left = (S32)((frame_recording.getPrevRecordingPeriod(i).getPerSec(*mCountFloatp) - mMinBar) * value_scale);
+ right = (S32)((frame_recording.getPrevRecordingPeriod(i).getPerSec(*mCountFloatp) - mMinBar) * value_scale) + 1;
+ }
+ else if (mCountIntp)
+ {
+ left = (S32)((frame_recording.getPrevRecordingPeriod(i).getPerSec(*mCountIntp) - mMinBar) * value_scale);
+ right = (S32)((frame_recording.getPrevRecordingPeriod(i).getPerSec(*mCountIntp) - mMinBar) * value_scale) + 1;
+ }
+ else if (mMeasurementFloatp)
+ {
+ left = (S32)((frame_recording.getPrevRecordingPeriod(i).getPerSec(*mMeasurementFloatp) - mMinBar) * value_scale);
+ right = (S32)((frame_recording.getPrevRecordingPeriod(i).getPerSec(*mMeasurementFloatp) - mMinBar) * value_scale) + 1;
+ }
+ else if (mMeasurementIntp)
+ {
+ left = (S32)((frame_recording.getPrevRecordingPeriod(i).getPerSec(*mMeasurementIntp) - mMinBar) * value_scale);
+ right = (S32)((frame_recording.getPrevRecordingPeriod(i).getPerSec(*mMeasurementIntp) - mMinBar) * value_scale) + 1;
+ }
gl_rect_2d(left, bottom+i+1, right, bottom+i, LLColor4(1.f, 0.f, 0.f, 1.f));
}
else
{
- left = (S32)((mStatp->getPrev(i) - mMinBar) * value_scale);
- right = (S32)((mStatp->getPrev(i) - mMinBar) * value_scale) + 1;
+ if (mCountFloatp)
+ {
+ left = (S32)((frame_recording.getPrevRecordingPeriod(i).getSum(*mCountFloatp) - mMinBar) * value_scale);
+ right = (S32)((frame_recording.getPrevRecordingPeriod(i).getSum(*mCountFloatp) - mMinBar) * value_scale) + 1;
+ }
+ else if (mCountIntp)
+ {
+ left = (S32)((frame_recording.getPrevRecordingPeriod(i).getSum(*mCountIntp) - mMinBar) * value_scale);
+ right = (S32)((frame_recording.getPrevRecordingPeriod(i).getSum(*mCountIntp) - mMinBar) * value_scale) + 1;
+ }
+ else if (mMeasurementFloatp)
+ {
+ left = (S32)((frame_recording.getPrevRecordingPeriod(i).getSum(*mMeasurementFloatp) - mMinBar) * value_scale);
+ right = (S32)((frame_recording.getPrevRecordingPeriod(i).getSum(*mMeasurementFloatp) - mMinBar) * value_scale) + 1;
+ }
+ else if (mMeasurementIntp)
+ {
+ left = (S32)((frame_recording.getPrevRecordingPeriod(i).getSum(*mMeasurementIntp) - mMinBar) * value_scale);
+ right = (S32)((frame_recording.getPrevRecordingPeriod(i).getSum(*mMeasurementIntp) - mMinBar) * value_scale) + 1;
+ }
gl_rect_2d(left, bottom+i+1, right, bottom+i, LLColor4(1.f, 0.f, 0.f, 1.f));
}
}
@@ -279,6 +328,15 @@ void LLStatBar::draw()
LLView::draw();
}
+void LLStatBar::setStat(const std::string& stat_name)
+{
+ mCountFloatp = LLTrace::Count<>::getInstance(stat_name);
+ mCountIntp = LLTrace::Count<S64>::getInstance(stat_name);
+ mMeasurementFloatp = LLTrace::Measurement<>::getInstance(stat_name);
+ mMeasurementIntp = LLTrace::Measurement<S64>::getInstance(stat_name);
+}
+
+
void LLStatBar::setRange(F32 bar_min, F32 bar_max, F32 tick_spacing, F32 label_spacing)
{
mMinBar = bar_min;
@@ -293,9 +351,9 @@ LLRect LLStatBar::getRequiredRect()
if (mDisplayBar)
{
- if (mDisplayHistory && mStatp)
+ if (mDisplayHistory)
{
- rect.mTop = 35 + mStatp->getNumBins();
+ rect.mTop = 35 + LLTrace::get_frame_recording().getNumPeriods();
}
else
{
diff --git a/indra/llui/llstatbar.h b/indra/llui/llstatbar.h
index d510f0e3fe9659216cb18556c45b1671d39bf012..6aefb1e2130f05aedd1b6ae43e495277b63361f2 100644
--- a/indra/llui/llstatbar.h
+++ b/indra/llui/llstatbar.h
@@ -30,7 +30,6 @@
#include "llview.h"
#include "llframetimer.h"
#include "lltracerecording.h"
-class LLStat;
class LLStatBar : public LLView
{
@@ -79,7 +78,8 @@ class LLStatBar : public LLView
virtual void draw();
virtual BOOL handleMouseDown(S32 x, S32 y, MASK mask);
- void setStat(LLStat* stat) { mStatp = stat; }
+ void setStat(const std::string& stat_name);
+
void setRange(F32 bar_min, F32 bar_max, F32 tick_spacing, F32 label_spacing);
void getRange(F32& bar_min, F32& bar_max) { bar_min = mMinBar; bar_max = mMaxBar; }
@@ -96,10 +96,11 @@ class LLStatBar : public LLView
BOOL mDisplayBar; // Display the bar graph.
BOOL mDisplayHistory;
BOOL mDisplayMean; // If true, display mean, if false, display current value
- LLTrace::PeriodicRecording* mFrameRecording;
- LLStat* mStatp;
- LLTrace::count_common_t* mNewStatp;
+ LLTrace::count_common_float_t* mCountFloatp;
+ LLTrace::count_common_int_t* mCountIntp;
+ LLTrace::measurement_common_float_t* mMeasurementFloatp;
+ LLTrace::measurement_common_int_t* mMeasurementIntp;
LLFrameTimer mUpdateTimer;
LLUIString mLabel;
diff --git a/indra/llui/llstatgraph.cpp b/indra/llui/llstatgraph.cpp
index e961e7d3c01cc49b78a0c84c2181176bfb51a00a..22c276a0183690d0f378b9cd3c60e89956cc42eb 100644
--- a/indra/llui/llstatgraph.cpp
+++ b/indra/llui/llstatgraph.cpp
@@ -32,7 +32,6 @@
#include "llmath.h"
#include "llui.h"
-#include "llstat.h"
#include "llgl.h"
#include "llglheaders.h"
#include "lltracerecording.h"
@@ -48,8 +47,8 @@ LLStatGraph::LLStatGraph(const Params& p)
mPerSec(true),
mPrecision(p.precision),
mValue(p.value),
- mStatp(p.stat.legacy_stat),
- mNewStatp(p.stat.count_stat)
+ mNewStatFloatp(p.stat.count_stat_float),
+ mNewStatIntp(p.stat.count_stat_int)
{
setToolTip(p.name());
@@ -73,30 +72,31 @@ void LLStatGraph::draw()
{
F32 range, frac;
range = mMax - mMin;
- if (mStatp)
+ if (mNewStatFloatp)
{
+ LLTrace::Recording& recording = LLTrace::get_frame_recording().getLastRecordingPeriod();
+
if (mPerSec)
{
- mValue = mStatp->getMeanPerSec();
+ mValue = recording.getPerSec(*mNewStatFloatp);
}
else
{
- mValue = mStatp->getMean();
+ mValue = recording.getSum(*mNewStatFloatp);
}
}
- else if (mNewStatp)
+ else if (mNewStatIntp)
{
LLTrace::Recording& recording = LLTrace::get_frame_recording().getLastRecordingPeriod();
if (mPerSec)
{
- mValue = recording.getPerSec(*mNewStatp);
+ mValue = recording.getPerSec(*mNewStatIntp);
}
else
{
- mValue = recording.getSum(*mNewStatp);
+ mValue = recording.getSum(*mNewStatIntp);
}
-
}
frac = (mValue - mMin) / range;
diff --git a/indra/llui/llstatgraph.h b/indra/llui/llstatgraph.h
index b20966d608dd544ea5d9134627937d9a1741db0d..f33c784262e73e3cc9ffa982f3b1675b352be7b9 100644
--- a/indra/llui/llstatgraph.h
+++ b/indra/llui/llstatgraph.h
@@ -32,8 +32,6 @@
#include "v4color.h"
#include "lltrace.h"
-class LLStat;
-
class LLStatGraph : public LLView
{
public:
@@ -59,9 +57,10 @@ class LLStatGraph : public LLView
struct StatParams : public LLInitParam::ChoiceBlock<StatParams>
{
- Alternative<LLStat*> legacy_stat;
- Alternative<LLTrace::count_common_t* > count_stat;
- Alternative<LLTrace::measurement_common_t* > measurement_stat;
+ Alternative<LLTrace::count_common_float_t* > count_stat_float;
+ Alternative<LLTrace::count_common_int_t* > count_stat_int;
+ Alternative<LLTrace::measurement_common_float_t* > measurement_stat_float;
+ Alternative<LLTrace::measurement_common_int_t* > measurement_stat_int;
};
struct Params : public LLInitParam::Block<Params, LLView::Params>
@@ -106,8 +105,8 @@ class LLStatGraph : public LLView
/*virtual*/ void setValue(const LLSD& value);
private:
- LLStat* mStatp;
- LLTrace::count_common_t* mNewStatp;
+ LLTrace::count_common_float_t* mNewStatFloatp;
+ LLTrace::count_common_int_t* mNewStatIntp;
BOOL mPerSec;
diff --git a/indra/llvfs/llvfile.cpp b/indra/llvfs/llvfile.cpp
index ca749c5eafb8dbb57fe1d94d490fe4137d898007..7f631ef0bbb91fc41cd5c4f51d1c5f220f81f86b 100644
--- a/indra/llvfs/llvfile.cpp
+++ b/indra/llvfs/llvfile.cpp
@@ -30,8 +30,8 @@
#include "llerror.h"
#include "llthread.h"
-#include "llstat.h"
#include "llvfs.h"
+#include "lltimer.h"
const S32 LLVFile::READ = 0x00000001;
const S32 LLVFile::WRITE = 0x00000002;
diff --git a/indra/lscript/lscript_execute/lscript_execute.cpp b/indra/lscript/lscript_execute/lscript_execute.cpp
index d79e9f8bde496797dd3a2a6de2073d2b90df9fae..23e1fe306eddd553ff9c718a20064f36969f3c77 100644
--- a/indra/lscript/lscript_execute/lscript_execute.cpp
+++ b/indra/lscript/lscript_execute/lscript_execute.cpp
@@ -35,7 +35,6 @@
#include "lscript_library.h"
#include "lscript_heapruntime.h"
#include "lscript_alloc.h"
-#include "llstat.h"
// Static
diff --git a/indra/newview/llagentcamera.cpp b/indra/newview/llagentcamera.cpp
index 751b73e1eb0a1fd68399acc9d8b1a7fb8c68e852..8d80e3aa0a97925132bee478bfd07dbce8bc0b43 100644
--- a/indra/newview/llagentcamera.cpp
+++ b/indra/newview/llagentcamera.cpp
@@ -1081,8 +1081,8 @@ void LLAgentCamera::updateLookAt(const S32 mouse_x, const S32 mouse_y)
LLQuaternion av_inv_rot = ~gAgentAvatarp->mRoot.getWorldRotation();
LLVector3 root_at = LLVector3::x_axis * gAgentAvatarp->mRoot.getWorldRotation();
- if ((gViewerWindow->getMouseVelocityStat()->getCurrent() < 0.01f) &&
- (root_at * last_at_axis > 0.95f))
+ if (LLTrace::get_frame_recording().getLastRecordingPeriod().getLastValue(*gViewerWindow->getMouseVelocityStat()) < 0.01f
+ && (root_at * last_at_axis > 0.95f))
{
LLVector3 vel = gAgentAvatarp->getVelocity();
if (vel.magVecSquared() > 4.f)
diff --git a/indra/newview/llappviewer.cpp b/indra/newview/llappviewer.cpp
index 559f427de642acd1176c8dbe25b0b4a7d601c23b..2d090f0f74e8be3dc54b90aac86da6a24ea00bfe 100644
--- a/indra/newview/llappviewer.cpp
+++ b/indra/newview/llappviewer.cpp
@@ -4305,6 +4305,9 @@ void LLAppViewer::idle()
update_statistics();
}
+ LLTrace::get_frame_recording().nextPeriod();
+
+
////////////////////////////////////////
//
// Handle the regular UI idle callbacks as well as
diff --git a/indra/newview/llfasttimerview.cpp b/indra/newview/llfasttimerview.cpp
index 4dfb93f1bca3359ace15787dc845598b2a710266..065b20ba2b84b481751a9f824b48a285d10fa3cd 100644
--- a/indra/newview/llfasttimerview.cpp
+++ b/indra/newview/llfasttimerview.cpp
@@ -46,7 +46,6 @@
#include "llviewertexturelist.h"
#include "llui.h"
#include "llviewercontrol.h"
-#include "llstat.h"
#include "llfasttimer.h"
#include "lltreeiterators.h"
diff --git a/indra/newview/llfloaterjoystick.cpp b/indra/newview/llfloaterjoystick.cpp
index f7b2670b8e1404ebb0816dab0d13e5bc1374cd62..e2813a8272e3ce228e0e1fbe4c58414d97a686c0 100644
--- a/indra/newview/llfloaterjoystick.cpp
+++ b/indra/newview/llfloaterjoystick.cpp
@@ -33,7 +33,7 @@
#include "llerror.h"
#include "llrect.h"
#include "llstring.h"
-#include "llstat.h"
+#include "lltrace.h"
// project includes
#include "lluictrlfactory.h"
@@ -42,6 +42,16 @@
#include "llviewerjoystick.h"
#include "llcheckboxctrl.h"
+static LLTrace::Measurement<> sJoystickAxes[6] =
+{
+ LLTrace::Measurement<>("Joystick axis 1"),
+ LLTrace::Measurement<>("Joystick axis 2"),
+ LLTrace::Measurement<>("Joystick axis 3"),
+ LLTrace::Measurement<>("Joystick axis 4"),
+ LLTrace::Measurement<>("Joystick axis 5"),
+ LLTrace::Measurement<>("Joystick axis 6")
+};
+
LLFloaterJoystick::LLFloaterJoystick(const LLSD& data)
: LLFloater(data)
{
@@ -61,7 +71,7 @@ void LLFloaterJoystick::draw()
for (U32 i = 0; i < 6; i++)
{
F32 value = joystick->getJoystickAxis(i);
- mAxisStats[i]->addValue(value * gFrameIntervalSeconds.value());
+ sJoystickAxes[i].sample(value * gFrameIntervalSeconds.value());
if (mAxisStatsBar[i])
{
F32 minbar, maxbar;
@@ -85,12 +95,11 @@ BOOL LLFloaterJoystick::postBuild()
for (U32 i = 0; i < 6; i++)
{
std::string stat_name(llformat("Joystick axis %d", i));
- mAxisStats[i] = new LLStat(stat_name, 4);
std::string axisname = llformat("axis%d", i);
mAxisStatsBar[i] = getChild<LLStatBar>(axisname);
if (mAxisStatsBar[i])
{
- mAxisStatsBar[i]->setStat(mAxisStats[i]);
+ mAxisStatsBar[i]->setStat(stat_name);
mAxisStatsBar[i]->setRange(-range, range, range * 0.25f, range * 0.5f);
}
}
diff --git a/indra/newview/llfloaterjoystick.h b/indra/newview/llfloaterjoystick.h
index dfdb108ff84236e2e8a4eb96bfee2980b19463d6..9c3752540d770d158ebc9cdd642953fd5f7a9d31 100644
--- a/indra/newview/llfloaterjoystick.h
+++ b/indra/newview/llfloaterjoystick.h
@@ -84,7 +84,6 @@ class LLFloaterJoystick : public LLFloater
LLCheckBoxCtrl *mCheckFlycamEnabled;
// stats view
- LLStat* mAxisStats[6];
LLStatBar* mAxisStatsBar[6];
};
diff --git a/indra/newview/llhudnametag.cpp b/indra/newview/llhudnametag.cpp
index 482294c8a614bf2aec9ba73251aefadd607cc684..56fbdb429a27b25b34cb9ec1265e6633fac1aed7 100644
--- a/indra/newview/llhudnametag.cpp
+++ b/indra/newview/llhudnametag.cpp
@@ -30,6 +30,7 @@
#include "llhudnametag.h"
#include "llrender.h"
+#include "lltracerecording.h"
#include "llagent.h"
#include "llviewercontrol.h"
@@ -899,8 +900,8 @@ void LLHUDNameTag::updateAll()
// }
}
- LLStat* camera_vel_stat = LLViewerCamera::getInstance()->getVelocityStat();
- F32 camera_vel = camera_vel_stat->getCurrent();
+ LLTrace::Count<>* camera_vel_stat = LLViewerCamera::getVelocityStat();
+ F32 camera_vel = LLTrace::get_frame_recording().getLastRecordingPeriod().getPerSec(*camera_vel_stat);
if (camera_vel > MAX_STABLE_CAMERA_VELOCITY)
{
return;
diff --git a/indra/newview/llstatusbar.cpp b/indra/newview/llstatusbar.cpp
index 5720395d05276b388e15b447dbdb922d11f1a86f..b945ec2318cfb8cff07dac00efddc54c91ea3f08 100644
--- a/indra/newview/llstatusbar.cpp
+++ b/indra/newview/llstatusbar.cpp
@@ -198,7 +198,7 @@ BOOL LLStatusBar::postBuild()
sgp.rect(r);
sgp.follows.flags(FOLLOWS_BOTTOM | FOLLOWS_RIGHT);
sgp.mouse_opaque(false);
- sgp.stat.count_stat(&LLStatViewer::KBIT);
+ sgp.stat.count_stat_float(&LLStatViewer::KBIT);
sgp.units("Kbps");
sgp.precision(0);
mSGBandwidth = LLUICtrlFactory::create<LLStatGraph>(sgp);
@@ -212,7 +212,7 @@ BOOL LLStatusBar::postBuild()
pgp.rect(r);
pgp.follows.flags(FOLLOWS_BOTTOM | FOLLOWS_RIGHT);
pgp.mouse_opaque(false);
- pgp.stat.measurement_stat(&LLStatViewer::PACKETS_LOST_PERCENT);
+ pgp.stat.measurement_stat_float(&LLStatViewer::PACKETS_LOST_PERCENT);
pgp.units("%");
pgp.min(0.f);
pgp.max(5.f);
diff --git a/indra/newview/llsurface.h b/indra/newview/llsurface.h
index 9d24bf8771b987d8f210af2eef6b88b5fc4a04d9..33a64ae7d5a591bd96ea54c083ccca2031b8d936 100644
--- a/indra/newview/llsurface.h
+++ b/indra/newview/llsurface.h
@@ -45,7 +45,6 @@
class LLTimer;
class LLUUID;
class LLAgent;
-class LLStat;
static const U8 NO_EDGE = 0x00;
static const U8 EAST_EDGE = 0x01;
diff --git a/indra/newview/lltexturefetch.cpp b/indra/newview/lltexturefetch.cpp
index 2a72e776723af41afd38ded52908fb7b56f5546e..fa0e3acf5ea33debdf65aaf71cd99def1c64dbec 100644
--- a/indra/newview/lltexturefetch.cpp
+++ b/indra/newview/lltexturefetch.cpp
@@ -59,8 +59,8 @@
#include "llviewerstats.h"
bool LLTextureFetchDebugger::sDebuggerEnabled = false ;
-LLStat LLTextureFetch::sCacheHitRate("texture_cache_hits", 128);
-LLStat LLTextureFetch::sCacheReadLatency("texture_cache_read_latency", 128);
+LLTrace::Measurement<> LLTextureFetch::sCacheHitRate("texture_cache_hits");
+LLTrace::Measurement<> LLTextureFetch::sCacheReadLatency("texture_cache_read_latency");
//////////////////////////////////////////////////////////////////////////////
class LLTextureFetchWorker : public LLWorkerClass
@@ -895,7 +895,7 @@ bool LLTextureFetchWorker::doWork(S32 param)
LL_DEBUGS("Texture") << mID << ": Cached. Bytes: " << mFormattedImage->getDataSize()
<< " Size: " << llformat("%dx%d",mFormattedImage->getWidth(),mFormattedImage->getHeight())
<< " Desired Discard: " << mDesiredDiscard << " Desired Size: " << mDesiredSize << LL_ENDL;
- LLTextureFetch::sCacheHitRate.addValue(100.f);
+ LLTextureFetch::sCacheHitRate.sample(100.f);
}
else
{
@@ -912,7 +912,7 @@ bool LLTextureFetchWorker::doWork(S32 param)
}
// fall through
- LLTextureFetch::sCacheHitRate.addValue(0.f);
+ LLTextureFetch::sCacheHitRate.sample(0.f);
}
}
@@ -2039,7 +2039,7 @@ bool LLTextureFetch::getRequestFinished(const LLUUID& id, S32& discard_level,
F32 cache_read_time = worker->mCacheReadTime;
if (cache_read_time != 0.f)
{
- sCacheReadLatency.addValue(cache_read_time * 1000.f);
+ sCacheReadLatency.sample(cache_read_time * 1000.f);
}
res = true;
LL_DEBUGS("Texture") << id << ": Request Finished. State: " << worker->mState << " Discard: " << discard_level << LL_ENDL;
diff --git a/indra/newview/lltexturefetch.h b/indra/newview/lltexturefetch.h
index 7ffa58660eb1bc9c3a221e4e35a8b12cfecce3a7..4ec67c8cdb09ea55b28715e9ab695d78dc3df9f9 100644
--- a/indra/newview/lltexturefetch.h
+++ b/indra/newview/lltexturefetch.h
@@ -35,8 +35,7 @@
#include "lltextureinfo.h"
#include "llapr.h"
#include "llimageworker.h"
-#include "llstat.h"
-//#include "lltexturecache.h"
+#include "lltrace.h"
class LLViewerTexture;
class LLTextureFetchWorker;
@@ -166,8 +165,8 @@ class LLTextureFetch : public LLWorkerThread
LLMutex mQueueMutex; //to protect mRequestMap and mCommands only
LLMutex mNetworkQueueMutex; //to protect mNetworkQueue, mHTTPTextureQueue and mCancelQueue.
- static LLStat sCacheHitRate;
- static LLStat sCacheReadLatency;
+ static LLTrace::Measurement<> sCacheHitRate;
+ static LLTrace::Measurement<> sCacheReadLatency;
LLTextureCache* mTextureCache;
LLImageDecodeThread* mImageDecodeThread;
diff --git a/indra/newview/llviewercamera.cpp b/indra/newview/llviewercamera.cpp
index a437a8b3b53624fbfc657507db888792291a474e..831304f42855a254d6293b3dfbfc5311a8cfdc08 100644
--- a/indra/newview/llviewercamera.cpp
+++ b/indra/newview/llviewercamera.cpp
@@ -49,10 +49,14 @@
#include "llglheaders.h"
#include "llquaternion.h"
#include "llwindow.h" // getPixelAspectRatio()
+#include "lltracerecording.h"
// System includes
#include <iomanip> // for setprecision
+LLTrace::Count<> LLViewerCamera::sVelocityStat("camera_velocity");
+LLTrace::Count<> LLViewerCamera::sAngularVelocityStat("camera_angular_velocity");
+
U32 LLViewerCamera::sCurCameraID = LLViewerCamera::CAMERA_WORLD;
//glu pick matrix implementation borrowed from Mesa3D
@@ -163,11 +167,12 @@ void LLViewerCamera::updateCameraLocation(const LLVector3 ¢er,
F32 drot;
rotation.getAngleAxis(&drot, &x, &y, &z);
- mVelocityStat.addValue(dpos);
- mAngularVelocityStat.addValue(drot);
+ sVelocityStat.add(dpos);
+ sAngularVelocityStat.add(drot);
- mAverageSpeed = mVelocityStat.getMeanPerSec() ;
- mAverageAngularSpeed = mAngularVelocityStat.getMeanPerSec() ;
+ LLTrace::Recording& recording = LLTrace::get_frame_recording().getTotalRecording();
+ mAverageSpeed = LLTrace::get_frame_recording().getPeriodMeanPerSec(sVelocityStat);
+ mAverageAngularSpeed = LLTrace::get_frame_recording().getPeriodMeanPerSec(sAngularVelocityStat);
mCosHalfCameraFOV = cosf(0.5f * getView() * llmax(1.0f, getAspect()));
// update pixel meter ratio using default fov, not modified one
diff --git a/indra/newview/llviewercamera.h b/indra/newview/llviewercamera.h
index b857c7fe89fb108c0c2abf7730b8739531022602..399eed7695bf9f33f079f1f2e5f126fb6f9ecdce 100644
--- a/indra/newview/llviewercamera.h
+++ b/indra/newview/llviewercamera.h
@@ -29,10 +29,10 @@
#include "llcamera.h"
#include "llsingleton.h"
-#include "llstat.h"
#include "lltimer.h"
#include "m4math.h"
#include "llcoord.h"
+#include "lltrace.h"
class LLViewerObject;
@@ -100,12 +100,12 @@ class LLViewerCamera : public LLCamera, public LLSingleton<LLViewerCamera>
BOOL projectPosAgentToScreen(const LLVector3 &pos_agent, LLCoordGL &out_point, const BOOL clamp = TRUE) const;
BOOL projectPosAgentToScreenEdge(const LLVector3 &pos_agent, LLCoordGL &out_point) const;
- const LLVector3* getVelocityDir() const {return &mVelocityDir;}
- LLStat *getVelocityStat() { return &mVelocityStat; }
- LLStat *getAngularVelocityStat() { return &mAngularVelocityStat; }
- F32 getCosHalfFov() {return mCosHalfCameraFOV;}
- F32 getAverageSpeed() {return mAverageSpeed ;}
- F32 getAverageAngularSpeed() {return mAverageAngularSpeed;}
+ const LLVector3* getVelocityDir() const {return &mVelocityDir;}
+ static LLTrace::Count<>* getVelocityStat() {return &sVelocityStat; }
+ static LLTrace::Count<>* getAngularVelocityStat() {return &sAngularVelocityStat; }
+ F32 getCosHalfFov() {return mCosHalfCameraFOV;}
+ F32 getAverageSpeed() {return mAverageSpeed ;}
+ F32 getAverageAngularSpeed() {return mAverageAngularSpeed;}
void getPixelVectors(const LLVector3 &pos_agent, LLVector3 &up, LLVector3 &right);
LLVector3 roundToPixel(const LLVector3 &pos_agent);
@@ -117,9 +117,9 @@ class LLViewerCamera : public LLCamera, public LLSingleton<LLViewerCamera>
F32 getDefaultFOV() { return mCameraFOVDefault; }
BOOL cameraUnderWater() const;
-
- const LLVector3 &getPointOfInterest() { return mLastPointOfInterest; }
BOOL areVertsVisible(LLViewerObject* volumep, BOOL all_verts);
+
+ const LLVector3 &getPointOfInterest() { return mLastPointOfInterest; }
F32 getPixelMeterRatio() const { return mPixelMeterRatio; }
S32 getScreenPixelArea() const { return mScreenPixelArea; }
@@ -130,12 +130,12 @@ class LLViewerCamera : public LLCamera, public LLSingleton<LLViewerCamera>
protected:
void calcProjection(const F32 far_distance) const;
- LLStat mVelocityStat;
- LLStat mAngularVelocityStat;
- LLVector3 mVelocityDir ;
- F32 mAverageSpeed ;
- F32 mAverageAngularSpeed ;
+ static LLTrace::Count<> sVelocityStat;
+ static LLTrace::Count<> sAngularVelocityStat;
+ LLVector3 mVelocityDir ;
+ F32 mAverageSpeed ;
+ F32 mAverageAngularSpeed ;
mutable LLMatrix4 mProjectionMatrix; // Cache of perspective matrix
mutable LLMatrix4 mModelviewMatrix;
F32 mCameraFOVDefault;
diff --git a/indra/newview/llviewerdisplay.cpp b/indra/newview/llviewerdisplay.cpp
index 169b45c14ea3a8f14980d38081aacb4984fe739b..41a08398bbded75e4fba368aa2b77452bfa16672 100644
--- a/indra/newview/llviewerdisplay.cpp
+++ b/indra/newview/llviewerdisplay.cpp
@@ -748,8 +748,10 @@ void display(BOOL rebuild, F32 zoom_factor, int subfield, BOOL for_snapshot)
{
LLFastTimer t(FTM_IMAGE_UPDATE_CLASS);
- LLViewerTexture::updateClass(LLViewerCamera::getInstance()->getVelocityStat()->getMean(),
- LLViewerCamera::getInstance()->getAngularVelocityStat()->getMean());
+ LLTrace::Count<>* velocity_stat = LLViewerCamera::getVelocityStat();
+ LLTrace::Count<>* angular_velocity_stat = LLViewerCamera::getAngularVelocityStat();
+ LLViewerTexture::updateClass(LLTrace::get_frame_recording().getPeriodMeanPerSec(*velocity_stat),
+ LLTrace::get_frame_recording().getPeriodMeanPerSec(*angular_velocity_stat));
}
diff --git a/indra/newview/llviewermessage.cpp b/indra/newview/llviewermessage.cpp
index 82caa059831415d46410ee1d42b8b72b50db108b..acbe836c2913cf75d9cb5c533ad96d4f823170fa 100755
--- a/indra/newview/llviewermessage.cpp
+++ b/indra/newview/llviewermessage.cpp
@@ -4765,28 +4765,6 @@ void process_sim_stats(LLMessageSystem *msg, void **user_data)
}
}
- /*
- msg->getF32Fast(_PREHASH_Statistics, _PREHASH_PhysicsTimeDilation, time_dilation);
- LLViewerStats::getInstance()->mSimTDStat.addValue(time_dilation);
-
- // Process information
- // { CpuUsage F32 }
- // { SimMemTotal F32 }
- // { SimMemRSS F32 }
- // { ProcessUptime F32 }
- F32 cpu_usage;
- F32 sim_mem_total;
- F32 sim_mem_rss;
- F32 process_uptime;
- msg->getF32Fast(_PREHASH_Statistics, _PREHASH_CpuUsage, cpu_usage);
- msg->getF32Fast(_PREHASH_Statistics, _PREHASH_SimMemTotal, sim_mem_total);
- msg->getF32Fast(_PREHASH_Statistics, _PREHASH_SimMemRSS, sim_mem_rss);
- msg->getF32Fast(_PREHASH_Statistics, _PREHASH_ProcessUptime, process_uptime);
- LLViewerStats::getInstance()->mSimCPUUsageStat.addValue(cpu_usage);
- LLViewerStats::getInstance()->mSimMemTotalStat.addValue(sim_mem_total);
- LLViewerStats::getInstance()->mSimMemRSSStat.addValue(sim_mem_rss);
- */
-
//
// Various hacks that aren't statistics, but are being handled here.
//
diff --git a/indra/newview/llviewerobjectlist.cpp b/indra/newview/llviewerobjectlist.cpp
index 14a2ac3384218be080599fbb8fd120592a81d2aa..9c6045943fe7326654ac8b5a8bf375bdacdb0dbb 100644
--- a/indra/newview/llviewerobjectlist.cpp
+++ b/indra/newview/llviewerobjectlist.cpp
@@ -93,7 +93,7 @@ extern LLPipeline gPipeline;
U32 LLViewerObjectList::sSimulatorMachineIndex = 1; // Not zero deliberately, to speed up index check.
std::map<U64, U32> LLViewerObjectList::sIPAndPortToIndex;
std::map<U64, LLUUID> LLViewerObjectList::sIndexAndLocalIDToUUID;
-LLStat LLViewerObjectList::sCacheHitRate("object_cache_hits", 128);
+LLTrace::Measurement<> LLViewerObjectList::sCacheHitRate("object_cache_hits");
LLViewerObjectList::LLViewerObjectList()
{
@@ -520,7 +520,7 @@ void LLViewerObjectList::processObjectUpdate(LLMessageSystem *mesgsys,
}
justCreated = TRUE;
mNumNewObjects++;
- sCacheHitRate.addValue(cached ? 100.f : 0.f);
+ sCacheHitRate.sample(cached ? 100.f : 0.f);
}
diff --git a/indra/newview/llviewerobjectlist.h b/indra/newview/llviewerobjectlist.h
index 9936432a71e288c7e3e73942725fbe24ea6e5486..ca4110230f3014ab6e57881805e062d65f4aea5a 100644
--- a/indra/newview/llviewerobjectlist.h
+++ b/indra/newview/llviewerobjectlist.h
@@ -31,8 +31,8 @@
#include <set>
// common includes
-#include "llstat.h"
#include "llstring.h"
+#include "lltrace.h"
// project includes
#include "llviewerobject.h"
@@ -194,7 +194,7 @@ class LLViewerObjectList
std::vector<OrphanInfo> mOrphanChildren; // UUID's of orphaned objects
S32 mNumOrphans;
- static LLStat sCacheHitRate;
+ static LLTrace::Measurement<> sCacheHitRate;
typedef std::vector<LLPointer<LLViewerObject> > vobj_list_t;
diff --git a/indra/newview/llviewerregion.cpp b/indra/newview/llviewerregion.cpp
index 31e3820a2174c9167c7970e27ed4065231a69393..652e0ee70bc46f85e045b8e895dc444adf1e6d69 100644
--- a/indra/newview/llviewerregion.cpp
+++ b/indra/newview/llviewerregion.cpp
@@ -291,7 +291,9 @@ LLViewerRegion::LLViewerRegion(const U64 &handle,
mCacheLoaded(FALSE),
mCacheDirty(FALSE),
mReleaseNotesRequested(FALSE),
- mCapabilitiesReceived(false)
+ mCapabilitiesReceived(false),
+ mBitsReceived(0.f),
+ mPacketsReceived(0.f)
{
mWidth = region_width_meters;
mImpl->mOriginGlobal = from_region_handle(handle);
@@ -909,9 +911,8 @@ void LLViewerRegion::updateNetStats()
mPacketsLost = cdp->getPacketsLost();
mPingDelay = cdp->getPingDelay();
- mBitStat.addValue(mBitsIn - mLastBitsIn);
- mPacketsStat.addValue(mPacketsIn - mLastPacketsIn);
- mPacketsLostStat.addValue(mPacketsLost);
+ mBitsReceived += mBitsIn - mLastBitsIn;
+ mPacketsReceived += mPacketsIn - mLastPacketsIn;
}
diff --git a/indra/newview/llviewerregion.h b/indra/newview/llviewerregion.h
index c9fffaf30e4abff15de3dbc7f31bddf8bef0cbbe..756c0dc61fea6dc3201662ee8ef9bc978b1823bb 100644
--- a/indra/newview/llviewerregion.h
+++ b/indra/newview/llviewerregion.h
@@ -34,7 +34,6 @@
#include "lldarray.h"
#include "llwind.h"
-#include "llstat.h"
#include "v3dmath.h"
#include "llstring.h"
#include "llregionflags.h"
@@ -351,9 +350,8 @@ class LLViewerRegion: public LLCapabilityProvider // implements this interface
LLWind mWind;
LLViewerParcelOverlay *mParcelOverlay;
- LLStat mBitStat;
- LLStat mPacketsStat;
- LLStat mPacketsLostStat;
+ F32 mBitsReceived;
+ F32 mPacketsReceived;
LLMatrix4 mRenderMatrix;
diff --git a/indra/newview/llviewerstats.cpp b/indra/newview/llviewerstats.cpp
index 04b0c30b4008dd160305e54f63bb8b6dfa20ef18..a42368cec4ba1c212ba4f7b0f1c8ebe94f2ba658 100755
--- a/indra/newview/llviewerstats.cpp
+++ b/indra/newview/llviewerstats.cpp
@@ -94,8 +94,8 @@ LLTrace::Count<LLTrace::Kilobits> KBIT("kbitstat"),
OBJECT_KBIT("objectkbitstat"),
ASSET_KBIT("assetkbitstat"),
TEXTURE_KBIT("texturekbitstat"),
- ACTUAL_IN_KBIT("actualinkbit"),
- ACTUAL_OUT_KBIT("actualoutkbit");
+ ACTUAL_IN_KBIT("actualinkbitstat"),
+ ACTUAL_OUT_KBIT("actualoutkbitstat");
LLTrace::Count<LLTrace::Seconds> AVATAR_EDIT_TIME("avataredittime", "Seconds in Edit Appearence"),
TOOLBOX_TIME("toolboxtime", "Seconds using Toolbox"),
@@ -276,20 +276,25 @@ void LLViewerStats::addToMessage(LLSD &body) const
// *NOTE:Mani The following methods used to exist in viewer.cpp
// Moving them here, but not merging them into LLViewerStats yet.
-U32 gTotalLandIn = 0, gTotalLandOut = 0;
-U32 gTotalWaterIn = 0, gTotalWaterOut = 0;
-
-F32 gAveLandCompression = 0.f, gAveWaterCompression = 0.f;
-F32 gBestLandCompression = 1.f, gBestWaterCompression = 1.f;
-F32 gWorstLandCompression = 0.f, gWorstWaterCompression = 0.f;
+U32 gTotalLandIn = 0,
+ gTotalLandOut = 0,
+ gTotalWaterIn = 0,
+ gTotalWaterOut = 0;
+
+F32 gAveLandCompression = 0.f,
+ gAveWaterCompression = 0.f,
+ gBestLandCompression = 1.f,
+ gBestWaterCompression = 1.f,
+ gWorstLandCompression = 0.f,
+ gWorstWaterCompression = 0.f;
LLUnit::Bytes<U32> gTotalWorldData = 0,
gTotalObjectData = 0,
gTotalTextureData = 0;
-U32 gSimPingCount = 0;
+U32 gSimPingCount = 0;
LLUnit::Bits<U32> gObjectData = 0;
-F32 gAvgSimPing = 0.f;
-LLUnit::Bytes<U32> gTotalTextureBytesPerBoostLevel[LLViewerTexture::MAX_GL_IMAGE_CATEGORY] = {0};
+F32 gAvgSimPing = 0.f;
+LLUnit::Bytes<U32> gTotalTextureBytesPerBoostLevel[LLViewerTexture::MAX_GL_IMAGE_CATEGORY] = {0};
extern U32 gVisCompared;
extern U32 gVisTested;
@@ -334,13 +339,13 @@ void update_statistics()
LLCircuitData *cdp = gMessageSystem->mCircuitInfo.findCircuit(gAgent.getRegion()->getHost());
if (cdp)
{
- LLStatViewer::SIM_PING.sample<LLTrace::Seconds>(cdp->getPingDelay());
+ LLStatViewer::SIM_PING.sample<LLTrace::Milliseconds>(cdp->getPingDelay());
gAvgSimPing = ((gAvgSimPing * (F32)gSimPingCount) + (F32)(cdp->getPingDelay())) / ((F32)gSimPingCount + 1);
gSimPingCount++;
}
else
{
- LLStatViewer::SIM_PING.sample<LLTrace::Seconds>(10000);
+ LLStatViewer::SIM_PING.sample<LLTrace::Seconds>(10);
}
LLStatViewer::FPS.add(1);
@@ -390,8 +395,6 @@ void update_statistics()
texture_stats_timer.reset();
}
}
-
- LLTrace::get_frame_recording().nextPeriod();
}
class ViewerStatsResponder : public LLHTTPClient::Responder
diff --git a/indra/newview/llviewerstats.h b/indra/newview/llviewerstats.h
index 34731481f5e8efa092de1309249d025a9a115330..eda7b3329d95447e44d103352b3ec3984ebbf402 100755
--- a/indra/newview/llviewerstats.h
+++ b/indra/newview/llviewerstats.h
@@ -27,7 +27,6 @@
#ifndef LL_LLVIEWERSTATS_H
#define LL_LLVIEWERSTATS_H
-#include "llstat.h"
#include "llstatenums.h"
#include "lltextureinfo.h"
#include "lltracerecording.h"
diff --git a/indra/newview/llviewertexturelist.h b/indra/newview/llviewertexturelist.h
index a00f48b5a2dd15be8a672e42e0ea40623a4ea3af..e3df71cca26fe7f89d4d7a1bb690bb10e72faaf3 100644
--- a/indra/newview/llviewertexturelist.h
+++ b/indra/newview/llviewertexturelist.h
@@ -30,7 +30,6 @@
#include "lluuid.h"
//#include "message.h"
#include "llgl.h"
-#include "llstat.h"
#include "llviewertexture.h"
#include "llui.h"
#include <list>
diff --git a/indra/newview/llviewerwindow.cpp b/indra/newview/llviewerwindow.cpp
index 06daf15c08ae43ba6e7a3d3fb6ccb2f4e887a0c9..b7415669bb494f3935e98ed2b843b7ead3c78fd8 100755
--- a/indra/newview/llviewerwindow.cpp
+++ b/indra/newview/llviewerwindow.cpp
@@ -77,7 +77,6 @@
#include "llmediaentry.h"
#include "llurldispatcher.h"
#include "raytrace.h"
-#include "llstat.h"
// newview includes
#include "llagent.h"
@@ -249,6 +248,9 @@ std::string LLViewerWindow::sSnapshotDir;
std::string LLViewerWindow::sMovieBaseName;
+LLTrace::Measurement<> LLViewerWindow::sMouseVelocityStat("Mouse Velocity");
+
+
class RecordToChatConsole : public LLError::Recorder, public LLSingleton<RecordToChatConsole>
{
public:
@@ -1541,8 +1543,7 @@ LLViewerWindow::LLViewerWindow(const Params& p)
mResDirty(false),
mStatesDirty(false),
mCurrResolutionIndex(0),
- mProgressView(NULL),
- mMouseVelocityStat(new LLStat("Mouse Velocity"))
+ mProgressView(NULL)
{
// gKeyboard is still NULL, so it doesn't do LLWindowListener any good to
// pass its value right now. Instead, pass it a nullary function that
@@ -2072,8 +2073,6 @@ LLViewerWindow::~LLViewerWindow()
delete mDebugText;
mDebugText = NULL;
-
- delete mMouseVelocityStat;
}
@@ -3247,7 +3246,7 @@ void LLViewerWindow::updateMouseDelta()
mouse_vel.setVec((F32) dx, (F32) dy);
}
- mMouseVelocityStat->addValue(mouse_vel.magVec());
+ sMouseVelocityStat.sample(mouse_vel.magVec());
}
void LLViewerWindow::updateKeyboardFocus()
diff --git a/indra/newview/llviewerwindow.h b/indra/newview/llviewerwindow.h
index 5f475fe145b2a79bf32a8b904cb578d0e3dd06c9..be2d6d885edbc3882180c452d69e3c4754f0869e 100644
--- a/indra/newview/llviewerwindow.h
+++ b/indra/newview/llviewerwindow.h
@@ -44,12 +44,12 @@
#include "llmousehandler.h"
#include "llhandle.h"
#include "llinitparam.h"
+#include "lltrace.h"
#include <boost/function.hpp>
#include <boost/signals2.hpp>
#include <boost/scoped_ptr.hpp>
-class LLStat;
class LLView;
class LLViewerObject;
class LLUUID;
@@ -250,7 +250,7 @@ class LLViewerWindow : public LLWindowCallbacks
S32 getCurrentMouseDX() const { return mCurrentMouseDelta.mX; }
S32 getCurrentMouseDY() const { return mCurrentMouseDelta.mY; }
LLCoordGL getCurrentMouseDelta() const { return mCurrentMouseDelta; }
- LLStat* getMouseVelocityStat() { return mMouseVelocityStat; }
+ static LLTrace::Measurement<>* getMouseVelocityStat() { return &sMouseVelocityStat; }
BOOL getLeftMouseDown() const { return mLeftMouseDown; }
BOOL getMiddleMouseDown() const { return mMiddleMouseDown; }
BOOL getRightMouseDown() const { return mRightMouseDown; }
@@ -427,7 +427,6 @@ class LLViewerWindow : public LLWindowCallbacks
LLCoordGL mCurrentMousePoint; // last mouse position in GL coords
LLCoordGL mLastMousePoint; // Mouse point at last frame.
LLCoordGL mCurrentMouseDelta; //amount mouse moved this frame
- LLStat* mMouseVelocityStat;
BOOL mLeftMouseDown;
BOOL mMiddleMouseDown;
BOOL mRightMouseDown;
@@ -482,6 +481,8 @@ class LLViewerWindow : public LLWindowCallbacks
// Object temporarily hovered over while dragging
LLPointer<LLViewerObject> mDragHoveredObject;
+
+ static LLTrace::Measurement<> sMouseVelocityStat;
};
//
diff --git a/indra/newview/llvoavatar.cpp b/indra/newview/llvoavatar.cpp
index 97c1b07ebc417f90fb27c95c8a2be68924374d46..3c1f8ca6b08aa1618dbdb916a4b4c53b3d904f5a 100755
--- a/indra/newview/llvoavatar.cpp
+++ b/indra/newview/llvoavatar.cpp
@@ -4318,8 +4318,6 @@ U32 LLVOAvatar::renderSkinned(EAvatarRenderPass pass)
//--------------------------------------------------------------------
// render all geometry attached to the skeleton
//--------------------------------------------------------------------
- static LLStat render_stat;
-
LLViewerJointMesh::sRenderPass = pass;
if (pass == AVATAR_RENDER_PASS_SINGLE)
@@ -4372,10 +4370,6 @@ U32 LLVOAvatar::renderSkinned(EAvatarRenderPass pass)
LLViewerJointMesh::sRenderPass = AVATAR_RENDER_PASS_SINGLE;
- //llinfos << "Avatar render: " << render_timer.getElapsedTimeF32() << llendl;
-
- //render_stat.addValue(render_timer.getElapsedTimeF32()*1000.f);
-
return num_indices;
}
diff --git a/indra/newview/llworld.cpp b/indra/newview/llworld.cpp
index dced5a847bae3b40915a8be000e65969ca65f5d8..e140f3b23bb9a9ef845eb566e30856a4577ef70a 100644
--- a/indra/newview/llworld.cpp
+++ b/indra/newview/llworld.cpp
@@ -692,8 +692,10 @@ void LLWorld::updateNetStats()
{
LLViewerRegion* regionp = *iter;
regionp->updateNetStats();
- bits += regionp->mBitStat.getCurrent();
- packets += llfloor( regionp->mPacketsStat.getCurrent() );
+ bits += regionp->mBitsReceived;
+ packets += llfloor( regionp->mPacketsReceived );
+ regionp->mBitsReceived = 0.f;
+ regionp->mPacketsReceived = 0.f;
}
S32 packets_in = gMessageSystem->mPacketsIn - mLastPacketsIn;
@@ -705,26 +707,15 @@ void LLWorld::updateNetStats()
LLStatViewer::ACTUAL_IN_KBIT.add<LLTrace::Bits>(actual_in_bits);
LLStatViewer::ACTUAL_OUT_KBIT.add<LLTrace::Bits>(actual_out_bits);
- //LLViewerStats::getInstance()->mActualInKBitStat.addValue(actual_in_bits/1024.f);
- //LLViewerStats::getInstance()->mActualOutKBitStat.addValue(actual_out_bits/1024.f);
LLStatViewer::KBIT.add<LLTrace::Bits>(bits);
- //LLViewerStats::getInstance()->mKBitStat.addValue(bits/1024.f);
LLStatViewer::PACKETS_IN.add(packets_in);
LLStatViewer::PACKETS_OUT.add(packets_out);
LLStatViewer::PACKETS_LOST.add(packets_lost);
LLStatViewer::PACKETS_LOST_PERCENT.sample(100.f*((F32)packets_lost/(F32)packets_in));
- //LLViewerStats::getInstance()->mPacketsInStat.addValue(packets_in);
- //LLViewerStats::getInstance()->mPacketsOutStat.addValue(packets_out);
- //LLViewerStats::getInstance()->mPacketsLostStat.addValue(gMessageSystem->mDroppedPackets);
if (packets_in)
{
LLStatViewer::PACKETS_LOST_PERCENT.sample(100.f*((F32)packets_lost/(F32)packets_in));
- // LLViewerStats::getInstance()->mPacketsLostPercentStat.addValue(100.f*((F32)packets_lost/(F32)packets_in));
}
- //else
- //{
- // LLViewerStats::getInstance()->mPacketsLostPercentStat.addValue(0.f);
- //}
mLastPacketsIn = gMessageSystem->mPacketsIn;
mLastPacketsOut = gMessageSystem->mPacketsOut;
diff --git a/indra/newview/pipeline.cpp b/indra/newview/pipeline.cpp
index 75af605ad7f3cf957e8f140dfcf2c25aa87b1fe9..1e050d2588ed2988138cbc8001dc4328d15f5ac4 100644
--- a/indra/newview/pipeline.cpp
+++ b/indra/newview/pipeline.cpp
@@ -488,7 +488,6 @@ void LLPipeline::init()
getPool(LLDrawPool::POOL_BUMP);
getPool(LLDrawPool::POOL_GLOW);
- //LLViewerStats::getInstance()->mTrianglesDrawnStat.reset();
resetFrameStats();
for (U32 i = 0; i < NUM_RENDER_TYPES; ++i)
@@ -1769,7 +1768,6 @@ void LLPipeline::resetFrameStats()
assertInitialized();
LLStatViewer::TRIANGLES_DRAWN.add(mTrianglesDrawn);
- //LLViewerStats::getInstance()->mTrianglesDrawnStat.addValue(mTrianglesDrawn/1000.f);
if (mBatchCount > 0)
{
@@ -9756,7 +9754,9 @@ void LLPipeline::generateSunShadow(LLCamera& camera)
if (gen_shadow)
{
- F32 fade_amt = gFrameIntervalSeconds.value() * llmax(LLViewerCamera::getInstance()->getVelocityStat()->getCurrentPerSec(), 1.f);
+ LLTrace::Measurement<>* velocity_stat = LLViewerCamera::getVelocityStat();
+ F32 fade_amt = gFrameIntervalSeconds.value()
+ * llmax(LLTrace::get_frame_recording().getLastRecordingPeriod().getLastValue(*velocity_stat), 1.0);
//update shadow targets
for (U32 i = 0; i < 2; i++)