Merge pull request #28022 from vespa-engine/balder/cheaper-split-nodes-into-leaf-groups

Balder/cheaper split nodes into leaf groups

12 files changed, 232 insertions, 340 deletions

diff --git a/storage/src/tests/distributor/distributor_stripe_test_util.cpp b/storage/src/tests/distributor/distributor_stripe_test_util.cpp
index 7a64eda28ff..6ececa39583 100644
--- a/storage/src/tests/distributor/distributor_stripe_test_util.cpp
+++ b/storage/src/tests/distributor/distributor_stripe_test_util.cpp
@@ -40,34 +40,22 @@ DistributorStripeTestUtil::createLinks()
     _node = std::make_unique<TestDistributorApp>(_config.getConfigId());
     _metrics = std::make_shared<DistributorMetricSet>();
     _ideal_state_metrics = std::make_shared<IdealStateMetricSet>();
-    _stripe = std::make_unique<DistributorStripe>(_node->getComponentRegister(),
-                                                  *_metrics,
-                                                  *_ideal_state_metrics,
-                                                  _node->node_identity(),
-                                                  _messageSender,
-                                                  *this,
-                                                  _done_initializing);
+    _stripe = std::make_unique<DistributorStripe>(_node->getComponentRegister(), *_metrics, *_ideal_state_metrics,
+                                                  _node->node_identity(), _messageSender, *this, _done_initializing);
 }
 
 void
-DistributorStripeTestUtil::setup_stripe(int redundancy,
-                                        int nodeCount,
-                                        const std::string& systemState,
-                                        uint32_t earlyReturn,
-                                        bool requirePrimaryToBeWritten)
+DistributorStripeTestUtil::setup_stripe(int redundancy, int nodeCount, const std::string& systemState,
+                                        uint32_t earlyReturn, bool requirePrimaryToBeWritten)
 {
     setup_stripe(redundancy, nodeCount, lib::ClusterStateBundle(lib::ClusterState(systemState)), earlyReturn, requirePrimaryToBeWritten);
 }
 
 void
-DistributorStripeTestUtil::setup_stripe(int redundancy,
-                                        int node_count,
-                                        const lib::ClusterStateBundle& state,
-                                        uint32_t early_return,
-                                        bool require_primary_to_be_written)
+DistributorStripeTestUtil::setup_stripe(int redundancy, int node_count, const lib::ClusterStateBundle& state,
+                                        uint32_t early_return, bool require_primary_to_be_written)
 {
-    lib::Distribution::DistributionConfigBuilder config(
-            lib::Distribution::getDefaultDistributionConfig(redundancy, node_count).get());
+    lib::Distribution::DistributionConfigBuilder config(lib::Distribution::getDefaultDistributionConfig(redundancy, node_count).get());
     config.redundancy = redundancy;
     config.initialRedundancy = early_return;
     config.ensurePrimaryPersisted = require_primary_to_be_written;
@@ -93,8 +81,7 @@ DistributorStripeTestUtil::setup_stripe(int redundancy,
 void
 DistributorStripeTestUtil::set_redundancy(uint32_t redundancy)
 {
-    auto distribution = std::make_shared<lib::Distribution>(
-            lib::Distribution::getDefaultDistributionConfig(redundancy, 100));
+    auto distribution = std::make_shared<lib::Distribution>(lib::Distribution::getDefaultDistributionConfig(redundancy, 100));
     // Same rationale for not triggering a full distribution change as
     // in setup_stripe() above
     _node->getComponentRegister().setDistribution(distribution);
@@ -217,8 +204,7 @@ DistributorStripeTestUtil::getIdealStr(document::BucketId id, const lib::Cluster
     }
 
     std::vector<uint16_t> nodes;
-    getDistribution().getIdealNodes(
-            lib::NodeType::STORAGE, state, id, nodes);
+    getDistribution().getIdealNodes(lib::NodeType::STORAGE, state, id, nodes, "uim");
     std::sort(nodes.begin(), nodes.end());
     std::ostringstream ost;
     ost << id << ": " << dumpVector(nodes);
@@ -226,8 +212,7 @@ DistributorStripeTestUtil::getIdealStr(document::BucketId id, const lib::Cluster
 }
 
 void
-DistributorStripeTestUtil::addIdealNodes(const lib::ClusterState& state,
-                                         const document::BucketId& id)
+DistributorStripeTestUtil::addIdealNodes(const lib::ClusterState& state, const document::BucketId& id)
 {
     BucketDatabase::Entry entry = getBucket(id);
 
@@ -236,15 +221,11 @@ DistributorStripeTestUtil::addIdealNodes(const lib::ClusterState& state,
     }
 
     std::vector<uint16_t> res;
-    getDistribution().getIdealNodes(
-            lib::NodeType::STORAGE, state, id, res);
+    getDistribution().getIdealNodes(lib::NodeType::STORAGE, state, id, res, "uim");
 
     for (uint32_t i = 0; i < res.size(); ++i) {
-        if (state.getNodeState(lib::Node(lib::NodeType::STORAGE, res[i])).getState() !=
-            lib::State::MAINTENANCE)
-        {
-            entry->addNode(BucketCopy(0, res[i], api::BucketInfo(1,1,1)),
-                           toVector<uint16_t>(0));
+        if (state.getNodeState(lib::Node(lib::NodeType::STORAGE, res[i])).getState() != lib::State::MAINTENANCE) {
+            entry->addNode(BucketCopy(0, res[i], api::BucketInfo(1,1,1)), toVector<uint16_t>(0));
         }
     }
 
@@ -292,10 +273,7 @@ DistributorStripeTestUtil::addNodesToBucketDB(const document::Bucket& bucket, co
         }
 
         uint16_t idx = atoi(tok2[0].data());
-        BucketCopy node(
-                0,
-                idx,
-                info);
+        BucketCopy node(0, idx, info);
 
         // Allow user to manually override trusted and active.
         if (tok3.size() > flagsIdx && tok3[flagsIdx] == "t") {
@@ -309,44 +287,32 @@ DistributorStripeTestUtil::addNodesToBucketDB(const document::Bucket& bucket, co
 }
 
 void
-DistributorStripeTestUtil::addNodesToBucketDB(const document::BucketId& id,
-                                              const std::string& nodeStr)
-{
+DistributorStripeTestUtil::addNodesToBucketDB(const document::BucketId& id, const std::string& nodeStr) {
     addNodesToBucketDB(document::Bucket(makeBucketSpace(), id), nodeStr);
 }
 
 void
-DistributorStripeTestUtil::removeFromBucketDB(const document::BucketId& id)
-{
+DistributorStripeTestUtil::removeFromBucketDB(const document::BucketId& id) {
     getBucketDatabase().remove(id);
 }
 
 void
-DistributorStripeTestUtil::addIdealNodes(const document::BucketId& id)
-{
+DistributorStripeTestUtil::addIdealNodes(const document::BucketId& id) {
     // TODO STRIPE roundabout way of getting state bundle..!
     addIdealNodes(*operation_context().cluster_state_bundle().getBaselineClusterState(), id);
 }
 
 void
-DistributorStripeTestUtil::insertBucketInfo(document::BucketId id,
-                                            uint16_t node,
-                                            uint32_t checksum,
-                                            uint32_t count,
-                                            uint32_t size,
-                                            bool trusted,
-                                            bool active)
+DistributorStripeTestUtil::insertBucketInfo(document::BucketId id, uint16_t node, uint32_t checksum,
+                                            uint32_t count, uint32_t size, bool trusted, bool active)
 {
     api::BucketInfo info(checksum, count, size);
     insertBucketInfo(id, node, info, trusted, active);
 }
 
 void
-DistributorStripeTestUtil::insertBucketInfo(document::BucketId id,
-                                            uint16_t node,
-                                            const api::BucketInfo& info,
-                                            bool trusted,
-                                            bool active)
+DistributorStripeTestUtil::insertBucketInfo(document::BucketId id, uint16_t node, const api::BucketInfo& info,
+                                            bool trusted, bool active)
 {
     BucketDatabase::Entry entry = getBucketDatabase().get(id);
     if (!entry.valid()) {
@@ -358,9 +324,7 @@ DistributorStripeTestUtil::insertBucketInfo(document::BucketId id,
         info2.setActive();
     }
     BucketCopy copy(operation_context().generate_unique_timestamp(), node, info2);
-
     entry->addNode(copy.setTrusted(trusted), toVector<uint16_t>(0));
-
     getBucketDatabase().update(entry);
 }
 
@@ -371,9 +335,7 @@ DistributorStripeTestUtil::dumpBucket(const document::BucketId& bid)
 }
 
 void
-DistributorStripeTestUtil::sendReply(Operation& op,
-                                     int idx,
-                                     api::ReturnCode::Result result)
+DistributorStripeTestUtil::sendReply(Operation& op, int idx, api::ReturnCode::Result result)
 {
     if (idx == -1) {
         idx = _sender.commands().size() - 1;
@@ -387,20 +349,17 @@ DistributorStripeTestUtil::sendReply(Operation& op,
 }
 
 BucketDatabase::Entry
-DistributorStripeTestUtil::getBucket(const document::Bucket& bucket) const
-{
+DistributorStripeTestUtil::getBucket(const document::Bucket& bucket) const {
     return getBucketDatabase(bucket.getBucketSpace()).get(bucket.getBucketId());
 }
 
 BucketDatabase::Entry
-DistributorStripeTestUtil::getBucket(const document::BucketId& bId) const
-{
+DistributorStripeTestUtil::getBucket(const document::BucketId& bId) const {
     return getBucketDatabase().get(bId);
 }
 
 void
-DistributorStripeTestUtil::disableBucketActivationInConfig(bool disable)
-{
+DistributorStripeTestUtil::disableBucketActivationInConfig(bool disable) {
     ConfigBuilder builder;
     builder.disableBucketActivation = disable;
     configure_stripe(builder);
@@ -437,14 +396,12 @@ DistributorStripeTestUtil::doc_selection_parser() const {
 }
 
 DistributorMetricSet&
-DistributorStripeTestUtil::metrics()
-{
+DistributorStripeTestUtil::metrics() {
     return *_metrics;
 }
 
 bool
-DistributorStripeTestUtil::tick()
-{
+DistributorStripeTestUtil::tick() {
     return _stripe->tick();
 }
 
@@ -553,8 +510,7 @@ DistributorStripeTestUtil::getBucketSpaces() const
 void
 DistributorStripeTestUtil::enable_cluster_state(vespalib::stringref state)
 {
-    getBucketDBUpdater().simulate_cluster_state_bundle_activation(
-            lib::ClusterStateBundle(lib::ClusterState(state)));
+    getBucketDBUpdater().simulate_cluster_state_bundle_activation(lib::ClusterStateBundle(lib::ClusterState(state)));
 }
 
 void
diff --git a/storage/src/tests/distributor/top_level_bucket_db_updater_test.cpp b/storage/src/tests/distributor/top_level_bucket_db_updater_test.cpp
index 567e0a947da..7eb9dfe6269 100644
--- a/storage/src/tests/distributor/top_level_bucket_db_updater_test.cpp
+++ b/storage/src/tests/distributor/top_level_bucket_db_updater_test.cpp
@@ -65,12 +65,9 @@ public:
         close();
     }
 
-    std::shared_ptr<RequestBucketInfoReply> make_fake_bucket_reply(
-            const lib::ClusterState& state,
-            const RequestBucketInfoCommand& cmd,
-            int storageIndex,
-            uint32_t bucketCount,
-            uint32_t invalidBucketCount = 0)
+    std::shared_ptr<RequestBucketInfoReply>
+    make_fake_bucket_reply(const lib::ClusterState& state, const RequestBucketInfoCommand& cmd,
+                           int storageIndex, uint32_t bucketCount,uint32_t invalidBucketCount = 0)
     {
         auto sreply = std::make_shared<RequestBucketInfoReply>(cmd);
         sreply->setAddress(storage_address(storageIndex));
@@ -84,19 +81,14 @@ public:
             }
 
             std::vector<uint16_t> nodes;
-            distributor_bucket_space(bucket).getDistribution().getIdealNodes(
-                    lib::NodeType::STORAGE, state, bucket, nodes);
+            distributor_bucket_space(bucket).getDistribution().getIdealNodes(lib::NodeType::STORAGE, state, bucket, nodes, "uim");
 
             for (uint32_t j = 0; j < nodes.size(); ++j) {
                 if (nodes[j] == storageIndex) {
                     if (i >= bucketCount) {
-                        vec.push_back(api::RequestBucketInfoReply::Entry(
-                                document::BucketId(16, i),
-                                api::BucketInfo()));
+                        vec.emplace_back(document::BucketId(16, i), api::BucketInfo());
                     } else {
-                        vec.push_back(api::RequestBucketInfoReply::Entry(
-                                document::BucketId(16, i),
-                                api::BucketInfo(10,1,1)));
+                        vec.emplace_back(document::BucketId(16, i), api::BucketInfo(10,1,1));
                     }
                 }
             }
@@ -105,45 +97,34 @@ public:
         return sreply;
     }
 
-    void fake_bucket_reply(const lib::ClusterState &state,
-                           const api::StorageCommand &cmd,
-                           uint32_t bucket_count,
-                           uint32_t invalid_bucket_count = 0)
+    void fake_bucket_reply(const lib::ClusterState &state, const api::StorageCommand &cmd,
+                           uint32_t bucket_count, uint32_t invalid_bucket_count = 0)
     {
         ASSERT_EQ(cmd.getType(), MessageType::REQUESTBUCKETINFO);
         const api::StorageMessageAddress& address(*cmd.getAddress());
         bucket_db_updater().onRequestBucketInfoReply(
-                make_fake_bucket_reply(state,
-                                       dynamic_cast<const RequestBucketInfoCommand &>(cmd),
-                                       address.getIndex(),
-                                       bucket_count,
-                                       invalid_bucket_count));
+                make_fake_bucket_reply(state, dynamic_cast<const RequestBucketInfoCommand &>(cmd),
+                                       address.getIndex(), bucket_count, invalid_bucket_count));
     }
 
-    void fake_bucket_reply(const lib::ClusterState &state,
-                           const api::StorageCommand &cmd,
-                           uint32_t bucket_count,
+    void fake_bucket_reply(const lib::ClusterState &state, const api::StorageCommand &cmd, uint32_t bucket_count,
                            const std::function<void(api::RequestBucketInfoReply&)>& reply_decorator)
     {
         ASSERT_EQ(cmd.getType(), MessageType::REQUESTBUCKETINFO);
         const api::StorageMessageAddress& address(*cmd.getAddress());
-        auto reply = make_fake_bucket_reply(state,
-                                            dynamic_cast<const RequestBucketInfoCommand &>(cmd),
-                                            address.getIndex(),
-                                            bucket_count, 0);
+        auto reply = make_fake_bucket_reply(state, dynamic_cast<const RequestBucketInfoCommand &>(cmd),
+                                            address.getIndex(), bucket_count, 0);
         reply_decorator(*reply);
         bucket_db_updater().onRequestBucketInfoReply(reply);
     }
 
-    void send_fake_reply_for_single_bucket_request(
-            const api::RequestBucketInfoCommand& rbi)
+    void send_fake_reply_for_single_bucket_request(const api::RequestBucketInfoCommand& rbi)
     {
         ASSERT_EQ(size_t(1), rbi.getBuckets().size());
         const document::BucketId& bucket(rbi.getBuckets()[0]);
 
         auto reply = std::make_shared<api::RequestBucketInfoReply>(rbi);
-        reply->getBucketInfo().push_back(
-                api::RequestBucketInfoReply::Entry(bucket, api::BucketInfo(20, 10, 12, 50, 60, true, true)));
+        reply->getBucketInfo().emplace_back(bucket, api::BucketInfo(20, 10, 12, 50, 60, true, true));
         stripe_of_bucket(bucket).bucket_db_updater().onRequestBucketInfoReply(reply);
     }
 
@@ -154,15 +135,11 @@ public:
         }
 
         std::vector<uint16_t> nodes;
-        distributor_bucket_space(id).getDistribution().getIdealNodes(
-                lib::NodeType::STORAGE, state, document::BucketId(id), nodes);
+        distributor_bucket_space(id).getDistribution().getIdealNodes(lib::NodeType::STORAGE, state, document::BucketId(id), nodes, "uim");
 
         if (nodes.size() != entry->getNodeCount()) {
-            return vespalib::make_string("Bucket Id %s has %d nodes in "
-                                         "ideal state, but has only %d in DB",
-                                         id.toString().c_str(),
-                                         (int)nodes.size(),
-                                         (int)entry->getNodeCount());
+            return vespalib::make_string("Bucket Id %s has %d nodes in ideal state, but has only %d in DB",
+                                         id.toString().c_str(), (int)nodes.size(), (int)entry->getNodeCount());
         }
 
         for (uint32_t i = 0; i<nodes.size(); i++) {
@@ -175,10 +152,7 @@ public:
             }
 
             if (!found) {
-                return vespalib::make_string(
-                        "Bucket Id %s has no copy from node %d",
-                        id.toString().c_str(),
-                        nodes[i]);
+                return vespalib::make_string("Bucket Id %s has no copy from node %d", id.toString().c_str(), nodes[i]);
             }
         }
 
@@ -188,13 +162,11 @@ public:
     struct OrderByIncreasingNodeIndex {
         template <typename T>
         bool operator()(const T& lhs, const T& rhs) {
-            return (lhs->getAddress()->getIndex()
-                    < rhs->getAddress()->getIndex());
+            return (lhs->getAddress()->getIndex() < rhs->getAddress()->getIndex());
         }
     };
 
-    void sort_sent_messages_by_index(DistributorMessageSenderStub& sender,
-                                     size_t sortFromOffset = 0)
+    void sort_sent_messages_by_index(DistributorMessageSenderStub& sender, size_t sortFromOffset = 0)
     {
         std::sort(sender.commands().begin() + sortFromOffset,
                   sender.commands().end(),
diff --git a/storage/src/tests/distributor/top_level_distributor_test_util.cpp b/storage/src/tests/distributor/top_level_distributor_test_util.cpp
index 9677ea568e8..9859a6fb237 100644
--- a/storage/src/tests/distributor/top_level_distributor_test_util.cpp
+++ b/storage/src/tests/distributor/top_level_distributor_test_util.cpp
@@ -187,7 +187,7 @@ TopLevelDistributorTestUtil::get_ideal_str(document::BucketId id, const lib::Clu
         return id.toString();
     }
     std::vector<uint16_t> nodes;
-    _component->getDistribution()->getIdealNodes(lib::NodeType::STORAGE, state, id, nodes);
+    _component->getDistribution()->getIdealNodes(lib::NodeType::STORAGE, state, id, nodes, "uim");
     std::sort(nodes.begin(), nodes.end());
     std::ostringstream ost;
     ost << id << ": " << dumpVector(nodes);
@@ -205,14 +205,11 @@ TopLevelDistributorTestUtil::add_ideal_nodes(const lib::ClusterState& state, con
 
     std::vector<uint16_t> res;
     assert(_component.get());
-    _component->getDistribution()->getIdealNodes(lib::NodeType::STORAGE, state, id, res);
+    _component->getDistribution()->getIdealNodes(lib::NodeType::STORAGE, state, id, res, "uim");
 
     for (uint32_t i = 0; i < res.size(); ++i) {
-        if (state.getNodeState(lib::Node(lib::NodeType::STORAGE, res[i])).getState() !=
-            lib::State::MAINTENANCE)
-        {
-            entry->addNode(BucketCopy(0, res[i], api::BucketInfo(1,1,1)),
-                           toVector<uint16_t>(0));
+        if (state.getNodeState(lib::Node(lib::NodeType::STORAGE, res[i])).getState() != lib::State::MAINTENANCE) {
+            entry->addNode(BucketCopy(0, res[i], api::BucketInfo(1,1,1)), toVector<uint16_t>(0));
         }
     }
 
diff --git a/storage/src/vespa/storage/bucketdb/bucketcopy.h b/storage/src/vespa/storage/bucketdb/bucketcopy.h
index e8d1db1d824..ca629a6cd8e 100644
--- a/storage/src/vespa/storage/bucketdb/bucketcopy.h
+++ b/storage/src/vespa/storage/bucketdb/bucketcopy.h
@@ -7,10 +7,10 @@ namespace storage {
 
 class BucketCopy {
 private:
-    uint64_t _timestamp;
+    uint64_t        _timestamp;
     api::BucketInfo _info;
-    uint16_t _flags;
-    uint16_t _node;
+    uint16_t        _flags;
+    uint16_t        _node;
 
 public:
     static const int TRUSTED = 1;
@@ -18,9 +18,7 @@ public:
     BucketCopy() noexcept
         : _timestamp(0), _flags(0), _node(0xffff) {}
 
-    BucketCopy(uint64_t timestamp,
-               uint16_t nodeIdx,
-               const api::BucketInfo& info) noexcept
+    BucketCopy(uint64_t timestamp, uint16_t nodeIdx, const api::BucketInfo& info) noexcept
         : _timestamp(timestamp),
           _info(info),
           _flags(0),
@@ -76,16 +74,14 @@ public:
         _info.setActive(setactive);
     }
 
-    bool consistentWith(const BucketCopy& other,
-                        bool countInvalidAsConsistent = false) const noexcept
-    {
+    bool consistentWith(const BucketCopy& other) const noexcept {
         // If both are valid, check checksum and doc count.
         if (valid() && other.valid()) {
             return (getChecksum() == other.getChecksum()
                     && getDocumentCount() == other.getDocumentCount());
         }
 
-        return countInvalidAsConsistent;
+        return false;
     }
 
     void print(std::ostream&, bool verbose, const std::string& indent) const;
@@ -93,9 +89,7 @@ public:
     std::string toString() const;
 
     bool operator==(const BucketCopy& other) const noexcept {
-        return
-            getBucketInfo() == other.getBucketInfo() &&
-            _flags == other._flags;
+        return (getBucketInfo() == other.getBucketInfo()) && (_flags == other._flags);
     }
 };
 
diff --git a/storage/src/vespa/storage/bucketdb/bucketinfo.cpp b/storage/src/vespa/storage/bucketdb/bucketinfo.cpp
index dcf49b4d022..a8c21efa793 100644
--- a/storage/src/vespa/storage/bucketdb/bucketinfo.cpp
+++ b/storage/src/vespa/storage/bucketdb/bucketinfo.cpp
@@ -9,9 +9,9 @@ namespace storage {
 template class BucketInfoBase<std::vector<BucketCopy>>;
 template class BucketInfoBase<vespalib::ConstArrayRef<BucketCopy>>;
 
-BucketInfo::BucketInfo() : BucketInfoBase() {}
+BucketInfo::BucketInfo() noexcept : BucketInfoBase() {}
 
-BucketInfo::BucketInfo(uint32_t lastGarbageCollection, std::vector<BucketCopy> nodes)
+BucketInfo::BucketInfo(uint32_t lastGarbageCollection, std::vector<BucketCopy> nodes) noexcept
     : BucketInfoBase(lastGarbageCollection, std::move(nodes))
 {}
 
@@ -23,7 +23,7 @@ BucketInfo::BucketInfo(BucketInfo&&) noexcept = default;
 BucketInfo& BucketInfo::operator=(BucketInfo&&) noexcept = default;
 
 void
-BucketInfo::updateTrusted() {
+BucketInfo::updateTrusted() noexcept {
     if (validAndConsistent()) {
         for (uint32_t i = 0; i < _nodes.size(); i++) {
             _nodes[i].setTrusted();
@@ -51,7 +51,7 @@ BucketInfo::updateTrusted() {
 }
 
 void
-BucketInfo::resetTrusted() {
+BucketInfo::resetTrusted() noexcept {
     for (uint32_t i = 0; i < _nodes.size(); i++) {
         _nodes[i].clearTrusted();
     }
@@ -63,10 +63,10 @@ namespace {
 struct Sorter {
     const std::vector<uint16_t>& _order;
 
-    Sorter(const std::vector<uint16_t>& recommendedOrder) :
+    Sorter(const std::vector<uint16_t>& recommendedOrder) noexcept :
         _order(recommendedOrder) {}
 
-    bool operator() (const BucketCopy& a, const BucketCopy& b) {
+    bool operator() (const BucketCopy& a, const BucketCopy& b) noexcept {
         int order_a = -1;
         for (uint32_t i = 0; i < _order.size(); i++) {
             if (_order[i] == a.getNode()) {
@@ -119,8 +119,7 @@ BucketInfo::addNodes(const std::vector<BucketCopy>& newCopies,
 
         if (found) {
             if (found->getTimestamp() < newCopies[i].getTimestamp()) {
-                found->setBucketInfo(newCopies[i].getTimestamp(),
-                                     newCopies[i].getBucketInfo());
+                found->setBucketInfo(newCopies[i].getTimestamp(), newCopies[i].getBucketInfo());
             }
         } else {
             _nodes.push_back(newCopies[i]);
@@ -135,19 +134,15 @@ BucketInfo::addNodes(const std::vector<BucketCopy>& newCopies,
 }
 
 void
-BucketInfo::addNode(const BucketCopy& newCopy,
-                    const std::vector<uint16_t>& recommendedOrder)
+BucketInfo::addNode(const BucketCopy& newCopy, const std::vector<uint16_t>& recommendedOrder)
 {
-    addNodes(toVector<BucketCopy>(newCopy),
-             recommendedOrder);
+    addNodes(toVector<BucketCopy>(newCopy), recommendedOrder);
 }
 
 bool
 BucketInfo::removeNode(unsigned short node, TrustedUpdate update)
 {
-    for (std::vector<BucketCopy>::iterator iter = _nodes.begin();
-         iter != _nodes.end();
-         iter++) {
+    for (auto iter = _nodes.begin(); iter != _nodes.end(); iter++) {
         if (iter->getNode() == node) {
             _nodes.erase(iter);
             if (update == TrustedUpdate::UPDATE) {
@@ -162,11 +157,9 @@ BucketInfo::removeNode(unsigned short node, TrustedUpdate update)
 BucketCopy*
 BucketInfo::getNodeInternal(uint16_t node)
 {
-    for (std::vector<BucketCopy>::iterator iter = _nodes.begin();
-         iter != _nodes.end();
-         iter++) {
-        if (iter->getNode() == node) {
-            return &*iter;
+    for (BucketCopy & copy : _nodes) {
+        if (copy.getNode() == node) {
+            return &copy;
         }
     }
     return 0;
diff --git a/storage/src/vespa/storage/bucketdb/bucketinfo.h b/storage/src/vespa/storage/bucketdb/bucketinfo.h
index 57ebf505a50..219d0335966 100644
--- a/storage/src/vespa/storage/bucketdb/bucketinfo.h
+++ b/storage/src/vespa/storage/bucketdb/bucketinfo.h
@@ -25,15 +25,15 @@ protected:
     uint32_t _lastGarbageCollection;
     NodeSeq _nodes;
 public:
-    BucketInfoBase()
+    BucketInfoBase() noexcept
         : _lastGarbageCollection(0),
           _nodes()
     {}
-    BucketInfoBase(uint32_t lastGarbageCollection, const NodeSeq& nodes)
+    BucketInfoBase(uint32_t lastGarbageCollection, const NodeSeq& nodes) noexcept
         : _lastGarbageCollection(lastGarbageCollection),
           _nodes(nodes)
     {}
-    BucketInfoBase(uint32_t lastGarbageCollection, NodeSeq&& nodes)
+    BucketInfoBase(uint32_t lastGarbageCollection, NodeSeq&& nodes) noexcept
         : _lastGarbageCollection(lastGarbageCollection),
           _nodes(std::move(nodes))
     {}
@@ -47,28 +47,28 @@ public:
     /**
      * @return Returns the last time when this bucket was "garbage collected".
      */
-    uint32_t getLastGarbageCollectionTime() const { return _lastGarbageCollection; }
+    uint32_t getLastGarbageCollectionTime() const noexcept { return _lastGarbageCollection; }
 
     /** True if the bucket contains no documents and is consistent. */
-    bool emptyAndConsistent() const;
+    bool emptyAndConsistent() const noexcept;
 
     /**
        Check that all copies have complete bucket information and are
        consistent with eachother.
     */
-    bool validAndConsistent() const;
+    bool validAndConsistent() const noexcept;
 
     /**
      * True if the bucket contains at least one invalid copy
      */
-    bool hasInvalidCopy() const;
+    bool hasInvalidCopy() const noexcept;
 
     /**
      * Returns the number of trusted nodes this entry has.
      */
-    uint16_t getTrustedCount() const;
+    uint16_t getTrustedCount() const noexcept;
 
-    bool hasTrusted() const {
+    bool hasTrusted() const noexcept {
         return getTrustedCount() != 0;
     }
 
@@ -78,14 +78,14 @@ public:
      * @param countInCompleteAsInconsistent If false, nodes that are incomplete
      *       are always counted as consistent with complete nodes.
      */
-    bool consistentNodes(bool countInvalidAsConsistent = false) const;
+    bool consistentNodes() const noexcept;
 
     void print(std::ostream&, bool verbose, const std::string& indent) const;
 
     /**
      * Returns the bucket copy struct for the given node, null if nonexisting
      */
-    const BucketCopy* getNode(uint16_t node) const;
+    const BucketCopy* getNode(uint16_t node) const noexcept;
 
     /**
      * Returns the number of nodes this entry has.
@@ -95,7 +95,7 @@ public:
     /**
      * Returns a list of the nodes this entry has.
      */
-    std::vector<uint16_t> getNodes() const;
+    std::vector<uint16_t> getNodes() const noexcept;
 
     /**
        Returns a reference to the node with the given index in the node
@@ -117,14 +117,14 @@ public:
 
     std::string toString() const;
 
-    uint32_t getHighestDocumentCount() const;
-    uint32_t getHighestTotalDocumentSize() const;
-    uint32_t getHighestMetaCount() const;
-    uint32_t getHighestUsedFileSize() const;
+    uint32_t getHighestDocumentCount() const noexcept;
+    uint32_t getHighestTotalDocumentSize() const noexcept;
+    uint32_t getHighestMetaCount() const noexcept;
+    uint32_t getHighestUsedFileSize() const noexcept;
 
-    bool hasRecentlyCreatedEmptyCopy() const;
+    bool hasRecentlyCreatedEmptyCopy() const noexcept;
 
-    bool operator==(const BucketInfoBase& other) const;
+    bool operator==(const BucketInfoBase& other) const noexcept;
 };
 
 template <typename NodeSeq>
@@ -140,8 +140,8 @@ public:
 
 class BucketInfo : public BucketInfoBase<std::vector<BucketCopy>> {
 public:
-    BucketInfo();
-    BucketInfo(uint32_t lastGarbageCollection, std::vector<BucketCopy> nodes);
+    BucketInfo() noexcept;
+    BucketInfo(uint32_t lastGarbageCollection, std::vector<BucketCopy> nodes) noexcept;
     ~BucketInfo();
 
     BucketInfo(const BucketInfo&);
@@ -152,20 +152,20 @@ public:
     /**
      * Sets the last time the bucket was "garbage collected".
      */
-    void setLastGarbageCollectionTime(uint32_t timestamp) {
+    void setLastGarbageCollectionTime(uint32_t timestamp) noexcept {
         _lastGarbageCollection = timestamp;
     }
 
     /**
        Update trusted flags if bucket is now complete and consistent.
     */
-    void updateTrusted();
+    void updateTrusted() noexcept;
 
     /**
        Removes any historical information on trustedness, and sets the bucket copies to
        trusted if they are now complete and consistent.
     */
-    void resetTrusted();
+    void resetTrusted() noexcept;
 
     /**
        Adds the given node.
@@ -184,8 +184,7 @@ public:
     /**
        Simplified API for the common case of inserting one node. See addNodes().
     */
-    void addNode(const BucketCopy& newCopy,
-                 const std::vector<uint16_t>& recommendedOrder);
+    void addNode(const BucketCopy& newCopy, const std::vector<uint16_t>& recommendedOrder);
 
     /**
        Updates bucket information for a node. Does nothing if the node
diff --git a/storage/src/vespa/storage/bucketdb/bucketinfo.hpp b/storage/src/vespa/storage/bucketdb/bucketinfo.hpp
index b7e8c5925c5..ce7adc8af67 100644
--- a/storage/src/vespa/storage/bucketdb/bucketinfo.hpp
+++ b/storage/src/vespa/storage/bucketdb/bucketinfo.hpp
@@ -9,16 +9,18 @@
 namespace storage {
 
 template <typename NodeSeq>
-std::string BucketInfoBase<NodeSeq>::toString() const {
+std::string
+BucketInfoBase<NodeSeq>::toString() const {
     std::ostringstream ost;
     print(ost, true, "");
     return ost.str();
 }
 
 template <typename NodeSeq>
-bool BucketInfoBase<NodeSeq>::emptyAndConsistent() const {
-    for (uint32_t i = 0; i < _nodes.size(); i++) {
-        if (!_nodes[i].empty()) {
+bool
+BucketInfoBase<NodeSeq>::emptyAndConsistent() const noexcept {
+    for (const auto & n : _nodes) {
+        if (!n.empty()) {
             return false;
         }
     }
@@ -26,9 +28,10 @@ bool BucketInfoBase<NodeSeq>::emptyAndConsistent() const {
 }
 
 template <typename NodeSeq>
-bool BucketInfoBase<NodeSeq>::validAndConsistent() const {
-    for (uint32_t i = 0; i < _nodes.size(); i++) {
-        if (!_nodes[i].valid()) {
+bool
+BucketInfoBase<NodeSeq>::validAndConsistent() const noexcept {
+    for (const auto & n : _nodes) {
+        if (!n.valid()) {
             return false;
         }
     }
@@ -36,9 +39,10 @@ bool BucketInfoBase<NodeSeq>::validAndConsistent() const {
 }
 
 template <typename NodeSeq>
-bool BucketInfoBase<NodeSeq>::hasInvalidCopy() const {
-    for (uint32_t i = 0; i < _nodes.size(); i++) {
-        if (!_nodes[i].valid()) {
+bool
+BucketInfoBase<NodeSeq>::hasInvalidCopy() const noexcept {
+    for (const auto & n : _nodes){
+        if (!n.valid()) {
             return true;
         }
     }
@@ -46,10 +50,11 @@ bool BucketInfoBase<NodeSeq>::hasInvalidCopy() const {
 }
 
 template <typename NodeSeq>
-uint16_t BucketInfoBase<NodeSeq>::getTrustedCount() const {
+uint16_t
+BucketInfoBase<NodeSeq>::getTrustedCount() const noexcept {
     uint32_t trustedCount = 0;
-    for (uint32_t i = 0; i < _nodes.size(); i++) {
-        if (_nodes[i].trusted()) {
+    for (const auto & n : _nodes) {
+        if (n.trusted()) {
             trustedCount++;
         }
     }
@@ -57,11 +62,11 @@ uint16_t BucketInfoBase<NodeSeq>::getTrustedCount() const {
 }
 
 template <typename NodeSeq>
-bool BucketInfoBase<NodeSeq>::consistentNodes(bool countInvalidAsConsistent) const {
+bool
+BucketInfoBase<NodeSeq>::consistentNodes() const noexcept {
     int compareIndex = 0;
     for (uint32_t i = 1; i < _nodes.size(); i++) {
-        if (!_nodes[i].consistentWith(_nodes[compareIndex],
-                                      countInvalidAsConsistent)) return false;
+        if (!_nodes[i].consistentWith(_nodes[compareIndex])) return false;
     }
     return true;
 }
@@ -90,14 +95,16 @@ struct ReplicaMetadata {
     };
 };
 
-constexpr bool is_majority(size_t n, size_t m) {
+constexpr bool
+is_majority(size_t n, size_t m) noexcept {
     return (n >= (m / 2) + 1);
 }
 
 }
 
 template <typename NodeSeq>
-api::BucketInfo BucketInfoBase<NodeSeq>::majority_consistent_bucket_info() const noexcept {
+api::BucketInfo
+BucketInfoBase<NodeSeq>::majority_consistent_bucket_info() const noexcept {
     if (_nodes.size() < 3) {
         return {};
     }
@@ -116,7 +123,8 @@ api::BucketInfo BucketInfoBase<NodeSeq>::majority_consistent_bucket_info() const
 }
 
 template <typename NodeSeq>
-void BucketInfoBase<NodeSeq>::print(std::ostream& out, bool verbose, const std::string& indent) const {
+void
+BucketInfoBase<NodeSeq>::print(std::ostream& out, bool verbose, const std::string& indent) const {
     if (_nodes.size() == 0) {
         out << "no nodes";
     }
@@ -129,7 +137,8 @@ void BucketInfoBase<NodeSeq>::print(std::ostream& out, bool verbose, const std::
 }
 
 template <typename NodeSeq>
-const BucketCopy* BucketInfoBase<NodeSeq>::getNode(uint16_t node) const {
+const BucketCopy*
+BucketInfoBase<NodeSeq>::getNode(uint16_t node) const noexcept {
     for (const auto& n : _nodes) {
         if (n.getNode() == node) {
             return &n;
@@ -139,54 +148,61 @@ const BucketCopy* BucketInfoBase<NodeSeq>::getNode(uint16_t node) const {
 }
 
 template <typename NodeSeq>
-std::vector<uint16_t> BucketInfoBase<NodeSeq>::getNodes() const {
+std::vector<uint16_t>
+BucketInfoBase<NodeSeq>::getNodes() const noexcept {
     std::vector<uint16_t> result;
-    for (uint32_t i = 0; i < _nodes.size(); i++) {
-        result.emplace_back(_nodes[i].getNode());
+    result.reserve(_nodes.size());
+    for (const auto & n : _nodes) {
+        result.emplace_back(n.getNode());
     }
     return result;
 }
 
 template <typename NodeSeq>
-uint32_t BucketInfoBase<NodeSeq>::getHighestDocumentCount() const {
+uint32_t
+BucketInfoBase<NodeSeq>::getHighestDocumentCount() const noexcept {
     uint32_t highest = 0;
-    for (uint32_t i = 0; i < _nodes.size(); ++i) {
-        highest = std::max(highest, _nodes[i].getDocumentCount());
+    for (const auto & n : _nodes) {
+        highest = std::max(highest, n.getDocumentCount());
     }
     return highest;
 }
 
 template <typename NodeSeq>
-uint32_t BucketInfoBase<NodeSeq>::getHighestTotalDocumentSize() const {
+uint32_t
+BucketInfoBase<NodeSeq>::getHighestTotalDocumentSize() const noexcept {
     uint32_t highest = 0;
-    for (uint32_t i = 0; i < _nodes.size(); ++i) {
-        highest = std::max(highest, _nodes[i].getTotalDocumentSize());
+    for (const auto & n : _nodes) {
+        highest = std::max(highest, n.getTotalDocumentSize());
     }
     return highest;
 }
 
 template <typename NodeSeq>
-uint32_t BucketInfoBase<NodeSeq>::getHighestMetaCount() const {
+uint32_t
+BucketInfoBase<NodeSeq>::getHighestMetaCount() const noexcept {
     uint32_t highest = 0;
-    for (uint32_t i = 0; i < _nodes.size(); ++i) {
-        highest = std::max(highest, _nodes[i].getMetaCount());
+    for (const auto & n : _nodes) {
+        highest = std::max(highest, n.getMetaCount());
     }
     return highest;
 }
 
 template <typename NodeSeq>
-uint32_t BucketInfoBase<NodeSeq>::getHighestUsedFileSize() const {
+uint32_t
+BucketInfoBase<NodeSeq>::getHighestUsedFileSize() const noexcept {
     uint32_t highest = 0;
-    for (uint32_t i = 0; i < _nodes.size(); ++i) {
-        highest = std::max(highest, _nodes[i].getUsedFileSize());
+    for (const auto & n : _nodes) {
+        highest = std::max(highest, n.getUsedFileSize());
     }
     return highest;
 }
 
 template <typename NodeSeq>
-bool BucketInfoBase<NodeSeq>::hasRecentlyCreatedEmptyCopy() const {
-    for (uint32_t i = 0; i < _nodes.size(); ++i) {
-        if (_nodes[i].wasRecentlyCreated()) {
+bool
+BucketInfoBase<NodeSeq>::hasRecentlyCreatedEmptyCopy() const noexcept {
+    for (const auto & n : _nodes) {
+        if (n.wasRecentlyCreated()) {
             return true;
         }
     }
@@ -194,7 +210,8 @@ bool BucketInfoBase<NodeSeq>::hasRecentlyCreatedEmptyCopy() const {
 }
 
 template <typename NodeSeq>
-bool BucketInfoBase<NodeSeq>::operator==(const BucketInfoBase<NodeSeq>& other) const {
+bool
+BucketInfoBase<NodeSeq>::operator==(const BucketInfoBase<NodeSeq>& other) const noexcept {
     if (_nodes.size() != other._nodes.size()) {
         return false;
     }
@@ -210,6 +227,6 @@ bool BucketInfoBase<NodeSeq>::operator==(const BucketInfoBase<NodeSeq>& other) c
     }
 
     return true;
-};
+}
 
 }
diff --git a/storage/src/vespa/storage/distributor/activecopy.cpp b/storage/src/vespa/storage/distributor/activecopy.cpp
index c46e9868cc8..ea194e1be21 100644
--- a/storage/src/vespa/storage/distributor/activecopy.cpp
+++ b/storage/src/vespa/storage/distributor/activecopy.cpp
@@ -91,66 +91,62 @@ operator<<(std::ostream& out, const ActiveCopy & e) {
 
 namespace {
 
-    struct ActiveStateOrder {
-        bool operator()(const ActiveCopy & e1, const ActiveCopy & e2) {
-            if (e1._ready != e2._ready) {
-                return e1._ready;
-            }
-            if (e1._doc_count != e2._doc_count) {
-                return e1._doc_count > e2._doc_count;
-            }
-            if (e1._ideal != e2._ideal) {
-                return e1._ideal < e2._ideal;
-            }
-            if (e1._active != e2._active) {
-                return e1._active;
-            }
-            return e1._nodeIndex < e2._nodeIndex;
+struct ActiveStateOrder {
+    bool operator()(const ActiveCopy & e1, const ActiveCopy & e2) noexcept {
+        if (e1._ready != e2._ready) {
+            return e1._ready;
         }
-    };
-
-    std::vector<uint16_t>
-    buildValidNodeIndexList(BucketDatabase::Entry& e) {
-        std::vector<uint16_t> result;
-        result.reserve(e->getNodeCount());
-        for (uint32_t i=0, n=e->getNodeCount(); i < n; ++i) {
-            const BucketCopy& cp = e->getNodeRef(i);
-            if (!cp.valid()) {
-                continue;
-            }
-            result.push_back(cp.getNode());
+        if (e1._doc_count != e2._doc_count) {
+            return e1._doc_count > e2._doc_count;
+        }
+        if (e1._ideal != e2._ideal) {
+            return e1._ideal < e2._ideal;
         }
-        return result;
+        if (e1._active != e2._active) {
+            return e1._active;
+        }
+        return e1._nodeIndex < e2._nodeIndex;
     }
-
-    std::vector<ActiveCopy>
-    buildNodeList(BucketDatabase::Entry& e,
-                  const std::vector<uint16_t>& nodeIndexes,
-                  const std::vector<uint16_t>& idealState)
-    {
-        std::vector<ActiveCopy> result;
-        result.reserve(nodeIndexes.size());
-        for (uint16_t nodeIndex : nodeIndexes) {
-            result.emplace_back(nodeIndex, e, idealState);
+};
+
+std::vector<uint16_t>
+buildValidNodeIndexList(BucketDatabase::Entry& e) {
+    std::vector<uint16_t> result;
+    result.reserve(e->getNodeCount());
+    for (uint32_t i=0, n=e->getNodeCount(); i < n; ++i) {
+        const BucketCopy& cp = e->getNodeRef(i);
+        if (!cp.valid()) {
+            continue;
         }
-        return result;
+        result.push_back(cp.getNode());
     }
+    return result;
+}
+
+std::vector<ActiveCopy>
+buildNodeList(BucketDatabase::Entry& e, const std::vector<uint16_t>& nodeIndexes, const std::vector<uint16_t>& idealState)
+{
+    std::vector<ActiveCopy> result;
+    result.reserve(nodeIndexes.size());
+    for (uint16_t nodeIndex : nodeIndexes) {
+        result.emplace_back(nodeIndex, e, idealState);
+    }
+    return result;
+}
+
 }
 
 ActiveList
-ActiveCopy::calculate(const std::vector<uint16_t>& idealState,
-                      const lib::Distribution& distribution,
-                      BucketDatabase::Entry& e,
-                      uint32_t max_activation_inhibited_out_of_sync_groups)
+ActiveCopy::calculate(const std::vector<uint16_t>& idealState, const lib::Distribution& distribution,
+                      BucketDatabase::Entry& e, uint32_t max_activation_inhibited_out_of_sync_groups)
 {
     std::vector<uint16_t> validNodesWithCopy = buildValidNodeIndexList(e);
     if (validNodesWithCopy.empty()) {
         return ActiveList();
     }
-    using IndexList = std::vector<uint16_t>;
-    std::vector<IndexList> groups;
+    std::vector<lib::Distribution::IndexList> groups;
     if (distribution.activePerGroup()) {
-        groups = distribution.splitNodesIntoLeafGroups(std::move(validNodesWithCopy));
+        groups = distribution.splitNodesIntoLeafGroups(validNodesWithCopy);
     } else {
         groups.push_back(std::move(validNodesWithCopy));
     }
diff --git a/storage/src/vespa/storage/distributor/idealstatemanager.cpp b/storage/src/vespa/storage/distributor/idealstatemanager.cpp
index cad141e76ed..bc928ca3d41 100644
--- a/storage/src/vespa/storage/distributor/idealstatemanager.cpp
+++ b/storage/src/vespa/storage/distributor/idealstatemanager.cpp
@@ -10,10 +10,9 @@
 #include <vespa/storageapi/message/persistence.h>
 #include <vespa/document/bucket/fixed_bucket_spaces.h>
 #include <vespa/vespalib/util/assert.h>
-#include <vespa/vespalib/stllike/hash_map.hpp>
 
 #include <vespa/log/log.h>
-LOG_SETUP(".distributor.operation.queue");
+LOG_SETUP(".distributor.idealstatemanager");
 
 using document::BucketSpace;
 using storage::lib::Node;
@@ -21,10 +20,9 @@ using storage::lib::NodeType;
 
 namespace storage::distributor {
 
-IdealStateManager::IdealStateManager(
-        const DistributorNodeContext& node_ctx,
-        DistributorStripeOperationContext& op_ctx,
-        IdealStateMetricSet& metrics)
+IdealStateManager::IdealStateManager(const DistributorNodeContext& node_ctx,
+                                     DistributorStripeOperationContext& op_ctx,
+                                     IdealStateMetricSet& metrics)
     : _metrics(metrics),
       _stateCheckers(),
       _splitBucketStateChecker(nullptr),
@@ -56,9 +54,7 @@ IdealStateManager::fillParentAndChildBuckets(StateChecker::Context& c)
 {
     c.db.getAll(c.getBucketId(), c.entries);
     if (c.entries.empty()) {
-        LOG(spam,
-            "Did not find bucket %s in bucket database",
-            c.bucket.toString().c_str());
+        LOG(spam, "Did not find bucket %s in bucket database", c.bucket.toString().c_str());
     }
 }
 void
@@ -85,8 +81,7 @@ namespace {
  * overwriting if already explicitly set.
  */
 bool
-canOverwriteResult(const StateChecker::Result& existing,
-                   const StateChecker::Result& candidate)
+canOverwriteResult(const StateChecker::Result& existing, const StateChecker::Result& candidate)
 {
     return (!existing.getPriority().requiresMaintenance()
             && candidate.getPriority().requiresMaintenance());
@@ -101,9 +96,7 @@ IdealStateManager::runStateCheckers(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()))
-        {
+        if (!operation_context().distributor_config().stateCheckerIsActive(checker->getName())) {
             LOG(spam, "Skipping state checker %s", checker->getName());
             continue;
         }
@@ -116,7 +109,8 @@ IdealStateManager::runStateCheckers(StateChecker::Context& c) const
     return highestPri;
 }
 
-void IdealStateManager::verify_only_live_nodes_in_context(const StateChecker::Context& c) const {
+void
+IdealStateManager::verify_only_live_nodes_in_context(const StateChecker::Context& c) const {
     if (_has_logged_phantom_replica_warning) {
         return;
     }
@@ -125,11 +119,8 @@ void IdealStateManager::verify_only_live_nodes_in_context(const StateChecker::Co
         const auto& state = c.systemState.getNodeState(lib::Node(lib::NodeType::STORAGE, index));
         // Only nodes in Up, Initializing or Retired should ever be present in the DB.
         if (!state.getState().oneOf("uir")) {
-            LOG(error, "%s in bucket DB is on node %u, which is in unavailable state %s. "
-                       "Current cluster state is '%s'",
-                       c.entry.getBucketId().toString().c_str(),
-                       index,
-                       state.getState().toString().c_str(),
+            LOG(error, "%s in bucket DB is on node %u, which is in unavailable state %s. Current cluster state is '%s'",
+                       c.entry.getBucketId().toString().c_str(), index, state.getState().toString().c_str(),
                        c.systemState.toString().c_str());
             ASSERT_ONCE_OR_LOG(false, "Bucket DB contains replicas on unavailable node", 10000);
             _has_logged_phantom_replica_warning = true;
@@ -138,9 +129,7 @@ void IdealStateManager::verify_only_live_nodes_in_context(const StateChecker::Co
 }
 
 StateChecker::Result
-IdealStateManager::generateHighestPriority(
-        const document::Bucket& bucket,
-        NodeMaintenanceStatsTracker& statsTracker) const
+IdealStateManager::generateHighestPriority(const document::Bucket& bucket, NodeMaintenanceStatsTracker& statsTracker) const
 {
     auto& distributorBucketSpace = _op_ctx.bucket_space_repo().get(bucket.getBucketSpace());
     StateChecker::Context c(node_context(), operation_context(), distributorBucketSpace, statsTracker, bucket);
@@ -159,9 +148,7 @@ IdealStateManager::generateHighestPriority(
 }
 
 MaintenancePriorityAndType
-IdealStateManager::prioritize(
-        const document::Bucket& bucket,
-        NodeMaintenanceStatsTracker& statsTracker) const
+IdealStateManager::prioritize(const document::Bucket& bucket, NodeMaintenanceStatsTracker& statsTracker) const
 {
     StateChecker::Result generated(generateHighestPriority(bucket, statsTracker));
     MaintenancePriority priority(generated.getPriority());
@@ -172,8 +159,7 @@ IdealStateManager::prioritize(
 }
 
 IdealStateOperation::SP
-IdealStateManager::generateInterceptingSplit(BucketSpace bucketSpace,
-                                             const BucketDatabase::Entry& e,
+IdealStateManager::generateInterceptingSplit(BucketSpace bucketSpace, const BucketDatabase::Entry& e,
                                              api::StorageMessage::Priority pri)
 {
     NodeMaintenanceStatsTracker statsTracker;
@@ -199,18 +185,15 @@ MaintenanceOperation::SP
 IdealStateManager::generate(const document::Bucket& bucket) const
 {
     NodeMaintenanceStatsTracker statsTracker;
-    IdealStateOperation::SP op(
-            generateHighestPriority(bucket, statsTracker).createOperation());
+    IdealStateOperation::SP op(generateHighestPriority(bucket, statsTracker).createOperation());
     if (op.get()) {
-        op->setIdealStateManager(
-                const_cast<IdealStateManager*>(this));
+        op->setIdealStateManager(const_cast<IdealStateManager*>(this));
     }
     return op;
 }
 
 std::vector<MaintenanceOperation::SP>
-IdealStateManager::generateAll(const document::Bucket &bucket,
-                               NodeMaintenanceStatsTracker& statsTracker) const
+IdealStateManager::generateAll(const document::Bucket &bucket, NodeMaintenanceStatsTracker& statsTracker) const
 {
     auto& distributorBucketSpace = _op_ctx.bucket_space_repo().get(bucket.getBucketSpace());
     StateChecker::Context c(node_context(), operation_context(), distributorBucketSpace, statsTracker, bucket);
@@ -234,15 +217,11 @@ IdealStateManager::generateAll(const document::Bucket &bucket,
 }
 
 void
-IdealStateManager::getBucketStatus(
-        BucketSpace bucketSpace,
-        const BucketDatabase::ConstEntryRef& entry,
-        NodeMaintenanceStatsTracker& statsTracker,
-        std::ostream& out) const
+IdealStateManager::getBucketStatus(BucketSpace bucketSpace, const BucketDatabase::ConstEntryRef& entry,
+                                   NodeMaintenanceStatsTracker& statsTracker, std::ostream& out) const
 {
     document::Bucket bucket(bucketSpace, entry.getBucketId());
-    std::vector<MaintenanceOperation::SP> operations(
-            generateAll(bucket, statsTracker));
+    std::vector<MaintenanceOperation::SP> operations(generateAll(bucket, statsTracker));
     if (operations.empty()) {
         out << entry.getBucketId() << " : ";
     } else {
@@ -261,13 +240,15 @@ IdealStateManager::getBucketStatus(
     out << "[" << entry->toString() << "]<br>\n";
 }
 
-void IdealStateManager::dump_bucket_space_db_status(document::BucketSpace bucket_space, std::ostream& out) const {
+void
+IdealStateManager::dump_bucket_space_db_status(document::BucketSpace bucket_space, std::ostream& out) const {
     StatusBucketVisitor proc(*this, bucket_space, out);
     auto& distributorBucketSpace = _op_ctx.bucket_space_repo().get(bucket_space);
     distributorBucketSpace.getBucketDatabase().for_each_upper_bound(proc);
 }
 
-void IdealStateManager::getBucketStatus(std::ostream& out) const {
+void
+IdealStateManager::getBucketStatus(std::ostream& out) const {
     LOG(debug, "Dumping bucket database valid at cluster state version %u",
         operation_context().cluster_state_bundle().getVersion());
 
diff --git a/storage/src/vespa/storage/distributor/idealstatemanager.h b/storage/src/vespa/storage/distributor/idealstatemanager.h
index 0c9e3ffa1c6..39a662e4a81 100644
--- a/storage/src/vespa/storage/distributor/idealstatemanager.h
+++ b/storage/src/vespa/storage/distributor/idealstatemanager.h
@@ -49,18 +49,14 @@ public:
     MaintenanceOperation::SP generate(const document::Bucket& bucket) const override;
 
     // MaintenanceOperationGenerator
-    std::vector<MaintenanceOperation::SP> generateAll(
-            const document::Bucket& bucket,
-            NodeMaintenanceStatsTracker& statsTracker) const override;
+    std::vector<MaintenanceOperation::SP> generateAll(const document::Bucket& bucket, NodeMaintenanceStatsTracker& statsTracker) const override;
 
     /**
      * If the given bucket is too large, generate a split operation for it,
      * with higher priority than the given one.
      */
-    IdealStateOperation::SP generateInterceptingSplit(
-            document::BucketSpace bucketSpace,
-            const BucketDatabase::Entry& e,
-            api::StorageMessage::Priority pri);
+    IdealStateOperation::SP generateInterceptingSplit(document::BucketSpace bucketSpace, const BucketDatabase::Entry& e,
+                                                      api::StorageMessage::Priority pri);
 
     IdealStateMetricSet& getMetrics() noexcept { return _metrics; }
 
@@ -78,9 +74,7 @@ private:
     void verify_only_live_nodes_in_context(const StateChecker::Context& c) const;
     static void fillParentAndChildBuckets(StateChecker::Context& c);
     static void fillSiblingBucket(StateChecker::Context& c);
-    StateChecker::Result generateHighestPriority(
-            const document::Bucket& bucket,
-            NodeMaintenanceStatsTracker& statsTracker) const;
+    StateChecker::Result generateHighestPriority(const document::Bucket& bucket, NodeMaintenanceStatsTracker& statsTracker) const;
     StateChecker::Result runStateCheckers(StateChecker::Context& c) const;
 
     static BucketDatabase::Entry* getEntryForPrimaryBucket(StateChecker::Context& c);
diff --git a/storage/src/vespa/storage/storageutil/distributorstatecache.h b/storage/src/vespa/storage/storageutil/distributorstatecache.h
index 8c4d07e39bf..0652a980e3a 100644
--- a/storage/src/vespa/storage/storageutil/distributorstatecache.h
+++ b/storage/src/vespa/storage/storageutil/distributorstatecache.h
@@ -1,6 +1,7 @@
 // Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
 
 #pragma once
+
 #include <vespa/vdslib/state/clusterstate.h>
 #include <vespa/vdslib/distribution/distribution.h>
 
@@ -9,9 +10,7 @@ namespace storage {
 class DistributorStateCache
 {
 public:
-    DistributorStateCache(
-            const lib::Distribution& distr,
-            const lib::ClusterState& state)
+    DistributorStateCache(const lib::Distribution& distr, const lib::ClusterState& state)
         : _distribution(distr),
           _state(state),
           _distrBitMask(0xffffffffffffffffull),
@@ -22,8 +21,7 @@ public:
         _distrBitMask >>= (64 - state.getDistributionBitCount());
     }
 
-    uint16_t getOwner(const document::BucketId& bid,
-                      const char* upStates = "ui")
+    uint16_t getOwner(const document::BucketId& bid, const char* upStates = "ui")
     {
         uint64_t distributionBits = bid.getRawId() & _distrBitMask;
 
diff --git a/storage/src/vespa/storage/tools/getidealstate.cpp b/storage/src/vespa/storage/tools/getidealstate.cpp
index 8b120924aaa..9e80517f4f7 100644
--- a/storage/src/vespa/storage/tools/getidealstate.cpp
+++ b/storage/src/vespa/storage/tools/getidealstate.cpp
@@ -64,18 +64,13 @@ Options::Options(int argc, const char* const* argv)
 Options::~Options() {}
 
 
-void processBucket(const lib::Distribution& distribution,
-                   const lib::ClusterState& clusterState,
-                   const std::string& upStates,
-                   const document::BucketId& bucket)
+void processBucket(const lib::Distribution& distribution, const lib::ClusterState& clusterState,
+                   const std::string& upStates, const document::BucketId& bucket)
 {
     std::ostringstream ost;
-    std::vector<uint16_t> storageNodes(distribution.getIdealStorageNodes(
-                clusterState, bucket, upStates.c_str()));
-    uint16_t distributorNode(distribution.getIdealDistributorNode(
-                clusterState, bucket, upStates.c_str()));
-    ost << bucket << " distributor: " << distributorNode
-              << ", storage:";
+    std::vector<uint16_t> storageNodes(distribution.getIdealStorageNodes(clusterState, bucket, upStates.c_str()));
+    uint16_t distributorNode(distribution.getIdealDistributorNode(clusterState, bucket, upStates.c_str()));
+    ost << bucket << " distributor: " << distributorNode << ", storage:";
     for (uint32_t i=0; i<storageNodes.size(); ++i) {
         ost << " " << storageNodes[i];
     }