utility.hpp

Go to the documentation of this file.

/* SPDX-License-Identifier: Apache-2.0 */
/* Copyright 2015-2019 Peter A. Bigot */
 
#ifndef NRFCXX_UTILITY_HPP
#define NRFCXX_UTILITY_HPP
#pragma once
 
#include <nrfcxx/core.hpp>
#include <type_traits>
#include <array>
#include <limits>
 
extern "C" {
  extern const uint32_t __PersistBase;
  extern const uint32_t __PersistLimit;
}
namespace nrfcxx {
 
namespace utility {
 
template <unsigned int ALIGN_BITS = 2>
class memory_pool {
  static constexpr size_t ignore_mask{(1U << ALIGN_BITS) - 1};
 
  static constexpr uintptr_t align_mask = ~static_cast<uintptr_t>(ignore_mask);
 
public:
  using pool_type = memory_pool<ALIGN_BITS>;
 
  static constexpr unsigned int align_bits = ALIGN_BITS;
 
  class scoped {
  public:
    ~scoped ()
    {
      pool_.clear();
    }
 
  protected:
    friend memory_pool;
    scoped (pool_type& pool) :
      pool_{pool}
    { }
 
    scoped (const scoped&) = delete;
    scoped& operator= (const scoped&) = delete;
    scoped (scoped&&) = delete;
    scoped& operator= (scoped&) = delete;
  private:
    pool_type& pool_;
  };
 
  scoped make_scoped ()
  {
    if (size()) {
      failsafe(code_);
    }
    return {*this};
  }
 
  constexpr memory_pool () :
    begin_{},
    end_{},
    head_{},
    code_{static_cast<unsigned int>(FailSafeCode::MEMORY_POOL)}
  { }
 
  memory_pool (const memory_pool&) = delete;
  memory_pool& operator= (const memory_pool&) = delete;
  memory_pool (memory_pool&&) = delete;
  memory_pool& operator= (memory_pool&&) = delete;
  void configure (void* begin,
                  void* end,
                  unsigned int code = FailSafeCode::MEMORY_POOL)
  {
    if (begin_) {
      failsafe(code_);
    }
    code_ = code;
 
    /* The region begins at the aligned address no less than the
     * provided address. */
    begin_ = reinterpret_cast<unsigned char*>(align_mask & (ignore_mask + reinterpret_cast<uintptr_t>(begin)));
 
    /* The region ends at the aligned address no greater than the
     * provided address. */
    end_ = reinterpret_cast<unsigned char*>(align_mask & reinterpret_cast<uintptr_t>(end));
 
    /* If somebody does something stupid, including configuring an
     * empty region, failsafe. */
    if (end_ <= begin_) {
      failsafe(code_);
    }
    head_ = begin_;
  }
 
  void clear ()
  {
    head_ = begin_;
  }
 
  size_t capacity () const
  {
    return (end_ - begin_);
  }
 
  size_t size () const
  {
    return (head_ - begin_);
  }
 
  size_t available () const
  {
    return (end_ - head_);
  }
 
  void* allocate (size_t span)
  {
    /* Increase the span so all pointers are aligned. */
    span = align_mask & (span + ignore_mask);
    if ((!head_) || ((head_ + span) > end_)) {
      failsafe(code_);
    }
    void* rv = reinterpret_cast<void *>(head_);
    head_ += span;
    return rv;
  }
 
private:
  /* Pointer to the aligned start of the configured region. */
  unsigned char* begin_;
 
  /* Pointer to the aligned address just past the start of the
   * unallocated portion of the configured region. */
  unsigned char* end_;
 
  /* Pointer to the aligned start of the unallocated portion of the
   * configured region. */
  unsigned char* head_;
 
  /* The code to be used in the failsafe reset if allocation fails. */
  unsigned int code_;
};
 
namespace internal {
 
/* Generic API underlying display_data */
template <typename T>
void display_data (const T* dp,
                   size_t count,
                   uintptr_t base);
 
/* Known specialization for octets.  ASCII values are displayed in
 * right column. */
template <>
void display_data<uint8_t> (const uint8_t* dp,
                            size_t count,
                            uintptr_t base);
 
/* Known specialization for words. */
template <>
void display_data<uint32_t> (const uint32_t* dp,
                             size_t count,
                             uintptr_t base);
 
} // namespace internal
template <typename T>
inline void display_data (const T* dp,
                          size_t count,
                          uintptr_t base)
{
  using base_type = typename std::remove_volatile<T>::type;
  internal::display_data(const_cast<const base_type*>(dp), count, base);
}
 
class Persist {
public:
 
  static constexpr uint16_t TAG_ERASED = 0;
 
  static constexpr uint16_t TAG_UNUSED = 0xFFFF;
 
  static constexpr const uint32_t* REGION_BEGIN = &__PersistBase;
 
  static constexpr const uint32_t* REGION_END = &__PersistLimit;
 
  struct header_type {
    uint16_t span;
 
    uint16_t tag;
 
    uint8_t data[0];
 
    const header_type* next () const
    {
      /* By construction `span` cannot be zero. */
      static_assert(sizeof(*this) == sizeof(uint32_t),
                    "header is too big");
      return this + span;
    }
  };
 
#if (51 == NRF_SERIES) || (NRFCXX_DOXYGEN - 0)
 
  static constexpr unsigned int PAGE_SIZE = 1024;
 
  static constexpr unsigned int BLOCK_SIZE = PAGE_SIZE;
#elif (52 == NRF_SERIES)
  static constexpr unsigned int PAGE_SIZE = 4096;
  static constexpr unsigned int BLOCK_SIZE = 512;
#endif
 
  constexpr Persist (FailSafeCode code = FailSafeCode::PERSIST_VIOLATION) :
    code_{code},
    begin_{},
    end_{},
    first_{},
    unused_{},
    erased_{}
  { }
 
  constexpr Persist (unsigned int code) :
    Persist(static_cast<FailSafeCode>(code))
  { }
 
  Persist (const Persist&) = delete;
  Persist& operator= (const Persist&) = delete;
  Persist (Persist&& ) = delete;
  Persist& operator= (Persist&) = delete;
  int configure (const uint32_t* begin,
                 const uint32_t* end);
 
  const header_type* find (uint16_t tag)
  {
    return find_(tag);
  }
 
  int erase (uint16_t tag)
  {
    int rv{-1};
    const header_type* hp{find_(tag)};
    if (hp) {
      erase_(hp);
      rv = 0;
    }
    return rv;
  }
 
  const header_type* addReplace (uint16_t tag,
                                  const void* data,
                                  size_t count);
 
  ptrdiff_t extract (header_type* buffer = nullptr,
                     size_t length = 0) const;
 
  int restore (const header_type* buffer,
               size_t length);
 
  int gc ();
 
  bool is_cleared () const
  {
    return begin_ && (TAG_UNUSED == begin_->tag);
  }
 
  size_t available () const
  {
    size_t rv{};
    if (unused_) {
      rv = (end_ - unused_ - 1) * sizeof(*unused_);
    }
    return rv;
  }
 
  size_t erased () const
  {
    return erased_ * sizeof(uint32_t);
  }
 
  void clear ();
 
protected:
  void erase_ (const header_type* hp);
 
  const header_type* find_ (uint16_t tag);
 
  const FailSafeCode code_;
 
  const header_type* begin_;
 
  const header_type* end_;
 
  const header_type* first_;
 
  const header_type* unused_;
 
  unsigned int erased_;
};
 
} // namespace utility
} // namespace nrfcxx
 
#endif /* NRFCXX_UTILITY_HPP */