remove syncReleaser and properly release buffers in renderer

Author: ikalco

src/helpers/Monitor.cpp

@@ -3,7 +3,6 @@
 #include "../macros.hpp"
 #include "math/Math.hpp"
 #include "../protocols/ColorManagement.hpp"
-#include "sync/SyncReleaser.hpp"
 #include "../Compositor.hpp"
 #include "../config/ConfigValue.hpp"
 #include "../protocols/GammaControl.hpp"

src/helpers/sync/SyncReleaser.cpp

@@ -19,14 +19,6 @@ WP<CSyncTimeline> CDRMSyncPointState::timeline() {
     return m_timeline;
 }
 
-UP<CSyncReleaser> CDRMSyncPointState::createSyncRelease() {
-    if (m_releaseTaken)
-        Debug::log(ERR, "CDRMSyncPointState: creating a sync releaser on an already created SyncRelease");
-
-    m_releaseTaken = true;
-    return makeUnique<CSyncReleaser>(m_timeline, m_point);
-}
-
 bool CDRMSyncPointState::addWaiter(const std::function<void()>& waiter) {
     m_acquireCommitted = true;
     return m_timeline->addWaiter(waiter, m_point, 0u);
@@ -107,8 +99,6 @@ CDRMSyncobjSurfaceResource::CDRMSyncobjSurfaceResource(UP<CWpLinuxDrmSyncobjSurf
 
         surface->pending.buffer.release = pendingRelease;
         pendingRelease                  = {};
-
-        surface->pending.buffer->syncReleaser = surface->pending.buffer.release.createSyncRelease();
     });
 }
 

src/helpers/sync/SyncReleaser.hpp

@@ -2,7 +2,6 @@
 
 #include <vector>
 #include "WaylandProtocol.hpp"
-#include "../helpers/sync/SyncReleaser.hpp"
 #include "linux-drm-syncobj-v1.hpp"
 #include "../helpers/signal/Signal.hpp"
 #include <hyprutils/os/FileDescriptor.hpp>
@@ -17,13 +16,12 @@ class CDRMSyncPointState {
     CDRMSyncPointState(SP<CSyncTimeline> timeline_, uint64_t point_);
     ~CDRMSyncPointState() = default;
 
-    const uint64_t&                                  point();
-    WP<CSyncTimeline>                                timeline();
-    Hyprutils::Memory::CUniquePointer<CSyncReleaser> createSyncRelease();
-    bool                                             addWaiter(const std::function<void()>& waiter);
-    bool                                             comitted();
-    Hyprutils::OS::CFileDescriptor                   exportAsFD();
-    void                                             signal();
+    const uint64_t&                point();
+    WP<CSyncTimeline>              timeline();
+    bool                           addWaiter(const std::function<void()>& waiter);
+    bool                           comitted();
+    Hyprutils::OS::CFileDescriptor exportAsFD();
+    void                           signal();
 
     operator bool() const {
         return m_timeline;

src/protocols/DRMSyncobj.cpp

@@ -7,7 +7,6 @@
 #include "Subcompositor.hpp"
 #include "../Viewporter.hpp"
 #include "../../helpers/Monitor.hpp"
-#include "../../helpers/sync/SyncReleaser.hpp"
 #include "../../managers/eventLoop/EventLoopManager.hpp"
 #include "../PresentationTime.hpp"
 #include "../DRMSyncobj.hpp"
@@ -526,8 +525,7 @@ void CWLSurfaceResource::commitState(SSurfaceState& state) {
             nullptr);
     }
 
-    // release the buffer if it's synchronous (SHM) as update() has done everything thats needed
-    // so we can let the app know we're done.
+    // release the buffer if it's synchronous (SHM) as updateSynchronousTexture() has copied the buffer data to a GPU tex
     // if it doesn't have a role, we can't release it yet, in case it gets turned into a cursor.
     if (current.buffer && current.buffer->isSynchronous() && role->role() != SURFACE_ROLE_UNASSIGNED)
         dropCurrentBuffer();
@@ -580,12 +578,6 @@ void CWLSurfaceResource::presentFeedback(timespec* when, PHLMONITOR pMonitor, bo
     else
         FEEDBACK->presented();
     PROTO::presentation->queueData(FEEDBACK);
-
-    if (!pMonitor || !pMonitor->inTimeline || !syncobj)
-        return;
-
-    // attach explicit sync
-    g_pHyprRenderer->explicitPresented.emplace_back(self.lock());
 }
 
 CWLCompositorResource::CWLCompositorResource(SP<CWlCompositor> resource_) : resource(resource_) {

src/protocols/DRMSyncobj.hpp

@@ -1,4 +1,5 @@
 #include "Buffer.hpp"
+#include "../DRMSyncobj.hpp"
 
 IHLBuffer::~IHLBuffer() {
     if (locked() && resource)
@@ -7,6 +8,11 @@ IHLBuffer::~IHLBuffer() {
 
 void IHLBuffer::sendRelease() {
     resource->sendRelease();
+    for (auto const& point : releasePoints) {
+        if (point && point->timeline())
+            point->signal();
+    }
+    releasePoints.clear();
 }
 
 void IHLBuffer::lock() {
@@ -18,10 +24,8 @@ void IHLBuffer::unlock() {
 
     ASSERT(nLocks >= 0);
 
-    if (nLocks == 0) {
+    if (nLocks == 0)
         sendRelease();
-        syncReleaser.reset();
-    }
 }
 
 bool IHLBuffer::locked() {
@@ -40,6 +44,12 @@ void IHLBuffer::onBackendRelease(const std::function<void()>& fn) {
     });
 }
 
+void IHLBuffer::addReleasePoint(UP<CDRMSyncPointState> point) {
+    ASSERT(locked());
+    if (point && point->timeline())
+        releasePoints.push_back(std::move(point));
+}
+
 CHLBufferReference::CHLBufferReference() : buffer(nullptr) {
     ;
 }

src/protocols/core/Compositor.cpp

@@ -24,19 +24,20 @@ class IHLBuffer : public Aquamarine::IBuffer {
     virtual bool                          locked();
 
     void                                  onBackendRelease(const std::function<void()>& fn);
+    void                                  addReleasePoint(UP<CDRMSyncPointState> point);
 
     SP<CTexture>                          texture;
     bool                                  opaque = false;
     SP<CWLBufferResource>                 resource;
-    UP<CSyncReleaser>                     syncReleaser;
 
     struct {
         CHyprSignalListener backendRelease;
         CHyprSignalListener backendRelease2; // for explicit ds
     } hlEvents;
 
   private:
-    int nLocks = 0;
+    std::vector<UP<CDRMSyncPointState>> releasePoints;
+    int                                 nLocks = 0;
 
     friend class CHLBufferReference;
 };

src/protocols/types/Buffer.cpp

@@ -1,7 +1,6 @@
 #include "Renderer.hpp"
 #include "../Compositor.hpp"
 #include "../helpers/math/Math.hpp"
-#include "../helpers/sync/SyncReleaser.hpp"
 #include <algorithm>
 #include <aquamarine/output/Output.hpp>
 #include <filesystem>
@@ -1543,25 +1542,6 @@ bool CHyprRenderer::commitPendingAndDoExplicitSync(PHLMONITOR pMonitor) {
         }
     }
 
-    auto explicitOptions = getExplicitSyncSettings(pMonitor->output);
-    if (!explicitOptions.explicitEnabled)
-        return ok;
-
-    Debug::log(TRACE, "Explicit: {} presented", explicitPresented.size());
-
-    if (!pMonitor->eglSync)
-        Debug::log(TRACE, "Explicit: can't add sync, monitor has no EGLSync");
-    else {
-        for (auto const& e : explicitPresented) {
-            if (!e->current.buffer || !e->current.buffer->syncReleaser)
-                continue;
-
-            e->current.buffer->syncReleaser->addReleaseSync(pMonitor->eglSync);
-        }
-    }
-
-    explicitPresented.clear();
-
     return ok;
 }
 
@@ -2290,6 +2270,11 @@ void CHyprRenderer::endRender() {
             return;
         }
 
+        // release all CHLBufferRefernce (with buf locks) when EGLSync is signalled,
+        // meaning that when opengl rendering is done we send release for all used buffers
+        PMONITOR->inTimeline->addWaiter([prevbfs = std::move(usedBuffers)]() mutable { prevbfs.clear(); }, PMONITOR->inTimelinePoint, 0u);
+        usedBuffers.clear();
+
         if (m_eRenderMode == RENDER_MODE_NORMAL && explicitOptions.explicitKMSEnabled) {
             PMONITOR->inFence = CFileDescriptor{PMONITOR->inTimeline->exportAsSyncFileFD(PMONITOR->inTimelinePoint)};
             if (!PMONITOR->inFence.isValid()) {
@@ -2304,6 +2289,8 @@ void CHyprRenderer::endRender() {
             glFinish();
         else
             glFlush();
+
+        usedBuffers.clear();
     }
 }
 

src/protocols/types/Buffer.hpp

@@ -90,20 +90,20 @@ class CHyprRenderer {
 
     bool m_bBlockSurfaceFeedback = false;
     bool m_bRenderingSnapshot    = false;
-    PHLMONITORREF                       m_pMostHzMonitor;
-    bool                                m_bDirectScanoutBlocked = false;
+    PHLMONITORREF                   m_pMostHzMonitor;
+    bool                            m_bDirectScanoutBlocked = false;
 
-    void                                setSurfaceScanoutMode(SP<CWLSurfaceResource> surface, PHLMONITOR monitor); // nullptr monitor resets
-    void                                initiateManualCrash();
+    void                            setSurfaceScanoutMode(SP<CWLSurfaceResource> surface, PHLMONITOR monitor); // nullptr monitor resets
+    void                            initiateManualCrash();
 
-    bool                                m_bCrashingInProgress = false;
-    float                               m_fCrashingDistort    = 0.5f;
-    wl_event_source*                    m_pCrashingLoop       = nullptr;
-    wl_event_source*                    m_pCursorTicker       = nullptr;
+    bool                            m_bCrashingInProgress = false;
+    float                           m_fCrashingDistort    = 0.5f;
+    wl_event_source*                m_pCrashingLoop       = nullptr;
+    wl_event_source*                m_pCursorTicker       = nullptr;
 
-    CTimer                              m_tRenderTimer;
+    CTimer                          m_tRenderTimer;
 
-    std::vector<SP<CWLSurfaceResource>> explicitPresented;
+    std::vector<CHLBufferReference> usedBuffers;
 
     struct {
         int                           hotspotX = 0;

src/render/Renderer.cpp

@@ -129,6 +129,11 @@ void CSurfacePassElement::draw(const CRegion& damage) {
     if (!g_pHyprRenderer->m_bBlockSurfaceFeedback)
         data.surface->presentFeedback(data.when, data.pMonitor->self.lock());
 
+    // add async (dmabuf) buffers to usedBuffers so we can handle release later
+    // sync (shm) buffers will be released in commitState, so no need to track them here
+    if (data.surface->current.buffer && !data.surface->current.buffer->isSynchronous())
+        g_pHyprRenderer->usedBuffers.emplace_back(data.surface->current.buffer);
+
     g_pHyprOpenGL->blend(true);
 }