Imagelibrary/tlsf
1
0
Fork 0
mirror of https://github.com/espressif/tlsf.git synced 2025-11-16 04:24:45 +00:00
Code Issues Packages Projects Releases Wiki Activity

Inline functions in tlsf.c and tlsf_block_functions.h

Browse Source 
Use the attribute __attribute__((always_inline)).
This commit is contained in:
Guillaume Souchere
2022-07-14 13:26:10 +02:00
parent 81cecf2e0d
commit 7d2c0f2264
2 changed files with 38 additions and 38 deletions
Download Patch File Download Diff File Expand all files Collapse all files

42
tlsf.c
View File

@@ -221,19 +221,19 @@ tlsf_static_assert(sizeof(unsigned int) * CHAR_BIT >= SL_INDEX_COUNT);
/* Ensure we've properly tuned our sizes. */
tlsf_static_assert(ALIGN_SIZE == SMALL_BLOCK_SIZE / SL_INDEX_COUNT);
static size_t align_up(size_t x, size_t align)
static inline __attribute__((always_inline)) size_t align_up(size_t x, size_t align)
{
tlsf_assert(0 == (align & (align - 1)) && "must align to a power of two");
return (x + (align - 1)) & ~(align - 1);
}
static size_t align_down(size_t x, size_t align)
static inline __attribute__((always_inline)) size_t align_down(size_t x, size_t align)
{
tlsf_assert(0 == (align & (align - 1)) && "must align to a power of two");
return x - (x & (align - 1));
}
static void* align_ptr(const void* ptr, size_t align)
static inline __attribute__((always_inline)) void* align_ptr(const void* ptr, size_t align)
{
const tlsfptr_t aligned =
(tlsf_cast(tlsfptr_t, ptr) + (align - 1)) & ~(align - 1);
@@ -245,7 +245,7 @@ static void* align_ptr(const void* ptr, size_t align)
** Adjust an allocation size to be aligned to word size, and no smaller
** than internal minimum.
*/
static size_t adjust_request_size(size_t size, size_t align)
static inline __attribute__((always_inline)) size_t adjust_request_size(size_t size, size_t align)
{
size_t adjust = 0;
if (size)
@@ -266,7 +266,7 @@ static size_t adjust_request_size(size_t size, size_t align)
** the documentation found in the white paper.
*/
static void mapping_insert(size_t size, int* fli, int* sli)
static inline __attribute__((always_inline)) void mapping_insert(size_t size, int* fli, int* sli)
{
int fl, sl;
if (size < SMALL_BLOCK_SIZE)
@@ -286,7 +286,7 @@ static void mapping_insert(size_t size, int* fli, int* sli)
}
/* This version rounds up to the next block size (for allocations) */
static void mapping_search(size_t size, int* fli, int* sli)
static inline __attribute__((always_inline)) void mapping_search(size_t size, int* fli, int* sli)
{
if (size >= SMALL_BLOCK_SIZE)
{
@@ -296,7 +296,7 @@ static void mapping_search(size_t size, int* fli, int* sli)
mapping_insert(size, fli, sli);
}
static block_header_t* search_suitable_block(control_t* control, int* fli, int* sli)
static inline __attribute__((always_inline)) block_header_t* search_suitable_block(control_t* control, int* fli, int* sli)
{
int fl = *fli;
int sl = *sli;
@@ -329,7 +329,7 @@ static block_header_t* search_suitable_block(control_t* control, int* fli, int*
}
/* Remove a free block from the free list.*/
static void remove_free_block(control_t* control, block_header_t* block, int fl, int sl)
static inline __attribute__((always_inline)) void remove_free_block(control_t* control, block_header_t* block, int fl, int sl)
{
block_header_t* prev = block->prev_free;
block_header_t* next = block->next_free;
@@ -358,7 +358,7 @@ static void remove_free_block(control_t* control, block_header_t* block, int fl,
}
/* Insert a free block into the free block list. */
static void insert_free_block(control_t* control, block_header_t* block, int fl, int sl)
static inline __attribute__((always_inline)) void insert_free_block(control_t* control, block_header_t* block, int fl, int sl)
{
block_header_t* current = control->blocks[fl][sl];
tlsf_assert(current && "free list cannot have a null entry");
@@ -379,7 +379,7 @@ static void insert_free_block(control_t* control, block_header_t* block, int fl,
}
/* Remove a given block from the free list. */
static void block_remove(control_t* control, block_header_t* block)
static inline __attribute__((always_inline)) void block_remove(control_t* control, block_header_t* block)
{
int fl, sl;
mapping_insert(block_size(block), &fl, &sl);
@@ -387,20 +387,20 @@ static void block_remove(control_t* control, block_header_t* block)
}
/* Insert a given block into the free list. */
static void block_insert(control_t* control, block_header_t* block)
static inline __attribute__((always_inline)) void block_insert(control_t* control, block_header_t* block)
{
int fl, sl;
mapping_insert(block_size(block), &fl, &sl);
insert_free_block(control, block, fl, sl);
}
static int block_can_split(block_header_t* block, size_t size)
static inline __attribute__((always_inline)) int block_can_split(block_header_t* block, size_t size)
{
return block_size(block) >= sizeof(block_header_t) + size;
}
/* Split a block into two, the second of which is free. */
static block_header_t* block_split(block_header_t* block, size_t size)
static inline __attribute__((always_inline)) block_header_t* block_split(block_header_t* block, size_t size)
{
/* Calculate the amount of space left in the remaining block. */
block_header_t* remaining =
@@ -422,7 +422,7 @@ static block_header_t* block_split(block_header_t* block, size_t size)
}
/* Absorb a free block's storage into an adjacent previous free block. */
static block_header_t* block_absorb(block_header_t* prev, block_header_t* block)
static inline __attribute__((always_inline)) block_header_t* block_absorb(block_header_t* prev, block_header_t* block)
{
tlsf_assert(!block_is_last(prev) && "previous block can't be last");
/* Note: Leaves flags untouched. */
@@ -432,7 +432,7 @@ static block_header_t* block_absorb(block_header_t* prev, block_header_t* block)
}
/* Merge a just-freed block with an adjacent previous free block. */
static block_header_t* block_merge_prev(control_t* control, block_header_t* block)
static inline __attribute__((always_inline)) block_header_t* block_merge_prev(control_t* control, block_header_t* block)
{
if (block_is_prev_free(block))
{
@@ -447,7 +447,7 @@ static block_header_t* block_merge_prev(control_t* control, block_header_t* bloc
}
/* Merge a just-freed block with an adjacent free block. */
static block_header_t* block_merge_next(control_t* control, block_header_t* block)
static inline __attribute__((always_inline)) block_header_t* block_merge_next(control_t* control, block_header_t* block)
{
block_header_t* next = block_next(block);
tlsf_assert(next && "next physical block can't be null");
@@ -463,7 +463,7 @@ static block_header_t* block_merge_next(control_t* control, block_header_t* bloc
}
/* Trim any trailing block space off the end of a block, return to pool. */
static void block_trim_free(control_t* control, block_header_t* block, size_t size)
static inline __attribute__((always_inline)) void block_trim_free(control_t* control, block_header_t* block, size_t size)
{
tlsf_assert(block_is_free(block) && "block must be free");
if (block_can_split(block, size))
@@ -476,7 +476,7 @@ static void block_trim_free(control_t* control, block_header_t* block, size_t si
}
/* Trim any trailing block space off the end of a used block, return to pool. */
static void block_trim_used(control_t* control, block_header_t* block, size_t size)
static inline __attribute__((always_inline)) void block_trim_used(control_t* control, block_header_t* block, size_t size)
{
tlsf_assert(!block_is_free(block) && "block must be used");
if (block_can_split(block, size))
@@ -490,7 +490,7 @@ static void block_trim_used(control_t* control, block_header_t* block, size_t si
}
}
static block_header_t* block_trim_free_leading(control_t* control, block_header_t* block, size_t size)
static inline __attribute__((always_inline)) block_header_t* block_trim_free_leading(control_t* control, block_header_t* block, size_t size)
{
block_header_t* remaining_block = block;
if (block_can_split(block, size))
@@ -506,7 +506,7 @@ static block_header_t* block_trim_free_leading(control_t* control, block_header_
return remaining_block;
}
static block_header_t* block_locate_free(control_t* control, size_t size)
static inline __attribute__((always_inline)) block_header_t* block_locate_free(control_t* control, size_t size)
{
int fl = 0, sl = 0;
block_header_t* block = 0;
@@ -536,7 +536,7 @@ static block_header_t* block_locate_free(control_t* control, size_t size)
return block;
}
static void* block_prepare_used(control_t* control, block_header_t* block, size_t size)
static inline __attribute__((always_inline)) void* block_prepare_used(control_t* control, block_header_t* block, size_t size)
{
void* p = 0;
if (block)

34
tlsf_block_functions.h
View File

@@ -15,79 +15,79 @@ extern "C" {
** block_header_t member functions.
*/
static size_t block_size(const block_header_t* block)
static inline __attribute__((always_inline)) size_t block_size(const block_header_t* block)
{
return block->size & ~(block_header_free_bit | block_header_prev_free_bit);
}
static void block_set_size(block_header_t* block, size_t size)
static inline __attribute__((always_inline)) void block_set_size(block_header_t* block, size_t size)
{
const size_t oldsize = block->size;
block->size = size | (oldsize & (block_header_free_bit | block_header_prev_free_bit));
}
static int block_is_last(const block_header_t* block)
static inline __attribute__((always_inline)) int block_is_last(const block_header_t* block)
{
return block_size(block) == 0;
}
static int block_is_free(const block_header_t* block)
static inline __attribute__((always_inline)) int block_is_free(const block_header_t* block)
{
return tlsf_cast(int, block->size & block_header_free_bit);
}
static void block_set_free(block_header_t* block)
static inline __attribute__((always_inline)) void block_set_free(block_header_t* block)
{
block->size |= block_header_free_bit;
}
static void block_set_used(block_header_t* block)
static inline __attribute__((always_inline)) void block_set_used(block_header_t* block)
{
block->size &= ~block_header_free_bit;
}
static int block_is_prev_free(const block_header_t* block)
static inline __attribute__((always_inline)) int block_is_prev_free(const block_header_t* block)
{
return tlsf_cast(int, block->size & block_header_prev_free_bit);
}
static void block_set_prev_free(block_header_t* block)
static inline __attribute__((always_inline)) void block_set_prev_free(block_header_t* block)
{
block->size |= block_header_prev_free_bit;
}
static void block_set_prev_used(block_header_t* block)
static inline __attribute__((always_inline)) void block_set_prev_used(block_header_t* block)
{
block->size &= ~block_header_prev_free_bit;
}
static block_header_t* block_from_ptr(const void* ptr)
static inline __attribute__((always_inline)) block_header_t* block_from_ptr(const void* ptr)
{
return tlsf_cast(block_header_t*,
tlsf_cast(unsigned char*, ptr) - block_start_offset);
}
static void* block_to_ptr(const block_header_t* block)
static inline __attribute__((always_inline)) void* block_to_ptr(const block_header_t* block)
{
return tlsf_cast(void*,
tlsf_cast(unsigned char*, block) + block_start_offset);
}
/* Return location of next block after block of given size. */
static block_header_t* offset_to_block(const void* ptr, size_t size)
static inline __attribute__((always_inline)) block_header_t* offset_to_block(const void* ptr, size_t size)
{
return tlsf_cast(block_header_t*, tlsf_cast(tlsfptr_t, ptr) + size);
}
/* Return location of previous block. */
static block_header_t* block_prev(const block_header_t* block)
static inline __attribute__((always_inline)) block_header_t* block_prev(const block_header_t* block)
{
tlsf_assert(block_is_prev_free(block) && "previous block must be free");
return block->prev_phys_block;
}
/* Return location of next existing block. */
static block_header_t* block_next(const block_header_t* block)
static inline __attribute__((always_inline)) block_header_t* block_next(const block_header_t* block)
{
block_header_t* next = offset_to_block(block_to_ptr(block),
block_size(block) - block_header_overhead);
@@ -96,14 +96,14 @@ static block_header_t* block_next(const block_header_t* block)
}
/* Link a new block with its physical neighbor, return the neighbor. */
static block_header_t* block_link_next(block_header_t* block)
static inline __attribute__((always_inline)) block_header_t* block_link_next(block_header_t* block)
{
block_header_t* next = block_next(block);
next->prev_phys_block = block;
return next;
}
static void block_mark_as_free(block_header_t* block)
static inline __attribute__((always_inline)) void block_mark_as_free(block_header_t* block)
{
/* Link the block to the next block, first. */
block_header_t* next = block_link_next(block);
@@ -111,7 +111,7 @@ static void block_mark_as_free(block_header_t* block)
block_set_free(block);
}
static void block_mark_as_used(block_header_t* block)
static inline __attribute__((always_inline)) void block_mark_as_used(block_header_t* block)
{
block_header_t* next = block_next(block);
block_set_prev_used(next);