update to 1.7.0

lib/espMqttClient/src/MemoryPool/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Bert Melis
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

lib/espMqttClient/src/MemoryPool/README.md

@@ -0,0 +1,105 @@
+# Memory Pool
+
+EARLY VERSION. USE AT OWN RISK.
+
+### Description
+
+This is a simple memory pool that doesn't solve the fragmentation problem but contains it. Inside the pool you will still suffer memory fragmentation. The upside is that you're not restricted on memory size. As long as it fits in the pool, you can request any size!
+
+For applications where the (maximum) size to allocate is known, a simple fixed block size memory pool is available. There is no memory fragmentation happening in this case. The downside is wastage of memory if you need less then the specified blocksize.
+
+#### Features
+
+- pool memory is statically allocated
+- pool size adjusts on architecture
+- no size calculation required: input number of blocks and size of block
+- header-only library
+- Variable size pool: no restriction on allocated size
+- Variable size pool: malloc and free are O(n); The number of allocated blocks affects lookup.
+- Fixed size pool: malloc and free are O(1).
+
+[![Test with Platformio](https://github.com/bertmelis/MemoryPool/actions/workflows/test-platformio.yml/badge.svg)](https://github.com/bertmelis/MemoryPool/actions/workflows/test-platformio.yml)
+[![cpplint](https://github.com/bertmelis/MemoryPool/actions/workflows/cpplint.yml/badge.svg)](https://github.com/bertmelis/MemoryPool/actions/workflows/cpplint.yml)
+<!---[![cppcheck](https://github.com/bertmelis/MemoryPool/actions/workflows/cppcheck.yml/badge.svg)](https://github.com/bertmelis/MemoryPool/actions/workflows/cppcheck.yml)--->
+
+### Usage
+
+#### Variable size pool
+
+```cpp
+#include <MemoryPool.h>
+
+Struct MyStruct {
+  unsigned int id;
+  std::size_t size;
+  unsigned char data[256];
+};
+
+// pool will be able to hold 10 blocks the size of MyStruct
+MemoryPool::Variable<10, sizeof(MyStruct)> pool;
+
+// you can allocate the specified blocksize
+// allocation is done in number of 'unsigned char'
+MyStruct* s = reinterpret_cast<MyStruct*>(pool.malloc(sizeof(MyStruct)));
+
+// you can allocate less than the specified blocksize
+int* i = reinterpret_cast<int*>(pool.malloc(sizeof(int)));
+
+// you can allocate more than the specified blocksize
+unsigned char* m = reinterpret_cast<unsigned char*>(pool.malloc(400));
+
+pool.free(s);
+pool.free(i);
+pool.free(m);
+```
+
+#### Fixed size pool
+
+```cpp
+#include <MemoryPool.h>
+
+Struct MyStruct {
+  unsigned int id;
+  std::size_t size;
+  unsigned char data[256];
+};
+
+// pool will be able to hold 10 blocks the size of MyStruct
+MemoryPool::Fixed<10, sizeof(MyStruct)> pool;
+
+// there is no size argument in the malloc function!
+MyStruct* s = reinterpret_cast<MyStruct*>(pool.malloc());
+
+// you can allocate less than the specified blocksize
+int* i = reinterpret_cast<int*>(pool.malloc());
+
+pool.free(s);
+pool.free(i);
+```
+
+#### How it works
+
+##### Variable size pool
+
+Free blocks are organized as a linked list with their header (contains pointer to next and size). An allocated block also has this header with it's pointer set to `nullptr`. Therefore, each allocation wastes memory the size of the header (`sizeof(void*) + sizeof(std::size_t)`). On creation, the pool calculations the needed space to store the number of blocks wich each their header.
+
+However, memory allocation isn't restricted the the specified blocksize. So in reality, you can allocate more if you allocate larger chunks because less memory blocks means less headers. After all, memory needs to be contiguous.
+
+If you inspect the pool you'll see that a free pool only has one big block.
+
+Allocation is linear: the pool is iterated until a suitable spot is found.
+Freeing is also linear as the pool is traversed to insert the chunk in the linked list of free blocks
+
+When freeing, free blocks which are adjacent are combined into one.
+
+##### Fixed size pool
+
+The fixed size pool is implemented as an array. Free blocks are saved as a linked list in this array.
+
+### Bugs and feature requests
+
+Please use Github's facilities to get in touch.
+
+### License
+
+This library is released under the MIT Licence. A copy is included in the repo.

lib/espMqttClient/src/MemoryPool/keywords.txt

@@ -0,0 +1,16 @@
+# Datatypes (KEYWORD1)
+Fixed	KEYWORD1
+Variable	KEYWORD1
+
+# Methods and Functions (KEYWORD2)
+malloc	KEYWORD2
+free	KEYWORD2
+freeMemory	KEYWORD2
+maxBlockSize	KEYWORD2
+print	KEYWORD2
+
+# Structures (KEYWORD3)
+# structure	KEYWORD3
+
+# Constants (LITERAL1)
+MemoryPool	LITERAL1

lib/espMqttClient/src/MemoryPool/library.json

@@ -0,0 +1,21 @@
+{
+    "name": "MemoryPool",
+    "keywords": "memory",
+    "description": "A simple memory pool for fixed and variable sizes",
+    "authors":
+    {
+      "name": "Bert Melis",
+      "url": "https://github.com/bertmelis"
+    },
+    "license": "MIT",
+    "homepage": "https://github.com/bertmelis/MemoryPool",
+    "repository":
+    {
+      "type": "git",
+      "url": "https://github.com/bertmelis/MemoryPool.git"
+    },
+    "version": "0.1.0",
+    "frameworks": "*",
+    "platforms": "*",
+    "headers": ["MemoryPool.h"]
+  }

lib/espMqttClient/src/MemoryPool/library.properties

@@ -0,0 +1,10 @@
+name=MemoryPool
+version=0.1.0
+author=Bert Melis
+maintainer=Bert Melis
+sentence=A simple memory pool for fixed and variable sizes
+paragraph=
+category=Other
+url=https://github.com/bertmelis/MemoryPool
+architectures=*
+includes=MemoryPool.h

lib/espMqttClient/src/MemoryPool/src/Fixed.h

@@ -0,0 +1,119 @@
+/*
+Copyright (c) 2024 Bert Melis. All rights reserved.
+
+This work is licensed under the terms of the MIT license.  
+For a copy, see <https://opensource.org/licenses/MIT> or
+the LICENSE file.
+*/
+
+#pragma once
+
+#include <cstddef>  // std::size_t
+#include <cassert>  // assert
+#if _GLIBCXX_HAS_GTHREADS
+#include <mutex>  // NOLINT [build/c++11] std::mutex, std::lock_guard
+#else
+#warning "The memory pool is not thread safe"
+#endif
+
+#ifdef MEMPOL_DEBUG
+#include <iostream>
+#endif
+
+namespace MemoryPool {
+
+template <std::size_t nrBlocks, std::size_t blocksize>
+class Fixed {
+ public:
+  Fixed()  // cppcheck-suppress uninitMemberVar
+  : _buffer{0}
+  , _head(_buffer) {
+    unsigned char* b = _head;
+    std::size_t adjustedBlocksize = sizeof(std::size_t) > blocksize ? sizeof(std::size_t) : blocksize;
+    for (std::size_t i = 0; i < nrBlocks - 1; ++i) {
+      *reinterpret_cast<unsigned char**>(b) = b + adjustedBlocksize;
+      b += adjustedBlocksize;
+    }
+    *reinterpret_cast<unsigned char**>(b) = nullptr;
+  }
+
+  // no copy nor move
+  Fixed (const Fixed&) = delete;
+  Fixed& operator= (const Fixed&) = delete;
+
+  void* malloc() {
+    #if _GLIBCXX_HAS_GTHREADS
+    const std::lock_guard<std::mutex> lockGuard(_mutex);
+    #endif
+    if (_head) {
+      void* retVal = _head;
+      _head = *reinterpret_cast<unsigned char**>(_head);
+      return retVal;
+    }
+    return nullptr;
+  }
+
+  void free(void* ptr) {
+    if (!ptr) return;
+    #if _GLIBCXX_HAS_GTHREADS
+    const std::lock_guard<std::mutex> lockGuard(_mutex);
+    #endif
+    *reinterpret_cast<unsigned char**>(ptr) = _head;
+    _head = reinterpret_cast<unsigned char*>(ptr);
+  }
+
+  std::size_t freeMemory() {
+    #if _GLIBCXX_HAS_GTHREADS
+    const std::lock_guard<std::mutex> lockGuard(_mutex);
+    #endif
+    unsigned char* i = _head;
+    std::size_t retVal = 0;
+    while (i) {
+      retVal += blocksize;
+      i = reinterpret_cast<unsigned char**>(i)[0];
+    }
+    return retVal;
+  }
+
+  #ifdef MEMPOL_DEBUG
+  void print() {
+    std::size_t adjustedBlocksize = sizeof(std::size_t) > blocksize ? sizeof(std::size_t) : blocksize;
+    std::cout << "+--------------------" << std::endl;
+    std::cout << "|start:" << reinterpret_cast<void*>(_buffer) << std::endl;
+    std::cout << "|blocks:" << nrBlocks << std::endl;
+    std::cout << "|blocksize:" << adjustedBlocksize << std::endl;
+    std::cout << "|head: " << reinterpret_cast<void*>(_head) << std::endl;
+    unsigned char* currentBlock = _buffer;
+
+    for (std::size_t i = 0; i < nrBlocks; ++i) {
+      std::cout << "|" << i + 1 << ": " << reinterpret_cast<void*>(currentBlock) << std::endl;
+      if (_isFree(currentBlock)) {
+        std::cout << "|   free" << std::endl;
+        std::cout << "|   next: " << reinterpret_cast<void*>(*reinterpret_cast<unsigned char**>(currentBlock)) << std::endl;
+      } else {
+        std::cout << "|   allocated" << std::endl;
+      }
+      currentBlock += adjustedBlocksize;
+    }
+    std::cout << "+--------------------" << std::endl;
+  }
+
+  bool _isFree(const unsigned char* ptr) {
+    unsigned char* b = _head;
+    while (b) {
+      if (b == ptr) return true;
+      b = *reinterpret_cast<unsigned char**>(b);
+    }
+    return false;
+  }
+  #endif
+
+ private:
+  unsigned char _buffer[nrBlocks * (sizeof(std::size_t) > blocksize ? sizeof(std::size_t) : blocksize)];
+  unsigned char* _head;
+  #if _GLIBCXX_HAS_GTHREADS
+  std::mutex _mutex;
+  #endif
+};
+
+}  // end namespace MemoryPool

lib/espMqttClient/src/MemoryPool/src/MemoryPool.h

@@ -0,0 +1,12 @@
+/*
+Copyright (c) 2024 Bert Melis. All rights reserved.
+
+This work is licensed under the terms of the MIT license.  
+For a copy, see <https://opensource.org/licenses/MIT> or
+the LICENSE file.
+*/
+
+#pragma once
+
+#include "Variable.h"
+#include "Fixed.h"

lib/espMqttClient/src/MemoryPool/src/Variable.h

@@ -0,0 +1,242 @@
+/*
+Copyright (c) 2024 Bert Melis. All rights reserved.
+
+This work is licensed under the terms of the MIT license.  
+For a copy, see <https://opensource.org/licenses/MIT> or
+the LICENSE file.
+*/
+
+#pragma once
+
+#include <cstddef>  // std::size_t
+#include <cassert>  // assert
+#if _GLIBCXX_HAS_GTHREADS
+#include <mutex>  // NOLINT [build/c++11] std::mutex, std::lock_guard
+#else
+#warning "The memory pool is not thread safe"
+#endif
+
+#ifdef MEMPOL_DEBUG
+#include <iostream>
+#endif
+
+namespace MemoryPool {
+
+template <std::size_t nrBlocks, std::size_t blocksize>
+class Variable {
+ public:
+  Variable()
+    : _buffer{0}
+    , _head(nullptr)
+    #ifdef MEMPOL_DEBUG
+    , _bufferSize(0)
+    #endif
+      {
+      std::size_t _normBlocksize = blocksize / sizeof(BlockHeader) + ((blocksize % sizeof(BlockHeader)) ? 1 : 0);
+      size_t nrBlocksToAlloc = nrBlocks * (_normBlocksize + 1);
+      BlockHeader* h = reinterpret_cast<BlockHeader*>(_buffer);
+      h->next = nullptr;
+      h->size = nrBlocksToAlloc;
+      _head = h;
+
+      #ifdef MEMPOL_DEBUG
+      _bufferSize = nrBlocksToAlloc;
+      #endif
+    }
+
+  // no copy nor move
+  Variable (const Variable&) = delete;
+  Variable& operator= (const Variable&) = delete;
+
+  void* malloc(size_t size) {
+    #if _GLIBCXX_HAS_GTHREADS
+    const std::lock_guard<std::mutex> lockGuard(_mutex);
+    #endif
+    if (size == 0) return nullptr;
+
+    size = (size / sizeof(BlockHeader) + (size % sizeof(BlockHeader) != 0)) + 1;  // count by BlockHeader size, add 1 for header
+
+    #ifdef MEMPOL_DEBUG
+    std::cout << "malloc (raw) " << size << std::endl;
+    std::cout << "malloc (adj) " << size << " - ";
+    #endif
+
+    BlockHeader* currentBlock = _head;
+    BlockHeader* previousBlock = nullptr;
+    void* retVal = nullptr;
+
+    // iterate through linked free blocks
+    while (currentBlock) {
+      // consume whole block is size equals required size
+      if (currentBlock->size == size) {
+        if (previousBlock) previousBlock->next = currentBlock->next;
+        break;
+
+      // split block if size is larger and add second part to list of free blocks
+      } else if (currentBlock->size > size) {
+        BlockHeader* newBlock = currentBlock + size;
+        if (previousBlock) previousBlock->next = newBlock;
+        newBlock->next = currentBlock->next;
+        newBlock->size = currentBlock->size - size;
+        currentBlock->next = newBlock;
+        break;
+      }
+      previousBlock = currentBlock;
+      currentBlock = currentBlock->next;
+    }
+
+    if (currentBlock) {
+      if (currentBlock == _head) {
+        _head = currentBlock->next;
+      }
+      currentBlock->size = size;
+      currentBlock->next = nullptr;  // used when freeing memory
+      retVal = currentBlock + 1;
+      #ifdef MEMPOL_DEBUG
+      std::cout << "ok" << std::endl;
+      #endif
+    } else {
+      #ifdef MEMPOL_DEBUG
+      std::cout << "nok" << std::endl;
+      #endif
+      (void)0;
+    }
+
+    return retVal;
+  }
+
+  void free(void* ptr) {
+    if (!ptr) return;
+    // check if ptr points to region in _buffer
+
+    #ifdef MEMPOL_DEBUG
+    std::cout << "free " << static_cast<void*>(reinterpret_cast<BlockHeader*>(ptr) - 1) << std::endl;
+    #endif
+
+    #if _GLIBCXX_HAS_GTHREADS
+    const std::lock_guard<std::mutex> lockGuard(_mutex);
+    #endif
+
+    BlockHeader* toFree = reinterpret_cast<BlockHeader*>(ptr) - 1;
+    BlockHeader* previous = reinterpret_cast<BlockHeader*>(_buffer);
+    BlockHeader* next = _head;
+
+    // toFree is the only free block
+    if (!next) {
+      _head = toFree;
+      return;
+    }
+
+    while (previous) {
+      if (!next || toFree < next) {
+        // 1. add block to linked list of free blocks
+        if (toFree < _head) {
+          toFree->next = _head;
+          _head = toFree;
+        } else {
+          previous->next = toFree;
+          toFree->next = next;
+        }
+
+        // 2. merge with previous if adjacent
+        if (toFree > _head && toFree == previous + previous->size) {
+          previous->size += toFree->size;
+          previous->next = toFree->next;
+          toFree = previous;  // used in next check
+        }
+
+        // 3. merge with next if adjacent
+        if (toFree + toFree->size == next) {
+          toFree->size += next->size;
+          toFree->next = next->next;
+        }
+
+        // 4. done
+        return;
+      }
+      previous = next;
+      next = next->next;
+    }
+  }
+
+  std::size_t freeMemory() {
+    #if _GLIBCXX_HAS_GTHREADS
+    const std::lock_guard<std::mutex> lockGuard(_mutex);
+    #endif
+    size_t retVal = 0;
+    BlockHeader* currentBlock = reinterpret_cast<BlockHeader*>(_head);
+
+    while (currentBlock) {
+      retVal += currentBlock->size - 1;
+      currentBlock = currentBlock->next;
+    }
+
+    return retVal * sizeof(BlockHeader);
+  }
+
+  std::size_t maxBlockSize() {
+    #if _GLIBCXX_HAS_GTHREADS
+    const std::lock_guard<std::mutex> lockGuard(_mutex);
+    #endif
+    size_t retVal = 0;
+    BlockHeader* currentBlock = reinterpret_cast<BlockHeader*>(_head);
+
+    while (currentBlock) {
+      retVal = (currentBlock->size - 1 > retVal) ? currentBlock->size - 1 : retVal;
+      currentBlock = currentBlock->next;
+    }
+
+    return retVal * sizeof(BlockHeader);
+  }
+
+  #ifdef MEMPOL_DEBUG
+  void print() {
+    std::cout << "+--------------------" << std::endl;
+    std::cout << "|start:" << static_cast<void*>(_buffer) << std::endl;
+    std::cout << "|size:" << _bufferSize << std::endl;
+    std::cout << "|headersize:" << sizeof(BlockHeader) << std::endl;
+    std::cout << "|head: " << static_cast<void*>(_head) << std::endl;
+    BlockHeader* nextFreeBlock = _head;
+    BlockHeader* currentBlock = reinterpret_cast<BlockHeader*>(_buffer);
+    size_t blockNumber = 1;
+    while (currentBlock < reinterpret_cast<BlockHeader*>(_buffer) + _bufferSize) {
+      std::cout << "|" << blockNumber << ": " << static_cast<void*>(currentBlock) << std::endl;
+      std::cout << "|   " << static_cast<void*>(currentBlock->next) << std::endl;
+      std::cout << "|   " << currentBlock->size << std::endl;
+      if (currentBlock == nextFreeBlock) {
+        std::cout << "|   free" << std::endl;
+        nextFreeBlock = nextFreeBlock->next;
+      } else {
+        std::cout << "|   allocated" << std::endl;
+      }
+      ++blockNumber;
+      currentBlock += currentBlock->size;
+    }
+    std::cout << "+--------------------" << std::endl;
+  }
+  #endif
+
+ private:
+  struct BlockHeader {
+    BlockHeader* next;
+    std::size_t size;
+  };
+  /*
+  pool size is aligned to sizeof(BlockHeader).
+  requested blocksize is therefore multiple of blockheader (rounded up)
+  total size = nr requested blocks * multiplier * blockheadersize
+
+  see constructor for calculation
+  */
+  unsigned char _buffer[(nrBlocks * ((blocksize / sizeof(BlockHeader) + ((blocksize % sizeof(BlockHeader)) ? 1 : 0)) + 1)) * sizeof(BlockHeader)];
+  BlockHeader* _head;
+  #if _GLIBCXX_HAS_GTHREADS
+  std::mutex _mutex;
+  #endif
+
+  #ifdef MEMPOL_DEBUG
+  std::size_t _bufferSize;
+  #endif
+};
+
+}  // end namespace MemoryPool