Pool.h

Go to the documentation of this file.

/*
 * Copyright (C) 1996-2021 The Squid Software Foundation and contributors
 *
 * Squid software is distributed under GPLv2+ license and includes
 * contributions from numerous individuals and organizations.
 * Please see the COPYING and CONTRIBUTORS files for details.
 */
 
#ifndef _MEM_POOL_H_
#define _MEM_POOL_H_
 
#include "mem/Meter.h"
#include "util.h"
 
#if HAVE_GNUMALLOC_H
#include <gnumalloc.h>
#elif HAVE_MALLOC_H
#include <malloc.h>
#endif
#if HAVE_MEMORY_H
#include <memory.h>
#endif
 
#if !M_MMAP_MAX
#if USE_DLMALLOC
#define M_MMAP_MAX -4
#endif
#endif
 
#define toMB(size) ( ((double) size) / ((double)(1024*1024)) )
#define toKB(size) ( (size + 1024 - 1) / 1024 )
 
#define MEM_PAGE_SIZE 4096
#define MEM_MIN_FREE  32
#define MEM_MAX_FREE  65535 /* unsigned short is max number of items per chunk */
 
class MemImplementingAllocator;
class MemPoolStats;
 
typedef struct _MemPoolGlobalStats MemPoolGlobalStats;
 
class MemPoolIterator
{
public:
    MemImplementingAllocator *pool;
    MemPoolIterator * next;
};
 
class mgb_t
{
public:
    mgb_t() : count(0), bytes(0) {}
    double count;
    double bytes;
};
 
class MemPoolMeter
{
public:
    MemPoolMeter();
    void flush();
 
    Mem::Meter alloc;
    Mem::Meter inuse;
    Mem::Meter idle;
 
    mgb_t gb_allocated;
    mgb_t gb_oallocated;
 
    mgb_t gb_saved;
 
    mgb_t gb_freed;
};
 
class MemImplementingAllocator;
 
class MemPools
{
public:
    static MemPools &GetInstance();
    MemPools();
    void flushMeters();
 
    MemImplementingAllocator * create(const char *label, size_t obj_size);
 
    void setIdleLimit(ssize_t new_idle_limit);
    ssize_t idleLimit() const;
 
    void clean(time_t maxage);
 
    void setDefaultPoolChunking(bool const &);
 
    MemImplementingAllocator *pools = nullptr;
    ssize_t mem_idle_limit = (2 << 20) /* 2MB */;
    int poolCount = 0;
    bool defaultIsChunked = false;
};
 
class MemAllocator
{
public:
    MemAllocator (char const *aLabel);
    virtual ~MemAllocator() {}
 
    virtual int getStats(MemPoolStats * stats, int accumulate = 0) = 0;
 
    virtual MemPoolMeter const &getMeter() const = 0;
 
    virtual void *alloc() = 0;
 
    virtual void freeOne(void *) = 0;
 
    virtual char const *objectType() const;
    virtual size_t objectSize() const = 0;
    virtual int getInUseCount() = 0;
    void zeroBlocks(bool doIt) {doZero = doIt;}
    int inUseCount();
 
    virtual void setChunkSize(size_t) {}
 
    static size_t RoundedSize(size_t minSize);
 
protected:
    bool doZero;
 
private:
    const char *label;
};
 
class MemImplementingAllocator : public MemAllocator
{
public:
    MemImplementingAllocator(char const *aLabel, size_t aSize);
    virtual ~MemImplementingAllocator();
    virtual MemPoolMeter const &getMeter() const;
    virtual MemPoolMeter &getMeter();
    virtual void flushMetersFull();
    virtual void flushMeters();
 
    virtual void *alloc();
 
    virtual void freeOne(void *);
 
    virtual bool idleTrigger(int shift) const = 0;
    virtual void clean(time_t maxage) = 0;
    virtual size_t objectSize() const;
    virtual int getInUseCount() = 0;
protected:
    virtual void *allocate() = 0;
    virtual void deallocate(void *, bool aggressive) = 0;
    MemPoolMeter meter;
    int memPID;
public:
    MemImplementingAllocator *next;
public:
    size_t alloc_calls;
    size_t free_calls;
    size_t saved_calls;
    size_t obj_size;
};
 
class MemPoolStats
{
public:
    MemAllocator *pool;
    const char *label;
    MemPoolMeter *meter;
    int obj_size;
    int chunk_capacity;
    int chunk_size;
 
    int chunks_alloc;
    int chunks_inuse;
    int chunks_partial;
    int chunks_free;
 
    int items_alloc;
    int items_inuse;
    int items_idle;
 
    int overhead;
};
 
struct _MemPoolGlobalStats {
    MemPoolMeter *TheMeter;
 
    int tot_pools_alloc;
    int tot_pools_inuse;
    int tot_pools_mempid;
 
    int tot_chunks_alloc;
    int tot_chunks_inuse;
    int tot_chunks_partial;
    int tot_chunks_free;
 
    int tot_items_alloc;
    int tot_items_inuse;
    int tot_items_idle;
 
    int tot_overhead;
    ssize_t mem_idle_limit;
};
 
#define memPoolCreate MemPools::GetInstance().create
 
/* Allocator API */
extern MemPoolIterator * memPoolIterate(void);
 
extern MemImplementingAllocator * memPoolIterateNext(MemPoolIterator * iter);
 
extern void memPoolIterateDone(MemPoolIterator ** iter);
 
extern int memPoolGetGlobalStats(MemPoolGlobalStats * stats);
 
extern int memPoolsTotalAllocated(void);
 
#endif /* _MEM_POOL_H_ */