genode/repos/base/include/base/slab.h

/*
 * \brief  Slab allocator
 * \author Norman Feske
 * \date   2006-04-18
 */

/*
 * Copyright (C) 2006-2013 Genode Labs GmbH
 *
 * This file is part of the Genode OS framework, which is distributed
 * under the terms of the GNU General Public License version 2.
 */

#ifndef _INCLUDE__BASE__SLAB_H_
#define _INCLUDE__BASE__SLAB_H_

#include <base/allocator.h>
#include <base/stdint.h>

namespace Genode { class Slab; }

/**
 * Transitional type definition, for API compatibility only
 *
 * \deprecated  To be removed once all Slab users are updated.
 */
namespace Genode { typedef void Slab_block; }


/**
 * Slab allocator
 */
class Genode::Slab : public Allocator
{
	private:

		struct Block;
		struct Entry;

		size_t const _slab_size;          /* size of one slab entry           */
		size_t const _block_size;         /* size of slab block               */
		size_t const _entries_per_block;  /* number of slab entries per block */

		Block       *_first_sb;      /* first slab block                     */
		Block       *_initial_sb;    /* initial (static) slab block          */
		bool         _alloc_state;   /* indicator for 'currently in service' */

		Allocator   *_backing_store;

		/**
		 * Allocate and initialize new slab block
		 */
		Block *_new_slab_block();


		/*****************************
		 ** Methods used by 'Block' **
		 *****************************/

		/**
		 * Remove block from slab block list
		 *
		 * \noapi
		 */
		void _remove_sb(Block *sb);

		/**
		 * Insert block into slab block list
		 *
		 * \noapi
		 */
		void _insert_sb(Block *sb, Block *at = 0);

		/**
		 * Free slab entry
		 */
		void _free(void *addr);

		/**
		 * Return true if number of free slab entries is higher than n
		 */
		bool _num_free_entries_higher_than(int n);

	public:

		/**
		 * Constructor
		 *
		 * At construction time, there exists one initial slab
		 * block that is used for the first couple of allocations,
		 * especially for the allocation of the second slab
		 * block.
		 */
		Slab(size_t slab_size, size_t block_size, void *initial_sb,
		     Allocator *backing_store = 0);

		/**
		 * Destructor
		 */
		~Slab();

		/**
		 * Add new slab block as backing store
		 *
		 * The specified 'ptr' has to point to a buffer with the size of one
		 * slab block.
		 */
		void insert_sb(void *ptr);

		/**
		 * Return a used slab element, or nullptr if empty
		 */
		void *any_used_elem();

		/**
		 * Define/request backing-store allocator
		 *
		 * \noapi
		 */
		void backing_store(Allocator *bs) { _backing_store = bs; }

		/**
		 * Request backing-store allocator
		 *
		 * \noapi
		 */
		Allocator *backing_store() { return _backing_store; }


		/*************************
		 ** Allocator interface **
		 *************************/

		/**
		 * Allocate slab entry
		 *
		 * The 'size' parameter is ignored as only slab entries with
		 * preconfigured slab-entry size are allocated.
		 */
		bool   alloc(size_t size, void **addr) override;
		void   free(void *addr, size_t) override { _free(addr); }
		size_t consumed() const override;
		size_t overhead(size_t) const override { return _block_size/_entries_per_block; }
		bool   need_size_for_free() const override { return false; }
};

#endif /* _INCLUDE__BASE__SLAB_H_ */