hashallocator.hh

// -*- related-file-name: "../../lib/hashallocator.cc" -*-
#ifndef CLICK_HASHALLOCATOR_HH
#define CLICK_HASHALLOCATOR_HH
#if HAVE_VALGRIND && HAVE_VALGRIND_MEMCHECK_H
# include <valgrind/memcheck.h>
#endif
CLICK_DECLS
 
class HashAllocator { public:
 
    HashAllocator(size_t size);
    ~HashAllocator();
 
    inline void increase_size(size_t new_size) {
        assert(!_free && !_buffer && new_size >= _size);
        _size = new_size;
    }
 
    inline void *allocate();
    inline void deallocate(void *p);
 
    void swap(HashAllocator &x);
 
  private:
 
#if HAVE_HASH_ALLOCATOR_POISONING
    // Freed blocks are poisoned with this byte value.
    static const uint8_t poison_byte = 0x0d;
#endif
 
    struct link {
        link *next;
    };
 
    struct buffer {
        buffer *next;
        size_t pos;
        size_t maxpos;
    };
 
    enum {
        min_buffer_size = 1024,
#if CLICK_LINUXMODULE
        max_buffer_size = 16384,
#else
        max_buffer_size = 1048576,
#endif
        min_nelements = 8
    };
 
    link *_free;
    buffer *_buffer;
    size_t _size;
 
    void *hard_allocate();
 
    HashAllocator(const HashAllocator &x);
    HashAllocator &operator=(const HashAllocator &x);
 
};
 
 
template <size_t size>
class SizedHashAllocator : public HashAllocator { public:
 
    SizedHashAllocator()
        : HashAllocator(size) {
    }
 
};
 
 
inline void *HashAllocator::allocate()
{
    if (link *l = _free) {
#ifdef VALGRIND_MEMPOOL_ALLOC
        VALGRIND_MEMPOOL_ALLOC(this, l, _size);
        VALGRIND_MAKE_MEM_DEFINED(&l->next, sizeof(l->next));
#endif
        _free = l->next;
#ifdef VALGRIND_MAKE_MEM_DEFINED
        VALGRIND_MAKE_MEM_UNDEFINED(&l->next, sizeof(l->next));
#endif
        return l;
    } else if (_buffer && _buffer->pos < _buffer->maxpos) {
        void *data = reinterpret_cast<char *>(_buffer) + _buffer->pos;
        _buffer->pos += _size;
#ifdef VALGRIND_MEMPOOL_ALLOC
        VALGRIND_MEMPOOL_ALLOC(this, data, _size);
#endif
        return data;
    } else
        return hard_allocate();
}
 
inline void HashAllocator::deallocate(void *p)
{
    if (p) {
#if HAVE_HASH_ALLOCATOR_POISONING
        memset(p, poison_byte, _size);
#endif
        reinterpret_cast<link *>(p)->next = _free;
        _free = reinterpret_cast<link *>(p);
#ifdef VALGRIND_MEMPOOL_FREE
        VALGRIND_MEMPOOL_FREE(this, p);
#endif
    }
}
 
CLICK_ENDDECLS
#endif