From dfdae5ffa96c99b896a821256937faae1b93443a Mon Sep 17 00:00:00 2001
From: Avi Kivity <avi@scylladb.com>
Date: Tue, 6 Dec 2022 21:37:38 +0200
Subject: [PATCH] dirty_memory_manager: stop using using namespace

`using namespace` is pretty bad, especially in a header, as it
pollutes the namespace for everyone. Stop using it and qualify
names instead.
---
 dirty_memory_manager.cc | 10 ++++------
 dirty_memory_manager.hh | 16 +++++++---------
 2 files changed, 11 insertions(+), 15 deletions(-)

diff --git a/dirty_memory_manager.cc b/dirty_memory_manager.cc
index 996e21a0b2..9b411a65b0 100644
--- a/dirty_memory_manager.cc
+++ b/dirty_memory_manager.cc
@@ -11,8 +11,6 @@
 // Code previously under logalloc namespace
 namespace dirty_memory_manager_logalloc {
 
-using namespace logalloc;
-
 inline void
 region_group_binomial_group_sanity_check(const region_group::region_heap& bh) {
 #ifdef SEASTAR_DEBUG
@@ -54,7 +52,7 @@ dirty_memory_manager_logalloc::size_tracked_region* region_group::get_largest_re
 }
 
 void
-region_group::add(region* child_r) {
+region_group::add(logalloc::region* child_r) {
     auto child = static_cast<size_tracked_region*>(child_r);
     assert(!child->_heap_handle);
     child->_heap_handle = std::make_optional(_regions.push(child));
@@ -63,7 +61,7 @@ region_group::add(region* child_r) {
 }
 
 void
-region_group::del(region* child_r) {
+region_group::del(logalloc::region* child_r) {
     auto child = static_cast<size_tracked_region*>(child_r);
     if (child->_heap_handle) {
         _regions.erase(*std::exchange(child->_heap_handle, std::nullopt));
@@ -73,7 +71,7 @@ region_group::del(region* child_r) {
 }
 
 void
-region_group::moved(region* old_address, region* new_address) {
+region_group::moved(logalloc::region* old_address, logalloc::region* new_address) {
     auto old_child = static_cast<size_tracked_region*>(old_address);
     if (old_child->_heap_handle) {
         _regions.erase(*std::exchange(old_child->_heap_handle, std::nullopt));
@@ -116,7 +114,7 @@ future<> region_group::release_queued_allocations() {
             co_await std::invoke([&] {
                 // Block reclaiming to prevent signal() from being called by reclaimer inside wait()
                 // FIXME: handle allocation failures (not very likely) like allocating_section does
-                tracker_reclaimer_lock rl(logalloc::shard_tracker());
+                logalloc::tracker_reclaimer_lock rl(logalloc::shard_tracker());
                 return _relief.wait();
             });
         }
diff --git a/dirty_memory_manager.hh b/dirty_memory_manager.hh
index ee4819dcce..c433ccc2cc 100644
--- a/dirty_memory_manager.hh
+++ b/dirty_memory_manager.hh
@@ -20,8 +20,6 @@
 // Code previously under logalloc namespace
 namespace dirty_memory_manager_logalloc {
 
-using namespace logalloc;
-
 class size_tracked_region;
 
 struct region_evictable_occupancy_ascending_less_comparator {
@@ -97,7 +95,7 @@ struct reclaim_config {
 // A container for memtables. Called "region_group" for historical
 // reasons. Receives updates about memtable size change via the
 // LSA region_listener interface.
-class region_group : public region_listener {
+class region_group : public logalloc::region_listener {
     using region_heap = dirty_memory_manager_logalloc::region_heap;
 public:
     struct allocating_function {
@@ -236,7 +234,7 @@ private:
     void notify_unspooled_pressure_relieved();
     friend void region_group_binomial_group_sanity_check(const region_group::region_heap& bh);
 private: // from region_listener
-    virtual void moved(region* old_address, region* new_address) override;
+    virtual void moved(logalloc::region* old_address, logalloc::region* new_address) override;
 public:
     // When creating a region_group, one can specify an optional throttle_threshold parameter. This
     // parameter won't affect normal allocations, but an API is provided, through the region_group's
@@ -275,16 +273,16 @@ public:
     // 2) some callers would like to pass delta = 0. For instance, when we are making a region
     //    evictable / non-evictable. Because the evictable occupancy changes, we would like to call
     //    the full update cycle even then.
-    virtual void increase_usage(region* r, ssize_t delta) override { // From region_listener
+    virtual void increase_usage(logalloc::region* r, ssize_t delta) override { // From region_listener
         _regions.increase(*static_cast<size_tracked_region*>(r)->_heap_handle);
         update_unspooled(delta);
     }
 
-    virtual void decrease_evictable_usage(region* r) override { // From region_listener
+    virtual void decrease_evictable_usage(logalloc::region* r) override { // From region_listener
         _regions.decrease(*static_cast<size_tracked_region*>(r)->_heap_handle);
     }
 
-    virtual void decrease_usage(region* r, ssize_t delta) override { // From region_listener
+    virtual void decrease_usage(logalloc::region* r, ssize_t delta) override { // From region_listener
         decrease_evictable_usage(r);
         update_unspooled(delta);
     }
@@ -330,8 +328,8 @@ private:
 
     uint64_t top_region_evictable_space() const noexcept;
 
-    virtual void add(region* child) override; // from region_listener
-    virtual void del(region* child) override; // from region_listener
+    virtual void add(logalloc::region* child) override; // from region_listener
+    virtual void del(logalloc::region* child) override; // from region_listener
 
     friend class test_region_group;
 };