Precompute node 2 group mapping config time.

4 files changed, 38 insertions, 27 deletions

diff --git a/storage/src/vespa/storage/distributor/activecopy.cpp b/storage/src/vespa/storage/distributor/activecopy.cpp
index 3cb44515076..5654e986882 100644
--- a/storage/src/vespa/storage/distributor/activecopy.cpp
+++ b/storage/src/vespa/storage/distributor/activecopy.cpp
@@ -86,23 +86,29 @@ namespace {
         }
     };
 
-    void buildValidNodeIndexList(BucketDatabase::Entry& e, std::vector<uint16_t>& result) {
+    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());
         }
+        return result;
     }
 
-    void buildNodeList(BucketDatabase::Entry& e,
-                       const std::vector<uint16_t>& nodeIndexes,
-                       const std::vector<uint16_t>& idealState,
-                       std::vector<ActiveCopy>& 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;
     }
 }
 
@@ -119,8 +125,7 @@ ActiveCopy::calculate(const std::vector<uint16_t>& idealState,
                       BucketDatabase::Entry& e)
 {
     DEBUG(std::cerr << "Ideal state is " << idealState << "\n");
-    std::vector<uint16_t> validNodesWithCopy;
-    buildValidNodeIndexList(e, validNodesWithCopy);
+    std::vector<uint16_t> validNodesWithCopy = buildValidNodeIndexList(e);
     if (validNodesWithCopy.empty()) {
         return ActiveList();
     }
@@ -134,8 +139,7 @@ ActiveCopy::calculate(const std::vector<uint16_t>& idealState,
     std::vector<ActiveCopy> result;
     result.reserve(groups.size());
     for (uint32_t i=0; i<groups.size(); ++i) {
-        std::vector<ActiveCopy> entries;
-        buildNodeList(e, groups[i], idealState, entries);
+        std::vector<ActiveCopy> entries = buildNodeList(e, groups[i], idealState);
         DEBUG(std::cerr << "Finding active for group " << entries << "\n");
         auto best = std::min_element(entries.begin(), entries.end(), ActiveStateOrder());
         DEBUG(std::cerr << "Best copy " << *best << "\n");
diff --git a/vdslib/src/vespa/vdslib/distribution/distribution.cpp b/vdslib/src/vespa/vdslib/distribution/distribution.cpp
index 46b85b87c5d..0abb99e17d2 100644
--- a/vdslib/src/vespa/vdslib/distribution/distribution.cpp
+++ b/vdslib/src/vespa/vdslib/distribution/distribution.cpp
@@ -39,6 +39,7 @@ VESPA_IMPLEMENT_EXCEPTION(TooFewBucketBitsInUseException, vespalib::Exception);
 Distribution::Distribution()
     : _distributionBitMasks(getDistributionBitMasks()),
       _nodeGraph(),
+      _node2Group(),
       _redundancy(),
       _initialRedundancy(0),
       _ensurePrimaryPersisted(true),
@@ -55,6 +56,7 @@ Distribution::Distribution()
 Distribution::Distribution(const Distribution& d)
     : _distributionBitMasks(getDistributionBitMasks()),
       _nodeGraph(),
+      _node2Group(),
       _redundancy(),
       _initialRedundancy(0),
       _ensurePrimaryPersisted(true),
@@ -69,7 +71,7 @@ Distribution::Distribution(const Distribution& d)
 Distribution::ConfigWrapper::ConfigWrapper(std::unique_ptr<DistributionConfig> cfg) :
     _cfg(std::move(cfg))
 { }
-Distribution::ConfigWrapper::~ConfigWrapper() { }
+Distribution::ConfigWrapper::~ConfigWrapper() = default;
 
 Distribution::Distribution(const ConfigWrapper & config) :
     Distribution(config.get())
@@ -78,6 +80,7 @@ Distribution::Distribution(const ConfigWrapper & config) :
 Distribution::Distribution(const vespa::config::content::StorDistributionConfig & config)
     : _distributionBitMasks(getDistributionBitMasks()),
       _nodeGraph(),
+      _node2Group(),
       _redundancy(),
       _initialRedundancy(0),
       _ensurePrimaryPersisted(true),
@@ -93,6 +96,7 @@ Distribution::Distribution(const vespa::config::content::StorDistributionConfig
 Distribution::Distribution(const vespalib::string& serialized)
     : _distributionBitMasks(getDistributionBitMasks()),
       _nodeGraph(),
+      _node2Group(),
       _redundancy(),
       _initialRedundancy(0),
       _ensurePrimaryPersisted(true),
@@ -113,7 +117,7 @@ Distribution::operator=(const Distribution& d)
     return *this;
 }
 
-Distribution::~Distribution() { }
+Distribution::~Distribution() = default;
 
 namespace {
     using ConfigDiskDistribution = vespa::config::content::StorDistributionConfig::DiskDistribution;
@@ -142,34 +146,35 @@ Distribution::configure(const vespa::config::content::StorDistributionConfig& co
 {
     typedef vespa::config::content::StorDistributionConfig::Group ConfigGroup;
     std::unique_ptr<Group> nodeGraph;
+    std::vector<const Group *> node2Group;
     for (uint32_t i=0, n=config.group.size(); i<n; ++i) {
         const ConfigGroup& cg(config.group[i]);
         std::vector<uint16_t> path;
-        if (nodeGraph.get() != nullptr) {
+        if (nodeGraph) {
             path = DistributionConfigUtil::getGroupPath(cg.index);
         }
         bool isLeafGroup = (cg.nodes.size() > 0);
-        std::unique_ptr<Group> group;
         uint16_t index = (path.empty() ? 0 : path.back());
-        if (isLeafGroup) {
-            group.reset(new Group(index, cg.name));
-        } else {
-            group.reset(new Group(
-                    index, cg.name,
-                    Group::Distribution(cg.partitions), config.redundancy));
-        }
+        std::unique_ptr<Group> group = (isLeafGroup)
+                ? std::make_unique<Group>(index, cg.name)
+                : std::make_unique<Group>(index, cg.name, Group::Distribution(cg.partitions), config.redundancy);
         group->setCapacity(cg.capacity);
         if (isLeafGroup) {
             std::vector<uint16_t> nodes(cg.nodes.size());
             for (uint32_t j=0, m=nodes.size(); j<m; ++j) {
-                nodes[j] = cg.nodes[j].index;
+                uint16_t nodeIndex = cg.nodes[j].index;
+                nodes[j] = nodeIndex;
+                if (node2Group.size() <= nodeIndex) {
+                    node2Group.resize(nodeIndex + 1);
+                }
+                node2Group[nodeIndex] = group.get();
             }
             group->setNodes(nodes);
         }
         if (path.empty()) {
             nodeGraph = std::move(group);
         } else {
-            assert(nodeGraph.get() != nullptr);
+            assert(nodeGraph);
             Group* parent = nodeGraph.get();
             for (uint32_t j=0; j<path.size() - 1; ++j) {
                 parent = parent->getSubGroups()[path[j]];
@@ -177,7 +182,7 @@ Distribution::configure(const vespa::config::content::StorDistributionConfig& co
             parent->addSubGroup(std::move(group));
         }
     }
-    if (nodeGraph.get() == nullptr) {
+    if ( ! nodeGraph) {
         throw vespalib::IllegalStateException(
             "Got config that didn't seem to specify even a root group. Must "
             "have a root group at minimum:\n"
@@ -185,6 +190,7 @@ Distribution::configure(const vespa::config::content::StorDistributionConfig& co
     }
     nodeGraph->calculateDistributionHashValues();
     _nodeGraph = std::move(nodeGraph);
+    _node2Group = std::move(node2Group);
     _redundancy = config.redundancy;
     _initialRedundancy = config.initialRedundancy;
     _ensurePrimaryPersisted = config.ensurePrimaryPersisted;
@@ -670,7 +676,7 @@ Distribution::splitNodesIntoLeafGroups(IndexList nodeList) const
     std::vector<IndexList> result;
     std::map<uint16_t, IndexList> nodes;
     for (auto node : nodeList) {
-        const Group* group(_nodeGraph->getGroupForNode(node));
+        const Group* group(_node2Group[node]);
         if (group == nullptr) {
             LOGBP(warning, "Node %u is not assigned to a group. "
                            "Should not happen?", node);
diff --git a/vdslib/src/vespa/vdslib/distribution/distribution.h b/vdslib/src/vespa/vdslib/distribution/distribution.h
index 6da60e084bb..9ee505be7cd 100644
--- a/vdslib/src/vespa/vdslib/distribution/distribution.h
+++ b/vdslib/src/vespa/vdslib/distribution/distribution.h
@@ -33,8 +33,9 @@ public:
     enum DiskDistribution { MODULO, MODULO_INDEX, MODULO_KNUTH, MODULO_BID };
 
 private:
-    std::vector<uint32_t> _distributionBitMasks;
-    std::unique_ptr<Group> _nodeGraph;
+    std::vector<uint32_t>      _distributionBitMasks;
+    std::unique_ptr<Group>     _nodeGraph;
+    std::vector<const Group *> _node2Group;
     uint16_t _redundancy;
     uint16_t _initialRedundancy;
     uint16_t _readyCopies;
diff --git a/vdslib/src/vespa/vdslib/distribution/group.cpp b/vdslib/src/vespa/vdslib/distribution/group.cpp
index abfea22416d..45f8f0f8aea 100644
--- a/vdslib/src/vespa/vdslib/distribution/group.cpp
+++ b/vdslib/src/vespa/vdslib/distribution/group.cpp
@@ -103,7 +103,7 @@ Group::addSubGroup(Group::UP group)
                 "Cannot add sub groups to a group without a valid distribution",
                 VESPA_STRLOC);
     }
-    if (!group.get()) {
+    if (!group) {
         throw vespalib::IllegalArgumentException(
                 "Cannot add null group.", VESPA_STRLOC);
     }