Pool.h

Go to the documentation of this file.

/*
 * Copyright (C) 1996-2018 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_ */