README.md (3511B)
1 # Tlsf 2 3 Two Level Segregated Fit memory allocator implementation. 4 Written by Matthew Conte ([email protected]). Licensed under BSD license and can be found [here](https://github.com/mattconte/tlsf). 5 6 ## Features 7 8 - O(1) cost for malloc, free, realloc, memalign. 9 - Extremely low overhead per allocation (4 bytes). 10 - Low overhead per TLSF management of pools (~3kB). 11 - Low fragmentation. 12 - Compiles to only a few kB of code and data. 13 - Support for adding and removing memory pool regions on the fly. 14 15 ## Caveats 16 17 - Currently, assumes architecture can make 4-byte aligned accesses. 18 - Not designed to be thread safe; the user must provide this. 19 20 ## Notes 21 22 This code was based on the TLSF 1.4 spec. 23 It also leverages the TLSF 2.0 improvement to shrink the per-block overhead 24 from 8 to 4 bytes. 25 26 ## Known Issues 27 28 - Due to the internal block structure size and the implementation 29 details of tlsf_memalign, there is worst-case behavior when requesting 30 small (<16 byte) blocks aligned to 8-byte boundaries. Overuse of memalign 31 will generally increase fragmentation, but this particular case will leave 32 lots of unusable "holes" in the pool. The solution would be to internally 33 align all blocks to 8 bytes, but this will require significantl changes 34 to the implementation. Contact me if you are interested. 35 36 ## History 37 38 ### 2016/04/10 - v3.1 39 40 - Code moved to github 41 - tlsfbits.h rolled into tlsf.c 42 - License changed to BSD 43 44 ### 2014/02/08 - v3.0 45 - This version is based on improvements from 3DInteractive GmbH 46 - Interface changed to allow more than one memory pool 47 - Separated pool handling from control structure (adding, removing, debugging) 48 - Control structure and pools can still be constructed in the same memory block 49 - Memory blocks for control structure and pools are checked for alignment 50 - Added functions to retrieve control structure size, alignment size, min and max block size, overhead of pool structure, and overhead of a single allocation 51 - Minimal Pool size is tlsf_block_size_min() + tlsf_pool_overhead() 52 - Pool must be empty when it is removed, in order to allow O(1) removal 53 54 ### 2011/10/20 - v2.0 55 - 64-bit support 56 - More compiler intrinsics for ffs/fls 57 - ffs/fls verification during TLSF creation in debug builds 58 59 ### 2008/04/04 - v1.9 60 - Add tlsf_heap_check, a heap integrity check 61 - Support a predefined tlsf_assert macro 62 - Fix realloc case where block should shrink; if adjacent block is in use, execution would go down the slow path 63 64 ### 2007/02/08 - v1.8 65 - Fix for unnecessary reallocation in tlsf_realloc 66 67 ### 2007/02/03 - v1.7 68 - tlsf_heap_walk takes a callback 69 - tlsf_realloc now returns NULL on failure 70 - tlsf_memalign optimization for 4-byte alignment 71 - Usage of size_t where appropriate 72 73 ### 2006/11/21 - v1.6 74 - ffs/fls broken out into tlsfbits.h 75 - tlsf_overhead queries per-pool overhead 76 77 ### 2006/11/07 - v1.5 78 - Smart realloc implementation 79 - Smart memalign implementation 80 81 ### 2006/10/11 - v1.4 82 - Add some ffs/fls implementations 83 - Minor code footprint reduction 84 85 ### 2006/09/14 - v1.3 86 - Profiling indicates heavy use of blocks of size 1-128, so implement small block handling 87 - Reduce pool overhead by about 1kb 88 - Reduce minimum block size from 32 to 12 bytes 89 - Realloc bug fix 90 91 ### 2006/09/09 - v1.2 92 - Add tlsf_block_size 93 - Static assertion mechanism for invariants 94 - Minor bugfixes 95 96 ### 2006/09/01 - v1.1 97 - Add tlsf_realloc 98 - Add tlsf_walk_heap 99 100 ### 2006/08/25 - v1.0 101 - First release