memory_buffer.hpp

Go to the documentation of this file.

#ifndef LIBJMMCG_CORE_MEMORY_BUFFER_HPP
#define LIBJMMCG_CORE_MEMORY_BUFFER_HPP
/******************************************************************************
** Copyright © 2004 by J.M.McGuiness, coder@hussar.me.uk
**
** This library is free software; you can redistribute it and/or
** modify it under the terms of the GNU Lesser General Public
** License as published by the Free Software Foundation; either
** version 2.1 of the License, or (at your option) any later version.
**
** This library is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
** Lesser General Public License for more details.
**
** You should have received a copy of the GNU Lesser General Public
** License along with this library; if not, write to the Free Software
** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
 
#include "exception.hpp"
 
#include <boost/mpl/assert.hpp>
#include <boost/mpl/comparison.hpp>
#include <boost/mpl/greater.hpp>
#include <boost/mpl/int.hpp>
 
#include <memory>
#include <type_traits>
 
namespace jmmcg { namespace LIBJMMCG_VER_NAMESPACE {
 
namespace heap {
 
/// A very simple custom allocator that allocates a contiguous block of *uninitialised* items on the heap.
/**
   Note that the items allocated are guaranteed not to be initialised.
*/
template<
   class OST,
   class El
>
class memory_buffer {
public:
   typedef OST os_traits;
   typedef typename os_traits::exception_type exception_type;
   typedef El element_type;   ///< The type of items to allocate, but not initialise.
 
private:
   typedef std::pair<element_type*, std::ptrdiff_t> buff_info_t;
 
public:
   typedef typename buff_info_t::second_type size_type;
   typedef unsigned char const * const_iterator;
   typedef unsigned char * iterator;
 
   enum {
      stride=sizeof(element_type)   ///< The sizeof(element_type) each item, specifically in bytes.
   };
 
   BOOST_MPL_ASSERT((boost::mpl::greater<boost::mpl::int_<stride>, boost::mpl::int_<0>>));
 
   /**
      \param num_objs   The number of the items to be allocated.
   */
   explicit memory_buffer(size_type const num_objs) noexcept(false) FORCE_INLINE
   : buff_info(std::get_temporary_buffer<element_type>(num_objs)) {
      if (!buff_info.first || buff_info.second<num_objs) {
         info::function fun(__LINE__, __PRETTY_FUNCTION__, typeid(*this), info::function::argument(_T("size_type const num_objs"), num_objs));
         fun.add_args(
            info::function::argument(_T("allocated buffer address"), buff_info.first),
            info::function::argument(_T("allocated buffer size"), buff_info.second),
            info::function::argument(_T("stride"), stride)
         );
         throw exception_type(_T("Failed to allocate custom memory-buffer for the internal operation of the parallel algorithm."), std::move(fun), JMMCG_REVISION_HDR(_T(LIBJMMCG_VERSION_NUMBER)));
      }
      assert(data()!=0);
      assert(stride>0);
      assert(std::fill_n(data(), stride*max_size(), static_cast<unsigned char>(0)));
   }
   ~memory_buffer() noexcept(true) FORCE_INLINE {
      std::return_temporary_buffer(buff_info.first);
   }
 
   memory_buffer(memory_buffer const &)=delete;
   memory_buffer(memory_buffer &&)=delete;
   void operator=(memory_buffer const &)=delete;
   void operator=(memory_buffer &&)=delete;
 
   /**
      \return Note the iterator returned is a byte-pointer.
   */
   const_iterator data() const noexcept(true) FORCE_INLINE {
      return reinterpret_cast<const_iterator const>(buff_info.first);
   }
   /**
      \return Note the iterator returned is a byte-pointer.
   */
   iterator data() noexcept(true) FORCE_INLINE {
      return reinterpret_cast<iterator>(buff_info.first);
   }
 
   /**
      \return  The size of the buffer in number of items.
   */
   size_type __fastcall max_size() const noexcept(true) FORCE_INLINE {
      return buff_info.second;
   }
 
   /**
      \todo Implement using the advice given in "Standard C++ IOStreams and Locales" by A.Langer & K.Kreft, page 170.
   */
   friend inline tostream &__fastcall
   operator<<(tostream &os, memory_buffer const &t) noexcept(false) {
      os
         <<_T("buffer address=0x")<<std::hex<<t.data()
         <<_T(", size=")<<std::dec<<t.max_size()
         <<_T(", stride=")<<memory_buffer::stride;
      return os;
   }
 
private:
   const buff_info_t buff_info;
};
 
}
 
namespace stack {
 
/// A very simple custom allocator that allocates a contiguous block of *uninitialised* items on the stack.
/**
   A simple char[] does not respect alignment, whereas this class ensures that the objects are suitably aligned.
   Note that the items allocated are guaranteed not to be initialised, which is how this differs from std::array, which, as I understand it, must default-initialise each std::array::value_type member according to 8.5.1p7 of the ISO Standard.
 
   \see std::array
*/
template<
   class El,
   std::size_t num_objs ///< The number of the items to be allocated.
>
class memory_buffer {
public:
   typedef El element_type;   ///< The type of items to allocate, but not initialise.
 
private:
   typedef typename std::aligned_storage<sizeof(element_type), std::alignment_of<element_type>::value>::type aligned_type;
   typedef aligned_type buff_info_t[num_objs];
 
public:
   enum : std::size_t {
      stride=sizeof(element_type),  ///< The sizeof(element_type) each item, specifically in bytes.
      max_size_=num_objs   ///< The size of the buffer in number of items.
   };
 
   BOOST_MPL_ASSERT((boost::mpl::greater<boost::mpl::int_<num_objs>, boost::mpl::int_<0>>));
   BOOST_MPL_ASSERT((boost::mpl::greater<boost::mpl::int_<stride>, boost::mpl::int_<0>>));
   BOOST_MPL_ASSERT((boost::mpl::greater<boost::mpl::int_<max_size_>, boost::mpl::int_<0>>));
 
public:
   typedef typename std::size_t size_type;
   typedef unsigned char const * const_iterator;
   typedef unsigned char * iterator;
 
   memory_buffer() noexcept(true) FORCE_INLINE {
      assert(std::fill_n(data(), stride*max_size(), static_cast<unsigned char>(0)));
   }
   ~memory_buffer() noexcept(true) FORCE_INLINE {}
 
   const_iterator data() const noexcept(true) FORCE_INLINE {
      return reinterpret_cast<const_iterator>(buff_info);
   }
   iterator data() noexcept(true) FORCE_INLINE {
      return reinterpret_cast<iterator>(buff_info);
   }
 
   /**
      \return  The size of the buffer in number of items.
   */
   static constexpr size_type max_size() noexcept(true) FORCE_INLINE {
      return max_size_;
   }
 
   /**
      \todo Implement using the advice given in "Standard C++ IOStreams and Locales" by A.Langer & K.Kreft, page 170.
   */
   friend inline tostream &
   operator<<(tostream &os, memory_buffer const &t) noexcept(false) {
      os
         <<_T("buffer address=0x")<<std::hex<<t.data()
         <<_T(", size=")<<std::dec<<t.max_size()
         <<_T(", stride=")<<memory_buffer::stride;
      return os;
   }
 
private:
   buff_info_t buff_info;
 
   memory_buffer(memory_buffer const &)=delete;
   memory_buffer(memory_buffer &&)=delete;
   void operator=(memory_buffer const &)=delete;
   void operator=(memory_buffer &&)=delete;
};
 
} } }
 
#endif