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
  120
  121
  122
  123
  124
  125
  126
  127
  128
  129
  130
  131
  132


cc / metrics / latency_ukm_reporter.cc [blame]

// Copyright 2019 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "cc/metrics/latency_ukm_reporter.h"

#include <climits>
#include <memory>
#include <utility>

#include "base/rand_util.h"
#include "cc/metrics/ukm_manager.h"
#include "services/metrics/public/cpp/ukm_recorder.h"

namespace cc {

// We use a Poisson process with an exponential decay multiplier. The goal is to
// get many randomly distributed samples early during page load and initial
// interaction, then samples at an exponentially decreasing rate to effectively
// cap the number of samples. The particular parameters chosen here give roughly
// 5-10 samples in the first 100 frames, decaying to several hours between
// samples by the 40th sample. The multiplier value should be tuned to achieve a
// total sample count that avoids throttling by the UKM system.
class LatencyUkmReporter::SamplingController {
 public:
  SamplingController() = default;
  ~SamplingController() = default;

  // When a new UKM event is issued, this function should be called (once and
  // only once) by the client to determine whether that event should be recorded
  // or ignored, according to the sampling parameters. The sampling state will
  // be updated to be ready for the next UKM event.
  bool ShouldRecordNextEvent() {
    bool should_record = false;
    if (!frames_to_next_event_) {
      should_record = true;
      frames_to_next_event_ = SampleFramesToNextEvent();
    }
    DCHECK_GT(frames_to_next_event_, 0);
    --frames_to_next_event_;
    return should_record;
  }

 private:
  // The |kSampleRateMultiplier| and |kSampleDecayRate| have been set to meet
  // UKM goals for data volume.
  const double kSampleDecayRate = 1.0;
  const double kSampleRateMultiplier = 2.0;

  int SampleFramesToNextEvent() {
    // Sample from an exponential distribution to give a Poisson distribution
    // of samples per time unit, then weigh it with an exponential multiplier
    // to give a few samples in rapid succession (for frames early in the
    // page's life) then exponentially fewer as the page lives longer.
    // RandDouble() returns [0,1), but we need (0,1]. If RandDouble() is
    // uniformly random, so is 1-RandDouble(), so use it to adjust the range.
    // When RandDouble() returns 0.0, as it could, we will get a float_sample
    // of 0, causing underflow. So rejection sample until we get a positive
    // count.
    double float_sample = 0.0;
    do {
      float_sample = -(kSampleRateMultiplier *
                       std::exp(samples_so_far_ * kSampleDecayRate) *
                       std::log(1.0 - base::RandDouble()));
    } while (float_sample == 0.0);
    // float_sample is positive, so we don't need to worry about underflow.
    // After around 30 samples we will end up with a super high sample. That's
    // OK because it just means we'll stop reporting metrics for that session,
    // but we do need to be careful about overflow and NaN.
    samples_so_far_++;
    int integer_sample =
        std::isnan(float_sample)
            ? INT_MAX
            : base::saturated_cast<int>(std::ceil(float_sample));
    return integer_sample;
  }

  int samples_so_far_ = 0;
  int frames_to_next_event_ = 0;
};

LatencyUkmReporter::LatencyUkmReporter()
    : compositor_latency_sampling_controller_(
          std::make_unique<SamplingController>()),
      event_latency_sampling_controller_(
          std::make_unique<SamplingController>()) {}

LatencyUkmReporter::~LatencyUkmReporter() = default;

void LatencyUkmReporter::ReportCompositorLatencyUkm(
    const CompositorFrameReporter::FrameReportTypes& report_types,
    const std::vector<CompositorFrameReporter::StageData>& stage_history,
    const ActiveTrackers& active_trackers,
    const CompositorFrameReporter::ProcessedBlinkBreakdown&
        processed_blink_breakdown,
    const CompositorFrameReporter::ProcessedVizBreakdown&
        processed_viz_breakdown) {
  if (ukm_manager_ &&
      compositor_latency_sampling_controller_->ShouldRecordNextEvent()) {
    ukm_manager_->RecordCompositorLatencyUKM(
        report_types, stage_history, active_trackers, processed_blink_breakdown,
        processed_viz_breakdown);
  }
}

void LatencyUkmReporter::ReportEventLatencyUkm(
    const EventMetrics::List& events_metrics,
    const std::vector<CompositorFrameReporter::StageData>& stage_history,
    const CompositorFrameReporter::ProcessedBlinkBreakdown&
        processed_blink_breakdown,
    const CompositorFrameReporter::ProcessedVizBreakdown&
        processed_viz_breakdown) {
  if (ukm_manager_ &&
      event_latency_sampling_controller_->ShouldRecordNextEvent()) {
    ukm_manager_->RecordEventLatencyUKM(events_metrics, stage_history,
                                        processed_blink_breakdown,
                                        processed_viz_breakdown);
  }
}

void LatencyUkmReporter::InitializeUkmManager(
    std::unique_ptr<ukm::UkmRecorder> recorder) {
  ukm_manager_ = std::make_unique<UkmManager>(std::move(recorder));
}

void LatencyUkmReporter::SetSourceId(ukm::SourceId source_id) {
  if (ukm_manager_) {
    ukm_manager_->SetSourceId(source_id);
  }
}

}  // namespace cc