tools: move options parsing into ObjectCacheStore for immutable obj cache daemon

This makes the options parsing more easy to read. SimplePolicy will get those
options from ObjectCacheStore.

Signed-off-by: Yuan Zhou <yuan.zhou@intel.com>

diff --git a/src/common/options.cc b/src/common/options.cc
index 3a3c3be5a0b4534ddacd85451368579352c2b850..002719c8eac26f258ce73029a112de7f2d82c906 100644 (file)
--- a/src/common/options.cc
+++ b/src/common/options.cc
@@ -7404,7 +7404,7 @@ static std::vector<Option> get_immutable_object_cache_options() {
 
     Option("immutable_object_cache_max_inflight_ops", Option::TYPE_UINT, Option::LEVEL_ADVANCED)
     .set_default(128)
-    .set_description("max immutable object caching inflight ops"),
+    .set_description("max inflight promoting requests for immutable object cache daemon"),
 
     Option("immutable_object_cache_client_dedicated_thread_num", Option::TYPE_UINT, Option::LEVEL_ADVANCED)
     .set_default(2)

diff --git a/src/test/immutable_object_cache/test_SimplePolicy.cc b/src/test/immutable_object_cache/test_SimplePolicy.cc
index 348d988ea5123ad118c4c603277642f138613f82..dee6b5b417bb04898d032fbd60d1a9c871898620 100644 (file)
--- a/src/test/immutable_object_cache/test_SimplePolicy.cc
+++ b/src/test/immutable_object_cache/test_SimplePolicy.cc
@@ -30,7 +30,7 @@ public:
   static void SetUpTestCase() {}
   static void TearDownTestCase() {}
   void SetUp() override {
-    m_simple_policy = new SimplePolicy(g_ceph_context, m_cache_size, 0.1);
+    m_simple_policy = new SimplePolicy(g_ceph_context, m_cache_size, 128, 0.1);
     // populate 50 entries
     for (uint64_t i = 0; i < m_cache_size / 2; i++, m_entry_index++) {
       insert_entry_into_promoted_lru(generate_file_name(m_entry_index));

diff --git a/src/tools/immutable_object_cache/ObjectCacheStore.cc b/src/tools/immutable_object_cache/ObjectCacheStore.cc
index 8f7dad8797fe7236b41c3c11186b63fa13a9c567..7c3864a157a7814993c1d091b687280f84dfd823 100644 (file)
--- a/src/tools/immutable_object_cache/ObjectCacheStore.cc
+++ b/src/tools/immutable_object_cache/ObjectCacheStore.cc
@@ -19,21 +19,25 @@ namespace immutable_obj_cache {
 ObjectCacheStore::ObjectCacheStore(CephContext *cct)
       : m_cct(cct), m_rados(new librados::Rados()),
         m_ioctx_map_lock("ceph::cache::ObjectCacheStore::m_ioctx_map_lock") {
-  m_object_cache_max_size =
-    m_cct->_conf.get_val<Option::size_t>("immutable_object_cache_max_size");
 
   m_cache_root_dir =
     m_cct->_conf.get_val<std::string>("immutable_object_cache_path");
 
-  m_cache_watermark =
-    m_cct->_conf.get_val<double>("immutable_object_cache_watermark");
-
   if (m_cache_root_dir.back() != '/') {
     m_cache_root_dir += "/";
   }
 
-  m_policy = new SimplePolicy(m_cct, m_object_cache_max_size,
-                              m_cache_watermark);
+  uint64_t cache_max_size =
+    m_cct->_conf.get_val<Option::size_t>("immutable_object_cache_max_size");
+
+  double cache_watermark =
+    m_cct->_conf.get_val<double>("immutable_object_cache_watermark");
+
+  uint64_t max_inflight_ops =
+    m_cct->_conf.get_val<uint64_t>("immutable_object_cache_max_inflight_ops");
+
+  m_policy = new SimplePolicy(m_cct, cache_max_size, max_inflight_ops,
+                              cache_watermark);
 }
 
 ObjectCacheStore::~ObjectCacheStore() {
@@ -164,7 +168,7 @@ int ObjectCacheStore::handle_promote_callback(int ret, bufferlist* read_buf,
 
   // update metadata
   ceph_assert(OBJ_CACHE_SKIP == m_policy->get_status(cache_file_name));
-  m_policy->update_status(cache_file_name, OBJ_CACHE_PROMOTED, ret);
+  m_policy->update_status(cache_file_name, OBJ_CACHE_PROMOTED, read_buf->length());
   ceph_assert(OBJ_CACHE_PROMOTED == m_policy->get_status(cache_file_name));
 
   delete read_buf;

diff --git a/src/tools/immutable_object_cache/ObjectCacheStore.h b/src/tools/immutable_object_cache/ObjectCacheStore.h
index 42237719fe5faffb9ce711565fbfdd9a02ee9868..57aec63c3d0942809ddadd9b56770628a06d614e 100644 (file)
--- a/src/tools/immutable_object_cache/ObjectCacheStore.h
+++ b/src/tools/immutable_object_cache/ObjectCacheStore.h
@@ -52,8 +52,6 @@ class ObjectCacheStore {
   std::map<uint64_t, librados::IoCtx> m_ioctx_map;
   Mutex m_ioctx_map_lock;
   Policy* m_policy;
-  uint64_t m_object_cache_max_size;
-  float m_cache_watermark;
   std::string m_cache_root_dir;
 };
 

diff --git a/src/tools/immutable_object_cache/SimplePolicy.cc b/src/tools/immutable_object_cache/SimplePolicy.cc
index 299676626cf16866fa8bbee5316e131ac96b61fe..6b008b1750229273583274554ee6d94b870c4f58 100644 (file)
--- a/src/tools/immutable_object_cache/SimplePolicy.cc
+++ b/src/tools/immutable_object_cache/SimplePolicy.cc
@@ -14,13 +14,17 @@ namespace ceph {
 namespace immutable_obj_cache {
 
 SimplePolicy::SimplePolicy(CephContext *cct, uint64_t cache_size,
-                           float watermark)
-  : cct(cct), m_watermark(watermark), m_max_cache_size(cache_size),
+                           uint64_t max_inflight, double watermark)
+  : cct(cct), m_watermark(watermark), m_max_inflight_ops(max_inflight),
+    m_max_cache_size(cache_size),
     m_cache_map_lock("rbd::cache::SimplePolicy::m_cache_map_lock") {
-  ldout(cct, 20) << dendl;
-  m_max_inflight_ops = cct->_conf.get_val<uint64_t>(
-    "immutable_object_cache_max_inflight_ops");
+
+  ldout(cct, 20) << "max cache size= " << m_max_cache_size
+                 << " ,watermark= " << m_watermark
+                 << " ,max inflight ops= " << m_max_inflight_ops << dendl;
+
   m_cache_size = 0;
+
 }
 
 SimplePolicy::~SimplePolicy() {

diff --git a/src/tools/immutable_object_cache/SimplePolicy.h b/src/tools/immutable_object_cache/SimplePolicy.h
index 2b79f0a851d19e6c1f718e41613a58f105072868..aac96519edfc000547629cf58408390f2a0b4950 100644 (file)
--- a/src/tools/immutable_object_cache/SimplePolicy.h
+++ b/src/tools/immutable_object_cache/SimplePolicy.h
@@ -18,7 +18,8 @@ namespace immutable_obj_cache {
 
 class SimplePolicy : public Policy {
  public:
-  SimplePolicy(CephContext *cct, uint64_t block_num, float watermark);
+  SimplePolicy(CephContext *cct, uint64_t block_num, uint64_t max_inflight,
+               double watermark);
   ~SimplePolicy();
 
   cache_status_t lookup_object(std::string file_name);
@@ -49,7 +50,7 @@ class SimplePolicy : public Policy {
   };
 
   CephContext* cct;
-  float m_watermark;
+  double m_watermark;
   uint64_t m_max_inflight_ops;
   uint64_t m_max_cache_size;
   std::atomic<uint64_t> inflight_ops = 0;