garnet/lib/ui/gfx/tests/frame_predictor_unittest.cc

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

#include "garnet/lib/ui/gfx/engine/frame_predictor.h"

#include <lib/gtest/test_loop_fixture.h>

#include "garnet/lib/ui/gfx/tests/error_reporting_test.h"

namespace scenic_impl {
namespace gfx {
namespace test {

class FramePredictorTest : public ErrorReportingTest {
 protected:
  // | ::testing::Test |
  void SetUp() override {
    predictor_ = std::make_unique<FramePredictor>(kInitialRenderTimePrediction,
                                                  kInitialUpdateTimePrediction);
  }
  // | ::testing::Test |
  void TearDown() override { predictor_.reset(); }

  zx::time ms_to_time(uint64_t ms) {
    return zx::time(0) + zx::msec(ms);
  }

  static constexpr zx::duration kInitialRenderTimePrediction =
      zx::msec(4);
  static constexpr zx::duration kInitialUpdateTimePrediction =
      zx::msec(2);

  std::unique_ptr<FramePredictor> predictor_;
};

TEST_F(FramePredictorTest, BasicPredictions_ShouldBeReasonable) {
  PredictionRequest request = {
      .now = ms_to_time(5),
      .requested_presentation_time = ms_to_time(10),
      .last_vsync_time = ms_to_time(0),
      .vsync_interval = zx::msec(10)};

  auto prediction = predictor_->GetPrediction(request);

  EXPECT_GT(prediction.presentation_time, request.now);
  EXPECT_GE(prediction.latch_point_time, request.now);
  EXPECT_LT(prediction.latch_point_time, prediction.presentation_time);
}

TEST_F(FramePredictorTest, PredictionsAfterUpdating_ShouldBeMoreReasonable) {
  const zx::duration update_duration = zx::msec(2);
  const zx::duration render_duration = zx::msec(5);

  const size_t kBiggerThanAllPredictionWindows = 5;
  for (size_t i = 0; i < kBiggerThanAllPredictionWindows; ++i) {
    predictor_->ReportRenderDuration(render_duration);
    predictor_->ReportUpdateDuration(update_duration);
  }

  PredictionRequest request = {.now = ms_to_time(5),
                               .requested_presentation_time = ms_to_time(0),
                               .last_vsync_time = ms_to_time(0),
                               .vsync_interval = zx::msec(10)};

  auto prediction = predictor_->GetPrediction(request);

  EXPECT_GT(prediction.presentation_time, request.now);
  EXPECT_GE(prediction.latch_point_time, request.now);

  EXPECT_GE(prediction.presentation_time - prediction.latch_point_time,
            update_duration + render_duration);
}

TEST_F(FramePredictorTest,
       OneExpensiveTime_ShouldNotPredictForFutureVsyncIntervals) {
  const zx::duration update_duration = zx::msec(4);
  const zx::duration render_duration = zx::msec(10);
  const zx::duration vsync_interval = zx::msec(10);

  predictor_->ReportRenderDuration(render_duration);
  predictor_->ReportUpdateDuration(update_duration);

  PredictionRequest request = {.now = ms_to_time(0),
                               .requested_presentation_time = ms_to_time(0),
                               .last_vsync_time = ms_to_time(0),
                               .vsync_interval = vsync_interval};
  auto prediction = predictor_->GetPrediction(request);

  EXPECT_GE(prediction.latch_point_time, request.now);
  EXPECT_LE(prediction.presentation_time,
            request.last_vsync_time + request.vsync_interval);
}

TEST_F(FramePredictorTest,
       ManyExpensiveTimes_ShouldPredictForFutureVsyncIntervals) {
  const zx::duration update_duration = zx::msec(4);
  const zx::duration render_duration = zx::msec(10);
  const zx::duration vsync_interval = zx::msec(10);

  for (size_t i = 0; i < 10; i++) {
    predictor_->ReportRenderDuration(render_duration);
    predictor_->ReportUpdateDuration(update_duration);
  }

  PredictionRequest request = {.now = ms_to_time(3),
                               .requested_presentation_time = ms_to_time(0),
                               .last_vsync_time = ms_to_time(0),
                               .vsync_interval = vsync_interval};
  auto prediction = predictor_->GetPrediction(request);

  EXPECT_GE(prediction.latch_point_time, request.now);
  EXPECT_GE(prediction.presentation_time,
            request.last_vsync_time + request.vsync_interval);
  EXPECT_LE(prediction.presentation_time,
            request.last_vsync_time + request.vsync_interval * 2);
  EXPECT_LE(prediction.latch_point_time,
            prediction.presentation_time - request.vsync_interval);
}

TEST_F(FramePredictorTest, ManyFramesOfPredictions_ShouldBeReasonable) {
  const zx::duration vsync_interval = zx::msec(10);

  zx::time now = ms_to_time(0);
  zx::time requested_present = ms_to_time(8);
  zx::time last_vsync_time = ms_to_time(0);
  for (uint64_t i = 0; i < 50; ++i) {
    zx::duration update_duration = zx::msec(i % 5);
    zx::duration render_duration = zx::msec(5);
    predictor_->ReportUpdateDuration(update_duration);
    predictor_->ReportRenderDuration(render_duration);
    EXPECT_GE(vsync_interval, update_duration + render_duration);

    PredictionRequest request = {.now = now,
                               .requested_presentation_time = requested_present,
                               .last_vsync_time = last_vsync_time,
                               .vsync_interval = vsync_interval};
    auto prediction = predictor_->GetPrediction(request);

    EXPECT_GE(prediction.latch_point_time, request.now);
    EXPECT_GE(prediction.presentation_time, requested_present);
    EXPECT_LE(prediction.presentation_time,
              requested_present + vsync_interval * 2);

    // For the next frame, increase time to be after the predicted present to
    // emulate a client that is regularly scheduling frames.
    now = prediction.presentation_time + zx::msec(1);
    requested_present = prediction.presentation_time + vsync_interval;
    last_vsync_time = prediction.presentation_time;
  }
}

TEST_F(FramePredictorTest, MissedLastVsync_ShouldPredictWithInterval) {
  const zx::duration update_duration = zx::msec(4);
  const zx::duration render_duration = zx::msec(5);
  predictor_->ReportRenderDuration(render_duration);
  predictor_->ReportUpdateDuration(update_duration);

  const zx::duration vsync_interval = zx::msec(16);
  zx::time last_vsync_time = ms_to_time(16);
  // Make now be more than a vsync_interval beyond the last_vsync_time
  zx::time now = last_vsync_time + (vsync_interval * 2) + zx::msec(3);
  zx::time requested_present = now + zx::msec(9);
  PredictionRequest request = {.now = now,
                               .requested_presentation_time = requested_present,
                               .last_vsync_time = last_vsync_time,
                               .vsync_interval = vsync_interval};
  auto prediction = predictor_->GetPrediction(request);

  // The predicted presentation and wakeup times should be greater than one
  // vsync interval since the last reported vsync time.
  EXPECT_GE(prediction.presentation_time, last_vsync_time + vsync_interval);
  EXPECT_LE(prediction.presentation_time, now + (request.vsync_interval * 2));
  EXPECT_LE(prediction.presentation_time - prediction.latch_point_time,
            vsync_interval);
}

TEST_F(FramePredictorTest, MissedPresentRequest_ShouldTargetNextVsync) {
  const zx::duration update_duration = zx::msec(2);
  const zx::duration render_duration = zx::msec(4);
  predictor_->ReportRenderDuration(render_duration);
  predictor_->ReportUpdateDuration(update_duration);

  const zx::duration vsync_interval = zx::msec(10);
  zx::time last_vsync_time = ms_to_time(10);
  zx::time now = ms_to_time(12);
  // Request a present time in the past.
  zx::time requested_present = now - zx::msec(1);
  PredictionRequest request = {.now = now,
                               .requested_presentation_time = requested_present,
                               .last_vsync_time = last_vsync_time,
                               .vsync_interval = vsync_interval};
  auto prediction = predictor_->GetPrediction(request);

  EXPECT_GE(prediction.presentation_time, last_vsync_time + vsync_interval);
  EXPECT_LE(prediction.presentation_time, last_vsync_time + (vsync_interval * 2));
  EXPECT_GE(prediction.latch_point_time,
            prediction.presentation_time - vsync_interval);
}

TEST_F(FramePredictorTest, AttemptsToBeLowLatent_ShouldBePossible) {
  const zx::duration update_duration = zx::msec(1);
  const zx::duration render_duration = zx::msec(3);
  predictor_->ReportRenderDuration(render_duration);
  predictor_->ReportUpdateDuration(update_duration);

  const zx::duration vsync_interval = zx::msec(10);
  zx::time last_vsync_time = ms_to_time(10);
  zx::time requested_present = last_vsync_time + vsync_interval;
  zx::time now =
      requested_present - update_duration - render_duration - zx::msec(1);
  EXPECT_GT(now, last_vsync_time);

  PredictionRequest request = {.now = now,
                               .requested_presentation_time = requested_present,
                               .last_vsync_time = last_vsync_time,
                               .vsync_interval = vsync_interval};
  auto prediction = predictor_->GetPrediction(request);

  // The prediction should be for the next vsync.
  EXPECT_LE(prediction.presentation_time, last_vsync_time + vsync_interval);
  EXPECT_GE(prediction.latch_point_time, now);
}

}  // namespace test
}  // namespace gfx
}  // namespace scenic_impl