kwin/renderloop.cpp
Vlad Zahorodnii ee3515680a platforms/drm: Make frame scheduling robust
If there is a pending frame, the RenderLoop will delay all schedule
repaint requests to the next vblank event. This means that the render
loop needs to be notified when a frame has been presented or failed.

At the moment, the RenderLoop is notified only about successfully
presented frames. If some frame fails, no repaints will be scheduled
on that output.

In order to make frame scheduling robust, the RenderLoop has to be
notified if a frame has failed.
2021-01-06 16:59:30 +00:00

231 lines
5.8 KiB
C++

/*
SPDX-FileCopyrightText: 2020 Vlad Zahorodnii <vlad.zahorodnii@kde.org>
SPDX-License-Identifier: GPL-2.0-or-later
*/
#include "renderloop.h"
#include "options.h"
#include "renderloop_p.h"
#include "utils.h"
namespace KWin
{
template <typename T>
T alignTimestamp(const T &timestamp, const T &alignment)
{
return timestamp + ((alignment - (timestamp % alignment)) % alignment);
}
RenderLoopPrivate *RenderLoopPrivate::get(RenderLoop *loop)
{
return loop->d.data();
}
RenderLoopPrivate::RenderLoopPrivate(RenderLoop *q)
: q(q)
{
compositeTimer.setSingleShot(true);
QObject::connect(&compositeTimer, &QTimer::timeout, q, [this]() { dispatch(); });
}
void RenderLoopPrivate::scheduleRepaint()
{
if (compositeTimer.isActive()) {
return;
}
const std::chrono::nanoseconds currentTime(std::chrono::steady_clock::now().time_since_epoch());
const std::chrono::nanoseconds vblankInterval(1'000'000'000'000ull / refreshRate);
// Estimate when the next presentation will occur. Note that this is a prediction.
nextPresentationTimestamp = lastPresentationTimestamp
+ alignTimestamp(currentTime - lastPresentationTimestamp, vblankInterval);
// Estimate when it's a good time to perform the next compositing cycle.
const std::chrono::nanoseconds safetyMargin = std::chrono::milliseconds(3);
std::chrono::nanoseconds renderTime;
switch (options->latencyPolicy()) {
case LatencyExteremelyLow:
renderTime = std::chrono::nanoseconds(long(vblankInterval.count() * 0.1));
break;
case LatencyLow:
renderTime = std::chrono::nanoseconds(long(vblankInterval.count() * 0.25));
break;
case LatencyMedium:
renderTime = std::chrono::nanoseconds(long(vblankInterval.count() * 0.5));
break;
case LatencyHigh:
renderTime = std::chrono::nanoseconds(long(vblankInterval.count() * 0.75));
break;
case LatencyExtremelyHigh:
renderTime = std::chrono::nanoseconds(long(vblankInterval.count() * 0.9));
break;
}
switch (options->renderTimeEstimator()) {
case RenderTimeEstimatorMinimum:
renderTime = std::max(renderTime, renderJournal.minimum());
break;
case RenderTimeEstimatorMaximum:
renderTime = std::max(renderTime, renderJournal.maximum());
break;
case RenderTimeEstimatorAverage:
renderTime = std::max(renderTime, renderJournal.average());
break;
}
std::chrono::nanoseconds nextRenderTimestamp = nextPresentationTimestamp - renderTime - safetyMargin;
// If we can't render the frame before the deadline, start compositing immediately.
if (nextRenderTimestamp < currentTime) {
nextRenderTimestamp = currentTime;
}
const std::chrono::nanoseconds waitInterval = nextRenderTimestamp - currentTime;
compositeTimer.start(std::chrono::duration_cast<std::chrono::milliseconds>(waitInterval));
}
void RenderLoopPrivate::delayScheduleRepaint()
{
pendingReschedule = true;
}
void RenderLoopPrivate::maybeScheduleRepaint()
{
if (pendingReschedule) {
scheduleRepaint();
pendingReschedule = false;
}
}
void RenderLoopPrivate::notifyFrameFailed()
{
Q_ASSERT(pendingFrameCount > 0);
pendingFrameCount--;
if (!inhibitCount) {
maybeScheduleRepaint();
}
}
void RenderLoopPrivate::notifyFrameCompleted(std::chrono::nanoseconds timestamp)
{
Q_ASSERT(pendingFrameCount > 0);
pendingFrameCount--;
if (lastPresentationTimestamp <= timestamp) {
lastPresentationTimestamp = timestamp;
} else {
qCWarning(KWIN_CORE, "Got invalid presentation timestamp: %ld (current %ld)",
timestamp.count(), lastPresentationTimestamp.count());
lastPresentationTimestamp = std::chrono::steady_clock::now().time_since_epoch();
}
if (!inhibitCount) {
maybeScheduleRepaint();
}
emit q->framePresented(q, timestamp);
}
void RenderLoopPrivate::dispatch()
{
// On X11, we want to ignore repaints that are scheduled by windows right before
// the Compositor starts repainting.
pendingRepaint = true;
emit q->frameRequested(q);
// The Compositor may decide to not repaint when the frameRequested() signal is
// emitted, in which case the pending repaint flag has to be reset manually.
pendingRepaint = false;
}
void RenderLoopPrivate::invalidate()
{
pendingReschedule = false;
pendingFrameCount = 0;
compositeTimer.stop();
}
RenderLoop::RenderLoop(QObject *parent)
: QObject(parent)
, d(new RenderLoopPrivate(this))
{
}
RenderLoop::~RenderLoop()
{
}
void RenderLoop::inhibit()
{
d->inhibitCount++;
if (d->inhibitCount == 1) {
d->compositeTimer.stop();
}
}
void RenderLoop::uninhibit()
{
Q_ASSERT(d->inhibitCount > 0);
d->inhibitCount--;
if (d->inhibitCount == 0) {
d->maybeScheduleRepaint();
}
}
void RenderLoop::beginFrame()
{
d->pendingRepaint = false;
d->pendingFrameCount++;
d->renderJournal.beginFrame();
}
void RenderLoop::endFrame()
{
d->renderJournal.endFrame();
}
int RenderLoop::refreshRate() const
{
return d->refreshRate;
}
void RenderLoop::setRefreshRate(int refreshRate)
{
if (d->refreshRate == refreshRate) {
return;
}
d->refreshRate = refreshRate;
emit refreshRateChanged();
}
void RenderLoop::scheduleRepaint()
{
if (d->pendingRepaint) {
return;
}
if (!d->pendingFrameCount && !d->inhibitCount) {
d->scheduleRepaint();
} else {
d->delayScheduleRepaint();
}
}
std::chrono::nanoseconds RenderLoop::lastPresentationTimestamp() const
{
return d->lastPresentationTimestamp;
}
std::chrono::nanoseconds RenderLoop::nextPresentationTimestamp() const
{
return d->nextPresentationTimestamp;
}
} // namespace KWin