benchmarks/cache_aligned_array.hpp

   1 /* cache-aligned array, based on boost::array
   2  *
   3  * The following code declares class array,
   4  * an STL container (as wrapper) for arrays of constant size.
   5  *
   6  * See
   7  *      http://www.boost.org/libs/array/
   8  * for documentation.
   9  *
  10  * The original author site is at: http://www.josuttis.com/
  11  *
  12  * (C) Copyright Nicolai M. Josuttis 2001.
  13  *
  14  * Distributed under the Boost Software License, Version 1.0. (See
  15  * accompanying file LICENSE_1_0.txt or copy at
  16  * http://www.boost.org/LICENSE_1_0.txt)
  17  *
  18  * 29 Jan 2004 - c_array() added, BOOST_NO_PRIVATE_IN_AGGREGATE removed (Nico Josuttis)
  19  * 23 Aug 2002 - fix for Non-MSVC compilers combined with MSVC libraries.
  20  * 05 Aug 2001 - minor update (Nico Josuttis)
  21  * 20 Jan 2001 - STLport fix (Beman Dawes)
  22  * 29 Sep 2000 - Initial Revision (Nico Josuttis)
  23  *
  24  * Jan 29, 2004
  25  */
  26 #ifndef CACHE_ALIGNED_ARRAY_HPP
  27 #define CACHE_ALIGNED_ARRAY_HPP
  28
  29 #include <cstddef>
  30 #include <stdexcept>
  31 #include <boost/assert.hpp>
  32
  33 // Handles broken standard libraries better than <iterator>
  34 #include <boost/detail/iterator.hpp>
  35 #include <boost/throw_exception.hpp>
  36 #include <algorithm>
  37
  38 // FIXES for broken compilers
  39 #include <boost/config.hpp>
  40
  41 #include "malloc_aligned.hpp"
  42
  43 namespace nova {
  44
  45     template<class T, std::size_t N>
  46     class aligned_array {
  47       public:
  48         T * elems; // fixed-size array of elements of type T
  49
  50       public:
  51         aligned_array(void)
  52         {
  53             elems = (T*)malloc_aligned(N * sizeof(T));
  54             for (int i = 0; i != N; ++i)
  55                 new(elems+i) T();
  56         }
  57
  58         aligned_array(aligned_array const & rhs)
  59         {
  60             elems = (T*)malloc_aligned(N * sizeof(T));
  61             for (int i = 0; i != N; ++i)
  62                 new(elems+i) T();
  63             operator=(rhs);
  64         }
  65
  66         ~aligned_array(void)
  67         {
  68             for (int i = 0; i != N; ++i)
  69                 elems[i].~T();
  70             free_aligned(elems);
  71         }
  72
  73         // type definitions
  74         typedef T              value_type;
  75         typedef T*             iterator;
  76         typedef const T*       const_iterator;
  77         typedef T&             reference;
  78         typedef const T&       const_reference;
  79         typedef std::size_t    size_type;
  80         typedef std::ptrdiff_t difference_type;
  81
  82         // iterator support
  83         iterator begin() { return elems; }
  84         const_iterator begin() const { return elems; }
  85         iterator end() { return elems+N; }
  86         const_iterator end() const { return elems+N; }
  87
  88         // reverse iterator support
  89 #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_MSVC_STD_ITERATOR) && !defined(BOOST_NO_STD_ITERATOR_TRAITS)
  90         typedef std::reverse_iterator<iterator> reverse_iterator;
  91         typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
  92 #elif defined(_MSC_VER) && (_MSC_VER == 1300) && defined(BOOST_DINKUMWARE_STDLIB) && (BOOST_DINKUMWARE_STDLIB == 310)
  93         // workaround for broken reverse_iterator in VC7
  94         typedef std::reverse_iterator<std::_Ptrit<value_type, difference_type, iterator,
  95                                       reference, iterator, reference> > reverse_iterator;
  96         typedef std::reverse_iterator<std::_Ptrit<value_type, difference_type, const_iterator,
  97                                       const_reference, iterator, reference> > const_reverse_iterator;
  98 #else
  99         // workaround for broken reverse_iterator implementations
 100         typedef std::reverse_iterator<iterator,T> reverse_iterator;
 101         typedef std::reverse_iterator<const_iterator,T> const_reverse_iterator;
 102 #endif
 103
 104         reverse_iterator rbegin() { return reverse_iterator(end()); }
 105         const_reverse_iterator rbegin() const {
 106             return const_reverse_iterator(end());
 107         }
 108         reverse_iterator rend() { return reverse_iterator(begin()); }
 109         const_reverse_iterator rend() const {
 110             return const_reverse_iterator(begin());
 111         }
 112
 113         // operator[]
 114         reference operator[](size_type i)
 115         {
 116             BOOST_ASSERT( i < N && "out of range" );
 117             return elems[i];
 118         }
 119
 120         const_reference operator[](size_type i) const
 121         {
 122             BOOST_ASSERT( i < N && "out of range" );
 123             return elems[i];
 124         }
 125
 126         // at() with range check
 127         reference at(size_type i) { rangecheck(i); return elems[i]; }
 128         const_reference at(size_type i) const { rangecheck(i); return elems[i]; }
 129
 130         // front() and back()
 131         reference front()
 132         {
 133             return elems[0];
 134         }
 135
 136         const_reference front() const
 137         {
 138             return elems[0];
 139         }
 140
 141         reference back()
 142         {
 143             return elems[N-1];
 144         }
 145
 146         const_reference back() const
 147         {
 148             return elems[N-1];
 149         }
 150
 151         // size is constant
 152         static size_type size() { return N; }
 153         static bool empty() { return false; }
 154         static size_type max_size() { return N; }
 155         enum { static_size = N };
 156
 157         // swap (note: linear complexity)
 158         void swap (aligned_array<T,N>& y) {
 159             std::swap_ranges(begin(),end(),y.begin());
 160         }
 161
 162         // direct access to data (read-only)
 163         const T* data() const { return elems; }
 164         T* data() { return elems; }
 165
 166         // use array as C array (direct read/write access to data)
 167         T* c_array() { return elems; }
 168
 169         // assignment with type conversion
 170         aligned_array & operator=(const aligned_array & rhs)
 171         {
 172             std::copy(rhs.begin(),rhs.end(), begin());
 173             return *this;
 174         }
 175
 176         template <typename T2>
 177         aligned_array<T,N>& operator= (const aligned_array<T2,N>& rhs) {
 178             std::copy(rhs.begin(),rhs.end(), begin());
 179             return *this;
 180         }
 181
 182         // assign one value to all elements
 183         void assign (const T& value)
 184         {
 185             std::fill_n(begin(),size(),value);
 186         }
 187
 188         // check range (may be private because it is static)
 189         static void rangecheck (size_type i) {
 190             if (i >= size()) {
 191                 throw std::out_of_range("aligned_array<>: index out of range");
 192             }
 193         }
 194
 195     };
 196
 197 #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
 198     template< class T >
 199     class aligned_array< T, 0 > {
 200
 201       public:
 202         // type definitions
 203         typedef T              value_type;
 204         typedef T*             iterator;
 205         typedef const T*       const_iterator;
 206         typedef T&             reference;
 207         typedef const T&       const_reference;
 208         typedef std::size_t    size_type;
 209         typedef std::ptrdiff_t difference_type;
 210
 211         // iterator support
 212         iterator begin() { return iterator( reinterpret_cast< T * >( this ) ); }
 213         const_iterator begin() const { return const_iterator(  reinterpret_cast< const T * >( this ) ); }
 214         iterator end() { return begin(); }
 215         const_iterator end() const { return begin(); }
 216
 217         // reverse iterator support
 218 #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_MSVC_STD_ITERATOR) && !defined(BOOST_NO_STD_ITERATOR_TRAITS)
 219         typedef std::reverse_iterator<iterator> reverse_iterator;
 220         typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
 221 #elif defined(_MSC_VER) && (_MSC_VER == 1300) && defined(BOOST_DINKUMWARE_STDLIB) && (BOOST_DINKUMWARE_STDLIB == 310)
 222         // workaround for broken reverse_iterator in VC7
 223         typedef std::reverse_iterator<std::_Ptrit<value_type, difference_type, iterator,
 224                                       reference, iterator, reference> > reverse_iterator;
 225         typedef std::reverse_iterator<std::_Ptrit<value_type, difference_type, const_iterator,
 226                                       const_reference, iterator, reference> > const_reverse_iterator;
 227 #else
 228         // workaround for broken reverse_iterator implementations
 229         typedef std::reverse_iterator<iterator,T> reverse_iterator;
 230         typedef std::reverse_iterator<const_iterator,T> const_reverse_iterator;
 231 #endif
 232
 233         reverse_iterator rbegin() { return reverse_iterator(end()); }
 234         const_reverse_iterator rbegin() const {
 235             return const_reverse_iterator(end());
 236         }
 237         reverse_iterator rend() { return reverse_iterator(begin()); }
 238         const_reverse_iterator rend() const {
 239             return const_reverse_iterator(begin());
 240         }
 241
 242         // operator[]
 243         reference operator[](size_type i)
 244         {
 245             return failed_rangecheck();
 246         }
 247
 248         const_reference operator[](size_type i) const
 249         {
 250             return failed_rangecheck();
 251         }
 252
 253         // at() with range check
 254         reference at(size_type i)               {   return failed_rangecheck(); }
 255         const_reference at(size_type i) const   {   return failed_rangecheck(); }
 256
 257         // front() and back()
 258         reference front()
 259         {
 260             return failed_rangecheck();
 261         }
 262
 263         const_reference front() const
 264         {
 265             return failed_rangecheck();
 266         }
 267
 268         reference back()
 269         {
 270             return failed_rangecheck();
 271         }
 272
 273         const_reference back() const
 274         {
 275             return failed_rangecheck();
 276         }
 277
 278         // size is constant
 279         static size_type size() { return 0; }
 280         static bool empty() { return true; }
 281         static size_type max_size() { return 0; }
 282         enum { static_size = 0 };
 283
 284         void swap (aligned_array<T,0>& y) {
 285         }
 286
 287         // direct access to data (read-only)
 288         const T* data() const { return 0; }
 289         T* data() { return 0; }
 290
 291         // use array as C array (direct read/write access to data)
 292         T* c_array() { return 0; }
 293
 294         // assignment with type conversion
 295         template <typename T2>
 296         aligned_array<T,0>& operator= (const aligned_array<T2,0>& ) {
 297             return *this;
 298         }
 299
 300         // assign one value to all elements
 301         void assign (const T& ) {   }
 302
 303         // check range (may be private because it is static)
 304         static reference failed_rangecheck () {
 305                 std::out_of_range e("attempt to access element of an empty aligned_array");
 306                 boost::throw_exception(e);
 307                 //
 308                 // We need to return something here to keep
 309                 // some compilers happy: however we will never
 310                 // actually get here....
 311                 //
 312                 static T placeholder;
 313                 return placeholder;
 314             }
 315     };
 316 #endif
 317
 318     // comparisons
 319     template<class T, std::size_t N>
 320     bool operator== (const aligned_array<T,N>& x, const aligned_array<T,N>& y) {
 321         return std::equal(x.begin(), x.end(), y.begin());
 322     }
 323     template<class T, std::size_t N>
 324     bool operator< (const aligned_array<T,N>& x, const aligned_array<T,N>& y) {
 325         return std::lexicographical_compare(x.begin(),x.end(),y.begin(),y.end());
 326     }
 327     template<class T, std::size_t N>
 328     bool operator!= (const aligned_array<T,N>& x, const aligned_array<T,N>& y) {
 329         return !(x==y);
 330     }
 331     template<class T, std::size_t N>
 332     bool operator> (const aligned_array<T,N>& x, const aligned_array<T,N>& y) {
 333         return y<x;
 334     }
 335     template<class T, std::size_t N>
 336     bool operator<= (const aligned_array<T,N>& x, const aligned_array<T,N>& y) {
 337         return !(y<x);
 338     }
 339     template<class T, std::size_t N>
 340     bool operator>= (const aligned_array<T,N>& x, const aligned_array<T,N>& y) {
 341         return !(x<y);
 342     }
 343
 344     // global swap()
 345     template<class T, std::size_t N>
 346     inline void swap (aligned_array<T,N>& x, aligned_array<T,N>& y) {
 347         x.swap(y);
 348     }
 349
 350 template <typename sample_type, unsigned int n>
 351 #ifdef GCC
 352 inline sample_type __attribute__((aligned(64))) * get_samples(aligned_array<sample_type, n> & arg)
 353 #else
 354 inline sample_type * get_samples(aligned_array<sample_type, n> & arg)
 355 #endif
 356 {
 357     return arg.begin();
 358 }
 359
 360 template <typename sample_type, unsigned int n>
 361 #ifdef GCC
 362 inline const sample_type __attribute__((aligned(64))) * get_samples(aligned_array<sample_type, n> const & arg)
 363 #else
 364 inline const sample_type * get_samples(aligned_array<sample_type, n> const & arg)
 365 #endif
 366 {
 367     return arg.begin();
 368 }
 369
 370
 371 } /* namespace nova */
 372
 373 #endif /*CACHE_ALIGNED_ARRAY_HPP*/