Skip to content
Snippets Groups Projects
Commit 0dfc08d2 authored by Richard Linden's avatar Richard Linden
Browse files

BUILDFIX: more bad merge stuff

also added ability for statbar to show memtrackable info
parent 02dc2706
Branches
Tags
No related merge requests found
...@@ -512,12 +512,17 @@ class MemTrackable ...@@ -512,12 +512,17 @@ class MemTrackable
return value; return value;
} }
const size_t& memClaim(const size_t& size)
{
claim_mem(sMemStat, size);
mMemFootprint += size;
return size;
}
template<typename AMOUNT_T> size_t& memClaim(size_t& size)
AMOUNT_T& memClaimAmount(AMOUNT_T& size)
{ {
MemStatAccumulator& accumulator = sMemStat.getCurrentAccumulator(); claim_mem(sMemStat, size);
mMemFootprint += (size_t)size; mMemFootprint += size;
return size; return size;
} }
...@@ -536,10 +541,17 @@ class MemTrackable ...@@ -536,10 +541,17 @@ class MemTrackable
return value; return value;
} }
template<typename AMOUNT_T> const size_t& memDisclaim(const size_t& size)
AMOUNT_T& memDisclaimAmount(AMOUNT_T& size) {
disclaim_mem(sMemStat, size);
mMemFootprint -= size;
return size;
}
size_t& memDisclaim(size_t& size)
{ {
disclaim_mem(size); disclaim_mem(sMemStat, size);
mMemFootprint -= size;
return size; return size;
} }
......
...@@ -168,6 +168,16 @@ F32 Recording::getPerSec(const TraceType<TimeBlockAccumulator::CallCountFacet>& ...@@ -168,6 +168,16 @@ F32 Recording::getPerSec(const TraceType<TimeBlockAccumulator::CallCountFacet>&
return (F32)mBuffers->mStackTimers[stat.getIndex()].mCalls / mElapsedSeconds.value(); return (F32)mBuffers->mStackTimers[stat.getIndex()].mCalls / mElapsedSeconds.value();
} }
bool Recording::hasValue(const TraceType<MemStatAccumulator>& stat)
{
return mBuffers->mMemStats[stat.getIndex()].mSize.hasValue();
}
bool Recording::hasValue(const TraceType<MemStatAccumulator::ShadowMemFacet>& stat)
{
return mBuffers->mMemStats[stat.getIndex()].mShadowSize.hasValue();
}
F64Bytes Recording::getMin(const TraceType<MemStatAccumulator>& stat) F64Bytes Recording::getMin(const TraceType<MemStatAccumulator>& stat)
{ {
return F64Bytes(mBuffers->mMemStats[stat.getIndex()].mSize.getMin()); return F64Bytes(mBuffers->mMemStats[stat.getIndex()].mSize.getMin());
...@@ -707,6 +717,98 @@ F64 PeriodicRecording::getPeriodStandardDeviation( const TraceType<SampleAccumul ...@@ -707,6 +717,98 @@ F64 PeriodicRecording::getPeriodStandardDeviation( const TraceType<SampleAccumul
: NaN; : NaN;
} }
F64Bytes PeriodicRecording::getPeriodMin( const TraceType<MemStatAccumulator>& stat, size_t num_periods /*= U32_MAX*/ )
{
size_t total_periods = mRecordingPeriods.size();
num_periods = llmin(num_periods, isStarted() ? total_periods - 1 : total_periods);
F64Bytes min_val(std::numeric_limits<F64>::max());
for (S32 i = 1; i <= num_periods; i++)
{
Recording& recording = getPrevRecording(i);
min_val = llmin(min_val, recording.getMin(stat));
}
return min_val;
}
F64Bytes PeriodicRecording::getPeriodMin(const MemStatHandle& stat, size_t num_periods)
{
return getPeriodMin(static_cast<const TraceType<MemStatAccumulator>&>(stat), num_periods);
}
F64Bytes PeriodicRecording::getPeriodMax(const TraceType<MemStatAccumulator>& stat, size_t num_periods /*= U32_MAX*/)
{
size_t total_periods = mRecordingPeriods.size();
num_periods = llmin(num_periods, isStarted() ? total_periods - 1 : total_periods);
F64Bytes max_val(0.0);
for (S32 i = 1; i <= num_periods; i++)
{
Recording& recording = getPrevRecording(i);
max_val = llmax(max_val, recording.getMax(stat));
}
return max_val;
}
F64Bytes PeriodicRecording::getPeriodMax(const MemStatHandle& stat, size_t num_periods)
{
return getPeriodMax(static_cast<const TraceType<MemStatAccumulator>&>(stat), num_periods);
}
F64Bytes PeriodicRecording::getPeriodMean( const TraceType<MemStatAccumulator>& stat, size_t num_periods /*= U32_MAX*/ )
{
size_t total_periods = mRecordingPeriods.size();
num_periods = llmin(num_periods, isStarted() ? total_periods - 1 : total_periods);
F64Bytes mean(0);
for (S32 i = 1; i <= num_periods; i++)
{
Recording& recording = getPrevRecording(i);
mean += recording.getMean(stat);
}
return mean / F64(num_periods);
}
F64Bytes PeriodicRecording::getPeriodMean(const MemStatHandle& stat, size_t num_periods)
{
return getPeriodMean(static_cast<const TraceType<MemStatAccumulator>&>(stat), num_periods);
}
F64Bytes PeriodicRecording::getPeriodStandardDeviation( const TraceType<MemStatAccumulator>& stat, size_t num_periods /*= U32_MAX*/ )
{
size_t total_periods = mRecordingPeriods.size();
num_periods = llmin(num_periods, isStarted() ? total_periods - 1 : total_periods);
F64Bytes period_mean = getPeriodMean(stat, num_periods);
S32 valid_period_count = 0;
F64 sum_of_squares = 0;
for (S32 i = 1; i <= num_periods; i++)
{
Recording& recording = getPrevRecording(i);
if (recording.hasValue(stat))
{
F64Bytes delta = recording.getMean(stat) - period_mean;
sum_of_squares += delta.value() * delta.value();
valid_period_count++;
}
}
return F64Bytes(valid_period_count
? sqrt(sum_of_squares / (F64)valid_period_count)
: NaN);
}
F64Bytes PeriodicRecording::getPeriodStandardDeviation(const MemStatHandle& stat, size_t num_periods)
{
return getPeriodStandardDeviation(static_cast<const TraceType<MemStatAccumulator>&>(stat), num_periods);
}
/////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////
// ExtendableRecording // ExtendableRecording
/////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////
......
...@@ -175,6 +175,9 @@ namespace LLTrace ...@@ -175,6 +175,9 @@ namespace LLTrace
F32 getPerSec(const TraceType<TimeBlockAccumulator::CallCountFacet>& stat); F32 getPerSec(const TraceType<TimeBlockAccumulator::CallCountFacet>& stat);
// Memory accessors // Memory accessors
bool hasValue(const TraceType<MemStatAccumulator>& stat);
bool hasValue(const TraceType<MemStatAccumulator::ShadowMemFacet>& stat);
F64Bytes getMin(const TraceType<MemStatAccumulator>& stat); F64Bytes getMin(const TraceType<MemStatAccumulator>& stat);
F64Bytes getMean(const TraceType<MemStatAccumulator>& stat); F64Bytes getMean(const TraceType<MemStatAccumulator>& stat);
F64Bytes getMax(const TraceType<MemStatAccumulator>& stat); F64Bytes getMax(const TraceType<MemStatAccumulator>& stat);
...@@ -392,6 +395,9 @@ namespace LLTrace ...@@ -392,6 +395,9 @@ namespace LLTrace
return T(getPeriodMin(static_cast<const TraceType<EventAccumulator>&>(stat), num_periods)); return T(getPeriodMin(static_cast<const TraceType<EventAccumulator>&>(stat), num_periods));
} }
F64Bytes getPeriodMin(const TraceType<MemStatAccumulator>& stat, size_t num_periods = U32_MAX);
F64Bytes getPeriodMin(const MemStatHandle& stat, size_t num_periods = U32_MAX);
template <typename T> template <typename T>
typename RelatedTypes<typename T::value_t>::fractional_t getPeriodMinPerSec(const TraceType<T>& stat, size_t num_periods = U32_MAX) typename RelatedTypes<typename T::value_t>::fractional_t getPeriodMinPerSec(const TraceType<T>& stat, size_t num_periods = U32_MAX)
{ {
...@@ -453,6 +459,9 @@ namespace LLTrace ...@@ -453,6 +459,9 @@ namespace LLTrace
return T(getPeriodMax(static_cast<const TraceType<EventAccumulator>&>(stat), num_periods)); return T(getPeriodMax(static_cast<const TraceType<EventAccumulator>&>(stat), num_periods));
} }
F64Bytes getPeriodMax(const TraceType<MemStatAccumulator>& stat, size_t num_periods = U32_MAX);
F64Bytes getPeriodMax(const MemStatHandle& stat, size_t num_periods = U32_MAX);
template <typename T> template <typename T>
typename RelatedTypes<typename T::value_t>::fractional_t getPeriodMaxPerSec(const TraceType<T>& stat, size_t num_periods = U32_MAX) typename RelatedTypes<typename T::value_t>::fractional_t getPeriodMaxPerSec(const TraceType<T>& stat, size_t num_periods = U32_MAX)
{ {
...@@ -519,6 +528,9 @@ namespace LLTrace ...@@ -519,6 +528,9 @@ namespace LLTrace
return typename RelatedTypes<T>::fractional_t(getPeriodMean(static_cast<const TraceType<EventAccumulator>&>(stat), num_periods)); return typename RelatedTypes<T>::fractional_t(getPeriodMean(static_cast<const TraceType<EventAccumulator>&>(stat), num_periods));
} }
F64Bytes getPeriodMean(const TraceType<MemStatAccumulator>& stat, size_t num_periods = U32_MAX);
F64Bytes getPeriodMean(const MemStatHandle& stat, size_t num_periods = U32_MAX);
template <typename T> template <typename T>
typename RelatedTypes<typename T::value_t>::fractional_t getPeriodMeanPerSec(const TraceType<T>& stat, size_t num_periods = U32_MAX) typename RelatedTypes<typename T::value_t>::fractional_t getPeriodMeanPerSec(const TraceType<T>& stat, size_t num_periods = U32_MAX)
{ {
...@@ -566,6 +578,9 @@ namespace LLTrace ...@@ -566,6 +578,9 @@ namespace LLTrace
return typename RelatedTypes<T>::fractional_t(getPeriodStandardDeviation(static_cast<const TraceType<EventAccumulator>&>(stat), num_periods)); return typename RelatedTypes<T>::fractional_t(getPeriodStandardDeviation(static_cast<const TraceType<EventAccumulator>&>(stat), num_periods));
} }
F64Bytes getPeriodStandardDeviation(const TraceType<MemStatAccumulator>& stat, size_t num_periods = U32_MAX);
F64Bytes getPeriodStandardDeviation(const MemStatHandle& stat, size_t num_periods = U32_MAX);
private: private:
// implementation for LLStopWatchControlsMixin // implementation for LLStopWatchControlsMixin
/*virtual*/ void handleStart(); /*virtual*/ void handleStart();
......
...@@ -159,7 +159,7 @@ void LLImageBase::sanityCheck() ...@@ -159,7 +159,7 @@ void LLImageBase::sanityCheck()
void LLImageBase::deleteData() void LLImageBase::deleteData()
{ {
FREE_MEM(sPrivatePoolp, mData) ; FREE_MEM(sPrivatePoolp, mData) ;
memDisclaimAmount(mDataSize) = 0; memDisclaim(mDataSize) = 0;
mData = NULL; mData = NULL;
} }
...@@ -202,7 +202,7 @@ U8* LLImageBase::allocateData(S32 size) ...@@ -202,7 +202,7 @@ U8* LLImageBase::allocateData(S32 size)
mBadBufferAllocation = true ; mBadBufferAllocation = true ;
} }
mDataSize = size; mDataSize = size;
memClaimAmount(mDataSize); memClaim(mDataSize);
} }
return mData; return mData;
...@@ -224,7 +224,7 @@ U8* LLImageBase::reallocateData(S32 size) ...@@ -224,7 +224,7 @@ U8* LLImageBase::reallocateData(S32 size)
FREE_MEM(sPrivatePoolp, mData) ; FREE_MEM(sPrivatePoolp, mData) ;
} }
mData = new_datap; mData = new_datap;
memClaimAmount(memDisclaimAmount(mDataSize) = size); memClaim(memDisclaim(mDataSize) = size);
return mData; return mData;
} }
...@@ -1619,7 +1619,7 @@ void LLImageBase::setDataAndSize(U8 *data, S32 size) ...@@ -1619,7 +1619,7 @@ void LLImageBase::setDataAndSize(U8 *data, S32 size)
{ {
ll_assert_aligned(data, 16); ll_assert_aligned(data, 16);
mData = data; mData = data;
memClaimAmount(memDisclaimAmount(mDataSize) = size); memClaim(memDisclaim(mDataSize) = size);
} }
//static //static
......
...@@ -190,8 +190,10 @@ LLStatBar::LLStatBar(const Params& p) ...@@ -190,8 +190,10 @@ LLStatBar::LLStatBar(const Params& p)
mAutoScaleMax(!p.bar_max.isProvided()), mAutoScaleMax(!p.bar_max.isProvided()),
mAutoScaleMin(!p.bar_min.isProvided()), mAutoScaleMin(!p.bar_min.isProvided()),
mTickValue(p.tick_spacing), mTickValue(p.tick_spacing),
mLastDisplayValue(0.f) mLastDisplayValue(0.f),
mStatType(STAT_NONE)
{ {
mStat.valid = NULL;
// tick value will be automatically calculated later // tick value will be automatically calculated later
if (!p.tick_spacing.isProvided() && p.bar_min.isProvided() && p.bar_max.isProvided()) if (!p.tick_spacing.isProvided() && p.bar_min.isProvided() && p.bar_max.isProvided())
{ {
...@@ -203,17 +205,22 @@ LLStatBar::LLStatBar(const Params& p) ...@@ -203,17 +205,22 @@ LLStatBar::LLStatBar(const Params& p)
BOOL LLStatBar::handleHover(S32 x, S32 y, MASK mask) BOOL LLStatBar::handleHover(S32 x, S32 y, MASK mask)
{ {
if (mCountFloatp) switch(mStatType)
{ {
LLToolTipMgr::instance().show(LLToolTip::Params().message(mCountFloatp->getDescription()).sticky_rect(calcScreenRect())); case STAT_COUNT:
} LLToolTipMgr::instance().show(LLToolTip::Params().message(mStat.countStatp->getDescription()).sticky_rect(calcScreenRect()));
else if ( mEventFloatp) break;
{ case STAT_EVENT:
LLToolTipMgr::instance().show(LLToolTip::Params().message(mEventFloatp->getDescription()).sticky_rect(calcScreenRect())); LLToolTipMgr::instance().show(LLToolTip::Params().message(mStat.eventStatp->getDescription()).sticky_rect(calcScreenRect()));
} break;
else if (mSampleFloatp) case STAT_SAMPLE:
{ LLToolTipMgr::instance().show(LLToolTip::Params().message(mStat.sampleStatp->getDescription()).sticky_rect(calcScreenRect()));
LLToolTipMgr::instance().show(LLToolTip::Params().message(mSampleFloatp->getDescription()).sticky_rect(calcScreenRect())); break;
case STAT_MEM:
LLToolTipMgr::instance().show(LLToolTip::Params().message(mStat.memStatp->getDescription()).sticky_rect(calcScreenRect()));
break;
default:
break;
} }
return TRUE; return TRUE;
} }
...@@ -321,9 +328,11 @@ void LLStatBar::draw() ...@@ -321,9 +328,11 @@ void LLStatBar::draw()
: mNumShortHistoryFrames; : mNumShortHistoryFrames;
S32 num_rapid_changes = 0; S32 num_rapid_changes = 0;
if (mCountFloatp) switch(mStatType)
{ {
const LLTrace::TraceType<LLTrace::CountAccumulator>& count_stat = *mCountFloatp; case STAT_COUNT:
{
const LLTrace::TraceType<LLTrace::CountAccumulator>& count_stat = *mStat.countStatp;
unit_label = std::string(count_stat.getUnitLabel()) + "/s"; unit_label = std::string(count_stat.getUnitLabel()) + "/s";
current = last_frame_recording.getPerSec(count_stat); current = last_frame_recording.getPerSec(count_stat);
...@@ -332,21 +341,22 @@ void LLStatBar::draw() ...@@ -332,21 +341,22 @@ void LLStatBar::draw()
mean = frame_recording.getPeriodMeanPerSec(count_stat, num_frames); mean = frame_recording.getPeriodMeanPerSec(count_stat, num_frames);
display_value = mean; display_value = mean;
} }
else if (mEventFloatp) break;
case STAT_EVENT:
{ {
const LLTrace::TraceType<LLTrace::EventAccumulator>& event_stat = *mEventFloatp; const LLTrace::TraceType<LLTrace::EventAccumulator>& event_stat = *mStat.eventStatp;
unit_label = mUnitLabel.empty() ? event_stat.getUnitLabel() : mUnitLabel; unit_label = mUnitLabel.empty() ? event_stat.getUnitLabel() : mUnitLabel;
current = last_frame_recording.getLastValue(event_stat); current = last_frame_recording.getLastValue(event_stat);
min = frame_recording.getPeriodMin(event_stat, num_frames); min = frame_recording.getPeriodMin(event_stat, num_frames);
max = frame_recording.getPeriodMax(event_stat, num_frames); max = frame_recording.getPeriodMax(event_stat, num_frames);
mean = frame_recording.getPeriodMean(event_stat, num_frames); mean = frame_recording.getPeriodMean(event_stat, num_frames);
num_rapid_changes = calc_num_rapid_changes(frame_recording, event_stat, RAPID_CHANGE_WINDOW);
display_value = mean; display_value = mean;
} }
else if (mSampleFloatp) break;
case STAT_SAMPLE:
{ {
const LLTrace::TraceType<LLTrace::SampleAccumulator>& sample_stat = *mSampleFloatp; const LLTrace::TraceType<LLTrace::SampleAccumulator>& sample_stat = *mStat.sampleStatp;
unit_label = mUnitLabel.empty() ? sample_stat.getUnitLabel() : mUnitLabel; unit_label = mUnitLabel.empty() ? sample_stat.getUnitLabel() : mUnitLabel;
current = last_frame_recording.getLastValue(sample_stat); current = last_frame_recording.getLastValue(sample_stat);
...@@ -366,6 +376,22 @@ void LLStatBar::draw() ...@@ -366,6 +376,22 @@ void LLStatBar::draw()
mLastDisplayValue = current; mLastDisplayValue = current;
} }
} }
break;
case STAT_MEM:
{
const LLTrace::TraceType<LLTrace::MemStatAccumulator>& mem_stat = *mStat.memStatp;
unit_label = mUnitLabel.empty() ? mem_stat.getUnitLabel() : mUnitLabel;
current = last_frame_recording.getLastValue(mem_stat).value();
min = frame_recording.getPeriodMin(mem_stat, num_frames).value();
max = frame_recording.getPeriodMax(mem_stat, num_frames).value();
mean = frame_recording.getPeriodMean(mem_stat, num_frames).value();
display_value = current;
}
break;
default:
break;
}
LLRect bar_rect; LLRect bar_rect;
if (mOrientation == HORIZONTAL) if (mOrientation == HORIZONTAL)
...@@ -405,8 +431,7 @@ void LLStatBar::draw() ...@@ -405,8 +431,7 @@ void LLStatBar::draw()
mLastDisplayValue = display_value; mLastDisplayValue = display_value;
if (mDisplayBar if (mDisplayBar && mStat.valid)
&& (mCountFloatp || mEventFloatp || mSampleFloatp))
{ {
// Draw the tick marks. // Draw the tick marks.
LLGLSUIDefault gls_ui; LLGLSUIDefault gls_ui;
...@@ -454,7 +479,7 @@ void LLStatBar::draw() ...@@ -454,7 +479,7 @@ void LLStatBar::draw()
? (bar_rect.getWidth()) ? (bar_rect.getWidth())
: (bar_rect.getHeight()); : (bar_rect.getHeight());
if (mDisplayHistory && (mCountFloatp || mEventFloatp || mSampleFloatp)) if (mDisplayHistory && mStat.valid)
{ {
const S32 num_values = frame_recording.getNumRecordedPeriods() - 1; const S32 num_values = frame_recording.getNumRecordedPeriods() - 1;
F32 value = 0; F32 value = 0;
...@@ -468,20 +493,26 @@ void LLStatBar::draw() ...@@ -468,20 +493,26 @@ void LLStatBar::draw()
F32 offset = ((F32)i / (F32)num_frames) * span; F32 offset = ((F32)i / (F32)num_frames) * span;
LLTrace::Recording& recording = frame_recording.getPrevRecording(i); LLTrace::Recording& recording = frame_recording.getPrevRecording(i);
if (mCountFloatp) switch(mStatType)
{ {
value = recording.getPerSec(*mCountFloatp); case STAT_COUNT:
num_samples = recording.getSampleCount(*mCountFloatp); value = recording.getPerSec(*mStat.countStatp);
} num_samples = recording.getSampleCount(*mStat.countStatp);
else if (mEventFloatp) break;
{ case STAT_EVENT:
value = recording.getMean(*mEventFloatp); value = recording.getMean(*mStat.eventStatp);
num_samples = recording.getSampleCount(*mEventFloatp); num_samples = recording.getSampleCount(*mStat.eventStatp);
} break;
else if (mSampleFloatp) case STAT_SAMPLE:
{ value = recording.getMean(*mStat.sampleStatp);
value = recording.getMean(*mSampleFloatp); num_samples = recording.getSampleCount(*mStat.sampleStatp);
num_samples = recording.getSampleCount(*mSampleFloatp); break;
case STAT_MEM:
value = recording.getMean(*mStat.memStatp).value();
num_samples = 1;
break;
default:
break;
} }
if (!num_samples) continue; if (!num_samples) continue;
...@@ -540,9 +571,32 @@ void LLStatBar::draw() ...@@ -540,9 +571,32 @@ void LLStatBar::draw()
void LLStatBar::setStat(const std::string& stat_name) void LLStatBar::setStat(const std::string& stat_name)
{ {
mCountFloatp = LLTrace::TraceType<LLTrace::CountAccumulator>::getInstance(stat_name); using namespace LLTrace;
mEventFloatp = LLTrace::TraceType<LLTrace::EventAccumulator>::getInstance(stat_name); const TraceType<CountAccumulator>* count_stat;
mSampleFloatp = LLTrace::TraceType<LLTrace::SampleAccumulator>::getInstance(stat_name); const TraceType<EventAccumulator>* event_stat;
const TraceType<SampleAccumulator>* sample_stat;
const TraceType<MemStatAccumulator>* mem_stat;
if ((count_stat = TraceType<CountAccumulator>::getInstance(stat_name)))
{
mStat.countStatp = count_stat;
mStatType = STAT_COUNT;
}
else if ((event_stat = TraceType<EventAccumulator>::getInstance(stat_name)))
{
mStat.eventStatp = event_stat;
mStatType = STAT_EVENT;
}
else if ((sample_stat = TraceType<SampleAccumulator>::getInstance(stat_name)))
{
mStat.sampleStatp = sample_stat;
mStatType = STAT_SAMPLE;
}
else if ((mem_stat = TraceType<MemStatAccumulator>::getInstance(stat_name)))
{
mStat.memStatp = mem_stat;
mStatType = STAT_MEM;
}
} }
...@@ -688,6 +742,3 @@ void LLStatBar::drawTicks( F32 min, F32 max, F32 value_scale, LLRect &bar_rect ) ...@@ -688,6 +742,3 @@ void LLStatBar::drawTicks( F32 min, F32 max, F32 value_scale, LLRect &bar_rect )
} }
} }
} }
...@@ -93,9 +93,23 @@ class LLStatBar : public LLView ...@@ -93,9 +93,23 @@ class LLStatBar : public LLView
F32 mLastDisplayValue; F32 mLastDisplayValue;
LLFrameTimer mLastDisplayValueTimer; LLFrameTimer mLastDisplayValueTimer;
const LLTrace::TraceType<LLTrace::CountAccumulator>* mCountFloatp; enum
const LLTrace::TraceType<LLTrace::EventAccumulator>* mEventFloatp; {
const LLTrace::TraceType<LLTrace::SampleAccumulator>* mSampleFloatp; STAT_NONE,
STAT_COUNT,
STAT_EVENT,
STAT_SAMPLE,
STAT_MEM
} mStatType;
union
{
void* valid;
const LLTrace::TraceType<LLTrace::CountAccumulator>* countStatp;
const LLTrace::TraceType<LLTrace::EventAccumulator>* eventStatp;
const LLTrace::TraceType<LLTrace::SampleAccumulator>* sampleStatp;
const LLTrace::TraceType<LLTrace::MemStatAccumulator>* memStatp;
} mStat;
LLUIString mLabel; LLUIString mLabel;
std::string mUnitLabel; std::string mUnitLabel;
......
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment