Add a new method to QueryConditionCache that determines whether the cached

query conditions need to be updated based on changes to underlying data or
configuration. This improves query performance by avoiding unnecessary cache
rebuilds while ensuring data consistency when conditions change. The method
also helps reduce unnecessary lock contention, improving concurrency in
multi-threaded query environments.

Performance improvements:
- Reduces the "native_queued_spin_lock_slowpath" hotspot of entry->mutex
  from 76% to 1% with Clickbench Q10 on a 2 x 240 vCPUs system
- Increases QPS for Q10 and Q11 by 85% and 89% respectively
- Improves overall performance across 43 queries with a geometric mean gain
  of 8.1%

Signed-off-by: Jiebin Sun <[email protected]>
Reviewed-by: Wangyang Guo <[email protected]>

Author: jiebinn

src/Interpreters/Cache/QueryConditionCache.cpp

@@ -18,6 +18,34 @@ QueryConditionCache::QueryConditionCache(const String & cache_policy, size_t max
 {
 }
 
+inline bool QueryConditionCache::needUpdate(const std::shared_ptr<Entry> & entry, const MarkRanges & mark_ranges, size_t marks_count, bool has_final_mark) const
+{
+    // If no marks to process, we may only need to update the final mark
+    if (mark_ranges.empty()) {
+        // Only acquire the lock and check final mark when has_final_mark is true
+        std::shared_lock read_lock(entry->mutex);
+        // Return true (update needed) only if final mark needs to be set to false
+        return has_final_mark && entry->matching_marks[marks_count - 1];
+    }
+    else {
+        // Acquire shared lock for read access to the matching_marks vector
+        std::shared_lock read_lock(entry->mutex);
+
+        // Check if any mark within the ranges is still true
+        for (const auto & mark_range : mark_ranges) {
+            if (std::find(
+                entry->matching_marks.begin() + mark_range.begin,
+                entry->matching_marks.begin() + mark_range.end,
+                true) != (entry->matching_marks.begin() + mark_range.end)) {
+                    return true;  // Found at least one true mark in range, need update
+                }
+        }
+
+        // If all marks in ranges are already false, check if final mark needs update
+        return has_final_mark && entry->matching_marks[marks_count - 1];
+    }
+}
+
 void QueryConditionCache::write(
     const UUID & table_id, const String & part_name, size_t condition_hash, const String & condition,
     const MarkRanges & mark_ranges, size_t marks_count, bool has_final_mark)
@@ -27,6 +55,10 @@ void QueryConditionCache::write(
     auto load_func = [&](){ return std::make_shared<Entry>(marks_count); };
     auto [entry, inserted] = cache.getOrSet(key, load_func);
 
+    // Skip update if not needed - optimization to avoid unnecessary locks and updates
+    if (!needUpdate(entry, mark_ranges, marks_count, has_final_mark))
+        return;
+
     std::lock_guard lock(entry->mutex);
 
     chassert(marks_count == entry->matching_marks.size());

src/Interpreters/Cache/QueryConditionCache.h

@@ -71,6 +71,21 @@ class QueryConditionCache
         size_t operator()(const Entry & entry) const;
     };
 
+    /**
+     * Check if we need to update the cache entry.
+     * This function determines whether a cache update is necessary by examining:
+     * 1. Whether the mark ranges are empty
+     * 2. Whether marks in specified ranges are already set to false
+     * 3. Whether the final mark (if applicable) is already set correctly
+     *
+     * @param entry The cache entry to check
+     * @param mark_ranges The ranges of marks to potentially update
+     * @param marks_count Total number of marks in the entry
+     * @param has_final_mark Flag indicating if the final mark needs special handling
+     * @return true if an update is needed, false if we can skip the update
+     */
+    inline bool needUpdate(const std::shared_ptr<Entry> & entry, const MarkRanges & mark_ranges, size_t marks_count, bool has_final_mark) const;
+
 public:
     using Cache = CacheBase<Key, Entry, KeyHasher, QueryConditionCacheEntryWeight>;