开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 游戏引擎 > 查看源码
llviewerstats.cpp
资源名称：snowglobe-src-viewer-2.0.0-r0.tar.gz　[点击查看]
上传用户：king477883
上传日期：2021-03-01
资源大小：9553k
文件大小：28k
源码类别：

游戏引擎

开发平台：

C++ Builder

llviewerstats.cpp：源码内容
  1. /** 
  2.  * @file llviewerstats.cpp
  3.  * @brief LLViewerStats class implementation
  4.  *
  5.  * $LicenseInfo:firstyear=2002&license=viewergpl$
  6.  * 
  7.  * Copyright (c) 2002-2010, Linden Research, Inc.
  8.  * 
  9.  * Second Life Viewer Source Code
  10.  * The source code in this file ("Source Code") is provided by Linden Lab
  11.  * to you under the terms of the GNU General Public License, version 2.0
  12.  * ("GPL"), unless you have obtained a separate licensing agreement
  13.  * ("Other License"), formally executed by you and Linden Lab.  Terms of
  14.  * the GPL can be found in doc/GPL-license.txt in this distribution, or
  15.  * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  16.  * 
  17.  * There are special exceptions to the terms and conditions of the GPL as
  18.  * it is applied to this Source Code. View the full text of the exception
  19.  * in the file doc/FLOSS-exception.txt in this software distribution, or
  20.  * online at
  21.  * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  22.  * 
  23.  * By copying, modifying or distributing this software, you acknowledge
  24.  * that you have read and understood your obligations described above,
  25.  * and agree to abide by those obligations.
  26.  * 
  27.  * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
  28.  * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
  29.  * COMPLETENESS OR PERFORMANCE.
  30.  * $/LicenseInfo$
  31.  */
  33. #include "llviewerprecompiledheaders.h"
  35. #include "llviewerstats.h"
  36. #include "llviewerthrottle.h"
  38. #include "message.h"
  39. #include "llfloaterreg.h"
  40. #include "llmemory.h"
  41. #include "lltimer.h"
  42. #include "llvfile.h"
  44. #include "llappviewer.h"
  46. #include "pipeline.h" 
  47. #include "lltexturefetch.h" 
  48. #include "llviewerobjectlist.h" 
  49. #include "llviewertexturelist.h" 
  50. #include "lltexlayer.h"
  51. #include "lltexlayerparams.h"
  52. #include "llsurface.h"
  53. #include "llvlmanager.h"
  54. #include "llagent.h"
  55. #include "llviewercontrol.h"
  56. #include "llfloatertools.h"
  57. #include "lldebugview.h"
  58. #include "llfasttimerview.h"
  59. #include "llviewerregion.h"
  60. #include "llvoavatar.h"
  61. #include "llvoavatarself.h"
  62. #include "llviewerwindow.h" // *TODO: remove, only used for width/height
  63. #include "llworld.h"
  64. #include "llfeaturemanager.h"
  65. #include "llviewernetwork.h"
  68. class StatAttributes
  69. {
  70. public:
  71. StatAttributes(const char* name,
  72.    const BOOL enabled,
  73.    const BOOL is_timer)
  74. : mName(name),
  75.   mEnabled(enabled),
  76.   mIsTimer(is_timer)
  77. {
  78. }
  80. std::string mName;
  81. BOOL mEnabled;
  82. BOOL mIsTimer;
  83. };
  85. const StatAttributes STAT_INFO[LLViewerStats::ST_COUNT] =
  86. {
  87. // ST_VERSION
  88. StatAttributes("Version", TRUE, FALSE),
  89. // ST_AVATAR_EDIT_SECONDS
  90. StatAttributes("Seconds in Edit Appearence", FALSE, TRUE),
  91. // ST_TOOLBOX_SECONDS
  92. StatAttributes("Seconds using Toolbox", FALSE, TRUE),
  93. // ST_CHAT_COUNT
  94. StatAttributes("Chat messages sent", FALSE, FALSE),
  95. // ST_IM_COUNT
  96. StatAttributes("IMs sent", FALSE, FALSE),
  97. // ST_FULLSCREEN_BOOL
  98. StatAttributes("Fullscreen mode", FALSE, FALSE),
  99. // ST_RELEASE_COUNT
  100. StatAttributes("Object release count", FALSE, FALSE),
  101. // ST_CREATE_COUNT
  102. StatAttributes("Object create count", FALSE, FALSE),
  103. // ST_REZ_COUNT
  104. StatAttributes("Object rez count", FALSE, FALSE),
  105. // ST_FPS_10_SECONDS
  106. StatAttributes("Seconds below 10 FPS", FALSE, TRUE),
  107. // ST_FPS_2_SECONDS
  108. StatAttributes("Seconds below 2 FPS", FALSE, TRUE),
  109. // ST_MOUSELOOK_SECONDS
  110. StatAttributes("Seconds in Mouselook", FALSE, TRUE),
  111. // ST_FLY_COUNT
  112. StatAttributes("Fly count", FALSE, FALSE),
  113. // ST_TELEPORT_COUNT
  114. StatAttributes("Teleport count", FALSE, FALSE),
  115. // ST_OBJECT_DELETE_COUNT
  116. StatAttributes("Objects deleted", FALSE, FALSE),
  117. // ST_SNAPSHOT_COUNT
  118. StatAttributes("Snapshots taken", FALSE, FALSE),
  119. // ST_UPLOAD_SOUND_COUNT
  120. StatAttributes("Sounds uploaded", FALSE, FALSE),
  121. // ST_UPLOAD_TEXTURE_COUNT
  122. StatAttributes("Textures uploaded", FALSE, FALSE),
  123. // ST_EDIT_TEXTURE_COUNT
  124. StatAttributes("Changes to textures on objects", FALSE, FALSE),
  125. // ST_KILLED_COUNT
  126. StatAttributes("Number of times killed", FALSE, FALSE),
  127. // ST_FRAMETIME_JITTER
  128. StatAttributes("Average delta between sucessive frame times", FALSE, FALSE),
  129. // ST_FRAMETIME_SLEW
  130. StatAttributes("Average delta between frame time and mean", FALSE, FALSE),
  131. // ST_INVENTORY_TOO_LONG
  132. StatAttributes("Inventory took too long to load", FALSE, FALSE),
  133. // ST_WEARABLES_TOO_LONG
  134. StatAttributes("Wearables took too long to load", FALSE, FALSE),
  135. // ST_LOGIN_SECONDS
  136. StatAttributes("Time between LoginRequest and LoginReply", FALSE, FALSE),
  137. // ST_LOGIN_TIMEOUT_COUNT
  138. StatAttributes("Number of login attempts that timed out", FALSE, FALSE),
  139. // ST_HAS_BAD_TIMER
  140. StatAttributes("Known bad timer if != 0.0", FALSE, FALSE),
  141. // ST_DOWNLOAD_FAILED
  142. StatAttributes("Number of times LLAssetStorage::getAssetData() has failed", FALSE, FALSE),
  143. // ST_LSL_SAVE_COUNT
  144. StatAttributes("Number of times user has saved a script", FALSE, FALSE),
  145. // ST_UPLOAD_ANIM_COUNT
  146. StatAttributes("Animations uploaded", FALSE, FALSE),
  147. // ST_FPS_8_SECONDS
  148. StatAttributes("Seconds below 8 FPS", FALSE, TRUE),
  149. // ST_SIM_FPS_20_SECONDS
  150. StatAttributes("Seconds with sim FPS below 20", FALSE, TRUE),
  151. // ST_PHYS_FPS_20_SECONDS
  152. StatAttributes("Seconds with physics FPS below 20", FALSE, TRUE),
  153. // ST_LOSS_05_SECONDS
  154. StatAttributes("Seconds with packet loss > 5%", FALSE, TRUE),
  155. // ST_FPS_DROP_50_RATIO
  156. StatAttributes("Ratio of frames 2x longer than previous", FALSE, FALSE),
  157. // ST_ENABLE_VBO
  158. StatAttributes("Vertex Buffers Enabled", TRUE, FALSE),
  159. // ST_DELTA_BANDWIDTH
  160. StatAttributes("Increase/Decrease in bandwidth based on packet loss", FALSE, FALSE),
  161. // ST_MAX_BANDWIDTH
  162. StatAttributes("Max bandwidth setting", FALSE, FALSE),
  163. // ST_LIGHTING_DETAIL
  164. StatAttributes("Lighting Detail", FALSE, FALSE),
  165. // ST_VISIBLE_AVATARS
  166. StatAttributes("Visible Avatars", FALSE, FALSE),
  167. // ST_SHADER_OJECTS
  168. StatAttributes("Object Shaders", FALSE, FALSE),
  169. // ST_SHADER_ENVIRONMENT
  170. StatAttributes("Environment Shaders", FALSE, FALSE),
  171. // ST_VISIBLE_DRAW_DIST
  172. StatAttributes("Draw Distance", FALSE, FALSE),
  173. // ST_VISIBLE_CHAT_BUBBLES
  174. StatAttributes("Chat Bubbles Enabled", FALSE, FALSE),
  175. // ST_SHADER_AVATAR
  176. StatAttributes("Avatar Shaders", FALSE, FALSE),
  177. // ST_FRAME_SECS
  178. StatAttributes("FRAME_SECS", FALSE, FALSE),
  179. // ST_UPDATE_SECS
  180. StatAttributes("UPDATE_SECS", FALSE, FALSE),
  181. // ST_NETWORK_SECS
  182. StatAttributes("NETWORK_SECS", FALSE, FALSE),
  183. // ST_IMAGE_SECS
  184. StatAttributes("IMAGE_SECS", FALSE, FALSE),
  185. // ST_REBUILD_SECS
  186. StatAttributes("REBUILD_SECS", FALSE, FALSE),
  187. // ST_RENDER_SECS
  188. StatAttributes("RENDER_SECS", FALSE, FALSE),
  189. // ST_CROSSING_AVG
  190. StatAttributes("CROSSING_AVG", FALSE, FALSE),
  191. // ST_CROSSING_MAX
  192. StatAttributes("CROSSING_MAX", FALSE, FALSE),
  193. // ST_LIBXUL_WIDGET_USED
  194. StatAttributes("LibXUL Widget used", FALSE, FALSE), // Unused
  195. // ST_WINDOW_WIDTH
  196. StatAttributes("Window width", FALSE, FALSE),
  197. // ST_WINDOW_HEIGHT
  198. StatAttributes("Window height", FALSE, FALSE),
  199. // ST_TEX_BAKES
  200. StatAttributes("Texture Bakes", FALSE, FALSE),
  201. // ST_TEX_REBAKES
  202. StatAttributes("Texture Rebakes", FALSE, FALSE)
  204. };
  206. LLViewerStats::LLViewerStats() :
  207. mKBitStat("kbitstat"),
  208. mLayersKBitStat("layerskbitstat"),
  209. mObjectKBitStat("objectkbitstat"),
  210. mAssetKBitStat("assetkbitstat"),
  211. mTextureKBitStat("texturekbitstat"),
  212. mVFSPendingOperations("vfspendingoperations"),
  213. mObjectsDrawnStat("objectsdrawnstat"),
  214. mObjectsCulledStat("objectsculledstat"),
  215. mObjectsTestedStat("objectstestedstat"),
  216. mObjectsComparedStat("objectscomparedstat"),
  217. mObjectsOccludedStat("objectsoccludedstat"),
  218. mFPSStat("fpsstat"),
  219. mPacketsInStat("packetsinstat"),
  220. mPacketsLostStat("packetsloststat"),
  221. mPacketsOutStat("packetsoutstat"),
  222. mPacketsLostPercentStat("packetslostpercentstat", 64),
  223. mTexturePacketsStat("texturepacketsstat"),
  224. mActualInKBitStat("actualinkbitstat"),
  225. mActualOutKBitStat("actualoutkbitstat"),
  226. mTrianglesDrawnStat("trianglesdrawnstat"),
  227. mSimTimeDilation("simtimedilation"),
  228. mSimFPS("simfps"),
  229. mSimPhysicsFPS("simphysicsfps"),
  230. mSimAgentUPS("simagentups"),
  231. mSimScriptEPS("simscripteps"),
  232. mSimFrameMsec("simframemsec"),
  233. mSimNetMsec("simnetmsec"),
  234. mSimSimOtherMsec("simsimothermsec"),
  235. mSimSimPhysicsMsec("simsimphysicsmsec"),
  236. mSimSimPhysicsStepMsec("simsimphysicsstepmsec"),
  237. mSimSimPhysicsShapeUpdateMsec("simsimphysicsshapeupdatemsec"),
  238. mSimSimPhysicsOtherMsec("simsimphysicsothermsec"),
  239. mSimAgentMsec("simagentmsec"),
  240. mSimImagesMsec("simimagesmsec"),
  241. mSimScriptMsec("simscriptmsec"),
  242. mSimSpareMsec("simsparemsec"),
  243. mSimSleepMsec("simsleepmsec"),
  244. mSimPumpIOMsec("simpumpiomsec"),
  245. mSimMainAgents("simmainagents"),
  246. mSimChildAgents("simchildagents"),
  247. mSimObjects("simobjects"),
  248. mSimActiveObjects("simactiveobjects"),
  249. mSimActiveScripts("simactivescripts"),
  250. mSimInPPS("siminpps"),
  251. mSimOutPPS("simoutpps"),
  252. mSimPendingDownloads("simpendingdownloads"),
  253. mSimPendingUploads("simpendinguploads"),
  254. mSimPendingLocalUploads("simpendinglocaluploads"),
  255. mSimTotalUnackedBytes("simtotalunackedbytes"),
  256. mPhysicsPinnedTasks("physicspinnedtasks"),
  257. mPhysicsLODTasks("physicslodtasks"),
  258. mPhysicsMemoryAllocated("physicsmemoryallocated"),
  259. mSimPingStat("simpingstat"),
  260. mNumImagesStat("numimagesstat", 32, TRUE),
  261. mNumRawImagesStat("numrawimagesstat", 32, TRUE),
  262. mGLTexMemStat("gltexmemstat", 32, TRUE),
  263. mGLBoundMemStat("glboundmemstat", 32, TRUE),
  264. mRawMemStat("rawmemstat", 32, TRUE),
  265. mFormattedMemStat("formattedmemstat", 32, TRUE),
  266. mNumObjectsStat("numobjectsstat"),
  267. mNumActiveObjectsStat("numactiveobjectsstat"),
  268. mNumNewObjectsStat("numnewobjectsstat"),
  269. mNumSizeCulledStat("numsizeculledstat"),
  270. mNumVisCulledStat("numvisculledstat"),
  271. mLastTimeDiff(0.0)
  272. {
  273. for (S32 i = 0; i < ST_COUNT; i++)
  274. {
  275. mStats[i] = 0.0;
  276. }
  278. if (LLTimer::knownBadTimer())
  279. {
  280. mStats[ST_HAS_BAD_TIMER] = 1.0;
  281. }
  282. }
  284. LLViewerStats::~LLViewerStats()
  285. {
  286. }
  288. void LLViewerStats::resetStats()
  289. {
  290. LLViewerStats::getInstance()->mKBitStat.reset();
  291. LLViewerStats::getInstance()->mLayersKBitStat.reset();
  292. LLViewerStats::getInstance()->mObjectKBitStat.reset();
  293. LLViewerStats::getInstance()->mTextureKBitStat.reset();
  294. LLViewerStats::getInstance()->mVFSPendingOperations.reset();
  295. LLViewerStats::getInstance()->mAssetKBitStat.reset();
  296. LLViewerStats::getInstance()->mPacketsInStat.reset();
  297. LLViewerStats::getInstance()->mPacketsLostStat.reset();
  298. LLViewerStats::getInstance()->mPacketsOutStat.reset();
  299. LLViewerStats::getInstance()->mFPSStat.reset();
  300. LLViewerStats::getInstance()->mTexturePacketsStat.reset();
  301. }
  304. F64 LLViewerStats::getStat(EStatType type) const
  305. {
  306. return mStats[type];
  307. }
  309. F64 LLViewerStats::setStat(EStatType type, F64 value)
  310. {
  311. mStats[type] = value;
  312. return mStats[type];
  313. }
  315. F64 LLViewerStats::incStat(EStatType type, F64 value)
  316. {
  317. mStats[type] += value;
  318. return mStats[type];
  319. }
  321. void LLViewerStats::updateFrameStats(const F64 time_diff)
  322. {
  323. if (mPacketsLostPercentStat.getCurrent() > 5.0)
  324. {
  325. incStat(LLViewerStats::ST_LOSS_05_SECONDS, time_diff);
  326. }
  328. if (mSimFPS.getCurrent() < 20.f && mSimFPS.getCurrent() > 0.f)
  329. {
  330. incStat(LLViewerStats::ST_SIM_FPS_20_SECONDS, time_diff);
  331. }
  333. if (mSimPhysicsFPS.getCurrent() < 20.f && mSimPhysicsFPS.getCurrent() > 0.f)
  334. {
  335. incStat(LLViewerStats::ST_PHYS_FPS_20_SECONDS, time_diff);
  336. }
  338. if (time_diff >= 0.5)
  339. {
  340. incStat(LLViewerStats::ST_FPS_2_SECONDS, time_diff);
  341. }
  342. if (time_diff >= 0.125)
  343. {
  344. incStat(LLViewerStats::ST_FPS_8_SECONDS, time_diff);
  345. }
  346. if (time_diff >= 0.1)
  347. {
  348. incStat(LLViewerStats::ST_FPS_10_SECONDS, time_diff);
  349. }
  351. if (gFrameCount && mLastTimeDiff > 0.0)
  352. {
  353. // new "stutter" meter
  354. setStat(LLViewerStats::ST_FPS_DROP_50_RATIO,
  355. (getStat(LLViewerStats::ST_FPS_DROP_50_RATIO) * (F64)(gFrameCount - 1) + 
  356.  (time_diff >= 2.0 * mLastTimeDiff ? 1.0 : 0.0)) / gFrameCount);
  359. // old stats that were never really used
  360. setStat(LLViewerStats::ST_FRAMETIME_JITTER,
  361. (getStat(LLViewerStats::ST_FRAMETIME_JITTER) * (gFrameCount - 1) + 
  362.  fabs(mLastTimeDiff - time_diff) / mLastTimeDiff) / gFrameCount);
  364. F32 average_frametime = gRenderStartTime.getElapsedTimeF32() / (F32)gFrameCount;
  365. setStat(LLViewerStats::ST_FRAMETIME_SLEW,
  366. (getStat(LLViewerStats::ST_FRAMETIME_SLEW) * (gFrameCount - 1) + 
  367.  fabs(average_frametime - time_diff) / average_frametime) / gFrameCount);
  369. F32 max_bandwidth = gViewerThrottle.getMaxBandwidth();
  370. F32 delta_bandwidth = gViewerThrottle.getCurrentBandwidth() - max_bandwidth;
  371. setStat(LLViewerStats::ST_DELTA_BANDWIDTH, delta_bandwidth / 1024.f);
  373. setStat(LLViewerStats::ST_MAX_BANDWIDTH, max_bandwidth / 1024.f);
  375. }
  377. mLastTimeDiff = time_diff;
  379. }
  381. void LLViewerStats::addToMessage(LLSD &body) const
  382. {
  383. LLSD &misc = body["misc"];
  385. for (S32 i = 0; i < ST_COUNT; i++)
  386. {
  387. if (STAT_INFO[i].mEnabled)
  388. {
  389. // TODO: send timer value so dataserver can normalize
  390. misc[STAT_INFO[i].mName] = mStats[i];
  391. llinfos << "STAT: " << STAT_INFO[i].mName << ": " << mStats[i]
  392. << llendl;
  393. }
  394. }
  395. }
  397. // static
  398. // const std::string LLViewerStats::statTypeToText(EStatType type)
  399. // {
  400. //  if (type >= 0 && type < ST_COUNT)
  401. //  {
  402. //  return STAT_INFO[type].mName;
  403. //  }
  404. //  else
  405. //  {
  406. //  return "Unknown statistic";
  407. //  }
  408. // }
  410. // *NOTE:Mani The following methods used to exist in viewer.cpp
  411. // Moving them here, but not merging them into LLViewerStats yet.
  412. void reset_statistics()
  413. {
  414. if (LLSurface::sTextureUpdateTime)
  415. {
  416. LLSurface::sTexelsUpdated = 0;
  417. LLSurface::sTextureUpdateTime = 0.f;
  418. }
  419. }
  422. void output_statistics(void*)
  423. {
  424. llinfos << "Number of orphans: " << gObjectList.getOrphanCount() << llendl;
  425. llinfos << "Number of dead objects: " << gObjectList.mNumDeadObjects << llendl;
  426. llinfos << "Num images: " << gTextureList.getNumImages() << llendl;
  427. llinfos << "Texture usage: " << LLImageGL::sGlobalTextureMemoryInBytes << llendl;
  428. llinfos << "Texture working set: " << LLImageGL::sBoundTextureMemoryInBytes << llendl;
  429. llinfos << "Raw usage: " << LLImageRaw::sGlobalRawMemory << llendl;
  430. llinfos << "Formatted usage: " << LLImageFormatted::sGlobalFormattedMemory << llendl;
  431. llinfos << "Zombie Viewer Objects: " << LLViewerObject::getNumZombieObjects() << llendl;
  432. llinfos << "Number of lights: " << gPipeline.getLightCount() << llendl;
  434. llinfos << "Memory Usage:" << llendl;
  435. llinfos << "--------------------------------" << llendl;
  436. llinfos << "Pipeline:" << llendl;
  437. llinfos << llendl;
  439. #if LL_SMARTHEAP
  440. llinfos << "--------------------------------" << llendl;
  441. {
  442. llinfos << "sizeof(LLVOVolume) = " << sizeof(LLVOVolume) << llendl;
  444. U32 total_pool_size = 0;
  445. U32 total_used_size = 0;
  446. MEM_POOL_INFO pool_info;
  447. MEM_POOL_STATUS pool_status;
  448. U32 pool_num = 0;
  449. for(pool_status = MemPoolFirst( &pool_info, 1 ); 
  450. pool_status != MEM_POOL_END; 
  451. pool_status = MemPoolNext( &pool_info, 1 ) )
  452. {
  453. llinfos << "Pool #" << pool_num << llendl;
  454. if( MEM_POOL_OK != pool_status )
  455. {
  456. llwarns << "Pool not ok" << llendl;
  457. continue;
  458. }
  460. llinfos << "Pool blockSizeFS " << pool_info.blockSizeFS
  461. << " pageSize " << pool_info.pageSize
  462. << llendl;
  464. U32 pool_count = MemPoolCount(pool_info.pool);
  465. llinfos << "Blocks " << pool_count << llendl;
  467. U32 pool_size = MemPoolSize( pool_info.pool );
  468. if( pool_size == MEM_ERROR_RET )
  469. {
  470. llinfos << "MemPoolSize() failed (" << pool_num << ")" << llendl;
  471. }
  472. else
  473. {
  474. llinfos << "MemPool Size " << pool_size / 1024 << "K" << llendl;
  475. }
  477. total_pool_size += pool_size;
  479. if( !MemPoolLock( pool_info.pool ) )
  480. {
  481. llinfos << "MemPoolLock failed (" << pool_num << ") " << llendl;
  482. continue;
  483. }
  485. U32 used_size = 0; 
  486. MEM_POOL_ENTRY entry;
  487. entry.entry = NULL;
  488. while( MemPoolWalk( pool_info.pool, &entry ) == MEM_POOL_OK )
  489. {
  490. if( entry.isInUse )
  491. {
  492. used_size += entry.size;
  493. }
  494. }
  496. MemPoolUnlock( pool_info.pool );
  498. llinfos << "MemPool Used " << used_size/1024 << "K" << llendl;
  499. total_used_size += used_size;
  500. pool_num++;
  501. }
  503. llinfos << "Total Pool Size " << total_pool_size/1024 << "K" << llendl;
  504. llinfos << "Total Used Size " << total_used_size/1024 << "K" << llendl;
  506. }
  507. #endif
  509. llinfos << "--------------------------------" << llendl;
  510. llinfos << "Avatar Memory (partly overlaps with above stats):" << llendl;
  511. LLTexLayerStaticImageList::getInstance()->dumpByteCount();
  512. LLVOAvatarSelf::dumpScratchTextureByteCount();
  513. LLTexLayerSetBuffer::dumpTotalByteCount();
  514. LLVOAvatarSelf::dumpTotalLocalTextureByteCount();
  515. LLTexLayerParamAlpha::dumpCacheByteCount();
  516. LLVOAvatar::dumpBakedStatus();
  518. llinfos << llendl;
  520. llinfos << "Object counts:" << llendl;
  521. S32 i;
  522. S32 obj_counts[256];
  523. // S32 app_angles[256];
  524. for (i = 0; i < 256; i++)
  525. {
  526. obj_counts[i] = 0;
  527. }
  528. for (i = 0; i < gObjectList.getNumObjects(); i++)
  529. {
  530. LLViewerObject *objectp = gObjectList.getObject(i);
  531. if (objectp)
  532. {
  533. obj_counts[objectp->getPCode()]++;
  534. }
  535. }
  536. for (i = 0; i < 256; i++)
  537. {
  538. if (obj_counts[i])
  539. {
  540. llinfos << LLPrimitive::pCodeToString(i) << ":" << obj_counts[i] << llendl;
  541. }
  542. }
  543. }
  546. U32 gTotalLandIn = 0, gTotalLandOut = 0;
  547. U32 gTotalWaterIn = 0, gTotalWaterOut = 0;
  549. F32 gAveLandCompression = 0.f, gAveWaterCompression = 0.f;
  550. F32 gBestLandCompression = 1.f, gBestWaterCompression = 1.f;
  551. F32 gWorstLandCompression = 0.f, gWorstWaterCompression = 0.f;
  555. U32 gTotalWorldBytes = 0, gTotalObjectBytes = 0, gTotalTextureBytes = 0, gSimPingCount = 0;
  556. U32 gObjectBits = 0;
  557. F32 gAvgSimPing = 0.f;
  560. extern U32  gVisCompared;
  561. extern U32  gVisTested;
  563. std::map<S32,LLFrameTimer> gDebugTimers;
  564. std::map<S32,std::string> gDebugTimerLabel;
  566. void init_statistics()
  567. {
  568. // Label debug timers
  569. gDebugTimerLabel[0] = "Texture";
  570. }
  572. void update_statistics(U32 frame_count)
  573. {
  574. gTotalWorldBytes += gVLManager.getTotalBytes();
  575. gTotalObjectBytes += gObjectBits / 8;
  577. // make sure we have a valid time delta for this frame
  578. if (gFrameIntervalSeconds > 0.f)
  579. {
  580. if (gAgent.getCameraMode() == CAMERA_MODE_MOUSELOOK)
  581. {
  582. LLViewerStats::getInstance()->incStat(LLViewerStats::ST_MOUSELOOK_SECONDS, gFrameIntervalSeconds);
  583. }
  584. else if (gAgent.getCameraMode() == CAMERA_MODE_CUSTOMIZE_AVATAR)
  585. {
  586. LLViewerStats::getInstance()->incStat(LLViewerStats::ST_AVATAR_EDIT_SECONDS, gFrameIntervalSeconds);
  587. }
  588. else if (LLFloaterReg::instanceVisible("build"))
  589. {
  590. LLViewerStats::getInstance()->incStat(LLViewerStats::ST_TOOLBOX_SECONDS, gFrameIntervalSeconds);
  591. }
  592. }
  593. LLViewerStats::getInstance()->setStat(LLViewerStats::ST_ENABLE_VBO, (F64)gSavedSettings.getBOOL("RenderVBOEnable"));
  594. LLViewerStats::getInstance()->setStat(LLViewerStats::ST_LIGHTING_DETAIL, (F64)gSavedSettings.getS32("RenderLightingDetail"));
  595. LLViewerStats::getInstance()->setStat(LLViewerStats::ST_DRAW_DIST, (F64)gSavedSettings.getF32("RenderFarClip"));
  596. LLViewerStats::getInstance()->setStat(LLViewerStats::ST_CHAT_BUBBLES, (F64)gSavedSettings.getBOOL("UseChatBubbles"));
  597. #if 0 // 1.9.2
  598. LLViewerStats::getInstance()->setStat(LLViewerStats::ST_SHADER_OBJECTS, (F64)gSavedSettings.getS32("VertexShaderLevelObject"));
  599. LLViewerStats::getInstance()->setStat(LLViewerStats::ST_SHADER_AVATAR, (F64)gSavedSettings.getBOOL("VertexShaderLevelAvatar"));
  600. LLViewerStats::getInstance()->setStat(LLViewerStats::ST_SHADER_ENVIRONMENT, (F64)gSavedSettings.getBOOL("VertexShaderLevelEnvironment"));
  601. #endif
  602. LLViewerStats::getInstance()->setStat(LLViewerStats::ST_FRAME_SECS, gDebugView->mFastTimerView->getTime("Frame"));
  603. F64 idle_secs = gDebugView->mFastTimerView->getTime("Idle");
  604. F64 network_secs = gDebugView->mFastTimerView->getTime("Network");
  605. LLViewerStats::getInstance()->setStat(LLViewerStats::ST_UPDATE_SECS, idle_secs - network_secs);
  606. LLViewerStats::getInstance()->setStat(LLViewerStats::ST_NETWORK_SECS, network_secs);
  607. LLViewerStats::getInstance()->setStat(LLViewerStats::ST_IMAGE_SECS, gDebugView->mFastTimerView->getTime("Update Images"));
  608. LLViewerStats::getInstance()->setStat(LLViewerStats::ST_REBUILD_SECS, gDebugView->mFastTimerView->getTime("Sort Draw State"));
  609. LLViewerStats::getInstance()->setStat(LLViewerStats::ST_RENDER_SECS, gDebugView->mFastTimerView->getTime("Geometry"));
  611. LLCircuitData *cdp = gMessageSystem->mCircuitInfo.findCircuit(gAgent.getRegion()->getHost());
  612. if (cdp)
  613. {
  614. LLViewerStats::getInstance()->mSimPingStat.addValue(cdp->getPingDelay());
  615. gAvgSimPing = ((gAvgSimPing * (F32)gSimPingCount) + (F32)(cdp->getPingDelay())) / ((F32)gSimPingCount + 1);
  616. gSimPingCount++;
  617. }
  618. else
  619. {
  620. LLViewerStats::getInstance()->mSimPingStat.addValue(10000);
  621. }
  623. LLViewerStats::getInstance()->mFPSStat.addValue(1);
  624. F32 layer_bits = (F32)(gVLManager.getLandBits() + gVLManager.getWindBits() + gVLManager.getCloudBits());
  625. LLViewerStats::getInstance()->mLayersKBitStat.addValue(layer_bits/1024.f);
  626. LLViewerStats::getInstance()->mObjectKBitStat.addValue(gObjectBits/1024.f);
  627. LLViewerStats::getInstance()->mVFSPendingOperations.addValue(LLVFile::getVFSThread()->getPending());
  628. LLViewerStats::getInstance()->mAssetKBitStat.addValue(gTransferManager.getTransferBitsIn(LLTCT_ASSET)/1024.f);
  629. gTransferManager.resetTransferBitsIn(LLTCT_ASSET);
  631. if (LLAppViewer::getTextureFetch()->getNumRequests() == 0)
  632. {
  633. gDebugTimers[0].pause();
  634. }
  635. else
  636. {
  637. gDebugTimers[0].unpause();
  638. }
  640. {
  641. static F32 visible_avatar_frames = 0.f;
  642. static F32 avg_visible_avatars = 0;
  643. F32 visible_avatars = (F32)LLVOAvatar::sNumVisibleAvatars;
  644. if (visible_avatars > 0.f)
  645. {
  646. visible_avatar_frames = 1.f;
  647. avg_visible_avatars = (avg_visible_avatars * (F32)(visible_avatar_frames - 1.f) + visible_avatars) / visible_avatar_frames;
  648. }
  649. LLViewerStats::getInstance()->setStat(LLViewerStats::ST_VISIBLE_AVATARS, (F64)avg_visible_avatars);
  650. }
  651. LLWorld::getInstance()->updateNetStats();
  652. LLWorld::getInstance()->requestCacheMisses();
  654. // Reset all of these values.
  655. gVLManager.resetBitCounts();
  656. gObjectBits = 0;
  657. // gDecodedBits = 0;
  659. // Only update texture stats periodically so that they are less noisy
  660. {
  661. static const F32 texture_stats_freq = 10.f;
  662. static LLFrameTimer texture_stats_timer;
  663. if (texture_stats_timer.getElapsedTimeF32() >= texture_stats_freq)
  664. {
  665. LLViewerStats::getInstance()->mTextureKBitStat.addValue(LLViewerTextureList::sTextureBits/1024.f);
  666. LLViewerStats::getInstance()->mTexturePacketsStat.addValue(LLViewerTextureList::sTexturePackets);
  667. gTotalTextureBytes += LLViewerTextureList::sTextureBits / 8;
  668. LLViewerTextureList::sTextureBits = 0;
  669. LLViewerTextureList::sTexturePackets = 0;
  670. texture_stats_timer.reset();
  671. }
  672. }
  674. }
  676. class ViewerStatsResponder : public LLHTTPClient::Responder
  677. {
  678. public:
  679.     ViewerStatsResponder() { }
  681.     void error(U32 statusNum, const std::string& reason)
  682.     {
  683. llinfos << "ViewerStatsResponder::error " << statusNum << " "
  684. << reason << llendl;
  685.     }
  687.     void result(const LLSD& content)
  688.     {
  689. llinfos << "ViewerStatsResponder::result" << llendl;
  690. }
  691. };
  693. /*
  694.  * The sim-side LLSD is in newsim/llagentinfo.cpp:forwardViewerStats.
  695.  *
  696.  * There's also a compatibility shim for the old fixed-format sim
  697.  * stats in newsim/llagentinfo.cpp:processViewerStats.
  698.  *
  699.  * If you move stats around here, make the corresponding changes in
  700.  * those locations, too.
  701.  */
  702. void send_stats()
  703. {
  704. // IW 9/23/02 I elected not to move this into LLViewerStats
  705. // because it depends on too many viewer.cpp globals.
  706. // Someday we may want to merge all our stats into a central place
  707. // but that day is not today.
  709. // Only send stats if the agent is connected to a region.
  710. if (!gAgent.getRegion() || gNoRender)
  711. {
  712. return;
  713. }
  715. LLSD body;
  716. std::string url = gAgent.getRegion()->getCapability("ViewerStats");
  718. if (url.empty()) {
  719. llwarns << "Could not get ViewerStats capability" << llendl;
  720. return;
  721. }
  723. body["session_id"] = gAgentSessionID;
  725. LLSD &agent = body["agent"];
  727. time_t ltime;
  728. time(&ltime);
  729. F32 run_time = F32(LLFrameTimer::getElapsedSeconds());
  731. agent["start_time"] = S32(ltime - S32(run_time));
  733. // The first stat set must have a 0 run time if it doesn't actually
  734. // contain useful data in terms of FPS, etc.  We use half the
  735. // SEND_STATS_PERIOD seconds as the point at which these statistics become
  736. // valid.  Data warehouse uses a 0 value here to easily discard these
  737. // records with non-useful FPS values etc.
  738. if (run_time < (SEND_STATS_PERIOD / 2))
  739. {
  740. agent["run_time"] = 0.0f;
  741. }
  742. else
  743. {
  744. agent["run_time"] = run_time;
  745. }
  747. // send fps only for time app spends in foreground
  748. agent["fps"] = (F32)gForegroundFrameCount / gForegroundTime.getElapsedTimeF32();
  749. agent["version"] = gCurrentVersion;
  750. std::string language = LLUI::getLanguage();
  751. agent["language"] = language;
  753. agent["sim_fps"] = ((F32) gFrameCount - gSimFrames) /
  754. (F32) (gRenderStartTime.getElapsedTimeF32() - gSimLastTime);
  756. gSimLastTime = gRenderStartTime.getElapsedTimeF32();
  757. gSimFrames   = (F32) gFrameCount;
  759. agent["agents_in_view"] = LLVOAvatar::sNumVisibleAvatars;
  760. agent["ping"] = gAvgSimPing;
  761. agent["meters_traveled"] = gAgent.getDistanceTraveled();
  762. agent["regions_visited"] = gAgent.getRegionsVisited();
  763. agent["mem_use"] = LLMemory::getCurrentRSS() / 1024.0;
  765. LLSD &system = body["system"];
  767. system["ram"] = (S32) gSysMemory.getPhysicalMemoryKB();
  768. system["os"] = LLAppViewer::instance()->getOSInfo().getOSStringSimple();
  769. system["cpu"] = gSysCPU.getCPUString();
  770. std::string macAddressString = llformat("%02x-%02x-%02x-%02x-%02x-%02x",
  771. gMACAddress[0],gMACAddress[1],gMACAddress[2],
  772. gMACAddress[3],gMACAddress[4],gMACAddress[5]);
  773. system["mac_address"] = macAddressString;
  774. system["serial_number"] = LLAppViewer::instance()->getSerialNumber();
  775. std::string gpu_desc = llformat(
  776. "%-6s Class %d ",
  777. gGLManager.mGLVendorShort.substr(0,6).c_str(),
  778. (S32)LLFeatureManager::getInstance()->getGPUClass())
  779. + LLFeatureManager::getInstance()->getGPUString();
  781. system["gpu"] = gpu_desc;
  782. system["gpu_class"] = (S32)LLFeatureManager::getInstance()->getGPUClass();
  783. system["gpu_vendor"] = gGLManager.mGLVendorShort;
  784. system["gpu_version"] = gGLManager.mDriverVersionVendorString;
  786. LLSD &download = body["downloads"];
  788. download["world_kbytes"] = gTotalWorldBytes / 1024.0;
  789. download["object_kbytes"] = gTotalObjectBytes / 1024.0;
  790. download["texture_kbytes"] = gTotalTextureBytes / 1024.0;
  792. LLSD &in = body["stats"]["net"]["in"];
  794. in["kbytes"] = gMessageSystem->mTotalBytesIn / 1024.0;
  795. in["packets"] = (S32) gMessageSystem->mPacketsIn;
  796. in["compressed_packets"] = (S32) gMessageSystem->mCompressedPacketsIn;
  797. in["savings"] = (gMessageSystem->mUncompressedBytesIn -
  798.  gMessageSystem->mCompressedBytesIn) / 1024.0;
  800. LLSD &out = body["stats"]["net"]["out"];
  802. out["kbytes"] = gMessageSystem->mTotalBytesOut / 1024.0;
  803. out["packets"] = (S32) gMessageSystem->mPacketsOut;
  804. out["compressed_packets"] = (S32) gMessageSystem->mCompressedPacketsOut;
  805. out["savings"] = (gMessageSystem->mUncompressedBytesOut -
  806.   gMessageSystem->mCompressedBytesOut) / 1024.0;
  808. LLSD &fail = body["stats"]["failures"];
  810. fail["send_packet"] = (S32) gMessageSystem->mSendPacketFailureCount;
  811. fail["dropped"] = (S32) gMessageSystem->mDroppedPackets;
  812. fail["resent"] = (S32) gMessageSystem->mResentPackets;
  813. fail["failed_resends"] = (S32) gMessageSystem->mFailedResendPackets;
  814. fail["off_circuit"] = (S32) gMessageSystem->mOffCircuitPackets;
  815. fail["invalid"] = (S32) gMessageSystem->mInvalidOnCircuitPackets;
  817. // Misc stats, two strings and two ints
  818. // These are not expecticed to persist across multiple releases
  819. // Comment any changes with your name and the expected release revision
  820. // If the current revision is recent, ping the previous author before overriding
  821. LLSD &misc = body["stats"]["misc"];
  823. // Screen size so the UI team can figure out how big the widgets
  824. // appear and use a "typical" size for end user tests.
  826. S32 window_width = gViewerWindow->getWindowWidthRaw();
  827. S32 window_height = gViewerWindow->getWindowHeightRaw();
  828. S32 window_size = (window_width * window_height) / 1024;
  829. misc["string_1"] = llformat("%d", window_size);
  830. // misc["string_2"] = 
  831. //  misc["int_1"] = LLSD::Integer(gSavedSettings.getU32("RenderQualityPerformance")); // Steve: 1.21
  832. //  misc["int_2"] = LLSD::Integer(gFrameStalls); // Steve: 1.21
  834. F32 unbaked_time = LLVOAvatar::sUnbakedTime * 1000.f / gFrameTimeSeconds;
  835. misc["int_1"] = LLSD::Integer(unbaked_time); // Steve: 1.22
  836. F32 grey_time = LLVOAvatar::sGreyTime * 1000.f / gFrameTimeSeconds;
  837. misc["int_2"] = LLSD::Integer(grey_time); // Steve: 1.22
  839. llinfos << "Misc Stats: int_1: " << misc["int_1"] << " int_2: " << misc["int_2"] << llendl;
  840. llinfos << "Misc Stats: string_1: " << misc["string_1"] << " string_2: " << misc["string_2"] << llendl;
  842. LLViewerStats::getInstance()->addToMessage(body);
  843. LLHTTPClient::post(url, body, new ViewerStatsResponder());
  844. }