Merge branch 'master' into balder/cleanup-distributormanagerconfig-1

9 files changed, 20 insertions, 266 deletions

diff --git a/storage/src/tests/distributor/distributor_stripe_test.cpp b/storage/src/tests/distributor/distributor_stripe_test.cpp
index 92cd3898886..a10e4ee6a0e 100644
--- a/storage/src/tests/distributor/distributor_stripe_test.cpp
+++ b/storage/src/tests/distributor/distributor_stripe_test.cpp
@@ -57,7 +57,7 @@ struct DistributorStripeTest : Test, DistributorStripeTestUtil {
         return _stripe->_bucketDBMetricUpdater.getMinimumReplicaCountingMode();
     }
 
-    std::string testOp(std::shared_ptr<api::StorageMessage> msg) {
+    std::string testOp(const std::shared_ptr<api::StorageMessage> & msg) {
         _stripe->handleMessage(msg);
 
         std::string tmp = _sender.getCommands();
@@ -83,8 +83,8 @@ struct DistributorStripeTest : Test, DistributorStripeTestUtil {
             std::vector<BucketCopy> changedNodes;
 
             vespalib::StringTokenizer tokenizer(states[i], ",");
-            for (uint32_t j = 0; j < tokenizer.size(); ++j) {
-                vespalib::StringTokenizer tokenizer2(tokenizer[j], ":");
+            for (auto token : tokenizer) {
+                vespalib::StringTokenizer tokenizer2(token, ":");
 
                 bool trusted = false;
                 if (tokenizer2.size() > 2) {
@@ -96,14 +96,7 @@ struct DistributorStripeTest : Test, DistributorStripeTestUtil {
                     removedNodes.push_back(node);
                 } else {
                     uint32_t checksum = atoi(tokenizer2[1].data());
-                    changedNodes.push_back(
-                            BucketCopy(
-                                    i + 1,
-                                    node,
-                                    api::BucketInfo(
-                                            checksum,
-                                            checksum / 2,
-                                            checksum / 4)).setTrusted(trusted));
+                    changedNodes.emplace_back(i + 1, node, api::BucketInfo(checksum, checksum / 2, checksum / 4)).setTrusted(trusted);
                 }
             }
 
@@ -112,9 +105,7 @@ struct DistributorStripeTest : Test, DistributorStripeTestUtil {
             uint32_t flags(DatabaseUpdate::CREATE_IF_NONEXISTING
                            | (resetTrusted ? DatabaseUpdate::RESET_TRUSTED : 0));
 
-            operation_context().update_bucket_database(makeDocumentBucket(document::BucketId(16, 1)),
-                                                       changedNodes,
-                                                       flags);
+            operation_context().update_bucket_database(makeDocumentBucket(document::BucketId(16, 1)), changedNodes, flags);
         }
 
         std::string retVal = dumpBucket(document::BucketId(16, 1));
@@ -122,8 +113,8 @@ struct DistributorStripeTest : Test, DistributorStripeTestUtil {
         return retVal;
     }
 
-    void assertBucketSpaceStats(size_t expBucketPending, size_t expBucketTotal, uint16_t node, const vespalib::string& bucketSpace,
-                                const BucketSpacesStatsProvider::PerNodeBucketSpacesStats& stats);
+    static void assertBucketSpaceStats(size_t expBucketPending, size_t expBucketTotal, uint16_t node, const vespalib::string& bucketSpace,
+                                       const BucketSpacesStatsProvider::PerNodeBucketSpacesStats& stats);
 
     SimpleMaintenanceScanner::PendingMaintenanceStats stripe_maintenance_stats() {
         return _stripe->pending_maintenance_stats();
@@ -175,12 +166,6 @@ struct DistributorStripeTest : Test, DistributorStripeTestUtil {
         });
     }
 
-    void configure_prioritize_global_bucket_merges(bool enabled) {
-        configure_stripe_with([&](auto& builder) {
-            builder.prioritizeGlobalBucketMerges = enabled;
-        });
-    }
-
     void configure_max_activation_inhibited_out_of_sync_groups(uint32_t n_groups) {
         configure_stripe_with([&](auto& builder) {
             builder.maxActivationInhibitedOutOfSyncGroups = n_groups;
@@ -471,43 +456,6 @@ TEST_F(DistributorStripeTest, update_bucket_database)
               updateBucketDB("0:456", "2:333", ResetTrusted(true)));
 }
 
-TEST_F(DistributorStripeTest, priority_config_is_propagated_to_distributor_configuration)
-{
-    using namespace vespa::config::content::core;
-
-    setup_stripe(Redundancy(2), NodeCount(2), "storage:2 distributor:1");
-
-    ConfigBuilder builder;
-    builder.priorityMergeMoveToIdealNode = 1;
-    builder.priorityMergeOutOfSyncCopies = 2;
-    builder.priorityMergeTooFewCopies = 3;
-    builder.priorityActivateNoExistingActive = 4;
-    builder.priorityActivateWithExistingActive = 5;
-    builder.priorityDeleteBucketCopy = 6;
-    builder.priorityJoinBuckets = 7;
-    builder.prioritySplitDistributionBits = 8;
-    builder.prioritySplitLargeBucket = 9;
-    builder.prioritySplitInconsistentBucket = 10;
-    builder.priorityGarbageCollection = 11;
-    builder.priorityMergeGlobalBuckets = 12;
-
-    configure_stripe(builder);
-
-    const auto& mp = getConfig().getMaintenancePriorities();
-    EXPECT_EQ(1, static_cast<int>(mp.mergeMoveToIdealNode));
-    EXPECT_EQ(2, static_cast<int>(mp.mergeOutOfSyncCopies));
-    EXPECT_EQ(3, static_cast<int>(mp.mergeTooFewCopies));
-    EXPECT_EQ(4, static_cast<int>(mp.activateNoExistingActive));
-    EXPECT_EQ(5, static_cast<int>(mp.activateWithExistingActive));
-    EXPECT_EQ(6, static_cast<int>(mp.deleteBucketCopy));
-    EXPECT_EQ(7, static_cast<int>(mp.joinBuckets));
-    EXPECT_EQ(8, static_cast<int>(mp.splitDistributionBits));
-    EXPECT_EQ(9, static_cast<int>(mp.splitLargeBucket));
-    EXPECT_EQ(10, static_cast<int>(mp.splitInconsistentBucket));
-    EXPECT_EQ(11, static_cast<int>(mp.garbageCollection));
-    EXPECT_EQ(12, static_cast<int>(mp.mergeGlobalBuckets));
-}
-
 TEST_F(DistributorStripeTest, no_db_resurrection_for_bucket_not_owned_in_pending_state) {
     setup_stripe(Redundancy(1), NodeCount(10), "storage:2 distributor:2");
     // Force new state into being the pending state. According to the initial
@@ -969,17 +917,6 @@ TEST_F(DistributorStripeTest, weak_internal_read_consistency_config_is_propagate
     EXPECT_FALSE(getExternalOperationHandler().use_weak_internal_read_consistency_for_gets());
 }
 
-TEST_F(DistributorStripeTest, prioritize_global_bucket_merges_config_is_propagated_to_internal_config)
-{
-    setup_stripe(Redundancy(1), NodeCount(1), "distributor:1 storage:1");
-
-    configure_prioritize_global_bucket_merges(true);
-    EXPECT_TRUE(getConfig().prioritize_global_bucket_merges());
-
-    configure_prioritize_global_bucket_merges(false);
-    EXPECT_FALSE(getConfig().prioritize_global_bucket_merges());
-}
-
 TEST_F(DistributorStripeTest, max_activation_inhibited_out_of_sync_groups_config_is_propagated_to_internal_config)
 {
     setup_stripe(Redundancy(1), NodeCount(1), "distributor:1 storage:1");
diff --git a/storage/src/tests/distributor/idealstatemanagertest.cpp b/storage/src/tests/distributor/idealstatemanagertest.cpp
index fbcc188a5da..0cadaa3fc9f 100644
--- a/storage/src/tests/distributor/idealstatemanagertest.cpp
+++ b/storage/src/tests/distributor/idealstatemanagertest.cpp
@@ -94,33 +94,6 @@ TEST_F(IdealStateManagerTest, status_page) {
               ost.str());
 }
 
-TEST_F(IdealStateManagerTest, disabled_state_checker) {
-    setup_stripe(1, 1, "distributor:1 storage:1");
-
-    auto cfg = make_config();
-    cfg->setSplitSize(100);
-    cfg->setSplitCount(1000000);
-    cfg->disableStateChecker("SplitBucket");
-    configure_stripe(cfg);
-
-    insertBucketInfo(document::BucketId(16, 5), 0, 0xff, 100, 200, true, true);
-    insertBucketInfo(document::BucketId(16, 2), 0, 0xff, 10, 10, true, true);
-
-    std::ostringstream ost;
-    getIdealStateManager().getBucketStatus(ost);
-
-    EXPECT_EQ(makeBucketStatusString(
-        "BucketId(0x4000000000000002) : [node(idx=0,crc=0xff,docs=10/10,bytes=10/10,trusted=true,active=true,ready=false)]<br>\n"
-         "<b>BucketId(0x4000000000000005):</b> <i> : split: [Splitting bucket because its maximum size (200 b, 100 docs, 100 meta, 200 b total) is "
-         "higher than the configured limit of (100, 1000000)]</i> [node(idx=0,crc=0xff,docs=100/100,bytes=200/200,trusted=true,"
-         "active=true,ready=false)]<br>\n"),
-         ost.str());
-
-    tick();
-    EXPECT_EQ("", active_ideal_state_operations());
-
-}
-
 TEST_F(IdealStateManagerTest, clear_active_on_node_down) {
     setSystemState(lib::ClusterState("distributor:1 storage:3"));
     for (int i = 1; i < 4; i++) {
diff --git a/storage/src/tests/distributor/statecheckerstest.cpp b/storage/src/tests/distributor/statecheckerstest.cpp
index 0f48440b5a1..a0d45292c1d 100644
--- a/storage/src/tests/distributor/statecheckerstest.cpp
+++ b/storage/src/tests/distributor/statecheckerstest.cpp
@@ -16,7 +16,6 @@
 #include <vespa/storageapi/message/stat.h>
 #include <vespa/vdslib/distribution/distribution.h>
 #include <vespa/vespalib/gtest/gtest.h>
-#include <gmock/gmock.h>
 
 using document::test::makeBucketSpace;
 using document::test::makeDocumentBucket;
@@ -175,7 +174,6 @@ struct StateCheckersTest : Test, DistributorStripeTestUtil {
         bool _includeMessagePriority {false};
         bool _includeSchedulingPriority {false};
         bool _merge_operations_disabled {false};
-        bool _prioritize_global_bucket_merges {true};
         bool _config_enable_default_space_merge_inhibition {false};
         bool _merges_inhibited_in_bucket_space {false};
         CheckerParams();
@@ -217,10 +215,6 @@ struct StateCheckersTest : Test, DistributorStripeTestUtil {
             _merge_operations_disabled = disabled;
             return *this;
         }
-        CheckerParams& prioritize_global_bucket_merges(bool enabled) noexcept {
-            _prioritize_global_bucket_merges = enabled;
-            return *this;
-        }
         CheckerParams& bucket_space(document::BucketSpace bucket_space) noexcept {
             _bucket_space = bucket_space;
             return *this;
@@ -246,7 +240,6 @@ struct StateCheckersTest : Test, DistributorStripeTestUtil {
         enable_cluster_state(params._clusterState);
         vespa::config::content::core::StorDistributormanagerConfigBuilder config;
         config.mergeOperationsDisabled = params._merge_operations_disabled;
-        config.prioritizeGlobalBucketMerges = params._prioritize_global_bucket_merges;
         config.inhibitDefaultMergesWhenGlobalMergesPending = params._config_enable_default_space_merge_inhibition;
         configure_stripe(config);
         if (!params._pending_cluster_state.empty()) {
@@ -734,7 +727,7 @@ TEST_F(StateCheckersTest, synchronize_and_move) {
             .clusterState("distributor:1 storage:4"));
 }
 
-TEST_F(StateCheckersTest, global_bucket_merges_have_very_high_priority_if_prioritization_enabled) {
+TEST_F(StateCheckersTest, global_bucket_merges_have_very_high_priority) {
     runAndVerify<SynchronizeAndMoveStateChecker>(
             CheckerParams().expect(
                             "[Synchronizing buckets with different checksums "
@@ -745,23 +738,7 @@ TEST_F(StateCheckersTest, global_bucket_merges_have_very_high_priority_if_priori
                     .bucketInfo("0=1,1=2")
                     .bucket_space(document::FixedBucketSpaces::global_space())
                     .includeSchedulingPriority(true)
-                    .includeMessagePriority(true)
-                    .prioritize_global_bucket_merges(true));
-}
-
-TEST_F(StateCheckersTest, global_bucket_merges_have_normal_priority_if_prioritization_disabled) {
-    runAndVerify<SynchronizeAndMoveStateChecker>(
-            CheckerParams().expect(
-                            "[Synchronizing buckets with different checksums "
-                            "node(idx=0,crc=0x1,docs=1/1,bytes=1/1,trusted=false,active=false,ready=false), "
-                            "node(idx=1,crc=0x2,docs=2/2,bytes=2/2,trusted=false,active=false,ready=false)] "
-                            "(pri 120) "
-                            "(scheduling pri MEDIUM)")
-                    .bucketInfo("0=1,1=2")
-                    .bucket_space(document::FixedBucketSpaces::global_space())
-                    .includeSchedulingPriority(true)
-                    .includeMessagePriority(true)
-                    .prioritize_global_bucket_merges(false));
+                    .includeMessagePriority(true));
 }
 
 // Upon entering a cluster state transition edge the distributor will
diff --git a/storage/src/vespa/storage/bucketdb/bucketinfo.h b/storage/src/vespa/storage/bucketdb/bucketinfo.h
index 8f9b3d3486a..8b37c50e00e 100644
--- a/storage/src/vespa/storage/bucketdb/bucketinfo.h
+++ b/storage/src/vespa/storage/bucketdb/bucketinfo.h
@@ -91,7 +91,7 @@ public:
     /**
      * Returns the number of nodes this entry has.
      */
-    uint32_t getNodeCount() const noexcept { return static_cast<uint32_t>(_nodes.size()); }
+    uint16_t getNodeCount() const noexcept { return static_cast<uint16_t>(_nodes.size()); }
 
     /**
      * Returns a list of the nodes this entry has.
diff --git a/storage/src/vespa/storage/config/distributorconfiguration.cpp b/storage/src/vespa/storage/config/distributorconfiguration.cpp
index 3169e2b5b2f..a855ea578ef 100644
--- a/storage/src/vespa/storage/config/distributorconfiguration.cpp
+++ b/storage/src/vespa/storage/config/distributorconfiguration.cpp
@@ -45,7 +45,6 @@ DistributorConfiguration::DistributorConfiguration(StorageComponent& component)
       _merge_operations_disabled(false),
       _use_weak_internal_read_consistency_for_client_gets(false),
       _enable_metadata_only_fetch_phase_for_inconsistent_updates(false),
-      _prioritize_global_bucket_merges(true),
       _implicitly_clear_priority_on_schedule(false),
       _use_unordered_merge_chaining(false),
       _inhibit_default_merges_when_global_merges_pending(false),
@@ -94,25 +93,6 @@ DistributorConfiguration::containsTimeStatement(const std::string& documentSelec
     return visitor.hasCurrentTime;
 }
 
-void
-DistributorConfiguration::configureMaintenancePriorities(
-        const vespa::config::content::core::StorDistributormanagerConfig& cfg)
-{
-    MaintenancePriorities& mp(_maintenancePriorities);
-    mp.mergeMoveToIdealNode       = cfg.priorityMergeMoveToIdealNode;
-    mp.mergeOutOfSyncCopies       = cfg.priorityMergeOutOfSyncCopies;
-    mp.mergeTooFewCopies          = cfg.priorityMergeTooFewCopies;
-    mp.mergeGlobalBuckets         = cfg.priorityMergeGlobalBuckets;
-    mp.activateNoExistingActive   = cfg.priorityActivateNoExistingActive;
-    mp.activateWithExistingActive = cfg.priorityActivateWithExistingActive;
-    mp.deleteBucketCopy           = cfg.priorityDeleteBucketCopy;
-    mp.joinBuckets                = cfg.priorityJoinBuckets;
-    mp.splitDistributionBits      = cfg.prioritySplitDistributionBits;
-    mp.splitLargeBucket           = cfg.prioritySplitLargeBucket;
-    mp.splitInconsistentBucket    = cfg.prioritySplitInconsistentBucket;
-    mp.garbageCollection          = cfg.priorityGarbageCollection;
-}
-
 void 
 DistributorConfiguration::configure(const vespa::config::content::core::StorDistributormanagerConfig& config) 
 {
@@ -152,11 +132,6 @@ DistributorConfiguration::configure(const vespa::config::content::core::StorDist
       _garbageCollectionInterval = vespalib::duration::zero();
     }
 
-    _blockedStateCheckers.clear();
-    for (uint32_t i = 0; i < config.blockedstatecheckers.size(); ++i) {
-        _blockedStateCheckers.insert(config.blockedstatecheckers[i]);
-    }
-
     _doInlineSplit = config.inlinebucketsplitting;
     _enableJoinForSiblingLessBuckets = config.enableJoinForSiblingLessBuckets;
     _enableInconsistentJoin = config.enableInconsistentJoin;
@@ -169,7 +144,6 @@ DistributorConfiguration::configure(const vespa::config::content::core::StorDist
     _merge_operations_disabled = config.mergeOperationsDisabled;
     _use_weak_internal_read_consistency_for_client_gets = config.useWeakInternalReadConsistencyForClientGets;
     _enable_metadata_only_fetch_phase_for_inconsistent_updates = config.enableMetadataOnlyFetchPhaseForInconsistentUpdates;
-    _prioritize_global_bucket_merges = config.prioritizeGlobalBucketMerges;
     _max_activation_inhibited_out_of_sync_groups = config.maxActivationInhibitedOutOfSyncGroups;
     _implicitly_clear_priority_on_schedule = config.implicitlyClearBucketPriorityOnSchedule;
     _use_unordered_merge_chaining = config.useUnorderedMergeChaining;
@@ -177,11 +151,8 @@ DistributorConfiguration::configure(const vespa::config::content::core::StorDist
     _enable_two_phase_garbage_collection = config.enableTwoPhaseGarbageCollection;
     _enable_condition_probing = config.enableConditionProbing;
     _enable_operation_cancellation = config.enableOperationCancellation;
-
     _minimumReplicaCountingMode = config.minimumReplicaCountingMode;
 
-    configureMaintenancePriorities(config);
-
     if (config.maxClusterClockSkewSec >= 0) {
         _maxClusterClockSkew = std::chrono::seconds(config.maxClusterClockSkewSec);
     }
diff --git a/storage/src/vespa/storage/config/distributorconfiguration.h b/storage/src/vespa/storage/config/distributorconfiguration.h
index 0f286d4bf0a..6a5ea9e3bbd 100644
--- a/storage/src/vespa/storage/config/distributorconfiguration.h
+++ b/storage/src/vespa/storage/config/distributorconfiguration.h
@@ -10,21 +10,20 @@
 namespace storage {
 
 class DistributorConfiguration {
-public: 
+public:
+    DistributorConfiguration(const DistributorConfiguration& other) = delete;
+    DistributorConfiguration& operator=(const DistributorConfiguration& other) = delete;
     explicit DistributorConfiguration(StorageComponent& component);
     ~DistributorConfiguration();
 
-    struct MaintenancePriorities
-    {
-        // Defaults for these are chosen as those used as the current (non-
-        // configurable) values at the time of implementation.
-        uint8_t mergeMoveToIdealNode {120};
+    struct MaintenancePriorities {
+        uint8_t mergeMoveToIdealNode {165};
         uint8_t mergeOutOfSyncCopies {120};
         uint8_t mergeTooFewCopies {120};
         uint8_t mergeGlobalBuckets {115};
         uint8_t activateNoExistingActive {100};
         uint8_t activateWithExistingActive {100};
-        uint8_t deleteBucketCopy {100};
+        uint8_t deleteBucketCopy {120};
         uint8_t joinBuckets {155};
         uint8_t splitDistributionBits {200};
         uint8_t splitLargeBucket {175};
@@ -55,14 +54,6 @@ public:
         _lastGarbageCollectionChange = lastChangeTime;
     }
 
-    bool stateCheckerIsActive(vespalib::stringref stateCheckerName) const {
-        return _blockedStateCheckers.find(stateCheckerName) == _blockedStateCheckers.end();
-    }
-
-    void disableStateChecker(vespalib::stringref stateCheckerName) {
-        _blockedStateCheckers.insert(stateCheckerName);
-    }
-
     void setDoInlineSplit(bool value) {
         _doInlineSplit = value;
     }
@@ -243,10 +234,6 @@ public:
         return _max_consecutively_inhibited_maintenance_ticks;
     }
 
-    bool prioritize_global_bucket_merges() const noexcept {
-        return _prioritize_global_bucket_merges;
-    }
-
     void set_max_activation_inhibited_out_of_sync_groups(uint32_t max_groups) noexcept {
         _max_activation_inhibited_out_of_sync_groups = max_groups;
     }
@@ -287,9 +274,6 @@ public:
     bool containsTimeStatement(const std::string& documentSelection) const;
     
 private:
-    DistributorConfiguration(const DistributorConfiguration& other);
-    DistributorConfiguration& operator=(const DistributorConfiguration& other);
-    
     StorageComponent& _component;
     
     uint32_t _byteCountSplitLimit;
@@ -310,8 +294,6 @@ private:
     uint32_t _minPendingMaintenanceOps;
     uint32_t _maxPendingMaintenanceOps;
 
-    vespalib::hash_set<vespalib::string> _blockedStateCheckers;
-
     uint32_t _maxVisitorsPerNodePerClientVisitor;
     uint32_t _minBucketsPerVisitor;
 
@@ -332,7 +314,6 @@ private:
     bool _merge_operations_disabled;
     bool _use_weak_internal_read_consistency_for_client_gets;
     bool _enable_metadata_only_fetch_phase_for_inconsistent_updates;
-    bool _prioritize_global_bucket_merges;
     bool _implicitly_clear_priority_on_schedule;
     bool _use_unordered_merge_chaining;
     bool _inhibit_default_merges_when_global_merges_pending;
@@ -341,9 +322,6 @@ private:
     bool _enable_operation_cancellation;
 
     DistrConfig::MinimumReplicaCountingMode _minimumReplicaCountingMode;
-
-    void configureMaintenancePriorities(
-            const vespa::config::content::core::StorDistributormanagerConfig&);
 };
 
 }
diff --git a/storage/src/vespa/storage/config/stor-distributormanager.def b/storage/src/vespa/storage/config/stor-distributormanager.def
index 8c4f1d5bb17..3136a54d080 100644
--- a/storage/src/vespa/storage/config/stor-distributormanager.def
+++ b/storage/src/vespa/storage/config/stor-distributormanager.def
@@ -39,18 +39,6 @@ garbagecollection.interval int default=0
 ## If false, dont do splits inline with feeding.
 inlinebucketsplitting bool default=true
 
-## List of state checkers (ideal state generators) that should be ignored in the cluster.
-## One or more of the following (case insensitive):
-##
-## SynchronizeAndMove
-## DeleteExtraCopies
-## JoinBuckets
-## SplitBucket
-## SplitInconsistentBuckets
-## SetBucketState
-## GarbageCollection
-blockedstatecheckers[] string restart
-
 ## Maximum nodes involved in a merge operation. Currently, this can not be more
 ## than 16 nodes due to protocol limitations. However, decreasing the max may
 ## be useful if 16 node merges ends up too expensive.
@@ -60,60 +48,6 @@ maximum_nodes_per_merge int default=16
 ## distributor thread to be able to call tick() manually and run single threaded
 start_distributor_thread bool default=true restart
 
-## The number of ticks calls done before a wait is done.  This can be
-## set higher than 10 for the distributor to improve speed of bucket iterations
-## while still keep CPU load low/moderate.
-ticks_before_wait int default=10
-
-## Allow overriding default priorities of certain maintenance operations.
-## This is an advanced feature, do not touch this unless you have a very good
-## reason to do so! Configuring these values wrongly may cause starvation of
-## important operations, leading to unpredictable behavior and/or data loss.
-##
-## Merge used to move data to ideal location
-priority_merge_move_to_ideal_node int default=165
-
-## Merge for copies that have gotten out of sync with each other
-priority_merge_out_of_sync_copies int default=120
-
-## Merge for restoring redundancy of copies
-priority_merge_too_few_copies int default=120
-
-## Merge that involves a global bucket. There are generally significantly fewer such
-## buckets than default-space buckets, and searches to documents in the default space
-## may depend on the presence of (all) global documents. Consequently, this priority
-## should be higher (i.e. numerically smaller) than that of regular merges.
-priority_merge_global_buckets int default=115
-
-## Copy activation when there are no other active copies (likely causing
-## lack of search coverage for that bucket)
-priority_activate_no_existing_active int default=100
-
-## Copy activation when there is already an active copy for the bucket.
-priority_activate_with_existing_active int default=100
-
-## Deletion of bucket copy.
-priority_delete_bucket_copy int default=120
-
-## Joining caused by bucket siblings getting sufficiently small to fit into a
-## single bucket.
-priority_join_buckets int default=155
-
-## Splitting caused by system increasing its minimum distribution bit count.
-priority_split_distribution_bits int default=200
-
-## Splitting due to bucket exceeding max document count or byte size (see
-## splitcount and splitsize config values)
-priority_split_large_bucket int default=175
-
-## Splitting due to buckets being inconsistently split. Should be higher
-## priority than the vast majority of external load.
-priority_split_inconsistent_bucket int default=110
-
-## Background garbage collection. Should be lower priority than external load
-## and other ideal state operations (aside from perhaps minimum bit splitting).
-priority_garbage_collection int default=200
-
 ## The distributor can send joins that "lift" a bucket without any siblings
 ## higher up in the bucket tree hierarchy. The assumption is that if this
 ## is done for all sibling-less buckets, they will all eventually reach a
@@ -237,15 +171,6 @@ enable_metadata_only_fetch_phase_for_inconsistent_updates bool default=true
 ## accesses when the distributor is heavily loaded with feed operations.
 max_consecutively_inhibited_maintenance_ticks int default=20
 
-## If set, pending merges to buckets in the global bucket space will be prioritized
-## higher than merges to buckets in the default bucket space. This ensures that global
-## documents will be kept in sync without being starved by non-global documents.
-## Note that enabling this feature risks starving default bucket space merges if a
-## resource exhaustion case prevents global merges from completing.
-## This is a live config for that reason, i.e. it can be disabled in an emergency
-## situation if needed.
-prioritize_global_bucket_merges bool default=true
-
 ## If set, activation of bucket replicas is limited to only those replicas that have
 ## bucket info consistent with a majority of the other replicas for that bucket.
 ## Multiple active replicas is only a feature that is enabled for grouped clusters,
diff --git a/storage/src/vespa/storage/distributor/idealstatemanager.cpp b/storage/src/vespa/storage/distributor/idealstatemanager.cpp
index 65e036282d3..0f5d0e48f5a 100644
--- a/storage/src/vespa/storage/distributor/idealstatemanager.cpp
+++ b/storage/src/vespa/storage/distributor/idealstatemanager.cpp
@@ -71,11 +71,6 @@ IdealStateManager::runStateCheckers(const StateChecker::Context& c) const
     // We go through _all_ active state checkers so that statistics can be
     // collected across all checkers, not just the ones that are highest pri.
     for (const auto & checker : _stateCheckers) {
-        if (!operation_context().distributor_config().stateCheckerIsActive(checker->getName())) {
-            LOG(spam, "Skipping state checker %s", checker->getName());
-            continue;
-        }
-
         auto result = checker->check(c);
         if (canOverwriteResult(highestPri, result)) {
             highestPri = std::move(result);
@@ -146,7 +141,7 @@ IdealStateManager::generateInterceptingSplit(BucketSpace bucketSpace, const Buck
     c.set_entry(e);
 
     IdealStateOperation::UP operation(_splitBucketStateChecker->check(c).createOperation());
-    if (operation.get()) {
+    if (operation) {
         operation->setPriority(pri);
         operation->setIdealStateManager(this);
     }
@@ -159,7 +154,7 @@ IdealStateManager::generate(const document::Bucket& bucket) const
 {
     NodeMaintenanceStatsTracker statsTracker;
     IdealStateOperation::SP op(generateHighestPriority(bucket, statsTracker).createOperation());
-    if (op.get()) {
+    if (op) {
         op->setIdealStateManager(const_cast<IdealStateManager*>(this));
     }
     return op;
diff --git a/storage/src/vespa/storage/distributor/statecheckers.cpp b/storage/src/vespa/storage/distributor/statecheckers.cpp
index 97641ae86a6..86790a2ddb7 100644
--- a/storage/src/vespa/storage/distributor/statecheckers.cpp
+++ b/storage/src/vespa/storage/distributor/statecheckers.cpp
@@ -721,7 +721,7 @@ checkForNodesMissingFromIdealState(const StateChecker::Context& c)
                 if (c.idealState().size() > c.entry()->getNodeCount()) {
                     ret.markMissingReplica(node, mp.mergeTooFewCopies);
                 } else {
-                    ret.markMoveToIdealLocation(node,mp.mergeMoveToIdealNode);
+                    ret.markMoveToIdealLocation(node, mp.mergeMoveToIdealNode);
                 }
                 c.stats.incCopyingIn(node, c.getBucketSpace());
                 hasMissingReplica = true;
@@ -807,9 +807,7 @@ SynchronizeAndMoveStateChecker::check(const Context &c) const
                                                    c.distributorConfig.getMaxNodesPerMerge());
         op->setDetailedReason(result.reason());
         MaintenancePriority::Priority schedPri;
-        if ((c.getBucketSpace() == document::FixedBucketSpaces::default_space())
-            || !c.distributorConfig.prioritize_global_bucket_merges())
-        {
+        if (c.getBucketSpace() == document::FixedBucketSpaces::default_space()) {
             schedPri = (result.needsMoveOnly() ? MaintenancePriority::LOW : MaintenancePriority::MEDIUM);
             op->setPriority(result.priority());
         } else {