os/bluestore/BlueFS: use bluefs mempool

Signed-off-by: Sage Weil <sage@redhat.com>

diff --git a/src/include/mempool.h b/src/include/mempool.h
index da017bb9143f70aecb08358664ddaecda259612f..577f97485a6deeca6169c3fa3b307f212383ff92 100644 (file)
--- a/src/include/mempool.h
+++ b/src/include/mempool.h
@@ -141,7 +141,8 @@ namespace mempool {
   f(unittest_1)                              \
   f(unittest_2)                              \
   f(bluestore_meta_onode)            \
-  f(bluestore_meta_other)
+  f(bluestore_meta_other)            \
+  f(bluefs)
 
 // give them integer ids
 #define P(x) mempool_##x,

diff --git a/src/os/bluestore/BlueFS.cc b/src/os/bluestore/BlueFS.cc
index c1d43f8d52eca27161549f488a0dc229b68ba3ad..41491a2e0dfb3fe4372500be3c1a1f415f921c55 100644 (file)
--- a/src/os/bluestore/BlueFS.cc
+++ b/src/os/bluestore/BlueFS.cc
@@ -13,6 +13,15 @@
 #undef dout_prefix
 #define dout_prefix *_dout << "bluefs "
 
+MEMPOOL_DEFINE_OBJECT_FACTORY(BlueFS::File, bluefs_file, bluefs);
+MEMPOOL_DEFINE_OBJECT_FACTORY(BlueFS::Dir, bluefs_dir, bluefs);
+MEMPOOL_DEFINE_OBJECT_FACTORY(BlueFS::FileWriter, bluefs_file_writer, bluefs);
+MEMPOOL_DEFINE_OBJECT_FACTORY(BlueFS::FileReaderBuffer,
+                             bluefs_file_reader_buffer, bluefs);
+MEMPOOL_DEFINE_OBJECT_FACTORY(BlueFS::FileReader, bluefs_file_reader, bluefs);
+MEMPOOL_DEFINE_OBJECT_FACTORY(BlueFS::FileLock, bluefs_file_lock, bluefs);
+
+
 BlueFS::BlueFS()
   : bdev(MAX_BDEV),
     ioc(MAX_BDEV),
@@ -842,7 +851,7 @@ int BlueFS::_read_random(
   int ret = 0;
   while (len > 0) {
     uint64_t x_off = 0;
-    vector<bluefs_extent_t>::iterator p = h->file->fnode.seek(off, &x_off);
+    auto p = h->file->fnode.seek(off, &x_off);
     uint64_t l = MIN(p->length - x_off, len);
     dout(20) << __func__ << " read buffered 0x"
              << std::hex << x_off << "~" << l << std::dec
@@ -894,8 +903,7 @@ int BlueFS::_read(
       buf->bl.clear();
       buf->bl_off = off & super.block_mask();
       uint64_t x_off = 0;
-      vector<bluefs_extent_t>::iterator p =
-       h->file->fnode.seek(buf->bl_off, &x_off);
+      auto p = h->file->fnode.seek(buf->bl_off, &x_off);
       uint64_t want = ROUND_UP_TO(len + (off & ~super.block_mask()),
                                  super.block_size);
       want = MAX(want, buf->max_prefetch);
@@ -957,7 +965,7 @@ void BlueFS::_invalidate_cache(FileRef f, uint64_t offset, uint64_t length)
     length = ROUND_UP_TO(length, super.block_size);
   }
   uint64_t x_off = 0;
-  vector<bluefs_extent_t>::iterator p = f->fnode.seek(offset, &x_off);
+  auto p = f->fnode.seek(offset, &x_off);
   while (length > 0 && p != f->fnode.extents.end()) {
     uint64_t x_len = MIN(p->length - x_off, length);
     bdev[p->bdev]->invalidate_cache(p->offset + x_off, x_len);
@@ -1064,7 +1072,7 @@ void BlueFS::_compact_log_sync()
   uint64_t need = bl.length() + g_conf->bluefs_max_log_runway;
   dout(20) << __func__ << " need " << need << dendl;
 
-  vector<bluefs_extent_t> old_extents;
+  mempool::bluefs::vector<bluefs_extent_t> old_extents;
   old_extents.swap(log_file->fnode.extents);
   while (log_file->fnode.get_allocated() < need) {
     int r = _allocate(log_file->fnode.prefer_bdev,
@@ -1186,7 +1194,7 @@ void BlueFS::_compact_log_async(std::unique_lock<std::mutex>& l)
   dout(10) << __func__ << " remove 0x" << std::hex << old_log_jump_to << std::dec
           << " of " << log_file->fnode.extents << dendl;
   uint64_t discarded = 0;
-  vector<bluefs_extent_t> old_extents;
+  mempool::bluefs::vector<bluefs_extent_t> old_extents;
   while (discarded < old_log_jump_to) {
     assert(!log_file->fnode.extents.empty());
     bluefs_extent_t& e = log_file->fnode.extents.front();
@@ -1473,7 +1481,7 @@ int BlueFS::_flush_range(FileWriter *h, uint64_t offset, uint64_t length)
   dout(20) << __func__ << " file now " << h->file->fnode << dendl;
 
   uint64_t x_off = 0;
-  vector<bluefs_extent_t>::iterator p = h->file->fnode.seek(offset, &x_off);
+  auto p = h->file->fnode.seek(offset, &x_off);
   assert(p != h->file->fnode.extents.end());
   dout(20) << __func__ << " in " << *p << " x_off 0x"
            << std::hex << x_off << std::dec << dendl;
@@ -1700,7 +1708,8 @@ void BlueFS::flush_bdev()
   }
 }
 
-int BlueFS::_allocate(uint8_t id, uint64_t len, vector<bluefs_extent_t> *ev)
+int BlueFS::_allocate(uint8_t id, uint64_t len,
+                     mempool::bluefs::vector<bluefs_extent_t> *ev)
 {
   dout(10) << __func__ << " len 0x" << std::hex << len << std::dec
            << " from " << (int)id << dendl;

diff --git a/src/os/bluestore/BlueFS.h b/src/os/bluestore/BlueFS.h
index f786f54722cebfbfecb6f7cbf0d19905c3f91963..f74d6f442376215dcda33229c932636a62a72397 100644 (file)
--- a/src/os/bluestore/BlueFS.h
+++ b/src/os/bluestore/BlueFS.h
@@ -52,6 +52,8 @@ public:
   };
 
   struct File : public RefCountedObject {
+    MEMPOOL_CLASS_HELPERS();
+
     bluefs_fnode_t fnode;
     int refs;
     uint64_t dirty_seq;
@@ -96,7 +98,9 @@ public:
        &File::dirty_item> > dirty_file_list_t;
 
   struct Dir : public RefCountedObject {
-    map<string,FileRef> file_map;
+    MEMPOOL_CLASS_HELPERS();
+
+    mempool::bluefs::map<string,FileRef> file_map;
 
     Dir() : RefCountedObject(NULL, 0) {}
 
@@ -110,6 +114,8 @@ public:
   typedef boost::intrusive_ptr<Dir> DirRef;
 
   struct FileWriter {
+    MEMPOOL_CLASS_HELPERS();
+
     FileRef file;
     uint64_t pos;           ///< start offset for buffer
     bufferlist buffer;      ///< new data to write (at end of file)
@@ -150,6 +156,8 @@ public:
   };
 
   struct FileReaderBuffer {
+    MEMPOOL_CLASS_HELPERS();
+
     uint64_t bl_off;        ///< prefetch buffer logical offset
     bufferlist bl;          ///< prefetch buffer
     uint64_t pos;           ///< current logical offset
@@ -178,6 +186,8 @@ public:
   };
 
   struct FileReader {
+    MEMPOOL_CLASS_HELPERS();
+
     FileRef file;
     FileReaderBuffer buf;
     bool random;
@@ -196,6 +206,8 @@ public:
   };
 
   struct FileLock {
+    MEMPOOL_CLASS_HELPERS();
+
     FileRef file;
     explicit FileLock(FileRef f) : file(f) {}
   };
@@ -206,8 +218,8 @@ private:
   PerfCounters *logger = nullptr;
 
   // cache
-  map<string, DirRef> dir_map;                    ///< dirname -> Dir
-  ceph::unordered_map<uint64_t,FileRef> file_map; ///< ino -> File
+  mempool::bluefs::map<string, DirRef> dir_map;              ///< dirname -> Dir
+  mempool::bluefs::unordered_map<uint64_t,FileRef> file_map; ///< ino -> File
 
   // map of dirty files, files of same dirty_seq are grouped into list.
   map<uint64_t, dirty_file_list_t> dirty_files;
@@ -251,7 +263,8 @@ private:
   FileRef _get_file(uint64_t ino);
   void _drop_link(FileRef f);
 
-  int _allocate(uint8_t bdev, uint64_t len, vector<bluefs_extent_t> *ev);
+  int _allocate(uint8_t bdev, uint64_t len,
+               mempool::bluefs::vector<bluefs_extent_t> *ev);
   int _flush_range(FileWriter *h, uint64_t offset, uint64_t length);
   int _flush(FileWriter *h, bool force);
   int _fsync(FileWriter *h, std::unique_lock<std::mutex>& l);

diff --git a/src/os/bluestore/bluefs_types.cc b/src/os/bluestore/bluefs_types.cc
index bba6506ce95ea318116a24903bb0f86240cd30ff..3d2717146798969f606256e32aed033fb878dee3 100644 (file)
--- a/src/os/bluestore/bluefs_types.cc
+++ b/src/os/bluestore/bluefs_types.cc
@@ -102,10 +102,10 @@ ostream& operator<<(ostream& out, const bluefs_super_t& s)
 
 // bluefs_fnode_t
 
-vector<bluefs_extent_t>::iterator bluefs_fnode_t::seek(
+mempool::bluefs::vector<bluefs_extent_t>::iterator bluefs_fnode_t::seek(
   uint64_t offset, uint64_t *x_off)
 {
-  vector<bluefs_extent_t>::iterator p = extents.begin();
+  auto p = extents.begin();
   while (p != extents.end()) {
     if ((int64_t) offset >= p->length) {
       offset -= p->length;

diff --git a/src/os/bluestore/bluefs_types.h b/src/os/bluestore/bluefs_types.h
index 78ab2d7dd92c150b9e7a0cd681f0bd480cc42fe6..06ef3b017dc56a186ca14d2bb6e2eaf6a3bb83d1 100644 (file)
--- a/src/os/bluestore/bluefs_types.h
+++ b/src/os/bluestore/bluefs_types.h
@@ -29,7 +29,7 @@ struct bluefs_fnode_t {
   uint64_t size;
   utime_t mtime;
   uint8_t prefer_bdev;
-  vector<bluefs_extent_t> extents;
+  mempool::bluefs::vector<bluefs_extent_t> extents;
 
   bluefs_fnode_t() : ino(0), size(0), prefer_bdev(0) {}
 
@@ -40,7 +40,8 @@ struct bluefs_fnode_t {
     return r;
   }
 
-  vector<bluefs_extent_t>::iterator seek(uint64_t off, uint64_t *x_off);
+  mempool::bluefs::vector<bluefs_extent_t>::iterator seek(
+    uint64_t off, uint64_t *x_off);
 
   void encode(bufferlist& bl) const;
   void decode(bufferlist::iterator& p);