DXR is a code search and navigation tool aimed at making sense of large projects. It supports full-text and regex searches as well as structural queries.

Implementation

Mercurial (409f3966645a)

VCS Links

Line Code
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#ifndef mozilla_gfx_layers_composite_Diagnostics_h
#define mozilla_gfx_layers_composite_Diagnostics_h

#include "FPSCounter.h"
#include "gfxPrefs.h"
#include "mozilla/Maybe.h"
#include "mozilla/TimeStamp.h"
#include <deque>
#include <string>
#include <utility>

namespace mozilla {
namespace layers {

class PaintTiming;

class TimedMetric
{
  typedef std::pair<float, TimeStamp> Entry;

public:
  void Add(float aValue) {
    if (mHistory.size() > kMaxHistory) {
      mHistory.pop_front();
    }
    mHistory.push_back(Entry(aValue, TimeStamp::Now()));
  }

  float Average() const;
  bool Empty() const {
    return mHistory.empty();
  }

private:
  static const size_t kMaxHistory = 60;

  std::deque<Entry> mHistory;
};

// These statistics are collected by layers backends, preferably by the GPU
struct GPUStats
{
  GPUStats()
   : mInvalidPixels(0),
     mScreenPixels(0),
     mPixelsFilled(0)
  {}

  uint32_t mInvalidPixels;
  uint32_t mScreenPixels;
  uint32_t mPixelsFilled;
  Maybe<float> mDrawTime;
};

// Collects various diagnostics about layers performance.
class Diagnostics
{
public:
  Diagnostics();

  void RecordPaintTimes(const PaintTiming& aPaintTimes);
  void RecordUpdateTime(float aValue) {
    mUpdateMs.Add(aValue);
  }
  void RecordPrepareTime(float aValue) {
    mPrepareMs.Add(aValue);
  }
  void RecordCompositeTime(float aValue) {
    mCompositeMs.Add(aValue);
  }
  void AddTxnFrame() {
    mTransactionFps.AddFrame(TimeStamp::Now());
  }

  std::string GetFrameOverlayString(const GPUStats& aStats);

  class Record {
  public:
    explicit Record(TimeStamp aStart = TimeStamp()) {
      if (gfxPrefs::LayersDrawFPS()) {
        mStart = aStart.IsNull() ? TimeStamp::Now() : aStart;
      }
    }
    bool Recording() const {
      return !mStart.IsNull();
    }
    float Duration() const {
      return (TimeStamp::Now() - mStart).ToMilliseconds();
    }

  private:
    TimeStamp mStart;
  };

private:
  FPSCounter mCompositeFps;
  FPSCounter mTransactionFps;
  TimedMetric mDlbMs;
  TimedMetric mDlb2Ms;
  TimedMetric mFlbMs;
  TimedMetric mRasterMs;
  TimedMetric mSerializeMs;
  TimedMetric mSendMs;
  TimedMetric mUpdateMs;
  TimedMetric mPrepareMs;
  TimedMetric mCompositeMs;
  TimedMetric mGPUDrawMs;
};

} // namespace layers
} // namespace mozilla

#endif // mozilla_gfx_layers_composite_Diagnostics_h