Malloc.hxx

Go to the documentation of this file.

/*--------------------------------------------------------------------------*\
 |                                                                          |
 |  Copyright (C) 2020                                                      |
 |                                                                          |
 |         , __                 , __                                        |
 |        /|/  \               /|/  \                                       |
 |         | __/ _   ,_         | __/ _   ,_                                |
 |         |   \|/  /  |  |   | |   \|/  /  |  |   |                        |
 |         |(__/|__/   |_/ \_/|/|(__/|__/   |_/ \_/|/                       |
 |                           /|                   /|                        |
 |                           \|                   \|                        |
 |                                                                          |
 |      Enrico Bertolazzi                                                   |
 |      Dipartimento di Ingegneria Industriale                              |
 |      Università degli Studi di Trento                                    |
 |      email: enrico.bertolazzi@unitn.it                                   |
 |                                                                          |
\*--------------------------------------------------------------------------*/
 
//
// file: Malloc.hxx
//
 
/*\
:|:    ____            _       _             __
:|:   / ___| _     _  (_)_ __ | |_ ___ _ __ / _| __ _  ___ ___
:|:  | |   _| |_ _| |_| | '_ \| __/ _ \ '__| |_ / _` |/ __/ _ \
:|:  | |__|_   _|_   _| | | | | ||  __/ |  |  _| (_| | (_|  __/
:|:   \____||_|   |_| |_|_| |_|\__\___|_|  |_|  \__,_|\___\___|
\*/
 
namespace Utils {

 
  #ifndef DOXYGEN_SHOULD_SKIP_THIS
  using std::int64_t;
  using std::string;
  using std::mutex;
  using std::size_t;
  #endif

  extern std::mutex MallocMutex;

  extern int64_t CountAlloc;
  extern int64_t CountFreed;
  extern int64_t AllocatedBytes;
  extern int64_t MaximumAllocatedBytes;
  extern bool    MallocDebug;


  string out_bytes( size_t nb );
 
  /*\
  :|:   __  __       _ _
  :|:  |  \/  | __ _| | | ___   ___
  :|:  | |\/| |/ _` | | |/ _ \ / __|
  :|:  | |  | | (_| | | | (_) | (__
  :|:  |_|  |_|\__,_|_|_|\___/ \___|
  \*/


  template <typename T>
  class Malloc {
  public:
    using valueType = T;
 
  private:
 
    string m_name;                   
    size_t m_num_total_values{0};    
    size_t m_num_total_reserved{0};  
    size_t m_num_allocated{0};       
    valueType * m_p_memory{nullptr};      

    void allocate_internal( size_t n );

    void memory_exausted( size_t sz );

    void pop_exausted( size_t sz );
 
  public:

    Malloc( Malloc<T> const & ) = delete;

    Malloc<T> const & operator = ( Malloc<T> const & ) const = delete;


    explicit
    Malloc( string name )
    : m_name(std::move(name))
    { }


    ~Malloc() { hard_free(); }


    void allocate( size_t n );
 
    template <typename T2>
    void
    allocate(T2 n) {
      static_assert(std::is_integral<T2>::value, "allocate() accepts only integral types!");
      allocate(static_cast<size_t>(n));
    }


    void reallocate( size_t n );
 
    template <typename T2>
    void
    reallocate(T2 n) {
      static_assert(std::is_integral<T2>::value, "reallocate() accepts only integral types!");
      reallocate(static_cast<size_t>(n));
    }

    void free() { m_num_total_values = m_num_allocated = 0; }

    void hard_free();


    size_t size() const { return m_num_total_values; }


    T * operator () ( size_t sz ) {
      size_t offs = m_num_allocated;
      m_num_allocated += sz;
      if ( m_num_allocated > m_num_total_values ) memory_exausted( sz );
      return m_p_memory + offs;
    }
 
    template <typename T2>
    T* operator() ( T2 sz ) {
      static_assert(std::is_integral<T2>::value, "operator() accepts only integral types!");
      return (*this)(static_cast<size_t>(sz));
    }


    void
    pop( size_t sz ) {
      if ( sz > m_num_allocated ) pop_exausted( sz );
      m_num_allocated -= sz;
    }
 
    template <typename T2>
    void
    pop( T2 n ) {
      static_assert(std::is_integral<T2>::value, "pop() accepts only integral types!");
      pop(static_cast<size_t>(n));
    }


    T * malloc( size_t n );
 
    template <typename T2>
    T *
    malloc( T2 n ) {
      static_assert(std::is_integral<T2>::value, "malloc() accepts only integral types!");
      return malloc(static_cast<size_t>(n));
    }


    T * realloc( size_t n );
 
    template <typename T2>
    T *
    realloc( T2 n ) {
      static_assert(std::is_integral<T2>::value, "realloc() accepts only integral types!");
      return realloc(static_cast<size_t>(n));
    }


    bool is_empty() const { return m_num_allocated >= m_num_total_values; }


    void must_be_empty( string_view where ) const;


    string info( string_view where ) const;
 
  };
 
  extern template class Malloc<char>;
  extern template class Malloc<uint16_t>;
  extern template class Malloc<int16_t>;
  extern template class Malloc<uint32_t>;
  extern template class Malloc<int32_t>;
  extern template class Malloc<uint64_t>;
  extern template class Malloc<int64_t>;
  extern template class Malloc<float>;
  extern template class Malloc<double>;
 
  extern template class Malloc<void*>;
  extern template class Malloc<char*>;
  extern template class Malloc<uint16_t*>;
  extern template class Malloc<int16_t*>;
  extern template class Malloc<uint32_t*>;
  extern template class Malloc<int32_t*>;
  extern template class Malloc<uint64_t*>;
  extern template class Malloc<int64_t*>;
  extern template class Malloc<float*>;
  extern template class Malloc<double*>;
 
  /*\
  :|:   __  __       _ _            _____ _              _
  :|:  |  \/  | __ _| | | ___   ___|  ___(_)_  _____  __| |
  :|:  | |\/| |/ _` | | |/ _ \ / __| |_  | \ \/ / _ \/ _` |
  :|:  | |  | | (_| | | | (_) | (__|  _| | |>  <  __/ (_| |
  :|:  |_|  |_|\__,_|_|_|\___/ \___|_|   |_/_/\_\___|\__,_|
  \*/


  template <typename T, std::size_t mem_size>
  class MallocFixed {
  public:
    using valueType = T;
 
  private:
 
    string    m_name;             
    size_t    m_num_allocated{0}; 
    valueType m_data[mem_size];   
 
  public:

    MallocFixed(MallocFixed<T,mem_size> const &) = delete; // blocco costruttore di copia

    MallocFixed<T,mem_size> const & operator = (MallocFixed<T,mem_size> const &) const = delete; // blocco copia


    explicit
    MallocFixed( string name )
    : m_name(std::move(name))
    {}

    ~MallocFixed() = default;

    void free() { m_num_allocated = 0; }


    static size_t size() { return mem_size; }


    T * operator () ( size_t sz );


    void pop( size_t sz );


    bool is_empty() const { return m_num_allocated >= mem_size; }
 
  };

 
}
 
//
// eof: Malloc.hxx
//