#include "squid.h"
#include "mem/AllocatorProxy.h"
+#include "mem/Meter.h"
#include "mem/Pool.h"
void *
getAllocator()->zeroBlocks(doIt);
}
-MemPoolMeter const &
+Mem::PoolMeter const &
Mem::AllocatorProxy::getMeter() const
{
return getAllocator()->getMeter();
class MemAllocator;
class MemPoolStats;
-class MemPoolMeter;
/**
* \hideinitializer
namespace Mem
{
+class PoolMeter;
+
/**
* Support late binding of pool type for allocator agnostic classes
*/
size_t objectSize() const {return size;}
char const * objectType() const {return label;}
- MemPoolMeter const &getMeter() const;
+ PoolMeter const &getMeter() const;
/**
* \param stats Object to be filled with statistical data about pool.
class Meter
{
public:
- Meter() : level(0), hwater_level(0), hwater_stamp(0) {}
-
/// flush the meter level back to 0, but leave peak records
void flush() {level=0;}
}
}
- ssize_t level; ///< current level (count or volume)
- ssize_t hwater_level; ///< high water mark
- time_t hwater_stamp; ///< timestamp of last high water mark change
+ ssize_t level = 0; ///< current level (count or volume)
+ ssize_t hwater_level = 0; ///< high water mark
+ time_t hwater_stamp = 0; ///< timestamp of last high water mark change
+};
+
+/**
+ * Object to track per-pool memory usage (alloc = inuse+idle)
+ */
+class PoolMeter
+{
+public:
+ /// Object to track per-pool cumulative counters
+ struct mgb_t {
+ double count = 0.0;
+ double bytes = 0.0;
+ };
+
+ /// flush counters back to 0, but leave historic peak records
+ void flush() {
+ alloc.flush();
+ inuse.flush();
+ idle.flush();
+ gb_allocated = mgb_t();
+ gb_oallocated = mgb_t();
+ gb_saved = mgb_t();
+ gb_freed = mgb_t();
+ }
+
+ Meter alloc;
+ Meter inuse;
+ Meter idle;
+
+ /** history Allocations */
+ mgb_t gb_allocated;
+ mgb_t gb_oallocated;
+
+ /** account Saved Allocations */
+ mgb_t gb_saved;
+
+ /** account Free calls */
+ mgb_t gb_freed;
};
} // namespace Mem
extern time_t squid_curtime;
-static MemPoolMeter TheMeter;
+static Mem::PoolMeter TheMeter;
static MemPoolIterator Iterator;
static int Pool_id_counter = 0;
getMeter().gb_freed.bytes = getMeter().gb_freed.count * obj_size;
}
-void
-MemPoolMeter::flush()
-{
- alloc.flush();
- inuse.flush();
- idle.flush();
- 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
*/
--MemPools::GetInstance().poolCount;
}
-MemPoolMeter const &
+Mem::PoolMeter const &
MemImplementingAllocator::getMeter() const
{
return meter;
}
-MemPoolMeter &
+Mem::PoolMeter &
MemImplementingAllocator::getMeter()
{
return meter;
MemPoolIterator * next;
};
-/**
- \ingroup MemPoolsAPI
- * Object to track per-pool cumulative counters
- */
-class mgb_t
-{
-public:
- mgb_t() : count(0), bytes(0) {}
- double count;
- double bytes;
-};
-
-/**
- \ingroup MemPoolsAPI
- * Object to track per-pool memory usage (alloc = inuse+idle)
- */
-class MemPoolMeter
-{
-public:
- MemPoolMeter();
- void flush();
-
- Mem::Meter alloc;
- Mem::Meter inuse;
- Mem::Meter idle;
-
- /** history Allocations */
- mgb_t gb_allocated;
- mgb_t gb_oallocated;
-
- /** account Saved Allocations */
- mgb_t gb_saved;
-
- /** account Free calls */
- mgb_t gb_freed;
-};
-
class MemImplementingAllocator;
/// \ingroup MemPoolsAPI
class MemAllocator
{
public:
+ typedef Mem::PoolMeter PoolMeter; // TODO remove
+
MemAllocator (char const *aLabel);
virtual ~MemAllocator() {}
*/
virtual int getStats(MemPoolStats * stats, int accumulate = 0) = 0;
- virtual MemPoolMeter const &getMeter() const = 0;
+ virtual PoolMeter const &getMeter() const = 0;
/**
* Allocate one element from the pool
class MemImplementingAllocator : public MemAllocator
{
public:
+ typedef Mem::PoolMeter PoolMeter; // TODO remove
+
MemImplementingAllocator(char const *aLabel, size_t aSize);
virtual ~MemImplementingAllocator();
- virtual MemPoolMeter const &getMeter() const;
- virtual MemPoolMeter &getMeter();
+ virtual PoolMeter const &getMeter() const;
+ virtual PoolMeter &getMeter();
virtual void flushMetersFull();
virtual void flushMeters();
protected:
virtual void *allocate() = 0;
virtual void deallocate(void *, bool aggressive) = 0;
- MemPoolMeter meter;
+ PoolMeter meter;
int memPID;
public:
MemImplementingAllocator *next;
class MemPoolStats
{
public:
+ typedef Mem::PoolMeter PoolMeter; // TODO remove
+
MemAllocator *pool;
const char *label;
- MemPoolMeter *meter;
+ PoolMeter *meter;
int obj_size;
int chunk_capacity;
int chunk_size;
/// \ingroup MemPoolsAPI
/// TODO: Classify and add constructor/destructor to initialize properly.
struct _MemPoolGlobalStats {
- MemPoolMeter *TheMeter;
+ typedef Mem::PoolMeter PoolMeter; // TODO remove
+
+ PoolMeter *TheMeter;
int tot_pools_alloc;
int tot_pools_inuse;
class StoreEntry;
class MemPoolStats;
-class MemPoolMeter;
/// Memory Management
namespace Mem
{
+class Meter;
+class PoolMeter;
+
void Init();
void Stats(StoreEntry *);
void CleanIdlePools(void *unused);
void Report(std::ostream &);
-void PoolReport(const MemPoolStats * mp_st, const MemPoolMeter * AllMeter, std::ostream &);
+void PoolReport(const MemPoolStats *, const PoolMeter *, std::ostream &);
};
extern const size_t squidSystemPageSize;
}
}
-/* MemPoolMeter */
-
void
-Mem::PoolReport(const MemPoolStats * mp_st, const MemPoolMeter * AllMeter, std::ostream &stream)
+Mem::PoolReport(const MemPoolStats * mp_st, const PoolMeter * AllMeter, std::ostream &stream)
{
int excess = 0;
int needed = 0;
- MemPoolMeter *pm = mp_st->meter;
+ PoolMeter *pm = mp_st->meter;
const char *delim = "\t ";
stream.setf(std::ios_base::fixed);
void *Mem::AllocatorProxy::alloc() {return xmalloc(64*1024);}
void Mem::AllocatorProxy::freeOne(void *address) {xfree(address);}
int Mem::AllocatorProxy::inUseCount() const {return 0;}
-//static MemPoolMeter tmpMemPoolMeter;
-//MemPoolMeter const &Mem::AllocatorProxy::getMeter() const STUB_RETVAL(tmpMemPoolMeter)
+//Mem::PoolMeter const &Mem::AllocatorProxy::getMeter() const STUB_RETSTATREF(PoolMeter)
int Mem::AllocatorProxy::getStats(MemPoolStats *) STUB_RETVAL(0)
#include "mem/forward.h"
void Mem::Stats(StoreEntry *) STUB_NOP
void Mem::CleanIdlePools(void *) STUB_NOP
void Mem::Report(std::ostream &) STUB_NOP
-void Mem::PoolReport(const MemPoolStats *, const MemPoolMeter *, std::ostream &) STUB_NOP
+void Mem::PoolReport(const MemPoolStats *, const PoolMeter *, std::ostream &) STUB_NOP
//const size_t squidSystemPageSize = 4096;
void memClean(void) STUB
void memInitModule(void) STUB
void memCheckInit(void) STUB_NOP
#include "mem/Pool.h"
-MemPoolMeter::MemPoolMeter() STUB_NOP
-void MemPoolMeter::flush() STUB
static MemPools tmpMemPools;
MemPools &MemPools::GetInstance() {return tmpMemPools;}
MemPools::MemPools() STUB_NOP
//MemImplementingAllocator::MemImplementingAllocator(char const *, size_t) STUB_NOP
//MemImplementingAllocator::~MemImplementingAllocator();
-MemPoolMeter const &MemImplementingAllocator::getMeter() const STUB_RETSTATREF(MemPoolMeter)
-MemPoolMeter &MemImplementingAllocator::getMeter() STUB_RETSTATREF(MemPoolMeter)
+Mem::PoolMeter const &MemImplementingAllocator::getMeter() const STUB_RETSTATREF(PoolMeter)
+Mem::PoolMeter &MemImplementingAllocator::getMeter() STUB_RETSTATREF(PoolMeter)
void MemImplementingAllocator::flushMetersFull() STUB
void MemImplementingAllocator::flushMeters() STUB
void *MemImplementingAllocator::alloc() STUB_RETVAL(nullptr)