Merge pull request ceph#57223 from myoungwon/wip-rename-global-values-ceph-dedup-daemon

tool: renaming and refactoring global variables in ceph-dedup-daemon

Reviewed-by: Samuel Just <[email protected]>

Author: yuriw

src/tools/ceph_dedup/ceph_dedup_daemon.cc

@@ -4,10 +4,6 @@
 #define dout_prefix *_dout << "ceph_dedup_daemon: " \
                            << __func__ << ": "
 
-ceph::shared_mutex glock = ceph::make_shared_mutex("glock");
-class SampleDedupWorkerThread;
-bool all_stop = false; // Accessed in the main thread and in other worker threads under glock
-
 po::options_description make_usage() {
   po::options_description desc("Usage");
   desc.add_options()
@@ -235,15 +231,42 @@ class SampleDedupWorkerThread : public Thread
   };
 
   struct SampleDedupGlobal {
-    FpStore fp_store;
-    const double sampling_ratio = -1;
+  public:
     SampleDedupGlobal(
       size_t chunk_threshold,
       int sampling_ratio,
       uint32_t report_period,
       size_t fpstore_threshold) :
       fp_store(chunk_threshold, report_period, fpstore_threshold),
       sampling_ratio(static_cast<double>(sampling_ratio) / 100) { }
+
+    bool is_all_stop() {
+      std::shared_lock l{glock};
+      return all_stop;
+    }
+    static void set_all_stop() {
+      std::unique_lock l{glock};
+      all_stop = true;
+    }
+    static void handle_signal(int signum) 
+    {
+      switch (signum) {
+	case SIGINT:
+	case SIGTERM:
+	  set_all_stop();
+	  dout(0) << "got a signal(" << signum << "), daemon wil be terminiated" << dendl;
+	  break;
+
+	default:
+	  ceph_abort_msgf("unexpected signal %d", signum);
+      }
+    }
+    friend class SampleDedupWorkerThread;
+  private:
+    FpStore fp_store;
+    const double sampling_ratio = -1;
+    inline static ceph::shared_mutex glock = ceph::make_shared_mutex("glock");
+    inline static bool all_stop = false; // Accessed in the main thread and in other worker threads under glock
   };
 
   SampleDedupWorkerThread(
@@ -317,9 +340,7 @@ class SampleDedupWorkerThread : public Thread
 void SampleDedupWorkerThread::crawl()
 {
   ObjectCursor current_object = begin;
-  std::shared_lock l{glock};
-  while (!all_stop && current_object < end) {
-    l.unlock();
+  while (!sample_dedup_global.is_all_stop()  && current_object < end) {
     std::vector<ObjectItem> objects;
     // Get the list of object IDs to deduplicate
     std::tie(objects, current_object) = get_objects(current_object, end, 100);
@@ -347,16 +368,12 @@ void SampleDedupWorkerThread::crawl()
       } else {
 	try_dedup_and_accumulate_result(target);
       }
-      l.lock();
-      if (all_stop) {
+      if (sample_dedup_global.is_all_stop()) {
 	oid_for_evict.clear();
 	break;
       }
-      l.unlock();
     }
-    l.lock();
   }
-  l.unlock();
 
   vector<AioCompRef> evict_completions(oid_for_evict.size());
   int i = 0;
@@ -576,7 +593,7 @@ int SampleDedupWorkerThread::do_chunk_dedup(chunk_t &chunk, snap_t snap)
   return ret;
 }
 
-int make_crawling_daemon(const po::variables_map &opts)
+int run_crawling_daemon(const po::variables_map &opts)
 {
   string base_pool_name = get_opts_pool_name(opts);
   string chunk_pool_name = get_opts_chunk_pool(opts);
@@ -662,16 +679,14 @@ int make_crawling_daemon(const po::variables_map &opts)
     << ")" 
     << dendl;
 
-  std::shared_lock l(glock);
+  SampleDedupWorkerThread::SampleDedupGlobal state(
+    chunk_dedup_threshold, sampling_ratio, report_period, fp_threshold);
+  ret = 0;
 
-  while (!all_stop) {
-    l.unlock();
+  while (!state.is_all_stop()) {
     ObjectCursor begin = io_ctx.object_list_begin();
     ObjectCursor end = io_ctx.object_list_end();
 
-    SampleDedupWorkerThread::SampleDedupGlobal sample_dedup_global(
-      chunk_dedup_threshold, sampling_ratio, report_period, fp_threshold);
-
     std::list<SampleDedupWorkerThread> threads;
     size_t total_size = 0;
     size_t total_duplicate_size = 0;
@@ -695,7 +710,7 @@ int make_crawling_daemon(const po::variables_map &opts)
 	chunk_size,
 	fp_algo,
 	chunk_algo,
-	sample_dedup_global,
+	state,
 	snap);
       threads.back().create("sample_dedup");
     }
@@ -724,31 +739,14 @@ int make_crawling_daemon(const po::variables_map &opts)
       return -EINVAL;
     }
 
-    l.lock();
     if (run_once) {
-      all_stop = true;
+      state.set_all_stop();
       break;
     }
   }
-  l.unlock();
 
   dout(0) << "done" << dendl;
-  return 0;
-}
-
-static void handle_signal(int signum) 
-{
-  std::unique_lock l{glock};
-  switch (signum) {
-    case SIGINT:
-    case SIGTERM:
-      all_stop = true;
-      dout(0) << "got a signal(" << signum << "), daemon wil be terminiated" << dendl;
-      break;
-
-    default:
-      ceph_abort_msgf("unexpected signal %d", signum);
-  }
+  return ret;
 }
 
 int main(int argc, const char **argv)
@@ -805,13 +803,17 @@ int main(int argc, const char **argv)
   }
 
   init_async_signal_handler();
-  register_async_signal_handler_oneshot(SIGINT, handle_signal);
-  register_async_signal_handler_oneshot(SIGTERM, handle_signal);
+  register_async_signal_handler_oneshot(SIGINT,
+    SampleDedupWorkerThread::SampleDedupGlobal::handle_signal);
+  register_async_signal_handler_oneshot(SIGTERM,
+    SampleDedupWorkerThread::SampleDedupGlobal::handle_signal);
 
-  int ret = make_crawling_daemon(opts);
+  int ret = run_crawling_daemon(opts);
 
-  unregister_async_signal_handler(SIGINT, handle_signal);
-  unregister_async_signal_handler(SIGTERM, handle_signal);
+  unregister_async_signal_handler(SIGINT,
+    SampleDedupWorkerThread::SampleDedupGlobal::handle_signal);
+  unregister_async_signal_handler(SIGTERM,
+    SampleDedupWorkerThread::SampleDedupGlobal::handle_signal);
   shutdown_async_signal_handler();
 
   return forker.signal_exit(ret);