memory.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: Apache-2.0
// Copyright 2026 Chris Leishman
 
#pragma once
 
#include <cstddef>
#include <cstdint>
#include <esp_heap_caps.h>
#include <esp_system.h>
#include <new>
 
namespace idfxx {
 
enum class memory_type : uint32_t {
    internal = MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT, 
    spiram = MALLOC_CAP_SPIRAM,                       
};
 
template<typename T>
struct dram_allocator {
    using value_type = T; 
    dram_allocator() = default;
 
    template<typename U>
    constexpr dram_allocator(const dram_allocator<U>&) noexcept {}
 
    [[nodiscard]] T* allocate(size_t n) {
        void* p = heap_caps_malloc(n * sizeof(T), MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT);
        if (!p) {
#ifdef CONFIG_COMPILER_CXX_EXCEPTIONS
            throw std::bad_alloc();
#else
            esp_system_abort("dram_allocator: allocation failed");
#endif
        }
        return static_cast<T*>(p);
    }
 
    void deallocate(T* p, size_t) noexcept { heap_caps_free(p); }
};
 
template<typename T, typename U>
bool operator==(const dram_allocator<T>&, const dram_allocator<U>&) {
    return true;
}
 
template<typename T, typename U>
bool operator!=(const dram_allocator<T>&, const dram_allocator<U>&) {
    return false;
}
 
template<typename T>
struct spiram_allocator {
    using value_type = T; 
    spiram_allocator() = default;
 
    template<typename U>
    constexpr spiram_allocator(const spiram_allocator<U>&) noexcept {}
 
    [[nodiscard]] T* allocate(size_t n) {
        void* p = heap_caps_malloc(n * sizeof(T), MALLOC_CAP_SPIRAM);
        if (!p) {
#ifdef CONFIG_COMPILER_CXX_EXCEPTIONS
            throw std::bad_alloc();
#else
            esp_system_abort("spiram_allocator: allocation failed");
#endif
        }
        return static_cast<T*>(p);
    }
 
    void deallocate(T* p, size_t) noexcept { heap_caps_free(p); }
};
 
template<typename T, typename U>
bool operator==(const spiram_allocator<T>&, const spiram_allocator<U>&) {
    return true;
}
 
template<typename T, typename U>
bool operator!=(const spiram_allocator<T>&, const spiram_allocator<U>&) {
    return false;
}
 
template<typename T>
struct dma_allocator {
    using value_type = T; 
    dma_allocator() = default;
 
    template<typename U>
    constexpr dma_allocator(const dma_allocator<U>&) noexcept {}
 
    [[nodiscard]] T* allocate(size_t n) {
        void* p = heap_caps_malloc(n * sizeof(T), MALLOC_CAP_DMA);
        if (!p) {
#ifdef CONFIG_COMPILER_CXX_EXCEPTIONS
            throw std::bad_alloc();
#else
            esp_system_abort("dma_allocator: allocation failed");
#endif
        }
        return static_cast<T*>(p);
    }
 
    void deallocate(T* p, size_t) noexcept { heap_caps_free(p); }
};
 
template<typename T, typename U>
bool operator==(const dma_allocator<T>&, const dma_allocator<U>&) {
    return true;
}
 
template<typename T, typename U>
bool operator!=(const dma_allocator<T>&, const dma_allocator<U>&) {
    return false;
}
 
 
} // namespace idfxx