tlsf.c File Reference

#include <assert.h>
#include <limits.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "tlsf.h"
#include "tlsfbits.h"

Go to the source code of this file.

Classes
struct	block_header_t
struct	control_t
struct	integrity_t

Macros
#define	tlsf_cast(t, exp)
#define	tlsf_min(a, b)
#define	tlsf_max(a, b)
#define	tlsf_assert   assert
#define	_tlsf_glue2(x, y)
#define	_tlsf_glue(x, y)
#define	tlsf_static_assert(exp)
#define	tlsf_insist(x)

Typedefs
typedef struct block_header_t	block_header_t
typedef struct control_t	control_t
typedef ptrdiff_t	tlsfptr_t
typedef struct integrity_t	integrity_t

Enumerations
enum	tlsf_public { SL_INDEX_COUNT_LOG2 = 5 }
enum	tlsf_private {   ALIGN_SIZE_LOG2 = 2 , ALIGN_SIZE = (1 << ALIGN_SIZE_LOG2) , FL_INDEX_MAX = 30 , SL_INDEX_COUNT = (1 << SL_INDEX_COUNT_LOG2) ,   FL_INDEX_SHIFT = (SL_INDEX_COUNT_LOG2 + ALIGN_SIZE_LOG2) , FL_INDEX_COUNT = (FL_INDEX_MAX - FL_INDEX_SHIFT + 1) , SMALL_BLOCK_SIZE = (1 << FL_INDEX_SHIFT) }

Functions
	tlsf_static_assert (sizeof(int) *CHAR_BIT==32)
	tlsf_static_assert (sizeof(size_t) *CHAR_BIT >=32)
	tlsf_static_assert (sizeof(size_t) *CHAR_BIT<=64)
	tlsf_static_assert (sizeof(unsigned int) *CHAR_BIT >=SL_INDEX_COUNT)
	tlsf_static_assert (ALIGN_SIZE==SMALL_BLOCK_SIZE/SL_INDEX_COUNT)
static size_t	block_size (const block_header_t *block)
static void	block_set_size (block_header_t *block, size_t size)
static int	block_is_last (const block_header_t *block)
static int	block_is_free (const block_header_t *block)
static void	block_set_free (block_header_t *block)
static void	block_set_used (block_header_t *block)
static int	block_is_prev_free (const block_header_t *block)
static void	block_set_prev_free (block_header_t *block)
static void	block_set_prev_used (block_header_t *block)
static block_header_t *	block_from_ptr (const void *ptr)
static void *	block_to_ptr (const block_header_t *block)
static block_header_t *	offset_to_block (const void *ptr, size_t size)
static block_header_t *	block_prev (const block_header_t *block)
static block_header_t *	block_next (const block_header_t *block)
static block_header_t *	block_link_next (block_header_t *block)
static void	block_mark_as_free (block_header_t *block)
static void	block_mark_as_used (block_header_t *block)
static size_t	align_up (size_t x, size_t align)
static size_t	align_down (size_t x, size_t align)
static void *	align_ptr (const void *ptr, size_t align)
static size_t	adjust_request_size (size_t size, size_t align)
static void	mapping_insert (size_t size, int *fli, int *sli)
static void	mapping_search (size_t size, int *fli, int *sli)
static block_header_t *	search_suitable_block (control_t *control, int *fli, int *sli)
static void	remove_free_block (control_t *control, block_header_t *block, int fl, int sl)
static void	insert_free_block (control_t *control, block_header_t *block, int fl, int sl)
static void	block_remove (control_t *control, block_header_t *block)
static void	block_insert (control_t *control, block_header_t *block)
static int	block_can_split (block_header_t *block, size_t size)
static block_header_t *	block_split (block_header_t *block, size_t size)
static block_header_t *	block_absorb (block_header_t *prev, block_header_t *block)
static block_header_t *	block_merge_prev (control_t *control, block_header_t *block)
static block_header_t *	block_merge_next (control_t *control, block_header_t *block)
static void	block_trim_free (control_t *control, block_header_t *block, size_t size)
static void	block_trim_used (control_t *control, block_header_t *block, size_t size)
static block_header_t *	block_trim_free_leading (control_t *control, block_header_t *block, size_t size)
static block_header_t *	block_locate_free (control_t *control, size_t size)
static void *	block_prepare_used (control_t *control, block_header_t *block, size_t size)
static void	control_construct (control_t *control)
static void	integrity_walker (void *ptr, size_t size, int used, void *user)
int	tlsf_check (tlsf_t tlsf)
static void	default_walker (void *ptr, size_t size, int used, void *user)
void	tlsf_walk_pool (pool_t pool, tlsf_walker walker, void *user)
size_t	tlsf_block_size (void *ptr)
int	tlsf_check_pool (pool_t pool)
size_t	tlsf_size ()
size_t	tlsf_align_size ()
size_t	tlsf_block_size_min ()
size_t	tlsf_block_size_max ()
size_t	tlsf_pool_overhead ()
size_t	tlsf_alloc_overhead ()
pool_t	tlsf_add_pool (tlsf_t tlsf, void *mem, size_t bytes)
void	tlsf_remove_pool (tlsf_t tlsf, pool_t pool)
tlsf_t	tlsf_create (void *mem)
tlsf_t	tlsf_create_with_pool (void *mem, size_t bytes)
void	tlsf_destroy (tlsf_t tlsf)
pool_t	tlsf_get_pool (tlsf_t tlsf)
void *	tlsf_malloc (tlsf_t tlsf, size_t size)
void *	tlsf_memalign (tlsf_t tlsf, size_t align, size_t size)
void	tlsf_free (tlsf_t tlsf, void *ptr)
void *	tlsf_realloc (tlsf_t tlsf, void *ptr, size_t size)

Variables
static const size_t	block_header_free_bit = 1 << 0
static const size_t	block_header_prev_free_bit = 1 << 1
static const size_t	block_header_overhead = sizeof(size_t)
static const size_t	block_start_offset
static const size_t	block_size_min
static const size_t	block_size_max = tlsf_cast(size_t, 1) << FL_INDEX_MAX

Macro Definition Documentation

_tlsf_glue

#define _tlsf_glue	(		x,
			y )

Value:

_tlsf_glue2(x, y)

_tlsf_glue2

#define _tlsf_glue2	(		x,
			y )

Value:

x ## y

tlsf_assert

#define tlsf_assert   assert

tlsf_cast

#define tlsf_cast	(		t,
			exp )

Value:

((t) (exp))

tlsf_insist

#define tlsf_insist

(

x

)

Value:

{ tlsf_assert(x); if (!(x)) { status--; } }

tlsf_max

#define tlsf_max	(		a,
			b )

Value:

((a) > (b) ? (a) : (b))

tlsf_min

#define tlsf_min	(		a,
			b )

Value:

((a) < (b) ? (a) : (b))

tlsf_static_assert

#define tlsf_static_assert

(

exp

)

Value:

typedef char _tlsf_glue(static_assert, __LINE__) [(exp) ? 1 : -1]

Typedef Documentation

block_header_t

typedef struct block_header_t block_header_t

control_t

typedef struct control_t control_t

integrity_t

typedef struct integrity_t integrity_t

tlsfptr_t

typedef ptrdiff_t tlsfptr_t

Enumeration Type Documentation

tlsf_private

enum tlsf_private

Enumerator
ALIGN_SIZE_LOG2
ALIGN_SIZE
FL_INDEX_MAX
SL_INDEX_COUNT
FL_INDEX_SHIFT
FL_INDEX_COUNT
SMALL_BLOCK_SIZE

tlsf_public

enum tlsf_public

Enumerator
SL_INDEX_COUNT_LOG2

Function Documentation

adjust_request_size()

size_t adjust_request_size ( size_t size, size_t align )

static

align_down()

size_t align_down ( size_t x, size_t align )

static

align_ptr()

void * align_ptr ( const void * ptr, size_t align )

static

align_up()

size_t align_up ( size_t x, size_t align )

static

block_absorb()

block_header_t * block_absorb ( block_header_t * prev, block_header_t * block )

static

block_can_split()

int block_can_split ( block_header_t * block, size_t size )

static

block_from_ptr()

block_header_t * block_from_ptr ( const void * ptr )

static

block_insert()

void block_insert ( control_t * control, block_header_t * block )

static

block_is_free()

int block_is_free ( const block_header_t * block )

static

block_is_last()

int block_is_last ( const block_header_t * block )

static

block_is_prev_free()

int block_is_prev_free ( const block_header_t * block )

static

block_link_next()

block_header_t * block_link_next ( block_header_t * block )

static

block_locate_free()

block_header_t * block_locate_free ( control_t * control, size_t size )

static

block_mark_as_free()

void block_mark_as_free ( block_header_t * block )

static

block_mark_as_used()

void block_mark_as_used ( block_header_t * block )

static

block_merge_next()

block_header_t * block_merge_next ( control_t * control, block_header_t * block )

static

block_merge_prev()

block_header_t * block_merge_prev ( control_t * control, block_header_t * block )

static

block_next()

block_header_t * block_next ( const block_header_t * block )

static

block_prepare_used()

void * block_prepare_used ( control_t * control, block_header_t * block, size_t size )

static

block_prev()

block_header_t * block_prev ( const block_header_t * block )

static

block_remove()

void block_remove ( control_t * control, block_header_t * block )

static

block_set_free()

void block_set_free ( block_header_t * block )

static

block_set_prev_free()

void block_set_prev_free ( block_header_t * block )

static

block_set_prev_used()

void block_set_prev_used ( block_header_t * block )

static

block_set_size()

void block_set_size ( block_header_t * block, size_t size )

static

block_set_used()

void block_set_used ( block_header_t * block )

static

block_size()

size_t block_size ( const block_header_t * block )

static

block_split()

block_header_t * block_split ( block_header_t * block, size_t size )

static

block_to_ptr()

void * block_to_ptr ( const block_header_t * block )

static

block_trim_free()

void block_trim_free ( control_t * control, block_header_t * block, size_t size )

static

block_trim_free_leading()

block_header_t * block_trim_free_leading ( control_t * control, block_header_t * block, size_t size )

static

block_trim_used()

void block_trim_used ( control_t * control, block_header_t * block, size_t size )

static

control_construct()

void control_construct ( control_t * control )

static

default_walker()

void default_walker ( void * ptr, size_t size, int used, void * user )

static

insert_free_block()

void insert_free_block ( control_t * control, block_header_t * block, int fl, int sl )

static

integrity_walker()

void integrity_walker ( void * ptr, size_t size, int used, void * user )

static

mapping_insert()

void mapping_insert ( size_t size, int * fli, int * sli )

static

mapping_search()

void mapping_search ( size_t size, int * fli, int * sli )

static

offset_to_block()

block_header_t * offset_to_block ( const void * ptr, size_t size )

static

remove_free_block()

void remove_free_block ( control_t * control, block_header_t * block, int fl, int sl )

static

search_suitable_block()

block_header_t * search_suitable_block ( control_t * control, int * fli, int * sli )

static

tlsf_add_pool()

pool_t tlsf_add_pool	(	tlsf_t	tlsf,
		void *	mem,
		size_t	bytes )

tlsf_align_size()

size_t tlsf_align_size

(

)

tlsf_alloc_overhead()

size_t tlsf_alloc_overhead

(

)

tlsf_block_size()

size_t tlsf_block_size

(

void *

ptr

)

tlsf_block_size_max()

size_t tlsf_block_size_max

(

)

tlsf_block_size_min()

size_t tlsf_block_size_min

(

)

tlsf_check()

int tlsf_check

(

tlsf_t

tlsf

)

tlsf_check_pool()

int tlsf_check_pool

(

pool_t

pool

)

tlsf_create()

tlsf_t tlsf_create

(

void *

mem

)

tlsf_create_with_pool()

tlsf_t tlsf_create_with_pool	(	void *	mem,
		size_t	bytes )

tlsf_destroy()

void tlsf_destroy

(

tlsf_t

tlsf

)

tlsf_free()

void tlsf_free	(	tlsf_t	tlsf,
		void *	ptr )

tlsf_get_pool()

pool_t tlsf_get_pool

(

tlsf_t

tlsf

)

tlsf_malloc()

void * tlsf_malloc	(	tlsf_t	tlsf,
		size_t	size )

tlsf_memalign()

void * tlsf_memalign	(	tlsf_t	tlsf,
		size_t	align,
		size_t	size )

tlsf_pool_overhead()

size_t tlsf_pool_overhead

(

)

tlsf_realloc()

void * tlsf_realloc	(	tlsf_t	tlsf,
		void *	ptr,
		size_t	size )

tlsf_remove_pool()

void tlsf_remove_pool	(	tlsf_t	tlsf,
		pool_t	pool )

tlsf_size()

size_t tlsf_size

(

)

tlsf_static_assert() [1/5]

tlsf_static_assert

(

ALIGN_SIZE

= =SMALL_BLOCK_SIZE/SL_INDEX_COUNT

)

tlsf_static_assert() [2/5]

tlsf_static_assert

(

sizeof(int) *

CHAR_BIT = =32

)

tlsf_static_assert() [3/5]

tlsf_static_assert

(

sizeof(size_t) *CHAR_BIT >=

32

)

tlsf_static_assert() [4/5]

tlsf_static_assert

(

sizeof(size_t) *CHAR_BIT<=

64

)

tlsf_static_assert() [5/5]

tlsf_static_assert

(

sizeof(unsigned int) *CHAR_BIT >=

SL_INDEX_COUNT

)

tlsf_walk_pool()

void tlsf_walk_pool	(	pool_t	pool,
		tlsf_walker	walker,
		void *	user )

Variable Documentation

block_header_free_bit

const size_t block_header_free_bit = 1 << 0

static

block_header_overhead

const size_t block_header_overhead = sizeof(size_t)

static

block_header_prev_free_bit

const size_t block_header_prev_free_bit = 1 << 1

static

block_size_max

const size_t block_size_max = tlsf_cast(size_t, 1) << FL_INDEX_MAX

static

block_size_min

const size_t block_size_min

static

Initial value:

                           = 
sizeof(block_header_t) - sizeof(block_header_t*)

block_start_offset

const size_t block_start_offset

static

Initial value:

                               =
offsetof(block_header_t, size) + sizeof(size_t)