| // Copyright 2023 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/scroll_jank_dropped_frame_tracker.h" |
| |
| #include <algorithm> |
| |
| #include "base/metrics/histogram_functions.h" |
| #include "base/metrics/histogram_macros.h" |
| #include "base/notreached.h" |
| #include "base/strings/strcat.h" |
| #include "base/trace_event/common/trace_event_common.h" |
| #include "base/trace_event/trace_event.h" |
| #include "base/trace_event/trace_id_helper.h" |
| #include "base/trace_event/typed_macros.h" |
| |
| namespace cc { |
| |
| namespace { |
| enum class PerScrollHistogramType { |
| // For Event.ScrollJank.DelayedFramesPercentage.PerScroll.* histograms. |
| kPercentage = 0, |
| // For Event.ScrollJank.MissedVsyncsMax.PerScroll.* histograms. |
| kMax = 1, |
| // For Event.ScrollJank.MissedVsyncsSum.PerScroll.* histograms. |
| kSum = 2, |
| }; |
| |
| // Histogram min, max and no. of buckets. |
| constexpr int kVsyncCountsMin = 1; |
| constexpr int kVsyncCountsMax = 50; |
| constexpr int kVsyncCountsBuckets = 25; |
| |
| const char* GetPerScrollHistogramName(int num_frames, |
| PerScrollHistogramType type) { |
| DCHECK_GT(num_frames, 0); |
| if (type == PerScrollHistogramType::kPercentage) { |
| if (num_frames <= 16) { |
| return "Event.ScrollJank.DelayedFramesPercentage.PerScroll.Small"; |
| } else if (num_frames <= 64) { |
| return "Event.ScrollJank.DelayedFramesPercentage.PerScroll.Medium"; |
| } else { |
| return "Event.ScrollJank.DelayedFramesPercentage.PerScroll.Large"; |
| } |
| } else if (type == PerScrollHistogramType::kMax) { |
| if (num_frames <= 16) { |
| return "Event.ScrollJank.MissedVsyncsMax.PerScroll.Small"; |
| } else if (num_frames <= 64) { |
| return "Event.ScrollJank.MissedVsyncsMax.PerScroll.Medium"; |
| } else { |
| return "Event.ScrollJank.MissedVsyncsMax.PerScroll.Large"; |
| } |
| } else { |
| DCHECK_EQ(type, PerScrollHistogramType::kSum); |
| if (num_frames <= 16) { |
| return "Event.ScrollJank.MissedVsyncsSum.PerScroll.Small"; |
| } else if (num_frames <= 64) { |
| return "Event.ScrollJank.MissedVsyncsSum.PerScroll.Medium"; |
| } else { |
| return "Event.ScrollJank.MissedVsyncsSum.PerScroll.Large"; |
| } |
| } |
| } |
| |
| const char* GetPerVsyncScrollHistogramName(int num_vsyncs, |
| PerScrollHistogramType type) { |
| DCHECK_GT(num_vsyncs, 0); |
| if (type == PerScrollHistogramType::kPercentage) { |
| if (num_vsyncs <= 16) { |
| return "Event.ScrollJank.MissedVsyncsPercentage.PerScroll.Small"; |
| } else if (num_vsyncs <= 64) { |
| return "Event.ScrollJank.MissedVsyncsPercentage.PerScroll.Medium"; |
| } else { |
| return "Event.ScrollJank.MissedVsyncsPercentage.PerScroll.Large"; |
| } |
| } else { |
| NOTREACHED(); |
| return ""; |
| } |
| } |
| } // namespace |
| |
| ScrollJankDroppedFrameTracker::ScrollJankDroppedFrameTracker() { |
| // Not initializing with 0 because the first frame in first window will be |
| // always deemed non-janky which makes the metric slightly biased. Setting |
| // it to -1 essentially ignores first frame. |
| fixed_window_.num_presented_frames = -1; |
| experimental_vsync_fixed_window_.num_past_vsyncs = -1; |
| } |
| |
| ScrollJankDroppedFrameTracker::~ScrollJankDroppedFrameTracker() { |
| if (per_scroll_.has_value()) { |
| // Per scroll metrics for a given scroll are emitted at the start of next |
| // scroll. Emittimg from here makes sure we don't loose the data for last |
| // scroll. |
| EmitPerScrollHistogramsAndResetCounters(); |
| EmitPerScrollVsyncHistogramsAndResetCounters(); |
| } |
| } |
| |
| void ScrollJankDroppedFrameTracker::EmitPerScrollHistogramsAndResetCounters() { |
| // There should be at least one presented frame given the method is only |
| // called after we have a successful presentation. |
| if (per_scroll_->num_presented_frames == 0) { |
| // TODO(1464878): Debug cases where we can have 0 presented frames. |
| TRACE_EVENT_INSTANT("input", "NoPresentedFramesInScroll"); |
| return; |
| } |
| // Emit non-bucketed histograms. |
| int delayed_frames_percentage = |
| (100 * per_scroll_->missed_frames) / per_scroll_->num_presented_frames; |
| UMA_HISTOGRAM_PERCENTAGE(kDelayedFramesPerScrollHistogram, |
| delayed_frames_percentage); |
| UMA_HISTOGRAM_CUSTOM_COUNTS(kMissedVsyncsMaxPerScrollHistogram, |
| per_scroll_->max_missed_vsyncs, kVsyncCountsMin, |
| kVsyncCountsMax, kVsyncCountsBuckets); |
| UMA_HISTOGRAM_CUSTOM_COUNTS(kMissedVsyncsSumPerScrollHistogram, |
| per_scroll_->missed_vsyncs, kVsyncCountsMin, |
| kVsyncCountsMax, kVsyncCountsBuckets); |
| // Emit bucketed histogram. |
| base::UmaHistogramPercentage( |
| GetPerScrollHistogramName(per_scroll_->num_presented_frames, |
| PerScrollHistogramType::kPercentage), |
| delayed_frames_percentage); |
| base::UmaHistogramCustomCounts( |
| GetPerScrollHistogramName(per_scroll_->num_presented_frames, |
| PerScrollHistogramType::kMax), |
| per_scroll_->max_missed_vsyncs, kVsyncCountsMin, kVsyncCountsMax, |
| kVsyncCountsBuckets); |
| base::UmaHistogramCustomCounts( |
| GetPerScrollHistogramName(per_scroll_->num_presented_frames, |
| PerScrollHistogramType::kSum), |
| per_scroll_->missed_vsyncs, kVsyncCountsMin, kVsyncCountsMax, |
| kVsyncCountsBuckets); |
| |
| per_scroll_->missed_frames = 0; |
| per_scroll_->missed_vsyncs = 0; |
| per_scroll_->num_presented_frames = 0; |
| per_scroll_->max_missed_vsyncs = 0; |
| } |
| |
| void ScrollJankDroppedFrameTracker:: |
| EmitPerScrollVsyncHistogramsAndResetCounters() { |
| // There should be at least one presented frame given the method is only |
| // called after we have a successful presentation. |
| if (experimental_per_scroll_vsync_->num_past_vsyncs == 0) { |
| return; |
| } |
| // Emit non-bucketed histograms. |
| int missed_vsyncs_percentage = |
| (100 * experimental_per_scroll_vsync_->missed_vsyncs) / |
| experimental_per_scroll_vsync_->num_past_vsyncs; |
| UMA_HISTOGRAM_PERCENTAGE(kMissedVsyncsPerScrollHistogram, |
| missed_vsyncs_percentage); |
| // Emit bucketed histogram. |
| base::UmaHistogramPercentage( |
| GetPerVsyncScrollHistogramName( |
| experimental_per_scroll_vsync_->num_past_vsyncs, |
| PerScrollHistogramType::kPercentage), |
| missed_vsyncs_percentage); |
| |
| experimental_per_scroll_vsync_->missed_frames = 0; |
| experimental_per_scroll_vsync_->missed_vsyncs = 0; |
| experimental_per_scroll_vsync_->num_past_vsyncs = 0; |
| experimental_per_scroll_vsync_->max_missed_vsyncs = 0; |
| } |
| |
| void ScrollJankDroppedFrameTracker::EmitPerWindowHistogramsAndResetCounters() { |
| DCHECK_EQ(fixed_window_.num_presented_frames, kHistogramEmitFrequency); |
| |
| UMA_HISTOGRAM_PERCENTAGE( |
| kDelayedFramesWindowHistogram, |
| (100 * fixed_window_.missed_frames) / kHistogramEmitFrequency); |
| UMA_HISTOGRAM_CUSTOM_COUNTS(kMissedVsyncsSumInWindowHistogram, |
| fixed_window_.missed_vsyncs, kVsyncCountsMin, |
| kVsyncCountsMax, kVsyncCountsBuckets); |
| UMA_HISTOGRAM_CUSTOM_COUNTS(kMissedVsyncsMaxInWindowHistogram, |
| fixed_window_.max_missed_vsyncs, kVsyncCountsMin, |
| kVsyncCountsMax, kVsyncCountsBuckets); |
| |
| fixed_window_.missed_frames = 0; |
| fixed_window_.missed_vsyncs = 0; |
| fixed_window_.max_missed_vsyncs = 0; |
| // We don't need to reset it to -1 because after the first window we always |
| // have a valid previous frame data to compare the first frame of window. |
| fixed_window_.num_presented_frames = 0; |
| } |
| |
| // TODO(b/306611560): Cleanup experimental per vsync metric or promote to |
| // default. |
| void ScrollJankDroppedFrameTracker:: |
| EmitPerVsyncWindowHistogramsAndResetCounters() { |
| DCHECK_GE(experimental_vsync_fixed_window_.num_past_vsyncs, |
| kHistogramEmitFrequency); |
| |
| UMA_HISTOGRAM_PERCENTAGE( |
| kMissedVsyncsWindowHistogram, |
| (100 * experimental_vsync_fixed_window_.missed_vsyncs) / |
| experimental_vsync_fixed_window_.num_past_vsyncs); |
| UMA_HISTOGRAM_CUSTOM_COUNTS(kMissedVsyncsSumInVsyncWindowHistogram, |
| experimental_vsync_fixed_window_.missed_vsyncs, |
| kVsyncCountsMin, kVsyncCountsMax, |
| kVsyncCountsBuckets); |
| UMA_HISTOGRAM_CUSTOM_COUNTS(kMissedVsyncsMaxInVsyncWindowHistogram, |
| fixed_window_.max_missed_vsyncs, kVsyncCountsMin, |
| kVsyncCountsMax, kVsyncCountsBuckets); |
| |
| experimental_vsync_fixed_window_.missed_vsyncs = 0; |
| experimental_vsync_fixed_window_.num_past_vsyncs = 0; |
| experimental_vsync_fixed_window_.max_missed_vsyncs = 0; |
| } |
| |
| void ScrollJankDroppedFrameTracker::ReportLatestPresentationData( |
| ScrollUpdateEventMetrics& earliest_event, |
| base::TimeTicks last_input_generation_ts, |
| base::TimeTicks presentation_ts, |
| base::TimeDelta vsync_interval) { |
| base::TimeTicks first_input_generation_ts = |
| earliest_event.GetDispatchStageTimestamp( |
| EventMetrics::DispatchStage::kGenerated); |
| if ((last_input_generation_ts < first_input_generation_ts) || |
| (presentation_ts <= last_input_generation_ts)) { |
| // TODO(crbug/1447358): Investigate when these edge cases can be triggered |
| // in field and web tests. We have already seen this triggered in field, and |
| // some web tests where an event with null(0) timestamp gets coalesced with |
| // a "normal" input. |
| return; |
| } |
| // TODO(b/276722271) : Analyze and reduce these cases of out of order |
| // frame termination. |
| if (presentation_ts <= prev_presentation_ts_) { |
| TRACE_EVENT_INSTANT("input", "OutOfOrderTerminatedFrame"); |
| return; |
| } |
| |
| // `per_scroll_` is initialized in OnScrollStarted when we see |
| // FIRST_GESTURE_SCROLL_UPDATE event. But in some rare scenarios we don't see |
| // the FIRST_GESTURE_SCROLL_UPDATE events on scroll start. |
| if (!per_scroll_.has_value()) { |
| per_scroll_ = JankData(); |
| experimental_per_scroll_vsync_ = JankData(); |
| } |
| |
| // The presentation delta is usually 16.6ms for 60 Hz devices, |
| // but sometimes random errors result in a delta of up to 20ms |
| // as observed in traces. This adds an error margin of 1/2 a |
| // vsync before considering the Vsync missed. |
| bool missed_frame = (presentation_ts - prev_presentation_ts_) > |
| (vsync_interval + vsync_interval / 2); |
| bool input_available = |
| (first_input_generation_ts - prev_last_input_generation_ts_) < |
| (vsync_interval + vsync_interval / 2); |
| |
| // Sometimes the vsync interval is not accurate and is slightly more |
| // than the actual signal arrival time, adding (vsync_interval / 2) |
| // here insures the result is always ceiled. |
| int curr_frame_total_vsyncs = |
| (presentation_ts - prev_presentation_ts_ + (vsync_interval / 2)) / |
| vsync_interval; |
| int curr_frame_missed_vsyncs = curr_frame_total_vsyncs - 1; |
| |
| if (missed_frame && input_available) { |
| ++fixed_window_.missed_frames; |
| ++per_scroll_->missed_frames; |
| UMA_HISTOGRAM_CUSTOM_COUNTS(kMissedVsyncsPerFrameHistogram, |
| curr_frame_missed_vsyncs, kVsyncCountsMin, |
| kVsyncCountsMax, kVsyncCountsBuckets); |
| fixed_window_.missed_vsyncs += curr_frame_missed_vsyncs; |
| per_scroll_->missed_vsyncs += curr_frame_missed_vsyncs; |
| |
| // TODO(b/306611560): If experimental per scroll logic is promoted to |
| // default, then UKM reporting will need to be recorded under the same |
| // conditions. |
| if (scroll_jank_ukm_reporter_) { |
| scroll_jank_ukm_reporter_->IncrementDelayedFrameCount(); |
| scroll_jank_ukm_reporter_->AddMissedVsyncs(curr_frame_missed_vsyncs); |
| } |
| |
| if (curr_frame_missed_vsyncs > per_scroll_->max_missed_vsyncs) { |
| per_scroll_->max_missed_vsyncs = curr_frame_missed_vsyncs; |
| if (scroll_jank_ukm_reporter_) { |
| scroll_jank_ukm_reporter_->set_max_missed_vsyncs( |
| curr_frame_missed_vsyncs); |
| } |
| } |
| if (curr_frame_missed_vsyncs > fixed_window_.max_missed_vsyncs) { |
| fixed_window_.max_missed_vsyncs = curr_frame_missed_vsyncs; |
| } |
| |
| TRACE_EVENT_INSTANT( |
| "input,input.scrolling", "MissedFrame", "per_scroll_->missed_frames", |
| per_scroll_->missed_frames, "per_scroll_->missed_vsyncs", |
| per_scroll_->missed_vsyncs, "vsync_interval", vsync_interval); |
| earliest_event.set_is_janky_scrolled_frame(true); |
| } else { |
| earliest_event.set_is_janky_scrolled_frame(false); |
| UMA_HISTOGRAM_CUSTOM_COUNTS(kMissedVsyncsPerFrameHistogram, 0, |
| kVsyncCountsMin, kVsyncCountsMax, |
| kVsyncCountsBuckets); |
| } |
| |
| if (input_available) { |
| // Per 64 vsyncs |
| experimental_vsync_fixed_window_.missed_vsyncs += curr_frame_missed_vsyncs; |
| experimental_vsync_fixed_window_.num_past_vsyncs += curr_frame_total_vsyncs; |
| experimental_vsync_fixed_window_.max_missed_vsyncs = |
| std::max(experimental_vsync_fixed_window_.max_missed_vsyncs, |
| curr_frame_missed_vsyncs); |
| |
| // Per scroll |
| experimental_per_scroll_vsync_->missed_vsyncs += curr_frame_missed_vsyncs; |
| experimental_per_scroll_vsync_->num_past_vsyncs += curr_frame_total_vsyncs; |
| if (scroll_jank_ukm_reporter_) { |
| scroll_jank_ukm_reporter_->AddVsyncs(curr_frame_total_vsyncs); |
| } |
| } else { |
| ++experimental_vsync_fixed_window_.num_past_vsyncs; |
| ++experimental_per_scroll_vsync_->num_past_vsyncs; |
| if (scroll_jank_ukm_reporter_) { |
| scroll_jank_ukm_reporter_->AddVsyncs(1); |
| } |
| } |
| |
| ++fixed_window_.num_presented_frames; |
| ++per_scroll_->num_presented_frames; |
| if (scroll_jank_ukm_reporter_) { |
| scroll_jank_ukm_reporter_->IncrementFrameCount(); |
| } |
| |
| if (fixed_window_.num_presented_frames == kHistogramEmitFrequency) { |
| EmitPerWindowHistogramsAndResetCounters(); |
| } |
| // TODO(b/306611560): Cleanup experimental per vsync metric or promote to |
| // default. |
| if (experimental_vsync_fixed_window_.num_past_vsyncs >= |
| kHistogramEmitFrequency) { |
| EmitPerVsyncWindowHistogramsAndResetCounters(); |
| } |
| DCHECK_LT(fixed_window_.num_presented_frames, kHistogramEmitFrequency); |
| |
| prev_presentation_ts_ = presentation_ts; |
| prev_last_input_generation_ts_ = last_input_generation_ts; |
| } |
| |
| void ScrollJankDroppedFrameTracker::OnScrollStarted() { |
| if (per_scroll_.has_value()) { |
| EmitPerScrollHistogramsAndResetCounters(); |
| EmitPerScrollVsyncHistogramsAndResetCounters(); |
| } else { |
| per_scroll_ = JankData(); |
| experimental_per_scroll_vsync_ = JankData(); |
| } |
| } |
| |
| } // namespace cc |
