commit 1fdd22e3351665aaa3c5da6608bcf7ceb507d5c8
author Kaiyi Li <kaiyili@google.com> Thu Mar 31 10:17:23 2022 -0700
committer Kaiyi Li <kaiyili@google.com> Wed Jun 01 16:30:05 2022 -0700
tree cee73960dd9a940df721f297004b437d188a5e69
parent f0e721deafe4e70b43ade5423e765a211189fe52

gfxstream renderer: always use VirtioGpuTimelines to manage fences

Change-Id: I9e37d8ee4adc0ee74ec6a9a7d48512fbe6f5cc38

stream-servers/VirtioGpuTimelines.cpp

diff --git a/stream-servers/VirtioGpuTimelines.cpp b/stream-servers/VirtioGpuTimelines.cpp
index 2953703..d71642b 100644
--- a/stream-servers/VirtioGpuTimelines.cpp
+++ b/stream-servers/VirtioGpuTimelines.cpp
@@ -19,34 +19,41 @@
 #include "host-common/GfxstreamFatalError.h"
 
 using TaskId = VirtioGpuTimelines::TaskId;
-using CtxId = VirtioGpuTimelines::CtxId;
+using Ring = VirtioGpuTimelines::Ring;
 using FenceId = VirtioGpuTimelines::FenceId;
 using AutoLock = android::base::AutoLock;
 using emugl::ABORT_REASON_OTHER;
 using emugl::FatalError;
 
-VirtioGpuTimelines::VirtioGpuTimelines() : mNextId(0) {}
+std::unique_ptr<VirtioGpuTimelines> VirtioGpuTimelines::create(bool withAsyncCallback) {
+    return std::unique_ptr<VirtioGpuTimelines>(new VirtioGpuTimelines(withAsyncCallback));
+}
 
-TaskId VirtioGpuTimelines::enqueueTask(CtxId ctxId) {
+VirtioGpuTimelines::VirtioGpuTimelines(bool withAsyncCallback)
+    : mNextId(0), mWithAsyncCallback(withAsyncCallback) {}
+
+TaskId VirtioGpuTimelines::enqueueTask(const Ring& ring) {
     AutoLock lock(mLock);
 
     TaskId id = mNextId++;
-    std::shared_ptr<Task> task(new Task(id, ctxId), [this](Task *task) {
+    std::shared_ptr<Task> task(new Task(id, ring), [this](Task* task) {
         mTaskIdToTask.erase(task->mId);
         delete task;
     });
     mTaskIdToTask[id] = task;
-    mTimelineQueues[ctxId].emplace_back(std::move(task));
+    mTimelineQueues[ring].emplace_back(std::move(task));
     return id;
 }
 
-void VirtioGpuTimelines::enqueueFence(
-    CtxId ctxId, FenceId, FenceCompletionCallback fenceCompletionCallback) {
+void VirtioGpuTimelines::enqueueFence(const Ring& ring, FenceId,
+                                      FenceCompletionCallback fenceCompletionCallback) {
     AutoLock lock(mLock);
 
     auto fence = std::make_unique<Fence>(fenceCompletionCallback);
-    mTimelineQueues[ctxId].emplace_back(std::move(fence));
-    poll_locked(ctxId);
+    mTimelineQueues[ring].emplace_back(std::move(fence));
+    if (mWithAsyncCallback) {
+        poll_locked(ring);
+    }
 }
 
 void VirtioGpuTimelines::notifyTaskCompletion(TaskId taskId) {
@@ -71,14 +78,26 @@
             << "Task(id = " << static_cast<uint64_t>(taskId) << ") has been set to completed.";
     }
     task->mHasCompleted = true;
-    poll_locked(task->mCtxId);
+    if (mWithAsyncCallback) {
+        poll_locked(task->mRing);
+    }
 }
 
-void VirtioGpuTimelines::poll_locked(CtxId ctxId) {
-    auto iTimelineQueue = mTimelineQueues.find(ctxId);
+void VirtioGpuTimelines::poll() {
+    if (mWithAsyncCallback) {
+        GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER))
+            << "Can't call poll with async callback enabled.";
+    }
+    AutoLock lock(mLock);
+    for (const auto& [ring, timeline] : mTimelineQueues) {
+        poll_locked(ring);
+    }
+}
+void VirtioGpuTimelines::poll_locked(const Ring& ring) {
+    auto iTimelineQueue = mTimelineQueues.find(ring);
     if (iTimelineQueue == mTimelineQueues.end()) {
         GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER))
-            << "Context(id = " << ctxId << " doesn't exist";
+            << "Ring(" << to_string(ring) << ") doesn't exist.";
     }
     std::list<TimelineItem> &timelineQueue = iTimelineQueue->second;
     auto i = timelineQueue.begin();