# tlsf

**Repository Path**: RT-Thread-Mirror/tlsf

## Basic Information

- **Project Name**: tlsf
- **Description**: No description available
- **Primary Language**: Unknown
- **License**: Not specified
- **Default Branch**: main
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2021-03-20
- **Last Updated**: 2024-07-04

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# TLSF

Two-Level Segregated Fit memory allocator implementation.
Written by Matthew Conte (matt@baisoku.org).
Released under the BSD license. https://github.com/mattconte/tlsf

## Features

  * O(1) cost for malloc, free, realloc, memalign
  * Extremely low overhead per allocation (4 bytes)
  * Low overhead per TLSF management of pools (~3kB)
  * Low fragmentation
  * Compiles to only a few kB of code and data
  * Support for adding and removing memory pool regions on the fly

## Caveats

  * Currently, assumes architecture can make 4-byte aligned accesses
  * Not designed to be thread safe; the user must provide this

## Notes

This code was based on the TLSF 1.4 spec and documentation found at:

	http://www.gii.upv.es/tlsf/main/docs

It also leverages the TLSF 2.0 improvement to shrink the per-block overhead from 8 to 4 bytes.

## History

2016/04/10 - v3.1
  * Code moved to github
  * tlsfbits.h rolled into tlsf.c
  * License changed to BSD

2014/02/08 - v3.0
  * This version is based on improvements from 3DInteractive GmbH
  * Interface changed to allow more than one memory pool
  * Separated pool handling from control structure (adding, removing, debugging)
  * Control structure and pools can still be constructed in the same memory block
  * Memory blocks for control structure and pools are checked for alignment
  * Added functions to retrieve control structure size, alignment size, min and max block size, overhead of pool structure, and overhead of a single allocation
  * Minimal Pool size is tlsf_block_size_min() + tlsf_pool_overhead()
  * Pool must be empty when it is removed, in order to allow O(1) removal

2011/10/20 - v2.0
  * 64-bit support
  * More compiler intrinsics for ffs/fls
  * ffs/fls verification during TLSF creation in debug builds

2008/04/04 - v1.9
  * Add tlsf_heap_check, a heap integrity check
  * Support a predefined tlsf_assert macro
  * Fix realloc case where block should shrink; if adjacent block is in use, execution would go down the slow path

2007/02/08 - v1.8
  * Fix for unnecessary reallocation in tlsf_realloc

2007/02/03 - v1.7
  * tlsf_heap_walk takes a callback
  * tlsf_realloc now returns NULL on failure
  * tlsf_memalign optimization for 4-byte alignment
  * Usage of size_t where appropriate

2006/11/21 - v1.6
  * ffs/fls broken out into tlsfbits.h
  * tlsf_overhead queries per-pool overhead

2006/11/07 - v1.5
  * Smart realloc implementation
  * Smart memalign implementation

2006/10/11 - v1.4
  * Add some ffs/fls implementations
  * Minor code footprint reduction

2006/09/14 - v1.3
  * Profiling indicates heavy use of blocks of size 1-128, so implement small block handling
  * Reduce pool overhead by about 1kb
  * Reduce minimum block size from 32 to 12 bytes
  * Realloc bug fix

2006/09/09 - v1.2
  * Add tlsf_block_size
  * Static assertion mechanism for invariants
  * Minor bugfixes 

2006/09/01 - v1.1
  * Add tlsf_realloc
  * Add tlsf_walk_heap

2006/08/25 - v1.0
  * First release

-----
## How to use TLSF

### Select TLSF package

Enable the user heap algorithm:

```                                   
  -> RT-Thread Kernel                             
    -> Memory Management                          
      -> Dynamic Memory Management 
            ( ) Disable Heap                                 
            ( ) Small Memory Algorithm                      
            ( ) SLAB Algorithm for large memory             
            ( ) Use all of memheap objects as heap          
            (X) Use user heap Algorithm
```
And enable the tlsf packages:

```
-> RT-Thread online packages 
    -> system packages  
        [*]  TLSF: A dynamic memory allocation algorithm with predictable execution time and low fragmentation.
             [ ] Enable TLSF align
                 Version (latest)  --->
```

- Enable TLSF align：Using TLSF align (malloc align and free align) algorithm if it is selected. Using system align algorithm if it is not selected.
- Version: The version of TLSF package.

### Multiple heaps

When the system is initialized, one heap(pool) is added automatically.  If multiple heaps(pools) are needed, use the APIs show below: 

add another heap(pool):

```c
void *heap = rt_system_heap_add((void *)SRAM_START_ADDR, (void *)SRAM_END_ADDR);
```

remove the heap(pool):

```c
rt_system_heap_remove(heap);
```

Note: the maximum number of heaps is 255.