for tile prioritization use an integer priority with a small set of l…

…evels

drops specific check of readonly viewers and combining factors in
general.

Signed-off-by: Caolán McNamara <caolan.mcnamara@collabora.com>
Change-Id: Ib2911e956e295ecaf92474bd222e5c30d470b702

kit/ChildSession.cpp

@@ -1275,35 +1275,34 @@ bool ChildSession::clientVisibleArea(const StringVector& tokens)
     return true;
 }
 
-float ChildSession::getTilePriority(const TileDesc &tile) const
+TilePrioritizer::Priority ChildSession::getTilePriority(const TileDesc &tile) const
 {
-    float score = tile.intersects(_clientVisibleArea) ? 2.0 : 1.0;
-
-    // most important to render things close to the cursor fast
-    if (tile.getPart() == _currentPart)
-    {
-        if (tile.intersects(_cursorPosition))
-            score *= 2.0;
-
-        // pre-loading near the viewing area is also more important than far away
-        Util::Rectangle r = tile.toAABBox();
-        // grow in each direction
-        Util::Rectangle enlarged =
-            Util::Rectangle::create(r.getLeft() - r.getWidth(), r.getTop() - r.getHeight(),
-                                    r.getRight() + r.getWidth(), r.getBottom() + r.getHeight());
-        if (enlarged.intersects(_clientVisibleArea))
-            score *= 2.0;
-    }
-
-    // previews are less interesting
+    // previews are least interesting
     if (tile.isPreview())
-        score /= 2.0;
+        return TilePrioritizer::Priority::LOWEST;
 
-    // readonly viewers are also less high priority
-    else if (isReadOnly())
-        score /= 2;
+    // different part less interesting than session's current part
+    if (tile.getPart() != _currentPart)
+        return TilePrioritizer::Priority::LOW;
 
-    return score;
+    // most important to render things close to the cursor fast
+    if (tile.intersects(_cursorPosition))
+        return TilePrioritizer::Priority::ULTRAHIGH;
+
+    // inside viewing area more important than outside it
+    if (tile.intersects(_clientVisibleArea))
+        return TilePrioritizer::Priority::VERYHIGH;
+
+    // pre-loading near the viewing area is also more important than far away
+    Util::Rectangle r = tile.toAABBox();
+    // grow in each direction
+    Util::Rectangle enlarged =
+        Util::Rectangle::create(r.getLeft() - r.getWidth(), r.getTop() - r.getHeight(),
+                                r.getRight() + r.getWidth(), r.getBottom() + r.getHeight());
+    if (enlarged.intersects(_clientVisibleArea))
+        return TilePrioritizer::Priority::HIGH;
+
+    return TilePrioritizer::Priority::NORMAL;
 }
 
 bool ChildSession::outlineState(const StringVector& tokens)

kit/ChildSession.hpp

@@ -157,7 +157,7 @@ class ChildSession final : public Session
 
     std::string getViewRenderState() { return _viewRenderState; }
 
-    float getTilePriority(const TileDesc &desc) const;
+    TilePrioritizer::Priority getTilePriority(const TileDesc &desc) const;
 
     void saveLogUiBackground()
 #if defined(BUILDING_TESTS)

kit/Kit.cpp

@@ -2287,9 +2287,9 @@ bool Document::forwardToChild(const std::string& prefix, const std::vector<char>
     return std::string();
 }
 
-float Document::getTilePriority(const TileDesc &desc) const
+TilePrioritizer::Priority Document::getTilePriority(const TileDesc &desc) const
 {
-    float maxPrio = std::numeric_limits<float>::min();
+    TilePrioritizer::Priority maxPrio = TilePrioritizer::Priority::NONE;
 
     assert(_sessions.size() > 0);
     for (const auto& it : _sessions)
@@ -2300,9 +2300,9 @@ float Document::getTilePriority(const TileDesc &desc) const
         if (session->getCanonicalViewId() != desc.getNormalizedViewId())
             continue;
 
-        maxPrio = std::max<int>(maxPrio, session->getTilePriority(desc));
+        maxPrio = std::max(maxPrio, session->getTilePriority(desc));
     }
-    if (maxPrio == std::numeric_limits<float>::min())
+    if (maxPrio == TilePrioritizer::Priority::NONE)
         LOG_WRN("No sessions match this viewId " << desc.getNormalizedViewId());
     // LOG_TRC("Priority for tile " << desc.generateID() << " is " << maxPrio);
     return maxPrio;
@@ -2490,11 +2490,12 @@ void Document::drainQueue()
 
         if (canRenderTiles())
         {
-            float prio = 8; // visible & intersect with an active viewport
-            while (!_queue->isTileQueueEmpty() && prio >= 8)
+            // Priority for tiles of visible part that intersect with an active viewport
+            TilePrioritizer::Priority prio = TilePrioritizer::Priority::VERYHIGH;
+            while (!_queue->isTileQueueEmpty() && prio >= TilePrioritizer::Priority::VERYHIGH)
             {
                 TileCombined tileCombined = _queue->popTileQueue(prio);
-                LOG_TRC("Tile priority is " << prio << " for " << tileCombined.serialize());
+                LOG_TRC("Tile priority is " << static_cast<int>(prio) << " for " << tileCombined.serialize());
 
                 renderTiles(tileCombined);
             }

kit/Kit.hpp

@@ -270,7 +270,7 @@ class Document final : public std::enable_shared_from_this<Document>, private Ti
     static void reapZombieChildren();
 
     /// Calculate tile rendering priority from a TileDesc
-    virtual float getTilePriority(const TileDesc &desc) const override;
+    virtual Priority getTilePriority(const TileDesc &desc) const override;
     virtual std::vector<ViewIdInactivity> getViewIdsByInactivity() const override;
 
 public:

kit/KitQueue.cpp

@@ -440,7 +440,7 @@ KitQueue::Payload KitQueue::pop()
     return front;
 }
 
-TileCombined KitQueue::popTileQueue(float &priority)
+TileCombined KitQueue::popTileQueue(TilePrioritizer::Priority &priority)
 {
     assert(!isTileQueueEmpty());
 
@@ -481,7 +481,7 @@ TileCombined KitQueue::popTileQueue(float &priority)
     return popTileQueue(*tileQueue, priority);
 }
 
-TileCombined KitQueue::popTileQueue(std::vector<TileDesc>& tileQueue, float &priority)
+TileCombined KitQueue::popTileQueue(std::vector<TileDesc>& tileQueue, TilePrioritizer::Priority &priority)
 {
     assert(!tileQueue.empty());
 
@@ -495,12 +495,12 @@ TileCombined KitQueue::popTileQueue(std::vector<TileDesc>& tileQueue, float &pri
     // We are handling a tile; first try to find one that is at the cursor's
     // position, otherwise handle the one that is at the front
     int prioritized = 0;
-    float prioritySoFar = -1000.0;
+    TilePrioritizer::Priority prioritySoFar = TilePrioritizer::Priority::NONE;
     for (size_t i = 0; i < tileQueue.size(); ++i)
     {
         auto& prio = tileQueue[i];
 
-        const float p = _prio.getTilePriority(prio);
+        const TilePrioritizer::Priority p = _prio.getTilePriority(prio);
         if (p > prioritySoFar)
         {
             prioritySoFar = p;

kit/KitQueue.hpp

@@ -26,7 +26,18 @@ class TilePrioritizer
 {
 public:
     virtual ~TilePrioritizer() {}
-    virtual float getTilePriority(const TileDesc &) const { return 0.0; }
+
+    enum class Priority {
+        NONE = -1,  // an error
+        LOWEST = 0,
+        LOW,
+        NORMAL,
+        HIGH,
+        VERYHIGH,
+        ULTRAHIGH
+    };
+    virtual Priority getTilePriority(const TileDesc &) const { return Priority::NORMAL; }
+
     typedef std::pair<int, float> ViewIdInactivity;
     virtual std::vector<ViewIdInactivity> getViewIdsByInactivity() const { return {}; }
 };
@@ -91,7 +102,7 @@ class KitQueue
     void pushTileCombineRequest(const Payload &value);
     /// Pops the highest priority TileCombined from the
     /// render queue, with it's priority.
-    TileCombined popTileQueue(float &priority);
+    TileCombined popTileQueue(TilePrioritizer::Priority& priority);
     size_t getTileQueueSize() const;
     bool isTileQueueEmpty() const;
 
@@ -173,7 +184,7 @@ class KitQueue
 
     std::vector<TileDesc>* getTileQueue(int viewid);
     std::vector<TileDesc>& ensureTileQueue(int viewid);
-    TileCombined popTileQueue(std::vector<TileDesc>& tileQueue, float &priority);
+    TileCombined popTileQueue(std::vector<TileDesc>& tileQueue, TilePrioritizer::Priority &priority);
 
 private:
     /// Queue of incoming messages from coolwsd

kit/TestStubs.cpp

@@ -23,7 +23,7 @@ void ChildSession::loKitCallback(const int /* type */, const std::string& /* pay
 void ChildSession::disconnect() {}
 int ChildSession::getSpeed() { return 0; }
 bool ChildSession::_handleInput(const char* /*buffer*/, int /*length*/) { return false; }
-float ChildSession::getTilePriority(const TileDesc &) const { return 0; }
+TilePrioritizer::Priority ChildSession::getTilePriority(const TileDesc &) const { return TilePrioritizer::Priority::NORMAL; }
 ChildSession::~ChildSession() {}
 
 int simd_initPixRowSimd(const uint32_t *, uint32_t *, size_t *, uint64_t *) { return 0; }

test/KitQueueTests.cpp

@@ -183,10 +183,10 @@ void KitQueueTests::testViewOrder()
 
     class TestPrioritizer : public TilePrioritizer {
     public:
-        virtual float getTilePriority(const TileDesc &) const
+        virtual Priority getTilePriority(const TileDesc &) const
         {
             // FIXME: implement cursor priority hooks.
-            return 0.0;
+            return Priority::NORMAL;
         }
     };
     TestPrioritizer dummy;