From 26581404e426b00cd0a07c38b5cb858d5d5faa28 Mon Sep 17 00:00:00 2001 From: Richard Linden Date: Wed, 14 Aug 2013 11:51:49 -0700 Subject: BUILDFIX: added header for numeric_limits support on gcc added convenience types for units F32Seconds, etc. --- indra/llcommon/llerror.h | 2 +- indra/llcommon/llfasttimer.cpp | 10 +- indra/llcommon/llfasttimer.h | 2 +- indra/llcommon/lltimer.cpp | 2 +- indra/llcommon/lltraceaccumulators.h | 4 +- indra/llcommon/lltracerecording.cpp | 62 ++++++------ indra/llcommon/lltracerecording.h | 28 +++--- indra/llcommon/llunit.h | 177 +++++++++++++++++++++++++++++++++- indra/llcommon/tests/llunits_test.cpp | 2 +- 9 files changed, 232 insertions(+), 57 deletions(-) (limited to 'indra/llcommon') diff --git a/indra/llcommon/llerror.h b/indra/llcommon/llerror.h index 7810676388..a3619559eb 100755 --- a/indra/llcommon/llerror.h +++ b/indra/llcommon/llerror.h @@ -308,7 +308,7 @@ typedef LLError::NoClassInfo _LL_CLASS_TO_LOG; #define lllog(level, once, ...) \ do { \ const char* tags[] = {"", ##__VA_ARGS__}; \ - size_t tag_count = LL_ARRAY_SIZE(tags) - 1; \ + ::size_t tag_count = LL_ARRAY_SIZE(tags) - 1; \ static LLError::CallSite _site( \ level, __FILE__, __LINE__, typeid(_LL_CLASS_TO_LOG), __FUNCTION__, once, &tags[1], tag_count);\ if (LL_UNLIKELY(_site.shouldLog())) \ diff --git a/indra/llcommon/llfasttimer.cpp b/indra/llcommon/llfasttimer.cpp index 8f86a1dfbc..a91e716f19 100755 --- a/indra/llcommon/llfasttimer.cpp +++ b/indra/llcommon/llfasttimer.cpp @@ -339,7 +339,7 @@ void TimeBlock::logStats() } call_count++; - LLUnit total_time(0); + LLUnits::F64Seconds total_time(0); LLSD sd; { @@ -382,11 +382,11 @@ void TimeBlock::dumpCurTimes() ++it) { TimeBlock* timerp = (*it); - LLUnit total_time = last_frame_recording.getSum(*timerp); + LLUnits::F64Seconds total_time = last_frame_recording.getSum(*timerp); U32 num_calls = last_frame_recording.getSum(timerp->callCount()); // Don't bother with really brief times, keep output concise - if (total_time < LLUnits::Milliseconds::fromValue(0.1f)) continue; + if (total_time < LLUnits::F32Milliseconds(0.1f)) continue; std::ostringstream out_str; TimeBlock* parent_timerp = timerp; @@ -466,11 +466,11 @@ void TimeBlockAccumulator::reset( const TimeBlockAccumulator* other ) } } -LLUnit BlockTimer::getElapsedTime() +LLUnits::F64Seconds BlockTimer::getElapsedTime() { U64 total_time = TimeBlock::getCPUClockCount64() - mStartTime; - return LLUnits::Seconds::fromValue((F64)total_time / (F64)TimeBlock::countsPerSecond()); + return LLUnits::F64Seconds((F64)total_time / (F64)TimeBlock::countsPerSecond()); } diff --git a/indra/llcommon/llfasttimer.h b/indra/llcommon/llfasttimer.h index 73c40749ed..589b9bb941 100755 --- a/indra/llcommon/llfasttimer.h +++ b/indra/llcommon/llfasttimer.h @@ -48,7 +48,7 @@ public: BlockTimer(TimeBlock& timer); ~BlockTimer(); - LLUnit getElapsedTime(); + LLUnits::F64Seconds getElapsedTime(); private: diff --git a/indra/llcommon/lltimer.cpp b/indra/llcommon/lltimer.cpp index a2c5f3d699..7077ea4b4f 100755 --- a/indra/llcommon/lltimer.cpp +++ b/indra/llcommon/lltimer.cpp @@ -262,7 +262,7 @@ LLUnitImplicit totalTime() } // Return the total clock tick count in microseconds. - return LLUnits::Microseconds::fromValue(gTotalTimeClockCount*gClocksToMicroseconds); + return LLUnits::U64Microseconds(gTotalTimeClockCount*gClocksToMicroseconds); } diff --git a/indra/llcommon/lltraceaccumulators.h b/indra/llcommon/lltraceaccumulators.h index ef73bd3091..4d79964526 100644 --- a/indra/llcommon/lltraceaccumulators.h +++ b/indra/llcommon/lltraceaccumulators.h @@ -418,7 +418,7 @@ namespace LLTrace class TimeBlockAccumulator { public: - typedef LLUnit value_t; + typedef LLUnits::F64Seconds value_t; typedef TimeBlockAccumulator self_t; // fake classes that allows us to view different facets of underlying statistic @@ -429,7 +429,7 @@ namespace LLTrace struct SelfTimeFacet { - typedef LLUnit value_t; + typedef LLUnits::F64Seconds value_t; }; TimeBlockAccumulator(); diff --git a/indra/llcommon/lltracerecording.cpp b/indra/llcommon/lltracerecording.cpp index 42d97ce314..963f0cd174 100644 --- a/indra/llcommon/lltracerecording.cpp +++ b/indra/llcommon/lltracerecording.cpp @@ -95,7 +95,7 @@ void Recording::handleReset() { mBuffers.write()->reset(); - mElapsedSeconds = LLUnits::Seconds::fromValue(0.0); + mElapsedSeconds = LLUnits::F64Seconds(0.0); mSamplingTimer.reset(); } @@ -128,17 +128,17 @@ void Recording::appendRecording( Recording& other ) mElapsedSeconds += other.mElapsedSeconds; } -LLUnit Recording::getSum(const TraceType& stat) +LLUnits::F64Seconds Recording::getSum(const TraceType& stat) { const TimeBlockAccumulator& accumulator = mBuffers->mStackTimers[stat.getIndex()]; - return LLUnits::Seconds::fromValue((F64)(accumulator.mTotalTimeCounter - accumulator.mStartTotalTimeCounter) + return LLUnits::F64Seconds((F64)(accumulator.mTotalTimeCounter - accumulator.mStartTotalTimeCounter) / (F64)LLTrace::TimeBlock::countsPerSecond()); } -LLUnit Recording::getSum(const TraceType& stat) +LLUnits::F64Seconds Recording::getSum(const TraceType& stat) { const TimeBlockAccumulator& accumulator = mBuffers->mStackTimers[stat.getIndex()]; - return LLUnits::Seconds::fromValue((F64)(accumulator.mSelfTimeCounter) / (F64)LLTrace::TimeBlock::countsPerSecond()); + return LLUnits::F64Seconds((F64)(accumulator.mSelfTimeCounter) / (F64)LLTrace::TimeBlock::countsPerSecond()); } @@ -147,19 +147,19 @@ U32 Recording::getSum(const TraceType& sta return mBuffers->mStackTimers[stat.getIndex()].mCalls; } -LLUnit Recording::getPerSec(const TraceType& stat) +LLUnits::F64Seconds Recording::getPerSec(const TraceType& stat) { const TimeBlockAccumulator& accumulator = mBuffers->mStackTimers[stat.getIndex()]; - return LLUnits::Seconds::fromValue((F64)(accumulator.mTotalTimeCounter - accumulator.mStartTotalTimeCounter) + return LLUnits::F64Seconds((F64)(accumulator.mTotalTimeCounter - accumulator.mStartTotalTimeCounter) / ((F64)LLTrace::TimeBlock::countsPerSecond() * mElapsedSeconds.value())); } -LLUnit Recording::getPerSec(const TraceType& stat) +LLUnits::F64Seconds Recording::getPerSec(const TraceType& stat) { const TimeBlockAccumulator& accumulator = mBuffers->mStackTimers[stat.getIndex()]; - return LLUnits::Seconds::fromValue((F64)(accumulator.mSelfTimeCounter) + return LLUnits::F64Seconds((F64)(accumulator.mSelfTimeCounter) / ((F64)LLTrace::TimeBlock::countsPerSecond() * mElapsedSeconds.value())); } @@ -168,54 +168,54 @@ F32 Recording::getPerSec(const TraceType& return (F32)mBuffers->mStackTimers[stat.getIndex()].mCalls / mElapsedSeconds.value(); } -LLUnit Recording::getMin(const TraceType& stat) +LLUnits::F64Bytes Recording::getMin(const TraceType& stat) { - return LLUnits::Bytes::fromValue(mBuffers->mMemStats[stat.getIndex()].mSize.getMin()); + return LLUnits::F64Bytes(mBuffers->mMemStats[stat.getIndex()].mSize.getMin()); } -LLUnit Recording::getMean(const TraceType& stat) +LLUnits::F64Bytes Recording::getMean(const TraceType& stat) { - return LLUnits::Bytes::fromValue(mBuffers->mMemStats[stat.getIndex()].mSize.getMean()); + return LLUnits::F64Bytes(mBuffers->mMemStats[stat.getIndex()].mSize.getMean()); } -LLUnit Recording::getMax(const TraceType& stat) +LLUnits::F64Bytes Recording::getMax(const TraceType& stat) { - return LLUnits::Bytes::fromValue(mBuffers->mMemStats[stat.getIndex()].mSize.getMax()); + return LLUnits::F64Bytes(mBuffers->mMemStats[stat.getIndex()].mSize.getMax()); } -LLUnit Recording::getStandardDeviation(const TraceType& stat) +LLUnits::F64Bytes Recording::getStandardDeviation(const TraceType& stat) { - return LLUnits::Bytes::fromValue(mBuffers->mMemStats[stat.getIndex()].mSize.getStandardDeviation()); + return LLUnits::F64Bytes(mBuffers->mMemStats[stat.getIndex()].mSize.getStandardDeviation()); } -LLUnit Recording::getLastValue(const TraceType& stat) +LLUnits::F64Bytes Recording::getLastValue(const TraceType& stat) { - return LLUnits::Bytes::fromValue(mBuffers->mMemStats[stat.getIndex()].mSize.getLastValue()); + return LLUnits::F64Bytes(mBuffers->mMemStats[stat.getIndex()].mSize.getLastValue()); } -LLUnit Recording::getMin(const TraceType& stat) +LLUnits::F64Bytes Recording::getMin(const TraceType& stat) { - return LLUnits::Bytes::fromValue(mBuffers->mMemStats[stat.getIndex()].mChildSize.getMin()); + return LLUnits::F64Bytes(mBuffers->mMemStats[stat.getIndex()].mChildSize.getMin()); } -LLUnit Recording::getMean(const TraceType& stat) +LLUnits::F64Bytes Recording::getMean(const TraceType& stat) { - return LLUnits::Bytes::fromValue(mBuffers->mMemStats[stat.getIndex()].mChildSize.getMean()); + return LLUnits::F64Bytes(mBuffers->mMemStats[stat.getIndex()].mChildSize.getMean()); } -LLUnit Recording::getMax(const TraceType& stat) +LLUnits::F64Bytes Recording::getMax(const TraceType& stat) { - return LLUnits::Bytes::fromValue(mBuffers->mMemStats[stat.getIndex()].mChildSize.getMax()); + return LLUnits::F64Bytes(mBuffers->mMemStats[stat.getIndex()].mChildSize.getMax()); } -LLUnit Recording::getStandardDeviation(const TraceType& stat) +LLUnits::F64Bytes Recording::getStandardDeviation(const TraceType& stat) { - return LLUnits::Bytes::fromValue(mBuffers->mMemStats[stat.getIndex()].mChildSize.getStandardDeviation()); + return LLUnits::F64Bytes(mBuffers->mMemStats[stat.getIndex()].mChildSize.getStandardDeviation()); } -LLUnit Recording::getLastValue(const TraceType& stat) +LLUnits::F64Bytes Recording::getLastValue(const TraceType& stat) { - return LLUnits::Bytes::fromValue(mBuffers->mMemStats[stat.getIndex()].mChildSize.getLastValue()); + return LLUnits::F64Bytes(mBuffers->mMemStats[stat.getIndex()].mChildSize.getLastValue()); } U32 Recording::getSum(const TraceType& stat) @@ -427,9 +427,9 @@ void PeriodicRecording::appendPeriodicRecording( PeriodicRecording& other ) getCurRecording().setPlayState(getPlayState()); } -LLUnit PeriodicRecording::getDuration() const +LLUnits::F64Seconds PeriodicRecording::getDuration() const { - LLUnit duration; + LLUnits::F64Seconds duration; size_t num_periods = mRecordingPeriods.size(); for (size_t i = 1; i <= num_periods; i++) { diff --git a/indra/llcommon/lltracerecording.h b/indra/llcommon/lltracerecording.h index 3722a61327..811786fbfa 100644 --- a/indra/llcommon/lltracerecording.h +++ b/indra/llcommon/lltracerecording.h @@ -166,12 +166,12 @@ namespace LLTrace void makeUnique() { mBuffers.makeUnique(); } // Timer accessors - LLUnit getSum(const TraceType& stat); - LLUnit getSum(const TraceType& stat); + LLUnits::F64Seconds getSum(const TraceType& stat); + LLUnits::F64Seconds getSum(const TraceType& stat); U32 getSum(const TraceType& stat); - LLUnit getPerSec(const TraceType& stat); - LLUnit getPerSec(const TraceType& stat); + LLUnits::F64Seconds getPerSec(const TraceType& stat); + LLUnits::F64Seconds getPerSec(const TraceType& stat); F32 getPerSec(const TraceType& stat); // Memory accessors @@ -295,7 +295,7 @@ namespace LLTrace U32 getSampleCount(const TraceType& stat); - LLUnit getDuration() const { return mElapsedSeconds; } + LLUnits::F64Seconds getDuration() const { return mElapsedSeconds; } protected: friend class ThreadRecorder; @@ -310,7 +310,7 @@ namespace LLTrace class ThreadRecorder* getThreadRecorder(); LLTimer mSamplingTimer; - LLUnit mElapsedSeconds; + LLUnits::F64Seconds mElapsedSeconds; LLCopyOnWritePointer mBuffers; bool mInHandOff; @@ -325,7 +325,7 @@ namespace LLTrace void nextPeriod(); size_t getNumRecordedPeriods() { return mNumPeriods; } - LLUnit getDuration() const; + LLUnits::F64Seconds getDuration() const; void appendPeriodicRecording(PeriodicRecording& other); void appendRecording(Recording& recording); @@ -485,7 +485,7 @@ namespace LLTrace size_t total_periods = mNumPeriods; num_periods = llmin(num_periods, isStarted() ? total_periods - 1 : total_periods); - typename RelatedTypes::fractional_t mean = 0; + typename RelatedTypes::fractional_t mean(0); for (S32 i = 1; i <= num_periods; i++) { @@ -495,9 +495,9 @@ namespace LLTrace mean += recording.getSum(stat); } } - return RelatedTypes::fractional_t(num_periods - ? mean / num_periods - : NaN); + return (num_periods + ? RelatedTypes::fractional_t(mean / num_periods) + : RelatedTypes::fractional_t(NaN)); } template @@ -536,9 +536,9 @@ namespace LLTrace } } - return RelatedTypes::fractional_t(num_periods - ? mean / num_periods - : NaN); + return (num_periods + ? RelatedTypes::fractional_t(mean / num_periods) + : RelatedTypes::fractional_t(NaN)); } template diff --git a/indra/llcommon/llunit.h b/indra/llcommon/llunit.h index b135be48fa..9a367d9182 100644 --- a/indra/llcommon/llunit.h +++ b/indra/llcommon/llunit.h @@ -39,7 +39,7 @@ struct LLUnit typedef STORAGE_TYPE storage_t; // value initialization - LLUnit(storage_t value = storage_t()) + explicit LLUnit(storage_t value = storage_t()) : mValue(value) {} @@ -644,6 +644,54 @@ LL_DECLARE_DERIVED_UNIT(Bytes, * 1024, Kibibytes, "KiB"); LL_DECLARE_DERIVED_UNIT(Kibibytes, * 1024, Mibibytes, "MiB"); LL_DECLARE_DERIVED_UNIT(Mibibytes, * 1024, Gibibytes, "GiB"); +typedef LLUnit F32Bytes; +typedef LLUnit F32KiloBytes; +typedef LLUnit F32MegaBytes; +typedef LLUnit F32GigaBytes; +typedef LLUnit F32KibiBytes; +typedef LLUnit F32MibiBytes; +typedef LLUnit F32GibiBytes; + +typedef LLUnit F64Bytes; +typedef LLUnit F64KiloBytes; +typedef LLUnit F64MegaBytes; +typedef LLUnit F64GigaBytes; +typedef LLUnit F64KibiBytes; +typedef LLUnit F64MibiBytes; +typedef LLUnit F64GibiBytes; + +typedef LLUnit S32Bytes; +typedef LLUnit S32KiloBytes; +typedef LLUnit S32MegaBytes; +typedef LLUnit S32GigaBytes; +typedef LLUnit S32KibiBytes; +typedef LLUnit S32MibiBytes; +typedef LLUnit S32GibiBytes; + +typedef LLUnit U32Bytes; +typedef LLUnit U32KiloBytes; +typedef LLUnit U32MegaBytes; +typedef LLUnit U32GigaBytes; +typedef LLUnit U32KibiBytes; +typedef LLUnit U32MibiBytes; +typedef LLUnit U32GibiBytes; + +typedef LLUnit S64Bytes; +typedef LLUnit S64KiloBytes; +typedef LLUnit S64MegaBytes; +typedef LLUnit S64GigaBytes; +typedef LLUnit S64KibiBytes; +typedef LLUnit S64MibiBytes; +typedef LLUnit S64GibiBytes; + +typedef LLUnit U64Bytes; +typedef LLUnit U64KiloBytes; +typedef LLUnit U64MegaBytes; +typedef LLUnit U64GigaBytes; +typedef LLUnit U64KibiBytes; +typedef LLUnit U64MibiBytes; +typedef LLUnit U64GibiBytes; + LL_DECLARE_DERIVED_UNIT(Bytes, / 8, Bits, "b"); LL_DECLARE_DERIVED_UNIT(Bits, * 1000, Kilobits, "Kb"); LL_DECLARE_DERIVED_UNIT(Kilobits, * 1000, Megabits, "Mb"); @@ -652,6 +700,54 @@ LL_DECLARE_DERIVED_UNIT(Bits, * 1024, Kibibits, "Kib"); LL_DECLARE_DERIVED_UNIT(Kibibits, * 1024, Mibibits, "Mib"); LL_DECLARE_DERIVED_UNIT(Mibibits, * 1024, Gibibits, "Gib"); +typedef LLUnit F32Bits; +typedef LLUnit F32KiloBits; +typedef LLUnit F32MegaBits; +typedef LLUnit F32GigaBits; +typedef LLUnit F32KibiBits; +typedef LLUnit F32MibiBits; +typedef LLUnit F32GibiBits; + +typedef LLUnit F64Bits; +typedef LLUnit F64KiloBits; +typedef LLUnit F64MegaBits; +typedef LLUnit F64GigaBits; +typedef LLUnit F64KibiBits; +typedef LLUnit F64MibiBits; +typedef LLUnit F64GibiBits; + +typedef LLUnit S32Bits; +typedef LLUnit S32KiloBits; +typedef LLUnit S32MegaBits; +typedef LLUnit S32GigaBits; +typedef LLUnit S32KibiBits; +typedef LLUnit S32MibiBits; +typedef LLUnit S32GibiBits; + +typedef LLUnit U32Bits; +typedef LLUnit U32KiloBits; +typedef LLUnit U32MegaBits; +typedef LLUnit U32GigaBits; +typedef LLUnit U32KibiBits; +typedef LLUnit U32MibiBits; +typedef LLUnit U32GibiBits; + +typedef LLUnit S64Bits; +typedef LLUnit S64KiloBits; +typedef LLUnit S64MegaBits; +typedef LLUnit S64GigaBits; +typedef LLUnit S64KibiBits; +typedef LLUnit S64MibiBits; +typedef LLUnit S64GibiBits; + +typedef LLUnit U64Bits; +typedef LLUnit U64KiloBits; +typedef LLUnit U64MegaBits; +typedef LLUnit U64GigaBits; +typedef LLUnit U64KibiBits; +typedef LLUnit U64MibiBits; +typedef LLUnit U64GibiBits; + LL_DECLARE_BASE_UNIT(Seconds, "s"); LL_DECLARE_DERIVED_UNIT(Seconds, * 60, Minutes, "min"); LL_DECLARE_DERIVED_UNIT(Minutes, * 60, Hours, "h"); @@ -660,11 +756,90 @@ LL_DECLARE_DERIVED_UNIT(Seconds, / 1000, Milliseconds, "ms"); LL_DECLARE_DERIVED_UNIT(Milliseconds, / 1000, Microseconds, "\x09\x3cs"); LL_DECLARE_DERIVED_UNIT(Microseconds, / 1000, Nanoseconds, "ns"); +typedef LLUnit F32Seconds; +typedef LLUnit F32Minutes; +typedef LLUnit F32Hours; +typedef LLUnit F32Days; +typedef LLUnit F32Milliseconds; +typedef LLUnit F32Microseconds; +typedef LLUnit F32Nanoseconds; + +typedef LLUnit F64Seconds; +typedef LLUnit F64Minutes; +typedef LLUnit F64Hours; +typedef LLUnit F64Days; +typedef LLUnit F64Milliseconds; +typedef LLUnit F64Microseconds; +typedef LLUnit F64Nanoseconds; + +typedef LLUnit S32Seconds; +typedef LLUnit S32Minutes; +typedef LLUnit S32Hours; +typedef LLUnit S32Days; +typedef LLUnit S32Milliseconds; +typedef LLUnit S32Microseconds; +typedef LLUnit S32Nanoseconds; + +typedef LLUnit U32Seconds; +typedef LLUnit U32Minutes; +typedef LLUnit U32Hours; +typedef LLUnit U32Days; +typedef LLUnit U32Milliseconds; +typedef LLUnit U32Microseconds; +typedef LLUnit U32Nanoseconds; + +typedef LLUnit S64Seconds; +typedef LLUnit S64Minutes; +typedef LLUnit S64Hours; +typedef LLUnit S64Days; +typedef LLUnit S64Milliseconds; +typedef LLUnit S64Microseconds; +typedef LLUnit S64Nanoseconds; + +typedef LLUnit U64Seconds; +typedef LLUnit U64Minutes; +typedef LLUnit U64Hours; +typedef LLUnit U64Days; +typedef LLUnit U64Milliseconds; +typedef LLUnit U64Microseconds; +typedef LLUnit U64Nanoseconds; + LL_DECLARE_BASE_UNIT(Meters, "m"); LL_DECLARE_DERIVED_UNIT(Meters, * 1000, Kilometers, "km"); LL_DECLARE_DERIVED_UNIT(Meters, / 100, Centimeters, "cm"); LL_DECLARE_DERIVED_UNIT(Meters, / 1000, Millimeters, "mm"); +typedef LLUnit F32Meters; +typedef LLUnit F32Kilometers; +typedef LLUnit F32Centimeters; +typedef LLUnit F32Millimeters; + +typedef LLUnit F64Meters; +typedef LLUnit F64Kilometers; +typedef LLUnit F64Centimeters; +typedef LLUnit F64Millimeters; + +typedef LLUnit S32Meters; +typedef LLUnit S32Kilometers; +typedef LLUnit S32Centimeters; +typedef LLUnit S32Millimeters; + +typedef LLUnit U32Meters; +typedef LLUnit U32Kilometers; +typedef LLUnit U32Centimeters; +typedef LLUnit U32Millimeters; + +typedef LLUnit S64Meters; +typedef LLUnit S64Kilometers; +typedef LLUnit S64Centimeters; +typedef LLUnit S64Millimeters; + +typedef LLUnit U64Meters; +typedef LLUnit U64Kilometers; +typedef LLUnit U64Centimeters; +typedef LLUnit U64Millimeters; + +// rare units LL_DECLARE_BASE_UNIT(Hertz, "Hz"); LL_DECLARE_DERIVED_UNIT(Hertz, * 1000, Kilohertz, "KHz"); LL_DECLARE_DERIVED_UNIT(Kilohertz, * 1000, Megahertz, "MHz"); diff --git a/indra/llcommon/tests/llunits_test.cpp b/indra/llcommon/tests/llunits_test.cpp index b0309585aa..8546bcbc54 100644 --- a/indra/llcommon/tests/llunits_test.cpp +++ b/indra/llcommon/tests/llunits_test.cpp @@ -112,7 +112,7 @@ namespace tut void units_object_t::test<4>() { // exercise math operations - LLUnit quatloos = 1.f; + LLUnit quatloos(1.f); quatloos *= 4.f; ensure(quatloos == 4); quatloos = quatloos * 2; -- cgit v1.2.3