MB-40531: [BP] Allow VBucketVisitors to specify vbucket order

Backport of http://review.couchbase.org/c/kv_engine/+/137339/

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/+/137665
Well-Formed: Build Bot <[email protected]>
Tested-by: Build Bot <[email protected]>
Reviewed-by: Dave Rigby <[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

@@ -2226,19 +2226,24 @@ VBCBAdaptor::VBCBAdaptor(KVBucket* s,
       sleepTime(sleep),
       maxDuration(std::chrono::microseconds::max()),
       currentvb(0) {
+    // populate the list of vbuckets to visit, and order them as needed by
+    // the visitor.
     const VBucketFilter& vbFilter = visitor->getVBucketFilter();
     for (auto vbid : store->getVBuckets().getBuckets()) {
         if (vbFilter(vbid)) {
-            vbList.push(vbid);
+            vbList.push_back(vbid);
         }
     }
+    std::sort(vbList.begin(),
+              vbList.end(),
+              visitor->getVBucketComparator());
 }
 
 std::string VBCBAdaptor::getDescription() {
     return std::string(label) + " on vb " + std::to_string(currentvb.load());
 }
 
-bool VBCBAdaptor::run(void) {
+bool VBCBAdaptor::run() {
     if (!vbList.empty()) {
         currentvb.store(vbList.front());
         VBucketPtr vb = store->getVBucket(currentvb);
@@ -2249,7 +2254,7 @@ bool VBCBAdaptor::run(void) {
             }
             visitor->visitBucket(vb);
         }
-        vbList.pop();
+        vbList.pop_front();
     }
 
     bool isdone = vbList.empty();

engines/ep/src/kv_bucket.h

@@ -62,13 +62,26 @@ class VBCBAdaptor : public GlobalTask {
     bool run(void);
 
 private:
-    std::queue<uint16_t>        vbList;
-    KVBucket  *store;
+    /**
+     * 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<VBucket::id_type> vbList;
+    KVBucket* store;
     std::unique_ptr<VBucketVisitor> visitor;
     const char                 *label;
     double                      sleepTime;
     std::chrono::microseconds maxDuration;
-    std::atomic<uint16_t>       currentvb;
+
+    /**
+     * Current VBucket.
+     * RelaxedAtomic as this is used by getDescription to generate the task
+     * description, which can be called by threads other than the one executing.
+     */
+    Couchbase::RelaxedAtomic<VBucket::id_type> currentvb;
 
     DISALLOW_COPY_AND_ASSIGN(VBCBAdaptor);
 };

engines/ep/src/monotonic.h

@@ -17,6 +17,8 @@
 
 #pragma once
 
+#include "comparators.h"
+
 #include <atomic>
 #include <functional>
 #include <limits>

engines/ep/src/vb_visitors.h

@@ -19,6 +19,7 @@
 
 #include "config.h"
 
+#include "comparators.h"
 #include "hash_table.h"
 #include "vb_filter.h"
 
@@ -50,6 +51,18 @@ class VBucketVisitor {
         return vBucketFilter;
     }
 
+    /**
+     * 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 uint16_t&, const uint16_t&)>
+    getVBucketComparator() const {
+        return cb::less<uint16_t>();
+    }
+
     /**
      * Called after all vbuckets have been visited.
      */