MB-40531: Allow VBucketVisitors to specify vbucket order

In a future patch, the item pager will specify a specific order to
visit vbuckets, to avoid eviction favouring early vbucket IDs.

To support that, vb visitors can now define an order the vbuckets will
be visited in.

Change-Id: Ib66685844c4609442f5d727f79c77d26cca713b3
Reviewed-on: http://review.couchbase.org/c/kv_engine/+/136627
Well-Formed: Build Bot <[email protected]>
Reviewed-by: Paolo Cocchi <[email protected]>
Tested-by: James Harrison <[email protected]>

Author: jameseh96

engines/ep/src/comparators.h

@@ -0,0 +1,67 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2020 Couchbase, Inc
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#pragma once
+
+namespace cb {
+/**
+ * Function object which returns true if lhs > rhs.
+ * Equivalent to std::greater, but without having to pull in all of <functional>
+ */
+template <typename T>
+struct greater {
+    constexpr bool operator()(const T& lhs, const T& rhs) const {
+        return lhs > rhs;
+    }
+};
+
+/**
+ * Function object which returns true if lhs >= rhs.
+ * Equivalent to std::greater_equal, but without having to pull in all of
+ * <functional>
+ */
+template <typename T>
+struct greater_equal {
+    constexpr bool operator()(const T& lhs, const T& rhs) const {
+        return lhs >= rhs;
+    }
+};
+
+/**
+ * Function object which returns true if lhs < rhs.
+ * Equivalent to std::less, but without having to pull in all of
+ * <functional>
+ */
+template <typename T>
+struct less {
+    constexpr bool operator()(const T& lhs, const T& rhs) const {
+        return lhs < rhs;
+    }
+};
+
+/**
+ * Function object which returns true if lhs <= rhs.
+ * Equivalent to std::less_equal, but without having to pull in all of
+ * <functional>
+ */
+template <typename T>
+struct less_equal {
+    constexpr bool operator()(const T& lhs, const T& rhs) const {
+        return lhs <= rhs;
+    }
+};
+} // namespace cb

engines/ep/src/kv_bucket.cc

@@ -2329,6 +2329,17 @@ VBCBAdaptor::VBCBAdaptor(KVBucket* s,
       label(l),
       maxDuration(std::chrono::microseconds::max()),
       currentvb(0) {
+    // populate the list of vbuckets to visit, and order them as needed by
+    // the visitor.
+    for (Vbid::id_type vbid = 0; vbid < store->getVBuckets().getSize();
+         ++vbid) {
+        if (visitor->getVBucketFilter()(Vbid(vbid))) {
+            vbucketsToVisit.emplace_front(vbid);
+        }
+    }
+    std::sort(vbucketsToVisit.begin(),
+              vbucketsToVisit.end(),
+              visitor->getVBucketComparator());
 }
 
 std::string VBCBAdaptor::getDescription() {
@@ -2337,19 +2348,19 @@ std::string VBCBAdaptor::getDescription() {
 
 bool VBCBAdaptor::run() {
     visitor->begin();
-    for (; currentvb < store->getVBuckets().getSize(); currentvb++) {
-        const auto vbid = Vbid(currentvb);
-        if (!visitor->getVBucketFilter()(vbid)) {
-            continue;
-        }
+
+    while (!vbucketsToVisit.empty()) {
+        const auto vbid = vbucketsToVisit.front();
         VBucketPtr vb = store->getVBucket(vbid);
         if (vb) {
+            currentvb = vbid.get();
             if (visitor->pauseVisitor()) {
                 snooze(0);
                 return true;
             }
             visitor->visitBucket(vb);
         }
+        vbucketsToVisit.pop_front();
     }
     visitor->complete();
 

engines/ep/src/kv_bucket.h

@@ -79,6 +79,14 @@ class VBCBAdaptor : public GlobalTask {
     const char                 *label;
     std::chrono::microseconds maxDuration;
 
+    /**
+     * VBuckets the visitor has not yet visited.
+     * Vbs will be sorted according to visitor->getVBucketComparator().
+     * Once visited, vbuckets will be removed, so the visitor can resume after
+     * pausing at the first element.
+     */
+    std::deque<Vbid> vbucketsToVisit;
+
     /**
      * Current VBucket.
      * RelaxedAtomic as this is used by getDescription to generate the task

engines/ep/src/monotonic.h

@@ -17,6 +17,8 @@
 
 #pragma once
 
+#include "comparators.h"
+
 #include <atomic>
 #include <limits>
 #include <stdexcept>
@@ -75,31 +77,6 @@ using DefaultOrderReversedPolicy = ThrowExceptionPolicy<T>;
 using DefaultOrderReversedPolicy = IgnorePolicy<T>;
 #endif
 
-namespace cb {
-/**
- * Function object which returns true if lhs > rhs.
- * Equivalent to std::greater, but without having to pull in all of <functional>
- */
-template <typename T>
-struct greater {
-    constexpr bool operator()(const T& lhs, const T& rhs) const {
-        return lhs > rhs;
-    }
-};
-
-/**
- * Function object which returns true if lhs >= rhs.
- * Equivalent to std::greater_equal, but without having to pull in all of
- * <functional>
- */
-template <typename T>
-struct greater_equal {
-    constexpr bool operator()(const T& lhs, const T& rhs) const {
-        return lhs >= rhs;
-    }
-};
-} // namespace cb
-
 /**
  * Monotonic is a class template for simple types T. It provides guarantee
  * of updating the class objects by only values that are greater than what is

engines/ep/src/vb_visitors.h

@@ -17,6 +17,7 @@
 
 #pragma once
 
+#include "comparators.h"
 #include "hash_table.h"
 #include "vb_filter.h"
 #include "vbucket_fwd.h"
@@ -62,6 +63,18 @@ class VBucketVisitor {
         vBucketFilter = std::move(filter);
     }
 
+    /**
+     * Get a comparator used to order the vbucket IDs based on visitor-specific
+     * criteria, if necessary. This can be used to specify the order the visitor
+     * wishes to visit vbuckets.
+     *
+     * Default behaviour is to visit vbuckets in ascending order.
+     */
+    virtual std::function<bool(const Vbid&, const Vbid&)> getVBucketComparator()
+            const {
+        return cb::less<Vbid>();
+    }
+
 protected:
     VBucketFilter vBucketFilter;
 };