ot::Utils::Heap class

Defines functionality to manipulate heap. This implementation is currently for mbedTLS. The memory is divided into blocks. The whole picture is as follows: +--------------------------------------------------------------------------+ | unused | super | block 1 | block 2 | ... | block n | guard | +----------------+------------+---------+---------+-----+---------+--------+ | kAlignSize - 2 | kAlignSize | 4 + s1 | 4 + s2 | ... | 4 + s4 | 2 | +--------------------------------------------------------------------------+

Syntax

Show:

Summary

Declaration

from heap.hpp:165

class Heap : private NonCopyable { public: Heap(void); void *CAlloc(size_t aCount, size_t aSize); void Free(void *aPointer); bool IsClean(void) const { Heap &self = *AsNonConst(this); const Block &super = self.BlockSuper(); const Block &first = self.BlockRight(super); return super.GetNext() == self.BlockOffset(first) && first.GetSize() == kFirstBlockSize; } size_t GetCapacity(void) const { return kFirstBlockSize; } size_t GetFreeSize(void) const { return mMemory.mFreeSize; } private: #if OPENTHREAD_CONFIG_TLS_ENABLE || OPENTHREAD_CONFIG_SECURE_TRANSPORT_ENABLE static constexpr uint16_t kMemorySize = OPENTHREAD_CONFIG_HEAP_INTERNAL_SIZE; #else static constexpr uint16_t kMemorySize = OPENTHREAD_CONFIG_HEAP_INTERNAL_SIZE_NO_DTLS; #endif static constexpr uint16_t kAlignSize = sizeof(void *); static constexpr uint16_t kBlockRemainderSize = kAlignSize - sizeof(uint16_t) * 2; static constexpr uint16_t kSuperBlockSize = kAlignSize - sizeof(Block); static constexpr uint16_t kFirstBlockSize = kMemorySize - kAlignSize * 3 + kBlockRemainderSize; static constexpr uint16_t kSuperBlockOffset = kAlignSize - sizeof(uint16_t); static constexpr uint16_t kFirstBlockOffset = kAlignSize * 2 - sizeof(uint16_t); static constexpr uint16_t kGuardBlockOffset = kMemorySize - sizeof(uint16_t); static_assert(kMemorySize % kAlignSize == 0, "The heap memory size is not aligned to kAlignSize!"); Block &BlockAt(uint16_t aOffset) { return *reinterpret_cast<Block *>(&mMemory.m16[aOffset / 2]); } Block &BlockOf(void *aPointer) { uint16_t offset = static_cast<uint16_t>(reinterpret_cast<uint8_t *>(aPointer) - mMemory.m8); offset -= sizeof(uint16_t); return BlockAt(offset); } Block &BlockSuper(void) { return BlockAt(kSuperBlockOffset); } Block &BlockNext(const Block &aBlock) { return BlockAt(aBlock.GetNext()); } Block &BlockRight(const Block &aBlock) { return BlockAt(BlockOffset(aBlock) + sizeof(Block) + aBlock.GetSize()); } Block &BlockPrev(const Block &aBlock); bool IsLeftFree(const Block &aBlock) { return (BlockOffset(aBlock) != kFirstBlockOffset && aBlock.IsLeftFree()); } uint16_t BlockOffset(const Block &aBlock) { return static_cast<uint16_t>(reinterpret_cast<const uint8_t *>(&aBlock) - mMemory.m8); } void BlockInsert(Block &aPrev, Block &aBlock); union { uint16_t mFreeSize; long mLong[kMemorySize / sizeof(long)]; uint8_t m8[kMemorySize]; uint16_t m16[kMemorySize / sizeof(uint16_t)]; } mMemory; };