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

SH-4299 FIX Interesting: High fps shown temporarily off scale in statistics console 

added ability to force uniqueness of LLCopyOnWritePointer
converted more variables to units
added convenience function for unit constants
meow-7.2.2
Richard Linden 2013-06-28 20:45:20 -07:00
parent 0f178ec33d
commit ffa7123bb5
19 changed files with 215 additions and 206 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
indra/llcharacter/llkeyframewalkmotion.cpp
View File

@ -383,7 +383,7 @@ BOOL LLFlyAdjustMotion::onUpdate(F32 time, U8* joint_mask)
F32 target_roll = llclamp(ang_vel.mV[VZ], -4.f, 4.f) * roll_factor;
// roll is critically damped interpolation between current roll and angular velocity-derived target roll
mRoll = LLSmoothInterpolation::lerp(mRoll, target_roll, LLUnit<F32, LLUnits::Milliseconds>(100));
mRoll = LLSmoothInterpolation::lerp(mRoll, target_roll, LLUnits::Milliseconds::fromValue(100));
LLQuaternion roll(mRoll, LLVector3(0.f, 0.f, 1.f));
mPelvisState->setRotation(roll);

4
indra/llcommon/llfasttimer.cpp
View File

@ -386,7 +386,7 @@ void TimeBlock::dumpCurTimes()
U32 num_calls = last_frame_recording.getSum(timerp->callCount());
// Don't bother with really brief times, keep output concise
if (total_time < LLUnit<F32, LLUnits::Milliseconds>(0.1)) continue;
if (total_time < LLUnits::Milliseconds::fromValue(0.1f)) continue;
std::ostringstream out_str;
TimeBlock* parent_timerp = timerp;
@ -397,7 +397,7 @@ void TimeBlock::dumpCurTimes()
}
out_str << timerp->getName() << " "
<< std::setprecision(3) << total_time.getAs<LLUnits::Milliseconds>() << " ms, "
<< std::setprecision(3) << total_time.valueAs<LLUnits::Milliseconds>() << " ms, "
<< num_calls << " calls";
llinfos << out_str.str() << llendl;

18
indra/llcommon/llpointer.h
View File

@ -173,15 +173,23 @@ public:
typedef LLPointer<Type> pointer_t;
LLCopyOnWritePointer()
: mStayUnique(false)
{}
LLCopyOnWritePointer(Type* ptr)
: LLPointer<Type>(ptr)
: LLPointer<Type>(ptr),
mStayUnique(false)
{}
LLCopyOnWritePointer(LLPointer<Type>& ptr)
: LLPointer<Type>(ptr)
{}
: LLPointer<Type>(ptr),
mStayUnique(false)
{
if (ptr.mForceUnique)
{
makeUnique();
}
}
Type* write()
{
@ -199,6 +207,10 @@ public:
const Type* operator->() const { return pointer_t::mPointer; }
const Type& operator*() const { return *pointer_t::mPointer; }
void setStayUnique(bool stay) { makeUnique(); mStayUnique = stay; }
private:
bool mStayUnique;
};
#endif

5
indra/llcommon/lltracerecording.cpp
View File

@ -100,14 +100,15 @@ void Recording::handleReset()
void Recording::handleStart()
{
mSamplingTimer.reset();
mBuffers.setStayUnique(true);
LLTrace::get_thread_recorder()->activate(mBuffers.write());
}
void Recording::handleStop()
{
mElapsedSeconds += mSamplingTimer.getElapsedTimeF64();
AccumulatorBufferGroup* buffers = mBuffers.write();
LLTrace::get_thread_recorder()->deactivate(buffers);
LLTrace::get_thread_recorder()->deactivate(mBuffers.write());
mBuffers.setStayUnique(false);
}
void Recording::handleSplitTo(Recording& other)

8
indra/llcommon/lltracethreadrecorder.cpp
View File

@ -99,14 +99,6 @@ TimeBlockTreeNode* ThreadRecorder::getTimeBlockTreeNode( S32 index )
void ThreadRecorder::activate( AccumulatorBufferGroup* recording )
{
active_recording_list_t::reverse_iterator it, end_it;
for (it = mActiveRecordings.rbegin(), end_it = mActiveRecordings.rend();
it != end_it;
++it)
{
llassert((*it)->mTargetRecording != recording);
}
ActiveRecording* active_recording = new ActiveRecording(recording);
if (!mActiveRecordings.empty())
{

66
indra/llcommon/llunit.h
View File

@ -75,17 +75,11 @@ struct LLUnit
}
template<typename NEW_UNIT_TYPE>
STORAGE_TYPE getAs()
STORAGE_TYPE valueAs()
{
return LLUnit<STORAGE_TYPE, NEW_UNIT_TYPE>(*this).value();
}
template<typename NEW_UNIT_TYPE>
STORAGE_TYPE setAs(STORAGE_TYPE val)
{
*this = LLUnit<STORAGE_TYPE, NEW_UNIT_TYPE>(val);
}
void operator += (storage_t value)
{
mValue += value;
@ -181,6 +175,7 @@ LL_FORCE_INLINE void ll_convert_units(LLUnit<S1, T1> in, LLUnit<S2, T2>& out, ..
if (boost::is_same<T1, typename T1::base_unit_t>::value)
{
if (boost::is_same<T2, typename T2::base_unit_t>::value)
{
// T1 and T2 fully reduced and equal...just copy
out = (S2)in.value();
@ -493,26 +488,45 @@ struct LLUnitInverseLinearOps
}
};
#define LL_DECLARE_BASE_UNIT(base_unit_name, unit_label) \
struct base_unit_name { typedef base_unit_name base_unit_t; static const char* getUnitLabel() { return unit_label; }}
#define LL_DECLARE_BASE_UNIT(base_unit_name, unit_label) \
struct base_unit_name \
{ \
typedef base_unit_name base_unit_t; \
static const char* getUnitLabel() { return unit_label; } \
template<typename T> \
static LLUnit<T, base_unit_name> fromValue(T value) { return LLUnit<T, base_unit_name>(value); } \
template<typename STORAGE_T, typename UNIT_T> \
static LLUnit<STORAGE_T, base_unit_name> fromValue(LLUnit<STORAGE_T, UNIT_T> value) \
{ return LLUnit<STORAGE_T, base_unit_name>(value); } \
}; \
template<typename T> std::ostream& operator<<(std::ostream& s, const LLUnit<T, base_unit_name>& val) \
{ s << val.value() << base_unit_name::getUnitLabel; return s; }
#define LL_DECLARE_DERIVED_UNIT(unit_name, unit_label, base_unit_name, conversion_operation) \
struct unit_name \
{ \
typedef base_unit_name base_unit_t; \
static const char* getUnitLabel() { return unit_label; } \
}; \
\
template<typename S1, typename S2> \
void ll_convert_units(LLUnit<S1, unit_name> in, LLUnit<S2, base_unit_name>& out) \
{ \
out = (S2)(LLUnitLinearOps<S1>(in.value()) conversion_operation).mValue; \
} \
\
template<typename S1, typename S2> \
void ll_convert_units(LLUnit<S1, base_unit_name> in, LLUnit<S2, unit_name>& out) \
{ \
out = (S2)(LLUnitInverseLinearOps<S1>(in.value()) conversion_operation).mValue; \
#define LL_DECLARE_DERIVED_UNIT(unit_name, unit_label, base_unit_name, conversion_operation) \
struct unit_name \
{ \
typedef base_unit_name base_unit_t; \
static const char* getUnitLabel() { return unit_label; } \
template<typename T> \
static LLUnit<T, unit_name> fromValue(T value) { return LLUnit<T, unit_name>(value); } \
template<typename STORAGE_T, typename UNIT_T> \
static LLUnit<STORAGE_T, unit_name> fromValue(LLUnit<STORAGE_T, UNIT_T> value) \
{ return LLUnit<STORAGE_T, unit_name>(value); } \
}; \
template<typename T> std::ostream& operator<<(std::ostream& s, const LLUnit<T, unit_name>& val) \
{ s << val.value() << unit_name::getUnitLabel; return s; } \
\
template<typename S1, typename S2> \
void ll_convert_units(LLUnit<S1, unit_name> in, LLUnit<S2, base_unit_name>& out) \
{ \
out = (S2)(LLUnitLinearOps<S1>(in.value()) conversion_operation).mValue; \
} \
\
template<typename S1, typename S2> \
void ll_convert_units(LLUnit<S1, base_unit_name> in, LLUnit<S2, unit_name>& out) \
{ \
out = (S2)(LLUnitInverseLinearOps<S1>(in.value()) conversion_operation).mValue; \
}
//

2
indra/newview/llappviewer.cpp
View File

@ -1294,8 +1294,6 @@ bool LLAppViewer::mainLoop()
{
LLFastTimer _(FTM_FRAME);
LLTrace::TimeBlock::processTimes();
llassert((LLTrace::get_frame_recording().getCurRecording().update(),
LLTrace::get_frame_recording().getCurRecording().getSampleCount(LLStatViewer::FPS) <= 1));
LLTrace::get_frame_recording().nextPeriod();
LLTrace::TimeBlock::logStats();

17
indra/newview/llclassifiedstatsresponder.cpp
View File

@ -38,10 +38,8 @@
#include "message.h"
LLClassifiedStatsResponder::LLClassifiedStatsResponder(LLUUID classified_id)
:
mClassifiedID(classified_id)
{
}
: mClassifiedID(classified_id)
{}
/*virtual*/
void LLClassifiedStatsResponder::result(const LLSD& content)
@ -53,12 +51,11 @@ void LLClassifiedStatsResponder::result(const LLSD& content)
S32 search_map = content["search_map_clicks"].asInteger();
S32 search_profile = content["search_profile_clicks"].asInteger();
LLPanelClassifiedInfo::setClickThrough(
mClassifiedID,
teleport + search_teleport,
map + search_map,
profile + search_profile,
true);
LLPanelClassifiedInfo::setClickThrough( mClassifiedID,
teleport + search_teleport,
map + search_map,
profile + search_profile,
true);
}
/*virtual*/

10
indra/newview/llfasttimerview.cpp
View File

@ -1101,7 +1101,7 @@ void LLFastTimerView::drawLineGraph()
j--)
{
LLTrace::Recording& recording = mRecording.getPrevRecording(j);
LLUnit<F32, LLUnits::Seconds> time = llmax(recording.getSum(*idp), LLUnit<F64, LLUnits::Seconds>(0.000001));
LLUnit<F32, LLUnits::Seconds> time = llmax(recording.getSum(*idp), LLUnits::Seconds::fromValue(0.000001));
U32 calls = recording.getSum(idp->callCount());
if (is_hover_timer)
@ -1126,7 +1126,7 @@ void LLFastTimerView::drawLineGraph()
}
gGL.vertex2f(x,y);
gGL.vertex2f(x,mGraphRect.mBottom);
}
}
gGL.end();
if (mHoverID == idp)
@ -1146,7 +1146,7 @@ void LLFastTimerView::drawLineGraph()
max_time = lerp(max_time.value(), cur_max.value(), LLSmoothInterpolation::getInterpolant(0.1f));
if (llabs((max_time - cur_max).value()) <= 1)
{
max_time = llmax(LLUnit<F32, LLUnits::Microseconds>(1), LLUnit<F32, LLUnits::Microseconds>(cur_max));
max_time = llmax(LLUnits::Microseconds::fromValue(1.f), LLUnits::Microseconds::fromValue(cur_max));
}
max_calls = llround(lerp((F32)max_calls, (F32) cur_max_calls, LLSmoothInterpolation::getInterpolant(0.1f)));
@ -1423,11 +1423,11 @@ void LLFastTimerView::updateTotalTime()
mTotalTimeDisplay = mRecording.getPeriodMax(FTM_FRAME, 20);
break;
default:
mTotalTimeDisplay = LLUnit<F32, LLUnits::Milliseconds>(100);
mTotalTimeDisplay = LLUnits::Milliseconds::fromValue(100);
break;
}
mTotalTimeDisplay = LLUnit<F32, LLUnits::Milliseconds>(llceil(mTotalTimeDisplay.getAs<LLUnits::Milliseconds>() / 20.f) * 20.f);
mTotalTimeDisplay = LLUnits::Milliseconds::fromValue(llceil(mTotalTimeDisplay.valueAs<LLUnits::Milliseconds>() / 20.f) * 20.f);
}
void LLFastTimerView::drawBars()

2
indra/newview/llscenemonitor.cpp
View File

@ -624,7 +624,7 @@ void LLSceneMonitor::dumpToFile(std::string file_name)
for (S32 frame = 1; frame <= frame_count; frame++)
{
os << ", " << scene_load_recording.getPrevRecording(frame_count - frame).getMax(*it).getAs<LLUnits::Kibibytes>();
os << ", " << scene_load_recording.getPrevRecording(frame_count - frame).getMax(*it).valueAs<LLUnits::Kibibytes>();
}
os << '\n';

132
indra/newview/lltexturefetch.cpp
View File

@ -504,81 +504,85 @@ private:
static const char* sStateDescs[];
e_state mState;
void setState(e_state new_state);
e_write_to_cache_state mWriteToCacheState;
LLTextureFetch* mFetcher;
e_write_to_cache_state mWriteToCacheState;
LLTextureFetch* mFetcher;
LLPointer<LLImageFormatted> mFormattedImage;
LLPointer<LLImageRaw> mRawImage;
LLPointer<LLImageRaw> mAuxImage;
FTType mFTType;
LLUUID mID;
LLHost mHost;
std::string mUrl;
U8 mType;
F32 mImagePriority;
U32 mWorkPriority;
F32 mRequestedPriority;
S32 mDesiredDiscard;
S32 mSimRequestedDiscard;
S32 mRequestedDiscard;
S32 mLoadedDiscard;
S32 mDecodedDiscard;
LLFrameTimer mRequestedTimer;
LLFrameTimer mFetchTimer;
LLTimer mCacheReadTimer;
F32 mCacheReadTime;
LLTextureCache::handle_t mCacheReadHandle;
LLTextureCache::handle_t mCacheWriteHandle;
S32 mRequestedSize;
S32 mRequestedOffset;
S32 mDesiredSize;
S32 mFileSize;
S32 mCachedSize;
e_request_state mSentRequest;
handle_t mDecodeHandle;
BOOL mLoaded;
BOOL mDecoded;
BOOL mWritten;
BOOL mNeedsAux;
BOOL mHaveAllData;
BOOL mInLocalCache;
BOOL mInCache;
bool mCanUseHTTP ;
bool mCanUseNET ; //can get from asset server.
S32 mRetryAttempt;
S32 mActiveCount;
LLCore::HttpStatus mGetStatus;
std::string mGetReason;
LLPointer<LLImageRaw> mRawImage,
mAuxImage;
FTType mFTType;
LLUUID mID;
LLHost mHost;
std::string mUrl;
U8 mType;
F32 mImagePriority;
U32 mWorkPriority;
F32 mRequestedPriority;
S32 mDesiredDiscard,
mSimRequestedDiscard,
mRequestedDiscard,
mLoadedDiscard,
mDecodedDiscard;
LLFrameTimer mRequestedTimer,
mFetchTimer;
LLTimer mCacheReadTimer;
F32 mCacheReadTime;
LLTextureCache::handle_t mCacheReadHandle,
mCacheWriteHandle;
S32 mRequestedSize,
mRequestedOffset,
mDesiredSize,
mFileSize,
mCachedSize;
e_request_state mSentRequest;
handle_t mDecodeHandle;
BOOL mLoaded;
BOOL mDecoded;
BOOL mWritten;
BOOL mNeedsAux;
BOOL mHaveAllData;
BOOL mInLocalCache;
BOOL mInCache;
bool mCanUseHTTP,
mCanUseNET ; //can get from asset server.
S32 mRetryAttempt;
S32 mActiveCount;
LLCore::HttpStatus mGetStatus;
std::string mGetReason;
// Work Data
LLMutex mWorkMutex;
LLMutex mWorkMutex;
struct PacketData
{
PacketData(U8* data, S32 size) { mData = data; mSize = size; }
PacketData(U8* data, S32 size)
: mData(data), mSize(size)
{}
~PacketData() { clearData(); }
void clearData() { delete[] mData; mData = NULL; }
U8* mData;
U32 mSize;
U8* mData;
U32 mSize;
};
std::vector<PacketData*> mPackets;
S32 mFirstPacket;
S32 mLastPacket;
U16 mTotalPackets;
U8 mImageCodec;
std::vector<PacketData*> mPackets;
S32 mFirstPacket;
S32 mLastPacket;
U16 mTotalPackets;
U8 mImageCodec;
LLViewerAssetStats::duration_t mMetricsStartTime;
LLCore::HttpHandle mHttpHandle; // Handle of any active request
LLCore::BufferArray * mHttpBufferArray; // Refcounted pointer to response data
int mHttpPolicyClass;
bool mHttpActive; // Active request to http library
unsigned int mHttpReplySize; // Actual received data size
unsigned int mHttpReplyOffset; // Actual received data offset
bool mHttpHasResource; // Counts against Fetcher's mHttpSemaphore
LLCore::HttpHandle mHttpHandle; // Handle of any active request
LLCore::BufferArray * mHttpBufferArray; // Refcounted pointer to response data
S32 mHttpPolicyClass;
bool mHttpActive; // Active request to http library
U32 mHttpReplySize, // Actual received data size
mHttpReplyOffset; // Actual received data offset
bool mHttpHasResource; // Counts against Fetcher's mHttpSemaphore
// State history
U32 mCacheReadCount;
U32 mCacheWriteCount;
U32 mResourceWaitCount; // Requests entering WAIT_HTTP_RESOURCE2
U32 mCacheReadCount,
mCacheWriteCount,
mResourceWaitCount; // Requests entering WAIT_HTTP_RESOURCE2
};
//////////////////////////////////////////////////////////////////////////////
@ -2390,7 +2394,7 @@ LLTextureFetch::LLTextureFetch(LLTextureCache* cache, LLImageDecodeThread* image
mFetcherLocked(FALSE)
{
mMaxBandwidth = gSavedSettings.getF32("ThrottleBandwidthKBPS");
mTextureInfo.setUpLogging(gSavedSettings.getBOOL("LogTextureDownloadsToViewerLog"), gSavedSettings.getBOOL("LogTextureDownloadsToSimulator"), gSavedSettings.getU32("TextureLoggingThreshold"));
mTextureInfo.setUpLogging(gSavedSettings.getBOOL("LogTextureDownloadsToViewerLog"), gSavedSettings.getBOOL("LogTextureDownloadsToSimulator"), LLUnits::Bytes::fromValue(gSavedSettings.getU32("TextureLoggingThreshold")));
LLTextureFetchDebugger::sDebuggerEnabled = gSavedSettings.getBOOL("TextureFetchDebuggerEnabled");
if(LLTextureFetchDebugger::isEnabled())
@ -3369,7 +3373,7 @@ bool LLTextureFetch::receiveImagePacket(const LLHost& host, const LLUUID& id, U1
if (log_to_viewer_log || log_to_sim)
{
U64 timeNow = LLTimer::getTotalTime();
LLUnit<U64, LLUnits::Microseconds> timeNow = LLTimer::getTotalTime();
mTextureInfo.setRequestSize(id, worker->mFileSize);
mTextureInfo.setRequestCompleteTimeAndLog(id, timeNow);
}

80
indra/newview/lltextureinfo.cpp
View File

@ -29,26 +29,28 @@
#include "lltextureinfo.h"
#include "lltexturestats.h"
#include "llviewercontrol.h"
#include "lltrace.h"
static LLTrace::CountStatHandle<S32> sTextureDownloadsStarted("texture_downloads_started", "number of texture downloads initiated");
static LLTrace::CountStatHandle<S32> sTextureDownloadsCompleted("texture_downloads_completed", "number of texture downloads completed");
static LLTrace::CountStatHandle<LLUnit<S32, LLUnits::Bytes> > sTextureDataDownloaded("texture_data_downloaded", "amount of texture data downloaded");
static LLTrace::CountStatHandle<LLUnit<U32, LLUnits::Milliseconds> > sTexureDownloadTime("texture_download_time", "amount of time spent fetching textures");
LLTextureInfo::LLTextureInfo() :
mLogTextureDownloadsToViewerLog(false),
mLogTextureDownloadsToSimulator(false),
mTotalBytes(0),
mTotalMilliseconds(0),
mTextureDownloadsStarted(0),
mTextureDownloadsCompleted(0),
mTextureDownloadProtocol("NONE"),
mTextureLogThreshold(100 * 1024),
mCurrentStatsBundleStartTime(0)
mTextureLogThreshold(LLUnits::Kibibytes::fromValue(100))
{
mTextures.clear();
mRecording.start();
}
void LLTextureInfo::setUpLogging(bool writeToViewerLog, bool sendToSim, U32 textureLogThreshold)
void LLTextureInfo::setUpLogging(bool writeToViewerLog, bool sendToSim, LLUnit<U32, LLUnits::Bytes> textureLogThreshold)
{
mLogTextureDownloadsToViewerLog = writeToViewerLog;
mLogTextureDownloadsToSimulator = sendToSim;
mTextureLogThreshold = textureLogThreshold;
mTextureLogThreshold = LLUnit<U32, LLUnits::Bytes>(textureLogThreshold);
}
LLTextureInfo::~LLTextureInfo()
@ -94,7 +96,7 @@ void LLTextureInfo::setRequestStartTime(const LLUUID& id, U64 startTime)
addRequest(id);
}
mTextures[id]->mStartTime = startTime;
mTextureDownloadsStarted++;
add(sTextureDownloadsStarted, 1);
}
void LLTextureInfo::setRequestSize(const LLUUID& id, U32 size)
@ -124,16 +126,19 @@ void LLTextureInfo::setRequestType(const LLUUID& id, LLTextureInfoDetails::LLReq
mTextures[id]->mType = type;
}
void LLTextureInfo::setRequestCompleteTimeAndLog(const LLUUID& id, U64 completeTime)
void LLTextureInfo::setRequestCompleteTimeAndLog(const LLUUID& id, LLUnit<U64, LLUnits::Microseconds> completeTime)
{
if (!has(id))
{
addRequest(id);
}
mTextures[id]->mCompleteTime = completeTime;
LLTextureInfoDetails& details = *mTextures[id];
details.mCompleteTime = completeTime;
std::string protocol = "NONE";
switch(mTextures[id]->mType)
switch(details.mType)
{
case LLTextureInfoDetails::REQUEST_TYPE_HTTP:
protocol = "HTTP";
@ -150,24 +155,23 @@ void LLTextureInfo::setRequestCompleteTimeAndLog(const LLUUID& id, U64 completeT
if (mLogTextureDownloadsToViewerLog)
{
llinfos << "texture=" << id
<< " start=" << mTextures[id]->mStartTime
<< " end=" << mTextures[id]->mCompleteTime
<< " size=" << mTextures[id]->mSize
<< " offset=" << mTextures[id]->mOffset
<< " length_in_ms=" << (mTextures[id]->mCompleteTime - mTextures[id]->mStartTime) / 1000
<< " protocol=" << protocol
<< llendl;
llinfos << "texture=" << id
<< " start=" << details.mStartTime
<< " end=" << details.mCompleteTime
<< " size=" << details.mSize
<< " offset=" << details.mOffset
<< " length=" << LLUnit<U32, LLUnits::Milliseconds>(details.mCompleteTime - details.mStartTime)
<< " protocol=" << protocol
<< llendl;
}
if(mLogTextureDownloadsToSimulator)
{
S32 texture_stats_upload_threshold = mTextureLogThreshold;
mTotalBytes += mTextures[id]->mSize;
mTotalMilliseconds += mTextures[id]->mCompleteTime - mTextures[id]->mStartTime;
mTextureDownloadsCompleted++;
add(sTextureDataDownloaded, details.mSize);
add(sTexureDownloadTime, details.mCompleteTime - details.mStartTime);
add(sTextureDownloadsCompleted, 1);
mTextureDownloadProtocol = protocol;
if (mTotalBytes >= texture_stats_upload_threshold)
if (mRecording.getSum(sTextureDataDownloaded) >= mTextureLogThreshold)
{
LLSD texture_data;
std::stringstream startTime;
@ -189,35 +193,33 @@ LLSD LLTextureInfo::getAverages()
{
LLSD averagedTextureData;
S32 averageDownloadRate;
if(mTotalMilliseconds == 0)
LLUnit<U32, LLUnits::Milliseconds> download_time = mRecording.getSum(sTexureDownloadTime);
if(download_time == 0)
{
averageDownloadRate = 0;
}
else
{
averageDownloadRate = (mTotalBytes * 8) / mTotalMilliseconds;
averageDownloadRate = mRecording.getSum(sTextureDataDownloaded).valueAs<LLUnits::Bits>() / download_time.valueAs<LLUnits::Seconds>();
}
averagedTextureData["bits_per_second"] = averageDownloadRate;
averagedTextureData["bytes_downloaded"] = mTotalBytes;
averagedTextureData["texture_downloads_started"] = mTextureDownloadsStarted;
averagedTextureData["texture_downloads_completed"] = mTextureDownloadsCompleted;
averagedTextureData["transport"] = mTextureDownloadProtocol;
averagedTextureData["bits_per_second"] = averageDownloadRate;
averagedTextureData["bytes_downloaded"] = mRecording.getSum(sTextureDataDownloaded).valueAs<LLUnits::Bytes>();
averagedTextureData["texture_downloads_started"] = mRecording.getSum(sTextureDownloadsStarted);
averagedTextureData["texture_downloads_completed"] = mRecording.getSum(sTextureDownloadsCompleted);
averagedTextureData["transport"] = mTextureDownloadProtocol;
return averagedTextureData;
}
void LLTextureInfo::resetTextureStatistics()
{
mTotalMilliseconds = 0;
mTotalBytes = 0;
mTextureDownloadsStarted = 0;
mTextureDownloadsCompleted = 0;
mRecording.restart();
mTextureDownloadProtocol = "NONE";
mCurrentStatsBundleStartTime = LLTimer::getTotalTime();
}
U32 LLTextureInfo::getRequestStartTime(const LLUUID& id)
LLUnit<U32, LLUnits::Microseconds> LLTextureInfo::getRequestStartTime(const LLUUID& id)
{
if (!has(id))
{
@ -230,7 +232,7 @@ U32 LLTextureInfo::getRequestStartTime(const LLUUID& id)
}
}
U32 LLTextureInfo::getRequestSize(const LLUUID& id)
LLUnit<U32, LLUnits::Bytes> LLTextureInfo::getRequestSize(const LLUUID& id)
{
if (!has(id))
{
@ -269,7 +271,7 @@ LLTextureInfoDetails::LLRequestType LLTextureInfo::getRequestType(const LLUUID&
}
}
U32 LLTextureInfo::getRequestCompleteTime(const LLUUID& id)
LLUnit<U32, LLUnits::Microseconds> LLTextureInfo::getRequestCompleteTime(const LLUUID& id)
{
if (!has(id))
{

32
indra/newview/lltextureinfo.h
View File

@ -29,6 +29,7 @@
#include "lluuid.h"
#include "lltextureinfodetails.h"
#include "lltracerecording.h"
#include <map>
class LLTextureInfo
@ -37,18 +38,18 @@ public:
LLTextureInfo();
~LLTextureInfo();
void setUpLogging(bool writeToViewerLog, bool sendToSim, U32 textureLogThreshold);
void setUpLogging(bool writeToViewerLog, bool sendToSim, LLUnit<U32, LLUnits::Bytes> textureLogThreshold);
bool has(const LLUUID& id);
void setRequestStartTime(const LLUUID& id, U64 startTime);
void setRequestSize(const LLUUID& id, U32 size);
void setRequestOffset(const LLUUID& id, U32 offset);
void setRequestType(const LLUUID& id, LLTextureInfoDetails::LLRequestType type);
void setRequestCompleteTimeAndLog(const LLUUID& id, U64 completeTime);
U32 getRequestStartTime(const LLUUID& id);
U32 getRequestSize(const LLUUID& id);
void setRequestCompleteTimeAndLog(const LLUUID& id, LLUnit<U64, LLUnits::Microseconds> completeTime);
LLUnit<U32, LLUnits::Microseconds>getRequestStartTime(const LLUUID& id);
LLUnit<U32, LLUnits::Bytes> getRequestSize(const LLUUID& id);
U32 getRequestOffset(const LLUUID& id);
LLTextureInfoDetails::LLRequestType getRequestType(const LLUUID& id);
U32 getRequestCompleteTime(const LLUUID& id);
LLUnit<U32, LLUnits::Microseconds> getRequestCompleteTime(const LLUUID& id);
void resetTextureStatistics();
U32 getTextureInfoMapSize();
LLSD getAverages();
@ -56,19 +57,14 @@ public:
private:
void addRequest(const LLUUID& id);
std::map<LLUUID, LLTextureInfoDetails *> mTextures;
LLSD mAverages;
bool mLogTextureDownloadsToViewerLog;
bool mLogTextureDownloadsToSimulator;
S32 mTotalBytes;
S32 mTotalMilliseconds;
S32 mTextureDownloadsStarted;
S32 mTextureDownloadsCompleted;
std::string mTextureDownloadProtocol;
U32 mTextureLogThreshold; // in bytes
U64 mCurrentStatsBundleStartTime;
std::map<LLUUID, LLTextureInfoDetails *> mTextures;
LLSD mAverages;
bool mLogTextureDownloadsToViewerLog,
mLogTextureDownloadsToSimulator;
std::string mTextureDownloadProtocol;
LLUnit<U32, LLUnits::Bytes> mTextureLogThreshold;
LLUnit<U64, LLUnits::Microseconds> mCurrentStatsBundleStartTime;
LLTrace::Recording mRecording;
};
#endif // LL_LLTEXTUREINFO_H

4
indra/newview/lltextureinfodetails.cpp
View File

@ -28,7 +28,9 @@
#include "lltextureinfodetails.h"
LLTextureInfoDetails::LLTextureInfoDetails() : mStartTime(0), mCompleteTime(0), mSize(0), mType(REQUEST_TYPE_NONE), mOffset(0)
LLTextureInfoDetails::LLTextureInfoDetails()
: mType(REQUEST_TYPE_NONE),
mOffset(0)
{
}

14
indra/newview/lltextureinfodetails.h
View File

@ -28,10 +28,10 @@
#define LL_LLTEXTUREINFODETAILS_H
#include "lluuid.h"
#include "llunit.h"
class LLTextureInfoDetails
struct LLTextureInfoDetails
{
public:
enum LLRequestType
{
REQUEST_TYPE_NONE,
@ -39,11 +39,11 @@ public:
REQUEST_TYPE_UDP
};
U32 mStartTime;
U32 mCompleteTime;
U32 mOffset;
U32 mSize;
LLRequestType mType;
LLUnit<U32, LLUnits::Microseconds> mStartTime,
mCompleteTime;
U32 mOffset;
LLUnit<U32, LLUnits::Bytes> mSize;
LLRequestType mType;
LLTextureInfoDetails();
};

3
indra/newview/lltexturestats.cpp
View File

@ -48,8 +48,7 @@ void send_texture_stats_to_sim(const LLSD &texture_stats)
texture_stats_report["stats_data"] = texture_stats;
std::string texture_cap_url = gAgent.getRegion()->getCapability("TextureStats");
LLTextureStatsUploader tsu;
llinfos << "uploading texture stats data to simulator" << llendl;
tsu.uploadStatsToSimulator(texture_cap_url, texture_stats);
LLTextureStatsUploader::uploadStatsToSimulator(texture_cap_url, texture_stats);
}

8
indra/newview/lltexturestatsuploader.cpp
View File

@ -30,14 +30,8 @@
#include "llhttpclient.h"
LLTextureStatsUploader::LLTextureStatsUploader()
{
}
LLTextureStatsUploader::~LLTextureStatsUploader()
{
}
// static
void LLTextureStatsUploader::uploadStatsToSimulator(const std::string texture_cap_url, const LLSD &texture_stats)
{
if ( texture_cap_url != "" )

4
indra/newview/lltexturestatsuploader.h
View File

@ -34,9 +34,7 @@
class LLTextureStatsUploader
{
public:
LLTextureStatsUploader();
~LLTextureStatsUploader();
void uploadStatsToSimulator(const std::string texture_cap_url, const LLSD &texture_stats);
static void uploadStatsToSimulator(const std::string texture_cap_url, const LLSD &texture_stats);
};
#endif // LL_LLTEXTURESTATSUPLOADER_H

10
indra/newview/llviewerstats.cpp
View File

@ -291,9 +291,9 @@ F32 gAveLandCompression = 0.f,
gWorstWaterCompression = 0.f;
LLUnit<U32, LLUnits::Bytes> gTotalWorldData = 0,
gTotalObjectData = 0,
gTotalTextureData = 0;
U32 gSimPingCount = 0;
gTotalObjectData = 0,
gTotalTextureData = 0;
U32 gSimPingCount = 0;
LLUnit<U32, LLUnits::Bits> gObjectData = 0;
F32 gAvgSimPing = 0.f;
LLUnit<U32, LLUnits::Bytes> gTotalTextureBytesPerBoostLevel[LLViewerTexture::MAX_GL_IMAGE_CATEGORY] = {0};
@ -353,7 +353,7 @@ void update_statistics()
}
else
{
sample(LLStatViewer::SIM_PING, LLUnit<F64, LLUnits::Seconds>(10));
sample(LLStatViewer::SIM_PING, LLUnits::Seconds::fromValue(10));
}
if (LLViewerStats::instance().getRecording().getSum(LLStatViewer::FPS))
@ -403,7 +403,7 @@ void update_statistics()
static LLFrameTimer texture_stats_timer;
if (texture_stats_timer.getElapsedTimeF32() >= texture_stats_freq)
{
gTotalTextureData = LLUnit<F64, LLUnits::Bytes>(LLViewerStats::instance().getRecording().getSum(LLStatViewer::TEXTURE_KBIT));
gTotalTextureData = LLViewerStats::instance().getRecording().getSum(LLStatViewer::TEXTURE_KBIT);
texture_stats_timer.reset();
}
}