summaryrefslogtreecommitdiff
path: root/indra/llcommon
diff options
context:
space:
mode:
Diffstat (limited to 'indra/llcommon')
-rw-r--r--indra/llcommon/llcriticaldamp.cpp77
-rw-r--r--indra/llcommon/llcriticaldamp.h32
-rw-r--r--indra/llcommon/lltrace.h81
-rw-r--r--indra/llcommon/lltracerecording.cpp74
-rw-r--r--indra/llcommon/lltracerecording.h75
-rw-r--r--indra/llcommon/llunit.h8
6 files changed, 160 insertions, 187 deletions
diff --git a/indra/llcommon/llcriticaldamp.cpp b/indra/llcommon/llcriticaldamp.cpp
index 87d79b1ee0..59a31bf9df 100644
--- a/indra/llcommon/llcriticaldamp.cpp
+++ b/indra/llcommon/llcriticaldamp.cpp
@@ -27,18 +27,38 @@
#include "linden_common.h"
#include "llcriticaldamp.h"
+#include <algorithm>
//-----------------------------------------------------------------------------
// static members
//-----------------------------------------------------------------------------
-LLFrameTimer LLCriticalDamp::sInternalTimer;
-std::map<F32, F32> LLCriticalDamp::sInterpolants;
-F32 LLCriticalDamp::sTimeDelta;
+LLFrameTimer LLSmoothInterpolation::sInternalTimer;
+std::vector<LLSmoothInterpolation::Interpolant> LLSmoothInterpolation::sInterpolants;
+F32 LLSmoothInterpolation::sTimeDelta;
+
+// helper functors
+struct LLSmoothInterpolation::CompareTimeConstants
+{
+ bool operator()(const F32& a, const LLSmoothInterpolation::Interpolant& b) const
+ {
+ return a < b.mTimeScale;
+ }
+
+ bool operator()(const LLSmoothInterpolation::Interpolant& a, const F32& b) const
+ {
+ return a.mTimeScale < b; // bottom of a is higher than bottom of b
+ }
+
+ bool operator()(const LLSmoothInterpolation::Interpolant& a, const LLSmoothInterpolation::Interpolant& b) const
+ {
+ return a.mTimeScale < b.mTimeScale; // bottom of a is higher than bottom of b
+ }
+};
//-----------------------------------------------------------------------------
-// LLCriticalDamp()
+// LLSmoothInterpolation()
//-----------------------------------------------------------------------------
-LLCriticalDamp::LLCriticalDamp()
+LLSmoothInterpolation::LLSmoothInterpolation()
{
sTimeDelta = 0.f;
}
@@ -47,43 +67,54 @@ LLCriticalDamp::LLCriticalDamp()
//-----------------------------------------------------------------------------
// updateInterpolants()
//-----------------------------------------------------------------------------
-void LLCriticalDamp::updateInterpolants()
+void LLSmoothInterpolation::updateInterpolants()
{
sTimeDelta = sInternalTimer.getElapsedTimeAndResetF32();
- F32 time_constant;
-
- for (std::map<F32, F32>::iterator iter = sInterpolants.begin();
- iter != sInterpolants.end(); iter++)
+ for (S32 i = 0; i < sInterpolants.size(); i++)
{
- time_constant = iter->first;
- F32 new_interpolant = 1.f - pow(2.f, -sTimeDelta / time_constant);
- new_interpolant = llclamp(new_interpolant, 0.f, 1.f);
- sInterpolants[time_constant] = new_interpolant;
+ Interpolant& interp = sInterpolants[i];
+ interp.mInterpolant = calcInterpolant(interp.mTimeScale);
}
}
//-----------------------------------------------------------------------------
// getInterpolant()
//-----------------------------------------------------------------------------
-F32 LLCriticalDamp::getInterpolant(const F32 time_constant, BOOL use_cache)
+F32 LLSmoothInterpolation::getInterpolant(LLUnit<LLUnits::Seconds, F32> time_constant, bool use_cache)
{
if (time_constant == 0.f)
{
return 1.f;
}
- if (use_cache && sInterpolants.count(time_constant))
+ if (use_cache)
{
- return sInterpolants[time_constant];
+ interpolant_vec_t::iterator find_it = std::lower_bound(sInterpolants.begin(), sInterpolants.end(), time_constant.value(), CompareTimeConstants());
+ if (find_it != sInterpolants.end() && find_it->mTimeScale == time_constant)
+ {
+ return find_it->mInterpolant;
+ }
+ else
+ {
+ Interpolant interp;
+ interp.mTimeScale = time_constant.value();
+ interp.mInterpolant = calcInterpolant(time_constant.value());
+ sInterpolants.insert(find_it, interp);
+ return interp.mInterpolant;
+ }
}
-
- F32 interpolant = 1.f - pow(2.f, -sTimeDelta / time_constant);
- interpolant = llclamp(interpolant, 0.f, 1.f);
- if (use_cache)
+ else
{
- sInterpolants[time_constant] = interpolant;
+ return calcInterpolant(time_constant.value());
+
}
+}
- return interpolant;
+//-----------------------------------------------------------------------------
+// getInterpolant()
+//-----------------------------------------------------------------------------
+F32 LLSmoothInterpolation::calcInterpolant(F32 time_constant)
+{
+ return llclamp(1.f - pow(2.f, -sTimeDelta / time_constant), 0.f, 1.f);
}
diff --git a/indra/llcommon/llcriticaldamp.h b/indra/llcommon/llcriticaldamp.h
index 52f052ae25..ab5d4ba6e2 100644
--- a/indra/llcommon/llcriticaldamp.h
+++ b/indra/llcommon/llcriticaldamp.h
@@ -28,26 +28,46 @@
#ifndef LL_LLCRITICALDAMP_H
#define LL_LLCRITICALDAMP_H
-#include <map>
+#include <vector>
#include "llframetimer.h"
+#include "llunit.h"
-class LL_COMMON_API LLCriticalDamp
+class LL_COMMON_API LLSmoothInterpolation
{
public:
- LLCriticalDamp();
+ LLSmoothInterpolation();
// MANIPULATORS
static void updateInterpolants();
// ACCESSORS
- static F32 getInterpolant(const F32 time_constant, BOOL use_cache = TRUE);
+ static F32 getInterpolant(LLUnit<LLUnits::Seconds, F32> time_constant, bool use_cache = true);
-protected:
+ template<typename T>
+ static T lerp(T a, T b, LLUnit<LLUnits::Seconds, F32> time_constant, bool use_cache = true)
+ {
+ F32 interpolant = getInterpolant(time_constant, use_cache);
+ return ((a * (1.f - interpolant))
+ + (b * interpolant));
+ }
+
+protected:
+ static F32 calcInterpolant(F32 time_constant);
+
+ struct CompareTimeConstants;
static LLFrameTimer sInternalTimer; // frame timer for calculating deltas
- static std::map<F32, F32> sInterpolants;
+ struct Interpolant
+ {
+ F32 mTimeScale;
+ F32 mInterpolant;
+ };
+ typedef std::vector<Interpolant> interpolant_vec_t;
+ static interpolant_vec_t sInterpolants;
static F32 sTimeDelta;
};
+typedef LLSmoothInterpolation LLCriticalDamp;
+
#endif // LL_LLCRITICALDAMP_H
diff --git a/indra/llcommon/lltrace.h b/indra/llcommon/lltrace.h
index 9bca3625b6..71bf1e53e4 100644
--- a/indra/llcommon/lltrace.h
+++ b/indra/llcommon/lltrace.h
@@ -674,57 +674,6 @@ struct MemFootprint<std::list<T> >
}
};
-template <size_t ALIGNMENT, size_t RESERVE>
-void* allocAligned(size_t size)
-{
- llstatic_assert((ALIGNMENT > 0) && (ALIGNMENT & (ALIGNMENT - 1)) == 0, "Alignment must be a power of 2");
-
- void* padded_allocation;
- const size_t aligned_reserve = (RESERVE / ALIGNMENT)
- + ((RESERVE % ALIGNMENT) ? ALIGNMENT : 0);
- const size_t size_with_reserve = size + aligned_reserve;
- if (ALIGNMENT <= LL_DEFAULT_HEAP_ALIGN)
- {
- padded_allocation = malloc(size_with_reserve);
- }
- else
- {
-#if LL_WINDOWS
- padded_allocation = _aligned_malloc(size_with_reserve, ALIGNMENT);
-#elif LL_DARWIN
- padded_allocation = ll_aligned_malloc(size_with_reserve, ALIGNMENT);
-#else
- if (LL_UNLIKELY(0 != posix_memalign(&padded_allocation, 16, size)))
- padded_allocation = NULL;
-#endif
- }
- return (char*)padded_allocation + aligned_reserve;
-}
-
-template<size_t ALIGNMENT, size_t RESERVE>
-void deallocAligned(void* ptr)
-{
- const size_t aligned_reserve = (RESERVE / ALIGNMENT)
- + ((RESERVE % ALIGNMENT) ? ALIGNMENT : 0);
-
- void* original_allocation = (char*)ptr - aligned_reserve;
-
- if (ALIGNMENT <= LL_DEFAULT_HEAP_ALIGN)
- {
- free(original_allocation);
- }
- else
- {
-#if LL_WINDOWS
- _aligned_free(original_allocation);
-#elif LL_DARWIN
- ll_aligned_free(original_allocation);
-#else
- free(original_allocation);
-#endif
- }
-}
-
template<typename DERIVED, size_t ALIGNMENT = LL_DEFAULT_HEAP_ALIGN>
class MemTrackable
{
@@ -736,7 +685,7 @@ class MemTrackable
public:
typedef void mem_trackable_tag_t;
- ~MemTrackable()
+ virtual ~MemTrackable()
{
memDisclaim(mMemFootprint);
}
@@ -750,24 +699,19 @@ public:
accumulator->mAllocatedCount++;
}
- // reserve 4 bytes for allocation size (and preserving requested alignment)
- void* allocation = allocAligned<ALIGNMENT, sizeof(size_t)>(size);
- ((size_t*)allocation)[-1] = size;
-
- return allocation;
+ return ::operator new(size);
}
- void operator delete(void* ptr)
+ void operator delete(void* ptr, size_t size)
{
- size_t allocation_size = ((size_t*)ptr)[-1];
MemStatAccumulator* accumulator = DERIVED::sMemStat.getPrimaryAccumulator();
if (accumulator)
{
- accumulator->mSize -= allocation_size;
+ accumulator->mSize -= size;
accumulator->mAllocatedCount--;
accumulator->mDeallocatedCount++;
}
- deallocAligned<ALIGNMENT, sizeof(size_t)>(ptr);
+ ::operator delete(ptr);
}
void *operator new [](size_t size)
@@ -779,24 +723,19 @@ public:
accumulator->mAllocatedCount++;
}
- // reserve 4 bytes for allocation size (and preserving requested alignment)
- void* allocation = allocAligned<ALIGNMENT, sizeof(size_t)>(size);
- ((size_t*)allocation)[-1] = size;
-
- return allocation;
+ return ::operator new[](size);
}
- void operator delete[](void* ptr)
+ void operator delete[](void* ptr, size_t size)
{
- size_t* allocation_size = (size_t*)((char*)ptr - 8);
MemStatAccumulator* accumulator = DERIVED::sMemStat.getPrimaryAccumulator();
if (accumulator)
{
- accumulator->mSize -= *allocation_size;
+ accumulator->mSize -= size;
accumulator->mAllocatedCount--;
accumulator->mDeallocatedCount++;
}
- deallocAligned<ALIGNMENT, sizeof(size_t)>(ptr);
+ ::operator delete[](ptr);
}
// claim memory associated with other objects/data as our own, adding to our calculated footprint
@@ -853,8 +792,6 @@ public:
private:
size_t mMemFootprint;
-
-
template<typename TRACKED, typename TRACKED_IS_TRACKER = void>
struct TrackMemImpl
{
diff --git a/indra/llcommon/lltracerecording.cpp b/indra/llcommon/lltracerecording.cpp
index ef0a633c9c..5d74ea32df 100644
--- a/indra/llcommon/lltracerecording.cpp
+++ b/indra/llcommon/lltracerecording.cpp
@@ -291,23 +291,6 @@ U32 Recording::getSampleCount( const TraceType<CountAccumulator<S64> >& stat ) c
return (*mMeasurementsFloat)[stat.getIndex()].getSampleCount();
}
-
-F64 Recording::getPerSec( const TraceType<MeasurementAccumulator<F64> >& stat ) const
-{
- F64 sum = (*mMeasurementsFloat)[stat.getIndex()].getSum();
- return (sum != 0.0)
- ? (sum / mElapsedSeconds)
- : 0.0;
-}
-
-F64 Recording::getPerSec( const TraceType<MeasurementAccumulator<S64> >& stat ) const
-{
- S64 sum = (*mMeasurements)[stat.getIndex()].getSum();
- return (sum != 0)
- ? ((F64)sum / mElapsedSeconds)
- : 0.0;
-}
-
F64 Recording::getMin( const TraceType<MeasurementAccumulator<F64> >& stat ) const
{
return (*mMeasurementsFloat)[stat.getIndex()].getMin();
@@ -372,41 +355,30 @@ U32 Recording::getSampleCount( const TraceType<MeasurementAccumulator<S64> >& st
// PeriodicRecording
///////////////////////////////////////////////////////////////////////
-PeriodicRecording::PeriodicRecording( S32 num_periods, EPlayState state)
-: mNumPeriods(num_periods),
+PeriodicRecording::PeriodicRecording( U32 num_periods, EPlayState state)
+: mAutoResize(num_periods == 0),
mCurPeriod(0),
- mTotalValid(false),
- mRecordingPeriods( new Recording[num_periods])
-{
- llassert(mNumPeriods > 0);
- setPlayState(state);
-}
-
-PeriodicRecording::PeriodicRecording(PeriodicRecording& other)
-: mNumPeriods(other.mNumPeriods),
- mCurPeriod(other.mCurPeriod),
- mTotalValid(other.mTotalValid),
- mTotalRecording(other.mTotalRecording)
+ mTotalValid(false)
{
- mRecordingPeriods = new Recording[mNumPeriods];
- for (S32 i = 0; i < mNumPeriods; i++)
+ if (num_periods)
{
- mRecordingPeriods[i] = other.mRecordingPeriods[i];
+ mRecordingPeriods.resize(num_periods);
}
+ setPlayState(state);
}
-
-PeriodicRecording::~PeriodicRecording()
-{
- delete[] mRecordingPeriods;
-}
-
-
void PeriodicRecording::nextPeriod()
{
EPlayState play_state = getPlayState();
Recording& old_recording = getCurRecordingPeriod();
- mCurPeriod = (mCurPeriod + 1) % mNumPeriods;
+ if (mAutoResize)
+ {
+ mRecordingPeriods.push_back(Recording());
+ }
+ U32 num_periods = mRecordingPeriods.size();
+ mCurPeriod = (num_periods > 0)
+ ? (mCurPeriod + 1) % num_periods
+ : mCurPeriod + 1;
old_recording.splitTo(getCurRecordingPeriod());
switch(play_state)
@@ -429,9 +401,21 @@ Recording& PeriodicRecording::getTotalRecording()
if (!mTotalValid)
{
mTotalRecording.reset();
- for (S32 i = mCurPeriod + 1; i < mCurPeriod + mNumPeriods; i++)
+ U32 num_periods = mRecordingPeriods.size();
+
+ if (num_periods)
+ {
+ for (S32 i = mCurPeriod + 1; i < mCurPeriod + num_periods; i++)
+ {
+ mTotalRecording.appendRecording(mRecordingPeriods[i % num_periods]);
+ }
+ }
+ else
{
- mTotalRecording.appendRecording(mRecordingPeriods[i % mNumPeriods]);
+ for (S32 i = 0; i < mCurPeriod; i++)
+ {
+ mTotalRecording.appendRecording(mRecordingPeriods[i]);
+ }
}
}
mTotalValid = true;
@@ -547,7 +531,7 @@ void ExtendableRecording::splitFrom(ExtendableRecording& other)
PeriodicRecording& get_frame_recording()
{
- static LLThreadLocalPointer<PeriodicRecording> sRecording(new PeriodicRecording(200, PeriodicRecording::STARTED));
+ static LLThreadLocalPointer<PeriodicRecording> sRecording(new PeriodicRecording(1000, PeriodicRecording::STARTED));
return *sRecording;
}
diff --git a/indra/llcommon/lltracerecording.h b/indra/llcommon/lltracerecording.h
index a5edcb857a..3e7ed2b592 100644
--- a/indra/llcommon/lltracerecording.h
+++ b/indra/llcommon/lltracerecording.h
@@ -100,15 +100,10 @@ private:
namespace LLTrace
{
- struct RecordingBuffers
+ class RecordingBuffers
{
+ public:
RecordingBuffers();
- LLCopyOnWritePointer<AccumulatorBuffer<CountAccumulator<F64> > > mCountsFloat;
- LLCopyOnWritePointer<AccumulatorBuffer<MeasurementAccumulator<F64> > > mMeasurementsFloat;
- LLCopyOnWritePointer<AccumulatorBuffer<CountAccumulator<S64> > > mCounts;
- LLCopyOnWritePointer<AccumulatorBuffer<MeasurementAccumulator<S64> > > mMeasurements;
- LLCopyOnWritePointer<AccumulatorBuffer<TimeBlockAccumulator> > mStackTimers;
- LLCopyOnWritePointer<AccumulatorBuffer<MemStatAccumulator> > mMemStats;
void handOffTo(RecordingBuffers& other);
void makePrimary();
@@ -120,6 +115,13 @@ namespace LLTrace
void mergeBuffers(const RecordingBuffers& other);
void resetBuffers(RecordingBuffers* other = NULL);
+ protected:
+ LLCopyOnWritePointer<AccumulatorBuffer<CountAccumulator<F64> > > mCountsFloat;
+ LLCopyOnWritePointer<AccumulatorBuffer<MeasurementAccumulator<F64> > > mMeasurementsFloat;
+ LLCopyOnWritePointer<AccumulatorBuffer<CountAccumulator<S64> > > mCounts;
+ LLCopyOnWritePointer<AccumulatorBuffer<MeasurementAccumulator<S64> > > mMeasurements;
+ LLCopyOnWritePointer<AccumulatorBuffer<TimeBlockAccumulator> > mStackTimers;
+ LLCopyOnWritePointer<AccumulatorBuffer<MemStatAccumulator> > mMemStats;
};
class Recording : public LLStopWatchControlsMixin<Recording>, public RecordingBuffers
@@ -182,14 +184,6 @@ namespace LLTrace
return (T)getSum(static_cast<const TraceType<MeasurementAccumulator<typename LLUnits::HighestPrecisionType<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 MeasurementStatHandle<T>& stat) const
- {
- return (T)getPerSec(static_cast<const TraceType<MeasurementAccumulator<typename LLUnits::HighestPrecisionType<T>::type_t> >&> (stat));
- }
-
F64 getMin(const TraceType<MeasurementAccumulator<F64> >& stat) const;
S64 getMin(const TraceType<MeasurementAccumulator<S64> >& stat) const;
template <typename T>
@@ -255,16 +249,15 @@ namespace LLTrace
: public LLStopWatchControlsMixin<PeriodicRecording>
{
public:
- PeriodicRecording(S32 num_periods, EPlayState state = STOPPED);
- PeriodicRecording(PeriodicRecording& recording);
- ~PeriodicRecording();
+ PeriodicRecording(U32 num_periods, EPlayState state = STOPPED);
void nextPeriod();
- S32 getNumPeriods() { return mNumPeriods; }
+ U32 getNumPeriods() { return mRecordingPeriods.size(); }
Recording& getLastRecordingPeriod()
{
- return mRecordingPeriods[(mCurPeriod + mNumPeriods - 1) % mNumPeriods];
+ U32 num_periods = mRecordingPeriods.size();
+ return mRecordingPeriods[(mCurPeriod + num_periods - 1) % num_periods];
}
const Recording& getLastRecordingPeriod() const
@@ -282,16 +275,18 @@ namespace LLTrace
return mRecordingPeriods[mCurPeriod];
}
- Recording& getPrevRecordingPeriod(S32 offset)
+ Recording& getPrevRecordingPeriod(U32 offset)
{
- offset = llclamp(offset, 0, mNumPeriods - 1);
- return mRecordingPeriods[(mCurPeriod + mNumPeriods - offset) % mNumPeriods];
+ U32 num_periods = mRecordingPeriods.size();
+ offset = llclamp(offset, 0u, num_periods - 1);
+ return mRecordingPeriods[(mCurPeriod + num_periods - offset) % num_periods];
}
- const Recording& getPrevRecordingPeriod(S32 offset) const
+ const Recording& getPrevRecordingPeriod(U32 offset) const
{
- offset = llclamp(offset, 0, mNumPeriods - 1);
- return mRecordingPeriods[(mCurPeriod + mNumPeriods - offset) % mNumPeriods];
+ U32 num_periods = mRecordingPeriods.size();
+ offset = llclamp(offset, 0u, num_periods - 1);
+ return mRecordingPeriods[(mCurPeriod + num_periods - offset) % num_periods];
}
Recording snapshotCurRecordingPeriod() const
@@ -307,7 +302,8 @@ namespace LLTrace
typename T::value_t getPeriodMin(const TraceType<T>& stat) const
{
typename T::value_t min_val = (std::numeric_limits<typename T::value_t>::max)();
- for (S32 i = 0; i < mNumPeriods; i++)
+ U32 num_periods = mRecordingPeriods.size();
+ for (S32 i = 0; i < num_periods; i++)
{
min_val = llmin(min_val, mRecordingPeriods[i].getSum(stat));
}
@@ -318,7 +314,8 @@ namespace LLTrace
F64 getPeriodMinPerSec(const TraceType<T>& stat) const
{
F64 min_val = (std::numeric_limits<F64>::max)();
- for (S32 i = 0; i < mNumPeriods; i++)
+ U32 num_periods = mRecordingPeriods.size();
+ for (S32 i = 0; i < num_periods; i++)
{
min_val = llmin(min_val, mRecordingPeriods[i].getPerSec(stat));
}
@@ -329,7 +326,8 @@ namespace LLTrace
typename T::value_t getPeriodMax(const TraceType<T>& stat) const
{
typename T::value_t max_val = (std::numeric_limits<typename T::value_t>::min)();
- for (S32 i = 0; i < mNumPeriods; i++)
+ U32 num_periods = mRecordingPeriods.size();
+ for (S32 i = 0; i < num_periods; i++)
{
max_val = llmax(max_val, mRecordingPeriods[i].getSum(stat));
}
@@ -340,7 +338,8 @@ namespace LLTrace
F64 getPeriodMaxPerSec(const TraceType<T>& stat) const
{
F64 max_val = (std::numeric_limits<F64>::min)();
- for (S32 i = 0; i < mNumPeriods; i++)
+ U32 num_periods = mRecordingPeriods.size();
+ for (S32 i = 0; i < num_periods; i++)
{
max_val = llmax(max_val, mRecordingPeriods[i].getPerSec(stat));
}
@@ -351,14 +350,15 @@ namespace LLTrace
typename MeanValueType<TraceType<T> >::type getPeriodMean(const TraceType<T>& stat) const
{
typename MeanValueType<TraceType<T> >::type mean = 0.0;
- for (S32 i = 0; i < mNumPeriods; i++)
+ U32 num_periods = mRecordingPeriods.size();
+ for (S32 i = 0; i < num_periods; i++)
{
if (mRecordingPeriods[i].getDuration() > 0.f)
{
mean += mRecordingPeriods[i].getSum(stat);
}
}
- mean /= mNumPeriods;
+ mean /= num_periods;
return mean;
}
@@ -366,14 +366,15 @@ namespace LLTrace
typename MeanValueType<TraceType<T> >::type getPeriodMeanPerSec(const TraceType<T>& stat) const
{
typename MeanValueType<TraceType<T> >::type mean = 0.0;
- for (S32 i = 0; i < mNumPeriods; i++)
+ U32 num_periods = mRecordingPeriods.size();
+ for (S32 i = 0; i < num_periods; i++)
{
if (mRecordingPeriods[i].getDuration() > 0.f)
{
mean += mRecordingPeriods[i].getPerSec(stat);
}
}
- mean /= mNumPeriods;
+ mean /= num_periods;
return mean;
}
@@ -388,11 +389,11 @@ namespace LLTrace
/*virtual*/ void splitFrom(PeriodicRecording& other);
private:
- Recording* mRecordingPeriods;
+ std::vector<Recording> mRecordingPeriods;
Recording mTotalRecording;
bool mTotalValid;
- S32 mNumPeriods,
- mCurPeriod;
+ const bool mAutoResize;
+ S32 mCurPeriod;
};
PeriodicRecording& get_frame_recording();
diff --git a/indra/llcommon/llunit.h b/indra/llcommon/llunit.h
index 823550db5d..f86f111b90 100644
--- a/indra/llcommon/llunit.h
+++ b/indra/llcommon/llunit.h
@@ -143,7 +143,7 @@ struct LLUnit
void operator *= (LLUnit<OTHER_UNIT, OTHER_STORAGE> multiplicand)
{
// spurious use of dependent type to stop gcc from triggering the static assertion before instantiating the template
- llstatic_assert_template(OTHER_UNIT, 0, "Multiplication of unit types not supported.");
+ llstatic_assert_template(OTHER_UNIT, false, "Multiplication of unit types not supported.");
}
void operator /= (storage_t divisor)
@@ -155,7 +155,7 @@ struct LLUnit
void operator /= (LLUnit<OTHER_UNIT, OTHER_STORAGE> divisor)
{
// spurious use of dependent type to stop gcc from triggering the static assertion before instantiating the template
- llstatic_assert_template(OTHER_UNIT, 0, "Illegal in-place division of unit types.");
+ llstatic_assert_template(OTHER_UNIT, false, "Illegal in-place division of unit types.");
}
template<typename SOURCE_UNITS, typename SOURCE_STORAGE>
@@ -315,7 +315,7 @@ template<typename UNIT_TYPE1, typename STORAGE_TYPE1, typename UNIT_TYPE2, typen
LLUnit<UNIT_TYPE1, STORAGE_TYPE1> operator * (LLUnit<UNIT_TYPE1, STORAGE_TYPE1>, LLUnit<UNIT_TYPE2, STORAGE_TYPE2>)
{
// spurious use of dependent type to stop gcc from triggering the static assertion before instantiating the template
- llstatic_assert_template(STORAGE_TYPE1, 0, "Multiplication of unit types results in new unit type - not supported.");
+ llstatic_assert_template(STORAGE_TYPE1, false, "Multiplication of unit types results in new unit type - not supported.");
return LLUnit<UNIT_TYPE1, STORAGE_TYPE1>();
}
@@ -335,7 +335,7 @@ template<typename UNIT_TYPE1, typename STORAGE_TYPE1, typename UNIT_TYPE2, typen
LLUnitImplicit<UNIT_TYPE1, STORAGE_TYPE1> operator * (LLUnitImplicit<UNIT_TYPE1, STORAGE_TYPE1>, LLUnitImplicit<UNIT_TYPE2, STORAGE_TYPE2>)
{
// spurious use of dependent type to stop gcc from triggering the static assertion before instantiating the template
- llstatic_assert_template(STORAGE_TYPE1, 0, "Multiplication of unit types results in new unit type - not supported.");
+ llstatic_assert_template(STORAGE_TYPE1, false, "Multiplication of unit types results in new unit type - not supported.");
return LLUnitImplicit<UNIT_TYPE1, STORAGE_TYPE1>();
}
generated by cgit v1.2.3 (git 2.25.1) at 2025-03-08 14:14:30 +0000