Use 50% load factor for fDigestForPackedGlyphID table

In certain workloads (e.g. Speedometer3, Editor-TipTap) the
hash-table lookup becomes very expensive and may require up to 25 probes (specifically for `fDigestForPackedGlyphID`). From local
experiments I see that this is not the problem of the hash function,
but rather the load faсtor of the HashTable, which is currently hardcoded to 75%.

The CL provides a way to customize this behaviour by adding an
optional `ShouldGrow(size, capacity)` function into `Traits`. The
function is also specialized for `fDigestForPackedGlyphID` to have
the load factor of 50%. This significantly reduces the number of extra
probes, increasing the ratio of 0-probe hits from 88% to 97% on the
overall Speedometer3 benchmark. No more than 5 probes are required.

The CL improves the Editor-TipTap Speedometer3 story by 1.3%.

Change-Id: Iedda0710839448e8df98d649456a168104488272
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/939016
Commit-Queue: Anton Bikineev <[email protected]>
Reviewed-by: Michael Ludwig <[email protected]>
Reviewed-by: Ben Wagner <[email protected]>

Author: Anton Bikineev

src/core/SkGlyph.h

@@ -372,6 +372,15 @@ class SkGlyphDigest {
     static uint32_t Hash(SkPackedGlyphID packedID) {
         return packedID.hash();
     }
+    static bool ShouldGrow(int count, int capacity) {
+        // Having the 50% load factor results in performance improvements and significantly reduces
+        // the average number of probes on the Speedometer3 Editor-TipTap benchmark.
+        return 2 * count >= capacity;
+    }
+    static bool ShouldShrink(int count, int capacity) {
+        // Use 1/6 as the minimal load.
+        return 6 * count <= capacity;
+    }
 
 private:
     void setAction(skglyph::ActionType actionType, skglyph::GlyphAction action) {

src/core/SkTHash.h

@@ -27,6 +27,10 @@ namespace skia_private {
 // Traits must have:
 //   - static K GetKey(T)
 //   - static uint32_t Hash(K)
+// Traits may also define (both required if either is defined):
+//   - static bool ShouldGrow(int count, int capacity)
+//   - static bool ShouldShrink(int count, int capacity)
+// , which specify the max/min load factor of the table.
 // If the key is large and stored inside T, you may want to make K a const&.
 // Similarly, if T is large you might want it to be a pointer.
 template <typename T, typename K, typename Traits = T>
@@ -98,7 +102,13 @@ class THashTable {
     // Copy val into the hash table, returning a pointer to the copy now in the table.
     // If there already is an entry in the table with the same key, we overwrite it.
     T* set(T val) {
-        if (4 * fCount >= 3 * fCapacity) {
+        bool shouldGrow = false;
+        if constexpr (HasShouldGrow<Traits>::value) {
+            shouldGrow = Traits::ShouldGrow(fCount, fCapacity);
+        } else {
+            shouldGrow = (4 * fCount >= 3 * fCapacity);
+        }
+        if (shouldGrow) {
             this->resize(fCapacity > 0 ? fCapacity * 2 : 4);
         }
         return this->uncheckedSet(std::move(val));
@@ -143,8 +153,16 @@ class THashTable {
             }
             if (hash == s.fHash && key == Traits::GetKey(*s)) {
                 this->removeSlot(index);
-                if (4 * fCount <= fCapacity && fCapacity > 4) {
-                    this->resize(fCapacity / 2);
+                if (fCapacity > 4) {
+                    bool shouldShrink = false;
+                    if constexpr (HasShouldShrink<Traits>::value) {
+                        shouldShrink = Traits::ShouldShrink(fCount, fCapacity);
+                    } else {
+                        shouldShrink = (4 * fCount <= fCapacity);
+                    }
+                    if (shouldShrink) {
+                        this->resize(fCapacity / 2);
+                    }
                 }
                 return true;
             }
@@ -192,7 +210,14 @@ class THashTable {
     // - Hash tables grow when they exceed 3/4 capacity, not when they are full.
     void reserve(int n) {
         int newCapacity = SkNextPow2(n);
-        if (n * 4 > newCapacity * 3) {
+
+        bool shouldGrow = false;
+        if constexpr (HasShouldGrow<Traits>::value) {
+            shouldGrow = Traits::ShouldGrow(n, newCapacity);
+        } else {
+            shouldGrow = (n * 4 > newCapacity * 3);
+        }
+        if (shouldGrow) {
             newCapacity *= 2;
         }
 
@@ -274,6 +299,27 @@ class THashTable {
     };
 
 private:
+    template <typename U, typename = void> struct HasShouldGrow : std::false_type {};
+    template <typename U, typename = void> struct HasShouldShrink : std::false_type {};
+
+    template <typename U>
+    struct HasShouldGrow<
+            U,
+            std::void_t<decltype(U::ShouldGrow(std::declval<int>(), std::declval<int>()))>>
+            : std::true_type {
+        static_assert(HasShouldShrink<U>::value,
+                      "The traits class must also provide ShouldShrink() method.");
+    };
+
+    template <typename U>
+    struct HasShouldShrink<
+            U,
+            std::void_t<decltype(U::ShouldShrink(std::declval<int>(), std::declval<int>()))>>
+            : std::true_type {
+        static_assert(HasShouldGrow<U>::value,
+                      "The traits class must also provide ShouldGrow() method.");
+    };
+
     // Finds the first non-empty slot for an iterator.
     int firstPopulatedSlot() const {
         for (int i = 0; i < fCapacity; i++) {