Adds memory_resource

Simple memory resource class enabling the usage of C++17 PMR facilities
with IDF heap allocation capabilities.

Author: euripedesrocha

CMakeLists.txt

@@ -1,6 +1,6 @@
 idf_build_get_property(target IDF_TARGET)
 
-set(srcs "esp_timer_cxx.cpp" "esp_exception.cpp" "gpio_cxx.cpp" "i2c_cxx.cpp" "spi_cxx.cpp" "spi_host_cxx.cpp")
+set(srcs "esp_timer_cxx.cpp" "esp_exception.cpp" "gpio_cxx.cpp" "i2c_cxx.cpp" "spi_cxx.cpp" "spi_host_cxx.cpp" "esp_memory_resource.cpp")
 set(requires "esp_timer")
 
 if(NOT ${target} STREQUAL "linux")

esp_memory_resource.cpp

@@ -0,0 +1,29 @@
+#include "esp_memory_resource.hpp"
+#include "esp_log.h"
+#include <utility>
+
+namespace idf::memory {
+
+
+void * resource::do_allocate(size_t bytes, size_t alignment)
+{
+
+    if(auto *mem = heap_caps_aligned_alloc(alignment, bytes, std::to_underlying(cap)); mem != nullptr) {
+        ESP_LOGD(tag, "Allocated %d bytes at %p", bytes, mem);
+        return mem;
+    }
+        ESP_LOGD(tag, "Failed to get memory from resource, allocating from upstream");
+    return upstream->allocate(bytes, alignment);
+
+}
+void resource::do_deallocate(void *ptr, [[maybe_unused]] size_t bytes, [[maybe_unused]]  size_t alignment)  {
+    free(ptr);
+    ESP_LOGD(tag, "Freed");
+}
+
+[[nodiscard]] bool resource::do_is_equal(const memory_resource &other) const noexcept
+{
+    return this == &other;
+}
+
+}

examples/memory_resource/CMakeLists.txt

@@ -0,0 +1,9 @@
+# For more information about build system see
+# https://docs.espressif.com/projects/esp-idf/en/latest/api-guides/build-system.html
+# The following five lines of boilerplate have to be in your project's
+# CMakeLists in this exact order for cmake to work correctly
+cmake_minimum_required(VERSION 3.16)
+
+include($ENV{IDF_PATH}/tools/cmake/project.cmake)
+set(COMPONENTS main)
+project(memory_resource)

examples/memory_resource/main/CMakeLists.txt

@@ -0,0 +1,4 @@
+
+idf_component_register(SRCS "resource.cpp"
+                    INCLUDE_DIRS "."
+                    )

examples/memory_resource/main/idf_component.yml

@@ -0,0 +1,8 @@
+## IDF Component Manager Manifest File
+dependencies:
+  idf:
+    version: ">=5.0"
+  espressif/esp-idf-cxx:
+    override_path: ../../../
+    version: "^1.0.0"
+

examples/memory_resource/main/resource.cpp

@@ -0,0 +1,21 @@
+#include <utility>
+#include "esp_memory_resource.hpp"
+#include "esp_heap_caps.h"
+#include "esp_log.h"
+#include "esp_system.h"
+
+constexpr auto TAG = "Example";
+extern "C" void app_main(void)
+{
+    ESP_LOGI(TAG, "[APP] Startup..");
+    ESP_LOGI(TAG, "[APP] Free memory: %" PRIu32 " bytes", esp_get_free_heap_size());
+    ESP_LOGI(TAG, "[APP] IDF version: %s", esp_get_idf_version());
+
+    esp_log_level_set("*", ESP_LOG_INFO);
+    esp_log_level_set(idf::memory::resource::tag, ESP_LOG_VERBOSE);
+    auto memory_source = idf::memory::capabilities::dma;
+    auto res = idf::memory::resource{memory_source};
+    std::pmr::vector<std::byte> data{&res};
+    data.reserve(2048);
+    heap_caps_print_heap_info(std::to_underlying(memory_source));
+}

idf_component.yml

@@ -3,4 +3,4 @@ dependencies:
     version: '>=5.0'
 description: C++ wrapper classes around ESP IDF components
 url: https://github.com/espressif/esp-idf-cxx
-version: 1.0.0
+version: 1.1.0

include/esp_memory_resource.hpp

@@ -0,0 +1,54 @@
+#pragma once
+
+#include <memory_resource>
+#include <utility>
+#include "esp_heap_caps.h"
+
+namespace idf::memory {
+
+/**
+ * Memory capabilities for memory allocation
+ *
+ * Refer to IDF documentation on memory allocation for the usage of each of them.
+ */
+enum class capabilities : uint32_t {
+    not_specified = MALLOC_CAP_DEFAULT,
+    adressable_8bit = MALLOC_CAP_8BIT,
+    adressable_32bit = MALLOC_CAP_32BIT,
+    dma = MALLOC_CAP_DMA,
+    executable = MALLOC_CAP_EXEC,
+    from_spiram = MALLOC_CAP_SPIRAM,
+    internal = MALLOC_CAP_INTERNAL,
+    retention_dma = MALLOC_CAP_RETENTION,
+    rtc = MALLOC_CAP_RTCRAM
+};
+
+constexpr capabilities operator|(const capabilities lhs, const capabilities rhs)
+{
+    return capabilities{std::to_underlying(lhs) | std::to_underlying(rhs)};
+}
+
+/**
+* @brief Memory resource to be used with polymorphic allocators
+*/
+class resource : public std::pmr::memory_resource {
+public:
+    static constexpr auto tag = "esp_memory_resource";
+    /**
+    * Construct a resource with the selected capabilities and upstream resource.
+    *
+    * @param cap capabilities to use in this allocator. Refer to idf memory allocation documentation to understand the effects. Default: capabilities::not_specified
+    * @param upstream memory resource to use when allocation fails. It can be used to compose memory resources. Default: default resource.
+    */
+    explicit resource(capabilities cap=capabilities::not_specified, std::pmr::memory_resource * upstream = std::pmr::get_default_resource()) : cap(cap), upstream(upstream) {}
+
+private:
+    void * do_allocate(size_t bytes, [[maybe_unused]] size_t alignment) override;
+    void do_deallocate(void *ptr, size_t bytes, size_t alignment) override;
+    [[nodiscard]] bool do_is_equal(const memory_resource &other) const noexcept override;
+    capabilities cap;
+    std::pmr::memory_resource * upstream;
+};
+
+
+}