Changeset 269943 in webkit


Ignore:
Timestamp:
Nov 17, 2020 10:15:45 PM (3 years ago)
Author:
timothy_horton@apple.com
Message:

GPU-process-hosted RemoteLayerBackingStore should flush off the main thread
​https://bugs.webkit.org/show_bug.cgi?id=219063

Reviewed by Simon Fraser.

  • GPUProcess/graphics/RemoteRenderingBackend.h:
  • Shared/RemoteLayerTree/RemoteLayerBackingStore.mm:

(WebKit::RemoteLayerBackingStore::display):
Construct the ImageBuffer flusher /after/ submitting the final DisplayList,
so that it takes the correct flush identifier.

  • GPUProcess/graphics/RemoteImageBuffer.h:
  • GPUProcess/graphics/RemoteRenderingBackend.cpp:

(WebKit::RemoteRenderingBackend::didFlush):
(WebKit::RemoteRenderingBackend::flushDisplayListWasCommitted): Deleted.

  • WebProcess/GPU/graphics/RemoteImageBufferProxy.h:

(WebKit::RemoteImageBufferProxy::didFlush):
(WebKit::RemoteImageBufferProxy::lastSentFlushIdentifier const):
(WebKit::RemoteImageBufferProxy::waitForDidFlushOnSecondaryThread):
(WebKit::RemoteImageBufferProxy::hasPendingFlush const):
(WebKit::RemoteImageBufferProxy::waitForDidFlushWithTimeout):
(WebKit::ThreadSafeRemoteImageBufferFlusher::ThreadSafeRemoteImageBufferFlusher):
(WebKit::RemoteImageBufferProxy::commitFlushDisplayList): Deleted.
(WebKit::RemoteImageBufferProxy::isPendingFlush const): Deleted.
(WebKit::RemoteImageBufferProxy::timeoutWaitForFlushDisplayListWasCommitted): Deleted.
Some renames:

Rename flushDisplayListWasCommitted to didFlush; this is the back-message from
GPU process to Web Content process that a FlushContext display list item was completed successfully.
Rename isPendingFlush to hasPendingFlush, for grammar.
Rename timeoutWaitForFlushDisplayListWasCommitted to waitForDidFlushWithTimeout, for similar reasons.
Rename waitForFlushDisplayListWasCommitted to waitForDidFlush.
Rename commitFlushDisplayList to didFlush.

  • WebProcess/GPU/graphics/RemoteRenderingBackendProxy.cpp:

(WebKit::RemoteRenderingBackendProxy::waitForDidFlush):
(WebKit::RemoteRenderingBackendProxy::didFlush):
(WebKit::RemoteRenderingBackendProxy::waitForFlushDisplayListWasCommitted): Deleted.
(WebKit::RemoteRenderingBackendProxy::flushDisplayListWasCommitted): Deleted.

  • WebProcess/GPU/graphics/RemoteRenderingBackendProxy.h:
  • WebProcess/GPU/graphics/RemoteRenderingBackendProxy.messages.in:

Reimplement ThreadSafeRemoteImageBufferFlusher such that it waits
(on the RemoteLayerTreeDrawingArea CommitQueue, in the only current use of it)
for the correct flush reply to come in before continuing. This is analogous
to what we do for in-process buffers, where we call CGContextFlush()
in the flusher.

Location:
trunk/Source/WebKit
Files:
9 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebKit/ChangeLog

    r269935 r269943  
     12020-11-17  Tim Horton  <timothy_horton@apple.com>
     2
     3        GPU-process-hosted RemoteLayerBackingStore should flush off the main thread
     4        https://bugs.webkit.org/show_bug.cgi?id=219063
     5
     6        Reviewed by Simon Fraser.
     7
     8        * GPUProcess/graphics/RemoteRenderingBackend.h:
     9        * Shared/RemoteLayerTree/RemoteLayerBackingStore.mm:
     10        (WebKit::RemoteLayerBackingStore::display):
     11        Construct the ImageBuffer flusher /after/ submitting the final DisplayList,
     12        so that it takes the correct flush identifier.
     13
     14        * GPUProcess/graphics/RemoteImageBuffer.h:
     15        * GPUProcess/graphics/RemoteRenderingBackend.cpp:
     16        (WebKit::RemoteRenderingBackend::didFlush):
     17        (WebKit::RemoteRenderingBackend::flushDisplayListWasCommitted): Deleted.
     18        * WebProcess/GPU/graphics/RemoteImageBufferProxy.h:
     19        (WebKit::RemoteImageBufferProxy::didFlush):
     20        (WebKit::RemoteImageBufferProxy::lastSentFlushIdentifier const):
     21        (WebKit::RemoteImageBufferProxy::waitForDidFlushOnSecondaryThread):
     22        (WebKit::RemoteImageBufferProxy::hasPendingFlush const):
     23        (WebKit::RemoteImageBufferProxy::waitForDidFlushWithTimeout):
     24        (WebKit::ThreadSafeRemoteImageBufferFlusher::ThreadSafeRemoteImageBufferFlusher):
     25        (WebKit::RemoteImageBufferProxy::commitFlushDisplayList): Deleted.
     26        (WebKit::RemoteImageBufferProxy::isPendingFlush const): Deleted.
     27        (WebKit::RemoteImageBufferProxy::timeoutWaitForFlushDisplayListWasCommitted): Deleted.
     28        Some renames:
     29
     30        Rename flushDisplayListWasCommitted to didFlush; this is the back-message from
     31        GPU process to Web Content process that a FlushContext display list item was completed successfully.
     32        Rename isPendingFlush to hasPendingFlush, for grammar.
     33        Rename timeoutWaitForFlushDisplayListWasCommitted to waitForDidFlushWithTimeout, for similar reasons.
     34        Rename waitForFlushDisplayListWasCommitted to waitForDidFlush.
     35        Rename commitFlushDisplayList to didFlush.
     36
     37        * WebProcess/GPU/graphics/RemoteRenderingBackendProxy.cpp:
     38        (WebKit::RemoteRenderingBackendProxy::waitForDidFlush):
     39        (WebKit::RemoteRenderingBackendProxy::didFlush):
     40        (WebKit::RemoteRenderingBackendProxy::waitForFlushDisplayListWasCommitted): Deleted.
     41        (WebKit::RemoteRenderingBackendProxy::flushDisplayListWasCommitted): Deleted.
     42        * WebProcess/GPU/graphics/RemoteRenderingBackendProxy.h:
     43        * WebProcess/GPU/graphics/RemoteRenderingBackendProxy.messages.in:
     44        Reimplement ThreadSafeRemoteImageBufferFlusher such that it waits
     45        (on the RemoteLayerTreeDrawingArea CommitQueue, in the only current use of it)
     46        for the correct flush reply to come in before continuing. This is analogous
     47        to what we do for in-process buffers, where we call CGContextFlush()
     48        in the flusher.
     49
    1502020-11-17  Chris Dumez  <cdumez@apple.com>
    251

  • trunk/Source/WebKit/GPUProcess/graphics/RemoteImageBuffer.h

    r269710 r269943  
    8888            BaseConcreteImageBuffer::flushContext();
    8989            auto identifier = item.get<WebCore::DisplayList::FlushContext>().identifier();
    90             m_remoteRenderingBackend.flushDisplayListWasCommitted(identifier, m_renderingResourceIdentifier);
     90            m_remoteRenderingBackend.didFlush(identifier, m_renderingResourceIdentifier);
    9191            return true;
    9292        }

  • trunk/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackend.cpp

    r269789 r269943  
    105105}
    106106
    107 void RemoteRenderingBackend::flushDisplayListWasCommitted(DisplayList::FlushIdentifier flushIdentifier, RenderingResourceIdentifier renderingResourceIdentifier)
    108 {
    109     send(Messages::RemoteRenderingBackendProxy::FlushDisplayListWasCommitted(flushIdentifier, renderingResourceIdentifier), m_renderingBackendIdentifier);
     107void RemoteRenderingBackend::didFlush(DisplayList::FlushIdentifier flushIdentifier, RenderingResourceIdentifier renderingResourceIdentifier)
     108{
     109    send(Messages::RemoteRenderingBackendProxy::DidFlush(flushIdentifier, renderingResourceIdentifier), m_renderingBackendIdentifier);
    110110}
    111111

  • trunk/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackend.h

    r269710 r269943  
    7272    // Messages to be sent.
    7373    void imageBufferBackendWasCreated(const WebCore::FloatSize& logicalSize, const WebCore::IntSize& backendSize, float resolutionScale, WebCore::ColorSpace, WebCore::PixelFormat, ImageBufferBackendHandle, WebCore::RenderingResourceIdentifier);
    74     void flushDisplayListWasCommitted(WebCore::DisplayList::FlushIdentifier, WebCore::RenderingResourceIdentifier);
     74    void didFlush(WebCore::DisplayList::FlushIdentifier, WebCore::RenderingResourceIdentifier);
    7575
    7676    void setNextItemBufferToRead(WebCore::DisplayList::ItemBufferIdentifier);

  • trunk/Source/WebKit/Shared/RemoteLayerTree/RemoteLayerBackingStore.mm

    r269895 r269943  
    314314    m_paintingRects.clear();
    315315
    316     m_frontBufferFlusher = m_frontBuffer.imageBuffer->createFlusher();
    317 
    318316    m_layer->owner()->platformCALayerLayerDidDisplay(m_layer);
    319317
    320318    // FIXME: This method has a weird name. This is "submit work".
    321319    m_frontBuffer.imageBuffer->flushDrawingContextAndCommit();
     320
     321    m_frontBufferFlusher = m_frontBuffer.imageBuffer->createFlusher();
    322322
    323323    return true;

  • trunk/Source/WebKit/WebProcess/GPU/graphics/RemoteImageBufferProxy.h

    r269824 r269943  
    3535#include <WebCore/DisplayListItems.h>
    3636#include <WebCore/DisplayListRecorder.h>
     37#include <wtf/Condition.h>
     38#include <wtf/Lock.h>
    3739#include <wtf/SystemTracing.h>
    3840
    … …  
    4042
    4143class RemoteRenderingBackend;
    42 
    43 class ThreadSafeRemoteImageBufferFlusher : public WebCore::ThreadSafeImageBufferFlusher {
    44     WTF_MAKE_FAST_ALLOCATED;
    45 public:
    46     ThreadSafeRemoteImageBufferFlusher(WebCore::ImageBuffer& imageBuffer)
    47     {
    48         // FIXME: We shouldn't synchronously wait on the flush until flush() is called, but have to invent
    49         // a thread-safe way to wait on the incoming message.
    50         imageBuffer.flushDrawingContext();
    51     }
    52 
    53     void flush() override
    54     {
    55     }
    56 
    57 private:
    58 };
     44template<typename BackendType> class ThreadSafeRemoteImageBufferFlusher;
    5945
    6046template<typename BackendType>
    … …  
    9177    }
    9278
    93     void commitFlushDisplayList(WebCore::DisplayList::FlushIdentifier flushIdentifier)
    94     {
     79    void didFlush(WebCore::DisplayList::FlushIdentifier flushIdentifier)
     80    {
     81        auto locker = holdLock(m_receivedFlushIdentifierLock);
    9582        m_receivedFlushIdentifier = flushIdentifier;
     83        m_receivedFlushIdentifierChangedCondition.notifyAll();
    9684    }
    9785
    … …  
    10896    }
    10997
     98    WebCore::DisplayList::FlushIdentifier lastSentFlushIdentifier() const { return m_sentFlushIdentifier; }
     99
     100    void waitForDidFlushOnSecondaryThread(WebCore::DisplayList::FlushIdentifier targetFlushIdentifier)
     101    {
     102        ASSERT(!isMainThread());
     103        auto locker = holdLock(m_receivedFlushIdentifierLock);
     104        m_receivedFlushIdentifierChangedCondition.wait(m_receivedFlushIdentifierLock, [&] {
     105            return m_receivedFlushIdentifier == targetFlushIdentifier;
     106        });
     107
     108        // Nothing should have sent more drawing commands to the GPU process
     109        // while waiting for this ImageBuffer to be flushed.
     110        ASSERT(m_sentFlushIdentifier == targetFlushIdentifier);
     111    }
     112
    110113protected:
     114    friend class RemoteRenderingBackend;
    111115    RemoteImageBufferProxy(const WebCore::FloatSize& size, WebCore::RenderingMode renderingMode, float resolutionScale, WebCore::ColorSpace colorSpace, WebCore::PixelFormat pixelFormat, RemoteRenderingBackendProxy& remoteRenderingBackendProxy)
    112116        : BaseDisplayListImageBuffer(size, this)
    … …  
    125129    }
    126130
    127     bool isPendingFlush() const { return m_sentFlushIdentifier != m_receivedFlushIdentifier; }
    128 
    129     void timeoutWaitForFlushDisplayListWasCommitted()
     131    bool hasPendingFlush() const { return m_sentFlushIdentifier != m_receivedFlushIdentifier; }
     132
     133    void waitForDidFlushWithTimeout()
    130134    {
    131135        if (!m_remoteRenderingBackendProxy)
    … …  
    134138        // Wait for our DisplayList to be flushed but do not hang.
    135139        static constexpr unsigned maxWaitingFlush = 3;
    136         for (unsigned numWaitingFlush = 0; numWaitingFlush < maxWaitingFlush && isPendingFlush(); ++numWaitingFlush)
    137             m_remoteRenderingBackendProxy->waitForFlushDisplayListWasCommitted();
     140        for (unsigned numWaitingFlush = 0; numWaitingFlush < maxWaitingFlush && hasPendingFlush(); ++numWaitingFlush)
     141            m_remoteRenderingBackendProxy->waitForDidFlush();
    138142    }
    139143
    … …  
    182186        TraceScope tracingScope(FlushRemoteImageBufferStart, FlushRemoteImageBufferEnd);
    183187        flushDrawingContextAndCommit();
    184         timeoutWaitForFlushDisplayListWasCommitted();
     188        waitForDidFlushWithTimeout();
    185189    }
    186190
    … …  
    338342    std::unique_ptr<WebCore::ThreadSafeImageBufferFlusher> createFlusher() override
    339343    {
    340         return WTF::makeUnique<ThreadSafeRemoteImageBufferFlusher>(*this);
     344        return WTF::makeUnique<ThreadSafeRemoteImageBufferFlusher<BackendType>>(*this);
    341345    }
    342346
    343347    WebCore::DisplayList::FlushIdentifier m_sentFlushIdentifier;
     348    Lock m_receivedFlushIdentifierLock;
     349    Condition m_receivedFlushIdentifierChangedCondition;
    344350    WebCore::DisplayList::FlushIdentifier m_receivedFlushIdentifier;
    345351    WeakPtr<RemoteRenderingBackendProxy> m_remoteRenderingBackendProxy;
    … …  
    352358};
    353359
     360template<typename BackendType>
     361class ThreadSafeRemoteImageBufferFlusher final : public WebCore::ThreadSafeImageBufferFlusher {
     362    WTF_MAKE_FAST_ALLOCATED;
     363public:
     364    ThreadSafeRemoteImageBufferFlusher(RemoteImageBufferProxy<BackendType>& imageBuffer)
     365        : m_imageBuffer(imageBuffer)
     366        , m_targetFlushIdentifier(imageBuffer.lastSentFlushIdentifier())
     367    {
     368    }
     369
     370    void flush() final
     371    {
     372        m_imageBuffer->waitForDidFlushOnSecondaryThread(m_targetFlushIdentifier);
     373    }
     374
     375private:
     376    Ref<RemoteImageBufferProxy<BackendType>> m_imageBuffer;
     377    WebCore::DisplayList::FlushIdentifier m_targetFlushIdentifier;
     378};
     379
    354380} // namespace WebKit
    355381

  • trunk/Source/WebKit/WebProcess/GPU/graphics/RemoteRenderingBackendProxy.cpp

    r269809 r269943  
    119119}
    120120
    121 bool RemoteRenderingBackendProxy::waitForFlushDisplayListWasCommitted()
     121bool RemoteRenderingBackendProxy::waitForDidFlush()
    122122{
    123123    Ref<IPC::Connection> connection = WebProcess::singleton().ensureGPUProcessConnection().connection();
    124     return connection->waitForAndDispatchImmediately<Messages::RemoteRenderingBackendProxy::FlushDisplayListWasCommitted>(m_renderingBackendIdentifier, 1_s, IPC::WaitForOption::InterruptWaitingIfSyncMessageArrives);
     124    return connection->waitForAndDispatchImmediately<Messages::RemoteRenderingBackendProxy::DidFlush>(m_renderingBackendIdentifier, 1_s, IPC::WaitForOption::InterruptWaitingIfSyncMessageArrives);
    125125}
    126126
    … …  
    196196}
    197197
    198 void RemoteRenderingBackendProxy::flushDisplayListWasCommitted(DisplayList::FlushIdentifier flushIdentifier, RenderingResourceIdentifier renderingResourceIdentifier)
     198void RemoteRenderingBackendProxy::didFlush(DisplayList::FlushIdentifier flushIdentifier, RenderingResourceIdentifier renderingResourceIdentifier)
    199199{
    200200    auto imageBuffer = m_remoteResourceCacheProxy.cachedImageBuffer(renderingResourceIdentifier);
    … …  
    203203
    204204    if (imageBuffer->isAccelerated())
    205         downcast<AcceleratedRemoteImageBufferProxy>(*imageBuffer).commitFlushDisplayList(flushIdentifier);
     205        downcast<AcceleratedRemoteImageBufferProxy>(*imageBuffer).didFlush(flushIdentifier);
    206206    else
    207         downcast<UnacceleratedRemoteImageBufferProxy>(*imageBuffer).commitFlushDisplayList(flushIdentifier);
     207        downcast<UnacceleratedRemoteImageBufferProxy>(*imageBuffer).didFlush(flushIdentifier);
    208208}
    209209

  • trunk/Source/WebKit/WebProcess/GPU/graphics/RemoteRenderingBackendProxy.h

    r269809 r269943  
    8383
    8484    bool waitForImageBufferBackendWasCreated();
    85     bool waitForFlushDisplayListWasCommitted();
     85    bool waitForDidFlush();
    8686
    8787private:
    … …  
    9797    // Messages to be received.
    9898    void imageBufferBackendWasCreated(const WebCore::FloatSize& logicalSize, const WebCore::IntSize& backendSize, float resolutionScale, WebCore::ColorSpace, WebCore::PixelFormat, ImageBufferBackendHandle, WebCore::RenderingResourceIdentifier);
    99     void flushDisplayListWasCommitted(WebCore::DisplayList::FlushIdentifier, WebCore::RenderingResourceIdentifier);
     99    void didFlush(WebCore::DisplayList::FlushIdentifier, WebCore::RenderingResourceIdentifier);
    100100
    101101    RemoteResourceCacheProxy m_remoteResourceCacheProxy { *this };

  • trunk/Source/WebKit/WebProcess/GPU/graphics/RemoteRenderingBackendProxy.messages.in

    r269710 r269943  
    2525messages -> RemoteRenderingBackendProxy NotRefCounted {
    2626    ImageBufferBackendWasCreated(WebCore::FloatSize logicalSize, WebCore::IntSize backendSize, float resolutionScale, WebCore::ColorSpace colorSpace, enum:uint8_t WebCore::PixelFormat pixelFormat, WebKit::ImageBufferBackendHandle handle, WebCore::RenderingResourceIdentifier renderingResourceIdentifier)
    27     FlushDisplayListWasCommitted(WebCore::DisplayList::FlushIdentifier flushIdentifier, WebCore::RenderingResourceIdentifier renderingResourceIdentifier)
     27    DidFlush(WebCore::DisplayList::FlushIdentifier flushIdentifier, WebCore::RenderingResourceIdentifier renderingResourceIdentifier)
    2828}
    2929
Note: See TracChangeset for help on using the changeset viewer.