os/bluestore/ZonedAllocator: be consistent with hex debug output

Signed-off-by: Sage Weil <sage@newdream.net>

diff --git a/src/os/bluestore/ZonedAllocator.cc b/src/os/bluestore/ZonedAllocator.cc
index ed74ff9b5b0e0268272044c6efc992a820bbc7df..6809f8023ee4f038eb382c95302936172c803a11 100644 (file)
--- a/src/os/bluestore/ZonedAllocator.cc
+++ b/src/os/bluestore/ZonedAllocator.cc
@@ -39,6 +39,7 @@ ZonedAllocator::ZonedAllocator(CephContext* cct,
                 << " zone size 0x" << zone_size << std::dec
                 << " number of zones " << num_zones
                 << " first sequential zone " << starting_zone_num
+                << std::dec
                 << dendl;
   ceph_assert(size % zone_size == 0);
 }
@@ -58,25 +59,26 @@ int64_t ZonedAllocator::allocate(
 
   ceph_assert(want_size % 4096 == 0);
 
-  ldout(cct, 10) << __func__ << " trying to allocate "
-                << std::hex << want_size << dendl;
+  ldout(cct, 10) << __func__ << " trying to allocate 0x"
+                << std::hex << want_size << std::dec << dendl;
 
   uint64_t zone_num = starting_zone_num;
   auto p = zones_to_clean.lower_bound(zone_num);
   for ( ; zone_num < num_zones; ++zone_num) {
     if (p != zones_to_clean.cend() && *p == zone_num) {
-      ldout(cct, 10) << __func__ << " skipping zone " << zone_num
-                    << " because it is being cleaned" << dendl;
+      ldout(cct, 10) << __func__ << " skipping zone 0x" << std::hex << zone_num
+                    << " because it is being cleaned" << std::dec << dendl;
       ++p;
       continue;
     }
     if (fits(want_size, zone_num)) {
       break;
     }
-    ldout(cct, 10) << __func__ << " skipping zone " << zone_num
+    ldout(cct, 10) << __func__ << " skipping zone 0x" << std::hex << zone_num
                   << " because there is not enough space: "
-                  << " want_size = " << want_size
-                  << " available = " << get_remaining_space(zone_num)
+                  << " want_size = 0x" << want_size
+                  << " available = 0x" << get_remaining_space(zone_num)
+                  << std::dec
                   << dendl;
   }
 
@@ -87,9 +89,10 @@ int64_t ZonedAllocator::allocate(
 
   uint64_t offset = get_offset(zone_num);
 
-  ldout(cct, 10) << __func__ << " incrementing zone " << std::hex
-                << zone_num << " write pointer from " << offset
-                << " to " << offset + want_size << dendl;
+  ldout(cct, 10) << __func__ << " incrementing zone 0x" << std::hex
+                << zone_num << " write pointer from 0x" << offset
+                << " to 0x" << offset + want_size
+                << std::dec << dendl;
 
   increment_write_pointer(zone_num, want_size);
   num_free -= want_size;
@@ -97,13 +100,10 @@ int64_t ZonedAllocator::allocate(
     starting_zone_num = zone_num + 1;
   }
 
-  ldout(cct, 10) << __func__ << std::hex << " zone " << zone_num
-                << " offset is now " << get_write_pointer(zone_num) << dendl;
-
-  ldout(cct, 10) << __func__ << " allocated " << std::hex << want_size
-                << " bytes at offset " << offset
-                << " located at zone " << zone_num
-                << " and zone offset " << offset % zone_size << dendl;
+  ldout(cct, 10) << " allocated 0x" << std::hex << offset << "~" << want_size
+                << " from zone 0x" << zone_num
+                << " and zone offset 0x" << (offset % zone_size)
+                << std::dec << dendl;
 
   find_zones_to_clean();
 
@@ -117,7 +117,8 @@ void ZonedAllocator::release(const interval_set<uint64_t>& release_set)
   for (auto p = cbegin(release_set); p != cend(release_set); ++p) {
     auto offset = p.get_start();
     auto length = p.get_len();
-    ldout(cct, 10) << __func__ << " 0x" << std::hex << offset << "~" << length << dendl;
+    ldout(cct, 10) << __func__ << " 0x" << std::hex << offset << "~" << length
+                  << std::dec << dendl;
     uint64_t zone_num = offset / zone_size;
     uint64_t num_dead = std::min(zone_size - offset % zone_size, length);
     for ( ; length; ++zone_num) {
@@ -149,7 +150,7 @@ void ZonedAllocator::dump(std::function<void(uint64_t offset,
 void ZonedAllocator::init_add_free(uint64_t offset, uint64_t length)
 {
   ldout(cct, 40) << __func__ << " " << std::hex
-                << offset << "~" << length << dendl;
+                << offset << "~" << length << std::dec << dendl;
 
   num_free += length;
 }
@@ -158,7 +159,7 @@ void ZonedAllocator::init_rm_free(uint64_t offset, uint64_t length)
 {
   std::lock_guard l(lock);
   ldout(cct, 40) << __func__ << " 0x" << std::hex
-                << offset << "~" << length << dendl;
+                << offset << "~" << length << std::dec << dendl;
 
   num_free -= length;
   ceph_assert(num_free >= 0);
@@ -172,7 +173,7 @@ void ZonedAllocator::init_rm_free(uint64_t offset, uint64_t length)
   increment_write_pointer(zone_num, remaining_space);
 
   ldout(cct, 40) << __func__ << " set zone 0x" << std::hex
-                << zone_num << " write pointer to 0x" << zone_size << dendl;
+                << zone_num << " write pointer to 0x" << zone_size << std::dec << dendl;
 
   length -= remaining_space;
   ceph_assert(length % zone_size == 0);
@@ -180,7 +181,7 @@ void ZonedAllocator::init_rm_free(uint64_t offset, uint64_t length)
   for ( ; length; length -= zone_size) {
     increment_write_pointer(++zone_num, zone_size);
     ldout(cct, 40) << __func__ << " set zone 0x" << std::hex
-                  << zone_num << " write pointer to 0x" << zone_size << dendl;
+                  << zone_num << " write pointer to 0x" << zone_size << std::dec << dendl;
   }
 }
 
@@ -199,9 +200,9 @@ bool ZonedAllocator::low_on_space(void)
   uint64_t sequential_num_free = num_free - conventional_size;
   double free_ratio = static_cast<double>(sequential_num_free) / sequential_size;
 
-  ldout(cct, 10) << __func__ << " free size " << sequential_num_free
-                << " total size " << sequential_size
-                << " free ratio is " << free_ratio << dendl;
+  ldout(cct, 10) << __func__ << " free size 0x" << std::hex << sequential_num_free
+                << " total size 0x" << sequential_size << std::dec
+                << ", free ratio is " << free_ratio << dendl;
 
    // TODO: make 0.25 tunable
   return free_ratio <= 0.25;
@@ -225,7 +226,8 @@ void ZonedAllocator::find_zones_to_clean(void)
   
   if (cct->_conf->subsys.should_gather<ceph_subsys_bluestore, 40>()) {
     for (size_t i = 0; i < zone_states.size(); ++i) {
-      dout(40) << __func__ << " zone " << i << zone_states[i] << dendl;
+      dout(40) << __func__ << " zone 0x" << std::hex << i << std::dec << " "
+              << zone_states[i] << dendl;
     }
   }
 
@@ -234,8 +236,10 @@ void ZonedAllocator::find_zones_to_clean(void)
                      return zone_states[i1].num_dead_bytes > zone_states[i2].num_dead_bytes;
                    });
 
-  ldout(cct, 10) << __func__ << " the zone that needs cleaning is "
-                << *idx.begin() << " num_dead_bytes = " << zone_states[*idx.begin()].num_dead_bytes
+  ldout(cct, 10) << __func__ << " the zone that needs cleaning is 0x"
+                << std::hex << *idx.begin() << " num_dead_bytes = 0x"
+                << zone_states[*idx.begin()].num_dead_bytes
+                << std::dec
                 << dendl;
 
   zones_to_clean = {idx.begin(), idx.begin() + num_zones_to_clean_at_once};
@@ -266,7 +270,8 @@ void ZonedAllocator::mark_zones_to_clean_free(void)
   std::lock_guard l(lock);
   ldout(cct, 10) << __func__ << dendl;
   for (auto zone_num : zones_to_clean) {
-    ldout(cct, 10) << __func__ << " zone " << zone_num << " is now clean" << dendl;
+    ldout(cct, 10) << __func__ << " zone 0x" << std::hex << zone_num
+                  << " is now clean" << std::dec << dendl;
     num_free += zone_states[zone_num].write_pointer;
     zone_states[zone_num].num_dead_bytes = 0;
     zone_states[zone_num].write_pointer = 0;