mds: convert unnecessary list usage to vector

The idea of this change is to use a more allocation efficient structure.

Signed-off-by: Patrick Donnelly <pdonnell@redhat.com>

diff --git a/src/mds/Beacon.cc b/src/mds/Beacon.cc
index 8cca7864a31185a6c07c5d2c192cb911d38fc373..cda44823fb9c38264f0b762ee1307a91be57c61e 100644 (file)
--- a/src/mds/Beacon.cc
+++ b/src/mds/Beacon.cc
@@ -320,41 +320,38 @@ void Beacon::notify_health(MDSRank const *mds)
   // Detect clients failing to respond to modifications to capabilities in
   // CLIENT_CAPS messages.
   {
-    std::list<client_t> late_clients;
-    mds->locker->get_late_revoking_clients(&late_clients,
-                                           mds->mdsmap->get_session_timeout());
-    std::list<MDSHealthMetric> late_cap_metrics;
-
-    for (std::list<client_t>::iterator i = late_clients.begin(); i != late_clients.end(); ++i) {
+    auto&& late_clients = mds->locker->get_late_revoking_clients(mds->mdsmap->get_session_timeout());
+    std::vector<MDSHealthMetric> late_cap_metrics;
 
+    for (const auto& client : late_clients) {
       // client_t is equivalent to session.info.inst.name.num
       // Construct an entity_name_t to lookup into SessionMap
-      entity_name_t ename(CEPH_ENTITY_TYPE_CLIENT, i->v);
+      entity_name_t ename(CEPH_ENTITY_TYPE_CLIENT, client.v);
       Session const *s = mds->sessionmap.get_session(ename);
       if (s == NULL) {
         // Shouldn't happen, but not worth crashing if it does as this is
         // just health-reporting code.
-        derr << "Client ID without session: " << i->v << dendl;
+        derr << "Client ID without session: " << client.v << dendl;
         continue;
       }
 
       std::ostringstream oss;
       oss << "Client " << s->get_human_name() << " failing to respond to capability release";
       MDSHealthMetric m(MDS_HEALTH_CLIENT_LATE_RELEASE, HEALTH_WARN, oss.str());
-      m.metadata["client_id"] = stringify(i->v);
-      late_cap_metrics.push_back(m);
+      m.metadata["client_id"] = stringify(client.v);
+      late_cap_metrics.emplace_back(std::move(m));
     }
 
     if (late_cap_metrics.size() <= (size_t)g_conf()->mds_health_summarize_threshold) {
-      health.metrics.splice(health.metrics.end(), late_cap_metrics);
+      auto&& m = late_cap_metrics;
+      health.metrics.insert(std::end(health.metrics), std::cbegin(m), std::cend(m));
     } else {
       std::ostringstream oss;
       oss << "Many clients (" << late_cap_metrics.size()
           << ") failing to respond to capability release";
       MDSHealthMetric m(MDS_HEALTH_CLIENT_LATE_RELEASE_MANY, HEALTH_WARN, oss.str());
       m.metadata["client_count"] = stringify(late_cap_metrics.size());
-      health.metrics.push_back(m);
-      late_cap_metrics.clear();
+      health.metrics.push_back(std::move(m));
     }
   }
 
@@ -369,8 +366,8 @@ void Beacon::notify_health(MDSRank const *mds)
     const auto recall_warning_threshold = g_conf().get_val<Option::size_t>("mds_recall_warning_threshold");
     const auto max_completed_requests = g_conf()->mds_max_completed_requests;
     const auto max_completed_flushes = g_conf()->mds_max_completed_flushes;
-    std::list<MDSHealthMetric> late_recall_metrics;
-    std::list<MDSHealthMetric> large_completed_requests_metrics;
+    std::vector<MDSHealthMetric> late_recall_metrics;
+    std::vector<MDSHealthMetric> large_completed_requests_metrics;
     for (auto& session : sessions) {
       const uint64_t recall_caps = session->get_recall_caps();
       if (recall_caps > recall_warning_threshold) {
@@ -381,7 +378,7 @@ void Beacon::notify_health(MDSRank const *mds)
         oss << "Client " << session->get_human_name() << " failing to respond to cache pressure";
         MDSHealthMetric m(MDS_HEALTH_CLIENT_RECALL, HEALTH_WARN, oss.str());
         m.metadata["client_id"] = stringify(session->get_client());
-        late_recall_metrics.push_back(m);
+        late_recall_metrics.emplace_back(std::move(m));
       }
       if ((session->get_num_trim_requests_warnings() > 0 &&
           session->get_num_completed_requests() >= max_completed_requests) ||
@@ -391,12 +388,13 @@ void Beacon::notify_health(MDSRank const *mds)
        oss << "Client " << session->get_human_name() << " failing to advance its oldest client/flush tid";
        MDSHealthMetric m(MDS_HEALTH_CLIENT_OLDEST_TID, HEALTH_WARN, oss.str());
        m.metadata["client_id"] = stringify(session->get_client());
-       large_completed_requests_metrics.push_back(m);
+       large_completed_requests_metrics.emplace_back(std::move(m));
       }
     }
 
     if (late_recall_metrics.size() <= (size_t)g_conf()->mds_health_summarize_threshold) {
-      health.metrics.splice(health.metrics.end(), late_recall_metrics);
+      auto&& m = late_recall_metrics;
+      health.metrics.insert(std::end(health.metrics), std::cbegin(m), std::cend(m));
     } else {
       std::ostringstream oss;
       oss << "Many clients (" << late_recall_metrics.size()
@@ -408,7 +406,8 @@ void Beacon::notify_health(MDSRank const *mds)
     }
 
     if (large_completed_requests_metrics.size() <= (size_t)g_conf()->mds_health_summarize_threshold) {
-      health.metrics.splice(health.metrics.end(), large_completed_requests_metrics);
+      auto&& m = large_completed_requests_metrics;
+      health.metrics.insert(std::end(health.metrics), std::cbegin(m), std::cend(m));
     } else {
       std::ostringstream oss;
       oss << "Many clients (" << large_completed_requests_metrics.size()

diff --git a/src/mds/CDir.cc b/src/mds/CDir.cc
index 9ff132caa9ac04eec6379708c68979a546c4afc3..687021de9f6e557ccee02f0af3d9ef95818fb00e 100644 (file)
--- a/src/mds/CDir.cc
+++ b/src/mds/CDir.cc
@@ -986,7 +986,7 @@ void CDir::init_fragment_pins()
     get(PIN_SUBTREE);
 }
 
-void CDir::split(int bits, list<CDir*>& subs, MDSContext::vec& waiters, bool replay)
+void CDir::split(int bits, std::vector<CDir*>* subs, MDSContext::vec& waiters, bool replay)
 {
   dout(10) << "split by " << bits << " bits on " << *this << dendl;
 
@@ -1033,7 +1033,7 @@ void CDir::split(int bits, list<CDir*>& subs, MDSContext::vec& waiters, bool rep
 
     dout(10) << " subfrag " << fg << " " << *f << dendl;
     subfrags[n++] = f;
-    subs.push_back(f);
+    subs->push_back(f);
 
     f->set_dir_auth(get_dir_auth());
     f->freeze_tree_state = freeze_tree_state;
@@ -1088,14 +1088,16 @@ void CDir::split(int bits, list<CDir*>& subs, MDSContext::vec& waiters, bool rep
   finish_old_fragment(waiters, replay);
 }
 
-void CDir::merge(list<CDir*>& subs, MDSContext::vec& waiters, bool replay)
+void CDir::merge(const std::vector<CDir*>& subs, MDSContext::vec& waiters, bool replay)
 {
   dout(10) << "merge " << subs << dendl;
 
+  ceph_assert(subs.size() > 0);
+
   set_dir_auth(subs.front()->get_dir_auth());
   freeze_tree_state = subs.front()->freeze_tree_state;
 
-  for (auto dir : subs) {
+  for (const auto& dir : subs) {
     ceph_assert(get_dir_auth() == dir->get_dir_auth());
     ceph_assert(freeze_tree_state == dir->freeze_tree_state);
   }
@@ -1110,7 +1112,7 @@ void CDir::merge(list<CDir*>& subs, MDSContext::vec& waiters, bool replay)
 
   map<string_snap_t, MDSContext::vec > dentry_waiters;
 
-  for (auto dir : subs) {
+  for (const auto& dir : subs) {
     dout(10) << " subfrag " << dir->get_frag() << " " << *dir << dendl;
     ceph_assert(!dir->is_auth() || dir->is_complete() || replay);
 
@@ -3416,26 +3418,23 @@ int CDir::scrub_dentry_next(MDSContext *cb, CDentry **dnout)
   return rval;
 }
 
-void CDir::scrub_dentries_scrubbing(list<CDentry*> *out_dentries)
+std::vector<CDentry*> CDir::scrub_dentries_scrubbing()
 {
   dout(20) << __func__ << dendl;
   ceph_assert(scrub_infop && scrub_infop->directory_scrubbing);
 
-  for (set<dentry_key_t>::iterator i =
-        scrub_infop->directories_scrubbing.begin();
-      i != scrub_infop->directories_scrubbing.end();
-      ++i) {
-    CDentry *d = lookup(i->name, i->snapid);
+  std::vector<CDentry*> result;
+  for (auto& scrub_info : scrub_infop->directories_scrubbing) {
+    CDentry *d = lookup(scrub_info.name, scrub_info.snapid);
     ceph_assert(d);
-    out_dentries->push_back(d);
+    result.push_back(d);
   }
-  for (set<dentry_key_t>::iterator i = scrub_infop->others_scrubbing.begin();
-      i != scrub_infop->others_scrubbing.end();
-      ++i) {
-    CDentry *d = lookup(i->name, i->snapid);
+  for (auto& scrub_info : scrub_infop->others_scrubbing) {
+    CDentry *d = lookup(scrub_info.name, scrub_info.snapid);
     ceph_assert(d);
-    out_dentries->push_back(d);
+    result.push_back(d);
   }
+  return result;
 }
 
 void CDir::scrub_dentry_finished(CDentry *dn)

diff --git a/src/mds/CDir.h b/src/mds/CDir.h
index 3654c6a04011f54833f685ae6fb21b7bd6a29260..38abdf1f4f293dcbabfb9b1cf4e1de533afad70b 100644 (file)
--- a/src/mds/CDir.h
+++ b/src/mds/CDir.h
@@ -317,7 +317,7 @@ public:
    * list will be filled with all CDentry * which have been returned
    * from scrub_dentry_next() but not sent back via scrub_dentry_finished().
    */
-  void scrub_dentries_scrubbing(std::list<CDentry*> *out_dentries);
+  std::vector<CDentry*> scrub_dentries_scrubbing();
   /**
    * Report to the CDir that a CDentry has been scrubbed. Call this
    * for every CDentry returned from scrub_dentry_next().
@@ -500,8 +500,8 @@ public:
 
 
 public:
-  void split(int bits, std::list<CDir*>& subs, MDSContext::vec& waiters, bool replay);
-  void merge(std::list<CDir*>& subs, MDSContext::vec& waiters, bool replay);
+  void split(int bits, std::vector<CDir*>* subs, MDSContext::vec& waiters, bool replay);
+  void merge(const std::vector<CDir*>& subs, MDSContext::vec& waiters, bool replay);
 
   bool should_split() const {
     return (int)get_frag_size() > g_conf()->mds_bal_split_size;

diff --git a/src/mds/CInode.cc b/src/mds/CInode.cc
index 1636e6c91be83a5fe5e3f63a04ad6fda96ff32e0..7f5bc27c4496201ed64e59c1f2b0173b17b7b681 100644 (file)
--- a/src/mds/CInode.cc
+++ b/src/mds/CInode.cc
@@ -633,15 +633,18 @@ frag_t InodeStoreBase::pick_dirfrag(std::string_view dn)
   return dirfragtree[h];
 }
 
-bool CInode::get_dirfrags_under(frag_t fg, list<CDir*>& ls)
+std::pair<bool, std::vector<CDir*>> CInode::get_dirfrags_under(frag_t fg)
 {
-  bool all = true;
+  std::pair<bool, std::vector<CDir*>> result;
+  auto& all = result.first;
+  auto& dirs = result.second;
+
   {
     frag_vec_t leaves;
     dirfragtree.get_leaves_under(fg, leaves);
     for (const auto &leaf : leaves) {
       if (auto it = dirfrags.find(leaf); it != dirfrags.end()) {
-        ls.push_back(it->second);
+        dirs.push_back(it->second);
       } else {
         all = false;
       }
@@ -649,14 +652,14 @@ bool CInode::get_dirfrags_under(frag_t fg, list<CDir*>& ls)
   }
 
   if (all)
-    return all;
+    return result;
 
   fragtree_t tmpdft;
   tmpdft.force_to_leaf(g_ceph_context, fg);
   for (auto &p : dirfrags) {
     tmpdft.force_to_leaf(g_ceph_context, p.first);
     if (fg.contains(p.first) && !dirfragtree.is_leaf(p.first))
-      ls.push_back(p.second);
+      dirs.push_back(p.second);
   }
 
   all = true;
@@ -671,7 +674,7 @@ bool CInode::get_dirfrags_under(frag_t fg, list<CDir*>& ls)
     }
   }
 
-  return all;
+  return result;
 }
 
 void CInode::verify_dirfrags()
@@ -715,10 +718,9 @@ CDir *CInode::get_approx_dirfrag(frag_t fg)
   if (dir) return dir;
 
   // find a child?
-  list<CDir*> ls;
-  get_dirfrags_under(fg, ls);
-  if (!ls.empty()) 
-    return ls.front();
+  auto&& p = get_dirfrags_under(fg);
+  if (!p.second.empty())
+    return p.second.front();
 
   // try parents?
   while (fg.bits() > 0) {

diff --git a/src/mds/CInode.h b/src/mds/CInode.h
index ca3d105066609a08d513ff67c4472a247a7c044a..b10b5a591d0bb2a3bbf075adddc16973692e68a2 100644 (file)
--- a/src/mds/CInode.h
+++ b/src/mds/CInode.h
@@ -559,7 +559,7 @@ public:
     } 
     return NULL;
   }
-  bool get_dirfrags_under(frag_t fg, std::list<CDir*>& ls);
+  std::pair<bool, std::vector<CDir*>> get_dirfrags_under(frag_t fg);
   CDir* get_approx_dirfrag(frag_t fg);
 
   template<typename Container>

diff --git a/src/mds/FSMap.cc b/src/mds/FSMap.cc
index 59a34fda696ac4345a03656b7747b22c0e7df45e..0663152430995c017c7c1ea5f1a573e215c9595b 100644 (file)
--- a/src/mds/FSMap.cc
+++ b/src/mds/FSMap.cc
@@ -946,7 +946,7 @@ void FSMap::insert(const MDSMap::mds_info_t &new_info)
   standby_epochs[new_info.global_id] = epoch;
 }
 
-std::list<mds_gid_t> FSMap::stop(mds_gid_t who)
+std::vector<mds_gid_t> FSMap::stop(mds_gid_t who)
 {
   ceph_assert(mds_roles.at(who) != FS_CLUSTER_ID_NONE);
   auto fs = filesystems.at(mds_roles.at(who));
@@ -956,7 +956,7 @@ std::list<mds_gid_t> FSMap::stop(mds_gid_t who)
   fs->mds_map.stopped.insert(info.rank);
 
   // Also drop any standby replays that were following this rank
-  std::list<mds_gid_t> standbys;
+  std::vector<mds_gid_t> standbys;
   for (const auto &i : fs->mds_map.mds_info) {
     const auto &other_gid = i.first;
     const auto &other_info = i.second;

diff --git a/src/mds/FSMap.h b/src/mds/FSMap.h
index 99bf3736bbf3755678e351a83365f20cb5ac66c1..ca286b290c45eaaefa354ab9f72bc1a9f2d97d21 100644 (file)
--- a/src/mds/FSMap.h
+++ b/src/mds/FSMap.h
@@ -277,7 +277,7 @@ public:
    * @returns a list of any additional GIDs that were removed from the map
    * as a side effect (like standby replays)
    */
-  std::list<mds_gid_t> stop(mds_gid_t who);
+  std::vector<mds_gid_t> stop(mds_gid_t who);
 
   /**
    * The rank held by 'who', if any, is to be relinquished, and

diff --git a/src/mds/Locker.cc b/src/mds/Locker.cc
index 584cf3b59fb030b02b002aad3ea70ed3ab16033b..9e16e702885ca671e8720283a2a8f2b247da9a0a 100644 (file)
--- a/src/mds/Locker.cc
+++ b/src/mds/Locker.cc
@@ -3611,20 +3611,21 @@ bool Locker::any_late_revoking_caps(xlist<Capability*> const &revoking,
     }
 }
 
-void Locker::get_late_revoking_clients(std::list<client_t> *result,
-                                       double timeout) const
+std::vector<client_t> Locker::get_late_revoking_clients(double timeout) const
 {
-  if (!any_late_revoking_caps(revoking_caps, timeout)) {
-    // Fast path: no misbehaving clients, execute in O(1)
-    return;
-  }
+  std::vector<client_t> result;
 
-  // Slow path: execute in O(N_clients)
-  for (auto &p : revoking_caps_by_client) {
-    if (any_late_revoking_caps(p.second, timeout)) {
-      result->push_back(p.first);
+  if (any_late_revoking_caps(revoking_caps, timeout)) {
+    // Slow path: execute in O(N_clients)
+    for (auto &p : revoking_caps_by_client) {
+      if (any_late_revoking_caps(p.second, timeout)) {
+        result.push_back(p.first);
+      }
     }
+  } else {
+    // Fast path: no misbehaving clients, execute in O(1)
   }
+  return result;
 }
 
 // Hard-code instead of surfacing a config settings because this is

diff --git a/src/mds/Locker.h b/src/mds/Locker.h
index 47b5b779edd78f20de280fd0bf8b86ba4af6e104..95845a0e7b069350caf2111e4b40e8e995709906 100644 (file)
--- a/src/mds/Locker.h
+++ b/src/mds/Locker.h
@@ -181,7 +181,7 @@ public:
 
   void remove_client_cap(CInode *in, Capability *cap);
 
-  void get_late_revoking_clients(std::list<client_t> *result, double timeout) const;
+  std::vector<client_t> get_late_revoking_clients(double timeout) const;
 
 private:
   bool any_late_revoking_caps(xlist<Capability*> const &revoking, double timeout) const;

diff --git a/src/mds/MDBalancer.cc b/src/mds/MDBalancer.cc
index d4a28e2e8ac377fe7792db551d7d3a7e18663fbf..03e9a32c370e6cc1f88afc76abb67c24cb7ce882 100644 (file)
--- a/src/mds/MDBalancer.cc
+++ b/src/mds/MDBalancer.cc
@@ -565,15 +565,13 @@ void MDBalancer::queue_merge(CDir *dir)
     frag_t fg = dir->get_frag();
     while (fg != frag_t()) {
       frag_t sibfg = fg.get_sibling();
-      list<CDir*> sibs;
-      bool complete = diri->get_dirfrags_under(sibfg, sibs);
+      auto&& [complete, sibs] = diri->get_dirfrags_under(sibfg);
       if (!complete) {
         dout(10) << "  not all sibs under " << sibfg << " in cache (have " << sibs << ")" << dendl;
         break;
       }
       bool all = true;
-      for (list<CDir*>::iterator p = sibs.begin(); p != sibs.end(); ++p) {
-        CDir *sib = *p;
+      for (auto& sib : sibs) {
         if (!sib->is_auth() || !sib->should_merge()) {
           all = false;
           break;

diff --git a/src/mds/MDCache.cc b/src/mds/MDCache.cc
index bb26263a056a5a53202982a59f56e653e602d378..188227d0089d7448c758cf2f9e29dced17644308 100644 (file)
--- a/src/mds/MDCache.cc
+++ b/src/mds/MDCache.cc
@@ -3002,7 +3002,7 @@ void MDCache::handle_mds_failure(mds_rank_t who)
 
     ++p;
     dout(10) << "cancelling fragment " << df << " bit " << info.bits << dendl;
-    list<CDir*> dirs;
+    std::vector<CDir*> dirs;
     info.dirs.swap(dirs);
     fragments.erase(df);
     fragment_unmark_unfreeze_dirs(dirs);
@@ -3041,12 +3041,12 @@ void MDCache::handle_mds_recovery(mds_rank_t who)
     ceph_assert(!dir->is_auth());
    
     // wake any waiters
-    list<CDir*> q;
-    q.push_back(dir);
+    std::queue<CDir*> q;
+    q.push(dir);
 
     while (!q.empty()) {
       CDir *d = q.front();
-      q.pop_front();
+      q.pop();
       d->take_waiting(d_mask, waiters);
 
       // inode waiters too
@@ -3060,7 +3060,7 @@ void MDCache::handle_mds_recovery(mds_rank_t who)
          auto&& ls = dnl->get_inode()->get_dirfrags();
          for (const auto& subdir : ls) {
            if (!subdir->is_subtree_root())
-             q.push_back(subdir);
+             q.push(subdir);
          }
        }
       }
@@ -3745,15 +3745,15 @@ void MDCache::recalc_auth_bits(bool replay)
       }
     }
 
-    std::deque<CDir*> dfq;  // dirfrag queue
-    dfq.push_back(p->first);
+    std::queue<CDir*> dfq;  // dirfrag queue
+    dfq.push(p->first);
 
     bool auth = p->first->authority().first == mds->get_nodeid();
     dout(10) << " subtree auth=" << auth << " for " << *p->first << dendl;
 
     while (!dfq.empty()) {
       CDir *dir = dfq.front();
-      dfq.pop_front();
+      dfq.pop();
 
       // dir
       if (auth) {
@@ -3811,7 +3811,7 @@ void MDCache::recalc_auth_bits(bool replay)
          if (in->is_dir()) {
            auto&& dfv = in->get_nested_dirfrags();
             for (const auto& dir : dfv) {
-              dfq.push_back(dir);
+              dfq.push(dir);
             }
           }
        }
@@ -5999,12 +5999,12 @@ void MDCache::rejoin_send_acks()
     dout(10) << "subtree " << *dir << dendl;
     
     // auth items in this subtree
-    std::deque<CDir*> dq;
-    dq.push_back(dir);
+    std::queue<CDir*> dq;
+    dq.push(dir);
 
     while (!dq.empty()) {
       CDir *dir = dq.front();
-      dq.pop_front();
+      dq.pop();
       
       // dir
       for (auto &r : dir->get_replicas()) {
@@ -6057,7 +6057,7 @@ void MDCache::rejoin_send_acks()
        {
           auto&& dirs = in->get_nested_dirfrags();
           for (const auto& dir : dirs) {
-            dq.push_back(dir);
+            dq.push(dir);
           }
         }
       }
@@ -10759,17 +10759,16 @@ void MDCache::handle_dentry_unlink(const MDentryUnlink::const_ref &m)
  * @param bits bit adjustment.  positive for split, negative for merge.
  */
 void MDCache::adjust_dir_fragments(CInode *diri, frag_t basefrag, int bits,
-                                  list<CDir*>& resultfrags, 
+                                  std::vector<CDir*>* resultfrags,
                                   MDSContext::vec& waiters,
                                   bool replay)
 {
   dout(10) << "adjust_dir_fragments " << basefrag << " " << bits 
           << " on " << *diri << dendl;
 
-  list<CDir*> srcfrags;
-  diri->get_dirfrags_under(basefrag, srcfrags);
+  auto&& p = diri->get_dirfrags_under(basefrag);
 
-  adjust_dir_fragments(diri, srcfrags, basefrag, bits, resultfrags, waiters, replay);
+  adjust_dir_fragments(diri, p.second, basefrag, bits, resultfrags, waiters, replay);
 }
 
 CDir *MDCache::force_dir_fragment(CInode *diri, frag_t fg, bool replay)
@@ -10780,7 +10779,7 @@ CDir *MDCache::force_dir_fragment(CInode *diri, frag_t fg, bool replay)
 
   dout(10) << "force_dir_fragment " << fg << " on " << *diri << dendl;
 
-  list<CDir*> src, result;
+  std::vector<CDir*> src, result;
   MDSContext::vec waiters;
 
   // split a parent?
@@ -10791,7 +10790,7 @@ CDir *MDCache::force_dir_fragment(CInode *diri, frag_t fg, bool replay)
       int split = fg.bits() - parent.bits();
       dout(10) << " splitting parent by " << split << " " << *pdir << dendl;
       src.push_back(pdir);
-      adjust_dir_fragments(diri, src, parent, split, result, waiters, replay);
+      adjust_dir_fragments(diri, src, parent, split, &result, waiters, replay);
       dir = diri->get_dirfrag(fg);
       if (dir) {
        dout(10) << "force_dir_fragment result " << *dir << dendl;
@@ -10807,12 +10806,15 @@ CDir *MDCache::force_dir_fragment(CInode *diri, frag_t fg, bool replay)
 
   if (!dir) {
     // hoover up things under fg?
-    diri->get_dirfrags_under(fg, src);
+    {
+      auto&& p = diri->get_dirfrags_under(fg);
+      src.insert(std::end(src), std::cbegin(p.second), std::cend(p.second));
+    }
     if (src.empty()) {
       dout(10) << "force_dir_fragment no frags under " << fg << dendl;
     } else {
       dout(10) << " will combine frags under " << fg << ": " << src << dendl;
-      adjust_dir_fragments(diri, src, fg, 0, result, waiters, replay);
+      adjust_dir_fragments(diri, src, fg, 0, &result, waiters, replay);
       dir = result.front();
       dout(10) << "force_dir_fragment result " << *dir << dendl;
     }
@@ -10823,9 +10825,9 @@ CDir *MDCache::force_dir_fragment(CInode *diri, frag_t fg, bool replay)
 }
 
 void MDCache::adjust_dir_fragments(CInode *diri,
-                                  list<CDir*>& srcfrags,
+                                  const std::vector<CDir*>& srcfrags,
                                   frag_t basefrag, int bits,
-                                  list<CDir*>& resultfrags, 
+                                  std::vector<CDir*>* resultfrags,
                                   MDSContext::vec& waiters,
                                   bool replay)
 {
@@ -10851,6 +10853,7 @@ void MDCache::adjust_dir_fragments(CInode *diri,
   if (parent_dir)
     parent_subtree = get_subtree_root(parent_dir);
 
+  ceph_assert(srcfrags.size() >= 1);
   if (bits > 0) {
     // SPLIT
     ceph_assert(srcfrags.size() == 1);
@@ -10861,7 +10864,7 @@ void MDCache::adjust_dir_fragments(CInode *diri,
     // did i change the subtree map?
     if (dir->is_subtree_root()) {
       // new frags are now separate subtrees
-      for (const auto& dir : resultfrags) {
+      for (const auto& dir : *resultfrags) {
        subtrees[dir].clear();   // new frag is now its own subtree
       }
       
@@ -10869,7 +10872,7 @@ void MDCache::adjust_dir_fragments(CInode *diri,
       if (parent_subtree) {
        ceph_assert(subtrees[parent_subtree].count(dir));
        subtrees[parent_subtree].erase(dir);
-       for (const auto& dir : resultfrags) {
+       for (const auto& dir : *resultfrags) {
          ceph_assert(dir->is_subtree_root());
          subtrees[parent_subtree].insert(dir);
        }
@@ -10897,7 +10900,7 @@ void MDCache::adjust_dir_fragments(CInode *diri,
     // are my constituent bits subtrees?  if so, i will be too.
     // (it's all or none, actually.)
     bool any_subtree = false, any_non_subtree = false;
-    for (CDir *dir : srcfrags) {
+    for (const auto& dir : srcfrags) {
       if (dir->is_subtree_root())
        any_subtree = true;
       else
@@ -10907,7 +10910,7 @@ void MDCache::adjust_dir_fragments(CInode *diri,
 
     set<CDir*> new_bounds;
     if (any_subtree)  {
-      for (CDir *dir : srcfrags) {
+      for (const auto& dir : srcfrags) {
        // this simplifies the code that find subtrees underneath the dirfrag
        if (!dir->is_subtree_root()) {
          dir->state_set(CDir::STATE_AUXSUBTREE);
@@ -10915,7 +10918,7 @@ void MDCache::adjust_dir_fragments(CInode *diri,
        }
       }
 
-      for (CDir *dir : srcfrags) {
+      for (const auto& dir : srcfrags) {
        ceph_assert(dir->is_subtree_root());
        dout(10) << " taking srcfrag subtree bounds from " << *dir << dendl;
        map<CDir*, set<CDir*> >::iterator q = subtrees.find(dir);
@@ -10945,7 +10948,7 @@ void MDCache::adjust_dir_fragments(CInode *diri,
       show_subtrees(10);
     }
 
-    resultfrags.push_back(f);
+    resultfrags->push_back(f);
   }
 }
 
@@ -10961,7 +10964,7 @@ public:
   }
 };
 
-bool MDCache::can_fragment(CInode *diri, list<CDir*>& dirs)
+bool MDCache::can_fragment(CInode *diri, const std::vector<CDir*>& dirs)
 {
   if (is_readonly()) {
     dout(7) << "can_fragment: read-only FS, no fragmenting for now" << dendl;
@@ -11015,7 +11018,7 @@ void MDCache::split_dir(CDir *dir, int bits)
   ceph_assert(dir->is_auth());
   CInode *diri = dir->inode;
 
-  list<CDir*> dirs;
+  std::vector<CDir*> dirs;
   dirs.push_back(dir);
 
   if (!can_fragment(diri, dirs)) {
@@ -11047,8 +11050,8 @@ void MDCache::merge_dir(CInode *diri, frag_t frag)
 {
   dout(7) << "merge_dir to " << frag << " on " << *diri << dendl;
 
-  list<CDir*> dirs;
-  if (!diri->get_dirfrags_under(frag, dirs)) {
+  auto&& [all, dirs] = diri->get_dirfrags_under(frag);
+  if (!all) {
     dout(7) << "don't have all frags under " << frag << " for " << *diri << dendl;
     return;
   }
@@ -11081,10 +11084,10 @@ void MDCache::merge_dir(CInode *diri, frag_t frag)
   fragment_mark_and_complete(mdr);
 }
 
-void MDCache::fragment_freeze_dirs(list<CDir*>& dirs)
+void MDCache::fragment_freeze_dirs(const std::vector<CDir*>& dirs)
 {
   bool any_subtree = false, any_non_subtree = false;
-  for (CDir* dir : dirs) {
+  for (const auto& dir : dirs) {
     dir->auth_pin(dir);  // until we mark and complete them
     dir->state_set(CDir::STATE_FRAGMENTING);
     dir->freeze_dir();
@@ -11098,7 +11101,7 @@ void MDCache::fragment_freeze_dirs(list<CDir*>& dirs)
 
   if (any_subtree && any_non_subtree) {
     // either all dirfrags are subtree roots or all are not.
-    for (CDir *dir : dirs) {
+    for (const auto& dir : dirs) {
       if (dir->is_subtree_root()) {
        ceph_assert(dir->state_test(CDir::STATE_AUXSUBTREE));
       } else {
@@ -11195,7 +11198,7 @@ void MDCache::fragment_mark_and_complete(MDRequestRef& mdr)
   fragment_frozen(mdr, 0);
 }
 
-void MDCache::fragment_unmark_unfreeze_dirs(list<CDir*>& dirs)
+void MDCache::fragment_unmark_unfreeze_dirs(const std::vector<CDir*>& dirs)
 {
   dout(10) << "fragment_unmark_unfreeze_dirs " << dirs << dendl;
   for (const auto& dir : dirs) {
@@ -11289,7 +11292,7 @@ void MDCache::find_stale_fragment_freeze()
     if (info.num_remote_waiters > 0 ||
        (!dir->inode->is_root() && dir->get_parent_dir()->is_freezing())) {
       dout(10) << " cancel fragmenting " << df << " bit " << info.bits << dendl;
-      list<CDir*> dirs;
+      std::vector<CDir*> dirs;
       info.dirs.swap(dirs);
       fragments.erase(df);
       fragment_unmark_unfreeze_dirs(dirs);
@@ -11414,7 +11417,7 @@ void MDCache::dispatch_fragment_dir(MDRequestRef& mdr)
   // refragment
   MDSContext::vec waiters;
   adjust_dir_fragments(diri, info.dirs, basedirfrag.frag, info.bits,
-                      info.resultfrags, waiters, false);
+                      &info.resultfrags, waiters, false);
   if (g_conf()->mds_debug_frag)
     diri->verify_dirfrags();
   mds->queue_waiters(waiters);
@@ -11422,7 +11425,7 @@ void MDCache::dispatch_fragment_dir(MDRequestRef& mdr)
   for (const auto& fg : le->orig_frags)
     ceph_assert(!diri->dirfragtree.is_leaf(fg));
 
-  le->metablob.add_dir_context(*info.resultfrags.begin());
+  le->metablob.add_dir_context(info.resultfrags.front());
   for (const auto& dir : info.resultfrags) {
     if (diri->is_auth()) {
       le->metablob.add_fragmented_dir(dir, false, false);
@@ -11715,8 +11718,8 @@ void MDCache::handle_fragment_notify(const MMDSFragmentNotify::const_ref &notify
 
     // refragment
     MDSContext::vec waiters;
-    list<CDir*> resultfrags;
-    adjust_dir_fragments(diri, base, bits, resultfrags, waiters, false);
+    std::vector<CDir*> resultfrags;
+    adjust_dir_fragments(diri, base, bits, &resultfrags, waiters, false);
     if (g_conf()->mds_debug_frag)
       diri->verify_dirfrags();
     
@@ -11814,11 +11817,11 @@ void MDCache::rollback_uncommitted_fragments()
     frag_vec_t old_frags;
     diri->dirfragtree.get_leaves_under(p->first.frag, old_frags);
 
-    list<CDir*> resultfrags;
+    std::vector<CDir*> resultfrags;
     if (uf.old_frags.empty()) {
       // created by old format EFragment
       MDSContext::vec waiters;
-      adjust_dir_fragments(diri, p->first.frag, -uf.bits, resultfrags, waiters, true);
+      adjust_dir_fragments(diri, p->first.frag, -uf.bits, &resultfrags, waiters, true);
     } else {
       auto bp = uf.rollback.cbegin();
       for (const auto& fg : uf.old_frags) {

diff --git a/src/mds/MDCache.h b/src/mds/MDCache.h
index fe3d0e6e60b10b923f6b36d140118388c25917e9..3183edcb4ce092f248c6e9ce75dfaa3b0f09101c 100644 (file)
--- a/src/mds/MDCache.h
+++ b/src/mds/MDCache.h
@@ -1169,8 +1169,8 @@ private:
 
   struct fragment_info_t {
     int bits;
-    list<CDir*> dirs;
-    list<CDir*> resultfrags;
+    std::vector<CDir*> dirs;
+    std::vector<CDir*> resultfrags;
     MDRequestRef mdr;
     set<mds_rank_t> notify_ack_waiting;
     bool finishing = false;
@@ -1188,21 +1188,21 @@ private:
   typedef map<dirfrag_t,fragment_info_t>::iterator fragment_info_iterator;
 
   void adjust_dir_fragments(CInode *diri, frag_t basefrag, int bits,
-                           list<CDir*>& frags, MDSContext::vec& waiters, bool replay);
+                           std::vector<CDir*>* frags, MDSContext::vec& waiters, bool replay);
   void adjust_dir_fragments(CInode *diri,
-                           list<CDir*>& srcfrags,
+                           const std::vector<CDir*>& srcfrags,
                            frag_t basefrag, int bits,
-                           list<CDir*>& resultfrags, 
+                           std::vector<CDir*>* resultfrags,
                            MDSContext::vec& waiters,
                            bool replay);
   CDir *force_dir_fragment(CInode *diri, frag_t fg, bool replay=true);
   void get_force_dirfrag_bound_set(const vector<dirfrag_t>& dfs, set<CDir*>& bounds);
 
-  bool can_fragment(CInode *diri, list<CDir*>& dirs);
-  void fragment_freeze_dirs(list<CDir*>& dirs);
+  bool can_fragment(CInode *diri, const std::vector<CDir*>& dirs);
+  void fragment_freeze_dirs(const std::vector<CDir*>& dirs);
   void fragment_mark_and_complete(MDRequestRef& mdr);
   void fragment_frozen(MDRequestRef& mdr, int r);
-  void fragment_unmark_unfreeze_dirs(list<CDir*>& dirs);
+  void fragment_unmark_unfreeze_dirs(const std::vector<CDir*>& dirs);
   void fragment_drop_locks(fragment_info_t &info);
   void fragment_maybe_finish(const fragment_info_iterator& it);
   void dispatch_fragment_dir(MDRequestRef& mdr);

diff --git a/src/mds/Mutation.cc b/src/mds/Mutation.cc
index a5436257ee3590a21f256a0d8b9bd673af6e8ece..bad865f683cc14a391fd6d0443eb0ad3dd7b4dfe 100644 (file)
--- a/src/mds/Mutation.cc
+++ b/src/mds/Mutation.cc
@@ -170,11 +170,10 @@ void MutationImpl::add_projected_fnode(CDir *dir)
 
 void MutationImpl::pop_and_dirty_projected_fnodes()
 {
-  while (!projected_fnodes.empty()) {
-    CDir *dir = projected_fnodes.front();
-    projected_fnodes.pop_front();
+  for (const auto& dir : projected_fnodes) {
     dir->pop_and_dirty_projected_fnode(ls);
   }
+  projected_fnodes.clear();
 }
 
 void MutationImpl::add_updated_lock(ScatterLock *lock)

diff --git a/src/mds/Mutation.h b/src/mds/Mutation.h
index fa5d3c715ec01ac967ed71e8e742bf71bed61cf7..c133050d8d450ec1b40f08a9c8c4f612cefbb6f0 100644 (file)
--- a/src/mds/Mutation.h
+++ b/src/mds/Mutation.h
@@ -143,7 +143,7 @@ public:
 
   // for applying projected inode changes
   list<CInode*> projected_inodes;
-  list<CDir*> projected_fnodes;
+  std::vector<CDir*> projected_fnodes;
   list<ScatterLock*> updated_locks;
 
   list<CInode*> dirty_cow_inodes;

diff --git a/src/mds/OpenFileTable.cc b/src/mds/OpenFileTable.cc
index 868212426dcf03ce5777817748964c913117b3b7..57f6d577e2c271bd39a90e3cb993be774eb3ea88 100644 (file)
--- a/src/mds/OpenFileTable.cc
+++ b/src/mds/OpenFileTable.cc
@@ -537,7 +537,7 @@ void OpenFileTable::commit(MDSContext *c, uint64_t log_seq, int op_prio)
   {
     size_t total_items = 0;
     unsigned used_objs = 1;
-    std::list<unsigned> objs_to_write;
+    std::vector<unsigned> objs_to_write;
     bool journaled = false;
     for (unsigned i = 0; i < omap_num_objs; i++) {
       total_items += omap_num_items[i];

diff --git a/src/mds/PurgeQueue.h b/src/mds/PurgeQueue.h
index feb304019bd50bfe70c38060e070bc3521a3c771..6d915f6940603104ec0c32f2460d4273aa4ec2fe 100644 (file)
--- a/src/mds/PurgeQueue.h
+++ b/src/mds/PurgeQueue.h
@@ -163,7 +163,7 @@ protected:
       uint64_t expire_to);
 
   bool recovered;
-  std::list<Context*> waiting_for_recovery;
+  std::vector<Context*> waiting_for_recovery;
 
   void _go_readonly(int r);
 

diff --git a/src/mds/ScrubStack.cc b/src/mds/ScrubStack.cc
index c36f932fda4a51f6f917408af962fda5ca1e2299..32205afc219f39c00f060e5ba01d1d2aae0e256e 100644 (file)
--- a/src/mds/ScrubStack.cc
+++ b/src/mds/ScrubStack.cc
@@ -201,7 +201,7 @@ void ScrubStack::scrub_dir_inode(CInode *in,
 
   if (header->get_recursive()) {
     frag_vec_t scrubbing_frags;
-    list<CDir*> scrubbing_cdirs;
+    std::queue<CDir*> scrubbing_cdirs;
     in->scrub_dirfrags_scrubbing(&scrubbing_frags);
     dout(20) << __func__ << " iterating over " << scrubbing_frags.size()
       << " scrubbing frags" << dendl;
@@ -209,7 +209,7 @@ void ScrubStack::scrub_dir_inode(CInode *in,
       // turn frags into CDir *
       CDir *dir = in->get_dirfrag(fg);
       if (dir) {
-       scrubbing_cdirs.push_back(dir);
+       scrubbing_cdirs.push(dir);
        dout(25) << __func__ << " got CDir " << *dir << " presently scrubbing" << dendl;
       } else {
        in->scrub_dirfrag_finished(fg);
@@ -220,20 +220,19 @@ void ScrubStack::scrub_dir_inode(CInode *in,
     dout(20) << __func__ << " consuming from " << scrubbing_cdirs.size()
             << " scrubbing cdirs" << dendl;
 
-    list<CDir*>::iterator i = scrubbing_cdirs.begin();
     while (g_conf()->mds_max_scrub_ops_in_progress > scrubs_in_progress) {
       // select next CDir
       CDir *cur_dir = NULL;
-      if (i != scrubbing_cdirs.end()) {
-       cur_dir = *i;
-       ++i;
+      if (!scrubbing_cdirs.empty()) {
+       cur_dir = scrubbing_cdirs.front();
+        scrubbing_cdirs.pop();
        dout(20) << __func__ << " got cur_dir = " << *cur_dir << dendl;
       } else {
        bool ready = get_next_cdir(in, &cur_dir);
        dout(20) << __func__ << " get_next_cdir ready=" << ready << dendl;
 
        if (ready && cur_dir) {
-         scrubbing_cdirs.push_back(cur_dir);
+         scrubbing_cdirs.push(cur_dir);
        } else if (!ready) {
          // We are waiting for load of a frag
          all_frags_done = false;
@@ -392,8 +391,7 @@ void ScrubStack::scrub_dirfrag(CDir *dir,
 
     if (r == ENOENT) {
       // Nothing left to scrub, are we done?
-      std::list<CDentry*> scrubbing;
-      dir->scrub_dentries_scrubbing(&scrubbing);
+      auto&& scrubbing = dir->scrub_dentries_scrubbing();
       if (scrubbing.empty()) {
         dout(20) << __func__ << " dirfrag done: " << *dir << dendl;
         // FIXME: greg: What's the diff meant to be between done and terminal

diff --git a/src/mds/ScrubStack.h b/src/mds/ScrubStack.h
index de51ed3fd94e4b678128e1dea210dd56276c729e..83e4482312884544afd175ee7b0eaf787db9dccb 100644 (file)
--- a/src/mds/ScrubStack.h
+++ b/src/mds/ScrubStack.h
@@ -142,7 +142,7 @@ private:
 
   // list of pending context completions for asynchronous scrub
   // control operations.
-  std::list<Context *> control_ctxs;
+  std::vector<Context *> control_ctxs;
 
   // list of inodes for which scrub operations are running -- used
   // to diplay out in `scrub status`.

diff --git a/src/mds/Server.cc b/src/mds/Server.cc
index fd1a2ddc047407c420cd42acc2ed1078ed1dc97c..654c1748802cb4176f502105c37d45726f04c4f5 100644 (file)
--- a/src/mds/Server.cc
+++ b/src/mds/Server.cc
@@ -1045,8 +1045,7 @@ void Server::evict_cap_revoke_non_responders() {
     return;
   }
 
-  std::list<client_t> to_evict;
-  mds->locker->get_late_revoking_clients(&to_evict, cap_revoke_eviction_timeout);
+  auto&& to_evict = mds->locker->get_late_revoking_clients(cap_revoke_eviction_timeout);
 
   for (auto const &client: to_evict) {
     mds->clog->warn() << "client id " << client << " has not responded to"
@@ -1108,7 +1107,7 @@ void Server::kill_session(Session *session, Context *on_safe)
 
 size_t Server::apply_blacklist(const std::set<entity_addr_t> &blacklist)
 {
-  std::list<Session*> victims;
+  std::vector<Session*> victims;
   const auto& sessions = mds->sessionmap.get_sessions();
   for (const auto& p : sessions)  {
     if (!p.first.is_client()) {
@@ -1123,7 +1122,7 @@ size_t Server::apply_blacklist(const std::set<entity_addr_t> &blacklist)
     }
   }
 
-  for (const auto s : victims) {
+  for (const auto& s : victims) {
     kill_session(s, nullptr);
   }
 

diff --git a/src/mds/journal.cc b/src/mds/journal.cc
index 60eb0675fa1726cec18774798a5e3a48111a4d1b..2893d7e598131829c3418ae50602d0cf5046eba9 100644 (file)
--- a/src/mds/journal.cc
+++ b/src/mds/journal.cc
@@ -914,7 +914,7 @@ void EMetaBlob::get_paths(
 
   // Whenever we see a dentry within a dirlump, we remember it as a child of
   // the dirlump's inode
-  std::map<inodeno_t, std::list<std::string> > children;
+  std::map<inodeno_t, std::vector<std::string> > children;
 
   // Whenever we see a location for an inode, remember it: this allows us to
   // build a path given an inode
@@ -2672,7 +2672,7 @@ void EFragment::replay(MDSRank *mds)
 {
   dout(10) << "EFragment.replay " << op_name(op) << " " << ino << " " << basefrag << " by " << bits << dendl;
 
-  list<CDir*> resultfrags;
+  std::vector<CDir*> resultfrags;
   MDSContext::vec waiters;
 
   // in may be NULL if it wasn't in our cache yet.  if it's a prepare
@@ -2686,7 +2686,7 @@ void EFragment::replay(MDSRank *mds)
     mds->mdcache->add_uncommitted_fragment(dirfrag_t(ino, basefrag), bits, orig_frags, segment, &rollback);
 
     if (in)
-      mds->mdcache->adjust_dir_fragments(in, basefrag, bits, resultfrags, waiters, true);
+      mds->mdcache->adjust_dir_fragments(in, basefrag, bits, &resultfrags, waiters, true);
     break;
 
   case OP_ROLLBACK: {
@@ -2695,7 +2695,7 @@ void EFragment::replay(MDSRank *mds)
       in->dirfragtree.get_leaves_under(basefrag, old_frags);
       if (orig_frags.empty()) {
        // old format EFragment
-       mds->mdcache->adjust_dir_fragments(in, basefrag, -bits, resultfrags, waiters, true);
+       mds->mdcache->adjust_dir_fragments(in, basefrag, -bits, &resultfrags, waiters, true);
       } else {
        for (const auto& fg : orig_frags)
          mds->mdcache->force_dir_fragment(in, fg);

diff --git a/src/messages/MMDSBeacon.h b/src/messages/MMDSBeacon.h
index 24922ae333036930d1497dfda9843bc4bde7d81e..318109a8697508b62eabf406a540a3ce91c636ad 100644 (file)
--- a/src/messages/MMDSBeacon.h
+++ b/src/messages/MMDSBeacon.h
@@ -157,7 +157,7 @@ WRITE_CLASS_ENCODER(MDSHealthMetric)
  */
 struct MDSHealth
 {
-  std::list<MDSHealthMetric> metrics;
+  std::vector<MDSHealthMetric> metrics;
 
   void encode(bufferlist& bl) const {
     ENCODE_START(1, 1, bl);