fix(priorityqueue): avoid unnecessary copies

Author: Tom94

CMakeLists.txt

@@ -188,6 +188,7 @@ set(TEV_SOURCES
     include/tev/Ipc.h src/Ipc.cpp
     include/tev/Lazy.h src/Lazy.cpp
     include/tev/MultiGraph.h src/MultiGraph.cpp
+    include/tev/PriorityQueue.h src/PriorityQueue.cpp
     include/tev/SharedQueue.h src/SharedQueue.cpp
     include/tev/Task.h src/Task.cpp
     include/tev/ThreadPool.h src/ThreadPool.cpp

include/tev/BackgroundImagesLoader.h

@@ -20,6 +20,7 @@
 
 #include <tev/Common.h>
 #include <tev/Image.h>
+#include <tev/PriorityQueue.h>
 #include <tev/SharedQueue.h>
 #include <tev/imageio/ImageLoader.h>
 
@@ -76,7 +77,7 @@ class BackgroundImagesLoader {
 private:
     SharedQueue<ImageAddition> mLoadedImages;
 
-    std::priority_queue<ImageAddition, std::vector<ImageAddition>, ImageAddition::Comparator> mPendingLoadedImages;
+    PriorityQueue<ImageAddition, ImageAddition::Comparator> mPendingLoadedImages;
     mutable std::mutex mPendingLoadedImagesMutex;
 
     std::atomic<int> mLoadCounter{0};

include/tev/PriorityQueue.h

@@ -0,0 +1,67 @@
+/*
+ * tev -- the EDR viewer
+ *
+ * Copyright (C) 2025 Thomas Müller <contact@tom94.net>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include <algorithm>
+#include <stdexcept>
+#include <utility>
+#include <vector>
+
+namespace tev {
+
+template <typename T, typename Cmp = std::less<T>> class PriorityQueue {
+    std::vector<T> mData;
+    Cmp mCmp;
+
+public:
+    explicit PriorityQueue(Cmp cmp = Cmp{}) : mCmp{cmp} {}
+
+    template <typename Iter> PriorityQueue(Iter first, Iter last, Cmp cmp = Cmp{}) : mData{first, last}, mCmp{cmp} {
+        std::make_heap(mData.begin(), mData.end(), mCmp);
+    }
+
+    void push(const T& val) {
+        mData.push_back(val);
+        std::push_heap(mData.begin(), mData.end(), mCmp);
+    }
+
+    void push(T&& val) {
+        mData.push_back(std::move(val));
+        std::push_heap(mData.begin(), mData.end(), mCmp);
+    }
+
+    T pop() {
+        if (mData.empty()) {
+            throw std::runtime_error{"pop from empty queue"};
+        }
+
+        std::pop_heap(mData.begin(), mData.end(), mCmp);
+        T val = std::move(mData.back());
+        mData.pop_back();
+        return val;
+    }
+
+    const T& top() const & { return mData.front(); }
+    T& top() & { return mData.front(); }
+
+    bool empty() const { return mData.empty(); }
+    std::size_t size() const { return mData.size(); }
+};
+
+} // namespace tev

include/tev/SharedQueue.h

@@ -39,12 +39,18 @@ template <typename T> class SharedQueue {
         return mRawQueue.size();
     }
 
-    void push(T newElem) {
+    void push(const T& newElem) {
         std::lock_guard lock{mMutex};
         mRawQueue.push_back(newElem);
         mDataCondition.notify_one();
     }
 
+    void push(T&& newElem) {
+        std::lock_guard lock{mMutex};
+        mRawQueue.push_back(std::move(newElem));
+        mDataCondition.notify_one();
+    }
+
     T waitAndPop() {
         std::unique_lock lock{mMutex};
 

include/tev/ThreadPool.h

@@ -19,6 +19,7 @@
 #pragma once
 
 #include <tev/Common.h>
+#include <tev/PriorityQueue.h>
 #include <tev/Task.h>
 
 #include <concurrentqueue/concurrentqueue.h> // Needs to be included before lightweightsemaphore.h
@@ -28,7 +29,6 @@
 #include <concepts>
 #include <functional>
 #include <future>
-#include <queue>
 #include <thread>
 #include <vector>
 
@@ -183,7 +183,7 @@ class ThreadPool {
         };
     };
 
-    std::priority_queue<QueuedTask, std::vector<QueuedTask>, QueuedTask::Comparator> mTaskQueue;
+    PriorityQueue<QueuedTask, QueuedTask::Comparator> mTaskQueue;
     std::recursive_mutex mTaskQueueMutex;
 
     // Significantly faster than C++20's std::semaphore implementation on some platforms

src/BackgroundImagesLoader.cpp

@@ -126,14 +126,8 @@ bool BackgroundImagesLoader::publishSortedLoads() {
     const lock_guard lock{mPendingLoadedImagesMutex};
     bool pushed = false;
     while (!mPendingLoadedImages.empty() && mPendingLoadedImages.top().loadId == mLoadCounter) {
-        // null image pointers indicate failed loads. These shouldn't be pushed.
-        if (!mPendingLoadedImages.top().images.empty()) {
-            mLoadedImages.push(mPendingLoadedImages.top());
-        }
-
-        mPendingLoadedImages.pop();
+        mLoadedImages.push(mPendingLoadedImages.pop());
         pushed = true;
-
         ++mLoadCounter;
     }
 

src/ImageViewer.cpp

@@ -1304,6 +1304,7 @@ void ImageViewer::draw_contents() {
             } else {
                 addImage(image, shallSelect);
             }
+
             first = false;
         }
     }

src/PriorityQueue.cpp

@@ -0,0 +1,23 @@
+/*
+ * tev -- the EDR viewer
+ *
+ * Copyright (C) 2025 Thomas Müller <contact@tom94.net>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <tev/PriorityQueue.h>
+
+namespace tev {
+
+}

src/ThreadPool.cpp

@@ -64,8 +64,7 @@ void ThreadPool::startThreads(size_t num) {
                     const scoped_lock taskQueueLock{mTaskQueueMutex};
                     TEV_ASSERT(!mTaskQueue.empty(), "Task queue was empty after semaphore wait.");
 
-                    task = std::move(mTaskQueue.top());
-                    mTaskQueue.pop();
+                    task = mTaskQueue.pop();
                 }
 
                 task.fun();