slab_cache_anon_i.h

Go to the documentation of this file.

// AUTOMATICALLY GENERATED -- DO NOT EDIT!         -*- c++ -*-

#ifndef slab_cache_anon_i_h
#define slab_cache_anon_i_h

#include <stddef.h>
#include <stdlib.h>
#include <assert.h>

// 
// class slab
// 

class slab                      // a slab of the cache
{
  slab();
  slab(const slab&);    // default constructors remain undefined

  struct slab_entry
  {
    slab_entry *_next_free;
    char _entry[0];
  };

  struct slab_data
  {
    slab_cache_anon *_cache;
    slab_entry *_first_free;
    slab *_next, *_prev;
    unsigned short _in_use, _free;
  };

  // slabs for CACHE_ENTRY should contain at least min_cache_items
  // cache entries
  static const unsigned min_cache_items = 4;

  // 
  // data declaration follows 
  // 
  slab_data _data;

public:  
  slab(slab_cache_anon *cache);
  
  inline ~slab();
  
  void * alloc();
  
  void free(void *entry);
  
  inline bool is_empty();
  
  inline bool is_full();
  
  void enqueue(slab *prev);
  
  void dequeue();
  
  inline slab * prev();
  
  inline slab * next();
  
  inline void * operator new(size_t, slab_cache_anon *cache);

private:  
  // default deallocator must not be called -- must use explicit destruction
  inline void operator delete(void* /*block*/);
};                              // end declaration of class slab

//
// IMPLEMENTATION of inline functions follows
//




inline slab::~slab()
{
  assert(_data._in_use == 0);

  slab_entry *e = _data._first_free;

  while (e)
    {
      _data._cache->elem_dtor(& e->_entry[0]);
      e = e->_next_free;
    }
}



inline bool
slab::is_empty()
{
  return _data._in_use == 0;
}



inline bool
slab::is_full()
{
  return _data._free == 0;
}



inline slab *
slab::prev()
{
  return _data._prev;
}



inline slab *
slab::next()
{
  return _data._next;
}



inline void *
slab::operator new(size_t,
                   slab_cache_anon *cache)
{
  // slabs must be size-aligned so that we can compute their addresses
  // from element addresses
  return cache->block_alloc(cache->_slab_size, cache->_slab_size);
}

#endif // slab_cache_anon_i_h

---