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

SH-3499 WIP Ensure asset stats output is correct 

Finished making LLUnit implicitly convertible to/from scalar integer values
cleaned up test code
master
Richard Linden 2012-11-08 23:42:18 -08:00
parent ed17c181dd
commit 0bb0bd514b
23 changed files with 305 additions and 336 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
indra/llcommon/lldate.cpp
View File

@ -54,8 +54,8 @@ LLDate::LLDate(const LLDate& date) :
mSecondsSinceEpoch(date.mSecondsSinceEpoch)
{}
LLDate::LLDate(LLUnit::Seconds<F64> seconds_since_epoch) :
mSecondsSinceEpoch(seconds_since_epoch)
LLDate::LLDate(LLUnit<LLUnits::Seconds, F64> seconds_since_epoch) :
mSecondsSinceEpoch(seconds_since_epoch.value())
{}
LLDate::LLDate(const std::string& iso8601_date)

4
indra/llcommon/lldate.h
View File

@ -57,9 +57,9 @@ public:
/**
* @brief Construct a date from a seconds since epoch value.
*
* @pararm seconds_since_epoch The number of seconds since UTC epoch.
* @param seconds_since_epoch The number of seconds since UTC epoch.
*/
LLDate(LLUnit::Seconds<F64> seconds_since_epoch);
LLDate(LLUnit<LLUnits::Seconds, F64> seconds_since_epoch);
/**
* @brief Construct a date from a string representation

3
indra/llcommon/lldefs.h
View File

@ -244,5 +244,8 @@ inline void llswap(LLDATATYPE& lhs, LLDATATYPE& rhs)
rhs = tmp;
}
#define LL_GLUE_IMPL(x, y) x##y
#define LL_GLUE_TOKENS(x, y) LL_GLUE_IMPL(x, y)
#endif // LL_LLDEFS_H

7
indra/llcommon/llerrorlegacy.h
View File

@ -29,6 +29,7 @@
#define LL_LLERRORLEGACY_H
#include "llpreprocessor.h"
#include <boost/static_assert.hpp>
/*
LEGACY -- DO NOT USE THIS STUFF ANYMORE
@ -111,6 +112,12 @@ const int LL_ERR_PRICE_MISMATCH = -23018;
#define llverify(func) do {if (func) {}} while(0)
#endif
#ifdef LL_WINDOWS
#define llstatic_assert(func, msg) static_assert(func, msg)
#else
#define llstatic_assert(func, msg) BOOST_STATIC_ASSERT(func)
#endif
// handy compile-time assert - enforce those template parameters!
#define cassert(expn) typedef char __C_ASSERT__[(expn)?1:-1] /* Flawfinder: ignore */
//XXX: used in two places in llcommon/llskipmap.h

15
indra/llcommon/lltimer.cpp
View File

@ -287,15 +287,14 @@ LLTimer::~LLTimer()
}
// static
LLUnit::Microseconds<U64> LLTimer::getTotalTime()
LLUnit<LLUnits::Microseconds, U64> LLTimer::getTotalTime()
{
LLUnit::Seconds<F64> sec = LLUnit::Milliseconds<U32>(2000) + LLUnit::Hours<F32>(1.f / 360.f);
// simply call into the implementation function.
return totalTime();
}
// static
LLUnit::Seconds<F64> LLTimer::getTotalSeconds()
LLUnit<LLUnits::Seconds, F64> LLTimer::getTotalSeconds()
{
return U64_to_F64(getTotalTime()) * USEC_TO_SEC_F64;
}
@ -344,23 +343,23 @@ U64 getElapsedTimeAndUpdate(U64& lastClockCount)
}
LLUnit::Seconds<F64> LLTimer::getElapsedTimeF64() const
LLUnit<LLUnits::Seconds, F64> LLTimer::getElapsedTimeF64() const
{
U64 last = mLastClockCount;
return (F64)getElapsedTimeAndUpdate(last) * gClockFrequencyInv;
}
LLUnit::Seconds<F32> LLTimer::getElapsedTimeF32() const
LLUnit<LLUnits::Seconds, F32> LLTimer::getElapsedTimeF32() const
{
return (F32)getElapsedTimeF64();
}
LLUnit::Seconds<F64> LLTimer::getElapsedTimeAndResetF64()
LLUnit<LLUnits::Seconds, F64> LLTimer::getElapsedTimeAndResetF64()
{
return (F64)getElapsedTimeAndUpdate(mLastClockCount) * gClockFrequencyInv;
}
LLUnit::Seconds<F32> LLTimer::getElapsedTimeAndResetF32()
LLUnit<LLUnits::Seconds, F32> LLTimer::getElapsedTimeAndResetF32()
{
return (F32)getElapsedTimeAndResetF64();
}
@ -373,7 +372,7 @@ void LLTimer::setTimerExpirySec(F32 expiration)
+ (U64)((F32)(expiration * gClockFrequency));
}
LLUnit::Seconds<F32> LLTimer::getRemainingTimeF32() const
LLUnit<LLUnits::Seconds, F32> LLTimer::getRemainingTimeF32() const
{
U64 cur_ticks = get_clock_count();
if (cur_ticks > mExpirationTicks)

16
indra/llcommon/lltimer.h
View File

@ -67,16 +67,16 @@ public:
// Return a high precision number of seconds since the start of
// this application instance.
static LLUnit::Seconds<F64> getElapsedSeconds()
static LLUnit<LLUnits::Seconds, F64> getElapsedSeconds()
{
return sTimer->getElapsedTimeF64();
}
// Return a high precision usec since epoch
static LLUnit::Microseconds<U64> getTotalTime();
static LLUnit<LLUnits::Microseconds, U64> getTotalTime();
// Return a high precision seconds since epoch
static LLUnit::Seconds<F64> getTotalSeconds();
static LLUnit<LLUnits::Seconds, F64> getTotalSeconds();
// MANIPULATORS
@ -87,16 +87,16 @@ public:
void setTimerExpirySec(F32 expiration);
BOOL checkExpirationAndReset(F32 expiration);
BOOL hasExpired() const;
LLUnit::Seconds<F32> getElapsedTimeAndResetF32(); // Returns elapsed time in seconds with reset
LLUnit::Seconds<F64> getElapsedTimeAndResetF64();
LLUnit<LLUnits::Seconds, F32> getElapsedTimeAndResetF32(); // Returns elapsed time in seconds with reset
LLUnit<LLUnits::Seconds, F64> getElapsedTimeAndResetF64();
LLUnit::Seconds<F32> getRemainingTimeF32() const;
LLUnit<LLUnits::Seconds, F32> getRemainingTimeF32() const;
static BOOL knownBadTimer();
// ACCESSORS
LLUnit::Seconds<F32> getElapsedTimeF32() const; // Returns elapsed time in seconds
LLUnit::Seconds<F64> getElapsedTimeF64() const; // Returns elapsed time in seconds
LLUnit<LLUnits::Seconds, F32> getElapsedTimeF32() const; // Returns elapsed time in seconds
LLUnit<LLUnits::Seconds, F64> getElapsedTimeF64() const; // Returns elapsed time in seconds
bool getStarted() const { return mStarted; }

50
indra/llcommon/lltrace.h
View File

@ -38,37 +38,35 @@
#include <list>
#define LL_TOKEN_PASTE_ACTUAL(x, y) x##y
#define LL_TOKEN_PASTE(x, y) LL_TOKEN_PASTE_ACTUAL(x, y)
#define LL_RECORD_BLOCK_TIME(block_timer) LLTrace::BlockTimer::Recorder LL_TOKEN_PASTE(block_time_recorder, __COUNTER__)(block_timer);
#define LL_RECORD_BLOCK_TIME(block_timer) LLTrace::BlockTimer::Recorder LL_GLUE_TOKENS(block_time_recorder, __COUNTER__)(block_timer);
namespace LLTrace
{
class Recording;
typedef LLUnit::Bytes<F64> Bytes;
typedef LLUnit::Kilobytes<F64> Kilobytes;
typedef LLUnit::Megabytes<F64> Megabytes;
typedef LLUnit::Gigabytes<F64> Gigabytes;
typedef LLUnit::Bits<F64> Bits;
typedef LLUnit::Kilobits<F64> Kilobits;
typedef LLUnit::Megabits<F64> Megabits;
typedef LLUnit::Gigabits<F64> Gigabits;
typedef LLUnit<LLUnits::Bytes, F64> Bytes;
typedef LLUnit<LLUnits::Kilobytes, F64> Kilobytes;
typedef LLUnit<LLUnits::Megabytes, F64> Megabytes;
typedef LLUnit<LLUnits::Gigabytes, F64> Gigabytes;
typedef LLUnit<LLUnits::Bits, F64> Bits;
typedef LLUnit<LLUnits::Kilobits, F64> Kilobits;
typedef LLUnit<LLUnits::Megabits, F64> Megabits;
typedef LLUnit<LLUnits::Gigabits, F64> Gigabits;
typedef LLUnit::Seconds<F64> Seconds;
typedef LLUnit::Milliseconds<F64> Milliseconds;
typedef LLUnit::Minutes<F64> Minutes;
typedef LLUnit::Hours<F64> Hours;
typedef LLUnit::Days<F64> Days;
typedef LLUnit::Weeks<F64> Weeks;
typedef LLUnit::Milliseconds<F64> Milliseconds;
typedef LLUnit::Microseconds<F64> Microseconds;
typedef LLUnit::Nanoseconds<F64> Nanoseconds;
typedef LLUnit<LLUnits::Seconds, F64> Seconds;
typedef LLUnit<LLUnits::Milliseconds, F64> Milliseconds;
typedef LLUnit<LLUnits::Minutes, F64> Minutes;
typedef LLUnit<LLUnits::Hours, F64> Hours;
typedef LLUnit<LLUnits::Days, F64> Days;
typedef LLUnit<LLUnits::Weeks, F64> Weeks;
typedef LLUnit<LLUnits::Milliseconds, F64> Milliseconds;
typedef LLUnit<LLUnits::Microseconds, F64> Microseconds;
typedef LLUnit<LLUnits::Nanoseconds, F64> Nanoseconds;
typedef LLUnit::Meters<F64> Meters;
typedef LLUnit::Kilometers<F64> Kilometers;
typedef LLUnit::Centimeters<F64> Centimeters;
typedef LLUnit::Millimeters<F64> Millimeters;
typedef LLUnit<LLUnits::Meters, F64> Meters;
typedef LLUnit<LLUnits::Kilometers, F64> Kilometers;
typedef LLUnit<LLUnits::Centimeters, F64> Centimeters;
typedef LLUnit<LLUnits::Millimeters, F64> Millimeters;
void init();
void cleanup();
@ -438,7 +436,7 @@ namespace LLTrace
void sample(UNIT_T value)
{
T converted_value;
converted_value.assignFrom(value);
converted_value = value;
getPrimaryAccumulator().sample((storage_t)converted_value.value());
}
};
@ -478,7 +476,7 @@ namespace LLTrace
void add(UNIT_T value)
{
T converted_value;
converted_value.assignFrom(value);
converted_value = value;
getPrimaryAccumulator().add((storage_t)converted_value.value());
}
};

2
indra/llcommon/lltracerecording.h
View File

@ -197,7 +197,7 @@ namespace LLTrace
U32 getSampleCount(const TraceType<MeasurementAccumulator<F64> >& stat) const;
U32 getSampleCount(const TraceType<MeasurementAccumulator<S64> >& stat) const;
LLUnit::Seconds<F64> getDuration() const { return mElapsedSeconds; }
LLUnit<LLUnits::Seconds, F64> getDuration() const { return mElapsedSeconds; }
private:
friend class ThreadRecorder;

428
indra/llcommon/llunit.h
View File

@ -30,326 +30,288 @@
#include "stdtypes.h"
#include "llpreprocessor.h"
template<typename STORAGE_TYPE, typename BASE_UNIT, typename DERIVED_UNIT = BASE_UNIT>
struct LLUnitType : public BASE_UNIT
namespace LLUnits
{
typedef DERIVED_UNIT unit_t;
template<typename DERIVED_UNITS_TAG, typename BASE_UNITS_TAG>
struct ConversionFactor
{
static F64 get()
{
llstatic_assert(sizeof(DERIVED_UNITS_TAG) == 0, "Cannot convert between types.");
}
};
template<typename BASE_UNITS_TAG>
struct ConversionFactor<BASE_UNITS_TAG, BASE_UNITS_TAG>
{
static F64 get() { return 1.0; }
};
}
template<typename UNIT_TYPE, typename STORAGE_TYPE>
struct LLUnit
{
typedef LLUnit<UNIT_TYPE, STORAGE_TYPE> self_t;
typedef typename STORAGE_TYPE storage_t;
typedef void is_unit_tag_t;
LLUnitType()
LLUnit(storage_t value = storage_t())
: mValue(value)
{}
LLUnitType(storage_t value)
: BASE_UNIT(convertToBase(value))
template<typename OTHER_UNIT, typename OTHER_STORAGE>
LLUnit(LLUnit<OTHER_UNIT, OTHER_STORAGE> other)
: mValue(convert(other))
{}
// implicit downcast
operator unit_t& ()
LLUnit(self_t& other)
: mValue(other.mValue)
{}
self_t& operator = (storage_t value)
{
return static_cast<unit_t&>(*this);
mValue = value;
return *this;
}
operator storage_t () const
template<typename OTHER_UNIT, typename OTHER_STORAGE>
self_t& operator = (LLUnit<OTHER_UNIT, OTHER_STORAGE> other)
{
mValue = convert(other);
return *this;
}
operator storage_t() const
{
return value();
}
storage_t value() const
{
return convertToDerived(mBaseValue);
return mValue;
}
template<typename CONVERTED_TYPE>
storage_t as() const
void operator += (storage_t value)
{
return CONVERTED_TYPE(*this).value();
mValue += value;
}
protected:
static storage_t convertToBase(storage_t derived_value)
template<typename OTHER_UNIT, typename OTHER_STORAGE>
void operator += (LLUnit<OTHER_UNIT, OTHER_STORAGE> other)
{
return (storage_t)((F32)derived_value * unit_t::conversionToBaseFactor());
mValue += convert(other);
}
static storage_t convertToDerived(storage_t base_value)
void operator -= (storage_t value)
{
return (storage_t)((F32)base_value / unit_t::conversionToBaseFactor());
mValue -= value;
}
};
template<typename STORAGE_TYPE, typename T>
struct LLUnitType<STORAGE_TYPE, T, T>
{
typedef T unit_t;
typedef STORAGE_TYPE storage_t;
typedef void is_unit_tag_t;
LLUnitType()
: mBaseValue()
{}
LLUnitType(storage_t value)
: mBaseValue(value)
{}
unit_t& operator=(storage_t value)
template<typename OTHER_UNIT, typename OTHER_STORAGE>
void operator -= (LLUnit<OTHER_UNIT, OTHER_STORAGE> other)
{
setBaseValue(value);
return *this;
}
//implicit downcast
operator unit_t& ()
{
return static_cast<unit_t&>(*this);
}
operator storage_t () const
{
return value();
}
storage_t value() const { return mBaseValue; }
template<typename CONVERTED_TYPE>
storage_t as() const
{
return CONVERTED_TYPE(*this).value();
}
static storage_t convertToBase(storage_t derived_value)
{
return (storage_t)derived_value;
}
static storage_t convertToDerived(storage_t base_value)
{
return (storage_t)base_value;
}
void operator += (const unit_t other)
{
mBaseValue += other.mBaseValue;
}
void operator -= (const unit_t other)
{
mBaseValue -= other.mBaseValue;
mValue -= convert(other);
}
void operator *= (storage_t multiplicand)
{
mBaseValue *= multiplicand;
mValue *= multiplicand;
}
template<typename OTHER_UNIT, typename OTHER_STORAGE>
void operator *= (LLUnit<OTHER_UNIT, OTHER_STORAGE> multiplicand)
{
llstatic_assert(sizeof(OTHER_UNIT) == false, "Multiplication of unit types not supported.");
}
void operator /= (storage_t divisor)
{
mBaseValue /= divisor;
mValue /= divisor;
}
template<typename OTHER_UNIT, typename OTHER_STORAGE>
void operator /= (LLUnit<OTHER_UNIT, OTHER_STORAGE> divisor)
{
llstatic_assert(sizeof(OTHER_UNIT) == false, "Division of unit types not supported.");
}
template<typename SOURCE_UNITS, typename SOURCE_VALUE>
static storage_t convert(LLUnit<SOURCE_UNITS, SOURCE_VALUE> v)
{
return (storage_t)(v.value()
* LLUnits::ConversionFactor<SOURCE_UNITS, typename UNIT_TYPE::base_unit_t>::get()
* LLUnits::ConversionFactor<typename UNIT_TYPE::base_unit_t, UNIT_TYPE>::get());
}
protected:
void setBaseValue(storage_t value)
{
mBaseValue = value;
}
storage_t mBaseValue;
storage_t mValue;
};
template<typename STORAGE_TYPE, typename BASE_UNIT, typename DERIVED_UNIT>
struct LLUnitTypeWrapper
: public LLUnitType<STORAGE_TYPE, BASE_UNIT, DERIVED_UNIT>
{
typedef LLUnitType<STORAGE_TYPE, BASE_UNIT, DERIVED_UNIT> unit_t;
LLUnitTypeWrapper(const unit_t& other)
: unit_t(other)
{}
};
//
// operator +
//
template<typename STORAGE_TYPE, typename BASE_UNIT, typename DERIVED_UNIT, typename STORAGE_TYPE2, typename BASE_UNIT2, typename DERIVED_UNIT2>
DERIVED_UNIT operator + (typename LLUnitType<STORAGE_TYPE, BASE_UNIT, DERIVED_UNIT>::storage_t first, LLUnitType<STORAGE_TYPE2, BASE_UNIT2, DERIVED_UNIT2> second)
template<typename STORAGE_TYPE1, typename UNIT_TYPE1, typename STORAGE_TYPE2, typename UNIT_TYPE2>
LLUnit<STORAGE_TYPE1, UNIT_TYPE1> operator + (LLUnit<STORAGE_TYPE1, UNIT_TYPE1> first, LLUnit<STORAGE_TYPE2, UNIT_TYPE2> second)
{
return DERIVED_UNIT(first + LLUnitType<STORAGE_TYPE, BASE_UNIT, DERIVED_UNIT>(second).value());
LLUnit<STORAGE_TYPE1, UNIT_TYPE1> result(first);
result += second;
return result;
}
template<typename STORAGE_TYPE, typename UNIT_TYPE, typename SCALAR_TYPE>
LLUnit<STORAGE_TYPE, UNIT_TYPE> operator + (LLUnit<STORAGE_TYPE, UNIT_TYPE> first, SCALAR_TYPE second)
{
LLUnit<STORAGE_TYPE, UNIT_TYPE> result(first);
result += second;
return result;
}
template<typename STORAGE_TYPE, typename UNIT_TYPE, typename SCALAR_TYPE>
LLUnit<STORAGE_TYPE, UNIT_TYPE> operator + (SCALAR_TYPE first, LLUnit<STORAGE_TYPE, UNIT_TYPE> second)
{
LLUnit<STORAGE_TYPE, UNIT_TYPE> result(first);
result += second;
return result;
}
//
// operator -
//
template<typename STORAGE_TYPE, typename BASE_UNIT, typename DERIVED_UNIT, typename STORAGE_TYPE2, typename BASE_UNIT2, typename DERIVED_UNIT2>
DERIVED_UNIT operator - (typename LLUnitType<STORAGE_TYPE, BASE_UNIT, DERIVED_UNIT>::storage_t first, LLUnitType<STORAGE_TYPE, BASE_UNIT, DERIVED_UNIT> second)
template<typename STORAGE_TYPE1, typename UNIT_TYPE1, typename STORAGE_TYPE2, typename UNIT_TYPE2>
LLUnit<STORAGE_TYPE1, UNIT_TYPE1> operator - (LLUnit<STORAGE_TYPE1, UNIT_TYPE1> first, LLUnit<STORAGE_TYPE2, UNIT_TYPE2> second)
{
return DERIVED_UNIT(first - LLUnitType<STORAGE_TYPE, BASE_UNIT, DERIVED_UNIT>(second).value());
LLUnit<STORAGE_TYPE1, UNIT_TYPE1> result(first);
result -= second;
return result;
}
template<typename STORAGE_TYPE, typename UNIT_TYPE, typename SCALAR_TYPE>
LLUnit<STORAGE_TYPE, UNIT_TYPE> operator - (LLUnit<STORAGE_TYPE, UNIT_TYPE> first, SCALAR_TYPE second)
{
LLUnit<STORAGE_TYPE, UNIT_TYPE> result(first);
result -= second;
return result;
}
template<typename STORAGE_TYPE, typename UNIT_TYPE, typename SCALAR_TYPE>
LLUnit<STORAGE_TYPE, UNIT_TYPE> operator - (SCALAR_TYPE first, LLUnit<STORAGE_TYPE, UNIT_TYPE> second)
{
LLUnit<STORAGE_TYPE, UNIT_TYPE> result(first);
result -= second;
return result;
}
//
// operator *
//
template<typename STORAGE_TYPE, typename BASE_UNIT, typename DERIVED_UNIT>
DERIVED_UNIT operator * (STORAGE_TYPE first, LLUnitType<STORAGE_TYPE, BASE_UNIT, DERIVED_UNIT> second)
template<typename STORAGE_TYPE, typename UNIT_TYPE, typename SCALAR_TYPE>
LLUnit<STORAGE_TYPE, UNIT_TYPE> operator * (SCALAR_TYPE first, LLUnit<STORAGE_TYPE, UNIT_TYPE> second)
{
return DERIVED_UNIT(first * second.value());
return LLUnit<STORAGE_TYPE, UNIT_TYPE>(first * second.value());
}
template<typename STORAGE_TYPE, typename BASE_UNIT, typename DERIVED_UNIT>
DERIVED_UNIT operator * (LLUnitType<STORAGE_TYPE, BASE_UNIT, DERIVED_UNIT> first, STORAGE_TYPE second)
template<typename STORAGE_TYPE, typename UNIT_TYPE, typename SCALAR_TYPE>
LLUnit<STORAGE_TYPE, UNIT_TYPE> operator * (LLUnit<STORAGE_TYPE, UNIT_TYPE> first, SCALAR_TYPE second)
{
return DERIVED_UNIT(first.value() * second);
return LLUnit<STORAGE_TYPE, UNIT_TYPE>(first.value() * second);
}
template<typename STORAGE_TYPE1, typename UNIT_TYPE1, typename STORAGE_TYPE2, typename UNIT_TYPE2>
void operator * (LLUnit<STORAGE_TYPE1, UNIT_TYPE1>, LLUnit<STORAGE_TYPE2, UNIT_TYPE2>)
{
llstatic_assert(sizeof(STORAGE_TYPE1) == false, "Multiplication of unit types results in new unit type - not supported.");
}
//
// operator /
//
template<typename STORAGE_TYPE, typename BASE_UNIT, typename DERIVED_UNIT>
DERIVED_UNIT operator / (STORAGE_TYPE first, LLUnitTypeWrapper<STORAGE_TYPE, BASE_UNIT, DERIVED_UNIT> second)
template<typename STORAGE_TYPE, typename UNIT_TYPE, typename SCALAR_TYPE>
SCALAR_TYPE operator / (SCALAR_TYPE first, LLUnit<STORAGE_TYPE, UNIT_TYPE> second)
{
return DERIVED_UNIT(first / second.value());
return SCALAR_TYPE(first / second.value());
}
template<typename STORAGE_TYPE, typename BASE_UNIT, typename DERIVED_UNIT>
DERIVED_UNIT operator / (LLUnitTypeWrapper<STORAGE_TYPE, BASE_UNIT, DERIVED_UNIT> first, STORAGE_TYPE second)
template<typename STORAGE_TYPE, typename UNIT_TYPE, typename SCALAR_TYPE>
LLUnit<STORAGE_TYPE, UNIT_TYPE> operator / (LLUnit<STORAGE_TYPE, UNIT_TYPE> first, SCALAR_TYPE second)
{
return DERIVED_UNIT(first.value() / second);
return LLUnit<STORAGE_TYPE, UNIT_TYPE>(first.value() / second);
}
//
// operator <
//
template<typename STORAGE_TYPE, typename BASE_UNIT, typename DERIVED_UNIT, typename STORAGE_TYPE2, typename BASE_UNIT2, typename DERIVED_UNIT2>
bool operator < (typename LLUnitType<STORAGE_TYPE, BASE_UNIT, DERIVED_UNIT>::storage_t first, LLUnitType<STORAGE_TYPE, BASE_UNIT, DERIVED_UNIT> second)
template<typename STORAGE_TYPE1, typename UNIT_TYPE1, typename STORAGE_TYPE2, typename UNIT_TYPE2>
void operator / (LLUnit<STORAGE_TYPE1, UNIT_TYPE1>, LLUnit<STORAGE_TYPE2, UNIT_TYPE2>)
{
return first < second.value();
llstatic_assert(sizeof(STORAGE_TYPE1) == false, "Multiplication of unit types results in new unit type - not supported.");
}
//
// operator <=
//
template<typename STORAGE_TYPE, typename BASE_UNIT, typename DERIVED_UNIT>
bool operator <= (typename LLUnitType<STORAGE_TYPE, BASE_UNIT, DERIVED_UNIT>::storage_t first, LLUnitType<STORAGE_TYPE, BASE_UNIT, DERIVED_UNIT> second)
{
return first <= second.value();
#define COMPARISON_OPERATORS(op) \
template<typename STORAGE_TYPE, typename UNIT_TYPE, typename SCALAR_TYPE> \
bool operator op (SCALAR_TYPE first, LLUnit<STORAGE_TYPE, UNIT_TYPE> second) \
{ \
return first op second.value(); \
} \
\
template<typename STORAGE_TYPE, typename UNIT_TYPE, typename SCALAR_TYPE> \
bool operator op (LLUnit<STORAGE_TYPE, UNIT_TYPE> first, SCALAR_TYPE second) \
{ \
return first.value() op second; \
} \
\
template<typename STORAGE_TYPE1, typename UNIT_TYPE1, typename STORAGE_TYPE2, typename UNIT_TYPE2> \
bool operator op (LLUnit<STORAGE_TYPE1, UNIT_TYPE1> first, LLUnit<STORAGE_TYPE2, UNIT_TYPE2> second) \
{ \
return first.value() op first.convert(second); \
}
COMPARISON_OPERATORS(<)
COMPARISON_OPERATORS(<=)
COMPARISON_OPERATORS(>)
COMPARISON_OPERATORS(>=)
COMPARISON_OPERATORS(==)
COMPARISON_OPERATORS(!=)
//
// operator >
//
template<typename STORAGE_TYPE, typename BASE_UNIT, typename DERIVED_UNIT>
bool operator > (typename LLUnitType<STORAGE_TYPE, BASE_UNIT, DERIVED_UNIT>::storage_t first, LLUnitType<STORAGE_TYPE, BASE_UNIT, DERIVED_UNIT> second)
namespace LLUnits
{
return first > second.value();
#define LL_DECLARE_DERIVED_UNIT(base_unit_name, unit_name, conversion_factor)\
struct unit_name \
{ \
typedef base_unit_name base_unit_t; \
}; \
template<> \
struct ConversionFactor<unit_name, base_unit_name> \
{ \
static F64 get() { return (conversion_factor); } \
}; \
\
template<> \
struct ConversionFactor<base_unit_name, unit_name> \
{ \
static F64 get() { return 1.0 / (conversion_factor); } \
}
//
// operator >=
//
template<typename STORAGE_TYPE, typename BASE_UNIT, typename DERIVED_UNIT>
bool operator >= (typename LLUnitType<STORAGE_TYPE, BASE_UNIT, DERIVED_UNIT>::storage_t first, LLUnitType<STORAGE_TYPE, BASE_UNIT, DERIVED_UNIT> second)
{
return first >= second.value();
}
struct Bytes { typedef Bytes base_unit_t; };
LL_DECLARE_DERIVED_UNIT(Bytes, Kilobytes, 1024);
LL_DECLARE_DERIVED_UNIT(Bytes, Megabytes, 1024 * 1024);
LL_DECLARE_DERIVED_UNIT(Bytes, Gigabytes, 1024 * 1024 * 1024);
LL_DECLARE_DERIVED_UNIT(Bytes, Bits, (1.0 / 8.0));
LL_DECLARE_DERIVED_UNIT(Bytes, Kilobits, (1024 / 8));
LL_DECLARE_DERIVED_UNIT(Bytes, Megabits, (1024 / 8));
LL_DECLARE_DERIVED_UNIT(Bytes, Gigabits, (1024 * 1024 * 1024 / 8));
//
// operator ==
//
template<typename STORAGE_TYPE, typename BASE_UNIT, typename DERIVED_UNIT>
bool operator == (typename LLUnitType<STORAGE_TYPE, BASE_UNIT, DERIVED_UNIT>::storage_t first, LLUnitType<STORAGE_TYPE, BASE_UNIT, DERIVED_UNIT> second)
{
return first == second.value();
}
struct Seconds { typedef Seconds base_unit_t; };
LL_DECLARE_DERIVED_UNIT(Seconds, Minutes, 60);
LL_DECLARE_DERIVED_UNIT(Seconds, Hours, 60 * 60);
LL_DECLARE_DERIVED_UNIT(Seconds, Days, 60 * 60 * 24);
LL_DECLARE_DERIVED_UNIT(Seconds, Weeks, 60 * 60 * 24 * 7);
LL_DECLARE_DERIVED_UNIT(Seconds, Milliseconds, (1.0 / 1000.0));
LL_DECLARE_DERIVED_UNIT(Seconds, Microseconds, (1.0 / (1000000.0)));
LL_DECLARE_DERIVED_UNIT(Seconds, Nanoseconds, (1.0 / (1000000000.0)));
//
// operator !=
//
template<typename STORAGE_TYPE, typename BASE_UNIT, typename DERIVED_UNIT>
bool operator != (typename LLUnitType<STORAGE_TYPE, BASE_UNIT, DERIVED_UNIT>::storage_t first, LLUnitType<STORAGE_TYPE, BASE_UNIT, DERIVED_UNIT> second)
{
return first != second.value();
}
#define LL_DECLARE_BASE_UNIT(unit_name) \
template<typename STORAGE> \
struct unit_name : public LLUnitType<STORAGE, unit_name<STORAGE>, unit_name<STORAGE> > \
{ \
typedef LLUnitType<STORAGE, unit_name> unit_t; \
\
unit_name(storage_t value = 0) \
: LLUnitType(value) \
{} \
\
template <typename SOURCE_STORAGE_TYPE, typename SOURCE_TYPE> \
unit_name(LLUnitType<SOURCE_STORAGE_TYPE, unit_name<SOURCE_STORAGE_TYPE>, SOURCE_TYPE> source) \
{ \
assignFrom(source); \
} \
\
template <typename SOURCE_STORAGE_TYPE, typename SOURCE_TYPE> \
void assignFrom(LLUnitType<SOURCE_STORAGE_TYPE, unit_name<SOURCE_STORAGE_TYPE>, SOURCE_TYPE> source) \
{ \
setBaseValue((storage_t)source.unit_name<SOURCE_STORAGE_TYPE>::unit_t::value()); \
} \
\
}; \
#define LL_DECLARE_DERIVED_UNIT(base_unit, derived_unit, conversion_factor) \
template<typename STORAGE> \
struct derived_unit : public LLUnitType<STORAGE, base_unit<STORAGE>, derived_unit<STORAGE> > \
{ \
typedef LLUnitType<STORAGE, base_unit<STORAGE>, derived_unit<STORAGE> > unit_t; \
\
derived_unit(storage_t value = 0) \
: LLUnitType(value) \
{} \
\
template <typename SOURCE_STORAGE_TYPE, typename SOURCE_TYPE> \
derived_unit(LLUnitType<SOURCE_STORAGE_TYPE, base_unit<SOURCE_STORAGE_TYPE>, SOURCE_TYPE> source) \
{ \
assignFrom(source); \
} \
\
template <typename SOURCE_STORAGE_TYPE, typename SOURCE_TYPE> \
void assignFrom(LLUnitType<SOURCE_STORAGE_TYPE, base_unit<SOURCE_STORAGE_TYPE>, SOURCE_TYPE> source) \
{ \
setBaseValue((storage_t)source.base_unit<SOURCE_STORAGE_TYPE>::unit_t::value()); \
} \
\
static F32 conversionToBaseFactor() { return (F32)(conversion_factor); } \
\
}; \
namespace LLUnit
{
LL_DECLARE_BASE_UNIT(Bytes);
LL_DECLARE_DERIVED_UNIT(Bytes, Kilobytes, 1024);
LL_DECLARE_DERIVED_UNIT(Bytes, Megabytes, 1024 * 1024);
LL_DECLARE_DERIVED_UNIT(Bytes, Gigabytes, 1024 * 1024 * 1024);
LL_DECLARE_DERIVED_UNIT(Bytes, Bits, (1.f / 8.f));
LL_DECLARE_DERIVED_UNIT(Bytes, Kilobits, (1024 / 8));
LL_DECLARE_DERIVED_UNIT(Bytes, Megabits, (1024 / 8));
LL_DECLARE_DERIVED_UNIT(Bytes, Gigabits, (1024 * 1024 * 1024 / 8));
LL_DECLARE_BASE_UNIT(Seconds);
LL_DECLARE_DERIVED_UNIT(Seconds, Minutes, 60);
LL_DECLARE_DERIVED_UNIT(Seconds, Hours, 60 * 60);
LL_DECLARE_DERIVED_UNIT(Seconds, Days, 60 * 60 * 24);
LL_DECLARE_DERIVED_UNIT(Seconds, Weeks, 60 * 60 * 24 * 7);
LL_DECLARE_DERIVED_UNIT(Seconds, Milliseconds, (1.f / 1000.f));
LL_DECLARE_DERIVED_UNIT(Seconds, Microseconds, (1.f / (1000000.f)));
LL_DECLARE_DERIVED_UNIT(Seconds, Nanoseconds, (1.f / (1000000000.f)));
LL_DECLARE_BASE_UNIT(Meters);
LL_DECLARE_DERIVED_UNIT(Meters, Kilometers, 1000);
LL_DECLARE_DERIVED_UNIT(Meters, Centimeters, 1 / 100);
LL_DECLARE_DERIVED_UNIT(Meters, Millimeters, 1 / 1000);
struct Meters { typedef Meters base_unit_t; };
LL_DECLARE_DERIVED_UNIT(Meters, Kilometers, 1000);
LL_DECLARE_DERIVED_UNIT(Meters, Centimeters, (1.0 / 100));
LL_DECLARE_DERIVED_UNIT(Meters, Millimeters, (1.0 / 1000));
}
#endif // LL_LLUNIT_H

6
indra/llmath/v4color.h
View File

@ -49,10 +49,10 @@ class LLColor4
LLColor4(); // Initializes LLColor4 to (0, 0, 0, 1)
LLColor4(F32 r, F32 g, F32 b); // Initializes LLColor4 to (r, g, b, 1)
LLColor4(F32 r, F32 g, F32 b, F32 a); // Initializes LLColor4 to (r. g, b, a)
explicit LLColor4(U32 clr); // Initializes LLColor4 to (r=clr>>24, etc))
explicit LLColor4(const F32 *vec); // Initializes LLColor4 to (vec[0]. vec[1], vec[2], 1)
explicit LLColor4(const LLColor3 &vec, F32 a = 1.f); // Initializes LLColor4 to (vec, a)
LLColor4(const LLColor3 &vec, F32 a = 1.f); // Initializes LLColor4 to (vec, a)
explicit LLColor4(const LLSD& sd);
explicit LLColor4(const F32 *vec); // Initializes LLColor4 to (vec[0]. vec[1], vec[2], 1)
explicit LLColor4(U32 clr); // Initializes LLColor4 to (r=clr>>24, etc))
explicit LLColor4(const LLColor4U& color4u); // "explicit" to avoid automatic conversion
explicit LLColor4(const LLVector4& vector4); // "explicit" to avoid automatic conversion

6
indra/llrender/llimagegl.cpp
View File

@ -50,9 +50,9 @@ U32 wpo2(U32 i);
U32 LLImageGL::sUniqueCount = 0;
U32 LLImageGL::sBindCount = 0;
LLUnit::Bytes<S32> LLImageGL::sGlobalTextureMemory = 0;
LLUnit::Bytes<S32> LLImageGL::sBoundTextureMemory = 0;
LLUnit::Bytes<S32> LLImageGL::sCurBoundTextureMemory = 0;
LLUnit<LLUnits::Bytes, S32> LLImageGL::sGlobalTextureMemory = 0;
LLUnit<LLUnits::Bytes, S32> LLImageGL::sBoundTextureMemory = 0;
LLUnit<LLUnits::Bytes, S32> LLImageGL::sCurBoundTextureMemory = 0;
S32 LLImageGL::sCount = 0;
LLImageGL::dead_texturelist_t LLImageGL::sDeadTextureList[LLTexUnit::TT_NONE];
U32 LLImageGL::sCurTexName = 1;

6
indra/llrender/llimagegl.h
View File

@ -246,9 +246,9 @@ public:
static F32 sLastFrameTime;
// Global memory statistics
static LLUnit::Bytes<S32> sGlobalTextureMemory; // Tracks main memory texmem
static LLUnit::Bytes<S32> sBoundTextureMemory; // Tracks bound texmem for last completed frame
static LLUnit::Bytes<S32> sCurBoundTextureMemory; // Tracks bound texmem for current frame
static LLUnit<LLUnits::Bytes, S32> sGlobalTextureMemory; // Tracks main memory texmem
static LLUnit<LLUnits::Bytes, S32> sBoundTextureMemory; // Tracks bound texmem for last completed frame
static LLUnit<LLUnits::Bytes, S32> sCurBoundTextureMemory; // Tracks bound texmem for current frame
static U32 sBindCount; // Tracks number of texture binds for current frame
static U32 sUniqueCount; // Tracks number of unique texture binds for current frame
static BOOL sGlobalUseAnisotropic;

2
indra/newview/llappviewer.cpp
View File

@ -277,7 +277,7 @@ LLPumpIO* gServicePump = NULL;
U64 gFrameTime = 0;
F32 gFrameTimeSeconds = 0.f;
LLUnit::Seconds<F32> gFrameIntervalSeconds = 0.f;
LLUnit<LLUnits::Seconds, F32> gFrameIntervalSeconds = 0.f;
F32 gFPSClamped = 10.f; // Pretend we start at target rate.
F32 gFrameDTClamped = 0.f; // Time between adjacent checks to network for packets
U64 gStartTime = 0; // gStartTime is "private", used only to calculate gFrameTimeSeconds

2
indra/newview/llappviewer.h
View File

@ -322,7 +322,7 @@ extern LLPumpIO* gServicePump;
extern U64 gFrameTime; // The timestamp of the most-recently-processed frame
extern F32 gFrameTimeSeconds; // Loses msec precision after ~4.5 hours...
extern LLUnit::Seconds<F32> gFrameIntervalSeconds; // Elapsed time between current and previous gFrameTimeSeconds
extern LLUnit<LLUnits::Seconds, F32> gFrameIntervalSeconds; // Elapsed time between current and previous gFrameTimeSeconds
extern F32 gFPSClamped; // Frames per second, smoothed, weighted toward last frame
extern F32 gFrameDTClamped;
extern U64 gStartTime;

2
indra/newview/lldrawpoolwater.cpp
View File

@ -463,7 +463,7 @@ void LLDrawPoolWater::renderReflection(LLFace* face)
gGL.getTexUnit(0)->bind(mHBTex[dr]);
LLOverrideFaceColor override(this, face->getFaceColor().mV);
LLOverrideFaceColor override(this, LLColor4(face->getFaceColor().mV));
face->renderIndexed();
}

18
indra/newview/lltextureview.cpp
View File

@ -503,17 +503,17 @@ private:
void LLGLTexMemBar::draw()
{
LLUnit::Megabytes<S32> bound_mem = LLViewerTexture::sBoundTextureMemory;
LLUnit::Megabytes<S32> max_bound_mem = LLViewerTexture::sMaxBoundTextureMem;
LLUnit::Megabytes<S32> total_mem = LLViewerTexture::sTotalTextureMemory;
LLUnit::Megabytes<S32> max_total_mem = LLViewerTexture::sMaxTotalTextureMem;
LLUnit<LLUnits::Megabytes, S32> bound_mem = LLViewerTexture::sBoundTextureMemory;
LLUnit<LLUnits::Megabytes, S32> max_bound_mem = LLViewerTexture::sMaxBoundTextureMem;
LLUnit<LLUnits::Megabytes, S32> total_mem = LLViewerTexture::sTotalTextureMemory;
LLUnit<LLUnits::Megabytes, S32> max_total_mem = LLViewerTexture::sMaxTotalTextureMem;
F32 discard_bias = LLViewerTexture::sDesiredDiscardBias;
F32 cache_usage = (F32)LLTrace::Megabytes(LLAppViewer::getTextureCache()->getUsage()).value() ;
F32 cache_max_usage = (F32)LLTrace::Megabytes(LLAppViewer::getTextureCache()->getMaxUsage()).value() ;
S32 line_height = LLFontGL::getFontMonospace()->getLineHeight();
S32 v_offset = 0;//(S32)((texture_bar_height + 2.2f) * mTextureView->mNumTextureBars + 2.0f);
LLUnit::Megabytes<F32> total_texture_downloaded = gTotalTextureData;
LLUnit::Megabytes<F32> total_object_downloaded = gTotalObjectData;
LLUnit<LLUnits::Megabytes, F32> total_texture_downloaded = gTotalTextureData;
LLUnit<LLUnits::Megabytes, F32> total_object_downloaded = gTotalObjectData;
U32 total_http_requests = LLAppViewer::getTextureFetch()->getCurlRequest().getTotalIssuedRequests() ;
//----------------------------------------------------------------------------
LLGLSUIDefault gls_ui;
@ -661,7 +661,7 @@ void LLGLTexSizeBar::draw()
if(LLImageGL::sCurTexSizeBar == mIndex)
{
F32 text_color[] = {1.f, 1.f, 1.f, 0.75f};
LLColor4 text_color(1.f, 1.f, 1.f, 0.75f);
std::string text;
text = llformat("%d", mTopLoaded) ;
@ -673,8 +673,8 @@ void LLGLTexSizeBar::draw()
text_color, LLFontGL::LEFT, LLFontGL::TOP);
}
F32 loaded_color[] = {1.0f, 0.0f, 0.0f, 0.75f};
F32 bound_color[] = {1.0f, 1.0f, 0.0f, 0.75f};
LLColor4 loaded_color(1.0f, 0.0f, 0.0f, 0.75f);
LLColor4 bound_color(1.0f, 1.0f, 0.0f, 0.75f);
gl_rect_2d(mLeft, mBottom + (S32)(mTopLoaded * mScale), (mLeft + mRight) / 2, mBottom, loaded_color) ;
gl_rect_2d((mLeft + mRight) / 2, mBottom + (S32)(mTopBound * mScale), mRight, mBottom, bound_color) ;
}

4
indra/newview/llviewerassetstats.cpp
View File

@ -430,10 +430,10 @@ void LLViewerAssetStats::getStats(AssetStats& stats, bool compact_output)
grid_from_region_handle(it->first, &grid_x, &grid_y);
r.grid_x(grid_x);
r.grid_y(grid_y);
r.duration(LLUnit::Microseconds<F64>(rec.getDuration()).value());
r.duration(LLUnit<LLUnits::Microseconds, F64>(rec.getDuration()).value());
}
stats.duration(mCurRecording ? LLUnit::Microseconds<F64>(mCurRecording->getDuration()).value() : 0.0);
stats.duration(mCurRecording ? LLUnit<LLUnits::Microseconds, F64>(mCurRecording->getDuration()).value() : 0.0);
stats.avatar.setProvided(true);
for (S32 rez_stat=0; rez_stat < mAvatarRezStates.size(); ++rez_stat)

20
indra/newview/llviewermessage.cpp
View File

@ -2587,7 +2587,7 @@ void process_improved_im(LLMessageSystem *msg, void **user_data)
LLSD args;
args["SUBJECT"] = subj;
args["MESSAGE"] = mes;
LLNotifications::instance().add(LLNotification::Params("GroupNotice").substitutions(args).payload(payload).time_stamp(timestamp));
LLNotifications::instance().add(LLNotification::Params("GroupNotice").substitutions(args).payload(payload).time_stamp(LLDate(timestamp)));
}
// Also send down the old path for now.
@ -4416,18 +4416,18 @@ void send_agent_update(BOOL force_send, BOOL send_reliable)
// *TODO: Remove this dependency, or figure out a better way to handle
// this hack.
extern LLUnit::Bits<U32> gObjectData;
extern LLUnit<LLUnits::Bits, U32> gObjectData;
void process_object_update(LLMessageSystem *mesgsys, void **user_data)
{
// Update the data counters
if (mesgsys->getReceiveCompressedSize())
{
gObjectData += (LLUnit::Bytes<U32>)mesgsys->getReceiveCompressedSize();
gObjectData += (LLUnit<LLUnits::Bytes, U32>)mesgsys->getReceiveCompressedSize();
}
else
{
gObjectData += (LLUnit::Bytes<U32>)mesgsys->getReceiveSize();
gObjectData += (LLUnit<LLUnits::Bytes, U32>)mesgsys->getReceiveSize();
}
// Update the object...
@ -4439,11 +4439,11 @@ void process_compressed_object_update(LLMessageSystem *mesgsys, void **user_data
// Update the data counters
if (mesgsys->getReceiveCompressedSize())
{
gObjectData += (LLUnit::Bytes<U32>)mesgsys->getReceiveCompressedSize();
gObjectData += (LLUnit<LLUnits::Bytes, U32>)mesgsys->getReceiveCompressedSize();
}
else
{
gObjectData += (LLUnit::Bytes<U32>)mesgsys->getReceiveSize();
gObjectData += (LLUnit<LLUnits::Bytes, U32>)mesgsys->getReceiveSize();
}
// Update the object...
@ -4455,11 +4455,11 @@ void process_cached_object_update(LLMessageSystem *mesgsys, void **user_data)
// Update the data counters
if (mesgsys->getReceiveCompressedSize())
{
gObjectData += (LLUnit::Bytes<U32>)mesgsys->getReceiveCompressedSize();
gObjectData += (LLUnit<LLUnits::Bytes, U32>)mesgsys->getReceiveCompressedSize();
}
else
{
gObjectData += (LLUnit::Bytes<U32>)mesgsys->getReceiveSize();
gObjectData += (LLUnit<LLUnits::Bytes, U32>)mesgsys->getReceiveSize();
}
// Update the object...
@ -4471,11 +4471,11 @@ void process_terse_object_update_improved(LLMessageSystem *mesgsys, void **user_
{
if (mesgsys->getReceiveCompressedSize())
{
gObjectData += (LLUnit::Bytes<U32>)mesgsys->getReceiveCompressedSize();
gObjectData += (LLUnit<LLUnits::Bytes, U32>)mesgsys->getReceiveCompressedSize();
}
else
{
gObjectData += (LLUnit::Bytes<U32>)mesgsys->getReceiveSize();
gObjectData += (LLUnit<LLUnits::Bytes, U32>)mesgsys->getReceiveSize();
}
gObjectList.processCompressedObjectUpdate(mesgsys, user_data, OUT_TERSE_IMPROVED);

6
indra/newview/llviewerstats.cpp
View File

@ -288,13 +288,13 @@ F32 gAveLandCompression = 0.f,
gWorstLandCompression = 0.f,
gWorstWaterCompression = 0.f;
LLUnit::Bytes<U32> gTotalWorldData = 0,
LLUnit<LLUnits::Bytes, U32> gTotalWorldData = 0,
gTotalObjectData = 0,
gTotalTextureData = 0;
U32 gSimPingCount = 0;
LLUnit::Bits<U32> gObjectData = 0;
LLUnit<LLUnits::Bits, U32> gObjectData = 0;
F32 gAvgSimPing = 0.f;
LLUnit::Bytes<U32> gTotalTextureBytesPerBoostLevel[LLViewerTexture::MAX_GL_IMAGE_CATEGORY] = {0};
LLUnit<LLUnits::Bytes, U32> gTotalTextureBytesPerBoostLevel[LLViewerTexture::MAX_GL_IMAGE_CATEGORY] = {0};
extern U32 gVisCompared;
extern U32 gVisTested;

6
indra/newview/llviewerstats.h
View File

@ -319,7 +319,7 @@ void update_statistics();
void send_stats();
extern LLFrameTimer gTextureTimer;
extern LLUnit::Bytes<U32> gTotalTextureData;
extern LLUnit::Bytes<U32> gTotalObjectData;
extern LLUnit::Bytes<U32> gTotalTextureBytesPerBoostLevel[] ;
extern LLUnit<LLUnits::Bytes, U32> gTotalTextureData;
extern LLUnit<LLUnits::Bytes, U32> gTotalObjectData;
extern LLUnit<LLUnits::Bytes, U32> gTotalTextureBytesPerBoostLevel[] ;
#endif // LL_LLVIEWERSTATS_H

18
indra/newview/llviewertexture.cpp
View File

@ -65,8 +65,8 @@
///////////////////////////////////////////////////////////////////////////////
// extern
const LLUnit::Megabytes<S32> gMinVideoRam = 32;
const LLUnit::Megabytes<S32> gMaxVideoRam = 512;
const LLUnit<LLUnits::Megabytes, S32> gMinVideoRam = 32;
const LLUnit<LLUnits::Megabytes, S32> gMaxVideoRam = 512;
// statics
@ -87,11 +87,11 @@ S32 LLViewerTexture::sAuxCount = 0;
LLFrameTimer LLViewerTexture::sEvaluationTimer;
F32 LLViewerTexture::sDesiredDiscardBias = 0.f;
F32 LLViewerTexture::sDesiredDiscardScale = 1.1f;
LLUnit::Bytes<S32> LLViewerTexture::sBoundTextureMemory = 0;
LLUnit::Bytes<S32> LLViewerTexture::sTotalTextureMemory = 0;
LLUnit::Megabytes<S32> LLViewerTexture::sMaxBoundTextureMem = 0;
LLUnit::Megabytes<S32> LLViewerTexture::sMaxTotalTextureMem = 0;
LLUnit::Bytes<S32> LLViewerTexture::sMaxDesiredTextureMem = 0 ;
LLUnit<LLUnits::Bytes, S32> LLViewerTexture::sBoundTextureMemory = 0;
LLUnit<LLUnits::Bytes, S32> LLViewerTexture::sTotalTextureMemory = 0;
LLUnit<LLUnits::Megabytes, S32> LLViewerTexture::sMaxBoundTextureMem = 0;
LLUnit<LLUnits::Megabytes, S32> LLViewerTexture::sMaxTotalTextureMem = 0;
LLUnit<LLUnits::Bytes, S32> LLViewerTexture::sMaxDesiredTextureMem = 0 ;
S8 LLViewerTexture::sCameraMovingDiscardBias = 0 ;
F32 LLViewerTexture::sCameraMovingBias = 0.0f ;
S32 LLViewerTexture::sMaxSculptRez = 128 ; //max sculpt image size
@ -532,8 +532,8 @@ void LLViewerTexture::updateClass(const F32 velocity, const F32 angular_velocity
if (sBoundTextureMemory >= sMaxBoundTextureMem ||
sTotalTextureMemory >= sMaxTotalTextureMem)
{
//when texture memory overflows, lower down the threashold to release the textures more aggressively.
sMaxDesiredTextureMem = llmin(sMaxDesiredTextureMem * 0.75f, LLUnit::Bytes<S32>(gMaxVideoRam));
//when texture memory overflows, lower down the threshold to release the textures more aggressively.
sMaxDesiredTextureMem = llmin(sMaxDesiredTextureMem * 0.75f, LLUnit<LLUnits::Bytes, S32>(gMaxVideoRam));
// If we are using more texture memory than we should,
// scale up the desired discard level

14
indra/newview/llviewertexture.h
View File

@ -39,8 +39,8 @@
#include <map>
#include <list>
extern const LLUnit::Megabytes<S32> gMinVideoRam;
extern const LLUnit::Megabytes<S32> gMaxVideoRam;
extern const LLUnit<LLUnits::Megabytes, S32> gMinVideoRam;
extern const LLUnit<LLUnits::Megabytes, S32> gMaxVideoRam;
class LLFace;
class LLImageGL ;
@ -323,11 +323,11 @@ public:
static LLFrameTimer sEvaluationTimer;
static F32 sDesiredDiscardBias;
static F32 sDesiredDiscardScale;
static LLUnit::Bytes<S32> sBoundTextureMemory;
static LLUnit::Bytes<S32> sTotalTextureMemory;
static LLUnit::Megabytes<S32> sMaxBoundTextureMem;
static LLUnit::Megabytes<S32> sMaxTotalTextureMem;
static LLUnit::Bytes<S32> sMaxDesiredTextureMem ;
static LLUnit<LLUnits::Bytes, S32> sBoundTextureMemory;
static LLUnit<LLUnits::Bytes, S32> sTotalTextureMemory;
static LLUnit<LLUnits::Megabytes, S32> sMaxBoundTextureMem;
static LLUnit<LLUnits::Megabytes, S32> sMaxTotalTextureMem;
static LLUnit<LLUnits::Bytes, S32> sMaxDesiredTextureMem ;
static S8 sCameraMovingDiscardBias;
static F32 sCameraMovingBias;
static S32 sMaxSculptRez ;

2
indra/newview/llviewerwindow.cpp
View File

@ -733,7 +733,7 @@ public:
{
if(gTotalTextureBytesPerBoostLevel[i] > 0)
{
addText(xpos, ypos, llformat("Boost_Level %d: %.3f MB", i, LLUnit::Megabytes<F32>(gTotalTextureBytesPerBoostLevel[i]).value()));
addText(xpos, ypos, llformat("Boost_Level %d: %.3f MB", i, LLUnit<LLUnits::Megabytes, F32>(gTotalTextureBytesPerBoostLevel[i]).value()));
ypos += y_inc;
}
}