cc/overdraw_metrics.cc

   1 // Copyright 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "cc/overdraw_metrics.h"
   6
   7 #include "base/debug/trace_event.h"
   8 #include "base/metrics/histogram.h"
   9 #include "cc/layer_tree_host.h"
  10 #include "cc/layer_tree_host_impl.h"
  11 #include "cc/math_util.h"
  12 #include "ui/gfx/quad_f.h"
  13 #include "ui/gfx/rect.h"
  14 #include "ui/gfx/transform.h"
  15
  16 namespace cc {
  17
  18 OverdrawMetrics::OverdrawMetrics(bool recordMetricsForFrame)
  19     : m_recordMetricsForFrame(recordMetricsForFrame)
  20     , m_pixelsPainted(0)
  21     , m_pixelsUploadedOpaque(0)
  22     , m_pixelsUploadedTranslucent(0)
  23     , m_tilesCulledForUpload(0)
  24     , m_contentsTextureUseBytes(0)
  25     , m_renderSurfaceTextureUseBytes(0)
  26     , m_pixelsDrawnOpaque(0)
  27     , m_pixelsDrawnTranslucent(0)
  28     , m_pixelsCulledForDrawing(0)
  29 {
  30 }
  31
  32 static inline float wedgeProduct(const gfx::PointF& p1, const gfx::PointF& p2)
  33 {
  34     return p1.x() * p2.y() - p1.y() * p2.x();
  35 }
  36
  37 // Calculates area of an arbitrary convex polygon with up to 8 points.
  38 static inline float polygonArea(const gfx::PointF points[8], int numPoints)
  39 {
  40     if (numPoints < 3)
  41         return 0;
  42
  43     float area = 0;
  44     for (int i = 0; i < numPoints; ++i)
  45         area += wedgeProduct(points[i], points[(i+1)%numPoints]);
  46     return fabs(0.5f * area);
  47 }
  48
  49 // Takes a given quad, maps it by the given transformation, and gives the area of the resulting polygon.
  50 static inline float areaOfMappedQuad(const gfx::Transform& transform, const gfx::QuadF& quad)
  51 {
  52     gfx::PointF clippedQuad[8];
  53     int numVerticesInClippedQuad = 0;
  54     MathUtil::mapClippedQuad(transform, quad, clippedQuad, numVerticesInClippedQuad);
  55     return polygonArea(clippedQuad, numVerticesInClippedQuad);
  56 }
  57
  58 void OverdrawMetrics::didPaint(const gfx::Rect& paintedRect)
  59 {
  60     if (!m_recordMetricsForFrame)
  61         return;
  62
  63     m_pixelsPainted += static_cast<float>(paintedRect.width()) * paintedRect.height();
  64 }
  65
  66 void OverdrawMetrics::didCullTilesForUpload(int count)
  67 {
  68     if (m_recordMetricsForFrame)
  69         m_tilesCulledForUpload += count;
  70 }
  71
  72 void OverdrawMetrics::didUpload(const gfx::Transform& transformToTarget, const gfx::Rect& uploadRect, const gfx::Rect& opaqueRect)
  73 {
  74     if (!m_recordMetricsForFrame)
  75         return;
  76
  77     float uploadArea = areaOfMappedQuad(transformToTarget, gfx::QuadF(uploadRect));
  78     float uploadOpaqueArea = areaOfMappedQuad(transformToTarget, gfx::QuadF(gfx::IntersectRects(opaqueRect, uploadRect)));
  79
  80     m_pixelsUploadedOpaque += uploadOpaqueArea;
  81     m_pixelsUploadedTranslucent += uploadArea - uploadOpaqueArea;
  82 }
  83
  84 void OverdrawMetrics::didUseContentsTextureMemoryBytes(size_t contentsTextureUseBytes)
  85 {
  86     if (!m_recordMetricsForFrame)
  87         return;
  88
  89     m_contentsTextureUseBytes += contentsTextureUseBytes;
  90 }
  91
  92 void OverdrawMetrics::didUseRenderSurfaceTextureMemoryBytes(size_t renderSurfaceUseBytes)
  93 {
  94     if (!m_recordMetricsForFrame)
  95         return;
  96
  97     m_renderSurfaceTextureUseBytes += renderSurfaceUseBytes;
  98 }
  99
 100 void OverdrawMetrics::didCullForDrawing(const gfx::Transform& transformToTarget, const gfx::Rect& beforeCullRect, const gfx::Rect& afterCullRect)
 101 {
 102     if (!m_recordMetricsForFrame)
 103         return;
 104
 105     float beforeCullArea = areaOfMappedQuad(transformToTarget, gfx::QuadF(beforeCullRect));
 106     float afterCullArea = areaOfMappedQuad(transformToTarget, gfx::QuadF(afterCullRect));
 107
 108     m_pixelsCulledForDrawing += beforeCullArea - afterCullArea;
 109 }
 110
 111 void OverdrawMetrics::didDraw(const gfx::Transform& transformToTarget, const gfx::Rect& afterCullRect, const gfx::Rect& opaqueRect)
 112 {
 113     if (!m_recordMetricsForFrame)
 114         return;
 115
 116     float afterCullArea = areaOfMappedQuad(transformToTarget, gfx::QuadF(afterCullRect));
 117     float afterCullOpaqueArea = areaOfMappedQuad(transformToTarget, gfx::QuadF(gfx::IntersectRects(opaqueRect, afterCullRect)));
 118
 119     m_pixelsDrawnOpaque += afterCullOpaqueArea;
 120     m_pixelsDrawnTranslucent += afterCullArea - afterCullOpaqueArea;
 121 }
 122
 123 void OverdrawMetrics::recordMetrics(const LayerTreeHost* layerTreeHost) const
 124 {
 125     if (m_recordMetricsForFrame)
 126         recordMetricsInternal<LayerTreeHost>(UpdateAndCommit, layerTreeHost);
 127 }
 128
 129 void OverdrawMetrics::recordMetrics(const LayerTreeHostImpl* layerTreeHost) const
 130 {
 131     if (m_recordMetricsForFrame)
 132         recordMetricsInternal<LayerTreeHostImpl>(DrawingToScreen, layerTreeHost);
 133 }
 134
 135 template<typename LayerTreeHostType>
 136 void OverdrawMetrics::recordMetricsInternal(MetricsType metricsType, const LayerTreeHostType* layerTreeHost) const
 137 {
 138     // This gives approximately 10x the percentage of pixels to fill the viewport once.
 139     float normalization = 1000.f / (layerTreeHost->deviceViewportSize().width() * layerTreeHost->deviceViewportSize().height());
 140     // This gives approximately 100x the percentage of tiles to fill the viewport once, if all tiles were 256x256.
 141     float tileNormalization = 10000.f / (layerTreeHost->deviceViewportSize().width() / 256.f * layerTreeHost->deviceViewportSize().height() / 256.f);
 142     // This gives approximately 10x the percentage of bytes to fill the viewport once, assuming 4 bytes per pixel.
 143     float byteNormalization = normalization / 4;
 144
 145     switch (metricsType) {
 146     case DrawingToScreen: {
 147         UMA_HISTOGRAM_CUSTOM_COUNTS(
 148             "Renderer4.pixelCountOpaque_Draw",
 149             static_cast<int>(normalization * m_pixelsDrawnOpaque),
 150             100, 1000000, 50);
 151         UMA_HISTOGRAM_CUSTOM_COUNTS(
 152             "Renderer4.pixelCountTranslucent_Draw",
 153             static_cast<int>(normalization * m_pixelsDrawnTranslucent),
 154             100, 1000000, 50);
 155         UMA_HISTOGRAM_CUSTOM_COUNTS(
 156             "Renderer4.pixelCountCulled_Draw",
 157             static_cast<int>(normalization * m_pixelsCulledForDrawing),
 158             100, 1000000, 50);
 159
 160         TRACE_COUNTER_ID1("cc", "DrawPixelsCulled", layerTreeHost, m_pixelsCulledForDrawing);
 161         TRACE_EVENT2("cc", "OverdrawMetrics", "PixelsDrawnOpaque", m_pixelsDrawnOpaque, "PixelsDrawnTranslucent", m_pixelsDrawnTranslucent);
 162         break;
 163     }
 164     case UpdateAndCommit: {
 165         UMA_HISTOGRAM_CUSTOM_COUNTS(
 166             "Renderer4.pixelCountPainted",
 167             static_cast<int>(normalization * m_pixelsPainted),
 168             100, 1000000, 50);
 169         UMA_HISTOGRAM_CUSTOM_COUNTS(
 170             "Renderer4.pixelCountOpaque_Upload",
 171             static_cast<int>(normalization * m_pixelsUploadedOpaque),
 172             100, 1000000, 50);
 173         UMA_HISTOGRAM_CUSTOM_COUNTS(
 174             "Renderer4.pixelCountTranslucent_Upload",
 175             static_cast<int>(normalization * m_pixelsUploadedTranslucent),
 176             100, 1000000, 50);
 177         UMA_HISTOGRAM_CUSTOM_COUNTS(
 178             "Renderer4.tileCountCulled_Upload",
 179             static_cast<int>(tileNormalization * m_tilesCulledForUpload),
 180             100, 10000000, 50);
 181         UMA_HISTOGRAM_CUSTOM_COUNTS(
 182             "Renderer4.renderSurfaceTextureBytes_ViewportScaled",
 183             static_cast<int>(
 184                 byteNormalization * m_renderSurfaceTextureUseBytes),
 185             10, 1000000, 50);
 186         UMA_HISTOGRAM_CUSTOM_COUNTS(
 187             "Renderer4.renderSurfaceTextureBytes_Unscaled",
 188             static_cast<int>(m_renderSurfaceTextureUseBytes / 1000),
 189             1000, 100000000, 50);
 190         UMA_HISTOGRAM_CUSTOM_COUNTS(
 191             "Renderer4.contentsTextureBytes_ViewportScaled",
 192             static_cast<int>(byteNormalization * m_contentsTextureUseBytes),
 193             10, 1000000, 50);
 194         UMA_HISTOGRAM_CUSTOM_COUNTS(
 195             "Renderer4.contentsTextureBytes_Unscaled",
 196             static_cast<int>(m_contentsTextureUseBytes / 1000),
 197             1000, 100000000, 50);
 198
 199         {
 200             TRACE_COUNTER_ID1("cc", "UploadTilesCulled", layerTreeHost, m_tilesCulledForUpload);
 201             TRACE_EVENT2("cc", "OverdrawMetrics", "PixelsUploadedOpaque", m_pixelsUploadedOpaque, "PixelsUploadedTranslucent", m_pixelsUploadedTranslucent);
 202         }
 203         {
 204             // This must be in a different scope than the TRACE_EVENT2 above.
 205             TRACE_EVENT1("cc", "OverdrawPaintMetrics", "PixelsPainted", m_pixelsPainted);
 206         }
 207         {
 208             // This must be in a different scope than the TRACE_EVENTs above.
 209             TRACE_EVENT2("cc", "OverdrawPaintMetrics", "ContentsTextureBytes", m_contentsTextureUseBytes, "RenderSurfaceTextureBytes", m_renderSurfaceTextureUseBytes);
 210         }
 211         break;
 212     }
 213     }
 214 }
 215
 216 }  // namespace cc