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

added memory usage and occlusion events to traces 

renamed "current" to "primary" when referring to accumulators
master
Richard Linden 2013-09-07 21:16:39 -07:00
parent 736efc7b57
commit 3fd68662f2
12 changed files with 95 additions and 57 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
indra/llcommon/llfasttimer.cpp
View File

@ -189,7 +189,7 @@ void TimeBlock::bootstrapTimerTree()
// when this timer was called
if (timer.getParent() == &TimeBlock::getRootTimeBlock())
{
TimeBlockAccumulator& accumulator = timer.getPrimaryAccumulator();
TimeBlockAccumulator& accumulator = timer.getCurrentAccumulator();
if (accumulator.mLastCaller)
{
@ -223,7 +223,7 @@ void TimeBlock::incrementalUpdateTimerTree()
// skip root timer
if (timerp != &TimeBlock::getRootTimeBlock())
{
TimeBlockAccumulator& accumulator = timerp->getPrimaryAccumulator();
TimeBlockAccumulator& accumulator = timerp->getCurrentAccumulator();
if (accumulator.mMoveUpTree)
{
@ -253,7 +253,7 @@ void TimeBlock::updateTimes()
U64 cur_time = getCPUClockCount64();
BlockTimer* cur_timer = stack_record->mActiveTimer;
TimeBlockAccumulator* accumulator = &stack_record->mTimeBlock->getPrimaryAccumulator();
TimeBlockAccumulator* accumulator = &stack_record->mTimeBlock->getCurrentAccumulator();
while(cur_timer
&& cur_timer->mParentTimerData.mActiveTimer != cur_timer) // root defined by parent pointing to self
@ -269,7 +269,7 @@ void TimeBlock::updateTimes()
cur_timer->mBlockStartTotalTimeCounter = accumulator->mTotalTimeCounter;
stack_record = &cur_timer->mParentTimerData;
accumulator = &stack_record->mTimeBlock->getPrimaryAccumulator();
accumulator = &stack_record->mTimeBlock->getCurrentAccumulator();
cur_timer = stack_record->mActiveTimer;
stack_record->mChildTime += cumulative_time_delta;
@ -299,7 +299,7 @@ void TimeBlock::processTimes()
++it)
{
TimeBlock& timer = *it;
TimeBlockAccumulator& accumulator = timer.getPrimaryAccumulator();
TimeBlockAccumulator& accumulator = timer.getCurrentAccumulator();
accumulator.mLastCaller = NULL;
accumulator.mMoveUpTree = false;

6
indra/llcommon/llfasttimer.h
View File

@ -257,11 +257,11 @@ LL_FORCE_INLINE BlockTimer::BlockTimer(TimeBlock& timer)
#if FAST_TIMER_ON
BlockTimerStackRecord* cur_timer_data = LLThreadLocalSingletonPointer<BlockTimerStackRecord>::getInstance();
if (!cur_timer_data) return;
TimeBlockAccumulator& accumulator = timer.getPrimaryAccumulator();
TimeBlockAccumulator& accumulator = timer.getCurrentAccumulator();
accumulator.mActiveCount++;
mBlockStartTotalTimeCounter = accumulator.mTotalTimeCounter;
// keep current parent as long as it is active when we are
accumulator.mMoveUpTree |= (accumulator.mParent->getPrimaryAccumulator().mActiveCount == 0);
accumulator.mMoveUpTree |= (accumulator.mParent->getCurrentAccumulator().mActiveCount == 0);
// store top of stack
mParentTimerData = *cur_timer_data;
@ -281,7 +281,7 @@ LL_FORCE_INLINE BlockTimer::~BlockTimer()
BlockTimerStackRecord* cur_timer_data = LLThreadLocalSingletonPointer<BlockTimerStackRecord>::getInstance();
if (!cur_timer_data) return;
TimeBlockAccumulator& accumulator = cur_timer_data->mTimeBlock->getPrimaryAccumulator();
TimeBlockAccumulator& accumulator = cur_timer_data->mTimeBlock->getCurrentAccumulator();
accumulator.mCalls++;
accumulator.mTotalTimeCounter += total_time - (accumulator.mTotalTimeCounter - mBlockStartTotalTimeCounter);

5
indra/llcommon/llmemory.cpp
View File

@ -43,12 +43,15 @@
#include "llsys.h"
#include "llframetimer.h"
#include "lltrace.h"
//----------------------------------------------------------------------------
//static
char* LLMemory::reserveMem = 0;
U32Kilobytes LLMemory::sAvailPhysicalMemInKB(U32_MAX);
U32Kilobytes LLMemory::sMaxPhysicalMemInKB(0);
static LLTrace::SampleStatHandle<F64Megabytes> sAllocatedMem("allocated_mem", "active memory in use by application");
static LLTrace::SampleStatHandle<F64Megabytes> sVirtualMem("virtual_mem", "virtual memory assigned to application");
U32Kilobytes LLMemory::sAllocatedMemInKB(0);
U32Kilobytes LLMemory::sAllocatedPageSizeInKB(0);
U32Kilobytes LLMemory::sMaxHeapSizeInKB(U32_MAX);
@ -114,7 +117,9 @@ void LLMemory::updateMemoryInfo()
}
sAllocatedMemInKB = (U32Bytes)(counters.WorkingSetSize) ;
sample(sAllocatedMem, sAllocatedMemInKB);
sAllocatedPageSizeInKB = (U32Bytes)(counters.PagefileUsage) ;
sample(sVirtualMem, sAllocatedPageSizeInKB);
U32Kilobytes avail_phys, avail_virtual;
LLMemoryInfo::getAvailableMemoryKB(avail_phys, avail_virtual) ;

2
indra/llcommon/lltrace.cpp
View File

@ -76,7 +76,7 @@ void TimeBlockTreeNode::setParent( TimeBlock* parent )
}
mParent = parent;
mBlock->getPrimaryAccumulator().mParent = parent;
mBlock->getCurrentAccumulator().mParent = parent;
parent_tree_node->mChildren.push_back(mBlock);
parent_tree_node->mNeedsSorting = true;
}

45
indra/llcommon/lltrace.h
View File

@ -80,9 +80,9 @@ public:
mAccumulatorIndex(AccumulatorBuffer<ACCUMULATOR>::getDefaultBuffer()->reserveSlot())
{}
LL_FORCE_INLINE ACCUMULATOR& getPrimaryAccumulator() const
LL_FORCE_INLINE ACCUMULATOR& getCurrentAccumulator() const
{
ACCUMULATOR* accumulator_storage = AccumulatorBuffer<ACCUMULATOR>::getPrimaryStorage();
ACCUMULATOR* accumulator_storage = AccumulatorBuffer<ACCUMULATOR>::getCurrentStorage();
return accumulator_storage[mAccumulatorIndex];
}
@ -137,7 +137,7 @@ template<typename T, typename VALUE_T>
void record(EventStatHandle<T>& measurement, VALUE_T value)
{
T converted_value(value);
measurement.getPrimaryAccumulator().record(storage_value(converted_value));
measurement.getCurrentAccumulator().record(storage_value(converted_value));
}
template <typename T = F64>
@ -160,7 +160,22 @@ template<typename T, typename VALUE_T>
void sample(SampleStatHandle<T>& measurement, VALUE_T value)
{
T converted_value(value);
measurement.getPrimaryAccumulator().sample(storage_value(converted_value));
measurement.getCurrentAccumulator().sample(storage_value(converted_value));
}
template<typename T, typename VALUE_T>
void add(SampleStatHandle<T>& measurement, VALUE_T value)
{
T converted_value(value);
SampleAccumulator& acc = measurement.getCurrentAccumulator();
if (acc.hasValue())
{
acc.sample(acc.getLastValue() + converted_value);
}
else
{
acc.sample(converted_value);
}
}
template <typename T = F64>
@ -183,7 +198,7 @@ template<typename T, typename VALUE_T>
void add(CountStatHandle<T>& count, VALUE_T value)
{
T converted_value(value);
count.getPrimaryAccumulator().add(storage_value(converted_value));
count.getCurrentAccumulator().add(storage_value(converted_value));
}
template<>
@ -340,7 +355,7 @@ public:
void* operator new(size_t size)
{
MemStatAccumulator& accumulator = DERIVED::sMemStat.getPrimaryAccumulator();
MemStatAccumulator& accumulator = DERIVED::sMemStat.getCurrentAccumulator();
accumulator.mSize.sample(accumulator.mSize.hasValue() ? accumulator.mSize.getLastValue() + (F64)size : (F64)size);
accumulator.mAllocatedCount++;
@ -349,7 +364,7 @@ public:
void operator delete(void* ptr, size_t size)
{
MemStatAccumulator& accumulator = DERIVED::sMemStat.getPrimaryAccumulator();
MemStatAccumulator& accumulator = DERIVED::sMemStat.getCurrentAccumulator();
accumulator.mSize.sample(accumulator.mSize.hasValue() ? accumulator.mSize.getLastValue() - (F64)size : -(F64)size);
accumulator.mAllocatedCount--;
accumulator.mDeallocatedCount++;
@ -358,7 +373,7 @@ public:
void *operator new [](size_t size)
{
MemStatAccumulator& accumulator = DERIVED::sMemStat.getPrimaryAccumulator();
MemStatAccumulator& accumulator = DERIVED::sMemStat.getCurrentAccumulator();
accumulator.mSize.sample(accumulator.mSize.hasValue() ? accumulator.mSize.getLastValue() + (F64)size : (F64)size);
accumulator.mAllocatedCount++;
@ -367,7 +382,7 @@ public:
void operator delete[](void* ptr, size_t size)
{
MemStatAccumulator& accumulator = DERIVED::sMemStat.getPrimaryAccumulator();
MemStatAccumulator& accumulator = DERIVED::sMemStat.getCurrentAccumulator();
accumulator.mSize.sample(accumulator.mSize.hasValue() ? accumulator.mSize.getLastValue() - (F64)size : -(F64)size);
accumulator.mAllocatedCount--;
accumulator.mDeallocatedCount++;
@ -393,7 +408,7 @@ public:
template<typename AMOUNT_T>
AMOUNT_T& memClaimAmount(AMOUNT_T& size)
{
MemStatAccumulator& accumulator = DERIVED::sMemStat.getPrimaryAccumulator();
MemStatAccumulator& accumulator = DERIVED::sMemStat.getCurrentAccumulator();
mMemFootprint += (size_t)size;
accumulator.mSize.sample(accumulator.mSize.hasValue() ? accumulator.mSize.getLastValue() + (F64)size : (F64)size);
return size;
@ -417,7 +432,7 @@ public:
template<typename AMOUNT_T>
AMOUNT_T& memDisclaimAmount(AMOUNT_T& size)
{
MemStatAccumulator& accumulator = DERIVED::sMemStat.getPrimaryAccumulator();
MemStatAccumulator& accumulator = DERIVED::sMemStat.getCurrentAccumulator();
accumulator.mSize.sample(accumulator.mSize.hasValue() ? accumulator.mSize.getLastValue() - (F64)size : -(F64)size);
return size;
}
@ -430,7 +445,7 @@ private:
{
static void claim(mem_trackable_t& tracker, const TRACKED& tracked)
{
MemStatAccumulator& accumulator = DERIVED::sMemStat.getPrimaryAccumulator();
MemStatAccumulator& accumulator = DERIVED::sMemStat.getCurrentAccumulator();
size_t footprint = MemFootprint<TRACKED>::measure(tracked);
accumulator.mSize.sample(accumulator.mSize.hasValue() ? accumulator.mSize.getLastValue() + (F64)footprint : (F64)footprint);
tracker.mMemFootprint += footprint;
@ -438,7 +453,7 @@ private:
static void disclaim(mem_trackable_t& tracker, const TRACKED& tracked)
{
MemStatAccumulator& accumulator = DERIVED::sMemStat.getPrimaryAccumulator();
MemStatAccumulator& accumulator = DERIVED::sMemStat.getCurrentAccumulator();
size_t footprint = MemFootprint<TRACKED>::measure(tracked);
accumulator.mSize.sample(accumulator.mSize.hasValue() ? accumulator.mSize.getLastValue() - (F64)footprint : -(F64)footprint);
tracker.mMemFootprint -= footprint;
@ -450,13 +465,13 @@ private:
{
static void claim(mem_trackable_t& tracker, TRACKED& tracked)
{
MemStatAccumulator& accumulator = DERIVED::sMemStat.getPrimaryAccumulator();
MemStatAccumulator& accumulator = DERIVED::sMemStat.getCurrentAccumulator();
accumulator.mChildSize.sample(accumulator.mChildSize.hasValue() ? accumulator.mChildSize.getLastValue() + (F64)MemFootprint<TRACKED>::measure(tracked) : (F64)MemFootprint<TRACKED>::measure(tracked));
}
static void disclaim(mem_trackable_t& tracker, TRACKED& tracked)
{
MemStatAccumulator& accumulator = DERIVED::sMemStat.getPrimaryAccumulator();
MemStatAccumulator& accumulator = DERIVED::sMemStat.getCurrentAccumulator();
accumulator.mChildSize.sample(accumulator.mChildSize.hasValue() ? accumulator.mChildSize.getLastValue() - (F64)MemFootprint<TRACKED>::measure(tracked) : -(F64)MemFootprint<TRACKED>::measure(tracked));
}
};

30
indra/llcommon/lltraceaccumulators.cpp
View File

@ -48,13 +48,13 @@ void AccumulatorBufferGroup::handOffTo(AccumulatorBufferGroup& other)
other.mMemStats.reset(&mMemStats);
}
void AccumulatorBufferGroup::makePrimary()
void AccumulatorBufferGroup::makeCurrent()
{
mCounts.makePrimary();
mSamples.makePrimary();
mEvents.makePrimary();
mStackTimers.makePrimary();
mMemStats.makePrimary();
mCounts.makeCurrent();
mSamples.makeCurrent();
mEvents.makeCurrent();
mStackTimers.makeCurrent();
mMemStats.makeCurrent();
ThreadRecorder* thread_recorder = get_thread_recorder().get();
AccumulatorBuffer<TimeBlockAccumulator>& timer_accumulator_buffer = mStackTimers;
@ -70,18 +70,18 @@ void AccumulatorBufferGroup::makePrimary()
}
//static
void AccumulatorBufferGroup::clearPrimary()
void AccumulatorBufferGroup::resetCurrent()
{
AccumulatorBuffer<CountAccumulator>::clearPrimary();
AccumulatorBuffer<SampleAccumulator>::clearPrimary();
AccumulatorBuffer<EventAccumulator>::clearPrimary();
AccumulatorBuffer<TimeBlockAccumulator>::clearPrimary();
AccumulatorBuffer<MemStatAccumulator>::clearPrimary();
AccumulatorBuffer<CountAccumulator>::resetCurrent();
AccumulatorBuffer<SampleAccumulator>::resetCurrent();
AccumulatorBuffer<EventAccumulator>::resetCurrent();
AccumulatorBuffer<TimeBlockAccumulator>::resetCurrent();
AccumulatorBuffer<MemStatAccumulator>::resetCurrent();
}
bool AccumulatorBufferGroup::isPrimary() const
bool AccumulatorBufferGroup::isCurrent() const
{
return mCounts.isPrimary();
return mCounts.isCurrent();
}
void AccumulatorBufferGroup::append( const AccumulatorBufferGroup& other )
@ -114,7 +114,7 @@ void AccumulatorBufferGroup::reset(AccumulatorBufferGroup* other)
void AccumulatorBufferGroup::sync()
{
if (isPrimary())
if (isCurrent())
{
F64SecondsImplicit time_stamp = LLTimer::getTotalSeconds();

16
indra/llcommon/lltraceaccumulators.h
View File

@ -75,7 +75,7 @@ namespace LLTrace
~AccumulatorBuffer()
{
if (isPrimary())
if (isCurrent())
{
LLThreadLocalSingletonPointer<ACCUMULATOR>::setInstance(NULL);
}
@ -128,22 +128,22 @@ namespace LLTrace
}
}
void makePrimary()
void makeCurrent()
{
LLThreadLocalSingletonPointer<ACCUMULATOR>::setInstance(mStorage);
}
bool isPrimary() const
bool isCurrent() const
{
return LLThreadLocalSingletonPointer<ACCUMULATOR>::getInstance() == mStorage;
}
static void clearPrimary()
static void resetCurrent()
{
LLThreadLocalSingletonPointer<ACCUMULATOR>::setInstance(NULL);
}
LL_FORCE_INLINE static ACCUMULATOR* getPrimaryStorage()
LL_FORCE_INLINE static ACCUMULATOR* getCurrentStorage()
{
ACCUMULATOR* accumulator = LLThreadLocalSingletonPointer<ACCUMULATOR>::getInstance();
return accumulator ? accumulator : getDefaultBuffer()->mStorage;
@ -534,9 +534,9 @@ namespace LLTrace
AccumulatorBufferGroup();
void handOffTo(AccumulatorBufferGroup& other);
void makePrimary();
bool isPrimary() const;
static void clearPrimary();
void makeCurrent();
bool isCurrent() const;
static void resetCurrent();
void append(const AccumulatorBufferGroup& other);
void merge(const AccumulatorBufferGroup& other);

14
indra/llcommon/lltracethreadrecorder.cpp
View File

@ -69,13 +69,13 @@ void ThreadRecorder::init()
tree_node.mBlock = &time_block;
tree_node.mParent = &root_time_block;
it->getPrimaryAccumulator().mParent = &root_time_block;
it->getCurrentAccumulator().mParent = &root_time_block;
}
mRootTimer = new BlockTimer(root_time_block);
timer_stack->mActiveTimer = mRootTimer;
TimeBlock::getRootTimeBlock().getPrimaryAccumulator().mActiveCount = 1;
TimeBlock::getRootTimeBlock().getCurrentAccumulator().mActiveCount = 1;
}
@ -135,7 +135,7 @@ void ThreadRecorder::activate( AccumulatorBufferGroup* recording, bool from_hand
}
mActiveRecordings.push_back(active_recording);
mActiveRecordings.back()->mPartialRecording.makePrimary();
mActiveRecordings.back()->mPartialRecording.makeCurrent();
}
ThreadRecorder::active_recording_list_t::reverse_iterator ThreadRecorder::bringUpToDate( AccumulatorBufferGroup* recording )
@ -186,19 +186,19 @@ void ThreadRecorder::deactivate( AccumulatorBufferGroup* recording )
if (it != mActiveRecordings.rend())
{
active_recording_list_t::iterator recording_to_remove = (++it).base();
bool was_primary = (*recording_to_remove)->mPartialRecording.isPrimary();
bool was_current = (*recording_to_remove)->mPartialRecording.isCurrent();
llassert((*recording_to_remove)->mTargetRecording == recording);
delete *recording_to_remove;
mActiveRecordings.erase(recording_to_remove);
if (was_primary)
if (was_current)
{
if (mActiveRecordings.empty())
{
AccumulatorBufferGroup::clearPrimary();
AccumulatorBufferGroup::resetCurrent();
}
else
{
mActiveRecordings.back()->mPartialRecording.makePrimary();
mActiveRecordings.back()->mPartialRecording.makeCurrent();
}
}
}

1
indra/newview/llagent.h
View File

@ -34,6 +34,7 @@
#include "llcoordframe.h" // for mFrameAgent
#include "llavatarappearancedefines.h"
#include "llpermissionsflags.h"
#include "v3dmath.h"
#include <boost/function.hpp>
#include <boost/shared_ptr.hpp>

4
indra/newview/llappviewer.cpp
View File

@ -1224,8 +1224,8 @@ void LLAppViewer::checkMemory()
}
mMemCheckTimer.reset() ;
//update the availability of memory
LLMemory::updateMemoryInfo() ;
//update the availability of memory
LLMemory::updateMemoryInfo() ;
bool is_low = LLMemory::isMemoryPoolLow() ;

3
indra/newview/llremoteparcelrequest.h
View File

@ -30,7 +30,8 @@
#define LL_LLREMOTEPARCELREQUEST_H
#include "llhttpclient.h"
#include "llpanel.h"
#include "llhandle.h"
#include "llsingleton.h"
class LLMessageSystem;
class LLRemoteParcelInfoObserver;

16
indra/newview/llvieweroctree.cpp
View File

@ -39,6 +39,11 @@
U32 LLViewerOctreeEntryData::sCurVisible = 0;
BOOL LLViewerOctreeDebug::sInDebug = FALSE;
static LLTrace::CountStatHandle<S32> sOcclusionQueries("occlusion_queries", "Number of occlusion queries executed"),
sNumObjectsOccluded("occluded_objects", "Count of objects being occluded by a query"),
sNumObjectsUnoccluded("unoccluded_objects", "Count of objects being unoccluded by a query");
static LLTrace::SampleStatHandle<S32> sOcclusionQueriesInFlight("occlusion_queries_in_flight", "Number of occlusion queries waiting for results");
//-----------------------------------------------------------------------------------
//some global functions definitions
//-----------------------------------------------------------------------------------
@ -921,6 +926,10 @@ void LLOcclusionCullingGroup::setOcclusionState(U32 state, S32 mode)
}
else
{
if (state & OCCLUDED)
{
add(sNumObjectsOccluded, 1);
}
mOcclusionState[LLViewerCamera::sCurCameraID] |= state;
if ((state & DISCARD_QUERY) && mOcclusionQuery[LLViewerCamera::sCurCameraID])
{
@ -979,6 +988,10 @@ void LLOcclusionCullingGroup::clearOcclusionState(U32 state, S32 mode)
}
else
{
if (state & OCCLUDED)
{
add(sNumObjectsUnoccluded, 1);
}
mOcclusionState[LLViewerCamera::sCurCameraID] &= ~state;
}
}
@ -1082,6 +1095,7 @@ void LLOcclusionCullingGroup::checkOcclusion()
#if LL_TRACK_PENDING_OCCLUSION_QUERIES
sPendingQueries.erase(mOcclusionQuery[LLViewerCamera::sCurCameraID]);
#endif
add(sOcclusionQueriesInFlight, -1);
}
else if (mOcclusionQuery[LLViewerCamera::sCurCameraID])
{ //delete the query to avoid holding onto hundreds of pending queries
@ -1187,6 +1201,8 @@ void LLOcclusionCullingGroup::doOcclusion(LLCamera* camera, const LLVector3* reg
#if LL_TRACK_PENDING_OCCLUSION_QUERIES
sPendingQueries.insert(mOcclusionQuery[LLViewerCamera::sCurCameraID]);
#endif
add(sOcclusionQueries, 1);
add(sOcclusionQueriesInFlight, 1);
{
LLFastTimer t(FTM_PUSH_OCCLUSION_VERTS);