mem_slab.hpp

Go to the documentation of this file.

//
// Copyright (c) 2021 Erwin Rol <erwin@erwinrol.com>
//
// SPDX-License-Identifier: Apache-2.0
//
 
#ifndef ZPP_INCLUDE_ZPP_MEM_SLAB_HPP
#define ZPP_INCLUDE_ZPP_MEM_SLAB_HPP
 
#include <zephyr/kernel.h>
#include <zephyr/sys/__assert.h>
 
#include <cstdint>
#include <chrono>
#include <array>
 
#include <zpp/utils.hpp>
 
namespace zpp {
 
template<class T_MemSlab>
class mem_slab_base {
public:
  using native_type = struct k_mem_slab;
  using native_pointer = native_type*;
  using native_const_pointer = native_type const *;
protected:
  constexpr mem_slab_base() noexcept {}
public:
  [[nodiscard]] void*
  allocate() noexcept
  {
    void* vp{nullptr};
 
    auto rc = k_mem_slab_alloc(native_handle(), &vp, K_FOREVER);
 
    if (rc == 0) {
      return vp;
    } else {
      return nullptr;
    }
  }
 
  [[nodiscard]] void*
  try_allocate() noexcept
  {
    void* vp{nullptr};
 
    auto rc = k_mem_slab_alloc(native_handle(), &vp, K_NO_WAIT);
 
    if (rc == 0) {
      return vp;
    } else {
      return nullptr;
    }
  }
 
  template<class T_Rep, class T_Period>
  [[nodiscard]] void*
  try_allocate_for(const std::chrono::duration<T_Rep, T_Period>& timeout) noexcept
  {
    using namespace std::chrono;
 
    void* vp{nullptr};
 
    auto rc = k_mem_slab_alloc(native_handle(), &vp, to_timeout(timeout));
 
    if (rc == 0) {
      return vp;
    } else {
      return nullptr;
    }
  }
 
  void deallocate(void* vp) noexcept
  {
    if (vp != nullptr) {
      k_mem_slab_free(native_handle(), &vp);
    }
  }
 
  constexpr auto block_size() const noexcept
  {
    return native_handle()->block_size;
  }
 
  constexpr auto total_block_count() const noexcept
  {
    return native_handle()->num_blocks;
  }
 
  constexpr auto used_block_count() noexcept
  {
    return k_mem_slab_num_used_get(native_handle());
  }
 
  constexpr auto free_block_count() noexcept
  {
    return k_mem_slab_num_free_get(native_handle());
  }
 
 
  auto native_handle() noexcept -> native_pointer
  {
    return static_cast<T_MemSlab*>(this)->native_handle();
  }
 
  auto native_handle() const noexcept -> native_const_pointer
  {
    return static_cast<const T_MemSlab*>(this)->native_handle();
  }
public:
  mem_slab_base(const mem_slab_base&) = delete;
  mem_slab_base(mem_slab_base&&) = delete;
  mem_slab_base& operator=(const mem_slab_base&) = delete;
  mem_slab_base& operator=(mem_slab_base&&) = delete;
};
 
 
template<uint32_t T_BlockSize, uint32_t T_BlockCount, uint32_t T_Align=sizeof(void*)>
class mem_slab : public mem_slab_base<mem_slab<T_BlockSize, T_BlockCount, T_Align>>
{
  static_assert(T_BlockCount > 0);
  static_assert(is_multiple_of(T_BlockSize, 4) == true);
  static_assert(T_Align >= sizeof(void*));
  static_assert(is_power_of_two(T_Align));
  static_assert(T_BlockSize >= T_Align);
  static_assert((T_BlockSize % T_Align) == 0);
public:
  using typename mem_slab_base<mem_slab<T_BlockSize, T_BlockCount, T_Align>>::native_type;
  using typename mem_slab_base<mem_slab<T_BlockSize, T_BlockCount, T_Align>>::native_pointer;
  using typename mem_slab_base<mem_slab<T_BlockSize, T_BlockCount, T_Align>>::native_const_pointer;
public:
  mem_slab() noexcept
  {
    k_mem_slab_init(&m_mem_slab, m_mem_buffer.data(), T_BlockSize, T_BlockCount);
  }
 
  constexpr auto native_handle() noexcept -> native_pointer
  {
    return &m_mem_slab;
  }
 
  constexpr auto native_handle() const noexcept -> native_const_pointer
  {
    return &m_mem_slab;
  }
private:
  native_type                                                       m_mem_slab{};
  alignas(T_Align) std::array<uint8_t, T_BlockSize * T_BlockCount>  m_mem_buffer;
public:
  mem_slab(const mem_slab&) = delete;
  mem_slab(mem_slab&&) = delete;
  mem_slab& operator=(const mem_slab&) = delete;
  mem_slab& operator=(mem_slab&&) = delete;
};
 
class mem_slab_ref : public mem_slab_base<mem_slab_ref> {
public:
  explicit constexpr mem_slab_ref(native_pointer m) noexcept
    : m_mem_slab_ptr(m)
  {
    __ASSERT_NO_MSG(m_mem_slab_ptr != nullptr);
  }
 
  template<class T_MemSlab>
  explicit constexpr mem_slab_ref(T_MemSlab& m) noexcept
    : m_mem_slab_ptr(m.native_handle())
  {
    __ASSERT_NO_MSG(m_mem_slab_ptr != nullptr);
  }
 
  constexpr mem_slab_ref& operator=(native_pointer m) noexcept
  {
    m_mem_slab_ptr = m;
    __ASSERT_NO_MSG(m_mem_slab_ptr != nullptr);
    return *this;
  }
 
  template<class T_MemSlab>
  constexpr mem_slab_ref& operator=(T_MemSlab& m) noexcept
  {
    m_mem_slab_ptr = m.native_handle();
    __ASSERT_NO_MSG(m_mem_slab_ptr != nullptr);
    return *this;
  }
 
  constexpr auto native_handle() noexcept -> native_pointer
  {
    return m_mem_slab_ptr;
  }
 
  constexpr auto native_handle() const noexcept -> native_const_pointer
  {
    return m_mem_slab_ptr;
  }
private:
  native_pointer m_mem_slab_ptr{ nullptr };
public:
  mem_slab_ref() = delete;
};
 
} // namespace zpp
 
#endif // ZPP_INCLUDE_ZPP_MEM_SLAB_HPP