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

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

游戏引擎

开发平台：

C++ Builder

llfasttimerview.cpp：源码内容
  1. /** 
  2.  * @file llfasttimerview.cpp
  3.  * @brief LLFastTimerView class implementation
  4.  *
  5.  * $LicenseInfo:firstyear=2004&license=viewergpl$
  6.  * 
  7.  * Copyright (c) 2004-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 "llfasttimerview.h"
  37. #include "llviewerwindow.h"
  38. #include "llrect.h"
  39. #include "llerror.h"
  40. #include "llgl.h"
  41. #include "llrender.h"
  42. #include "lllocalcliprect.h"
  43. #include "llmath.h"
  44. #include "llfontgl.h"
  45. #include "llsdserialize.h"
  46. #include "lltooltip.h"
  48. #include "llappviewer.h"
  49. #include "llviewertexturelist.h"
  50. #include "llui.h"
  51. #include "llviewercontrol.h"
  52. #include "llstat.h"
  54. #include "llfasttimer.h"
  55. #include "lltreeiterators.h"
  56. #include "llmetricperformancetester.h"
  57. //////////////////////////////////////////////////////////////////////////////
  59. static const S32 MAX_VISIBLE_HISTORY = 10;
  60. static const S32 LINE_GRAPH_HEIGHT = 240;
  62. //static const int FTV_DISPLAY_NUM  = (sizeof(ft_display_table)/sizeof(ft_display_table[0]));
  63. static S32 FTV_NUM_TIMERS;
  64. const S32 FTV_MAX_DEPTH = 8;
  66. std::vector<LLFastTimer::NamedTimer*> ft_display_idx; // line of table entry for display purposes (for collapse)
  68. typedef LLTreeDFSIter<LLFastTimer::NamedTimer, LLFastTimer::NamedTimer::child_const_iter> timer_tree_iterator_t;
  70. BOOL LLFastTimerView::sAnalyzePerformance = FALSE;
  72. static timer_tree_iterator_t begin_timer_tree(LLFastTimer::NamedTimer& id) 
  73. { 
  74. return timer_tree_iterator_t(&id, 
  75. boost::bind(boost::mem_fn(&LLFastTimer::NamedTimer::beginChildren), _1), 
  76. boost::bind(boost::mem_fn(&LLFastTimer::NamedTimer::endChildren), _1));
  77. }
  79. static timer_tree_iterator_t end_timer_tree() 
  80. { 
  81. return timer_tree_iterator_t(); 
  82. }
  84. LLFastTimerView::LLFastTimerView(const LLRect& rect)
  85. : LLFloater(LLSD()),
  86. mHoverTimer(NULL)
  87. {
  88. setRect(rect);
  89. setVisible(FALSE);
  90. mDisplayMode = 0;
  91. mAvgCountTotal = 0;
  92. mMaxCountTotal = 0;
  93. mDisplayCenter = ALIGN_CENTER;
  94. mDisplayCalls = 0;
  95. mDisplayHz = 0;
  96. mScrollIndex = 0;
  97. mHoverID = NULL;
  98. mHoverBarIndex = -1;
  99. FTV_NUM_TIMERS = LLFastTimer::NamedTimer::instanceCount();
  100. mPrintStats = -1;
  101. mAverageCyclesPerTimer = 0;
  102. }
  105. BOOL LLFastTimerView::handleRightMouseDown(S32 x, S32 y, MASK mask)
  106. {
  107. if (mHoverTimer )
  108. {
  109. // right click collapses timers
  110. if (!mHoverTimer->getCollapsed())
  111. {
  112. mHoverTimer->setCollapsed(true);
  113. }
  114. else if (mHoverTimer->getParent())
  115. {
  116. mHoverTimer->getParent()->setCollapsed(true);
  117. }
  118. }
  119. else if (mBarRect.pointInRect(x, y))
  120. {
  121. S32 bar_idx = MAX_VISIBLE_HISTORY - ((y - mBarRect.mBottom) * (MAX_VISIBLE_HISTORY + 2) / mBarRect.getHeight());
  122. bar_idx = llclamp(bar_idx, 0, MAX_VISIBLE_HISTORY);
  123. mPrintStats = bar_idx;
  124. }
  125. return FALSE;
  126. }
  128. LLFastTimer::NamedTimer* LLFastTimerView::getLegendID(S32 y)
  129. {
  130. S32 idx = (getRect().getHeight() - y) / ((S32) LLFontGL::getFontMonospace()->getLineHeight()+2) - 5;
  132. if (idx >= 0 && idx < (S32)ft_display_idx.size())
  133. {
  134. return ft_display_idx[idx];
  135. }
  137. return NULL;
  138. }
  140. BOOL LLFastTimerView::handleMouseDown(S32 x, S32 y, MASK mask)
  141. {
  142. if (x < mBarRect.mLeft) 
  143. {
  144. LLFastTimer::NamedTimer* idp = getLegendID(y);
  145. if (idp)
  146. {
  147. idp->setCollapsed(!idp->getCollapsed());
  148. }
  149. }
  150. else if (mHoverTimer)
  151. {
  152. //left click drills down by expanding timers
  153. mHoverTimer->setCollapsed(false);
  154. }
  155. else if (mask & MASK_ALT)
  156. {
  157. if (mask & MASK_CONTROL)
  158. {
  159. mDisplayHz = !mDisplayHz;
  160. }
  161. else
  162. {
  163. mDisplayCalls = !mDisplayCalls;
  164. }
  165. }
  166. else if (mask & MASK_SHIFT)
  167. {
  168. if (++mDisplayMode > 3)
  169. mDisplayMode = 0;
  170. }
  171. else if (mask & MASK_CONTROL)
  172. {
  173. mDisplayCenter = (ChildAlignment)((mDisplayCenter + 1) % ALIGN_COUNT);
  174. }
  175. else
  176. {
  177. // pause/unpause
  178. LLFastTimer::sPauseHistory = !LLFastTimer::sPauseHistory;
  179. // reset scroll to bottom when unpausing
  180. if (!LLFastTimer::sPauseHistory)
  181. {
  182. mScrollIndex = 0;
  183. }
  184. }
  185. // SJB: Don't pass mouse clicks through the display
  186. return TRUE;
  187. }
  189. BOOL LLFastTimerView::handleMouseUp(S32 x, S32 y, MASK mask)
  190. {
  191. return FALSE;
  192. }
  194. BOOL LLFastTimerView::handleHover(S32 x, S32 y, MASK mask)
  195. {
  196. mHoverTimer = NULL;
  197. mHoverID = NULL;
  199. if(LLFastTimer::sPauseHistory && mBarRect.pointInRect(x, y))
  200. {
  201. mHoverBarIndex = llmin(LLFastTimer::getCurFrameIndex() - 1, 
  202. MAX_VISIBLE_HISTORY - ((y - mBarRect.mBottom) * (MAX_VISIBLE_HISTORY + 2) / mBarRect.getHeight()));
  203. if (mHoverBarIndex == 0)
  204. {
  205. return TRUE;
  206. }
  207. else if (mHoverBarIndex == -1)
  208. {
  209. mHoverBarIndex = 0;
  210. }
  212. S32 i = 0;
  213. for(timer_tree_iterator_t it = begin_timer_tree(LLFastTimer::NamedTimer::getRootNamedTimer());
  214. it != end_timer_tree();
  215. ++it, ++i)
  216. {
  217. // is mouse over bar for this timer?
  218. if (x > mBarStart[mHoverBarIndex][i] &&
  219. x < mBarEnd[mHoverBarIndex][i])
  220. {
  221. mHoverID = (*it);
  222. mHoverTimer = (*it);
  223. mToolTipRect.set(mBarStart[mHoverBarIndex][i], 
  224. mBarRect.mBottom + llround(((F32)(MAX_VISIBLE_HISTORY - mHoverBarIndex + 1)) * ((F32)mBarRect.getHeight() / ((F32)MAX_VISIBLE_HISTORY + 2.f))),
  225. mBarEnd[mHoverBarIndex][i],
  226. mBarRect.mBottom + llround((F32)(MAX_VISIBLE_HISTORY - mHoverBarIndex) * ((F32)mBarRect.getHeight() / ((F32)MAX_VISIBLE_HISTORY + 2.f))));
  227. }
  229. if ((*it)->getCollapsed())
  230. {
  231. it.skipDescendants();
  232. }
  233. }
  234. }
  235. else if (x < mBarRect.mLeft) 
  236. {
  237. LLFastTimer::NamedTimer* timer_id = getLegendID(y);
  238. if (timer_id)
  239. {
  240. mHoverID = timer_id;
  241. }
  242. }
  244. return FALSE;
  245. }
  248. BOOL LLFastTimerView::handleToolTip(S32 x, S32 y, MASK mask)
  249. {
  250. if(LLFastTimer::sPauseHistory && mBarRect.pointInRect(x, y))
  251. {
  252. // tooltips for timer bars
  253. if (mHoverTimer)
  254. {
  255. LLRect screen_rect;
  256. localRectToScreen(mToolTipRect, &screen_rect);
  258. LLToolTipMgr::instance().show(LLToolTip::Params()
  259. .message(mHoverTimer->getToolTip(LLFastTimer::NamedTimer::HISTORY_NUM - mScrollIndex - mHoverBarIndex))
  260. .sticky_rect(screen_rect)
  261. .delay_time(0.f));
  263. return TRUE;
  264. }
  265. }
  266. else
  267. {
  268. // tooltips for timer legend
  269. if (x < mBarRect.mLeft) 
  270. {
  271. LLFastTimer::NamedTimer* idp = getLegendID(y);
  272. if (idp)
  273. {
  274. LLToolTipMgr::instance().show(idp->getToolTip());
  276. return TRUE;
  277. }
  278. }
  279. }
  281. return FALSE;
  282. }
  284. BOOL LLFastTimerView::handleScrollWheel(S32 x, S32 y, S32 clicks)
  285. {
  286. LLFastTimer::sPauseHistory = TRUE;
  287. mScrollIndex = llclamp(mScrollIndex - clicks, 
  288. 0, 
  289. llmin(LLFastTimer::getLastFrameIndex(), (S32)LLFastTimer::NamedTimer::HISTORY_NUM - MAX_VISIBLE_HISTORY));
  290. return TRUE;
  291. }
  293. static LLFastTimer::DeclareTimer FTM_RENDER_TIMER("Timers", true);
  295. static std::map<LLFastTimer::NamedTimer*, LLColor4> sTimerColors;
  297. void LLFastTimerView::draw()
  298. {
  299. LLFastTimer t(FTM_RENDER_TIMER);
  301. std::string tdesc;
  303. F64 clock_freq = (F64)LLFastTimer::countsPerSecond();
  304. F64 iclock_freq = 1000.0 / clock_freq;
  306. S32 margin = 10;
  307. S32 height = (S32) (gViewerWindow->getWindowRectScaled().getHeight()*0.75f);
  308. S32 width = (S32) (gViewerWindow->getWindowRectScaled().getWidth() * 0.75f);
  310. LLRect new_rect;
  311. new_rect.setLeftTopAndSize(getRect().mLeft, getRect().mTop, width, height);
  312. setRect(new_rect);
  314. S32 left, top, right, bottom;
  315. S32 x, y, barw, barh, dx, dy;
  316. S32 texth, textw;
  317. LLPointer<LLUIImage> box_imagep = LLUI::getUIImage("Rounded_Square");
  319. // Draw the window background
  320. gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
  321. gl_rect_2d(0, getRect().getHeight(), getRect().getWidth(), 0, LLColor4(0.f, 0.f, 0.f, 0.25f));
  323. S32 xleft = margin;
  324. S32 ytop = margin;
  326. mAverageCyclesPerTimer = LLFastTimer::sTimerCalls == 0 
  327. ? 0 
  328. : llround(lerp((F32)mAverageCyclesPerTimer, (F32)(LLFastTimer::sTimerCycles / (U64)LLFastTimer::sTimerCalls), 0.1f));
  329. LLFastTimer::sTimerCycles = 0;
  330. LLFastTimer::sTimerCalls = 0;
  332. // Draw some help
  333. {
  335. x = xleft;
  336. y = height - ytop;
  337. texth = (S32)LLFontGL::getFontMonospace()->getLineHeight();
  339. #if TIME_FAST_TIMERS
  340. tdesc = llformat("Cycles per timer call: %d", mAverageCyclesPerTimer);
  341. LLFontGL::getFontMonospace()->renderUTF8(tdesc, 0, x, y, LLColor4::white, LLFontGL::LEFT, LLFontGL::TOP);
  342. #else
  343. char modedesc[][32] = {
  344. "2 x Average ",
  345. "Max         ",
  346. "Recent Max  ",
  347. "100 ms      "
  348. };
  349. char centerdesc[][32] = {
  350. "Left      ",
  351. "Centered  ",
  352. "Ordered   "
  353. };
  355. tdesc = llformat("Full bar = %s [Click to pause/reset] [SHIFT-Click to toggle]",modedesc[mDisplayMode]);
  356. LLFontGL::getFontMonospace()->renderUTF8(tdesc, 0, x, y, LLColor4::white, LLFontGL::LEFT, LLFontGL::TOP);
  357. textw = LLFontGL::getFontMonospace()->getWidth(tdesc);
  359. x = xleft, y -= (texth + 2);
  360. tdesc = llformat("Justification = %s [CTRL-Click to toggle]",centerdesc[mDisplayCenter]);
  361. LLFontGL::getFontMonospace()->renderUTF8(tdesc, 0, x, y, LLColor4::white, LLFontGL::LEFT, LLFontGL::TOP);
  362. y -= (texth + 2);
  364. LLFontGL::getFontMonospace()->renderUTF8(std::string("[Right-Click log selected] [ALT-Click toggle counts] [ALT-SHIFT-Click sub hidden]"),
  365.  0, x, y, LLColor4::white, LLFontGL::LEFT, LLFontGL::TOP);
  366. #endif
  367. y -= (texth + 2);
  368. }
  370. S32 histmax = llmin(LLFastTimer::getLastFrameIndex()+1, MAX_VISIBLE_HISTORY);
  372. // Draw the legend
  373. xleft = margin;
  374. ytop = y;
  376. y -= (texth + 2);
  378. sTimerColors[&LLFastTimer::NamedTimer::getRootNamedTimer()] = LLColor4::grey;
  380. F32 hue = 0.f;
  382. for (timer_tree_iterator_t it = begin_timer_tree(LLFastTimer::NamedTimer::getRootNamedTimer());
  383. it != timer_tree_iterator_t();
  384. ++it)
  385. {
  386. LLFastTimer::NamedTimer* idp = (*it);
  388. const F32 HUE_INCREMENT = 0.23f;
  389. hue = fmodf(hue + HUE_INCREMENT, 1.f);
  390. // saturation increases with depth
  391. F32 saturation = clamp_rescale((F32)idp->getDepth(), 0.f, 3.f, 0.f, 1.f);
  392. // lightness alternates with depth
  393. F32 lightness = idp->getDepth() % 2 ? 0.5f : 0.6f;
  395. LLColor4 child_color;
  396. child_color.setHSL(hue, saturation, lightness);
  398. sTimerColors[idp] = child_color;
  399. }
  401. const S32 LEGEND_WIDTH = 220;
  402. {
  403. LLLocalClipRect clip(LLRect(margin, y, LEGEND_WIDTH, margin));
  404. S32 cur_line = 0;
  405. ft_display_idx.clear();
  406. std::map<LLFastTimer::NamedTimer*, S32> display_line;
  407. for (timer_tree_iterator_t it = begin_timer_tree(LLFastTimer::NamedTimer::getRootNamedTimer());
  408. it != timer_tree_iterator_t();
  409. ++it)
  410. {
  411. LLFastTimer::NamedTimer* idp = (*it);
  412. display_line[idp] = cur_line;
  413. ft_display_idx.push_back(idp);
  414. cur_line++;
  416. x = xleft;
  418. left = x; right = x + texth;
  419. top = y; bottom = y - texth;
  420. S32 scale_offset = 0;
  421. if (idp == mHoverID)
  422. {
  423. scale_offset = llfloor(sinf(mHighlightTimer.getElapsedTimeF32() * 6.f) * 2.f);
  424. }
  425. gl_rect_2d(left - scale_offset, top + scale_offset, right + scale_offset, bottom - scale_offset, sTimerColors[idp]);
  427. F32 ms = 0;
  428. S32 calls = 0;
  429. if (mHoverBarIndex > 0 && mHoverID)
  430. {
  431. S32 hidx = LLFastTimer::NamedTimer::HISTORY_NUM - mScrollIndex - mHoverBarIndex;
  432. U64 ticks = idp->getHistoricalCount(hidx);
  433. ms = (F32)((F64)ticks * iclock_freq);
  434. calls = (S32)idp->getHistoricalCalls(hidx);
  435. }
  436. else
  437. {
  438. U64 ticks = idp->getCountAverage();
  439. ms = (F32)((F64)ticks * iclock_freq);
  440. calls = (S32)idp->getCallAverage();
  441. }
  443. if (mDisplayCalls)
  444. {
  445. tdesc = llformat("%s (%d)",idp->getName().c_str(),calls);
  446. }
  447. else
  448. {
  449. tdesc = llformat("%s [%.1f]",idp->getName().c_str(),ms);
  450. }
  451. dx = (texth+4) + idp->getDepth()*8;
  453. LLColor4 color = LLColor4::white;
  454. if (idp->getDepth() > 0)
  455. {
  456. S32 line_start_y = (top + bottom) / 2;
  457. S32 line_end_y = line_start_y + ((texth + 2) * (cur_line - display_line[idp->getParent()])) - texth;
  458. gl_line_2d(x + dx - 8, line_start_y, x + dx, line_start_y, color);
  459. S32 line_x = x + (texth + 4) + ((idp->getDepth() - 1) * 8);
  460. gl_line_2d(line_x, line_start_y, line_x, line_end_y, color);
  461. if (idp->getCollapsed() && !idp->getChildren().empty())
  462. {
  463. gl_line_2d(line_x+4, line_start_y-3, line_x+4, line_start_y+4, color);
  464. }
  465. }
  467. x += dx;
  468. BOOL is_child_of_hover_item = (idp == mHoverID);
  469. LLFastTimer::NamedTimer* next_parent = idp->getParent();
  470. while(!is_child_of_hover_item && next_parent)
  471. {
  472. is_child_of_hover_item = (mHoverID == next_parent);
  473. next_parent = next_parent->getParent();
  474. }
  476. LLFontGL::getFontMonospace()->renderUTF8(tdesc, 0, 
  477. x, y, 
  478. color, 
  479. LLFontGL::LEFT, LLFontGL::TOP, 
  480. is_child_of_hover_item ? LLFontGL::BOLD : LLFontGL::NORMAL);
  482. y -= (texth + 2);
  484. textw = dx + LLFontGL::getFontMonospace()->getWidth(idp->getName()) + 40;
  486. if (idp->getCollapsed()) 
  487. {
  488. it.skipDescendants();
  489. }
  490. }
  491. }
  493. xleft += LEGEND_WIDTH + 8;
  494. // ytop = ytop;
  496. // update rectangle that includes timer bars
  497. mBarRect.mLeft = xleft;
  498. mBarRect.mRight = getRect().getWidth();
  499. mBarRect.mTop = ytop - ((S32)LLFontGL::getFontMonospace()->getLineHeight() + 4);
  500. mBarRect.mBottom = margin + LINE_GRAPH_HEIGHT;
  502. y = ytop;
  503. barh = (ytop - margin - LINE_GRAPH_HEIGHT) / (MAX_VISIBLE_HISTORY + 2);
  504. dy = barh>>2; // spacing between bars
  505. if (dy < 1) dy = 1;
  506. barh -= dy;
  507. barw = width - xleft - margin;
  509. // Draw the history bars
  510. if (LLFastTimer::getLastFrameIndex() >= 0)
  511. {
  512. LLLocalClipRect clip(LLRect(xleft, ytop, getRect().getWidth() - margin, margin));
  514. U64 totalticks;
  515. if (!LLFastTimer::sPauseHistory)
  516. {
  517. U64 ticks = LLFastTimer::NamedTimer::getRootNamedTimer().getHistoricalCount(mScrollIndex);
  519. if (LLFastTimer::getCurFrameIndex() >= 10)
  520. {
  521. U64 framec = LLFastTimer::getCurFrameIndex();
  522. U64 avg = (U64)mAvgCountTotal;
  523. mAvgCountTotal = (avg*framec + ticks) / (framec + 1);
  524. if (ticks > mMaxCountTotal)
  525. {
  526. mMaxCountTotal = ticks;
  527. }
  528. }
  530. if (ticks < mAvgCountTotal/100 || ticks > mAvgCountTotal*100)
  531. {
  532. LLFastTimer::sResetHistory = true;
  533. }
  535. if (LLFastTimer::getCurFrameIndex() < 10 || LLFastTimer::sResetHistory)
  536. {
  537. mAvgCountTotal = ticks;
  538. mMaxCountTotal = ticks;
  539. }
  540. }
  542. if (mDisplayMode == 0)
  543. {
  544. totalticks = mAvgCountTotal*2;
  545. }
  546. else if (mDisplayMode == 1)
  547. {
  548. totalticks = mMaxCountTotal;
  549. }
  550. else if (mDisplayMode == 2)
  551. {
  552. // Calculate the max total ticks for the current history
  553. totalticks = 0;
  554. for (S32 j=0; j<histmax; j++)
  555. {
  556. U64 ticks = LLFastTimer::NamedTimer::getRootNamedTimer().getHistoricalCount(j);
  558. if (ticks > totalticks)
  559. totalticks = ticks;
  560. }
  561. }
  562. else
  563. {
  564. totalticks = (U64)(clock_freq * .1); // 100 ms
  565. }
  567. // Draw MS ticks
  568. {
  569. U32 ms = (U32)((F64)totalticks * iclock_freq) ;
  571. tdesc = llformat("%.1f ms |", (F32)ms*.25f);
  572. x = xleft + barw/4 - LLFontGL::getFontMonospace()->getWidth(tdesc);
  573. LLFontGL::getFontMonospace()->renderUTF8(tdesc, 0, x, y, LLColor4::white,
  574.  LLFontGL::LEFT, LLFontGL::TOP);
  576. tdesc = llformat("%.1f ms |", (F32)ms*.50f);
  577. x = xleft + barw/2 - LLFontGL::getFontMonospace()->getWidth(tdesc);
  578. LLFontGL::getFontMonospace()->renderUTF8(tdesc, 0, x, y, LLColor4::white,
  579.  LLFontGL::LEFT, LLFontGL::TOP);
  581. tdesc = llformat("%.1f ms |", (F32)ms*.75f);
  582. x = xleft + (barw*3)/4 - LLFontGL::getFontMonospace()->getWidth(tdesc);
  583. LLFontGL::getFontMonospace()->renderUTF8(tdesc, 0, x, y, LLColor4::white,
  584.  LLFontGL::LEFT, LLFontGL::TOP);
  586. tdesc = llformat( "%d ms |", ms);
  587. x = xleft + barw - LLFontGL::getFontMonospace()->getWidth(tdesc);
  588. LLFontGL::getFontMonospace()->renderUTF8(tdesc, 0, x, y, LLColor4::white,
  589.  LLFontGL::LEFT, LLFontGL::TOP);
  590. }
  592. LLRect graph_rect;
  593. // Draw borders
  594. {
  595. gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
  596. gGL.color4f(0.5f,0.5f,0.5f,0.5f);
  598. S32 by = y + 2;
  600. y -= ((S32)LLFontGL::getFontMonospace()->getLineHeight() + 4);
  602. //heading
  603. gl_rect_2d(xleft-5, by, getRect().getWidth()-5, y+5, FALSE);
  605. //tree view
  606. gl_rect_2d(5, by, xleft-10, 5, FALSE);
  608. by = y + 5;
  609. //average bar
  610. gl_rect_2d(xleft-5, by, getRect().getWidth()-5, by-barh-dy-5, FALSE);
  612. by -= barh*2+dy;
  614. //current frame bar
  615. gl_rect_2d(xleft-5, by, getRect().getWidth()-5, by-barh-dy-2, FALSE);
  617. by -= barh+dy+1;
  619. //history bars
  620. gl_rect_2d(xleft-5, by, getRect().getWidth()-5, LINE_GRAPH_HEIGHT-barh-dy-2, FALSE);
  622. by = LINE_GRAPH_HEIGHT-barh-dy-7;
  624. //line graph
  625. graph_rect = LLRect(xleft-5, by, getRect().getWidth()-5, 5);
  627. gl_rect_2d(graph_rect, FALSE);
  628. }
  630. mBarStart.clear();
  631. mBarEnd.clear();
  633. // Draw bars for each history entry
  634. // Special: -1 = show running average
  635. gGL.getTexUnit(0)->bind(box_imagep->getImage());
  636. for (S32 j=-1; j<histmax && y > LINE_GRAPH_HEIGHT; j++)
  637. {
  638. mBarStart.push_back(std::vector<S32>());
  639. mBarEnd.push_back(std::vector<S32>());
  640. int sublevel_dx[FTV_MAX_DEPTH];
  641. int sublevel_left[FTV_MAX_DEPTH];
  642. int sublevel_right[FTV_MAX_DEPTH];
  643. S32 tidx;
  644. if (j >= 0)
  645. {
  646. tidx = LLFastTimer::NamedTimer::HISTORY_NUM - j - 1 - mScrollIndex;
  647. }
  648. else
  649. {
  650. tidx = -1;
  651. }
  653. x = xleft;
  655. // draw the bars for each stat
  656. std::vector<S32> xpos;
  657. std::vector<S32> deltax;
  658. xpos.push_back(xleft);
  660. LLFastTimer::NamedTimer* prev_id = NULL;
  662. S32 i = 0;
  663. for(timer_tree_iterator_t it = begin_timer_tree(LLFastTimer::NamedTimer::getRootNamedTimer());
  664. it != end_timer_tree();
  665. ++it, ++i)
  666. {
  667. LLFastTimer::NamedTimer* idp = (*it);
  668. F32 frac = tidx == -1
  669. ? (F32)idp->getCountAverage() / (F32)totalticks 
  670. : (F32)idp->getHistoricalCount(tidx) / (F32)totalticks;
  672. dx = llround(frac * (F32)barw);
  673. S32 prev_delta_x = deltax.empty() ? 0 : deltax.back();
  674. deltax.push_back(dx);
  676. int level = idp->getDepth() - 1;
  678. while ((S32)xpos.size() > level + 1)
  679. {
  680. xpos.pop_back();
  681. }
  682. left = xpos.back();
  684. if (level == 0)
  685. {
  686. sublevel_left[level] = xleft;
  687. sublevel_dx[level] = dx;
  688. sublevel_right[level] = sublevel_left[level] + sublevel_dx[level];
  689. }
  690. else if (prev_id && prev_id->getDepth() < idp->getDepth())
  691. {
  692. U64 sublevelticks = 0;
  694. for (LLFastTimer::NamedTimer::child_const_iter it = prev_id->beginChildren();
  695. it != prev_id->endChildren();
  696. ++it)
  697. {
  698. sublevelticks += (tidx == -1)
  699. ? (*it)->getCountAverage() 
  700. : (*it)->getHistoricalCount(tidx);
  701. }
  703. F32 subfrac = (F32)sublevelticks / (F32)totalticks;
  704. sublevel_dx[level] = (int)(subfrac * (F32)barw + .5f);
  706. if (mDisplayCenter == ALIGN_CENTER)
  707. {
  708. left += (prev_delta_x - sublevel_dx[level])/2;
  709. }
  710. else if (mDisplayCenter == ALIGN_RIGHT)
  711. {
  712. left += (prev_delta_x - sublevel_dx[level]);
  713. }
  715. sublevel_left[level] = left;
  716. sublevel_right[level] = sublevel_left[level] + sublevel_dx[level];
  717. }
  719. right = left + dx;
  720. xpos.back() = right;
  721. xpos.push_back(left);
  723. mBarStart.back().push_back(left);
  724. mBarEnd.back().push_back(right);
  726. top = y;
  727. bottom = y - barh;
  729. if (right > left)
  730. {
  731. //U32 rounded_edges = 0;
  732. LLColor4 color = sTimerColors[idp];//*ft_display_table[i].color;
  733. S32 scale_offset = 0;
  735. BOOL is_child_of_hover_item = (idp == mHoverID);
  736. LLFastTimer::NamedTimer* next_parent = idp->getParent();
  737. while(!is_child_of_hover_item && next_parent)
  738. {
  739. is_child_of_hover_item = (mHoverID == next_parent);
  740. next_parent = next_parent->getParent();
  741. }
  743. if (idp == mHoverID)
  744. {
  745. scale_offset = llfloor(sinf(mHighlightTimer.getElapsedTimeF32() * 6.f) * 3.f);
  746. //color = lerp(color, LLColor4::black, -0.4f);
  747. }
  748. else if (mHoverID != NULL && !is_child_of_hover_item)
  749. {
  750. color = lerp(color, LLColor4::grey, 0.8f);
  751. }
  753. gGL.color4fv(color.mV);
  754. F32 start_fragment = llclamp((F32)(left - sublevel_left[level]) / (F32)sublevel_dx[level], 0.f, 1.f);
  755. F32 end_fragment = llclamp((F32)(right - sublevel_left[level]) / (F32)sublevel_dx[level], 0.f, 1.f);
  756. gl_segmented_rect_2d_fragment_tex(sublevel_left[level], top - level + scale_offset, sublevel_right[level], bottom + level - scale_offset, box_imagep->getTextureWidth(), box_imagep->getTextureHeight(), 16, start_fragment, end_fragment);
  758. }
  760. if ((*it)->getCollapsed())
  761. {
  762. it.skipDescendants();
  763. }
  765. prev_id = idp;
  766. }
  767. y -= (barh + dy);
  768. if (j < 0)
  769. y -= barh;
  770. }
  772. //draw line graph history
  773. {
  774. gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
  775. LLLocalClipRect clip(graph_rect);
  777. //normalize based on last frame's maximum
  778. static U64 last_max = 0;
  779. static F32 alpha_interp = 0.f;
  780. U64 max_ticks = llmax(last_max, (U64) 1);
  781. F32 ms = (F32)((F64)max_ticks * iclock_freq);
  783. //display y-axis range
  784. std::string tdesc;
  785.  if (mDisplayCalls)
  786. tdesc = llformat("%d calls", (int)max_ticks);
  787. else if (mDisplayHz)
  788. tdesc = llformat("%d Hz", (int)max_ticks);
  789. else
  790. tdesc = llformat("%4.2f ms", ms);
  792. x = graph_rect.mRight - LLFontGL::getFontMonospace()->getWidth(tdesc)-5;
  793. y = graph_rect.mTop - ((S32)LLFontGL::getFontMonospace()->getLineHeight());
  794.  
  795. LLFontGL::getFontMonospace()->renderUTF8(tdesc, 0, x, y, LLColor4::white,
  796.  LLFontGL::LEFT, LLFontGL::TOP);
  798. //highlight visible range
  799. {
  800. S32 first_frame = LLFastTimer::NamedTimer::HISTORY_NUM - mScrollIndex;
  801. S32 last_frame = first_frame - MAX_VISIBLE_HISTORY;
  803. F32 frame_delta = ((F32) (graph_rect.getWidth()))/(LLFastTimer::NamedTimer::HISTORY_NUM-1);
  805. F32 right = (F32) graph_rect.mLeft + frame_delta*first_frame;
  806. F32 left = (F32) graph_rect.mLeft + frame_delta*last_frame;
  808. gGL.color4f(0.5f,0.5f,0.5f,0.3f);
  809. gl_rect_2d((S32) left, graph_rect.mTop, (S32) right, graph_rect.mBottom);
  811. if (mHoverBarIndex >= 0)
  812. {
  813. S32 bar_frame = first_frame - mHoverBarIndex;
  814. F32 bar = (F32) graph_rect.mLeft + frame_delta*bar_frame;
  816. gGL.color4f(0.5f,0.5f,0.5f,1);
  818. gGL.begin(LLRender::LINES);
  819. gGL.vertex2i((S32)bar, graph_rect.mBottom);
  820. gGL.vertex2i((S32)bar, graph_rect.mTop);
  821. gGL.end();
  822. }
  823. }
  825. U64 cur_max = 0;
  826. for(timer_tree_iterator_t it = begin_timer_tree(LLFastTimer::NamedTimer::getRootNamedTimer());
  827. it != end_timer_tree();
  828. ++it)
  829. {
  830. LLFastTimer::NamedTimer* idp = (*it);
  832. //fatten highlighted timer
  833. if (mHoverID == idp)
  834. {
  835. gGL.flush();
  836. glLineWidth(3);
  837. }
  839. const F32 * col = sTimerColors[idp].mV;// ft_display_table[idx].color->mV;
  841. F32 alpha = 1.f;
  843. if (mHoverID != NULL &&
  844. idp != mHoverID)
  845. { //fade out non-hihglighted timers
  846. if (idp->getParent() != mHoverID)
  847. {
  848. alpha = alpha_interp;
  849. }
  850. }
  852. gGL.color4f(col[0], col[1], col[2], alpha);
  853. gGL.begin(LLRender::LINE_STRIP);
  854. for (U32 j = 0; j < LLFastTimer::NamedTimer::HISTORY_NUM; j++)
  855. {
  856. U64 ticks = idp->getHistoricalCount(j);
  858. if (mDisplayHz)
  859. {
  860. F64 tc = (F64) (ticks+1) * iclock_freq;
  861. tc = 1000.f/tc;
  862. ticks = llmin((U64) tc, (U64) 1024);
  863. }
  864. else if (mDisplayCalls)
  865. {
  866. ticks = (S32)idp->getHistoricalCalls(j);
  867. }
  869. if (alpha == 1.f)
  870. { 
  871. //normalize to highlighted timer
  872. cur_max = llmax(cur_max, ticks);
  873. }
  874. F32 x = graph_rect.mLeft + ((F32) (graph_rect.getWidth()))/(LLFastTimer::NamedTimer::HISTORY_NUM-1)*j;
  875. F32 y = graph_rect.mBottom + (F32) graph_rect.getHeight()/max_ticks*ticks;
  876. gGL.vertex2f(x,y);
  877. }
  878. gGL.end();
  880. if (mHoverID == idp)
  881. {
  882. gGL.flush();
  883. glLineWidth(1);
  884. }
  886. if (idp->getCollapsed())
  887. {
  888. //skip hidden timers
  889. it.skipDescendants();
  890. }
  891. }
  893. //interpolate towards new maximum
  894. F32 dt = gFrameIntervalSeconds*3.f;
  895. last_max = (U64) ((F32) last_max + ((F32) cur_max- (F32) last_max) * dt);
  896. F32 alpha_target = last_max > cur_max ?
  897. llmin((F32) last_max/ (F32) cur_max - 1.f,1.f) :
  898. llmin((F32) cur_max/ (F32) last_max - 1.f,1.f);
  900. alpha_interp = alpha_interp + (alpha_target-alpha_interp) * dt;
  902. if (mHoverID != NULL)
  903. {
  904. x = (graph_rect.mRight + graph_rect.mLeft)/2;
  905. y = graph_rect.mBottom + 8;
  907. LLFontGL::getFontMonospace()->renderUTF8(
  908. mHoverID->getName(), 
  909. 0, 
  910. x, y, 
  911. LLColor4::white,
  912. LLFontGL::LEFT, LLFontGL::BOTTOM);
  913. }
  914. }
  915. }
  917. // Output stats for clicked bar to log
  918. if (mPrintStats >= 0)
  919. {
  920. std::string legend_stat;
  921. bool first = true;
  922. for(timer_tree_iterator_t it = begin_timer_tree(LLFastTimer::NamedTimer::getRootNamedTimer());
  923. it != end_timer_tree();
  924. ++it)
  925. {
  926. LLFastTimer::NamedTimer* idp = (*it);
  928. if (!first)
  929. {
  930. legend_stat += ", ";
  931. }
  932. first = true;
  933. legend_stat += idp->getName();
  935. if (idp->getCollapsed())
  936. {
  937. it.skipDescendants();
  938. }
  939. }
  940. llinfos << legend_stat << llendl;
  942. std::string timer_stat;
  943. first = true;
  944. for(timer_tree_iterator_t it = begin_timer_tree(LLFastTimer::NamedTimer::getRootNamedTimer());
  945. it != end_timer_tree();
  946. ++it)
  947. {
  948. LLFastTimer::NamedTimer* idp = (*it);
  950. if (!first)
  951. {
  952. timer_stat += ", ";
  953. }
  954. first = false;
  956. U64 ticks;
  957. if (mPrintStats > 0)
  958. {
  959. S32 hidx = (mPrintStats - 1) - mScrollIndex;
  960. ticks = idp->getHistoricalCount(hidx);
  961. }
  962. else
  963. {
  964. ticks = idp->getCountAverage();
  965. }
  966. F32 ms = (F32)((F64)ticks * iclock_freq);
  968. timer_stat += llformat("%.1f",ms);
  970. if (idp->getCollapsed())
  971. {
  972. it.skipDescendants();
  973. }
  974. }
  975. llinfos << timer_stat << llendl;
  976. mPrintStats = -1;
  977. }
  979. mHoverID = NULL;
  980. mHoverBarIndex = -1;
  982. LLView::draw();
  983. }
  985. F64 LLFastTimerView::getTime(const std::string& name)
  986. {
  987. const LLFastTimer::NamedTimer* timerp = LLFastTimer::getTimerByName(name);
  988. if (timerp)
  989. {
  990. return (F64)timerp->getCountAverage() / (F64)LLFastTimer::countsPerSecond();
  991. }
  992. return 0.0;
  993. }
  995. //static
  996. LLSD LLFastTimerView::analyzePerformanceLogDefault(std::istream& is)
  997. {
  998. LLSD ret;
  1000. LLSD cur;
  1002. LLSD::Real total_time = 0.0;
  1003. LLSD::Integer total_frames = 0;
  1005. while (!is.eof() && LLSDSerialize::fromXML(cur, is))
  1006. {
  1007. for (LLSD::map_iterator iter = cur.beginMap(); iter != cur.endMap(); ++iter)
  1008. {
  1009. std::string label = iter->first;
  1011. F64 time = iter->second["Time"].asReal();
  1013. // Skip the total figure
  1014. if(label.compare("Total") != 0)
  1015. {
  1016. total_time += time;
  1017. }
  1019. if (time > 0.0)
  1020. {
  1021. ret[label]["TotalTime"] = ret[label]["TotalTime"].asReal() + time;
  1022. ret[label]["MaxTime"] = llmax(time, ret[label]["MaxTime"].asReal());
  1024. if (ret[label]["MinTime"].asReal() == 0)
  1025. {
  1026. ret[label]["MinTime"] = time;
  1027. }
  1028. else
  1029. {
  1030. ret[label]["MinTime"] = llmin(ret[label]["MinTime"].asReal(), time);
  1031. }
  1033. LLSD::Integer samples = iter->second["Calls"].asInteger();
  1035. ret[label]["Samples"] = ret[label]["Samples"].asInteger() + samples;
  1036. ret[label]["MaxSamples"] = llmax(ret[label]["MaxSamples"].asInteger(), samples);
  1038. if (ret[label]["MinSamples"].asInteger() == 0)
  1039. {
  1040. ret[label]["MinSamples"] = samples;
  1041. }
  1042. else
  1043. {
  1044. ret[label]["MinSamples"] = llmin(ret[label]["MinSamples"].asInteger(), samples);
  1045. }
  1046. }
  1047. }
  1048. total_frames++;
  1049. }
  1051. ret["SessionTime"] = total_time;
  1052. ret["FrameCount"] = total_frames;
  1054. return ret;
  1056. }
  1058. //static
  1059. void LLFastTimerView::doAnalysisDefault(std::string baseline, std::string target, std::string output)
  1060. {
  1062. //analyze baseline
  1063. std::ifstream base_is(baseline.c_str());
  1064. LLSD base = analyzePerformanceLogDefault(base_is);
  1065. base_is.close();
  1067. //analyze current
  1068. std::ifstream target_is(target.c_str());
  1069. LLSD current = analyzePerformanceLogDefault(target_is);
  1070. target_is.close();
  1072. //output comparision
  1073. std::ofstream os(output.c_str());
  1075. LLSD::Real session_time = current["SessionTime"].asReal();
  1077. os << "Label, % Change, % of Session, Cur Min, Cur Max, Cur Mean, Cur Total, Cur Samples, Base Min, Base Max, Base Mean, Base Total, Base Samplesn"; 
  1078. for (LLSD::map_iterator iter = base.beginMap();  iter != base.endMap(); ++iter)
  1079. {
  1080. LLSD::String label = iter->first;
  1082. if (current[label]["Samples"].asInteger() == 0 ||
  1083. base[label]["Samples"].asInteger() == 0)
  1084. {
  1085. //cannot compare
  1086. continue;
  1087. }
  1088. LLSD::Real a = base[label]["TotalTime"].asReal() / base[label]["Samples"].asReal();
  1089. LLSD::Real b = current[label]["TotalTime"].asReal() / base[label]["Samples"].asReal();
  1091. LLSD::Real diff = b-a;
  1093. LLSD::Real perc = diff/a * 100;
  1095. os << llformat("%s, %.2f, %.4f, %.4f, %.4f, %.4f, %.4f, %d, %.4f, %.4f, %.4f, %.4f, %dn",
  1096. label.c_str(), 
  1097. (F32) perc, 
  1098. (F32) (current[label]["TotalTime"].asReal()/session_time * 100.0), 
  1099. (F32) current[label]["MinTime"].asReal(), 
  1100. (F32) current[label]["MaxTime"].asReal(), 
  1101. (F32) b, 
  1102. (F32) current[label]["TotalTime"].asReal(), 
  1103. current[label]["Samples"].asInteger(),
  1104. (F32) base[label]["MinTime"].asReal(), 
  1105. (F32) base[label]["MaxTime"].asReal(), 
  1106. (F32) a, 
  1107. (F32) base[label]["TotalTime"].asReal(), 
  1108. base[label]["Samples"].asInteger());
  1109. }
  1112. os.flush();
  1113. os.close();
  1114. }
  1116. //-------------------------
  1117. //static
  1118. LLSD LLFastTimerView::analyzeMetricPerformanceLog(std::istream& is)
  1119. {
  1120. LLSD ret;
  1121. LLSD cur;
  1123. while (!is.eof() && LLSDSerialize::fromXML(cur, is))
  1124. {
  1125. for (LLSD::map_iterator iter = cur.beginMap(); iter != cur.endMap(); ++iter)
  1126. {
  1127. std::string label = iter->first;
  1129. LLMetricPerformanceTester* tester = LLMetricPerformanceTester::getTester(iter->second["Name"].asString()) ;
  1130. if(tester)
  1131. {
  1132. ret[label]["Name"] = iter->second["Name"] ;
  1134. S32 num_of_strings = tester->getNumOfMetricStrings() ;
  1135. for(S32 index = 0 ; index < num_of_strings ; index++)
  1136. {
  1137. ret[label][ tester->getMetricString(index) ] = iter->second[ tester->getMetricString(index) ] ;
  1138. }
  1139. }
  1140. }
  1141. }
  1143. return ret;
  1144. }
  1146. //static
  1147. void LLFastTimerView::doAnalysisMetrics(std::string baseline, std::string target, std::string output)
  1148. {
  1149. if(!LLMetricPerformanceTester::hasMetricPerformanceTesters())
  1150. {
  1151. return ;
  1152. }
  1154. //analyze baseline
  1155. std::ifstream base_is(baseline.c_str());
  1156. LLSD base = analyzeMetricPerformanceLog(base_is);
  1157. base_is.close();
  1159. //analyze current
  1160. std::ifstream target_is(target.c_str());
  1161. LLSD current = analyzeMetricPerformanceLog(target_is);
  1162. target_is.close();
  1164. //output comparision
  1165. std::ofstream os(output.c_str());
  1167. os << "Label, Metric, Base(B), Target(T), Diff(T-B), Percentage(100*T/B)n"; 
  1168. for(LLMetricPerformanceTester::name_tester_map_t::iterator iter = LLMetricPerformanceTester::sTesterMap.begin() ; 
  1169. iter != LLMetricPerformanceTester::sTesterMap.end() ; ++iter)
  1170. {
  1171. LLMetricPerformanceTester* tester = ((LLMetricPerformanceTester*)iter->second) ;
  1172. tester->analyzePerformance(&os, &base, &current) ;
  1173. }
  1175. os.flush();
  1176. os.close();
  1177. }
  1179. //static
  1180. void LLFastTimerView::doAnalysis(std::string baseline, std::string target, std::string output)
  1181. {
  1182. if(LLFastTimer::sLog)
  1183. {
  1184. doAnalysisDefault(baseline, target, output) ;
  1185. return ;
  1186. }
  1188. if(LLFastTimer::sMetricLog)
  1189. {
  1190. doAnalysisMetrics(baseline, target, output) ;
  1191. return ;
  1192. }
  1193. }