Fix statistics

diff --git a/include/MemPool.h b/include/MemPool.h
index 6a43ca600a4f3faafdcd58e231713ecb73cb46c5..f18b6207b125cd21d199d625d7f2293183563580 100644 (file)
--- a/include/MemPool.h
+++ b/include/MemPool.h
@@ -96,16 +96,19 @@ public:
 class MemPoolMeter
 {
 public:
+    MemPoolMeter();
     void flush();
     MemMeter alloc;
     MemMeter inuse;
     MemMeter idle;
 
-    /** account Allocations */
-    mgb_t gb_saved;
 
     /** history Allocations */
-    mgb_t gb_osaved;
+    mgb_t gb_allocated;
+    mgb_t gb_oallocated;
+
+    /** account Saved Allocations */
+    mgb_t gb_saved;
 
     /** account Free calls */
     mgb_t gb_freed;
@@ -317,6 +320,7 @@ class MemImplementingAllocator : public MemAllocator
 {
 public:
     MemImplementingAllocator(char const *aLabel, size_t aSize);
+    ~MemImplementingAllocator();
     virtual MemPoolMeter const &getMeter() const;
     virtual MemPoolMeter &getMeter();
     virtual void flushMetersFull();
@@ -346,6 +350,7 @@ public:
 public:
     size_t alloc_calls;
     size_t free_calls;
+    size_t saved_calls;
     size_t obj_size;
 };
 

diff --git a/lib/MemPool.cc b/lib/MemPool.cc
index 183869527751a2417d96426f4a600ad9277a5e3f..07c2ac236283f07b8fd946190aa3ff102ab23e3b 100644 (file)
--- a/lib/MemPool.cc
+++ b/lib/MemPool.cc
@@ -218,15 +218,21 @@ MemImplementingAllocator::flushMeters()
     }
     calls = alloc_calls;
     if (calls) {
-        meter.gb_saved.count += calls;
+        meter.gb_allocated.count += calls;
         alloc_calls = 0;
     }
+    calls = saved_calls;
+    if (calls) {
+        meter.gb_saved.count += calls;
+        saved_calls = 0;
+    }
 }
 
 void
 MemImplementingAllocator::flushMetersFull()
 {
     flushMeters();
+    getMeter().gb_allocated.bytes = getMeter().gb_allocated.count * obj_size;
     getMeter().gb_saved.bytes = getMeter().gb_saved.count * obj_size;
     getMeter().gb_freed.bytes = getMeter().gb_freed.count * obj_size;
 }
@@ -237,11 +243,21 @@ MemPoolMeter::flush()
     alloc.level = 0;
     inuse.level = 0;
     idle.level = 0;
+    gb_allocated.count = 0;
+    gb_allocated.bytes = 0;
+    gb_oallocated.count = 0;
+    gb_oallocated.bytes = 0;
     gb_saved.count = 0;
     gb_saved.bytes = 0;
     gb_freed.count = 0;
     gb_freed.bytes = 0;
 }
+
+MemPoolMeter::MemPoolMeter()
+{
+    flush();
+}
+
 /*
  * Updates all pool counters, and recreates TheMeter totals from all pools
  */
@@ -259,8 +275,10 @@ MemPools::flushMeters()
         memMeterAdd(TheMeter.alloc, pool->getMeter().alloc.level * pool->obj_size);
         memMeterAdd(TheMeter.inuse, pool->getMeter().inuse.level * pool->obj_size);
         memMeterAdd(TheMeter.idle, pool->getMeter().idle.level * pool->obj_size);
+        TheMeter.gb_allocated.count += pool->getMeter().gb_allocated.count;
         TheMeter.gb_saved.count += pool->getMeter().gb_saved.count;
         TheMeter.gb_freed.count += pool->getMeter().gb_freed.count;
+        TheMeter.gb_allocated.bytes += pool->getMeter().gb_allocated.bytes;
         TheMeter.gb_saved.bytes += pool->getMeter().gb_saved.bytes;
         TheMeter.gb_freed.bytes += pool->getMeter().gb_freed.bytes;
     }
@@ -441,9 +459,39 @@ MemImplementingAllocator::MemImplementingAllocator(char const *aLabel, size_t aS
         next(NULL),
         alloc_calls(0),
         free_calls(0),
+        saved_calls(0),
         obj_size(RoundedSize(aSize))
 {
-       memPID = ++Pool_id_counter;
+    memPID = ++Pool_id_counter;
+
+    MemImplementingAllocator *last_pool;
+
+    assert(aLabel != NULL && aSize);
+    /* Append as Last */
+    for (last_pool = MemPools::GetInstance().pools; last_pool && last_pool->next;)
+        last_pool = last_pool->next;
+    if (last_pool)
+        last_pool->next = this;
+    else
+        MemPools::GetInstance().pools = this;
+}
+
+MemImplementingAllocator::~MemImplementingAllocator()
+{
+    MemImplementingAllocator *find_pool, *prev_pool;
+
+    assert(MemPools::GetInstance().pools != NULL && "Called MemImplementingAllocator::~MemImplementingAllocator, but no pool exists!");
+
+    /* Pool clean, remove it from List and free */
+    for (find_pool = MemPools::GetInstance().pools, prev_pool = NULL; (find_pool && this != find_pool); find_pool = find_pool->next)
+        prev_pool = find_pool;
+    assert(find_pool != NULL && "pool to destroy not found");
+
+    if (prev_pool)
+        prev_pool->next = next;
+    else
+        MemPools::GetInstance().pools = next;
+    --MemPools::GetInstance().poolCount;
 }
 
 void

diff --git a/lib/MemPoolChunked.cc b/lib/MemPoolChunked.cc
index 5768f0be68f454602bfad7837ca71607f7706ba0..7492b17adeb26e0d99fd45c7910281f16d3695d9 100644 (file)
--- a/lib/MemPoolChunked.cc
+++ b/lib/MemPoolChunked.cc
@@ -173,19 +173,8 @@ MemPoolChunked::MemPoolChunked(const char *aLabel, size_t aSize) : MemImplementi
     nextFreeChunk = 0;
     Chunks = 0;
     next = 0;
-    MemImplementingAllocator *last_pool;
-
-    assert(aLabel != NULL && aSize);
 
     setChunkSize(MEM_CHUNK_SIZE);
-
-    /* Append as Last */
-    for (last_pool = MemPools::GetInstance().pools; last_pool && last_pool->next;)
-        last_pool = last_pool->next;
-    if (last_pool)
-        last_pool->next = this;
-    else
-        MemPools::GetInstance().pools = this;
 }
 
 MemChunk::~MemChunk()
@@ -225,6 +214,8 @@ MemPoolChunked::get()
 {
     void **Free;
 
+    saved_calls++;
+
     /* first, try cache */
     if (freeCache) {
         Free = (void **)freeCache;
@@ -236,6 +227,7 @@ MemPoolChunked::get()
     /* then try perchunk freelist chain */
     if (nextFreeChunk == NULL) {
         /* no chunk with frees, so create new one */
+       saved_calls--; // compensate for the ++ above
         createChunk();
     }
     /* now we have some in perchunk freelist chain */
@@ -323,7 +315,6 @@ MemPoolChunked::setChunkSize(size_t chunksize)
 MemPoolChunked::~MemPoolChunked()
 {
     MemChunk *chunk, *fchunk;
-    MemImplementingAllocator *find_pool, *prev_pool;
 
     flushMetersFull();
     clean(0);
@@ -336,18 +327,6 @@ MemPoolChunked::~MemPoolChunked()
     }
     /* TODO we should be doing something about the original Chunks pointer here. */
 
-    assert(MemPools::GetInstance().pools != NULL && "Called MemPoolChunked::~MemPoolChunked, but no pool exists!");
-
-    /* Pool clean, remove it from List and free */
-    for (find_pool = MemPools::GetInstance().pools, prev_pool = NULL; (find_pool && this != find_pool); find_pool = find_pool->next)
-        prev_pool = find_pool;
-    assert(find_pool != NULL && "pool to destroy not found");
-
-    if (prev_pool)
-        prev_pool->next = next;
-    else
-        MemPools::GetInstance().pools = next;
-    --MemPools::GetInstance().poolCount;
 }
 
 int

diff --git a/src/mem.cc b/src/mem.cc
index 5e197e94f7c1188879ede73f411f431092d60023..43b3290a272329d63db5b516229bc14edcdc00c9 100644 (file)
--- a/src/mem.cc
+++ b/src/mem.cc
@@ -580,6 +580,9 @@ Mem::PoolReport(const MemPoolStats * mp_st, const MemPoolMeter * AllMeter, std::
     MemPoolMeter *pm = mp_st->meter;
     const char *delim = "\t ";
 
+#if HAVE_IOMANIP
+    stream.setf(std::ios_base::fixed);
+#endif
     stream << std::setw(20) << std::left << mp_st->label << delim;
     stream << std::setw(4) << std::right << mp_st->obj_size << delim;
 
@@ -627,10 +630,10 @@ Mem::PoolReport(const MemPoolStats * mp_st, const MemPoolMeter * AllMeter, std::
     stream << toKB(mp_st->obj_size * pm->idle.hwater_level) << delim;
     /* saved */
     stream << (int)pm->gb_saved.count << delim;
-    stream << std::setprecision(3) << xpercent(pm->gb_saved.count, AllMeter->gb_saved.count) << delim;
-    stream << std::setprecision(3) << xpercent(pm->gb_saved.bytes, AllMeter->gb_saved.bytes) << delim;
-    stream << std::setprecision(3) << xdiv(pm->gb_saved.count - pm->gb_osaved.count, xm_deltat) << "\n";
-    pm->gb_osaved.count = pm->gb_saved.count;
+    stream << std::setprecision(3) << xpercent(pm->gb_saved.count, AllMeter->gb_allocated.count) << delim;
+    stream << std::setprecision(3) << xpercent(pm->gb_saved.bytes, AllMeter->gb_allocated.bytes) << delim;
+    stream << std::setprecision(3) << xdiv(pm->gb_allocated.count - pm->gb_oallocated.count, xm_deltat) << "\n";
+    pm->gb_oallocated.count = pm->gb_allocated.count;
 }
 
 static int
@@ -683,7 +686,7 @@ Mem::Report(std::ostream &stream)
     "In Use\t\t\t\t\t"
     "Idle\t\t\t"
     "Allocations Saved\t\t\t"
-    "Hit Rate\t"
+    "Rate\t"
     "\n"
     " \t (bytes)\t"
     "KB/ch\t obj/ch\t"
@@ -692,7 +695,7 @@ Mem::Report(std::ostream &stream)
     "(#)\t (KB)\t high (KB)\t high (hrs)\t %alloc\t"
     "(#)\t (KB)\t high (KB)\t"
     "(#)\t %cnt\t %vol\t"
-    "(#) / sec\t"
+    "(#)/sec\t"
     "\n";
     xm_deltat = current_dtime - xm_time;
     xm_time = current_dtime;
@@ -712,7 +715,7 @@ Mem::Report(std::ostream &stream)
         if (!mp_stats.pool)    /* pool destroyed */
             continue;
 
-        if (mp_stats.pool->getMeter().gb_saved.count > 0)      /* this pool has been used */
+        if (mp_stats.pool->getMeter().gb_allocated.count > 0)  /* this pool has been used */
             sortme[npools++] = mp_stats;
         else
             not_used++;
@@ -746,7 +749,7 @@ Mem::Report(std::ostream &stream)
     PoolReport(&mp_stats, mp_total.TheMeter, stream);
 
     /* Cumulative */
-    stream << "Cumulative allocated volume: "<< double_to_str(buf, 64, mp_total.TheMeter->gb_saved.bytes) << "\n";
+    stream << "Cumulative allocated volume: "<< double_to_str(buf, 64, mp_total.TheMeter->gb_allocated.bytes) << "\n";
     /* overhead */
     stream << "Current overhead: " << mp_total.tot_overhead << " bytes (" <<
     std::setprecision(3) << xpercent(mp_total.tot_overhead, mp_total.TheMeter->inuse.level) << "%)\n";