Return a reference from GetStrPool()

diff --git a/src/mem/old_api.cc b/src/mem/old_api.cc
index 9ccf60220c69c9fba0b2b47b969dabc9dd569344..638ee5b5d148e0e4404dea82607d5cb0a000daf7 100644 (file)
--- a/src/mem/old_api.cc
+++ b/src/mem/old_api.cc
@@ -78,7 +78,7 @@ GetPool(size_t type)
     return pools[type];
 }
 
-static MemAllocator *&
+static MemAllocator &
 GetStrPool(size_t type)
 {
     static MemAllocator *strPools[mem_str_pool_count];
@@ -111,7 +111,7 @@ GetStrPool(size_t type)
         initialized = true;
     }
 
-    return strPools[type];
+    return *strPools[type];
 }
 
 /* Find the best fit string pool type */
@@ -120,13 +120,11 @@ memFindStringSizeType(size_t net_size, bool fuzzy)
 {
     mem_type type = MEM_NONE;
     for (unsigned int i = 0; i < mem_str_pool_count; ++i) {
-        auto pool = GetStrPool(i);
-        if (!pool)
-            continue;
-        if (fuzzy && net_size < pool->objectSize()) {
+        auto &pool = GetStrPool(i);
+        if (fuzzy && net_size < pool.objectSize()) {
             type = static_cast<mem_type>(i);
             break;
-        } else if (net_size == pool->objectSize()) {
+        } else if (net_size == pool.objectSize()) {
             type = static_cast<mem_type>(i);
             break;
         }
@@ -146,13 +144,13 @@ memStringStats(std::ostream &stream)
     /* table body */
 
     for (i = 0; i < mem_str_pool_count; ++i) {
-        const MemAllocator *pool = GetStrPool(i);
-        const auto plevel = pool->getMeter().inuse.currentLevel();
-        stream << std::setw(20) << std::left << pool->objectType();
+        const auto &pool = GetStrPool(i);
+        const auto plevel = pool.getMeter().inuse.currentLevel();
+        stream << std::setw(20) << std::left << pool.objectType();
         stream << std::right << "\t " << xpercentInt(plevel, StrCountMeter.currentLevel());
-        stream << "\t " << xpercentInt(plevel * pool->objectSize(), StrVolumeMeter.currentLevel()) << "\n";
+        stream << "\t " << xpercentInt(plevel * pool.objectSize(), StrVolumeMeter.currentLevel()) << "\n";
         pooled_count += plevel;
-        pooled_volume += plevel * pool->objectSize();
+        pooled_volume += plevel * pool.objectSize();
     }
 
     /* malloc strings */
@@ -237,18 +235,22 @@ memFree(void *p, int type)
 void *
 memAllocString(size_t net_size, size_t * gross_size)
 {
-    MemAllocator *pool = NULL;
     assert(gross_size);
 
     auto type = memFindStringSizeType(net_size, true);
-    if (type != MEM_NONE)
-        pool = GetStrPool(type);
+    if (type != MEM_NONE) {
+        auto &pool = GetStrPool(type);
+        *gross_size = pool.objectSize();
+        assert(*gross_size >= net_size);
+        ++StrCountMeter;
+        StrVolumeMeter += *gross_size;
+        return pool.alloc();
+    }
 
-    *gross_size = pool ? pool->objectSize() : net_size;
-    assert(*gross_size >= net_size);
+    *gross_size = net_size;
     ++StrCountMeter;
     StrVolumeMeter += *gross_size;
-    return pool ? pool->alloc() : xcalloc(1, net_size);
+    return xcalloc(1, net_size);
 }
 
 size_t
@@ -257,7 +259,7 @@ memStringCount()
     size_t result = 0;
 
     for (int counter = 0; counter < mem_str_pool_count; ++counter)
-        result += GetStrPool(counter)->inUseCount();
+        result += GetStrPool(counter).inUseCount();
 
     return result;
 }
@@ -266,16 +268,16 @@ memStringCount()
 void
 memFreeString(size_t size, void *buf)
 {
-    MemAllocator *pool = NULL;
     assert(buf);
 
     auto type = memFindStringSizeType(size, false);
     if (type != MEM_NONE)
-        pool = GetStrPool(type);
+        GetStrPool(type).freeOne(buf);
+    else
+        xfree(buf);
 
     --StrCountMeter;
     StrVolumeMeter -= size;
-    pool ? pool->freeOne(buf) : xfree(buf);
 }
 
 /* Find the best fit MEM_X_BUF type */